216 files changed, 7886 insertions, 53 deletions

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..f063da3
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+waf binary
\ No newline at end of file
diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..d72aad1
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,14 @@
+Author:
+	David Robillard <d@drobilla.net>
+
+Original GTK2 Generic Plugin UI:
+	Nick Lanham <nick@afternight.org>
+
+Various UI improvements:
+	Robin Gareus <robin@gareus.org>
+
+Preset menu support for Qt:
+	Timo Westkämper <timo.westkamper@gmail.com>
+
+Qt4 Generic Plugin UI:
+	Amadeus Folego <amadeusfolego@gmail.com>
diff --git a/COPYING b/COPYING
index a4147d2..cf8477f 100644
--- a/COPYING
+++ b/COPYING
@@ -1,25 +1,13 @@
-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 name of the author may not be used to endorse or promote products
-   derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 AUTHOR 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.
+Copyright 2011-2017 David Robillard <http://drobilla.net>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..623cddd
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,59 @@
+Installation Instructions
+=========================
+
+Basic Installation
+------------------
+
+Building this software requires only Python.  To install with default options:
+
+    ./waf configure
+    ./waf
+    ./waf install
+
+You may need to become root for the install stage, for example:
+
+    sudo ./waf install
+
+Configuration Options
+---------------------
+
+All supported options can be viewed using the command:
+
+    ./waf --help
+
+Most options only need to be passed during the configure stage, for example:
+
+    ./waf configure --prefix=/usr
+    ./waf
+    ./waf install
+
+Compiler Configuration
+----------------------
+
+Several standard environment variables can be used to control how compilers are
+invoked:
+
+ * CC:        Path to C compiler
+ * CFLAGS:    C compiler options
+ * CXX:       Path to C++ compiler
+ * CXXFLAGS:  C++ compiler options
+ * CPPFLAGS:  C preprocessor options
+ * LINKFLAGS: Linker options
+
+Installation Directories
+------------------------
+
+The --prefix option (or the PREFIX environment variable) can be used to change
+the prefix which all files are installed under.  There are also several options
+allowing for more fine-tuned control, see the --help output for details.
+
+Packaging
+---------
+
+Everything can be installed to a specific root directory by passing a --destdir
+option to the install stage (or setting the DESTDIR environment variable),
+which adds a prefix to all install paths.  For example:
+
+    ./waf configure --prefix=/usr
+    ./waf
+    ./waf install --destdir=/tmp/package
diff --git a/NEWS b/NEWS
new file mode 100644
index 0000000..d66a66c
--- /dev/null
+++ b/NEWS
@@ -0,0 +1,111 @@
+jalv (1.6.1) unstable;
+
+  * Fix compilation with recent Gtkmm versions that require C++11
+  * Add jalv -i option to ignore stdin for background use
+  * Fix Jack deactivation
+
+ -- David Robillard <d@drobilla.net>  Sun, 07 May 2017 13:35:11 +0200
+
+jalv (1.6.0) stable;
+
+  * Support CV ports if Jack metadata is enabled (patch from Hanspeter Portner)
+  * Fix unreliable UI state initialization (patch from Hanspeter Portner)
+  * Fix memory error on preset save resulting in odd bundle names
+  * Improve preset support
+  * Support numeric and string plugin properties (event-based control)
+  * Support thread-safe state restoration
+  * Update UI when internal plugin state is changed during preset load
+  * Add generic Qt control UI from Amadeus Folego
+  * Add PortAudio backend (compile time option, audio only)
+  * Set Jack port order metadata
+  * Allow Jack client name to be set from command line (thanks Adam Avramov)
+  * Add command prompt to console version for changing controls
+  * Add option to print plugin trace messages
+  * Print colorful log if output is a terminal
+  * Exit on Jack shutdown (patch from Robin Gareus)
+  * Report Jack latency (patch from Robin Gareus)
+  * Exit GUI versions on interrupt
+  * Fix semaphore correctness issues
+  * Use moc-qt4 if present for systems with multiple Qt versions
+  * Add Qt5 version
+
+ -- David Robillard <d@drobilla.net>  Wed, 04 Jan 2017 12:24:58 -0500
+
+jalv (1.4.6) stable;
+
+  * Show newly saved presets in the preset menu
+  * Generate Qt moc nonsense at build time for broader compatibility
+  * Update for latest LV2 Atom Object simplifications
+  * Set port pretty names via new Jack metadata API
+  * Add support for data-access extension (based on patch by Filipe Coelho)
+  * Support new UI show/hide interface in console version
+  * Add option to print control output changes to stdout
+  * Support saving the same preset several times
+  * Update man pages and console jalv help output for new options
+  * Upgrade to waf 1.7.16
+
+ -- David Robillard <d@drobilla.net>  Fri, 08 Aug 2014 18:30:28 -0400
+
+jalv (1.4.4) stable;
+
+  * Add -c option for setting controls from the command line
+  * Add --no-menu option for jalv.gtk
+  * Don't expose non-MIDI event ports to Jack
+  * Hide controls for ports with notOnGUI property in generic UI
+    (based on patch from Robin Gareus)
+  * Support ui:portMap feature to allow UIs to avoid hard-coded port indices
+    (useful for compatibility and separately distributed UIs)
+  * Preset menu support for Qt (patch from Timo Westkämper)
+
+ -- David Robillard <d@drobilla.net>  Sat, 04 Jan 2014 16:11:45 -0500
+
+jalv (1.4.2) stable;
+
+  * Fix crash when running "jalv" with bad command line arguments
+  * Fix potential crash with UIs and debug printing
+  * Fix parameter changes with Qt UI
+  * Nicer printing of atom messages with -d
+  * Add command-line option to control UI update frequency
+  * Support rsz:minimumSize for atom and event ports
+  * Fix default setting for non-sequential enumeration ports
+    (patch from Robin Gareus)
+  * Work around Gtk bug for labels on sliders (patch from Robin Gareus)
+  * Upgrade to waf 1.7.11
+
+ -- David Robillard <d@drobilla.net>  Fri, 09 Aug 2013 10:40:20 -0400
+
+jalv (1.4.0) stable;
+
+  * Send time information to plugin when Jack tempo changes
+  * Group controls under headings if port group information is available
+  * Add spinbuttons for precisely setting control values
+  * Use a more efficient dense layout for controls
+  * Make URI map thread-safe, fixing occasional crashes for plugins with UIs
+  * Add menu bar and pass parent widget in Qt version for true UI embedding
+  * Support state:loadDefaultState
+  * Update to waf 1.7.8 and autowaf r90
+
+ -- David Robillard <d@drobilla.net>  Fri, 22 Feb 2013 22:35:22 -0500
+
+jalv (1.2.0) stable;
+
+  * Tune UI update rate and ring size based on JACK rate and MIDI buffer size
+    to handle the handle the maximum message rate the plugin can send.
+  * Support lv2:sampleRate control ports.
+  * Tolerate loading presets with port values that aren't xsd:decimal
+  * Notify plugins of Jack transport changes by sending events (an atom:Blank
+    with properties from the LV2 time extension)
+  * Refuse to instantiate plugins which require unsupported features
+  * Support LV2 buf-size extension (with all features)
+  * Add Gtk3 UI
+  * Port to MinGW
+  * Fix Jack Session support
+
+ -- David Robillard <d@drobilla.net>  Sun, 14 Oct 2012 18:38:53 -0400
+
+jalv (1.0.0) stable;
+
+  * Initial release
+
+ -- David Robillard <d@drobilla.net>  Thu, 19 Apr 2012 18:42:42 -0400
+
diff --git a/README.md b/README.md
index c5361b9..21207ab 100644
--- a/README.md
+++ b/README.md
@@ -1,24 +1,18 @@
-Autowaf
-=======
+Jalv
+====
 
-This is autowaf, a bundle of waf and a few extensions intended to be easy to
-use directly as source code in a project.  Using this as a submodule or subtree
-named `waflib` in a project allows waf to be used without including binary
-encoded data in the waf script.  This gets along with revision control and
-distributions better, among other advantages, without losing
-self-containedness.
+Jalv is a simple but fully featured LV2 host for Jack which exposes plugin
+ports to Jack, essentially making any LV2 plugin function as a Jack
+application.
+For more information, see <http://drobilla.net/software/jalv>.
 
-To use this in a project, add this repository as a directory named `waflib` in
-the top level of the project, and link or copy `waf` to the top level.
+Jalv is a small program which is useful, but also intended to be an appropriate
+test host for plugin development.  It runs plugins from the command line with
+no user interaction, is light enough to run in valgrind, and is capable of
+dumping all communication between the plugin and its UI in a human readable
+format.
 
-Two waf extras are also included: `autowaf.py` and `lv2.py`.
-
-The `autowaf.py` module is a kitchen sink of Python utilities for building
-consistent packages, and can be imported in a wcript as
-`waflib.extras.autowaf`.
-
-The `lv2.py` extra defines options for LV2 plugin installation paths.  It can
-be used by calling `opt.load('lv2')` and `conf.load('lv2')` in the appropriate
-locations in a wscript.
+To make it simple to test plugins in hosts that use different toolkits, there
+are several Jalv executables: jalv, jalv.gtk, jalv.gtkmm, and jalv.qt.
 
  -- David Robillard <d@drobilla.net>
diff --git a/doc/jalv.1 b/doc/jalv.1
new file mode 100644
index 0000000..02ae649
--- /dev/null
+++ b/doc/jalv.1
@@ -0,0 +1,72 @@
+.TH JALV 1 "18 Feb 2017"
+
+.SH NAME
+.B jalv \- Run an LV2 plugin as a JACK application (console version).
+
+.SH SYNOPSIS
+.B jalv [OPTION]... PLUGIN_URI
+
+.SH OPTIONS
+
+.TP
+\fB\-b SIZE\fR
+Buffer size for plugin <=> UI communication.
+
+.TP
+\fB\-c SYM=VAL\fR
+Set control value (e.g. "vol=1.4").
+
+.TP
+\fB\-d\fR
+Dump plugin <=> UI communication.
+
+.TP
+\fB\-h\fR
+Print the command line options.
+
+.TP
+\fB\-i\fR
+Ignore input on stdin (for background use).
+
+.TP
+\fB\-l DIR\fR
+Load state from state directory.
+
+.TP
+\fB\-n NAME\fR
+Jack client name
+
+.TP
+\fB\-p\fR
+Print control output changes to stdout.
+
+.TP
+\fB\-s\fR
+Show plugin UI if possible.
+
+This option only works when plugins provide a UI that is usable via the non-embeddable showHide interface.  For other, embeddable UIs, use jalv.gtk(1) or jalv.qt(1).
+
+.TP
+\fB\-t\fR
+Print trace messages from plugin
+
+.TP
+\fB\-u UUID\fR
+UUID for Jack session restoration.
+
+.TP
+\fB\-x\fR
+Use only exact Jack client name, and exit if it is taken
+
+.SH "SEE ALSO"
+.BR jalv.gtk(1),
+.BR jalv.gtkmm(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/doc/jalv.gtk.1 b/doc/jalv.gtk.1
new file mode 100644
index 0000000..5177e1d
--- /dev/null
+++ b/doc/jalv.gtk.1
@@ -0,0 +1,58 @@
+.TH JALV.GTK "18 Feb 2017"
+
+.SH NAME
+.B jalv.gtk \- Run an LV2 plugin as a JACK application (Gtk version).
+
+.SH SYNOPSIS
+.B jalv.gtk [OPTION]... PLUGIN_URI
+
+.SH OPTIONS
+
+.TP
+\fB\-b SIZE\fR
+Buffer size for plugin <=> UI communication.
+
+.TP
+\fB\-c SYM=VAL\fR
+Set control value (e.g. "vol=1.4").
+
+.TP
+\fB\-d\fR, \fB\-\-dump\fR
+Dump plugin <=> UI communication.
+
+.TP
+\fB\-g\fR, \fB\-\-generic\-ui\fR
+Use Jalv generic UI and not the plugin UI.
+
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Print the command line options.
+
+.TP
+\fB\-l DIR\fR, \fB\-\-load DIR\fR
+Load state from state directory.
+
+.TP
+\fB\-p\fR, \fB\-\-print\-controls\fR
+Print control output changes to stdout.
+
+.TP
+\fB\-t\fR, \fB\-\-trace\fR
+Print trace messages from plugin.
+
+.TP
+\fB\-u UUID\fR, \fB\-\-uuid UUID\fR
+UUID for Jack session restoration.
+
+.SH "SEE ALSO"
+.BR jalv(1),
+.BR jalv.gtkmm(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/doc/jalv.gtkmm.1 b/doc/jalv.gtkmm.1
new file mode 100644
index 0000000..2a6ce01
--- /dev/null
+++ b/doc/jalv.gtkmm.1
@@ -0,0 +1,25 @@
+.TH JALV.GTKMM 1 "19 Apr 2012"
+
+.SH NAME
+.B jalv.gtkmm \- Run an LV2 plugin as a JACK application (Gtkmm version).
+
+.SH SYNOPSIS
+.B jalv.gtkmm PLUGIN_URI
+
+.SH DESCRIPTION
+
+This is a version of Jalv with a GUI implemented in Gtkmm.  It is mainly for
+developer testing purposes, for a production ready program use jalv.gtk.
+
+.SH "SEE ALSO"
+.BR jalv(1),
+.BR jalv.gtk(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/doc/jalv.qt.1 b/doc/jalv.qt.1
new file mode 100644
index 0000000..352835d
--- /dev/null
+++ b/doc/jalv.qt.1
@@ -0,0 +1,25 @@
+.TH JALV.QT 1 "19 Apr 2012"
+
+.SH NAME
+.B jalv.qt \- Run an LV2 plugin as a JACK application (Qt version).
+
+.SH SYNOPSIS
+.B jalv.qt PLUGIN_URI
+
+.SH DESCRIPTION
+
+This is a version of Jalv with a GUI implemented in Qt.  It is mainly for
+developer testing purposes, for a production ready program use jalv.gtk.
+
+.SH "SEE ALSO"
+.BR jalv(1),
+.BR jalv.gtkmm(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/src/control.c b/src/control.c
new file mode 100644
index 0000000..9fe5924
--- /dev/null
+++ b/src/control.c
@@ -0,0 +1,170 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "jalv_internal.h"
+
+int
+scale_point_cmp(const ScalePoint* a, const ScalePoint* b)
+{
+	if (a->value < b->value) {
+		return -1;
+	} else if (a->value == b->value) {
+		return 0;
+	}
+	return 1;
+}
+
+ControlID*
+new_port_control(Jalv* jalv, uint32_t index)
+{
+	struct Port*      port  = &jalv->ports[index];
+	const LilvPort*   lport = port->lilv_port;
+	const LilvPlugin* plug  = jalv->plugin;
+	const JalvNodes*  nodes = &jalv->nodes;
+
+	ControlID* id = (ControlID*)calloc(1, sizeof(ControlID));
+	id->jalv           = jalv;
+	id->type           = PORT;
+	id->node           = lilv_node_duplicate(lilv_port_get_node(plug, lport));
+	id->symbol         = lilv_node_duplicate(lilv_port_get_symbol(plug, lport));
+	id->label          = lilv_port_get_name(plug, lport);
+	id->index          = index;
+	id->group          = lilv_port_get(plug, lport, jalv->nodes.pg_group);
+	id->value_type     = jalv->forge.Float;
+	id->is_writable    = lilv_port_is_a(plug, lport, nodes->lv2_InputPort);
+	id->is_readable    = lilv_port_is_a(plug, lport, nodes->lv2_OutputPort);
+	id->is_toggle      = lilv_port_has_property(plug, lport, nodes->lv2_toggled);
+	id->is_integer     = lilv_port_has_property(plug, lport, nodes->lv2_integer);
+	id->is_enumeration = lilv_port_has_property(plug, lport, nodes->lv2_enumeration);
+	id->is_logarithmic = lilv_port_has_property(plug, lport, nodes->pprops_logarithmic);
+
+	lilv_port_get_range(plug, lport, &id->def, &id->min, &id->max);
+	if (lilv_port_has_property(plug, lport, jalv->nodes.lv2_sampleRate)) {
+		/* Adjust range for lv2:sampleRate controls */
+		if (lilv_node_is_float(id->min) || lilv_node_is_int(id->min)) {
+			const float min = lilv_node_as_float(id->min) * jalv->sample_rate;
+			lilv_node_free(id->min);
+			id->min = lilv_new_float(jalv->world, min);
+		}
+		if (lilv_node_is_float(id->max) || lilv_node_is_int(id->max)) {
+			const float max = lilv_node_as_float(id->max) * jalv->sample_rate;
+			lilv_node_free(id->max);
+			id->max = lilv_new_float(jalv->world, max);
+		}
+	}
+
+	/* Get scale points */
+	LilvScalePoints* sp = lilv_port_get_scale_points(plug, lport);
+	if (sp) {
+		id->points = (ScalePoint*)malloc(
+			lilv_scale_points_size(sp) * sizeof(ScalePoint));
+		size_t np = 0;
+		LILV_FOREACH(scale_points, s, sp) {
+			const LilvScalePoint* p = lilv_scale_points_get(sp, s);
+			if (lilv_node_is_float(lilv_scale_point_get_value(p)) ||
+			    lilv_node_is_int(lilv_scale_point_get_value(p))) {
+				id->points[np].value = lilv_node_as_float(
+					lilv_scale_point_get_value(p));
+				id->points[np].label = strdup(
+					lilv_node_as_string(lilv_scale_point_get_label(p)));
+				++np;
+			}
+			/* TODO: Non-float scale points? */
+		}
+
+		qsort(id->points, np, sizeof(ScalePoint),
+		      (int (*)(const void*, const void*))scale_point_cmp);
+		id->n_points = np;
+
+		lilv_scale_points_free(sp);
+	}
+
+	return id;
+}
+
+static bool
+has_range(Jalv* jalv, const LilvNode* subject, const char* range_uri)
+{
+	LilvNode*  range  = lilv_new_uri(jalv->world, range_uri);
+	const bool result = lilv_world_ask(
+		jalv->world, subject, jalv->nodes.rdfs_range, range);
+	lilv_node_free(range);
+	return result;
+}
+
+ControlID*
+new_property_control(Jalv* jalv, const LilvNode* property)
+{
+	ControlID* id = (ControlID*)calloc(1, sizeof(ControlID));
+	id->jalv     = jalv;
+	id->type     = PROPERTY;
+	id->node     = lilv_node_duplicate(property);
+	id->symbol   = lilv_world_get_symbol(jalv->world, property);
+	id->label    = lilv_world_get(jalv->world, property, jalv->nodes.rdfs_label, NULL);
+	id->property = jalv->map.map(jalv, lilv_node_as_uri(property));
+
+	id->min = lilv_world_get(jalv->world, property, jalv->nodes.lv2_minimum, NULL);
+	id->max = lilv_world_get(jalv->world, property, jalv->nodes.lv2_maximum, NULL);
+	id->def = lilv_world_get(jalv->world, property, jalv->nodes.lv2_default, NULL);
+
+	const char* const types[] = {
+		LV2_ATOM__Int, LV2_ATOM__Long, LV2_ATOM__Float, LV2_ATOM__Double,
+		LV2_ATOM__Bool, LV2_ATOM__String, LV2_ATOM__Path, NULL
+	};
+
+	for (const char*const* t = types; *t; ++t) {
+		if (has_range(jalv, property, *t)) {
+			id->value_type = jalv->map.map(jalv, *t);
+			break;
+		}
+	}
+
+	id->is_toggle  = (id->value_type == jalv->forge.Bool);
+	id->is_integer = (id->value_type == jalv->forge.Int ||
+	                  id->value_type == jalv->forge.Long);
+
+	const size_t sym_len = strlen(lilv_node_as_string(id->symbol));
+	if (sym_len > jalv->longest_sym) {
+		jalv->longest_sym = sym_len;
+	}
+
+	if (!id->value_type) {
+		fprintf(stderr, "Unknown value type for property <%s>\n",
+		        lilv_node_as_string(property));
+	}
+
+	return id;
+}
+
+void
+add_control(Controls* controls, ControlID* control)
+{
+	controls->controls = (ControlID**)realloc(
+		controls->controls, (controls->n_controls + 1) * sizeof(ControlID*));
+	controls->controls[controls->n_controls++] = control;
+}
+
+ControlID*
+get_property_control(const Controls* controls, LV2_URID property)
+{
+	for (size_t i = 0; i < controls->n_controls; ++i) {
+		if (controls->controls[i]->property == property) {
+			return controls->controls[i];
+		}
+	}
+
+	return NULL;
+}
diff --git a/src/jack.c b/src/jack.c
new file mode 100644
index 0000000..a763040
--- /dev/null
+++ b/src/jack.c
@@ -0,0 +1,482 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <jack/jack.h>
+#include <jack/midiport.h>
+#ifdef JALV_JACK_SESSION
+#    include <jack/session.h>
+#endif
+#ifdef HAVE_JACK_METADATA
+#    include <jack/metadata.h>
+#endif
+
+#include "jalv_internal.h"
+#include "worker.h"
+
+struct JalvBackend {
+	jack_client_t* client;  ///< Jack client
+};
+
+/** Jack buffer size callback. */
+static int
+jack_buffer_size_cb(jack_nframes_t nframes, void* data)
+{
+	Jalv* const jalv = (Jalv*)data;
+	jalv->block_length = nframes;
+	jalv->buf_size_set = true;
+#ifdef HAVE_JACK_PORT_TYPE_GET_BUFFER_SIZE
+	jalv->midi_buf_size = jack_port_type_get_buffer_size(
+		jalv->backend->client, JACK_DEFAULT_MIDI_TYPE);
+#endif
+	jalv_allocate_port_buffers(jalv);
+	return 0;
+}
+
+/** Jack shutdown callback. */
+static void
+jack_shutdown_cb(void* data)
+{
+	Jalv* const jalv = (Jalv*)data;
+	jalv_close_ui(jalv);
+	zix_sem_post(jalv->done);
+}
+
+/** Jack process callback. */
+static REALTIME int
+jack_process_cb(jack_nframes_t nframes, void* data)
+{
+	Jalv* const    jalv   = (Jalv*)data;
+	jack_client_t* client = jalv->backend->client;
+
+	/* Get Jack transport position */
+	jack_position_t pos;
+	const bool rolling = (jack_transport_query(client, &pos)
+	                      == JackTransportRolling);
+
+	/* If transport state is not as expected, then something has changed */
+	const bool xport_changed = (rolling != jalv->rolling ||
+	                            pos.frame != jalv->position ||
+	                            pos.beats_per_minute != jalv->bpm);
+
+	uint8_t   pos_buf[256];
+	LV2_Atom* lv2_pos = (LV2_Atom*)pos_buf;
+	if (xport_changed) {
+		/* Build an LV2 position object to report change to plugin */
+		lv2_atom_forge_set_buffer(&jalv->forge, pos_buf, sizeof(pos_buf));
+		LV2_Atom_Forge*      forge = &jalv->forge;
+		LV2_Atom_Forge_Frame frame;
+		lv2_atom_forge_object(forge, &frame, 0, jalv->urids.time_Position);
+		lv2_atom_forge_key(forge, jalv->urids.time_frame);
+		lv2_atom_forge_long(forge, pos.frame);
+		lv2_atom_forge_key(forge, jalv->urids.time_speed);
+		lv2_atom_forge_float(forge, rolling ? 1.0 : 0.0);
+		if (pos.valid & JackPositionBBT) {
+			lv2_atom_forge_key(forge, jalv->urids.time_barBeat);
+			lv2_atom_forge_float(
+				forge, pos.beat - 1 + (pos.tick / pos.ticks_per_beat));
+			lv2_atom_forge_key(forge, jalv->urids.time_bar);
+			lv2_atom_forge_long(forge, pos.bar - 1);
+			lv2_atom_forge_key(forge, jalv->urids.time_beatUnit);
+			lv2_atom_forge_int(forge, pos.beat_type);
+			lv2_atom_forge_key(forge, jalv->urids.time_beatsPerBar);
+			lv2_atom_forge_float(forge, pos.beats_per_bar);
+			lv2_atom_forge_key(forge, jalv->urids.time_beatsPerMinute);
+			lv2_atom_forge_float(forge, pos.beats_per_minute);
+		}
+
+		if (jalv->opts.dump) {
+			char* str = sratom_to_turtle(
+				jalv->sratom, &jalv->unmap, "time:", NULL, NULL,
+				lv2_pos->type, lv2_pos->size, LV2_ATOM_BODY(lv2_pos));
+			jalv_ansi_start(stdout, 36);
+			printf("\n## Position ##\n%s\n", str);
+			jalv_ansi_reset(stdout);
+			free(str);
+		}
+	}
+
+	/* Update transport state to expected values for next cycle */
+	jalv->position = rolling ? pos.frame + nframes : pos.frame;
+	jalv->bpm      = pos.beats_per_minute;
+	jalv->rolling  = rolling;
+
+	switch (jalv->play_state) {
+	case JALV_PAUSE_REQUESTED:
+		jalv->play_state = JALV_PAUSED;
+		zix_sem_post(&jalv->paused);
+		break;
+	case JALV_PAUSED:
+		for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+			jack_port_t* jport = jalv->ports[p].sys_port;
+			if (jport && jalv->ports[p].flow == FLOW_OUTPUT) {
+				void* buf = jack_port_get_buffer(jport, nframes);
+				if (jalv->ports[p].type == TYPE_EVENT) {
+					jack_midi_clear_buffer(buf);
+				} else {
+					memset(buf, '\0', nframes * sizeof(float));
+				}
+			}
+		}
+		return 0;
+	default:
+		break;
+	}
+
+	/* Prepare port buffers */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* port = &jalv->ports[p];
+		if (port->type == TYPE_AUDIO && port->sys_port) {
+			/* Connect plugin port directly to Jack port buffer */
+			lilv_instance_connect_port(
+				jalv->instance, p,
+				jack_port_get_buffer(port->sys_port, nframes));
+#ifdef HAVE_JACK_METADATA
+		} else if (port->type == TYPE_CV && port->sys_port) {
+			/* Connect plugin port directly to Jack port buffer */
+			lilv_instance_connect_port(
+				jalv->instance, p,
+				jack_port_get_buffer(port->sys_port, nframes));
+#endif
+		} else if (port->type == TYPE_EVENT && port->flow == FLOW_INPUT) {
+			lv2_evbuf_reset(port->evbuf, true);
+
+			/* Write transport change event if applicable */
+			LV2_Evbuf_Iterator iter = lv2_evbuf_begin(port->evbuf);
+			if (xport_changed) {
+				lv2_evbuf_write(&iter, 0, 0,
+				                lv2_pos->type, lv2_pos->size,
+				                (const uint8_t*)LV2_ATOM_BODY(lv2_pos));
+			}
+
+			if (jalv->request_update) {
+				/* Plugin state has changed, request an update */
+				const LV2_Atom_Object get = {
+					{ sizeof(LV2_Atom_Object_Body), jalv->urids.atom_Object },
+					{ 0, jalv->urids.patch_Get } };
+				lv2_evbuf_write(&iter, 0, 0,
+				                get.atom.type, get.atom.size,
+				                (const uint8_t*)LV2_ATOM_BODY(&get));
+			}
+
+			if (port->sys_port) {
+				/* Write Jack MIDI input */
+				void* buf = jack_port_get_buffer(port->sys_port, nframes);
+				for (uint32_t i = 0; i < jack_midi_get_event_count(buf); ++i) {
+					jack_midi_event_t ev;
+					jack_midi_event_get(&ev, buf, i);
+					lv2_evbuf_write(&iter,
+					                ev.time, 0,
+					                jalv->midi_event_id,
+					                ev.size, ev.buffer);
+				}
+			}
+		} else if (port->type == TYPE_EVENT) {
+			/* Clear event output for plugin to write to */
+			lv2_evbuf_reset(port->evbuf, false);
+		}
+	}
+	jalv->request_update = false;
+
+	/* Run plugin for this cycle */
+	const bool send_ui_updates = jalv_run(jalv, nframes);
+
+	/* Deliver MIDI output and UI events */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* const port = &jalv->ports[p];
+		if (port->flow == FLOW_OUTPUT && port->type == TYPE_CONTROL &&
+		    lilv_port_has_property(jalv->plugin, port->lilv_port,
+		                           jalv->nodes.lv2_reportsLatency)) {
+			if (jalv->plugin_latency != port->control) {
+				jalv->plugin_latency = port->control;
+				jack_recompute_total_latencies(client);
+			}
+		} else if (port->flow == FLOW_OUTPUT && port->type == TYPE_EVENT) {
+			void* buf = NULL;
+			if (port->sys_port) {
+				buf = jack_port_get_buffer(port->sys_port, nframes);
+				jack_midi_clear_buffer(buf);
+			}
+
+			for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf);
+			     lv2_evbuf_is_valid(i);
+			     i = lv2_evbuf_next(i)) {
+				// Get event from LV2 buffer
+				uint32_t frames, subframes, type, size;
+				uint8_t* body;
+				lv2_evbuf_get(i, &frames, &subframes, &type, &size, &body);
+
+				if (buf && type == jalv->midi_event_id) {
+					// Write MIDI event to Jack output
+					jack_midi_event_write(buf, frames, body, size);
+				}
+
+				if (jalv->has_ui && !port->old_api) {
+					// Forward event to UI
+					jalv_send_to_ui(jalv, p, type, size, body);
+				}
+			}
+		} else if (send_ui_updates &&
+		           port->flow == FLOW_OUTPUT && port->type == TYPE_CONTROL) {
+			char buf[sizeof(ControlChange) + sizeof(float)];
+			ControlChange* ev = (ControlChange*)buf;
+			ev->index    = p;
+			ev->protocol = 0;
+			ev->size     = sizeof(float);
+			*(float*)ev->body = port->control;
+			if (zix_ring_write(jalv->plugin_events, buf, sizeof(buf))
+			    < sizeof(buf)) {
+				fprintf(stderr, "Plugin => UI buffer overflow!\n");
+			}
+		}
+	}
+
+	return 0;
+}
+
+/** Calculate latency assuming all ports depend on each other. */
+static void
+jack_latency_cb(jack_latency_callback_mode_t mode, void* data)
+{
+	Jalv* const         jalv = (Jalv*)data;
+	const enum PortFlow flow = ((mode == JackCaptureLatency)
+	                            ? FLOW_INPUT : FLOW_OUTPUT);
+
+	/* First calculate the min/max latency of all feeding ports */
+	uint32_t             ports_found = 0;
+	jack_latency_range_t range       = { UINT32_MAX, 0 };
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* port = &jalv->ports[p];
+		if (port->sys_port && port->flow == flow) {
+			jack_latency_range_t r;
+			jack_port_get_latency_range(port->sys_port, mode, &r);
+			if (r.min < range.min) { range.min = r.min; }
+			if (r.max > range.max) { range.max = r.max; }
+			++ports_found;
+		}
+	}
+
+	if (ports_found == 0) {
+		range.min = 0;
+	}
+
+	/* Add the plugin's own latency */
+	range.min += jalv->plugin_latency;
+	range.max += jalv->plugin_latency;
+
+	/* Tell Jack about it */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* port = &jalv->ports[p];
+		if (port->sys_port && port->flow == flow) {
+			jack_port_set_latency_range(port->sys_port, mode, &range);
+		}
+	}
+}
+
+#ifdef JALV_JACK_SESSION
+static void
+jack_session_cb(jack_session_event_t* event, void* arg)
+{
+	Jalv* const jalv = (Jalv*)arg;
+
+	#define MAX_CMD_LEN 256
+	event->command_line = (char*)malloc(MAX_CMD_LEN);
+	snprintf(event->command_line, MAX_CMD_LEN, "%s -u %s -l \"${SESSION_DIR}\"",
+	         jalv->prog_name,
+	         event->client_uuid);
+
+	switch (event->type) {
+	case JackSessionSave:
+	case JackSessionSaveTemplate:
+		jalv_save(jalv, event->session_dir);
+		break;
+	case JackSessionSaveAndQuit:
+		jalv_save(jalv, event->session_dir);
+		jalv_close_ui(jalv);
+		break;
+	}
+
+	jack_session_reply(jalv->backend->client, event);
+	jack_session_event_free(event);
+}
+#endif /* JALV_JACK_SESSION */
+
+JalvBackend*
+jalv_backend_init(Jalv* jalv)
+{
+	jack_client_t* client = NULL;
+
+	/* Determine the name of the JACK client */
+	char* jack_name = NULL;
+	if (jalv->opts.name) {
+		/* Name given on command line */
+		jack_name = jalv_strdup(jalv->opts.name);
+	} else {
+		/* Use plugin name */
+		LilvNode* name = lilv_plugin_get_name(jalv->plugin);
+		jack_name = jalv_strdup(lilv_node_as_string(name));
+		lilv_node_free(name);
+	}
+
+	/* Truncate client name to suit JACK if necessary */
+	if (strlen(jack_name) >= (unsigned)jack_client_name_size() - 1) {
+		jack_name[jack_client_name_size() - 1] = '\0';
+	}
+	printf("JACK Name:    %s\n", jack_name);
+
+	/* Connect to JACK */
+#ifdef JALV_JACK_SESSION
+	if (jalv->opts.uuid) {
+		client = jack_client_open(
+			jack_name,
+			(jack_options_t)(JackSessionID |
+			                 (jalv->opts.name_exact ? JackUseExactName : 0)),
+			NULL,
+			jalv->opts.uuid);
+	}
+#endif
+
+	if (!client) {
+		client = jack_client_open(
+			jack_name,
+			(jalv->opts.name_exact ? JackUseExactName : JackNullOption),
+			NULL);
+	}
+
+	free(jack_name);
+	if (!client) {
+		return NULL;
+	}
+
+	/* Set audio engine properties */
+	jalv->sample_rate   = jack_get_sample_rate(client);
+	jalv->block_length  = jack_get_buffer_size(client);
+	jalv->midi_buf_size = 4096;
+#ifdef HAVE_JACK_PORT_TYPE_GET_BUFFER_SIZE
+	jalv->midi_buf_size = jack_port_type_get_buffer_size(
+		client, JACK_DEFAULT_MIDI_TYPE);
+#endif
+
+	/* Set JACK callbacks */
+	void* const arg = (void*)jalv;
+	jack_set_process_callback(client, &jack_process_cb, arg);
+	jack_set_buffer_size_callback(client, &jack_buffer_size_cb, arg);
+	jack_on_shutdown(client, &jack_shutdown_cb, arg);
+	jack_set_latency_callback(client, &jack_latency_cb, arg);
+#ifdef JALV_JACK_SESSION
+	jack_set_session_callback(client, &jack_session_cb, arg);
+#endif
+
+	/* Allocate and return opaque backend */
+	JalvBackend* backend = (JalvBackend*)calloc(1, sizeof(JalvBackend));
+	backend->client = client;
+	return backend;
+}
+
+void
+jalv_backend_close(Jalv* jalv)
+{
+	if (jalv->backend) {
+		jack_client_close(jalv->backend->client);
+		free(jalv->backend);
+		jalv->backend = NULL;
+	}
+}
+
+void
+jalv_backend_activate(Jalv* jalv)
+{
+	jack_activate(jalv->backend->client);
+}
+
+void
+jalv_backend_deactivate(Jalv* jalv)
+{
+	if (jalv->backend) {
+		jack_deactivate(jalv->backend->client);
+	}
+}
+
+void
+jalv_backend_activate_port(Jalv* jalv, uint32_t port_index)
+{
+	jack_client_t*     client = jalv->backend->client;
+	struct Port* const port   = &jalv->ports[port_index];
+
+	const LilvNode* sym = lilv_port_get_symbol(jalv->plugin, port->lilv_port);
+
+	/* Connect unsupported ports to NULL (known to be optional by this point) */
+	if (port->flow == FLOW_UNKNOWN || port->type == TYPE_UNKNOWN) {
+		lilv_instance_connect_port(jalv->instance, port_index, NULL);
+		return;
+	}
+
+	/* Build Jack flags for port */
+	enum JackPortFlags jack_flags = (port->flow == FLOW_INPUT)
+		? JackPortIsInput
+		: JackPortIsOutput;
+
+	/* Connect the port based on its type */
+	switch (port->type) {
+	case TYPE_CONTROL:
+		lilv_instance_connect_port(jalv->instance, port_index, &port->control);
+		break;
+	case TYPE_AUDIO:
+		port->sys_port = jack_port_register(
+			client, lilv_node_as_string(sym),
+			JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0);
+		break;
+#ifdef HAVE_JACK_METADATA
+	case TYPE_CV:
+		port->sys_port = jack_port_register(
+			client, lilv_node_as_string(sym),
+			JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0);
+		if (port->sys_port) {
+			jack_set_property(client, jack_port_uuid(port->sys_port),
+			                  "http://jackaudio.org/metadata/signal-type", "CV",
+			                  "text/plain");
+		}
+		break;
+#endif
+	case TYPE_EVENT:
+		if (lilv_port_supports_event(
+			    jalv->plugin, port->lilv_port, jalv->nodes.midi_MidiEvent)) {
+			port->sys_port = jack_port_register(
+				client, lilv_node_as_string(sym),
+				JACK_DEFAULT_MIDI_TYPE, jack_flags, 0);
+		}
+		break;
+	default:
+		break;
+	}
+
+#ifdef HAVE_JACK_METADATA
+	if (port->sys_port) {
+		// Set port order to index
+		char index_str[16];
+		snprintf(index_str, sizeof(index_str), "%d", port_index);
+		jack_set_property(client, jack_port_uuid(port->sys_port),
+		                  "http://jackaudio.org/metadata/order", index_str,
+		                  "http://www.w3.org/2001/XMLSchema#integer");
+
+		// Set port pretty name to label
+		LilvNode* name = lilv_port_get_name(jalv->plugin, port->lilv_port);
+		jack_set_property(client, jack_port_uuid(port->sys_port),
+		                  JACK_METADATA_PRETTY_NAME, lilv_node_as_string(name),
+		                  "text/plain");
+		lilv_node_free(name);
+	}
+#endif
+}
diff --git a/src/jalv.c b/src/jalv.c
new file mode 100644
index 0000000..f55a315
--- /dev/null
+++ b/src/jalv.c
@@ -0,0 +1,1209 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#define _POSIX_C_SOURCE 200809L /* for mkdtemp */
+#define _DARWIN_C_SOURCE        /* for mkdtemp on OSX */
+
+#include <assert.h>
+#include <math.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifndef __cplusplus
+#    include <stdbool.h>
+#endif
+
+#ifdef _WIN32
+#    include <io.h>  /* for _mktemp */
+#    define snprintf _snprintf
+#else
+#    include <unistd.h>
+#endif
+
+#include "jalv_config.h"
+#include "jalv_internal.h"
+
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
+#include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
+#include "lv2/lv2plug.in/ns/ext/data-access/data-access.h"
+#include "lv2/lv2plug.in/ns/ext/event/event.h"
+#include "lv2/lv2plug.in/ns/ext/options/options.h"
+#include "lv2/lv2plug.in/ns/ext/parameters/parameters.h"
+#include "lv2/lv2plug.in/ns/ext/patch/patch.h"
+#include "lv2/lv2plug.in/ns/ext/port-groups/port-groups.h"
+#include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
+#include "lv2/lv2plug.in/ns/ext/presets/presets.h"
+#include "lv2/lv2plug.in/ns/ext/state/state.h"
+#include "lv2/lv2plug.in/ns/ext/time/time.h"
+#include "lv2/lv2plug.in/ns/ext/uri-map/uri-map.h"
+#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
+#include "lv2/lv2plug.in/ns/ext/worker/worker.h"
+#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
+
+#include "lilv/lilv.h"
+
+#include "suil/suil.h"
+
+#include "lv2_evbuf.h"
+#include "worker.h"
+
+#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_XSD "http://www.w3.org/2001/XMLSchema#"
+
+#ifndef MIN
+#    define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef MAX
+#    define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#endif
+
+/* Size factor for UI ring buffers.  The ring size is a few times the size of
+   an event output to give the UI a chance to keep up.  Experiments with Ingen,
+   which can highly saturate its event output, led me to this value.  It
+   really ought to be enough for anybody(TM).
+*/
+#define N_BUFFER_CYCLES 16
+
+ZixSem exit_sem;  /**< Exit semaphore */
+
+static LV2_URID
+map_uri(LV2_URID_Map_Handle handle,
+        const char*         uri)
+{
+	Jalv* jalv = (Jalv*)handle;
+	zix_sem_wait(&jalv->symap_lock);
+	const LV2_URID id = symap_map(jalv->symap, uri);
+	zix_sem_post(&jalv->symap_lock);
+	return id;
+}
+
+static const char*
+unmap_uri(LV2_URID_Unmap_Handle handle,
+          LV2_URID              urid)
+{
+	Jalv* jalv = (Jalv*)handle;
+	zix_sem_wait(&jalv->symap_lock);
+	const char* uri = symap_unmap(jalv->symap, urid);
+	zix_sem_post(&jalv->symap_lock);
+	return uri;
+}
+
+/**
+   Map function for URI map extension.
+*/
+static uint32_t
+uri_to_id(LV2_URI_Map_Callback_Data callback_data,
+          const char*               map,
+          const char*               uri)
+{
+	Jalv* jalv = (Jalv*)callback_data;
+	zix_sem_wait(&jalv->symap_lock);
+	const LV2_URID id = symap_map(jalv->symap, uri);
+	zix_sem_post(&jalv->symap_lock);
+	return id;
+}
+
+#define NS_EXT "http://lv2plug.in/ns/ext/"
+
+static LV2_URI_Map_Feature uri_map = { NULL, &uri_to_id };
+
+static LV2_Extension_Data_Feature ext_data = { NULL };
+
+LV2_Feature uri_map_feature      = { NS_EXT "uri-map", NULL };
+LV2_Feature map_feature          = { LV2_URID__map, NULL };
+LV2_Feature unmap_feature        = { LV2_URID__unmap, NULL };
+LV2_Feature make_path_feature    = { LV2_STATE__makePath, NULL };
+LV2_Feature sched_feature        = { LV2_WORKER__schedule, NULL };
+LV2_Feature state_sched_feature  = { LV2_WORKER__schedule, NULL };
+LV2_Feature safe_restore_feature = { LV2_STATE__threadSafeRestore, NULL };
+LV2_Feature log_feature          = { LV2_LOG__log, NULL };
+LV2_Feature options_feature      = { LV2_OPTIONS__options, NULL };
+LV2_Feature def_state_feature    = { LV2_STATE__loadDefaultState, NULL };
+
+/** These features have no data */
+static LV2_Feature buf_size_features[3] = {
+	{ LV2_BUF_SIZE__powerOf2BlockLength, NULL },
+	{ LV2_BUF_SIZE__fixedBlockLength, NULL },
+	{ LV2_BUF_SIZE__boundedBlockLength, NULL } };
+
+const LV2_Feature* features[12] = {
+	&uri_map_feature, &map_feature, &unmap_feature,
+	&sched_feature,
+	&log_feature,
+	&options_feature,
+	&def_state_feature,
+	&safe_restore_feature,
+	&buf_size_features[0],
+	&buf_size_features[1],
+	&buf_size_features[2],
+	NULL
+};
+
+/** Return true iff Jalv supports the given feature. */
+static bool
+feature_is_supported(const char* uri)
+{
+	if (!strcmp(uri, "http://lv2plug.in/ns/lv2core#isLive")) {
+		return true;
+	}
+	for (const LV2_Feature*const* f = features; *f; ++f) {
+		if (!strcmp(uri, (*f)->URI)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/** Abort and exit on error */
+static void
+die(const char* msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	exit(EXIT_FAILURE);
+}
+
+/**
+   Create a port structure from data description.  This is called before plugin
+   and Jack instantiation.  The remaining instance-specific setup
+   (e.g. buffers) is done later in activate_port().
+*/
+static void
+create_port(Jalv*    jalv,
+            uint32_t port_index,
+            float    default_value)
+{
+	struct Port* const port = &jalv->ports[port_index];
+
+	port->lilv_port = lilv_plugin_get_port_by_index(jalv->plugin, port_index);
+	port->sys_port  = NULL;
+	port->evbuf     = NULL;
+	port->buf_size  = 0;
+	port->index     = port_index;
+	port->control   = 0.0f;
+	port->flow      = FLOW_UNKNOWN;
+
+	const bool optional = lilv_port_has_property(
+		jalv->plugin, port->lilv_port, jalv->nodes.lv2_connectionOptional);
+
+	/* Set the port flow (input or output) */
+	if (lilv_port_is_a(jalv->plugin, port->lilv_port, jalv->nodes.lv2_InputPort)) {
+		port->flow = FLOW_INPUT;
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.lv2_OutputPort)) {
+		port->flow = FLOW_OUTPUT;
+	} else if (!optional) {
+		die("Mandatory port has unknown type (neither input nor output)");
+	}
+
+	/* Set control values */
+	if (lilv_port_is_a(jalv->plugin, port->lilv_port, jalv->nodes.lv2_ControlPort)) {
+		port->type    = TYPE_CONTROL;
+		port->control = isnan(default_value) ? 0.0f : default_value;
+		if (jalv->opts.show_hidden ||
+		    !lilv_port_has_property(jalv->plugin, port->lilv_port, jalv->nodes.pprops_notOnGUI)) {
+			add_control(&jalv->controls, new_port_control(jalv, port->index));
+		}
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.lv2_AudioPort)) {
+		port->type = TYPE_AUDIO;
+#ifdef HAVE_JACK_METADATA
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.lv2_CVPort)) {
+		port->type = TYPE_CV;
+#endif
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.ev_EventPort)) {
+		port->type = TYPE_EVENT;
+		port->old_api = true;
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.atom_AtomPort)) {
+		port->type = TYPE_EVENT;
+		port->old_api = false;
+	} else if (!optional) {
+		die("Mandatory port has unknown data type");
+	}
+
+	LilvNode* min_size = lilv_port_get(
+		jalv->plugin, port->lilv_port, jalv->nodes.rsz_minimumSize);
+	if (min_size && lilv_node_is_int(min_size)) {
+		port->buf_size = lilv_node_as_int(min_size);
+		jalv->opts.buffer_size = MAX(
+			jalv->opts.buffer_size, port->buf_size * N_BUFFER_CYCLES);
+	}
+	lilv_node_free(min_size);
+
+	/* Update longest symbol for aligned console printing */
+	const LilvNode* sym = lilv_port_get_symbol(jalv->plugin, port->lilv_port);
+	const size_t    len = strlen(lilv_node_as_string(sym));
+	if (len > jalv->longest_sym) {
+		jalv->longest_sym = len;
+	}
+}
+
+/**
+   Create port structures from data (via create_port()) for all ports.
+*/
+void
+jalv_create_ports(Jalv* jalv)
+{
+	jalv->num_ports = lilv_plugin_get_num_ports(jalv->plugin);
+	jalv->ports     = (struct Port*)calloc(jalv->num_ports, sizeof(struct Port));
+	float* default_values = (float*)calloc(
+		lilv_plugin_get_num_ports(jalv->plugin), sizeof(float));
+	lilv_plugin_get_port_ranges_float(jalv->plugin, NULL, NULL, default_values);
+
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		create_port(jalv, i, default_values[i]);
+	}
+
+	const LilvPort* control_input = lilv_plugin_get_port_by_designation(
+		jalv->plugin, jalv->nodes.lv2_InputPort, jalv->nodes.lv2_control);
+	if (control_input) {
+		jalv->control_in = lilv_port_get_index(jalv->plugin, control_input);
+	}
+
+	free(default_values);
+}
+
+/**
+   Allocate port buffers (only necessary for MIDI).
+*/
+void
+jalv_allocate_port_buffers(Jalv* jalv)
+{
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		struct Port* const port     = &jalv->ports[i];
+		switch (port->type) {
+		case TYPE_EVENT: {
+			lv2_evbuf_free(port->evbuf);
+			const size_t buf_size = (port->buf_size > 0)
+				? port->buf_size
+				: jalv->midi_buf_size;
+			port->evbuf = lv2_evbuf_new(
+				buf_size,
+				port->old_api ? LV2_EVBUF_EVENT : LV2_EVBUF_ATOM,
+				jalv->map.map(jalv->map.handle,
+				              lilv_node_as_string(jalv->nodes.atom_Chunk)),
+				jalv->map.map(jalv->map.handle,
+				              lilv_node_as_string(jalv->nodes.atom_Sequence)));
+			lilv_instance_connect_port(
+				jalv->instance, i, lv2_evbuf_get_buffer(port->evbuf));
+		}
+		default: break;
+		}
+	}
+}
+
+/**
+   Get a port structure by symbol.
+
+   TODO: Build an index to make this faster, currently O(n) which may be
+   a problem when restoring the state of plugins with many ports.
+*/
+struct Port*
+jalv_port_by_symbol(Jalv* jalv, const char* sym)
+{
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		struct Port* const port     = &jalv->ports[i];
+		const LilvNode*    port_sym = lilv_port_get_symbol(jalv->plugin,
+		                                                   port->lilv_port);
+
+		if (!strcmp(lilv_node_as_string(port_sym), sym)) {
+			return port;
+		}
+	}
+
+	return NULL;
+}
+
+ControlID*
+jalv_control_by_symbol(Jalv* jalv, const char* sym)
+{
+	for (size_t i = 0; i < jalv->controls.n_controls; ++i) {
+		if (!strcmp(lilv_node_as_string(jalv->controls.controls[i]->symbol),
+		            sym)) {
+			return jalv->controls.controls[i];
+		}
+	}
+	return NULL;
+}
+
+static void
+print_control_value(Jalv* jalv, const struct Port* port, float value)
+{
+	const LilvNode* sym = lilv_port_get_symbol(jalv->plugin, port->lilv_port);
+	printf("%-*s = %f\n", jalv->longest_sym, lilv_node_as_string(sym), value);
+}
+
+void
+jalv_create_controls(Jalv* jalv, bool writable)
+{
+	const LilvPlugin* plugin         = jalv->plugin;
+	LilvWorld*        world          = jalv->world;
+	LilvNode*         patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
+	LilvNode*         patch_readable = lilv_new_uri(world, LV2_PATCH__readable);
+
+	LilvNodes* properties = lilv_world_find_nodes(
+		world,
+		lilv_plugin_get_uri(plugin),
+		writable ? patch_writable : patch_readable,
+		NULL);
+	LILV_FOREACH(nodes, p, properties) {
+		const LilvNode* property = lilv_nodes_get(properties, p);
+		ControlID*      record   = NULL;
+
+		if (!writable && lilv_world_ask(world,
+		                                lilv_plugin_get_uri(plugin),
+		                                patch_writable,
+		                                property)) {
+			// Find existing writable control
+			for (size_t i = 0; i < jalv->controls.n_controls; ++i) {
+				if (lilv_node_equals(jalv->controls.controls[i]->node, property)) {
+					record              = jalv->controls.controls[i];
+					record->is_readable = true;
+					break;
+				}
+			}
+
+			if (record) {
+				continue;
+			}
+		}
+
+		record = new_property_control(jalv, property);
+		if (writable) {
+			record->is_writable = true;
+		} else {
+			record->is_readable = true;
+		}
+
+		if (record->value_type) {
+			add_control(&jalv->controls, record);
+		} else {
+			fprintf(stderr, "Parameter <%s> has unknown value type, ignored\n",
+			        lilv_node_as_string(record->node));
+			free(record);
+		}
+	}
+	lilv_nodes_free(properties);
+
+	lilv_node_free(patch_readable);
+	lilv_node_free(patch_writable);
+}
+
+void
+jalv_set_control(const ControlID* control,
+                 uint32_t         size,
+                 LV2_URID         type,
+                 const void*      body)
+{
+	Jalv* jalv = control->jalv;
+	if (control->type == PORT && type == jalv->forge.Float) {
+		struct Port* port = &control->jalv->ports[control->index];
+		port->control = *(float*)body;
+	} else if (control->type == PROPERTY) {
+		// Copy forge since it is used by process thread
+		LV2_Atom_Forge       forge = jalv->forge;
+		LV2_Atom_Forge_Frame frame;
+		uint8_t              buf[1024];
+		lv2_atom_forge_set_buffer(&forge, buf, sizeof(buf));
+
+		lv2_atom_forge_object(&forge, &frame, 0, jalv->urids.patch_Set);
+		lv2_atom_forge_key(&forge, jalv->urids.patch_property);
+		lv2_atom_forge_urid(&forge, control->property);
+		lv2_atom_forge_key(&forge, jalv->urids.patch_value);
+		lv2_atom_forge_atom(&forge, size, type);
+		lv2_atom_forge_write(&forge, body, size);
+
+		const LV2_Atom* atom = lv2_atom_forge_deref(&forge, frame.ref);
+		jalv_ui_write(jalv,
+		              jalv->control_in,
+		              lv2_atom_total_size(atom),
+		              jalv->urids.atom_eventTransfer,
+		              atom);
+	}
+}
+
+void
+jalv_ui_instantiate(Jalv* jalv, const char* native_ui_type, void* parent)
+{
+	jalv->ui_host = suil_host_new(jalv_ui_write, jalv_ui_port_index, NULL, NULL);
+
+	const LV2_Feature parent_feature = {
+		LV2_UI__parent, parent
+	};
+	const LV2_Feature instance_feature = {
+		NS_EXT "instance-access", lilv_instance_get_handle(jalv->instance)
+	};
+	const LV2_Feature data_feature = {
+		LV2_DATA_ACCESS_URI, &ext_data
+	};
+	const LV2_Feature idle_feature = {
+		LV2_UI__idleInterface, NULL
+	};
+	const LV2_Feature* ui_features[] = {
+		&uri_map_feature, &map_feature, &unmap_feature,
+		&instance_feature,
+		&data_feature,
+		&log_feature,
+		&parent_feature,
+		&options_feature,
+		&idle_feature,
+		NULL
+	};
+
+	const char* bundle_uri  = lilv_node_as_uri(lilv_ui_get_bundle_uri(jalv->ui));
+	const char* binary_uri  = lilv_node_as_uri(lilv_ui_get_binary_uri(jalv->ui));
+	char*       bundle_path = lilv_file_uri_parse(bundle_uri, NULL);
+	char*       binary_path = lilv_file_uri_parse(binary_uri, NULL);
+
+	jalv->ui_instance = suil_instance_new(
+		jalv->ui_host,
+		jalv,
+		native_ui_type,
+		lilv_node_as_uri(lilv_plugin_get_uri(jalv->plugin)),
+		lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)),
+		lilv_node_as_uri(jalv->ui_type),
+		bundle_path,
+		binary_path,
+		ui_features);
+
+	lilv_free(binary_path);
+	lilv_free(bundle_path);
+}
+
+bool
+jalv_ui_is_resizable(Jalv* jalv)
+{
+	if (!jalv->ui) {
+		return false;
+	}
+
+	const LilvNode* s   = lilv_ui_get_uri(jalv->ui);
+	LilvNode*       p   = lilv_new_uri(jalv->world, LV2_CORE__optionalFeature);
+	LilvNode*       fs  = lilv_new_uri(jalv->world, LV2_UI__fixedSize);
+	LilvNode*       nrs = lilv_new_uri(jalv->world, LV2_UI__noUserResize);
+
+	LilvNodes* fs_matches = lilv_world_find_nodes(jalv->world, s, p, fs);
+	LilvNodes* nrs_matches = lilv_world_find_nodes(jalv->world, s, p, nrs);
+
+	lilv_nodes_free(nrs_matches);
+	lilv_nodes_free(fs_matches);
+	lilv_node_free(nrs);
+	lilv_node_free(fs);
+	lilv_node_free(p);
+
+	return !fs_matches && !nrs_matches;
+}
+
+void
+jalv_ui_write(SuilController controller,
+              uint32_t       port_index,
+              uint32_t       buffer_size,
+              uint32_t       protocol,
+              const void*    buffer)
+{
+	Jalv* const jalv = (Jalv*)controller;
+
+	if (protocol != 0 && protocol != jalv->urids.atom_eventTransfer) {
+		fprintf(stderr, "UI write with unsupported protocol %d (%s)\n",
+		        protocol, unmap_uri(jalv, protocol));
+		return;
+	}
+
+	if (port_index >= jalv->num_ports) {
+		fprintf(stderr, "UI write to out of range port index %d\n",
+		        port_index);
+		return;
+	}
+
+	if (jalv->opts.dump && protocol == jalv->urids.atom_eventTransfer) {
+		const LV2_Atom* atom = (const LV2_Atom*)buffer;
+		char*           str  = sratom_to_turtle(
+			jalv->sratom, &jalv->unmap, "jalv:", NULL, NULL,
+			atom->type, atom->size, LV2_ATOM_BODY_CONST(atom));
+		jalv_ansi_start(stdout, 36);
+		printf("\n## UI => Plugin (%u bytes) ##\n%s\n", atom->size, str);
+		jalv_ansi_reset(stdout);
+		free(str);
+	}
+
+	char buf[sizeof(ControlChange) + buffer_size];
+	ControlChange* ev = (ControlChange*)buf;
+	ev->index    = port_index;
+	ev->protocol = protocol;
+	ev->size     = buffer_size;
+	memcpy(ev->body, buffer, buffer_size);
+	zix_ring_write(jalv->ui_events, buf, sizeof(buf));
+}
+
+void
+jalv_apply_ui_events(Jalv* jalv, uint32_t nframes)
+{
+	if (!jalv->has_ui) {
+		return;
+	}
+
+	ControlChange ev;
+	const size_t  space = zix_ring_read_space(jalv->ui_events);
+	for (size_t i = 0; i < space; i += sizeof(ev) + ev.size) {
+		zix_ring_read(jalv->ui_events, (char*)&ev, sizeof(ev));
+		char body[ev.size];
+		if (zix_ring_read(jalv->ui_events, body, ev.size) != ev.size) {
+			fprintf(stderr, "error: Error reading from UI ring buffer\n");
+			break;
+		}
+		assert(ev.index < jalv->num_ports);
+		struct Port* const port = &jalv->ports[ev.index];
+		if (ev.protocol == 0) {
+			assert(ev.size == sizeof(float));
+			port->control = *(float*)body;
+		} else if (ev.protocol == jalv->urids.atom_eventTransfer) {
+			LV2_Evbuf_Iterator    e    = lv2_evbuf_end(port->evbuf);
+			const LV2_Atom* const atom = (const LV2_Atom*)body;
+			lv2_evbuf_write(&e, nframes, 0, atom->type, atom->size,
+			                (const uint8_t*)LV2_ATOM_BODY_CONST(atom));
+		} else {
+			fprintf(stderr, "error: Unknown control change protocol %d\n",
+			        ev.protocol);
+		}
+	}
+}
+
+uint32_t
+jalv_ui_port_index(SuilController controller, const char* symbol)
+{
+	Jalv* const  jalv = (Jalv*)controller;
+	struct Port* port = jalv_port_by_symbol(jalv, symbol);
+
+	return port ? port->index : LV2UI_INVALID_PORT_INDEX;
+}
+
+void
+jalv_init_ui(Jalv* jalv)
+{
+	// Set initial control port values
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		if (jalv->ports[i].type == TYPE_CONTROL) {
+			jalv_ui_port_event(jalv, i,
+			                   sizeof(float), 0,
+			                   &jalv->ports[i].control);
+		}
+	}
+
+	if (jalv->control_in != (uint32_t)-1) {
+		// Send patch:Get message for initial parameters/etc
+		LV2_Atom_Forge       forge = jalv->forge;
+		LV2_Atom_Forge_Frame frame;
+		uint8_t              buf[1024];
+		lv2_atom_forge_set_buffer(&forge, buf, sizeof(buf));
+		lv2_atom_forge_object(&forge, &frame, 0, jalv->urids.patch_Get);
+
+		const LV2_Atom* atom = lv2_atom_forge_deref(&forge, frame.ref);
+		jalv_ui_write(jalv,
+		              jalv->control_in,
+		              lv2_atom_total_size(atom),
+		              jalv->urids.atom_eventTransfer,
+		              atom);
+		lv2_atom_forge_pop(&forge, &frame);
+	}
+}
+
+bool
+jalv_send_to_ui(Jalv*       jalv,
+                uint32_t    port_index,
+                uint32_t    type,
+                uint32_t    size,
+                const void* body)
+{
+	/* TODO: Be more disciminate about what to send */
+	char evbuf[sizeof(ControlChange) + sizeof(LV2_Atom)];
+	ControlChange* ev = (ControlChange*)evbuf;
+	ev->index    = port_index;
+	ev->protocol = jalv->urids.atom_eventTransfer;
+	ev->size     = sizeof(LV2_Atom) + size;
+
+	LV2_Atom* atom = (LV2_Atom*)ev->body;
+	atom->type = type;
+	atom->size = size;
+
+	if (zix_ring_write_space(jalv->plugin_events) >= sizeof(evbuf) + size) {
+		zix_ring_write(jalv->plugin_events, evbuf, sizeof(evbuf));
+		zix_ring_write(jalv->plugin_events, (const char*)body, size);
+		return true;
+	} else {
+		fprintf(stderr, "Plugin => UI buffer overflow!\n");
+		return false;
+	}
+}
+
+bool
+jalv_run(Jalv* jalv, uint32_t nframes)
+{
+	/* Read and apply control change events from UI */
+	jalv_apply_ui_events(jalv, nframes);
+
+	/* Run plugin for this cycle */
+	lilv_instance_run(jalv->instance, nframes);
+
+	/* Process any worker replies. */
+	jalv_worker_emit_responses(&jalv->state_worker, jalv->instance);
+	jalv_worker_emit_responses(&jalv->worker, jalv->instance);
+
+	/* Notify the plugin the run() cycle is finished */
+	if (jalv->worker.iface && jalv->worker.iface->end_run) {
+		jalv->worker.iface->end_run(jalv->instance->lv2_handle);
+	}
+
+	/* Check if it's time to send updates to the UI */
+	jalv->event_delta_t += nframes;
+	bool     send_ui_updates = false;
+	uint32_t update_frames   = jalv->sample_rate / jalv->ui_update_hz;
+	if (jalv->has_ui && (jalv->event_delta_t > update_frames)) {
+		send_ui_updates = true;
+		jalv->event_delta_t = 0;
+	}
+
+	return send_ui_updates;
+}
+
+bool
+jalv_update(Jalv* jalv)
+{
+	/* Check quit flag and close if set. */
+	if (zix_sem_try_wait(&exit_sem)) {
+		jalv_close_ui(jalv);
+		return false;
+	}
+
+	/* Emit UI events. */
+	ControlChange ev;
+	const size_t  space = zix_ring_read_space(jalv->plugin_events);
+	for (size_t i = 0;
+	     i + sizeof(ev) < space;
+	     i += sizeof(ev) + ev.size) {
+		/* Read event header to get the size */
+		zix_ring_read(jalv->plugin_events, (char*)&ev, sizeof(ev));
+
+		/* Resize read buffer if necessary */
+		jalv->ui_event_buf = realloc(jalv->ui_event_buf, ev.size);
+		void* const buf = jalv->ui_event_buf;
+
+		/* Read event body */
+		zix_ring_read(jalv->plugin_events, (char*)buf, ev.size);
+
+		if (jalv->opts.dump && ev.protocol == jalv->urids.atom_eventTransfer) {
+			/* Dump event in Turtle to the console */
+			LV2_Atom* atom = (LV2_Atom*)buf;
+			char*     str  = sratom_to_turtle(
+				jalv->ui_sratom, &jalv->unmap, "jalv:", NULL, NULL,
+				atom->type, atom->size, LV2_ATOM_BODY(atom));
+			jalv_ansi_start(stdout, 35);
+			printf("\n## Plugin => UI (%u bytes) ##\n%s\n", atom->size, str);
+			jalv_ansi_reset(stdout);
+			free(str);
+		}
+
+		if (jalv->ui_instance) {
+			suil_instance_port_event(jalv->ui_instance, ev.index,
+			                         ev.size, ev.protocol, buf);
+		} else {
+			jalv_ui_port_event(jalv, ev.index, ev.size, ev.protocol, buf);
+		}
+
+		if (ev.protocol == 0 && jalv->opts.print_controls) {
+			print_control_value(jalv, &jalv->ports[ev.index], *(float*)buf);
+		}
+	}
+
+	return true;
+}
+
+static bool
+jalv_apply_control_arg(Jalv* jalv, const char* s)
+{
+	char  sym[256];
+	float val = 0.0f;
+	if (sscanf(s, "%[^=]=%f", sym, &val) != 2) {
+		fprintf(stderr, "warning: Ignoring invalid value `%s'\n", s);
+		return false;
+	}
+
+	ControlID* control = jalv_control_by_symbol(jalv, sym);
+	if (!control) {
+		fprintf(stderr, "warning: Ignoring value for unknown control `%s'\n", sym);
+		return false;
+	}
+
+	jalv_set_control(control, sizeof(float), jalv->urids.atom_Float, &val);
+	printf("%-*s = %f\n", jalv->longest_sym, sym, val);
+
+	return true;
+}
+
+static void
+signal_handler(int ignored)
+{
+	zix_sem_post(&exit_sem);
+}
+
+int
+main(int argc, char** argv)
+{
+	Jalv jalv;
+	memset(&jalv, '\0', sizeof(Jalv));
+	jalv.prog_name     = argv[0];
+	jalv.block_length  = 4096;  /* Should be set by backend */
+	jalv.midi_buf_size = 1024;  /* Should be set by backend */
+	jalv.play_state    = JALV_PAUSED;
+	jalv.bpm           = 120.0f;
+	jalv.control_in    = (uint32_t)-1;
+
+	suil_init(&argc, &argv, SUIL_ARG_NONE);
+	if (jalv_init(&argc, &argv, &jalv.opts)) {
+		return EXIT_FAILURE;
+	}
+
+	if (jalv.opts.uuid) {
+		printf("UUID: %s\n", jalv.opts.uuid);
+	}
+
+	jalv.symap = symap_new();
+	zix_sem_init(&jalv.symap_lock, 1);
+	zix_sem_init(&jalv.work_lock, 1);
+	uri_map_feature.data  = &uri_map;
+	uri_map.callback_data = &jalv;
+
+	jalv.map.handle  = &jalv;
+	jalv.map.map     = map_uri;
+	map_feature.data = &jalv.map;
+
+	jalv.worker.jalv       = &jalv;
+	jalv.state_worker.jalv = &jalv;
+
+	jalv.unmap.handle  = &jalv;
+	jalv.unmap.unmap   = unmap_uri;
+	unmap_feature.data = &jalv.unmap;
+
+	lv2_atom_forge_init(&jalv.forge, &jalv.map);
+
+	jalv.env = serd_env_new(NULL);
+	serd_env_set_prefix_from_strings(
+		jalv.env, (const uint8_t*)"patch", (const uint8_t*)LV2_PATCH_PREFIX);
+	serd_env_set_prefix_from_strings(
+		jalv.env, (const uint8_t*)"time", (const uint8_t*)LV2_TIME_PREFIX);
+	serd_env_set_prefix_from_strings(
+		jalv.env, (const uint8_t*)"xsd", (const uint8_t*)NS_XSD);
+
+	jalv.sratom    = sratom_new(&jalv.map);
+	jalv.ui_sratom = sratom_new(&jalv.map);
+	sratom_set_env(jalv.sratom, jalv.env);
+	sratom_set_env(jalv.ui_sratom, jalv.env);
+
+	jalv.midi_event_id = uri_to_id(
+		&jalv, "http://lv2plug.in/ns/ext/event", LV2_MIDI__MidiEvent);
+
+	jalv.urids.atom_Float           = symap_map(jalv.symap, LV2_ATOM__Float);
+	jalv.urids.atom_Int             = symap_map(jalv.symap, LV2_ATOM__Int);
+	jalv.urids.atom_Object          = symap_map(jalv.symap, LV2_ATOM__Object);
+	jalv.urids.atom_Path            = symap_map(jalv.symap, LV2_ATOM__Path);
+	jalv.urids.atom_String          = symap_map(jalv.symap, LV2_ATOM__String);
+	jalv.urids.atom_eventTransfer   = symap_map(jalv.symap, LV2_ATOM__eventTransfer);
+	jalv.urids.bufsz_maxBlockLength = symap_map(jalv.symap, LV2_BUF_SIZE__maxBlockLength);
+	jalv.urids.bufsz_minBlockLength = symap_map(jalv.symap, LV2_BUF_SIZE__minBlockLength);
+	jalv.urids.bufsz_sequenceSize   = symap_map(jalv.symap, LV2_BUF_SIZE__sequenceSize);
+	jalv.urids.log_Error            = symap_map(jalv.symap, LV2_LOG__Error);
+	jalv.urids.log_Trace            = symap_map(jalv.symap, LV2_LOG__Trace);
+	jalv.urids.log_Warning          = symap_map(jalv.symap, LV2_LOG__Warning);
+	jalv.urids.midi_MidiEvent       = symap_map(jalv.symap, LV2_MIDI__MidiEvent);
+	jalv.urids.param_sampleRate     = symap_map(jalv.symap, LV2_PARAMETERS__sampleRate);
+	jalv.urids.patch_Get            = symap_map(jalv.symap, LV2_PATCH__Get);
+	jalv.urids.patch_Put            = symap_map(jalv.symap, LV2_PATCH__Put);
+	jalv.urids.patch_Set            = symap_map(jalv.symap, LV2_PATCH__Set);
+	jalv.urids.patch_body           = symap_map(jalv.symap, LV2_PATCH__body);
+	jalv.urids.patch_property       = symap_map(jalv.symap, LV2_PATCH__property);
+	jalv.urids.patch_value          = symap_map(jalv.symap, LV2_PATCH__value);
+	jalv.urids.time_Position        = symap_map(jalv.symap, LV2_TIME__Position);
+	jalv.urids.time_bar             = symap_map(jalv.symap, LV2_TIME__bar);
+	jalv.urids.time_barBeat         = symap_map(jalv.symap, LV2_TIME__barBeat);
+	jalv.urids.time_beatUnit        = symap_map(jalv.symap, LV2_TIME__beatUnit);
+	jalv.urids.time_beatsPerBar     = symap_map(jalv.symap, LV2_TIME__beatsPerBar);
+	jalv.urids.time_beatsPerMinute  = symap_map(jalv.symap, LV2_TIME__beatsPerMinute);
+	jalv.urids.time_frame           = symap_map(jalv.symap, LV2_TIME__frame);
+	jalv.urids.time_speed           = symap_map(jalv.symap, LV2_TIME__speed);
+	jalv.urids.ui_updateRate        = symap_map(jalv.symap, LV2_UI__updateRate);
+
+#ifdef _WIN32
+	jalv.temp_dir = jalv_strdup("jalvXXXXXX");
+	_mktemp(jalv.temp_dir);
+#else
+	char* templ = jalv_strdup("/tmp/jalv-XXXXXX");
+	jalv.temp_dir = jalv_strjoin(mkdtemp(templ), "/");
+	free(templ);
+#endif
+
+	LV2_State_Make_Path make_path = { &jalv, jalv_make_path };
+	make_path_feature.data = &make_path;
+
+	LV2_Worker_Schedule sched = { &jalv.worker, jalv_worker_schedule };
+	sched_feature.data = &sched;
+
+	LV2_Worker_Schedule ssched = { &jalv.state_worker, jalv_worker_schedule };
+	state_sched_feature.data = &ssched;
+
+	LV2_Log_Log llog = { &jalv, jalv_printf, jalv_vprintf };
+	log_feature.data = &llog;
+
+	zix_sem_init(&exit_sem, 0);
+	jalv.done = &exit_sem;
+
+	zix_sem_init(&jalv.paused, 0);
+	zix_sem_init(&jalv.worker.sem, 0);
+
+	signal(SIGINT, signal_handler);
+	signal(SIGTERM, signal_handler);
+
+	/* Find all installed plugins */
+	LilvWorld* world = lilv_world_new();
+	lilv_world_load_all(world);
+	jalv.world = world;
+	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+
+	/* Cache URIs for concepts we'll use */
+	jalv.nodes.atom_AtomPort          = lilv_new_uri(world, LV2_ATOM__AtomPort);
+	jalv.nodes.atom_Chunk             = lilv_new_uri(world, LV2_ATOM__Chunk);
+	jalv.nodes.atom_Float             = lilv_new_uri(world, LV2_ATOM__Float);
+	jalv.nodes.atom_Path              = lilv_new_uri(world, LV2_ATOM__Path);
+	jalv.nodes.atom_Sequence          = lilv_new_uri(world, LV2_ATOM__Sequence);
+	jalv.nodes.ev_EventPort           = lilv_new_uri(world, LV2_EVENT__EventPort);
+	jalv.nodes.lv2_AudioPort          = lilv_new_uri(world, LV2_CORE__AudioPort);
+	jalv.nodes.lv2_CVPort             = lilv_new_uri(world, LV2_CORE__CVPort);
+	jalv.nodes.lv2_ControlPort        = lilv_new_uri(world, LV2_CORE__ControlPort);
+	jalv.nodes.lv2_InputPort          = lilv_new_uri(world, LV2_CORE__InputPort);
+	jalv.nodes.lv2_OutputPort         = lilv_new_uri(world, LV2_CORE__OutputPort);
+	jalv.nodes.lv2_connectionOptional = lilv_new_uri(world, LV2_CORE__connectionOptional);
+	jalv.nodes.lv2_control            = lilv_new_uri(world, LV2_CORE__control);
+	jalv.nodes.lv2_default            = lilv_new_uri(world, LV2_CORE__default);
+	jalv.nodes.lv2_enumeration        = lilv_new_uri(world, LV2_CORE__enumeration);
+	jalv.nodes.lv2_integer            = lilv_new_uri(world, LV2_CORE__integer);
+	jalv.nodes.lv2_maximum            = lilv_new_uri(world, LV2_CORE__maximum);
+	jalv.nodes.lv2_minimum            = lilv_new_uri(world, LV2_CORE__minimum);
+	jalv.nodes.lv2_name               = lilv_new_uri(world, LV2_CORE__name);
+	jalv.nodes.lv2_reportsLatency     = lilv_new_uri(world, LV2_CORE__reportsLatency);
+	jalv.nodes.lv2_sampleRate         = lilv_new_uri(world, LV2_CORE__sampleRate);
+	jalv.nodes.lv2_symbol             = lilv_new_uri(world, LV2_CORE__symbol);
+	jalv.nodes.lv2_toggled            = lilv_new_uri(world, LV2_CORE__toggled);
+	jalv.nodes.midi_MidiEvent         = lilv_new_uri(world, LV2_MIDI__MidiEvent);
+	jalv.nodes.pg_group               = lilv_new_uri(world, LV2_PORT_GROUPS__group);
+	jalv.nodes.pprops_logarithmic     = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
+	jalv.nodes.pprops_notOnGUI        = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
+	jalv.nodes.pprops_rangeSteps      = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
+	jalv.nodes.pset_Preset            = lilv_new_uri(world, LV2_PRESETS__Preset);
+	jalv.nodes.pset_bank              = lilv_new_uri(world, LV2_PRESETS__bank);
+	jalv.nodes.rdfs_comment           = lilv_new_uri(world, LILV_NS_RDFS "comment");
+	jalv.nodes.rdfs_label             = lilv_new_uri(world, LILV_NS_RDFS "label");
+	jalv.nodes.rdfs_range             = lilv_new_uri(world, LILV_NS_RDFS "range");
+	jalv.nodes.rsz_minimumSize        = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
+	jalv.nodes.work_interface         = lilv_new_uri(world, LV2_WORKER__interface);
+	jalv.nodes.work_schedule          = lilv_new_uri(world, LV2_WORKER__schedule);
+	jalv.nodes.end                    = NULL;
+
+	/* Get plugin URI from loaded state or command line */
+	LilvState* state      = NULL;
+	LilvNode*  plugin_uri = NULL;
+	if (jalv.opts.load) {
+		struct stat info;
+		stat(jalv.opts.load, &info);
+		if (S_ISDIR(info.st_mode)) {
+			char* path = jalv_strjoin(jalv.opts.load, "/state.ttl");
+			state = lilv_state_new_from_file(jalv.world, &jalv.map, NULL, path);
+			free(path);
+		} else {
+			state = lilv_state_new_from_file(jalv.world, &jalv.map, NULL,
+			                                 jalv.opts.load);
+		}
+		if (!state) {
+			fprintf(stderr, "Failed to load state from %s\n", jalv.opts.load);
+			return EXIT_FAILURE;
+		}
+		plugin_uri = lilv_node_duplicate(lilv_state_get_plugin_uri(state));
+	} else if (argc > 1) {
+		plugin_uri = lilv_new_uri(world, argv[argc - 1]);
+	}
+
+	if (!plugin_uri) {
+		fprintf(stderr, "Missing plugin URI, try lv2ls to list plugins\n");
+		return EXIT_FAILURE;
+	}
+
+	/* Find plugin */
+	printf("Plugin:       %s\n", lilv_node_as_string(plugin_uri));
+	jalv.plugin = lilv_plugins_get_by_uri(plugins, plugin_uri);
+	lilv_node_free(plugin_uri);
+	if (!jalv.plugin) {
+		fprintf(stderr, "Failed to find plugin\n");
+		lilv_world_free(world);
+		return EXIT_FAILURE;
+	}
+
+	/* Load preset, if specified */
+	if (jalv.opts.preset) {
+		LilvNode* preset = lilv_new_uri(jalv.world, jalv.opts.preset);
+
+		jalv_load_presets(&jalv, NULL, NULL);
+		state = lilv_state_new_from_world(jalv.world, &jalv.map, preset);
+		jalv.preset = state;
+		lilv_node_free(preset);
+		if (!state) {
+			fprintf(stderr, "Failed to find preset <%s>\n", jalv.opts.preset);
+			lilv_world_free(world);
+			return EXIT_FAILURE;
+		}
+	}
+
+	/* Check that any required features are supported */
+	LilvNodes* req_feats = lilv_plugin_get_required_features(jalv.plugin);
+	LILV_FOREACH(nodes, f, req_feats) {
+		const char* uri = lilv_node_as_uri(lilv_nodes_get(req_feats, f));
+		if (!feature_is_supported(uri)) {
+			fprintf(stderr, "Feature %s is not supported\n", uri);
+			lilv_world_free(world);
+			return EXIT_FAILURE;
+		}
+	}
+	lilv_nodes_free(req_feats);
+
+	/* Check for thread-safe state restore() method. */
+	LilvNode* state_threadSafeRestore = lilv_new_uri(
+		jalv.world, LV2_STATE__threadSafeRestore);
+	if (lilv_plugin_has_feature(jalv.plugin, state_threadSafeRestore)) {
+		jalv.safe_restore = true;
+	}
+	lilv_node_free(state_threadSafeRestore);
+
+	if (!state) {
+		/* Not restoring state, load the plugin as a preset to get default */
+		state = lilv_state_new_from_world(
+			jalv.world, &jalv.map, lilv_plugin_get_uri(jalv.plugin));
+	}
+
+	/* Get a plugin UI */
+	const char* native_ui_type_uri = jalv_native_ui_type(&jalv);
+	jalv.uis = lilv_plugin_get_uis(jalv.plugin);
+	if (!jalv.opts.generic_ui && native_ui_type_uri) {
+		const LilvNode* native_ui_type = lilv_new_uri(jalv.world, native_ui_type_uri);
+		LILV_FOREACH(uis, u, jalv.uis) {
+			const LilvUI* this_ui = lilv_uis_get(jalv.uis, u);
+			if (lilv_ui_is_supported(this_ui,
+			                         suil_ui_supported,
+			                         native_ui_type,
+			                         &jalv.ui_type)) {
+				/* TODO: Multiple UI support */
+				jalv.ui = this_ui;
+				break;
+			}
+		}
+	} else if (!jalv.opts.generic_ui && jalv.opts.show_ui) {
+		jalv.ui = lilv_uis_get(jalv.uis, lilv_uis_begin(jalv.uis));
+	}
+
+	/* Create ringbuffers for UI if necessary */
+	if (jalv.ui) {
+		fprintf(stderr, "UI:           %s\n",
+		        lilv_node_as_uri(lilv_ui_get_uri(jalv.ui)));
+	} else {
+		fprintf(stderr, "UI:           None\n");
+	}
+
+	/* Create port and control structures */
+	jalv_create_ports(&jalv);
+	jalv_create_controls(&jalv, true);
+	jalv_create_controls(&jalv, false);
+
+	if (!(jalv.backend = jalv_backend_init(&jalv))) {
+		die("Failed to connect to audio system");
+	}
+
+	printf("Sample rate:  %u Hz\n", jalv.sample_rate);
+	printf("Block length: %u frames\n", jalv.block_length);
+	printf("MIDI buffers: %zu bytes\n", jalv.midi_buf_size);
+
+	if (jalv.opts.buffer_size == 0) {
+		/* The UI ring is fed by plugin output ports (usually one), and the UI
+		   updates roughly once per cycle.  The ring size is a few times the
+		   size of the MIDI output to give the UI a chance to keep up.  The UI
+		   should be able to keep up with 4 cycles, and tests show this works
+		   for me, but this value might need increasing to avoid overflows.
+		*/
+		jalv.opts.buffer_size = jalv.midi_buf_size * N_BUFFER_CYCLES;
+	}
+
+	if (jalv.opts.update_rate == 0.0) {
+		/* Calculate a reasonable UI update frequency. */
+		jalv.ui_update_hz = (float)jalv.sample_rate / jalv.midi_buf_size * 2.0f;
+		jalv.ui_update_hz = MAX(25.0f, jalv.ui_update_hz);
+	} else {
+		/* Use user-specified UI update rate. */
+		jalv.ui_update_hz = jalv.opts.update_rate;
+		jalv.ui_update_hz = MAX(1.0f, jalv.ui_update_hz);
+	}
+
+	/* The UI can only go so fast, clamp to reasonable limits */
+	jalv.ui_update_hz     = MIN(60, jalv.ui_update_hz);
+	jalv.opts.buffer_size = MAX(4096, jalv.opts.buffer_size);
+	fprintf(stderr, "Comm buffers: %d bytes\n", jalv.opts.buffer_size);
+	fprintf(stderr, "Update rate:  %.01f Hz\n", jalv.ui_update_hz);
+
+	/* Build options array to pass to plugin */
+	const LV2_Options_Option options[] = {
+		{ LV2_OPTIONS_INSTANCE, 0, jalv.urids.param_sampleRate,
+		  sizeof(float), jalv.urids.atom_Float, &jalv.sample_rate },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv.urids.bufsz_minBlockLength,
+		  sizeof(int32_t), jalv.urids.atom_Int, &jalv.block_length },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv.urids.bufsz_maxBlockLength,
+		  sizeof(int32_t), jalv.urids.atom_Int, &jalv.block_length },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv.urids.bufsz_sequenceSize,
+		  sizeof(int32_t), jalv.urids.atom_Int, &jalv.midi_buf_size },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv.urids.ui_updateRate,
+		  sizeof(float), jalv.urids.atom_Float, &jalv.ui_update_hz },
+		{ LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
+	};
+
+	options_feature.data = (void*)&options;
+
+	/* Create Plugin <=> UI communication buffers */
+	jalv.ui_events     = zix_ring_new(jalv.opts.buffer_size);
+	jalv.plugin_events = zix_ring_new(jalv.opts.buffer_size);
+	zix_ring_mlock(jalv.ui_events);
+	zix_ring_mlock(jalv.plugin_events);
+
+	/* Instantiate the plugin */
+	jalv.instance = lilv_plugin_instantiate(
+		jalv.plugin, jalv.sample_rate, features);
+	if (!jalv.instance) {
+		die("Failed to instantiate plugin.\n");
+	}
+
+	ext_data.data_access = lilv_instance_get_descriptor(jalv.instance)->extension_data;
+
+	fprintf(stderr, "\n");
+	if (!jalv.buf_size_set) {
+		jalv_allocate_port_buffers(&jalv);
+	}
+
+	/* Create workers if necessary */
+	if (lilv_plugin_has_extension_data(jalv.plugin, jalv.nodes.work_interface)) {
+		const LV2_Worker_Interface* iface = (const LV2_Worker_Interface*)
+			lilv_instance_get_extension_data(jalv.instance, LV2_WORKER__interface);
+
+		jalv_worker_init(&jalv, &jalv.worker, iface, true);
+		if (jalv.safe_restore) {
+			jalv_worker_init(&jalv, &jalv.state_worker, iface, false);
+		}
+	}
+
+	/* Apply loaded state to plugin instance if necessary */
+	if (state) {
+		jalv_apply_state(&jalv, state);
+	}
+
+	if (jalv.opts.controls) {
+		for (char** c = jalv.opts.controls; *c; ++c) {
+			jalv_apply_control_arg(&jalv, *c);
+		}
+	}
+
+	/* Set Jack callbacks */
+	jalv_backend_init(&jalv);
+
+	/* Create Jack ports and connect plugin ports to buffers */
+	for (uint32_t i = 0; i < jalv.num_ports; ++i) {
+		jalv_backend_activate_port(&jalv, i);
+	}
+
+	/* Print initial control values */
+	for (size_t i = 0; i < jalv.controls.n_controls; ++i) {
+		ControlID* control = jalv.controls.controls[i];
+		if (control->type == PORT) {// && control->value_type == jalv->forge.Float) {
+			struct Port* port = &jalv.ports[control->index];
+			print_control_value(&jalv, port, port->control);
+		}
+	}
+
+	/* Activate plugin */
+	lilv_instance_activate(jalv.instance);
+
+	/* Discover UI */
+	jalv.has_ui = jalv_discover_ui(&jalv);
+
+	/* Activate Jack */
+	jalv_backend_activate(&jalv);
+	jalv.play_state = JALV_RUNNING;
+
+	/* Run UI (or prompt at console) */
+	jalv_open_ui(&jalv);
+
+	/* Wait for finish signal from UI or signal handler */
+	zix_sem_wait(&exit_sem);
+	jalv.exit = true;
+
+	fprintf(stderr, "Exiting...\n");
+
+	/* Terminate the worker */
+	jalv_worker_finish(&jalv.worker);
+
+	/* Deactivate audio */
+	jalv_backend_deactivate(&jalv);
+	for (uint32_t i = 0; i < jalv.num_ports; ++i) {
+		if (jalv.ports[i].evbuf) {
+			lv2_evbuf_free(jalv.ports[i].evbuf);
+		}
+	}
+	jalv_backend_close(&jalv);
+
+	/* Deactivate plugin */
+	suil_instance_free(jalv.ui_instance);
+	lilv_instance_deactivate(jalv.instance);
+	lilv_instance_free(jalv.instance);
+
+	/* Clean up */
+	free(jalv.ports);
+	zix_ring_free(jalv.ui_events);
+	zix_ring_free(jalv.plugin_events);
+	for (LilvNode** n = (LilvNode**)&jalv.nodes; *n; ++n) {
+		lilv_node_free(*n);
+	}
+	symap_free(jalv.symap);
+	zix_sem_destroy(&jalv.symap_lock);
+	suil_host_free(jalv.ui_host);
+	sratom_free(jalv.sratom);
+	sratom_free(jalv.ui_sratom);
+	lilv_uis_free(jalv.uis);
+	lilv_world_free(world);
+
+	zix_sem_destroy(&exit_sem);
+
+	remove(jalv.temp_dir);
+	free(jalv.temp_dir);
+	free(jalv.ui_event_buf);
+
+	return 0;
+}
diff --git a/src/jalv_console.c b/src/jalv_console.c
new file mode 100644
index 0000000..70fe5aa
--- /dev/null
+++ b/src/jalv_console.c
@@ -0,0 +1,222 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE   600
+#define _BSD_SOURCE     1
+#define _DEFAULT_SOURCE 1
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "jalv_config.h"
+#include "jalv_internal.h"
+
+#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
+
+static int
+print_usage(const char* name, bool error)
+{
+	FILE* const os = error ? stderr : stdout;
+	fprintf(os, "Usage: %s [OPTION...] PLUGIN_URI\n", name);
+	fprintf(os, "Run an LV2 plugin as a Jack application.\n");
+	fprintf(os, "  -b SIZE      Buffer size for plugin <=> UI communication\n");
+	fprintf(os, "  -c SYM=VAL   Set control value (e.g. \"vol=1.4\")\n");
+	fprintf(os, "  -d           Dump plugin <=> UI communication\n");
+	fprintf(os, "  -h           Display this help and exit\n");
+	fprintf(os, "  -l DIR       Load state from save directory\n");
+	fprintf(os, "  -n NAME      JACK client name\n");
+	fprintf(os, "  -p           Print control output changes to stdout\n");
+	fprintf(os, "  -s           Show plugin UI if possible\n");
+	fprintf(os, "  -t           Print trace messages from plugin\n");
+	fprintf(os, "  -u UUID      UUID for Jack session restoration\n");
+	fprintf(os, "  -x           Exact JACK client name (exit if taken)\n");
+	return error ? 1 : 0;
+}
+
+int
+jalv_ui_resize(Jalv* jalv, int width, int height)
+{
+	return 0;
+}
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer)
+{
+}
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	opts->controls    = (char**)malloc(sizeof(char*));
+	opts->controls[0] = NULL;
+
+	int n_controls = 0;
+	int a          = 1;
+	for (; a < *argc && (*argv)[a][0] == '-'; ++a) {
+		if ((*argv)[a][1] == 'h') {
+			return print_usage((*argv)[0], true);
+		} else if ((*argv)[a][1] == 's') {
+			opts->show_ui = true;
+		} else if ((*argv)[a][1] == 'p') {
+			opts->print_controls = true;
+		} else if ((*argv)[a][1] == 'u') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -u\n");
+				return 1;
+			}
+			opts->uuid = jalv_strdup((*argv)[a]);
+		} else if ((*argv)[a][1] == 'l') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -l\n");
+				return 1;
+			}
+			opts->load = jalv_strdup((*argv)[a]);
+		} else if ((*argv)[a][1] == 'b') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -b\n");
+				return 1;
+			}
+			opts->buffer_size = atoi((*argv)[a]);
+		} else if ((*argv)[a][1] == 'c') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -c\n");
+				return 1;
+			}
+			opts->controls = (char**)realloc(
+				opts->controls, (++n_controls + 1) * sizeof(char*));
+			opts->controls[n_controls - 1] = (*argv)[a];
+			opts->controls[n_controls]     = NULL;
+		} else if ((*argv)[a][1] == 'i') {
+			opts->non_interactive = true;
+		} else if ((*argv)[a][1] == 'd') {
+			opts->dump = true;
+		} else if ((*argv)[a][1] == 't') {
+			opts->trace = true;
+		} else if ((*argv)[a][1] == 'n') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -n\n");
+				return 1;
+			}
+			free(opts->name);
+			opts->name = jalv_strdup((*argv)[a]);
+		} else if ((*argv)[a][1] == 'x') {
+			opts->name_exact = 1;
+		} else {
+			fprintf(stderr, "Unknown option %s\n", (*argv)[a]);
+			return print_usage((*argv)[0], true);
+		}
+	}
+
+	return 0;
+}
+
+const char*
+jalv_native_ui_type(Jalv* jalv)
+{
+	return NULL;
+}
+
+static void
+jalv_process_command(Jalv* jalv, const char* cmd)
+{
+	char  sym[64];
+	float value;
+	if (sscanf(cmd, "%[a-zA-Z0-9] = %f", sym, &value) == 2) {
+		struct Port* port = NULL;
+		for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+			struct Port* p = &jalv->ports[i];
+			const LilvNode* s = lilv_port_get_symbol(jalv->plugin, p->lilv_port);
+			if (!strcmp(lilv_node_as_string(s), sym)) {
+				port = p;
+				break;
+			}
+		}
+		if (port) {
+			port->control = value;
+			printf("%-*s = %f\n", jalv->longest_sym, sym, value);
+		} else {
+			fprintf(stderr, "error: no port `%s'\n", sym);
+		}
+	}
+}
+
+bool
+jalv_discover_ui(Jalv* jalv)
+{
+	return jalv->opts.show_ui;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	const LV2UI_Idle_Interface* idle_iface = NULL;
+	const LV2UI_Show_Interface* show_iface = NULL;
+	if (jalv->ui && jalv->opts.show_ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(jalv), NULL);
+		idle_iface = (const LV2UI_Idle_Interface*)
+			suil_instance_extension_data(jalv->ui_instance, LV2_UI__idleInterface);
+		show_iface = (LV2UI_Show_Interface*)
+			suil_instance_extension_data(jalv->ui_instance, LV2_UI__showInterface);
+	}
+
+	if (show_iface && idle_iface) {
+		show_iface->show(suil_instance_get_handle(jalv->ui_instance));
+
+		// Drive idle interface until interrupted
+		while (!zix_sem_try_wait(jalv->done)) {
+			jalv_update(jalv);
+			if (idle_iface->idle(suil_instance_get_handle(jalv->ui_instance))) {
+				break;
+			}
+			usleep(33333);
+		}
+
+		show_iface->hide(suil_instance_get_handle(jalv->ui_instance));
+
+	} else if (!jalv->opts.non_interactive) {
+		// Primitive command prompt for setting control values
+		while (!zix_sem_try_wait(jalv->done)) {
+			char line[128];
+			printf("> ");
+			if (fgets(line, sizeof(line), stdin)) {
+				jalv_process_command(jalv, line);
+			} else {
+				break;
+			}
+		}
+	} else {
+		zix_sem_wait(jalv->done);
+	}
+
+	// Caller waits on the done sem, so increment it again to exit
+	zix_sem_post(jalv->done);
+
+	return 0;
+}
+
+int
+jalv_close_ui(Jalv* jalv)
+{
+	zix_sem_post(jalv->done);
+	return 0;
+}
diff --git a/src/jalv_gtk.c b/src/jalv_gtk.c
new file mode 100644
index 0000000..c156994
--- /dev/null
+++ b/src/jalv_gtk.c
@@ -0,0 +1,1246 @@
+/*
+  Copyright 2007-2017 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <math.h>
+
+#include <gtk/gtk.h>
+
+#include "lv2/lv2plug.in/ns/ext/patch/patch.h"
+#include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
+
+#include "jalv_internal.h"
+
+#if GTK_MAJOR_VERSION == 3
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+#endif
+
+static GtkCheckMenuItem* active_preset_item = NULL;
+static bool              updating           = false;
+
+/** Widget for a control. */
+typedef struct {
+	GtkSpinButton* spin;
+	GtkWidget*     control;
+} Controller;
+
+static float
+get_float(const LilvNode* node, float fallback)
+{
+	if (lilv_node_is_float(node) || lilv_node_is_int(node)) {
+		return lilv_node_as_float(node);
+	}
+
+	return fallback;
+}
+
+static GtkWidget*
+new_box(gboolean horizontal, gint spacing)
+{
+	#if GTK_MAJOR_VERSION == 3
+	return gtk_box_new(
+		horizontal ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL,
+		spacing);
+	#else
+	return (horizontal
+	        ? gtk_hbox_new(FALSE, spacing)
+	        : gtk_vbox_new(FALSE, spacing));
+	#endif
+}
+
+static GtkWidget*
+new_hscale(gdouble min, gdouble max, gdouble step)
+{
+	#if GTK_MAJOR_VERSION == 3
+	return gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, min, max, step);
+	#else
+	return gtk_hscale_new_with_range(min, max, step);
+	#endif
+}
+
+static void
+size_request(GtkWidget* widget, GtkRequisition* req)
+{
+	#if GTK_MAJOR_VERSION == 3
+	gtk_widget_get_preferred_size(widget, NULL, req);
+	#else
+	gtk_widget_size_request(widget, req);
+	#endif
+}
+
+static void
+on_window_destroy(GtkWidget* widget,
+                  gpointer   data)
+{
+	gtk_main_quit();
+}
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	GOptionEntry entries[] = {
+		{ "uuid", 'u', 0, G_OPTION_ARG_STRING, &opts->uuid,
+		  "UUID for Jack session restoration", "UUID" },
+		{ "load", 'l', 0, G_OPTION_ARG_STRING, &opts->load,
+		  "Load state from save directory", "DIR" },
+		{ "preset", 'p', 0, G_OPTION_ARG_STRING, &opts->preset,
+		  "Load state from preset", "URI" },
+		{ "dump", 'd', 0, G_OPTION_ARG_NONE, &opts->dump,
+		  "Dump plugin <=> UI communication", NULL },
+		{ "trace", 't', 0, G_OPTION_ARG_NONE, &opts->trace,
+		  "Print trace messages from plugin", NULL },
+		{ "show-hidden", 's', 0, G_OPTION_ARG_NONE, &opts->show_hidden,
+		  "Show controls for ports with notOnGUI property on generic UI", NULL },
+		{ "no-menu", 'n', 0, G_OPTION_ARG_NONE, &opts->no_menu,
+		  "Do not show Jalv menu on window", NULL },
+		{ "generic-ui", 'g', 0, G_OPTION_ARG_NONE, &opts->generic_ui,
+		  "Use Jalv generic UI and not the plugin UI", NULL},
+		{ "buffer-size", 'b', 0, G_OPTION_ARG_INT, &opts->buffer_size,
+		  "Buffer size for plugin <=> UI communication", "SIZE"},
+		{ "update-frequency", 'r', 0, G_OPTION_ARG_DOUBLE, &opts->update_rate,
+		  "UI update frequency", NULL},
+		{ "control", 'c', 0, G_OPTION_ARG_STRING_ARRAY, &opts->controls,
+		  "Set control value (e.g. \"vol=1.4\")", NULL},
+		{ "print-controls", 'p', 0, G_OPTION_ARG_NONE, &opts->print_controls,
+		  "Print control output changes to stdout", NULL},
+		{ "jack-name", 'n', 0, G_OPTION_ARG_STRING, &opts->name,
+		  "JACK client name", NULL},
+		{ "exact-jack-name", 'x', 0, G_OPTION_ARG_NONE, &opts->name_exact,
+		  "Exact JACK client name (exit if taken)", NULL },
+		{ 0, 0, 0, G_OPTION_ARG_NONE, 0, 0, 0 } };
+	GError* error = NULL;
+	const int err = gtk_init_with_args(
+		argc, argv,
+		"PLUGIN_URI - Run an LV2 plugin as a Jack application",
+		entries, NULL, &error);
+
+	if (!err) {
+		fprintf(stderr, "%s\n", error->message);
+	}
+
+	return !err;
+}
+
+const char*
+jalv_native_ui_type(Jalv* jalv)
+{
+#if GTK_MAJOR_VERSION == 2
+	return "http://lv2plug.in/ns/extensions/ui#GtkUI";
+#elif GTK_MAJOR_VERSION == 3
+	return "http://lv2plug.in/ns/extensions/ui#Gtk3UI";
+#else
+	return NULL;
+#endif
+}
+
+static void
+on_save_activate(GtkWidget* widget, void* ptr)
+{
+	Jalv* jalv = (Jalv*)ptr;
+	GtkWidget* dialog = gtk_file_chooser_dialog_new(
+		"Save State",
+		(GtkWindow*)jalv->window,
+		GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
+		"_Cancel", GTK_RESPONSE_CANCEL,
+		"_Save", GTK_RESPONSE_ACCEPT,
+		NULL);
+
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		char* path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+		char* base = g_build_filename(path, "/", NULL);
+		jalv_save(jalv, base);
+		g_free(path);
+		g_free(base);
+	}
+
+	gtk_widget_destroy(dialog);
+}
+
+static void
+on_quit_activate(GtkWidget* widget, gpointer data)
+{
+	GtkWidget* window = (GtkWidget*)data;
+	gtk_widget_destroy(window);
+}
+
+typedef struct {
+	Jalv*     jalv;
+	LilvNode* preset;
+} PresetRecord;
+
+static char*
+symbolify(const char* in)
+{
+	const size_t len = strlen(in);
+	char*        out = (char*)calloc(len + 1, 1);
+	for (size_t i = 0; i < len; ++i) {
+		if (g_ascii_isalnum(in[i])) {
+			out[i] = in[i];
+		} else {
+			out[i] = '_';
+		}
+	}
+	return out;
+}
+
+static void
+set_window_title(Jalv* jalv)
+{
+	LilvNode*   name   = lilv_plugin_get_name(jalv->plugin);
+	const char* plugin = lilv_node_as_string(name);
+	if (jalv->preset) {
+		const char* preset_label = lilv_state_get_label(jalv->preset);
+		char* title = g_strdup_printf("%s - %s", plugin, preset_label);
+		gtk_window_set_title(GTK_WINDOW(jalv->window), title);
+		free(title);
+	} else {
+		gtk_window_set_title(GTK_WINDOW(jalv->window), plugin);
+	}
+	lilv_node_free(name);
+}
+
+static void
+on_preset_activate(GtkWidget* widget, gpointer data)
+{
+	if (GTK_CHECK_MENU_ITEM(widget) != active_preset_item) {
+		PresetRecord* record = (PresetRecord*)data;
+		jalv_apply_preset(record->jalv, record->preset);
+		if (active_preset_item) {
+			gtk_check_menu_item_set_active(active_preset_item, FALSE);
+		}
+
+		active_preset_item = GTK_CHECK_MENU_ITEM(widget);
+		gtk_check_menu_item_set_active(active_preset_item, TRUE);
+		set_window_title(record->jalv);
+	}
+}
+
+static void
+on_preset_destroy(gpointer data, GClosure* closure)
+{
+	PresetRecord* record = (PresetRecord*)data;
+	lilv_node_free(record->preset);
+	free(record);
+}
+
+typedef struct {
+	GtkMenuItem* item;
+	char*        label;
+	GtkMenu*     menu;
+	GSequence*   banks;
+} PresetMenu;
+
+static PresetMenu*
+pset_menu_new(const char* label)
+{
+	PresetMenu* menu = (PresetMenu*)malloc(sizeof(PresetMenu));
+	menu->label = g_strdup(label);
+	menu->item  = GTK_MENU_ITEM(gtk_menu_item_new_with_label(menu->label));
+	menu->menu  = GTK_MENU(gtk_menu_new());
+	menu->banks = NULL;
+	return menu;
+}
+
+static void
+pset_menu_free(PresetMenu* menu)
+{
+	if (menu->banks) {
+		for (GSequenceIter* i = g_sequence_get_begin_iter(menu->banks);
+		     !g_sequence_iter_is_end(i);
+		     i = g_sequence_iter_next(i)) {
+			PresetMenu* bank_menu = (PresetMenu*)g_sequence_get(i);
+			pset_menu_free(bank_menu);
+		}
+		g_sequence_free(menu->banks);
+	}
+
+	free(menu->label);
+	free(menu);
+}
+
+static gint
+menu_cmp(gconstpointer a, gconstpointer b, gpointer data)
+{
+	return strcmp(((PresetMenu*)a)->label, ((PresetMenu*)b)->label);
+}
+
+static PresetMenu*
+get_bank_menu(Jalv* jalv, PresetMenu* menu, const LilvNode* bank)
+{
+	LilvNode* label = lilv_world_get(
+		jalv->world, bank, jalv->nodes.rdfs_label, NULL);
+
+	const char*    uri = lilv_node_as_string(bank);
+	const char*    str = label ? lilv_node_as_string(label) : uri;
+	PresetMenu     key = { NULL, (char*)str, NULL, NULL };
+	GSequenceIter* i   = g_sequence_lookup(menu->banks, &key, menu_cmp, NULL);
+	if (!i) {
+		PresetMenu* bank_menu = pset_menu_new(str);
+		gtk_menu_item_set_submenu(bank_menu->item, GTK_WIDGET(bank_menu->menu));
+		g_sequence_insert_sorted(menu->banks, bank_menu, menu_cmp, NULL);
+		return bank_menu;
+	}
+	return (PresetMenu*)g_sequence_get(i);
+}
+
+static int
+add_preset_to_menu(Jalv*           jalv,
+                   const LilvNode* node,
+                   const LilvNode* title,
+                   void*           data)
+{
+	PresetMenu* menu  = (PresetMenu*)data;
+	const char* label = lilv_node_as_string(title);
+	GtkWidget*  item  = gtk_check_menu_item_new_with_label(label);
+	gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE);
+	if (jalv->preset &&
+	    lilv_node_equals(lilv_state_get_uri(jalv->preset), node)) {
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+		active_preset_item = GTK_CHECK_MENU_ITEM(item);
+	}
+
+	LilvNode* bank = lilv_world_get(
+		jalv->world, node, jalv->nodes.pset_bank, NULL);
+
+	if (bank) {
+		PresetMenu* bank_menu = get_bank_menu(jalv, menu, bank);
+		gtk_menu_shell_append(GTK_MENU_SHELL(bank_menu->menu), item);
+	} else {
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu->menu), item);
+	}
+
+	PresetRecord* record = (PresetRecord*)malloc(sizeof(PresetRecord));
+	record->jalv   = jalv;
+	record->preset = lilv_node_duplicate(node);
+
+	g_signal_connect_data(G_OBJECT(item), "activate",
+	                      G_CALLBACK(on_preset_activate),
+	                      record, on_preset_destroy,
+	                      (GConnectFlags)0);
+
+	return 0;
+}
+
+static void
+finish_menu(PresetMenu* menu)
+{
+	for (GSequenceIter* i = g_sequence_get_begin_iter(menu->banks);
+	     !g_sequence_iter_is_end(i);
+	     i = g_sequence_iter_next(i)) {
+		PresetMenu* bank_menu = (PresetMenu*)g_sequence_get(i);
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu->menu),
+		                      GTK_WIDGET(bank_menu->item));
+	}
+	g_sequence_free(menu->banks);
+}
+
+static void
+rebuild_preset_menu(Jalv* jalv, GtkContainer* pset_menu)
+{
+	// Clear current menu
+	active_preset_item = NULL;
+	for (GList* items = g_list_nth(gtk_container_get_children(pset_menu), 3);
+	     items;
+	     items = items->next) {
+		gtk_container_remove(pset_menu, GTK_WIDGET(items->data));
+	}
+
+	// Load presets and build new menu
+	PresetMenu menu = {
+		NULL, NULL, GTK_MENU(pset_menu),
+		g_sequence_new((GDestroyNotify)pset_menu_free)
+	};
+	jalv_load_presets(jalv, add_preset_to_menu, &menu);
+	finish_menu(&menu);
+	gtk_widget_show_all(GTK_WIDGET(pset_menu));
+}
+
+static void
+on_save_preset_activate(GtkWidget* widget, void* ptr)
+{
+	Jalv* jalv = (Jalv*)ptr;
+
+	GtkWidget* dialog = gtk_file_chooser_dialog_new(
+		"Save Preset",
+		(GtkWindow*)jalv->window,
+		GTK_FILE_CHOOSER_ACTION_SAVE,
+		"_Cancel", GTK_RESPONSE_REJECT,
+		"_Save", GTK_RESPONSE_ACCEPT,
+		NULL);
+
+	char* dot_lv2 = g_build_filename(g_get_home_dir(), ".lv2", NULL);
+	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), dot_lv2);
+	free(dot_lv2);
+
+	GtkWidget* content    = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+	GtkBox*    box        = GTK_BOX(new_box(true, 8));
+	GtkWidget* uri_label  = gtk_label_new("URI (Optional):");
+	GtkWidget* uri_entry  = gtk_entry_new();
+	GtkWidget* add_prefix = gtk_check_button_new_with_mnemonic(
+		"_Prefix plugin name");
+
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(add_prefix), TRUE);
+	gtk_box_pack_start(box, uri_label, FALSE, TRUE, 2);
+	gtk_box_pack_start(box, uri_entry, TRUE, TRUE, 2);
+	gtk_box_pack_start(GTK_BOX(content), GTK_WIDGET(box), FALSE, FALSE, 6);
+	gtk_box_pack_start(GTK_BOX(content), add_prefix, FALSE, FALSE, 6);
+
+	gtk_widget_show_all(GTK_WIDGET(dialog));
+	gtk_entry_set_activates_default(GTK_ENTRY(uri_entry), TRUE);
+	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		LilvNode*   plug_name = lilv_plugin_get_name(jalv->plugin);
+		const char* path      = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+		const char* uri       = gtk_entry_get_text(GTK_ENTRY(uri_entry));
+		const char* prefix    = "";
+		const char* sep       = "";
+		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_prefix))) {
+			prefix = lilv_node_as_string(plug_name);
+			sep    = "_";
+		}
+
+		char* dirname  = g_path_get_dirname(path);
+		char* basename = g_path_get_basename(path);
+		char* sym      = symbolify(basename);
+		char* sprefix  = symbolify(prefix);
+		char* bundle   = g_strjoin(NULL, sprefix, sep, sym, ".preset.lv2/", NULL);
+		char* file     = g_strjoin(NULL, sym, ".ttl", NULL);
+		char* dir      = g_build_filename(dirname, bundle, NULL);
+
+		jalv_save_preset(jalv, dir, (strlen(uri) ? uri : NULL), basename, file);
+
+		// Reload bundle into the world
+		LilvNode* ldir = lilv_new_file_uri(jalv->world, NULL, dir);
+		lilv_world_unload_bundle(jalv->world, ldir);
+		lilv_world_load_bundle(jalv->world, ldir);
+		lilv_node_free(ldir);
+
+		// Rebuild preset menu and update window title
+		rebuild_preset_menu(jalv, GTK_CONTAINER(gtk_widget_get_parent(widget)));
+		set_window_title(jalv);
+
+		g_free(dir);
+		g_free(file);
+		g_free(bundle);
+		free(sprefix);
+		free(sym);
+		g_free(basename);
+		g_free(dirname);
+		lilv_node_free(plug_name);
+	}
+
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+static void
+on_delete_preset_activate(GtkWidget* widget, void* ptr)
+{
+	Jalv* jalv = (Jalv*)ptr;
+	if (!jalv->preset) {
+		return;
+	}
+
+	GtkWidget* dialog = gtk_dialog_new_with_buttons(
+		"Delete Preset?",
+		(GtkWindow*)jalv->window,
+		(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
+		"_Cancel", GTK_RESPONSE_REJECT,
+		"_OK", GTK_RESPONSE_ACCEPT,
+		NULL);
+
+	char* msg = g_strdup_printf("Delete preset \"%s\" from the file system?",
+	                            lilv_state_get_label(jalv->preset));
+
+	GtkWidget* content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+	GtkWidget* text    = gtk_label_new(msg);
+	gtk_box_pack_start(GTK_BOX(content), text, TRUE, TRUE, 4);
+
+	gtk_widget_show_all(dialog);
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		jalv_delete_current_preset(jalv);
+		rebuild_preset_menu(jalv, GTK_CONTAINER(gtk_widget_get_parent(widget)));
+	}
+
+	lilv_state_free(jalv->preset);
+	jalv->preset = NULL;
+	set_window_title(jalv);
+
+	g_free(msg);
+	gtk_widget_destroy(text);
+	gtk_widget_destroy(dialog);
+}
+
+static void
+set_control(const ControlID* control,
+            uint32_t         size,
+            LV2_URID         type,
+            const void*      body)
+{
+	if (!updating) {
+		jalv_set_control(control, size, type, body);
+	}
+}
+
+static bool
+differ_enough(float a, float b)
+{
+	return fabsf(a - b) >= FLT_EPSILON;
+}
+
+static void
+set_float_control(const ControlID* control, float value)
+{
+	if (control->value_type == control->jalv->forge.Int) {
+		const int32_t ival = lrint(value);
+		set_control(control, sizeof(ival), control->jalv->forge.Int, &ival);
+	} else if (control->value_type == control->jalv->forge.Long) {
+		const int64_t lval = lrint(value);
+		set_control(control, sizeof(lval), control->jalv->forge.Long, &lval);
+	} else if (control->value_type == control->jalv->forge.Float) {
+		set_control(control, sizeof(value), control->jalv->forge.Float, &value);
+	} else if (control->value_type == control->jalv->forge.Double) {
+		const double dval = value;
+		set_control(control, sizeof(dval), control->jalv->forge.Double, &dval);
+	} else if (control->value_type == control->jalv->forge.Bool) {
+		const int32_t ival = value;
+		set_control(control, sizeof(ival), control->jalv->forge.Bool, &ival);
+	}
+
+	Controller* controller = (Controller*)control->widget;
+	if (controller && controller->spin &&
+	    differ_enough(gtk_spin_button_get_value(controller->spin), value)) {
+		gtk_spin_button_set_value(controller->spin, value);
+	}
+}
+
+static double
+get_atom_double(Jalv* jalv, uint32_t size, LV2_URID type, const void* body)
+{
+	if (type == jalv->forge.Int || type == jalv->forge.Bool) {
+		return *(const int32_t*)body;
+	} else if (type == jalv->forge.Long) {
+		return *(const int64_t*)body;
+	} else if (type == jalv->forge.Float) {
+		return *(const float*)body;
+	} else if (type == jalv->forge.Double) {
+		return *(const double*)body;
+	}
+	return NAN;
+}
+
+static void
+control_changed(Jalv*       jalv,
+                Controller* controller,
+                uint32_t    size,
+                LV2_URID    type,
+                const void* body)
+{
+	GtkWidget*   widget = controller->control;
+	const double fvalue = get_atom_double(jalv, size, type, body);
+
+	if (!isnan(fvalue)) {
+		if (GTK_IS_COMBO_BOX(widget)) {
+			GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
+			GValue        value = { 0, { { 0 } } };
+			GtkTreeIter   i;
+			bool          valid = gtk_tree_model_get_iter_first(model, &i);
+			while (valid) {
+				gtk_tree_model_get_value(model, &i, 0, &value);
+				const double v = g_value_get_float(&value);
+				g_value_unset(&value);
+				if (fabs(v - fvalue) < FLT_EPSILON) {
+					gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), &i);
+					return;
+				}
+				valid = gtk_tree_model_iter_next(model, &i);
+			}
+		} else if (GTK_IS_TOGGLE_BUTTON(widget)) {
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),
+			                             fvalue > 0.0f);
+		} else if (GTK_IS_RANGE(widget)) {
+			gtk_range_set_value(GTK_RANGE(widget), fvalue);
+		} else {
+			fprintf(stderr, "Unknown widget type for value\n");
+		}
+
+		if (controller->spin) {
+			// Update spinner for numeric control
+			gtk_spin_button_set_value(GTK_SPIN_BUTTON(controller->spin),
+			                          fvalue);
+		}
+	} else if (GTK_IS_ENTRY(widget) && type == jalv->urids.atom_String) {
+		gtk_entry_set_text(GTK_ENTRY(widget), (const char*)body);
+	} else if (GTK_IS_FILE_CHOOSER(widget) && type == jalv->urids.atom_Path) {
+		gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(widget), (const char*)body);
+	} else {
+		fprintf(stderr, "Unknown widget type for value\n");
+	}
+}
+
+static int
+patch_set_get(Jalv*                  jalv,
+              const LV2_Atom_Object* obj,
+              const LV2_Atom_URID**  property,
+              const LV2_Atom**       value)
+{
+	lv2_atom_object_get(obj,
+	                    jalv->urids.patch_property, (const LV2_Atom*)property,
+	                    jalv->urids.patch_value,    value,
+	                    0);
+	if (!*property) {
+		fprintf(stderr, "patch:Set message with no property\n");
+		return 1;
+	} else if ((*property)->atom.type != jalv->forge.URID) {
+		fprintf(stderr, "patch:Set property is not a URID\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+static int
+patch_put_get(Jalv*                   jalv,
+              const LV2_Atom_Object*  obj,
+              const LV2_Atom_Object** body)
+{
+	lv2_atom_object_get(obj,
+	                    jalv->urids.patch_body, (const LV2_Atom*)body,
+	                    0);
+	if (!*body) {
+		fprintf(stderr, "patch:Put message with no body\n");
+		return 1;
+	} else if (!lv2_atom_forge_is_object_type(&jalv->forge, (*body)->atom.type)) {
+		fprintf(stderr, "patch:Put body is not an object\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+static void
+property_changed(Jalv* jalv, LV2_URID key, const LV2_Atom* value)
+{
+	ControlID* control = get_property_control(&jalv->controls, key);
+	if (control) {
+		control_changed(jalv,
+		                (Controller*)control->widget,
+		                value->size,
+		                value->type,
+		                value + 1);
+	}
+}
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer)
+{
+	if (jalv->ui_instance) {
+		suil_instance_port_event(jalv->ui_instance, port_index,
+		                         buffer_size, protocol, buffer);
+		return;
+	} else if (protocol == 0 && (Controller*)jalv->ports[port_index].widget) {
+		control_changed(jalv,
+		                (Controller*)jalv->ports[port_index].widget,
+		                buffer_size,
+		                jalv->forge.Float,
+		                buffer);
+		return;
+	} else if (protocol == 0) {
+		return;  // No widget (probably notOnGUI)
+	} else if (protocol != jalv->urids.atom_eventTransfer) {
+		fprintf(stderr, "Unknown port event protocol\n");
+		return;
+	}
+
+	const LV2_Atom* atom = (const LV2_Atom*)buffer;
+	if (lv2_atom_forge_is_object_type(&jalv->forge, atom->type)) {
+		updating = true;
+		const LV2_Atom_Object* obj = (const LV2_Atom_Object*)buffer;
+		if (obj->body.otype == jalv->urids.patch_Set) {
+			const LV2_Atom_URID* property = NULL;
+			const LV2_Atom*      value    = NULL;
+			if (!patch_set_get(jalv, obj, &property, &value)) {
+				property_changed(jalv, property->body, value);
+			}
+		} else if (obj->body.otype == jalv->urids.patch_Put) {
+			const LV2_Atom_Object* body = NULL;
+			if (!patch_put_get(jalv, obj, &body)) {
+				LV2_ATOM_OBJECT_FOREACH(body, prop) {
+					property_changed(jalv, prop->key, &prop->value);
+				}
+			}
+		} else {
+			printf("Unknown object type?\n");
+		}
+		updating = false;
+	}
+}
+
+static gboolean
+scale_changed(GtkRange* range, gpointer data)
+{
+	set_float_control((const ControlID*)data, gtk_range_get_value(range));
+	return FALSE;
+}
+
+static gboolean
+spin_changed(GtkSpinButton* spin, gpointer data)
+{
+	const ControlID* control    = (const ControlID*)data;
+	Controller*      controller = (Controller*)control->widget;
+	GtkRange*        range      = GTK_RANGE(controller->control);
+	const double     value      = gtk_spin_button_get_value(spin);
+	if (differ_enough(gtk_range_get_value(range), value)) {
+		gtk_range_set_value(range, value);
+	}
+	return FALSE;
+}
+
+static gboolean
+log_scale_changed(GtkRange* range, gpointer data)
+{
+	set_float_control((const ControlID*)data, expf(gtk_range_get_value(range)));
+	return FALSE;
+}
+
+static gboolean
+log_spin_changed(GtkSpinButton* spin, gpointer data)
+{
+	const ControlID* control    = (const ControlID*)data;
+	Controller*      controller = (Controller*)control->widget;
+	GtkRange*        range      = GTK_RANGE(controller->control);
+	const double     value      = gtk_spin_button_get_value(spin);
+	if (differ_enough(gtk_range_get_value(range), logf(value))) {
+		gtk_range_set_value(range, logf(value));
+	}
+	return FALSE;
+}
+
+static void
+combo_changed(GtkComboBox* box, gpointer data)
+{
+	const ControlID* control = (const ControlID*)data;
+
+	GtkTreeIter iter;
+	if (gtk_combo_box_get_active_iter(box, &iter)) {
+		GtkTreeModel* model = gtk_combo_box_get_model(box);
+		GValue        value = { 0, { { 0 } } };
+
+		gtk_tree_model_get_value(model, &iter, 0, &value);
+		const double v = g_value_get_float(&value);
+		g_value_unset(&value);
+
+		set_float_control(control, v);
+	}
+}
+
+static gboolean
+toggle_changed(GtkToggleButton* button, gpointer data)
+{
+	set_float_control((const ControlID*)data,
+	                  gtk_toggle_button_get_active(button) ? 1.0f : 0.0f);
+	return FALSE;
+}
+
+static void
+string_changed(GtkEntry* widget, gpointer data)
+{
+	ControlID*  control = (ControlID*)data;
+	const char* string  = gtk_entry_get_text(widget);
+
+	set_control(control, strlen(string) + 1, control->jalv->forge.String, string);
+}
+
+static void
+file_changed(GtkFileChooserButton* widget,
+             gpointer              data)
+{
+	ControlID*  control   = (ControlID*)data;
+	Jalv*       jalv     = control->jalv;
+	const char* filename = gtk_file_chooser_get_filename(
+		GTK_FILE_CHOOSER(widget));
+
+	set_control(control, strlen(filename), jalv->forge.Path, filename);
+}
+
+static Controller*
+new_controller(GtkSpinButton* spin, GtkWidget* control)
+{
+	Controller* controller = (Controller*)malloc(sizeof(Controller));
+	controller->spin    = spin;
+	controller->control = control;
+	return controller;
+}
+
+static Controller*
+make_combo(ControlID* record, float value)
+{
+	GtkListStore* list_store = gtk_list_store_new(
+		2, G_TYPE_FLOAT, G_TYPE_STRING);
+	int active = -1;
+	for (size_t i = 0; i < record->n_points; ++i) {
+		const ScalePoint* point = &record->points[i];
+		GtkTreeIter       iter;
+		gtk_list_store_append(list_store, &iter);
+		gtk_list_store_set(list_store, &iter,
+		                   0, point->value,
+		                   1, point->label,
+		                   -1);
+		if (fabs(value - point->value) < FLT_EPSILON) {
+			active = i;
+		}
+	}
+
+	GtkWidget* combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list_store));
+	gtk_combo_box_set_active(GTK_COMBO_BOX(combo), active);
+	g_object_unref(list_store);
+
+	gtk_widget_set_sensitive(combo, record->is_writable);
+
+	GtkCellRenderer* cell = gtk_cell_renderer_text_new();
+	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE);
+	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell, "text", 1, NULL);
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(combo), "changed",
+		                 G_CALLBACK(combo_changed), record);
+	}
+
+	return new_controller(NULL, combo);
+}
+
+static Controller*
+make_log_slider(ControlID* record, float value)
+{
+	const float min   = get_float(record->min, 0.0f);
+	const float max   = get_float(record->max, 1.0f);
+	const float lmin  = logf(min);
+	const float lmax  = logf(max);
+	const float ldft  = logf(value);
+	GtkWidget*  scale = new_hscale(lmin, lmax, 0.001);
+	GtkWidget*  spin  = gtk_spin_button_new_with_range(min, max, 0.000001);
+
+	gtk_widget_set_sensitive(scale, record->is_writable);
+	gtk_widget_set_sensitive(spin, record->is_writable);
+
+	gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
+	gtk_range_set_value(GTK_RANGE(scale), ldft);
+	gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(scale), "value-changed",
+		                 G_CALLBACK(log_scale_changed), record);
+		g_signal_connect(G_OBJECT(spin), "value-changed",
+		                 G_CALLBACK(log_spin_changed), record);
+	}
+
+	return new_controller(GTK_SPIN_BUTTON(spin), scale);
+}
+
+static Controller*
+make_slider(ControlID* record, float value)
+{
+	const float  min   = get_float(record->min, 0.0f);
+	const float  max   = get_float(record->max, 1.0f);
+	const double step  = record->is_integer ? 1.0 : ((max - min) / 100.0);
+	GtkWidget*   scale = new_hscale(min, max, step);
+	GtkWidget*   spin  = gtk_spin_button_new_with_range(min, max, step);
+
+	gtk_widget_set_sensitive(scale, record->is_writable);
+	gtk_widget_set_sensitive(spin, record->is_writable);
+
+	if (record->is_integer) {
+		gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 0);
+	} else {
+		gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 7);
+	}
+
+	gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
+	gtk_range_set_value(GTK_RANGE(scale), value);
+	gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
+	if (record->points) {
+		for (size_t i = 0; i < record->n_points; ++i) {
+			const ScalePoint* point = &record->points[i];
+
+			gchar* str = g_markup_printf_escaped(
+				"<span font_size=\"small\">%s</span>", point->label);
+			gtk_scale_add_mark(
+				GTK_SCALE(scale), point->value, GTK_POS_TOP, str);
+		}
+	}
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(scale), "value-changed",
+		                 G_CALLBACK(scale_changed), record);
+		g_signal_connect(G_OBJECT(spin), "value-changed",
+		                 G_CALLBACK(spin_changed), record);
+	}
+
+	return new_controller(GTK_SPIN_BUTTON(spin), scale);
+}
+
+static Controller*
+make_toggle(ControlID* record, float value)
+{
+	GtkWidget* check = gtk_check_button_new();
+
+	gtk_widget_set_sensitive(check, record->is_writable);
+
+	if (value) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
+	}
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(check), "toggled",
+		                 G_CALLBACK(toggle_changed), record);
+	}
+
+	return new_controller(NULL, check);
+}
+
+static Controller*
+make_entry(ControlID* control)
+{
+	GtkWidget* entry = gtk_entry_new();
+
+	gtk_widget_set_sensitive(entry, control->is_writable);
+	if (control->is_writable) {
+		g_signal_connect(G_OBJECT(entry), "activate",
+		                 G_CALLBACK(string_changed), control);
+	}
+
+	return new_controller(NULL, entry);
+}
+
+static Controller*
+make_file_chooser(ControlID* record)
+{
+	GtkWidget* button = gtk_file_chooser_button_new(
+		"Open File", GTK_FILE_CHOOSER_ACTION_OPEN);
+
+	gtk_widget_set_sensitive(button, record->is_writable);
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(button), "file-set",
+		                 G_CALLBACK(file_changed), record);
+	}
+
+	return new_controller(NULL, button);
+}
+
+static Controller*
+make_controller(ControlID* control, float value)
+{
+	Controller* controller = NULL;
+
+	if (control->is_toggle) {
+		controller = make_toggle(control, value);
+	} else if (control->is_enumeration) {
+		controller = make_combo(control, value);
+	} else if (control->is_logarithmic) {
+		controller = make_log_slider(control, value);
+	} else {
+		controller = make_slider(control, value);
+	}
+
+	return controller;
+}
+
+static GtkWidget*
+new_label(const char* text, bool title, float xalign, float yalign)
+{
+	GtkWidget*  label = gtk_label_new(NULL);
+	const char* fmt   = title ? "<span font_weight=\"bold\">%s</span>" : "%s:";
+	gchar*      str   = g_markup_printf_escaped(fmt, text);
+	gtk_label_set_markup(GTK_LABEL(label), str);
+	g_free(str);
+	gtk_misc_set_alignment(GTK_MISC(label), xalign, yalign);
+	return label;
+}
+
+static void
+add_control_row(GtkWidget*  table,
+                int         row,
+                const char* name,
+                Controller* controller)
+{
+	GtkWidget* label = new_label(name, false, 1.0, 0.5);
+	gtk_table_attach(GTK_TABLE(table),
+	                 label,
+	                 0, 1, row, row + 1,
+	                 GTK_FILL, (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 8, 1);
+	int control_left_attach = 1;
+	if (controller->spin) {
+		control_left_attach = 2;
+		gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(controller->spin),
+		                 1, 2, row, row + 1,
+		                 GTK_FILL, GTK_FILL, 2, 1);
+	}
+	gtk_table_attach(GTK_TABLE(table), controller->control,
+	                 control_left_attach, 3, row, row + 1,
+	                 (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), GTK_FILL, 2, 1);
+}
+
+static int
+control_group_cmp(const void* p1, const void* p2, void* data)
+{
+	const ControlID* control1 = *(const ControlID**)p1;
+	const ControlID* control2 = *(const ControlID**)p2;
+
+	const int cmp = (control1->group && control2->group)
+		? strcmp(lilv_node_as_string(control1->group),
+		         lilv_node_as_string(control2->group))
+		: ((intptr_t)control1->group - (intptr_t)control2->group);
+
+	return cmp;
+}
+
+static GtkWidget*
+build_control_widget(Jalv* jalv, GtkWidget* window)
+{
+	GtkWidget* port_table = gtk_table_new(jalv->num_ports, 3, false);
+
+	/* Make an array of controls sorted by group */
+	GArray* controls = g_array_new(FALSE, TRUE, sizeof(ControlID*));
+	for (unsigned i = 0; i < jalv->controls.n_controls; ++i) {
+		g_array_append_vals(controls, &jalv->controls.controls[i], 1);
+	}
+	g_array_sort_with_data(controls, control_group_cmp, jalv);
+
+	/* Add controls in group order */
+	LilvNode* last_group = NULL;
+	int       n_rows     = 0;
+	for (size_t i = 0; i < controls->len; ++i) {
+		ControlID*  record     = g_array_index(controls, ControlID*, i);
+		Controller* controller = NULL;
+		LilvNode*   group      = record->group;
+
+		/* Check group and add new heading if necessary */
+		if (group && !lilv_node_equals(group, last_group)) {
+			LilvNode* group_name = lilv_world_get(
+				jalv->world, group, jalv->nodes.lv2_name, NULL);
+			GtkWidget* group_label = new_label(
+				lilv_node_as_string(group_name), true, 0.0f, 1.0f);
+			gtk_table_attach(GTK_TABLE(port_table), group_label,
+			                 0, 2, n_rows, n_rows + 1,
+			                 GTK_FILL, GTK_FILL, 0, 6);
+			++n_rows;
+		}
+		last_group = group;
+
+		/* Make control widget */
+		if (record->value_type == jalv->forge.String) {
+			controller = make_entry(record);
+		} else if (record->value_type == jalv->forge.Path) {
+			controller = make_file_chooser(record);
+		} else {
+			const float val = get_float(record->def, 0.0f);
+			controller = make_controller(record, val);
+		}
+
+		record->widget = controller;
+		if (record->type == PORT) {
+			jalv->ports[record->index].widget = controller;
+		}
+		if (controller) {
+			/* Add row to table for this controller */
+			add_control_row(
+				port_table, n_rows++,
+				(record->label
+				 ? lilv_node_as_string(record->label)
+				 : lilv_node_as_uri(record->node)),
+				controller);
+
+			/* Set tooltip text from comment, if available */
+			LilvNode* comment = lilv_world_get(
+				jalv->world, record->node, jalv->nodes.rdfs_comment, NULL);
+			if (comment) {
+				gtk_widget_set_tooltip_text(controller->control,
+				                            lilv_node_as_string(comment));
+			}
+			lilv_node_free(comment);
+		}
+	}
+
+	if (n_rows > 0) {
+		gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
+		GtkWidget* alignment = gtk_alignment_new(0.5, 0.0, 1.0, 0.0);
+		gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 8, 8);
+		gtk_container_add(GTK_CONTAINER(alignment), port_table);
+		return alignment;
+	} else {
+		gtk_widget_destroy(port_table);
+		GtkWidget* button = gtk_button_new_with_label("Close");
+		g_signal_connect_swapped(button, "clicked",
+		                         G_CALLBACK(gtk_widget_destroy), window);
+		gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
+		return button;
+	}
+}
+
+static void
+build_menu(Jalv* jalv, GtkWidget* window, GtkWidget* vbox)
+{
+	GtkWidget* menu_bar  = gtk_menu_bar_new();
+	GtkWidget* file      = gtk_menu_item_new_with_mnemonic("_File");
+	GtkWidget* file_menu = gtk_menu_new();
+
+	GtkAccelGroup* ag = gtk_accel_group_new();
+	gtk_window_add_accel_group(GTK_WINDOW(window), ag);
+
+	GtkWidget* save = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, ag);
+	GtkWidget* quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, ag);
+
+	gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), file_menu);
+	gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save);
+	gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
+
+	GtkWidget* pset_item   = gtk_menu_item_new_with_mnemonic("_Presets");
+	GtkWidget* pset_menu   = gtk_menu_new();
+	GtkWidget* save_preset = gtk_menu_item_new_with_mnemonic(
+		"_Save Preset...");
+	GtkWidget* delete_preset = gtk_menu_item_new_with_mnemonic(
+		"_Delete Current Preset...");
+	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pset_item), pset_menu);
+	gtk_menu_shell_append(GTK_MENU_SHELL(pset_menu), save_preset);
+	gtk_menu_shell_append(GTK_MENU_SHELL(pset_menu), delete_preset);
+	gtk_menu_shell_append(GTK_MENU_SHELL(pset_menu),
+	                      gtk_separator_menu_item_new());
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), pset_item);
+
+	PresetMenu menu = {
+		NULL, NULL, GTK_MENU(pset_menu),
+		g_sequence_new((GDestroyNotify)pset_menu_free)
+	};
+	jalv_load_presets(jalv, add_preset_to_menu, &menu);
+	finish_menu(&menu);
+
+	g_signal_connect(G_OBJECT(quit), "activate",
+	                 G_CALLBACK(on_quit_activate), window);
+
+	g_signal_connect(G_OBJECT(save), "activate",
+	                 G_CALLBACK(on_save_activate), jalv);
+
+	g_signal_connect(G_OBJECT(save_preset), "activate",
+	                 G_CALLBACK(on_save_preset_activate), jalv);
+
+	g_signal_connect(G_OBJECT(delete_preset), "activate",
+	                 G_CALLBACK(on_delete_preset_activate), jalv);
+
+	gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0);
+}
+
+bool
+jalv_discover_ui(Jalv* jalv)
+{
+	return TRUE;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	jalv->window = window;
+
+	g_signal_connect(window, "destroy",
+	                 G_CALLBACK(on_window_destroy), jalv);
+
+	set_window_title(jalv);
+
+	GtkWidget* vbox = new_box(false, 0);
+	gtk_window_set_role(GTK_WINDOW(window), "plugin_ui");
+	gtk_container_add(GTK_CONTAINER(window), vbox);
+
+	if (!jalv->opts.no_menu) {
+		build_menu(jalv, window, vbox);
+	}
+
+	/* Create/show alignment to contain UI (whether custom or generic) */
+	GtkWidget* alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
+	gtk_box_pack_start(GTK_BOX(vbox), alignment, TRUE, TRUE, 0);
+	gtk_widget_show(alignment);
+
+	/* Attempt to instantiate custom UI if necessary */
+	if (jalv->ui && !jalv->opts.generic_ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(jalv), alignment);
+	}
+
+	if (jalv->ui_instance) {
+		GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(
+			jalv->ui_instance);
+
+		gtk_container_add(GTK_CONTAINER(alignment), widget);
+		gtk_window_set_resizable(GTK_WINDOW(window), jalv_ui_is_resizable(jalv));
+		gtk_widget_show_all(vbox);
+		gtk_widget_grab_focus(widget);
+	} else {
+		GtkWidget* controls   = build_control_widget(jalv, window);
+		GtkWidget* scroll_win = gtk_scrolled_window_new(NULL, NULL);
+		gtk_scrolled_window_add_with_viewport(
+			GTK_SCROLLED_WINDOW(scroll_win), controls);
+		gtk_scrolled_window_set_policy(
+			GTK_SCROLLED_WINDOW(scroll_win),
+			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+		gtk_container_add(GTK_CONTAINER(alignment), scroll_win);
+		gtk_widget_show_all(vbox);
+
+		GtkRequisition controls_size, box_size;
+		size_request(GTK_WIDGET(controls), &controls_size);
+		size_request(GTK_WIDGET(vbox), &box_size);
+
+		gtk_window_set_default_size(
+			GTK_WINDOW(window),
+			MAX(MAX(box_size.width, controls_size.width) + 24, 640),
+			box_size.height + controls_size.height);
+	}
+
+	jalv_init_ui(jalv);
+
+	g_timeout_add(1000 / jalv->ui_update_hz, (GSourceFunc)jalv_update, jalv);
+
+	gtk_window_present(GTK_WINDOW(window));
+
+	gtk_main();
+	suil_instance_free(jalv->ui_instance);
+	jalv->ui_instance = NULL;
+	zix_sem_post(jalv->done);
+	return 0;
+}
+
+int
+jalv_close_ui(Jalv* jalv)
+{
+	gtk_main_quit();
+	return 0;
+}
+
+#if GTK_MAJOR_VERSION == 3
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#    pragma GCC diagnostic pop
+#endif
+#endif
+
diff --git a/src/jalv_gtkmm2.cpp b/src/jalv_gtkmm2.cpp
new file mode 100644
index 0000000..5b1b3c9
--- /dev/null
+++ b/src/jalv_gtkmm2.cpp
@@ -0,0 +1,106 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <gtkmm/button.h>
+#include <gtkmm/main.h>
+#include <gtkmm/window.h>
+
+#include "jalv_internal.h"
+
+Gtk::Main* jalv_gtk_main = NULL;
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	jalv_gtk_main = new Gtk::Main(*argc, *argv);
+	return 0;
+}
+
+const char*
+jalv_native_ui_type(Jalv* jalv)
+{
+	return "http://lv2plug.in/ns/extensions/ui#GtkUI";
+}
+
+int
+jalv_ui_resize(Jalv* jalv, int width, int height)
+{
+	if (jalv->ui_instance) {
+		GtkWidget* widget = GTK_WIDGET(
+			suil_instance_get_widget(jalv->ui_instance));
+		if (widget) {
+			gtk_widget_set_size_request(GTK_WIDGET(widget), width, height);
+		}
+	}
+	return 0;
+}
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer)
+{
+}
+
+bool
+jalv_discover_ui(Jalv* jalv)
+{
+	return true;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	Gtk::Window* window = new Gtk::Window();
+
+	if (jalv->ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(jalv), NULL);
+	}
+
+	if (jalv->ui_instance) {
+		GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(
+			jalv->ui_instance);
+		Gtk::Widget* widgetmm = Glib::wrap(widget);
+		window->add(*Gtk::manage(widgetmm));
+		widgetmm->show_all();
+
+		g_timeout_add(1000 / jalv->ui_update_hz,
+		              (GSourceFunc)jalv_update, jalv);
+	} else {
+		Gtk::Button* button = Gtk::manage(new Gtk::Button("Close"));
+		window->add(*Gtk::manage(button));
+	}
+
+	window->set_resizable(jalv_ui_is_resizable(jalv));
+	window->show_all();
+
+	Gtk::Main::run(*window);
+
+	delete window;
+	delete jalv_gtk_main;
+	zix_sem_post(jalv->done);
+
+	return 0;
+}
+
+int
+jalv_close_ui(Jalv* jalv)
+{
+	Gtk::Main::quit();
+	return 0;
+}
diff --git a/src/jalv_internal.h b/src/jalv_internal.h
new file mode 100644
index 0000000..7fa3970
--- /dev/null
+++ b/src/jalv_internal.h
@@ -0,0 +1,525 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef JALV_INTERNAL_H
+#define JALV_INTERNAL_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_ISATTY
+#    include <unistd.h>
+#endif
+
+#include "lilv/lilv.h"
+#include "serd/serd.h"
+#include "suil/suil.h"
+
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
+#include "lv2/lv2plug.in/ns/ext/atom/forge.h"
+#include "lv2/lv2plug.in/ns/ext/log/log.h"
+#include "lv2/lv2plug.in/ns/ext/midi/midi.h"
+#include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
+#include "lv2/lv2plug.in/ns/ext/state/state.h"
+#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
+#include "lv2/lv2plug.in/ns/ext/worker/worker.h"
+
+#include "zix/ring.h"
+#include "zix/sem.h"
+#include "zix/thread.h"
+
+#include "sratom/sratom.h"
+
+#include "lv2_evbuf.h"
+#include "symap.h"
+
+#ifdef __clang__
+#    define REALTIME __attribute__((annotate("realtime")))
+#else
+#    define REALTIME
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct JalvBackend JalvBackend;
+
+typedef struct Jalv Jalv;
+
+enum PortFlow {
+	FLOW_UNKNOWN,
+	FLOW_INPUT,
+	FLOW_OUTPUT
+};
+
+enum PortType {
+	TYPE_UNKNOWN,
+	TYPE_CONTROL,
+	TYPE_AUDIO,
+	TYPE_EVENT,
+	TYPE_CV
+};
+
+struct Port {
+	const LilvPort* lilv_port;  ///< LV2 port
+	enum PortType   type;       ///< Data type
+	enum PortFlow   flow;       ///< Data flow direction
+	void*           sys_port;   ///< For audio/MIDI ports, otherwise NULL
+	LV2_Evbuf*      evbuf;      ///< For MIDI ports, otherwise NULL
+	void*           widget;     ///< Control widget, if applicable
+	size_t          buf_size;   ///< Custom buffer size, or 0
+	uint32_t        index;      ///< Port index
+	float           control;    ///< For control ports, otherwise 0.0f
+	bool            old_api;    ///< True for event, false for atom
+};
+
+/* Controls */
+
+/** Type of plugin control. */
+typedef enum {
+	PORT,     ///< Control port
+	PROPERTY  ///< Property (set via atom message)
+} ControlType;
+
+typedef struct {
+	float value;
+	char* label;
+} ScalePoint;
+
+/** Order scale points by value. */
+int scale_point_cmp(const ScalePoint* a, const ScalePoint* b);
+
+/** Plugin control. */
+typedef struct {
+	Jalv*       jalv;
+	ControlType type;
+	LilvNode*   node;
+	LilvNode*   symbol;          ///< Symbol
+	LilvNode*   label;           ///< Human readable label
+	LV2_URID    property;        ///< Iff type == PROPERTY
+	uint32_t    index;           ///< Iff type == PORT
+	LilvNode*   group;           ///< Port/control group, or NULL
+	void*       widget;          ///< Control Widget
+	size_t      n_points;        ///< Number of scale points
+	ScalePoint* points;          ///< Scale points
+	LV2_URID    value_type;      ///< Type of control value
+	LilvNode*   min;             ///< Minimum value
+	LilvNode*   max;             ///< Maximum value
+	LilvNode*   def;             ///< Default value
+	bool        is_toggle;       ///< Boolean (0 and 1 only)
+	bool        is_integer;      ///< Integer values only
+	bool        is_enumeration;  ///< Point values only
+	bool        is_logarithmic;  ///< Logarithmic scale
+	bool        is_writable;     ///< Writable (input)
+	bool        is_readable;     ///< Readable (output)
+} ControlID;
+
+ControlID*
+new_port_control(Jalv* jalv, uint32_t index);
+
+ControlID*
+new_property_control(Jalv* jalv, const LilvNode* property);
+
+typedef struct {
+	size_t      n_controls;
+	ControlID** controls;
+} Controls;
+
+void
+add_control(Controls* controls, ControlID* control);
+
+ControlID*
+get_property_control(const Controls* controls, LV2_URID property);
+
+/**
+   Control change event, sent through ring buffers for UI updates.
+*/
+typedef struct {
+	uint32_t index;
+	uint32_t protocol;
+	uint32_t size;
+	uint8_t  body[];
+} ControlChange;
+
+typedef struct {
+	char*    name;              ///< Client name
+	int      name_exact;        ///< Exit if name is taken
+	char*    uuid;              ///< Session UUID
+	char*    load;              ///< Path for state to load
+	char*    preset;            ///< URI of preset to load
+	char**   controls;          ///< Control values
+	uint32_t buffer_size;       ///< Plugin <= >UI communication buffer size
+	double   update_rate;       ///< UI update rate in Hz
+	int      dump;              ///< Dump communication iff true
+	int      trace;             ///< Print trace log iff true
+	int      generic_ui;        ///< Use generic UI iff true
+	int      show_hidden;       ///< Show controls for notOnGUI ports
+	int      no_menu;           ///< Hide menu iff true
+	int      show_ui;           ///< Show non-embedded UI
+	int      print_controls;    ///< Print control changes to stdout
+	int      non_interactive;   ///< Do not listen for commands on stdin
+} JalvOptions;
+
+typedef struct {
+	LV2_URID atom_Float;
+	LV2_URID atom_Int;
+	LV2_URID atom_Object;
+	LV2_URID atom_Path;
+	LV2_URID atom_String;
+	LV2_URID atom_eventTransfer;
+	LV2_URID bufsz_maxBlockLength;
+	LV2_URID bufsz_minBlockLength;
+	LV2_URID bufsz_sequenceSize;
+	LV2_URID log_Error;
+	LV2_URID log_Trace;
+	LV2_URID log_Warning;
+	LV2_URID midi_MidiEvent;
+	LV2_URID param_sampleRate;
+	LV2_URID patch_Get;
+	LV2_URID patch_Put;
+	LV2_URID patch_Set;
+	LV2_URID patch_body;
+	LV2_URID patch_property;
+	LV2_URID patch_value;
+	LV2_URID time_Position;
+	LV2_URID time_bar;
+	LV2_URID time_barBeat;
+	LV2_URID time_beatUnit;
+	LV2_URID time_beatsPerBar;
+	LV2_URID time_beatsPerMinute;
+	LV2_URID time_frame;
+	LV2_URID time_speed;
+	LV2_URID ui_updateRate;
+} JalvURIDs;
+
+typedef struct {
+	LilvNode* atom_AtomPort;
+	LilvNode* atom_Chunk;
+	LilvNode* atom_Float;
+	LilvNode* atom_Path;
+	LilvNode* atom_Sequence;
+	LilvNode* ev_EventPort;
+	LilvNode* lv2_AudioPort;
+	LilvNode* lv2_CVPort;
+	LilvNode* lv2_ControlPort;
+	LilvNode* lv2_InputPort;
+	LilvNode* lv2_OutputPort;
+	LilvNode* lv2_connectionOptional;
+	LilvNode* lv2_control;
+	LilvNode* lv2_default;
+	LilvNode* lv2_enumeration;
+	LilvNode* lv2_integer;
+	LilvNode* lv2_maximum;
+	LilvNode* lv2_minimum;
+	LilvNode* lv2_name;
+	LilvNode* lv2_reportsLatency;
+	LilvNode* lv2_sampleRate;
+	LilvNode* lv2_symbol;
+	LilvNode* lv2_toggled;
+	LilvNode* midi_MidiEvent;
+	LilvNode* pg_group;
+	LilvNode* pprops_logarithmic;
+	LilvNode* pprops_notOnGUI;
+	LilvNode* pprops_rangeSteps;
+	LilvNode* pset_Preset;
+	LilvNode* pset_bank;
+	LilvNode* rdfs_comment;
+	LilvNode* rdfs_label;
+	LilvNode* rdfs_range;
+	LilvNode* rsz_minimumSize;
+	LilvNode* work_interface;
+	LilvNode* work_schedule;
+	LilvNode* end;  ///< NULL terminator for easy freeing of entire structure
+} JalvNodes;
+
+typedef enum {
+	JALV_RUNNING,
+	JALV_PAUSE_REQUESTED,
+	JALV_PAUSED
+} JalvPlayState;
+
+typedef struct {
+	Jalv*                       jalv;       ///< Pointer back to Jalv
+	ZixRing*                    requests;   ///< Requests to the worker
+	ZixRing*                    responses;  ///< Responses from the worker
+	void*                       response;   ///< Worker response buffer
+	ZixSem                      sem;        ///< Worker semaphore
+	ZixThread                   thread;     ///< Worker thread
+	const LV2_Worker_Interface* iface;      ///< Plugin worker interface
+	bool                        threaded;   ///< Run work in another thread
+} JalvWorker;
+
+struct Jalv {
+	JalvOptions        opts;           ///< Command-line options
+	JalvURIDs          urids;          ///< URIDs
+	JalvNodes          nodes;          ///< Nodes
+	LV2_Atom_Forge     forge;          ///< Atom forge
+	const char*        prog_name;      ///< Program name (argv[0])
+	LilvWorld*         world;          ///< Lilv World
+	LV2_URID_Map       map;            ///< URI => Int map
+	LV2_URID_Unmap     unmap;          ///< Int => URI map
+	SerdEnv*           env;            ///< Environment for RDF printing
+	Sratom*            sratom;         ///< Atom serialiser
+	Sratom*            ui_sratom;      ///< Atom serialiser for UI thread
+	Symap*             symap;          ///< URI map
+	ZixSem             symap_lock;     ///< Lock for URI map
+	JalvBackend*       backend;        ///< Audio system backend
+	ZixRing*           ui_events;      ///< Port events from UI
+	ZixRing*           plugin_events;  ///< Port events from plugin
+	void*              ui_event_buf;   ///< Buffer for reading UI port events
+	JalvWorker         worker;         ///< Worker thread implementation
+	JalvWorker         state_worker;   ///< Synchronous worker for state restore
+	ZixSem             work_lock;      ///< Lock for plugin work() method
+	ZixSem*            done;           ///< Exit semaphore
+	ZixSem             paused;         ///< Paused signal from process thread
+	JalvPlayState      play_state;     ///< Current play state
+	char*              temp_dir;       ///< Temporary plugin state directory
+	char*              save_dir;       ///< Plugin save directory
+	const LilvPlugin*  plugin;         ///< Plugin class (RDF data)
+	LilvState*         preset;         ///< Current preset
+	LilvUIs*           uis;            ///< All plugin UIs (RDF data)
+	const LilvUI*      ui;             ///< Plugin UI (RDF data)
+	const LilvNode*    ui_type;        ///< Plugin UI type (unwrapped)
+	LilvInstance*      instance;       ///< Plugin instance (shared library)
+	SuilHost*          ui_host;        ///< Plugin UI host support
+	SuilInstance*      ui_instance;    ///< Plugin UI instance (shared library)
+	void*              window;         ///< Window (if applicable)
+	struct Port*       ports;          ///< Port array of size num_ports
+	Controls           controls;       ///< Available plugin controls
+	uint32_t           block_length;   ///< Audio buffer size (block length)
+	size_t             midi_buf_size;  ///< Size of MIDI port buffers
+	uint32_t           control_in;     ///< Index of control input port
+	uint32_t           num_ports;      ///< Size of the two following arrays:
+	uint32_t           longest_sym;    ///< Longest port symbol
+	uint32_t           plugin_latency; ///< Latency reported by plugin (if any)
+	float              ui_update_hz;   ///< Frequency of UI updates
+	uint32_t           sample_rate;    ///< Sample rate
+	uint32_t           event_delta_t;  ///< Frames since last update sent to UI
+	uint32_t           midi_event_id;  ///< MIDI event class ID in event context
+	uint32_t           position;       ///< Transport position in frames
+	float              bpm;            ///< Transport tempo in beats per minute
+	bool               rolling;        ///< Transport speed (0=stop, 1=play)
+	bool               buf_size_set;   ///< True iff buffer size callback fired
+	bool               exit;           ///< True iff execution is finished
+	bool               has_ui;         ///< True iff a control UI is present
+	bool               request_update; ///< True iff a plugin update is needed
+	bool               safe_restore;   ///< Plugin restore() is thread-safe
+};
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts);
+
+JalvBackend*
+jalv_backend_init(Jalv* jalv);
+
+void
+jalv_backend_activate(Jalv* jalv);
+
+void
+jalv_backend_deactivate(Jalv* jalv);
+
+void
+jalv_backend_close(Jalv* jalv);
+
+/** Expose a port to the system (if applicable) and connect it to its buffer. */
+void
+jalv_backend_activate_port(Jalv* jalv, uint32_t port_index);
+
+void
+jalv_create_ports(Jalv* jalv);
+
+void
+jalv_allocate_port_buffers(Jalv* jalv);
+
+struct Port*
+jalv_port_by_symbol(Jalv* jalv, const char* sym);
+
+void
+jalv_create_controls(Jalv* jalv, bool writable);
+
+ControlID*
+jalv_control_by_symbol(Jalv* jalv, const char* sym);
+
+void
+jalv_set_control(const ControlID* control,
+                 uint32_t         size,
+                 LV2_URID         type,
+                 const void*      body);
+
+const char*
+jalv_native_ui_type(Jalv* jalv);
+
+bool
+jalv_discover_ui(Jalv* jalv);
+
+int
+jalv_open_ui(Jalv* jalv);
+
+void
+jalv_init_ui(Jalv* jalv);
+
+int
+jalv_close_ui(Jalv* jalv);
+
+void
+jalv_ui_instantiate(Jalv*       jalv,
+                    const char* native_ui_type,
+                    void*       parent);
+
+bool
+jalv_ui_is_resizable(Jalv* jalv);
+
+void
+jalv_ui_write(SuilController controller,
+              uint32_t       port_index,
+              uint32_t       buffer_size,
+              uint32_t       protocol,
+              const void*    buffer);
+
+void
+jalv_apply_ui_events(Jalv* jalv, uint32_t nframes);
+
+uint32_t
+jalv_ui_port_index(SuilController controller, const char* symbol);
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer);
+
+bool
+jalv_send_to_ui(Jalv*       jalv,
+                uint32_t    port_index,
+                uint32_t    type,
+                uint32_t    size,
+                const void* body);
+bool
+jalv_run(Jalv* jalv, uint32_t nframes);
+
+bool
+jalv_update(Jalv* jalv);
+
+int
+jalv_ui_resize(Jalv* jalv, int width, int height);
+
+typedef int (*PresetSink)(Jalv*           jalv,
+                          const LilvNode* node,
+                          const LilvNode* title,
+                          void*           data);
+
+int
+jalv_load_presets(Jalv* jalv, PresetSink sink, void* data);
+
+int
+jalv_unload_presets(Jalv* jalv);
+
+int
+jalv_apply_preset(Jalv* jalv, const LilvNode* preset);
+
+int
+jalv_delete_current_preset(Jalv* jalv);
+
+int
+jalv_save_preset(Jalv*       jalv,
+                 const char* dir,
+                 const char* uri,
+                 const char* label,
+                 const char* filename);
+
+void
+jalv_save(Jalv* jalv, const char* dir);
+
+void
+jalv_save_port_values(Jalv*           jalv,
+                      SerdWriter*     writer,
+                      const SerdNode* subject);
+char*
+jalv_make_path(LV2_State_Make_Path_Handle handle,
+               const char*                path);
+
+void
+jalv_apply_state(Jalv* jalv, LilvState* state);
+
+char*
+atom_to_turtle(LV2_URID_Unmap* unmap,
+               const SerdNode* subject,
+               const SerdNode* predicate,
+               const LV2_Atom* atom);
+
+static inline char*
+jalv_strdup(const char* str)
+{
+	const size_t len  = strlen(str);
+	char*        copy = (char*)malloc(len + 1);
+	memcpy(copy, str, len + 1);
+	return copy;
+}
+
+static inline char*
+jalv_strjoin(const char* a, const char* b)
+{
+	const size_t a_len = strlen(a);
+	const size_t b_len = strlen(b);
+	char* const  out   = (char*)malloc(a_len + b_len + 1);
+
+	memcpy(out,         a, a_len);
+	memcpy(out + a_len, b, b_len);
+	out[a_len + b_len] = '\0';
+
+	return out;
+}
+
+int
+jalv_printf(LV2_Log_Handle handle,
+            LV2_URID       type,
+            const char*    fmt, ...);
+
+int
+jalv_vprintf(LV2_Log_Handle handle,
+             LV2_URID       type,
+             const char*    fmt,
+             va_list        ap);
+
+static inline bool
+jalv_ansi_start(FILE* stream, int color)
+{
+#ifdef HAVE_ISATTY
+	if (isatty(fileno(stream))) {
+		return fprintf(stream, "\033[0;%dm", color);
+	}
+#endif
+	return 0;
+}
+
+static inline void
+jalv_ansi_reset(FILE* stream)
+{
+#ifdef HAVE_ISATTY
+	if (isatty(fileno(stream))) {
+		fprintf(stream, "\033[0m");
+		fflush(stream);
+	}
+#endif
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // JALV_INTERNAL_H
diff --git a/src/jalv_qt.cpp b/src/jalv_qt.cpp
new file mode 100644
index 0000000..72f9f0a
--- /dev/null
+++ b/src/jalv_qt.cpp
@@ -0,0 +1,739 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+
+#include "jalv_internal.h"
+
+#include "lv2/lv2plug.in/ns/ext/patch/patch.h"
+#include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
+
+#include <qglobal.h>
+
+#if QT_VERSION >= 0x050000
+#    include <QAction>
+#    include <QApplication>
+#    include <QDial>
+#    include <QGroupBox>
+#    include <QLabel>
+#    include <QLayout>
+#    include <QMainWindow>
+#    include <QMenu>
+#    include <QMenuBar>
+#    include <QScrollArea>
+#    include <QStyle>
+#    include <QTimer>
+#    include <QWidget>
+#    include <QWindow>
+#else
+#    include <QtGui>
+#endif
+
+#define CONTROL_WIDTH 150
+#define DIAL_STEPS    10000
+
+static QApplication* app = NULL;
+
+class FlowLayout : public QLayout
+{
+public:
+	FlowLayout(QWidget* parent,
+	           int      margin   = -1,
+	           int      hSpacing = -1,
+	           int      vSpacing = -1);
+
+	FlowLayout(int margin = -1, int hSpacing = -1, int vSpacing = -1);
+
+	~FlowLayout();
+
+	void             addItem(QLayoutItem* item);
+	int              horizontalSpacing() const;
+	int              verticalSpacing() const;
+	Qt::Orientations expandingDirections() const;
+	bool             hasHeightForWidth() const;
+	int              heightForWidth(int) const;
+	int              count() const;
+	QLayoutItem*     itemAt(int index) const;
+	QSize            minimumSize() const;
+	void             setGeometry(const QRect &rect);
+	QSize            sizeHint() const;
+	QLayoutItem*     takeAt(int index);
+
+private:
+	int doLayout(const QRect &rect, bool testOnly) const;
+	int smartSpacing(QStyle::PixelMetric pm) const;
+
+	QList<QLayoutItem*> itemList;
+	int m_hSpace;
+	int m_vSpace;
+};
+
+FlowLayout::FlowLayout(QWidget* parent, int margin, int hSpacing, int vSpacing)
+	: QLayout(parent), m_hSpace(hSpacing), m_vSpace(vSpacing)
+{
+	setContentsMargins(margin, margin, margin, margin);
+}
+
+FlowLayout::FlowLayout(int margin, int hSpacing, int vSpacing)
+	: m_hSpace(hSpacing), m_vSpace(vSpacing)
+{
+	setContentsMargins(margin, margin, margin, margin);
+}
+
+FlowLayout::~FlowLayout()
+{
+	QLayoutItem* item;
+	while ((item = takeAt(0))) {
+		delete item;
+	}
+}
+
+void
+FlowLayout::addItem(QLayoutItem* item)
+{
+	itemList.append(item);
+}
+
+int
+FlowLayout::horizontalSpacing() const
+{
+	if (m_hSpace >= 0) {
+		return m_hSpace;
+	} else {
+		return smartSpacing(QStyle::PM_LayoutHorizontalSpacing);
+	}
+}
+
+int
+FlowLayout::verticalSpacing() const
+{
+	if (m_vSpace >= 0) {
+		return m_vSpace;
+	} else {
+		return smartSpacing(QStyle::PM_LayoutVerticalSpacing);
+	}
+}
+
+int
+FlowLayout::count() const
+{
+	return itemList.size();
+}
+
+QLayoutItem*
+FlowLayout::itemAt(int index) const
+{
+	return itemList.value(index);
+}
+
+QLayoutItem*
+FlowLayout::takeAt(int index)
+{
+	if (index >= 0 && index < itemList.size()) {
+		return itemList.takeAt(index);
+	} else {
+		return 0;
+	}
+}
+
+Qt::Orientations
+FlowLayout::expandingDirections() const
+{
+	return 0;
+}
+
+bool
+FlowLayout::hasHeightForWidth() const
+{
+	return true;
+}
+
+int
+FlowLayout::heightForWidth(int width) const
+{
+	return doLayout(QRect(0, 0, width, 0), true);
+}
+
+void
+FlowLayout::setGeometry(const QRect &rect)
+{
+	QLayout::setGeometry(rect);
+	doLayout(rect, false);
+}
+
+QSize
+FlowLayout::sizeHint() const
+{
+	return minimumSize();
+}
+
+QSize
+FlowLayout::minimumSize() const
+{
+	QSize        size;
+	QLayoutItem* item;
+	foreach (item, itemList) {
+		size = size.expandedTo(item->minimumSize());
+	}
+
+	return size + QSize(2 * margin(), 2 * margin());
+}
+
+int
+FlowLayout::doLayout(const QRect &rect, bool testOnly) const
+{
+	int left, top, right, bottom;
+	getContentsMargins(&left, &top, &right, &bottom);
+
+	QRect effectiveRect = rect.adjusted(+left, +top, -right, -bottom);
+	int   x             = effectiveRect.x();
+	int   y             = effectiveRect.y();
+	int   lineHeight    = 0;
+
+	QLayoutItem* item;
+	foreach (item, itemList) {
+		QWidget* wid = item->widget();
+
+		int spaceX = horizontalSpacing();
+		if (spaceX == -1) {
+			spaceX = wid->style()->layoutSpacing(QSizePolicy::PushButton,
+			                                     QSizePolicy::PushButton,
+			                                     Qt::Horizontal);
+		}
+		int spaceY = verticalSpacing();
+		if (spaceY == -1) {
+			spaceY = wid->style()->layoutSpacing(QSizePolicy::PushButton,
+			                                     QSizePolicy::PushButton,
+			                                     Qt::Vertical);
+		}
+
+		int nextX = x + item->sizeHint().width() + spaceX;
+		if (nextX - spaceX > effectiveRect.right() && lineHeight > 0) {
+			x          = effectiveRect.x();
+			y          = y + lineHeight + spaceY;
+			nextX      = x + item->sizeHint().width() + spaceX;
+			lineHeight = 0;
+		}
+
+		if (!testOnly) {
+			item->setGeometry(QRect(QPoint(x, y), item->sizeHint()));
+		}
+
+		x          = nextX;
+		lineHeight = qMax(lineHeight, item->sizeHint().height());
+	}
+	return y + lineHeight - rect.y() + bottom;
+}
+
+int
+FlowLayout::smartSpacing(QStyle::PixelMetric pm) const
+{
+	QObject* parent = this->parent();
+	if (!parent) {
+		return -1;
+	} else if (parent->isWidgetType()) {
+		QWidget* pw = static_cast<QWidget*>(parent);
+		return pw->style()->pixelMetric(pm, 0, pw);
+	} else {
+		return static_cast<QLayout*>(parent)->spacing();
+	}
+}
+
+class PresetAction : public QAction
+{
+	Q_OBJECT
+
+public:
+	PresetAction(QObject* parent, Jalv* jalv, LilvNode* preset)
+		: QAction(parent)
+		, _jalv(jalv)
+		, _preset(preset)
+	{
+		connect(this, SIGNAL(triggered()),
+		        this, SLOT(presetChosen()));
+	}
+
+	Q_SLOT void presetChosen() {
+		jalv_apply_preset(_jalv, _preset);
+	}
+
+private:
+	Jalv*     _jalv;
+	LilvNode* _preset;
+};
+
+typedef struct {
+	Jalv*        jalv;
+	struct Port* port;
+} PortContainer;
+
+class Control : public QGroupBox
+{
+	Q_OBJECT
+
+public:
+	Control(PortContainer portContainer, QWidget* parent = 0);
+
+	Q_SLOT void dialChanged(int value);
+
+	void setValue(float value);
+
+	QDial* dial;
+
+private:
+	void    setRange(float min, float max);
+	QString getValueLabel(float value);
+	float   getValue();
+
+	const LilvPlugin* plugin;
+	struct Port*      port;
+
+	QLabel* label;
+	QString name;
+	int     steps;
+	float   max;
+	float   min;
+	bool    isInteger;
+	bool    isEnum;
+	bool    isLogarithmic;
+
+	std::vector<float>           scalePoints;
+	std::map<float, const char*> scaleMap;
+};
+
+#if QT_VERSION >= 0x050000
+#    include "jalv_qt5_meta.hpp"
+#else
+#    include "jalv_qt4_meta.hpp"
+#endif
+
+extern "C" {
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	app = new QApplication(*argc, *argv, true);
+	app->setStyleSheet("QGroupBox::title { subcontrol-position: top center }");
+
+	return 0;
+}
+
+const char*
+jalv_native_ui_type(Jalv* jalv)
+{
+#if QT_VERSION >= 0x050000
+	return "http://lv2plug.in/ns/extensions/ui#Qt5UI";
+#else
+	return "http://lv2plug.in/ns/extensions/ui#Qt4UI";
+#endif
+}
+
+int
+jalv_ui_resize(Jalv* jalv, int width, int height)
+{
+	if (jalv->ui_instance && width > 0 && height > 0) {
+		QWidget* widget = (QWidget*)suil_instance_get_widget(jalv->ui_instance);
+		if (widget) {
+			widget->resize(width, height);
+		}
+	}
+	return 0;
+}
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer)
+{
+	if (jalv->ui_instance) {
+		suil_instance_port_event(jalv->ui_instance, port_index,
+		                         buffer_size, protocol, buffer);
+	} else {
+		Control* control = (Control*)jalv->ports[port_index].widget;
+		if (control) {
+			control->setValue(*(const float*)buffer);
+		}
+	}
+}
+
+class Timer : public QTimer
+{
+public:
+	explicit Timer(Jalv* jalv) : _jalv(jalv) {}
+
+	void timerEvent(QTimerEvent* e) {
+		jalv_update(_jalv);
+	}
+
+private:
+	Jalv* _jalv;
+};
+
+static int
+add_preset_to_menu(Jalv*           jalv,
+                   const LilvNode* node,
+                   const LilvNode* title,
+                   void*           data)
+{
+	QMenu*      menu  = (QMenu*)data;
+	const char* label = lilv_node_as_string(title);
+
+	QAction* action = new PresetAction(menu, jalv, lilv_node_duplicate(node));
+	action->setText(label);
+	menu->addAction(action);
+	return 0;
+}
+
+Control::Control(PortContainer portContainer, QWidget* parent)
+	: QGroupBox(parent)
+	, dial(new QDial())
+	, plugin(portContainer.jalv->plugin)
+	, port(portContainer.port)
+	, label(new QLabel())
+{
+	JalvNodes*      nodes    = &portContainer.jalv->nodes;
+	const LilvPort* lilvPort = port->lilv_port;
+
+	LilvNode* nmin;
+	LilvNode* nmax;
+	LilvNode* ndef;
+	lilv_port_get_range(plugin, lilvPort, &ndef, &nmin, &nmax);
+
+	LilvNode* stepsNode = lilv_port_get(plugin, lilvPort, nodes->pprops_rangeSteps);
+	if (lilv_node_is_int(stepsNode)) {
+		steps = std::max(lilv_node_as_int(stepsNode), 2);
+	} else {
+		steps = DIAL_STEPS;
+	}
+
+	// Fill scalePoints Map
+	LilvScalePoints* sp = lilv_port_get_scale_points(plugin, lilvPort);
+	if (sp) {
+		LILV_FOREACH(scale_points, s, sp) {
+			const LilvScalePoint* p   = lilv_scale_points_get(sp, s);
+			const LilvNode*       val = lilv_scale_point_get_value(p);
+			if (!lilv_node_is_float(val) && !lilv_node_is_int(val)) {
+				continue;
+			}
+
+			const float f = lilv_node_as_float(val);
+			scalePoints.push_back(f);
+			scaleMap[f] = lilv_node_as_string(lilv_scale_point_get_label(p));
+		}
+
+		lilv_scale_points_free(sp);
+	}
+
+	// Check port properties
+	isLogarithmic = lilv_port_has_property(plugin, lilvPort, nodes->pprops_logarithmic);
+	isInteger     = lilv_port_has_property(plugin, lilvPort, nodes->lv2_integer);
+	isEnum        = lilv_port_has_property(plugin, lilvPort, nodes->lv2_enumeration);
+
+	if (lilv_port_has_property(plugin, lilvPort, nodes->lv2_toggled)) {
+		isInteger = true;
+
+		if (!scaleMap[0]) {
+			scaleMap[0] = "Off";
+		}
+		if (!scaleMap[1]) {
+			scaleMap[1] = "On" ;
+		}
+	}
+
+	// Find and set min, max and default values for port
+	float defaultValue = ndef ? lilv_node_as_float(ndef) : port->control;
+	setRange(lilv_node_as_float(nmin), lilv_node_as_float(nmax));
+	setValue(defaultValue);
+
+	// Fill layout
+	QVBoxLayout* layout = new QVBoxLayout();
+	layout->addWidget(label, 0, Qt::AlignHCenter);
+	layout->addWidget(dial, 0, Qt::AlignHCenter);
+	setLayout(layout);
+
+	setMinimumWidth(CONTROL_WIDTH);
+	setMaximumWidth(CONTROL_WIDTH);
+
+	LilvNode* nname = lilv_port_get_name(plugin, lilvPort);
+	name = QString("%1").arg(lilv_node_as_string(nname));
+
+	// Handle long names
+	if (fontMetrics().width(name) > CONTROL_WIDTH) {
+		setTitle(fontMetrics().elidedText(name, Qt::ElideRight, CONTROL_WIDTH));
+	} else {
+		setTitle(name);
+	}
+
+	// Set tooltip if comment is available
+	LilvNode* comment = lilv_port_get(plugin, lilvPort, nodes->rdfs_comment);
+	if (comment) {
+		QString* tooltip = new QString();
+		tooltip->append(lilv_node_as_string(comment));
+		setToolTip(*tooltip);
+	}
+
+	setFlat(true);
+
+	connect(dial, SIGNAL(valueChanged(int)), this, SLOT(dialChanged(int)));
+
+	lilv_node_free(nmin);
+	lilv_node_free(nmax);
+	lilv_node_free(ndef);
+	lilv_node_free(nname);
+	lilv_node_free(comment);
+}
+
+void
+Control::setValue(float value)
+{
+	float step;
+
+	if (isInteger) {
+		step = value;
+	} else if (isEnum) {
+		step = (std::find(scalePoints.begin(), scalePoints.end(), value)
+		        - scalePoints.begin());
+	} else if (isLogarithmic) {
+		step = steps * log(value / min) / log(max / min);
+	} else {
+		step = value * steps;
+	}
+
+	dial->setValue(step);
+	label->setText(getValueLabel(value));
+}
+
+QString
+Control::getValueLabel(float value)
+{
+	if (scaleMap[value]) {
+		if (fontMetrics().width(scaleMap[value]) > CONTROL_WIDTH) {
+			label->setToolTip(scaleMap[value]);
+			return fontMetrics().elidedText(QString(scaleMap[value]),
+			                                Qt::ElideRight,
+			                                CONTROL_WIDTH);
+		}
+		return scaleMap[value];
+	}
+
+	return QString("%1").arg(value);
+}
+
+void
+Control::setRange(float minRange, float maxRange)
+{
+	min = minRange;
+	max = maxRange;
+
+	if (isLogarithmic) {
+		minRange = 1;
+		maxRange = steps;
+	} else if (isEnum) {
+		minRange = 0;
+		maxRange = scalePoints.size() - 1;
+	} else if (!isInteger) {
+		minRange *= steps;
+		maxRange *= steps;
+	}
+
+	dial->setRange(minRange, maxRange);
+}
+
+float
+Control::getValue()
+{
+	if (isEnum) {
+		return scalePoints[dial->value()];
+	} else if (isInteger) {
+		return dial->value();
+	} else if (isLogarithmic) {
+		return min * pow(max / min, (float)dial->value() / (steps - 1));
+	} else {
+		return (float)dial->value() / steps;
+	}
+}
+
+void
+Control::dialChanged(int dialValue)
+{
+	float value = getValue();
+
+	label->setText(getValueLabel(value));
+	port->control = value;
+}
+
+static bool
+portGroupLessThan(const PortContainer &p1, const PortContainer &p2)
+{
+	Jalv*           jalv  = p1.jalv;
+	const LilvPort* port1 = p1.port->lilv_port;
+	const LilvPort* port2 = p2.port->lilv_port;
+
+	LilvNode* group1 = lilv_port_get(
+		jalv->plugin, port1, jalv->nodes.pg_group);
+	LilvNode* group2 = lilv_port_get(
+		jalv->plugin, port2, jalv->nodes.pg_group);
+
+	const int cmp = (group1 && group2)
+		? strcmp(lilv_node_as_string(group1), lilv_node_as_string(group2))
+		: ((intptr_t)group1 - (intptr_t)group2);
+
+	lilv_node_free(group2);
+	lilv_node_free(group1);
+
+	return cmp < 0;
+}
+
+static QWidget*
+build_control_widget(Jalv* jalv)
+{
+	const LilvPlugin* plugin = jalv->plugin;
+	LilvWorld*        world  = jalv->world;
+
+	QList<PortContainer> portContainers;
+	for (unsigned i = 0; i < jalv->num_ports; ++i) {
+		if (!jalv->opts.show_hidden &&
+		    lilv_port_has_property(plugin, jalv->ports[i].lilv_port,
+		                           jalv->nodes.pprops_notOnGUI)) {
+			continue;
+		}
+
+		if (jalv->ports[i].type == TYPE_CONTROL) {
+			PortContainer portContainer;
+			portContainer.jalv = jalv;
+			portContainer.port = &jalv->ports[i];
+			portContainers.append(portContainer);
+		}
+	}
+
+	qSort(portContainers.begin(), portContainers.end(), portGroupLessThan);
+
+	QWidget*    grid       = new QWidget();
+	FlowLayout* flowLayout = new FlowLayout();
+	QLayout*    layout     = flowLayout;
+
+	LilvNode*    lastGroup   = NULL;
+	QHBoxLayout* groupLayout = NULL;
+	for (int i = 0; i < portContainers.count(); ++i) {
+		PortContainer portContainer = portContainers[i];
+		Port*         port          = portContainer.port;
+
+		Control*  control = new Control(portContainer);
+		LilvNode* group   = lilv_port_get(
+			plugin, port->lilv_port, jalv->nodes.pg_group);
+		if (group) {
+			if (!lilv_node_equals(group, lastGroup)) {
+				/* Group has changed */
+				LilvNode* groupName = lilv_world_get(
+					world, group, jalv->nodes.lv2_name, NULL);
+				QGroupBox* groupBox = new QGroupBox(lilv_node_as_string(groupName));
+
+				groupLayout = new QHBoxLayout();
+				groupBox->setLayout(groupLayout);
+				layout->addWidget(groupBox);
+			}
+
+			groupLayout->addWidget(control);
+		} else {
+			layout->addWidget(control);
+		}
+		lastGroup = group;
+
+		uint32_t index = lilv_port_get_index(plugin, port->lilv_port);
+		jalv->ports[index].widget = control;
+	}
+
+	grid->setLayout(layout);
+
+	return grid;
+}
+
+bool
+jalv_discover_ui(Jalv* jalv)
+{
+	return true;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	QMainWindow* win          = new QMainWindow();
+	QMenu*       file_menu    = win->menuBar()->addMenu("&File");
+	QMenu*       presets_menu = win->menuBar()->addMenu("&Presets");
+	QAction*     quit_action  = new QAction("&Quit", win);
+
+	QObject::connect(quit_action, SIGNAL(triggered()), win, SLOT(close()));
+	quit_action->setShortcuts(QKeySequence::Quit);
+	quit_action->setStatusTip("Quit Jalv");
+	file_menu->addAction(quit_action);
+
+	jalv_load_presets(jalv, add_preset_to_menu, presets_menu);
+
+	if (jalv->ui && !jalv->opts.generic_ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(jalv), win);
+	}
+
+	QWidget* widget;
+	if (jalv->ui_instance) {
+		widget = (QWidget*)suil_instance_get_widget(jalv->ui_instance);
+	} else {
+		QWidget* controlWidget = build_control_widget(jalv);
+
+		widget = new QScrollArea();
+		((QScrollArea*)widget)->setWidget(controlWidget);
+		((QScrollArea*)widget)->setWidgetResizable(true);
+		widget->setMinimumWidth(800);
+		widget->setMinimumHeight(600);
+	}
+
+	LilvNode* name = lilv_plugin_get_name(jalv->plugin);
+	win->setWindowTitle(lilv_node_as_string(name));
+	lilv_node_free(name);
+
+	win->setCentralWidget(widget);
+	app->connect(app, SIGNAL(lastWindowClosed()), app, SLOT(quit()));
+
+	win->show();
+	if (jalv->ui_instance && !jalv_ui_is_resizable(jalv)) {
+		widget->setMinimumSize(widget->width(), widget->height());
+		widget->setMaximumSize(widget->width(), widget->height());
+		win->adjustSize();
+		win->setFixedSize(win->width(), win->height());
+	} else {
+		win->resize(widget->width(),
+		            widget->height() + win->menuBar()->height());
+	}
+
+	Timer* timer = new Timer(jalv);
+	timer->start(1000 / jalv->ui_update_hz);
+
+	int ret = app->exec();
+	zix_sem_post(jalv->done);
+	return ret;
+}
+
+int
+jalv_close_ui(Jalv* jalv)
+{
+	app->quit();
+	return 0;
+}
+
+}  // extern "C"
diff --git a/src/log.c b/src/log.c
new file mode 100644
index 0000000..45a8f59
--- /dev/null
+++ b/src/log.c
@@ -0,0 +1,60 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "jalv_internal.h"
+
+int
+jalv_printf(LV2_Log_Handle handle,
+            LV2_URID       type,
+            const char*    fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	const int ret = jalv_vprintf(handle, type, fmt, args);
+	va_end(args);
+	return ret;
+}
+
+int
+jalv_vprintf(LV2_Log_Handle handle,
+             LV2_URID       type,
+             const char*    fmt,
+             va_list        ap)
+{
+	// TODO: Lock
+	Jalv* jalv  = (Jalv*)handle;
+	bool  fancy = true;
+	if (type == jalv->urids.log_Trace && jalv->opts.trace) {
+		jalv_ansi_start(stderr, 32);
+		fprintf(stderr, "trace: ");
+	} else if (type == jalv->urids.log_Error) {
+		jalv_ansi_start(stderr, 31);
+		fprintf(stderr, "error: ");
+	} else if (type == jalv->urids.log_Warning) {
+		jalv_ansi_start(stderr, 33);
+		fprintf(stderr, "warning: ");
+	} else {
+		fancy = false;
+	}
+
+	const int st = vfprintf(stderr, fmt, ap);
+
+	if (fancy) {
+		jalv_ansi_reset(stderr);
+	}
+
+	return st;
+}
diff --git a/src/lv2_evbuf.c b/src/lv2_evbuf.c
new file mode 100644
index 0000000..2307c12
--- /dev/null
+++ b/src/lv2_evbuf.c
@@ -0,0 +1,276 @@
+/*
+  Copyright 2008-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
+#include "lv2/lv2plug.in/ns/ext/event/event.h"
+
+#include "lv2_evbuf.h"
+
+struct LV2_Evbuf_Impl {
+	LV2_Evbuf_Type type;
+	uint32_t       capacity;
+	uint32_t       atom_Chunk;
+	uint32_t       atom_Sequence;
+	union {
+		LV2_Event_Buffer  event;
+		LV2_Atom_Sequence atom;
+	} buf;
+};
+
+static inline uint32_t
+lv2_evbuf_pad_size(uint32_t size)
+{
+	return (size + 7) & (~7);
+}
+
+LV2_Evbuf*
+lv2_evbuf_new(uint32_t       capacity,
+              LV2_Evbuf_Type type,
+              uint32_t       atom_Chunk,
+              uint32_t       atom_Sequence)
+{
+	// FIXME: memory must be 64-bit aligned
+	LV2_Evbuf* evbuf = (LV2_Evbuf*)malloc(
+		sizeof(LV2_Evbuf) + sizeof(LV2_Atom_Sequence) + capacity);
+	evbuf->capacity      = capacity;
+	evbuf->atom_Chunk    = atom_Chunk;
+	evbuf->atom_Sequence = atom_Sequence;
+	lv2_evbuf_set_type(evbuf, type);
+	lv2_evbuf_reset(evbuf, true);
+	return evbuf;
+}
+
+void
+lv2_evbuf_free(LV2_Evbuf* evbuf)
+{
+	free(evbuf);
+}
+
+void
+lv2_evbuf_set_type(LV2_Evbuf* evbuf, LV2_Evbuf_Type type)
+{
+	evbuf->type = type;
+	switch (type) {
+	case LV2_EVBUF_EVENT:
+		evbuf->buf.event.data     = (uint8_t*)(evbuf + 1);
+		evbuf->buf.event.capacity = evbuf->capacity;
+		break;
+	case LV2_EVBUF_ATOM:
+		break;
+	}
+	lv2_evbuf_reset(evbuf, true);
+}
+
+void
+lv2_evbuf_reset(LV2_Evbuf* evbuf, bool input)
+{
+	switch (evbuf->type) {
+	case LV2_EVBUF_EVENT:
+		evbuf->buf.event.header_size = sizeof(LV2_Event_Buffer);
+		evbuf->buf.event.stamp_type  = LV2_EVENT_AUDIO_STAMP;
+		evbuf->buf.event.event_count = 0;
+		evbuf->buf.event.size        = 0;
+		break;
+	case LV2_EVBUF_ATOM:
+		if (input) {
+			evbuf->buf.atom.atom.size = sizeof(LV2_Atom_Sequence_Body);
+			evbuf->buf.atom.atom.type = evbuf->atom_Sequence;
+		} else {
+			evbuf->buf.atom.atom.size = evbuf->capacity;
+			evbuf->buf.atom.atom.type = evbuf->atom_Chunk;
+		}
+	}
+}
+
+uint32_t
+lv2_evbuf_get_size(LV2_Evbuf* evbuf)
+{
+	switch (evbuf->type) {
+	case LV2_EVBUF_EVENT:
+		return evbuf->buf.event.size;
+	case LV2_EVBUF_ATOM:
+		assert(evbuf->buf.atom.atom.type != evbuf->atom_Sequence
+		       || evbuf->buf.atom.atom.size >= sizeof(LV2_Atom_Sequence_Body));
+		return evbuf->buf.atom.atom.type == evbuf->atom_Sequence
+			? evbuf->buf.atom.atom.size - sizeof(LV2_Atom_Sequence_Body)
+			: 0;
+	}
+	return 0;
+}
+
+void*
+lv2_evbuf_get_buffer(LV2_Evbuf* evbuf)
+{
+	switch (evbuf->type) {
+	case LV2_EVBUF_EVENT:
+		return &evbuf->buf.event;
+	case LV2_EVBUF_ATOM:
+		return &evbuf->buf.atom;
+	}
+	return NULL;
+}
+
+LV2_Evbuf_Iterator
+lv2_evbuf_begin(LV2_Evbuf* evbuf)
+{
+	LV2_Evbuf_Iterator iter = { evbuf, 0 };
+	return iter;
+}
+
+LV2_Evbuf_Iterator
+lv2_evbuf_end(LV2_Evbuf* evbuf)
+{
+	const uint32_t           size = lv2_evbuf_get_size(evbuf);
+	const LV2_Evbuf_Iterator iter = { evbuf, lv2_evbuf_pad_size(size) };
+	return iter;
+}
+
+bool
+lv2_evbuf_is_valid(LV2_Evbuf_Iterator iter)
+{
+	return iter.offset < lv2_evbuf_get_size(iter.evbuf);
+}
+
+LV2_Evbuf_Iterator
+lv2_evbuf_next(LV2_Evbuf_Iterator iter)
+{
+	if (!lv2_evbuf_is_valid(iter)) {
+		return iter;
+	}
+
+	LV2_Evbuf* evbuf  = iter.evbuf;
+	uint32_t   offset = iter.offset;
+	uint32_t   size;
+	switch (evbuf->type) {
+	case LV2_EVBUF_EVENT:
+		size    = ((LV2_Event*)(evbuf->buf.event.data + offset))->size;
+		offset += lv2_evbuf_pad_size(sizeof(LV2_Event) + size);
+		break;
+	case LV2_EVBUF_ATOM:
+		size = ((LV2_Atom_Event*)
+		        ((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, &evbuf->buf.atom)
+		         + offset))->body.size;
+		offset += lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size);
+		break;
+	}
+
+	LV2_Evbuf_Iterator next = { evbuf, offset };
+	return next;
+}
+
+bool
+lv2_evbuf_get(LV2_Evbuf_Iterator iter,
+              uint32_t*          frames,
+              uint32_t*          subframes,
+              uint32_t*          type,
+              uint32_t*          size,
+              uint8_t**          data)
+{
+	*frames = *subframes = *type = *size = 0;
+	*data = NULL;
+
+	if (!lv2_evbuf_is_valid(iter)) {
+		return false;
+	}
+
+	LV2_Event_Buffer*  ebuf;
+	LV2_Event*         ev;
+	LV2_Atom_Sequence* aseq;
+	LV2_Atom_Event*    aev;
+	switch (iter.evbuf->type) {
+	case LV2_EVBUF_EVENT:
+		ebuf = &iter.evbuf->buf.event;
+		ev = (LV2_Event*)((char*)ebuf->data + iter.offset);
+		*frames    = ev->frames;
+		*subframes = ev->subframes;
+		*type      = ev->type;
+		*size      = ev->size;
+		*data      = (uint8_t*)ev + sizeof(LV2_Event);
+		break;
+	case LV2_EVBUF_ATOM:
+		aseq = &iter.evbuf->buf.atom;
+		aev = (LV2_Atom_Event*)(
+			(char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq)
+			+ iter.offset);
+		*frames    = aev->time.frames;
+		*subframes = 0;
+		*type      = aev->body.type;
+		*size      = aev->body.size;
+		*data      = (uint8_t*)LV2_ATOM_BODY(&aev->body);
+		break;
+	}
+
+	return true;
+}
+
+bool
+lv2_evbuf_write(LV2_Evbuf_Iterator* iter,
+                uint32_t            frames,
+                uint32_t            subframes,
+                uint32_t            type,
+                uint32_t            size,
+                const uint8_t*      data)
+{
+	LV2_Event_Buffer*  ebuf;
+	LV2_Event*         ev;
+	LV2_Atom_Sequence* aseq;
+	LV2_Atom_Event*    aev;
+	switch (iter->evbuf->type) {
+	case LV2_EVBUF_EVENT:
+		ebuf = &iter->evbuf->buf.event;
+		if (ebuf->capacity - ebuf->size < sizeof(LV2_Event) + size) {
+			return false;
+		}
+
+		ev = (LV2_Event*)(ebuf->data + iter->offset);
+		ev->frames    = frames;
+		ev->subframes = subframes;
+		ev->type      = type;
+		ev->size      = size;
+		memcpy((uint8_t*)ev + sizeof(LV2_Event), data, size);
+
+		size               = lv2_evbuf_pad_size(sizeof(LV2_Event) + size);
+		ebuf->size        += size;
+		ebuf->event_count += 1;
+		iter->offset      += size;
+		break;
+	case LV2_EVBUF_ATOM:
+		aseq = &iter->evbuf->buf.atom;
+		if (iter->evbuf->capacity - sizeof(LV2_Atom) - aseq->atom.size
+		    < sizeof(LV2_Atom_Event) + size) {
+			return false;
+		}
+
+		aev = (LV2_Atom_Event*)(
+			(char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq)
+			+ iter->offset);
+		aev->time.frames = frames;
+		aev->body.type   = type;
+		aev->body.size   = size;
+		memcpy(LV2_ATOM_BODY(&aev->body), data, size);
+
+		size             = lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size);
+		aseq->atom.size += size;
+		iter->offset    += size;
+		break;
+	}
+
+	return true;
+}
diff --git a/src/lv2_evbuf.h b/src/lv2_evbuf.h
new file mode 100644
index 0000000..42951f0
--- /dev/null
+++ b/src/lv2_evbuf.h
@@ -0,0 +1,164 @@
+/*
+  Copyright 2008-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef LV2_EVBUF_H
+#define LV2_EVBUF_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+/**
+   Format of actual buffer.
+*/
+typedef enum {
+	/**
+	   An (old) ev:EventBuffer (LV2_Event_Buffer).
+	*/
+	LV2_EVBUF_EVENT,
+
+	/**
+	   A (new) atom:Sequence (LV2_Atom_Sequence).
+	*/
+	LV2_EVBUF_ATOM
+} LV2_Evbuf_Type;
+
+/**
+   An abstract/opaque LV2 event buffer.
+*/
+typedef struct LV2_Evbuf_Impl LV2_Evbuf;
+
+/**
+   An iterator over an LV2_Evbuf.
+*/
+typedef struct {
+	LV2_Evbuf* evbuf;
+	uint32_t   offset;
+} LV2_Evbuf_Iterator;
+
+/**
+   Allocate a new, empty event buffer.
+   URIDs for atom:Chunk and atom:Sequence must be passed for LV2_EVBUF_ATOM.
+*/
+LV2_Evbuf*
+lv2_evbuf_new(uint32_t       capacity,
+              LV2_Evbuf_Type type,
+              uint32_t       atom_Chunk,
+              uint32_t       atom_Sequence);
+
+/**
+   Free an event buffer allocated with lv2_evbuf_new.
+*/
+void
+lv2_evbuf_free(LV2_Evbuf* evbuf);
+
+/**
+   Reset and change the type of an existing event buffer.
+   URIDs for atom:Chunk and atom:Sequence must be passed for LV2_EVBUF_ATOM.
+*/
+void
+lv2_evbuf_set_type(LV2_Evbuf* evbuf, LV2_Evbuf_Type type);
+
+/**
+   Clear and initialize an existing event buffer.
+   The contents of buf are ignored entirely and overwritten, except capacity
+   which is unmodified.
+   If input is false and this is an atom buffer, the buffer will be prepared
+   for writing by the plugin.  This MUST be called before every run cycle.
+*/
+void
+lv2_evbuf_reset(LV2_Evbuf* evbuf, bool input);
+
+/**
+   Return the total padded size of the events stored in the buffer.
+*/
+uint32_t
+lv2_evbuf_get_size(LV2_Evbuf* evbuf);
+
+/**
+   Return the actual buffer implementation.
+   The format of the buffer returned depends on the buffer type.
+*/
+void*
+lv2_evbuf_get_buffer(LV2_Evbuf* evbuf);
+
+/**
+   Return an iterator to the start of `evbuf`.
+*/
+LV2_Evbuf_Iterator
+lv2_evbuf_begin(LV2_Evbuf* evbuf);
+
+/**
+   Return an iterator to the end of `evbuf`.
+*/
+LV2_Evbuf_Iterator
+lv2_evbuf_end(LV2_Evbuf* evbuf);
+
+/**
+   Check if `iter` is valid.
+   @return True if `iter` is valid, otherwise false (past end of buffer)
+*/
+bool
+lv2_evbuf_is_valid(LV2_Evbuf_Iterator iter);
+
+/**
+   Advance `iter` forward one event.
+   `iter` must be valid.
+   @return True if `iter` is valid, otherwise false (reached end of buffer)
+*/
+LV2_Evbuf_Iterator
+lv2_evbuf_next(LV2_Evbuf_Iterator iter);
+
+/**
+   Dereference an event iterator (i.e. get the event currently pointed to).
+   `iter` must be valid.
+   `type` Set to the type of the event.
+   `size` Set to the size of the event.
+   `data` Set to the contents of the event.
+   @return True on success.
+*/
+bool
+lv2_evbuf_get(LV2_Evbuf_Iterator iter,
+              uint32_t*          frames,
+              uint32_t*          subframes,
+              uint32_t*          type,
+              uint32_t*          size,
+              uint8_t**          data);
+
+/**
+   Write an event at `iter`.
+   The event (if any) pointed to by `iter` will be overwritten, and `iter`
+   incremented to point to the following event (i.e. several calls to this
+   function can be done in sequence without twiddling iter in-between).
+   @return True if event was written, otherwise false (buffer is full).
+*/
+bool
+lv2_evbuf_write(LV2_Evbuf_Iterator* iter,
+                uint32_t            frames,
+                uint32_t            subframes,
+                uint32_t            type,
+                uint32_t            size,
+                const uint8_t*      data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LV2_EVBUF_H */
diff --git a/src/portaudio.c b/src/portaudio.c
new file mode 100644
index 0000000..cb16c63
--- /dev/null
+++ b/src/portaudio.c
@@ -0,0 +1,223 @@
+/*
+   Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+   Permission to use, copy, modify, and/or distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <math.h>
+#include <portaudio.h>
+
+#include "jalv_internal.h"
+#include "worker.h"
+
+struct JalvBackend {
+	PaStream* stream;
+};
+
+static int
+pa_process_cb(const void*                     inputs,
+              void*                           outputs,
+              unsigned long                   nframes,
+              const PaStreamCallbackTimeInfo* time,
+              PaStreamCallbackFlags           flags,
+              void*                           handle)
+{
+	Jalv* jalv = (Jalv*)handle;
+
+	/* Prepare port buffers */
+	uint32_t in_index  = 0;
+	uint32_t out_index = 0;
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		struct Port* port = &jalv->ports[i];
+		if (port->type == TYPE_AUDIO) {
+			if (port->flow == FLOW_INPUT) {
+				lilv_instance_connect_port(jalv->instance, i, ((float**)inputs)[in_index++]);
+			} else if (port->flow == FLOW_OUTPUT) {
+				lilv_instance_connect_port(jalv->instance, i, ((float**)outputs)[out_index++]);
+			}
+		} else if (port->type == TYPE_EVENT && port->flow == FLOW_INPUT) {
+			lv2_evbuf_reset(port->evbuf, true);
+
+			if (jalv->request_update) {
+				/* Plugin state has changed, request an update */
+				const LV2_Atom_Object get = {
+					{ sizeof(LV2_Atom_Object_Body), jalv->urids.atom_Object },
+					{ 0, jalv->urids.patch_Get } };
+				LV2_Evbuf_Iterator iter = lv2_evbuf_begin(port->evbuf);
+				lv2_evbuf_write(&iter, 0, 0,
+				                get.atom.type, get.atom.size,
+				                (const uint8_t*)LV2_ATOM_BODY(&get));
+			}
+		} else if (port->type == TYPE_EVENT) {
+			/* Clear event output for plugin to write to */
+			lv2_evbuf_reset(port->evbuf, false);
+		}
+	}
+	jalv->request_update = false;
+
+	/* Run plugin for this cycle */
+	const bool send_ui_updates = jalv_run(jalv, nframes);
+
+	/* Deliver UI events */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* const port = &jalv->ports[p];
+		if (port->flow == FLOW_OUTPUT && port->type == TYPE_EVENT) {
+			for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf);
+			     lv2_evbuf_is_valid(i);
+			     i = lv2_evbuf_next(i)) {
+				// Get event from LV2 buffer
+				uint32_t frames, subframes, type, size;
+				uint8_t* body;
+				lv2_evbuf_get(i, &frames, &subframes, &type, &size, &body);
+
+				if (jalv->has_ui && !port->old_api) {
+					// Forward event to UI
+					jalv_send_to_ui(jalv, p, type, size, body);
+				}
+			}
+		} else if (send_ui_updates &&
+		           port->flow == FLOW_OUTPUT && port->type == TYPE_CONTROL) {
+			char buf[sizeof(ControlChange) + sizeof(float)];
+			ControlChange* ev = (ControlChange*)buf;
+			ev->index    = p;
+			ev->protocol = 0;
+			ev->size     = sizeof(float);
+			*(float*)ev->body = port->control;
+			if (zix_ring_write(jalv->plugin_events, buf, sizeof(buf))
+			    < sizeof(buf)) {
+				fprintf(stderr, "Plugin => UI buffer overflow!\n");
+			}
+		}
+	}
+
+	return paContinue;
+}
+
+static JalvBackend*
+pa_error(const char* msg, PaError err)
+{
+	fprintf(stderr, "error: %s (%s)\n", msg, Pa_GetErrorText(err));
+	Pa_Terminate();
+	return NULL;
+}
+
+JalvBackend*
+jalv_backend_init(Jalv* jalv)
+{
+	PaStreamParameters inputParameters;
+	PaStreamParameters outputParameters;
+	PaStream*          stream = NULL;
+	PaError            st     = paNoError;
+
+	if ((st = Pa_Initialize())) {
+		return pa_error("Failed to initialize audio system", st);
+	}
+
+	// Get default input and output devices
+	inputParameters.device  = Pa_GetDefaultInputDevice();
+	outputParameters.device = Pa_GetDefaultOutputDevice();
+	if (inputParameters.device == paNoDevice) {
+		return pa_error("No default input device", paDeviceUnavailable);
+	} else if (outputParameters.device == paNoDevice) {
+		return pa_error("No default output device", paDeviceUnavailable);
+	}
+
+	const PaDeviceInfo* in_dev  = Pa_GetDeviceInfo(inputParameters.device);
+	const PaDeviceInfo* out_dev = Pa_GetDeviceInfo(outputParameters.device);
+
+	// Count number of input and output audio ports/channels
+	inputParameters.channelCount  = 0;
+	outputParameters.channelCount = 0;
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		if (jalv->ports[i].type == TYPE_AUDIO) {
+			if (jalv->ports[i].flow == FLOW_INPUT) {
+				++inputParameters.channelCount;
+			} else if (jalv->ports[i].flow == FLOW_OUTPUT) {
+				++outputParameters.channelCount;
+			}
+		}
+	}
+
+	// Configure audio format
+	inputParameters.sampleFormat               = paFloat32|paNonInterleaved;
+	inputParameters.suggestedLatency           = in_dev->defaultLowInputLatency;
+	inputParameters.hostApiSpecificStreamInfo  = NULL;
+	outputParameters.sampleFormat              = paFloat32|paNonInterleaved;
+	outputParameters.suggestedLatency          = out_dev->defaultLowOutputLatency;
+	outputParameters.hostApiSpecificStreamInfo = NULL;
+
+	// Open stream
+	if ((st = Pa_OpenStream(
+		     &stream,
+		     inputParameters.channelCount ? &inputParameters : NULL,
+		     outputParameters.channelCount ? &outputParameters : NULL,
+		     in_dev->defaultSampleRate,
+		     paFramesPerBufferUnspecified,
+		     0,
+		     pa_process_cb,
+		     jalv))) {
+		return pa_error("Failed to open audio stream", st);
+	}
+
+	// Set audio parameters
+	jalv->sample_rate   = in_dev->defaultSampleRate;
+	// jalv->block_length  = FIXME
+	jalv->midi_buf_size = 4096;
+
+	// Allocate and return opaque backend
+	JalvBackend* backend = (JalvBackend*)calloc(1, sizeof(JalvBackend));
+	backend->stream = stream;
+	return backend;
+}
+
+void
+jalv_backend_close(Jalv* jalv)
+{
+	Pa_Terminate();
+	free(jalv->backend);
+	jalv->backend = NULL;
+}
+
+void
+jalv_backend_activate(Jalv* jalv)
+{
+	const int st = Pa_StartStream(jalv->backend->stream);
+	if (st != paNoError) {
+		fprintf(stderr, "error: Error starting audio stream (%s)\n",
+		        Pa_GetErrorText(st));
+	}
+}
+
+void
+jalv_backend_deactivate(Jalv* jalv)
+{
+	const int st = Pa_CloseStream(jalv->backend->stream);
+	if (st != paNoError) {
+		fprintf(stderr, "error: Error closing audio stream (%s)\n",
+		        Pa_GetErrorText(st));
+	}
+}
+
+void
+jalv_backend_activate_port(Jalv* jalv, uint32_t port_index)
+{
+	struct Port* const port = &jalv->ports[port_index];
+	switch (port->type) {
+	case TYPE_CONTROL:
+		lilv_instance_connect_port(jalv->instance, port_index, &port->control);
+		break;
+	default:
+		break;
+	}
+}
diff --git a/src/state.c b/src/state.c
new file mode 100644
index 0000000..e2f2b47
--- /dev/null
+++ b/src/state.c
@@ -0,0 +1,265 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef HAVE_LV2_STATE
+#    include "lv2/lv2plug.in/ns/ext/state/state.h"
+#endif
+
+#include "lilv/lilv.h"
+
+#include "jalv_config.h"
+#include "jalv_internal.h"
+
+#define NS_JALV "http://drobilla.net/ns/jalv#"
+#define NS_RDF  "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_RDFS "http://www.w3.org/2000/01/rdf-schema#"
+#define NS_XSD  "http://www.w3.org/2001/XMLSchema#"
+
+extern LV2_Feature uri_map_feature;
+extern LV2_Feature map_feature;
+extern LV2_Feature unmap_feature;
+extern LV2_Feature make_path_feature;
+extern LV2_Feature sched_feature;
+extern LV2_Feature state_sched_feature;
+extern LV2_Feature safe_restore_feature;
+extern LV2_Feature log_feature;
+extern LV2_Feature options_feature;
+extern LV2_Feature def_state_feature;
+
+const LV2_Feature* state_features[9] = {
+	&uri_map_feature, &map_feature, &unmap_feature,
+	&make_path_feature,
+	&state_sched_feature,
+	&safe_restore_feature,
+	&log_feature,
+	&options_feature,
+	NULL
+};
+
+char*
+jalv_make_path(LV2_State_Make_Path_Handle handle,
+               const char*                path)
+{
+	Jalv* jalv = (Jalv*)handle;
+
+	// Create in save directory if saving, otherwise use temp directory
+	return jalv_strjoin(jalv->save_dir ? jalv->save_dir : jalv->temp_dir, path);
+}
+
+static const void*
+get_port_value(const char* port_symbol,
+               void*       user_data,
+               uint32_t*   size,
+               uint32_t*   type)
+{
+	Jalv*        jalv = (Jalv*)user_data;
+	struct Port* port = jalv_port_by_symbol(jalv, port_symbol);
+	if (port && port->flow == FLOW_INPUT && port->type == TYPE_CONTROL) {
+		*size = sizeof(float);
+		*type = jalv->forge.Float;
+		return &port->control;
+	}
+	*size = *type = 0;
+	return NULL;
+}
+
+void
+jalv_save(Jalv* jalv, const char* dir)
+{
+	jalv->save_dir = jalv_strjoin(dir, "/");
+
+	LilvState* const state = lilv_state_new_from_instance(
+		jalv->plugin, jalv->instance, &jalv->map,
+		jalv->temp_dir, dir, dir, dir,
+		get_port_value, jalv,
+		LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, NULL);
+
+	lilv_state_save(jalv->world, &jalv->map, &jalv->unmap, state, NULL,
+	                dir, "state.ttl");
+
+	lilv_state_free(state);
+
+	free(jalv->save_dir);
+	jalv->save_dir = NULL;
+}
+
+int
+jalv_load_presets(Jalv* jalv, PresetSink sink, void* data)
+{
+	LilvNodes* presets = lilv_plugin_get_related(jalv->plugin,
+	                                             jalv->nodes.pset_Preset);
+	LILV_FOREACH(nodes, i, presets) {
+		const LilvNode* preset = lilv_nodes_get(presets, i);
+		lilv_world_load_resource(jalv->world, preset);
+		if (!sink) {
+			continue;
+		}
+
+		LilvNodes* labels = lilv_world_find_nodes(
+			jalv->world, preset, jalv->nodes.rdfs_label, NULL);
+		if (labels) {
+			const LilvNode* label = lilv_nodes_get_first(labels);
+			sink(jalv, preset, label, data);
+			lilv_nodes_free(labels);
+		} else {
+			fprintf(stderr, "Preset <%s> has no rdfs:label\n",
+			        lilv_node_as_string(lilv_nodes_get(presets, i)));
+		}
+	}
+	lilv_nodes_free(presets);
+
+	return 0;
+}
+
+int
+jalv_unload_presets(Jalv* jalv)
+{
+	LilvNodes* presets = lilv_plugin_get_related(jalv->plugin,
+	                                             jalv->nodes.pset_Preset);
+	LILV_FOREACH(nodes, i, presets) {
+		const LilvNode* preset = lilv_nodes_get(presets, i);
+		lilv_world_unload_resource(jalv->world, preset);
+	}
+	lilv_nodes_free(presets);
+
+	return 0;
+}
+
+static void
+set_port_value(const char* port_symbol,
+               void*       user_data,
+               const void* value,
+               uint32_t    size,
+               uint32_t    type)
+{
+	Jalv*        jalv = (Jalv*)user_data;
+	struct Port* port = jalv_port_by_symbol(jalv, port_symbol);
+	if (!port) {
+		fprintf(stderr, "error: Preset port `%s' is missing\n", port_symbol);
+		return;
+	}
+
+	float fvalue;
+	if (type == jalv->forge.Float) {
+		fvalue = *(const float*)value;
+	} else if (type == jalv->forge.Double) {
+		fvalue = *(const double*)value;
+	} else if (type == jalv->forge.Int) {
+		fvalue = *(const int32_t*)value;
+	} else if (type == jalv->forge.Long) {
+		fvalue = *(const int64_t*)value;
+	} else {
+		fprintf(stderr, "error: Preset `%s' value has bad type <%s>\n",
+		        port_symbol, jalv->unmap.unmap(jalv->unmap.handle, type));
+		return;
+	}
+
+	if (jalv->play_state != JALV_RUNNING) {
+		// Set value on port struct directly
+		port->control = fvalue;
+	} else {
+		// Send value to running plugin
+		jalv_ui_write(jalv, port->index, sizeof(fvalue), 0, &fvalue);
+	}
+
+	if (jalv->has_ui) {
+		// Update UI
+		char buf[sizeof(ControlChange) + sizeof(fvalue)];
+		ControlChange* ev = (ControlChange*)buf;
+		ev->index    = port->index;
+		ev->protocol = 0;
+		ev->size     = sizeof(fvalue);
+		*(float*)ev->body = fvalue;
+		zix_ring_write(jalv->plugin_events, buf, sizeof(buf));
+	}
+}
+
+void
+jalv_apply_state(Jalv* jalv, LilvState* state)
+{
+	bool must_pause = !jalv->safe_restore && jalv->play_state == JALV_RUNNING;
+	if (state) {
+		if (must_pause) {
+			jalv->play_state = JALV_PAUSE_REQUESTED;
+			zix_sem_wait(&jalv->paused);
+		}
+
+		lilv_state_restore(
+			state, jalv->instance, set_port_value, jalv, 0, state_features);
+
+		if (must_pause) {
+			jalv->request_update = true;
+			jalv->play_state     = JALV_RUNNING;
+		}
+	}
+}
+
+int
+jalv_apply_preset(Jalv* jalv, const LilvNode* preset)
+{
+	lilv_state_free(jalv->preset);
+	jalv->preset = lilv_state_new_from_world(jalv->world, &jalv->map, preset);
+	jalv_apply_state(jalv, jalv->preset);
+	return 0;
+}
+
+int
+jalv_save_preset(Jalv*       jalv,
+                 const char* dir,
+                 const char* uri,
+                 const char* label,
+                 const char* filename)
+{
+	LilvState* const state = lilv_state_new_from_instance(
+		jalv->plugin, jalv->instance, &jalv->map,
+		jalv->temp_dir, dir, dir, dir,
+		get_port_value, jalv,
+		LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, NULL);
+
+	if (label) {
+		lilv_state_set_label(state, label);
+	}
+
+	int ret = lilv_state_save(
+		jalv->world, &jalv->map, &jalv->unmap, state, uri, dir, filename);
+
+	lilv_state_free(jalv->preset);
+	jalv->preset = state;
+
+	return ret;
+}
+
+int
+jalv_delete_current_preset(Jalv* jalv)
+{
+	if (!jalv->preset) {
+		return 1;
+	}
+
+	lilv_world_unload_resource(jalv->world, lilv_state_get_uri(jalv->preset));
+	lilv_state_delete(jalv->world, jalv->preset);
+	lilv_state_free(jalv->preset);
+	jalv->preset = NULL;
+	return 0;
+}
diff --git a/src/symap.c b/src/symap.c
new file mode 100644
index 0000000..40c8980
--- /dev/null
+++ b/src/symap.c
@@ -0,0 +1,231 @@
+/*
+  Copyright 2011-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "symap.h"
+
+/**
+  @file symap.c Implementation of Symap, a basic symbol map (string interner).
+
+  This implementation is primitive, but has some desirable qualities: good
+  (O(lg(n)) lookup performance for already-mapped symbols, minimal space
+  overhead, extremely fast (O(1)) reverse mapping (ID to string), simple code,
+  no dependencies.
+
+  The tradeoff is that mapping new symbols may be quite slow.  In other words,
+  this implementation is ideal for use cases with a relatively limited set of
+  symbols, or where most symbols are mapped early.  It will not fare so well
+  with very dynamic sets of symbols.  For that, you're better off with a
+  tree-based implementation (and the associated space cost, especially if you
+  need reverse mapping).
+*/
+
+struct SymapImpl {
+	/**
+	   Unsorted array of strings, such that the symbol for ID i is found
+	   at symbols[i - 1].
+	*/
+	char** symbols;
+
+	/**
+	   Array of IDs, sorted by corresponding string in `symbols`.
+	*/
+	uint32_t* index;
+
+	/**
+	   Number of symbols (number of items in `symbols` and `index`).
+	*/
+	uint32_t size;
+};
+
+Symap*
+symap_new(void)
+{
+	Symap* map = (Symap*)malloc(sizeof(Symap));
+	map->symbols = NULL;
+	map->index   = NULL;
+	map->size    = 0;
+	return map;
+}
+
+void
+symap_free(Symap* map)
+{
+	for (uint32_t i = 0; i < map->size; ++i) {
+		free(map->symbols[i]);
+	}
+
+	free(map->symbols);
+	free(map->index);
+	free(map);
+}
+
+static char*
+symap_strdup(const char* str)
+{
+	const size_t len  = strlen(str);
+	char*        copy = (char*)malloc(len + 1);
+	memcpy(copy, str, len + 1);
+	return copy;
+}
+
+/**
+   Return the index into map->index (not the ID) corresponding to `sym`,
+   or the index where a new entry for `sym` should be inserted.
+*/
+static uint32_t
+symap_search(const Symap* map, const char* sym, bool* exact)
+{
+	*exact = false;
+	if (map->size == 0) {
+		return 0;  // Empty map, insert at 0
+	} else if (strcmp(map->symbols[map->index[map->size - 1] - 1], sym) < 0) {
+		return map->size;  // Greater than last element, append
+	}
+
+	uint32_t lower = 0;
+	uint32_t upper = map->size - 1;
+	uint32_t i     = upper;
+	int      cmp;
+
+	while (upper >= lower) {
+		i   = lower + ((upper - lower) / 2);
+		cmp = strcmp(map->symbols[map->index[i] - 1], sym);
+
+		if (cmp == 0) {
+			*exact = true;
+			return i;
+		} else if (cmp > 0) {
+			if (i == 0) {
+				break;  // Avoid underflow
+			}
+			upper = i - 1;
+		} else {
+			lower = ++i;
+		}
+	}
+
+	assert(!*exact || strcmp(map->symbols[map->index[i] - 1], sym) > 0);
+	return i;
+}
+
+uint32_t
+symap_try_map(Symap* map, const char* sym)
+{
+	bool           exact;
+	const uint32_t index = symap_search(map, sym, &exact);
+	if (exact) {
+		assert(!strcmp(map->symbols[map->index[index]], sym));
+		return map->index[index];
+	}
+
+	return 0;
+}
+
+uint32_t
+symap_map(Symap* map, const char* sym)
+{
+	bool           exact;
+	const uint32_t index = symap_search(map, sym, &exact);
+	if (exact) {
+		assert(!strcmp(map->symbols[map->index[index] - 1], sym));
+		return map->index[index];
+	}
+
+	const uint32_t id  = ++map->size;
+	char* const    str = symap_strdup(sym);
+
+	/* Append new symbol to symbols array */
+	map->symbols = (char**)realloc(map->symbols, map->size * sizeof(str));
+	map->symbols[id - 1] = str;
+
+	/* Insert new index element into sorted index */
+	map->index = (uint32_t*)realloc(map->index, map->size * sizeof(uint32_t));
+	if (index < map->size - 1) {
+		memmove(map->index + index + 1,
+		        map->index + index,
+		        (map->size - index - 1) * sizeof(uint32_t));
+	}
+
+	map->index[index] = id;
+
+	return id;
+}
+
+const char*
+symap_unmap(Symap* map, uint32_t id)
+{
+	if (id == 0) {
+		return NULL;
+	} else if (id <= map->size) {
+		return map->symbols[id - 1];
+	}
+	return NULL;
+}
+
+#ifdef STANDALONE
+
+#include <stdio.h>
+
+static void
+symap_dump(Symap* map)
+{
+	fprintf(stderr, "{\n");
+	for (uint32_t i = 0; i < map->size; ++i) {
+		fprintf(stderr, "\t%u = %s\n",
+		        map->index[i], map->symbols[map->index[i] - 1]);
+	}
+	fprintf(stderr, "}\n");
+}
+
+int
+main()
+{
+	#define N_SYMS 5
+	char* syms[N_SYMS] = {
+		"hello", "bonjour", "goodbye", "aloha", "salut"
+	};
+
+	Symap* map = symap_new();
+	for (int i = 0; i < N_SYMS; ++i) {
+		if (symap_try_map(map, syms[i])) {
+			fprintf(stderr, "error: Symbol already mapped\n");
+			return 1;
+		}
+
+		const uint32_t id = symap_map(map, syms[i]);
+		if (strcmp(map->symbols[id - 1], syms[i])) {
+			fprintf(stderr, "error: Corrupt symbol table\n");
+			return 1;
+		}
+
+		if (symap_map(map, syms[i]) != id) {
+			fprintf(stderr, "error: Remapped symbol to a different ID\n");
+			return 1;
+		}
+
+		symap_dump(map);
+	}
+
+	symap_free(map);
+	return 0;
+}
+
+#endif /* STANDALONE */
diff --git a/src/symap.h b/src/symap.h
new file mode 100644
index 0000000..8333298
--- /dev/null
+++ b/src/symap.h
@@ -0,0 +1,69 @@
+/*
+  Copyright 2011-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/**
+   @file symap.h API for Symap, a basic symbol map (string interner).
+
+   Particularly useful for implementing LV2 URI mapping.
+
+   @see <a href="http://lv2plug.in/ns/ext/urid">LV2 URID</a>
+   @see <a href="http://lv2plug.in/ns/ext/uri-map">LV2 URI Map</a>
+*/
+
+#ifndef SYMAP_H
+#define SYMAP_H
+
+#include <stdint.h>
+
+struct SymapImpl;
+
+typedef struct SymapImpl Symap;
+
+/**
+   Create a new symbol map.
+*/
+Symap*
+symap_new(void);
+
+/**
+   Free a symbol map.
+*/
+void
+symap_free(Symap* map);
+
+/**
+   Map a string to a symbol ID if it is already mapped, otherwise return 0.
+*/
+uint32_t
+symap_try_map(Symap* map, const char* sym);
+
+/**
+   Map a string to a symbol ID.
+
+   Note that 0 is never a valid symbol ID.
+*/
+uint32_t
+symap_map(Symap* map, const char* sym);
+
+/**
+   Unmap a symbol ID back to a symbol, or NULL if no such ID exists.
+
+   Note that 0 is never a valid symbol ID.
+*/
+const char*
+symap_unmap(Symap* map, uint32_t id);
+
+#endif /* SYMAP_H */
diff --git a/src/worker.c b/src/worker.c
new file mode 100644
index 0000000..6f94997
--- /dev/null
+++ b/src/worker.c
@@ -0,0 +1,134 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "worker.h"
+
+static LV2_Worker_Status
+jalv_worker_respond(LV2_Worker_Respond_Handle handle,
+                    uint32_t                  size,
+                    const void*               data)
+{
+	JalvWorker* worker = (JalvWorker*)handle;
+	zix_ring_write(worker->responses, (const char*)&size, sizeof(size));
+	zix_ring_write(worker->responses, (const char*)data, size);
+	return LV2_WORKER_SUCCESS;
+}
+
+static void*
+worker_func(void* data)
+{
+	JalvWorker* worker = (JalvWorker*)data;
+	Jalv*       jalv   = worker->jalv;
+	void*       buf    = NULL;
+	while (true) {
+		zix_sem_wait(&worker->sem);
+		if (jalv->exit) {
+			break;
+		}
+
+		uint32_t size = 0;
+		zix_ring_read(worker->requests, (char*)&size, sizeof(size));
+
+		if (!(buf = realloc(buf, size))) {
+			fprintf(stderr, "error: realloc() failed\n");
+			free(buf);
+			return NULL;
+		}
+
+		zix_ring_read(worker->requests, (char*)buf, size);
+
+		zix_sem_wait(&jalv->work_lock);
+		worker->iface->work(
+			jalv->instance->lv2_handle, jalv_worker_respond, worker, size, buf);
+		zix_sem_post(&jalv->work_lock);
+	}
+
+	free(buf);
+	return NULL;
+}
+
+void
+jalv_worker_init(Jalv*                       jalv,
+                 JalvWorker*                 worker,
+                 const LV2_Worker_Interface* iface,
+                 bool                        threaded)
+{
+	worker->iface = iface;
+	worker->threaded = threaded;
+	if (threaded) {
+		zix_thread_create(&worker->thread, 4096, worker_func, worker);
+		worker->requests = zix_ring_new(4096);
+		zix_ring_mlock(worker->requests);
+	}
+	worker->responses = zix_ring_new(4096);
+	worker->response  = malloc(4096);
+	zix_ring_mlock(worker->responses);
+}
+
+void
+jalv_worker_finish(JalvWorker* worker)
+{
+	if (worker->requests) {
+		if (worker->threaded) {
+			zix_sem_post(&worker->sem);
+			zix_thread_join(worker->thread, NULL);
+			zix_ring_free(worker->requests);
+		}
+		zix_ring_free(worker->responses);
+		free(worker->response);
+	}
+}
+
+LV2_Worker_Status
+jalv_worker_schedule(LV2_Worker_Schedule_Handle handle,
+                     uint32_t                   size,
+                     const void*                data)
+{
+	JalvWorker* worker = (JalvWorker*)handle;
+	Jalv*       jalv   = worker->jalv;
+	if (worker->threaded) {
+		// Schedule a request to be executed by the worker thread
+		zix_ring_write(worker->requests, (const char*)&size, sizeof(size));
+		zix_ring_write(worker->requests, (const char*)data, size);
+		zix_sem_post(&worker->sem);
+	} else {
+		// Execute work immediately in this thread
+		zix_sem_wait(&jalv->work_lock);
+		worker->iface->work(
+			jalv->instance->lv2_handle, jalv_worker_respond, worker, size, data);
+		zix_sem_post(&jalv->work_lock);
+	}
+	return LV2_WORKER_SUCCESS;
+}
+
+void
+jalv_worker_emit_responses(JalvWorker* worker, LilvInstance* instance)
+{
+	if (worker->responses) {
+		uint32_t read_space = zix_ring_read_space(worker->responses);
+		while (read_space) {
+			uint32_t size = 0;
+			zix_ring_read(worker->responses, (char*)&size, sizeof(size));
+
+			zix_ring_read(worker->responses, (char*)worker->response, size);
+
+			worker->iface->work_response(
+				instance->lv2_handle, size, worker->response);
+
+			read_space -= sizeof(size) + size;
+		}
+	}
+}
diff --git a/src/worker.h b/src/worker.h
new file mode 100644
index 0000000..93f39e0
--- /dev/null
+++ b/src/worker.h
@@ -0,0 +1,36 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "lv2/lv2plug.in/ns/ext/worker/worker.h"
+
+#include "jalv_internal.h"
+
+void
+jalv_worker_init(Jalv*                       jalv,
+                 JalvWorker*                 worker,
+                 const LV2_Worker_Interface* iface,
+                 bool                        threaded);
+
+void
+jalv_worker_finish(JalvWorker* worker);
+
+LV2_Worker_Status
+jalv_worker_schedule(LV2_Worker_Schedule_Handle handle,
+                     uint32_t                   size,
+                     const void*                data);
+
+void
+jalv_worker_emit_responses(JalvWorker* worker, LilvInstance* instance);
diff --git a/src/zix/common.h b/src/zix/common.h
new file mode 100644
index 0000000..ffeeea1
--- /dev/null
+++ b/src/zix/common.h
@@ -0,0 +1,110 @@
+/*
+  Copyright 2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_COMMON_H
+#define ZIX_COMMON_H
+
+/**
+   @addtogroup zix
+   @{
+*/
+
+/** @cond */
+#ifdef ZIX_SHARED
+#    ifdef _WIN32
+#        define ZIX_LIB_IMPORT __declspec(dllimport)
+#        define ZIX_LIB_EXPORT __declspec(dllexport)
+#    else
+#        define ZIX_LIB_IMPORT __attribute__((visibility("default")))
+#        define ZIX_LIB_EXPORT __attribute__((visibility("default")))
+#    endif
+#    ifdef ZIX_INTERNAL
+#        define ZIX_API ZIX_LIB_EXPORT
+#    else
+#        define ZIX_API ZIX_LIB_IMPORT
+#    endif
+#    define ZIX_PRIVATE static
+#elif defined(ZIX_INLINE)
+#    define ZIX_API     static inline
+#    define ZIX_PRIVATE static inline
+#else
+#    define ZIX_API
+#    define ZIX_PRIVATE static
+#endif
+/** @endcond */
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#    include <stdbool.h>
+#endif
+
+typedef enum {
+	ZIX_STATUS_SUCCESS,
+	ZIX_STATUS_ERROR,
+	ZIX_STATUS_NO_MEM,
+	ZIX_STATUS_NOT_FOUND,
+	ZIX_STATUS_EXISTS,
+	ZIX_STATUS_BAD_ARG,
+	ZIX_STATUS_BAD_PERMS
+} ZixStatus;
+
+static inline const char*
+zix_strerror(const ZixStatus status)
+{
+	switch (status) {
+	case ZIX_STATUS_SUCCESS:
+		return "Success";
+	case ZIX_STATUS_ERROR:
+		return "Unknown error";
+	case ZIX_STATUS_NO_MEM:
+		return "Out of memory";
+	case ZIX_STATUS_NOT_FOUND:
+		return "Not found";
+	case ZIX_STATUS_EXISTS:
+		return "Exists";
+	case ZIX_STATUS_BAD_ARG:
+		return "Bad argument";
+	case ZIX_STATUS_BAD_PERMS:
+		return "Bad permissions";
+	}
+	return "Unknown error";
+}
+
+/**
+   Function for comparing two elements.
+*/
+typedef int (*ZixComparator)(const void* a, const void* b, void* user_data);
+
+/**
+   Function for testing equality of two elements.
+*/
+typedef bool (*ZixEqualFunc)(const void* a, const void* b);
+
+/**
+   Function to destroy an element.
+*/
+typedef void (*ZixDestroyFunc)(void* ptr);
+
+/**
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_COMMON_H */
diff --git a/src/zix/ring.c b/src/zix/ring.c
new file mode 100644
index 0000000..a76b4ea
--- /dev/null
+++ b/src/zix/ring.c
@@ -0,0 +1,228 @@
+/*
+  Copyright 2011-2017 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_MLOCK
+#    include <sys/mman.h>
+#    define ZIX_MLOCK(ptr, size) mlock((ptr), (size))
+#elif defined(_WIN32)
+#    include <windows.h>
+#    define ZIX_MLOCK(ptr, size) VirtualLock((ptr), (size))
+#else
+#    pragma message("warning: No memory locking, possible RT violations")
+#    define ZIX_MLOCK(ptr, size)
+#endif
+
+#if __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_ATOMICS__)
+#    include <stdatomic.h>
+#    define ZIX_WRITE_BARRIER() atomic_thread_fence(memory_order_release)
+#    define ZIX_READ_BARRIER() atomic_thread_fence(memory_order_acquire)
+#elif defined(__APPLE__) /* Pre 10.12 */
+#    include <libkern/OSAtomic.h>
+#    define ZIX_WRITE_BARRIER() OSMemoryBarrier()
+#    define ZIX_READ_BARRIER() OSMemoryBarrier()
+#elif defined(_WIN32)
+#    include <windows.h>
+#    define ZIX_WRITE_BARRIER() MemoryBarrier()
+#    define ZIX_READ_BARRIER() MemoryBarrier()
+#elif (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)
+#    define ZIX_WRITE_BARRIER() __sync_synchronize()
+#    define ZIX_READ_BARRIER() __sync_synchronize()
+#else
+#    pragma message("warning: No memory barriers, possible SMP bugs")
+#    define ZIX_WRITE_BARRIER()
+#    define ZIX_READ_BARRIER()
+#endif
+
+#include "zix/ring.h"
+
+struct ZixRingImpl {
+	uint32_t write_head;  ///< Read index into buf
+	uint32_t read_head;   ///< Write index into buf
+	uint32_t size;        ///< Size (capacity) in bytes
+	uint32_t size_mask;   ///< Mask for fast modulo
+	char*    buf;         ///< Contents
+};
+
+static inline uint32_t
+next_power_of_two(uint32_t size)
+{
+	// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+	size--;
+	size |= size >> 1;
+	size |= size >> 2;
+	size |= size >> 4;
+	size |= size >> 8;
+	size |= size >> 16;
+	size++;
+	return size;
+}
+
+ZixRing*
+zix_ring_new(uint32_t size)
+{
+	ZixRing* ring = (ZixRing*)malloc(sizeof(ZixRing));
+	ring->write_head = 0;
+	ring->read_head  = 0;
+	ring->size       = next_power_of_two(size);
+	ring->size_mask  = ring->size - 1;
+	ring->buf        = (char*)malloc(ring->size);
+	return ring;
+}
+
+void
+zix_ring_free(ZixRing* ring)
+{
+	if (ring) {
+		free(ring->buf);
+		free(ring);
+	}
+}
+
+void
+zix_ring_mlock(ZixRing* ring)
+{
+	ZIX_MLOCK(ring, sizeof(ZixRing));
+	ZIX_MLOCK(ring->buf, ring->size);
+}
+
+void
+zix_ring_reset(ZixRing* ring)
+{
+	ring->write_head = 0;
+	ring->read_head  = 0;
+}
+
+static inline uint32_t
+read_space_internal(const ZixRing* ring, uint32_t r, uint32_t w)
+{
+	if (r < w) {
+		return w - r;
+	} else {
+		return (w - r + ring->size) & ring->size_mask;
+	}
+}
+
+uint32_t
+zix_ring_read_space(const ZixRing* ring)
+{
+	return read_space_internal(ring, ring->read_head, ring->write_head);
+}
+
+static inline uint32_t
+write_space_internal(const ZixRing* ring, uint32_t r, uint32_t w)
+{
+	if (r == w) {
+		return ring->size - 1;
+	} else if (r < w) {
+		return ((r - w + ring->size) & ring->size_mask) - 1;
+	} else {
+		return (r - w) - 1;
+	}
+}
+
+uint32_t
+zix_ring_write_space(const ZixRing* ring)
+{
+	return write_space_internal(ring, ring->read_head, ring->write_head);
+}
+
+uint32_t
+zix_ring_capacity(const ZixRing* ring)
+{
+	return ring->size - 1;
+}
+
+static inline uint32_t
+peek_internal(const ZixRing* ring, uint32_t r, uint32_t w,
+              uint32_t size, void* dst)
+{
+	if (read_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	if (r + size < ring->size) {
+		memcpy(dst, &ring->buf[r], size);
+	} else {
+		const uint32_t first_size = ring->size - r;
+		memcpy(dst, &ring->buf[r], first_size);
+		memcpy((char*)dst + first_size, &ring->buf[0], size - first_size);
+	}
+
+	return size;
+}
+
+uint32_t
+zix_ring_peek(ZixRing* ring, void* dst, uint32_t size)
+{
+	return peek_internal(ring, ring->read_head, ring->write_head, size, dst);
+}
+
+uint32_t
+zix_ring_read(ZixRing* ring, void* dst, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+
+	if (peek_internal(ring, r, w, size, dst)) {
+		ZIX_READ_BARRIER();
+		ring->read_head = (r + size) & ring->size_mask;
+		return size;
+	} else {
+		return 0;
+	}
+}
+
+uint32_t
+zix_ring_skip(ZixRing* ring, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+	if (read_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	ZIX_READ_BARRIER();
+	ring->read_head = (r + size) & ring->size_mask;
+	return size;
+}
+
+uint32_t
+zix_ring_write(ZixRing* ring, const void* src, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+	if (write_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	if (w + size <= ring->size) {
+		memcpy(&ring->buf[w], src, size);
+		ZIX_WRITE_BARRIER();
+		ring->write_head = (w + size) & ring->size_mask;
+	} else {
+		const uint32_t this_size = ring->size - w;
+		memcpy(&ring->buf[w], src, this_size);
+		memcpy(&ring->buf[0], (const char*)src + this_size, size - this_size);
+		ZIX_WRITE_BARRIER();
+		ring->write_head = size - this_size;
+	}
+
+	return size;
+}
diff --git a/src/zix/ring.h b/src/zix/ring.h
new file mode 100644
index 0000000..f7f1893
--- /dev/null
+++ b/src/zix/ring.h
@@ -0,0 +1,130 @@
+/*
+  Copyright 2011-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_RING_H
+#define ZIX_RING_H
+
+#include <stdint.h>
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Ring
+   @{
+*/
+
+/**
+   A lock-free ring buffer.
+
+   Thread-safe with a single reader and single writer, and realtime safe
+   on both ends.
+*/
+typedef struct ZixRingImpl ZixRing;
+
+/**
+   Create a new ring.
+   @param size Size in bytes (note this may be rounded up).
+
+   At most `size` - 1 bytes may be stored in the ring at once.
+*/
+ZixRing*
+zix_ring_new(uint32_t size);
+
+/**
+   Destroy a ring.
+*/
+void
+zix_ring_free(ZixRing* ring);
+
+/**
+   Lock the ring data into physical memory.
+
+   This function is NOT thread safe or real-time safe, but it should be called
+   after zix_ring_new() to lock all ring memory to avoid page faults while
+   using the ring (i.e. this function MUST be called first in order for the
+   ring to be truly real-time safe).
+
+*/
+void
+zix_ring_mlock(ZixRing* ring);
+
+/**
+   Reset (empty) a ring.
+
+   This function is NOT thread-safe, it may only be called when there are no
+   readers or writers.
+*/
+void
+zix_ring_reset(ZixRing* ring);
+
+/**
+   Return the number of bytes of space available for reading.
+*/
+uint32_t
+zix_ring_read_space(const ZixRing* ring);
+
+/**
+   Return the number of bytes of space available for writing.
+*/
+uint32_t
+zix_ring_write_space(const ZixRing* ring);
+
+/**
+   Return the capacity (i.e. total write space when empty).
+*/
+uint32_t
+zix_ring_capacity(const ZixRing* ring);
+
+/**
+   Read from the ring without advancing the read head.
+*/
+uint32_t
+zix_ring_peek(ZixRing* ring, void* dst, uint32_t size);
+
+/**
+   Read from the ring and advance the read head.
+*/
+uint32_t
+zix_ring_read(ZixRing* ring, void* dst, uint32_t size);
+
+/**
+   Skip data in the ring (advance read head without reading).
+*/
+uint32_t
+zix_ring_skip(ZixRing* ring, uint32_t size);
+
+/**
+   Write data to the ring.
+*/
+uint32_t
+zix_ring_write(ZixRing* ring, const void* src, uint32_t size);
+
+/**
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_RING_H */
diff --git a/src/zix/sem.h b/src/zix/sem.h
new file mode 100644
index 0000000..1fea796
--- /dev/null
+++ b/src/zix/sem.h
@@ -0,0 +1,237 @@
+/*
+  Copyright 2012-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_SEM_H
+#define ZIX_SEM_H
+
+#ifdef __APPLE__
+#    include <mach/mach.h>
+#elif defined(_WIN32)
+#    include <limits.h>
+#    include <windows.h>
+#else
+#    include <semaphore.h>
+#    include <errno.h>
+#endif
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Semaphore
+   @{
+*/
+
+/**
+   A counting semaphore.
+
+   This is an integer that is always positive, and has two main operations:
+   increment (post) and decrement (wait).  If a decrement can not be performed
+   (i.e. the value is 0) the caller will be blocked until another thread posts
+   and the operation can succeed.
+
+   Semaphores can be created with any starting value, but typically this will
+   be 0 so the semaphore can be used as a simple signal where each post
+   corresponds to one wait.
+
+   Semaphores are very efficient (much moreso than a mutex/cond pair).  In
+   particular, at least on Linux, post is async-signal-safe, which means it
+   does not block and will not be interrupted.  If you need to signal from
+   a realtime thread, this is the most appropriate primitive to use.
+*/
+typedef struct ZixSemImpl ZixSem;
+
+/**
+   Create and initialize `sem` to `initial`.
+*/
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned initial);
+
+/**
+   Destroy `sem`.
+*/
+static inline void
+zix_sem_destroy(ZixSem* sem);
+
+/**
+   Increment (and signal any waiters).
+   Realtime safe.
+*/
+static inline void
+zix_sem_post(ZixSem* sem);
+
+/**
+   Wait until count is > 0, then decrement.
+   Obviously not realtime safe.
+*/
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem);
+
+/**
+   Non-blocking version of wait().
+
+   @return true if decrement was successful (lock was acquired).
+*/
+static inline bool
+zix_sem_try_wait(ZixSem* sem);
+
+/**
+   @cond
+*/
+
+#ifdef __APPLE__
+
+struct ZixSemImpl {
+	semaphore_t sem;
+};
+
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned val)
+{
+	return semaphore_create(mach_task_self(), &sem->sem, SYNC_POLICY_FIFO, val)
+		? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+static inline void
+zix_sem_destroy(ZixSem* sem)
+{
+	semaphore_destroy(mach_task_self(), sem->sem);
+}
+
+static inline void
+zix_sem_post(ZixSem* sem)
+{
+	semaphore_signal(sem->sem);
+}
+
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem)
+{
+	if (semaphore_wait(sem->sem) != KERN_SUCCESS) {
+		return ZIX_STATUS_ERROR;
+	}
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline bool
+zix_sem_try_wait(ZixSem* sem)
+{
+	const mach_timespec_t zero = { 0, 0 };
+	return semaphore_timedwait(sem->sem, zero) == KERN_SUCCESS;
+}
+
+#elif defined(_WIN32)
+
+struct ZixSemImpl {
+	HANDLE sem;
+};
+
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned initial)
+{
+	sem->sem = CreateSemaphore(NULL, initial, LONG_MAX, NULL);
+	return (sem->sem) ? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+static inline void
+zix_sem_destroy(ZixSem* sem)
+{
+	CloseHandle(sem->sem);
+}
+
+static inline void
+zix_sem_post(ZixSem* sem)
+{
+	ReleaseSemaphore(sem->sem, 1, NULL);
+}
+
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem)
+{
+	if (WaitForSingleObject(sem->sem, INFINITE) != WAIT_OBJECT_0) {
+		return ZIX_STATUS_ERROR;
+	}
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline bool
+zix_sem_try_wait(ZixSem* sem)
+{
+	return WaitForSingleObject(sem->sem, 0) == WAIT_OBJECT_0;
+}
+
+#else  /* !defined(__APPLE__) && !defined(_WIN32) */
+
+struct ZixSemImpl {
+	sem_t sem;
+};
+
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned initial)
+{
+	return sem_init(&sem->sem, 0, initial)
+		? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+static inline void
+zix_sem_destroy(ZixSem* sem)
+{
+	sem_destroy(&sem->sem);
+}
+
+static inline void
+zix_sem_post(ZixSem* sem)
+{
+	sem_post(&sem->sem);
+}
+
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem)
+{
+	while (sem_wait(&sem->sem)) {
+		if (errno != EINTR) {
+			return ZIX_STATUS_ERROR;
+		}
+		/* Otherwise, interrupted, so try again. */
+	}
+
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline bool
+zix_sem_try_wait(ZixSem* sem)
+{
+	return (sem_trywait(&sem->sem) == 0);
+}
+
+#endif
+
+/**
+   @endcond
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_SEM_H */
diff --git a/src/zix/thread.h b/src/zix/thread.h
new file mode 100644
index 0000000..b007efa
--- /dev/null
+++ b/src/zix/thread.h
@@ -0,0 +1,133 @@
+/*
+  Copyright 2012-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_THREAD_H
+#define ZIX_THREAD_H
+
+#ifdef _WIN32
+#    include <windows.h>
+#else
+#    include <errno.h>
+#    include <pthread.h>
+#endif
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#    include <stdbool.h>
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Thread
+   @{
+*/
+
+#ifdef _WIN32
+typedef HANDLE ZixThread;
+#else
+typedef pthread_t ZixThread;
+#endif
+
+/**
+   Initialize `thread` to a new thread.
+
+   The thread will immediately be launched, calling `function` with `arg`
+   as the only parameter.
+*/
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg);
+
+/**
+   Join `thread` (block until `thread` exits).
+*/
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval);
+
+#ifdef _WIN32
+
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg)
+{
+	*thread = CreateThread(NULL, stack_size,
+	                       (LPTHREAD_START_ROUTINE)function, arg,
+	                       0, NULL);
+	return *thread ? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR;
+}
+
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval)
+{
+	return WaitForSingleObject(thread, INFINITE)
+		? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR;
+}
+
+#else  /* !defined(_WIN32) */
+
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg)
+{
+	pthread_attr_t attr;
+	pthread_attr_init(&attr);
+	pthread_attr_setstacksize(&attr, stack_size);
+
+	const int ret = pthread_create(thread, NULL, function, arg);
+	pthread_attr_destroy(&attr);
+
+	if (ret == EAGAIN) {
+		return ZIX_STATUS_NO_MEM;
+	} else if (ret == EINVAL) {
+		return ZIX_STATUS_BAD_ARG;
+	} else if (ret == EPERM) {
+		return ZIX_STATUS_BAD_PERMS;
+	} else if (ret) {
+		return ZIX_STATUS_ERROR;
+	}
+
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval)
+{
+	return pthread_join(thread, retval)
+		? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+#endif
+
+/**
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_THREAD_H */
diff --git a/waf b/waf
index e22930a..82cf344 100755
--- a/waf
+++ b/waf
@@ -1,16 +1,169 @@
 #!/usr/bin/env python
+# encoding: latin-1
+# Thomas Nagy, 2005-2018
+#
+"""
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
 
-# Minimal waf script for projects that include waflib directly
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
 
-from waflib import Context, Scripting
+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.
 
-import inspect
-import os
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
 
-def main():
-    script_path = os.path.abspath(inspect.getfile(inspect.getmodule(main)))
-    project_path = os.path.dirname(script_path)
-    Scripting.waf_entry_point(os.getcwd(), Context.WAFVERSION, project_path)
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 AUTHOR 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.
+"""
+
+import os, sys, inspect
+
+VERSION="2.0.9"
+REVISION="052b461396977f83e2fa8290956322ed"
+GIT="x"
+INSTALL=''
+C1='#8'
+C2='#7'
+C3='#&'
+cwd = os.getcwd()
+join = os.path.join
+
+
+WAF='waf'
+def b(x):
+	return x
+if sys.hexversion>0x300000f:
+	WAF='waf3'
+	def b(x):
+		return x.encode()
+
+def err(m):
+	print(('\033[91mError: %s\033[0m' % m))
+	sys.exit(1)
+
+def unpack_wafdir(dir, src):
+	f = open(src,'rb')
+	c = 'corrupt archive (%d)'
+	while 1:
+		line = f.readline()
+		if not line: err('run waf-light from a folder containing waflib')
+		if line == b('#==>\n'):
+			txt = f.readline()
+			if not txt: err(c % 1)
+			if f.readline() != b('#<==\n'): err(c % 2)
+			break
+	if not txt: err(c % 3)
+	txt = txt[1:-1].replace(b(C1), b('\n')).replace(b(C2), b('\r')).replace(b(C3), b('\x00'))
+
+	import shutil, tarfile
+	try: shutil.rmtree(dir)
+	except OSError: pass
+	try:
+		for x in ('Tools', 'extras'):
+			os.makedirs(join(dir, 'waflib', x))
+	except OSError:
+		err("Cannot unpack waf lib into %s\nMove waf in a writable directory" % dir)
+
+	os.chdir(dir)
+	tmp = 't.bz2'
+	t = open(tmp,'wb')
+	try: t.write(txt)
+	finally: t.close()
+
+	try:
+		t = tarfile.open(tmp)
+	except:
+		try:
+			os.system('bunzip2 t.bz2')
+			t = tarfile.open('t')
+			tmp = 't'
+		except:
+			os.chdir(cwd)
+			try: shutil.rmtree(dir)
+			except OSError: pass
+			err("Waf cannot be unpacked, check that bzip2 support is present")
+
+	try:
+		for x in t: t.extract(x)
+	finally:
+		t.close()
+
+	for x in ('Tools', 'extras'):
+		os.chmod(join('waflib',x), 493)
+
+	if sys.hexversion<0x300000f:
+		sys.path = [join(dir, 'waflib')] + sys.path
+		import fixpy2
+		fixpy2.fixdir(dir)
+
+	os.remove(tmp)
+	os.chdir(cwd)
+
+	try: dir = unicode(dir, 'mbcs')
+	except: pass
+	try:
+		from ctypes import windll
+		windll.kernel32.SetFileAttributesW(dir, 2)
+	except:
+		pass
+
+def test(dir):
+	try:
+		os.stat(join(dir, 'waflib'))
+		return os.path.abspath(dir)
+	except OSError:
+		pass
+
+def find_lib():
+	src = os.path.abspath(inspect.getfile(inspect.getmodule(err)))
+	base, name = os.path.split(src)
+
+	#devs use $WAFDIR
+	w=test(os.environ.get('WAFDIR', ''))
+	if w: return w
+
+	#waf-light
+	if name.endswith('waf-light'):
+		w = test(base)
+		if w: return w
+		err('waf-light requires waflib -> export WAFDIR=/folder')
+
+	dirname = '%s-%s-%s' % (WAF, VERSION, REVISION)
+	for i in (INSTALL,'/usr','/usr/local','/opt'):
+		w = test(i + '/lib/' + dirname)
+		if w: return w
+
+	#waf-local
+	dir = join(base, (sys.platform != 'win32' and '.' or '') + dirname)
+	w = test(dir)
+	if w: return w
+
+	#unpack
+	unpack_wafdir(dir, src)
+	return dir
+
+wafdir = find_lib()
+sys.path.insert(0, wafdir)
 
 if __name__ == '__main__':
-    main()
+
+	from waflib import Scripting
+	Scripting.waf_entry_point(cwd, VERSION, wafdir)
+
+#==>
+#BZh91AY&SYË»—˜¦ÿÿ°
ðÿÿÿÿÿÿÿÿÿÿÿÿÅ°‚„ 0�
˜�(bK¼÷½»0#&#&#&#&#&#&#&#&#&#&#&#&#&P#&#&#&#&#&#&#&#&Ö÷×—·�Ú㛦ÖΗ½�²ö«¦šîâ6¾w»eíÝ7Üë˜#7o’÷uUOwkéêݽîvòuíʧm¬Ù©»™Ý»ížÀû×ÞŸo¶à›ÙëžÅèÓC �×½îZÞì÷ì2#7U°�žm»¯^’ìè÷Íï§Ã's}žoºóá÷œ®·]niAåîë.ݼönt#7[>=¾×Ö{�>ûwÒ¸Emí9�»íó°#&#&#&ûì#&#&ì#&
¥Q€ô#&ézð
ÝŒ¾ó€¶÷mØ6�Û{g½mìo h#&4�\íZîØ:PFŽØ&Ài!ZÐWlS@Û,#&Ô�D”¥(#&½î”Š$ƒ@j”†ª@{f¶ÝÚ�Ÿ}»^�4ûºãgß}Ͼw´ÍÁë¼Þ¹Sw8¥Ô6Ä"+l±jï¯�èÃॻ}‹i­w¾s{}¬wl=½ìöîÎ÷:ú7“}ö<óßzíw¹¬{v{›oFH··ÛzUöªÙó´š÷:÷�íovØôj¥K°h°©!)µ²‚u•]bíÛÝjÝï]Åž÷d^ƒ¦á£¦ØâTER¥¯niÅ*‚€A#&’°ÐÃRœ8jŠw·½½�qÛlöÝw�J•}ÀçÛ¼ø¾ûîùß=¸elÖÞæÞîÓ;mj–í×½“©•_keIëåÈ•¶¾ÃU^{{u³4ò·]„[g³}öã¼ÝëVÚuÖÖº®ñÞÍn�ÖŠÁ¦Z(ûººª[ë8Ô^ë¼ÝÜôëÄå½}�ôõÙ¤Lu÷yrš£Ýºî¾ås¯S‰±Üsªî´îº«9Û›)O›¼Ý¾•íî#8[ÑË+²ëßxô½Ó³»¾œìâ9vÆÛ\ÛÖŠzÜض+œ#7�ß#7TöÒ.±Åk.|øÏ{Þó¶Þ÷½êõÓ¯›=zÙؘ\îÚÑÞß]ê‘/®·cÛ3U/s¦ë(-ÂgôÝÀ
·³,ïoyŽå¾æž7eíxtB…
AQ;jR#8©°VŽíÓw]Í$:ëM‚¤Œ7#&š4ì6ÂŒ&ù�ïiEzšŽÝºd•Ž°½x{Ì8ÑzÍ%CÕÖÌzmÝO#&Õ(]ï;ÑH#&VóÛmuw_;wµóÏ]}޽루}ìܾν+ݸìwl}ÖÛ»²†WK¹Êân½;Û;Øê§É¾›ÛWËu5[M͇aG >˜¯2¼÷ÛŸVúök·s�o‘k4kv¶¯,Ñêƺ—µíí›�SÛ#7ŽÖí�\k:Úcí½<ùäh}íËÖåÆyÎí¥éÏ{Ûx;­Á�oO;Ë»Ž»¤zå÷ß]¾Ý·XP×p7và#&}:kÒ–Ýìá.ÚÞzv3»@ëíÎ@שõN꛳ÖJï^î§z®¾÷=ö€”#&Um©¦Šo½t·níÛ¸�1}÷w¾»9¬^žp­¯¦}îßxêö˜ðù½Ú¯q�Ût½{·Ö·Ä.÷·Ü¸ú¼ßvÑÓ£Aô#&{ªÊ»-ª©¥í›^çs}ÝÛTÙ|Þ#&:ïcŠêV4ëÞsÏçÆû#&Þo:¯AÒ‹w#7,5í·oyT
œ=uuï9}´$úí´.à
"ËÓ}½ïrk`—ÛG1â²www4ûš}ywm4×/yÕêš÷4œZ@*E»W:³6͵'Nîë“#8�;£êm7Ë=zâÝu×V#&û·‹W¶¶ów½¾Yx�«²–ìû·¾tgMQ&©Auó½P®ðÇ4ÍÞìîwj^µ×¶î³îݹ|û±ª}jÍ,Ó�<]qé[×O }­ñ]†š #&L€#&#&#7#&ÔÓIê�¨OÔšPõHÐ4zA) B  
I‘ŠjlTý2ž¨ÛRhõ4ÓF‡¤Ð= #&#&#&#&
 ‘ „ɦ€MTô›$¦Ù4šžSÊ›$6L¦'‰©£ÔÚ€#&#7#&#&
'ªRHš§ŠzÄô�56šš#&F È@ÐÐhÑ£@#&#&#&#&
#8HAb#&†€#B4M£HÂ#&Ôôjz(y#Ôñ€#&#&#&
&¢ €@È#&¦ÐCBiª�h0©¼†©úOÕ'”ó*PhÂ#7
 #&áÿìþµµk·þ×wEVºü«O‰�&#87ŵkº$€Z�¡XH¸TÈP@ >UÔHB?Iú¿ÎÏÏ/ÎW7uÌÚß´šnäÛ¹Å)©Ô�5Š±Ëºšºµ‹€Œÿ”_þJLrÌ×´ͳЀ‡E¤«€#‡lZß$Ú1¨Ù4X¼pD¾]çÊ•X§­¦ˆŠ"'#ÌaîiÕ>›ª!â•I‡Ã¸ªo¥tø{}¶fèåøýb¢fRP!I…ƒ ÀD•#8)P	•dTˆD6…L�rQÈA(EqA$Ar&Œ<|°Ð…$ §37ƒT §‚EC@$ è…B û! **@¡˜……@Òîf(fˆÉBff*‚³5šbl0D±AD’I±©˜™•	ªeŒ€LiJ4¢›i#„„Í
’PFBÔ´m�A…´f’É¥‘ˆÃ	´b1QˆÈ›JPR#&k–4 i‹˜ÅJI›H¤Ù-Q%–ZSZ##8ˆ…–�Ù ˜,¤Í2ŒV5ŠÑ€h4› B(J“b˜ÒP&4Í2Ò1�¥cR”l%´Ú¶jÖ‚Ä#8Bj†lI£3$ÈMA–M´ªÍ6�5%)*kc-KlÍ™i2šJHÑ¥„5fŠIK#8YXÅ2B$Ê‹4ŠÅ&ÅD‚6)5"Df•‚¥1Š6!PHŒ¥†Dd‘µ&!Xˆ!fhJ"$P€ˆe ³F•š3FD#7lŠ"–Md¢Œh؆‘b,¤$lk)I	Š$¤ÈÁJ$"2hQÄ‚¤Ñ¤J1¤�5�¨Å‰"ÀQ3)´ÄS0#7�²C1D	ŒÓLØLбRlM•„"À‰%&Åb"KE�– $M¦(”#7ˆ˜fÉ)Âf„ÊIIX³*65„´š’$˜„BZR¤	dY-ˆ	"Ë2ŠE™&‰³)±ˆ“bdE(Í‘0LªiŒ��)`³QR$iˆÔ¬–HØ6T„Ñ"–I	Ô‰šj@±¢Ô!$„³)²Œ Å¢™šFÑ"¦–(›j`±Pi,ÆB1d¤²$˜‹Ó0¢”Q£0™¨¦…&*#7‚$H$I˜À’HÑ£&XLPFÉ2¦f¬ÆŠ¥*‰DLÈjF˜†�±R†ÙM$h¢RI&Éj4d©²-3E�ˆ¦“)3)ŠYY´È•ˆŒ%d)©¤Ó$†2ˆÒš-6ųR¥2aLLHlŒ‘“$¥`4XÉXŒeIÌEcI¢M%MFɨ²I4��1Á2Ù¤ÄÚ#7*`Í0šL¢ˆ±¦d6dI)²S#J	›&BZÍ•‹XK
‘1&™d‰,[F±¨5ˆ¦[#8D�%ؤH0Œ£RX´i†S4Ò˜6JÊiLšÒA¡$Å)1˜B†Y6De0H¦Ê�2ÂÒ ¡2&dD‘¢mµ*¶Œ¡’„´ËLÆ&”RJf"+A©K`RÍb“Le	e•6Y6 ‹S-…³F&¦Äe(–BSkíõÛdBjj�FÆmb£[É4i5²H¥”ÑE*5¢ii#8‹FÂ*I¨ÚÈŒÔj2ÉŒ£$YL©1ŠÈƒLÍ)¶eXŒLÒ¡lmE!hɦ,eRI™Q¡ci#8Vh¦L™i6ƒceXÛ�6P�¬‰–ESÍE0¦ÍŒ¤ÌÛ%´Ñ1£kE‹"5²išÉ%L²›Y5¢›e)M1³Ô�$d¤mEŠk,I¤©5´U`ªŒ!Q¢¶Œ•ckÒk%Ôm%Ñ4DÉEˆ´EŠ´l2ѵ‹m&’†ˆKT0’ŠA6ƒ!i’bVšÆÁ¬hÚb[¤°h¶’#7µªkm›4ª†Be3SVMlŒHD¦¡Y#[RÖmŒP%%a’i’Y@˜¢…eRÈ™š¥HÅšh�[C ÌÉ2ÙcBi”†’ɶVT…£Z%”c‚0‘QbCLƃ˜±`a`�b$H†ÐXLb-¦j™�	QC%´•’icdÉ¢�‘eŠE6R�‘š‘Dˆh”Ì’Â’‹1¦`bjZ6Ì�ˆÊÅ6“%�dJB3L‰’B#2`,(Q”M¦ ²A‰…¤ ƃ%´X¢iLŠb̳JØLbPY1Ša)d™d„ÔZ2b£LµQ³)$£ …Œ…Qe+#L6Š“’Œ›#’-,$Q’±¤H@hÒŒšM&̦̤¥™YJJÅ0hh²F¢Ô’´U5£4Ea¢¥4›#71²Æ³(Ú�FB2Å ÓbJ“i2…)¦*H))l”Ê� ªeM’ÉRe	Š‰4’"%#7(É´É-£["6"™™)`ÄHlÙŠ"6 Öih�¬Òl†b&ÄÄMI	£F‹a**5cV3-†“P’†B‘¥“#c¢Ø£`MAYfÉd2AbјY)²$©"#7´TV5EcDš6	J£IA±A’6MQh4˜J!…„¥(jcL2¥*�QSM,…X“&Ù’Z$Z‹±KU-4UÆ“E’Ä‘M2•˜V, Ì	#&˜™%M‰DL­¨Š°IŠ™¨©-0¥ij2V-m&)+4ªFm£hšÉ)�̦¤°� ,*J6MDbJ¤¤5ŠLÈ#³ h!¨²•2¦"›jJÉlÈ)#8i&£A`¢lÖ“h¶RK&4˜Ñ‚4bÀRH­J#FÒËE£k[h«FR�¤ª‘-FÚ5%)Й%23cMH“©›$ͨÔU%‹T•,«&´%h¶5!EEB­ÊÉ#8-	H…-#8É™3e–[+mE™QµM•¥©E1©(22“S%cE‚$Ñ¢ŒM&m¶53bH±I[MJi¬µ�c4�£&4Y,mm²¶±H™´MLIF1PÂÄQ±M$­21’U�±m‹LÕ´cZËISC-l¥“mMM²Ôi«FQDEŒÑY%#7f¤ÔmŒÍ›*"„ƒQ’L¤™‘Dd#8¤¶ŠelÇèÿWê×è-¿¦üÁìmî¹_ãAÿfŽ¶ýÕ8™jlÃDà“tþ`¸uŠ¹X4i6|'~‡v+ÇøáÚ`œÊÈÌ?íë¬é£þ)Šq'Žävÿµ8Ä£@ÁŠƒãŒ#8X.ˆªª#8ª $˜*ƒqÃæØÑ8þ*¤׬3ÿ¯éµ£ÿA%¦¼dÆF_°‘ˆ¾Žz4ŽÅ·8=k`¡âpöâéŸ:ËK¤ïºœ™–Ù–î£UÉÇÍÛRR(l“ŠrrXĶº:ÓåÄ›'ú©öd­M@$ŽÒðÈ›zw¦º3Ù®y94uÙ;Îé	™ª™¤ÍåÂ’*ÕU$Kh¿Wl�È¢˜–®12h.³Äï�¸Ó¼†FA’
@°ÍÏZµ@;XÆ‘œ@#»"ÚaËQ¤ã+ÓsI`Ù#%¯=y¯KÖbYÓA¦Þ¿ïhÐd!ÒÚ»äÉE$Óàï‡uâÞ5äÑ⸗̹¤†ô‘`±A‡ýõ¢Ï¦+Q2ìØŠ)„)´)O9+ïrH¦4¯`[#x¹•I)ÃñÒ¯ƒþñ‡d,x»¡j4AŒ1›™=ÇÕÿ½:®o¤¨¬åBum6ý�¡�`{|XƒZµY46ÓÔ²^dÇ.]qL®mÒÈj#&Épµ˜PÒÐ^f]BRl[ì÷WÆßi^ª×"™¯‰È­¼\Þ:Dýí«Ç.nÅñõk‰aß¾a½§™*#6ÌziÙÛm6‡×¬S‰Úâ@2H”¦Ì2#8Õ“OiÏ1á$Ãz”eaÛÐÚÛ�5×+¼îÅÊ:W.d¢—]„DVY1P{%MÇþsúÌÑÊ1yF%Á†,RlFVysÛ{�ÎÁ–¬#8üè¤OZ#7?ƒS•µ?[Óx)Ÿòã�s—»��U!Pm‰ÿV9FÌ„›„õã¶�ïÏ„ ‰ŠÑ>öâÐ1Õù^—Ël_ø™(nˆªjËah#¹Qo›#be|Eì»Ùk’Ee4=g(Ç�Û^q>>í_Bå,rpÕ{x˜F»¾õMÙ%ó¯e×e™�b¶ôÖðø+É­«äÃ8¡e òªŠSã¯Ý~®yßC½;nÖéÊϧ$ŠmBÚD¬èœ{ãZÎ�ky(¤Ÿ“Œ[rÉ„lÈFÏ6J‡}ÖŒÐñвÓ,YL-…§F•ŠPDsžw�½ùâ§Ur‘tMYeUS)>ÌZ‡4›ÆI _™”(ûBiòë;ºöï<þZ¾fòbÞ—LÏÏv†`ÅãEtP°è}T!¾klJÕòO:riêët÷9îWžºzÇ@ÌrÐ"¾lÍí¥bz2µñ®¬Æ”Õ
TQW�Ë&£x娫cð»yKÎÀ‰MàÈbj/»Ïöè;÷Á¤»«siBä÷þ7›^”l‰ŒbI5%'½ÍÊïs¶­ÒéÊRtNìPL	ªrºÊREÂR¨ÁJMÍE¶ó¾÷zõy4¤–ÒT=×rÅ¢¾ä·^çcëõÆ6Å{pã–Σä#9faXd´%,@|�¢¯´K}W@�>.¾60úr{÷ÍX#7èqdDh#�~"Tcüª.}K¢1‰¥mfÌüRL ƒûš/†ŒÔJÄŸ$dDxæ!ÒΖ’g‡]¶±!’œƒÈNv¡­`dYMFX'm�ǦÀ|ÒC•uÄÚÐõ£Ñ1ºQL¡—UiH¯mêÖFþº¹æè›ùÖS“–[4ð«)"£
N)³#7D-š´�D•Q­g:Ä®ÂãìŠ4wh�-´´Õ¼ÛÚ^* ÆÏHEúZg.Í.¦¬¬2*$ð‡¬ûçj".Ù%HyE#&gºFŸ‰õ»ñ�ëÛ>2ñ&±@B9XA®îø–¨vÃŽ2LÜ/gõ¹ì®	bÙZ!ºlárîiEIÑ~pÕvÃ³Ü l†Œ4ëÏ#7#8F¤
)3#83(Ò™ö>e}mòwzˆýó°ê„Á÷avˆ±ž/•Ó¸;PS{×$0òª§f\ÊRÕB‘&�ä…E8Õ*m]*��;>7ãg#8£�õÉYJéå›øä f¢��Õ€²·1nŸ+n+¾i„—"nHÉ4Ñ,íaõå» Â	·�Ͻ5Ýæ^\÷¬¦J½ÏR왲#7“Íš;}*nã�=*�Êj½(Q9s¾(qaÁÑDæÑ÷2…<öë}~O'SQœœ+ŒÛfZô|æ¡|sÅr_4ê…©ÔÆ$øû]#ïåÅâƒÆ?FÚU#?4€u�õIÈ�1~Iïf0Y´C{†²}§}
n•I›-øWm„‘y²…ëÑÌuǦhÉËÑǤjLC:_DéC‰ç./{Â&½>¼MïuXaãH�ÕÄŒá—­¹ãZ=›{Êeƒr}J‘‰ýs‘ë¶ÌÐWéÖã�BªÂ5ð™HΞk²¡ºP’ÅÅPŒ*�÷ý—}É‘›©®»¡Š¥º0Œã³`Ä…!B�Õ³s­8(rbãŧ§�«¡òþˆŠuhBÁ»�$J3âç)«w¸puôM×5²’ÝŒýîJ)�Ó
Â2¸œŠ=ýÙLiÈ,­†�§EbÊ¡?ØGÅß®Õ3�±O]\ƒñXÈçÜd=ÞÑ1TR¬xû·¯u“G¦.æק›�AƨŠÍ†#8ÃÚ¥"ï¾×<C}%®”ѽ֫ƒ¶*#7·©4ÑãÔâí¢ã^çnèF6�ÍÕ§_°é#8pÏÆÛü·O‹#7s?\#8ߟ‹áã²I"5•PgO»¦,O�ZR?:Œu§ÌAWðÉ£{˜H?<Õõ#ˆpHÒü˜ÚŽÂ'ã¿ÎŽ›=Ü)ôO‡M3Œ&äûHK}ý°)ïé¼íuHÑèÑéÒßÚãÞB鑆œÜ��iÂòµ·ßü´^Û%$ƒbÛj„$ED…NÖG×ìvú¢›Ý|©Æ8v³™«óSq®ß^/–Cd5R(7IöÈË}ü«»Ù\.µzûw0
ŠZ…l…ÙB£I%Kèw‹yô�cO»îCrºõ×aò·¾�WSVBWᮋÓFxYnÍy´Ì²…º¥ª˜¾øðYa“OKÿ¯Íüÿö�KO§éãxæÓùUE~,>ô¶)ò]·Úë¼EX�Cçë›ð[éÄyq{:¾N·_V[•#7ŒÉ2®Q‘
HñPæ)Äñ–zâ‚úfìd‘?ÒÖÚ¾pèÝÂJmĸ`çk¥AŠ¬Ô@צgÃ1åSK¯š]‡]ç-kY¥¬˜Â}ykw¤4Ìü¡Kì>FwcK(º¥A€¼ê"ëóK²™â›3îOG¶Û[q?*9c-¥>ùJ»Å{ÏC’.N #8Am0œ}q¹ü37�ÜUÒ©A _y#&·*¾²qaÛqõ矛\÷ýt;4mJUQ_ܘÇ¿7e‰š«…Ø›IÖ§ÒÒ;9Ž.%=û†ŒgßÕÕ>ÍûwÀöÑ£îaTxíÛXâ|=_Z¿1ÕÙÓ{µ¶Fýxóܶ»°0¥(óï4ýn(ø—¹�jç9#7ø0¬ ¼CµŸ4ðd¸±(PrÔÈ)Ž¯LV¾…—د4Æ™îé�·‡²¿FaŽÍjÔðd�é´�Åt;‡�ãTÅ"�òjôŸÔM#/»úè†9U/&mrSßé½Ì>§ÙF7̹–À‚‚óçš�®™g—ftgv"ŠŠrL{%¶ÑÝwL<“|�LuO#71l8¥>Ô¦re)4®—³c½qºÅQŽu%Š¬Ï¾ª$yóÚ#7tz²8ï5›`Býìñ5£î½î³EÒ„A:T8ðhÝ)UžL Ƙä1¸N>9{÷¥Û;SþN!óuˆQÁjCÀcQé“+yÊ#8˜é=󌘂ÓÎs×ËawÛ(WnN¦I0å‘H¤œ_Úùù»ìŒ Îx‰«æ�øögò4.:.«ƒ�@elÚ2ÅyÒnFC‘Á†&…	í¢ˆS;f}š?*”q¬¥±9<‰Íó»íëYÆ5¨$EbZRáɬE‰-ugc Ÿþã±zw\îó£˜ßŽhÍÂÖ\ZyLht™Ï’Ê‹‰ÇÆœYÇY’óIúE¼Km·¦¾F”Ô'/i™Œ™¶"�ÖÿÔYñ>­X(EB¸Ô7Cui+YuÏ7àî9qõ’;A̤ŠšiÚLÖ÷ã„’Ä£–ÐÄß~9’`•ßί–IC÷5ãé(,EP·ª²øfæ¹É-å¢,¡*ÂiHåúÐÒÿ©}¨{>ºù¾É¸ÛˆnwyGø)‡áEüUmPƒ”†.¸4ÛÅ#7¸Ñ‡ƒ£†Ü'�@»eÅÂ%)´&Êù'§ç‡8Ì�¯›Ž]ÄšS!3ø<¦„¼gZª-Ç_ÌËQ°ãw·ÏyÏZÀtJÞ\lt߆îcòzXT/‚6�(5ì‰E.;@¬·Ò¢1þØxÖµ—¯ž\ß6Ý–;ôdáKáCNtN	ï5£˜^E^£œÚj@ŠémGÙ%–<ùÚvãÒ5æú÷stX§ÉÛbA;§Âðà°TàÐü¢"óÇË?ÊOîþ½uöÃs¬ñCíy¼øÃãˆ,Üö×ÉÑ8ÿ…̱+Z)&n®êB#7“§÷C±VøRéÏxîc}³ºÂl»³ã:Äôb+„]ZСeU<ñr|ÇPÒ«~‡ÛÇ»­ó�½Êé��ŸNÄÅŸ•uHLÜ~ú|«Ú“A¶˜ÕB®\)ÍÒ�z´9ãw’�èõC®¹ÓL8U#8©xjºUà�îj1ôŠâ«Øãå­]e-ûêžþuƒáÛZ¡#7:þ<É)DŠ8dt_hs¸º¯Å3f]kB­;bŒ8÷Q-#±ù'·êìZmWNÉOj‹ÛcÞ²Òü<êôÍë#7ôΘCˆ¢/¦žûôºQg}VŽü1liÃbpm�ê¢g‡¤‘è°�nÚï$@ç�&sµÅ¥èƒšâ#O%	e5¦=‹(ýêÑoˆríÍ'–â=QTê¯TÝé¼ní@r#85=f,êûâÆuñ«Ç6úß}[Eêwr¯$Ì%×{i³®î5Á1®lÈÁ^Ù¹{oá‰èiGs5‚£gù:fÞÈwvG9XI#7BI\G.}(2¨ÛXx&‘Ÿ&€ÐJŒ§ƒJœ�þ~»5<µ¢Ù÷¡wˆþSŽ<xÉ2ûåð�4Zj¦vBI~ŸŽ•&ÂH}BÙÕo’p�~C°â›}bÿG�eö‹A²:CRˆ—ø(¢òà/øTˆþ‰†?öaÁ%v<Žb�rS�cƒÀði#Þk74ˆ#7#7Œ‡4Ñ*—ó©²ßãœO#8•MR¸4PÎ#7‹ô¥ö6þ[RoX]wqŒ3¿J0˜›T�Ô…Îð Ûi�ŒmtiÅòØNû˜Ö|Xõú¢VÉù°+Öºòáã#&�qÉò Üí+ó•ìæ—ô®`q!‚;¤s’ÒƱâ3µpç"Yf ,pQa6‹£7À£y€‡ŸX‘û:À?.×MJýfœÔQ‹ÍƒÉ¥âÕ¤uWV[9íG*ý»¶ÛÃ]Ä:<A)†iã¯>~ä/izWRLašü…ëÕë´±[Fêm´à‡Ó¨¾,�dºÁy>Ô¨?›]‡æéÛ6z0ã­LoUQ80±…«!ZÕsªba Ñ´Æ%»g6(;íß|ìV‰è›ä‹wîçç§n+º8Èàö£�¨]“ÈùöÐ>Ð0×I•ÏK;eÖ_–J) »ºYYùxþis^îÄZ}&Ç/vW‘p«°lQ3P'Ã/|‡¬m|=¶úÏ}Ó­íÉé`z87“ÙCúÁ(þ¬ëöãZQ48Ìn�üNã#Ï몣ÄÖ
jŠ‰¯ì&Ê�#7A¨œÔˆêãlôk5•ŒVÄ}6pÀÞ�ñp£0p¦‰ÖßfÙ[`˜Ôº¥+*jñÛ»sx�®E.02,0c]ëH5TÑ#öç»}­IBõ%¼ýzØD€!Ùâî~ÙÉ÷X¬Ö�ãÜÄ“Št’RÚGË/}^ÓoÔVÑü¼wÿ·›#&bËGÐG»UˆHQcßQ÷±D
˜wðÊñ¸<_o�k&KôW(T 9TSdzîÿgÎ)ý/Òå©â£YñÖ¶ú$[ÑŽ6ïþWÊvO—”þ3k¶ˆâ“D“F}èqvXMö‡1PG�½Õ×Æ2¥1²lÛà�“B³«ª¬Á籘5ËxF�±‘§&nçÚ¬åu3M%.l¡�ÜÏòå®TÑÝ"Œã»æâ—JÌ»˜^X¸ϲºÚ(ÝÞ±û™(E+ëdX(–#8-(Ä8¦D<‡²Åœ[æs�÷»
e¿‚�°Ą̃ãó^ŽÆŠƒƒÌKª€aøuh~ŒT[VáF‡ÀЈ£g¨L˜SìmYÂ.±±qòè¤@y3YhTA¥±mqg•:^óaÐÿùÆÙQÄ£ªüæEäYïP"å«îôUƒÅyâÎùY‘ƒÍ¥’ÞåP«aˆG.ç’â6þékÁ>¿dÎö8	$.âÚù®�íÎ"¾›�âë¥ZléTBÞÑàöN6OD¡*š#8]ðirºzØtM¦Õöºˆ‡¢d4U!¼<A¨ :up¦{1â×<ÀR€ÇG†ãÃ!%§Çøo>
V;»[ü­Ò-^8ˆðèÒG±f~x†ín¦tÃlï¿wZYÖÞ?	®fš+å”"R?8^ÝéWo¡ÐRFŸîâ}Þ›0Žé,!«_ߥ–#8ÌÑìJoëÍ^_‚¦X.žU‡�²¢šEï®ih44�‡µÆÖlGŠã[Œ1á£Èƒ@H0\ë7(;î¹Uqi9Ñ6Û›àî~ñ±KÏÊ"AÜñLò®™Ñ/ü¾Qhuâ9.TÄ™eïá.u>DCÂaFóT¡ïlRç.Ôm§Š\çh&°`Á©Œ³Ð™2K%œ Tc+DÍšñ+E¸ÁlÉÙB8P9ËÌSX¦CØÿ<d”4G)\yãÊ4Wßw¯<3óòÃðÍ®Ç]íמ#7�Û‚³Ö¥Øs[^h[·Ëí¸@G¡ZK¨¢L¸¤È¡Ö윇ˆã–ÈZ«Ë&Ù¦ùÔ`Ó\Á<_R?%|¤x�
üí³·U/`öФ„;‘Ä4£	™˜ÑÓÙÇOåð�¨´½¼ã½µ¦ÎAõÝàÔ<+ƒŒ¢¬#7æTïævÓ=µ¼+¼OÆÁ=“LrÎ!“û‘~m¦ÜÑ/ûö¥vRSïÉEx9áB Ð@F@Q ‘ƒîÀM¿Û‡§çå¥O9æ�‡ýiC·Ë/$&gAaµBC›§��6ÊssâJ½ÚÔF˜~Ÿ:ê·˜mqpƒ]Á´#7¿`àšÕ5¼Yžù�4Þ=•œ�`7áHùèé¬eG-/¹¢oœ:ç3fK"Y×Eÿë„dø‚ã¡âÉVŽ_0`Á×`Té“	^©(Àa£ê#eƒŸ•âûqPÞ~k»×›íÀV±nšQ¯ó^Uû5Ê;jú£µÁÏC£ÝŠ.áfB+hêZþî‘øíkå˜]#&BÿÍ$kRaèk´ƒv)#7,ÚBïUç×HXû¶¹îT5sÜ�ÄŒãB8V©å‹Ú!gbq•ÖÃ\•ÁˆQ#8#8�lå(^ågŠüôê‰6#7! éPM×ËHjÏ[©´áU•âÆxj¢7xÅX;zrÑÑãÏu’·Xbý òv\�)¦²s°z¦Œ”¡Ð†Û�ÞÜ™o"Ë„Rˆ—#&±Ýö½ptçä»—ðwÀº�À‡B¼^ÜÂÃVŒœ—\:ˆ¬îe }8裥lr’×­®q]E^rtû#&ëwž�¾[rúù²ò‘3`NHÖŒúõE½€zóØS”90æmOã¢ïúc·íõïäï¦DŠª"Ô£Ø`/œú³v~û¢ã¯ÚŽ—¯'ˆ¦ï%É'€JF­ß‰°ÃÄFä¸^U_è#828܇ãäÃs¸{z#&Ae¿ -ß2	x_ãùœ
(
(	z	Óá4	'ù.[ÞËŒb»}5Öhª—$²Pô³rÍŽXtAÙ@£Ëá$rv'€L%ìéuÙD‹rÒôèöëõùuÔ;§ß˜Øˆ"öFG	oçUï÷Y„GÄS³ï]{¦Ãˆuä•IE!E€IºØ<wv‡ø:žµägbqE 	0éüvaÑúZð‰�7úÛCìÇý4>zq^3�mTÇÈ8E>�{‹Z<½Üÿ‡åì_ñeît4+í#Bçª?Áo'=1ÿ\{SÃe$!
‚Ho¡3d°û(âD#&3øïW‡psE+”#–  J3Î(6zºDEãͶ—D}Ä«Ÿ]~>Ýý”Ïè‹wÛÖi¨ ¶ÖG¸õ¿×k¤JÂ?Ѫa¼³î;¬ØáDÑ�`K¢�¹ªmÑ\Ø�u-˜çÖ¶_vF½†ÓCaÂ:’‚�Ù)nbT–rûµËY$^¾<8yÑOÒ#8‘ö»Î„'f¯lâ4�gòû«	Ò¢o–_õ|àý_ì˜Õu—ó’üã#&†¡^ø˜'¿^ ûþëA±ìo¦f ×a˜ÙSåðÚ¦X¬¾)înHL—É
÷?¯‘çŠ AyúÍŸõ‰\ápI"ãæúÞ€H_òI„^žˆd ³î¹%ÑD{NPü¶>˜êlè÷·Ó¼}Ÿ'±ã.7W
ý×ñõÜlS;rˆð±%nÄŒä5ˆ.ùþjIu“¯øgðÐ8ÐúõÑÛ,�`ÓÕópÊÝÞ[ìùÇåá‡7µ@Û²6ûz³‰Ìd‘òtc’Ö¾,×~B"ÑYòÌ=Ñøuþzþ¯ª–¢€=Dp>J|äš‚ßÛžðæ®Cr$»­¸}§ò㟛ÆqàZÆMÒˆ¢§O�æqÏOà³´¦½·àw1eð9­Ï³¶ÁÔ›±—Ó-”øBò"!'t$óþÎ2`Sÿ}þ]Øunp…�½Þ·çמ›#§mÍ1"0î–b8�&DGïS$¾"NBdŒ¸«³¹b°/gã¯N]Jã?Þ~íŽsÚQîURé‰mÒµ²ݶ�Û¢ÉèÍo(ªþó1º“ؽr>¿"ÿO×ò6`ÐŽ�ž—ïpqªÞ3Ã@Fh¼UC÷®ñD@¥„D¤VSkgÑ+Úy÷özêW:ÍN?3(æ[ËýlE&@™oä•¢U´’™¼W�T$~¯§œë¿ŒF{<O1[÷€´“f¼gþ‘å±X8Ë#6ôq.Çø~Û–…ç93O{lŒá'ïîãðVÔÌ´ÈöÀê³#m=d£@Ë*mP^1vŠ®õ˜/wÆ+�úñð!ÀîâB/¼Å™Û¨}�ÖtÙ†H-°ÚõŠ¦5zi×ÚØãj#70Î_»Æ¼­Ð¯ûÖ‰%¹N�‡F¦–	7fxQxž˜«ø3ô?ÝlÐvFסJ#7§=ÔslŒ‚ÒTçÊúJF,DÔ3Î$ö¦ÒlXF^]~¹8[xä7­àè‡ÆáZ“¦~îòO’2ÊF_}ä°·$PŸ@­šiŠ‘sUØÎ4UUH#8Âr[¥“EÆçV5×Í.¸êÓôEªà#ü�O.¦øÿ‘ ñn#&¬8bi.	¾'íÛJäÔ¥$aïмïv¢®ÀËÑ;!ꌄx�#7.‹º÷k›ò50yòdûÇ�ÛJÜä°
â�æÝ>Sš³ú|¢ûþM½´*}ˆ€ öu†è‹ZÅQPC6^}qd²@�æ0m˜¤][WìíRzNša£Å�¤�]þ•ýÿ’Æ„NÄÅ;Ç™¿lSvLõYjÑLì»âXi&»Ì0üÜü¿=ÏçólêxZꎨ’(­Œíª…‚XäQ‘úouˆm<WÖqé>šsÆ׋<ÆJ,¢£W½A$žQ¤ Õ‚¢h±ð�Áˆºüüõ?Ϭ)oEÍõãJ0ënT"(Ö*4ù{š…ü•ÐRY³d@3Œ1-ì<;GiÅ•þK7pz߬Êi2tƒÓ¾å±¥‘ÑÕd”.}ÃuN:	&…ó^èòú�~H5…îþÈq#7“qö„(¤$•"Ýwfô’Av¨×l(jèÂøS²±ÄŠk4@”!
ì#7f¢s#8‡�ia‚C
À.|(ÔuÇ}™.Œ±I‘ÔM3LŒ=kÓyíRx*ÖÝ9Ϲ(Ð!‡^«%b(VÇrœiaN\Ðà.¶€o8Åýßkq‹n‰‡r”2ò$Ë;Pw@ëNL¦1¼š5­=»uµK;a„Êli·–ap4ÕÙHˆ°R•…âÚlÀ˜`c¦”@ã^Zyˆ÷UChtæȸ‡ýôÁ]Ïöûúõò¼8«µÆg"’‚b©ÀÏhجi˜w9™Bé•uJƒ…ÃwéD
…‘$~Ý#7ŒÃ…}ÞžV	ö³Ý¼üøû?±ÕÔ4GõQ-Ê2ÛжºÖ#&vy¡#7(+à6îœHí#&w™zž „h(1 X�PC /|DR#&{Bi'õV½zÄ¢96ýM#8,ì\¨øbÃ¥¤ô.àtÍŒõŒ¢SAõm±P>ÿmùx’J\jRÝ4}á÷*=ˆZX¡êtÊ¢+UBÐÎà 'x–i#&FÌ% ˜dí2ÐæÖBŽTÍlkH’„�—/èLJn#7Í÷Ïh‚¤�tÁÃÏKvè³î´ôŽÔ~R	Ñ�]eªÇ6¯“ö®¾T™÷î¶c0ÂÒƒÖ@ca”Õ#Ag»8yY4ç~šÜ,„tr¬DäÉw–¯šW{‹ïÍ/ŽiªåÛ<¡ãÎÏz3Ž»št»r3­Ÿ®Ž†9·Ã–ˆyøO^·Á�v^5<"¸7;­‹ßBáçÁJèІºx<@ŒâÃ¥ä5„qé¿YÓe,g1¢6ÔÐäNfë/p”Û-#8„¡ç}>®¡„럓–¥Û•6þk®›ô‡õÊYÕz\ôc†ˆ¥!#ŠV9v“v6<Ìd½ÍüÚ9Ä›¤2Zà“³á›�.¾ýKÓ
Ý-º]ÓW¯#­ÕF§œU–M¾¬¢Éç£Ôé¨ÛŽž¹2´nò—”�‚f>áîæ­#7ˆïý:öK(±Ÿ;%ªŽß'Šg¯ê!öÓ>Å=NÕ:ð;ÆÛa\\éÝ·¶ÙJ�)à¦3�N¡
®ç'l‚œ©#&Ä'Ö£¤¹ÜÅjŽ`Ô‡™]"”/`Íôj]fT’õÝ®ï<˵ŧŽÈÌ`#Fæé#7®kQG‡ÅçÕ÷û{Ƴ&#8$«v ô{ãʬþ…ëÍ�‘Á.äm E<€5"Bli�#8IÐÕ1\)ŒCØt,³Ê$g¿_DÁ¥BâR ÆãŒ1#&Ø#&{ C±N7¸j(¤Yòóòß2pqˆïpËãn.��$�†ñ¼6+ÛV,‰í(´ò„OÝ;*rÇcº>8Ç”VOº½aƒ­Ê²yK”Íp)A$ØþÆ’Z…Öƒ5ɇcÀ‡{o«�x®sÒN8ÉÁÃp½f¨�üÔ¥—c„BöóN@I³°	$È´ç#8¼dÈUÕ<Üú)Èɘʌ¶‡•Ö4íÓPÑ%·Áa©­R…�Lʼn§CÍ¿O_¼¤eˆ„C u´Ï©4GdzÃÍ(ßß&ö©Îõ´~ñÇç�JÑkg`pÚãwËü¯:J[…°Æ±A'	?EÛ `,\:ŸÏæ\òwóK£ØÀž&Jlù]lˆéKZmÿ»úuy4¢r=bÆ´^î³³1ì‘ŒÇ:¬àœ1áƒ8Z*µ1M¡Ð2VñL„ï	öØu¢¡x´‡§|ß© ‰ÄœI#7C­¦D£#8ņ}�#7ˆŸÃ#8�˜ÌHÑZ\±b1‘	3e¬´Š•6Ë8ùQêßÞžEê=ú×n+ïÚùvß Ýt…²#8 Áb€ŽÂCiÖbH6ã2*Š’bb‹Ñ–�½’Z÷6ñ£fѦ‚È—1˜ÅlóÜ+&n�ŒN^k^*ñnWŒZô-u6²ELÂCcwmOWǵº|ðq™Ü$�ý<}Ü[ªóõ™�£}¢	yNûw2³™ƒ]Wªûs~{:Æð>+r€¶ÂeK¸Ö÷$ïaÞêqVã6ÊËÓaAtYËDˆ‹"cÒ;�rÚ3›"pñwnó'óÐ4Ù•�¯NmÖ
ÕÛðV"tpÁÒ€ÜO¾5â1”A”ÍÃF±ù?�ƒ˜#8ôØ$ëÑúY,Î#T¾¸(ô¿Ñ×Q\†ÙrÞÍlSº!tm#8y“ªBgmŸ¶c`<Á2à¸åD´)•Á¶V6Fš²64¥ˆnÈ9*Æ�ê`×Ï°ó¹ãËó©rÚÑ8r&Aõ‡\—f+ÒÊšR>’Önb:^;QM…GÛ³8ǾîJÖuœ9OˆÝö-›ñZ‚ÛHü¿Èæh1ï6r3Âñå*ò}_Îü¤'‰Þ?é°èQ÷F,s|`t3¡ŽâôJ)—špÂè¥nQ¯ŒÝl›x“É¥’�0cöÛåWÄNÛ×óÌø¸ÄÆØüíãµÎÎØã½;ó£÷ßÁ˜Õùô5™ð™I$ âk£¥´\ÒªÒTý"Â8b®
Ø4~+L¼†·$Ö©(‚Š‘(00²Z±á8‘¶|T—nÆ8üó²éƒ#8ÛöŽß­0YEàcǃ«½«.PÄ|®I#8-iì– Œúø‚>ŒŸ� ªÔ…MVùcö†´‚ËAÍiÄsÀ�¸$à�õ+“LP“ýÎØ)4Q·º¤hB—*ý ƒí}Ìiò/:'D\þß~M€c
È¡´ÆA4F�õgy2ÈŠÈ4ÙË¥3S=a„¤šEÖIC"̈“£­ÒN¬Ž¸#7Š=ñÃF9ŒqË�©Bœ¶H<8ú®…ÀMH&Ò+J‡,µÆCD#	­PÞ]°J"íECF•Š¡FGQÌš"Ø™#8È–œC­¸:ö1Äm9“‰µ¼lîæT4!	òæk‘%ü|ñXÝürí4ÌÅà–”›ÜOçQM	é%tíD!¼ys ¯—8\}Þ|òyóÇŽ¢˜Òo!í4®öu‡–¢RÀþó ³Ü×uæùÔâ]a}gºÏw�NuÑ;p9çZ¾p÷Ê|÷NF7”‚*Eº=V#¡Ÿî§T3WäG³jeþ]¼-™Ü)ÜC�ÇÉeÖZWs�°Ñ±,ÊÅv_+˜²Š¬5ìÏÛ®}e˜ã7nØ´C&Ï£ë‘]z(Ûò9h#7Ê\†	'n×,Ío‹Ÿ#åÞ/t‚Þ
æiv6Âs*3*6Ž^%eƒþtƒ¶™-2>�jŠ²ÆT;¾½#µDJk¸O”?ƒº¦¦×¡ÞÊ6^ùt©òm²£hSdÞ&©f~}莌‘ô`´qPà²7,äUF2Êô�˜‰‡"LöTr�ÊtÉÓ„ÇRû£×…IdÇp@iæI	‚v|S›2»q!X]â)þ8Õƾ!úÏ]î·i¾ÄÚCý&–p †"£è¥x¸"XÏg_>x8¯‹œB�h³ÅÍϲ©×Vªx˜sTZCt¾o|ñµLn¤‹šmP}	yxÉ~ž/ÚýÝ~Žgt�Ÿ³Ž�7tÇ"Œ"dhgÛtimË“*ÒDbŠš¨bŠ½zÕ»k.iÿ«ö}L›FR)êøeQ¸˜G§ç³gm ŸNûg<²|I]ñ³æl£ãOv(À糊¿–¾M§þ[AÄAÐH[êℨðÚóçëþß,{�>„�92I‡ý_uã^×Õ”¥éñàûcQP›†‘MŽY‘#&¤nÞì5«É:‚q}@Žk,ÇdØ�ˆ@z�pÿXP׶RfË#8ù;í”)KLJ”Ôæ- ˜KE!’dD‰@ä«„ƒ$9ƒnôDYˆ„aŽ²v–Èx°Y€ŠßP˜�ÛÈj$H&”2ZÖ~Åtk·íµao#&qÓÀbÎú¥éÞpÅéú«ý‡tÙCa6^_``L}§Úý�|ÜåýàDÅîùþfÞµ¹’�Ž€9*Í?‘÷?|8oH}O@}ð‹¬¨¸ôµ}siº7|œ¼¼ö
§¢8êô©v�š‡#7`u^Ö	Tt°Ìê)`jÏÓ‡ã¸~ÿà9d,üïÙ¯¯¹4�’æP¡
¨ ý¤éO,GŽ#8¶†X3 �»ùú:¹ãŸÉÌ4;‰nz"žì@Ò<4@ÿBþÚú¨år�jküeÚéñ‹OÏCˆŠ|ñm†Å£‚¡—ògå±Rm#8,'H§ÝØ&;ØH™ã,i{»bXœ‰ç²krc8#7ÑÓ¢ÇÿŽÆëj‘HŸoõ<|«û�|Ai�	,| ¹ù?g|º;~®	_>À9TQ¬Í̬ŒS¶Ÿá.^/ÝKM‹súç_M´¸ýUãì
÷'2¤[�Ôì×£Û@<¾~^Ì6Ëo¨€Ê‹[PžPÒ>|\=_¥Üj›õWà¾Ùóf.‹{<�ÈD{5mÞ&8ž†`<§ÒÓ­’S1qTtd«Ñ7¡H=rà:làÜFZn¦BNÕ/)É0K²ûó¦VsuýZ„E3µs@üδ¸îd‘eÂƊܶ´Q§j­¢¾}zÃþ†bƒó$€;~�ŸEyüd?`2…Ê®*¯oSX'¯¯/¯å_õäÀÌŽ’xj6¨C) #7JšDª#8OïþÞ©™��ÝœõÿÖÌç§ÈË7Ó»½à@›=WÙóóÛÒˆ©~,*¨¥”ÑÙç×~³U;Ü4>aó¼|éè§?Xˆ#7ÐHØÃI¾Ë}¯m½oÌÞ»b,*[ž§mŸK­Â)›RY4LÄl©c(¾ýÆbhÓb¯Ç^Õ‹ˆRPºÁÖ¬00„È5QãäK#8šþÐ>±VæîÕû?!xx"I[šP‡—ß7,¸QL•TÒS«L+…a!€b’„q‰–Oã¯F�à¤55M
˜b8	ÓIH#êÛh½“^œkóþÙ¯?ìØû_ÉL!{Ž‹!¼>5û$U€˜Á³ðÿN#&ýk±òý.gYùU£ª0£/=#‚OÁ)!PE L��ÍÌR“×z‚5Ó(\/)‰ðœ$‰ìC#º÷ÿnê6‚·©WÛzI·Áµ`�bÂBB#7 úØÑüzGû‡îÑû$ÇØ<é\‡5nÍHÒÓ:¦6«ÿšpûÆÜAºB˜,0ʨTž~¥m/ýXî4Ñýû{
Ç7?Ðç¦ë&OòUå¦Ý×ûÆY¥ø4ê_â?ª/ö”¥3�‘þUè.šÒ[0ÒV¤Þjê^ÝáÝúXýqëVz<�âì}æ?5Á—ÄÏØÿµiCÉM-ëè\N%#&ùê¡B‘B¡µu:€€+v–Œ½¬(˽#7#7”õ¤>`Ên’CÃ]V ÛGq�“ŸtŸó%¨ƒ`ý½sË#7[o�á\ÞIôKÔ÷¸˜ID›÷4¼vf;bÑ]“�M„É;ùŠ¥-C­Öh;ªÿÖ¦p#ÕÎémHfÆ“ÃìItaÑàÒ�NKôN)ûöCAÖ:\a›Bb7êЈåEX#'ïJd˜ß·ønáhCúl¥ñû|Èß48ûù{hퟟїÒz>{¿;~.ü`#îïú~Ÿ¨Yíê_/$žgØz!ùûIx‚Þwûvu#7’®°]l;¯´|xZ›è<‡±ÿ©vzþ=˜~·®Y·çïˆD¬Úk‚Øsè°µÐ�Ïd7x}¹xXÀ¶Þ�e4[Fé�×ßûbà9È
9¦H«²s®ÛÅý–[Jsܳ˜è4{Ê•ói¾i{Ûñ‚�Â;»8ÚlKP±®ÿ™~QOï¦ãÇôD;‹/1Öå�îþÜ<‘á�¶ê¬®ïÔ;¿‹Ÿ¨›.ä䮦¸w½#Jñ Ö2&òª@ÂOTëÕä±à‘õ¨¥ý”ÔLMy@>ïŽG™¼QiKû±*ÒÃà£MoépÖƒp ÇøªLÉƬ3ÐpÁr˜I8fߪÊXí.sº5Qÿ'müj‹8°î:xc/–^M=tŠ=|Ý7Ï;�ÕMWkÛ•Þb�¨)#8¯¡ƒ…ÂÁ–ÂÓŒºâî®…‰KHûþ6,ŽÂ>áà=�~Õ@£áWü^íŸN¶1ßÒB�#þu¢1I?kC‘d(@aÁ‡�ÿMë_h€¿Ì*5X‹)‚#&P¬¤Ä�‡Öÿ¡©ù`óÍ�¼cX¤²ü1Ãçl;J“`Rw«ẔVŽlÖ(›iØ@ ÿBgÃzj¼D,ÿdK €_?îÉ#7+öwÏJÀŒ'Jž¥Yúúsèg]	çt¿cH~‰K3MØzÝc{‡‡ÔLÕO"KÍÓùdíãú{Ú?Þ£c�¯NJ§ôÙz�ó<)³ô}±ã¢^ÿ݈M!í8’dcµ•�åQ†¯ÒÁ÷aô»š£	+’Â#8ü„!"�c„YÊÈIˆ�PAEÁúUSÙ »
§£ü>7HŠL—ú‰hxà–w|#&÷^~)Œ©ú¨ÚêIêJ&,«3ÇíÎŽSVZj†"J*ˆ¦œ!N,½ºM½~D'Õ!ʚػ>}ÓôþÿÑvÏX:O ñ3ÆÛK€´Ž+ú´0¶j�,�ˆbWجI®˜‘r>FχœÓÔˆþ¾ž‹×õ÷I+AÂÍ3¢ãÎíO9v‹²´Ôó­¼Yç`$B*'à—Ú8l<\þÌsû¬	û�!þvrTÀŠ
ÏóxúPé/"³Î4:$ÈÔ&䡪BGª=J[K´”T†KÌ£ú1üŒâØõ´ûÖ˜Õ,ÙLnÁüßy±WùÃ;7wcÕ»òíòý^o»žŸÝ÷8ü&ÍÝ=ÐUAò{º~§ßLµ%6}}¶ÙÍÍê#õYïlç쵂½vºñ§Õ1¤¥«]çEË]�®÷²,�ñørw‡¸þ<7_Acò·OnÏ¿»õ#7ÉÃÉN~k„/y^¨zqÏ(¨–ʽ¿Ÿõ~=ÍRáæ>Ÿ´uýôÿW“éΗTîpbsß«Ùƒ�ïw¯±ZS˜‹G‹¶ü¸sKòä>-¾_ÑÚ:5�^²Ø¯1m;?gíîúÞxì`ºÅ©p0ñ÷ì};çYjÙÕêÖᦖ�Ýwcôná¤zäÃßÝ$¦ôø¿¤¾hƒó#�€eš@l>o¶ïT1’çã±íÕ—M%>cny¾	Ë?ŸÏþ6þ2jZ‚›h;F^ëÜŒ=x\Û¯¶³æéxáݲɷÊ7[ãÂéÇ�Èîû)³à…ÎÙäžNþª8:=ÿ&ÏÀµ§§N)Õ>Ïñ�±Œ4Õµoxë×3Ý^�ÛŽ¨_sæ5¬zßÒî^hf.Ä-ärG:^äµ»ìòNûL8b¶wGhòÊ.‰¶®Ÿß¯æl
ºË6ÊÛ6ÄÛeìîˆ=†5ŽÎl피6ñaöÆÁÍßû7yííY5LñÇh·o!¹‚ÅÌÚBè#7XÀ̽îz¹§îøœâ6cfœyöIܽݱßoŸ�F�ü=§vân–;Ýê"_ÁÂ5Þùß®ü<–LJÏ~Ûšu:Xò²n»�J´‡4øî^#7³Øþ­n°£‰ôõ�Õ‘墸¥‡¿�E…\5ÿµÏ7ðø=_×Ät;,¬ÛÕNçñ�‡£gjïÚñÍ÷Ø3õzú—¿ö™ü~Ÿ8ø]“XŒö_IÄxsnñ]ƒE²öøï•ÿ`úxPx/2>\r[Ú¹ôüûk»+{6¾ü6‹¬ú°/ʪÿzúD«³»Ù—O¶w†õsËÆ©á›eÛá£ì#7Ÿ¨â 2´€Öôcn›=lÞ/ÒÛ9iÆ\Ð礹7À;DtSõoêýUÇ×ÆÃ;TuÿE#ÚSV:Ñ;µ/ßô·èßÕ§ÿYÝ |y;‰Æœéù½ÿ×éÙ*i»óìÛ¼ëÆøžÄ-ÞÜð[ä¿Å¡³èIé2ùäù#7WÁ—» rúz¿-ùƒÒãhðúõiEˆäW0£¿/²ßÎì†ÝL¿.ßæë‡Û»‹¾Þ›cvìãœz™ÎÓ­ê#cGB¿ÑÔßIÆQÀyîú[ý^¸ÏýŸ[C_ëÏBv‡Œ)¥ÏG&,ôxŽÒ<¯_×ç�»1ùþ?íe×{­´ôôtlz}Çï?Qû~óøþ_Ž­üÖãÏÐ+àý>-kgî´•½†·óT…}_Vc?4½-“K»Òß×öjú�_çÝü‰AñªE@Xøà+BаQ1Wg¯×öýxÂèÿ9û¾+=5�üýH¹]>5Z?Ƀµ×Ã"{#7AUú‘c­RB=�CD¾öý$?}Ê.#&)
EÅè°úª2îÖþ—þ#îꊱ\’~_ÑñûÂ/(ë·×Þ)öný?=ý8ôj?oËžœ;óòyM?p¹™¶y{G~úç±ÏØwþ$wßžÐð¢–W«fÍK³oϯ�A©³J'/Å~´ø|Px”»ÇXíòøcùtô�â>_–ž<»ÿ—3Æ¿Ïñ»¥GÈ?
Ö<ˆáœ²·É0ýÁG­ãÏ2¸ý3ÙLלyhþoÎÇÓ©Öÿ�î
ËõeªÁ‡ìTGù/߆~fþ|é{Æñöâž8÷kÝà?þý{µ[;÷|õÖá¹8øóµnþ-ý¶#7ÂÁ¿âN›£Íús–è&0Û®~U¼uGîõžsíòñÔžQùØl�Î,èþÃü& >‘=‚j<â;}ý�<º@ùGÏùÏÀ–§�y{9ÇGLªß<ƒ°³SÏ�â#8~TYû¹Ú€„*ƒe±ÉëÍ»0›‘ÔD¨H¢o#7ÎœyaÎñ¦üagwéðÏÁxŒ6Ño^~z™ŸÊÃÓ*|åŠþ#7ÉÙƒçÿ�ut;øOš³&KðŸÛO4ÑGÒòÿ‡òÂGçå#8|Š£8yf/»ì؆ëéÍÙós¤µÃ„†Æ	0>)c`§¾zf‹U�!x	ÎÁ&ô_�B‹-ÕÓ%´^†Ii3$s¨òVÌ#&�#8=†«ÅÐ%w‹$�õ!‘ÒWl¬g]0}Jôãͦu–2¼|0åñ\^ìó¥z¯èæuã˜#7*íR";€ÔúíŽR#ÙÍúy¦–‰—8Šï]îÀ‹‡ºfp$–:‚	~;�aÄt�âšÀ�‡Ô›¿g6»=3Õô[î	Ì4_wÖ0ø{« m&ƒ¿sú\ sZéîÅø‚^ÐeåtÇòuœÓ­•ª+‡Aädã>œøº÷Ø*E:_>K#5hT2ÑTFmA1AÁ^óÅö™±g�Ëw-._)­clb^jPŠÔÇüiíy»Ç‡ŽÝŸ‹Œu~½¦Øt	çÌ0Èoæ?pá虋È�’™Ñ©²[-ãX—Tto®!Õ´Q@ÐÖÛ`#8é6òOéö¼jÏrJ¶éŽrÃ๔«H› Úô ÌhÔ/Þ'i•´%v'ÁépÓèƼ^5|b�QÙ’ú_æ½Øàû¾@ôÐ*$‚RwB�#³[âÞ<#8l=[@Ó¨:Ræns1�`*çíã!H£ÌÖ4WŽl�‚`@jâ>OåÂ#&‚«Ãßûí·é濵ÿç Ü<>,‡Gh¢|Zå‡#7‹dWƒy,¾¦s@±#7É°©öÄBŽ£¤ÏQÔGS”ÔE QQæö$áôSÁÐ�Ç$Qß«P¿]šz´Yâe«wô\ì.þïËÇƽ~Ÿ¹§Yiò;LøTlÛÍ#8T·#Õ¬™³?"ÀùeFlx͈�“ß�Éõò>ß‘“/'´nqLŸ¢ÜF/>#&j?¿Ý&ØÃÔy;Ñ£jíq£Êÿ>ö¾B�§$Óv›÷zïõF'¬µ1I'>×Ñÿ(}—Éýö2;IîŒ^êØëf1¸$³˜æçücõöã„�áùg#7^ª�7ûF€ï?�€mH9ª½r`cÒÄ’€-t#7�ã혨þ¿Í’©N�2<Žõñ¿úˆ½’rʲóý^Áµø4£�#&þÞ‰lÁ¨6ÇX(àï&­4ÿŸêAõ�¬(àSÖ¨äe?‘#8?�f@ç9œP¹[EmÈܬ°�M7(È0Œ)<zà�š„�¥m±R8‚9‚ŠÑR‰4íˆÑ#7d##Àx8•U¥�ED[Sm�!üûµ<‰m®G¦pÖšÔ‰í�cÕ¤n°�lv(éª æ°Æ£#72J`B#7X¢hhn„)-VFƒV+`Œ3(ÆÛqÊDhQ]½ri�Õá‚aE!Â2`QI×ñÒ»ÕuuÜ9.„¹ÙFÝE¡+öÄ["É´ë+�?—í½Ö´wÈŠç3’�ˆ¯é¿úw¡è¡“%ÛŽU‹À9ÁCf'¯ó†jJïTÃ3ùõ®{#7±w#¡h*V(¦F]JC	�Æ+ôïôä/ìÇŽŸo÷gÜþîçpg€‹ÍžßB›ZVÔÆH::ªÍf.ú“ÔpÅÒÂT˜ÊȘƓ#d!«PX›c‰‘³I%JªöU@rPJºLÜ+ð�Ÿ~ÄÑ8Ýôèú<Ù\³µEz¾TÓ‡p§êǾ]‡úöeKáÚDWCÅÃ];�¶ë–PœîV­v¹÷YèøÞ:|õ×çëùj}7t|Ý»øù}ܽbå^Ï>:Wô}þ×HÀx)ÏøööõðçûÇš	Î'šy?oø`ûs³ëÃ÷e#ù{ D·ˆŽ¼…�—5ØhüÓÔ²„ þéUþLjº•X5ð½¶]nEvÇ@áÍ[þí9;·™×Æ*/ð;BêX#7<î3ó&„‚H’Üæ.×`û‡³Çäýߊýܾ-Zþ)Dµ ôâ:¸¸ÐjªmôðpÚu{½ëøYŸÑ+¸óuxè‡VKÑžõçЃ	ßüowír8¹Îg¹]kša†!�û¼o³ôÿ]º(7)—ôîó~�­?56ùÛwåvÞ}“ç&ÜQ7Ýoïžý>ÉdÂþø¾Ð·øzBHíõ+‘ŸÐ�Ð+ìÔ.8Ëï8aý>ÎvÆ&�i¯#¹¸‚˜bÅJ’+q‰ÿeš¤xÆ)NÙ/«¶	15¥#7r#7a#8Á³ÞyåÍ·syæOÖe6M‘DéRÀÅm¤Ž¬Ýk#8»µ&¡†2ªŠ5Ú‘³yk4FÀd€È£°®ÈXF†GUÈ”¬¶?¶‹FŽjJÛÖ¢3¦…_‡�²òÓEj`ì-P¬¤€ÇØ(ÉAºv“ŒâçVaHÆ»ò¥ D�éÃB¸Á�ƒ„MÍƒKƒ	‚(Ñ€éâÞ“K®ÉtØ7ƒQ&Ñ�%ZaQ1N-N³­Qiˆ#M\eqŠL©msZ$…¡Ã|ñImh  £M`Î™
8Þ–ëŠÝt3Š”ÁN5%i2†§ùð ÝC�‹”Mø¨��éB ôh#¢Í*xÔNJ:«Aâ¢6l.r³-–ÚU”ˆŠWx@:'K«4pO#à…V’#8I$O	¥¬°®æPéY[¤{o[&3E÷HxïëŒÀ¼{º?G7AS]Æ iÑZ~oö·?T#†Xœ�ÅaÊñ{àÞ� w,#&{#úUÿ?Àž%‡Ë¾_R¢“Ù¯JéðÏëßb{ãò}NÎÍ&ïeþšh‰hÁ’U<�OöPüðÔ‹k‡É¦õvv|Ãß³¯lPL*æäë¤ã`zö2p:#8)R#k“©ÝÓwLBƒžÏÜìëн÷/Î_ª\tÆFÙ	#8WŸÌ½“ÙN,2ÜžåÛi§nËÎÃôý]�ï#o7ù5ƒ*¶âðàínµ¶½Šåe[|*=°Q|BøÀ꼎²Ar2¿¤§y;�T0»'l_€0û¹žÊGWŠ	�>˜øžžh�éèó¶‘eô#8.N(/_‡Ö\ËÁAìf$’ç*«™Ë§‘JyÅ#8#7K:@Ì&€&�J¤/O[95P(�wœõœÐý_Úro ;×Óô½âAø#7_“oˆÞ8êPÇ9ÜçvÛßíÚ®ö?^.�Æ_�,_Cm¶4@ïü4ò¦(ÿ±9sŒ®åúæ	yøzžÝ¶j'fhd! Á­ý²ôN t%CD¥QH5QµeßÕ6HicO%áÈñ}£ËELUosÉ&#7!y"aßÄ8vmÙÚ4‹þ\r磮]u0Gúst	+NÞÚ_òüªY%£À	BBE„%'÷ei²Á¦Ú¤ld„q",CQ/ï±[#&ŸË—MæÚ%áÑؤdeEeeTFE²Ï_®_ã�ÐGÍç³ä퇙¤oÄc>þÿž‡�‡,˜öçMC@D4ÒDe�¿žÚrdˆ®c™@ýX1ï¢�Aü�ÆîŒ&FŠ¥Ø‰5X\b1‹I¨�ÔÕ„\b£ðËA„Bz�ÇŽjæ<ù¨«0d(Ôl+É5ƒÁÁ˜e�”FLØŒ€Uñz¹´¼KÛ�‰¦÷vÀ{¦ñ�#�kNŽºvú°­ƒ¹ß§(6l&â¬jªð6aš#Z°Q¸ŸbÔË1+»sƒd[ˆP�‘ux¹¨:#š´>5Q\É·�ë Ö]WYEQ”¬p²(DΖ&Q©
±DØÌ+G+C4ÓhÄm”{cï`ѱhî]ƒ]ZS¤7dQp˜ÛIÖÐë¶X6‡jn†	rE³.ØF©Š8í?µþõPq±$êK”öÑN8’I2I‰O"RŠ¡S£vbâ­]Ô—(U$tJU·š˜xÜ­�¡4.1™�ßž#ÈÂA˜0„Y°Æ|þÂcÝé#8•¨!B#8ƒw]û¾:Ä•k¯Þ~_½Ç�EGë?ÇZ¸ÝÄ‘çùèÐâ$¡�cM�L¼f/à³ï2›˜pÃüˆ=@T+™ßç¢h:�Çææ§#nÉÒO_ã"ÿO¸ì?0–>ž?W—ðîúO¤_ ýã>üV*¸bñ@{Ì8G),²Û1bÂÒª§çJª `ÓŒÙw†=سòàÑ�Ä�D\Üatá¥Ò!S§ß>},Y#ÔYHŽ)FD‰*a3~›­éëûfŒ"f>Ý!£DžÍÞg{¶6ι¦�Jšn:8¨#±ä"½Ï'£X@i-¶ô´A¢#8‚quQíѱ¼
Ú°^,º¥Uhª#8ŸŸ=þÿO«ðý6<8q»lk‡,áL”¸%‚òðç.-„QÄ2§oì?›ÏîÎýþßO_ñèïèˆóz²Éßv¡~züƒ4ù²áå�;èÀ†§�Qzƒ"°wB„aáöÝ|š	-+A‘¸·B&:;H3Î.e‚l…$X#8‚¿�Q��p‘±´Äú1ÕÖ˜Hyƒ#Cí#­¸ÛëUIÚÑud#8›Ž7tq°üŒE±åE#Pm§]ŽF8©zÞ8•‘C�g=&gh¸¢ÙÁÍÌ¥TÙ"0ƒ"8°¡‹&ŒS(€à#Z�¾øc#&P�õDŒ¥J)‰zAB:ªE”¢�~ÖC6Jš8D×±vª2C€µs£›à¹µkiv¤ÜAغÉ&EGI¦Sl²:Ž9f�¥ˆŽsq§¶C[Ú­HT+•ñ`ffŒ´…²G�ÏÎi5'í„+kÈ}Œ‚èœ\nlnج#7B”2É[,‘Œ#)�”$Õ¯ì&žï±¤[¹+ðÉSD!pÌDÈeêaú±Ò]ù¹DP¸9«-þ°‰Þ¯9ÌÖÐ|Yáo¦7f2Ï+Ú	ýƒsÄÇ“Õš	”˜ Z(([ˆÛ¢ö~Øs§`šT“˜û›hz£^Ø{Ü&d®àúÞ™¥ü¡ÖÍ-·êmXyj Âb™™-ÎaÛ¬§¼ôk€ã8{A˶¦…ï‹1+R�6ž36G©Ôî#7qs4Õuë·ÜͶöáO(¥ÆÇMðÌ�¹7$V¶ºRÜc¬mV±–Ò-àLH›oZ+Žû™ðZð€ÖÄCìókÞ¼[wÑ{ék­O\0lèÙ2`¨iu†,0ä��Ù6!L”d›fó‚Å>•�Aß4Uí«3y¾)åJ¯{ÊÐOØÿF0„Ú°´#7ô$›[—A"#+€èð�;‡È¢-ø6ØÍ9’Ú„3kŽ“lìp[˜[k¡CŒs1ÃŽ$ŧ+9‡ö?y$†/j ‘}hV8Æ%d¾·ó6ŠU’7À_N—·¥8	’YÕ§ÚŒ“ݽk†ã8o™–.Úà�ýa;Zì4°ilÔÚ�)×û‘ÆÂ#72º»ó5$#88n#75¦fÒf<-»âŠ×®v¼îÑŽ±­nú%¯ ø¢F�$Ø]õàÔº†Ës~s~·YíT$’Yf¤’»îrùh§fs#äxå³áv#8xQÁÛLr¸8ð%ñ¶¶äsgêlÛÀ�A±æÐÐeº„#8�¥(·‹|âÁ7-­v®TGá%Õ£2Üin…¼øL–&:³šJY¸ðé´ïC®â�¶£°ë£º ¬›ÌK%c¸o§8Ø(æòÙÝ5oŽ¨µ×8�`'ßA¶,7m­ow;ˆ÷.‘Z±Ú:1M×WGÌògfÊ™òjkè6ÃPD“\:tѬj,œ1º+³
„çCЩ°í¾ÎI�²‰B]35¢»>øÆU'PÆMÎ\ßs'- žIµ©4 ÃiælÌwÙî7Xؘðè5X·é{3lÛqÛ
ûu¿‹°ôðª@öiÜ\Dðí·çåƒ>U±°í:ꦅ/ðªB’{Ìxl{>eµ9`sgÕÑÐNL½ÑÙŒaÆ%äÉwùÝ*j¶ÏCI_û7q98Ø¢`ßh•ÎÝ“õ6SxëŽ'7#8ª}±9wþjDÖ9n1‘ND\Ì;íLðøÿ>*×GQYÌANMp£tMÇQŒÑ“4<#8c!•70ëÃ¥¬¬¥‘cy§¹"h³ÁÇ­¢SMf´æUîeß4ð @éH¯|ÛUº‘#w¥o¨L�™&ÞÝYþ÷M'N•JéÇo,àÞ0c&œo‘ta�_ôó…÷~—;¹Žù¬+ãÅë¶4@úŽˆ4RLXâïp¼¾!Œu1Ùv�V–Ó°B|'˜#7CКnYÉ[#œã!\bRO[d×õ£;Ê"O¼ÄÒ¤´êçN"™ˆJ"Ô£’ü.s=4ÄDV5fÏ$ï”/¸Ë—O&Tq“„Òµ�Eã�Ûô°··J�š÷¼½i£2½“–rÕÙkÑ8t¯!zºY¶«ß?•ÛáÉÃ�cœ#7È×/ʯª]ánÃ�zglÔ8\»=î‰7#¨¦TbãJ-–šú4�!¶4×n$bS¶²r†Ò2�@‡BØSJ¸Æ%´Í]F#ui¥�!1ßâú£Ã¬ú([«·è^=²Íñ’çzÌð½}rV(Ñ+Á¢KÊǵ¦È´ºôéÂß%1…#7�w±?ÀdÅGãü;XØÚv�r©ñ®ñÜÀF¸Ä‹_¯fàj(7§yf®ÿ3ˆå戔:
JE?3ï×òÂS3<ÞÅÎU†xßdpJV;\ù2áÎ5öªóþ·ýççùú÷þ™jk—˃ÖžoHwØ/Ôið
	¤HQUOH ³Ó�ë#7«è@Îð7ó¸(Ê@{#7�Æ0à2æ@“�5<R}~G;z‰
8#8äõýøÊË®ÀˆŒõ	Ü_o¹Ð—Óîï?ÕÂw¨ß›ŽÏ+ê®Õͳ>cåÞíÄ3àËv¸��þ«áç8ÎÛ(¼‰4™Á0,#&‰ú­D�ßør¹ÍÏ×3³z…õÌÅ0ì=ð]Ë g¤Ê"Q-áÎ! QèKŠˆëéçò°¥VXxeü×Ê+Ž~"ßlA ¢íE˜…A�xv‚K xžJa…çÄgþ:·W¶ìC#¾¦QÁ4p€xŠ�!`£X#&$;d cäµ@<«¸VV['öÛ;ÈúŠbŠJØ·Á‡.Ø9×Ú²¼ttõ7eÄÕDƒ0Ó`ýÃÉýÄÃ#,Syý©ú’ýlÁâ)>ø	ïùŽvž[ÚɼñèQXå/Vðcî/k±ý€ìçð|¼¥Öñì’=¤ü4Ó‰ZÞrf †¢Pð#flbnÛ#&C ^L�Œ·ÆE€þ^O�ÉN¡Î]ÿç¼i8H�o8;CÖ»ÿ•º(g<¶n¡^&LÅSå1ºùeÃxç�²)^ëˆ~-'4æ$(AFó«àKtnF0ÉŒ0õ#´h±DËíI|?˳†ɆÛ)Ç�¬s±TÕ4G¸^þݹ��7ÖŸmÁÛ†–BwƒØÞ|dÄÓ¬)8&"^ã0èM±ÆvÂZ‹"šbMVÊw05ª-V=ëËWíyë%!#8—œAÈ4ËdKû`¨O«c�O‡ZÔ¾#8çÄìáÁc7üðïïS[î›ôgÛòò¢;¬hÓžÍVÅÓæ#73èÈTî¾ò�h­½Q×=¦tGYáRƦŸ(Ê&ÇFËÑf÷nJ�{÷ÃñÝ;yÁ í4?5ñ}¤‹Ñ@ýÞÈaaŒ›¼¾ê ÷ô…댢GOˆM‡A‘’s
áyL—wko,�…§eÏTÔIÈöGãð�ä× =2RO]W¢6(îÎ,-»&#«°èI€˜pÎMž§¦p7ÜêX¸ÄX�K¯xLC]7Èj {Ã¦Ô Ý¬FWV,x¿Ø.³Ìxk¡Æ6�«ø23{dy4æiåÙ™©)GÙQ=!9bo6ÅÓ9gõ«ï „ЩŸQaILºÄ	ßÅ#8vc½z3fòëðkX¥cÃzƒa¯Õ�>+ëÏÆg¡R“Û°\.$â©ÃÑÎ0~b‚áv‹eIÔW'c›¢~<†ð?µ¡ƒøövhLº’CàŽ£§Aå‚zW*A?¹ršâå»N±9Ë&ŸŽÚZLHí¶šDa1æ £¢h:°½5‡>X©L:-	@~ÍnUì$Ç9÷å½ÛeºôØè±±nY$¦¦ó\«c?óQ#8g-‚~�.êÂóÄfBÚeâ-3ÍJ0Èjؘ|6$„�[Ïésc¥„ùH[#7±‰g½»ž<øe¸8nœ¶²\Œ\äx`70;å›àÑ)Èödm¡st–ÑJ­¶ã§]'·•ç±/˜æR†1Ê2IþÞvé»OuÕ¡ÌìË»LƒÉQÁ×ßEWîC{goqÇSʼvf#7=ÑÞ-Ç/¤Æ¡ H#7.jXòµ©*–éÞ*o‰X&•®d„)þÉ3	ÇÕ¸ŽÎN_©èíàŽ$vÊEÃÀ°´]ÔYK^ä#^V{¨ûJýGîÊN�Ý0mrƒ¢ªyµWè‹Áey¼ˆ›Šùç3´)TC$Íž�MU7Åj$:¤´ƒ`MŸeB«M*Š¥ñô¹ÓÐöuyóï¶�"tÏÕÂWQ4;·Xrt"ݧ½A1W9f¿móÍïOð!ôþ]4gÆ0ÆÕ�±Ò¬»¡¼ØHhNǨ²…§¬ˆž+flmëÛäh”}ƒåÄuÚÄœ½v¨RP"�HfC¹WSÝ
âQú%¾ƒ^ÍBþëé‚ž5�¥ BO—™eíio‹¾³®´Ö°,0…)Õ§jSãlTé<W„êÉ}¶b^js·<Å…ÙõMFÖðÉ7çy{ØímïLë	Ÿ/ÐÙò¶€»YÌÔïpYÕp°¦ˆèºeò¸è>ŒêC.¥ =ê†K#q�b̸ÙGG›:Ý\húÂÍ×Y¹9wΡ4ˆ®·®°W\Ú]Å+HôôÚÉ>Þ½»
È`yÉ{ïOD𢯷�#7O¿lBï¿>Kkº܈è!øñŽª«*[�˜Òª!b‘%ZOMÖbâUôÁ�>“,¹³#¥-*÷?Ž"lÝo
¢Õ˽C¼Ì;wìdp—Mh¸³=‰ª/¢6<õ ›q>ãïßž†rx²!Ü&_òñƒ}gÏÊ<ê×"s¾|TÒjðx#ÉõoÑúÜ¼,½�Ä`Ä�qÆ›š5'‹Ç”ë’Ï9Œ›±™6Û¾üÉn™ñ{G-µ¶Ùó:÷ÆDÜ>Æ€ÞÙÚÕçj¡Í:
€U#8Â×\l}J: ñJP•ØÂ)KïY=÷{é;t['6Œ$!’„Ìò—'fa­ê‹ÇŒ"²‚[O2,ÕèoÒï`ü^Ãrñ@ÂJ—(^�lý»7¿±Põ$Ö›UáW;”fò]Ʋªà‘eëgþKU>xlf­/�)+^�ü§:¶è$qG1΀]êZ‹{f‰(žÓóŠ�Ø>¤kó™ØØÛ1�~ÜâÕG–5XTƒÏoÁ¤y%Ì®A!‡{šZ·’€Þ‘€Ž…‡¦À¢
ü¿®÷b쪌7ÙJ°z©ØŠq?0ó1öÉãå´�½ŠÂ3©aôZnpgjÓ6ͧn+jXOâøã�™";"ïm¼Ùu7ƒçRåâîê(hàvsºiðoO¡$—¢?§î9ñÇrVŽ§+irÑ¿Ñv®Ý﻾ÐðFœ¿	°¥KW~d)l¦�/3bvÆûL‰¥–"aﵑ.FÞY¦ Ãa“øLøf›Â«ÃŽÛãªãfÈûlM)‚
4éRú%™,ðmo�¡ÅW–oKvý6¿·Øl‡ýŠ žyé¿5mËEn£Â0‰¨¸÷–¡jƒ§¶¡Êx& ‹KÄ\Üþepˆ|…æÁÉ�
Œm5éëMëPdh.“��Vµ�3Ê(Ææpb«5ð>;<3u­P#8‡¶‡†e£—�áŽ!ƒÂ•èö#ò{�ñ?¹ÑÞ= ¼öÇmlÀŒõ˜ñjm+°|ÜYåN».-.4¼¶~~…��@ó_bÜ÷Çã-%~U²‘0W+2‚€¹ì<ÿ¶M	ë]×M¶Là^çŽßÞ%G¼„•¦¸çYÓæ�0.U¹ËiEú«XúöR#œ,#7ÓyifØzÚÊã\!e€ßaa4º-k�œk¥€ ²Rßu!—>ûyi¾Ä¹ª]“´^vüAsÅ‚KfÔqˆX^'ˆà¯Ð"Ñvn[£`„5˜µdë›W+š*¸¨˜Ø'J,~磢+d˜º¸ÀWÈõ†¥Ñ.TÜõ
”bÿù¾KRVlçc,V�CŸV‘	K<ëvjœ ¸áKŸ%Þbx¿5a… §%}ôÕy[£ÏøUøh…‹hjÄÖ6e“IŽó'c›•ÆÇÙ7ÎB渾OyŒC¢òaYcX|lçå;í—ÉTÒ*6…[íuÖóÃ�»ž½üuâ®ë¯,5_2N0EyE^^þÜ¿W뎕¿ZÜù%èmvñ³ËW`»[#8ñÊ0ÉHÂ4Ø\ølÒ¯ÓÜ‹ `uIê_µgíÇ$»u}kǸíTØ;p|ï·Ž°ÊààóæÕó±#81ð†öÜç+n4qÒÞGÚk8_•íú§2d*Ê=J£SïÒ3¿[íœá&#8ü/p&8).y-‘£ÞÏ!A6Øàýpü”û3��^º2s·àÐq�gCÊÈe7»D#&^0„
Bñ½l¿;%Ò¬uõÓåùì�QžW?#7]^í™ÙÎE¸H=Íf®žÐðù*[G5öìíÄôã²àM–¥XÍá…¬#8¸[Gˆºý	(µ²|ž%htdÁÝo§&ÈãY†^4ÔXR6wëá�™••—®;*µå�¸­d9&°'Ó¿¢˜ïÞ"WŸ'ûfç>çÜ\C“Ì£ÎÕ�i{�ÞºôQ´d4–‘<Ì÷B�.Nyz ~~½M²1–É:y2®ØïÝG!9è©1ŠÜCˆ€c¢,,±ž|4Ù<¬u)}Ì„ÿ5ƒ&,,9Ö“.'ï�lðFÇIƒƒNâ*ÜÂ|>ÄGD{0Ý2údó½ÒNõ!o¥gnk+�6¹7m‹mÞ,¾.s̆*ê�pæ{°6]#8¶EMKðõÁØù2Œé¾èŠTR"¸åÔü|óq2Ê.V3�ÑŽ!èèf:O�üFøÚ�Õew�à©gäª!�mÕóÇdôêÿŽ…Ô„erc�€c¢"ÿZíFòZwKÁðIßÝÑ5Ü$Ú¹­®ÁÖõR±&’‹ªø¥úë·Jn­,|–‹¢ëÊøœ/’2—7Lj9ñw®‘ûy~[š‚ÈÁã™E¯‹…òðº#(K®×å*µHwGÇ•—ÀO2‘è\ÖØ:*²>EánEíV�YR†™Ñé-.NY_^øû$2½“�Ǭ1Â{}åAÄÒeâ‹ùtÏ›²…¢ÊÙ.êÊøÑ’â)b‡«4¯±�i2)|x±ƒù-ð¶ø<Ú^ç›.Ñ	î‹ÝFÄè¹e£Í7K:XZëêý°™x L‡ÎÞŠ˜$_£lãÌûQœ¢VgjöyÉ‚éþ©þˆQÑÂ9·Çö@`ȵæ-OL,~=n±¨ñ7´áGnÂ6QF˜Šµ3Åí¡ø´Kï`µtµµû_U#8"dΡº#7ÑÎý“ß�Ôèb£>Sê•
yš°'#ê @§>L5ëŠTRi%ŽÜrYl³.ˆÎÅ^ˆ’ú&§$·’ÈŠ ä‘Åøë*YFN�+88­ÍKz8F|Ò•¶Ñ¨‹ˆKd7I6ü”AGó•bñƒV„=±4
ûs²·ÙàÄU¶Ç4‚	�æü_GNq­Œ\Úxp–BÁ€aZÒ±²Ù4•qVH„!Òµ¬-fƒ	sŠ(”nB‘<`£…íen¥v8	>K%+Y9‡„êëª2�KÅôZžk–èØ£dB»öÍÑrßÁ§*IÌ$CAl覡̜‘áTÂÛn¥Œ^ºptˆà,Ù#8ɬ®ÝZërí±î:¨>»Û=çÚ‘÷jµœJ—“ZÕ]·Y.3ÙãdK癘=õΙY4ýóéÇcgŸ>6¢€Æ5úVpC#7ДÁ‰Í#7Iß®|«5åzôhè&<‹¨RÀ^3(TE#8Èç#7hÍy›3¸cÍl­iŠÁÂ6…„n¦|ܼ#7Üa¾ Òè½û°¹öBó9hÂ/r»ÈT3”ƒ(;ƒBnê9;*7YM“Õ~zœúÁÄÙ#8³®c	Ö×óœôOQiN•}¥ïÌS†0\Îêk3ŒlɉÒŒ¢ëóq�¾ÉÛG©Z²ŸCñ÷0q³Sš ÊôøÔ†ïW0x¨Du&Ž¿|l³‡:Æ{ã|W§CÓ#‹�ð�Ò¨Ää„ҿܧnO¨å+9~`<=BŸÖöÏ—iÀxNÞ٘ǃwºpZuà:Ç?5Äî9à/@·~_e•,D$-*âõØŽRA#7€(¤"ù9øÚð݆P³ÅDg¿7h¤² ´Ì¹(ªX=erQDG*rp¤µ†#7þ+—Íu°™�#8ª®^]È&ç§^µ8¿×Ú*�£Æ_úë›l”ÞÈs…Ðiq[™m;ii‚Fë;í™ ˆAÝ#7–¸NỶ�k!AÄó3ÁWÇú:�%"I€¶„vÒ/¹È^è8©k˶ïšë›iTÖêœÏãˆd�û�ÓÍÓòr!Õ5‰•\æ�xä¯tÞÑÙ´:Éë–¢ž¿HÁô²&×aK!W(xV[,úÙ‘“
'êþ4›¹h‹Ü³Î.*;TÆÝ}�3D¯ÁÇ#7Ÿ|ajLÆé1+ów!—‹ Ñ_'´°…³âªf<:I2‚á×áÐâ5|ä"_íáÅ—ZôlÕ>6tÌsÛö“otsÔšt£døŒä'5V7v·eTÙi:éPÝŠ¶¨”Àšå!š®×¬ö�î¢�%#¦ ‰†Ô:D&”/·ëµŸnØlúÑa£Ûñ|*ãÂ5RýbÒõJUo벋BÞÙÏ”G—›Á�Ò÷9®þFgjóëïÅcYp§ü!»L3“�wk¡K0ìV*„ß/€¾*”ôXÎŒTÎþ¸5ïË“ÌP�¹o`£Jb£EE¢®�†Òꪈ[Ž�o劔°’Ϧ·m¾äìÃ~ê†#7õœ`¨L½ØqÙªLí�KRQ6ÅÍôh¦‘f2Ò÷%ˆ¦‡3‚й–¦¥TÂKº;¸ð±û`±ÖÊg:UÉ|ü…�Éáú»Z“ˆÎ?Ë1iFG› ÷=¢PûȆÂà:/]#77;<óÝÏ‹	›dêÜWëqÁTt¾ãÎCéö,^áë¤rÅ�€l„ÚÙœ�#7‚ÖºAë1m¬b¤)Œ7ºÔq‡”�gÒRøQ…yldìÖóž<Öü¯Q‡V~\êx?^zñë駊óz\!º[åÙܧ;´[º•iÅSãgT¸k¹ ¥J?¦­5sä±uúF§ÛNu²MÄŠˆ¹íMh¼.¸¿÷çïQâ=ïm&7#&X”°oÞÿꪞ+éˆê*h‹°]»~�‰ý9¸}º+´À@¨ºœ4¹CàÒ"<¨2äVÅ‘d&({ fuôË_´Öcí×*‰Ïïô’ì0tºÿŸÇ¯¨¿+ë#V«N_¬úÜ1Zë	c“rËEö½Bõ+æ;µÑÇnè½€pÞq’ÑWdõ«�q¯GC…’N`Mó4‰åéæ*çûWÛwïЭ}uÃìKE7½oèÌ©ÑÂSKû
Тt��s4õ\é˜Ú1tõ>ëE¢v(Ý�šaÏzl„§›Sß‹3ý÷ÒN±ß|êšøؽ<£JÒu…ì¯\]
'úýëºÝóÑ�ºM‰ÁÑÚûá¡ã¢\Ò¡aá9½ækÄ«óvQ;.hEdÃø4Ù),0ÍŽŠnù–ÞÝ[·”»¢×Ôðo˜#otpÓþK÷ÕRÉ›Ó?†2øýs[`€;žöB'{D€àv%÷0/uò¿“<‹,ÐÑLc_2¯õÆ°ÒÏ4ñjάٹD 7Þçé”D«WEÑ�rÏ<î÷¬le
°jP¿‚³-ÏÎå>9bê¢Z°UìU ßsFú(çÈüQs.3•<ðsæ¾³pR:ǼïŸW‡\I�+2ÖܨãIHwæ�TÕ‰’�jª’Ÿ¯Økìÿqé|̦‰©V/ÞÙ{kö»ýGV#Ïl’e#8”Y�Hö:ÌÃïëóKÇå:��‰[X¬`ä°ø°én~ùrxz|¶X,sQ@¹•WëÌù”D´„
ý‘ièCFÚ—Ø'$F/ÖEšð„i…=]®Ø^Aˆ(±U	/w /.·.N¿ÊèîV:9kuÆŽ‡šÐö´»Â¬,»°=«§@¨ø#7´BB`SBüÕp³]„.{¥“ËVAÂ`ŒÓ‚mÕó¾¤6�q¡‚WA× ;t0}È9G~…¶á1¬h¾]|ø;šJ¥
Å<ÜæOòš_Ï2“¯#87áã8J8ŒáëÏ!„Ñ¥¡X#8S—tFTs–�UüH$P¿Û'±y‘ÞðÜ´?D—ªh®“,Z¬ã#&ù	°Ã5šëŠ ¢ïs9QEq“íUÑAûèØ‹0¶¯¼5bQÌ�±áïÉ£¬¾’鄺g�'+C)N�8œ!Kì�×uâ&Û^tÍV£Tl¦Ü£‰ „b7�´>ȵïQ˜ƒÚ†áªéRœn’PášÛ*lqs›Lȸ#kÚ¿êæ;d4O'@ø×¾>oã³V?ŒdQlÄ‹Y8¿SÞCp¬š$‡§qÃ}k«:Ô^o‹‹¢/Åâ±é92­qŸ|Š|ŸÀ¶G{„Ó0þö_ƒÓO¶ÎžT{&ÿzëº0îðT£i»suÖ|&íÚáéÖ)ÓKßÊ[Óá‚.ûú6èQ®‘ŽóÌHèd&z¼¼ÕqëáÑ|¶:)Ë9˜ãbŠ,:¼o)�;šÆ¢x¸x­'—>žoÕÇ3ÖïœëE:ïíþš>˜Ûôh×ñê4 “«¬8@¯¦Ö¬ìYhÀŸ/ÆÎA˾Ê×Ì–³ËF1XÆ&$‚HõMŠ/å‰hÔa*ºxL¢Dñ×$H#8,šW#&£'È_káƒËçÇh‘!28ÂVó?Ke�ú^±Ì¹â™¨ºs{—Fš]œ?*cE^æ:ÃÚ§És¢Þr�²a()6­ÊŸå‹²HÄ6?†û±jüúÀWO쉼ÅG«AŠð‚çÓ¾½¯�óçää*É/h”•.9Á„×ëé™ûΛ@ÒãžýÜâ} 7ÅC÷ıïvô lôv”s�±ùçŽqƒÔ‡'#7÷wöϯÇÏx0|ôŸ·æ¤øÊ€4gW=˜õ«¤‘Má®_Øjñs#8
ÐèÐþ÷_oºqâpg�½˜qJ;Æ‹2?Y‰¾bÞÈÞ1Ï9ôg¢×zŽ¬#]t9
Ë!7$�;L˜$yUùuCT×uh‚!.ÿñÆ°Èžü4¹aÛœ<aHoAoHÃ�ͦ%01�F•Ps§œ£qÛËw‘&—dîysC4òhY\ã�aõºð\'uh�¹_0úÓ0…—C¤B7ë{Tt¼EÀ•/MEä¦Ä¤ï‘g8+ýtpa€×hä%#&éÙ‰DöÅúu×U¥¨åAÚ{|ïè„=¾�k:9©L~Ý­¤iôLµk2#7.Tç^¬g6íìMp;,båüˆ(·%\LË'½®K<Þ~é=nr±Ô¾šðO#8²ÁN½ÞáÔCÄjw‘4Ùå=%@@P¤(&w4£…ÏV<Úõæ¼#yê6õ¯:|�&wÐ
d¯d@�r=}÷
UliÞƒøn×Õp#8‡ÛágÍ®à�Üûo¶û“Oj ˜'yv`\3#Y#8^Ȥ†~·ZS_Éæ|¸¯x×ÃÅCÁÒ¨²vÇdÞñ·0�oSÏÔ)w­TóªvÐM&Úôð‹Ý¿¤6ëO”5®‡?´üƒ^)i¹”4ΚàáÈR°÷ðùï	ðv/2Õž?½à�ªÀáÝYnš!Ñ‹1—(m*OŬX|�„ªýŠcØ?!Z@¤éQÇÔn@­TåNVW¸éGyu—á}£<ÓË	DÃÀÎ#ñ^#8'êm1‡y›4«í‡³„\¶^@Q”tÅÕI¸5ô#7¿´â!%$±,E‹W#™¸£Œ	3!Hh(ïú�™#&ëŒVÄñ'EÃ.�Í¡,ÐÓ1JÍ©WÚ*NctÄJµÚCJ<¬ÕhŽL0}@”Ø@Á”,ýÞ¦WÐ6fc„n¿ÙÍô�
æý#7ŸÏéÂÏÙáäOžÎ]vÏŒ¥¥|9q(#&`SØ©ôû
§÷§êOÙö�æíŠ	hfà:,ág8ü'	U…¶8;q
ø+ª&n)›Oôg“ÃPXeø§À1¥0Q?¯îçbTEö{o#7Âé’ÿ3¨þ ÕCóÿiú\Š!o]ËbMs]>_À×›uu% B%bZi¤C¦úû3íêf\UÚ§¬aá5 a„Œ8ð ß€v¦Wþ©†E
Cr=S­„´8K’T%„'ÅzТ›€2³!x�j¡¥e¡#8	©H(}Är"”Ü&ëÅùH)(	E!QUý–§!È
!¦NÝ|öÞÁ„~iä³rcÜì6lG)+r`ªŽâ¥Þ´çdNõ�ôÊ~œ³	‚ŠX*�>;Ú>š“‰GH‘/²×¼?Bó?Äsé1b	#8¢JÌ*øú~sûçóî,µ˜®•#8T)¦ªŠ�µ9¿u£“ïÞl`Š Üåo±=†—5Ð#&c—ÙeQé�ÛVàà¬#7>P#7-§SƒÚ%Ϩ}DCÆÐ@7Iòú é»ç#ï¨0×™ˆ„{>RûuŠŒ�fgC´B¢Ë�#7œ<4¦Ë”¨$k¾Ïœù‘œ¼†ãü[øz?7Ò­®…ŠzìnbcžciŽª‘06$»úR›kHsúmsÃʲ
ßø_ßÅÏÜâ)¯ï¶gØuÄsÜû*»EHPÃa‚å�£÷`>lk#8L}UÔ©¡ý”1µ†Ôé å²o™f,öTjŽ¤Où#8V¨”ÿ#7ù|Úi9¾•Â³@…U]•ÔàF�ì5ýK÷ê÷þ«™à¸•hAºlKÙ:Ú�îPŽ_±ÙgíÝm#8ú;c;žÑ@8½F£&¸d/yŸG ëƒËL…¡¾öÎë<_îåFˆ>8V»4€�&¨ò‡ó¾~7{íì{Ûî`õ00z	¸GŠk4‡!Ç#8dXZÿmN¯f(e�û?rŠ’e)�Î膵AI7C§çÿMñ`S#&ÆÔ{&Ü­¾e¯ÂûîÞ#Å_Èy(Š˜†–ŠO¯ÃN/|‡6xίyW#7L>¦�³M¤øY�z†IYðj07:bä™Ý×.–±R] Ây$(Mw.J›ÑîÞ÷…‡ÜÉÅ{	>Œ#7#8”wVT«Ò©dA£ö*#°¢ÁçáøAÃ4ubU3.´‚õ�áWàãÉìvŒ¡!ñî{A#¸wF鸯š…ü\pWï¿dÐ}—=½·‘†È…¢&šæ_Ž?•ŒÖ‹¦aÓãÂ{S‚»óøóÄÓµU$÷qh“þTw£�Cù÷nh°2‘b³[¾ñ17ª,Å€Z^‰sJ¡ŒÊH-$Ыã\ó+1¦p#7,.O’­ðû8åßY/yÚŸ²°ÍÚ&YPWK.¥Wé�l\ýu#7=µŸÙÔðhâQH'š#7f2É�ìdÿV6†tÍ�{òýÔÊ< ¾I à¥õùcé=qÛO2ót’긿Žew°¯Ù|;ò"Ú"7sãážC¿Ÿõq¤úBËϦi9ÍÕ�ææˆ?ª9ò"·LŒp*¦Åû[ž×„f¸4E”{ÑOV÷¢b'?U¶±‚÷t,;"€|\æCT°¤�.{x_U‰>eÈ’­uVÉÜp�·úÌ¡¬ÛpïhÓH< -$kZ™o÷PÀ’:�ª±–œYblM1>`5ÏÛ°G-rÆÒ`%ࢸ¢£�mìI×�øê^sÄéü"*´¥B«ÌÀ:Vëï‹õ­|uCZïÙ²ˆÍš3¡‚@ì…Ž!Q”ˆMèX³TVPxS£¿Àq³‚ ù~^ç¸Óp#&_�\zowí€<g‹£�}ßS»$àÂî.#8oz½Øô	]¾/N:|ì‚*@ÄåñTÕu÷ëÃlR•>0‰�³èòôë¿»±<¦¶Cʼ�P:¾Ã9›[³N)lP1(£-ð¶0`·#8y­ÿ9C³H�!©¥"“v†l=ðþ×ïNY=M!ÃöÁªz™ô²j—Ö‚j’#8¤ÕzÕ*'
5IGZç¾,¤0菱Æ%¾�=ÜE÷í§V)]]!Tñ,-Æ:³EÉ„Ð@AYa&‡ñÇãÎO‡ßƸŽ$»ù¶) ŒAÞRÎ,Ü![Ô[ð¸EÃ@U²[Žz¦†  ˆl„?)S²qèàE?‡\œ}	Œ¯žÈxPÏý¬ê“zKñ}j#ïÈþ�íöc~Ê°ë'/QÅ<¿q˃2s¶ ð—W…Å\#8®8êu(tŽ8°º0Á&#&D9æÕ
‰Kšowœ¾÷“=ƒÉå–n�u‰›â=]žaž <�79‡©”5÷íóÀÓNq¨-‹¹¨KôétÈ4º7ó§sØ6è µ)ìÆp½žC�Òn¥]iÛØn{7Ÿ¤Ù§å¤Еh+ŽR	­³ƒ©o̪Ç/²ñÓ3y¹nSD_Î2’EBB!laý‰?œ`b°¹áõQnÜ–ú“Õæ–»
¡‹rö>ÕLoW	RÓªCU,Td“Ÿ±UΨ¡êðŠŠ¦èÕ,uÓdN×"†Ú.A#&ƒiDLzÆ<¹ÀzŽlQ�"
½ô"Wuà‰…Õ—>Ìd#)‡ÈfK±²gž#8Z‚pæ>�â�¯r‚O·–�ûŸª½>“0ÙØ—~øÅ	ØQ$Ê<¥PêÇs„<¯²ç/nŒ˜aP¢xeÅ6"W -�áBË{Ü‚Ä�Ì0Nƒ|Ü8'Ø�¸3¿§œ†ÿØXü¹]sRfãˇ€L̲;²`d#&Ž%#&[Æ厵ÊB¸ôªQ„¢Ê¼ž×èÜ#£ž{é´�`€¸go
5¹¯#ºo˜€Ä,Q^ÊåL\õM,ð»‡�ð˜�0ë|,ŵ±º×è­Áfÿî¨,›2•Xiízœ÷•˜�÷�´¿V�<Æ?GDj€:2äÃ}–Ž ÞÁ"Ø	 #8-{¢þ>Qm±$y@Îl‹<k©m²ðGá!ŒÖÀçnY‰Q`¸tqä GBä/» »	%®¶çˆó‹ØBõNKÃÌØ!Ó«eYç…Cû.Í|`Ä‹à´ÓÎŔɧ¢JKDHKèŠðrÂñO&ðþÄ_Q®@'qæ×7ÆïßcVôtGÉ4˱ÝúñÒ		Ѳöîæè´Å3#„]	¬ÏL²ÍO¿–j£Yê–Mœ0@-€ #!C;"÷rÀA".!狵;.°â6ƒº°–Zvm\á¢õ*¦VŽYœïÝÌKO'ÙÆOŽŸœ»ä’Òs=¹ˆäæ_PìáŠøklb)ÒìÞ¾°&G¦+ð+�#7¼wÓ×´ÓÒ²Hí4ù)H'!àç2ÆÍý'Ê¢›6ñš@�MqPó¢ÄXOXa�H:x¼ŽåWE{9·u‹cI5”#7ï!sÎ[ž	#8�R#ÎäØ@Ä÷:HIXœjå�œ´-¦¨SPKøííYß~}\bIsjfç^5á4¨·l`&…3ÍÀŒÈ'“a¶ŠP0•Ï×nvDö÷{5OW,ؤáâ™Ln^OIÀ{
ظvØŒ«_“¹ãnƒÕÅӳלðÞ?éðýœñoÐØÂ(ÞÂZgçþÊÞX»Ú=ò÷›�Jªo7Cœc
â#8<ÏBÅ$'hì!J82†F®Íù¸ªª ü<âI²4°�I¸ê"èÆäG\I# r.èÚ‰•ãÍ'Ptµ*p Átƒ¦ÔR^ŠšÉ\%ël‰Løñô•Ê‚û«“do3ø¦:Óá_v›ß¤Ý¦4“æØÉÒ ¶®œ4[ÒßäÊnBjt–Áœàæ>�k££íß»Ÿ‘(úoÈßÛ†T©5nRL‘�k‡¡�ÓU·£eb„Ý÷/·ö½µ§jBT’Côpº‚¤CµF,…ÖÓRÌ(%n”«éfO@£·þæT¾¨ñ4çÁì˜K5®sŠiýþuâ€1òòòð¦5<:P˜Ú r/D€õ:ÔÑô꓾Êeœ?£bGç {ÎÛVólX›²ª3ÛÂûùlÍUuª-7‡QÓ¶EÙìRPÆ*lÒŤ‰õÕ¸Ra:÷í5â:s”ÃTÝx5É�ÄZx/D€ùá|WÚ+(áÝ­Ž$Á‚Ùp™Dyb;vvFi]Z€Ô®Â&jˆ_Ѻn·âäl¿›bSò0ŸÎB¹‘õ¼3ÔÙátcM$*™·§BÙ+Üë%ïdö!?ê"ªÁÈχÑaÓï_àP>ÿ7Ë5Ñ ÓŸæì?æ˜Ãn}	Váåœ##8bÙ
FE ;m#8#76#IEVúÿÕÿOÍö�SL÷¥#&kþ¿c9e×õUCüðCþžB ÅÂõ¡ôi®þ5¦¨ë𠪩ïÚ@‡ûÙ¶OÐ|~]�Ž¯^óù{}Á„?Þ“Ú©õççõ#W¥¿-_v¯¦_¹›dzõ€@
ýÇãø¦û�[à$Ÿ³ÖÏàêÄ=“#&9R›è�#&E=“#8��òÞ¾ËnoˆŠu�w··w P›ékœh8ÝVåˆ
JHOjU,!4˜ ó0¨<q=P†2_� ¼ÙLF!åÕúÕK³KE7åßÅ©“lØï¦ÏT6ßmÀƒõWÌaɇðüüÛ1ñi†‰PëiÉÃîéåŽ#žó{/ou“�Ð{è†g1R#8
ä0Ï*øÙÉä'K+Q£ìݯo%E6Ì÷ïeÇw&êV2T”'ór—F=¤¼r�<›áÖ~‡ðîß‘ËÍÚ{D0ä¿%–�|}¡¬óõ×’`šk!êËҺϯ×ÇãÖG�³¡Yâf|hdäÓ-(U߬.ÕòóË7Ùƒò£ýÐóääû\>u'n}n“ôÆ�¨¯Xß~�?ï²Pd\[­QRÃa#8õDÚA/ïÿ&IßÒ £…yn7fˆjÃFA‚¯êBån®gÔ~oñJerÏ—ïÌÉËíòõÏìõ`"}#8‰EöÎZÅÿ«R¶ ÷|?ð!åõô±_~/¿�dÆ¿ø¡Èˆ{½~Æv#&üd³{ÏP¹5Ô£œ¹8s7Qr@
ÝWÜ`s@Ùå!¦>†AN�'²G‡n®ŒI‚­)ž K€õ�=�<ú�°i�“±Ð:?Ã=>{
#7’:§a‚rMˆ•(#7�Ž»G¢ŽÎ”4,£6*OÎÂ	tCboÖÉ?Y�È€e„®“ªaϼ_
yèäæü�èHMé&”M÷R[œ˜nC�¸ˆó>®"Aâ¯öB…¶|�8ýÇôþwOýÞïgŸèœñâÈ�Ä94è’ŽqR_§êg‡€£VæVÔ‡ßsáçàÐãßÌV�ù1A·úè\¬›;4þÞ^	%‡>#7›™#78ˆ$�ŘŸ(€ž¿+GÔ8.-þWöÂ'qP½m)܆í5ßX¤Š¨§i%Øéèô-üuœ×–ÑáI’»ÔŸ›©{AÃßîslçY%i­Èþ~È
&Ã
·4zöYÒ¹ïÙQèqm2$BÒG†tÈ!6ˆÔ"��qDB@‘�i¥	Ubº	°‡„DÝ÷mw&¬‚ŒB¤aê\èìmÜ~õ	°/6~ýöâ$ „ê%Ïø굞P³–™ô¶†Àñ»7Jê–qQÀ\Õ¨�Šlb¢e‡ºøJàÑâkSOu¨ÈÉ&žžÚ²%Õ¥íkmpÇ+,=µ_ó8öU>m1MDÐCŠcË6ó­t=1mƒÁ°ñx쨪Ý÷ËÌ#8áùXFtC¡y	ã&¼_•³àô£ØZÓCï1©þç„8 gÞ` ÁÊÁ=àTx²E"nÚ‚¢¨GEÀ~é«�/C°É§ÜhoÃi]9•Ʀ‹"5¢™¥K5¦d¦,}7ŸBû¿Qž§]ÝÉÌQÌ*¡ìî×ݬÌ&Y#7Ã3Û=�ôÝÙæ<У”Öq	G3K“”ûLY&!Ë×iž”E‚B‹ÇH	H ˜NQà‘Ý88ò3ù�îÑg¤
hHŸœðq­½‡–°ü‹6<î÷Q©ÄdD�FIàq9ÐËÈŽ=ÓÜÑÓ¨¶“;ú‚ö!�¨Žæ!˜I#.Ù4Ócçá¹C7f2y1l±`Ü£dëÌI	ó#&áÛÓuÏP>äÂ#8겓t€ °(=+¨ðˆMä…®i·;p(É	hC£~ŸÇ<5gÑ#8]³ûúžGižC �9uZÒuEï¸o­v¹Ù#7{M$ÉÝ;á|Âøìð}r¢�ÒM’‡±pŸÀ‰<¿!ðD0¼ó˜•®ŸµÉ2=¾ØÚ@•¬æž)çåEW2µÁ’“;Ò¤€â2E8‡R,@- êÁ�b4@ê#&ÆHš• ‘�0”2Øf“0Ïe¬Í¶LÚi¢-èÇ$¢œ6ÇXà¸Û_,›%&Œí�›+
T¦£Fk€æ%ÍY«¸:À>Ð# ìhú#ŠôˆùYµ³ÊìrC«ð†Žy!ï¼±Ñ<ÏÅy¦i4xì6åiYÀl’,Z†¾b}{ä[úë‰é_eÊð)|ºúVL)öÊÏ�MòŸO;‚)ÒIÍ Œ!‰JEª� hb<ØÀy d›"+T=9²Ê´®¾y#81åI´½çË "¯€Ã"—ÜšA•qÄ.]˜£ƒ›ð2Õ%#8™€-ኤ”ËV]‡T7Jä·úÖ°vì¯Ãb‚$ñ„Ì#³6>Y½œÖ%O˶-™Í†;ˆ
Ò.ŠRÐbŽï•ª-zü{Ách5¯tºQ¥Ý¢T‰ûÜÿÕãZ‹ÇßDã�oä�§wP2x‚¢UK­xvÀF"¬.Mªz¨�lë—f¡1æ„‹[Hä2ÖÎÐ5n‹ëƒ®|cç=€g¹£È¡ê£(vt±@˜
Àˆ BSúÈêž$V{­[ÈèÖ›Y.™¦pJ�yv[<س‰Cé^•e#8P²é!Pm†À€ Ÿ_Ï–{ù÷o#&öžäûzHÌJz`·�;1ŒâW¬ñ¢c™AÁ'‹”Êf	aÕ<	#¾).)·â+àã‡~)‹5’dRR†¡Œ	.]žü,9ìoL©:Êd!v¹�¾~\äcÙÝðc¯»•wOD0r2`á�ÝAŽ¬7¿nΙÒõ<댲˜2b¾­dÿ�7ÕTvŸu:â¸>%Ë(2ˆ©¢«ÏÍ!ò¥‘b<P�)~$&0qrŒ 26ÓÊTs¹vj»ºSd±й�–‘B ,ßSÆl/§qê.Š}]1ßGX~U«á×Æd8@äT÷iQv(t¯lšNxcé5'G#LÀ?.U9RTCà;ˆK	ï¶�ö^Ùå’<4±¶üq�07	h|¯MWcšz‰ÌwñÙÔò=EÝÀtâø¢oM;wdÍM ùQ¶Û°'ÛÔjfå3mÀt=í'ûðý`jâ`¨MÖS+z¡$˜NÀ?#8{ÓÅÊ{6m{Ãú~½pË#GèÏr9÷
4ÔhrÝ¢6•˜¨R³$1¼#yGñóïÆO*61(–„Ú©	™Ryº#8ªdZ®-€/Lå›zh&´›*§{Õ$ŠÙ<Eírß”R�·µ]:ÞFC°@ÒéGZ¿&Ì'�ñ8=:\yzGLš|ùI�X,—	CO`pöþYôo¢�_	-3¶ d#É� V=SøOÑ¿vO(¼•ê哦é#r92È̢܇к» 4²P„�ÀÕB”O¨Å ¥õiˆ·›¦ÅŒƒ	zÐp=OŸ–ycYÙ;p•*²ÕS‰ž^E¤“î»Ø2ÚO�ÑÅͲžUN¨ºŽXHüŠ§T�Å,ªí4ï¿vÝúaQyÙ=s7Ì`ƒ"ÅÞDÔ¶8:Õˆµ#7|Îü`]p0ånm±Òò¹sGß	ǸÈnnî³�!xûºt÷íïíþ<`ºxH\�„‚L“ÞUŠ)zàpO­wÚÈi#&;弞�ÛVzÚÞyÄÆGâghC«dH›Cz´¡ÂeaB…B)$ hKž»2’âiÝuÏ´³ó‚þU},Zº®×ÍW¾<äë1惧—ë¤ !sÙ®«i‹6.gÞýUuP¸ñý™Äõøüײ¹¨iåhÛÔ÷Ì�ùË#7,††&Ûà¡õ �ŒITêBÉÍÍõ¡~,†zW|X{´0lRMJ ;«‘Ã"Ö¸/5äox_¼:÷ÚȤ\BŠ÷0r¹å9™tïöMäóÙŠý¹åB–îÃú„3n(<Æ=-¹³ž P+#ÐitÎ'R§7ϬrçX_ZÑ„Ê|8í ¢Ae“:“…n³ î¾`õ9ÔØ{ÒC}:×ãù~·8{¶¿\C“D’¨aßGaAb¬‡Á©#7Så­‘�#72æŽ5@'É!‘<…TãÕ­˜�uÁVl&KápäÁÎÞ&Ë(±¢ú±ÝÌúÔO'P÷)ö¸è”»o‘7îüdÙr^&M(å]xÃi#7„ìrç5<Þ+�E*ƒ™Á²ƒƒõ?zU� ŒÝ:ðe
;´lc¢:¥	0òâ~³Ì�6úE§ùe² öô3ä6™Ž�Yˆå'É°¡7$¡Ø	AÈQ°†6oÁj#&Òi¹Ï‘ÙõyL�.J×z‰òó•ÅŽv9œ`v�óô>‡v r#8;ÐÕ¤hó…õHQ©N°÷^£ÈL]–Àù²8�]·®m¡Øˆ:6<L1©È»ml\Ü@I±U\X„UD` #ÓuQ¤Ö2›­ïµâ®�_¡µedD��kgŒÝ=ß%‹²ýê*C®Gæ	Aðhœn€æeÄ„0Ó§ÜõÚߺÁrØ35ôa¦Û]eÖÌ�¿$x¶�°<ºÀòGʤ'&Af¼(zYiãSÅdÄï�îÁÁñªüÇ}w8õ¨YšgfÆÜ’â$;YØ nÉ�ÈßÞ¾Çí¹evøôy’
ïª:s*#&œ¸ªåË-�rUÞ<Œ÷†�bhXÉœN£F>½¾Î#7¯8;n��âƒ�y#&Ë4ÎP؈…~ GEfx3AíÂuìa««¥a(y‹G~Þ=ýý=¼ó´=‚ ºå¯§#&©Ì@ƒgÇí²Ã߷鳂l×ù¯ÅÌ?èÁê9�ù¥hPÜ„û1R#71­Ò·†qhˆ‰ÈDÃçù$"#81^.úo¯µOJ 5|Ñ’ ë=nOk7a͆IáA‹þwåöHöÞœ»ä¹½VŒ¹Âc;oaD$u¹ïþ¶`c›ÃrÇÁúš(gFV#8È#8Õï@nÙëÞá\AÎ24õŒY=J[5±Ìt9Ä—÷ÜŠ�—ý#7>͸Ã=XÈI
J×C»Œ÷gÞœ¢~Y­f'ßQñÎÏ©. ‰pa5‡Eóþ/a‡íû¿Ó†.Ùm³€€óÿ‰:FÌ#8AQ$ŠCUr›!‡Gígëÿ$öÝóÁJÌSQêŸ3˜¯ø‡%ä0(È¥ÿz SA€Â´Ÿº®RSצ<|¨þ:‡Ãv²nü"�Ñ¿–;$1ûôúÚõíÏÇãÃ9¦{t €
ë^hÀ#&#&åüÇúOWñøO/Ç÷|¿ÊCù˜M‚ÿ·üØÂÈ>µ3|¶–/±Y¨µ“9ðŠŠþ‹ÿù+0ЪޮZ—QÌõ'¼w}>“ÖìŸéU‚_ùÔQS}Ž=æ½þ1Ð…/3âï²�#&AN”£Úôz"Ë㮂^ûmt®£®NÚãS|t“(]Í+ü°ŽvïØýŸ¬lm'ûc„’#7R%w�ù@àÿÍþ÷òØ„š²'âwiÑÆsøÿéØí”S¤†Bis÷žœ»Þ]|êÔÍ3γk~ÃüröÉ�/�.Õ-(VÐíªŸìlbÜE¦Pùšï¼pÏø‹ÅÿgðÛðHqÙw?ÍrÇù§øÿ I0ý>DÈÚ§xèIÚ‰/˜ „#èP1e,XŒ\Û³½·�ß!4¤aƒª&'}÷x …µt¢€%3ä?‘¬Oj‰%P`T;›‡.‹òÕ»²šžu‘ú?Ñxÿé#7Àa׫™4™Œ*)�7S»&æÐo¾Œy÷JÞ2OÌ�#7Þ]¶ã9§³—xð’bqM£É„4kD#&j¥¶DýwÇlH6ÁS·Ìªÿ¯“:Ë¿ö´5{£þ*DÐ#&³§ðDë�Ɉ%3æ`À‚C*íF&ž‰¤@‡Ìæ|l¾·bú.î‘�6#8,ñ˜³ïø|¹}×Rè�̪RÜcõýëɺ2Y;'  ˆ™L_òò>Û#&ËûÇË><Ç¡ÒègEâpؘú×Êèèt™t™J€~߬ï²{{“âÃa“OyÐå¿ìiþô?“F¯Œ�ÑùsÀî�®zÛTÏÃ!¦�ÿ!…ùuÃÐ�‘U]¥¯ÁEh‰Ik~ Ì»vÆL#8~±98:ï^î�Ò6Ýêão�óÀgš(çš:4#7hžÓÓÑåÚ
PPªDú—�ã··»_&éwná×âì;}ôäs‹¤!|‚�½#K&ocöõW©Ìp©åDÂzflSî=jd+ºßëÈ“ÈýAª´ÇúˆÎ1¡�UVèºìŒ�…ŒÊW÷³3‹ms6Æ@¥=H
ÛÚþ€PNß5d#8AÊD¹Öö…þÍF§£ôü�Șxåó(P�I1QX`#8úð埊pùxë(½èSZ#;·¨tÐwA®í ‡¹W iáêÛÀyɨé™×æSê préÈ{-ûëá(Œ7
G�ä8klÕ z�6�¬î÷++ •øs®½á÷ŸéÏéš>“ù7ÿO͸þ›D>G4W·#8zkl|Äï‘ê\_ñ–‡'¼5L\##&€f‚ýïpQðÄ"y'‹#7Ž„K<Ý\zP#&ƒ¤§gÍɬÙ7Û믎¶kñ†�ј_ž/s?äk�pÌÐs²@#&Û>@ïË׸m€’#7^‡ŽÆô�?§Ì•3EN¨z´}<ueðõ„ã츢Þ|ÅÑázødú&tÁèƒùz;IAÛ´-Gô)\þ^ÝÝ2ÆÄôt(éÕ~ήË"ˆœ.RÔ‚-ñý¯ó¡óÃäþZ.#8fLKŒBfû¿•}mÚ�¯JÅ&´5/Ò�3#&Z¤ÚÛMJc|kŸŠ‰äç†#&ðÅœyuiÅI¹>)¸
Š'¥Es¹¨©¤º«ÅMT°
J)ãÁ�Éxókw%vIö\¨SÊBy˜D/s3ˆ·åé¿ÎHVÂ?'Mî½,‚JŽ¶n¶�Uœ¬òQ™GõÖ��$™1ŸVÚÚ†Ëe2ɨ�nÒa\»,«Òº|Ï7ß¿ßñ3é8)E‚†A€ž‘�£¶ã8tÛ*±œó¾Ž,è½Í¦—-þ\‘ÓEÐ#8ù{¬º‚j¶ìWíÉñ(#&0.1­�C%tIuܺõ óTû“Ö=áψ‡'¶“MrÈ&ïø9‚#&�P4ûÐe†y�£#&4#7{6�·.‚ý®$ª“xVrwLE:žH'QXu^ˆ•‚9ÏWî)ý³ý£ÐŽö­mp�O,*Y¼®]Þã‚o,#&NOéXjÓ#&¿•OÇâ6l¬>Š9ß5ÁæבöíêÇ?" !@ 1@{0#Ï
ÃéÞþ‹ãú÷ù(=©zqÝ0ˆ2 ;z¢¶”þßv�½ºÛ¯õhÎîœèî–{9î,F–]ˆåúåFDòe°‘æ¿ëŽïÏDÁ#&\/ÌRå»{~V|!‡ªöGu€KÓá5#7GÎRGÕ½Cž{*Ãá|*ñ&I0EwJϹ…Ô”ðZQ\=w�P¸<Öz¥ïêuÚÃ^<?§Ø®¹ñÙ€v#&‡ÃÚáÖ×ßäþmñ®Js6µ\‘º¦qƒ‘³Øÿ¡”Ø…,jBäæ�›n×Dî’ƶ0Ê/ƒ‚Õ̓‡g;Ä6	íý”ْ΃ðoQgK¸˜xQî}÷ž÷[ˆs;ž;檫Åjx1ý•ŒÜxSšæ­)”—–Ðlb»[×¼øA·ÖˆIlº¡ý9}åÑi#ÍokÎ.©?kÓ¢·½½•œ¿TøÞ#2¯´´wA€©ÂÞ„ÌÃŽ�°mm—l¬�Fz׶6þ¦s8볺Ù÷ é¾WÅTÝͦhÕøG»%Hz¡‡ªCÃÜŽ’•`¤¸÷”G\†µÿ·Fû†S·�(”x±š<Ê·¼4èÀãƒù°n>]VóT†6«1ùÕP’!@Dõ·f…–´¢NÊR¯%Œ&ÜÓ\È•'¡Uа@>Š1jÄ+Êõ•LJ	7íQÊ�,07ÅhXñ…Œ¡Ð˜TfPÃÐs�³cžx#7ÄüÜÞÌ�–ãÑÛØ¡=]®Võ_<?gE�ÎÓÉ沫cLDëfSœ>¦{"¦of õù\|›«Ÿ¸6�ú•`£ð5MÇŠ„ˆ{ŽQ¢ò„åÄu,#8®Â÷c×g-?çé™aÒÒ÷©iËå~¸¤Î$r®göoQÅ‘Û—ø2¥
Pu\¨C)·S ‹¶ù÷±¤$aµ’¶åpÆ«^'êV‰¶ÖNóXÝ=ÂI¥ö	 �±¯lØËøIËÇ\¨�óõQïÃÃPö#ˆ‚$Ýôm#�:)]ù]´2¯M£®\Pc§U£÷B¨WÍ7�QÝöΌdž	ÜÛÆs�d¬äãÆ(³ô91;¾!ëï¬Ç_Šœ"wñŠ:ô×ë:ísª Ç¶Õ¬Á#7X ¯ª½Ÿš®$ÀLE Ù¿P½Ï¼ÓœýqA@$@Â17½éÊ.ÁÁƒ{,J›Üí³Ù)WI$“C‰iºÞ¥Ð»;ßž&Yl'ýIÔK·×Ïæv(¸9ô‰÷mM„pW:€´œ£"[Ú [OŠ½.øŽ!Ó+‚´÷.·¸kUÑh¶Òna#7¹I�飑Ê4O ¿)FÙùÔG|sµCäá±ê¦J¯WíÿN®—M]¼iܤC¦_mA´ XÖ…0éûΔNñî;f=ÛúغÁ4xÝâ÷îÍš?æëVc5·I=b¡šƒ)lj'7•]3YTB’•êÒ&ˆ¢WíNÄPéVÒø¢�~p}bsÅ3‡É!ϯÎ�º‡I~ØWM;¶ïåÇÎý\J"ælCÓ¼¥ä³ðDµó’ a°2±!²©%âR± Ûe“­”–.˜¶:Ó¬;±á#8c¤“»Ú^)ËûÝÅ6Ñîë3’ïNéÝç„:¹ÃO‰¶qN΃‡q`Âr»Ÿ¿oøövÙ}iå¶~S!šP“&tOszè_ñ çNaa×ë©)%8ð�?¯h‡œeðÙ™T»" C“¶óJé´åFOæÖj¼Ÿ9Ï[|µI-®zÄ"c´¿làÐ�‹#&G#7+�À?]Ë\õ�ÇU®Ÿ‹%uM혠……Ý<Ý#7{ìQ2úB¥¥ùÞ3Œê™Œ³V÷L]EéAÕ8³cEs!»Kí^åx&$
Y(»}ý]Ídl¥…ˆ]åâÓV¡ Òyvtæ%÷º*4Ržß}Á8h�ü·.�³Eg§Ù·wÌÇ—“Ác¬`ÒËÓJ\BÌ¢#8ÎUµFeÅJ °ÇP*˹hv¹ÐØeò/÷;ïÓȈÊ~öIÝÞì~§ÃW8Ã{š1™#7–e�ö3ÜpÉ>úÒ	£;)ÉéºXÌ1aÊ…ç	CèáܤW�9;#“kò¶»qþ—q4ƒó[D¨Jþ2û¾A³ÜE*~²â×%TdZCžÁ‘õ[¸A„Î#Ÿ»Åü”ÝÖ=žûUŠMû(a žE›N
üÙ†@él›�%ZV9üQ#&Ó9¿-~ý0¾tkŸAk•õµÎŠ�ðÁœfQ|Ë#8‡ù;dƒ…mís”W=µdK&‚@¢êÜ̵f“†Pλ‚]à5±Ù†hÂ;¥.Iô‰¡ÿ!:øK·ªcïþzy	©lv>²OøÅ¢=3°õ7²Jqø^‘ø6©¨Ù‘Ù(³�“â�0–Äçíª÷>ßG‘…ˆÎjB÷ó|ËýNaÂ|¼~¹XãÀ«û¬fü}� �â‚Ú{¼þ7Ͼ�G›	IL#7Çè÷&Žƒ8³¹ŠnØaJú;¥¾U‰¡ÏkæÓí}f>ßgäoÆ@èÈœó-½õO.�jo$äA—˜+u}f9vÛœ
V6’äqø�‡ã=3£¡(dž"ªK�Tpa¥nñ]Xþ#8§½B‚ä4Äwe»§lK«Srú?<íù}aט!þsD¡j)l¿�Æà-x»Ø�wÁˆL¥Ã¥K¼ÏOŸ®Ù5Ç„\½”ÿˆ=ð^ºoJͦÔ,Ó1Ñ:ðw9v|¦OÒoPkŒØŸÓ$¯¯n"yÕú ç.ÀøÔqÑ5óv‰®�‡Ú“7.1R~HÜžÜÔ™ª#8ñI»ß‹«¯»£ëžXSŸ‚�26ˆpâ®tN°dµµ•ÜHR„‰—JyY%×oKºº=\¤˜Þ=¾$ÈjO™‹ÚÏtÙDV%Õ�ê×K&~hé†wÖØÞÂÓ,))Š~?;ïáC÷!Û}ì-8}“8…hø5x(1ñaØh–=ĘžÖažŒ<\¦Œ…¤ö¡x¢“#&ÜV(@Ä)åsC©EVïw èC9Åv¨êT°mÊçƒ�4ïˇ¹Hû<ê+€^œ·4�ÎåÄ`#8}¸¨ÜÊ)™
 Œ>†#&\Æš¤–VÐŒi#´~È#&ÉE陼©¼zs×#&seD@‹Í©m=��möbÓ¶AAëóJ�³—“+3í�ÇUªô&ô‚Ôö÷“Xxüµõƒ�3”nó°ç¸Pã±ÑÌ"'™h"ð�’ñTÎKOݹžÔO!Þ�¾kÎù:Kï_6:¬ÀÆ¿Í�/1Æ£ô�Zy†kW”�¯Ý§#7!x=Œ/Q#&9(c¢ÎÇ6¾¸Pñ$w€_w™ýçoìú¿ÀÑ»	ÁÔø¾ ‰?_“ܤÁGÂáØ?°ÓËýž„ðàÄ‘�J‡ü‚„„,ýݾ^U‚vüÎtÑYüÊÏØ7ýqMd©F÷¿žWô±ÉM�˜þØób<!�IãÚ p v*9¼ £pQ…	˜…㔂ï°|�Ü¿÷W²_ýæn@>C00âr5{ÿý^ðÿ'áù—7þ™E´…§ý¡åYF”ýá÷ùŽ—§únºŸ�ˆa&Ïç—$ç¡&S³v÷�UŸ5÷ü.æµyùþè Íéö‘œ±ëûUÏ·íüß&zô'iI
�Pe#§¨0\téh£~ƒ©õsç¦r‰O৤�Í:4:¤ˆ#7b„‘Q‡•oƃ£ôvŒ€T¨+\Ú4ƒ¬ºÔ"Q·*ArôŽqôÄ&`’HOúV0dDb€#7ŸË«íÃíüX?J„D>¯G
³‡T"†Œî©àé0…ë/‹€ô¬ÑµÊPwP—¸ƒ©%?Ë+’¹í?ÀÅn¼_'ö)J#&¡%<ì1�¾>(+;ï^°6ýº­ Íê3ÒýE/Ö?O£F¼çùbŽ�O—½þQ�ådÉ. >~œÞçÞû<Zç’Ü}c>pÎI–Ø£Ü	�Areöç*W³ApÈuÁƒï¿s…­šŒ‹X—­ÌÖL
¸'®oAÔ?#8SAœ%úpVínwf•Gæ¨;Ù5*µy@wâ°eG=ALçJÓe!¼w'B…(:ºPšF‘Ü/|,»#&'@I
äN‚Ý”z:0­n´4P|ßÏ⮘#8Ku\„q
`#&Xw2å±*#8»}x]s#&VE lp²±=$iÓzXƒzŒ¹¤Ï϶U!ñÔ£Tv ŒE9YžrÜ«îR|çÑ~-Î5³
Òí“¿ä@;CÃ|m²U2Lžß[,ÑíœjIahëÄÍ6“a`‹š3çŠÝËDK±'ï§ 
ÚØN&øOÚütbÁé6ÖǤÐFzY5ìw4	™÷õ
òº­wÝçNXiþì�#û«ì�Z09þyÜÈç»ѹÒ>o“žóëôÓ›,@±sÿ#§(*îñ£íÉ1·tîl³AVhÁ’„ÀŽFü¥Z”–ñåàíj	rØ8g+îðˆéÓ¨úþžr`0�µc%Çœwå¹nf™¶Y\Mr¤ð;÷fëqÂsŽÊá/×qÍ@îÇ2Þíº—§B›5”šøô«S¦²º%ŽÀÒ~7H¦âè‡lÿ0LÝ*0­¾o5¶ºÝÐ`5grsAúq¶ÛA�,'@îßb:_œm̹âKo;±ú Æ…9ìçÉÉqPo¶àÕ(À;™n@sØûqëò›#&}š±¿(º)¼F(ŽDùµÀ?Nwbné²cܶÛÄws2ÒŠ²Eܾ™ñÒ.äµQˆuð‹fÖi10‘œ¨<aI¾¬ÜÆh#|ôã¢1/üþ–×0H&?v&>Z	êrúe²È¿OŽœúý×ö{ð÷É©ã0÷Ñ3Ú¡ê̸}£Ÿ^sÇRɳ5Jí¥–d^¢8«”t{¡WnZ ªê˜ãíäHÍf�ƒµuãXaû/ˆwJÿnÔë4<^R\bÚ7ÚÐý_­‡¡Ë¢£Ò-½ôzh‡ÁëùÁ·‰ùˆ·µ¹9[&þFW<+™ÄP=áûqdRl/U°ôdÂAÆr<(+ôà£Âó	’gýeÝ·søˆBs:ãgB>/­”h½EÓ@~õGοgcÝYõ$¬&8ƒ¨x·?¢OÙ:ÝŒÙÈQ�®¤ïgÜ£A)ƒ˜e¨2¶Ý»ÜE´‘+ƒÌ§qJLRªI”´Æ01*IBŠ¤¼ƒìÆ¢�M£Üœé´ËtlYJiÓ8Bþ%j¥ÚÜ´¾¢÷Ý+Þ‚#õi‚}†ì;£Ÿ:Ö&ÎÎñéŵg˜R®Ôý©„Žfú\œ,¼œ29M¾R±ëRÍ8抪£ÙôÄx--ç×ã_Km߄ꮾzâ^Í»>çHh�n<‚i¥-Do©½®.qF}jåõR�¨‡ÉCÝ?nh‰„U·ÎIºËõÀeû¨—Zÿxé|ÑA~¸sgÔÔÙ¦ &°Q-¬í/g-Ç\âÍ0h4FCT¹é£fu‘E³#83•w·¡x¨ü,­,-:òÙN­£5æ·Z-’ÔÓˆ�?c|ôGc±#&`P”a7ƒ‚èߢÒà÷õˆ¿ä‹Ç¶†yÒAûº�.”ÃÅ.´¼§^»ëèüNÛ¤nûcYk-%„ìB£g=�Í2Q¯]®|_qM\ÍkÄ0Üjì²aQ‡ÈÂ2�“ãrß<±¦vM6o­c’µÕžÚM±‹=žùÒs"~ÝD‹™äŽÙg£=Ö!>úòˆw)—bÔ@I.N—L1Z%×S2”)£€˜7Þme(èñF©az£¯QQ¬].Ko€¯­x‡�·Mˆr%¼D>ŽaüTD£º-6¿~)·#7ØÂÀp�!À¬G…Ÿž(ÕSíÙÄ8QÛÂL|#8$ ÂðØ|Ð'�¤’Ík3$Ž¶‚xeÿOßWcòü#7|ì#8>¾Áɽ,A–tP6ŠÑkÔR£¾E¥ÏØeF[ú–®«DVtÿárýÒܵè|÷Âþ϶íw©Å¾I¸ÔM(húûTáž-¨Se½>ǵ²#7&6wcm.ŽJ™ëéuÛ™îÕÊ‹zP­í0x'H‡{st±âùÛÑŽtã±ý„ &.²d^nÙäoàëêüH¡BnÐ4’G2RMß^Ýl©þåÀN¾Ãì0ÅÓ:cØCjÕÐ%ãu5#7åÕÛr™Û¯ÝÚ–‚m+PS2ÁW´µOÕfæý?@tç²#&qv lPw=#8è¤-#76àÕöVñìßSƒÈ6¢Çu¢°ÉêÑÕ�Ô¦!ʨ¶‹œÙ††ç8é�äóW†Ÿº#7‚.Ztyw0æK4wÃ7§´wþqús·ï}†á"MÂç‚S�ÔÌž‹¾Êø'›Ñ²ý��eØm�Pv¿Œ6Æeûv…`÷›4{¼|¶(’ÔPAJ¸Aé<½=
a´î}{lYøÉàí)!&I$¾œuk[þ½ô#Œ.O?g“vüy#8av.g;Q9*�£†ng#8UøkÀâ_ƒØ�M¨@’w½ºßT~ŒžÉŸÉ§ëœ�ËÒ: «@\,MB]–Ýòókhd¢ÑÔ¨d•~“Üè� ¢Úž�ML#>	¯ÆÖn¥à:÷„Ý!›ì†)GÊ@[€žž[]ãä®s@ÈUG@Ù�¥múD5å7åÅ“ÈèüûØÛàÜ÷„‡yXsÏFöÞÉÛ/$’¡¨HG²ïÓvìxÜ"ûÚn¨òºïÜáÂ	3—wƒT‘$Ź�;·~2�½jóÞ±C³ Ö[<Ñ3àãúvÁ檸ß4‰êµ[óïsòIˆçžüŸ†xŒME¨$£ºÉÚt¾•</»A‹ƒ—¾ÃÞ�€–HÁÕ¸eˆdº>#86OpA@u„mŠ£D´Dt3JPçÆËÊFzå¥Û-Xì¼#7�ïÜaŸÆÚe~zw´–#ñu™™D¬•ôÍE(2�Áù‰Œ#&{3”lr‰P/"Ù0laQŠä¾–œíGv¨#ª8eðŸb®sÎv¦­�î�´4G‘ñÞç—!{Þ‡IBƒr†Ým#7ÅC„Ji1pîæ#&ò-®¾¼]…âRkß!æs�\|™N™ vgnÓ´fð(€ÚÇd#}6«Ùk=¾Üï–7â·èÙbÓ‚l-ˆÁî:PN¶OÞO[öÔ®»1ßió¶q7D‘Ì1×ÕäÎ�þ¨Úz–Å®ßêÐíÇB:dó>¿yw	ØÈ›Úþ'8­Ø_¼B'Ú»ú›å~ÂMy˜µd3Õ;½u¹®±#7~ª#F"cßU––2­v:T/¸®vÃÅ`;' Ž9úµö•ë’ž9Äð<7ô{!Z*oa¡QBì¡ï�Si�¶:Ï�T9fÝ@�ð´ÒŒÀ\DÒE1ê!K÷6†®¨ÄN¹/f�-Ê Öu2âéŽgGbÁpÔôv»OP²ÙÖ³rô))á2PÏçYuÂÁ¼ºÌf#8wÍd	ÆëZwBªä=Ï^lð¾˜÷3•Í"z%ª´u2¯Ê-Ó:	íí[!ÅÎļ—\Uª£NÜeL_hÂZªäºÑb#8#8ß>Ž¾û(�¢Ý‹a'9úJ«`Ž‰„4Z†¢ >G¨uS}úpO².vG¼Ž¦[èe7Œžµ¨ß2ßs°—#›†öQ#7b©ÌÜ‚HlzúàÁæ0ÖšÐ6ç·±Õ¦¼Z�_‚ «¹ûeÒíœÎص†Û–Þ „£Q‘O±b×¾ÉDXkSÙŽÝ/kq6ÑÈ”[ËuÆñœfg¢úSÈ­:´Úý¹ÆkÜ÷âýÈóìèç«"wBè³ï¿»UCBóÃ’$þ#&e2Úüñàu°Ðd£'go¯ŸgJ7õ?oK�ÖdÛ#7ã°÷Až{õƒ×9æXöx8TÄý�[ã·²¸h7å�¹‹€9-¤ ÷èmhÅ»]
JwÒUͨãmœíò‡kJ߈*s—giÖG&it@ës�ƒOÛLÉëˆÜìîÈßž>†jp€±›"á­€}Æ@ŽaGšy
vSÔö_!±Ïž—¿HÄ޸b­MâfÙi €C¢£Ò”dp0.£Ç˹gºà’ð‡ƒƒœ‰A¶yC‘o%¬¹YÀdÕ±3½ðíוFƒ‡�еõM‚*/Û®æ¿R0�uëõªô«t6i³Èåy`oTÇLšÇÐ÷öÓt¤îÀ>/2/°¿·Å9Šڸ#7#xÄC’8C˜<)›Tyµ€^FÞnnWðÄHQF@õª9’ð’ÁA#8^à!@nŽ{£×îc…—d#7�A™ ÝÙ!N¾±ŽtÑfþ«øY~¿z±µC±Q¤¦ Œ¯C	hµÐ“Ã0*è׃Ô��qgñÁE Ìiƒ€ætu—e\œ×±A·úþ½¼ÿ£ã÷�Î>¯H¸�è:[érýAÝôú
j£ëÒ $�ù¬ô¿»­WÌ¢‰(üvZÏbþqz#8H…@åY¯šÏ¿íûÀ³)«BÁ˜ãRÅN�Þî¿q;¹©¡T¡ò0+/�´#àütr¥¢Ø_aà8€IýŸ-mO+œàwíÜì#&|!óÏ·’/#7af‡jÎѧë2�rWgü¯ÂÞÞ̸~Áð¬ÿg`ò�g”1[”�î0?�¸~ˆZÖ¶ºYàÏAAb'í ý§%‚êÀA 5 ¨dr~á�k;9üÿH8*žÈ]û�'—©Íê CU
j#8¨#&8…ƒ¼Bzµ÷d½ÿÓ~ žðwÔjWühœ0�Hcmýâ;dr¡³oøp�.ù_âs22þÓI|±M"¨{ÈuWæ‘ðþ·œ;Eôö€lXipêœ#82¡ óÎj#qŽaÀö®Ÿígú‹ä|6ã=},Éù°11=vã\Üõ¸QÂD?áZ÷:#7�ÚŸ‚sÞ�1à9z{cnÿW¼ð7$!¨NKë#&À��9¹‰Zû¹›Òwù"85á<øaå‰B©Ÿ/Lc�T%y2~#&ndv½ºÙ‚Ûu{ÄÝÿlrfñG#8Ýë§ÁÍ!æ#ëh=áëCù<¾°ög¯ûµþ÷èys#ó¯×úŽª#ÔìŽ#7}h÷Bêÿ¡ýHØÜ#7`lðüKÚ'\‚¥P¶™˜aýº‡	N.9‡P§øèЀ~³©ˆu‚šÖyþÞÇg„ø vJùÿ@!Úƒýý#8‰Çï2û;O“Ý­l§‚c´íð ´ïªëUùKW0#sÀ ”$D€Çø ×íD÷€s@(ÄeB½‡°äÜó.I!M5*½^È/�y†B#�. JÈÐ#&±áa*%y¡á÷ÿV
ÿ/»éú#8þ‹n åî`Ôµ�6n
€{•
(£g>ž=à86Ÿ¹îÖ„™ùãÊën§âd©>°ÐŸÍðð†Í\.UÁ#8lÄü `?¡#ÐþïCÔ”“æqáŸü[ú‹êV>€T/©Œ	Š&ä°Ì§`IøÀå_Ø<¿Ì`'/éÂ�¤�’ЪØ0&Ì&/ŽýÞ�ÖìÄvyù‹‚¿Äì&AÑçaé¼,›ˆ³�‘\÷&#7<ÔV(¼ÄOOBa»Ò´Ÿåv0CŸXœSÝã_%£¿ØWï˜Oí`kçµJ®w-‘�~Ÿ—°=@ãÀãæI]áç=Jg©ädêy{eù„9É@kü½±§s‰8ò„ºf=КŸ\&öÏé¢xœ1´õ°¶&† µŽ„t3/Y¤¥#8Ö‚:“ž¿T•Ïi�’çY*BŒ�À b}:—¬QC¼;ðhC°GE›SVpgõ"#U\0pqlF‚Ыà!ý	>Ÿ°~÷Ù<ò
¤"�NkãŠù�‡ƒü?`ÆßÿW¼œœ³èVC—;÷nNŸÖjB’·P «’Ìm·ýv#8ÆXoð
#&øçÄyæMÄšƒ|4~Ûù»…ö°ÀC*¥P9¬Cƒxð»aût:ë.²j†A‚•…TÒ¯õYß¾0ØgÁoü³]“cÄLD
T§ë¿“Øž£ß‰ŠÆçÕö|˜Ñf}šû`û7Ǽþ*9q£·“ø?iýǹ"ë«“*'ͱVDuXAhcô‰æà)b~£A#…(2aÍñl{�P€<¦&‰h{L‡�çÚ‡przl{ÕO#÷„AF#é¼×Ä_]åóx$£~…ìH‡)…µ"¿q*o¼íã7<þŸé31#&ý÷Ð.#Ç÷ÐcÞd%˜ÄJa@îÁâr˜Ä_@O@›0ئgýnÔlà†�·_ܹ�»³¿IøW‡Âë+5›³`ªJ½Ù)ˆY3µ©ËÝŽRËŽ‘l[£c�PÉ%’Юê�ÒI$…‹ÌA†Ÿôkª#Ð&s{ï¼ðæ+[ë? Ÿ!KÓ=/ƒFÝ:3^�Æx‡²fn1HˆzNý€<ô˜0ŽÇSq¼Ì�¤7vé÷kfTÜ1#7؆�¡Qø‘¥=bÚÑ΀ÉÂñEoHr #7úýãò ˜ŽY/ñòýxOö�瘔±“û™/ß�°ÀaeÔþùÁÉ?)#7M³í¼`ÉîÛlœ>'̽÷Û�}¯[éJv%ŸÕå¡<þå¶qÛQ~À˜ÊAPlZ( @+#&÷#7åôyþ߸	‰iQâS„b¾#Ùq`³±±ÛHe,H(ÆoâT›ðr/xªÆÔO‚ɸÐÌí!
l	Çø´	LJð$~^¦Õ¦T¥d`‰4Q‹ÆqeÎsC‹LòÏ/ X-­é (y±€‘!
Àv8ßÑÞÙÚà“ƒ½ä÷˜~(pœÉb=êñðeh)t}?Wêÿw$;S×õúº��áƒ�+çêS¸ïN¿ÁÈÔ(jp�òô:!rx-Õ¬1Ê
vQ
Ò{àõ‡*GÇÁÄá@(èr ÐÿL,Äö™‡ã:_k*Ú”©ìé¡x9u×
öÞ™Ó¡ÍwÉ a‡�’áØÈÅœ�¦š^Â#&yõ:’ ‡”¥<ûpè¦ìø#&À558ÉRæ'
�³Ä_g·Ì‰é�¼76fï�ûÇÔíP�2!åËOú;*½áÉèu�j/�liÇÞyûžPÑÒDò,šÅ7Û‰¼óÓ|J—#8I¤`AÔ;#8¤v:š#7ÀÔ'B?}þoWò¿Áú�`ÿ¯%ÿR”€fd?Ù^Aüó/–FKK~ï8ׂ¯Úpã]=zê“z2Ra‘~ýJlc`Ø?N#Ô³wüªæ#s»%¥Þ£p‹LÑ+¬�¬Ñ¬ÓÖ™Ô!Ö5��-.°oe™\¥"¬›µ×’I$™ª�5ŠLTË­MIikm§™«š²×¬Ç¦V`ax˨c¯X@ÁÑâ{Þ[Ò5b넹#7áxÃ#Öc®Úå¬MÎÔh§28©ŸðK�ÞoÚ¦3HQD€d ù@¿«…1A<nÿK#&™ˆ2*Üê�4à•±\x·8éœBx]ð§ÏÔ½^¦ihàÎiÑ	aûWp™ÕÔ±¶ÿz=]"1žyw™)/±¯Äº·ˆ¨z{;}!ýŸ?ݾ§nÁ¬’u-?a;ý¶�èD9ö©ÞŸUªªä›€Q�™÷=ÙÓÐÿ™ùÇÃùË-í²áò˜�ZjPLwL™8îà…¨¶DèT•Þ¬³X0IA#&ñuû¤•#7§ÄxNî’PÛ6,�Ÿm¸Ö3“C±ž^–ª³�p*ømˆÐRD	(˜8fcQ+©jزéœJj‚’¼º(-Bì¦cyBƒŽrˆ"ªˆ>šCd«KärM­àûÇià £û/ä#8©U�O¬<§ÊcðçA½:ó¤¸È*Ávdm0žuöoÀ®œfëJW(Š4¹ºS)´hwmW¯¹î÷yßp8‚qàƒ·»Â^È"#&‘|‰¬V)ÄU#8Paì÷YÕ¯Ÿba�¯·ÚÎ0�ý¿°ýS»� ¤IN~ÀÅ”¤z.G�}¢BëõÛ‘ÿCs`~ŸÔÅÈ;="Aú„Ëùž§á¯bí‡Ïú‰"Q²1DS�=N@Û#&|Ýã~Pá‰	zÉ$9À	¶ÍÕ4¨m(æö(Šiç€)Áü}€þ#9ù¦x‡{Š÷t?­U»Žÿû$Ñ�|�ÅR}!ùCãyÊûÈ#7&¦ŠNq¦#&¤>d6ÀÕGõ2ššÞØqG`™>Oo�6ß’â`¾A ÓfFhä=Çì�	¶
Í6�ñL0ßÌ!&n~¼zf
–C�_ÚäÄØ¢J#&îð‡w &÷s¼ä¨_5ÜG
üÇÕnËð€„†¤þ=ôvJ_v~Z«òßhséK_Cì>ü\/¶TS~ã¹âk_ÆYen¾¢?^ÎŹ³ûú!ú?yÿ¹îyw×Ü/yéÏô!äéúÇ@šX�OßÌ=÷™ÝÉ¥	@€>'©#òh5ô›Üç¼êÁ&½SÉÊš
íõþéú‡Ìør.æÌœ ÁöÑ_̲råï‡ô�d{À'Þ)í%L	'd{Àí~_h¢[Ü“þ!ð°dϧ�{=ó¡“â§9F�,ç„ñ°´J#&dRð[ŽØF%Oñ`“#8 ë«ÇÈvÀõ”’@T2ÓQ!KDÄÑÜzÑÛè#7=UþcÌ6@ö„ú}ûàöC´÷#7Žs�NÀl©ÙÇå_9d�ë�Éñ�äöH?y“5¯Õú@Ô(ôbí@û%.Ðä
|Á>õÐ�=äZ=a}a;°›?#8ÏW* Ø×&Q>
üôÄ÷šn~!=¿½$ù~äùè™ÒÐô
­†’:¢0ü1 14#7Ÿ~¦ª¯µd
ú#&û©³»ú:¨fÆ„z…Ö€$€~�›äWøRR¿O¬DõÏ�{›úø‰oÞ[]ÿ³g™ò”!ùXñÜÞ˜TÒŒíle©ïðâð/Š#7Ü9§ncÔ4?¢ˆú#&cxø7ÖXmÂÊ`-ÿqö:OCPh<?Pg¡G±‰‚zºÑöŸÇ7‘î&j¿,_²"bl”N²t„ŸaÞž¨TÁÚ0‡À<Hq±àZ=Çoè;¶KòûÞLÉ~#ɼrcpƆ‡®µhQ’¬"Z:«Q§ëª�¬™³‘G !sú`–	½U4¢q㱬3X;-„dëöeDv󹜱1—a+*¯—åðSu€ÙöÕ2�µDbš;9^z¾<>qpÚz¸“K¯
Êö¡,<“ÒÐöÏ2¼a¼ùõùׇtÔd5€u'ì{÷uÎb¥JÐ}þ�Á+R哯«Ðü±ê=§{­£‚G<˜`�ëúžÓ?Bc“¼FÇI•%�¾}ÿ4žæôüï#è÷�æŸ!Ì?O¬=#&2ztêø
’¼„õ99�'¥ÄöÿT/„ÜæPR†>ƒA¦Ì°Ûcà}žÿ½ò™úóðOÛ;}Þ�Nv|2É™U…Ò¿jßØêTójd³3úpÑN‹ýÚs4j+ýö)AÌ Õ­¬ ¢m‰2‚“Ú붕´³jT¢†B¨w¹€áúùú{_™í_cò»Éü�Æ¿¡÷‚عhõ@rˆ¶dÒùϽž•ßÇá$½šÐSÉC“ÿ1Œ~#7ËB<ñXok&7ßñ‰˜û@¢r‘ŸbBv�3—çú'âò�<AO`Œ“eAL±�&2äߊŸ"zÔ¯Y jIÏ#&yU!ä~#¬>LÇ~ËàW»|^U<`690п[“ÕXøÀ¯¸A¼ d@Tá1nËÝêTÄhýa‡ØaB”¡@¡P´mô±�áVÀfJ¸Ü,í�#74Gþyõéü樣þ?ú†‹IG¹žv`fRbYðV6F?¦kx„iê+¹s2Aa¹ª·¬Q¤Ž?R1*g2°€M$˜‰bo†à‚NA>`~ö³ûŒ=Ö‚�}Åý� ¨z°°,�€€€ïÔ©Ý4´ò(kv$Û@4!óȾ̉‘G‚L3!z/€¢s>pý¼¡é	6‡yMãÌ÷æqÐûþ£oÂ,Ðíõf�ö?V¦u(š*¦°²©àSJRœèPŒ#&1µŒJSÓ·r½©ïá“�#7ä58§ÓZ£  ñúBPY2üŸß>ËøäñZ~G³Å]¶Ìþ\Ä2YIåF&»ì¢C6¯¥I0CLÇ9­|J|]qPÙ#84lJf"¨¦¹¥zÉI’Òdá¡»!²¢LA¬µ-»¯/2à#cRØZÉ*b”íÑŸ?§Ëølãú#&ÃОCç#7³öýÙôÚý}æȸ=ëóì¼ÿÜxõ”­³D�чw˜ú~gÍã5ƒ4#7€°žÃ;yœgò8
wÞ¡`�7„4B혥3*RHà
¨�É#&¹“ZSBdðC‘´#86£=‚`’õ�÷Èa~#7
ç^Þé˧©õT8Db-�›Ÿ¨ðÚöòÇÒ/ˆî†¿™PÄ1|Ǽq¨õèîõäg³¸uöá‰ygY[ÃÜ�ýX>P#&q;A:”z<#&ÇE�c¹“˜wˇ‡y')¶ãçô}o…ÿ+âk�aŽ°;‰Ð5	@t7Œ‰ˆ—²R‘>ÿ—3OYÏI	ä}Ÿ×§Û±òûôš\˜V?imj¬ªÚ2sE"‚Œª)DNNO¼çð>Æü…¢H]i·hÐà©Ãµ:œƒÌSêDZšô
©9ìE‘Ô})¤þBc(©þ­¬™%²eÁƒ)›LŠ“¹i ‹€’e#7êYêY%Y$‘öùÃ$&ž6Fèfé
ÙÚÔ…#8j�)å˜(1‹“#„T¢ƒ}¤sþ÷�ÛMRS|k"¨ÖeúÌó?<19-è	öaêá'¸Âyp(pð†Ü½�øWÙ4¬ììRGqiE<!¾H#Éú�ãér|O <¼¿/Øže-¼Ê+¨qÇN$�áèt�¬
$¨gË·—Z� Ú=Éëe ¨Œéû“ô#7ü¼R«c÷GG·Œ·�¿½_§Õý±O•°à‡À4„ÆzÇÐ}°2Àv›ž
ÞÁ#7K3@¤³Å��Â	mUTÁS·m,S#dŽÑö’ÞoÅùÜ/àþÕFߥ^ßÞYÍpß\R?¢à#&ïN…€È›úÓ}ÆÕû¿�õ�'Œ?¼JŸôxŸgð3ƒŒ=¹Mr bÊ(‚(>Ã*«Ãà[³=p7ú6£·³_dÅ1~‡Zý›APg®#8ø†#8�X¬+ ŠÄ4˜CîaHd«ÚœVHqe8qÃ5¤#7k[léHB‘‡ø‚IOâIPÝüIñ,_­ãóƒêÀûN_ 3ßî~_W=qåÔŒŸ’!ˆ¦,-(l.“pÁßøAî#7Ÿ“cÌ;þ"RcËÒ£Ñ:"�	ý°Yé€âÿzbý=N=a;’HtDפ“Ð?ŒòS�REЯóþö“`	U7H9sŸ3¸ÖIâO¯–äò�ñò“Á=ª£U5!¥#&Ù?v�w6‘:�W£à*OìXES¦ÜF™{ùòõ—ŒQT»’fœŸZw~Jcù_oËûž“éS�®2ø:#é¹}ˆ«8–„4#&UP”U@‰¯³"òÌ~ž+ñÄ<4âÂn뤼9‹$;3T�“Fé#Úhn!òüèã’Ø>ÅúÁùXî»%Ààà�Ѩç¶Ñbµ@Çá¤ÔžP˜F˜Ýzœùìõy]c.k×D¾)Õ™«%KªwlqȇÇ] J$X鬟¼s¤ã,â6Œ8Ϧîá‹ÆÐ=dŠ‡*•IÌ›¦æŠÝ>aêmiíÍK”ÍKXPƒRùwÞ#8TqrÑŠ�ƒ¿¨}}ıù0uaîö„÷ëaî;w{ýrz�é=>ø,ç“©ã^pöËšBM ·\›£¡ìðâ#4›RêzÊpÏÌ`{Í—ÓÇœzÀL­r�{!±úïãb„¯uõ„®§ø{#73Ô'Üô
ëÄ
Ãv§FoݾڭûÒÓ#7ëÆ7�3³0lã~dÚCÞžg¡Øq"y‘3âC›@Ž¤ÐÈÄ+	äxlg§^'æ‹â	ß½€û=½ãp.x¦’æLŠB«Cv8Y.h'>¾]ŠíÙïÔO^G™ˆDdNclŸÎm;;†ÔÇÁ€¹´Àç†_á—ötfc¹þŠ=HÀéï'¾Í#8ü!Dí÷#7CÆd®kd#8)röÁ
}¸˜›�#7y²#&“ö‡ëüÏÃXØr_Ä#&„EA0<ãÀC�¦ÎÏò”b ‘ßþäzydG³­ãxÿa_�)¬™Ñ3ððï‰Îgy�e»òÏ·äÏ­_±¯â?j•³ñ¢ó–ÖãFv£!"ðï2�
Üâ£Àx¼#&Â×Iï«EâR?¤zä*¨§;�ÃÙ¾±œ#&ç!®!Ø~ªí�þS¾ü~«Þô׎ÁØìcûQ—»j;ºå¶< !ˆ
é*ˆã¢Kˆ˜á
°Žjö$²^dý†’NßOoØë=ŸoÃöj•UÏ8ÏÞrG±0<nó*CíÝÔL×s¨‘éÙM€žÀùT¯#aýéôùŒÛax}͸~ß: ³ç+G/D¢$ÂÐ0_à÷#8?({ÀØ‘;GÅ=/�Èœ(T#&`x�Éd“Ô‚
,7úç‰ÖrïßËialçíþÞŸ zN5'ù¶ÈbO²Løó0Q.³�…|[O9�+>95,ÌÔNr
6ƒ'ýšöBv+ãÎ(g@÷¡ïÒc!à*�Ü!‚iàÜš¦†Ý¤iîK�¾¿#&êP3d¹�
±–7V*ª,C@Êp#8û?Ïû¿q±÷ýß’è‡5ÓèSih@Ͷ Š#8C„ŒÃc‰V¡Ôã€#7øNùon‘ŸÝžS¼â(ÄÓçﳕX@¤s}0k‘ð¦C�’m¶º™¶ª²{IL^“ëŸPc ,S´`wYAL¡Ž°ù%Zo‰‰Xùÿ;Ä€b u‚º:têfÇU#7Èš#8¦h}ÿ6¹ô:æ!-Îl½3Ï+ÈÓDžR€
‡Â�jÉá6vôu¢u‘ÔWc0Nw(N™wûõ~
¹Ìú�d?R<ÀÝ?:l„>#7Ÿy´Û±Ú ˆ~l]dü½¿v!:Ÿ´;Ô“ž"\Ð?ãùÑáíäR(¼â+ÇÝŽ'bq<ÆG™*_-ùãíò �Ú@Rù~·æÚ}/Ž}-¾�x7…~šÈ„�ˆF	¿'	$L?¦ì#&­Lýš1V1ÂØñ€Ð-cpüñJöÆæ§"Ä1-adÉþÄ4c’¤ªj‚…ÝKŠ£…u™øšÖÄm˜‘3°éêT+ ðiÔ/óƒ^6"&yñR#8¢�°
ȃ£åzaB¯â›â|9bbþ˾û¯°ìÂÌ#8=‘ß“VáM}´¤š‰Àç9„àK9ŸlûM¾O|ëúyyo_¢ÅqO=~_÷ž|aýoîºs‹»³¤�ùà?y„ã§?b#7|êϺ±´~pœ‚Ðòÿo�5Šó�JéMȈ‡
pî˜Ä¸â®û¨0`)!y#&…ù±WïûIOµéþ>¾ã²xDzþÜÓ•%}É÷Ç÷Ï±ƒÇÖæÀ•¨~(XiÅû4››f,àcdãûõtöøæ<—=¾ã=§#8û@:S˜¾!†¦)¨M€0 ¹0Fv°Á3ψ@˜Ãë%éó¯øäÛËüQò
:;•ì“D¾_ŸÑïÛ‘O#&ò>Ï�<Þg{åËDM<�ÐAŠ·5.#&é
dn@†Ó©*&{fÏ°ô�žçÞ#8y…c¢ã¾xª#&xEà&—ön‡Oªš¸iA�_PAêqг÷!÷¨ÿ.β\}Ãú«€—(¿Õ‘;úÐøþNWñªFqûß°¹ü_ÃB?=Í1¢±#7FŒÖie– ԄβÃ	˜XtiË(•u&ØÚP¬ý„¸ƒÕ-�À�‘"ŒI`…L¥´›Pjn?Cs,°N$㌳ZX¦#8ÕDÈÂ45I“U€ÌPJEÓþA6§õ|™È{Å#7ØCþ‘æO0à©3fI^ ¥¨Ë8ñ†Ä@Þ÷µ Æ€ÿµb(—íÿt\N{$Æ—½êÁ{o«Û5zó#S&äÞˆí²lâY4KBìazÄØMŒå-h\0›˜�Gb?�À�’hNG�<#7Òã±Å8�¥¤9ÚÀ,ÄqRÄÕ
ú€ýßS×fl4ó#&‘AÌ°�°Ø½6ýIû5
R7­NÓõlf.,æE@H*eü ý´õ«Q\RN˜�?ãIÚV+ö5?K3™ô·ö<&Ã~�áøëûäï¹aÚ±Ó¯n”R�äRH‰#7LXZ (i\®g±}Ýýúÿa©]ÏÕ}/<èýÄ‚T^á#&¡^¬À9xrÔð5a;jô¬$ÑWs8
šL8ª¡‹›†Æ­Òl�l(ØlltB®Øg5Í⎴åLTB!þGY;cŽü©ôcôoþ‰!‚4¾Çe«,e¨2"ÒBÁ­F‚ˆC
‘þшkí.cù~F4¾—×%]?™ø\ýô$&âæAèƒh2\ƒÇÞ_©Ù¼ó’²«`§ïàã#&º¯åý€ݵ÷Gú0Pü¾w¹š8ÿ#8—7ðŸƒíd¤PÞ|¡±Ù±â¿Âöún?ûõQ$¨¾Ü3Ð.k€‡9£è4ßȈˆØk#8HèÎ/Bø‰
˜¸'çöª ùPß2
ñÝÃ[Ä·ÐbhÍÑ2Éa¢:C¡µU·†¾fsõ4l‘»´pT àxy}÷7õ£N´&|ÿ ÷dù�XèÚѧðà›7YÈ$Þ賌Ðlÿ™8jt3¯i¶+³ª:ùežYÓ^.#8aD¢k{©ˆ¦c†s©ß4X'óŒ{õ�kç®#7gÔFh)#ЬÆÙ˜t=xÒÀèìƒ�PÞ‹ªòMÐTîmAí²a�%cý9¿ÖŸÉh"ì\ö¸ôÅƤo‹•�‘w*½¹ä¬3‹³ˆð�Ïék¹¼,} ÆUÖ�‹@Ÿ’xrÚBóÀ+ê'@ø†ï{0æ•äóËË7õ»Øu°•#&„À‡Ç	»ý?Ôì1)Í5�¿Óq~¿b¢
$!#&çz 9ý^¦ÛéÜŒ%ü¸ª…Ðá°�DQ˜(¡ïd�ÍiäáÐlEñŽtxþå^‡áv¢œ2{�Ïí×ôÞh;É]äL­DÀ§A_í³·óö
]C8½ÚÀâP(›mr¨Ueî#7†}2ù0™HzÇõþæJ#7d@íP¯#Ìíbozï×þÏ…ú‰�uâcÌѪ®2ív¤7íYC÷ƒŠáƒúSoîgÐ65Ú#7@œ;ôÝŠ;}"ü—•èþRJì™GgLƒ~ø(ÿ]£œu|ïÌÒÁÑr³v=×—Ài*jtø=ƒê[.ªw�ô9÷réÊCßxþ�ñ×_ø¸ƒ¨<>O�­Pÿ•Þ³¾,z{K#Ìþ{–5EC©õ¼Os¢|'õ7ð�Z:9^¢Bw¨›¾òœŸwâ¾ÎBØ+›+ƒX/€6 eÊøº##77SXÁíöIJ÷ªœµm#8ëÍ‚/„å«%Ž¯î½“unÔÓ¾PÓWߔƠÑÓ�ë‚#íQ Ù%W®lúg
Xc%ú^6:ǹ—EÂäC±@ÈÄ„ÝeŽtÔÅÊ4*wœ¢ÓGQò/AÁ£RñntÓ0ò�Ãn—àUƇ3ˆ¤ð­»?º·ÇS½_,—”óˆ'·)e7uÂ(Êwvb/c¶²ýÌÅò«ºÛ–pиCË‚T¸ofh#ý§aÕ6îåô½�1‰1»=	elØغm`†âÿM°+”�©ñzÚo8”¾ú@¶æë³»t˳ž<¸$w­(oB<#8çá³ç—ñéÌáÄÞ.àwNæ Òå4®®ä»l±< }Gs¦_¦r™f›2òÔhyFÜmïœÊ{)ݽʾSΚRT£ELÑ !½‘€ˆ#8NU¬óNZòßmWµn›b"”#8£,,dGy([¸Û0 ŠBY=ÿµP.…°–{ü}p×l‡ƒéÑtf�6óôò^ãéÿ#7˜�€„Wˆù¿oŸãiwê—°ÖätŠŒ´Ý¿¼‘G™ûw¯HaœûžM1sûžzw(þÝT_‡~]î²+Â?#8ï[ôžNƒP?Æ�€ƒ ȉ¸cc¦ä¤æÖÎZQD"ª_×\))ý�³_ÃCàî/¯I¼þ«Äç\9C­¡QžÒñ&Wœ‹�TW*úávÒéÚ³RU#7„(
phfø_j›wy^yD†dß’FGcÎÏÝ#&{½\Á¸.d{.º¢úöGÐcy[à×j£#�HrµŒ”2 ¸äy;"ÔQ`…¦çbA3(»gªjð*+*RQ”ëÞÌ:UCô0h~íà‡¿æñÔÀ})ö}éÛã®òª;ùú@çáx—G¯VÐœç¿ÓÓ}ð.!O(½7Åû~t|kéfPʉ'òg�úÔ‡·IE‰âFc¼d¹d�¿^ ¹ 8ÔýÝ#&kþ±ÑB†ÎÚVŒ­ô¾)NIùjQê˜DîC‚€�K{½ Œ‡éGÞNŒ 5ò¨äVq½…uH2	c<ˆˆõå„â]õ0SÁ?wmùû}�9¥‹G¥ÅÃ{Ÿ¹é~·¨iò”Rq$L¡¯y“óÄî:VÌ’˜@Ïùié›á°ÄÍ¡{ÌTɦ’‹6d¥|µCÅÃÖ†žÒG¢1³Ǻ^¾ßXŸW~Ø5&ŠtzÅ4„»‡¯#7$7t#&öŸ107žÔG'C[Ý}2³Š_OÍÌïÉ´KË·’"ݪ‘0Àr&bˆÞ 8a­0”•H¸Y0«UX%?	 ›ueMbmeug”“�ó“ä~è7ÉîúàüVÉ;£‚6·&KªÉ]1Bõé阫‘7ëY‹ZKä#¬=Ø0jP਒ó�ˆ¨HeùóQóÇÀ#¨È0PÈFÑÌ#8#&Jˆ<¨B~Ž_اÜ|=ÜÒM?�óYàÈ(ABP:ÙËþo#7ì±oŒ~éʲ„RAÀïlÜJ9ø”*@ò€jxý~ÿÂ={F–šLP~öD0ŽHÿpÚkø÷;ñ
J6$ŸFÝ£ÇÙµà¢á9Çóü:pà€~q½À“s $!º?Òí’J/òjhX‘£Aþp_‡"gýcÍ¿šW�;òÝK$#õî,þGø�é¿x�Ñœ7v/phóìÊá`³c‡£}Š n!&P‘Ÿõ¾Iþ}/ˆwu¼¯C¼Ë0×g´åÏB®t=X5'±Û6�`cˆ9�fûvv·n#8¼CÊ{$2zìbÀuÜ#7g9àN—Ç é‚X-ù,$èí÷è>Ôw�3èäkpö7´p†°ð`ô#&ö�^DöÀ7#&ò¹ëÓlòÛ]l¢ÃØ*lû¨ƒ¦d±–#7›¾À³2™[3ýFÇ�Çî6ôˆ”4•JÕR¨ÕØv“PêvÈosÀÛcp0#7"ÂÁ~hDÞñšZF#&+)�ú§í@¾¯Km_¹#&dÐÐ*a$š e™Dy‡‘ã:ó뇧SÒd(ìê5½ùJ)–Ö10xy™Ü'�pz?.ï¡ÆøØk†ìXšÆoŸJ�TÇmONg=ÄöT«”TeƦj›MÞíž�Pk"0àf0Ðj
Ã`,MÄb D”jÒÐ`8@à‡s‚#&e£K©›éFì ãëâf"°*ÄÅÑmKqÌ�ÄÝÁÀ-‹X¢ˆ©œåšÐ¤'w7�ËëÛsµtÖgª€„©0¹©D &·æ"ÉöÄà7"y�B¿Z²#&zíFöïõyùskûÉ#8wjðèk'béü>>ËÝ.dþŒ=ܶÄlÿV¾ì~ˉËÃÇ—Ýí3‰€<»š0È#8*°ž¬þw £BìÂH#¸9iE¬�`Æë¹Y#¶æΦ*3}kP°&a)‘¢´eÆŸêº�üLûÆBR1BJÔ¯ã6äÈ’ò¿‰ùߟíoi­%™))FŸØð`Ôi¿»¬*IÖá�ü©˜ZFÇþ3µ>àÅ~¤<‘ŸR#jîÛ³'¬ xž! Þÿ'ûà¨B†=Úg=—·½¬HE³TˆPqãÔÖßï,>¾£×©ªñ*¢±7ÉÚ?Îvî,÷‡l*Ip5“Ì.MŒ“÷‰ÆdÔànYƒmÁ‡+!#‹E8FÕî‹-«“Pž%G\h®rôpbª�aÞšÁ6°èRvãÏ°0v<*ó'�Œz€G“ôÂ<½ÕœaÝô“aêÀð9µý$RAj¯!SÙÖ9‡Þ4�#71�±¨4TþÒ¥šw6‚hñŒAŽlCn^wámÞáóûß":uõñ,½Ä¼#&ÌÖJ`6¸Ç&ÀvîÛvŸyÂ4…àA=¢Ãcoº‹pF*v•¬CÈÜ0k™ú�gRùwÇ¥è
ÜJÚáÒÙÿ¯"U^;³$<º#8&ó¢c�!ÌßYa63>eÀÞMHé7Ä#&ìdà3ºîÖh°Cr½¾úNâkg›á½M�Uc›êéxŒEÇ„2ftœç‘g�Àëq�±y$Žž·âí“æ–CÑšyé–îO	yvJ�Ê)R“G©ºÖònï¾éÇ¡Ó£œ:—¥M]Ì,„ˆá‡k0›wŒé˜I±ÀrW]š¶î‘˜t…œm‚ë°úNÐ:~Šã\3œ÷ÍN¸à=¡9”N±(C¸ÖhÚzɦ“!1ïŒí6÷ó�ài¾ç©š=ø¨¡y¨¥=±mÜòž{‘„<—±Ðê�t"p>ÊúGs˜AԺ݃ÃÐûÿ¯1Ã;}ß?³ãéÒp‡q€n>Àžf°³`ñøf@ƒ^š	"š0¶;¶Ë}´¸*…«#&Ö#8Y,A#8¯0Õtt„ˆwxF|ämmáAŸ8O—Nåntæûb�ïvè ÖT¢iAŒÎÊpU¨ÛFѶ˜ïh@žŒÉ“noÜÁOÀ4ÈO®¨Á¡c÷.WJm{Ü"ã‰Ï^¯•AR™I…âÄ°,9PCH\œ»™Äc‘<½üaäHt›ÍwFnLv¹Â“]á|h„ÚËã‡\yZTåÏÔ…Œ+©¹1‰¾Ê>dÔ¡37¡ÅÉ&¦áö}‰ë<=ábìC�¹Æw¤,Bzœ@æŒÌì#7Õ5¶¢}¯*f¦ª’C%($Zt#7ƒ¾«`qö†ÆœvšB�fóTØ,Ôð�Î�Ó^vë´L®\«Ëųàä½½`vä½Øp†bý=ž´ôÆ¥i%ý�PÉG¨pð‚w“ÞöV¡P5�çncÜ_‡j`9Ä;GÂLä”0ÌäPUxÎëÓ¬:Zzs„�äðÉ´cXUxõþŒíuˆâ¯zßiß)äyõà~#8SØ‘ó*Š»ˆóˆ¯
Ä’
ªfs†>•¯iã2ce]e‡,B„TË8Rlü%Ó‰²Ün$ɃËâ`¢¹ Y¢Ò�‹^ÞUÊlÁg/øC€Ô³yÛLZ6öÙ¶žØÄ¥@†(rQë(qîß‘x½ë	c�#8³TÒÛÕ7iwºDò3š"^Aäù÷Œ‘kÜëÚ]¢;Hdj6É ¡y|n» ¯®ž×ÃWɳæJ#8H,ÛÍ¥0á²ö�qÞшp?Îp…šhpÀëB‡¡Dö18Ï,”r2J�‹)ÕÎå2±’šJI'/•…Z©“©GCÙ4£·(rÕw7:èä 4w#7û¾~u™Le±W™—fdË™™™clƲ¬Ë3$•c¶gšè½[o=šôCifžcÃ�®b3AB™$yK4ÞtD°kŸÃÏ~³VW›;‹¹#&!{6O(­<òËrNè§Þ"UÆû]Ó:#7ƒ�‹¯h#7¯#&ÕÛ'Ù­EìÎüZ–g^ƒ¤ñ2(Æa¨lÉ\]Œ£AŽº°¦‰™jÒ %µ§81:Ø}^ Û#¦Fv�…¯3C‘1ƒ§4Ú«)vz…í¿\É«³�,�ˆÔŸNÂÉw°X#¨¡%Õ,±h¨" ÅâYËI‡»±õs½¬eÜn™{öé{PØÃÌ&FÐfâlÔì’Ü—Ó†“c[6û¾v˺Î!Ô9kOäŽðÎC<‚¶D˳¯§¬5“NIã1§,%@»V€éâikeŒ�#8!ÒoàŠŠ´oЯA9j#&*§FJ`>üŸŸ¡Ó'ýµfᨃ´#&ïÜÂÑ;¦I˜Låû{I™¤ww#˜ø&�:!'Ç¿é¶8é]s��|:q¹Ÿõm’1ÏÍ@ÍÝ#8xò6YaãNø½	ˆñÃûTt7m@‘Ê5fø¦8œޒɆBÅb�[l·­C]gzÐmƒ¡œllâx‹!æ#�12žm®ŠTuXŒÀ<ui4#7€Ñ€¶4uëc›cË.\‹SÓm@ø͘ù†#8›—±ñ,Â'õDƒï	\q^…×C6mhñS’Æ3ÓËhmðEÐœ@
ˆu&˜ãÌЇ!ƒ1›|1C#8³§ô~Xg€9ö·AŒi²qÇCØ›^åÀ˜žE}8!Ëš^WØQ'Sª©2„z3Ù,7HšƒÏcsCù7�j àæ±XQ&ç¨ì!êÊz×±.y&éð®‰@á…#7ü[¸Åßã„ŽU�baÃÃÕFÇ`UÁ�šoÈ9NÆo†²"¯Ë¼Âb¾�ã"I¸«¨J5ëtÎd‘‰RÎ`1„÷
›;:}MÃmS=ê-܇(`-©=�Õ°ÍêLò>_
ÜmÌI8‡^öµœapçó`"QÐìc¡Ø5Ç
ÑQV q#8Á„„�HYcr’‡¼ÝÔPÁÇZ›hÄI#7 8äÀã8q†³[&ᨧC–± &µK‚D–2#–Õ`L˜ÌE!Ü´Öµ{—(Ûåô�ÇÏ›öb­b7ÛC…·MþIä`�,!ÖgDj^mÇhèƒÌ}«Ž%;¼iFÈI^àZ„	u¾An3ò`1�¡A:šòÜع…0ACJQ$°„ÁAÀpG#— Ùô�ò;ɱ¡6Œ‘é7X
î�ƒŒ8ŸqY|qà;C~cÜDúa–æ+ Ç“z†ѽL9éïfM�H•;%ó#7#8#&c0x#8©ó/0‹ÉtHô 80�-Á‡<çR¹*”&"Ÿ=‰<ì#7ªøTÖÌÛÉœèz6T¿8zxúöMšx7R½Ü½ú/´q`�‚0HÃÏ/#&ïÏo�ÐÙ›šaC¤o¹¼o¥ˆ‰5DJuퟣp•„¯+ÚøuÍâó—fÈ0H óÔÐd1áì#7·býÑLÈ	7K*É$°	n�*é,i­ŒlŸ¯´àÃ#ê@93þ­‰Mu�!˜^œ(QM·rýç´ 4|Ù„Ý¡5!¥Ð�{?ÒåÉ«–ÊÚœm“7l�šúŸq²fIŒ£“i¹?(aö·=9û"ÍwÚ³‡m’ëX™å–õxfFH*á€`?¹YÆ=ä;\	~ªj±¿Ä�È ¢J`¥¡ÃPXB×Úý‰°}Eüú¿…Ó3¼T¸+9SU\žòcútÕî0Nâc¾ýxÈ
'œ•¨R�#8¢‹÷}?„–ö?næ{Íæfe‡éGÇA¨0¶d6^ûs–*lLˆlì§ÏˆíìíO DL$ôööUâD-˜abSá
ÀPX©T
ïü�§ÑïèžîeÁ]{�)ŽN`ç§úÈøÍú|“,Ãý?ìœ5­Ed·uz�XBŒ2D1õ•U/¬ù=§ÚµjïÀ©î—R%ÌÙ%±Cû%[w»çæ>ñõ`4vüäðõéý¬¼iö!§[z_°ô¡úš
˜ššDÄÖöî¢M~[mÖfR ‘<G¿ÑÛÈ,@É_•�)¬#8†þŸ¨ûdõŒÀØ€Üå_\1ƒh`÷¸Š“ìü;ͪ�±Yê—â]"EERÂQ±‹ødÏ—‡3©$'‹#&ÁîQD¢±>±7÷ÄÃã¥OÛþ¿ðÈ�úª^ÅæT†µˆ¤#&>'~"€{{Ôú“þoN—çÃפ=›CÍú73‹š�rÕTGN§€¸öI’ä{D#È>µv¿GŽ¿�‘((0Â.°Æh’FqÖÙ¨i](óAWôð}„Pò_Õ$�¦‡¦+ªû­Œp9Éñ–aC`Tê�j’¢…õœ#&üQïÄ;‰‚#&`Š¡À:“T‡Ý×^�ä†ãø`S~ÞsžxçÎÈN‰‰$¡[ƒl�š#86͘#7PDÕÒÊ’7ã6vt¦Æ!°HPÑLBk›±¡qÍÎPï�ºD5„€?ì¬B¨:ü>ƒÍŸS›[‡Ó¿ÆŸÄÄÔâ’øœº¨¾]ç1åUñòº“­‘h‰}²#1=Ÿ0lº!¤ …ôŠB‡Òs=aiQýì~¨®M—âFNè‰ìï,z#&t•®9t×F�šö%Ÿá”ÎSìÚ½ÀÙÊŒ‡®¾d%÷÷wqžÃé	'ÉA
ÓnC;Š§É $£ P3·Ópùe-Uò«W-KIfÒˆ‰Gè�î'q@öH#&šQ”7�L„))#&" UÑ<	‚ƒ²A¥YSÀãÐþ!º'ÇÅ+éײžU5„NiüîÙKöÄQ�c�lÏ°•¶´�lNµ
ƒXk¦Ä±„°C³UT9š#7ý¸¯èäe_œÉW¦/è·.¤’-êîÞ=*¹^¦åêoæ‰)ÌĪb4a�I¶°uF±uÝ(¹twmÍÊ’²»´rX…Øѣȭ´�R„‚º”¿Í¿©Øæ0©?è{I–*’ª%Š¤Å_½=žÄPðCpë—„6çªK jY|ÏÈET�`÷>aÌžì/îû×÷tzþ$îí¥i.wÕD/™¨8Ë!GOÃfýòý,;‡‘žïÝVÅ4#Q‚LJ@c¬i{ kOHHÁä°,Äwé.Óªyå é¦øžØç–LÁúXt’'$Y¦‰­¿áö4Çéïºvÿ¯aàí#&òa:B©�ÓXÚ#&)¤·_tºÛ3†ˆ$™¤IûýéÛùûô”‡7ù—ÒuÐõÓÿ$¾‘ö}ûô^õ~�HÒ?ÄXv‘gªºS�?º~ùÁŸ£uœ›<|ïíÁyœ·5;nðh]ä §-ˆ2nìïaÀ—œ¦ç.@ÚOŒjÆ #&·‹ ¢Uœø‚’Ñ‘D†Q*Œ
ˆÌšÿ|a#&Ȇ‚iè‡r'NÓ
<ó;iudðsúJ’=B‡kU–þïªç·Jzj~ƒ³Zä2˜C·nŸ‘Êü¡÷ËÞÃï%ú°æ;àßWUaƒ¶q†â“¨`ó>–¨Üîõ—dý„æ©øÄ”‚H¨{Ã×Þ{yž>íÚ,õuçQ&§˜!<ĹuU4ÁɃðúÿ¾N‰$+fèû:Y‡ž�/%ÏL–J²CoÛ£4mÏWû;N3hãŒN›J¿ºöF‰Þ0?#&þ”#&ýßgˆ%#TÕ4T=ž¿¨zu‡™ð”Q�aìP;éÁé‹ìò¾/	Е‰PõÀnMš¬i�jò¥vª¾ØH÷:n‚ÐL#8I¿@’>E<UŸ�‰ç:63*̬œhŽã;1ð ø4…ë³ÈDÐ@ºžÄN?Š–ÄFØ›}×ôÖxÞ1™#ëE\|N˜i0ᡯîÝk`÷mù}竪š#8‰I¡¦%ÓXf²H±Æ‘�æͶÁB�6ðÀÌ€ù}‹Šd¯ðÆÁ÷n#7’4¨SU%j6ÉÍXÒM”I¨¤Ú5–•[J¤´“V+LÕf4¨¥3*ß‹ BY„Òz½ç¼uùY^QáÚ#8|¨xJ”#8’|eÉ”h#&ôë_8l
¸Ž¡Aê£ÁtôáíM|·íZñ²#v2ѹ°&Ñ?z\ÈPÀxhluÅQÍD†(´hÕF±
Æâ|€�¸#&H¦Çl€›«&jm¤6Ö»mYïÑÓáYGéŠX"cQÕŽZ[4M¼C6é_+û¸qvn+¨Ó ”8'v4«ó«j6cp-Rð¸#&xùÞ¾õØA|×#85J4#&#&=�ª˜ªh�(µ$�ß-@5å¢iÜÖnŠ­ÚÁ"ÛR²f:è1‘™P�±#7±OùZÚ>ÍÿŒŸS
õü£çç€sâË)”ÌÅ:C�NÕ4"#8	¯P	Ùá#E
L•-,2=ì†HÌi6ŠÆµsn[r·4Ê…,S4[3¢¤Ûb¨ÓH °Yøf~“ͬvÙ;’ó6ÔÞ@îÑ€Q+@£Â¢{ÁPì<	Û³|ùùæyûãùTwsP0ašNŠ2a·Ø$îüU^D'Òyøñ=â}~å=û°=2‰HCï@â
ïÌFTÖþ*}Çõû¯úÿoóÿ‡ýßïì;:u4#84”üׇD*üY#8#&ÑåîÑé�m�A[DÕ@Nb›Ht°…uP¿X‹~O@#8ƒ	“ 9ê‹€ÊOZªMO¼åxqÌô<|{ìÒMØnÊLy¸¡´	ÙºT^¼±xƒùów�£��y§ù£ô²ý�mr}xÒjWóÁÙz7p\ÕÓìòZƒoLcY¨ƒÜ2ÿŽ#×Øþç¯ü¸"öÁsd·qÅÉI¯O¡î"	 “Ƕ}œõ{�d<eù	S`Ð?)BR†ªp6ö¿Å“Úv¯žÐبÍà‚�gÃ7†è#8f@C”ÛHí›å�n8äa†›§TÙѺwúìÇ¥=gßì=_§p¼ºj-’rBv$š@Ä�|?å°ÛÀûü9mŽ8Ÿ»j#7rhÈÜFW„Þyº¡÷uŸÔ‡qðõžo¼ÉÚ}”N·š?K'žgSȬ4ú8|î½sÑÕ÷þ\&f	uK°v?�Ò‚pXj$ülÖ ø{¬z5=Öi#73íåúZ]>4xiănóË
Àå¼�>Î_gNÿö`äDÏÒBOúÄ’N>g�0†ºw·%âCÅ>Ûèhš,BÌ�P¥3tB®e¥pÊg܃‰Kˆs`ð£¿;Å’ÙÁ�á1·•¼V†O@:¸`,ÃlbÊ¡Æ®p嬖Q©ƿ—7½�ß=9ãz]‰Ìh�0dE`6ÓÎmóÀ‰†3+‹Žf6g9Ѓ®8ãUìùˆ‘	„`!Gêq:k¨~`ù°ù°î>�ƒ÷(=ßï퟿Ô#&íÏÐxç C^ßèÿ.Óþcú½ûÁÆ`rœ°Ì1,¢Æ ¤¾HÑ÷÷žÀ<û‚€‰kÜf&dPÖHá
AKçô~ç	ÜN@�°"}< —O"|_?n�»µGVk±Ab½¯7ñ�qÖD]þ÷ÓcrHjOWK
8yHŽÉC?[ÇØ’yp®Þ6Ûàm(oUjÎ>T¿Ì׳”¶ÈHåVÇõìz²ô‚k5æp8b Ÿã]'±b¤ó$��;;@GúØd@¢X˜ëê]å—ÅrÍÌ@aÃk�v˜Ä@n‹xé¿äÁCí‹Ã2†?ÓŠÀ‹�ò�ÏV�…²å}Á—.ó£ Щi¼\¥É†¿�Ú:¹Ó“ê-t‹@ ˜š…Òý.¿1di¥ƒ¢`²lŒšâÍ]³•Ï�çÊ=N¢I�>æ:çõ4ã­“â�qÑ0ÜÁáSˆR3W‹í0K.Áø³²öÂvÚlQe–<G	ÀFá
\,횆ÝVaT¦Â¹¦s·¶¸é„ï´ó›xº›Ñ^.6–ˆ H¥×BðoÂÛ6ÆEœ‘Kmu®9h²NDÒÞuÉÉ‹Üëg^Mgj#7¸rá¾[z»‚�›7~˜¶56ïŸXµ;Q‰šc¶xÆéšßÙ¯«;ý+ÒÓâEªûy\#8EùÉCp9#8äæfÓ3‹è�KàöÌPZbÈ
mBc~øÎl:ôÞ}xà±vCÂfŽÍçD²c`Cbä8Ú¶i·7ìŠ »r*DÛ¥B‚9cF Q°&­‡i8õ±Û¨…OŒÂñ@KéDgÒ"…&]_mâWò_“qãákÚ¡¥'ÅCP:zòÝ^æbY/�~ø|µÕ€ˆ†(G¡úëÓ¦=쌖bè<#fH<$"¯F;¸Ï8`Ŷ~X!ùÁS–‰Êà4èº�DDšToÔJ-g�jŠ$|0³�ùåîÄõœ`yD·ÇÄ7ò	¢ƒ©ïW˜çe«�ÑQÝб#8 
e$(.FL.šÀ’Zo—hƒÜrc‚˜£ †¹6,üÛÍ’ö3ä–¶~òÁÛ~ÏõêÀ7B›\í¡Ñ&Ìyx#7†n#7ʹÏe
-Ž{œ„t=GAÝœ(ÑÂ�yjªT±Ad>]ÝNïöuã¡8™˜6¢‘O¥×šÈŒŽÍ4VK*›ªãXÄù|·1ì=¨ )G»†÷&r ‚aaî;&a ¥X_(öŸµwéÞò2È�MDÇXÁW§O¨–$å6NÜ{ÿêÔÏ!Ɇ­ gx�+cÇ¥#8!Bh<¹öªÖ•Ñ¥"ÈŒ˜=ýÁéÒþÓÝÃtæmœgêÁƒí•PÊY좥„:¤:ÔѼÔÔ³hýž>¬ˆò5Ô‘'"wÛ¥ð’§êGN&=¥d
+³6;m–UY3&l!ÄâvŠèùñä@a’þ~<$ïåHBü�邽?_z»T.eÕ<CÛ^ÜW!<ÀòÎw•„†ÕO]�fI@�Õ\Æ–F†lš×K›"Cºº—Kw"ä±jÊ[]¾·ž:ãCµªHDA¶‚¸X*2*ÆÉ"hdˆŠiw;÷X¶4-%±PJ€Nćm•�­ŒD¬n7e°›�©HT„�ÍLˆAJ‰@`v‡ißÝåûûúѬ,>á�í#7f|ؽ>`¥ønpßw?!°æYû{cÛ¹>óÅD¥DR‹A*¦Ò\®–M®—m¾½×W×WOšÇD3ÛB#8 "��²À|É
é‰ñÏ»^É}ñŒÃócö>´ä÷+Õ„… QäwÅmÙ…Å
’Ú<ëPÒ÷š5ýÌ 6wÕ®ÖÖÊc"8\¢`ÛQ„k°>z˜¨pÈ0ÛࣞŽtÛ(8»;wï>ÁWíìCã<ànþ'#&d†�ÛjÓ f’'"–SíZÏPëɸ>ìç]ø><{˜1àÀ¿]@wòo¢½žá»­×5Öw[µÀ¢"T¥°…#8�9µ„bidLY#&�Å$SB‘£ê:Ø�´3#&ØÚC±öÐ#7žS
ŒxÓßÁ#7Ç~Ôa±æA!MUXJ€°‚�×ûDÊ)$á›óo@Õ%ä¨Z?*1ðå“×8—wT}Á¶kxA“A¢=ó¯Àà]æfp8�w�á~Œßœ'"…1Þöå°Ò§‘_{�™¯%¹2ÒÓïa›oÇŽ¸ÆŽsœã‰èô‘‘’IëžÁ]wéþêÈæ¼Úé:ÝÉÚve´úŒpÝÊÚ‰e°x˜žÙ6ÔHz‰HK¡·æ×lN#7‘I™].¾4	,dälq›Æ±
1A÷7¾¢@EhÏ’ªŒ6_ßÏÀk؜Ģ#&4¶B¤Xª:G“f´Î^ ´�*Mƒò/`¡ñŸéñëõíÞu”â:h¦(¢Nyã£am3©ì3Ú†+³Ö®šçSTΉ¡r·Ó·#&�jŽ–*‰G2‰Ã3ŽÜ&?3S›'ÌhJLniÈw%ÏÒl::oÐí×[ä
ƒ³`» ®íCågruó÷^ö¼'BÓvÈ5P¦5ëQ½v:Þz¾“m¼"�÷ó9w.pŽK(yQöíÂFiÁ,`æ Alœs¶*�ÙFóõãVö’`ÇõkŒ2Ãu6±”�=Îf6Ûm/¬>η\Ø™‚8×.È µ¸h!6PÙã�#8HHAš#7xÔ¯x4$°!ùsÄRbáèÎ3d=ÂÁH#”8"pà–j£ ô (@kÅZt%Î^
E†A� K dN/îs{²½ó�™à† LHWòØÏhò4£ê
Z	zúLä"P|]A��Φ±˜*TØ#
�¢1€˜jNƘ2& ]+ž„ZÑ"ÜK».BqÂn]ÙPÜ0ª„¾¤ƒÆÑŒòi±#Ð`”	 6Ѽå­,kœ*Ài`àM$BQS9`/SÖØ@1eŒ2	u)a‡}Öì‚/áÎpôÅ÷~>Al?ÙX~½!-’òÔ†½¢©S™šÖ£I³T3.k7%x⸤ýˆfÑC«_숃i÷È’Ä^aôí}Ç-%Í;›#&?hsã¦My2x¦89óŸsüXI 	L¶÷nê6€G°Ý¿KèId¿¥4 ÷xHYÏ·gå4‡@x¤åg;‰kÊ®Ë;{ËöŒ#7”ÒÜÙû	ëÉ‘‡Å•¥­.ÍÒêÒÛ<x"ŸÇ:?gºèI¤ŸÄÜå<êHa€Î�"纼ïïìF£N]M‰R·,^¶{"u“»ˆp¡¤Ø¢�b)UP#7výö$�+KHÌ	Ñ}$‚4„D-G‡FÚ¥ÎìkPE.˜ô@¹ìÆJÅÈã”ûåþZÖÇ�´ßˆT|:fåJª¯d²'6—·˜L‘{ÀÑIÖo—ÚòzS6SÁöên<ãö5*˜"Âu²„ˆHR„ó�«RaÌ�¬Ë�G?�‘(”�¶‹n¥1¡˜BWÐA£|ا—¼5; ìÑEÈ”l†‚iXêÛÚÒÒ^>4)óŠ«„KýÌóM°Û~^Ío¸Âñ
¦S­HË$“àùž——¤ñÙ EÇ¥ÍbN%°=i…ºým=ÊØh.ãfô	š ï_«…8_J@zˆÅZFt$#lh¾ñ�¦Œ0‰åi�õǸ†˜–òj(vç†æ‘7Î8Ô|7NŠ=â�"¾C‘º€b¾Ÿ3…ÁÌ攌Ÿ¦ˆb_åìyè„âš’²2µV€ò1ï–1�_Æ!FˆbS:ùÂœ6“u�:ùÇka¶²Ž=8É#Xøç¹³x`˜Ç›6Šcb®D•B”t.ü§ª5“&€Õ
@9&{ußüjѬ>ø-Ÿ4K³E›jóx¼ºÖ�‹°?Êı�„Ó�û²#8§Ã¾�873iL™±p‰	"ž4š(âËrè6lîMroŸ‡dcѨ`ÊÚ)!5¬t>ï[MqTg,­ÅzBz5¶šÂ”pMzu-5¡ì^L¶H2u¡:@[k_:æîºÓÙÎóÍzšT…�E,4±PM

;q†áknaœëîš(�숺2žpÖ4	³otˆ+“e;1´Óx}š07 Øc›Ê
èÃNµhÀ0jÒz_ÎÙ½±ÈzCMõ�ÈÎ7ÚÌ1ëß#&º×ªò4�dysQë%zqBLQq…†�‰ý‡5ö·êH#7]zÜR¥D—<�ºAQq'kèŒUí“ßkÑÆxgds¸�•;¿Æb-›TcªoñCd0ŠtŸ#7¢g~œd¦ {ââPꃰã#7˜dFHB±Œ<Ì0¥¬ÎS|­)ˆ©¾Œ¹+£e–¢¼Ph*–¹ÊN†½ž·.ÌN!:’<IÀzU·’©¾´ämšj82058´ðNCÈŒ(ƒ¤œ@š…yœà0irè>^ñf'Ù„;ºHgirÝâ“™×Fpg-lÉZMÂ‘6D>F–5`܃%to‘˜ê�qu“‚^&–H,47j݇GH„tû®Ó�¾�:ܪ=×|ãuu*LÏ*Pôý4å%—*÷ÔY¨Æ¤cw1{½\:3 ™´{Ѷz‘¸ƒn3É͵ˆéÙ¤­sùªp`O°-‡“ða�õ“Ž…Ê"U0J	#7�ØMÍ… A©s‚A§éT3n؆†Â6ˆÍLÉÙŠM °¦øãËœ[9•CÄSBŽØ("IL%G©!H½ß&¿A¢_GqÚ²Næf¯®µC¿#”ÜÄ!Àg‰³g7»±Ê�êà7û—àXàŒm8„�&Â{]éå&D×*q“*0ÝœˆèLºœç+2b6çtî^‚‚Š&‰°Ç•²ÄᾦGrª6Ì •�ñUV`¢éúlدA1HE¹�~Û‹–gÓ¢O²2ç07mpñ—©9­æãAê߃ïµ,9¥½p›ØwpD34Ël›
×ÜÙ“;»”ªQ£›Û&*	°÷%,ÀB˜ë=�Û {Žlä=SB<ÅS›ÇOÇ¡Ó>Eâ_TXh
S4,õ8ýß!ë	ïÜâpšcÖ†1LRZaÖ‹r]ÃBâ+d¾#&i1Ÿgº”šJ�ðX’#7p°ê­Xih‰!b4š‚BäÆŽ™$ŽbHÕ4!¤¨
¡SÏ¥FŸBûÖuJš@@Æ�<sM†Îœ(²aQa³¥š0a"@�°´èûÈê˜w‡$MÅGO)C¿³Éày'äM8…í©’~;’\¦�Ãé<nBÎÃåóe˜Í쥗>>¹ó×CY/Æ£ÒSÁ„2,PÐûã‡ÛÝYo
™‰œ5VÈõGíFæÉ»BRøM½Ív«0˜n¾åPç$nz¤„&Kuõ†w%¨5´cÀ ž¬É}Q#7aI�I?™D—•‹o9½1êì~œbòa
�Šì{o^€(ï›ã�¨Düdˆˆ*u¯�sÅ·DÔZ´m¯R™#&PŠ%(&B¹*Ј(Ø`‘‚b½‡ãÁÐ5&½ƒñ£$<F4öÊÍ¿#7(ÊRy.—ÃÛ#&1	4@à@úÉ–O‘õð<ƒcŃ8ZØáûI¹øsÍtÕ­õdÊ"2LB ”¤ÉLÆj”³2VRšb“j6“-'Ûu%VÒ&*&š˜6h‰B‹ic^îÜÃ$mI‹$¢R•³B™13LÈLhЊ£LM(š_'u
F…1¤”–X˜UdѨ"¦¢Š0L¦FÆ2kJ6U!)‚RTe5R£1š#8e`QdÍ‘)Ý{Ÿ#8ðI¼Ùï©ÄN@W»J˜¯|…’!jgŽÚ‚dççCíQ}LZ%äÝöf?†ëãüúÊÒGñ¨�4×Tk!êØô‰oÁ´f¸| 2a¾Ý!©5:Î17‚ë>îAÀmLX¡£ÒX”Ï(`#›êwùÓ¡O	E#8ÇL¿ƒŸFLOSŽ
!í…ËŠH8#&=í‚™—mn1óv%–ìbµhJg¾\¥£fq™ëk"æ³]pqeŒzöÖgxfOì!Ügëøý ½Ð¡o·svH#7¤ÛaŒ¥oF«dp2.EÑ-úŸ¨@¶lH¨÷½‰Óm‘SY6Å¢ &Fašª‚ˆˆcáÙËÑážnǤ>c–¡~R%­¦A‚KoÉÅêQMœüåù…•Sy¹Æzôaàaк³´ÂD²#8g$äpßÙËSOÖºë1«‹=I<'�âA	ë*4²½'{öPB6C$(¯^'ÇÊ�)?H'“ïÖô=F0‰¼RöHP,¾Æ4^	ð#7ª¾Âþ?×U#7#7$xG<£ÜÖ’÷,)¦�µ¥ßg䳨—»•Ög¾IUa:ÅZA‘	…#&#7¬L€šbpϧ½Ûôz¿-‚�jÊi^Åüpï›ü |WO9³¤T¸èËÁ§Üû*ª¼x"&#ˆð�Ën)ðh·~]áǨ�kµf_²ÖµbçgÂþÔÞC¬ÑÁ²\2îú±ÞwÜß0¶fyf[M»S‹ö½ŒÁ‡¹�šÆ Íú@‹¡Qm^+W+“ˆ1{6]ÈBGjÉ¡q·ºÕŽ·§¥åĹí–“}¤ƒ¿K#7õqºaÇÛh bè$ÚGØìÍ.=ç:Ûçï~gÏ»aÎZ‚Q!F�Nv£Ï¥ôöz?–^�Üô.K×#dç¤*bŒ¡Àê[šiÜOy¥nkÅ.�l›X]ÍrMa6ØOÂhKb“—O¹ïyÕ9o	)_J*l&#7»–`m�ûÕý2WÙ­?Q&Ç|÷b[;ͧd*a='b¹—uAA™Æ3
Œgu¹EJ�Ä¥~Dw‹FtΣnå»+㓃1›ïÁî…ô/ ø #7ؘÀ" øúM#&æÑZ{oÞ�‡†@
�ª !
;ùþæUþ›ÍÈ}•ìöËÎÏÓæÏh=£õ®ØÇ÷¾0JW‘ä7¾ÝŽ^Ê›\—KÚ� €qô°Q+99bÁuÞ‰yT t¢LÈžj(8 ~a㥿xB_{S@Q£:P"Q\®Û¨²Šûü_l	3£õo´Ó‡ÊBJåò)pžŸ|Ù7"_Ò¡)üt¨[0”Æé!ˆq(n½…Ôn¡¿Ÿ¥Iïôíª¦ªŽFOëêÇ„–†oR‘S«ß¹ê8‹O>}S‘'CŸ%.ò{aÔই¹ÔÔJ=ÕÔ‡†œÑ]'_å#8Ä'()ÀÎõLéÏž#fßñ&Þ^í>ÍÇçýóÞÛcGß&~9˜},–…©MÔM²$ò}-ѨÅ5©ãyYs2ðj1¶dÕD¡•ÂŒ�k�:7¹¬Àm?g˜·•Ï®6a�·5§33Ly¨köÂk$wH´úraÇF„Yö˜¨ý°[y`½³0brÊG‡f;VM-浈œU¬‹Eцó&dg:ß·$ÞÚº²j�­¾tíw‚mäîñºbÒ–ñ?fkFç7�úja�,n©ÇsĬZåfËŠ†¨“l3>ÍtJ#LÏTâÒ{U¹™Be¥PD&’‰P˜hHAPRæî(ÈÌD£Bæñ;PZÙ8ƒ��8â?S¤é/råɧŒ-.ó[Þv½¬®NÝŒBÐ&AÑœH-±$쎴0yÔÇ0µ£µdÏ\Ü×N	Ë‘»l#GWv¸»0¤åÞQb¥ø1•¦â6•}]¡¶}s6'HE;mcýÜàqÒ�ÚÁ¸Yׇk¬iÍÔIF$wz`ƒc³
MGêÎŒ»¥XêÃ!i/‡Á €ÐÁ¦·WŠ¦‘Ù¹±½´bdí�ŒY’h}CNJ�Ž;ï7k™|ïÖAx>7a	Îs·+uUÌcmDÅ(Ö•2´ý3kv4™šSå¦ãb‹·rñ†BeÒÑÉ¿Å6¥ÿb`c@¢~Žù‚“"¢¥È1Ô&ÙdÙJu(Å`ÍCU,QJŒ!6k'DzƒÏÌÛª1yßPN»ÅŠ v$åEç�#84Ë�ìÃѵw�õz­ö5¶ÙÜÕô~šÎÝtu%$mFr2.¼u��Bîë½úǾ°f9çÓ<+η‰N†&ú6ÜLry9·Ÿ¾!ÒN“ãBRac‡3[Áªœï�ä8Û8$‘úmz­ïšäìÛZ7€”͉}îªZøO.9¾_ç:–èóŒ'!z½BT;g$éö¶ææs°Ù;Û½ª0PŸ1Ê©Ý=ìÕV•#8]E'ûÌ�3«!#­æ:ƒÌnîKÍ:Êl3&‘FZ¥CÆRÈ<5µä7:¬›#7ÄF„=	3³Bë3iSjƒ48Ø–µÆI’÷e¢#\´ºa‚ãPeOØX‘XDtj£$‡\RgK˜z¤Œ$�B7WOáyTäÀÒ²"îß8�­µqd¹–Ç11*grö†ÔÄšL	L™fVšÉB�øÁ2w\j%¡<‰™¹’¼'1tY5½æ´ƒ+éª4r<¥L¹ƒZÀ�ƒ©a1°Àp†ƒ&ï²	Z“]!ÐóD”›‰‚¶zÁÖ‰*™2nxˆ•¾ª¶y,t‹dš$Õ£O„BÙÜE˜ åö�–éŠ\õ‚ѲÑÓŠrX”׮tovsÚ2f€ÖÊ6šïœ_–’÷ètÜA ú-N�óª:#7æíD•¢-‘f™Uµ•NÉ5Ä.‰Æk¬S#8éÉe´F+…çw;Ù¦ÎջμÙÖAzIŒ½&xaÉ–VÛT6)…–Í*$Yhv´^H§�¸iëV_.l…ºbJ©ˆ½¡Ph‡TØŠQÔ‡¡š‡!^ñ2›*v¦¹á©¢n¿/xq·¡jR}i®afft-[9[l;cm‹Ä.!\2±‡WE°a(Á
!�óYΤßÝFôoŽô;KÆí!4™tçß’á#!#7ß9—F¤mº×2#7Â3Rj•þhÛ"ÞWÄìl—;†ø�†±¹g–Ç\å9Å®“éÕÆ#7[ušo¯÷‘›ÆÜήµ˜#7œX\&Ì�dѲGÛ#7ë+³XqšÑ3(dÌ’™ÞžV©ñˆ„"qÕk§™ÑXW·å…f9�àh‡³KfËfÞIISÍŠ*¨¡	:ͅ‡u
7WóI완j�#8Þ²Ìf2úZVnjŽLñÆñë{ÔÔöO~xŒÞt¦!Ëõ&‹s¥DÍEÕU<„Ò¨x“Qáeøpõ°*+ˆ�’%Q±S	epSÁ»ùk]°˜©®ÐÎØqV¨´Ui¡-©£ÑãY ´˜Pg`slÕ“W’³ˆG�Á¹u©žÃ5 Çƒ&&M3v�\tÔÝ21ÉO%ÂMPl+zešÌÌÔèi$ÞknmÖfMÛ53—N½Fb­ŽÍS'’c,”Nš%Í:k®³–ELPÖÉmÑá+<+TŠCT4òº°â•Å±„á®Ú3•�Z©øÕ(Ï&Ãeµ“¬#TáŸ$jÙÞå6vPa9¹”¦®pÄÖ4T¢Sd6àöøÖ,ÞÍÓˆ@Óí¸VØF8bçSS§<-ÀÙ£µX?q:s…8�B™GÒ@4Î�8µ| 7tG�–× 9LÃKÊÆki€ÌR&P¦
Àι+sã0rnჸMíŒÍJûÚ–5Z):*ƒc|@ïtÊÑ’U¡#Âà¬4c›ZªšDÜ:#7ÆŒbÎ%,7ý^ÅÌ:¶Üå|³o�{qàÕzë™N@]š; T³<®P’n„….å
‰Úbèòe�-#7xw`ã´êõ1ÕbŽ)Y՜Ҿ³ÏåÛ�ƒ‰×-š`„[s£Õ�ËXXe‡cc#’xA§\YmÁäwXœp#&Ã,‰ òb©vÝôiÚȺSóР¹äÙH�lDIÜj�ä"sÔܲcèd.vªê�8gµgç”OñC€‡ŸM	ÿXÂw09ê%ñƒ×.·âÐjW^ŒL‚„å&GcÙ†ºÔ¦™£&ŒÑ†,rå†éXôÎ!i4`[v½ÕX­˜™ êÂó\„Ëf.þœN'¤õ5/Ì�àÔ›ËÛ†/“ðK“×2†¸�ü³ˆßb(,G5)#7Ü1Kz4‘´0!l&î®™©³%2X¨<u½ÙÉ%¤[V†4©ºjñMdI«'6mƧÂI«-‹–GJ,#7Ó	\«ƒ7`9¦`=»_Dç°_ŸJ5³½b1ËôáÒM)·)JQÍ#8^Vhä°Êq6©«'FqC¢ë¾0.õQ)8*‚GC(3|èôä=3.^¸#8é‚"2hb,l)qY ó¾·)ܽ8zݯ$FÐ8èNr‡‡Ýw�t-´=¿r…›n#8‘¦n6«Î6f5¥Žc™Ùn‡78'&ÊBlŒæˆd`g †n �pãìhÚ[v­w–Œ<oKÁ/m5´9Ž0¬˜l¿Ž»\õ[0Æ”7 ‰5ÔÞ“Bwj`E¸n[ñJ§‡”ÄÉ“—2‘ÐLøàLÕ~ì˜8ÌLåÆ(1E¶ÊÒ£PòžÕÞøE�[ß©É��2b¼'K°ˆ“f€áH-øL�3[Q;rŠ×™P›¼`-ì›!L"†R�P¤%b
Ì(£Œb±#[x¼ã‹b òhMw;ÃŒj>º³©Ð§tª6vˆð2e‘Œmµ$`1³„»÷¼~:æ¹luã¬kÖmד‰ÿ¤c;À‹ºÝ¨hö:ÐV0`¹ž¸#¾Å	ÄÚuÒÀXšƒ�Aë8†æy¬äb¨Ú�#7Ô¸\¥°Pio¶ž¹â#8�©Ë]äPÈQ&£™3+HÌj&ÆádÍ3á cRÄBWU(ˆ#ááB�ÃLbkJi¸Q.ðì¼"·eà¨à<r΄h½ØÑÜŽC*¨Þ½ÆÅ
RŠ £
 &Óy±ÒŒïÇ«8 ¢“$`¹™i#7#wHsa—)œd¸ÍáÇŒ+”!¸È‚
‚Þ†!˜t…�#aœÙ)¶`²gÆT)ÝÇÔP#7±±@ØöJ‡ee°;8e¤ÀÛpÍe0l6X£{¶³@M˜l2%�0ì5°ÁV»e#–¶8Â\bÍ^GxfÝ©$2]h­làìl4™@ÒБÐÓÂ…IU�Îj‚x::¥é6Äç˜#72S“2ˆi)€ò÷Ÿå*R%Dì„N€ø7- p¸©‚<JÄQ‘Ïö|AG€}þNèz%§¨{}ªÆ&UI@4ædÙ™„H}æaÞ~�ÿ
ÀrKÈXÞDï#&�!æì’ŸàGÊu	DB<à¬aÖ&�Æš©–$ßmÀ#7À0©²@Q移-æƾcK
¦ÁÝ�¾•¾0útxº«¦ãƉʄë ûvµe²9íë8?SîÖ…§}8û¾ÊÞc	ÚÙ‰NR™­c&ïÔ[H,‹JU‡0ãZ}t¶â…Xn®ûG<·…æÓƒfÍaƒàdëU¿L%#âðg2$›‰¶oS§`èš\.SˆO1GsŽìM0qË~ÓÐwžfÃÏ…',²Öxc!#7�ØvnŸ�=0äûÈŸCùÝ–•„©äÇ‹±ŠD€ÁHP3œ°Ÿïí€ä¼²Bš•
eÂ,,¡§Qű«Xefm É1„}ò#&,I°$`a)©PMŽŠ�ƒ¥ih‰=,'n‡e@ò	vß?O$0ñ9bzüŸ—Ð’8Ï
á|ÝTlcë+PZUý¤Ùî3J’MkY‰0ŸoÛ¿¼#7‚kÜ
Gš	¿§ñá}j¿�Bˆ ¿�j’T }0dŸ¶BÈÀÌÀ1šGÆc''ªC%ˆïF��µÌb�yÁ�~éê÷à{Ä_G¬|‹H©ƒüÇšÿi=Ö0r�$ë#&�@ì“ ð^ó´¤´•ò“Ê=pÑä@f±ƒp]ÉO´ûpù•î0çÌ~qÍââ¸6|þÃ�€lƒÚðþN•¯s³ýßw™âX»—‘£€_ŽzyU­(Öº5h¯@Ú¥Rb`0(Ô`eŠ#8c´M¤ˆÞ'Ð72à\ß(cÜ�wfÊDÓš;#&‘¡M1(·¨ø!Šá°QèÕj,¨Ñ„æ#ˆ…äl;ïÄ& 0wÿ ùz8RǬ12:Ž+ì?c!ÈCûä‡Pô¿†¿�ï#7��[2Bâš3#8Ù î‘ó>º7ü*‰#7¡%&¶-�‹FÖ‹Q‰1¨Ä¡´f™–�@‹CI©9€™!�ÌÖ#&�Ù’}Ãßô›ü:gAhòPS^µ;{võ{×€á|#7‘ê{`S°éíùÖõ8áʼn~kDDm�a4ÄA1hÃ#7¤#&ÅÂB“ ËšN<J9ï	ÙéΓÂ|�SƒÜ–GŠ{Ì	Ñ©—ßÆ9‡îß#7d}çå‚„Kbó8仺Ãjè¥=  di£ä¾xVø|¥ü–�ð0`×Áò wvd¤jþ�a¨Qü7yš]ªúÔÕË L¯ À;ž\ò‘˜[]dy„Èb´®á#Αõ0öœT*ÒcKi"ÈF+|F²6…”¤»´†Õ i‚­%vL`lÊRÈ#7‚i ŒU¥Ã3D"ÜŒ˜Ž{ŒÊDÍŒpgܨEbæ÷Â${Ž´´`e×1&a‰j©Y‹¬Àr 0#8¯×K{÷Ì7¨ù†cÉ;wdÌ=7|jÉhLÞºç$g®2iEV2‘%Á:ñé×["�4È5$*GÖ©K‘ëD+7²–C€Ì%†S�„£Â‰5uI“zÔÙ'#7J“¢BÄŸÜ›Œ4\fÂnŽ*rÇ–ÉÙ ˆœ
H<@ñÙ&‡€“ŠÇ}0øfô÷ÿWÄ=�ázzŒg³àTÁF%P­�Í:gdÀvGi“G镲îl†)û#8‚�Ö…NœPÚ~ý
Û#8$
Hæy-¥5þäÌ·'xwÄÉÏXˆ/RL¯…XH1T³#7—ž0ÂÅ`Ã)ùéP5”Ôé½Í†nogm‘„ȸû0£8zë“>ò”¤îàò;‚Ä‹gØÒÝð6lÊB«ÊYÓìQ­cñc„QÒÅé˜PI¼µŒS#7pîÏÆšš"NÎ-„WôîNès:ÀìЪ;lÒ B—ÂŎϱ›8ÊÝ]30¯\`q£#8ö6êØÞå1‡‰¬�pAIљ̇‡À>¼[íÛƒ†[øA”Ϥáš`üzÙÊIŽGnÇJ&ÙÎcs‡É‡Ëd4ÎgXH„ }+Þº,”§!½ˆèöj׈Wו"™F×BÂ�6¡ÑÎ2à²í\&óM7Òù-ñ£pÌbF”žŽñqÖ=�‰©ÖóH³Œ³µoHè1ƒôEG;#7ƒ›–y¡¡�Ò¨aVd1ÉÙÙ^Æ91#p9¼ÑM.#耢&1ŒÄˆàÀ##&…æaÆ3‘¸0;#8×Nõ�5P*@¥È®C²fñ
@u˜6œ	#8:±Ñè¼[þ0€D6'¹h^}¼_h{çɯ¤�üs&}Êå4â‘E‰ì `ÃQýêÝ(˜5÷>ù@«¨ËÄ'ãr¢Òk²�“Îö�ð¥ îÒ�LƒD>èòc5ÏJbi%�ôG’ù5˜ûôjÂÌÌœË'¼Rª…µQk&Ñ«X¶Ø0B¨|‚’‘GÅ÷©ÉÅCËR“§¥²­Q}îf]³ö>“íAô&ö'D�+½µ<|ù‰ª�óÒÊPŠ_]ⲿ¼¤Ö#8Ü[GebM\GPÕi%r(l›ß]8k;Ä£e3Њ4°®f‡Òu.)e¶¥:Û/y¶Ù1”›¡™[âìjZö¥¢®”¢&††‘s¤ofLBÚ.ÙUâiÃ"áâ¤*ÛÂK™¼“ã†F²™¦îØîÄЇzŒVV6ßlmŽH™X¦œˆ“<ÏÙ�½°p‰ÅL™Õ�Àâ…¤×C»#>s#&˜uj5£x™g”¶3)C=Q”­fš8|+‰ÉχY³‡qØ׈8âN);œ	ï$9	á9ÖÞ(´Ü§#‚ðÏ*„-U&0óulÕÌÍÖ¶é-�ŠˆmœÖÕSO½ÌŠwp�Ô¡d–…™:á[áÐífv}Fef±8SµÉ$ÞÈàfõáã¹ÄíVñ²-2I¨«P]+uœG"Ò
%ÚVI6XòH;Š|ªè}©‘†É±e�†¡Ì0_©Ÿ½œ¦#7HPe9n®ÁÉ€XšNŠv›vmÆsµ”`4�*˜À¹.0L¨ð’«aÉúnV3j£4edš%ªr#Ga6#7mâ±DÁÙEË°�­ƒbTpÖ›h#7B¥:P©*	i]O!Ø01D8	$€#7¡pç`jÐêïÌcò̯á³zì|¤ÆÀ]¶GÂHk¦ÔÐwv‹³n•‹»«ÓãÊVVã,•±’72È:;šuPLlÚÃÍe!$š—#8�Ö‘ÁгNN1;Lfm˜4‰“-§iæë¼Í^f¹¹(VêVâÖŒiÔÈR”“
:lÓÌáI'wtpÇS§"#7×+ð”]ˆJ`«Lªd…)DÙ¬m‹YRe)eåu®š±M¦Mh52Ê¡x'jömµ0” U5F51(¶Ò[Tmª£@UIJÄlkêùþ&sxO5Š?�;w°ë&Âm¤[*�äºx€‡Ô€‰¨oÐâÁ)A@»2a&*¸Ô÷ˆ¿ô�úiöX|õËò‰€8mýÑ("zþ=´�Ø9�}Çoèä‰òv(~fP÷#8Âöíî)£§Ú	ó@¶a€´åfp2ð‚X{uå¥��¬­bÜ¡!1*zZJMKyµZm§ÓO9ß�ç&`&äðRñ7ÅOB~—öh=L»mŠ™˜#„% FHh*ÿj #8Ó`Š³(£+BÒ]z�á;v#ÓÅì§|×oF“i®R‡ôp7ß{/öÖl!g:Ÿ¢#7ôµn²$MÓ#7ß#7ñýc#Å›
aRJÚÖ¦S1ò�à‰‰«ÑÖH(0`9	ϯŸü³ºøtïãMÕ�½£×\Aàì7}`œ„ÁÛñå–Øàþ¢ø¢þ9˜Ç”Ã¥J%MˆKHW†—ˆÜ«gïç•,æå	„#71›�„-V„-¦	3¬6‹Œv#l.aûä:¡+;c»³îP—4?0áqY-‘ÉËä^o#B;B“¢ªþnÆkhëo˜G«Üø_á©)xòñÓ–2µ;‰ú]Ñ*Ó¶åI¨<[s»Ëà�úÐ?š�@e ‘÷O�Ïõ½O¸ýþ'„Ù©)$º¯Ž0Bcõ¨@%c:”p÷�ÐÀP†ßĨ*Â#&߆@ÛzRôì›hÖ�üžêŠ²I¼ë¦š3i/nµÅQ“xÜÖÓ"ÊÒKd˜ÚÏ)[\–k-Œ¥´›li4“Ç)¦ivéf™4ÛLRÊЊDeõÚë#8F«)˜l¶i�1,Ú(µ©ª¦‰éÅHÕJ\0”*#¹L“¤d7ÃJHJ	LÚ¬¢m^§R­D‹E$4ÒÀ¢UÅ;,bM�^»¶I²(µ‹"[ª©M6Í­n]´´Y4.ða®Ûf¨%¢RRX%0©kj‹RÙ´›Ó¶Ú¥j1‹G�º+6mçW^w&SV™#7#7_žñ¯6š¤Þ…vÍ^-uŒ¥«	o#8L‰¢„%š“kj#7ûÿE¶iÇ—~Pÿðñc[&íÏu#&Ç÷ÿOë•ÅŒ6é�¼t?çùüóí÷ôôêÄù’$À˜Æ�ý×¹$Â*7ùVRf¡“h”cìñÞ|Ò"ùT>#7¦˜jÐP<Pƒ)&QvN²Ð4»ºÑ‹"Ú9C¨^#§v#8ð ô�^pC´%>.éš–›J™¥Y6¢�0�—³¦îÈ{¤$¨(¥Y Y$$Âhv22FœL‚S ;3ÐH˜HPÛ*»º£b‹IbØÛjäxJo*»¤R&܃Ô"œñí7QëÜbˆóR;
•ÈP#8X…XÙ²‰f(XÈɉm}5tP”jRj”Ö¶›f̱VJ´4¦ŠT¦ß"Ü¡†ËQYTKF%&Q¦”�£Ci¶R–DÔÌ“Ìe�‚¢0¥šÙ¨¥&$ÒdKHб²Tk(¦‹)e,Z”ª"¢¥4™R”È›61hŠ4ÉdÒT’˜¤ªCHµ(›Qµ›M*B„”˜°Re&L“L•,µM±�Q²&+E,LÚ“$‹+mK5“&�)„$¬2(D¨'0DÌ¥@‰H‘ˆab¤ˆy#©WD²È#&±"‰‘’-<piC!MÙQ¡DøÚÜÕ)lÔZÚDÖ¨,#8t•#&É‚ ÃŸ_y|C“°wíÙÀ¶r²R3®€agl”Èúq.ùÏJ Ë¯%a¸éŒ™ÔWÃL7ùYÁŠ#8néuõÜeþz‰µ˜E7¹ú"#&[·=媇#&¬ºt°|—SéúÑ/fF¬hj0ùw�Ä™ùl4÷ãÚI$tç#&�÷$=¿æêÎ,òE3s«p%‘Šü|»êÙ×]ضhÛYA3rìô]Mø9)Fí%îA)]¦%Õ|”Ïœóã¨YþíCFßlp{uȇBŸÌØQ		\i´0�ÞCH˜æs5„‘¦™s9leba�Qa±šÏxŠ¬õ}Èsû¤ö#&G}�FúBúŽÝ0ñ;¨vJxø†*©
S?w»Û~[#8'÷¤'(l£ô–;Q§2�¢‘CçPä’ØþlýýIÔ‰)Š—‰@y&SJ(ªœ·öÚ$Õ1~GÍŽ>;™¤Ò¨l¶ÎÆå= ì�)‡Ð`¢†“kì2à"¨[Þ¬Û`„Ec“†Y;
`”–,Å�@ «x» §6$ZD¤‚žŽJ>xF€çÃo½áßpÅãz‚¢¹b}•Y.¹ŠÐé:ü[h•�­œMú59#7ó,’3³z­õÍ&k#ª¯*ªšÂÐÑ=�ÅX^–6õÓG"Å3­Ì>Ž#covÊH8Â7Ý3•iÚ w.Ö¤v#7©ù˜¼29°Œàà¶í^dIT—�ˆ4Î&6 ùù|¯w­··iÀE�I€�åÜ#&#&-�¶-ª2¥{	Ã"­‹*ÞÀ{”Íüä»?=†	©J&p^½ž‚l²Pö¡áŒq~^%§xcÃZÉEÁ„~�·oG‰ëCH¬-/‡C«ª¢ïL&¬]-:¶ñIä—/mk{îúG:Þ¾:g@é÷œÞøz	�æòìíßìd”øóÐ]Á6¦´Jôñ¡rêF˦Íʈ  þ´òxŒ�in ~ßNüc›Õé�y`’y¿7ò¨ò®ów�«è<ÓQ͘>n.¢?ÖÕå¸Ó@¡`‘dA‹Ô@ecu¤Q¡³ùÿŠWËU£{•–ÅRF£Fb™¹g<t2;ÛA£0"e°+l#8Äh{ÄCRMn¢×	ŠeF‰¤öï^mé¼Z$¼‘�C�šhãˆbkXâ­
ª¤dEœÀª±³‡ƒiÊíR(Îlؘ¥Y^e(ò6›cUí†cˆ�€)JîºH0Tµhy¤PýnŒªg"lŒ8ÈÇWÆ%¶hsÐ#&äò»ù Cºg†(Ý£ß$
gáûÌdÖ¬FC¬8ZY¹õïÈÐ93ݧ: Ød¡2Öã¥J¦²­ÀY©íÉê„90Œ:²PT<Pñ)¯OŸ3]Œ½�©<¦ðªÏ1
Áhð0�B*8sïÉŒ)oFõne›rœÁí÷ŒÑ´º�-#¨r��NÙDõÓ¦Áþ¾Kúׄ¯,Q…`ŸxN_«ù†~Ô#8
³ÐLBÌ=9ó™Ç_Ïôýw•©¥"CI�×4½²5.#ß#7HjCb1+\ïšM$,•·ŸZ«ÎMòB¼0Uðß½Å_Òëz8Í•ˆ‡a‚úÚßTsDrq¡V—v‚A[êK6CÒJÊ™P!+~¿#8Èÿ[&ñ˜[|ö,7 Ì¢#7 G5ÝeäðG‘½ËÀ,KÓèʃòzë8$8Ÿ•HèÑ\iƒC�úlBÓúþê‘Ã
äB?¯#8Â9Ô\ß³xöÁÃ25Û
;�P¤…´†ÖuWîZf~;#ö´gg÷ë=Vt™RV阆‹Lj°ãjØ$™DÜKc3y
°i©IIæÑðÔEd47	¨�F™2�>8#7¸>¶v8>~z|gT—"|EÕ‚é‰�ÙR€ñ ÆM…PÈe"g’xQȵßxǘbŠƒMØâ•27Až¾Ø`æµH2ÉGu:¾t]P’ðË®!q�¨Ž&3�ñç6\O[…>fÏC¾þ0AUNãÙÄ0ìÊ…U/FP‚P'‹S£Ò‘§<nû¡ST�B 0Iד‚‹Ì£Å#8±M¥C�•‰Prd\Ì@¹B7r7íï2zû;ûÐù_—j¤|R‡,ãxê.UDy#À±æ�¼’¦Iè6#7­zK‘
)ª#"‘L¹¶©ðÖ¦f”VØœt•�ݪ§~•™‰¨Ç›š&#7·ÓD„NÑ#&!³ã—’$ðw^?Wȇ’èb)ÂÐQTvLFÖÈ,]Ö:jŒ\	£OL`dZì3¨/�´#a·*³dŠØY™ž%C™´šHÜM¡¸2OÆhu*’qèªÄUöQJ¼‰=¥ê,Ìöx3»¬ÞVÌïT.4ï:’gàâ{(ÈpÁÜu‡Q
Jò#8hÅL‚*CŒ4(Z—²úÎì:¦,lø)åJšdîb\HžíÁΗ#7@#7zGVl©’É$¦+~'Ô÷÷4%!'‚š�±<ÎÓPÑ)O<ˆió`ÅUñ	W¿sFCB4ÅM;˜£<ËQä¾+ÎöqS—­;µÜË×v3Ž7°‘¦›VB=Y¤5[CÖ§u#ùþßo_#7ñWH W½ŽÑîàѨ#8¨æG\ËŸ!éÄS%OXE`¢|µÅDÇ„�¶&Ø0­Æã0$Ýwrèótín’Í*nè‚­£kwq¯“*%ÑK�#8+)Ás3#829Nû†É–0Õ>ŒÆù�Ô�ŒjH´m`ÕgQÑ”û}�æ¡í€yIÄöðã„ï[£!ð›
"£$ׄ’pÄμÈzž·É9ùkßÓ¯‡�oÈ'#8#7ùª8wÒêF»5¾ù	q¢¼o°wÊ©Šjµ†Æa7‚¢2Wá6­ŒƒÕYÂs!ƒûø‡§¤4I«$ìWuÀŸÖÍ¡ãÝÛëßÔ…R1�é‡Ëç¦_˜zB½óÔ�äõë*m¢‰ÝêÛ˜C¬å�Y¥/âŸUî�3#&B�e~_ŠÞÆïÇ�Í�ⶾÌ2#R}´=
‰j‡Y’U,Ÿ›òØÜs<W0uú|}”�‹#Ï–X˜‰¶‚±;l‚Û3ìÅZ)ˆÔ÷9yrïWŽÎm÷�åe2U5kA­„$1ˆƒFc:UJÀFìÅ#&ªëbÑTfýÕã®uNíÄL—,\�v:ÓX4#7¨jÔ4£±Ò�“ŠLJ•q13‰!:0y‰~ݲ
ÆLñÚx6O�îåØ›
Ú„šyžâ†øy>3çQ¦ËZìCÄôKG�ž83MÊÊbCê#hÔÕ'ªÜûÌØfª™dc$÷%¤ßl
”0®�c«F¬›Õd]¯ô@š#8‚å‡v²^	Ø´€” ÞåM4m(û]Ú­^4mši4­+®‹›à¯!☒ÈØÚ5Fµö®cCOt!ØR�¼o�©¨2†_êþ¼Ó(‘"¤¬#8¦ÐŽ¿¶‹ÐÅð.¸5!„ñ}qQÍ2Ï·7R4øæšÀZb+I6…X‘0‚#&€Ëz˜Î˜6Ö„Œ‡ä…éB¦³®d$±�¼Ë-!0¾Kxb*°±‚±*I›!0Hdw+Û¯ÏS‡dÙí¹À˜‘ãÒ-‚ÃÜs6:N8®Ðû–ŠMàCüQH'Ž¨¦×¢:xã„•´äŽùoÍ©1ñüP¿YÜo`_cŠ…],#&Ýì*8Øe�>8@åÊdyüŸ>:ºòCûݹ9!�2@faR“…$JR)XŠ²‚v?Dÿ1¹Ø±‘»²éÅEÂGíA†`…â�o±sR:
Ó/Ë#7·­­�‘©Úæ…>L¤ó_�С ŠG±!.ŒT¢6ú¶ü/ËÉúýð/Fæ…Ô¨Þ¾ª-ÀCÐÂævS¸ÛgÔ“ëîñå!¶¿ýÜÀ“2s›0äñ�‘�i’#&—ŸÛø»î áÀ#&Ì=2iPM�¦K	ŸKÖI¡×Òç¾ýÍÉ°kä8ñ—ƪ‘™<“ˆy”E+Ê9�”þ^b¾Î½Š‰ïŠiû÷ÁBTèÆ#73JÿF§È?€þ›7·_SÇýÙ¡›þdü¯	µOk'[(á¬ì]£vÊmø4)®ø°ôŽÑÇÅ{�F¬C½Ös‚U³HˆeOßäøHë#8¢ ¶­¥‚ð p!ÁˆWçnŒ^õ­'³Õ%z;µ�ßÇ´/6ìßùþ°ëÜôï®ÁäØb3ôÅéÀæ^ÉR¨©bOyðÄ÷D?ˆ|á/ù�zî!íùÑ>$ž,M#7b­}쪱sk•VºUT„Xƒ$L”
¡9‹à.�0m�% P°´/ @1ÈßšÛï*7 Ìc‡øA^úÒé´5mˆ+ÚK#8p2��»>³]Ò«€hÙí<ÓÌû´|ZŸÜýþÑñì#&—º¿@ù$2v§ÌŸHQâ§ShN×2Vaþ°�;ç2'rª#8B8²9Ž`)á¯Q¡€éÛ�‘Ä_+%ªEIH®ƒKÌ ø${¾½ß3ì¶"%ÒHL‰zúsî^¹Û”3n}´>T�+TÌბÆ+Á¼�°ó%œ�„¿ã¸y1ïã§êPa÷ž%ß<7ù9ð¡g¡,•4Ó×N§�¶�¬ŸÊBOi*粦˜‚�)"#&ô‚>ƒ‡ÝÍ#7ó…	uˆÔŠziòNðñÁ	ðÛ”[²Y€ÓQT�ͯ#„™i6‘DŒÆ‚µ[@1Q�_º—¤c#7µŒ å�„‚ŽÔiÿ†¦7ÿ•u²¡H%1&4 léb]ò#&6³ ‹Ø"Ž¹gF[ªI”U‹5¶7Èa
nè�Õ!LK0„m#7“ �$3Ympb€Èë!´�Ó#&Ø#x¥Ã,s6Q²…w.´ÅÉ‘Âe#8"bÒµ�“†o›E:ž³�–°!Jƒ‰Éœ¹ÏÉšEŠß}¬å¥da‰¡¾YM] m‹LG$É…Ê‚“yÔHä:†—‰h#7FNIÏ}Y¬¸�ˆCb9N¡âÞˆx�ˆÍ°ÉÕ%hÊu(>”º&¥�éá„ÙaXcZ+E‰½T=eXwY m£®C7¶�y;ºwG5Ë\¹V6•Ý*-×-Ësb¼îðe%Z0ÀsT91­¹bñµÉnÓ¤‚á˜Õ§X3£�cH­'Fu"íþmfe„�7ÉpÖ˜Q£¾Aµ�ºDí×ÃA·$XËbn�@� 8ZÖÔþ\†<5MÓÏ+I´Û9‚%0F
«09šV¸®šñ¸ÎzŸQh�” ó'3ƒ�Øvàü ~8ºì¯›+q#7ŽiÕ?‹å�CØFçê”ùeÂoÓ(L4êÀ5†',d“qa6FOÍÏëÄÆ žx‡
Àë�¿Ùã¥õ;vû'‡á0žÍ¦Ð'w8'ŒÔpñ#8 ~�áÞ0þ{õÄi‰H2ö�ìBËH°C*B@„JH½¿ìƒbTK0¤(24®¡q�„–f„Òµåj1�:®NvK–é-Œ6+;©ÝtÕµÔ¬V£ d2Ë�ÀBJH˺á#8DÂ1­�YØ@X‘µŠ”*P(D‰ü“Áü�þ�àx4= �Q�&òD8
þ^óÀýoŸ‘ :'î•åñÍ™ãáú~OoÛòq«ê®7;Þ?WÄæ¼!Ìøô#7à21 W0+/çÇA©€Ï¡ÀmLÆE÷á ‘�XU0˜‘D€�ºë«ä¬ŸH÷'�>áÇ��D÷KÖÊîdü§”»A¶fHRPm(þkV‹bR—!Èé:#7NB‘FÒmΔʑM«›sjñ[æm¯,½:"‹dµdm!ªŽšÅ�º®íE¯M¯k»Ò%ë”:È¥4Ù%43B’J´jÔ“JÉ{{ºÕ{‘ 44�õ¨¢G¶qÐ>}Üc¼ØѤ:š!þù¶÷#7	3�Š—/øF‚”˜”íƒ7LÙ&ËNEú.`&ÐDµ¸Èï.éh€Þ
7‚Œ]Ú(Б{ð1µI$ŸXР»¹ÜQ:*¸4Ý."b-0kZ@ÿ\Ô8ÃtuÄLw‡¦ru½³¾MJ‚s¡²OµR r’'Ç—?Žçǧ]>b�^V„M5ôM€èM…UH©žã#7–ìÂö„<-p„ƒÞùwÉÕà‘iÜ)#8`�#7¦Ûlfg!‚É©a¶�úל?VOFHSWâØQÜ”Qì×ä�ú|dïwØà}J	ÅkC³Ç§±W°b!ñB=ã¦�YŸC�]²ì0‘¦²-)Li#8B…(‰Y8 À#8IA’Û/³¥ÞÒº� ŒLÑX`Š2JˆcìÁØó:™ëßí¸eb«Õ‡ÎÖ_¯©H��„«� Ì=»»êoßÚ!õUq›ØÒ�Þ_ŽLÄü�[—©¦‚Ã4m>#é~r'u”fÙ†4KŸ#7�Zbi2bâ„HÎ7\ýëW‰—žxÕß"á ÀŠ=Å8cbl:tÞ`üàm»…å$ÄƆR6ˆ(HA†4�®*ƒ�‰¦#y(È#«¦vV©Øi6`p´‘”�¶ŽÏR6ÈæI«D‘
¦G�ù>†•>Tø¾Ï|#8�{#8ª¤Šè�¦T÷NÆÄpÖn|��óç¾l¿³÷λ°Ó¶Ëa¬Üb¨Û‰‡ºÃðYi:ícÄ&¦ÌzN‰5E`Ô!-�™?Ñ÷r!–ç%fÛ�(þO™· 3¨é*äÙÍ1²ÇŠ˜ÝÉ1îí :�tµÈÆD(!ÓˆÔ¦ˆL@›ÎœfnïÒ§´â$”Í›óN s1ç88"�ÄÜp	Š$žÌ¤¹S]7ÁJ2ªS½WÀ’@×÷9Á[õ³ðU~þóƒõlL‘y¤9	®„“´Õ>¶Î|Tmþ¤@,
û±r9X†v_Õßüº-%–Èè, y0Áå[©Ý¾»aF¶kKú¦ñ|üˆ~°ú¢�ô?ZtæŽxu?¼:^#&‰9>#&k³=Wßé6Æ�É‘TcYHH6¦³6i˜ª6£im²ÔÓbM`£1ŠS_}+±	ŒÍ¤6–~kr¨ÉX¶fU4T‹E)ªI­J*™±¶eV
„¥	…` J…¬T¢*•¦Q6j³DÓT´ZÚ�hËHA%¸#&肇á�½üïã¤ñáïÓ¢žÜ×.‰n*î|9*ž¹çL"AÈV…GÉEJEiL1mÙžqW˜T`·íu5鶋å–A"Š=‰zÈöùvÚí#&
’|mnUÎE­Í‹:—صêê·
=t�ŸÀBöJÿ	¶ç+ôöàMÞ3&/"È¡›,“c0øA‘>w
^0|fGñÐu�wDÊ,‚?˱ãˆNh¼{;Í�Hí$aÙêTCäÜS¯ÈŸé~)#&žˆ�0‘Èúÿ#&÷(­<•íçd°Ú?Q8JEYD>¦ýx´ž5¶¢ÆÛx»D6ò\Hlfi€2@ÛXºH!‚íRCé
Ò|8—†2Y«;ÉÐý>ÞÛíÓ‡Aù“{±Ź,ÀÄþGu��²2õ@“žÜMCÙ«çmÔà¼úF;I%û	-f_#8>'T×ýÒôÀÌe6
é˜�™Æ$ÀÀ®§ç‹úŠ‡Q‡´#8¨Áƒvy>?UEôykçóØÏ£¹¨~”y ôOxávyÂêîíFM˜`çÄìf„õð=’1Íô÷�<O㎂÷�Ù›§X:#·%#&f?ÇF‘äq#7VäŠZÈÁ�#’�Üü‘Ñ�Ã?�£VÎ"µŒ!¨‹2C™…†4ì±ÞAÛ¿òwêy–aE0HуK¯Œíýžó”ùáO›Ï|åüÌI£"!Ój×徆r‘7¶\ùkò©_UWËrè<¡ö™mFÅ4÷ áît¿ÍÆ}6¯ ˜.àt×Hk¯íÈè¨"È(ˆ¨Hƒ|±ÃùíÇ–y]¿¹ô^�=*HB|@�9¬­ùûòt}3=Ê	•g,Óoärö°:°'{|h.mïZé9êï-yI†åÛ—KÄQP©#ëò4Ç]¶·`ù¥nÌZ‘*ƒØŒÊY¬C5Ø×Ô]yéÎ_Ö_—4➆=éV"[~ýI¥›5ˆ.-ÁÉHP`Æ&˜4 6#ˆF–ÉÓL*vƒ,ªV ùWŸ»î¸bªP¦1å€ÀÄ]jRN9ali7’‘¸ôñ¤VV�$…#7¨5Ë0º›â!.¸Ç"$MjÓ渷“©í¹Ä0ѳ&?@*Йtˆ½¿+¤ÑB	ÄcJ@ñƒ´Lˆäz­AI‚IÞß·Z9·#)5÷0�@|½RuçZ¤v@«£Ã÷œýhlã/�áÆ0ɇƒN¥’5sr’žfÚiØ“, ³#7Ž†¶ÙP=,pìÝN©Ä#¢D£=#8�q¦âæÚ©‡˜Ô~²M@y]‡³½!%_S†|c4«8JÌFF&ˆ%4$„hC#&(qô:#7;˜ˆúU>	ËNÍòûñ|m�=}Š�Aì#&Üýï�€‡/_¥‹Ýíø{ó0 ¤+€¸4äÄLP„iBµæúMF}_z?…ø ;T‘#7Ž·%±v#8Ûl—<c~RáúI	ì€6{{®¾Ó¢)çÌêm€{;¸Á~Qá]ü[Ò6×#7I�w]“d«Ó–UB1jâR#7!¶GÕ¿¦“Ïê!Π{å2C$µ™>ÙÂWFlé#8
)iSÕ Ólðe«ƒFDÉH]çža·Ñt‘g®ìŽÃ#&DÑœ¡õñ²‹"‡½®$D0øB�Pë:eݦ¢Ó:h´ÀcÈ»9™5@¨‚#7Š3Bþã%C[2XmÒ6Å8Ѥç[¤™N;(ƒ€5ò÷‡±Ó;2Ð;6üȱÅÜ¢¾éâÐYˆX•>È#7‘W€ø;ðFÍ#˜-ñuybÖ ,:=édã7­\­ Dø¤$|åÀZI‰ûáÿ­Q+q#8��˜�mÖ‰OÃŽüèáÛ�pš/Ç…üsÊë Š¹Ta®+�Ó2‰&Ú8á—#71B�¤µ1¢¨tY]F=ät’#RÊÛ#°�¬ Ï‹&¦¼Dz3ñ“èÑ]YâD´9íîû˜�yB<µã¤ª(™YÁІ©Ò�¡ó#8Šº—…�Õ˜�1dF7Âsßí>ln¶`Ñêµkb7´¥‰OÏ;øQ FiøâG¥tEyÝ#8u5<ñïz4jî®MV/•[k†ó’ðP€ÈNXl|³‚÷åòiVž²¨¡¬I#ê˜iÒoú±”Ú$öù÷ÚD1:fƒl°;FBéÑÞl;æ`!PR€lÎL`Iš—K#8�鱤Ò)
 0Iê7Ü#8ìËï0=}1¡O¨@1‰§ƒ0á>Þ¯Ÿë9xð�³±Ó°ìß
#7Ý»—þ;–é†tØv¬»0>Þ[ý5ÙÖsï<ؘ<ã$#7î§O¬Ð<ŠAiˆA<SÇ›‡¬Og‚)ä{ùyžÏ™0 7,£¡Õe¼Ð¨.Œ_8rŸ‹!¿ŸŸËŒ“^<ÏfÚŽü‚z�ûõaÄAüï×ó½:ÝÌw øxý½½‰ò z¤™�–ÆOyz™P10£lSjj¡Š!I‚&€ÔÖ†´º�eŠ`ÉYTª“Z´–¬´ŽçRT°Uщ†‰(Â�`ƒÇóðx<ˆ@¼œ“.Rþ�­^¬Ki©
Ü  ?ƒ$„`„7ûàßÙ%þ_‚ÄVÆ	�
Š›(†¾âVuˆÇ-Íé¹%I½»¥—Áw®ï­œ|ýaMÉw¶ó¬ÖA¼¥ÂÓ.�c+ˆRmu�É"#71¦5%#&dº5bCÎ6ÄáŒ�BQ±ÛÊY­ÂÒf¨Ê²S„4ÛXE‘©HŒÜ„ŠÀŒ#7°Ãbºhzl.Ó#7�t›T›Ý1`VtIœP�hˆä�RÌ&×[º¶ÅŠh”Ý鉃. ®$ÃÆm‘µ�$	#f¥à@Æ°KûiÐ$Hˆ�Aá¤-áÃ%†ÃÖbÂ0#ž9; r"%©€rù™n‘Ó#º!&�Œ9w/Õ ãô¹ˆžÀô+ËâôZ-îÍ)„ö™ˆÐ.þAsñåòeó|ÿ–qîçTþ@â9	÷úiibëzýB
ˆ¹@‘d\^CLâ&Éý[Ýý–oˆ(3N§D÷/~ïx ~œõ@oP4�ó@¾¹M02RÊ�d­‰–�‹I­¨ÀAüОù¥‚[£@…òíh5)C¨ — Ê�i …ùÿOí‚H˜‡npþž¤bD£Å>8,…:yK§'wèüä€
>¯[¹W™÷;‡b¤;¼Íü;t<+«#&>ìå‡FT¿C3—nïbd#8)á‚Ë4öš¶‹ºò¼Bòµ�÷í¶­p—#7œ*¿´ü–E´¬¼Þéð³–Ù»jßLÖãi„“ocV7
�ú³)”Çí}¸ö#8ç�‘Ѭé¾[ì`¶CØe1ðÜ š)Øa�	4ˆ;žvÝ©Ø©Ž	¶åÚúµŒ„Ã2HL™6ùÌúuØÆ,gª³~;—�;	Š¨È!"v×g˜tç‚É6aƒN&ºŒ(>Ý‹\ö¦ý¯=€bÚ)–ä°ã~e/Œ»–úé†ËÓâyÐ$/ÏË^ÛmØ�ÎÔp9åàKUØdéo#�mýòÉ™‘ßæðdæ‰:wÍ×Æ“§v±ô¹ãò¬Ñ>ív,úFØ]çeÜBqˇgÏCw7Zpµ@8Ž
NÇ…~l #&²ÑÕÙŸ¡è>Ù|¡Ã¤ü€ôƒæíC‰SM›:7%¤rZ4ÎÛ¶¼ìLêäB%:Î>,—ÑǤF&šúÉÍ‘´MòÌÞÛÔl.®‡ƒ+9G@í÷$Y>”+1©«·OqŒ'ßéE±ƒ}S#7v~îÊvèݾ2(9^(�†0üx!þ"Và XÔ#îÐÑ`8#÷1"öƒ2rßéÛ;½«
2Üí2êß'eÔ²ƒêºÅEƒ£÷µ‚¤Õ�q¹í(€-ÝÚÂ(”f;@9%)®ÝÍ&ùƒíÛ#8¤Ò±Hm&ð®¾&.HsNžý±�"Œß—MÂHJ_ºr“X?A‡ýˆ±'>Òü°¬"(ÆiŒ}FÝâÄS*"Ò`¡$“dÉ(ËQbH$7Zl '`8)0#8ˆšD#&¸È.Ð	„¢Ÿ˜…f(Ú]É$tNÃat1G~Ó©øížFÇÈjՈʎ„„ß‚NI˜@
oÇú\�Çjª³ks.A‚
¼ Dþ¨S·âOÉ}º4<
„‹''8<�mÞȆ¿xûZti»©0Cmj,,	g!HRe©ƒ"t®�žÜX`ë©3‡¢š:ƒ4ḹBKU±êý°xIПN?4uåÇ—!Eä�­þÄ=‡¨§yÄ#&lÇÐ?@°$WÍ…
G©	äs;<˼>«Ðâ2!†9'N„jÌçšMHb­I•Šd™ŽIŽ�$)¢XâKD¨’ `IA“1¨Èј�:Dz’ÁK’€*#7'�×±ÐïN#&øU<¼ÊË0>ï_’R´×¸¥1´ÕŒÓv-#7´Vƒˆ)·?6‚1tÏ}ñI¸ñΧÚÒ}¬ÜAµ×í»)À©uKo¥ÂP˜ýrr“�ljÅ1ÄåµI¿6ˆ°ræ%ú˜©Ð­ëý5§Ú#£+ªvb„a™’ᤘ¨||‡çto'cI²RƒÓèçƃáý¿!}à¾LIAÃo²ôö_!÷à†Îü‚ÞD}:‹
Ó×Áùä8@Ï´Að<®ÿ»=‡oQø*Œ¨/÷sâî~=ÊýNÿGÖ†ŽFÌø‡Ÿ×Úšù¨Vº´žOì–"#&˜»–ÃQ@v-VönÐ[²Öñÿ†ÛšªÄH¬ËPr§#7Ꟶg]#&×BABy}¿dÂA†L1	°)#7‘ƒhÇ´ùÀÈ¡€x“í†ïŸñýÿåýÿ›@¸�¥-N…F½Í¬‡_uÒx&½ÞY¼|mk#7„c!ø{*JT‡’BëÇy‰,]TC‚ÑHclL/9H~F²°Xn`ïXÙ&ezÏÆàõ¨\!^HÛÉ Ýi(¬)6'À]íä\@2:a½EÀñßÓ‡zÞ8\Rœ:�¥;‹ÈÒØÚ`õ¬X#7Àí"’A÷üžGÇ	èNå4é¶8ˆ}Ù1Cc–ÈD߉^ô´ŒÚà:ª*Ä€#ª¼¾|^ú¨òÀ’JófÐX#8ðxæƒfe¿Ôe8†W–ýÁ‘1v×	­™ÝPâ(ƒ¯`D Åð=�Lfžažt#7Kéæñ³ŽÐböÚÄýŒ"0ñ3½zt¶ÛíÓDÆ–L•ŒR0¿MGc,öð#7´3�©VAïìBÝôÕÇ fÞɨ]óŸÖ´ÐpbÏn̛У#&Aâ™dx%?ßX,)º³ë]Æý)š¤¡ƒÄ`l`-Fä1\á2@�Ãøs³36Lé"M8­š¶<·¯è§ê`þoÃ!�6%„pAјÈ1Ò8ÝÍOHˆª�Ïp#7µÙ£†Ð´"¼V£GÕ#&h(ØìôżQë¦õ³	“3…uá§NJ±ÐèOŒòÃu^àò"žð; 'òèvšãÃõå>¶úÈNp~‚˜�°"dQÃè-Ãsáà§#&mËÕ×`7ñ”)ih)*Ö0-…ã
F¥(˜J#7DU¶5XµQ[j4l1
B1#8Ò±!@´#8š„!#8ÉPpŽ¬qh€7êt0}Ç÷ï³0ž ÑƒIÚTÈÄ@`È�l„h¤1�Am‰¥¿—»±ä|ñ��\Çn°9‰#&™14õn¦¬ÉSô¯´Ô K …»¾Z#&$?˜îW0Æû`×´+\öú\ ú)�p]5t<‚#!»xí‚Óm‚ÍL/<#7áºΤAÓúÊÒº2x'ó©èiëDçvžéϤþBPJ‚h#8Lê}i+Ç׳·!ö‚Ý#pˆ%Ü�µ£Ëˇ�:ŽÞwN°#8ÓßÆÄi0ëöI±ü]›„˜·Þç18-�Éê8»óÑKâHyˆ�CÓCØån* ñÕŒ^vƈ~nø  )hMSV¶iR�Ó˜Æ.Fqe6Û #“ÞÌ7ûÛÆ›MÈâ¢
2NÙLÜs?–³2°ù^#ßSô|fO’~¸¸2!qC¤Q£–-0­y1/Ê5j9$XÙt`'80uØ!ÅE^�"�J Ÿô•%;	ØêˆkÏž£zû¦gÒ2$†ÈN¨1ÀdgÞ‘’lÊ©ÑUª
Çf~¿§Üﵟ,žÿ�Sù¬cšðaˆk-ÕÔâ»�×võoŠ‚˜Éµ½é$Ø/“>3éÖa{å£ÉZ¯D?qñÙ¯G¤Ûäw•ò5Dl+cVîr¢&É	…Lª\�9FÎLò@lÐÎÔ(V܈^»²ëîM'†ÖR°¾Kúôd·¢Œ¨CÑ5è¼D#(™ÿž…ÕA¿ÏÖ�<ýÀ9Õ	´
0âü�—äe(~³ì“
8ý|LHwü�)µh}Z™üZn½YlšÌ*¢§Œ8ÑÊ•Êâ8�ÉL„ÌÁD`Èü`×6›8=”ÀÖeÆ‚:Q½ÈB@i1¼)¦›fô»á€nÎ:0[2H™G0Ä‚!VQ›ECE£\]Ô[Ù t1«Ÿ€ø̶Ö!eFÃ
°¦„c$Æ"#i(Àdh–�e]íӶ뎷R–4¹ÇM{yåz…
8IF´ZšL ‰K¬Lb|S5˜4ýxa!D#7ö`GþmÀK'¢f‰ûÏ2ÕÅûrm&uwd$Ú5Vû©Ù¯UÊøåtȳdÛRms¤˜Ï7]¤Ý:¤)I´×zóÉæ=J»Ýׯ%SzÍvh<ºê^Ý[ÀªkQ‰4Á¦Øë3&4!Y�S2¼×yÚïí¥¥¦dX!°jZ¥5#7#8eÕ$†”¬²YTÌLŠÙMK×Wo.µÉnçs†Ü�›ä8èÃ$hÉ+àœ‡N³EREKPÈÜ·Çë½Ïfl353R¶aK(Ö¦’ó⊂Xs4Hf‚ci«[¥ÄD©±ƒÂlÕ«#7 "+CqØî)«øɦ1·™8º¦¶õ&Íj*ÓcÑÌ#8³˜†6}uV±„‹¹2ØHÛSi�¯.$Ÿ<$l&{ê8É´Ø¢!ć&qKî‚᥆AŒã.ÛC}´£mC9Ó>œ^^¼i]­F´Ce0�¤¢)9NM†!š¬Ñ!ª˜G0Àå§6Uä(˜U‹†ó…²¼·:LÜž»ÛË­½4Ué’fD×õbZ.�>µ4� `æŠèÒ*iXšaÛM´läµDíJØf:¬ «#86“Ç‘¸Ä[K1²ÑÛ#+	¢$«AI2'5¶˜ÆÒlì‚cC™%µ¦0ÍõËœpˆÔiäx±­Ù”�’ƈˆƒÇâV¸Ë¤Öæ¸ò•©a	‰ ­#s&#7çÍhØÚÔ†HS#Ó>û¦I°¡.�¹Ä´ë7B6›²niK(ò¦ku5coô9­¹½Ï%D@;áO~֒Ʊ‡—œÆ,žt ÎÐ;q>V%’#7Rnmm8ᙌ½a\4‘»˜+†À5˜Å¶c{z¡%Saçå¤+‘#8úŒ †}&ºo‘§Á-P]EûNߦ…>²u9Iõz–*]Št
¸Ž#7ú¯Ša†4/aû{›7Îòp!´$¥ÀìŸyâÂüó'ÌöéåîÇJè÷£œI¼‘Q˜Ûvr»�¯£%´˜t#8.²aˆz-¥2`p˜c#&ÚÕi*›U›ã.—Qîœqr›âñ½H¶$îpÂ-6°Ò¡¬ÆETrØ”r%OF/@�Œ¶/=ÄGŸ³ÅòŠmüï„*Ð�ATWüÚú¨€Úó�$&AÞs9ànw�ÐÒÜ`:#8-ÂÆPfU[¶Ø7¤#7©¸Gå¦ù×6…6$Rˆ¨&s˜`ˆÚC¢T—„µ™b)@a(ÀRmÐj´TÊ#&>D\A¢6:é#8##&ˆLX†1¡#8h§dÂ*Иð›ÿ�À<ÑžG¯Ø}�ëóÝ8ž}¿«K2Î):'zgõD–ü颾ûßêÀ›{”7�éü"¨<íMŸÖ‚£Ae5‚¾¿²^™Ñ–ká^;¬Qîk«J0Sdþ-åyÆK˜«¥}¯¼»O¬.JÀ¥‰©ûßO8y·¬P¹î”xµíÚÐXõ�¦ûÍnjRR½Ùä9qùó.>xã/Ff…‹SŠ%©d…0Õ5i[;ˆeã4éVfŒ#8O*Ðô8ö¯öó“<<�ºuêaã¯í~×ØJ-—�¤ˆI!ÉÌQÍè­SóÔW¢¿#7o=MóŽa0‡­àgqÆžB(â‡4dbŒ§{ÎÒNÓt}z#7ª°*°ƒ&OIgRÜìÖÜh„kµç…Ýƺ�³�rž§kÏsÚo“zÖÄÂݵ¹¾�NÿC�.<ûÇ£fæƒ{ø<¸ª�ÿ*Ü5“xÁ/úHeäÈTÑùƒtî|Êc^× {Ϫù'_Â,~i¹ã„¢rá‚à=¹¨BÆåË~N@y2cÙè‚|zRXTÆm„Ó+T9ìK$†#±âV´ë–ý÷!Ï#7!K®¯…“úÿ÷†y­Ò›`áâ¼aÅ�æΡë‰Ë‹ô"}Aô±D�Gê·ø·NœÄO
ø�®Ì#&2(dªU5|uöý•ŠÜµ®H‰A1„è\a#7!¡ÂJNÄÒ¤?Ž#8­#&Zð“„M�áÉuJ9"‘´†‡j£¢EpaÅWe­ÂªéZ¼tµxóº,Vů:æ髵WM»·2—jñZ)á–KR+#  %Ë+1s1R„"@„$ç(”ÔÄ¢D䣋†´êi	%°‚’`‡ÅÆÇÚ˪(CÛ©¥ù°n±Q�Q´G$D—ߊtŸ&²-¡(’†¤Dc`•’b1ÆAMtgÄŠ#vC€WÂt±ÌLC8¡*CQé®×¶×„ËÙ^š«ÖÒkøÝÝ8w““P9
„`Œ˜7²Úˆ¨Ö¥$”k(¿¥Ý-ƒE6h­EH&iJÆØÕÌ¢¢Æ¢´[Ø“Y#71¦kI²E3C2bmM"´Ói fÌeZš¼íWFú<Zí‚?�:‡®�!�ÓRƒòÚ"£F\+�mµëÈ4›Tm	©#7Ó"wêîÓêâí¼Éš`ˆåãÔÁ‡òsppQiØ	#&Q(¿i8›#|®®ï“: ¡±�O$4§É"”„’‰L”¥>Ë'µÛyPÉH†²EršÚ,ŸfêìAj4Þ³³1li4îëtµÝ¢•ÒÚÄjB)HÅI%#©Ö“R%D�X6Ç�¤¡SÌYÃôiÉÿ§GqÍ{·Ç‚`¸ä!ø|åÌ°1A-Ó‚ò8�#7ÒX*…Fg¾Žf�ˆz/owo"›Õ@R¢ÑšÌ#¸õùs‹·bhGŒex¹Má’°„50LôcÞXm4u]s¾)ôüZ~Ýܾáì~>N|ÿèÖ
>½êÞ�ÃIþsã˜U�,ۦƛBû7ËH)ù�Qí·1¿)ëË#7¸°‚¸i“dn~«,q±ŒetÌ“MB`ƒ#8a!r�Ú•º8$ÓÉ2†\›zQb ˆ…“U$»<¼OëÅäòðíY„×^’´u	�[š5ÉåÖsÈ7¹ïÉaÇ~ANî°*O"#7!ÌŸy]%ØÊù»Þ7�µ^]™3aÎa¾G3.{rmi¸}-™k@ý!ã5£muô)]põ{eÛ
þ;«FÂe<™8àË.L4‰w{¾ÐX5~åò¦a¥ö„…/‚lxøíåÐÍÝïÁÚ8¯K	Ù
Gz›§-ã�§öró±ÿ’«>4a’÷MDÖp›º2åÏ2™ ãà‡{‡Ç>C¦|Qý*“x‡•õ‡PÒŒ'ã±"Dˆ´‰BÕŠ<å	¥"b	‡þ6´€ãl@ WEÊ
tEµ�JÄ(´(R¦@@9üb¨ûû%ä|ÿC3§¸u¾ÞNHËóqJACvD#7må§oÀÈ|	ü#m}VÛyH›‘H!bT“Œã0hAÄ#8cÄÅ#&Ëg…nìÃ@ÉÉ#84ŠÕ$KˆiÔØ´6¢‘h073êÎ#7Ðý¡Àl#8KÈÙ W”�„+Q«1M,J"i�{dªóº®Ø§²ïu‘$•£$Ñ£—׶[Fh“@Ê0B#7.£µ›¸V<4�#8ÆÙ2¡LÁ¶¶µ«E)
V‘õaV™tQBA³ƒJ8�§ÃHá¨u�ì„ì<L6N�±º:äZv?a€DY¡$!„ZÙ‰ :@^t�}aûÛkeŒ
#8™ˆ ¡“æŽ,<ßìâëî•Îo#&8QóÐ÷R]~‡ëƒØT¶ƒSŸqó#7â«ÂÏ›2fÝ42Ž68_B¤æ	4cç€Ý¹møtמÐóÌïä�+}­ª‹Z¯­xLDµ½z€Øw�NïãõŸ|¿Qø“˜f}üÄ8YòÏûÿØôE’€Å3šAüÐíYvsö²sÞÁÌãë?µA(ší;�Ïà”㦔f&=®ðè|Aßé{Ÿ|½,j F>é#Éóâx'ZºÖ|�›ñPbÎKÅmö£9YØé™PàlÊMÄ&¹xÈ@b¢Í·Üæ8:>¡TMG	.wpÎ:Ø-yç› ¾è§‡.	ˆãhDLJ°û¦·OS{2r7Ý� œ½ÁÄš¹ž•	gl|TaѪÁ)#8Ö6ÒLCZ¢«x`É(Y�K€Ôˆo(°à‘{„2o	¹T(,+èÌF:&	Âo&òÃ%†ç¿ñ C(à  ¸Bh„-$ŽuØwlìÖ
. –(ȲÙ˜+àÄN	Òð¯§Â63–ö5Ø÷+‹•&õ<2»E½À(ÇÌý¨þ|”Ùév=,EXdˆbSB’0àf4Èy¦"c Q“Ñ¥ƒg¢8#7°ôþí_,äZ¾7¤âUÝWµ°™YÙZÆ+é#7:ï?nŽÁú&–”“{‡5­%ÞwE.m\M(ë»Åä6%(ËÊä±¥…‘4Ì�„ÙR´y*榕I¢Å%&ÆÆâX0—5r¹mÊî;¦óyvã®»Sè—+»·H®í·^-Ï&Øå"–òy-Õ˹¬ËtyUšÚ4V²aBÌrS%S	ViL	s "GQ˜Ctæ§3:[’)©ÝºjÁŒ±`iJÈÃ0L_ì#ÔŽ®êÓ¥´bª÷¸š#&CèOž³píá;
IP}›üþ#&â»Éõ°ùä4G˸¹ø½Áï�¤U†G"!@¡0Ok"i(¾©äTG½<ý|Ô“úoEõª§°w!¿`~sH;ªø)HYWÇ›ôO»áÒC¯ãšåÇ}þ§j>žÑ�o¼Rýx(`~߷ПÇï=/³¸�_¹#7„W¼T¤fjŠ
#8ffIíMò7$(DÉ„”NJkA³þÓ¶#&d�êúýSx£[&¬V­#8Zk}Õà“à}3·S“Ö �œò1)¦*æ×nuzZ»Çrç)fÑb‰Œ�Ñ	¨tDú´é¦d7‘Ä�PCw$%‡ ­#&yýäBHäf1%Ý)ç[{Æ$ëºRRLÚŠŠ%xìÐá„¡¢6^«¼Üí¯lô£I!F¼oP"hš
1V[¬ºÜŒ$0Æbˆ¡XxÀÄØ:›ýÏ	hFÂ$~)$‰Äú¼¡AŒÿ5>ðÞ½)#&ﻂ¤KL
. ÑìáŸiýÿçºVnº”=ž�íNrø#8*²fÊ©«fÍ¥VAfÕ 	!#À;·üB=Y" óä« D‘,¬RJLL	J‹Pˆ~¼Ä=_1ò°„:¨$÷‡�äÜÑté©-37òš´­F‘*Y‘YÝÜ8ã¼@pˆÉ
’æ¹�vÆ÷aãÙ�éžá~ˆRœv¡#¾#&è’äûCü©~GÒ)ŠG$ðŠrû»c€N3Äñúð{SïN<±ý©!ôü¤þ1bCºA_^|mÿ”ùÂ�0úCX&(Ù2g‘@«A(©
šU`$nÓ]h2²Šú]ÉÁ„ÊCwdQd•TTµU©¥FŽºîlg}É©ÖLP0‹ýUsX)ý•Ö!›öù>±"$=Foßê
h'¦¡ü®2?{#8ì6fDH
$K¬’V(Æ#8'"‰µä
°¡MÂ1ŒÔ†°+TÄ7óÚ�&9!„D&@qj#&lO[¢Tnµ©	Q@1¤*Â3ŒªÝ²ƒyŽ…U…¬lB°eé�54m.@D9ªš€’Xɳ.#&´gª¼.ˬáÉÄ ¬9Uðq'·ÚñC»;*¬‚þp¶´‚�((\”€â^GRØ×!�¼ad•ë÷…h4Ö#7�ôéAk#&lLr‚ÊaVÎjÓw0X‚BÄ“h¤V€QÙAÉÂr#8)¬/ç1¤ÀÚ68ðcÑ€7Ž�:À$eCaå€'Š8tñ)‚ƒvdAõ“=œTþ²¬Š! Ð_ÓP°ç]ëZjCIÅÌÙ#8M¨9›lg»ã‡aL~ ‚ŸÑØÉ~Ý#8 ¦b íA<•=}Ðá’¶`

#&,�ádf
䪧ˆJ§ðH�zŠI’6Å�rEÓ‘È_½Ö’‰OM³ØÉ2+‚Œw�!ƒÈ�Ÿ›�¬>0ñ™3,SèSþÑDM¯°·ú’ÍÖ4muCVYim€ÖéeÄã?‚l7ôÃÖ×£þùû;ÇO³./ìðK!¡ÍZFŒH$ˆ�1‰Lhœ-4Þ™mØK&¡1ÁBHÔÚ®3�£.VÛ²B*WH<3Ucú²pͳk`EZÕxñ‘¨ùeàÙÀj¡V^[m…{´Â?Üs<$ð�¨›í¶a<ÃhD€~ÀÃà'Ë„Âr6=�ñ�5ÉIïØ'îgLB|HyQûa2z#&Gxbw\„ï§ø¥…Þ�€¥õ`ã €FÅõÚ Ñ!‡¸$%CÒ�ÀB‡ÍÜX=æ#7¡½Ì9ü��¥ãøIâD‰ ¯Ön	´îó·ë9@X”¿j
ù`žð
€Ü›{@"I£�Ø*f�>æµú…�"ítúá�‚½ñE?t ¤Àpÿ(g×·‚�Éý´ònË1êWÚÝ9]*PWó"cmŽ‹åÑ^NŸ³E1­îË�ͺ]3î“TPš���œ¡lý•z0Ç#&ËHh•jú�¯“6Äû@ð³øT:%·›�Kä§SHÆ7“;p·°Äz™É9΢“¶û§qËŽæ…‹»˜*éáÙ”%oL8o{	‹¢™ÅÞY°&§ÕeÃièfY«ñ¤ÀT	H#&gp¸gyFƒRÿ-B?RÛl„¥€|N§wñîš–{ƒ/ªš /øí&4nh¤}¡øáÍ°)ߺ#7þéCÄ¥Q‘�Ÿú‰0‡¼ßµýQ§—÷VkMhö«õ¼H‘ö]ñçw™|÷šÁ‹øâÓ–á…¢ª–²ËB¹E¾îáUMØæ|�Ê|èiÙù·Ê)þwµ„õücßÅ#7ø²M«nR¶„/Ñ:lV„ºÎ+èËþÎùL7£L€‘A‚¥4ß	»»9ÕÚWž^•ØO>‹ª•M^nÅ)Š¥2ƒ«ˆE�0*æ¦ÌÌ2cLC#8QÍ-Š1SAØûçw‹'4ƒ²çás×%ÞïÏŠºt„gi¾ bŒ¬n—Šu¼óÇKy\&’Û4íÌAë<´ígJy¥ì?¡ëIæÀÀ-äéÎ=HkÖy°ï³�S‚'‹j'†#7ýÒÍyvØEûÙ;P·»®<:k×¥…9@ÑÄ#7=ªõÄqß¼®ä<›øVa7yyQ�oÐj‚jÆl$ã 4´ºµ‰tI=Ô†÷m_l¦± ªt®¸)ˆA~�¤I³”†Ï5rýeü.7�ð²#7K»|1\Éès~YÃl)†ËFèZHƇB�Âr¥†Ò?JÃ�âi5�ÔBskëÞ{‰æ}‡¸kªe󺯻9#ÕG|Åí&#8­	®9¢!²Åyz#8ª(7g£E²ˆ	Oô—9#$á̈|�…÷|ö™ÔÇbW¸î‡©“‡Ž�Î�Í;Ô(rKã@˜Ëy¥£c ×´!¨Hâ íŸçòä£y¸ÁDV|áÔüÖ#AÂ>ÏŒ$”kaL“& 6‡*T9¼AÚzL<=}ø÷jlgBb·œ›/'l‘#8;¼Ââ£åt°}é�5»Á#7ÖkT#æ�ü™¿�n2ª¥©UU›]½õÿ‚~ø\‡ìµ5´ˆeHR®ˆÉ¶ÉsW;ÕßQ{üå¼â	xï�Í]½­]â2¿›Ô„óžúÉ·[t‰faÝ«è¯Û8|ôœq4µÚ[Ò‘Ž¼eø"ö½4šyêPÌ÷kËѪNÚMkÂ9#7u6$ñU#8#7Ôó/¥ïǵëÍ5
,(t‚P˜äZ<}!ØcÙÏ!°™Åb­$A¡%�lZ`RO32‰(*ÊŒj5k§ožØá¤ÔqU-3ÓX.%8s>ÆÈ$;¢”h|3Øñ»ÑУ�êR>¯½çs8‘5�&†\w#d’@ÔÍ¢z9	’îLâK²ÙûtkHÉß®ZnéålÖô…�PL¿ 7«}¹aS”ªð<Ùë×sÝÝ›‡…ýü³a<p�Âs�½_ÐÚé”.q/}4Ñ<‡8ñùÂIþ©Û€{>}ÖOÀÓéþŸÃùì—�?k@'@ë? ˜ˆð!i¦„¼ˆI#ó z”ôï÷Gà(˜Vß�#8QBД”ƒAI"Ø=ýæÙ°/h?›ÃËs)ögqûùñ>)ÀÜŽìSÀõÈ�¸x3>Aå÷hÔ¢ˆ1Äôs20¯œw Ú]P@DO1’à08#7²!³�$‡@Ù¨"?-HþËÆ’›MÃì#7ùÓôï§>¡toTq5áï@wügI�É/Ãç`©ŽwjÚ¶ùÀ4Z[iµá›aWi�E'‚½¡ÚŸ0šæÊ=ì00CÀ¡QU&Ùþu÷u«·yÔìŽ|{€‚}>A‡�iâ û°ùô�ÜJœŽ¯Ó燔xëN~'¯fÎñÉùx™ri¥múÉ'�žƒø¿#7= *oŒx˜|!P�Äa�ÇÄÔ3®^øÀOƒuÇq&£¸@voÖ�³è#7&µØ“>c´»"ÞÑš"Pi�a 9XÄá~Í”ák�·¿ô¿·äž~﬷¨¡">ŠltƉa:Á
0� "Cù3S«¦²€àõ�ÝÝÙÚñ4Ê‚9–e"s‰$Ò‡AòEïŒv¾ìs³#&øz¤>aÝþS¡ž'+Í…�•Mž*þï‚Š™Ÿz†™‚“˜ öÓú¤¥ËtP„„{\†pæyíÁÈŒ€Q5Oõ±×{¬9dö²b`1;w@íôÃ'*êënÆ*9 ?‰qŒOw>ë¸ÿƒÛ:ýˆJ5þ¿¶õù�	N2•„b'„1åã†qQèM½'Ó30ÓIáf²èªÅË# ="ÞCž4±’Neˆ“V™s†øá+ÒcI#7pABgë?<þŸëøžu_T KÝkœ‹¾À À—P$ÇqAû#ÌîÞt!Ê튜d£È¹@-HÝ—X”ÇqúßQE%RˆhdéÄ#7-Ó¦È<oÀÛ`ðXÄòd7¸ôŸ�k$É´2Cõè`ÆžÓ�׳�ò ²ÂIgq‡äó=ʶÔñ¢‘È'Ý�ó·L}jÖ�çv‹º5É©©OxPAîßËAßÄ6�	9‚Dëj(É,‘�Ý0xâä�QOèļá²ÚC…š¶jËñxÒTdèEF¸‰/qñù+ò›n—[mÐÓÉÌr¹Wtý†ºÕF€U’„’TIJ&ö÷öè^÷Ë:%@Œýèy¯%—�o-ž¯ó�ÚÇ‚=òsP´#7#&m7ÜüO—yé>çÙðó ±™Iš2DhÌ!eŠ	¥ ˜…Da1	1c(ÄF”Ù6&‘ ²Q,KPTE0T'ç^ÞËè>oA˸4ì~W'KC°›²}×ÂŽ?^™ä~7—#7›vÌ ÜÆ0Øh4L˜2ÉqÒd&v'ÅÍãžD`Œ#L¼ìgLY_á*Î_iúæô)„uàÓO7ú:‰[ß�õ›°©]Õ"‘©UšŠ9¨Á‰vÕ�õdæ«ÅäE#8ÁlÈ`z˜Ûoâf7¥Âü°Øk¦“US�‡ÍÕžšÎO¨3vÉ	½²5ôdÆÃBÓo,á4ª�PgΈ@AXÈ=(’#&£Pœ#7ìûhpíÝjÕ†´êz`ËðŸ´3úÞq#7=aªA�7ÂzÚÀç�RH?ì2L¿ÑýYß×o‰#8ƒ´�S–�#3ö¢�¢Ö[©Œ”«Á„æÜêÞ+՛ɰ·£-³&ô’i2¤ÑY³�
ZNë’•ËUÚî››ªKµtŽÐº±P‘Œ’£Fm›æüƒªaH¬0”
˜L @š0ZaŒ<4Af(c#8ˆ|j6ô)Ë|4I¶b¹&¿>m"Õ"”-Mi›xÛ�W.—,î·/e�
Q®¿'±>L^ÊŒ´Äqž÷ˆÑŠ&¥çbÜŽeÜŠ#7ìÐYye…­ÈŸ“Q55YpÅ!4\Í5,"ÿWó?yzœ,ïƪ¶¤Ø¬¦°:&f1*ÈbŠ4¦“îüD¯ÚqœâFôR¸©£4¬*ÕÅQL#7ʇC‹42›O"­
êÖÍš*-œF¢!RD‹’lAŒ�`‚0i·�MH˯9ÜÈ‘y¶îZDN˜«èÛLj�§¦ÃÁ‚Ì-L6Õ+8z=ælÃlÞ"™EA1³iÆA8äƒ!
Ë-µ4Úšq10Ç ˜ÌÈZˆˆ`VŒ•vË@ÆT6,#J ÕQX›•V‡JK”vaeu¼™¶W„Ñ£ªE‘	P®GY-ÇA±6W)CeDÞBR�¡e1Á¼*°b¦ hlZ‡MåÉ°o:<±Ë‰R	J±EÜ`åE\ÝUÉ.Ö”&q‹c£ƒOOy‚ÛY^Eµ›Ô~ö1‘�™§o0¾ˆåèc£w—䮎�ÐNÅ™JV‘ZvF«–@�¬’;ˆ”™G5Ü	/}0ÃÓÒÂH-ö>’ÔÎ:ŒëUƒçßkX²%ÈÈ�ÓCk«JØ“àë\dhz oPÕ4ën–bȤ�$iÃj­O+ƒ6Çf��c2´äÍBPnr¨Óâ9‰ið£NôÈ4«ÄÒžJ°V;„©q�X„â�Q…eå8:4`Y�i8ÂŒ#7ˆi:-À¸hÇ1ײIÄl*Hà—7̇#q�"gZ2†‘ÐJ5I@14ú~€BzØòàÑÈÙ�Bóg)œœçš€hMPF˜ÕÅZ%2Ä¥s­Bf2ae ÚÒÉÆûèªh6„2L†deˆE$V*Ш4DbƒHÆ�î;èª*9öM=±WÊfí�†®y›Ø[	ÍR%Ó!‹¢‰ŒLv9fñJ6Þ˜ ºCéhÎu‹D×-dIÒq®0Öœz6AöÉ·ìŠ^0J!j¦Ê*A‚jt0Œ’ÃÒ4R("¸÷2ŠÈôò··Ht0&AGÄž’5¶W€¤¯™êaµœ¨ÄÙ.ùoš„É[³I
R‡Á:¦$gÏÆŠ\
6 ææ1TܱÄÚÂiðÏ#7ÎY\…ø{k©­rk¢"¶[¸Lˆše—„á„X…}£·ŒM‰8ÓŠ˜€h„n�3©Jhˆ‚F’ÐlP�¡#7—žA�#&1 á#7
¨V ¢˜‘†6WaÁ6#±"Jp0á&Ú­.
Ò”‡®ëŽ©0W¢`¦‘ýÿ#&óñ#8#2œ’“5g8nî¼ñ|ï.˜Õ6»×WIýxeÆEf6dBVt9Tô©QV�U-M›LÙdÉ¡êd#üíš!#7”CöµSùPÿ_èÒ9Ç C’ö#Ò2ùoãðßÖ‰´¢ä˜ ‘õðÀú›X|v�.‡ôq«û²"4…úõ
ÞzÅóáÏGgè¬Îfâ½£óTˆD J$“#P©‡@
î	Ûœ¨ö6Ñúcˆ�¡òŸ`4-‹Ãã�; ÃJ‚ÁAÀÉ*dû9íÏÀ˜1ùCmg‰òs­È¦HÓ…�jð‡=&*ì±AÁÂ�øس$rd‘&ÆÆĈ#–‘46É P`!�Ô…0¹B†,‘² Ž(«PM*„‡,ÇsNLl)û*´iPôBŽ‡-Ù£–F7�ÉAM@5ÖJá’Œ“n�ðù5„FÂÃ`=&l Æ%ÙÞKá/s—Ûfº÷nU¹Ù!t#pÀmñyì¦i¹8�,2lò5X�Ö#&R
¿Þk³-1|•¨ÌÊ{yï·9‘Ü[ñuäz·§ÃšgЈ™Ú?B�¿ô™`ùr“”ý5âd¨v2à¼0Õ!æDÄÒl-kÔö#&#&Þe¿Õåˆw_?+èb±ŸAB™ ša&5‘(%Õ�†åEÔ1SåÓökƒîaæ…<Ñ@-ØôÄŒ$T�Sñ�¹=üþ@TôùáýïÁæSÜÂ
Ëߺ¯Ç�ÂrÃí°˜ÚdÒÅ7çÓð²XøÃ1“Që}dø}~WrNÏj�±kôì(»=K÷Î1Ÿ‘ôL„H÷lróWqMC’‚dCºþèzHi5ÚSÀ=Ê`$œ³Q2'j¡:¡ëMt@öªÁ×BlI½õ^§¥¢ºûL_9�)�'8�θò§+:”@owêXO\µ�^ZëL¡zjX}ÚxšN#î#:	ÓAQî�ûa#7““¦zÆÉs"×?“*Ò"ù9ÔÞœfã#7>ì
†e!«šªCí¨°Ÿ½¬ò7Á¹Ò'#¬76-I8 �‡!5@m¿ïG‘†¢DVeb1²E\cRQE¯ÖÉkñ�[±-ÍÝÚÕÍb¨Õ9\Öéµ·MY#7b¢×Kk•“\Ü´kW*w{5Èѵ&µöûˆ£TW‹ÒÎíbµû‰o˜ÛÁìvÆAÚE�¢᤺†´Ò]ÈXùëžµl°0æÌFE.Çm|˜Æsôy -¸÷&áÞHxðoˆð#7	*o#8þD¢D9
Žø#ô?›#7Ú¥ä@d„˜˜Àvøwú3>ßàæü�\'ÀÌ‘OÊÍ>µÁSó#8¼¿}@?A#8ta_ i¥ûoéÄ´}ên©Ì%x{ ‰<ì,•Ö³rÑvü3\²L‰G!3)\32±0ˆÌÝð6üqÕ²¤!2�ðAÐTvP•�eH…JZ#8$€ª$ôö+µ&ÎÈÈ&lí²>FHwË#8«ç¢C!JMd�ª’ÕF¦Wå_7߈(†ÁÑPz„#ÿiA>•ëû$=^˜5ö�ÕŒÕf�}ƒy6„}°ˆ7Ž?+JqwÚ¬<º�<#8J:Á= ¨·“|œŸÒ{‘T¢Ó2‘!RKQJ)ïø�éœy4î'¨õpgçÊV¨úº‡'™€}³Õ-#8Ч81ùµk­«òiJ¦Si2Í1idƒ-M‹46¦hµ)I’RM£D¢P¡J�"…„¤	eR�™SmbØÚM¨ÀЯÚgÆ·[’AÉ+È*D¬;½5t^:í§{ûÕêõå#¹•e!$ÜaŒ ïÞñѽ0"wPi*nÄm�q¨òˆH!X	&ÜKÒ½/9uÞªn׋irB#yHñŠ´Æd¥MŒ$ƃ(-<@l‡#&c!†!8H¸6H¦ ™ ¨DŠªç´ÜHÃn#&•G Á˜`/Ë÷rÐl‚;ýŽÚñ*x²è·MMÝÓ»1pÄ/¢IÛlÆTÔ��#&¬‘¢wµN£ÚŽÂ¡Û°‹Ú{ðQª0¿•ÏàM½ŠÃÙO×å/÷ûsî­.y襆UèìDJ…!ø¹õþï3œE¢ÏŠw_xâá@S#8hã¶ñÔãgÒÒ>ý;C@J}øeå7ÏL#7È“Ll2Ž�r€b xF#7øã©#8@†©Áû<»ë.ë1Ðd<Ù("hd Ëlq¾#8.@èÉn0Ù)À:ÿfBϾ¡ëØ£ÁhaDîk©�Ø;Ï.ó®ÝÑÚ[Ë.¥J”Ì€/µ×Eµq#8ThJ…¤!0ª
³ØPtB¿•Ý4zCˆyß²ÿEJèÛvÙ“éµr ÞP©20û?.9ÖLÁvpθ¤vrŸV*ÐÒ×€ËSŽw¿§ùˆ'ŒŸ2]5D‘ƒÔ™Ò#7ïŸK>év]H9h1t^ö’dR˜YcEÿ;ôk…#;ÈEtÉ/#8h¸é|ÊŽ8I«ª5—~ï	°ü�P·ß­Îö­K‘³�Íœv”ðïÄ4#8d{…×Qr»bÈOÇ^=m÷5žˆB;è•—ëC³Zå3¥	;6…úl}øp~2Øž0íÁ¬ÊjiË•ÍaôÅÀ§WýšÔꆎqÔ:Œ'âÐ0CÆ *1jáîeÑKæñØOŸYénV}ŽÔ‰Û»™ÜwÕ+¿/¬?†ïVÏh»—Š‡
ÕzÀq·H¼¦´d#&ÍzkÂÆkX`é›m½‘ÖJ³Põ,Ù‰|Bé®5¶ìÌÐZpÞ]Îù£=_Ï®ªß¥Ì.�`¾‡3Iúäf~ï8gäæç#&´²�¤‘ÄìtvЉãO`�:Ûgæ9öûN#8Û…Sf•nåzf'œ	%šE])XDñMbl«Û”‚2v•Õ=_Ò.×-–¡	1áåSì\]tÆóÎÁ,ƒ-ç–áÑ#&ôHlvëç^ÉŒ¼6½Rmøžê»AcÃßÓ+CÏXäaFŒO—Xdd§i(hœ‚ä´lGl/tІØ^)ý?ѲrŽSqmxrWSÁÛ\&zy÷nmw^Ñ×)`hù¹7³ƒŒ¾Ì#&¶&´OÂN%UÝ5`B›y•Û¢ƒj¼X°t=WˆJ›�’]J	DãVkËJA†1qš^8Éî•(B¶Kº2RT•uÑ#-Ô{†éAÈ:(„³}�	*^Óƒi¦Ù“ÙQœêY²™å΢/8ÝH¼1¬[ñ§6»EÂ<N`Ï¿·mîºk<v‡HOc>S:Q‘(d&Z¦®xÇI-Ž¢Õmg#7I�d#7¬po*ZI,Åì¾]öÏŠÎòæÚÚr Sq\Ô®/ç¾ÐðbÙ¬dÂH:&f#mø†jㆼ=5¾‘�Š÷wöìM¹XMv�JÃÇ7µ-¥*˜HBzxBI$;¸‹àæy�ʪͼèÛl÷ñÕ½IÒFÓBÃ�¶å‰Z¬¡ðŽM¨˜—ÐÙ`ìm¹½#7›2¾+DNž%ðÌk·Lï¤Ø†hænV\»Øñ^ˆÝ¼rošÀ>ÎÎ!ú¸õ£ÃK›g0¢³K0Áµ>ÙZñ�΋XúÚ#8“»m<pæyßßµ»ao<uàï)Ê)ä’z<šhâ9¢N4ø—¤¯l׎1r!ĺnj#7#8–C:ÚÒsŠ/}ÑZÆT�¶Èîf©ÎæÊgš�f¥ÌVk¼=hÄÈ\5�ˆtñ…#7"‚�4r:KãkòWCT™÷ã�_sïê*ÁeÛ›ÅÁ‹1Ì”»övÙßjË´.šû£"jXò™‘ÝÄþÇï=ý1kWÕJñ¥Q3„ýëÌné˜s¡‚^æ¶"±�•k'‘jšÑ+_RùÊx<X.’-2Miã^rM;½?ŒËdìúRC»ºðõÕåUwX¾oÊ3¾¶n‰Ö—N›½¤ÇvæW6D?'k˜Fx{—}¿¸Ù6ëºi2ñ‡`õÙ¯/KñR¡µtZ0RÁ!Sh@ºÔæŽM#7Zã¯TŒÄòÈçŠ"$Eîf¼§7rŽWcA‘KFØÔ¥µ5‰H˦¤ÄoKÅÊô1Ó<°÷¬ÙÓ�…ë9RÍ	‘Áˆz;èÜnÆ©½E¤Ýwx—zaëá>MvÐÛ»p ±=&imõ¿5‹ð‡â÷':@“2[u%À˽S$ðñ8é¾ÛÈn>º*7Îq'¸²™‚q\y0?g=czÎXµÄ#7$‚î…<Á‡E†(!#7{±HE èi†Û[º7ŒàÝÈÝ#7âdž;�\c˘©FPÇ‚òÀ:ãpd‘�$&l\#7t¡׬tQÀniBª74Jk¿¢"fÙx=�» i÷Bi„Äj\žçæT›ÙÃ~ÛØgMa øl•…D †h©3ôúr�%�#8êâ$h�Ü;tïéG6»ë‹X®AéÖÞN¼w%I<“È—/&#7É×$f#&�`ÜX#7OÖÁ�>Ü^ð÷žZS똋~CƒÇ˜P7T¡FwrK`”C¾�Ì5ç5Èfw'–é ÓŠ‰Œ3°è#&"#&Rabfb¦o.N¨ñ³vfløòþ½3wÎ`vŸ·1'}’JP›u4ÔçÙ¦ŠñÚó8Hs9¾|"l4vléE$�7í¾[�Î�›ùôè�Ô„ÉÊçI%ó£QxÙ«Øþ*òð¢�骼ïÈrw«¸ykR’q <¥€[¶©´j@·÷“vÛ†V¢4ݹÌáQ¤`²D¬»žø¶,½ÓÀý1ÉÂ#ÔÂh�WÊ•3„J÷-ó÷m YÂ-͈–ávž§;õÙ¶ë´UÊ	27”TÒín¶#8á#F¹¯!†+m¸µæZ�®S°¸Pý£¥E¢ªm(Š©©§#Ž9ðÍÄë´È¡+;-‹�ñMSPðm7]“fs’‹œ·¬šßVô3Á–òଜçØ6SR<¼xbGf걄²xÙ\ÐãW>xl»˜Òn™Ä5*Rñ„tLKaˆ‚3OâpäB‹1Äó3Ž xßKéáMˆèø¶'iªÌñE–Ÿh]2Ú)»ÞÝCë©n0ûOáËœŒ`VG‘”ŒuñÔ¥!À9²¹ÚvÇ®;q¼™6:”��;w \‘©ólºÒ«­D“#›á÷—l[˜âtq[b0ʬkèí‚)èÀøŠì¥Î™hé­oZk¿\B®ÍË;HqÛÓ©é™Ç(l±\ïÆöüxU>\íO^.ÑMeàë˜;a4:u×YorSSîm¢p.½f驸ó9òðÁáŽP胹¿ç©«G´ì�KìÝŒ˜MßÆÜó—ßÁÎÄ¿LÔmSz;›s^Réq[/›lib�çÌ¿Ú#7Žè\tP;ÕO“†ˆ:\B~Ü$×^=œa¸c‡‡ÅÚ•öò�‘Ï/%ø	nžÎ}¾#7þ¿[È»¦^y,a*ˆ¬Œö¦Íÿ‘éÉ¡‘)¨!tijÀ4Ä”>Ó:S*ø‹ATCKyf,Ø^©ƒêE/ÏŸB0ØxBt`‘ß®2²¬#7�Áõ•BÌX\‘¨hMa`êØ¡¹fCEE»¦ô£-éæ$Þ#7÷9?¾#&d¼kÀ]'°ñ³¥]à-†G«Äm›i휺yËë/Úh¼��BQ{zžÄ²½y ùÒø�sæa@LgUL0ùŒN‡ ¢&·#:ÌÏIpãÌÌ'~¡¹E�ñ‡9}CÏNrLyÂÂˈÆpš#ÚŠ§ Ç·zÙT�UÔ*›qQè[NÜѦ°¼�ÊŸU¤³mÏ0¯
¨#7J2�.CHó(9;˜†Ã»Ú[b¥^¯¨‰ÛBöâöŒ]ŠðÄðÇŽ@ð;$ã!Þ€ýÂ$ñp#7îl¡4·æ/ÅWlxj5;ó6bœ¤ñx‡Ý?\üYöýÂ_ã*îÏÒå8g÷WD»¡ð}ã=ý“ó¶É±?�óËË€–öü\.¸r”ÃÝ;›àt^´íú-J÷×_î4|#8ª†ŸOï�x%³&%,ï¸>æoR(îÁ�%ô‘•-ee$•5Õ~ŒÂÀO=#8ê
F)™#&(Ë€‡�­<Õ>i;ÃÀê=Þ6Çg7ê3ž34µ
'Õe@СôQ€¹!™ôæÇ–¸Ín°v•=™4=6uIÆ´8À•6[ˆfƒT!!aDÚA™Im�šv3l—i’�¦’“h·6¼o$î¹&KLÀ6V¡•",Mƃh
V
 zmáSD#B#7#8;B”Šä!(Òˆm‘b‡Ze�¬ˆ¢HÁci¬ Ç…PȨˆ*Š2(�#7R%ó¤ßÎyç;ù´é<v#í8C²a”¡ÏV½wˆÌÁºZã/Vy¤†Ù3Þó(¨÷e™C´ u!‘YÒ$(‰ñ…)@i”A°@5zm›ÖŸÐÜ�k>èu#7&©coƒïàÌϮ怜Ë-N‚•_àô’Ñ˜”ZÜ(JņwwÖRˆA¦Û¶¹Æ¸Ñ�Ñš�êlÅ¢Ev`Êâdß4>,ÞM±S¦¶ãK
Vbã+«†#8RñÚ×�ÐK£!#8HRUÐe!Ã)TE|¸ÓâopÇ­jê›Æ³‘, ,ÊŤÍÐÔ�qÍ�‰¨Àm6–5$RÅ.ê+M1¢@%rÑQîJ„d%í:»wL¤vI!VËí–ÀûŽÍàŽBŽ.óFwÁ†Lª#8@Y1!•.ˆZ�Cf;y—)š•¸ÂÄ܉”:P¬DmNˆ)˜Ö36/rê'5š7nŒh¤†â­iéµ­j™ám¬¸òN–ÕÕàçÎu¼²·Œ˜#m$1²ÁQq`›Ì8‘m(6¦”-M§£4FL16Ô³‚m°É3¤µu¼U>³/ºQ	�#7$!Éœ²Œ<#lŽ1„H‘q§|]¬Í„YccF=ØñWXÅ«�Ö¨ƒCD9$m¦U�æÒÌSys+ᚬrdt­a&o[1¸Lº”L`Î�4Ý€Þé#7´iÖvÅk›JD�‚p„nœ4q×TÓž.º ¹T¤q²�ì`©I‘Àcû™€÷®šzÒljq^Ts–¥ÕD5¤hiœÉZnD£E´nJD©B¬2#7‚š4†“MŒMBãV�¼Ü[y2Xë®Þœì3ka7.ŸdZ†È©QZêðcHjá*á#7m&£2�PÎl°{nè*1ù>3U(Æ3MSPZsýGƒmõëÄ&;Œ'NP>ý+#8MÔÕ?“+,CrGç%åQ²§ÍÇNš˜TÀ—1•áX7L7¤¼Ìi�¤W¹ßlPË`É$P'#âÌiÇ$ƒšÓpjd V›RÂ0<:ÑŒÒZÑ63äÂwÑ39¶¨‰›™ƒ§xSA£øyRéßÆMÍ!Ò³­Óm¶ëHƒš"Q[ÛéOæÞŠ= ­GÒ¼Ãte@Ê>ˆ�F"Æ4«ÜŠ˜Em×L\÷�¦‘�VàÌÉ%x妇� ý.h�"'M¼X[2”Àãˆ]’MjÁ™Ý6ôÁ—}X¥�d#�3øHÊ6ð“Ž–f‹n4-Ž5I€EBÌœ«s2±5»Æ‰œ”pÁZ¹f„(›T¨b0fµ9Ò†šZxÌI��¡‘¨Ôƒ|ë1#7eœäc¬Óƒ0ä|Â�¦<:zMæÓê»{Ð	|ëâûÁ˜~Ç"�F‚‘)GqeÝC�€ÄÛ^93ÃÚørÿ!|ØáCÄDŒ18_À`‰ôZŠÄÁ°h£"s"Cç^œê”sC¹ê@=;>Û¤¼Æ†‹rS< X}0Ÿ“{§”ñ˜¥¹¼yFÀ1'@öz•ÞÉOSMj3ú+÷q8éYÌê›ïŒ—S…ÙY¶¶]8Æðû±2*ýç¨WÞHzïÄC¥ú½ÁùwåðÀš §·9m‹�P�À¥:´|Ü€JMǘ
^8 âÂ(…3#7»¹•_Ž³ì̃)NY~'6°`Ciq»ÙÎT½æàä‚mšª•ÁåÊaŸ-æ÷=6àcyw#MÝ'wra9YŽ2Îf[ö†ï¾b´{§×ó秹ññ1ùì>°;�P@èlÃ�Ѳ³åE	e445¼,¨'ïÄ	û^ïMëG™<º?#8‘E%3Üò|EPÜO$ Ú§"”Ô!’é€ÔA†8@i`•u+LmQu×W+NíWuÖ£d,°ƒP"èÀÀ3_�^›�åÿµ‡¼„î6…B{ÿ»•z×»Ò±ŽÇò‚Ác©&ØS-­†Æ4„dŒDÉF‘•IBÕ3V4&±¶M‚«d¤¢¨’²Q…²¢Ø¤fÐ¥›$Ò“d¥e™QÒÐTJbZ3E)¢ÊiªQ†²L6Ãë.6aJ‰¥TÌ0ªOè<}g¼Ï�¸ˆú·>³Ìõèp/×'”g¦÷7—qû.á~¾ÍŽ`ý�à¯æwMÎÌ;…E#×Ü@ì C¨O/³Ý|8f«¸åôÁP~N$–�jGÝŠ€*�µ}¤†¹fw—IT艽N;OvŽ[[~ ‡(Úö³dšVœH¨MOe“5Äúj~7¦Û¶Á?¥.üÏ
A	,±uíî_�ÀxÆ^ÓÕÛìWg›±�#7Æ.ÁË#8ªbï8]ù_ÕðÔO¿"sž¬CLª”¡ÊÚ�#8kú3bÛÐÓl™c'™Y—¡‹Õ×;Y#&t—ý@|BÍ )#&Q* ¬U#(�©6´Qó6­r²û�Öå]B“Q£#8´�7™€dÓˆ#c1©4j¥”wpÜOnÒï&EŒ˜á*|‡ÉÁZ8#8ÐS‘ëœã4k\oäfÆÐÖÅŸCEi˜ˆò-¨f#'á—F«liC—G�C¥E+JjR«ce"(0rA°clalzb3|y‘A €(#7åCP…(qlÙ #8Å€À.½íV›MÁ­²’)gg+ÛÎ×—;F2•Ñ–ö•å%ãrÉ6ºíÚ¹Ž¦“ׯ>¬Z¦àœ�.‹ƒÃ@,“(ûA§œE
i¤¤Ek”AÈȬH�ºnyQÇBºë<O•ÃIópê˜Ùõ8bRV±ÛHg<Ê©2À^óe0Ô=iܦѷÝ5»“1+’#c|"GŒ,þÅçDeá©Áû&Äg“jÞj’UʨØÓS�YRwý{ŒÔ˜dÎä‘Ñ917C¨O+ur#8ѬÌ)â#7fT;†�f-�@Ò†�‚Ò˜¶	aP¶.þc�‹T•U'–À ž–UCéñÛ¾·ÍA9óMÂqLôrvDÕÕb€>�j2 çOcì~è#7€…x�Y#&`6íÄ&d”?R#82¡ñh˜�Ž(ž#b˜þYÇí‘LÅݤgœ×ÃÀK3¸›åÁmÙIì÷�r~‡0žÚL)\Ì‚K§]�ƒež‡I%>,’–’á�Œ3Ê€.éM½á®¿O¾@?Iק®šŒ‘“˜LoE Ï/«]?nƒñL�:sÛ3D½}|½&’BB�A‚‡w)Smt#8ñ<› §¬ù…�á§:dHK3,# »Î6Ú$O@Øx÷§ì@^�—Iô�~ý�Ñ¢h/™†ƒäm7Z˜ëv¸ØÈ®n„ÐÆ#7´É•#7ƒE4I	M1ÀÙ•¶@×—šõÏ|µy5ý?Aõh4˜äÑ�8>N?îS¦û0ƒØ ûòc1'³‘÷Õ0Y •“ËNäÙ¾ÓÜE�: Ââ�ØE”£/Êyô4=Üý¥òZõ{×cõú~‹ÒN@r$7ÔÔï�>rIã#8DEÒ|Nª[MË(øœ;€ÿ¦fÅ=§‘¯457*ZX!2ó(²{XGÌ�‚ØišÚGx×Çéä˜ùü&–$à<*Çž#AÇ	Þ"Ð¥OÛ1#7݃µRj93?ºû�
âO‡™¸þo¼=2’5DB «Ÿdz¿Ëj,ð&e÷?�Õ¾#8ƒ àÚ�ï°ù²tÂÙòü?kÍœ!~Zç4й>—LàûþÈÙ®;9 d*ºh±É0ÚÝX3“Ö#&wÉѬø$ï5‚dd5/I÷ŽÀ.æ<9oÜ#&Alj)ÏÚÀùd7‹@󸾓	¹˜•ú…x´¹õÖêiÝËÙâ]òEçŠ!I¹RCuâx1R¡b�Sº4‡!ćMvö=ÉH†Û%�ÏXmìm�äEïW—£àUF„JS»rb¥@ý3<->³ª®С²ªºÃªBÃL&€l€´ŠGföØÁbà€I�ŸœãN¥pdBÿd@¨¨´N™a¾GÊhî]ɬÑÇMƒ�ÛnÉ6™H2q2Nè×bdQi —a;¸¬˜tb£Ç„3ÅEí´5ÆÍóš@Žu	ÌÛ@à.jeÙÛ<o©#&1éfäG…ŒÆÈMA°@j2m%ÛÏÊžgezL%8¥'lp.af‘Þ«^¼°`¤äÀÝ4ÐG.ÜÓ+'<qb#&êÏqû#7Ã`ša# &7Ì"C©=9™H�š´*ò‘>œ^#7­“a†p#&Q#8æÉޛQ“çÏ–Û9*o!‘‰*�Â�¡á±ã­^zsc·R%ŠB4D9ß¿IžºíÉÅ®µ*Úa¡¤†Ç2òÂÔ:E”ÍHĽ0G±�u†’1´4‡¨óÛÖöpÎg}Ô0ën:`уŒrv¡ŸZ¸v“-€¥+x¸0‹d&F95
5:�fbZH¨™@œ“²Îؼ}Þ?ôÙo|Ķ¶©™]qÁ2™œè9ÕÇF
ÙaÁ&\kn“,™¯>á¿$°rx€]®D¨7f¶%+(†ø¯„ð5ãh+moph†åZD”)#&kÙfù¢“HÀL8†Ø&n™Ã	B<ˆW	éŠ;ÃÃäp-mÝ@·Iå¥lg¶ëÔ²ñÑ¢*"š‚-\’®®híˆD`ŠN<ƒÄÊRŠ4ÇgIQËIµªŽÒ<Ê–27×1çKeh#7bì®È+·œNã(jüóOƒ—M^k�ß,<Ê$LaNÓl£i” I¬—6@1Ám9“	ÚGÂ…‚�ï¤Im:L6•,2°¦vÐõIios§b£4™‰5&#&ƒvÛm¥‚˜¹*G¡©çQF#2Ò’·Îí,ª4fqYòÛ&L’ûFDæ—$Ä3pÈmŒ8o(½¤4&”÷Ã�@wµ]6!¶A7§€ÁnÛlbÊiw)„b™Ì	Õ-²šu8‚Çd;KÙ.žõeÖψ[m$�KYq(tSÌ|aw‘¯ítÂí1ùÅÇ®[ÏR¾	1Ã�ö«ç´H©`‡ç‡�­Î14ª#wŒˆy&‹SmõwˆúFàôqaÏ~—f�ÑÉdé×4gÙ³pÉäN‰¬iÛœ/0#9cãSß'‚µu�å¨Y®°òèyÄ×^Xœ5Ûx'×HŠñs&âiÒtîJ¥kŽµ#8µ
‘eP#(k—„+r¹Ã•U[^0V$dã6v{¨py’¥G!n§Ë�[aw<§Xç#8Í3m5V·û
--,)-wrà{Â+®r‹ß ˆÉÁ®Lt«@ˆ©ô©”o37	›@Þ�·1Óƒ<
…ÆΘT¸¹�ó0p�‰JGÇœÏpê×—|¼ �·A”ìa®ö˜‰ÙŸ„.áÀàu¾°*¼ÛË2eJg[’´KàKÈvƒÊA!¯#x0ç4ñÇÈ@㛩#8˜¤Âš
�1ðÖùÈÖêlpÁàÇdÕKÌrT$W—–Û¨õs–rC³>�ßbʘ¸S©®cLÎt&5ò€o—JaƒËÃÃð\ó†4æÏ:äa4µ‘ÏY¢ºÙÞPìÓR3Cj¦:ØÖ+.™&.×Û%�ñ¦!Óp0¥Wå4£ õ)“tä˜?¿ÃìÂoZÍèÓƒ¦Ð¥Èláü³VÒ~^z9í[î¬>‚H!�BLh!Í•åG}i×ÅÖ¯®õ�ÍzRÈCSŽ~01éit³¢1Î7,Ì‹ž“Sz�_.B5¹&ªoÞ3‡’a8/WÃèÒÒzV}œ3†�äÁbdtBL$µ‡(¨LP{ôÛggò½4§Ój&žU•/;8˜V6Çž¹¿fúXÀPÝ•Kd,`i½‹Cc¦†hP”'›5¿F–×Ôš"m­º†Ù`\÷ã3–x�å½Ì·Wiêö¡˜K#8œñ±ÍSõÂvhœ›ó͆™gæh˜8�œ e�³�Kƒ	bIL2Àá§.ZîmØjíÓDT9òÛFn&k4ªÙ¢šcylÂê@¼Lîal³Šv#So3P‡Æó²fÚ`ùâ#8î׆ï&a.?&g‰›Ê¹€Œêš@„Ôí״㶯¨&Á´Ô¶¥�‡O]nN2AË«³Éƒ7j7ˆ´ÉsNC’�ôÊ¡–]bš+F/Z»?â›ìˆÙÚÞø7Ë™Ù1óÄ#7t0HƒEÒ$O'aïØž¢QC#7ÍÍžféšã™¾¶mM�"ÐjvÓI13?T‘ŧöj(D�{#7<Ô®Œo¬#8mÖ!ÍR†6ª#7Œx
ðÝ�ƒNN×AOƒ-F#&¬á�Í0QcÇ; f6êã· ïƒL�ÇQØ:âè”p$‰H%ÐØ¥ùr2ãÐÒ[bX�‚‚€×
#&L‡?2\9©ÃÔä »yh2&¬¥¨’†,´¡Z»CBi,ɪÉPân°Á™–*¢P	ƒŽ™+#8-µhÝæZ	#7Á&R#8qÊ2™‚�‡nÌ:ìù!£w~-	ª¼°h3p"ŠÐl�Ú:ƒäfÅÁG)2 §cf± Òi½‘
ƒ:%C}ü*ÇH£V„Œ«–Û90aÊÁ
€šF. Tѳ©¤wP‘„h:½ ;#7Žd°3›•ébA	ÐÎ(ÚLÄ )¢.øSƒžxëÜqÁðbdÀs,°	í8qéuìÆ4h­ÔÀSHPeÎ;&Á§câÚSýŠŠ[X‘dÆ`a&_`J]/?KÙëûœ(:" Ê(¨ˆ 1¯^WëëÍSª÷qÓo�®¾‘Ø9�/·Ée�a¨É;V$Š#&Ô´@A5	æ!ƒž¬ùoÌ/.DÿPx}_ÎæÏ”U@‘Ÿ®tæn-Œt_½ô)†º%´¾ó®7Ó!J£’0�Ûô�¡¬¦4¤M”f­�AlËÚl6®ð'3ã™™çM&)µ*Dî�Ô\µ¦�Ñ÷¤ÀàÒd�ŸQuj©J›vdØbyóìÌ�ØÙ¢#7ŒˆåHðuüSN~ßJªõå×6,Ì~�a/í„îšVdž}xªÒ/‰wå%×êÍÓlÆ°0Äc�ˆ^�µN=v³DÏoÓ'
àз‹.$¾û–Xï.T‰Ã•�–,â&F‘UªŸ�–I¦=ˆkÓD}åiÒDÓ&Nü�®Øû˜ŽjÓGMÛã“ökJêD8‰Î0Àf -JýáqÒ;ª›/¦ªv-ÐÈämμa·4}o{žvv³YËLlm&õnõ�'}²šaóõ)ôçõOЈ)*'Ù†çÞ~*yøÑÇ}Nò¯bï‡&¤>æ#&K„d„å÷bMfªyŸN<ÂP~Õ	Cœõ‹1Z=Q§UƒXØdY�„b£_IÜäݹ²×‘¬vÝ\§i+F#7%La‰µêyÎ]Õ¼“!2Je¼KNñ¹5æîÑš‘]çGŠàé�Š$”ƒ#ŽáD�°[„̺!(t$›¶pɈ‚1•\Ü#&°æ~ÌN#&™7÷´õ¨Ê#7;‰t{ƒ1.V7v0ÊbBšfâØ¢£]ž�àpr9#ÑVä4³¼á,4EOĨM	gWêôõ}“íöüA?ϼ÷oÙ b?�
ô§’y„žß
ÈüGmðŒ’,œ”Éômm¢ª£#P¢#7’<w0¶ÄBà«CEi+²DÒ)…x|¦ùØr†¶$Š ¸Jcöùˆ�à€}AuÄôxH=Ì�b>#7«Þû'¸ƒ¹÷Yè~/]{äJ);•oZ—y½/¾ä×Ó½"¢bti˜ŸÓ/‡ÜlI°&X#8›†pý

èZÅœŒ%»,0ª'ç&§hpØ&ƒ~ßf,»�½-¨‡Irwr™rÎÓ-öMOÑ•3&Ýc&îXn Ó{ TGkvÐ	P{e#8?úùyÑæBC,ï“ß'X(‚@“l’aƒƒÀqe©•~ˆÊZ¢Ë–‘˜ÇåãäÆA¦Å„×_åÃêøho7Š¤b±ÛAHý#7[yMÒƒKrŠ±Ê.!‹vo`­3ˆQ}�8%'Íe"}ð®#&L)DAHÒ²¨�M1ĉ>Œ‘ˆSxÂÈ%‚#&"#&Ý‘mÇ6 ‰Õ’¦Ú74«’Ò.’Ø$waBH“š«ê‘õ¾»Ž¼a‚â¤hxÿVà#&}j‚s;>go¸èÁá'—=Žã²F„’X–€¤#8J"
é¶ß'ÃÇó?(cõ©ÑCP©ƒ·†Îü€?p°Ê«J�ŒB �ï<–¤îW§…%;ñQ…y�B�¶Ö#&¸"JQ–<ƒ€Ð�$æyºžZJû©Æ°fðg6îÉЋYܼscs€Ðâ9�8C% �°­K”�Vˆ€#826Wd*$L–GSLN…£¬j°#l´Ë•#bI� "q0„(äiÄÄ)[NQB´É!Ÿ¥vÌî;ºÝzmÅ#&yºß ð2u¸+ÉUô)¡pѱÁ¦‘µÛûÈö”ì}}§t,ˆ"æ¬û{þߺ£¬Ò`ªcAo�!ÓÊŒ;QzËd’¿R†*ög׿.ÿ`y¾ÉÒ{‡¹î%Gb-
“â’IF&Ýxê½5	wÌ£óh³ëTW§Àõ/A¬Aih¹b¹�#7RfaÄ×»´&#8#½¨¢7ø	»½§„ÙbÀÒÀ(x	ÅÈLHÊW÷gŸþ§Ç®@ü Ç˧A¾+ž"c¤¢\ñ�˜*ë�ÁE©$  P-#8ƶ*5R¼EvÞˆŽ%D’ç[Ä®ÇñåŒ#7mYxçgÚLÄfÜ0?§ÅàÉæ~_@Ÿž>¨¥;ÏÓ¤ÐÊP�01„Q4‘$P<ug.zú…)éä=矣"Ù”ê¦Òmó‡à|I”žÐ�O¹„, ›*£ÇɱµRHÊ¥ÊD„TªYTÉ�±)C+kb¶a¬&„hÙY�V’¯Ñ%#8M’a4”Œ²˜|dcÂv:¤9¿}lÍ•^
ÇáÆÉÖBcÏÅéòwšÀÚ#&{Oñ
79éáå´<¤#&P`>ßÞîi‚€¡Cv>Ü9·âO	ùs×ߤ'ÙÜ&Uåå©T>ôOhŸQ÷l›Áªž`¨ö²ýüºúb¨ñ>¸øt왽j·÷Éký©;Þ§áS#†^’4‚^ †zÔß1¯ƒ³ÅzêrÂh�§EM(Î8ŠB6péؘváh›¦•kqA· FF¬¥rîKΈ#7”¸C†ƒÃKŽ‘gHb‰’WÎÂ#«8ÝU€É…LÌØT&™‘U…°|ŽÜq°Ü!´€Ø–œ)4$¥«|QµŽ-ÂŒ†¼¬E”¸	&„„Ð!öŒÉo›D3Ns—)zÇSžà”‚ï;®ÆÖ˜PG„õê�†’»4`ÇÝxûZSÁ÷ Dê–"ö†ÚÇswøBÖE�{•Q­#’µ¡�ó³KZ[¬0ØÖO¡t	üS:„º©»)6?2ÌBÜŠSpõû~wÔ“B/¸Ï5½ÞhÀ®*¾ý{ÿ:Šn £û™‚…Fd‡ˆ€Ž»�Ø#8žîóHy°_3¡ãfá0“ÒÈ|¡ …0BÁ¡�G’ˆ#*'sá>{&Žÿ¼ø|§Tûþ& 
Ÿ7™èöž0–ÊV…`xC#UG”	FqY¢š‚Ÿw›õøwÚèb È#7(�ŽC)#&(g–f»î|vßñó=�òýš%õ#7Îî&ÝéשØßRáà—V¿I9÷ºjÍ�¶Èg1¢1ä̇i®uIüäT:ýüÿOqöóª5(Xˆ\�Ý\‘Wœžð	áÐÝ÷bÞrªFsôlKó`»/µô
ŸP%¯ÓUSõŸä‚Ÿ2îœÖOgÄ0xÿ
K-0$©!ù0�#þ[±#& öÊ*ø(úqÖ– =}ÝUF«ËäÅ1™žuÔI±4›�w\‘‰…‘¦~!Slû䎱¨ãµT®HØ�ãi)(ÚRÊ0ÒŠ(‰y7\ÕËy&ÆЕ¯:írÝÆ‹»uãt’ó­‹Í’‰¢b_ÚI“D{OåINÁ!Þ#´×ogçûÂÃ#8¯Ä¯Ãì³ÞdÅÇæÑkP&añ6üñ²jxH—¬<ý3EB‘ @3JA(CH!C°/¼î“Ö"½T…M‰#8�JFÆѤ)iˆ_†'Çá>(ÇèjH¢ˆÑ‰±°ªfØÛEe) ûP>�w§mÒb"ˆ9‡~r#&Ø€R'_Ó.z;ï¨Hy­¾Dp§ÌÂì)ÊôdS/ã#7
ȃd·u͘ÓcY²¶(¶6dbØËb¦”[,ž›Æ¥R%B(dH!Ûá¤h—ÀC
þô<méUNÃþÞôõ{=Aóþ?Ìlõ÷|€#&Hpà‚�'¶O¬ù~œiÏë©NøÈ_§³6d!ø„pô{…$Ï´:n`{ÞHM¶tóØ…2{Ï™!òÚgÝR«ß·m´!S!Z#8_E�}…ýíaDE!>Ã7�÷C±]€0µÎ"i"áüé>;}™a°—¸qž`N �<´‰Â©éOµr P¡|Ñ®”Eè:L ‘�É‘ˆDˆ`¡	°%ƒ‡Ò)¨A¤£s«·>Ï–ð×%Gú¹Ð¡Ø…଎¤;Y8ü˜"�¨-„nO^ž\<>”)÷4•ïÎÄa>õ°áû5†W§4°&âc4;û4-�“Z»,¥�¶Î4Í}ºtùñ!¼üу°MX8Úˆf}í˜jÒfœ`?º�r¹os:Ë׌lcú©#ŽlGÒL`ýŒh$ î#7ú›òú8̸ ˜|Hù^°0GË”ãU#AM*L”ŠŠ[¨ BŠP"U¨!)>I_–CSS#8+FÔšfƒbTÖMõ<ÎÿŽ�G
Ê)J"LÚJ#7DkE1ií3e~ðØí‘f%òÊpAdáŒ>L1Âævv˜u#7(&/P‹ð¿)åÞ½½›`÷l=IAþÀ iQ5b­ÛAZPÕC,4P-*…0J0?@áì:íßìêoóg~öÒ«,”�?¸×ß�âÒ}ÈX„±Ñ@þg8Û_kMc¶÷‚IRSŒ5ƒ„WË#8¬ƒñƒ¯Ê$}æçaýi¥-¿¥áä–FîÙ–!´£‚ÂÈÄéÐ�Äϵ�˜9"š*¿éÙÔll`‘£CA¬C	ÕƒÖ"BJve¨1K1„ÌÆ#7I§@˜¥Bí!‘
C§0dœfb®¹»j*çjl™e«Ë»i“k»«»µ²l©*dHi6…dPÑ`Ea"Œ\”‹	שÕåÚèUʼ‰¼–Ù„^›×—U)¥²jL©W¥kÖÖ š‘¡`‰‚`D&&Ù™&c…4ȱ„˜1„iG³®ê˜Hh�
×–©„Ø–	ÄYêÌÍð®#8šS }†ºá¸jZ‰ªÝY¶#8¡
2õîbsÃûÜp÷œaµ‡e?Œ<LÀÛhªõцož8ÒŽä„wó•‡òw=¯R=0yôØælLûU{Âñüû#&ýÃè‰ÌGí_"§·ëãžaîò ¡qBÀ®Ü8c“foq¬7	ƒ•)·uF±±èÜn%Ä…»µãǃêüËLŒI�R&†ª¥N.—ÄèαošÍ4Ó
”c}Þff¹#8v}û‘H¢Ž+”R1‰x\ëÔ˜ãÂS£\Äþ]Mû	Eì`©!ì90K#7.el‡-ÝÝ&'§Çy‹«".ïÄ°þܤ—ö‘À�·+ó#Z¾‡O¬•—uÒ¤ôÖö1ù(VÃœ@xð#7ƒñÃ#‘ÃmdI§ßí&zÉ«ÁÓ|“àÈ#!h[!Hd˜Ì¾O”ö›†¨s.1úøÏE–ÈYð'¹]%!¥Ÿl‹ßŸ¹ÓÑ$ÝP’ÿ,•­^±+gÊ®±¦¦‘=ÑúÏšQ8³yÁMÊ#7�rÍh-ZN¤–ÁQHXÜGpÌiÉ�ÙŒs£ƒ
–Ó#
N\#��BòMé,ϯÀ#8öC�!}Nòåå¤h¦T›E^-Å!J1(@¢ë!Úºÿ™ìoòþzâÿÐÃÚí1££’Gb«XÛ9ì‚]Üãjýß'18&|SZ‹lœ#7Í{ͦÂI9{&OyÞð�Ïà‚<há./‡Ø¸à‡Æ¥QÇJ¯Éã|Y¦sT�OêIAlDEf{éÅñ«ÙšÖf}ª#7d'\p—ú0§i×ÛU^
€fÔDdZ=#8Û+xƒ€ÜUuñf­�ö°²#7"Ð͵QˆVÒž	[�ýIå@Úla˜qÓÅm<a­Í‚`QêÛŽ7”7±iK#7H׃ÌH‘ä|r×c2``Á#06X#&2Sl}¦ç>]¤¾ò> J>&síƒÝ`±g°ÜÇ ‡‰ÚO! 2>Ô¹©ê|>Ý�:MM5»è-ƒ¬‹!Ù¤7¿p#o¯±¦ð%@�h¨=,–Ž*<ÔD¿W(#7D Tý’tþƒà~n#&ÝT9<_×R&Ée@î#& å¨{Ôº¥9Yxâƒb%EãÜ�•_¹˜û®ûo¸3ìßǙÔ#&92¡tþ]*º–ÿ¿ÿ“ý?Áí×þïû?ãîÿ·ÿ¨ÛÍ�ïû¼Ÿ»ýÿòêÿÏýþWýÚÿîêÿMþoøõ~ïü¿ïÿŽ?øÿ>ÿ¯ÿ#7<ÿñ?ðß—Ÿ³ýßòÓÿíßû?ÿãÿ§ü¿òÿÏþ_ùÿËœ·»ãûðÿ—ôú¾ï²žE#&�±Gë <š/”ýœ�³ûÇéDà@àýad'	È̓üÿÙ@Oyq&ŽîçKsîÆo&tàØOíQÀ?æ„>z¢ N#7¹“¬ooÈ¿�O×w;º‰$	33å¶øê‰#ØÀ$‰Drι	#&êÏV¤ »4Ú!®<ÎHTȧ¦…w£ýÚ¼ý2¤´#&ì!2áéÓ”4&ÜŠ§û	/ÂvwØ„òøDá÷Kþ´gˆ%¼�°ôݽÆÞ9ãçyè·I	#7°`¿×9aÎF3Ü#7Ëí´Æ³Û™N°:ö�è"¸5b�¯ùð)ž­qþ3ç;aÔŸðÙþA•ËîYý7õÎ7ÆæëºPáäÞ'¡¾><#/$*Ú³üaºå)AE‚ãL
b
¢HÆ!1“ƒ§Ûˆü³T;¹N„#¢ÿ�¥0yòòûôäêš´ºâálF°Ùk-)9–¦gõqv–
½©SRD7õ²5ðÝLÓÝš	Íy•äÍh€èyy¥L79?òà˜±Ä쮥¤æ Jð¥c½4‰—�_q	¼”0R3»Uï®ÍÜ4Õm•ªÓC ¨9CèÓÑË7ªŠ;TÕ·háÕ§EÒ²Ë
›q­ŽU5`߃0Ùiíg,Y#8žìI«±¦˜/CSjt¨ÄV‘•MÅ°׶!b\¸ñHÝÝÛ¦ˆ!­Þe!Ô¡ÄĬ#y{ÚÉhÆ­Ô>h4úëÍåžö—#7sæwzÈ…ËíÓ˳`‹�‘#$bqk—�±y#0Æ\!ƒCŸ¢ù Û‰™øe®%•gæXVÕ�"ƒ}voÐFu§HØÑ®Tt7»($gµèÌãoǵ{Ïø’M õùÐJ#7SäÉÔe!‰<Î;¾¬,vêÖj¦+Á%“èÅŠDuÄŽTC¨cÏ^”X�\‘¡<)Yv'/ØømÃkÄÁUEª‡ q¿óùx{7îë‚»îb¬âgÓ`±�ŒÑPUÙŠ
°¤ÆÜ»úà�ÔžÎ\P$GM	×µî¶Ç’œÿèŽ*é`‘„%M�w»çù�«Ø'#§»N€Nµ…$Ê„‘נ؇¥ò¼¹.u4jY†¡&3mȃœÌK3†/ÿ¼„öÊÉ
>­Ÿ^ã—ŽÏwm(2
›¢yyvéðdzz¦½þœìÒÓ’D*�A/‰¨¦†ÔcmM&m´[%c$i"E…f#7šùnÚºª¯¿¤8>ÿÿ’üIL׉¥é±
úd<ꛢ­éPRزu=å
—š
•�ë@}]�ø¨'‡è>>“�§ÝíÃh_ÉOÆ?(�oÍ·}Éucäÿµ8*�‘—û}ݸîèd$!/¨‡X&#8ëÙÑÛþ±Ìœ¾Y+EÑ3Ò‰„;6ÈÙÉwPa´Â2¯ÿDþé£â"|øû ïÎŒr/~ÜkF>ö!³¹l~t�™šºsÒ@:ìâ•–6¢@$ggKWÃCÊ&~^;j|†x#7"0çDO– ‹w�„ÆÔ¡³Prʼn£Ó[ðñ7@mšŽ"³õÑhÔ\6Ò-Fì÷MÁ	[¢²Zúô¯™˜0®“ïàí;\˺D¤¡åÙ8ÃHê·Ókš’±ðjºZ-FN¡]¤¤7„‰(P‰iJ¡ ÚhDbM�yû7­f�dì±ÊߌãpïƒÂäÑ;¸'IDí1ÑÉ?¸õv?ð#&ú<¶ê‰åP<
Ør{	æ{fÒ¬Áï&LOLÉÎI˜˜À!6/˧Aq&=GMw…æc•ûKæ±cô©(ìÏüg¤>}½Ò/@<p:Ô´7x÷�7%#7ËúoÃô¶ž�¥^õ�ØBü±²Ÿì`0סCâ§átGÿ<*ÌP
@$A’‡cØ�vžî¢ãX©’Àƒ‰3&T.(Âe –B$ÜÜ>r()JP‚PxGÞuëóø‰
Å�üO‘L¢œ/ωH'vò£»¨é§y™|¬´þ·´âHlw3ƒÀVCæÃÀ°!		¿Õîßþðˆ�#&ø,$9¿Òßy
�#&Ѷ~˜T¤)bCÿ¡I‹?ç9õöWÇþó�ÿ8ÿï€$O`!ˆ	—ooÿyÙËýí£ýÁrôóeÒpØ,ò„Åh?ïó?ÉÿãþÖ×ê_§ÑñýŽÃO>„é¯lrç!çK»ãÒ÷�.Ô#áö8| |Ä°õ{¼=\GwÄg¼q_þÖ?«ÿ¨†õAòýd›O‘ðÿ·¾OÞ¶ŸñHs–Ž²s‘ãá”B;õÉ#ÿ‘š–‡1r…uv¯ü=¢;~pÊ¡UùÄ%ü½DGDêRAý¢6QûjQÿ΋YÀé]¼N*ˆ¦pMóÕp¸Ë9ƒSùCãé´éÛDè2²±û¹ÈÓxFà±7–ÂQ¿Ñ8¨–½*:LH8Œ»1ç¹Äf„¡ ƒmX+tYrxa"0͉p‡ßßèA_Ú…^×#¦�u<øYó¿»ÿ3Ðñ)èˆÎ,˜ª†ÇÞgÝ-Uˆ"ýaÚyñãÓ_Ÿÿ€•©îWÊ&%ð}O ÿþ.äŠp¡!—w/0
+#<==
diff --git a/.gitignore b/waflib/.gitignore
index 8d35cb3..8d35cb3 100644
--- a/.gitignore
+++ b/waflib/.gitignore
diff --git a/Build.py b/waflib/Build.py
index 1afcba6..1afcba6 100644
--- a/Build.py
+++ b/waflib/Build.py
diff --git a/waflib/COPYING b/waflib/COPYING
new file mode 100644
index 0000000..a4147d2
--- /dev/null
+++ b/waflib/COPYING
@@ -0,0 +1,25 @@
+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 name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 AUTHOR 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.
diff --git a/ConfigSet.py b/waflib/ConfigSet.py
index b300bb5..b300bb5 100644
--- a/ConfigSet.py
+++ b/waflib/ConfigSet.py
diff --git a/Configure.py b/waflib/Configure.py
index d0a4793..d0a4793 100644
--- a/Configure.py
+++ b/waflib/Configure.py
diff --git a/Context.py b/waflib/Context.py
index bb47c92..bb47c92 100644
--- a/Context.py
+++ b/waflib/Context.py
diff --git a/Errors.py b/waflib/Errors.py
index bf75c1b..bf75c1b 100644
--- a/Errors.py
+++ b/waflib/Errors.py
diff --git a/Logs.py b/waflib/Logs.py
index 2a47516..2a47516 100644
--- a/Logs.py
+++ b/waflib/Logs.py
diff --git a/Node.py b/waflib/Node.py
index 4ac1ea8..4ac1ea8 100644
--- a/Node.py
+++ b/waflib/Node.py
diff --git a/Options.py b/waflib/Options.py
index ad802d4..ad802d4 100644
--- a/Options.py
+++ b/waflib/Options.py
diff --git a/waflib/README.md b/waflib/README.md
new file mode 100644
index 0000000..c5361b9
--- /dev/null
+++ b/waflib/README.md
@@ -0,0 +1,24 @@
+Autowaf
+=======
+
+This is autowaf, a bundle of waf and a few extensions intended to be easy to
+use directly as source code in a project.  Using this as a submodule or subtree
+named `waflib` in a project allows waf to be used without including binary
+encoded data in the waf script.  This gets along with revision control and
+distributions better, among other advantages, without losing
+self-containedness.
+
+To use this in a project, add this repository as a directory named `waflib` in
+the top level of the project, and link or copy `waf` to the top level.
+
+Two waf extras are also included: `autowaf.py` and `lv2.py`.
+
+The `autowaf.py` module is a kitchen sink of Python utilities for building
+consistent packages, and can be imported in a wcript as
+`waflib.extras.autowaf`.
+
+The `lv2.py` extra defines options for LV2 plugin installation paths.  It can
+be used by calling `opt.load('lv2')` and `conf.load('lv2')` in the appropriate
+locations in a wscript.
+
+ -- David Robillard <d@drobilla.net>
diff --git a/Runner.py b/waflib/Runner.py
index 261084d..261084d 100644
--- a/Runner.py
+++ b/waflib/Runner.py
diff --git a/Scripting.py b/waflib/Scripting.py
index 749d4f2..749d4f2 100644
--- a/Scripting.py
+++ b/waflib/Scripting.py
diff --git a/Task.py b/waflib/Task.py
index 0fc449d..0fc449d 100644
--- a/Task.py
+++ b/waflib/Task.py
diff --git a/TaskGen.py b/waflib/TaskGen.py
index a74e643..a74e643 100644
--- a/TaskGen.py
+++ b/waflib/TaskGen.py
diff --git a/Tools/__init__.py b/waflib/Tools/__init__.py
index 079df35..079df35 100644
--- a/Tools/__init__.py
+++ b/waflib/Tools/__init__.py
diff --git a/Tools/ar.py b/waflib/Tools/ar.py
index b39b645..b39b645 100644
--- a/Tools/ar.py
+++ b/waflib/Tools/ar.py
diff --git a/Tools/asm.py b/waflib/Tools/asm.py
index b6f26fb..b6f26fb 100644
--- a/Tools/asm.py
+++ b/waflib/Tools/asm.py
diff --git a/Tools/bison.py b/waflib/Tools/bison.py
index eef56dc..eef56dc 100644
--- a/Tools/bison.py
+++ b/waflib/Tools/bison.py
diff --git a/Tools/c.py b/waflib/Tools/c.py
index effd6b6..effd6b6 100644
--- a/Tools/c.py
+++ b/waflib/Tools/c.py
diff --git a/Tools/c_aliases.py b/waflib/Tools/c_aliases.py
index c9d5369..c9d5369 100644
--- a/Tools/c_aliases.py
+++ b/waflib/Tools/c_aliases.py
diff --git a/Tools/c_config.py b/waflib/Tools/c_config.py
index d2b3c0d..d2b3c0d 100644
--- a/Tools/c_config.py
+++ b/waflib/Tools/c_config.py
diff --git a/Tools/c_osx.py b/waflib/Tools/c_osx.py
index f70b128..f70b128 100644
--- a/Tools/c_osx.py
+++ b/waflib/Tools/c_osx.py
diff --git a/Tools/c_preproc.py b/waflib/Tools/c_preproc.py
index 7e04b4a..7e04b4a 100644
--- a/Tools/c_preproc.py
+++ b/waflib/Tools/c_preproc.py
diff --git a/Tools/c_tests.py b/waflib/Tools/c_tests.py
index f858df5..f858df5 100644
--- a/Tools/c_tests.py
+++ b/waflib/Tools/c_tests.py
diff --git a/Tools/ccroot.py b/waflib/Tools/ccroot.py
index cfef8bf..cfef8bf 100644
--- a/Tools/ccroot.py
+++ b/waflib/Tools/ccroot.py
diff --git a/Tools/clang.py b/waflib/Tools/clang.py
index 3828e39..3828e39 100644
--- a/Tools/clang.py
+++ b/waflib/Tools/clang.py
diff --git a/Tools/clangxx.py b/waflib/Tools/clangxx.py
index 152013c..152013c 100644
--- a/Tools/clangxx.py
+++ b/waflib/Tools/clangxx.py
diff --git a/Tools/compiler_c.py b/waflib/Tools/compiler_c.py
index 2dba3f8..2dba3f8 100644
--- a/Tools/compiler_c.py
+++ b/waflib/Tools/compiler_c.py
diff --git a/Tools/compiler_cxx.py b/waflib/Tools/compiler_cxx.py
index 1af65a2..1af65a2 100644
--- a/Tools/compiler_cxx.py
+++ b/waflib/Tools/compiler_cxx.py
diff --git a/Tools/compiler_d.py b/waflib/Tools/compiler_d.py
index 43bb1f6..43bb1f6 100644
--- a/Tools/compiler_d.py
+++ b/waflib/Tools/compiler_d.py
diff --git a/Tools/compiler_fc.py b/waflib/Tools/compiler_fc.py
index 96b58e7..96b58e7 100644
--- a/Tools/compiler_fc.py
+++ b/waflib/Tools/compiler_fc.py
diff --git a/Tools/cs.py b/waflib/Tools/cs.py
index aecca6d..aecca6d 100644
--- a/Tools/cs.py
+++ b/waflib/Tools/cs.py
diff --git a/Tools/cxx.py b/waflib/Tools/cxx.py
index 194fad7..194fad7 100644
--- a/Tools/cxx.py
+++ b/waflib/Tools/cxx.py
diff --git a/Tools/d.py b/waflib/Tools/d.py
index e4cf73b..e4cf73b 100644
--- a/Tools/d.py
+++ b/waflib/Tools/d.py
diff --git a/Tools/d_config.py b/waflib/Tools/d_config.py
index 6637556..6637556 100644
--- a/Tools/d_config.py
+++ b/waflib/Tools/d_config.py
diff --git a/Tools/d_scan.py b/waflib/Tools/d_scan.py
index 14c6c31..14c6c31 100644
--- a/Tools/d_scan.py
+++ b/waflib/Tools/d_scan.py
diff --git a/Tools/dbus.py b/waflib/Tools/dbus.py
index d520f1c..d520f1c 100644
--- a/Tools/dbus.py
+++ b/waflib/Tools/dbus.py
diff --git a/Tools/dmd.py b/waflib/Tools/dmd.py
index 8917ca1..8917ca1 100644
--- a/Tools/dmd.py
+++ b/waflib/Tools/dmd.py
diff --git a/Tools/errcheck.py b/waflib/Tools/errcheck.py
index de8d75a..de8d75a 100644
--- a/Tools/errcheck.py
+++ b/waflib/Tools/errcheck.py
diff --git a/Tools/fc.py b/waflib/Tools/fc.py
index d9e8d8c..d9e8d8c 100644
--- a/Tools/fc.py
+++ b/waflib/Tools/fc.py
diff --git a/Tools/fc_config.py b/waflib/Tools/fc_config.py
index 222f3a5..222f3a5 100644
--- a/Tools/fc_config.py
+++ b/waflib/Tools/fc_config.py
diff --git a/Tools/fc_scan.py b/waflib/Tools/fc_scan.py
index 12cb0fc..12cb0fc 100644
--- a/Tools/fc_scan.py
+++ b/waflib/Tools/fc_scan.py
diff --git a/Tools/flex.py b/waflib/Tools/flex.py
index 2256657..2256657 100644
--- a/Tools/flex.py
+++ b/waflib/Tools/flex.py
diff --git a/Tools/g95.py b/waflib/Tools/g95.py
index f69ba4f..f69ba4f 100644
--- a/Tools/g95.py
+++ b/waflib/Tools/g95.py
diff --git a/Tools/gas.py b/waflib/Tools/gas.py
index 77afed7..77afed7 100644
--- a/Tools/gas.py
+++ b/waflib/Tools/gas.py
diff --git a/Tools/gcc.py b/waflib/Tools/gcc.py
index acdd473..acdd473 100644
--- a/Tools/gcc.py
+++ b/waflib/Tools/gcc.py
diff --git a/Tools/gdc.py b/waflib/Tools/gdc.py
index d89a66d..d89a66d 100644
--- a/Tools/gdc.py
+++ b/waflib/Tools/gdc.py
diff --git a/Tools/gfortran.py b/waflib/Tools/gfortran.py
index 1050667..1050667 100644
--- a/Tools/gfortran.py
+++ b/waflib/Tools/gfortran.py
diff --git a/Tools/glib2.py b/waflib/Tools/glib2.py
index 949fe37..949fe37 100644
--- a/Tools/glib2.py
+++ b/waflib/Tools/glib2.py
diff --git a/Tools/gnu_dirs.py b/waflib/Tools/gnu_dirs.py
index 2847071..2847071 100644
--- a/Tools/gnu_dirs.py
+++ b/waflib/Tools/gnu_dirs.py
diff --git a/Tools/gxx.py b/waflib/Tools/gxx.py
index 22c5d26..22c5d26 100644
--- a/Tools/gxx.py
+++ b/waflib/Tools/gxx.py
diff --git a/Tools/icc.py b/waflib/Tools/icc.py
index b6492c8..b6492c8 100644
--- a/Tools/icc.py
+++ b/waflib/Tools/icc.py
diff --git a/Tools/icpc.py b/waflib/Tools/icpc.py
index 8a6cc6c..8a6cc6c 100644
--- a/Tools/icpc.py
+++ b/waflib/Tools/icpc.py
diff --git a/Tools/ifort.py b/waflib/Tools/ifort.py
index 74934f3..74934f3 100644
--- a/Tools/ifort.py
+++ b/waflib/Tools/ifort.py
diff --git a/Tools/intltool.py b/waflib/Tools/intltool.py
index af95ba8..af95ba8 100644
--- a/Tools/intltool.py
+++ b/waflib/Tools/intltool.py
diff --git a/Tools/irixcc.py b/waflib/Tools/irixcc.py
index c3ae1ac..c3ae1ac 100644
--- a/Tools/irixcc.py
+++ b/waflib/Tools/irixcc.py
diff --git a/Tools/javaw.py b/waflib/Tools/javaw.py
index f6fd20c..f6fd20c 100644
--- a/Tools/javaw.py
+++ b/waflib/Tools/javaw.py
diff --git a/Tools/ldc2.py b/waflib/Tools/ldc2.py
index a51c344..a51c344 100644
--- a/Tools/ldc2.py
+++ b/waflib/Tools/ldc2.py
diff --git a/Tools/lua.py b/waflib/Tools/lua.py
index 15a333a..15a333a 100644
--- a/Tools/lua.py
+++ b/waflib/Tools/lua.py
diff --git a/Tools/md5_tstamp.py b/waflib/Tools/md5_tstamp.py
index 6428e46..6428e46 100644
--- a/Tools/md5_tstamp.py
+++ b/waflib/Tools/md5_tstamp.py
diff --git a/Tools/msvc.py b/waflib/Tools/msvc.py
index 17b347d..17b347d 100644
--- a/Tools/msvc.py
+++ b/waflib/Tools/msvc.py
diff --git a/Tools/nasm.py b/waflib/Tools/nasm.py
index 411d582..411d582 100644
--- a/Tools/nasm.py
+++ b/waflib/Tools/nasm.py
diff --git a/Tools/nobuild.py b/waflib/Tools/nobuild.py
index 2e4b055..2e4b055 100644
--- a/Tools/nobuild.py
+++ b/waflib/Tools/nobuild.py
diff --git a/Tools/perl.py b/waflib/Tools/perl.py
index 32b03fb..32b03fb 100644
--- a/Tools/perl.py
+++ b/waflib/Tools/perl.py
diff --git a/Tools/python.py b/waflib/Tools/python.py
index 25841d0..25841d0 100644
--- a/Tools/python.py
+++ b/waflib/Tools/python.py
diff --git a/Tools/qt5.py b/waflib/Tools/qt5.py
index 4f9c690..4f9c690 100644
--- a/Tools/qt5.py
+++ b/waflib/Tools/qt5.py
diff --git a/Tools/ruby.py b/waflib/Tools/ruby.py
index 8d92a79..8d92a79 100644
--- a/Tools/ruby.py
+++ b/waflib/Tools/ruby.py
diff --git a/Tools/suncc.py b/waflib/Tools/suncc.py
index 33d34fc..33d34fc 100644
--- a/Tools/suncc.py
+++ b/waflib/Tools/suncc.py
diff --git a/Tools/suncxx.py b/waflib/Tools/suncxx.py
index 3b384f6..3b384f6 100644
--- a/Tools/suncxx.py
+++ b/waflib/Tools/suncxx.py
diff --git a/Tools/tex.py b/waflib/Tools/tex.py
index eaf9fdb..eaf9fdb 100644
--- a/Tools/tex.py
+++ b/waflib/Tools/tex.py
diff --git a/Tools/vala.py b/waflib/Tools/vala.py
index 822ec50..822ec50 100644
--- a/Tools/vala.py
+++ b/waflib/Tools/vala.py
diff --git a/Tools/waf_unit_test.py b/waflib/Tools/waf_unit_test.py
index a71ed1c..a71ed1c 100644
--- a/Tools/waf_unit_test.py
+++ b/waflib/Tools/waf_unit_test.py
diff --git a/Tools/winres.py b/waflib/Tools/winres.py
index 586c596..586c596 100644
--- a/Tools/winres.py
+++ b/waflib/Tools/winres.py
diff --git a/Tools/xlc.py b/waflib/Tools/xlc.py
index 134dd41..134dd41 100644
--- a/Tools/xlc.py
+++ b/waflib/Tools/xlc.py
diff --git a/Tools/xlcxx.py b/waflib/Tools/xlcxx.py
index 76aa59b..76aa59b 100644
--- a/Tools/xlcxx.py
+++ b/waflib/Tools/xlcxx.py
diff --git a/Utils.py b/waflib/Utils.py
index b4665c4..b4665c4 100644
--- a/Utils.py
+++ b/waflib/Utils.py
diff --git a/__init__.py b/waflib/__init__.py
index 079df35..079df35 100644
--- a/__init__.py
+++ b/waflib/__init__.py
diff --git a/ansiterm.py b/waflib/ansiterm.py
index 0d20c63..0d20c63 100644
--- a/ansiterm.py
+++ b/waflib/ansiterm.py
diff --git a/extras/__init__.py b/waflib/extras/__init__.py
index c8a3c34..c8a3c34 100644
--- a/extras/__init__.py
+++ b/waflib/extras/__init__.py
diff --git a/extras/autowaf.py b/waflib/extras/autowaf.py
index a4a06ba..a4a06ba 100644
--- a/extras/autowaf.py
+++ b/waflib/extras/autowaf.py
diff --git a/extras/batched_cc.py b/waflib/extras/batched_cc.py
index aad2872..aad2872 100644
--- a/extras/batched_cc.py
+++ b/waflib/extras/batched_cc.py
diff --git a/extras/biber.py b/waflib/extras/biber.py
index fd9db4e..fd9db4e 100644
--- a/extras/biber.py
+++ b/waflib/extras/biber.py
diff --git a/extras/bjam.py b/waflib/extras/bjam.py
index 8e04d3a..8e04d3a 100644
--- a/extras/bjam.py
+++ b/waflib/extras/bjam.py
diff --git a/extras/blender.py b/waflib/extras/blender.py
index e5efc28..e5efc28 100644
--- a/extras/blender.py
+++ b/waflib/extras/blender.py
diff --git a/extras/boo.py b/waflib/extras/boo.py
index 06623d4..06623d4 100644
--- a/extras/boo.py
+++ b/waflib/extras/boo.py
diff --git a/extras/boost.py b/waflib/extras/boost.py
index c2aaaa9..c2aaaa9 100644
--- a/extras/boost.py
+++ b/waflib/extras/boost.py
diff --git a/extras/build_file_tracker.py b/waflib/extras/build_file_tracker.py
index c4f26fd..c4f26fd 100644
--- a/extras/build_file_tracker.py
+++ b/waflib/extras/build_file_tracker.py
diff --git a/extras/build_logs.py b/waflib/extras/build_logs.py
index cdf8ed0..cdf8ed0 100644
--- a/extras/build_logs.py
+++ b/waflib/extras/build_logs.py
diff --git a/extras/buildcopy.py b/waflib/extras/buildcopy.py
index a6d9ac8..a6d9ac8 100644
--- a/extras/buildcopy.py
+++ b/waflib/extras/buildcopy.py
diff --git a/extras/c_bgxlc.py b/waflib/extras/c_bgxlc.py
index 6e3eaf7..6e3eaf7 100644
--- a/extras/c_bgxlc.py
+++ b/waflib/extras/c_bgxlc.py
diff --git a/extras/c_dumbpreproc.py b/waflib/extras/c_dumbpreproc.py
index ce9e1a4..ce9e1a4 100644
--- a/extras/c_dumbpreproc.py
+++ b/waflib/extras/c_dumbpreproc.py
diff --git a/extras/c_emscripten.py b/waflib/extras/c_emscripten.py
index e1ac494..e1ac494 100644
--- a/extras/c_emscripten.py
+++ b/waflib/extras/c_emscripten.py
diff --git a/extras/c_nec.py b/waflib/extras/c_nec.py
index 96bfae4..96bfae4 100644
--- a/extras/c_nec.py
+++ b/waflib/extras/c_nec.py
diff --git a/extras/cabal.py b/waflib/extras/cabal.py
index e10a0d1..e10a0d1 100644
--- a/extras/cabal.py
+++ b/waflib/extras/cabal.py
diff --git a/extras/cfg_altoptions.py b/waflib/extras/cfg_altoptions.py
index 47b1189..47b1189 100644
--- a/extras/cfg_altoptions.py
+++ b/waflib/extras/cfg_altoptions.py
diff --git a/extras/clang_compilation_database.py b/waflib/extras/clang_compilation_database.py
index 4d9b5e2..4d9b5e2 100644
--- a/extras/clang_compilation_database.py
+++ b/waflib/extras/clang_compilation_database.py
diff --git a/extras/codelite.py b/waflib/extras/codelite.py
index 523302c..523302c 100644
--- a/extras/codelite.py
+++ b/waflib/extras/codelite.py
diff --git a/extras/color_gcc.py b/waflib/extras/color_gcc.py
index b68c5eb..b68c5eb 100644
--- a/extras/color_gcc.py
+++ b/waflib/extras/color_gcc.py
diff --git a/extras/color_rvct.py b/waflib/extras/color_rvct.py
index f89ccbd..f89ccbd 100644
--- a/extras/color_rvct.py
+++ b/waflib/extras/color_rvct.py
diff --git a/extras/compat15.py b/waflib/extras/compat15.py
index 0e74df8..0e74df8 100644
--- a/extras/compat15.py
+++ b/waflib/extras/compat15.py
diff --git a/extras/cppcheck.py b/waflib/extras/cppcheck.py
index 13ff424..13ff424 100644
--- a/extras/cppcheck.py
+++ b/waflib/extras/cppcheck.py
diff --git a/extras/cpplint.py b/waflib/extras/cpplint.py
index e3302e5..e3302e5 100644
--- a/extras/cpplint.py
+++ b/waflib/extras/cpplint.py
diff --git a/extras/cross_gnu.py b/waflib/extras/cross_gnu.py
index 309f53b..309f53b 100644
--- a/extras/cross_gnu.py
+++ b/waflib/extras/cross_gnu.py
diff --git a/extras/cython.py b/waflib/extras/cython.py
index 481d6f4..481d6f4 100644
--- a/extras/cython.py
+++ b/waflib/extras/cython.py
diff --git a/extras/dcc.py b/waflib/extras/dcc.py
index c1a57c0..c1a57c0 100644
--- a/extras/dcc.py
+++ b/waflib/extras/dcc.py
diff --git a/extras/distnet.py b/waflib/extras/distnet.py
index 09a31a6..09a31a6 100644
--- a/extras/distnet.py
+++ b/waflib/extras/distnet.py
diff --git a/extras/doxygen.py b/waflib/extras/doxygen.py
index 28f56e9..28f56e9 100644
--- a/extras/doxygen.py
+++ b/waflib/extras/doxygen.py
diff --git a/extras/dpapi.py b/waflib/extras/dpapi.py
index b94d482..b94d482 100644
--- a/extras/dpapi.py
+++ b/waflib/extras/dpapi.py
diff --git a/extras/eclipse.py b/waflib/extras/eclipse.py
index bb78741..bb78741 100644
--- a/extras/eclipse.py
+++ b/waflib/extras/eclipse.py
diff --git a/extras/erlang.py b/waflib/extras/erlang.py
index 49f6d5b..49f6d5b 100644
--- a/extras/erlang.py
+++ b/waflib/extras/erlang.py
diff --git a/extras/fast_partial.py b/waflib/extras/fast_partial.py
index b3af513..b3af513 100644
--- a/extras/fast_partial.py
+++ b/waflib/extras/fast_partial.py
diff --git a/extras/fc_bgxlf.py b/waflib/extras/fc_bgxlf.py
index cca1810..cca1810 100644
--- a/extras/fc_bgxlf.py
+++ b/waflib/extras/fc_bgxlf.py
diff --git a/extras/fc_cray.py b/waflib/extras/fc_cray.py
index da733fa..da733fa 100644
--- a/extras/fc_cray.py
+++ b/waflib/extras/fc_cray.py
diff --git a/extras/fc_nag.py b/waflib/extras/fc_nag.py
index edcb218..edcb218 100644
--- a/extras/fc_nag.py
+++ b/waflib/extras/fc_nag.py
diff --git a/extras/fc_nec.py b/waflib/extras/fc_nec.py
index 67c8680..67c8680 100644
--- a/extras/fc_nec.py
+++ b/waflib/extras/fc_nec.py
diff --git a/extras/fc_open64.py b/waflib/extras/fc_open64.py
index 413719f..413719f 100644
--- a/extras/fc_open64.py
+++ b/waflib/extras/fc_open64.py
diff --git a/extras/fc_pgfortran.py b/waflib/extras/fc_pgfortran.py
index afb2817..afb2817 100644
--- a/extras/fc_pgfortran.py
+++ b/waflib/extras/fc_pgfortran.py
diff --git a/extras/fc_solstudio.py b/waflib/extras/fc_solstudio.py
index 53766df..53766df 100644
--- a/extras/fc_solstudio.py
+++ b/waflib/extras/fc_solstudio.py
diff --git a/extras/fc_xlf.py b/waflib/extras/fc_xlf.py
index 5a3da03..5a3da03 100644
--- a/extras/fc_xlf.py
+++ b/waflib/extras/fc_xlf.py
diff --git a/extras/file_to_object.py b/waflib/extras/file_to_object.py
index 1393b51..1393b51 100644
--- a/extras/file_to_object.py
+++ b/waflib/extras/file_to_object.py
diff --git a/extras/fluid.py b/waflib/extras/fluid.py
index 4814a35..4814a35 100644
--- a/extras/fluid.py
+++ b/waflib/extras/fluid.py
diff --git a/extras/freeimage.py b/waflib/extras/freeimage.py
index f27e525..f27e525 100644
--- a/extras/freeimage.py
+++ b/waflib/extras/freeimage.py
diff --git a/extras/fsb.py b/waflib/extras/fsb.py
index 1b8f398..1b8f398 100644
--- a/extras/fsb.py
+++ b/waflib/extras/fsb.py
diff --git a/extras/fsc.py b/waflib/extras/fsc.py
index c67e70b..c67e70b 100644
--- a/extras/fsc.py
+++ b/waflib/extras/fsc.py
diff --git a/extras/gccdeps.py b/waflib/extras/gccdeps.py
index d9758ab..d9758ab 100644
--- a/extras/gccdeps.py
+++ b/waflib/extras/gccdeps.py
diff --git a/extras/gdbus.py b/waflib/extras/gdbus.py
index 0e0476e..0e0476e 100644
--- a/extras/gdbus.py
+++ b/waflib/extras/gdbus.py
diff --git a/extras/gob2.py b/waflib/extras/gob2.py
index b4fa3b9..b4fa3b9 100644
--- a/extras/gob2.py
+++ b/waflib/extras/gob2.py
diff --git a/extras/halide.py b/waflib/extras/halide.py
index 6078e38..6078e38 100644
--- a/extras/halide.py
+++ b/waflib/extras/halide.py
diff --git a/extras/javatest.py b/waflib/extras/javatest.py
index 979b8d8..979b8d8 100755
--- a/extras/javatest.py
+++ b/waflib/extras/javatest.py
diff --git a/extras/kde4.py b/waflib/extras/kde4.py
index e49a9ec..e49a9ec 100644
--- a/extras/kde4.py
+++ b/waflib/extras/kde4.py
diff --git a/extras/local_rpath.py b/waflib/extras/local_rpath.py
index b2507e1..b2507e1 100644
--- a/extras/local_rpath.py
+++ b/waflib/extras/local_rpath.py
diff --git a/extras/lv2.py b/waflib/extras/lv2.py
index 815987f..815987f 100644
--- a/extras/lv2.py
+++ b/waflib/extras/lv2.py
diff --git a/extras/make.py b/waflib/extras/make.py
index 933d9ca..933d9ca 100644
--- a/extras/make.py
+++ b/waflib/extras/make.py
diff --git a/extras/midl.py b/waflib/extras/midl.py
index 43e6cf9..43e6cf9 100644
--- a/extras/midl.py
+++ b/waflib/extras/midl.py
diff --git a/extras/msvcdeps.py b/waflib/extras/msvcdeps.py
index fc1ecd4..fc1ecd4 100644
--- a/extras/msvcdeps.py
+++ b/waflib/extras/msvcdeps.py
diff --git a/extras/msvs.py b/waflib/extras/msvs.py
index 8aa2db0..8aa2db0 100644
--- a/extras/msvs.py
+++ b/waflib/extras/msvs.py
diff --git a/extras/netcache_client.py b/waflib/extras/netcache_client.py
index dc49048..dc49048 100644
--- a/extras/netcache_client.py
+++ b/waflib/extras/netcache_client.py
diff --git a/extras/objcopy.py b/waflib/extras/objcopy.py
index 82d8359..82d8359 100644
--- a/extras/objcopy.py
+++ b/waflib/extras/objcopy.py
diff --git a/extras/ocaml.py b/waflib/extras/ocaml.py
index afe73c0..afe73c0 100644
--- a/extras/ocaml.py
+++ b/waflib/extras/ocaml.py
diff --git a/extras/package.py b/waflib/extras/package.py
index c06498e..c06498e 100644
--- a/extras/package.py
+++ b/waflib/extras/package.py
diff --git a/extras/parallel_debug.py b/waflib/extras/parallel_debug.py
index 35883a3..35883a3 100644
--- a/extras/parallel_debug.py
+++ b/waflib/extras/parallel_debug.py
diff --git a/extras/pch.py b/waflib/extras/pch.py
index 103e752..103e752 100644
--- a/extras/pch.py
+++ b/waflib/extras/pch.py
diff --git a/extras/pep8.py b/waflib/extras/pep8.py
index 676beed..676beed 100644
--- a/extras/pep8.py
+++ b/waflib/extras/pep8.py
diff --git a/extras/pgicc.py b/waflib/extras/pgicc.py
index 9790b9c..9790b9c 100644
--- a/extras/pgicc.py
+++ b/waflib/extras/pgicc.py
diff --git a/extras/pgicxx.py b/waflib/extras/pgicxx.py
index eae121c..eae121c 100644
--- a/extras/pgicxx.py
+++ b/waflib/extras/pgicxx.py
diff --git a/extras/proc.py b/waflib/extras/proc.py
index 764abec..764abec 100644
--- a/extras/proc.py
+++ b/waflib/extras/proc.py
diff --git a/extras/protoc.py b/waflib/extras/protoc.py
index f3cb4d8..f3cb4d8 100644
--- a/extras/protoc.py
+++ b/waflib/extras/protoc.py
diff --git a/extras/pyqt5.py b/waflib/extras/pyqt5.py
index c21dfa7..c21dfa7 100644
--- a/extras/pyqt5.py
+++ b/waflib/extras/pyqt5.py
diff --git a/extras/pytest.py b/waflib/extras/pytest.py
index 7dd5a1a..7dd5a1a 100644
--- a/extras/pytest.py
+++ b/waflib/extras/pytest.py
diff --git a/extras/qnxnto.py b/waflib/extras/qnxnto.py
index 1158124..1158124 100644
--- a/extras/qnxnto.py
+++ b/waflib/extras/qnxnto.py
diff --git a/extras/qt4.py b/waflib/extras/qt4.py
index 90cae7e..90cae7e 100644
--- a/extras/qt4.py
+++ b/waflib/extras/qt4.py
diff --git a/extras/relocation.py b/waflib/extras/relocation.py
index 7e821f4..7e821f4 100644
--- a/extras/relocation.py
+++ b/waflib/extras/relocation.py
diff --git a/extras/remote.py b/waflib/extras/remote.py
index 3b038f7..3b038f7 100644
--- a/extras/remote.py
+++ b/waflib/extras/remote.py
diff --git a/extras/resx.py b/waflib/extras/resx.py
index caf4d31..caf4d31 100644
--- a/extras/resx.py
+++ b/waflib/extras/resx.py
diff --git a/extras/review.py b/waflib/extras/review.py
index 561e062..561e062 100644
--- a/extras/review.py
+++ b/waflib/extras/review.py
diff --git a/extras/rst.py b/waflib/extras/rst.py
index f3c3a5e..f3c3a5e 100644
--- a/extras/rst.py
+++ b/waflib/extras/rst.py
diff --git a/extras/run_do_script.py b/waflib/extras/run_do_script.py
index f3c5812..f3c5812 100644
--- a/extras/run_do_script.py
+++ b/waflib/extras/run_do_script.py
diff --git a/extras/run_m_script.py b/waflib/extras/run_m_script.py
index b5f27eb..b5f27eb 100644
--- a/extras/run_m_script.py
+++ b/waflib/extras/run_m_script.py
diff --git a/extras/run_py_script.py b/waflib/extras/run_py_script.py
index 3670381..3670381 100644
--- a/extras/run_py_script.py
+++ b/waflib/extras/run_py_script.py
diff --git a/extras/run_r_script.py b/waflib/extras/run_r_script.py
index b0d8f2b..b0d8f2b 100644
--- a/extras/run_r_script.py
+++ b/waflib/extras/run_r_script.py
diff --git a/extras/sas.py b/waflib/extras/sas.py
index 754c614..754c614 100644
--- a/extras/sas.py
+++ b/waflib/extras/sas.py
diff --git a/extras/satellite_assembly.py b/waflib/extras/satellite_assembly.py
index 005eb07..005eb07 100644
--- a/extras/satellite_assembly.py
+++ b/waflib/extras/satellite_assembly.py
diff --git a/extras/scala.py b/waflib/extras/scala.py
index a9880f0..a9880f0 100644
--- a/extras/scala.py
+++ b/waflib/extras/scala.py
diff --git a/extras/slow_qt4.py b/waflib/extras/slow_qt4.py
index ec7880b..ec7880b 100644
--- a/extras/slow_qt4.py
+++ b/waflib/extras/slow_qt4.py
diff --git a/extras/softlink_libs.py b/waflib/extras/softlink_libs.py
index 50c777f..50c777f 100644
--- a/extras/softlink_libs.py
+++ b/waflib/extras/softlink_libs.py
diff --git a/extras/stale.py b/waflib/extras/stale.py
index cac3f46..cac3f46 100644
--- a/extras/stale.py
+++ b/waflib/extras/stale.py
diff --git a/extras/stracedeps.py b/waflib/extras/stracedeps.py
index 37d82cb..37d82cb 100644
--- a/extras/stracedeps.py
+++ b/waflib/extras/stracedeps.py
diff --git a/extras/swig.py b/waflib/extras/swig.py
index fd3d6d2..fd3d6d2 100644
--- a/extras/swig.py
+++ b/waflib/extras/swig.py
diff --git a/extras/syms.py b/waflib/extras/syms.py
index dfa0059..dfa0059 100644
--- a/extras/syms.py
+++ b/waflib/extras/syms.py
diff --git a/extras/ticgt.py b/waflib/extras/ticgt.py
index f43a7ea..f43a7ea 100644
--- a/extras/ticgt.py
+++ b/waflib/extras/ticgt.py
diff --git a/extras/unity.py b/waflib/extras/unity.py
index 78128ed..78128ed 100644
--- a/extras/unity.py
+++ b/waflib/extras/unity.py
diff --git a/extras/use_config.py b/waflib/extras/use_config.py
index ef5129f..ef5129f 100644
--- a/extras/use_config.py
+++ b/waflib/extras/use_config.py
diff --git a/extras/valadoc.py b/waflib/extras/valadoc.py
index c50f69e..c50f69e 100644
--- a/extras/valadoc.py
+++ b/waflib/extras/valadoc.py
diff --git a/extras/waf_xattr.py b/waflib/extras/waf_xattr.py
index 351dd63..351dd63 100644
--- a/extras/waf_xattr.py
+++ b/waflib/extras/waf_xattr.py
diff --git a/extras/why.py b/waflib/extras/why.py
index 1bb941f..1bb941f 100644
--- a/extras/why.py
+++ b/waflib/extras/why.py
diff --git a/extras/win32_opts.py b/waflib/extras/win32_opts.py
index 9f7443c..9f7443c 100644
--- a/extras/win32_opts.py
+++ b/waflib/extras/win32_opts.py
diff --git a/extras/wix.py b/waflib/extras/wix.py
index d87bfbb..d87bfbb 100644
--- a/extras/wix.py
+++ b/waflib/extras/wix.py
diff --git a/extras/xcode6.py b/waflib/extras/xcode6.py
index 91bbff1..91bbff1 100644
--- a/extras/xcode6.py
+++ b/waflib/extras/xcode6.py
diff --git a/fixpy2.py b/waflib/fixpy2.py
index 24176e0..24176e0 100644
--- a/fixpy2.py
+++ b/waflib/fixpy2.py
diff --git a/processor.py b/waflib/processor.py
index 2eecf3b..2eecf3b 100755
--- a/processor.py
+++ b/waflib/processor.py
diff --git a/waflib/waf b/waflib/waf
new file mode 100755
index 0000000..e22930a
--- /dev/null
+++ b/waflib/waf
@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+
+# Minimal waf script for projects that include waflib directly
+
+from waflib import Context, Scripting
+
+import inspect
+import os
+
+def main():
+    script_path = os.path.abspath(inspect.getfile(inspect.getmodule(main)))
+    project_path = os.path.dirname(script_path)
+    Scripting.waf_entry_point(os.getcwd(), Context.WAFVERSION, project_path)
+
+if __name__ == '__main__':
+    main()
diff --git a/wscript b/wscript
new file mode 100644
index 0000000..57f98a5
--- /dev/null
+++ b/wscript
@@ -0,0 +1,273 @@
+#!/usr/bin/env python
+import os
+import subprocess
+from waflib.extras import autowaf as autowaf
+import waflib.Options as Options
+
+# Version of this package (even if built as a child)
+JALV_VERSION = '1.6.1'
+
+# Variables for 'waf dist'
+APPNAME = 'jalv'
+VERSION = JALV_VERSION
+
+# Mandatory variables
+top = '.'
+out = 'build'
+
+def options(ctx):
+    ctx.load('compiler_c')
+    ctx.load('compiler_cxx')
+    autowaf.set_options(ctx)
+    opt = ctx.get_option_group('Configuration options')
+    opt.add_option('--portaudio', action='store_true', default=False,
+                   dest='portaudio',
+                   help='use PortAudio backend, not JACK')
+    opt.add_option('--no-jack-session', action='store_true', default=False,
+                   dest='no_jack_session',
+                   help='do not build JACK session support')
+    opt.add_option('--no-gtk', action='store_true', default=False,
+                   dest='no_gtk',
+                   help='do not build Gtk GUI')
+    opt.add_option('--no-gtkmm', action='store_true', default=False,
+                   dest='no_gtkmm',
+                   help='do not build Gtkmm GUI')
+    opt.add_option('--no-gtk2', action='store_true', dest='no_gtk2',
+                   help='do not build Gtk2 GUI')
+    opt.add_option('--no-gtk3', action='store_true', dest='no_gtk3',
+                   help='do not build Gtk3 GUI')
+    opt.add_option('--no-qt', action='store_true', default=False, dest='no_qt',
+                   help='do not build Qt GUI')
+    opt.add_option('--no-qt4', action='store_true', dest='no_qt4',
+                   help='do not build Qt4 GUI')
+    opt.add_option('--no-qt5', action='store_true', dest='no_qt5',
+                   help='do not build Qt5 GUI')
+
+def configure(conf):
+    autowaf.display_header('Jalv Configuration')
+    autowaf.set_line_just(conf, 45)
+    conf.load('compiler_c', cache=True)
+    conf.load('compiler_cxx', cache=True)
+    conf.load('autowaf', cache=True)
+    autowaf.set_c_lang(conf, 'c99')
+
+    autowaf.check_pkg(conf, 'lv2', atleast_version='1.14.0', uselib_store='LV2')
+    autowaf.check_pkg(conf, 'lilv-0', uselib_store='LILV',
+                      atleast_version='0.24.0', mandatory=True)
+    autowaf.check_pkg(conf, 'serd-0', uselib_store='SERD',
+                      atleast_version='0.14.0', mandatory=True)
+    autowaf.check_pkg(conf, 'sord-0', uselib_store='SORD',
+                      atleast_version='0.12.0', mandatory=True)
+    autowaf.check_pkg(conf, 'suil-0', uselib_store='SUIL',
+                      atleast_version='0.8.7', mandatory=True)
+    autowaf.check_pkg(conf, 'sratom-0', uselib_store='SRATOM',
+                      atleast_version='0.6.0', mandatory=True)
+    if Options.options.portaudio:
+        autowaf.check_pkg(conf, 'portaudio-2.0', uselib_store='PORTAUDIO',
+                          atleast_version='2.0.0', mandatory=False)
+    else:
+        autowaf.check_pkg(conf, 'jack', uselib_store='JACK',
+                          atleast_version='0.120.0', mandatory=True)
+
+    if not Options.options.no_gtk:
+        if not Options.options.no_gtk2:
+            autowaf.check_pkg(conf, 'gtk+-2.0', uselib_store='GTK2',
+                              atleast_version='2.18.0', mandatory=False)
+        if not Options.options.no_gtkmm:
+            autowaf.check_pkg(conf, 'gtkmm-2.4', uselib_store='GTKMM2',
+                              atleast_version='2.20.0', mandatory=False)
+        if not Options.options.no_gtk3:
+            autowaf.check_pkg(conf, 'gtk+-3.0', uselib_store='GTK3',
+                              atleast_version='3.0.0', mandatory=False)
+
+    if not Options.options.no_qt:
+        if not Options.options.no_qt4:
+            autowaf.check_pkg(conf, 'QtGui', uselib_store='QT4',
+                              atleast_version='4.0.0', mandatory=False)
+            if conf.env.HAVE_QT4:
+                if not conf.find_program('moc-qt4', var='MOC4', mandatory=False):
+                    conf.find_program('moc', var='MOC4')
+
+        if not Options.options.no_qt5:
+            autowaf.check_pkg(conf, 'Qt5Widgets', uselib_store='QT5',
+                              atleast_version='5.1.0', mandatory=False)
+            if conf.env.HAVE_QT5:
+                if not conf.find_program('moc-qt5', var='MOC5', mandatory=False):
+                    conf.find_program('moc', var='MOC5')
+
+    if conf.env.HAVE_JACK:
+        autowaf.check_function(
+            conf, 'c', 'jack_port_type_get_buffer_size',
+            header_name = 'jack/jack.h',
+            define_name = 'HAVE_JACK_PORT_TYPE_GET_BUFFER_SIZE',
+            uselib      = 'JACK',
+            mandatory   = False)
+
+        autowaf.check_function(conf, 'c', 'jack_set_property',
+                               header_name = 'jack/metadata.h',
+                               define_name = 'HAVE_JACK_METADATA',
+                               uselib      = 'JACK',
+                               mandatory   = False)
+
+    defines = ['_POSIX_C_SOURCE=200809L']
+
+    autowaf.check_function(conf, 'c', 'isatty',
+                           header_name = 'unistd.h',
+                           defines     = defines,
+                           define_name = 'HAVE_ISATTY',
+                           mandatory   = False)
+
+    autowaf.check_function(conf, 'c', 'fileno',
+                           header_name = 'stdio.h',
+                           defines     = defines,
+                           define_name = 'HAVE_FILENO',
+                           mandatory   = False)
+
+    autowaf.check_function(conf, 'c', 'mlock',
+                           header_name = 'sys/mman.h',
+                           defines     = defines,
+                           define_name = 'HAVE_MLOCK',
+                           mandatory   = False)
+
+    if conf.is_defined('HAVE_ISATTY') and conf.is_defined('HAVE_FILENO'):
+        autowaf.define(conf, 'JALV_WITH_COLOR', 1)
+        conf.env.append_unique('CFLAGS', ['-D_POSIX_C_SOURCE=200809L'])
+
+    if not Options.options.no_jack_session:
+        autowaf.define(conf, 'JALV_JACK_SESSION', 1)
+
+    autowaf.define(conf, 'JALV_VERSION', JALV_VERSION)
+
+    conf.write_config_header('jalv_config.h', remove=False)
+
+    autowaf.display_summary(conf)
+    autowaf.display_msg(conf, "Backend", "Jack" if conf.env.HAVE_JACK else "PortAudio")
+    if conf.env.HAVE_JACK:
+        autowaf.display_msg(conf, "Jack metadata support",
+                            conf.is_defined('HAVE_JACK_METADATA'))
+    autowaf.display_msg(conf, "Gtk 2.0 support", bool(conf.env.HAVE_GTK2))
+    autowaf.display_msg(conf, "Gtk 3.0 support", bool(conf.env.HAVE_GTK3))
+    autowaf.display_msg(conf, "Gtkmm 2.0 support", bool(conf.env.HAVE_GTKMM2))
+    autowaf.display_msg(conf, "Qt 4.0 support", bool(conf.env.HAVE_QT4))
+    autowaf.display_msg(conf, "Qt 5.0 support", bool(conf.env.HAVE_QT5))
+    autowaf.display_msg(conf, "Color output", bool(conf.env.JALV_WITH_COLOR))
+    print('')
+
+def build(bld):
+    libs   = 'LILV SUIL JACK SERD SORD SRATOM LV2 PORTAUDIO'
+    source = '''
+    src/control.c
+    src/jalv.c
+    src/log.c
+    src/lv2_evbuf.c
+    src/state.c
+    src/symap.c
+    src/worker.c
+    src/zix/ring.c
+    '''
+
+    if bld.env.HAVE_JACK:
+        source += 'src/jack.c'
+    elif bld.env.HAVE_PORTAUDIO:
+        source += 'src/portaudio.c'
+
+    # Non-GUI version
+    obj = bld(features     = 'c cprogram',
+              source       = source + ' src/jalv_console.c',
+              target       = 'jalv',
+              includes     = ['.', 'src'],
+              lib          = ['pthread'],
+              install_path = '${BINDIR}')
+    autowaf.use_lib(bld, obj, libs)
+
+    # Gtk2 version
+    if bld.env.HAVE_GTK2:
+        obj = bld(features     = 'c cprogram',
+                  source       = source + ' src/jalv_gtk.c',
+                  target       = 'jalv.gtk',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread', 'm'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' GTK2')
+
+    # Gtk3 version
+    if bld.env.HAVE_GTK3:
+        obj = bld(features     = 'c cprogram',
+                  source       = source + ' src/jalv_gtk.c',
+                  target       = 'jalv.gtk3',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread', 'm'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' GTK3')
+
+    # Gtkmm version
+    if bld.env.HAVE_GTKMM2:
+        obj = bld(features     = 'c cxx cxxprogram',
+                  source       = source + ' src/jalv_gtkmm2.cpp',
+                  target       = 'jalv.gtkmm',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' GTKMM2')
+
+    # Qt4 version
+    if bld.env.HAVE_QT4:
+        obj = bld(rule = '${MOC4} ${SRC} > ${TGT}',
+                  source = 'src/jalv_qt.cpp',
+                  target = 'jalv_qt4_meta.hpp')
+        obj = bld(features     = 'c cxx cxxprogram',
+                  source       = source + ' src/jalv_qt.cpp',
+                  target       = 'jalv.qt4',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' QT4')
+
+    # Qt5 version
+    if bld.env.HAVE_QT5:
+        obj = bld(rule = '${MOC5} ${SRC} > ${TGT}',
+                  source = 'src/jalv_qt.cpp',
+                  target = 'jalv_qt5_meta.hpp')
+        obj = bld(features     = 'c cxx cxxprogram',
+                  source       = source + ' src/jalv_qt.cpp',
+                  target       = 'jalv.qt5',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread'],
+                  install_path = '${BINDIR}',
+                  cxxflags     = ['-fPIC'])
+        autowaf.use_lib(bld, obj, libs + ' QT5')
+
+    # Man pages
+    bld.install_files('${MANDIR}/man1', bld.path.ant_glob('doc/*.1'))
+
+def upload_docs(ctx):
+    import glob
+    import os
+    for page in glob.glob('doc/*.[1-8]'):
+        os.system('mkdir -p build/doc')
+        os.system('soelim %s | pre-grohtml troff -man -wall -Thtml | post-grohtml > build/%s.html' % (page, page))
+        os.system('rsync -avz --delete -e ssh build/%s.html drobilla@drobilla.net:~/drobilla.net/man/' % page)
+
+def lint(ctx):
+    "checks code for style issues"
+    import subprocess
+    cmd = ("clang-tidy -p=. -header-filter=src/ -checks=\"*," +
+           "-clang-analyzer-alpha.*," +
+           "-google-readability-todo," +
+           "-llvm-header-guard," +
+           "-llvm-include-order," +
+           "-misc-unused-parameters," +
+           "-readability-else-after-return\" " +
+           "$(find .. -name '*.c')")
+    subprocess.call(cmd, cwd='build', shell=True)
+
+def posts(ctx):
+    path = str(ctx.path.abspath())
+    autowaf.news_to_posts(
+        os.path.join(path, 'NEWS'),
+        {'title'        : 'Jalv',
+         'description'  : autowaf.get_blurb(os.path.join(path, 'README')),
+         'dist_pattern' : 'http://download.drobilla.net/jalv-%s.tar.bz2'},
+        { 'Author' : 'drobilla',
+          'Tags'   : 'Hacking, LAD, LV2, Jalv' },
+        os.path.join(out, 'posts'))