atmel-samd: Add direct write access to the DAC output.

12 files changed, 3883 insertions, 1 deletions

diff --git a/atmel-samd/Makefile b/atmel-samd/Makefile
index 6003c519c..ef363ef43 100644
--- a/atmel-samd/Makefile
+++ b/atmel-samd/Makefile
@@ -48,6 +48,8 @@ INC +=  $(addprefix -Iasf/sam0/,\
 	drivers/port \
 	drivers/system \
 	drivers/adc/adc_sam_d_r \
+	drivers/dac \
+	drivers/dac/dac_sam_d_c \
 	drivers/system/clock \
 	drivers/system/clock/clock_samd21_r21_da \
 	drivers/system/interrupt \
@@ -93,12 +95,13 @@ endif
 
 
 SRC_ASF = $(addprefix asf/sam0/,\
+	drivers/adc/adc_sam_d_r/adc.c \
+	drivers/dac/dac_sam_d_c/dac.c \
 	drivers/port/port.c \
 	drivers/sercom/sercom.c \
 	drivers/sercom/sercom_interrupt.c \
 	drivers/sercom/usart/usart.c \
 	drivers/sercom/usart/usart_interrupt.c \
-	drivers/adc/adc_sam_d_r/adc.c \
 	drivers/system/clock/clock_samd21_r21_da/clock.c \
 	drivers/system/clock/clock_samd21_r21_da/gclk.c \
 	drivers/system/interrupt/system_interrupt.c   \
@@ -114,6 +117,7 @@ SRC_C = \
 	main.c \
 	modmachine.c \
 	modutime.c \
+	mpdac.c \
 	mphalport.c \
 	pin.c \
 	pin_named_pins.c \
diff --git a/atmel-samd/asf/sam0/drivers/dac/dac.h b/atmel-samd/asf/sam0/drivers/dac/dac.h
new file mode 100644
index 000000000..f26e08e5a
--- /dev/null
+++ b/atmel-samd/asf/sam0/drivers/dac/dac.h
@@ -0,0 +1,207 @@
+/**
+ * \file
+ *
+ * \brief SAM Peripheral Digital-to-Analog Converter Driver
+ *
+ * Copyright (C) 2012-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * 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 Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL 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.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#ifndef DAC_H_INCLUDED
+#define DAC_H_INCLUDED
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <compiler.h>
+#include <clock.h>
+#include <gclk.h>
+
+/**
+ * \addtogroup asfdoc_sam0_dac_group
+ *
+ * @{
+ */
+
+/**
+ * Define DAC features set according to different device families.
+ * @{
+ */
+#if (SAMD21 || SAMD10 || SAMD11 || SAMDA1)
+#  define FEATURE_DAC_DATABUF_WRITE_PROTECTION
+#endif
+/**@}*/
+
+#ifndef DAC_TIMEOUT
+#  define DAC_TIMEOUT 0xFFFF
+#endif
+
+#if DAC_CALLBACK_MODE == true
+#  include <system_interrupt.h>
+
+/** Forward definition of the device instance. */
+struct dac_module;
+
+#if !defined(__DOXYGEN__)
+extern struct dac_module *_dac_instances[DAC_INST_NUM];
+#endif
+
+/** Type definition for a DAC module callback function. */
+typedef void (*dac_callback_t)(uint8_t channel);
+
+/** Enum for the possible callback types for the DAC module. */
+enum dac_callback {
+	/** Callback type for when a DAC channel data empty condition occurs
+	 *  (requires event triggered mode) */
+	DAC_CALLBACK_DATA_EMPTY,
+
+	/** Callback type for when a DAC channel data underrun condition occurs
+	 *  (requires event triggered mode) */
+	DAC_CALLBACK_DATA_UNDERRUN,
+
+	/** Callback type for when a DAC channel write buffer job complete (requires
+	 *  event triggered mode) */
+	DAC_CALLBACK_TRANSFER_COMPLETE,
+#if !defined(__DOXYGEN__)
+	DAC_CALLBACK_N,
+#endif
+};
+
+#endif
+
+#include <dac_feature.h>
+
+/**
+ * \name Configuration and Initialization
+ * @{
+ */
+
+bool dac_is_syncing(
+		struct dac_module *const dev_inst);
+
+void dac_get_config_defaults(
+		struct dac_config *const config);
+
+enum status_code dac_init(
+		struct dac_module *const dev_inst,
+		Dac *const module,
+		struct dac_config *const config);
+
+void dac_reset(
+		struct dac_module *const dev_inst);
+
+void dac_enable(
+		struct dac_module *const dev_inst);
+
+void dac_disable(
+		struct dac_module *const dev_inst);
+
+void dac_enable_events(
+		struct dac_module *const module_inst,
+		struct dac_events *const events);
+
+void dac_disable_events(
+		struct dac_module *const module_inst,
+		struct dac_events *const events);
+
+/** @} */
+
+/**
+ * \name Configuration and Initialization (Channel)
+ * @{
+ */
+
+void dac_chan_get_config_defaults(
+		struct dac_chan_config *const config);
+
+void dac_chan_set_config(
+		struct dac_module *const dev_inst,
+		const enum dac_channel channel,
+		struct dac_chan_config *const config);
+
+void dac_chan_enable(
+		struct dac_module *const dev_inst,
+		enum dac_channel channel);
+
+void dac_chan_disable(
+		struct dac_module *const dev_inst,
+		enum dac_channel channel);
+
+/** @} */
+
+/**
+ * \name Channel Data Management
+ * @{
+ */
+
+enum status_code dac_chan_write(
+		struct dac_module *const dev_inst,
+		enum dac_channel channel,
+		const uint16_t data);
+
+enum status_code dac_chan_write_buffer_wait(
+		struct dac_module *const module_inst,
+		enum dac_channel channel,
+		uint16_t *buffer,
+		uint32_t length);
+
+/** @} */
+
+/**
+ * \name Status Management
+ * @{
+ */
+uint32_t dac_get_status(
+		struct dac_module *const module_inst);
+void dac_clear_status(
+		struct dac_module *const module_inst,
+		uint32_t status_flags);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+
+
+#endif /* DAC_H_INCLUDED */
diff --git a/atmel-samd/asf/sam0/drivers/dac/dac_callback.h b/atmel-samd/asf/sam0/drivers/dac/dac_callback.h
new file mode 100644
index 000000000..0de73056b
--- /dev/null
+++ b/atmel-samd/asf/sam0/drivers/dac/dac_callback.h
@@ -0,0 +1,119 @@
+/**
+ * \file
+ *
+ * \brief SAM Digital-to-Analog Interrupt Driver
+ *
+ * Copyright (C) 2013-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * 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 Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL 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.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#ifndef DAC_CALLBACK_H_INCLUDED
+#define DAC_CALLBACK_H_INCLUDED
+
+#include <compiler.h>
+#include "dac.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \addtogroup asfdoc_sam0_dac_group
+ *
+ * @{
+ */
+
+/** \name Callback Configuration and Initialization
+ * @{
+ */
+enum status_code dac_chan_write_buffer_job(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		uint16_t *buffer,
+		uint32_t buffer_size);
+
+enum status_code dac_chan_write_job(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		uint16_t data);
+
+enum status_code dac_register_callback(
+		struct dac_module *const module,
+		const enum dac_channel channel,
+		const dac_callback_t callback,
+		const enum dac_callback type);
+
+enum status_code dac_unregister_callback(
+		struct dac_module *const module,
+		const enum dac_channel channel,
+		const enum dac_callback type);
+
+/** @} */
+
+/** \name Callback Enabling and Disabling (Channel)
+ * @{
+ */
+
+enum status_code dac_chan_enable_callback(
+		struct dac_module *const module,
+		const enum dac_channel channel,
+		const enum dac_callback type);
+
+enum status_code dac_chan_disable_callback(
+		struct dac_module *const module,
+		const enum dac_channel channel,
+		const enum dac_callback type);
+
+enum status_code dac_chan_get_job_status(
+		struct dac_module *module_inst,
+		const enum dac_channel channel);
+
+void dac_chan_abort_job(
+		struct dac_module *module_inst,
+		const enum dac_channel channel);
+
+/** @} */
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac.c b/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac.c
new file mode 100644
index 000000000..aa73badd3
--- /dev/null
+++ b/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac.c
@@ -0,0 +1,779 @@
+/**
+ * \file
+ *
+ * \brief SAM Peripheral Digital-to-Analog Converter Driver
+ *
+ * Copyright (C) 2012-2016 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * 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 Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL 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.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#include "dac.h"
+#include <system.h>
+#include <pinmux.h>
+
+/**
+ * \internal Writes a DAC configuration to the hardware module.
+ *
+ * Writes out a given configuration to the hardware module.
+ *
+ * \param[out] module_inst  Pointer to the DAC software instance struct
+ * \param[in]  config       Pointer to the configuration struct
+ *
+ */
+static void _dac_set_config(
+		struct dac_module *const module_inst,
+		struct dac_config *const config)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(config);
+	Assert(module_inst->hw);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* Set selected DAC output to be enabled when enabling the module */
+	module_inst->output = config->output;
+	module_inst->start_on_event = false;
+
+	uint32_t new_ctrla = 0;
+	uint32_t new_ctrlb = 0;
+
+	/* Enable DAC in standby sleep mode if configured */
+	if (config->run_in_standby) {
+		new_ctrla |= DAC_CTRLA_RUNSTDBY;
+	}
+
+	/* Set reference voltage */
+	new_ctrlb |= config->reference;
+
+	/* Left adjust data if configured */
+	if (config->left_adjust) {
+		new_ctrlb |= DAC_CTRLB_LEFTADJ;
+	}
+
+#ifdef FEATURE_DAC_DATABUF_WRITE_PROTECTION
+	/* Bypass DATABUF write protection if configured */
+	if (config->databuf_protection_bypass) {
+		new_ctrlb |= DAC_CTRLB_BDWP;
+	}
+#endif
+
+	/* Voltage pump disable if configured */
+	if (config->voltage_pump_disable) {
+		new_ctrlb |= DAC_CTRLB_VPD;
+	}
+
+	/* Apply the new configuration to the hardware module */
+	dac_module->CTRLA.reg = new_ctrla;
+
+	while (dac_is_syncing(module_inst)) {
+		/* Wait until the synchronization is complete */
+	}
+
+	dac_module->CTRLB.reg = new_ctrlb;
+}
+
+/**
+ * \brief Determines if the hardware module(s) are currently synchronizing to the bus.
+ *
+ * Checks to see if the underlying hardware peripheral module(s) are currently
+ * synchronizing across multiple clock domains to the hardware bus. This
+ * function can be used to delay further operations on a module until such time
+ * that it is ready, to prevent blocking delays for synchronization in the
+ * user application.
+ *
+ * \param[in] dev_inst  Pointer to the DAC software instance struct
+ *
+ * \return Synchronization status of the underlying hardware module(s).
+ *
+ * \retval true If the module synchronization is ongoing
+ * \retval false If the module has completed synchronization
+ */
+bool dac_is_syncing(
+		struct dac_module *const dev_inst)
+{
+	/* Sanity check arguments */
+	Assert(dev_inst);
+
+	Dac *const dac_module = dev_inst->hw;
+
+#if (SAMC21)
+	if (dac_module->SYNCBUSY.reg) {
+#else
+	if (dac_module->STATUS.reg & DAC_STATUS_SYNCBUSY) {
+#endif
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * \brief Initializes a DAC configuration structure to defaults.
+ *
+ *  Initializes a given DAC configuration structure to a set of
+ *  known default values. This function should be called on any new
+ *  instance of the configuration structures before being modified by the
+ *  user application.
+ *
+ *  The default configuration is as follows:
+ *   \li 1V from internal bandgap reference
+ *   \li Drive the DAC output to the VOUT pin
+ *   \li Right adjust data
+ *   \li GCLK generator 0 (GCLK main) clock source
+ *   \li The output buffer is disabled when the chip enters STANDBY sleep
+ *       mode
+ *
+ * \param[out] config  Configuration structure to initialize to default values
+ */
+void dac_get_config_defaults(
+		struct dac_config *const config)
+{
+	/* Sanity check arguments */
+	Assert(config);
+
+	/* Default configuration values */
+	config->reference      = DAC_REFERENCE_INT1V;
+	config->output         = DAC_OUTPUT_EXTERNAL;
+	config->left_adjust    = false;
+#ifdef FEATURE_DAC_DATABUF_WRITE_PROTECTION
+	config->databuf_protection_bypass = false;
+#endif
+	config->voltage_pump_disable = false;
+	config->clock_source   = GCLK_GENERATOR_0;
+	config->run_in_standby = false;
+#if (SAMC21)
+	config->dither_mode    = false;
+#endif
+}
+
+/**
+ * \brief Initialize the DAC device struct.
+ *
+ * Use this function to initialize the Digital to Analog Converter. Resets the
+ * underlying hardware module and configures it.
+ *
+ * \note The DAC channel must be configured separately.
+ *
+ * \param[out] module_inst  Pointer to the DAC software instance struct
+ * \param[in]  module       Pointer to the DAC module instance
+ * \param[in]  config       Pointer to the config struct, created by the user
+ *                          application
+ *
+ * \return Status of initialization.
+ * \retval STATUS_OK          Module initiated correctly
+ * \retval STATUS_ERR_DENIED  If module is enabled
+ * \retval STATUS_BUSY        If module is busy resetting
+ */
+enum status_code dac_init(
+		struct dac_module *const module_inst,
+		Dac *const module,
+		struct dac_config *const config)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module);
+	Assert(config);
+
+	/* Initialize device instance */
+	module_inst->hw = module;
+
+	/* Turn on the digital interface clock */
+#if (SAMC21)
+	system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, MCLK_APBCMASK_DAC);
+#else
+	system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, PM_APBCMASK_DAC);
+#endif
+
+	/* Check if module is enabled. */
+	if (module->CTRLA.reg & DAC_CTRLA_ENABLE) {
+		return STATUS_ERR_DENIED;
+	}
+
+	/* Check if reset is in progress. */
+	if (module->CTRLA.reg & DAC_CTRLA_SWRST) {
+		return STATUS_BUSY;
+	}
+
+	/* Configure GCLK channel and enable clock */
+	struct system_gclk_chan_config gclk_chan_conf;
+	system_gclk_chan_get_config_defaults(&gclk_chan_conf);
+	gclk_chan_conf.source_generator = config->clock_source;
+	system_gclk_chan_set_config(DAC_GCLK_ID, &gclk_chan_conf);
+	system_gclk_chan_enable(DAC_GCLK_ID);
+
+	/* MUX the DAC VOUT pin */
+	struct system_pinmux_config pin_conf;
+	system_pinmux_get_config_defaults(&pin_conf);
+
+	/* Set up the DAC VOUT pin */
+	pin_conf.mux_position = MUX_PA02B_DAC_VOUT;
+	pin_conf.direction    = SYSTEM_PINMUX_PIN_DIR_INPUT;
+	pin_conf.input_pull   = SYSTEM_PINMUX_PIN_PULL_NONE;
+	system_pinmux_pin_set_config(PIN_PA02B_DAC_VOUT, &pin_conf);
+
+	/* Write configuration to module */
+	_dac_set_config(module_inst, config);
+
+	/* Store reference selection for later use */
+	module_inst->reference = config->reference;
+
+#if DAC_CALLBACK_MODE == true
+	for (uint8_t i = 0; i < DAC_CALLBACK_N; i++) {
+		module_inst->callback[i] = NULL;
+	};
+
+	_dac_instances[0] = module_inst;
+#endif
+
+	return STATUS_OK;
+}
+
+/**
+ * \brief Resets the DAC module.
+ *
+ * This function will reset the DAC module to its power on default values and
+ * disable it.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ */
+void dac_reset(
+		struct dac_module *const module_inst)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	Dac *const dac_module = module_inst->hw;
+
+	while (dac_is_syncing(module_inst)) {
+		/* Wait until the synchronization is complete */
+	}
+
+	/* Software reset the module */
+	dac_module->CTRLA.reg |= DAC_CTRLA_SWRST;
+}
+
+/**
+ * \brief Enable the DAC module.
+ *
+ * Enables the DAC interface and the selected output. If any internal reference
+ * is selected it will be enabled.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ *
+ */
+void dac_enable(
+		struct dac_module *const module_inst)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* Enable selected output */
+	dac_module->CTRLB.reg |= module_inst->output;
+
+	while (dac_is_syncing(module_inst)) {
+		/* Wait until the synchronization is complete */
+	}
+
+	/* Enable the module */
+	dac_module->CTRLA.reg |= DAC_CTRLA_ENABLE;
+
+	/* Enable internal bandgap reference if selected in the configuration */
+	if (module_inst->reference == DAC_REFERENCE_INT1V) {
+#if (SAMC21)
+		system_voltage_reference_enable(SYSTEM_VOLTAGE_REFERENCE_OUTPUT);
+	}
+
+	if(dac_module->CTRLA.reg & DAC_CTRLA_ENABLE) {
+		while(! (dac_module->STATUS.reg & DAC_STATUS_READY)) {
+		};
+	}
+#else
+		system_voltage_reference_enable(SYSTEM_VOLTAGE_REFERENCE_BANDGAP);
+	}
+
+#endif
+}
+
+/**
+ * \brief Disable the DAC module.
+ *
+ * Disables the DAC interface and the output buffer.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ *
+ */
+void dac_disable(
+		struct dac_module *const module_inst)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* Wait until the synchronization is complete */
+	while (dac_is_syncing(module_inst)) {
+	};
+
+	/* Disbale interrupt */
+	dac_module->INTENCLR.reg = DAC_INTENCLR_MASK;
+	/* Clear interrupt flag */
+	dac_module->INTFLAG.reg = DAC_INTFLAG_MASK;
+
+	/* Disable DAC */
+	dac_module->CTRLA.reg &= ~DAC_CTRLA_ENABLE;
+}
+
+/**
+ * \brief Enables a DAC event input or output.
+ *
+ *  Enables one or more input or output events to or from the DAC module. See
+ *  \ref dac_events "dac_events" for a list of events this module supports.
+ *
+ *  \note Events cannot be altered while the module is enabled.
+ *
+ *  \param[in] module_inst  Software instance for the DAC peripheral
+ *  \param[in] events       Struct containing flags of events to enable
+ */
+void dac_enable_events(
+		struct dac_module *const module_inst,
+		struct dac_events *const events)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+	Assert(events);
+
+	Dac *const dac_module = module_inst->hw;
+
+	uint32_t event_mask = 0;
+
+#if(SAMC21)
+	/* Configure Enable Inversion of input event */
+	if (events->generate_event_on_chan_falling_edge) {
+		event_mask |= DAC_EVCTRL_INVEI;
+	}
+#endif
+
+	/* Configure Buffer Empty event */
+	if (events->generate_event_on_buffer_empty) {
+		event_mask |= DAC_EVCTRL_EMPTYEO;
+	}
+
+	/* Configure Conversion Start event */
+	if (events->on_event_start_conversion) {
+		event_mask |= DAC_EVCTRL_STARTEI;
+		module_inst->start_on_event = true;
+	}
+
+	dac_module->EVCTRL.reg |= event_mask;
+}
+
+/**
+ * \brief Disables a DAC event input or output.
+ *
+ *  Disables one or more input or output events to or from the DAC module. See
+ *  \ref dac_events "dac_events" for a list of events this module supports.
+ *
+ *  \note Events cannot be altered while the module is enabled.
+ *
+ *  \param[in] module_inst  Software instance for the DAC peripheral
+ *  \param[in] events       Struct containing flags of events to disable
+ */
+void dac_disable_events(
+		struct dac_module *const module_inst,
+		struct dac_events *const events)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+	Assert(events);
+
+	Dac *const dac_module = module_inst->hw;
+
+	uint32_t event_mask = 0;
+
+	/* Configure Buffer Empty event */
+	if (events->generate_event_on_buffer_empty) {
+		event_mask |= DAC_EVCTRL_EMPTYEO;
+	}
+
+	/* Configure Conversion Start event */
+	if (events->on_event_start_conversion) {
+		event_mask |= DAC_EVCTRL_STARTEI;
+		module_inst->start_on_event = false;
+	}
+
+	dac_module->EVCTRL.reg &= ~event_mask;
+}
+
+/**
+ * \brief Initializes a DAC channel configuration structure to defaults.
+ *
+ * Initializes a given DAC channel configuration structure to a set of
+ * known default values. This function should be called on any new
+ * instance of the configuration structures before being modified by the
+ * user application.
+ *
+ * The default configuration is as follows:
+ *  \li Start Conversion Event Input enabled
+ *  \li Start Data Buffer Empty Event Output disabled
+ *
+ * \param[out] config  Configuration structure to initialize to default values
+ */
+void dac_chan_get_config_defaults(
+		struct dac_chan_config *const config)
+{
+	/* Sanity check arguments */
+	Assert(config);
+}
+
+/**
+ * \brief Writes a DAC channel configuration to the hardware module.
+ *
+ * Writes a given channel configuration to the hardware module.
+ *
+ * \note The DAC device instance structure must be initialized before calling
+ *       this function.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ * \param[in] channel      Channel to configure
+ * \param[in] config       Pointer to the configuration struct
+ *
+ */
+void dac_chan_set_config(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		struct dac_chan_config *const config)
+{
+	/* No channel support yet */
+	UNUSED(channel);
+}
+
+/**
+ * \brief Enable a DAC channel.
+ *
+ * Enables the selected DAC channel.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ * \param[in] channel      Channel to enable
+ *
+ */
+void dac_chan_enable(
+		struct dac_module *const module_inst,
+		enum dac_channel channel)
+{
+	/* No channel support yet */
+	UNUSED(channel);
+}
+
+/**
+ * \brief Disable a DAC channel.
+ *
+ * Disables the selected DAC channel.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ * \param[in] channel      Channel to disable
+ *
+ */
+void dac_chan_disable(
+		struct dac_module *const module_inst,
+		enum dac_channel channel)
+{
+	/* No channel support yet */
+	UNUSED(channel);
+}
+
+/**
+ * \brief Enable the output buffer.
+ *
+ * Enables the output buffer and drives the DAC output to the VOUT pin.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ * \param[in] channel      DAC channel to alter
+ */
+void dac_chan_enable_output_buffer(
+		struct dac_module *const module_inst,
+		enum dac_channel channel)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	/* No channel support yet */
+	UNUSED(channel);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* Enable output buffer */
+	dac_module->CTRLB.reg |= DAC_OUTPUT_EXTERNAL;
+}
+
+/**
+ * \brief Disable the output buffer.
+ *
+ * Disables the output buffer.
+ *
+ * \note The output buffer(s) should be disabled when a channel's output is not
+ *       currently needed, as it will draw current even if the system is in
+ *       sleep mode.
+ *
+ * \param[in] module_inst  Pointer to the DAC software instance struct
+ * \param[in] channel      DAC channel to alter
+ */
+void dac_chan_disable_output_buffer(
+		struct dac_module *const module_inst,
+		enum dac_channel channel)
+{
+	/* Sanity check arguments*/
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	/* No channel support yet */
+	UNUSED(channel);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* Disable output buffer */
+	dac_module->CTRLB.reg &= ~DAC_OUTPUT_EXTERNAL;
+}
+
+/**
+ * \brief Write to the DAC.
+ *
+ * This function writes to the DATA or DATABUF register.
+ * If the conversion is not event-triggered, the data will be written to
+ * the DATA register and the conversion will start.
+ * If the conversion is event-triggered, the data will be written to DATABUF
+ * and transferred to the DATA register and converted when a Start Conversion
+ * Event is issued.
+ * Conversion data must be right or left adjusted according to configuration
+ * settings.
+ * \note To be event triggered, the enable_start_on_event must be
+ * enabled in the configuration.
+ *
+ * \param[in] module_inst      Pointer to the DAC software device struct
+ * \param[in] channel          DAC channel to write to
+ * \param[in] data             Conversion data
+ *
+ * \return Status of the operation.
+ * \retval STATUS_OK           If the data was written
+ */
+enum status_code dac_chan_write(
+		struct dac_module *const module_inst,
+		enum dac_channel channel,
+		const uint16_t data)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	/* No channel support yet */
+	UNUSED(channel);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* Wait until the synchronization is complete */
+	while (dac_is_syncing(module_inst)) {
+	};
+
+	if (module_inst->start_on_event) {
+		/* Write the new value to the buffered DAC data register */
+		dac_module->DATABUF.reg = data;
+	} else {
+		/* Write the new value to the DAC data register */
+		dac_module->DATA.reg = data;
+	}
+
+	return STATUS_OK;
+}
+
+/**
+ * \brief Write to the DAC.
+ *
+ * This function converts a specific number of digital data.
+ * The conversion should be event-triggered, the data will be written to DATABUF
+ * and transferred to the DATA register and converted when a Start Conversion
+ * Event is issued.
+ * Conversion data must be right or left adjusted according to configuration
+ * settings.
+ * \note To be event triggered, the enable_start_on_event must be
+ * enabled in the configuration.
+ *
+ * \param[in] module_inst      Pointer to the DAC software device struct
+ * \param[in] channel          DAC channel to write to
+ * \param[in] buffer           Pointer to the digital data write buffer to be converted
+ * \param[in] length           Length of the write buffer
+ *
+ * \return Status of the operation.
+ * \retval STATUS_OK           If the data was written or no data conversion required
+ * \retval STATUS_ERR_UNSUPPORTED_DEV  The DAC is not configured as using event trigger
+ * \retval STATUS_BUSY                 The DAC is busy to convert
+ */
+enum status_code dac_chan_write_buffer_wait(
+		struct dac_module *const module_inst,
+		enum dac_channel channel,
+		uint16_t *buffer,
+		uint32_t length)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	/* No channel support yet */
+	UNUSED(channel);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* Wait until the synchronization is complete */
+	while (dac_is_syncing(module_inst)) {
+	};
+
+	/* Zero length request */
+	if (length == 0) {
+		/* No data to be converted */
+		return STATUS_OK;
+	}
+
+#if DAC_CALLBACK_MODE == true
+	/* Check if busy */
+	if (module_inst->job_status == STATUS_BUSY) {
+		return STATUS_BUSY;
+	}
+#endif
+
+	/* Only support event triggered conversion */
+	if (module_inst->start_on_event == false) {
+		return STATUS_ERR_UNSUPPORTED_DEV;
+	}
+
+	/* Blocks while buffer is being transferred */
+	while (length--) {
+		/* Convert one data */
+		dac_chan_write(module_inst, channel, buffer[length]);
+
+		/* Wait until Transmit is complete or timeout */
+		for (uint32_t i = 0; i <= DAC_TIMEOUT; i++) {
+			if (dac_module->INTFLAG.reg & DAC_INTFLAG_EMPTY) {
+				break;
+			} else if (i == DAC_TIMEOUT) {
+				return STATUS_ERR_TIMEOUT;
+			}
+		}
+	}
+
+	return STATUS_OK;
+}
+
+/**
+ * \brief Retrieves the current module status
+ *
+ * Checks the status of the module and returns it as a bitmask of status
+ * flags.
+ *
+ * \param[in] module_inst      Pointer to the DAC software device struct
+ *
+ * \return Bitmask of status flags.
+ *
+ * \retval DAC_STATUS_CHANNEL_0_EMPTY    Data has been transferred from DATABUF
+ *                                       to DATA by a start conversion event
+ *                                       and DATABUF is ready for new data
+ * \retval DAC_STATUS_CHANNEL_0_UNDERRUN A start conversion event has occurred
+ *                                       when DATABUF is empty
+ *
+ */
+uint32_t dac_get_status(
+		struct dac_module *const module_inst)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	Dac *const dac_module = module_inst->hw;
+
+	uint8_t intflags = dac_module->INTFLAG.reg;
+	uint32_t status_flags = 0;
+
+	if (intflags & DAC_INTFLAG_EMPTY) {
+		status_flags |= DAC_STATUS_CHANNEL_0_EMPTY;
+	}
+
+	if (intflags & DAC_INTFLAG_UNDERRUN) {
+		status_flags |= DAC_STATUS_CHANNEL_0_UNDERRUN;
+	}
+
+	return status_flags;
+}
+
+/**
+ * \brief Clears a module status flag
+ *
+ * Clears the given status flag of the module.
+ *
+ * \param[in] module_inst      Pointer to the DAC software device struct
+ * \param[in] status_flags     Bit mask of status flags to clear
+ *
+ */
+void dac_clear_status(
+		struct dac_module *const module_inst,
+		uint32_t status_flags)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	Dac *const dac_module = module_inst->hw;
+
+	uint32_t intflags = 0;
+
+	if (status_flags & DAC_STATUS_CHANNEL_0_EMPTY) {
+		intflags |= DAC_INTFLAG_EMPTY;
+	}
+
+	if (status_flags & DAC_STATUS_CHANNEL_0_UNDERRUN) {
+		intflags |= DAC_INTFLAG_UNDERRUN;
+	}
+
+	dac_module->INTFLAG.reg = intflags;
+}
diff --git a/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac_callback.c b/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac_callback.c
new file mode 100644
index 000000000..d49fc09cb
--- /dev/null
+++ b/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac_callback.c
@@ -0,0 +1,435 @@
+/**
+ * \file
+ *
+ * \brief SAM Digital-to-Analog Interrupt Driver
+ *
+ * Copyright (C) 2013-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * 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 Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL 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.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#include "dac.h"
+#include "dac_callback.h"
+
+struct dac_module *_dac_instances[DAC_INST_NUM];
+
+/**
+ * \brief Convert a specific number digital data to analog through DAC.
+ *
+ * This function will perform a conversion of specific number of digital data.
+ * The conversion should be event-triggered, the data will be written to DATABUF
+ * and transferred to the DATA register and converted when a Start Conversion
+ * Event is issued.
+ * Conversion data must be right or left adjusted according to configuration
+ * settings.
+ * \note To be event triggered, the enable_start_on_event must be
+ * enabled in the configuration.
+ *
+ * \param[in] module_inst      Pointer to the DAC software device struct
+ * \param[in] channel          DAC channel to write to
+ * \param[in] buffer             Pointer to the digital data write buffer to be converted
+ * \param[in] length             Size of the write buffer
+ *
+ * \return Status of the operation.
+ * \retval STATUS_OK           If the data was written
+ * \retval STATUS_ERR_UNSUPPORTED_DEV  If a callback that requires event driven
+ *                                     mode was specified with a DAC instance
+ *                                     configured in non-event mode
+ * \retval STATUS_BUSY      The DAC is busy to accept new job
+ */
+enum status_code dac_chan_write_buffer_job(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		uint16_t *buffer,
+		uint32_t length)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+	Assert(buffer);
+
+	UNUSED(channel);
+
+	Dac *const dac_module = module_inst->hw;
+
+	/* DAC interrupts require it to be driven by events to work, fail if in
+	 * unbuffered (polled) mode */
+	if (module_inst->start_on_event == false) {
+		return STATUS_ERR_UNSUPPORTED_DEV;
+	}
+
+	if(module_inst->remaining_conversions != 0 ||
+			module_inst->job_status == STATUS_BUSY){
+		return STATUS_BUSY;
+	}
+
+	/* Wait until the synchronization is complete */
+	while (dac_is_syncing(module_inst)) {
+	};
+
+	module_inst->job_status = STATUS_BUSY;
+
+	module_inst->remaining_conversions = length;
+	module_inst->job_buffer = buffer;
+	module_inst->transferred_conversions = 0;
+
+	/* Enable interrupt */
+	system_interrupt_enable(SYSTEM_INTERRUPT_MODULE_DAC);
+	dac_module->INTFLAG.reg = DAC_INTFLAG_UNDERRUN | DAC_INTFLAG_EMPTY;
+	dac_module->INTENSET.reg = DAC_INTENSET_UNDERRUN | DAC_INTENSET_EMPTY;
+
+	return STATUS_OK;
+}
+
+/**
+ * \brief Convert one digital data job.
+ *
+ * This function will perform a conversion of specfic number of digital data.
+ * The conversion is event-triggered, the data will be written to DATABUF
+ * and transferred to the DATA register and converted when a Start Conversion
+ * Event is issued.
+ * Conversion data must be right or left adjusted according to configuration
+ * settings.
+ * \note To be event triggered, the enable_start_on_event must be
+ * enabled in the configuration.
+ *
+ * \param[in] module_inst      Pointer to the DAC software device struct
+ * \param[in] channel          DAC channel to write to
+ * \param[in] data             Digital data to be converted
+ *
+ * \return Status of the operation.
+ * \retval STATUS_OK           If the data was written
+ * \retval STATUS_ERR_UNSUPPORTED_DEV  If a callback that requires event driven
+ *                                     mode was specified with a DAC instance
+ *                                     configured in non-event mode
+ * \retval STATUS_BUSY      The DAC is busy to accept new job
+ */
+enum status_code dac_chan_write_job(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		uint16_t data)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(module_inst->hw);
+
+	UNUSED(channel);
+
+	/* DAC interrupts require it to be driven by events to work, fail if in
+	 * unbuffered (polled) mode */
+	if (module_inst->start_on_event == false) {
+		return STATUS_ERR_UNSUPPORTED_DEV;
+	}
+
+	if(module_inst->remaining_conversions != 0 ||
+			module_inst->job_status == STATUS_BUSY){
+		return STATUS_BUSY;
+	}
+
+	dac_chan_write_buffer_job(module_inst, channel, &data, 1);
+
+	return STATUS_OK;
+}
+
+/**
+ * \brief Registers an asynchronous callback function with the driver.
+ *
+ * Registers an asynchronous callback with the DAC driver, fired when a callback
+ * condition occurs.
+ *
+ * \param[in,out] module_inst  Pointer to the DAC software instance struct
+ * \param[in]     callback    Pointer to the callback function to register
+ * \param[in]     channel     Logical channel to register callback function
+ * \param[in]     type        Type of callback function to register
+ *
+ * \return Status of the registration operation.
+ * \retval STATUS_OK                   The callback was registered successfully
+ * \retval STATUS_ERR_INVALID_ARG      If an invalid callback type was supplied
+ * \retval STATUS_ERR_UNSUPPORTED_DEV  If a callback that requires event driven
+ *                                     mode was specified with a DAC instance
+ *                                     configured in non-event mode
+ */
+enum status_code dac_register_callback(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		const dac_callback_t callback,
+		const enum dac_callback type)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+	Assert(callback);
+
+	UNUSED(channel);
+
+	/* DAC interrupts require it to be driven by events to work, fail if in
+	 * unbuffered (polled) mode */
+	if (module_inst->start_on_event == false) {
+		return STATUS_ERR_UNSUPPORTED_DEV;
+	}
+
+	if ((uint8_t)type < DAC_CALLBACK_N) {
+		module_inst->callback[(uint8_t)type] = callback;
+		return STATUS_OK;
+	}
+
+	return STATUS_ERR_INVALID_ARG;
+}
+
+/**
+ * \brief Unregisters an asynchronous callback function with the driver.
+ *
+ * Unregisters an asynchronous callback with the DAC driver, removing it
+ * from the internal callback registration table.
+ *
+ * \param[in,out] module_inst  Pointer to the DAC software instance struct
+ * \param[in]     channel     Logical channel to unregister callback function
+ * \param[in]     type        Type of callback function to unregister
+ *
+ * \return Status of the de-registration operation.
+ * \retval STATUS_OK                   The callback was unregistered successfully
+ * \retval STATUS_ERR_INVALID_ARG      If an invalid callback type was supplied
+ * \retval STATUS_ERR_UNSUPPORTED_DEV  If a callback that requires event driven
+ *                                     mode was specified with a DAC instance
+ *                                     configured in non-event mode
+ */
+enum status_code dac_unregister_callback(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		const enum dac_callback type)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+
+	UNUSED(channel);
+
+	/* DAC interrupts require it to be driven by events to work, fail if in
+	 * unbuffered (polled) mode */
+	if (module_inst->start_on_event == false) {
+		return STATUS_ERR_UNSUPPORTED_DEV;
+	}
+
+	if ((uint8_t)type < DAC_CALLBACK_N) {
+		module_inst->callback[(uint8_t)type] = NULL;
+		return STATUS_OK;
+	}
+
+	return STATUS_ERR_INVALID_ARG;
+}
+
+/**
+ * \brief Enables asynchronous callback generation for a given channel and type.
+ *
+ * Enables asynchronous callbacks for a given logical DAC channel and type. This
+ * must be called before a DAC channel will generate callback events.
+ *
+ * \param[in,out] dac_module  Pointer to the DAC software instance struct
+ * \param[in]     channel     Logical channel to enable callback function
+ * \param[in]     type        Type of callback function callbacks to enable
+ *
+ * \return Status of the callback enable operation.
+ * \retval STATUS_OK                   The callback was enabled successfully
+ * \retval STATUS_ERR_UNSUPPORTED_DEV  If a callback that requires event driven
+ *                                     mode was specified with a DAC instance
+ *                                     configured in non-event mode
+ */
+enum status_code dac_chan_enable_callback(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		const enum dac_callback type)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+
+	UNUSED(channel);
+
+	/* DAC interrupts require it to be driven by events to work, fail if in
+	 * unbuffered (polled) mode */
+	if (module_inst->start_on_event == false) {
+		return STATUS_ERR_UNSUPPORTED_DEV;
+	}
+
+	module_inst->callback_enable[type] = true;
+
+	return STATUS_OK;
+}
+
+/**
+ * \brief Disables asynchronous callback generation for a given channel and type.
+ *
+ * Disables asynchronous callbacks for a given logical DAC channel and type.
+ *
+ * \param[in,out] dac_module  Pointer to the DAC software instance struct
+ * \param[in]     channel     Logical channel to disable callback function
+ * \param[in]     type        Type of callback function callbacks to disable
+ *
+ * \return Status of the callback disable operation.
+ * \retval STATUS_OK                   The callback was disabled successfully
+ * \retval STATUS_ERR_UNSUPPORTED_DEV  If a callback that requires event driven
+ *                                     mode was specified with a DAC instance
+ *                                     configured in non-event mode
+ */
+enum status_code dac_chan_disable_callback(
+		struct dac_module *const module_inst,
+		const enum dac_channel channel,
+		const enum dac_callback type)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+
+	UNUSED(channel);
+
+	/* DAC interrupts require it to be driven by events to work, fail if in
+	 * unbuffered (polled) mode */
+	if (module_inst->start_on_event == false) {
+		return STATUS_ERR_UNSUPPORTED_DEV;
+	}
+
+	module_inst->callback_enable[type] = false;
+
+	return STATUS_OK;
+}
+
+/** \internal
+ *  Internal handler for DAC module interrupts.
+ *
+ * \param[in] instance  DAC instance number
+ */
+static void _dac_interrupt_handler(const uint8_t instance)
+{
+	struct dac_module *module = _dac_instances[instance];
+	Dac *const dac_hw = module->hw;
+
+	if (dac_hw->INTFLAG.reg & DAC_INTFLAG_UNDERRUN) {
+		dac_hw->INTFLAG.reg = DAC_INTFLAG_UNDERRUN;
+
+		if ((module->callback) &&
+			 (module->callback_enable[DAC_CALLBACK_DATA_UNDERRUN])){
+			module->callback[DAC_CALLBACK_DATA_UNDERRUN](0);
+		}
+	}
+
+	if (dac_hw->INTFLAG.reg & DAC_INTFLAG_EMPTY) {
+		dac_hw->INTFLAG.reg = DAC_INTFLAG_EMPTY;
+
+		/* If in a write buffer job */
+		if (module->remaining_conversions) {
+
+			/* Fill the data buffer with next data in write buffer */
+			dac_hw->DATABUF.reg =
+				module->job_buffer[module->transferred_conversions++];
+
+			/* Write buffer size decrement */
+			module->remaining_conversions --;
+
+			/* If in a write buffer job and all the data are converted */
+			if (module->remaining_conversions == 0) {
+				module->job_status = STATUS_OK;
+
+				/* Disable interrupt */
+				dac_hw->INTENCLR.reg = DAC_INTENCLR_EMPTY;
+				dac_hw->INTFLAG.reg = DAC_INTFLAG_EMPTY;
+				system_interrupt_disable(SYSTEM_INTERRUPT_MODULE_DAC);
+
+				if ((module->callback) &&
+					 (module->callback_enable[DAC_CALLBACK_TRANSFER_COMPLETE])) {
+					module->callback[DAC_CALLBACK_TRANSFER_COMPLETE](0);
+				}
+			}
+		}
+
+		if ((module->callback) &&
+			 (module->callback_enable[DAC_CALLBACK_DATA_EMPTY])) {
+			module->callback[DAC_CALLBACK_DATA_EMPTY](0);
+		}
+	}
+}
+
+/** Handler for the DAC hardware module interrupt. */
+void DAC_Handler(void)
+{
+	_dac_interrupt_handler(0);
+}
+
+/**
+ * \brief Gets the status of a job
+ *
+ * Gets the status of an ongoing or the last job.
+ *
+ * \param[in]  module_inst Pointer to the DAC software instance struct
+ * \param[in]  channel     Logical channel to enable callback function
+ *
+ * \return Status of the job.
+ */
+enum status_code dac_chan_get_job_status(
+		struct dac_module *module_inst,
+		const enum dac_channel channel)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+
+	UNUSED(channel);
+
+	return module_inst->job_status;
+}
+
+/**
+ * \brief Aborts an ongoing job
+ *
+ * Aborts an ongoing job.
+ *
+ * \param[in]  module_inst Pointer to the DAC software instance struct
+ * \param[in]  channel     Logical channel to enable callback function
+ */
+void dac_chan_abort_job(
+		struct dac_module *module_inst,
+		const enum dac_channel channel)
+{
+	/* Sanity check arguments */
+	Assert(module_inst);
+
+	UNUSED(channel);
+
+	/* Disable interrupt */
+	module_inst->hw->INTFLAG.reg = DAC_INTFLAG_UNDERRUN | DAC_INTFLAG_EMPTY;
+	module_inst->hw->INTENCLR.reg = DAC_INTENCLR_UNDERRUN | DAC_INTENCLR_EMPTY;
+
+	/* Mark job as aborted */
+	module_inst->job_status = STATUS_ABORTED;
+	module_inst->remaining_conversions = 0;
+
+}
diff --git a/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac_feature.h b/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac_feature.h
new file mode 100644
index 000000000..ae7ce8d65
--- /dev/null
+++ b/atmel-samd/asf/sam0/drivers/dac/dac_sam_d_c/dac_feature.h
@@ -0,0 +1,634 @@
+/**
+ * \file
+ *
+ * \brief SAM Peripheral Digital-to-Analog Converter Driver
+ *
+ * Copyright (C) 2012-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * 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 Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL 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.
+ *
+ * \asf_license_stop
+ *
+ */
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+#ifndef DAC_FEATURE_H_INCLUDED
+#define DAC_FEATURE_H_INCLUDED
+
+/**
+ * \defgroup asfdoc_sam0_dac_group SAM Digital-to-Analog (DAC) Driver
+ *
+ * This driver for Atmel&reg; | SMART ARM&reg;-based microcontrollers provides an interface for the conversion of
+ * digital values to analog voltage. The following driver API modes are covered
+ * by this manual:
+ *
+ *  - Polled APIs
+ * \if DAC_CALLBACK_MODE
+ *  - Callback APIs
+ * \endif
+ *
+ * The following peripheral is used by this module:
+ *  - DAC (Digital-to-Analog Converter)
+ *
+ * The following devices can use this module:
+ *  - Atmel | SMART SAM D20/D21
+ *  - Atmel | SMART SAM D10/D11
+ *  - Atmel | SMART SAM DA1
+ *  - Atmel | SMART SAM C21
+ *
+ * The outline of this documentation is as follows:
+ *  - \ref asfdoc_sam0_dac_prerequisites
+ *  - \ref asfdoc_sam0_dac_module_overview
+ *  - \ref asfdoc_sam0_dac_special_considerations
+ *  - \ref asfdoc_sam0_dac_extra_info
+ *  - \ref asfdoc_sam0_dac_examples
+ *  - \ref asfdoc_sam0_dac_api_overview
+ *
+ *
+ * \section asfdoc_sam0_dac_prerequisites Prerequisites
+ *
+ * There are no prerequisites for this module.
+ *
+ *
+ * \section asfdoc_sam0_dac_module_overview Module Overview
+ *
+ * The Digital-to-Analog converter converts a digital value to analog voltage.
+ * The SAM DAC module has one channel with 10-bit resolution,
+ * and is capable of converting up to 350k samples per second (ksps).
+ *
+ * A common use of DAC is to generate audio signals by connecting the DAC
+ * output to a speaker, or to generate a reference voltage; either for an
+ * external circuit or an internal peripheral such as the Analog Comparator.
+ *
+ * After being set up, the DAC will convert new digital values written to the
+ * conversion data register (DATA) to an analog value either on the VOUT pin of
+ * the device, or internally for use as an input to the AC, ADC, and other analog
+ * modules.
+ *
+ * Writing the DATA register will start a new conversion. It is also possible
+ * to trigger the conversion from the event system.
+ *
+ * A simplified block diagram of the DAC can be seen in
+ * \ref asfdoc_sam0_dac_module_block_diagram "the figure below".
+ *
+ * \anchor asfdoc_sam0_dac_module_block_diagram
+ * \image html dac_block_diagram.svg "DAC Block Diagram"
+ *
+ * \subsection asfdoc_sam0_dac_conversion_range Conversion Range
+ * The conversion range is between GND and the selected voltage reference.
+ * Available voltage references are:
+ * \li AVCC voltage reference
+ * \li Internal 1V reference (INT1V)
+ * \li External voltage reference (AREF)
+ *
+ * \note Internal references will be enabled by the driver, but not disabled.
+ * Any reference not used by the application should be disabled by the application.
+ *
+ * The output voltage from a DAC channel is given as:
+ * \f[
+ *    V_{OUT} = \frac{DATA}{0x3FF} \times VREF
+ * \f]
+ *
+ * \subsection asfdoc_sam0_dac_conversion Conversion
+ * The digital value written to the conversion data register (DATA) will be
+ * converted to an analog value.
+ * Writing the DATA register will start a new conversion.
+ * It is also possible to write the conversion data to the DATABUF register,
+ * the writing of the DATA register can then be triggered from the event
+ * system, which will load the value from DATABUF to DATA.
+ *
+ * \subsection asfdoc_sam0_dac_analog_output Analog Output
+ * The analog output value can be output to either the VOUT pin or internally,
+ * but not both at the same time.
+ *
+ * \subsubsection asfdoc_sam0_dac_analog_output_external External Output
+ * The output buffer must be enabled in order to drive the DAC output to the
+ * VOUT pin. Due to the output buffer, the DAC has high drive strength, and is
+ * capable of driving both resistive and capacitive loads, as well as loads
+ * which combine both.
+ *
+ * \subsubsection asfdoc_sam0_dac_analog_output_internal Internal Output
+ * The analog value can be internally available for use as input to the
+ * AC or ADC modules.
+ *
+ * \subsection asfdoc_sam0_dac_events Events
+ * Events generation and event actions are configurable in the DAC.
+ * The DAC has one event line input and one event output: <i>Start Conversion</i>
+ * and <i>Data Buffer Empty</i>.
+ *
+ * If the Start Conversion input event is enabled in the module configuration,
+ * an incoming event will load data from the data buffer to the data register
+ * and start a new conversion. This method synchronizes conversions with
+ * external events (such as those from a timer module) and ensures regular and
+ * fixed conversion intervals.
+ *
+ * If the Data Buffer Empty output event is enabled in the module configuration,
+ * events will be generated when the DAC data buffer register becomes empty and
+ * new data can be loaded to the buffer.
+ *
+ * \note The connection of events between modules requires the use of the event
+ *       driver to route output event of one module to the input event of another.
+ *       For more information on event routing, refer to the documentation
+ *       \ref asfdoc_sam0_events_group "SAM Event System (EVENTS) Driver".
+ *
+ * \subsection asfdoc_sam0_dac_data_adjust Left and Right Adjusted Values
+ * The 10-bit input value to the DAC is contained in a 16-bit register. This
+ * can be configured to be either left or right adjusted. In
+ * \ref asfdoc_sam0_dac_module_adj_modes "the figure below" both options are
+ * shown, and the position of the most (MSB) and the least (LSB) significant bits
+ * are indicated. The unused bits should always be written to zero.
+ *
+ * \anchor asfdoc_sam0_dac_module_adj_modes
+ * \dot
+ * digraph {
+ *   subgraph cluster_right {
+ *      msbl [label="MSB", shape=none, group="msbl"];
+ *      lsbl [label="LSB", shape=none];
+ *      node [shape=none];
+ *      color="white";
+ *      reg_left [label=<
+ *        <table cellspacing="0" cellpadding="2" width="100%">
+ *          <tr>
+ *            <td port="msb">15</td>
+ *            <td>14</td>
+ *            <td>13</td>
+ *            <td>12</td>
+ *            <td>11</td>
+ *            <td>10</td>
+ *            <td>9</td>
+ *            <td>8</td>
+ *            <td>7</td>
+ *            <td port="lsb">6</td>
+ *            <td>5</td>
+ *            <td>4</td>
+ *            <td>3</td>
+ *            <td>2</td>
+ *            <td>1</td>
+ *            <td>0</td>
+ *          </tr>
+ *          <tr>
+ *            <td COLSPAN="10"> DATA[9:0] </td>
+ *            <td BGCOLOR="lightgray"> </td>
+ *            <td BGCOLOR="lightgray"> </td>
+ *            <td BGCOLOR="lightgray"> </td>
+ *            <td BGCOLOR="lightgray"> </td>
+ *            <td BGCOLOR="lightgray"> </td>
+ *            <td BGCOLOR="lightgray"> </td>
+ *          </tr>
+ *        </table>
+ *      >];
+ *      msbl -> reg_left:msb:n;
+ *      lsbl -> reg_left:lsb;
+ *      label ="Left adjusted.\n";
+ *   }
+ *   subgraph cluster_left {
+ *      rankdir=TB;
+ *      msb [label="MSB", shape=none];
+ *      lsb [label="LSB", shape=none];
+ *      color="white";
+ *      node [shape=none];
+ *      reg_right [label=<
+ *        <table cellspacing="0" cellpadding="2">
+ *          <tr>
+ *            <td>15</td>
+ *            <td>14</td>
+ *            <td>13</td>
+ *            <td>12</td>
+ *            <td>11</td>
+ *            <td>10</td>
+ *            <td port="msb">9</td>
+ *            <td>8</td>
+ *            <td>7</td>
+ *            <td>6</td>
+ *            <td>5</td>
+ *            <td>4</td>
+ *            <td>3</td>
+ *            <td>2</td>
+ *            <td>1</td>
+ *            <td port="lsb">0</td>
+ *          </tr>
+ *          <tr>
+ *            <td BGCOLOR="lightgray"></td>
+ *            <td BGCOLOR="lightgray"></td>
+ *            <td BGCOLOR="lightgray"></td>
+ *            <td BGCOLOR="lightgray"></td>
+ *            <td BGCOLOR="lightgray"></td>
+ *            <td BGCOLOR="lightgray"></td>
+ *            <td COLSPAN="10"> DATA[9:0] </td>
+ *          </tr>
+ *        </table>
+ *      >];
+ *      msb -> reg_right:msb;
+ *      lsb -> reg_right:lsb:n;
+ *      label = "Right adjusted.\n";
+ *      graph [shape=none];
+ *  }
+ * }
+ * \enddot
+ *
+ * \subsection asfdoc_sam0_dac_clk_sources Clock Sources
+ * The clock for the DAC interface (CLK_DAC) is generated by the Power Manager.
+ * This clock is turned on by default, and can be enabled and disabled in the
+ * Power Manager.
+ *
+ * Additionally, an asynchronous clock source (GCLK_DAC) is required.
+ * These clocks are normally disabled by default. The selected clock source
+ * must be enabled in the Power Manager before it can be used by the DAC.
+ * The DAC core operates asynchronously from the user interface and
+ * peripheral bus. As a consequence, the DAC needs two clock cycles of both
+ * CLK_DAC and GCLK_DAC to synchronize the values written to some of the
+ * control and data registers.
+ * The oscillator source for the GCLK_DAC clock is selected in the System
+ * Control Interface (SCIF).
+ *
+ * \section asfdoc_sam0_dac_special_considerations Special Considerations
+ *
+ * \subsection asfdoc_sam0_dac_special_considerations_output_buffer Output Driver
+ * The DAC can only do conversions in Active or Idle modes. However, if the
+ * output buffer is enabled it will draw current even if the system is in
+ * sleep mode. Therefore, always make sure that the output buffer is not
+ * enabled when it is not needed, to ensure minimum power consumption.
+ *
+ * \subsection asfdoc_sam0_dac_special_considerations_conversion_time Conversion Time
+ * DAC conversion time is approximately 2.85µs. The user must ensure that new
+ * data is not written to the DAC before the last conversion is complete.
+ * Conversions should be triggered by a periodic event from a Timer/Counter or
+ * another peripheral.
+ *
+ *
+ * \section asfdoc_sam0_dac_extra_info Extra Information
+ *
+ * For extra information, see \ref asfdoc_sam0_dac_extra. This includes:
+ *  - \ref asfdoc_sam0_dac_extra_acronyms
+ *  - \ref asfdoc_sam0_dac_extra_dependencies
+ *  - \ref asfdoc_sam0_dac_extra_errata
+ *  - \ref asfdoc_sam0_dac_extra_history
+ *
+ *
+ * \section asfdoc_sam0_dac_examples Examples
+ *
+ * For a list of examples related to this driver, see
+ * \ref asfdoc_sam0_dac_exqsg.
+ *
+ *
+ * \section asfdoc_sam0_dac_api_overview API Overview
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <compiler.h>
+#include <clock.h>
+#include <gclk.h>
+
+
+/**
+ * \name DAC Status Flags
+ *
+ * DAC status flags, returned by \ref dac_get_status() and cleared by
+ * \ref dac_clear_status().
+ * @{
+ */
+
+/** Data Buffer Empty Channel 0 - Set when data is transferred from DATABUF
+ *  to DATA by a start conversion event and DATABUF is ready for new data.
+ */
+#define DAC_STATUS_CHANNEL_0_EMPTY     (1UL << 0)
+
+/** Under-run Channel 0 - Set when a start conversion event occurs when
+ *  DATABUF is empty.
+ */
+#define DAC_STATUS_CHANNEL_0_UNDERRUN  (1UL << 1)
+
+/** @} */
+
+/**
+ * \brief DAC reference voltage enum.
+ *
+ * Enum for the possible reference voltages for the DAC.
+ */
+enum dac_reference {
+	/** 1V from the internal band-gap reference*/
+	DAC_REFERENCE_INT1V = DAC_CTRLB_REFSEL(0),
+	/** Analog V<SUB>CC</SUB> as reference */
+	DAC_REFERENCE_AVCC  = DAC_CTRLB_REFSEL(1),
+	/** External reference on AREF */
+	DAC_REFERENCE_AREF  = DAC_CTRLB_REFSEL(2),
+};
+
+/**
+ * \brief DAC output selection enum.
+ *
+ * Enum for the DAC output selection.
+ */
+enum dac_output {
+	/** DAC output to VOUT pin */
+	DAC_OUTPUT_EXTERNAL = DAC_CTRLB_EOEN,
+	/** DAC output as internal reference */
+	DAC_OUTPUT_INTERNAL = DAC_CTRLB_IOEN,
+	/** No output */
+	DAC_OUTPUT_NONE     = 0,
+};
+
+/**
+ * \brief DAC channel selection enum.
+ *
+ * Enum for the DAC channel selection.
+ */
+enum dac_channel {
+	/** DAC output channel 0 */
+	DAC_CHANNEL_0,
+};
+
+/**
+ * \brief DAC software device instance structure.
+ *
+ * DAC software instance structure, used to retain software state information
+ * of an associated hardware module instance.
+ *
+ * \note The fields of this structure should not be altered by the user
+ *       application; they are reserved for module-internal use only.
+ */
+struct dac_module {
+#if !defined(__DOXYGEN__)
+	/** DAC hardware module */
+	Dac *hw;
+	/** DAC output selection */
+	enum dac_output output;
+	/** Reference selection */
+	enum dac_reference reference;
+	/** DAC event selection */
+	bool start_on_event;
+#  if DAC_CALLBACK_MODE == true
+	/** Pointer to buffer used for ADC results */
+	volatile uint16_t *job_buffer;
+	/** Remaining number of conversions in current job */
+	volatile uint16_t remaining_conversions;
+	/** Transferred number of conversions in current job */
+	volatile uint16_t transferred_conversions;
+	/** DAC callback enable */
+	bool callback_enable[DAC_CALLBACK_N];
+	/** DAC registered callback functions */
+	dac_callback_t callback[DAC_CALLBACK_N];
+	/** Holds the status of the ongoing or last conversion job */
+	volatile enum status_code job_status;
+#  endif
+#endif
+};
+
+/**
+ * \brief DAC configuration structure.
+ *
+ * Configuration structure for a DAC instance. This structure should be
+ * initialized by the \ref dac_get_config_defaults()
+ * function before being modified by the user application.
+ */
+struct dac_config {
+	/** Reference voltage */
+	enum dac_reference reference;
+	/** Select DAC output */
+	enum dac_output output;
+	/** Left adjusted data */
+	bool left_adjust;
+	/** GCLK generator used to clock the peripheral */
+	enum gclk_generator clock_source;
+#ifdef FEATURE_DAC_DATABUF_WRITE_PROTECTION
+	/** Bypass DATABUF write protection */
+	bool databuf_protection_bypass;
+#endif
+	/** Voltage pump disable */
+	bool voltage_pump_disable;
+	/**
+	 * The DAC behaves as in normal mode when the chip enters STANDBY sleep
+	 * mode
+	 */
+	bool run_in_standby;
+#if (SAMC21)
+	/** Dither mode enable data */
+	bool dither_mode;
+#endif
+};
+
+/**
+ * \brief DAC event enable/disable structure.
+ *
+ * Event flags for the DAC module. This is used to enable and
+ * disable events via \ref dac_enable_events() and \ref dac_disable_events().
+ */
+struct dac_events {
+	/** Start a new DAC conversion */
+	bool on_event_start_conversion;
+	/** Enable event generation on data buffer empty */
+	bool generate_event_on_buffer_empty;
+#if (SAMC21)
+	/** Enable the falling edge of the input event for DAC1 */
+	bool generate_event_on_chan_falling_edge;
+#endif
+};
+
+/**
+ * \brief DAC channel configuration structure
+ *
+ * Configuration for a DAC channel. This structure should be initialized by the
+ * \ref dac_chan_get_config_defaults() function before being modified by the
+ * user application.
+ */
+struct dac_chan_config {
+#if !defined(__DOXYGEN__)
+	/** Dummy value to ensure the struct has at least one member */
+	uint8_t _dummy;
+#endif
+};
+
+/**
+ * \name Configuration and Initialization (Channel)
+ * @{
+ */
+
+void dac_chan_enable_output_buffer(
+		struct dac_module *const dev_inst,
+		const enum dac_channel channel);
+
+void dac_chan_disable_output_buffer(
+		struct dac_module *const dev_inst,
+		const enum dac_channel channel);
+
+/** @} */
+
+/** @} */
+
+/**
+ * \page asfdoc_sam0_dac_extra Extra Information for DAC Driver
+ *
+ * \section asfdoc_sam0_dac_extra_acronyms Acronyms
+ * The table below presents the acronyms used in this module:
+ *
+ * <table>
+ *	<tr>
+ *		<th>Acronym</th>
+ *		<th>Description</th>
+ *	</tr>
+ *	<tr>
+ *		<td>ADC</td>
+ *		<td>Analog-to-Digital Converter</td>
+ *	</tr>
+ *	<tr>
+ *		<td>AC</td>
+ *		<td>Analog Comparator</td>
+ *	</tr>
+ *	<tr>
+ *		<td>DAC</td>
+ *		<td>Digital-to-Analog Converter</td>
+ *	</tr>
+ *	<tr>
+ *		<td>LSB</td>
+ *		<td>Least Significant Bit</td>
+ *	</tr>
+ *	<tr>
+ *		<td>MSB</td>
+ *		<td>Most Significant Bit</td>
+ *	</tr>
+ *	<tr>
+ *		<td>DMA</td>
+ *		<td>Direct Memory Access</td>
+ *	</tr>
+ * </table>
+ *
+ *
+ * \section asfdoc_sam0_dac_extra_dependencies Dependencies
+ * This driver has the following dependencies:
+ *
+ *  - \ref asfdoc_sam0_system_pinmux_group "System Pin Multiplexer Driver"
+ *
+ *
+ * \section asfdoc_sam0_dac_extra_errata Errata
+ * There are no errata related to this driver.
+ *
+ *
+ * \section asfdoc_sam0_dac_extra_history Module History
+ * An overview of the module history is presented in the table below, with
+ * details on the enhancements and fixes made to the module since its first
+ * release. The current version of this corresponds to the newest version in
+ * the table.
+ *
+ * <table>
+ *	<tr>
+ *		<th>Changelog</th>
+ *	</tr>
+ *	<tr>
+ *		<td>Add configuration for using 14-bit hardware dithering (SAMC21 support)</td>
+ *	</tr>
+ *	<tr>
+ *		<td>Added new configuration parameters \c databuf_protection_bypass,
+ *		\c voltage_pump_disable. Added new callback functions
+ *		\c dac_chan_write_buffer_wait,
+ *		\c dac_chan_write_buffer_job, \c dac_chan_write_job,
+ *		\c dac_get_job_status, \c dac_abort_job and new callback type
+ *		\c DAC_CALLBACK_TRANSFER_COMPLETE for DAC conversion job</td>
+ *	</tr>
+ *	<tr>
+ *		<td>Initial Release</td>
+ *	</tr>
+ * </table>
+ */
+
+/**
+ * \page asfdoc_sam0_dac_exqsg Examples for DAC Driver
+ *
+ * This is a list of the available Quick Start guides (QSGs) and example
+ * applications for \ref asfdoc_sam0_dac_group. QSGs are simple examples with
+ * step-by-step instructions to configure and use this driver in a selection of
+ * use cases. Note that a QSG can be compiled as a standalone application or be
+ * added to the user application.
+ *
+ *  - \subpage asfdoc_sam0_dac_basic_use_case
+ * \if DAC_CALLBACK_MODE
+ *  - \subpage asfdoc_sam0_dac_basic_use_case_callback
+ * \endif
+ * \if DAC_DMA_USE_MODE_SELECTION
+ *  - \subpage asfdoc_sam0_adc_dma_use_case_dac_in_dma
+ * \endif
+ *
+ * \if DAC_DMA_USE_MODE_SELECTION
+ * \page asfdoc_sam0_adc_dma_use_case_dac_in_dma Quick Start Guide for Using DMA with ADC/DAC
+ * For this examples, see
+ * \ref asfdoc_sam0_adc_dma_use_case
+ * \endif
+ *
+ * \page asfdoc_sam0_dac_document_revision_history Document Revision History
+ *
+ * <table>
+ *	<tr>
+ *		<th>Doc. Rev.</td>
+ *		<th>Date</td>
+ *		<th>Comments</td>
+ *	</tr>
+ *	<tr>
+ *		<td>42110E</td>
+ *		<td>09/2015</td>
+ *		<td>Add SAM C21 and SAM DA1 support</td>
+ *	</tr>
+ *	<tr>
+ *		<td>42110D</td>
+ *		<td>12/2014</td>
+ *		<td>Add SAM D10/D11 support</td>
+ *	</tr>
+ *	<tr>
+ *		<td>42110C</td>
+ *		<td>01/2014</td>
+ *		<td>Add SAM D21 support</td>
+ *	</tr>
+ *	<tr>
+ *		<td>42110B</td>
+ *		<td>06/2013</td>
+ *		<td>Added additional documentation on the event system. Corrected
+ *          documentation typos.</td>
+ *	</tr>
+ *	<tr>
+ *		<td>42110A</td>
+ *		<td>06/2013</td>
+ *		<td>Initial document release</td>
+ *	</tr>
+ * </table>
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* DAC_FEATURE_H_INCLUDED */
+
diff --git a/atmel-samd/asf/sam0/drivers/dac/docimg/dac_block_diagram.svg b/atmel-samd/asf/sam0/drivers/dac/docimg/dac_block_diagram.svg
new file mode 100644
index 000000000..0b064257a
--- /dev/null
+++ b/atmel-samd/asf/sam0/drivers/dac/docimg/dac_block_diagram.svg
@@ -0,0 +1,218 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   id="svg2985"
+   version="1.1"
+   inkscape:version="0.48.4 r9939"
+   width="500"
+   height="290"
+   sodipodi:docname="dac_block_diagram.gif">
+  <metadata
+     id="metadata2991">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs2989" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1397"
+     inkscape:window-height="1023"
+     id="namedview2987"
+     showgrid="false"
+     inkscape:zoom="2.168"
+     inkscape:cx="250"
+     inkscape:cy="145"
+     inkscape:window-x="0"
+     inkscape:window-y="100"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg2985" />
+  <image
+     width="500"
+     height="290"
+     xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAfQAAAEiCAIAAACA07fvAAAAA3NCSVQICAjb4U/gAAAgAElEQVR4
+nO3dL5Ta2t4+8Ce/9RMHV3eQu4pUlaqOG1yD46hBjroEdXGXUW3VcF2OIrxqJKOKI3UZN68qVc2o
+ieS6urmOVwRCgAQCE/Jn5/msrq6ZsBMCAw9fdnZ2lMViASIiksv/y3oHiIgoeQx3IiIJMdyJiCTE
+cCcikhDDnYhIQgx3IiIJMdyJiCTEcCcikhDDnYhIQgx3IiIJMdyJiCTEcCcikhDDnYhIQgx3IiIJ
+MdypBFyzoWxomK6/fPmzx9IVRdGt3VV0a3crqxs272hjAVFWGO5UDpfD58WarYvV8kuMLXfVypo4
+l5chqzwPnabu6Pbyl8v1TdNFs7NKc9e8HrefTS29R0UU6ehwDyld5HWOZ5xP9Ssl/TS326qf7tbE
+abfVkEZCa186rhtyizaaKk3dwjLa7/xPDaJssXKncnjovg18QgS7TrTWKt2tidPWRNjarjV+UEXo
+TdDMKQamaw0Y7ZQn///E9aYvie5G/jQrWe/BivRPdXyv+aNcDp/tiOjVWmrDcnXdmTjtvsBstfyh
++1bprn7pTBeR3S2a2deVQf3ZDt8+URZYuRN5tftO3b7RTX+gJ32BWkRhT5QNhjsRtJY6vh5E9ckQ
+FRHDncphs899c/wjoLXUB6SQ7Wc4IEwUTlksFset4L06pe8IblYAHPvkJKssT3V8OfijvJIf7oV+
+FFQIrNyJ0uP132M1zjXr3SGZMdxLxjXQrGz8m1joVfAYbGSh2YAb2thZLnwMNu4BDnqVkMYUhhFP
+KTh1KCQVV+0WRm9jSbWDRwsXq/EgjxY+9SEAN6yxa6H2EWMDF8HlKowXAHANGNheJVHypaGiHN07
+SnRQKpV7aAHo1XqhBSMAw2/sxURYYWj0tpc8Aq6BnpHGg0pO9uXbhYbvgbN6HkfroA/XQmPCwpwo
+z9LqlqndYvqy/tdSARXtDh6DmeIVjA56FYgfy5afgWZvWRhOXzC8XW+qJTY2O7zF1zMWjOeWXsQ/
+3Wx/IkLDp9Hyg9Y14N7iYk9jAEDLhK0vP4nTtZDC1mPJ4Hkk2WXa5x5aMLoWcIvWaoKPCwNDLZMQ
+SU3wvZ1Gvm990Ho53rrF2ACA2QQN7UBjAFDRa8Eo2JekPPA/xZnpdFZphXt4ARhWMM4mEJtTNwkN
+IsZmuzf4XNSsCZZv2fTSCA2YwHVgA/WwqbNCVumhMdnsWKMD/FhnstO5ZdQt4xeAuwVjtX7KZj8B
+nR+BujIZic5meNjWXSf8YA5Q0QAmJkQ/8qN0V6uPr3+dbZckxFin1GQ9FHK3YKwKuJtH6owYg+p6
+3zD6wCoylq1vUf7x53oL33cOpUY1XtLwuZPOXhPRUTIfCrlTMAoN+ICJtux2f+zhewfTgx0FGjof
+MTaQ6CHVlIusra7YsxTvoodpxHO0e1NU42DCXxiYbq5S1L4xIqlk1OceLAC3C0YVxg/YH5YtvwLT
+eGnRMoEbTNyN+yrIsEgeZEuPpa87wsKup6esJ56x9OAcNDsNl5foiFydKEucWyZCitOYRMV6WZ7q
++BL4o1gd5dtfi5FXSljeLOzeNO+u2bjGXXDOd0tvTKDW+2ZoA9dsvJ31/amAd1cnylTWfe7Eg2xp
+ct2nyw9+H59mLqLT2DUHTrvfr48HvOA1FRHDncpE6Hft8ds4nSeuNVb7uhBa2xn4LYPzBr/tqlNe
+C5vyi+Eute1ZHHaXV9bnGcScDmx3yof9m83ZYQ+h295Xpf7srbJ5MdUga9BVWxoAobXhX0B7dW2m
+aQeXw2dGO+UZw11WobM4AACMCvBtdc7BN3xdBbE3HdiGnVkfgtM/bE35ELXZvNLMxWLaGU1C092a
+jDBqLiv0h4fuVteMZk7V7tuoDwaiPGC4SypqFgfvTOCeX3NqGK7OI3vNdGD7Npsnm+NfAFyGnY7r
+mgMneP3UkM8ArT+8HA04LIbyi+EuqahZHObuznIVT+7y5zjTgYVO+bB/s2eze2bvAZr5vOpzVxRF
+mbTCDqhat91aP7hc6w+dgbn5qSf0uyG614x3yqvMT2Ki86jWwzN6PoPQo1dbTQdmRJ815s/wblQg
+VlM+HNhs8k4+w0vo9iJ0T4Vu295P2mihhd6ma1sLA1tar06UC6zcJRU1i0O9BXuzh8F1UBPrX+NP
+Bxac8uHgZpMTrNY5ipQoCsNdUkIDbtYd6N4sDi0VogdxA8MPYgvdG7Q3x9LEnQ5sNeUDEGuziWKs
+E+3HbhlZqTB+oPcBI+/XznoWh94LjAqa3i8fMXxZXlFvTcPnDr7GuJOWCXs1EVDUZp9u0LxZtt+9
+aF98zUrwt9RnzTwvflBR4k6dfqAcsn3LcfqBbZv5LhOGOyWOlXskvt/yabFYcJI1ooOODne+oyhz
+3ouQEU+0Bw+oUlF5x1RL1U9IFB/DnYqNlTtRKIY7EZGEGO5ERBI6eigkpYa9yaH4iiWKg5U7FQmT
+nSgmVu50WHAul2z3hIhiYuVORCQhhjsdwK5/oiJiuNMRGPRERcFwp314ij9RQTHc6Tgs3okKgeFO
+kXbLdpbwREXBcKejsXgnyr+jp/wtzxubVWroM8CnhagQWLkTEUno1CsxyX3tN3kv50ZEJcHKnYhI
+Qgx3IiIJMdyJiCTEcCcikhDDnYhIQgx3IiIJMdyJiCTEcCciktDZwt010Kys//WMzZstNBtw/V8d
+9Cob7ZsVTJyQllGbdY3Nu7DQ7G03blbweJ4HS0SUM6eeoRpH7RZGb/nzpIEe1r8+WvhUx8yBUAEA
+KowXAHANGIFmIS03N2tUMNHQUhEl2JiIqDTS6pZpmcBkVYA7GM/Q0mGbh1Y72PIj6tHJTkRUVqn1
+uasQ/4s5AMC1IPoQKhqzVd9LhNCWTzfrbpbvh+422NiwXv8wiIgKIYsDqpMbXGgAUG/B3hu4oS1r
+t5i+LP91gMneLQQb97REdp+IKP/O2ee+wYH7ES0AFr4D3wPTLj72cBG6SljL6maTan3Z1SNUPLEw
+T1joBVR5VVWiQkircp/oQAsCmAzQ+bGupj938BgRynFazmcQAgAgUButB8NMBqiJczwOIqJCOGe4
+B/u77RaMHmBhVN8Y3HKhwx0ExkT6IlrOdzbb8sfbfMPX1fJRnYNkXs8rz4PX3mLZTlQUyrFv1OVb
+vQQX62CEIZDmwYjnM0OUfzxDlfbZLd6Z7HmgKEp5rmZMp2G4ExUV8532YLjTAcFSnWV7rgx/XTHf
+KQrDnajAvHxnxNOu1Ma5U4F5B1RZtufT8NcVAP6BaAvDPddyVZHlamc8jDOf30XD54Q87JahAsvh
+502G/BI+6x2hXGDlXgDem5ZCsTsiKJjvfFpK7tRwb1YOtyE6P687gkEWNPx11X13z6el5Fi5h+O7
+okCY77tYwtPRfe6LdGVypwu+GYqGI75DsRe+zFi5kyRYv4fiQMnS4mgZkgfr9yg816mEGO4kFeZ7
+FHbRlA27ZUg27J+JwqOspcLKnSTE+n0PlvAlwcqd5MT6fQ+W8GWQx8o96sgPaw06Cuv3/VjCyy2/
+lftW2cWXIJ2A9ft+LOEllsfKPepFxhcfnYD1+0Es4aWU38odgVcbX3b0GqzfD2IJL588Vu4Ie3nx
+BUevwfo9DpbwMslpuIOX7iTKgp/vjPiiy2+4EyWLxXtMw19XLOElcHS4KynK5E5Dd2DFNRu6FfjF
+a9Yw3ROffkoX8z0+lvBFx8o9PktX3nYfVr+55nVXnS4Wi8Vze3zNeC8K5nt8LOEL7dTRMtOXRHcj
+f7YvNeWajUlrMV0o35a/W2MM7zQAEFob15ar6yLlfaTTlG/wzHzc/t0Yq9WT2vvXdQKPfhUKK/eY
+hG6bWtRtQn2YOanuDr1Ouep39/f8de1ZwhcRw51KSpJ8dx3j3X333X333aq+sGfdtuOls/Plfmz/
+tvs/n37+/Np25piP383GX+K338Be+GJhuCfAdZ3Lupr1XtDRip/vv+3+z+rwavjr6vO/fv/9JbRA
+f9MYvK+9f/952c3yhMZR7Td4+Y6clfAJDZeQDcP9REJrozuwAMAadNHWRMY7RCcpdr678xneNxoA
+UG1Ua/fzGJ2DtbrX/lq9jNV+W567aHh55CCG+6mEfjd0moqiKE1neMeDqcVV7HwPev/Hm0TaxJDD
+LprFYnFwZ/KztylguB9FGy1G/mFVodteLWAz2guuqPkuqnX8tG0AmNvzJ/VNFYD4o/bzv78BYD67
+31nl56r9nfNwVVUPto+W5xI+VNkG/OR64rCCKthryHWM5s+njUW1f/7aPoYwv7O//htX00ZD7Fk9
+ZEVgPn7nVNcrzsfvHh4iG2emmOMj3zQG743mfRcAav/8VQUAoWpX93+/ewJqV//6cw5AvKn+fPja
+xufxG6AG+77bjdn+8OjJXA2U9Ir3zHcjJ45+Ipaf0uUY537Cq+S0V3nUWt5y/yjWWbiO0ZzXA6kd
+luO/7fZsrmIu6r3rwNd6e9bt/vZbzu/sr/9+sxnZXpT/6bdxvtxb4lPv+o3z5f5vXA6/xB57nYru
+u/tcRUPSL4z5+N28fp7P1O67e5w53/c/G/7y0HwPtgnbjms23s76i8B4Z0tXBvXnAn8tZ7dMkk6u
+X/zXXB6+4VavG/+8+s/9XWAohe3eo9povHn6txs4BDcfd58uh+vPgOp1/er9k3X3e3nznd199zC/
+qtUCq8zu/6w33gBQr9/HOwCYqrz1z+TqhbFfCr3wMZ+N3c73GG9Mofc7o4m1XmBNRp1+cZMdWYa7
+a6BZWf/rGZs3W2g24Pq/OuhVNto3K5g4YS0zdnLlEqw7ktudE6mNGgLJ69hPNa1abVQv8TSzV0vd
+3/PV0IuVN43x1bq0F+rnX1e96z/Wt7u/53hTFd6tb6r4PXfP9RBOlsN8Ty7iq+1zdoWlMFAy5rMR
+zPe4JZfW+sfom5/u1mTUaUWdtlgMmVbutVtMX5b/GpONfH+08KmO9WmfKowXTF8wvF2v1VLDWmbm
+9S/oRN/GryP+CCu3q41//flgryp6979Pe4deVBvVfPW5xJa3fMfmZ3/e9i0oeJR1z36+8lHEeTa8
+fD/my7T2V+d/lrW7aw6cYb/Y2Z6fbpmWCUxWBbiD8QwtHbZ5aLX4LU8R/4SIYJnwSsF7P8eDOtb8
+znm4Ur2+l2qjWrt3bDfbPUqDl++5kvVTcoRgCb/nsaTzbMT/Mq31h87AdL2Zo4p/6kpuwh0qxP/C
+KwpdC6IPoaIxW/W9RIjfsoCyPLK3rsp/O9Z/cP/Q9c5xb/58wn9m9m8gOIROTuc9jk05JLQ2xpa7
+le3+3N6KbsE19eUUsMuf1rcqykWuZofNT7gHTG5woQFAvQXbSqblSeKc8OZFcMyW+zeydb+JP5z4
+HPsJ3qBpdz77Wfvnr6vh6t/nf/35ZM3nAES1/j7QBe+t+OW+G35SO4DNfvZg/3sueSNnEoHXvUL8
+Xdpdss11jK05YXaXnJ83cgbRj3r/rYk8G8qqQ+aYMl9obYwHg7G6PpTqmtezvnc/z/WBvpMyQrcX
+i+dhZ/i8WDzm6gBsfsLdgfsRVQAWvgNfK2hW0L3B0w0eo1aJ3/KMlCTG1QZff6/f2ivN7+y/72v/
+/FIF4Nz9xL9E8BBc9Vq9XJ4I86ah1x66tt9LM7+z/77/8+p6T097tb4ah+Pc/XzyTqLJpZyMifS7
+IA5k+h5C7R0x2e9red/wcJ4CJf6zoQS62o/Kd6G1MRqpgUOpzsz/TWhtzGan7XsGcnMS00QHWhDA
+ZIDOj+XBUgCPPTxay/J8e5XYLc8mkWT3ZZcm/7lv3gdOTvRPL5rP7v+sT7cOmlbrV/jbnrcbVTTq
+w6ljrNc9fF6S+uXy8t1D9x7rk2jyJyfJ7om1J6tTyWpXNeCP5ZK7/1bvnx7e/1lDtT1Wf3+5nzWu
+2g14Zy1g0GhgdQKaN02Yv8rViecfBAv2E1aPI86WlZ2DqIv4JzcJ3V7owQVq3RlY0DR4XfGtPiYO
+IABn5iDXh1wzDfenGzRvlj/XbmH0AAujOqaBfLjQMdbhahBbK8dveS4JHuPKMkqE2vsVFcjVdlj+
+ql+uhrFWD21Qbf+6ap+wn2kpXrKv5obsNTC/s786qz/Z/e/q9GoIx+gDgNqoLT+S3fkM1bb4bbfn
+9elVT2B+Z4/vqr3GahVx9H6mEOsxN76b7P66p5ViQr+rNxSlCQCd6ULXrMnynd+ZLsSxW0tTduEu
+epj2dpZqmG59GKow7I21jHgtU5GfFKBE5CrZ43LnM7xvNwBvOJPfK/y+qgqsTwFpVC+7c+dL9Y09
+h1av4r/2z/88+N+6rv67XuVI6SR7HFHJ/jpbxbxmLhbbg/OEburIm9x0yxRNsh0ylAeFTPYjVOtX
+DzNbVC3UB2+A+XY3mnv00Kf8xHocJxfvBZWfA6oFU56XSEkUONm35oaMbqhev5+bsxm88vyP6mqw
+k/Pl3rgrfLLHKduPHDxTbKzciYqc7EBwbsjaxkw+O0S1jp9zvVHdXAvv33/+8gZu3AGTeYt1X5z9
+KU++c1bICKfOCpksJYVZIUsvhWRPvDcgwxdGIsmebOf4aWGd+bv73Fi5U6kVvGZPWwrz+qZDgodw
+EMOdyovJHl9uu2KQy13KA4Y7lRSTPT5pCvZSYbjnwnnG51IkJntMeS7YaT8OhcyFRU6mcS8HJntM
+55slhlJwauXerCS6G7Sd73w7nQmTPQ6/YKfiYrdMpEwigCX8WTHZ42Cyy+HocOd7w8PwLRwm+0Gh
+sV6qU/Zlwj53KgUm+0FbPex8uoqO3TKvco7TDoNb5veDRDDZ99sa6bj7qmPxXkSs3PPCf0dxcEKy
+mOz7hY5h37rSRdr7RElg5Z4LHCFzJkz2PUJjPerLIov3wmG45wLfNufAZN9jz0mnoZcxSmOfKFEM
+d5ITkz3K/rkE+KRJg33uJCEmexTOElMerNxJNkz2UIz1smHlTlJhsodispcQK3eSB5N9F2O9tFi5
+kySY7LuY7GXGyp1kwGTfxeek5BjuVHhMsS0s2AknhHt5Zjvhe6MQmOxb+ISQh5U7FRiDLIgFOwWd
+Gu7Tl0R3I2dydp0pXjwhCoPMx8852sLKnajYWLBTKIZ7ruXkHRucjjjbPaEtLNgpytHTeC7f5yXo
+ltn/zJRqkl6G+yslPl9uOn+R873IS/X2yQpPYqIDguOjyjNWqhDKE47HXDLe0pWG6QYWuGZDCdi8
+0dL9G3QruR3OA4Y7HVaeECmQUv1R/KtOHo54a+J01Jnlbiy8HD4vlp7b47fLfHfNhjKor26ZoilX
+vjPcaZ/Qy2lmsicUVKpk9/iXn9wb8a45cNr9fn08iIppod8NMbZcwLXGGN7pYnmDZj4/t1Q34d3O
+UEYHVI0Kvns/dTA1AAe9D3jabPOpg++jjSWfX1A1YABGb2eLFpoDDG2IM+1xeW1dTpPhTkk54VDE
+Vr5vr+5aY7VvC+G2nWvT1fzg3iCE+jBx4LrjB7UvNm7QjtqZnEu/cnfQq0D8wPQF0xd8Bpo9QIXx
+gukLhreo3S5vaon1z95NX3czfeXRwqc6Zk6KD0R+ey6nmfKekKyUkwRXD27NGnTVlgZAaG2vOt9D
+CPUcjyg/Ug931wJu0Vo9rRcGhhrcV27UwXiGlg7bfOWGKMj/InxwIVEmNl+K1mSEUVNRFEV52314
+6EZ0zbiuc1lXAbV+6bhucP3tQ7HFlnq4zybY+sAUWmRfytMNmpXlv+4NPhvhzVwLog+hojHDhMU7
+Ud4tTrK7heAS1xw46+Omi8W0M5qEpLtrXnfR1oRX3nev/TS39Oao0w/vySmk1MO9Wj+isd8t8wno
+/MBFRLPJDS40AKi3YMt0uJuIloJD+8O+O1q33dpGNGv9oTNYRvdD9+2qS+ftuP1se+2Ebj+3x6tb
+mpguTJk63VM/oFoVcB0g8BwaFYgf646aUL1vaH5A9QXV3dssfAe+B2aDeexFfgwQUQHFOOlJGy22
+klnotg0A0O2FHrGW2HNb0aVeuQsNuFl3njz28L1zINkBQEPnI8Zh3TKTATo/1sddP3fwyOKdSCo8
+0nOC9IdCqjB+oPcBy1GO3lDIGFom7A+YdPA0QvNmubD2EU91TAOfDRc6xjrc6H58IjqEA6IkwLll
+wsSe8rc81USak4HsJkvRn+fE55Y5K/me/3LiGaqUL6wZs8XnXxqc8jcSqxUiT7G+eZCH4Z53uaqk
+stqZXD0Jp5HgIVCxsFuGiA5g2V5ErNyLIfN3V2oHVEMr3Mwf/isVqFuD3zCkwcqd8qUoISir0BP9
+s9oZeg1W7pRrTBai07Byp9zxA53JnhWeESoBhjsRkYQY7kREEmK4ExFJ6NS5ZUogJ32OaU7qkp/d
+yMmjTkqBhkIGSfZXKBtW7uH4giaiQjt6KCRTj4go/1i5ExFJiOFORCQhhjsRkYQY7kREEmK4ExFJ
+iOFORCQhhjsRkYQY7kREEmK4ExFJiOFORGuKouzOHxW6kHKO4U5E23ajnPOOFA7DnYjWdkM8Ts3O
+uj6HGO5EFCKY13vKdr/HhvmeNwx3ItoQswdmqyOe/TZ5c/SUv+X5fOaLlQgxOmr4Tsmno8N9afqS
+6G7kTLOS9R4QZWmxWISWcYz1Ajk13ImoTBjrhcM+dyIK4cW39/9W3zqTvRBYuRNRuK3OGWZ6sTDc
+iSgEY73oGO5EtIGxLgeGOxEtMdZlwgOqRATIluyWrjRMd3vRim5ls1epYrgTlV3wXFNJBsNYE6ej
+zix39btrNpRB/dl7dIspmiXId+XYP+TyRfDKk5iMCr57P3Uw1dH7gKfNBp86+D7aWPL5BVUDBmD0
+1gtdA92b9a+1241bT5a/k5gyf795f/fUdiPluzs3RTn6jZbsvfs/b+1G4tX6+cr/Y14Srtm4xt0d
+rgfCNjV/ga0Lv4VrAZoQkZuQQPp97g56H9D4gakKAI89NM3lR4UbyG7XgBtIatdAt4ehCNleMNCN
+CiYaWmoiOypNslCZbZ185H/MnCOFo+4rEd64zFgR71pjtW8L4bada9PVdOFa4we1LwJNhNCS2rHc
+Sr1bxrWA23X+XhgYanCT2vpH1JNJdiIJRE0hcI5OmBRmnfJ3df99WYOu2tIACK2NseUCQpQxFlKv
+3GcTiP7GkqiP0KcbNANdLp9fAONQs49oJbGTRLJL54tp4v1R/teO6BLemowwGil+r+7A0k21fum4
+LiD8RroyqD8H+mkklHrlXq3HbVm7xfQF0xd8Ajo/cHGo2fQFHWAi/WESKiQlC1k/aOA8Dzy48a27
+c82BM1wdOF0sFtPOaGJBaG10r/3RM5beHHX6Uic7sgh3AdfZWGJUMHEiWgMAet8w+oDHOBuP/clB
+RMW3U7lbt93aRmpr/aEzMF2h28/t8dvlh0MT04Upfad76t0yQgM+rA97PvbwvbM8uBpJQ+cjxgYO
+DoSZzyD0hHaUKDFZHZyPKt7T3J8E70s5fBBYGy22Qlvotr36YVGqdEh/nLsK4wfsD2hW0KzgKzAN
+60nf0jKBG0xcPN0sV2xW0DMAbCyxW0kNlSGSQGgCninZz31fMZKdNmQ0zj3nmhXwBbRJOf/AcyVw
+8C14d0qmg8QlkGYsnu++UngFSoZnqFKO5OQYoGT88Y4pJKN/R4nflySnzqaI4U55EfrW3VO252pM
+SP6lloyM4JxguFO+xAlrZjrRQQx3ypHdmU92lzDWieLgfO6UO6HxzUwnOgord8qXYKm+da45EcXH
+yp3yi5lOdDJW7pQ7HG5B9HoMd8qX13fCsN4nAsOd8iORWD9/sgcvzumaja3LtYVcupMoE6dOP1AC
+7BwIOuvJ3698UXnX6An++uo9imbpjQnUet/0ph60dGXSWs8wuPUrUXZYuYdjsqcjkVrb38L5z1B3
+zYHT7vfr48GyXtda/xh982t3azLqtJjslAuckoliSbxyz/9XwJAH65qNgbBNLXi95XWxvnMVZqIM
+sXInimv34pzwrwYBuNYYbU1kuH9EAQx3KrytEnuRkJ37sSYjjJqKoijK2+7DQ3fZNbNM+q1sd82G
+1+fkHXDd+pXo7BjuJINgHJ+pwyf84pzAMt0Hg7G6vr6ba17P+ovFYrF4rk9Md+vXc+we0Rb2uVMs
+ee5z351cbHfhq1kd5dtfi1HgaGmgi901G2+76jQ4akaHuR40s/UrUQoY7hRLgcI9D1ZHXpc/3dUH
+wV9t5jydH+eWIUqe0O/qDUVpAuhMF7qAGvw1672jUmDlTrGwcicqFh5QJSKSEMOdiEhCDHciIgkx
+3ImIJMRwJyKSEMOdiEhCDHciIgkdfRJT/mdqTQpHTxeUovDsDSJW7iSRc15mz+ooHcs1GxvzOlod
+pWOtZ3xcW11qzzUbusWr8VEWTp1+YPqS6G7kTLOS9R7QcdK7zN7lpTMwXS14RQ6h2wsduxfrsHSl
+OUJnCqH3O8rEMjV/XrHJqNNfCBCdDyt3OsJ2gfoKye6V98P5L7MHoN1vj68PV92u2Zi0FtN/YAHw
+anyUAYY7ySPBz549Hz+qfhcj3oW+Mfej9lfnf5bTv7vmwBn2me10Zgx3iiWpyxtFX+eoQESseN/E
+q/FRyhjuVHj+R0V6Hz9Cv2uPB0ddMS/8anxE58L53EkGXhYrZ7kGUzih96E0/wedv2KvobVxPRhA
+7dvijDtG5GHlTvLwKu7ED9hG0Mxp56gVhNbGaKTyUCql4ujTPZZvmxIMhSx4v3DeJZi//EsR7WLl
+TkQkobTC/bGHZmX5z/COQznoVdYLvX8TBwBgodmAi8hmRg89I7B1C81exL0QEZVROgdULXwN9OQY
+FUx+oKXCeAEA14ABGL1180cLn+qYORAqENbM+znmvRARlU8q4e46qIn1r739/fUOxjP0TBgmWiER
+ntC9EJEkTjt+I/2hmlS6ZUQPjclmx0s014LoQ6hozA43PvleiIikllafe8vG9AXTF7gf0KzgMbrl
+5AYXGgDUW7CP7DePfy9EJB3ZT40+TuonMfVecNHDo7VM8G0WvgPfA1oo778AAAKjSURBVJMyPvZw
+sdNKqHjam/sH7oWIZOOd4rA/vr0GqZwGkb1UKvfHrcEtgBDhLScDdH4sq+/pCz538Bga4gK10bow
+nwxQE0fcCxGVT3SmR0+4vzNXv26FLFzOzb/b2Nxaoqc5hi+VcL8w1r3hzQoetYhBLBZG9Y2bLnS4
+g9WYyCAVxjd8XW1wVIfRi30vRCSng1V5RF0v9H5nNAkErzUZdfrLifkvh89+n87z0Gnq1tbCxWI9
+h//mclPbWOKvnY60umVaNloRN4nealyjhulWL4oKw95p5jfeGQ+z516oHA5+MSe5RXXOHHhhaK1/
+NL/5l1OxJqNOy0x834TWvhy7LiAS33QYnqFKkkhrShnKu936PcZHfvSE+w/dt363ytuuOjW1rYXB
+3pbg8p0i3bXGD2p6ncUMdyo8P9bLNhyCogTzPeaXucgJ91f9KtMOLofPyyuw7Ha/YGe5tzQQ9/5H
+QzoY7iQDxjrtOu7L3KEJ9zVzqnbfHt1nvvExkGK0cz53ykqyI9LYIUNb/BdY7E/9gxPua/3h5duB
+2b9Lah/Pi5U7ZYblNuXKwQn3hX43RPd6MNvqc1+NhcwXzucehvO5p+71pTf/XqUVWqH7Xe27fe5H
+VvRFxcqdcuE1Vby3LkfLkG93tExWe5IhhjvlSCIRn+wuUeFsFeaLwPV1S+XUbpkSkP5bW87Ff6Xx
+L1VywTSP6nKJ00YyrNzDSf+Hzz8ebqVj7UntEr6Wjh4KWcLniDJU2u/UdJo9ARU1M4GsWLlTAbCK
+p4NiVgDlKRQY7lQYjHja7+DLo1SvH56hSgXDjhqKwldFUIl6oIiIyoPdMkREEmK4ExFJiOFORCQh
+hjsRkYQY7kREEmK4ExFJiOFORCQhhjsRkYQY7kREEmK4ExFJ6P8AiPh3kkqHPTkAAAAASUVORK5C
+YII=
+"
+     id="image2993"
+     x="0"
+     y="0" />
+</svg>
diff --git a/atmel-samd/asf/sam0/drivers/dac/docimg/dac_block_diagram_saml.svg b/atmel-samd/asf/sam0/drivers/dac/docimg/dac_block_diagram_saml.svg
new file mode 100644
index 000000000..0ed3f88e7
--- /dev/null
+++ b/atmel-samd/asf/sam0/drivers/dac/docimg/dac_block_diagram_saml.svg
@@ -0,0 +1,1303 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   id="svg2985"
+   version="1.1"
+   inkscape:version="0.48.4 r9939"
+   width="792"
+   height="421"
+   sodipodi:docname="dac_block_diagram_saml.gif">
+  <metadata
+     id="metadata2991">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs2989" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="945"
+     inkscape:window-height="1005"
+     id="namedview2987"
+     showgrid="false"
+     inkscape:zoom="0.4280303"
+     inkscape:cx="396"
+     inkscape:cy="210.5"
+     inkscape:window-x="0"
+     inkscape:window-y="100"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg2985" />
+  <image
+     width="792"
+     height="421"
+     xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAxgAAAGlCAYAAAB5tlDmAAAABHNCSVQICAgIfAhkiAAAIABJREFU
+eJzsXdl54zqzrLnfHw05b3AqcghUGJbDEEOwUjHejpjO3AeggeoGKG/SWOZ0nW8OLRA7ty70gl9/
+/vz5A4fD4XA4HA6Hw+G4Av7vuzvgcDgcDofD4XA4tgMnGA6Hw+FwOBwOh+NqcILhcDgcDofD4XA4
+rgYnGA6Hw+FwOBwOh+NqcILhcDgcDofD4XA4rgYnGA6Hw+FwOBwOh+NqcILhcDgcDofD4XA4rgYn
+GA6Hw+FwOBwOh+NqcILhcDgcDofD4XA4rgYnGA6Hw+FwOBwOh+NqcILhcDgcDofD4XA4rgYnGA6H
+w+FwOBwOh+NqcILhcDgcDofD4XA4rob/fXcHron5NGN+nr+7Gw6H48oIu4Dj0/G7u+FwOBwOh+M9
++LMhTIfpz/Hl+OfPnz9/Xs+vfvSjHzdwfD2//glj+ONwOBwOh+Nn4NefP3/+fDfJuRb2zzOmAQi7
+6bu74nA4roS4ROwf93j97/W7u+JwOBwOh+Md2JQPRkBERPjubjgcjivCn2iHw+FwOH4WNkUwIgIC
+4nd3w+FwXBFxcIrhcDgcDsdPwqYIhmswHI4NYvFFA4fD4XA4fhI2RTBcg+FwbA9h+O4eOBwOh8Ph
++Ag2RTBcg+FwbA9x+e4eOBwOh8Ph+Ag2RTBcg+FwbBG+aOBwOBwOx0/CpgiGazAcji3CFw0cDofD
+4fhJ2BTBcA2Gw7E9uA+Gw+FwOBw/C5siGK7BcDi2B/fBcDgcDofjZ2FTBMM1GA7HBuH7YDgcDofD
+8aOwKYLhGgyHY3sIvg+Gw+FwOBw/CpsiGK7BcDi2B3+iHQ6Hw+H4WdgUwXANhsPhcDgcDofD8b3Y
+FMFwDYbDsT0E98FwOBwOh+NHYVMEwzUYDsf2EN0Hw+FwOByOH4VNEQzXYDgcDofD4XA4HN+LTREM
+12A4HA6Hw+FwOBzfi00RDNdgOBzbg/tgOBwOh8Pxs7ApguEaDIdje3AfDIfD4XA4fhY2RTBcg+Fw
+OBwOh8PhcHwvNkUwXIPhcGwP/kQ7HA6Hw/GzsCmC4RoMh2N7iO6D4XA4HA7Hj8KmCIZrMByODcJ9
+MBwOh8Ph+FHYFMFwDYbDsT2E4bt74HA4HA6H4yPYFMFwDYbDsT3E5bt74HA4HA6H4yP433d34JqI
+CJgQ4W6hH8QCzOcZyBqgSH8FoPm/zYNO/vaM1/lT6gy7e3t+7q0/DofD4XA4LuHXnz9//nx3J66F
++XkPDBOmuxOQ7hvzaUY8zcA4AecIjEkExTkAo5ichXyu8zcicAaVo78BXY/Xedd1xlPE63+vuCfE
+JWL/uL+7fjkcDofD4ehjUwRj/zxjGoCwm767Kz8K8TRjXgAMoSUX55CE1EI86O8zdB508ksedPJ7
+nd9cJ0zdEfH5HgX5iIff99gvh8PhcDgcPbgPhqMYzchKdyByEca02h1EIM3GNbLyLbMdiJSELLgG
+Em7Z+T7A1MP1j7X9cAaVqQY/JY3r935+op8/42lxHwyHw+FwOH4WNkUwPIrU51CE2iyURlrdjuYo
+58Mb53v12Po/ev4z/fB+XupnQCTtxf3iJ9Agh8PhcDgcgk0RjH9NgzGf5qvUI66+InSGLHQGEj6D
+CKFiStNJf6tc/ML5Xjtv9cP7efl8U/+dwhcNHA6Hw+H4WdgUwfjXNBjz84z5+eskIxR7fihhN5Lw
+GRshFbRSHppydqWchdveeStshwsr7Vw+XDhfzYTSedt+NOft+Hrnaz9Z81DPR3MeZny985YU2Pbj
+2JIGKA3FhfPQJnCRTKn09brf5yb6PhgOh8PhcPwobIpg/GsaDCBpMb6qyYiQFWyy4+8J6yU/lG1/
+VMJ+ylN8EbLPAZv9KJ+BfL4K29QnUz6Y8kBAND4N7HvAoVtV++LLQIQ0NOZDdS6kvO5nFdht+WDK
+A2Z8Ul7mDzJnpn2KEGXN2NK8Z98KLq+uqhCm2jecZc5CuUZAJjX3CvfBcDgcDofjR2FTBONf02Bg
+ADCEL2syygo6r3CrFfss9Ep+oLHpB6qbuFp9hykH42dgz4HqPFOdqHWxf4I6N1441/N5WKvT9J3L
+h07fpXzj88Bjtz4Wa+e4TnxiPkc0hEMRGNZgsGbjjjUY4R9bNHA4HA6H46djUwTjn9NgLFloHMKX
+NBlR9ku44GDcrvCTxsIK89Cr6R85Z89/qM4eCej0f21ctlzolI+d/BfnZa29a4+dy6z0p59OvjV3
+ioj7JT8Oh8PhcDhabIpg/HMaDEL4giYjrRAbkxlz5NVuyRcpvw11G1fyXSrXyx9MuV5/mtX4Tvle
+O9vr59vkDbCkhxy/7xXug+FwOBwOx4/CpgjGP6fBgAiPecyf1GQkATV2nYV7kYhsxKP3RkZaO16K
+pGTbt7/XjpciKdl2fno/G1O2C1oaNrOyvil3C/fBcDgcDofjR2FTBOPf1GAEvYb9CU1GWfvuhC0t
+q+AdElFJCEio7QjfUgfQJy/cj15EJ9Aq/ErEKhtxSQvh+TzNl424VP0i8mx2xhculG8iNr3Rv2j6
+14sIFcz8odM/RT6M5kNpPDrkJp6tpuQ+4T4YDofD4XD8LGyKYPyLGgyKY1TTPqjJsGY55TevgrO5
+jhL+qfVsctOsyJe+1vNqZb70A33NAI2uv6cD+T0YoTry+dxKja4kR5BfRB6nqb+u/Lfl2UG7CPeq
+n6h+G2zeRP2LnfMlCpaNfnVuzaN45+9ojuGs61s327pPuA+Gw+FwOBw/C//77g5cExEB0w1WY+Mp
+khgfPvf3gmJLLlb3X/m/rGvXFBY1Y9FkYAGmp+ni+JhUWOFT6lMkJK+Yywp6OS+/6dgzu+LybCbU
+S7f1xJV8auW/0x+rGeDyb/WX6/lUP1mYl9Cz5xSCN9p5tucprGyk0LYh/05H7bjNplGxW47P1+Pd
+wn0wHA6Hw+H4UdgUwUgi2nR1Hcb+eY8wiKlOXk0doUJ7phVz5JVuSpd9HJCFOdSV8HQexcG2/L8I
+fJQu+0Xkv+M5aSr0bg+xlAkAYtZkYACm3TrJKDb5VuBcEVxXSQMi5kNMfV2SaVFY2tVn9gGINv20
+z2dCv/3TjBlAWOYklp/m1I9lTsLzMgMIiKeIcJgMKQBwmDGLudPaOJYIUP1xDMBCNMGSjjzusNN3
+XhnnGYjLHlgCMNQ88RyB04y4BAAz4ikgjHOaO0TgFBF3EwKRDWAGTsCMiLAExJ2Qh861KZSz9qXe
+UfW8dhq/PwT3wXA4HA6H40dhUwTjVhqMVHdCEcPOWqwHsiBpxH0OSRqaurQJUK1HGz5JPUU7oVab
+K7HQLedf79BkBCRBPu50/3TtnFajGinNx7JPmpolk6wBiCfT0tOEKRMHG/I1YkY85dZ2AQHtKj6w
+B05krjQAOFXjpdK2aDBYA3PeZ/IAxN0xXRNDquIIxNOcHYtr/UpAHyZFXnDYp3PLERNiQ0DiCMTn
+XMNTxCTjOcRKJGQES70CiXCluYgAsOzz/FBfzlMhNvVK5CuT22GtSKv9YG1J9/b4dsTh+s+zw+Fw
+OByO22FTBONWGoxaf89oSKcKNeCUskYswmypQRs4vTfdGjVBpUn71L8BFzUZEQEYZwBTQx7KKnjH
+tj8agRVLpiO7I8KQai5i75IEaTzPmJ+mTLjMKvop5x/Syj5ejsqBPPlYHBGeqPPLnOoepkaDwI7M
+kPoH+VvXr/aGkDnZTXkcdaYS+cjahkE0GgBOWeOyphUZkPctCVWrNUbgBJov3VahpGPWdJxi7tNE
+aTPigkStjSmVJg/VJKvMuTmPTArvDh0tmMPhcDgcjvvFppy8bxlFik2bSD9A/2dtRiM6J1GRHI0B
+TVjelx6IPLSxgmpP2/RL+2RUJ+fWF6Psz8AOwySYKt8A6dGATAaEzEyYhiPCEwn6ihrVecUQivO4
+3V260IeRfvHqtqRLxCgV/Um0A239TEviWK9zHYdgqgTtTFeXhfNOGNk4QodalQ3uYPsu6XnueJwS
+8UnIxZkIkGh9UK8JXytFCPnuNecB3GVIWNdfOBwOh8Pxs7ApgnHLKFLVmn1dqI8lR+ykcV11Gzs2
+mGLC0KaDRmc1GGTXv5qeSca5jS5VnZW1gGpXwa2jsTW9Kb4mQE0bc14AGLNALP4MrD3IpkvYkZ/C
+CW1Y1TFUkjPy/EH1W9rFufpJAP36bcSrOseB6sp9NVcSQCUHi65P1TtQGdFy8DUiPwppq847Ejka
+TJ5CVKoZHe9pUWhpQzpAEcJozu4Urr9wOBwOh+NnYVME45YajFS/1ihUQiCinOgWYNJYSNLaDUlj
+TUjNZUclQiDrTjSxYs1G22r6y2oyAsSsh/UwgUKjooluVI7Uogi2AXQ81zqqQJzIRI1mFIspU+p3
+1oIs+86eEbH6bpy5Nd02r9ADKOZXuv5Zhc2VPSvAdeSrF855jsRcp2gXhCwAGPRYeW+LQFHEqrkX
+XSM7tyr8rRCUan5VwuCKKdqS65DrweSk2XyPQ+yaebpHuA+Gw+FwOBw/CpsiGLfUYFShmQV4rVVA
+SannYc6uaSZ0XjsSTWBA6QHINviW/GgSwmZWdsfvCNIMEEXSu0G3mgsxuSmkhH9zPrVvBqGs9Gen
+ajH/GUNdmV84nxaugxWKV3ayLuZRTf2x1K/2vJD5et5jft4jPu4xPz8gnrKT9XBE2E15TmPpqyZN
+3Jd8hbOJFqhfaR5m4DAjnvaY5Zj9K8odt4A0G9RO0YDwXUHHEeZObO6G+9cQuA+Gw+FwOBw/Cpsi
+GLfUYFhtBRtNRXPGxldi9HawuFymiodF67EYkXEw5lWLNsHqEg3xyTjNVediBXPWYHCPyLQmWDMp
+1mhIr5ggkBNxEXjFuXuHQnIwTPVcoxFAXZlnyKo+kaSAkDQVuX4gj2nIq/9ZiGeTsjJX0lc5in/C
+sqddtHUX9CzX1MAmUjb3kp3g5R/yUfnFQLWl6Swa7VH5W4UXhrmuxsztTnG/PXM4HA6Hw9HDpgjG
+LTUYCa35kqRrrQUbN6USoJxW45G0EGSPj2RSo300OCqUbVdrL8JwyQSrrloLydg/P6RsJMRbYV6t
+ftOO0tGQizJCZdJUTXvYiTjVPWftAtIeF0tazcciZGROoW5tpCdZzWcU3wY2QsvlERNZOUXMSwp1
+W+dQmxQVgrQ7Ijy9Ihxe0/HliCChfp9nHaFKXYE860WgFwdzUH4q93REeHlN/56OCIdXTE+vCIdJ
++5n0tCOMFR+ZxjGf5kebu90n7rdnDofD4XA4etgUwbhpFKki8KeWSshRgDQGuQeLNT7RfWIRL9ee
+7PdLWiy29aWWxRASpfnQPhZSZ0lf2LPCkLABmJ5eVd/aHrNhF82JTSt7fmghVptdUc1nmiNZvT/N
+SeQve1HAOESTyZVddSetQrBmSNnnIp7mtO/EQvWfIgnkusogGyEWQV3C4WbSUIhVboPJGc1UyOcj
+2OehmlZJX+udJOZTbZgAdW0We6YXX6wlf8XvhNPvFe6D4XA4HA7Hj8KmCMZNo0gNVSMQs8lLaW2o
+4ndELOckre1nz4/DpikjH6BoJUwEqyWqOlqNR8yCLZ+thOP18FpX7FcE1DaOldrdg/Z10C2TriRr
+CUgHNGQhW5yvZRX/6RXhcKwagxx1ijcslLbiCBpvID8NMv2R+neigciagpdjarPU3/dGqH4UMk6T
+h02kZHM+M/5QfDBSiFwd1jf33mqM1I7c0laHsEn5AcZZvTqtB1OnPVbNz32itxu8w+FwOByO+8Wm
+CMbto0hxGFoAsNoDuxcGi5soZYqYv/DqNBMFbiNSu0wRcruDbqs4Eqv+Mh3IeZeI15epkA+gNWmy
+x17IWJzFJKfOUwD6Jk2nvNP3TvZyiBR+VYReVLJCUaeSmZT2GQhF4JYZkd8SSYnqV9oUqrvUP+c+
+2HFUjUMN8Uq6ojHUFfZzcppX4XdHMX9DCpGrzKqq5sM6sOvfNbwvhKiVSFp1zEpzw/t/QEymTL/s
+9blTOL1wOBwOh+NnYVME4/ZRpPpaBKYAKCK97kv9i/w1ym7XRAbIgbuKoFGXXViorm0pM5xeuUIz
+Il7/e1V9BUTgpNXtngbDnA8IlQxIaxIBKR/nU4rEJJGcwpAF+RLylVbrmzCsMtYZMA7llropAjYi
+ay9QiUR3fwqaSyVoR8ST/EvRo/Q4jslpPM9ZGEJy1pboXOeYTLIOEnlKHL1b7Y7sn9EPyZvz5ahV
+UfYwOef5LYQNjd+FulvXnPLVRom4z528HQ6Hw+Fw/ChsimDcOooUUA2F6q8quItmoNcj1mC0mg3S
+MCgH7Sz0Ldp8Kplk9Tbm4/6s+YhETIfqcyG9rNGFSAhvesor7DwvvCqPFLVJ/BxOMTtsB4TdMTsu
+53xld2poYmO1JrI5XzZlUo7oilCyWRLRqsGYLPG4mBwsdTR1HMknBKe5jAO7I8IB4H0rcMi+GUsm
+Fs9z9SMZphzW1gj1fAc0Ggwo4hYwJQfzJSI+71P9S8y7eed63rEhot04sXHyvsedvN0Hw+FwOByO
+H4X/fXcHrokkpE830WFU45qYBPaBHHFZCzGIGL/mPsvmVW2AW52W0wcOXytCqa4/qr91v0LxEQGO
+h2OzSh1EM0E12GCzfR8MnhskwXvH2pVKEsoeExIFCQE4HJXZUTCmV0EEbfETKQIzSBORBe/iw1AF
+6YBXNDuM07Fgd6yCNgDsXrMmQ6/0cySm2BHe0/hre2V2SvlkjlTMm3bHdG3Ez8JoMCJFjJJdt8PL
+kepnk63e9WG9FaV3+i97mtwjovtgOBwOh8Pxo+AajHfXTfF4BqYE/ahRVoug8pc8WSSkkLRMEGqK
+/Kp9AKXX9infoqNKRUS8Ho7diDxFW2DGqwVWrl2LospISfwCzqFZlbe+CV2tyWijH4m2wzorA9V/
+IJadrxs/BOtnsHa+jKWSt7U62v7TOIo/Sq5RkRMgrvWB7xaaC0u4iilTMWHju6wXOUp5e2QiI/0n
+Dcwdh6l1OBwOh8Pxs7ApgnHrfTCsKFdSh54orkV0FmCFKpReU4Qqsclf8/NIZEJS8vmhbS8O0m7M
+5OJ11b6++DsYgZPDqdbWzCyY/LHslN1GM7LCtY2cZEOnhjwCJTQXoVtrA9ikin0seo7qvZV9vWeE
+FuxtHSr6EtdhNvmzc9rbDb1rzsR1NONnozAbIkCb8vFda68bcl3K0dvhcDgcDofjCtgUwbhpFKml
+iqTSWm0TYArBe2a0PhjZ1n+Zy5F3co7LnELSmnR9jtKKKKrbq/4XEceXdXKB0vcqcF7aZK8RaGk1
+X+U/w6zUV8LSmBeZ69anaNXkqruBXyf8ajREoPpndMyblLDf1rkWQUsRga6jep2jaLQlPNb3aog0
+IWvHYMdWImBVfVmdi8aZ/D7hPhgOh8PhcPwsuA/Ge+s2Wgr2d6hrxFnYVJvkkWC7C5jGKYnTQ0xm
+TPZYaFJEGEIJZavSc/n9773RLWgzLSDi+N9rOxiDQppWTIC6JMKsfscmf+7tioNxNFoPJhGrvgMX
+zrcajipAF3Mjmhl0ZzWfI+0Hm22VvnRMmEKH8LBGg/1n7NjROcocvXWs9Zix5fOqXqPX4OM9w30w
+HA6Hw+H4WXANxrvrBsRg6S1zJrsezV4TYQh51+6V40BHmN+DKU/9qpu8FTE2mUW9A9YUqaxwN3tA
+0Aq5Eexbk551X4V287qVNlaiIjWr9GZVfn0/CZBWpTV9KiQJ7BOjSQHOmiy0McGMiZM4nBsncTum
+4jsD3X4Ej1VrQ7SmaX3utb+Hnh+lpXE4HA6Hw+G4AjZFMG7pgyHiPJsjaf8Ldqpm456cdww36VsR
+ZNWGe7joc2Ehjs2NHwNrDewKOwnTl7QKnK/1Yaikg7UjEjGJiUzotFV+m9CuQXwyFN1qNR09IZv7
+xn1pfVMun1fkYUV7o/wzyj0DRQS0GRaht1HeihN5T9OkNFFc7x3ug+EGUg6Hw+Fw/CxsimD8DQ0G
+AGDRRIN9M8JSRW0umQTF6/etFZ0jXg/TxwVFQxoCiXUhn2+1B1W47dr429+rq+9mlT2PbN2voY1M
+lepgYR66//ZozbrKfPbK9Ey4Lpxf2WtCC/taC6N8KbrtGe+a92p3VpzJ1fUpfiq4y30wovtgOBwO
+h8Pxo7ApgvE3NBgRyUxJm0SRVX8R7GuOYs50A0dau76fNBcfa0fModaE6Lq2boVdEszVfhctIYhG
+Y6Go1ohVEyRNWNoV+Lc0Az0hvnGAPtdxr/lztMTmwvmueVOsZAiAJQ18Fe3RzoU1n1ojEb2N9ewc
+a03UncJ9MBwOh8Ph+FHYFMG4tQbDaiW0qF2FNBa/RRQEstnLTfqVIku9vnxCcwHy3LhgMnQxQtMF
+u/5VUyUj3He1DHQsM/7OqEldEjFqobo6jffb7IXSVUfu30rI3V57PE+xQ1Z6DuQ2EhZrMmKj/THH
+TOB6IYjVPN0p7rdnDofD4XA4etgUwbilBgPorKcvTCrYldsSjVtrMIDX/17xWVGsCK3vEHbXVvTb
+XaiJbHRW5Fsh//IxrBzfWrGvviMgB+46dzXl7ShVVgug7ohGe9KSkzU/idXN9+y8Ut/03VhxaYfu
+Sm87fix3rMG43545HA6Hw+HoYVME45YajFBs06tOgnf0FnE1aRNqPkkDbqXByD4XX8VZajNk4A3N
+RM+h2zpR93alXtvDot/eigYhEwYWsOuKPYo5ksyUJTprzuir/iQ95+yOaVLXr8JGuzLt9zffgzYr
+Y83I2r4cnahdb0WSqhqSO4X7YDgcDofD8aOwKYJxSw2G9q3Qa+kAaL8KIOR9MJQJ1Q2iSIUh4PXl
+4z4XFkIIepqFS7tgrzl+r4V6ZSOzUP6vSUm/vQ6JaFbfSeNg/CHWtCU9Pw0dAQqrkaIu+nOskZAV
+Asa7aIs/TI+8rGlGehGj1vYsAVqHdiZrdwn3wXA4HA6H40dhUwTjphoM+j9TmSKsDtXXouYm05Mb
+RJGarqG5AGgfhPX9HIQa1NX0NbMk0Op5PV9JCEgQbh2tg53pNcH5gkZC/25NbKTuRiPRkA89ll5k
+pmBISOwQLt73o5AUcwcJImz51iRKnLt75GhtP5HS357GprRzn3D9hcPhcDgcPwubIhg31WDQ/4GI
+sLA4XIlFKwpSf65shhKuZDpSTWxaR2C9/wWviscmPwv4RQPC5VmwbXwk+u3YVfqgNCT5SPtmXCY8
+tk4jpKs56eXXvxN5YG2E7pds6MfnbZjaboQnqwHpEb4LYWhlrvkaXAqLWzQ2wF3ug3G/1MfhcDgc
+DkcPmyIYt9dg1L/ioPQTUL4ZqK63lfJkW/k7RPW3iKu7Z69FH2KzqKIZ4LpZwOdzXafm9XRr1pP6
+zXV1CM/KWLor+8b8SO3x0dGiKMJD/VJEhvpqr/x6KN5WI9PbE6M19zL95jlaGX9jxgXc5T4Y7oPh
+cDgcDsfPwqYIxu01GPUvtvxPqUQklnRe6zeMNuOOUP0tjMkNC7wrq+u8v0NPAF/TRKztML3qR6D8
+OMwKfcd8qAnDuuKz0S1vtDCrG9TJcSWS1keOF8PTkrO7jTBV2lXX044hodyfa74kd4rgPhgOh8Ph
+cPwo/Prz58+f7+7EtbB/njENQNhdxzdB8PD7AcnPoh/CNCxao9EKdlk4HQKmK/ftGoinGfMph5cd
+ssi9IJnLLAEYYlrZNudUPqCbp6YFxCWmv5fkNC/HVDa1I2VlrkueBdnPhfqEtq5U3vY5YP/4kIT0
+NGKAaAo7jPMxQu9BUUjG7rVGEJN+qWMdK8/LW3/L+Oq8hLQzfM6j56vNr+egzn+dN+j5z9ekno+I
+p5hDHt8P4hKxf9zfXb8cDofD4XD08b/v7sA1kUTS6TZ6ghwZqrZTj8mEo0s98q+0on4tn4mrYwzA
+kkXqpYrcJXrPklMWEr+LKU0qU0B5krlNTAI/ZiSBmYRiyOp0Oh8XIgC5rLQbcj3FBG4hbZX0heqS
+PsU8hpDNrGpoV5D5FLK/CR1FVzGSHmdMxyn3tfTW9E9+w8xL/bvMUEmPKk8qGzCndmUezd82v61b
+QitLhLM6H4EiM9WyAQHh6U7vUYfD4XA4HD8GmyIYSfgj4e3q9esVciYQUH83JbITdDWpuieEIeC4
+ccFyPs2J4A1TEv4HpLtliJiQVvTVEfUu4uNxF66uIXNcxt0Sc4fD4XA4HF24D8a7606ICAgDu3AX
+t++UYakr3uD08z1Si38L9prZsMLsmZF+V8+NkueeN6TbKKL7YDgcDofD8aOwKYJxyyhSVRRNYqkI
+nU38n7K7t44NVMO4Or4L9RoGc/2i+rvuxaFc99PxTiOBORwOh8PhcNwLNkUwbq/BqMYyZc272MTX
+9nXeTDgojKvje1Dnn31p7F4mbSypUnqEk0SHw+FwOByON7ApgnFrDUaNDUUW+kN1kJVzJW92sg1F
+OPXV7+9ENY1ir4p27xK+lpIvImaS6Nfwb8N9MBwOh8Ph+FnYFMG4pQaDW9H2+5VWBLBxDQtGkfZy
+cHw/9K4X2sNGm0lxetpDwq/h34b7YDgcDofD8bOwKYJx6528y6r2klKaVe+lai+kR+X/o94bw/E9
+0I7cbMZm/Gk4lCxpNNwHw+FwOBwOh+MyNkUwbr2Td7HWH/ReGCXH0HH6zj3D+X538v5X0LhuL9oH
+g83gwqDT3Afj++Az7nA4HA7Hz8KmCMbNNBiy+7GKNmTD0bI9f/XVKAKq+2B8L2SXbXbaVkQRtDFe
+ABPKor9yH4xvQXQfDIfD4XA4fhQ2RTBupsFYRGsBVMffLJgu2hwqmUpV4bRQHt8H43uxIO/GDvCd
+ogjisGbi5j4Y3wr3wXA4HA6H40dhUwTjlj4Yqf7OHgoDr3JnYXRgf4t89H0w7gLK5CmnsNN+TzvF
+UaXcB+Pvw58ah8PhcDh+FjZFMP7OTt4RIe99ISk28pCKTpQdwt285vuh74yoCKM1h9LmVO6D8Z3w
+p8bhcDgcjp+FTRGMm+6DQXtaJHMpG4nI0ptst5+dhV04vQPkaxgRMkkqmgFmAAAgAElEQVSk2GCL
+0WQMVpPhPhjfBvfBcDgcDofjR2FTBOOmGoxiv2/t8rPAuURDOopRTcrnO3l/O4QYApEigeXrQ6Zu
+ilSkku6D8Z1wHwyHw+FwOH4UNkUwbr+Tt/G/YGFUNBXgKFJEejyK1F2gt7leu0t7OgrFcB+M74VT
+OofD4XA4fhY2RTBuvZO31lqEvI9CdRouwihFkZKSvpP396P1wTA7r8vVXbSTd7nuoxtIfQd8zh0O
+h8Ph+FnYFMG4dRQprbWIZDbFRjUx2+/TfguA7+R9B2i1UCuhhk242hpq2DdL/Ba4D4bD4XA4HD8K
+//vuDlwTSWCcbiICsldFLMKppLK/hT5fVr/PEWGYbtAzx0cQiQgmBMShvXLtFc95RycZfxvhm30w
+4lKpqQ5mrH11OIfnf3/+4ATS4fg04mmP+TRhennvlykmLf3wds7bImJ+nIHDEVPTl0vnbtun+5ib
+bWBTBCMiYCrC4bXrTghL3ZBt7fPJ9vxF6zFGZZTjuB6iEUD5mhRDpwHAgrJHSb1ali6yH00w5yNw
+1tRyDS40XQ/frffbjw9FAxnOoexpExARz+nZLneMn//4+R1w3B0Rdv7MOBwfxikWyeM9mB/3mMcj
+Xp++/3mLSwTOsaulvnTuVrinudkCNkUw/oYGIw68mpn8MDDQ2tyiV8TTDtJJMHVWfBvMh7khGUIo
+GMp0TV03MmdbIpEQdvxOd8D8PL/Zn+PL8SvDcdwZ4hhwfAIwigYy7WuDElHMf3/ldzxF7J/3mDBh
+2rmW1+H4CD62AJNlkt1t+vIhLPTdbRBw/O/1b/YGdzU3G4H7YLy77uoErDQVFD0KCAiDtucv7Nt3
+8r4Zji9p9TMM6R+GKV0r/j0EvkrmuhFl7PjPsL4j1Tk1R9FYHF+Orr24Mr57PsOZ7pQzIPvaSPAG
+//3J3zkiW9gFTE8B8/OM/fP+fRfF4fjhmE8z5lNnceyDCCNoMW3G/HuP/WnG/PiAh98PePi9x/6U
+tPXz4x4zADzv8fA40xcwIj7vc/6HdG6p5/a/H7B/nrF/TPXFZcZ+tZ2MJWLmOu35IeTomz3kNnO/
+32wLqT/zSfr4gIfHPeaSR+rrtYE35sbxWWyKYNw6ihQTifSrUg57vq55iw/GbR3Q/3Ucn5LWQJuo
+1evCBFEbtUm+atRW7qCFzaUoyhSsH0fSgji5uA2++gH+cvvsdzMCOOe/zyELznlFHsHPv+e80mBk
+0jFGTE8BOEc8PO597xPH5jHtJuwfk0C8f0zC8WcQz6iC+pJ18s8R2B1xfDli2gHxNCffgsOUfBp2
+E46HqXzR5scZ+zMwvaQyx3HG/rDHvKTzQNI0Ype1jHmBrt9OrvOwx3wOqb6XI447ID7PuU6kZ9xY
+GRQo7UZ8o6007mRhEBEkz5hJHI2h28aYDtPhmOZDzY3jK9gUwbhpFKmlajG0nT5MCsBr5dKvpMFw
+3BLHl2NazcnouZTK66q5jku9WqV0s2N7S0wCkgB83Dm52CrCuV57nGk1nlflRz/fPS/7xoykvVD5
+iXSMSZsRRuDhcf/txNLhuDWOhwlASILw84xfv35h/7hPwvw7oTQYYkHxNGHKWv3pKSAsEfM5a4MX
+IFlb5DJLxLxETIcjpqz1D09HTIi5H3kZdTfhuJtSfZLWbScTh3HC8WUqlgXhSfyuch/L97Iz1iHk
+89T+ypjWxz01Y1BtSfvnfH7IuQY3Z78W3AfjvXUPhUcnATPb8JeUJRbn72pSQyvd8nA7borj0xH7
+x32HSFQqqMmGmEbZ6FEUdhiio9BEBYiJXLjmYtOIYwSQfQNGWn2Xo6zajxfOq1V7ym9X+bd23v5W
+WoxIWoy0CIMxlEWC/eM+CQnul+H4Ih5+PSCOEX9e/nSWndLfoG+CXky6dn7CAKXNC2PAvMyIzxHx
+MeJ4qOa/a7AaDGm5wGoJBmjTpCzwx8MeeyA/10jagRF1pZ/70POfWEJNG4DpKWkZ5pw/nvuWBF0f
+jCXmNgKAuc3X1XwETGNbV5SFjaatTlrHd9PxeWyKYNw+ihQRB7LVr74YJLLmaFNFYB2rcOu4LY4v
+TDJsxKh83RYUgljSYM2rWlJSTakAOLn4K/ju+Q1n0kyKIJy1kiwY49J5TmfBeqTfWzzP83O2+Xsk
+LZVJQhUwP8+Ip+iBExxfQzZz3J/2ondWS00BM4CAuXyja3q1jODzsykv5+d31k9fl7G+W+IokdYA
+ZBMfnC9HWQsjAPEtKOSB5KDi65AF6gVKiI6SZ8wr99nROXTLX0qDamf/uE+WAcNUSdJzpDLyryOz
+Ke1G52/b/sJEpMxMmhsxz2zq6xEbuJP3FbEpgnH7KFKV8WqhsxIL5L9C0Wb4PhjfgZZk8PqRXB9e
+waDPwQJE2myvUgrSfDi5+Gv4blOZOMpbhQVhOqInKKPmt+VYsIb5vaYF+MnnsTbe2P5d5ir9np4C
+5lNM2oyXyRdoHJ9C2KX9FMKdacPm04xwnhGL5q4S9ePTK6ZdTrsArcGIxQSqYIlZAM/fP2P+E4AU
+wl38M6TeEzk6X6yz0/Zpj7gETP8dUWZ8mbFnAX/JZKOjdWh9MN5oP5tIRRXWNqa5EZNNmP6e8jd+
+jHhrjh2fg/tgvLvunlLUHoMRSlF75Dt5/3UcX44QBy5kR6/+9WEthqyMhHJNw2Kuu5OLfwti54uo
+/Qd6fgfWH4GP7IcwmvNv+S1s5bwaf6BzwfhohFLHdEikY//7Y7bpDofg9gFgPod4IpKNiONuwvHl
+Fa//vWLaGYF4BdoHg1fqOS3qNMTqIL2bMA0xhXsv/dpj/2wlljfq7LVNkajmw6yjNyofCIOuf8al
+9rNWiBy/42nGvIQyj2GIiAs5oS9Z4yFBKeTbf4rfvqi1FWyKYPydl0hEWNjxV1oGlAajnK9ChK++
+/X0cn3JkiLwyU5XZvIrC16yjuRgkh5OLfxFhJE2ljZIEkIBgztuV/d55W/5SfW+1d0/n5felKFOq
+LBENRb7ym3SICE8B+8eHT0fbcaxDnIy3ipsGgPkk4hKTBmMX8Ho+4vW/P5iepg9/W7QGQ1K5DhbC
+k/khTnMyYcrp02FCwIx9Dim7f46YniYcd2HF30IWEVbShLSUsLIz4m7CBKjwt21fuS6bvjYmahso
+be6fkXy48oLhVMadQ+02EllMplzLjP2jLwdfA7/+/Pnz57s7cS3sn+ebqEEffj9kJ2DWXrTKu6h2
+ipbf+eU2Jkdid1j8HuwfU3z9vuJ1LcKUtrF1cvF9ePj9gNe/vvFSwq9fDzi+QJvzgAXjfOewn8Vb
+v60/Ap9f89f4Sb/X5mV1vmDmE+1c57T5lJ5I98u4HmSzQwzAtDvmVd/tYH7eA8N0V+OKeVPXb2sf
+HdF+of2ertSKyEW3RdorA0+vOO4ut/meee/OjePDcA3GO9HTUIj5TNFgDNr4BgOVO9OqueOvQ8yl
+ApBDDrdapriwex5KOpxcfCu+W10deJNMIQCAEYbfWK1f016gU76nBZF6ub17O8/jekur02g/ojkf
+++eBLCTm/TJ8nfEqiEj7kExjwHzaJ4F8Q7hHDcZ3f0u6rUtI2Su28nfGydf2cpvv6Y9/5a+DTRGM
+v7UPhhI8B1Cb1XCqxiJyH4x7gWzGF9Qu3tVNv8TSJjOqCKRoUU9OLv5VRN4ksxABkDAM8rvgv2PN
+2/gl8PmVfLa+t9pYa7fXhvIZ4fMmTbXfSev6nFB9b/ljlLpXiIWUI58MjEA4JK3wr1/ul3E9BGCX
+CFwE8PD785u/3Rvu1QfDcS3ItfV3wT1hUwTjli+RuvFK1WVUni/r3aTZAOeH+2DcCViTwddQXzsi
+jKK5uCPVuuPvQkUZYUEZICE6kGBuV/t7mo6IRjvQSxup7l4at/FWu5f60uy+HdFqZTppvb6wgcEl
+fw3eD6PMJc1z0x/uCxB2AdMLvrQLsiNB7e8zAmGX9jGYs63+T8c9ajAc10TA8b/X5DPiuBtsimB8
+dxSpInQsUQmsAFyDcUcomgxke0wAPY2Gm0XdB757/mUzxlZQ7qyud1fve5oOKQPSKDBJuZDGZZs+
+mHaBFU0BOkI8j4HSGgfslb70xtvVtrwxPw2Zyr/B85LNTseA8JL2y9iCIPxdiECOlodyTcOYzdHG
+5AP1k0mcazAcjr+PTRGMW79Eiu6CdqxUpjTS9iB9IfMp12DcFYomY4C+duKH4eTibvDtPhjy7DYm
+REELyl0/C2tyZMkIoDUOOe38zrLNCn+uj82VlBYkEkkwQnwhFtaMy/pJrJRV4+3lNdqUXn6l4aG8
+loTR3IcxYHpJb9yH3w9wfBwBsUbay9ci5jmedsj7kfxcEucaDIfj72NTBOPWL5ES4nSoIUwDQhGA
+9C7QkoIinLgG477AmoyiwRjcodthMOa3ipgh8Sq+Epxzmg2z2tMUqPSOHwKAIuxfKrtmSiTCe6MF
+Ca0moSELXD9rQYgQrPlKNKZQ0ZzvzU+nD/a36kdv7tN+GWEX8OvXL/fL+CAiQlk4k0U6CU4SAWAM
+P1qb4RoMh+PvY1ME46Y+GGCCEFRaGGpatWYFQtljIa0+ugbj/iChLrPoVH0unFw4Mqptemc1XZn6
+wKzO27Q14dz4ISgSY4X/zkq+1XwoLQiXsUK51ZJYIsJleoSA2lWaD5Neztv5saZSvT6/1Q89prCL
+mF4m3y/jgwiIiEO+z8+0fDbW80qbkU3Svlu7+F7kpQGHw/EXsSmCcWsfDEA7w2k/i1hyFrMp2hEa
+Y3QNxp2i7Pjt5OIu8d3XI5zJf8ru04C44kPQW7G3Qjbls9oBGz2q2cSOzzNBsUSE+8fkg0mSJQbc
+fqfPjY/Hijai0VaY+hvTKTOmpp/cD6sxqX0IIxBeJvfL+ADqtyz5tQCZdJzlL2RtRjabeknHn+Jg
+X5f9HA7H38KmNtq71WY6daO9BCYV5aUsxGMJiEOkfCiv7mk33WU0oq3v4ur4AAbg9eV7NrRbQ1wi
+9o/779to7/cvHJ8mEs6h/RqaqEucz/6WciT4j5fy828pY0iOLd+tU/pn+vmu8qbPnK7GzL8789GM
+ydZLZVbb6sw7r02buuZTBBbg+N/RNcgXEE8zZlRNBaP5xqEu5sUzEE8p33T4+C7Ufwv75z2m4T6/
+vw7HVrEpgnHLnbyRX5xCIMpLt0Mo6t9kLjXibnfyjqeYVqHusG+Ov4glIp7mbxPk1/DdBOPh9wOm
+J6D6RFwiFlYQfoMUAFoo7grcl4T1ThmYsqq/K+1e3HV8rb92zJ35KKTljTGtES3bliUWTf1tnngC
+4sHDTV/CfIoAZoQxz9oZiKOQCLkXsEpCI4D4nBbRpqf7+47Mz3Pepfz++uZwbBWbMpG6tQ8GgEwu
+yBBrYB0F7w4NiPV2smu93w9blFUrthtnc4ofl37hyGUoPai6Pnp8b197578zn+nnna4+fjcimzd1
+fR5I+Or6GqCSDADKjKmck7qpjNrde830KvTrUP3omCrZMlzXxbLcP2saxX9bM69OW718am47bYlw
+a31T6J1r84RdRHgBHp73rqldgSyExXwPxHxt0uKYLKClaxaAcl3S32kBbXoKmM8zHh4f7s43g77E
+DofjL2FTBOP2PhhCJFScDbLujCV3fZ3lc+P9vuDKp6KstpoVxrJqdc/pAYFWiwOtGqt0poKUzxq7
+AWmn4GTTXVddA7UZqO1a16W+BugVwPAX8+m5asvdl0DA+G6zi6CiSIGEZSvkW+H/vUSChOr3RFuy
+bQJGmDd12Paa/q/0uVs251VpvT4HXX61rQ4h6/XHpjdzT/WxBiP3ISDg+ATMZ/fL6KEsk411iS4I
+2chzWr5y55JazgHpOZkOAdMYkm/GHZE598FwOP4+NkUwbq/BqKtlsfl/ABbWYkRggZxBCfd3hyjC
+dRHGqyD9U444R0QiFeRqr9NXjkxCJL/aRjEL55HMSCQ9qLqSeUH/qNsKq/lvkY/nTJ/vms/cEb57
+NVRHkYo0X0EL9k3I1RWhWQnb5vyqBsRoMFhjUM6HmtYV7pmM2P6/RUKYLAWTtjLu1R261whWL//K
+nJd3Frdj58qMIYdarftl3Osb+e+juHiLIzeAWMhGLBre+hwQ0cj3YtmMchcwPaX34cPjw12EDHYN
+hsPx97EpgnEzDcYAxEwWmFIkAkFi6JB+J4S8cZEIorh63661QlReu0W4zoL0DzkGWZUvH5EqTMez
+TmcNBaf3NBiqHGks1PaK56AIjCIod3VcmUM13u1gPs1XIyY6ilSohGJVgwEiHaxVIAKg8pt6lH+H
+HEmI75oWSTo65y15WOs/1vs8mjqsVsMSqHK+089SxhCDMn5TjyU0lkCsmmz15pX3y7gP4fceUGaB
+vlPyRsRZUqLSXoi5VNXn03duBMIh7QS+f95j//y9WiPXYDgcfx+bIhg302AsKOShvHQRi826Mbyp
+L2P0V4auhfk0XyVEYO1p7b18QBoTIRbEe6ZDLLD2TIp4pnomSB+svwrMMhZ9hPldP4hCFetVQh5z
+PNu6U18k3R4bjQG1G0hDELgHbMLFhOZm6e2cio29DrO8DQSE68XpZ/NGJbDSKrr8LoKxEcyZGFAv
+G18Hpd0gUgGp17Yl1/nSeZCAT2lrZXt97vpJrBGk0JmTTluNpoMIR2l/rV+WbND5hsyYOc9+GWm/
+jJ8RZvXWKOK3kIkzLTuMRCFEW1HMp4BkekomVKVOAGPyzcAZ36rNcA2Gw/H3sSmCcWsfDF67rqks
+prJ3hs5zCw0GcJ0Qs0F9HhIiRGCOWuCmF3UkO/+iSWCSdwbiiEabUHRAufxX6lcCfMf0J5hjlJVQ
+o/EoH8U8ZmuCxX20xKjRDJCgH0XAKiZyefys8WDCc7N07o/ufyEdd4rP+GDIFd0/7r8s1ESlwTBE
+oAjr0Cvrq74NRmjvCedNGWpLtW0EdSaKDRkwwnfJZ0lBh0woIoSWgFhBvtHM9IjDSvrqXNq6bV2d
+uVR52+uW9suA75eB+iYsDt1jLOn87hJiUR2/AYz0ZTvXQCeRrk84IPlmnPaYn/d/fTnDNRgOx9/H
+pgjGLX0wAF7rLWs7KMLywuZTKXc1ppKX9C36liJ3fIVklBevEc6jEc5hhPS6St7LTwJut55qwvOV
++tmHwpoGXfK1COdKCatgpqmi1nDoI98NPW2MPrZEp8619aEIhiAFNRchC2O1nvXyuh5DJjqamHvF
+Z7QQAckMBkMSar6iyQhKg2FW/4ELwjC0UN7Ny9qL2ntdhtpqhGupD0YrwHXEcs9VokHpPa1JQyYs
+qbEEhsr06lB9MMTI+mCoOnpEyJCkS8SimI1ZEiPPZcD0lJ7mh98P/6wQKt/OSJpg0VFo/4tMNUiD
+Ec5MNuqbUy+qBWCXTKbiGdj/ZW2GazAcjr+PTRGMW2owsPD6YEBYqkI4AGpvDOQ8WIiQ3EiDkXvz
+JXMpWXHSQn8rpFtB9rvTVRQo4wexFlWqR0L6ztKdckQqmGwk58a+0N47as1HJU71yJoTIGl5+Mj1
+9Mtr/5QOmbCmaXeswfgMisMpyFzqswINa59YuH5zRd4I5eU+kXrlfG/l3hwtQen6Xlihf4349EgO
+2jzdPr5BQBqtC7dl25VyK/NYNI0wbRgC1vTfzLHtj9RB11H8Mva/vq7x+omQb6eYQAXSQIjfRSIT
++TxpMGK+DrHRXlQNSPHrEG3GLhH/q5kxvgHXYLwf8ZTItvz79evXTY/yt2N72BTBuGkUqaGKlUDM
+DtzV9wKoaubSk4G0Fudwk74VSjUEzM+fIxmrQrP8XhHOLwntt8z/HvIDkC3wCim56JRt9FEB0MK4
+8sHQx67w3tEc2HT+HTv1rGkgPlpPyEKpkJYg5GRDEIfTgiE5m35GmJENxxrh2grRzYq8EZxXV+W5
+HsqLTpmLvhfB9COs9I+E69UxsBBvSU2EEuAbzQg6pIHnQeqjcVpfClWHJRaWfEm/zJxyHT0yYrUZ
+u4jwEvDw+PDP+WUERMSFv2VpzqsmIqfzu1X8NaTUSItuReuRyvM3Mp0BpkO6H65hxvgWXIPxfsQi
+3yS5Z9qlHdplp/Zpl3ZEv0q6bGC882uzRWyKYNzaByMdq2EMpwaTq56tL99b9E15fQzhUz4Z5dHu
++BpcisKkzIt6pjyGpLCQ30R96mgUbP3v0WAU0kLjsiRkjWwoJ+kijIOE8b7Qbn0wGr+Vdwr/nG+N
+RPR8QdbqackI0JigKa3MfeLTPhgi1FI9n1kxDWeanfdqMIBWEC9podbVXcHPZcZOmVXCQGUajQLX
+a4V1S4K439H0i8u8Y6xrvhiW4Kgx9MiDkARJt4SNiEdvjlc1O3JVa31hBI4v4Z/zy4j5+yEO24Dc
+9/nLJtdJ3o0gLQab/55p0etMOgOpNx+jzPcuOYHvT/tPLwC8B67BeD+C/DcEzCfohRqgvkuukB6X
+TGZO1+m7476wKYJxUw1G/n8Vmyt9CIsSldWx5DzfivpI7+rHcj7FD63AFW3FhRX5SC8JXvlOR54V
+Oq6QlDKLLJyTcF8oHK/cc3pPg2FmAzQjML/7GhCdP9oy5pjmoZ0n5WtBZKxLBni8nXlXd5shDVKe
+62/IIc83kSV1HX8APuuDkUvXevA5khHH+jTX6Fu5RkUIArRwzMK3FeitoN8TgjtlupoAKcvnQqcP
+OX21PTsOuZ+ov9JOT1Ngx3pe6UvPF6TRcqyRhw4R4bKXNEm9fjUmaSnf9JTeOA+/729X6lugRJpj
+bQOZ9VbTKeTw1jpfXUiT70l+z+YyxRFc6jdmU1Newb5VVC/XYLwf7JM57YD5RtqleIoIQ0CjbXZs
+BpsiGLfXYFRxU8Q7IKr9Lso6SfkosQbj+i84I5KntOFj0aWSE3rs7JOAuvJgtRNkVsPkoKfp6Lm/
+9/PXMVkNCRPHKMICazBKuZZYWHLQ14DUsTZRqKjOcgcYjUbXZ6JDlnoRtYIlWx3SpTUYADtj1v5A
+kxBD9tY0KfceReozECGovbuQzKU+YpZRrhW0tqBnssPCcUM0QPlJ2BYtw5pW4mzqbfw5pCyRhqZf
+3IceeQnUFy5rBP1LZmGqvt68GGGeSYOai5V+dH1PTLodc1cbxH2h8RnSVvwy7mSzuFuiPi3pVyjv
+l/yuFzIh2gugaiMOUHkkkpRoEcvb/1wMrRDG3OYZmA9IpC5rM+bTfHXfDNdgfBYB0xAQl7l+D9e+
+kx9Ij8ucNGZKhnBsDb/+/Pnz5ysVxCWtlldxka33499NJzWcPs8paH5V4dz+X4QzlFLyulTHYjJA
+6SwIlHyX2wayunnkXtNKuepVQDzNeS8Onheqb4mYniZMu+niNUybkgHYTTUaUxZqRXguO1gb4bwX
+xaloBDr+A7zqbwVelV8+6LnedH2TSh1LAHZQdVsfhDhG4DQnwXo3NT4Iqa2IeEqq/ojaZ3FwlP6G
+EcAwmbZQSeQQ3p4TpPxF2M39DyMTHlyco/4cQl0TfURTD5e3v+PjQ+rdLtAdWdH11cgfkWjSkt02
+pXeezZqPnodyr5l8kHbq/X/xyAJS5//pXMRxd3zT/vfh9y+EpymTTboeRbjlMZLg35j12DJEJBfp
+E32IAWAQrZi5tmVea7psBopBf9hV36R9ZJt7mlsM+d7ka0zmjDgHEvrys6iIDnT/mvbNxKo+2XFx
+fnmzmTJN26aNronV2rm165mez/kROL68/S79qYiniBkzJsgzbr8p5nku8x8xPwPTS+DUkqcv1uvv
+3f4UEQ5V4x/OEfOS+vSe79d7sH/eYxomt/V/B6JYQKgFxqTJmHbm3cbfw5Iuz3M/X1xiJRfynl4i
+Xv97/etjddwWXyYY82nWqzuNyUD8a+nxFNMHWeWjBwD5t3rl8e+eWEXaiyUU5yeFBW16J6282rhv
+3J59MLnvPFZVB7/8NV2RVaRpnDA9rb+k42nGvERgOHYF9lUBvnPeCrCfyY9zAJYHxFOew6XX6wA8
+TZhWBfqI+Dyn8uMxqWJtW9KGoNfWAGAJCE8TAKoDe8TnfD12x7QRIwliajz2GQEA+diR1qE7D6Q9
+anxYOuO+RPqU70uH4O2fHxDOEeFw7BBm0y90+vLufEDzcWISbu79mInZtJvM84GVv6ksLKE3Is8S
+cXw5XvTz+PX7AccnGgvwPvJgBeemTEqOp6jvQ0DdixFpZVe0aSXVCPbzc07fTZh2tv2aX7Vn7/kB
+iWCO630s4n7Ji844LQkw/blIRGxelOfg/WXee616xKKdM5nfMAQcX47YGpIZTBYqTzHZ3gPAAEyH
+CTjNmM8B0yEvNCwRMwLCKSLmd+T0AuAEzKLZWAAMKULXxfLI+XZoSGB6b1bH4E+PL38LtkoQr4m0
+4GhJAyCLGIocGA2FtQSIJl9DLkij8frfl0RRxx3iyyZSVemp1akRgJiu/K10UF/E56GqaeVcFTXK
++dJ/+TuoIxYiF/Ix5mMvXdJKeq27rq5GakvGI2PMOaTvNFY9PuMXsshLuB7fCmFbxklqzDU1J+il
+0dvbQVG3Xn7qWTH14fZkHKVPR4Qn/jcBuzzi5zk7H2YqVYRsJO2F1JFXY5q2BlO3CCTDBEja7ljI
+Bfs1IH/4koNaFXrt7OOcycUwIbxInQFYstZImT71/F/yyv07r0d8z3UCXSfKy8745f6TuZVV77PQ
+VtD9SvnPJj+fP9P9Xuqjex2g+Pr6uU1aiXyX8/N8Lpbcpa5iElbvjHo9iGgAeJdPRpD+dx2aRQgP
+bfqbZaK6Z7DLROIpCe7TExB2eQzPefznfh2FjMt8d02gIuIhlrzhKQl800ttC3nlOIom4xwhmj4M
+Ke/xhfLKvK35lpR6TH+KAA+05kucp16zftQt9Mt06w8mb/4bIKLL7RCBG81+GRvzyyi0+wTM53Qf
+Ti8BEzL5oMUy1mKGJ1Rykc6mb95Oyse3ywOYDoBoM1N/0tyHQzruH/df3uvJfTDehwB0yAXSotUQ
+MHfMpVqTavn+VL/ENXJBrTo2hi8TjIj6Uahrg7yKLn/p9GvlV9mLs7YAACAASURBVOlZqCcRqKzp
+98yjQskhqbpmUJkCIQ587EHO5XxRwrFRL+S3jJuFutoXzsNjj+pcGccgeWnN9o3oUlUYrkJ6b7O6
+tf0o1Mp6GUm74l4ERBmN8oGo5ZUOpmgGkO+zCdNwRMgryvEUq0BO7cjqWYmUxESErzGbZdAKWVDC
+B81VEZy5/jkJYGxupEy9ktlRElhCMkUbkEmQmTM5kiagmshR/ztkRM0bp6+QmGoTnWfmTOM3Pap3
+SXu/Son35Ocnr37y+Rlcr79/30eeFZWPnyH7TCkq/IZPRglT2/gZiDBtBWBooblXBrEIsGWE+eMb
+pL38QZ+yEBZPcl9w/fna5oUMEfyLcF36iLpwMSTnzWAE87AL6b5ccr9zumguwqGSlZL3VMmiFt6l
+f715iqikBy35WJ1XO5ehrZfzdQlFh9TQPOaZXr2G0y4gPAU8jNvyyyjPoryzZd52yMJhytUKgvy9
+RP7mkbZtl+qMXS20lM/Hc32+JWpVQCiRpuJ5xsPj58id+2C8H7wco9/PCdMwYV6iWbCrZF8HE8mL
+SGvkQjSkNx6T43twHQ2GfBRqSvMh5w98wHXyS3ohJlmor0RFk4vQbYN1GJzK+QEMccVUB+8iGmER
+8SqNoR0nC0iVJID6Yo8odVXBjWlMnbcAYF2TUWeHaZ4mEw35oJ6Lz0W7cq5JhK2vR15Seha+ZE5o
+lQRjzCtgWUhfaBVcXm7yAdqFShqylkFFvuKVffJ7AWpbqU9VII9jzBotU3/RoNG8ENFJH20RrKS9
+3GJH21CvrMDMlbpL8jVbOW/30tDkJc2H+JzwXQGsPGd0nokD99o+c5r+tCQBJVd/ASACpn1+Wni2
+mKC3belnSgv3azt+B9G8NCvoVThvBHp1rlNGhGPEdE/mQBHNKno24QlDvu/KfUvnxZxFhH4kMmIF
+/nhCvW+7mpWYCMouQEhqvYfzDI91nCoAwnltbmJnLkiYf1MbYeakISmS3inXJR92XmQeeQwreXJf
+JZTtw40iHn0HlPg98FMX0oaxoh3j6yF5Bpp//kbKfC71vkzpnfL5epXnu9xbldyFQ8A0hk9pM1yD
+8RFE85d5J45Ijt+nWX27VjUZHXKhSAj4++HYEr6uwRhZZOZP9rpWQq8mfix/K5TQyqayJ2bBwgo5
+fSEITT75KNVzClabsXZO6h7bPl1asdWCW1QlI6cvdvVYk6Sy6ruyGV+dQUN3rA2/Ep5DjZ7EHyea
+KSsA6yugjzod9IEJ7Wo9fXTS+KGEZ9FWpLpCISKaJNWXXMyru/oas9CuTZbA9Y9S/9yQpnIfCM4k
+7ItAudTr1YrhLCrzvGrY9GjT6eXf2wCwjA2p7yy0a+2ZIWHqftTnm3sP+qpzD3V79m7KZ858B7E4
+tP5MrZHz1UUE9DUZSYOR21KmO1hfjW8EZxLOOB3pg1wctFkoLn4ttc1qklQFZjG5nAC6H8mkSoR8
+0XLwe031K93P05DJg4zF3MNF+JZ0ef5y+11TqSJM2HS6Fy5qOWz9wcyvmRd0SE3ph22jU8ebGqpk
+Kib7ZdyrydT++X3R0mJ5nyFppYA0ziUqzS74nYn8/Cx0r8u7FkjzaBff1srn36y5SOaD+ZmWa7BL
+ZnrxHJM2451apH9dgyEWDO+5T4O6z/VRRYXaJU2GJg1R5VfkglB6UdK/Tv7mxz32z/PqVY7P9nxE
+PM3YP9Zdyx8e505Y3oj5eY/9c6/mmNvNX5a8O/36v9p+afuNfv9kfF2DUWymYT7fVZBoxUcmFXYF
+MnTzW5GLBfBSXjZtUfVJO5ymiUYVirhFEj3Mw6EIRc9kypINZbLQ70NrsmX7qNPUHAx63kt7vXqH
+gPlZ75NRRMgVjUIoH/UqzlmTntbiXa8jK6dRss+0zt/lN9XHDsk1GpJ5IZWX35yvQ476lIUmIK/E
+djQyQbQLjDzmpp9Sj4oqpesvmhu5FoWkVWFfCbacfub8+nroKF0r47iYrtuJ6lqkroRRU3Lwfabo
+Qu9+7GstepST7yZLR3rPINtt955TXS8/HTn/wuOqbVfCkkuJJoM+MmrcVihdFXStIAwSzqP6W8hT
+6ZfyU0C6hvxeK6v1EeW+26HWJ+R8ITIgfiQD6vPcrOqjXdUH6j0MQGkOuM/neo0bDUtXs8MkCrXO
+xv8hNnPBGpeW2Nl85ro0mhS0ddjfrDnh9seQoydF7A/3STLCkHYmf/j966KAme7xmIOkRMyH5Dsx
+n8X5Oqc/R8yPsRCQ5LuVQ82eUXwV58eIeIjFsVueb1Ue+bkdsp9Hvh7yFUnmg/k5HYVo5P4ekEII
+P6cN+t7Cv67BmHZTDv/7UDVvKxYZZVPFhlQE5eNXNBlLT5OBVnPRISzXRNghvbd741oycRim8uUQ
+QoJxwvR0xPFpwjTOiUxYknGK5JtowedCMh/NwS8i0ne4pO3y9+qU2g67I467AJxn7B/v7/3xVVzH
+B0NBaxm0doDXsrVw31t95/zrQgoJE0PIN1co9fa1HzVPzWlNlWrLAC6ThzV/DE4nH4xWSLs0R+2a
+/6U5iEgrmEW0U9qNnDZAaTICCSt2nRidWWMSYUlFj3ykBzDk1XLo1Q7Kb015ylUz5CQJyrGZ7wiQ
+zwPqC6yYMbGQgY4Gg5D716zy5w90qX/k+mc17qjqgnpZq+eG0/OKqTUvs2TBhgSu5KElIY2DuMwV
+QHMaOFVdSbsQ0LuHmfT2aWgwaT3TJlt7naX3PKesB+IFiwAgGhKu+6PfYQFB7Socz7W3rVCa+8Dp
+ALpCdLMqn0fJCxi9lXZ+D4kJIZCubVnoIKF5V/PWHZgzljyPjXbB9tEQiWacps9MVnpjFWIBS0BW
+CMdFDYYlcahkAtKGIXirhMf8boiEITjWHO6MFGJ1vE+/jGk35UWDZCL7MKaV2hIpKEOePYzAdEi+
+JtMu4HhAud7hEKrz9yGfAxBeQnHSxpBqml6SMDXlPBg75XeUfqj3UES9rlWTIUQjpQLANCbfDJyB
+h8eHi+Zq/7oGAwCmpyl9h5ckXP96/JU1tj2LhorY+UvlH6ZMELFOLkaoby47f6eav35tkvAesbfv
+PCATgFC/f6cZ8xIwvbwmYrELCLsJ09Mrjk8B8XnG/mQqGe3MmPaBVEf5l+TRMASdhoj4HBGejqXd
+42EClj3mVV+ln4n/fbWCKgBqIT4g5G3gK1UI2dk5XeqIuATEoZYK+XcRJcrvfFHyxSoCxBJz+fxS
+EuGPRdslIg4kfNfWSXCPWhhWaRlrmoqhc75HOJbEnmu7WqCSvgo5SPOR+q7Hr8fR9JPE2wiUF34d
+da4vkwypPX04VW+aGeKZtfNZyhlnYrWPRufIzsnN/g+y6pxNe5KfAJkg8Qsgay/EXjyeYokmFbPZ
+SFxmRBzTiwB6xSUAemdrs7ovgr+ETYxL7vVpTkK/mKUssTiWlxfyiDKm6vzdCvTcdvGNUOkdjQaJ
+2u3dy9eP2qF5FI2FCIBxTKY2mnrzvRnzvZ1bWVDS6/3Jzy7yqma9x4t5mH1fmF6X0ctHCeY5zvXW
+94U864H6WZ/rSj5Q7MrtfJX+ZMfv48sx75MypVk0JoPy3BThVJ0PWjglU7QmjKrMCZcnTUIJK8tl
+EOszcIqVbKhj0Pf4IPPJ7UfTR9CYpN3YjhPm3Jn/lnrqc179mdbKrM2VGXcR8jt5Gi2JnWubhwjI
+SO2wFqlZ4KA65O7dAcdhwsPjQ75nLokifw8BSM+qvAdzv+bHPUoQgRK6lQR8JezHugfNaLQPZ9A+
+RabxPEfqe0x5y34bYrLK36lGk8H5pHzq5zSmRYD5FIFljzBMDQmeT3tEJB+Of5FmlOWfUQTt9Dsu
+Mx6eA/C4x/GQIhz2Flx4SamZvxHp7bjMCJguOnTzF4/ruY52aUIYUtTGuOMa83d7d8Q0AMCM+Zl/
+a4TdhOm0T9GykJ+NAZAoiE1Ps1+b3ONNfTb1NGPO92LBkCO2nSOmL4Rjvjd8mWBE1JUms2ZdwybK
+p3vQon0ROuRWU6uMTB7yS3xgASSWjaGU8FycvPPLcWCxwQjfZQRaUNdCc8ZbpGJNk1HS6sdIC1ck
+Sqn5SmRM9WvQYxUBrwh7SqDU47ZkSuovJGMXOivj6TdfVdtre+Q9HXpkorfpmz3GsQpLga5Rud9K
+W/UqhnNARF6JWfK1phDBJecpAjv+cAYKlUrIq/3KpIg/rSe633jVUjQrY8h9Sv2MO+g5GGjVaOS+
+VKE/oCUUhrqofioyRHeafpFLmiaMItyyw7G66gM/t/RUDnR3DdTvgT5IvAjACwpyXWkhQhYmVHvj
+Su8H/dmzz0vtZ/tkMPFQ7xT+awjJ9OWcwm0qIfTMRzlnhVM+ZwXsWjYUAtEpXzRpmRzI/ScmfLxf
+BhNuiV53isn5W8YszwRrCpXwHtPOzDv6MA45/0DEp2feoAR1EFHidGqzIWLSN0qHrcsSGK7n7bnu
+k5NO+rnXlrmeau5SHdNLwPw4NwLudyIMAXMW2Iv/WRa042lOJi7DhKmsMsdKBCDkopatpCC/y+WJ
+y9d5Iu1uIR5lcUTyyhMZy/sqihknQqctyof8Hi1ft9zWIiF198BzHnx5PtK77eGwb82b7d+931vA
+gPKd1d9fAGPAfNoDp1A3I2RrAbPgVr9JoGd3ypvxoUsuevtiXNtUatolE3BZ+AKQF/6SZi79Tof1
+fVXynJyA+MSkYYUGZfKxRpLqd6XWk76jnXo2ds9dR4OhxBi7tt5+vIkymLxcql1P79VfV11gBHwS
+1JVoYYSqUqNm6rqPtKeCfSm9hUI8jGBGI7PCu4zTzhOvMJXRDFH1uRX77ZjMDOTNh+IJSRBRjtAk
++EqvzcupkgaQsCsfgFbj0Qu/GvMHXPkhmHuimY1zvXphyPUe8qieJtIiiAABxMd9Jh+BXp6ofT2z
+0K8F84hY976Q+suKdaoDxQ47C398j5BQknYZz1e5rCjX8eujvha9DfXW/DT6T5G918x5sXVunsn6
+nHAtlSiA7s/2OVsrn4hJ/VtevJzfXIXu+4Kpwlv91OdtP6knS9pJOK1koSMASzkRoiO04CzXHXQf
+siCb7/MzzRsLyKj3l6jO0+7Z+V44IangZRM+I6THEyg8aBYS8t4VSYiQPtAzKWWWUMwAk+Y5FoJb
+7q9yDxsBnjUwKh2VcAAmrxX235jPVa1HZ67L9THHS+VLPnvNbJ461ngC4iFiennNphD3gYffD0n4
+4UWKc0zmU3mn7GpeFNMmeCcU86byFJV3YlSahDAC8yE/RfKeAhCWUHyDqlZCFlHyMyjfElTtiNVg
+tJqOWDUYiOlde0r9emvTzH8Z8RSxXx7qXNPcH3dTDj0d0k7e53Ynb32MLVlYErmYFwk4oUkF71Ol
+fDlS764zyKx9SCbUoYw7DlPVVmRNxPSORYBCDRYAO/liGLyhwbCpMX/jggkCVN6tK7X8RFw9ilRV
+QNr0mpbSteCb0pjrVQIg5bVYQiv/5qL3zpe2lRlVIJ+NXGYJqs4qcmSsaijMxHSjSHG9NFdlEz5u
+KYL7oMeqBTo7R2FBqamUXWRWSZxaIl5fXlNJUYmbFQcWYCtLNz2lD61a7aDpsBqONqIR2lUSuTLm
+hRRHAKe8ErUTZ+uo9r4I51w33X1hF4AhC2ZlfLnOc2ktoTzoNOZSPwqZSsdIgorUH4ExO5RlDQr7
+nyShMqtfTX26b7Eb5rfnjB/V71pfe0078ylaSH7hL1bIZ/IB6FdqoDs2ly93SrhQvrlDmvwASnQr
+rrvft9ipQz8Duh8xPy/0psh76UxZ+JIPkggzbzoij9RPeTYkXe6z8nGL5e/Agi3qsWgmdkGFEo7q
+/RLbvowgDVtAGKD3rij+BtSuPHd5VQ5jFhLN3hilHTVOGv+5l85tduakawrFeQDlm3Guc7fqM1Hm
+ks6raxJNX6PJb65Zt/8R8ZDu0eP5vshFhbwf0n39en7F8eVYzKMCQo3+RCaMxf/hTM/mmZ4qeZcs
+QNhNCLuYyWkoZLg+gfk5G0lwG+u3rEgDZYEJ5fopTQdfizMwP6d35PHl1cnFBUR+Zs/ZD+bpFX/+
+e8X0VHdKj+VZ6H2TQpOufC4QsuN3bL49NdBIKOXA1/QqSN//+Ez3VdHiZvD7eQ15MTjwYvL5LQ1G
+pzflWeIeIu+Nxqm5v3diWnktXDWKVBXiq7BR03O+hUVUKUsvIXLSplJVICEhgUXw1C7K6icLPlUQ
+CaTdyC0Ppi9DfRUy1SnoRYu6pGqVfpWHW6+icp/0HFDexYx10fntHImpSB09cqSpKhJGAK//vdaS
++aPRqjO1gKsFW9SoHjTc/t+WnDBt0qvp6WOe75zTnJzQ8r942iM+7kskp7J6qnYUjsU+V5loSRCA
+ZVbtV20HwWoKVP2pbq2BCRTOcc7CWkwEaIjAKff5PCdVNO9HYDQSa5qKkt6Zy9b5u5IIvh6XdmEH
+eOUwFM0Ci+72yazz1jsXKK3mTf4r9Q6VvPUO4Py59ZHbryS66dui+6XKDDYt16+eP6TVpV21Ta9h
+ao2QWYTber/qqEgsNHcEWiZ1mQjEU1pBjoccxeex+hUl05M8PnlHjEI6jCCc323pfq/vxCT0AfE5
+rVKnTSlTu2JagB1obxig7q2R6xGBegHwFKq/wUhjH+k+UEL8CgkpQk1nntTvUOdd1dGOX2l0+Lz8
+LtfOXqtO/5hQgOo5R8yn9PfrHQq48/Oc7vfdEa8vR7z+eU2aC9PPtKoq91Y6zodkq74/oAiE+8Oc
+vgNAsiU/5fsWQHyeMT+muuIpaRlwStFx5sc5md4B5d2Y0mOKQIUqSwS5f4G0+ASUTUDLtzlrLeZT
+0lpMT+JH4ljD/nGfHIqfJrz+ecXx6VjNoQihPAvoLETFNp19LmSxZEAnhC3qu4G/PTAy1heRxpTf
+m6cZ82D8HZC+GPO5WxyFlAzBLBzzghaBo+wxzqjhxxmSd2PmUD1cIYpURRGQre/EUj/q1faZ0ko0
+Cxb4UfJhIWG62F2TmCofUBLulTlEL031mtukdpU4ntHzwWCs+WQQsbHiv+4Tm4zkHI2vCs9uTqU5
+YjHPCoOS9nqoL+T0IhfVtRVUjQZjxWSHV8+tQNxLt/X1dvRO8zlnB9Y5h6DLD/7uiHCYKhHJZUL2
+f7A2kTJGWVEQLYZoL8rOswp0Vaj+nnBeNrkjZ2+MAQEBYTeltNMe8TmHB9yll/va3PQ0DUzoqnCe
+74JLc0r5VndhRywrNJFaUORe2lSajVAIbyHBiylbnhERWKn0Yp7nomEMph9cR6TADVQWKCSi9rNq
+S2rNmpiXvuZxTSM7vqL635hVawB6pZvGWOPBU3/USngVhOOISgROJMiLxmyXo+yQMB5PSERI/CMA
+s8Ie6H5H2WgSY9oZXMhHfK5tAkB4SnbMigTlMil/xPyMQkQmUD4EPR+0WtqmydzQvHS1Q3beuL1Y
+57I7/l5eQwQLcaFrpc5ZwlH7Hs/A/JyiGR1fjrhLDMCf//7g+NSSCg16brOvTtjliE9IZLSYl8oz
+I8LhLr8Xc4SoIGnIYWqfajjfWbS78i54yj4bQLGG4CU+nPN7YKS30KlqLe6R1N0j4hIbrdVqXr6+
+5dsT2gUpSy5YYB+zJuMUiZzo8uXbllu9GoaAKYc+npcIYNLO3EOO5nSauzvMp0UeJI0cACCsyAeo
+/p09c/lR0s3YxFfwTOkLShCjLeEKO3nbD2xsP+BDyVlJAajMYDUetS4RGrSwYdSuQ24rC/N8TlYo
+ue4iCJW+aOGARbJKMgzeYp+WZCyBhI3ak2jatuYj0r+2z2YsQ627zG1DrAAsEceXV/DmSWW0K6Y3
+6xoMTRZsKNW1EKscYSV9PFpBGsMR4eWI8PKa/x0RntJx2h0Rdig7VgcA4fCK8HRUfRJzLeVcdsj1
+DXRVS/spHnY4TLmfsQgq0y61Xa+efm2U+3aX6hdHx7Lr+MsR4Un+vVaio54WnjPUFzLdHVrT01/5
+0XPamlF1Vd+5DOhOUxqChQirIstV2C8jGsz9OvQ0GTltqG0AyC9f846gF3FP89lqNbmfUaWXq7ZE
+nvVUekAOVWg+wNlHZ918x5INGAHZ3jGx3uvIBOIlbSBWjpJ2yFoHId1S5iUJZknTwAIBERwghQDN
+IUOrRiDk9CzgPZFwKIK09L2sWmZhU/I+pT5qsiTzQWO0gv1Ix3PopK2UUXXyO9PmNQSPCR2f5zpK
++TWSY8jiGBFPAfExYnpJ74x7xVvCpCDwc02moAFIJnLnjgjIwuGC+q4FipOsEPcSCEOuU14oCqOU
+o7cAmZuISWA4p/RkigYc/3OtxUcQhvBu4TUAdG31e7PcAz1y0WgqEtGc8z4Z+juvScn1TKRSj9Mi
+yT77ErV1h6f0Dd0f9pglYEteBJyfZ8TdlMIoS/5hApY5h/cXre+cfI+GKe1l0UNPg4G0iCOav7Rg
+tE9+Irsm64/GFTQYWWAh8UGtckAEgUjnahqvWdQ1Rl53rx+CYMoFk79ETiGxwZpnaL8HEmaUHbYI
+VHRjrPlarJ23mg4AbLvKPQxADXuqXuNaMGu1LNbYyHx4O8Tu+PLa3O4lh9U88MwVgZcEVSXs5iOv
+jtNV5JdLZEEHVYgvPgrct/xh0dRLjnX06ZwWulX/VZ3rZElrbkIRhCQUs7UdbcWVfK16mgcl/AUz
+JqhySoNRxsBX0l55faw+LkDrgxE7Y8vP5Vk/l9J6o1UrLevRrz1zuqy+irat5mqPgWq39aKj1dRt
+8RuopA32PZLIXU8gi2d6uymthNwTTDZy+njpPAvxUaeV55DTqGyvXlXG1kfCueQtwkOe0TELepYE
+NH4SuUxDamx+Ig+NBoCORLIukoGeBmQ04yx5oykTL/SxM5esJWHiQe3HQ8j+FkdMwzaE3PLtOEf1
+javPd6TNHg3G9C4rJGSg9x9CtVrYieAXFPkPAGkvUELiln6dgRlZa7ELyZG7+Yo5roXIzxk6xBKg
+QBG2bItpmIpPRpUj6Dd6IvgXsZuy5nxauW8nHA9HTCPSxnq/ZUftCORN92x9x6cJOOeN+A5po7wZ
+wHSYVvvP5IxTw9OECXNq9/ce+1O4WM9PxXU0GOBXRSv2aKEh5gvPa5FGQFHOmK0gEhcrTpEGg/pU
+KUrH3luZWIQijJcWWbXFqj9p5y1fDM5bZqiKQOkcCUTWhKqYodQ5Yudtrq+K+pqIiFglBOb15bVL
+kKyQWubdrnBDX8muL8KKkKtIg2qba5Z2jfBbrortpx2DrrPcBUY92+w4as5r5+0A7YxOR+7zSh9D
+N13qjMpnoufo3nP8tqtEvf1FbJQvSyZ6Y0tCtn2W2/uLfzGlsPerJQq9sr226t3AmgcmLrZv9j2i
+rwYQOoEU5BlMf01jR3NR7h/qmRWelVD/1nkiAVZ4Ze3Hqv0/CdXK3AdGGOdng4TjNROhXh2lHyZf
+eSfSfIhA0lv55zLWbIxJUS9fjxwoDZHNT324pMHgdATdHrCSP5tE5ZX4rZnmlGd8RDHXA5DGXkyj
+dHrdoDS9O2RxKCibdCHuQDiRiRT7WopWDkAxiRItxjn5IuGU5vy9GhnH51GtUmpKAWsu2rN9jEih
+kk89TYZk6lGTryDg+N8rXv+7ILQPAdPTEa//vap/R3YI5xp3E44vOV859vfSSPVPOOb6ev2bXrjd
+C/X8YFxHg1H+zuK6+ESIfZqYV8hHXsxTJLpOyVdXJJHzC3GIuV5Ar1iqdmz8/sXWU9tLOU0/YPor
+AxuRVbpoyQVjzf9iAeJAL1zyGWmIgWhSirO6vIyNKcpS+87XIiiVXBXJxKG7h/Qix6rwafexwIrw
+WvOjeZEUP4fuinpfeG4Ffl1ep8dGG2F9ECq5I7G0M6bmyCJ2Myd1LHrm9RHqt9TdHxdrcWJTtjd/
+64Sm3tWd8+Y68spVzPddQNR2qksdQ7lXy/OdSy7teVVWiDU9nwC/B/TzC6D0K3Tz8+IDPbvk8C0b
+8NVa8mwMMZkjXTK3UBqMUD++I6f1zqdWuv4ESiDnv1loXhOKoy7TmBZJOtVntRENmbB1mPy2zzze
+0haVXxv3JWG/IWamPM9Rt16aG0UcuL/8t71mhlCZOY3PyT/nbv0tvgB+Q8h3dD7kQANn2ZE7PS/z
+IQcEAOq8AeUdVgjCLpnczY8R+0MO9r7LDdK3U5y6U335Wz0C8ylpLabdlOZ8gwLYPaJ8Bzrahp5Z
+lNW6J1kAqo5kZkyaDMFIbTo2h19//vz585UK4mnG/jS3K/dZsA6A2gyql+fTvw2CmASxYPKWhqGH
+br5QX3AXiMTasdjcW63HVzAAeQ9NaNMxIk942wFxFmenHJKz54jdOiFrc6Je/l45eWGxlqJ3LBvy
+od9G7xhA9aLf136f2vKXNgTk873dym3/y8ZVTT/QH7MhbWttr81do8HA+65ffN6bO+eNe3Xl2Uq7
+pq/k65TrBWloy13oF9dBqL4g9VwlH2mhIlzQXAh+/f6V1ONWcCZiqc2X+HrI+TzPfJ7vbdj8nfr4
+w6/q5DI0Yq7vYh9g8q203Yz9whhW+/+Oeeg987B9XSuPznjqu6c/5rW5T3/LvhCvT1MK2LBBxNNc
+SbQslojJE81lAAmUqAtHmfI33yBdT6EwtACC+v4DihZ8PqUAAtMGydy9I56SnwEMSVjfoVueP5ve
+P87LnEwLx3pvxCVeXAR1/Ex8mWDcE+bnOam9uiqpz+Ph90Nximbh/UPHEQgSveCK/RIhqvat/h94
+X3STeIrJEWuYlADeE0L7ZANdIXtN4L0kAK8TF6i8ZfO/Tt1rbVZTFG6HCQ867d7yiNX+XyIb/XGY
+awNcuH5Qc6I2V3ze392LPgLY/374UL/iEjEfZiLe9pgc7d5jcvHw+wHhKWtA3iU0U+E1wffi3x2h
++dK5nuC8RkS6ZOI943hHfR8Q2vtl3pPvPfWukLy1cVwgLXFJzphb38AtmX7NmTi0NCG945kUgOa1
+oQwwFKM53xCVXKc4hJc9aBx/HfMSEQ+0uaiQi13n/SIEONMo9wAAIABJREFUc5VQyHeL0tGSlbjM
+eP1vM6KoI+PLJlL3hCQ+xLczfhL0uqU2G/fa7nmc1frr1dDavH+MXKQ68sfEkAcb/Ykdt8Whu0Q8
+gv54ACgrFEqNCp0XkHP9NusR6UXE5VdUtGtmXIE+irV99o+g/pf6+mZXvc3v3jq25XM/mzuI7mIx
+HVHjQX0xr73ksVZvVHOl/EDuFGH5eN9qCMB6jBCzqjYU7Vt1VXIBElrlgxtMeiwf0saPoTEjyulA
+hyhIvbSy3JgXRZNu21rrAyrJ7Y4j1jy9+lT5zjhg6ujmM+llLDTeUkb+Dm/UBajrw3PO82PNvdjU
+Ki9izKc0L6//bcvfoocSiOFc3xxKL5HnPOR5CqOcQbleKUAE8rcu0jevni+tnVGiCcq7fD6ls6//
+ua/FdyKo9w2RAUMq7PfXmkbVgCK1XNGODRRdCvz1dWwJmyIY1aX5FnXXh0A7s7IAw2k6L0YRca6N
+2j6vEH3ETrg6ZVvBGLnfKVf6wIT6UgGRCXrp8E7clnT0oyuhEcbtPg0f2UPD+mjETr+4T5b0lNU0
+EsDbftVx2PrrMXTKg17KSWCycZUUTc0allWfmJyffS5a9+pab4CeK0WA7hTxE7bX7PYdKSUi2QJ/
+JMRlaAT9NYHYCKolPcAKsDpfoLpE6M31K8EfHYE6mPQVstMjD++qd408xfVxNf4ZvfH26uY2eS7t
+vJo2VRtEWnp12z42GpEkEMV739/iyhDNnoTFjuf6DAlZZ6KRKUM6ysLRWH+nozhs52dxlHqi+h7G
+QyIXx13A8Y5D/v4rKFIKk4sR6rvdDTdryIQNpmJJxjRMeZ8KpxdbxaYIxi01GLyuXMU2/VioqFQm
+L+iFfU0w8ZHfH/0oVq2EFlYLOSBh2IZr7Tl091b+e9oQZZrDR6JqMqZ6bAVnpVWxq/WS3tPGmOPa
+3h/9/muNVCBNQ3V8N/OEqme65DC/6nTe00iYOW/msvS5d4103+4WS3g7j4Foapj0xyXm/Rs+tjpa
+bdM7ArGkN6v2kr+z0g4YApLLdrUAnC9SPiI9vfLNqjzdj0XY7qStaifk7zUyweOSeTFE7L1z0SUT
+K6TuzPNN89Prn9znQtCBhjhFBMTHGcen413vb3FtyNsyEsEtX7NCOoiqn+l9fObFt0rsS+pY31yi
+hQ4IaYPHQ8wb5h0369/y85C//9bnwmgu6uIXzDeFSQfKomRTHsA0hEwyHFvEpgjGzTQYxaFUi7gc
+ZjYAJbwuxZypeUdOvR6ExsioP7PiVohF8/KAIhFrUZ36UZ7MKnlnNb13rQJ0HS0R0FoQFuzFGbob
+8aohHdTmBbJkX558BVVkrHI1qA2jeahaLiZrAZW8UT94PuTvTt+UVsPml35S3y5pNe4Vn1k0qEKQ
+mEbh03bdxSa9Jyw3QrMVri+szrMGodFgcHvB1A19TrRyVsDmfI3DueRZEdwtaerVabURzfyYsZfy
+XMa2Z/th2zbtyXxa7U9XE0N1Cei6xbxT+fH82o3xv2XIN6xqGSpRiDTn8hYr2gn5bsjyB5lLpVSg
+hJ4t1wlpg7JzxLTzDfPuDfK15P275N3R+FLwQlXJG+s76Yz67pRvl6lzK3vJOFpsimDcTINRQtJK
+3VlY41CyCMCgCUdaea0raLfSYHyFXAC0QmtWGLqbvq0eL2sC1MyYVf5LbbLfRCM8l/xEJtY0GEbD
+EameNR+O7v4Rl7QkRsNgNRBvaSzUXJRr0/4dOmly/boapV4dPTJ1p/jMEx3pyQRi2n36kyuk2gfD
+CMtK8K0CVCO88xx3/QjsirttryN498rIOSXsB1OWSMkaAQLMWOw4ZPGgl94rU9+DdR6kPU4PJj10
+ynbms8wJ9DjW5p3GlvwtUt5/wd+iB9HI1409I0Sjw6ZN1TQ2v6/k7VLy5vNMVLIGQ1bB52fRWvx7
+RO4nIOTgF8fdEeGQ/g5DPu4CpiEfD+/8/VY+CUPs2Bw2FkVqD1w5UhNgo0hZQyiOudEzkqKX7PB5
+IWetX6LC/IrtajzNmBekMRqtw1vRmXrhXJuoNCpaS62riZSES1Gk3n+USEmXokO9ux3YsYHa0JGb
+1up8T1scFcvOcy9U7aXzIROt90QBs+PYTBSpU8T+NOdV2Tf2uXgDD79/ITylcNA6ypK+d/umRARF
+JqQuQAvB/Ldtz+Rpytl+UHqjwXjHOFbbp76rPtt6VsZo+wCbp1O+aavX3tr8m3w0L/Ec0v4WH/TL
+2Rp0FCn9XQNQ5rZ+19q/+JuniWEqGw+JuBwP247I5XA4EjamwSgGSVeHvA4jIkI2hapr2PVsylvX
+zKWMWu25Jr5ILoCi3G6dpo3WwUY9AvrkQna5tvG17OibFfkzVn013orKxAJ7MaUq9dfPn3UIV+10
+tBBtGNk051Zrs1Znz8RM26tSfTwXdF3U8ZKPhjEJq3bRds7X/FjuE5+KIoWYTBh3XyMXuQdELgCl
+XQAdG3MeWnmX83aFvquZQGcVP+dlbUCzsh/0eSYdq+ZPZjyqfs4nY0O533UbvXqk/1H339bdM4dq
+zJpsHtP/Ve2R7ZfUA8QT+1v8u+QCIDNEMmdiR2+5lmL6FFCvVVTlRLtMWgsA82N6Fre2A7rD4VjH
+pghGz/H6Wkg7BOe6By2mFVFw0VoMFues/f41EIbrRN2QD4F1mlZmQGvkwQi3bE60Fl1J+U/AEg2i
+bStOy72oTl0SQoJ5Eag7ZMQSqnonaQG/IR+lz9T/FR8J6yNSNhE0dUT1Wzt0l+tUhMJKgFoHc0nX
+815DB7b57xWfjSJ1rVj6Mf+rwjE6QvGFVX4lTMMI25ZwdPL0BHj5reoXIZsEbqlP5TP9XjO9Uvk6
+JEW1BzN27v9bRMkQnm67K3U0fTDlmvFl0n9IPgD/or9FHwFxYXMo5G+WfFGtwzayRiPnl3LnupQU
+z0D8f/auLrtRXgnWd85dDcxbZyvOEmAZiZdhLSFsJf02sJ25D1JL3UI4TsaOHabrnBnbIIT4CXSp
++mdKGaLeTp561uH4x7ArgnFLBUPHYFjTszx+Y0xGmTfWJm5UMK6La/ktStCe1V7sZ3125TVUBzSf
+i6+wcRXJ2K+JTIMMUEUKtNFfAtTbZGRLsVhnVlrvp+zfjl/fYcV4L8ejM0XpYoLlvBVSdy5Gow4E
+t7EilkC1zmEz61Tl7qYVqIfFF6re0wFXM2jIxGBsGc0NA7yeeZfPcwawMc71zLvqY0VusDb0s0Fe
+G/sNslIfz9Y4Tbu0zrRtnZv6uOp9t4ha63xK3x+dm5qA6OOLf0PhGP8WTj6bnsFgUMeVGiEZovQy
+rWLomI30fJNrZmIt3CXK4fgXsSuCcUsFQ/aw3o81tQuxYJVek/Js0COiuANtG+ra9Uj7aG/N/hvj
+d6VsKGNBkZBWNqfsNqXJx0xV27Uh3cqWtHIJMq5KWyREsqQoYqENfRTlxSoe1THlHtakQN0x9rpU
+So+949rnriZUtRvX2m2tGvMD4muuhVc8nhwfk/o1hn1t9LfUhOpTz/TXBv6KuKj9rBSLhhEu/Wby
+UrfVJESNc5OAfGDw18Z+3e+WyvJpokaNseljPUM0stFLCEfGcKBYmRsOi0IY5ZmW02tLjJxaXyam
+1NMrqRYsqsU/7nrmcPzL2BXBuKmCkfYg/68IRP6m5qi7Ys7eLAbjCigqRDFKy2z+ORUC2Kp9Ubsq
+6Vn9j+o9NLMr5bHaMQNrqrfdF+zxqP7ylVGKBlfHsFIDNj7jsbaWbWSbyoTGnudyrDDEq5UBypyX
+M3EqZwsYPijuTcyzUrmagW8Z/RsGbybVxRArpKKevVdGMeRzy8DX+z6jRkg/Mm5gTYAuUQQ+IgRb
+x5/Vh4owtI63dT7nrT5lckT3L2Mox8cLYXwOeH/7t+pbXIoyyaSeqvm5K3EWahItT65wmkCh6A51
+jLEWJ1ctHI5/HrsiGLdUMLQpm81EkZTB0X8Vdk64bIcyC/qAKGlVi7FZZsDLvDtQGb0K+TxURvNK
+CWkY5KuZfKVOtGo/1ETBGt61KiB9FiNkXUdDqSb5nJSxcaO/s4QBtLFsw52pYexvZaPajDvR+6sV
+jDNjNWTkUfGFGIxrIk9brJQCTTpkOZX7SKsOZ92dlLrQclsysRN1fxVxaRrtLeLx0XY1+WmpE5q4
+VKRGKwt1+5X7VT0+3U7GccnYZDs7Bqm58D67S9QW8vO8L0+n+OxAPq9FSY3nVU/nhdcAzIgEzmMt
+HA4HdpamdjwGDB2uXhFU0tQW0xDZULR0QptvvPqUPNKPhjAFhGMoC3JhQbSXbX2/ZNuP+tva5rO/
+v7rNNfZ97vcl+/ybNlvtP9Hv+9tjpanFAjw9fy5N7TXx33//4fQ2bJAJMa61Ia+/A/qp0Uw3C9h+
+mqle1fJaQWn1t/pdj+ncNmpKoRn38MF25rhgJwY2zx+q741zU5/P1flVfaeYAZ7i09fz7J8HTwEh
+K3Vl+si8zxqKEb8CvDBOL6eHfLc5HI77YVcE41vqYCwEzlmk9Ey+IhML58w32fTocfU6GNcEL0mR
+WdK8VEdAOg5a0pF1yOtleXZWkvZIikjHqU9ZXvrlhVWbarneR+qXdcX0joGlfJd91G10Rq/NsSFe
+S1oA7uJ1Q+MYs+6Q2mQ9oOP1uVF9t/aDekwb5xfQYyrnLI83H2f9qc9Huj553HJcco+q41HnEA82
+y8tgjL/uV5/j6dcT6AXK+PqkEY163RaZwLbxX5OFOkbjI4LSMuq3tjH7q4lFRag2j6Hu88yxbpKM
+mnA0iITuS7XnGeBj8ErRF2JVByMlfihFOPW0GiCxFuiB08uAonE7HA5HxK4Ixngcc3XIa0IK2lkH
+E61Q1GQDZo1sORyur644HHsHL4zx+Y4E47//MBgFY8sw31AXLpqlx3nVoklA6pn9Vp+6ffV7awyr
+fSrDXm/T3NcZAma2/6DdV4hG+s0Lg1+B0+xxAJeCpyDTGtU9otULZGLBC18tDbTD4dgndhaDcbs4
+B9EsxD+V1dLy8pUwbjJbMAD0j52px+F4VNw7OQLnIHrl41/HEADKMJfvUO3rbbkY6avYgqr/VcyB
+uKjIcti4BUDFQDR+mz7q9XqfapnEgJgMVdV+m4HYjf3W/bfiOppxJ/V4qvM2x5l4np1cfBZZm8hx
+FvImk/cXjGrx/vvdyYXD4TiLXRGMnO3lBkjCu1IwACyrUGL1mRxUUvB3ycjhcDg+g3snR6BZBcg3
+g5zVspaBDayJRUsd2Cx+l5aZzE2qrelf+lWkp16/IhLV+ExGpmo8Z/tV4/2QLG2dA1FuLjiHinhx
+IhcErxb9FeR3l2TdSuc817l4jed3OAxXKe7qcDj2j10RjFsrGJUXKtCtqxnUpCOmqo0v13sbSg7H
+j8Sds0gV9bGlNHwwq75FLBqz722jv1ZEuN1Wp2bdUg9qg725Xvo9dyw4r15sqhs1MWuck83z0BpP
+bM8zxXiLfvBg7i8iT4ile4SUMhdepWCeVz13OByXY1cE45YKht5LCcMtrlHZAarTSU2LzBwVDH84
+OxyfxhcqeV8TXCsYrVoWmwXf8AEBkUkH9ZkNfNX/ZkrWxuz+h+pBQ+VojTHHg0i/W8euyE+9n1b/
+q6KCan/6XNQFDRvpaXlh8DPj9Pbuwdx/AVvXKQXJvzJ4Ypw8UN7hcHwBuyIYt1QwADXLs9j4ClNc
+L7WM/yu944HrYDgcj4x7E3PS8VPaEG7GDLRn2TeJRYsMNNWGSsE4V3eidq/6SEloxWE0K2mrdS3S
+Ydad2e8qDmSDpBlXMFL9xuXhFR5vcSUwCOjSuZ5TwbweGFy1cDgcX8SuCMZ3xGAwkF9mMSUtivGR
+iYXRLlIMhvIzdjgcF+PexLwoGLDuPcAFCkY9e18Ti4bx3VIBNhUMrI102S73+4GS0HSB2nB3Oqt8
+NPbbdOdS29UVyc251G1LOwYjPMenqcdbXAeEmOKaJyBMwClVPPcz63A4vopdEYybKRgdUj2DuBeT
+IaoDdGRGLse36OXxJUl3NpQcjh+Ju8dg6B+NuICtWXjgjIKBMulQG9/GTWqLWGzFO7TcnOQ4Kpcj
+M95GnMaKjFTjumg7rPfTjCXR28u50P3Gdjwz+BkYXjze4ppgUCxKeCC8v7ki5HA4/h67Ihg3UzAW
+KCNHZYhaKRWK4GiVI71MPU2tw/F50J1jMGjWLlK14nDG8P/QtagxY79yo6rjEjYIxIepXOuxfhCH
+UVVszm30uD4KTN+K1zD7q87FmWxbPCHGW8wnT5F6ZVCfVAs/rw6H40rYFcG4dQwGFJ0QZyikTxub
+UVqUPOLKzcLhcFyMexNz7sskgSUMwFkFYxWLUBvlG6Rk5Ualvm8SiI9iQao2eVmrj/pYz43r3Bhq
+t7DaDUwpOKj7sscbXhEDjv/88dn1G4A68vPqcDiuil0RjNtnkUovykWIhlYuoB7QbNYDAPQsqMPh
++ATuS8xzjrhVXQZsz8Q3YxbYGtO9el4YNUS7I6l9AWcIxEexILwe29msT2r8H43LbF+RkYtiPvQ2
+dtwMQnhOaVJ/v/sT1OFwOH4IdkUwbqlgxGDuuBd08vKTGAv1wobKNpUphcdgOBxfBd05BmOdpraK
+awAs0QCQY7VWM/u1+5B2N8JG7IPq4xyByPtQYzsbwK3jJLZiRbaWbygorZS3WyqGJhWruA2KqVKf
+Q4y38OJuDofD8aOwK4JxSwWDO51Jah17EdeUbzEovBTdw0yuYDgcXwDfOwajr2Iw5LPpBtRwazJB
+yxuz+K16Fi23o1VsRGt5g/ScdVVK/Wyl0d1UROr96/Ww5OGj2hyVexZPqb7F/O5xAQ6Hw/EDsSuC
+cVMFA9bxKRMHAJI1qiynFBSuWvXsCobD8RXc2TfcpqltBClvxjqo2f9LZvE/VB6q2IitmIlGQbpt
+V6VG/IU+ztV+NhQMHaNyNtC8dex2TGFir2/hcDgcPxy7Ihg3VTBQFIz8bVHZpLqtehhlRs8VDIfj
+C1juHINRKxjGrag25lHFMgBnDfyztTMqI7wVHN5sn77X7T+Kn1gRhCquZLV/NXYdrH226GDr2NPz
+cuZU4I28voXD4XD8cOyKYHxbJW/RMrqiZBRKYV2lMjyLlMPxJdzbzMwKRjaka8Wg/l4TgzqOoaFw
+XKI8rAx+NIiJIiObMRe1m1VDTVgdqx73mfgK+TxLnOr9xhoMfASGg8dbOBwOxx7wv3sP4JpgMAbc
+xl9XiIW4QMm3opuUkG8snGI2KK/FzOBuuLux5HD8NNyblkcFY4h/zXMupZnqY6Q2s0pNPaephFm7
+Vuo2pGprcHtb0z/lfcf2OpQ8BkPH76qN/D+XIqCYdT/6exqn7idvm8Ymx52Ihdlv67hW23I1HrXf
+iREm4P3lBDr4E9LhcDj2gP/+/Pnz596DuBbCMQAdrh4U+PTrCejSC3ahrFwAmkTU+WOsnkI9MHQE
+8oBFh+NTYADjrye8/36/y/7/+/UUjfo+kYG+GPOUZuR5jkREsh+V79HlB2p7JJcrkgJyl3yfqeof
+cdKir9tzVATqNkAZg0x45PoepJZ/ZpxpX5D2KMcL/b01fnv+Tl492uF4CPAdXFL9b3+fcAXjs+jY
+kIdMLjLxEMJhZx8xA9zdtkqHw7FH0J1jMP7cidjcEgwGHxnDi094OByOgvAaIJkwAcSENTqTn/59
+hXXUEYbD4OrlDrErgmFckm6AQiwa+kXHqlVSM5TaQTkGw/+IHI7P4N4uUntEdEsKTjAc3w5eGDyz
+px9+UPDCQJdUBbFbdFHQHBvW+A6UrHj1d93PzMCBEOaQ1ty6SLLjHtgVwfiOGAz5xWBQjrXQyoX6
+7JRp5DEYDofjQRCO6cW+sLsnOL4NYQr53qOe/N57UGRjfw5gDFXyCJ3EQX03SSiq74BNQpHcNykR
+FCcX+4RnkboQ4u7E+X/k/PwmHS0kn5SOy5A/Ip+LdTg+CzdCrgvxseaZwZM/kxy3By+M8XnMcZKO
+B0aHnO0tZ8dMWeUIDMqEoHwX20Y8NQjI6oeklECK86JZJZRImfdumf3TcT/simDcUmYrVGJd70IX
+2JNPaZ3T1Xolb4fjS7hH0OGewRPnAOxxGu89HMeOwQsjHAPG5zFPumnfe8cDYkFK5kAYeu0UXpI0
+lByaMZFFdoNK67IvR86KVxL6ByEdfbKlXMHYLXZFMG6vYABYdBrIuFfZewn4ZrMksnmv5O1wOO6P
+cRpzpicArmI4bgKeGOPriDCFSCaW9M5MCoZPHDwuuC/fCUO0q0Rp6IU8JOvHxGNIuu20RMdgzJxS
+d1MmF6T7dewOuyIYt1cwoIK5Ux73pRTby/+bmZn0pzM7vXA4HPcFTyEV9BMDgRCmcO9hOXYEcYca
+pzG+j7sSOAygKBg+a/2wKIWCI2kYZPJ2VhOnvaoCNtsJVUl7nZWOWXWuYjZcwdg3dkUwbq1grN2j
+SBXUA4qyof+4SjYF/yNyOD4Pd6W4HsLEufaEGAg88c2em45/C2EKGF/HmDwAFImFpCbVKUrhs9aP
+jFhIVHll9JTjLsKMXFAze3IY0qDya87iYlWCu3OhUsAVjJ1jVwTj1qnOVkqFCegurlJ52VKCvTHf
+jvw4HHuGu1JcB4ZMJEU1+lq7m5Tj78BTCeLOkYdatdCB3Uv87RNuj41ahYgkImoZAVJstFhDmMuU
+KqcMUdxzzhZV3DJL8U2kfv1e2Cd2lab2ZnUwUlEY6tZF9HR1jBx/0aU1ndIzXMFwOBx3BE8oeel7
+gDpAqo3zxMDhvuNz/DxITYucHapTEwK6sNoi78S0bLl8QtBTKX8zuhRDIXEYM/Jzg/pIDAiMMJcg
+8KhyaPeppFvMkkFqvZvYhlIK/7+xjxjhOYB7wvDSLgXAxxEBhOGFwMdgXbYEKW3ykAv+xfu62TYe
+AYbXAdR90O4w4HTAdpsDYeiH9DzeF3ZFMG5WB2OJL+OsQCyUKnoXl6iIuLwQDhWf4ZW8HQ7HHcHT
+iNPLO+iQ4i4WYHgbYqafKbgh5/gUeOKYhUwm32piUVVt5qqS80d3Gk+MsATwxHj//X6DI3A0sQB8
+KEWFqdf2DFliIAZzDuZOtk5KP2uyRUFqY8iO0rK/VjAIdADCMU2S1Ib6EhAmBl5O8RgmBhsiAQAM
+ngLCRGAMOMm6ZlsF2ddWuwXleFttJMtaB5ze9lcnbVcE45aVvE3t7q7KIpVezIVo6MRslP9IvZK3
+w/F5uNF7HZzeipFGIASkgmcd4fRyutewHD8MmZBOpaBsdofSxAJpYk7HYBgFY/025CUagGEO0SDr
+Ce9ebf570SGSh14X0oMqlBetnwEDAkJxo5JtkltUVDx0/CoKWZmVC9ZfKxhSfyNgnBnv1fsi9k8Y
+5DiSckuHyqA/MMLziDChqLlbbWt82C7ZhodhRUKGLuDpGMnNaYvI/FB4DMaFKKJZoxZGlz5z0JOM
+osiHmFlt43A4LoXHYFwft45Xc+wTYUo1LaY0qdbZIG6qYi64Cuy2CkbJVRT7fcJTPyJMY3LnS2/T
+gxOMb8WiArBVJW6WAG0VX1EqfotLFQMTEN0wS6KbuI0iG73YSqVA31+ho3jvTXWkqxQTHTDoe7A/
+9/RTfXzY9hPttIKnkZNu7O957ArGheAF8SauKIaOxSgZFEphmkw4ch2M/d1EDsdNsUPf1HtDKxgO
+x0fghRFeixsdgy3xFzeollqRDSsCdRzbLECYA/hVDEDrfqPrJ0T/euUPkN1sVN7IuXLFgY4jsO3E
+JYcb7XIPjXb1PnS7W45lfA3fbnzWYzXnoS9UIcZkSNapdM3S7L+2lXKWqZkLUZF+RfH4K6U6xkOE
+53h/ZaK7MMICDG+qb1FotKUosUQLQC9qeWobFmW56WvenWmHqs2CZpwbz2mSesbu3nW7Ihg3i8FA
+FYMBHWdRKl1KWj7WRGThWDvDYzAcjq+hNevj+Cu4guG4BNllaYpB3KSDuIHNeAsAKYuiXsdG0SAQ
++MA5pW2ejEuuNjSnWd0D0ns9veEPqAxEyu9ncVDhbNiVTEgDKAah2y3BHTDkqcGkrHTFQB5SS+5M
+i7gu7eOmY+l5Pft9699zCcKO16O4M+XlYvckV6pMCWftCpWuZW6baJNxvbqSbdQRBoRksKdzPwWg
+qwKoFwAIGH+tJ1jo5WTdlFLb8NzY38upuGNttesGvL8pm3QKGKf0vUc8bwtAhxNoh0k2dkUwviMG
+Q6sVMXCt0jPygyl9yo3tMRgOx5fghvD14QqG4yO0grjze7BBLEgUjBzULfGJyKqF2a4HTt0Jp8Mp
+B3TjNWRXEzFqKWX3MU+CTpvl+PCbfobUy+z/535d2uOVx3IE3t++L8j96flJ/dogCJCAbVmznnQt
+blQo9pCs7RFrZPQS5H0N24hALzHYOwepT5UiASSVYMDpNZGQOUSXvMPQjoE4DB/HAVV9luWVcgIY
+YhVjNs4Ekf9weAzGhbAxGFsVu8vMht6KQB6D4XB8EbVXrePv4QqGYwu6EjdQqRaNWAr5zfI7u0kl
+R+GlvZ0xtA8x0cD7nz8x1WhH0YBFciFxfB8S+YvqhV5RwrUjeUBUImZAYi50xW8dd5HbaDtJYjhm
+XM02oj4pXQsDEyN0tHYvk3iJjlJa2hOGA8DHsagLgg65ZtBZZBfA6t9qvwNOL6f47+2EoRH0vSfs
+imAYP8Erowij8qsK+F6sclG3Kyzd4XB8CjvzS30E3PJZ6fi5qCtxm7iKhlsNNYgG6d8VsSBDSNr3
+33AYcHo74X1+x/AyeBHI70aKB4gkQMVSCNmYAVTXjiTAO1X81lGoBOUOBaQq4OoZdE3bqCMMHSNM
+iIqYDu42x2fvPjqccOoiyQj6Hl8A9BfQny62+/Ao/rF32a4Ixu1n5fQfDVCEPR2gpDInQJGSK7J0
+h+OfgsdgXB2uYDg0NitxAxeqFpTXmbgLrV6AjJrxUfrpOLscyYbjG7GIK5Su5K0ySvUUg9tzDYxi
+E+WU/NI21cqwblPp93x9BQPibjTHdLND7bKUjq+cHk9uAAAgAElEQVSV8YmkaN5rsERhjsQ7TFIr
+Q33qPmd/otbYFcG49axcJgxLUSj0H6DJHKXaAFAxGA6H4zPwx/b14QqGQ8ALYzyO8X4QdyitQFyi
+WnScv5t1pr1t4+mnHxcxK5Ryipp1RinOzw7S2aYqImGtIsm6pWIy+ht5dxyGdM9tVMduKBhxeXJX
+WkKshSFtERCOAeE4YpzsJ5t2HzxRt9LU7hi7CvK+aRYpSGh3ClrLf0psWuQ/MEnlJxRkZnC3v0qN
+Dset4Ybw9eEKhkOQYxxq1xD5zOlm4+TaKtYCtRsVgaRdKzYjfff775EhAdo2fTCUe1NJV5toSJ8s
+nhS8HbNLQS1T/RTqktKzXvNeIJw2K78Thrf3TSuRDie8Hy5re2mfn+trX3AF40IUGlErFpTS8XG1
+f1mb/qA8BsPh+Br+Mb/V74ArGA6BpGUFoNyX1G+Jq9CKgyYIK7VDZU9UaTypcrXy+++RkUgBRMGI
+y2qPDB1Lke+HvvSBPqYYZuUuhdxn2qb3e2Gv2BXBuH0WqZwTQe1J5GRVtbuKwxCW7jEYDscX8I/J
+yt8BVzAcAgab2hUAbME8QBGG8ikuVfW2rUxS6LCq6t10X3HcH11yj+rVpGkPlS1KpZw1blSmOkbq
+jFKQdLGdiuKRvs+uZu0VuyIYt1cwGLwoYpH2ajNHJVcplSWDAI/BcDi+CH/5XB+uYDgEWonI7kz5
+kyrCgPXvBK4Uis04jkxi/O/6UWGyPKmA7pLytQR8i6WTi+tJD7NyheoB9EPur8RiuIKxZ+yKYHxH
+HQzqDG1ADupWvwFkaTjTCq+D4XB8Cf7yuT5cwXAI8t9XTRpS6nWdCYr0+k6npKXNdqQzSSnVIgeG
+7whS+fxHI9XByPERAlmWYjEiEhVZBYSjKrIHYGYMvU3iH5f7JNJesSuC8R0xGGZPCxS5ENWiHkdh
+8K5gOBxfgLtSXB2uYDgENpaCKjcoGAWCO9VWArgXrDNE1X000tayVjV+OHhhhGOIqX6XcO/hXAWs
+0tBG+0WlsRElQ1QKVecCfXGRim5UEigef6dSeDkA3BWM/WJXBOM7YjBMgHdXqRidVTE8BsPhuAJ2
+ZIg8ClzBcAgkloJSgPamG1SHElNh6ls0VIq8La1jLkTZ2MH9p4kFg0GHPRwVrHIBldxGyEKeONXx
+FlzUCxSKUbJNpVY9TMVvVzD2i10RjO+IwSh/KvXeyKwnUM7z7TEYDsfX4S+f68MVDIcgV+yWBbp2
+BSwxKC5RAJ0rrgdpy+uYC1EwfvL9twDjcczEYngh0AE5hf1PBnVFWZCCdJwre9f1MFSqWZQ0tK26
+GPG39ugY8j3wo+8Fxya8DsaFaNAH8638qUnQE6uHzWPXwQhTAC/yEOD0x68S8aa81oAN/JKgrrzc
+t93FtsPLY2Xr9pfP9eEKhkNgskFp16dU0yIX3jMuUTDLkdrTQuBEKnhV+8KqHz/1/huPI3iKasXw
+QtY9SEjYDwYviHW8JkZOOZzrmlSJ+PW1nqq2HXI8Sr4npI/UjhI5faw3juNa+O/Pnz9/7j2IayEc
+A9ABw+G6t+vTryegU9Kf/EFB+SUunFykCtEwpl3PGDoCXXls10A4hkKXUoFAyEMmvUSyIqNfIrAv
+FN/2p22bZhWV/zRPAe+bRYruAwZj/DU+3Lh+MnhihCXg9HK691AcdwZPsZJ3E40Cec2KxFtVilUd
+Da7and5OoKsWWLstwhQrOtOBQB1STEFEfvPPMTbzmn9XT7+evvXZx8lVTt4PhGjbxOKJFBPdLPEc
+QJZBaxrxfUNL+p3eUUbNqC2kH3QfOC7HrgjGeBwxdAPocN2bVQgGgPYfB1QGBdNG+yICdEil6B8M
+8eUyAAeooK2UKUI+kfwtZ/Xp7X54O8Qc5XOJFeLj4xnyvDDG58cb109GmAKw4OHUKsf3I0wh3w8k
+9Sq2CENCjDksbczvjwhI+v7+9v7wCRwYAB/j+aEuukEZxQIpiFmWTZFonK74d/XdBMPhuBY8BuPi
+vuX/bIqpZfHTkIvs05qMt4eOwYizEtGlBrmoDklxnb76nj7Nd9/2B24bCQf3nIL1HhM/1ZXikeEx
+GA6BxGAAMntdfuuK3jGmIoXuVoSBoX4vur1dBtXuoe+/JRKv8dcTGCHGWLyikIu51MPiXIQOydPh
+gY/L4fhG7Ipg3NKvmNX/YvLYupWWeHBXHkAEPHQdDEKUPNEnH/05BWupWW9Os+JxtibNjotxqtun
+dqa97kfa6358v3fdL82UlI3HxEMbIj8UHoPhEOQYDCB9lt+6onckEZx/t+pfFBJBJl4DwCrT1CO6
+xTBiVqin5yfwIsHbMc6iTCUC6EsMJoBSgG553Pe8w/Hd2BXBuNmsnMmqEakFL7B7W7QLFWATtckD
+6rpjG583/GY/DYp++DPHB2Vl9KJPyytjNRunun1ab9rrfqR95crj+73ffh9dwXh0N4qfCFcwHAJR
+MGijQveKPOisUlX9i/KeZEM2tjJNfQQGvqdwXVYsbFYoUSyKG2nyVJizfoFczwEoBM3hcOyLYNxs
+Vk4FdWfHp648cKJiwWq9KBycKQZmuvrMhvim/3U/Keg3z3CroC0ZMc/IM+X5U1GmTK9WM+t2fZ73
+0ev71L/Zb+rfuPzo/drxyXquxpfHX42vjLMaf96vHR/N1fjzcajxm/1W56c6f1yNL5+fanxy/rga
+nxm/Gp8OttPjM+dHtRMdLisYj2jMex2Mq8MVDIdAjGPWakMmE1QyI6n4ivxcrVQJBiwBAUyq2kuf
+LxJ4Pv73X3FLugHaikVyJYU6TsmylypY66x7Wd2Yy1vE4XDsjGB8TwxG/DTkwexfKRuL2qbnm/hm
+Mq5BMlJGCOXTz/mzuNTY5dJeu+To5XZ7We/9P1b/hZTZmchHgr+wrw9XMBwCAq3jI7LSkAzqev1W
+UT3VZqVayPcNksELI0wBT7+e8HQcwVMADsNtXKk2FAshFjLhxYAhDjmYW00iQtSN9Az1vyuHI2JX
+BOP7YjBKYrYW6cij6BQRmW9BL8p+/4ZkUHL5ijPxxXVGjFftUkNqvS//+ctLAPjjGvH+wr4+XMFw
+CLKCveUKBdiYC/mtlmelAup3HXOh+1IIU6yE/dQ/xZTpc3lnXjvr4pZiISpJTt3Sq199eq/P6o0/
+l6cSyeRMfob635XDAeys0J5OIXub/tMjZ+H8MC3zgClzVEd2GZLTVM+gm5STKTMp4/OI09tX8m+n
+GSydtrTy05egYFbGqi//+ctZXe+cCeXR8IhuWz8cBEJAuPcwHA+AEqCcfqf6BTqTFC9pfcelDlRd
+mE8HhMv61rL0+fTrKZGJ9BxKLp9ZReg5qhrH0biIRlUBMa5M1syI8WZi9s8wRUZlGQCghymQlycF
+Z47jQJloEwUjxqnF1gyGZIXktF9C3Db0AegJT9M1/7Z8gsXxM7ErgsG4dSXv9HjJyoT95K720i9r
+MSOtv/a4OD98sUS/1c8W+YkvkziTw5WbTdFskH35WX3mWRxUy2WGXJ+jagad1foYCK+WC8lRmpBZ
+7v3/Vf+adGQS8qgvsgd02/rpcAXDIZCZ+UwWJGZCflf1KyyZoBJjUQeJdzIZl34v6RmjCu3xHN9Z
+WVHtKRv71FNy35KpOfWG7+JbNi5NKsRcJvG4K/e3fHLH4Cn+w4Gsuyg4uz/JhKDsIZMOQNW8SO9d
+IRdpT8PbAF6uWwfD4fip2JWL1C39ikuvWcdQszx6fsWOIztJ3SCLlAaBIvGZv+IupfxJLZXKhijN
+0kJ/AlJ3QYKlyxGmPqqgZtO3Wo8qeDuPpdp+NUbv/9P9k/7UblQPCjeErw+PwXAI8t9XRRJISALs
+8vwbiFmk6gxS2UWKc7+1C1XcljAcBvz5/Qen+QR0Q5zYAqfsd4lSHChWz06FauW7WZb6orRevtfL
+Tm8nnH6fQCCE56J25PMwl/d4cWumEpOR09Wms6ZcpZBdqPzvyuEAdkYwbj0rZ43wuIS64reZIzWW
+ehxJwbjB2LJ6IQ+1lH/8MyRDVBkdd0Ebs9x6eZ2hSKdNlc9V5imVmUlk7HV72y8pI5vSi4dUkLL3
+f1n/de2MNSl5TLghfH24guEQMNjGTQAqQDu9YeosUHUwuM4gtajvpi+7rQZ1hPe3E97/nDC8nOJY
++lRx/sogEIaXSDawEMKRUwVujpNl8lbtFWGQCcL8Hk9PzV56RHLZus173uH4idgVwbjprJzKCFX2
+IvtiZeIL6SjOKwCylHoLaL2EukKELicZScpWLjTrYOCynCrSwYpssPpcZ0SSz0JS2u11/2W70r8e
+h/d/af9bZLCk131QeAzG1eEKhkNAoDUpqAiFziJFWtWQzzqTVKumRl3de2M0w2HA++/3qDYcTgjH
+28QKUVeIBouiMSErGmzUDKw8EUptjPScBuf6WA6Hw2MwLocpoKP83iuXFBMTAUamGDPHkMpjsITg
+i9+1f6l2XCrtopJySUxGnMEiFeyrg4GhjNQ1+eCKbOgK0a12pIzfOh7A29++fdmukEFDQh4RHoNx
+dbiC4RCIgpGDslvkwMRk8OY6iccgTVhW1cBx0aQBdQR6uf09Sh3h9ELgA4GnmGVqOBBw0GpG+Z4n
+fXr1Vk5xGuioqDoOxz8OVzA+uQcgvZwXbfazquxN1TJKNAOpImky/GTGw3xH/D6nfuS7Xj4X39Q4
+kyRuLnFfMkIA8WE3XaZkWLKUeuhRuddYR5q65gIQECYGLwF4DfFzYoQlAGpm3Ri/VVyAba8e5rLT
+mYFlBF4ZvIypvfwO4CnuN0xs+r20/+gmEIDUD14DwhLitVuCjTXJBe4C8CpXmSoFIn6GiQEl98fz
+GMDpPPEUgCUgpOPiSY5P7UeRAZrT8Vb7KXfcWmkySlRFih/ZRcoN4evDFQyHQBQMWyCP1kX3ajcp
+rUjoYnzQ5IKsalH39UDIisbvE3iGUTTkfSyuUGV6DzlIniHu0f535XAArmB8eg9Aejl32gWKVc0L
+pWB0rChHbCtSanww6e+VKjLb/otBkB5eKutPWaNVlPSZxnUuhS2B4qzUYShZMipDVHpdzYprYiIG
+sYxsKSZMPnMvA7TiY+MBkiEPgA8nEFJWEXHjgZCI1OOiZpU6Tn60yH3jZchji5/n+8+9zSHNQnF0
+DZhKrwCAbgBhQE5juHA8f0v0HZbsWwRFBqYQUxjPQyEEy2hmBPNM4mSPiw7llSUvtDCF6I7woq8j
+TBYwyYoi46gL8dmA/cd9KbohfH08HZ9AIDxNT/ceiuNRoOMpFrZkIb3PVqlnQTlTFBslQ9pxSU+L
+et1jgkDRbWphhNf4zqAXHekorqsSh1HeuOgYLG5iDsc/jl0RDG1a3wI6aaheqk1YGYk222S7MmNs
+KACKy1Vt7rWXE0jtV41rIVCXTVN1VvAByeCcLUTPaZcR1M5h1hytx9usvppUAD4G4GXAoNQDSW0b
+VYD0IpsCkNIYioIS85yfgBc93x7AR07G9mCvvIo9wIxEFKR/Bt6oGkNSauRYUnYSfZ4iQQlJnYpk
+wc7ssb1iadwEZNKiCdbqfC0ADtXlqV2ZXkf18mcM+a60/ZJeXp1reUEat7ZHNeQ9BuPqIKV4GYNv
+63vrty/7+cvShAYO6nd9/dNzS7s9lVoY/KFLlYnB0GlvHxzUWaIRlpjRCh2Smi/PV86xcR6D4XAU
+7Ipg3FLBEJNRawS6ysD6V9lKkw/rmlBmrlvxHFo/0IZj5YhVtuy2xpfGsqAZk8Fpncx0a+OzLtR2
+LtYiZhwhUDfE8WbXKYpGtCgIU7xStk9OM2ApPmCJM/UD1mRsACsyIArSoFy1amqX9B3TfwDPp0xI
+MinrkVWYSLqU4d2nYzgmUvEm+0vrF0S1QQVOyzjLLJ64m1EhPKDihnZQx2BcmxBdp45cuSis9yef
+63FUCkblJlbI1YPhhxgkPwnD2wAswOD5+v958BQwSiC1vAcaREMXz2PAkIlcjK8jkCjXDaLCLbLz
+4KiJBs+MYYleDJloeAyGw7GCx2BcAnl4KjUg+/TL7A6UK8ciakDRLjQhALQ2oZWXuBWg+1yrGGX+
+vvRflqW+Ft0X5ZdGKyaDkCTuesZf+f6X3u3ojA//rGhYn373ylA+DOllU9QcOYacM/1AybBPRKRB
+dCzhQh6R3h8lw724b9X9I7s+mWObNeVIx9aTircQn+Raw4kzWyvFZeZIfPJLR5EiqTzboZCOOe5L
+9yxb8RSVJjqcUhErlH40malS1a6zSKFkpTL7eUxp32Mwrg+PwXBkSCVvnTGqpWLVapbeJrfhknFK
+YjhyfAddHOD9iBCicXpNMRpHBk/wGAyHYwO7Ihg3c49a1kZlJg+dNrETRehqhaFsBej2tZJRQpL1
+UbWWlbaFmJQ+KT/QixaS9qxiMvQeaEExQs2e0mc1200NQ1oMY4IY1lE61nUbSGIdFsDUZZgZQHJx
+6ime7yWqI4WiKWKnqFVG2l/rjG72j0JYbCxCWlYXuVvS2A+DImOJMC3IdShWxry8iHvK5yUjb8eZ
+FDTJwcspkote3zsNolf0mNwiX886pa3Z4jHhhvD1cUtXUsfPQq7kLQprIguUgrQBVAHfqo10oklD
+5SZV1Ay2638oMtF4OwEzUgIPxOd25/TC4RDsimDcclbOmG6LjoKQtVsKgzjr2DGuzWQ9eh1abXWK
+lRay6GU1obDkpMznW5Ih6kbeeqNAXq6doI5A11KwZ4mK4a63kRdRqsdAs3ZfglU+wDF2Q41hHZNh
+lQQyZ7UEzLOeRYPuHzYTVp7VZ+A4gp+fwPpzYqA7gQ7q5apmAFmRBGPMywtZMoRps34OCK8jeKo+
+F1ZkJe2jSifL0ERGqUVbGaNWRfm4ij15QPzQGc9HhisYDkEmmjKJZlQJTkRDLVMVublWN7YyT6V1
+pNr8dLQVjeDE3eFI2BXBuP2sXDLUO70npV4oN5g6QSqpNTBmcO0aRcr0ZG0mw85OS/o/TVi025Ca
+61/s8txXisngZGjzhuHJalae9cw7RNEQomCDjc2Meo7TSBv25fiK+9KQDGAoNyZU7kb208zPN4rW
+UY8YMN5RDNoWxaFLKkZKHcsyJjk+/RKsUywiZrJa1Y5YYEhQMeaVggEhZFzcsRa2/5JSsgru1ulq
+03gI+lgb5KoiFfo8arKWSdIj4ofPeD4iXMFwCFhIhU41q55/XJGHdQE9RVAyEaH1c1PHbuyEZACV
+ouHE3eHI2BXBuPWsnI6pUM5DxcGma6kFnE1tGaPeJmMh015ykW8pEOv9qzZLRUpydiNDh3JMBmZE
+YzWRhbXhWRy02p9Wu5G4BT2jTtqg7mCCsVmIwhRn7Xka1UsoxOMQBaMyng0qA1sqYfOCaLBPjPA6
+RjcnldJW0sRmJSBdD3o5gd7eQYd30Nspfr4Mqa/QnvVvKQNawciqDxKRAnA4xf7f3uM+X+Pn8Frc
+sCT+Q+8xZ6XSwfaG4Onf+nrV2cse20nKDeHrwxUMh0BPjnFNIjRJ2FIjVOG94jLFhohQg2zsDZlo
+fFDY1uH4V7ArgnHLWTmtQBjlYqmDrG3gtXYWku3XKkNML2u27pDUgNSLyq29NiHLngAkVaMY/1su
+VIT4UJRgX6uN6PgFWgVbt4KvS6yCGOvKTUe3SalYaZZZe9l7lJgxpU95CU2FFK2Dz5WRVBvYMwFI
+2VE6AEso+1hCITGzPhZ9JVGUAVUYMFaXTW5XomLIi7O3qW/zZ56xqwy7TDwqZSYTPZQ0vjoAX13V
+FbGqFQy1v/oab5K1B4IbwteHKxgOAQPW8G+RioUsSajUCCEbXG0nMRvGlWpH6oXD4djGrtLUFpej
+6784cwo+pWPEh2mhEibiYoEiDa1RRtclroLH13PLnAkI6+0XKr6woJi9QtXAaIwUxbws5uTp7YQg
+KQorg9Nub6NHmst7Apa0rllFWsx9Km2EPEgBPnFhEhVgGrPbkLhjGfctZSijGg+DU90KAh2G7K6U
+8/9X/WeiNMlZRUWOKBr6ksYWSNmxAByRjX/qy/7jeRQyU49V3V8NYz/fTRW5oB4IU9kyH0uVGlfc
+oFiRljqFrVmOB4UbJFcHgRAQPm7o2D0ov69E7Y1L47Mcud5FM95iI22toNT+se0dlyMcx5VrMoCU
+rIRibY7PYAkYX1Mx2W7A6a2qH/VXYITnAD4MOB3SRNwE0GfHeBMwwvMIvJ6A1xjbOdS1s6TlcUQA
+YXgh8DFccP4ZYasdAIAwvA6g7oN26ryNzwF0GD5/fR8IrmBcCJtFSusDaxWBgZxNwsZgaMOyZKCy
+/djAbktRlFnfUDzsXkS21rQEOUAdPXLRvRiDQTZgeyuo+txybSRrt6ikDGTXp0PKva9qX5QgcaXv
+9LBZp+r4CxPkvR6PvDhzPQudpSnvQ/fPqwBqfRwk9TrENUoFxsfjSQrJbK9kdiEAzLnNLlYdldiK
+HHCuj6MmT9rVyWoPrPazjgUpgfH5LjPLHxRukFwdrmA4BDkK0LhFcZUBCkbZyG5VxvWJ1nEXlepB
+etnF4/vHMaVn/oHUP8TkIMeAcfrMGWKE1/jXP7yccHq9JrlAIqLl3RyeR4wfbvQ94GNAwCl6bRyS
+e3jr3bKEmBmsS+fm0vPfbKfay32/1a4v3iQA4XSIGcp+8v3vCsaFWKkKqYLpOgDbxldYhxhGKhNn
+2hlCoOeys/ys5+TL0SIvkxZcraNYDEgRG+oCADJ+otLOKCTN2XDkAm3UrxWOvJ+JgT4gLASaY0B0
+NrK7IZK1rF5glYEqn5GZVE2MAHSnKlVuOYsAsnGeU+rq/pNqwTVBQt2/KBic6nAEYCJwn44jk5Yh
+qTBpvwdKlcrHSKDSzF1x9Uoqij5nSfGR3PFK/6ruKHsfFscwm1/M3BkfKRiw5+ORs0i5IXx9uILh
+EGSjf4EhArpgXFY3gFQwj60aIUrFVh+SsvYTCgZPydBDmQz7J5HIGx0qMnCIBnyYANZZDc9CJspu
+NDMuAf/iFvwwilW8l4a39DY5EOgYMM6M986eB54Z3BEGlUzl7PlfPmhX49J2hwFD+hs4/VAVwxWM
+T/WvHIeUYgBQrl5aPOHLOt1Sj1GrFc10s13ZClW/2jnIKByLJSvIYxaXn2H1sGZwqoNBKlhY9aqq
+e5fq3bBt9K9FKnaHFEDNKYvTCfQ6lLMh7kudPUfmu9SsEAKlFAXuK6O4V8b4jBwTQh0Z1UL3T3It
+O87B3gUpHmSJn5EMUMx2dRiy4kE9IuEQZWYK8diFXHRDdAGr09cKcs0SRQYbCoRJMau2q9PsrmqW
+qF2pOwVaFXnkLFI/ew7nMeEKhkPAQgwAW7tCqQ9bmaR0XEa+m1p9NBWPxlgWxngM+O+//zAeA8IS
+/m1yAeTshNt/rTqNByMcRzz9eor/noN6rzHC8xPGCQACnn4p41itf3oO9om7BDz9eoptl7r/qg+z
+rzFOYUxj6XMJGJ/V9r+e1grMEuI4fj3h6deIcQoIpt0HY2idoYnBMrkJACAMHbKaoM9BnJgc4nrg
+4/Mv7sUfXqcL+8soSstPfQO6gvGl/mvXJVYF92RNI1OUohnxl4qZ6NpqBup9ZuUkLV+sSlFmwqna
+PuL0MrSPS/KX59EpXaRRX0FiKyiRjmjsv4PeYNOeZuMYJYhaCMrbezRuFVlpzdrj8F7Sy64UjAH0
+Vlyg4h8up7Su7yXtLWAUGJPOtn/PWZrW+1MzMjmYOikEiMfNqvo2vb2ra6iu92xVGgKBD0MkP6lw
+oYlvWSkQZczUAyxjzsqMOie6nfzO11rOr9a9HlvB8BiM68MVDIeAEF2baIGt4l0HZi9lIg3Aqg5G
+JhRVHAeAGB+4UjzkOyPMyTcd8f0iriJOgpETkRjLZomuumFBSjoSEY365KHQRxVofGUMrycMHYFe
+TxheRwQMOL1R9WwlDK+E8ByvVU6tLkVqO879Dy+nnAJ+fB6Bt1M0yLvSJ70OGF4DQj/gdBhAYITX
+AEaM+wCSSnUMCH3aPrUJGJLawODXgKAIbHMMrzG2Ymi+KxJp6LVikDwKjvZYscRzOryp++6j839I
+NkFqF3Q2tZxWnmyShLodqjaypMd6jD8IuyIYDMaAtQF9DWjDX4dQW0NNZZhaosy2Cv4Gme3t+rXD
+kxCLvLTTfSFXDa8NRh1ILn/wWzNBseWQe4HtYfVbB25n8qFnxJXiYc+cdYECYDMj1eTBfK7dtnI8
+waxcjkzdDjXuaryaJMV2YpgX0lTGUc6KjlfgNP54vGr/6ViLq9mG0a+2bcW3aAVjVYukV9TxgzoX
+q3O22f+DkoyHkNj3BVcwHAJRMPIsLBANxYWrwG8uBCQTESopabVrlKSvlYxTehtZNjHGaYxBwGlC
+h/rodhoncYDhQDHIGXYC7z7f1+9t/f5et7t8D6cDFfeiGguALmD8tZ4QoJdTcZ9ZRoSFMLydsjFK
+LwPwa4zP+lT7iYEcoLzGAEJpDzD4yMDLAJoCxtR/NuRfBgzzGN2PXihnhRTPAF4Q3ZHk2vcDTiqw
+ml4IPIWyv4njMfwWS45Ar0B4TraEOkYzhl96zOvzxwtiHITGgUBT8rZIJI2nUNy49fnHR+efc7vw
+3DitL6fiirXVrhlwX1+Pn4VdEYybKRjpD0XqXGjjXWeBKms4BXlrJUKPk0tF1PQp6kT8o+TVjFKe
+ARJCUcVnaKVCqybcxYf3udzchPhg4FTorpVlaGWM1o9ZPeMOa8STZF9SbT76rElEHbGSjzyrJ9To
+vxjy9ez+2uAvpIRrZaYx/lZGpkyC0kg1IaljHwB7XusYiVUWqMZrbXUuFKnZCs4/m2XqQeGG8PXh
+CoZDkP++8rsG2a1Gx2HYtLVpW3kvqWVNFaS1TPbdp6eZxPXNFJ+ZfXqGdUOe/hrURJgYoHpi8bbf
+5dv6E+rXl/bQnXnKdQBEcQDAEteYMw4lzIi2xGsKrFYp1DnHaVBJItJ6sqasSOPE4IMoVnEZH3lt
+fNf9dWryTcauSOuQCEUAsgpQ/AIARkA0qjKvB3oAACAASURBVKsxdVIPK52v1xFjVRiXZczN8xfH
+ahHjLMZ8LjiS3ZeqDzn/rx+cf8Rl7w0vkfV4Sn96PK2xE/Bjn9S7Ihj6T/aqUD6lxpBbpa0tcxn6
+eyYgSSZkEAZxbek5/TklgxOMQWbI+/jYsstleyBMIbtECa3ghVSl8bjfjwr/MBI7bhjedcXn1gz5
+OnBajHL7aQKwP/hczfqnsSrtQ53h7bG0Zu9bY99UCfI41oRAG+6r1LkrQqP23SBlsrxoYBUtPUOO
+7PkTRUbPpp3f1vx+QLA9E44rwBUMhyA+/1EIQkNtsIZiu20kJqQSelSTZIBRQOhAOB3iuykkVxkh
+HEIyMDFOv+WZmOe91VPSmmW3/U7VHrfG8fk9nEXKhJhjFbsTGCPG44gR7zilmfk4SUlFMRAk8pLt
+hJnOxgDQASn2kGMsYXfCCdh4CsuEmYy1arUgpnFPbSUomrohuhZ1BBw/MJ9FAZM3Qco6GWMnpU3s
+q3lMq9hKfaxDOlaA5oDQUba/7DF8fP6j6xPVZ6R5PPp67hm7Ihg3UzBQHIXiH5TWDFB+53iI2ukp
+YuioBAJfAWEKmr7E/XZlbMBl2TcKFYE6QiSDtZqdz7P2UMZpaxZ/LR2LsmHdkJS7khjDsMqD3pdV
+JNoKwsc1IGANa5SHZyFWomygIlznPyWouuUGZQkQ0CRWUOpHflS15Pdt2R5my3R3Vue6dm0zbmuP
+hh/oe/rocAXDIYgKdvpRZ/5Rn8VdSibYbNtWzQtWfTAa/SYMhwHDYYiuxXMM9BZTLdZ42r8xtomU
+dVFbNnQ44TQ9YTyOOX6hrBtMLAJPQcXhUUm3vmUpdQOGboyKwFxciyi5MNXxADlGA1AxGPY+kHFE
+96dTmQZeAsbcnkCiAJl9pL6SuzEWxPgOtZ4nUfpbxyOuYQ3TvyOcuoBxCmk/jTiORgxG6/xHInKB
+/dm4nufwIWF5YHgWqYv7Lq5NRc6zMxkSD6H+1Msccn+bmVgZQ34Yq71fmn2DwTGLVD2rrdusDHxW
+VbqxIgBbM+V63KgUDn2GTBVs9Ql1fPXZzISmUhpsrQe2xwVkwoJZqyNqzJ9QXnQfZh+w57NcqUIS
+Ch0lc37rgoWamNnMXu3lth89FjKZqR4WHoNxdbiC4RBkBQMos6uAyviU3neZhHAhC3VWKPH9X9bb
+f5RBCkAqXDbgz+93nF7eU/rvf5wIpwyP9V8rSeG21+Q+dBgw6N9g8DRiPIacGTIqGDAKRkwHrDNH
+UT7vvKh0toe4P34tbSNpAIbX1EYyLVZvWZOhMZPMNNZFtT1QOYaFwUsoxzO3jjGOYTxb5C61a75H
+ouKDmREmdRwaG1mf6C0FrutzN6faFSm9bPlU1t/G9WxiSk/qLfL04NgVwSizvLfoG1mes/PE+tPO
+NReTl5PBfoubhKu9A7qI3iWI5OiMsQtrpFK/NoZtYb1CCOqrYajXqohd+azdqySWA/igT1hFYxXn
+UM38a4VAf2rjOxvhen1vjXOq16v+W+eTq/3V8RTWtazxeeb8azKyuo6AIoCVm9eDwg3h6+OWz0rH
+z4IoGDqTjhAISr8zVq5Saaqiyjhl1QrejME4O65DzIZEH7j47h55xrtenoz/hVO9kBT8jIBRUrwe
+OQUiy0YlZiKCgSkgHG3XJAa1iWkgnF5PQO7/CeMRoBc162+S0ESiQlPA+MyFHDyX9LKclmlyk4/h
+ecT4zOBe4j7SMb7qY3xqHGONOI6SgKVaexgwLEmFaZHfrGDUGGJg+xQQptQOAeEYSV2Y9OeY6mgl
+tK5nEyErMD8Ru3KRulkMBlCZhspoW1iRDvXSVrEQYhJLdoxrQszGQno+jrmowaAUzDWsZr5rQ9+s
+l/1WbjclqBvK7Uf2ddln2aYY3iamAGs3Jr3PVdxDFXuhs021YhlaaozEwgB2e6NkrMa/Xkao+7Yu
+Y/V5rOMr7PnHagw2uL6QlpZbVU2JHxGPPLafClcwHII8HVa7SYlLlI6bqNPRgtftqn4IZf0qFe4F
++Nfv0uHtfdOqocMJ78awptg+BWe3DFN6ece7ak9v+ndCN+D0u7HXjnB6e88kdO26Rjj9Vr0fouEv
+7z16e4/h8Isa20FZbQsjzNUxLwHjRGUSrNPH2BpD45h7Am2meyUMv7fOMV1+/g/b7S7bV42oqtDh
+5z6pXcG4uG/tXCOmL+csUvW8NLpiXmZHqpu5oShy8YWiRPk4GjPhK+XijMpQu/PU7XQxOFKGfGt5
+MfSLi5NxdZo1edtSI+TsoDLA9aeKR2gcq3Yxartttc9ROSdrNUeTgjwGcyyqnT6+6nzx5vkp6+vz
+uT6/ikA9Kn7o7M0j49FJpeP7kJ84xk0KzTiMfMfkLFLrdtG9imxWKb29uzzeHree9f5kkDJVvzbH
+1jH4ONqiesm9aB0b8YkxdAOGA+fK8D8CE8d6IA/sXfARdkUwviMGI363DjUNJ52qHScD8/pjE7Ma
++Bq5iH2QquStXZDabj21e49xBzobK4BGsPZ2liqjXFTB3M34ijOZpIwSskGEbDXsbRVn65OaZKUc
+q776lkRYwsUNcsPzWsmpf8t52qqL0fpNuv2jwg2Sq8MVDIcgx2C0SEOnlqnf8mkrfJNyj+KyXNfW
+0H04HCsMGF4GcK7UPSZF4/TXTyt6OYFSzMjjI5IhqjOC/TDsimDcdFYu35RpLzpjhph4Jh1aNZo5
+O7RcFQR8OuZi3QerSt7auEVDZWjFNiiXHz2uBHtWUKkAljSYeAWtJBi6tmFsb8RFtOIb2sqC3hZN
+t6vzqoslF9QiCR+oPltxLufiRc7FjTTjUDQJM/0/JtwQvj5cwXAIJAZjFcwNxBiLDlWtC7KkP7k+
+AbwO/JY4Dim8l/twONqgw4D33+94fzvhlD7bFbo/3TNOv6/V160RY1FWdTZ+GHZFMG46K1fXwZAZ
+G8RPAlKgdBmNXlfcYK6M/vMxFzX0uDRByOaHcbFpzYJjZYS3MhjpmfishjTdntYz/PXYmkZ3K3tV
+ZYQrJzZF/gphqN2qtrJZZTVGj+sDFzIy5GQ7wL1WLJqkqlV/ZFXzAyprVDruKm2v7f8x4Ybw9eEK
+hqNADH9eZ4NqkAYCr0gEq21KcHjqvVZHdFuHYwvnig86fgR2RTBuPStXTNWSJQrps7hGrd2lOBm/
+154lpo7+mlwAcVxl1BHGmK/9/nWbOrVt/lzPzLdcqmo3nTjjvtWnGoOqtwF1RdbjbysBW7/N8i13
+KENqlPtRgwy0XMS4iv1obVdnoFopFobwbLk9pfVQd+gZ96mHhRsjV4crGI4CsvEX8tkp4lDHYVTt
+zLbdmnDk5Z/MJOVwOH4udkUwbjkrV2a8C4nQZmBZY8lG+R/bhWC+iL9xi9JgUHzw1zUrGtmVxGAF
+CvlozeyvXaVsTEQrZqJp9G7M1KMy6o1CcTYO5Pz6c8uzUiPHs0FWjNtSI9Zj1a/erqlE2AxYrMhD
+JHwNknTmfFJ1HksF9geFGyNXhysYDgErlSK7MwFtEmGUDEC7S9FqO7KTA1Vch8Ph2Dd2RTBuOSun
+iUShGsm8XWT2PJmKiw7zLi5I2jh/JGTJeyO2YK0eIJOJlrIBNFyJzgQa5wqdG1mOTPzHxgy/jsU4
+n9Xp4/V2uT7eYpjXqkrzfGyRm2q8xv2pMv5XMRQ1mUJ9XDCuXuddzSoy9KBwQ/j6cAXDIchFvIw6
+QdadSZZpJUNqE+iAb0NEuO0a5RMGDsc/gV0RjFvPyhVCUbJHMaBSpSVa0ZVxZAWjf1wTLmeRqpQK
+bSRfNNPfMH61W9RW9iOCTa3aMtyFpNTuRC23opXxXikQ1s2r4X5kxg+0yJZVdtZEQFy9Wsdkjf9t
+0qRjVIob01oxqd3EAO28p/elFSXt2MfVmseCG8LXhysYDgGLe2RFDrQ7U1Q20l/iOYVD3o0V2cjV
+ml3FcDj+GeyKYHxXDIatcVFe1muVo5itt4jBuBZ0FilBHukHNS0kYHkroNkU3Ft9KpLSIh+qEN55
+dcUqI6uYhHyV1DFXWaxWblh6HFVNkHOpaNdpeJUqU53bSgdrk6YNItNyo6qPu0V8zqX6fVi4MXJ1
+uILhEJTpsg0SoCtz1wqEuErlbQoJMdW90722cqNyOBy7xX9//vz5c+9BXAvjccTQDbEs/BXx9OsJ
+1FkPe5nt1i9p7Wii1+XZ49cBwyeK03wXxmMoBmYP5CORAGJj/CeYdSjGtsGaOKx0HLOdMpTz/mG3
+U25Gti+1D9MHgZdxtV4CxDU1jGC7D5XONdPFwwn6Sp//bo1/c862zrOoH/V5rs95c3u9vD5XH4x1
+jvTm/W1V1/Wu4IUxPo94//1Y4/rJCFMAFmB4uaymrGPfGI8jeOL0nuM1AVgRC2rXuqihqoDXxOTR
+njOPC0Z4DuB+wOmlZT8w+BhiUbYXgJ9DfLLrmMEeoGQbkenTtsFMoANh2LKhFsb4GoCeMLwMlQYq
+fZ5b1ziGJWB85Y0+HT8Z/7v3AK4JbTJeFZL9ohOjrMw1GxeVhVNqNTZONjImmrkUG3ognF4G8BTU
+mWMAQ/GjxYB4tOWPnw+pCB3SGegYhCFvXebih9yH/DYmbyf9pqUHRMMYUOeqtOGuzLdpxcjs6zAk
+d6oB1DGejumaJGUlkovYR3QFS7+FePTKWSqty1d5JtAL1HFp5yM5V/a8oRuiAtLV5zG1OaCMN7XP
+OKRxp/Nhz2HrOqlzcWDwPOR25RxB9aMoVkeF2DwQ3JXn+iAQAsK9h+F4EJxeTuADI7xG4kmdvM8Q
+YwprMrEwSN6LWvFYGp9otPmEghGmgOHwLxNhAh2AcAwIh3YdhzAx8FLeu/Hpnt6nAHhihGkEpgGn
+t/L+4ZlipWiJo5kDwgQE005hDtHumQA+oFEEjuO+OmrUcGDw3LDQZi59dgAdvnCKHA8JVzAugFYw
+gGRsygNWtVOOLUa9YET3HuqG7ZkBx83ACzA+1ypUxJbGsjXnP7xSIgqO74IrGNeHKxiOLYQpIBxD
+cn8qRENiMcQFSpOGmNhk7XKXSUhD5Tj39xwN4oAwBby/vV/9nf7jsISoHBzWxdd4GjEegeH3CQMY
+4deI8HLCe33OlhFPz/Fvfjhgu90U8HQMoJd6X4zwPCL0A4Y5IPQnvL9U63+NadoiFoorZCitOzS2
+0X0eGuNx/Fh4DMaFKHPV6RHblVnuwsf1bHr5Hd1eHjcGY++g6noJ9bOEMLc0TlOrwn+zP/y+HR6D
+cXV4DIZjC8NhwOntHUNPJkMigBKrV9W/4PSMBVCK0Jq6F7ROg1uBF0Y4jvjvvyeMxyeEJcT9+ow2
+0EU1gaf6rzYqBuiGrJ1vuqx1JwwdI0gfW+0OhKFr7GthhCW6Tw0HAqaA0HKlOwxxP6/Bbt8hqRV1
+n8Agk6/HRp+OH4tdEYzbZ5HSOXeKk5QNz6Wc7m9VE+ORaw3sGDlA0WpQ6kGn6UW5jgxNCsm0cXwj
+/IVzdXgWKcc5UAcML6dYa6lDUuzJ/i3WweBSuVuetWY92zS4apswBTz9esJTP0ZXnxQ3RikewO/T
+iOEQ417YXIP4e3hV50if3wrUo539y7aKitFSUZkpRBfwjnLKeK5T7ydX8uEwAEuI11Ov6+3VFHJE
+BwAH6dPfsXuBx2BciiXJvXneW7lALZQyS6X9m3YyJo4ZgR4wBmP3kJm1TCvKA6wsqx3crBMVg01s
+huP74Gf8+vAYDMcloI7w/vZ+3m1KamK04i+2XKsW4Ol5BJaQYuNSNjuk2L70m8F4+vV0j0P/Vlzk
+/nkYMBxHhJlzshieGNwNNi7jbNB9ep9JEcQPJm94EUWKSyZDIComh4BxCuCDitWQPl8GnMAYj9GV
+auigFAwVOTkxkAO7BwxdwDgx+OBP/T1gVwQjhsnexqdY4i0KXShZpKizFQWKUVrao/c5w3uBFuu6
+trp+AAqhUGsWpOD1RBjneK3hV/Fb4a4814c/jRyfwXAYQD1Ft5ekZoj7FCtDlUyxvkI+WnEY728n
+8DQgTCPCQqXGUJ8mFWYGHQYMbyfQwmY/kga3dvXJMR9qOVVjfLRtL0dMMIKjGOC1gZ6wYNutbEmT
+aDLeC9oByO5Q1CMnhJF2hYTYfdNhwDCNCK8B9JbUL0UceIpTHLQweErP+Z6AqerT8WOxK4JxSwVD
+z3nnDBrKYNUhwevlMQWoG6f3gVYjCj2Ma+L/QiiiEpXvoo7tNcxtHd8Kf9FcHa5gOD4L6gintxN4
+YozH0aoZ8u6rlAtjYNeZpADQgXA6vOOEaHCOE4OmkLL5RUJzejml7Iywz4JOvU3VcqraAI3Yjwfb
+9lJQPwAI4GkA9QEBKQuUxjnyor0oNtuxbYeUpaojYJanBsdsjynWYngbGn0ShtcB/BwQjkM8P1rB
+kD7ByTVOxlf16fix8BiMC1E88LULVNmzicGAVTvytg+YAvRfQh1PYa8WErlQhAN1zA1iwUHH98Jj
+MK4OVzAcXwUdCO+/36MLU5psy8VnFyBOwqH8VgYt5Tatfge8v51wmt9xOqQU2j3FWXpHRBcDsAMY
+/MopoLpqsxVbsQSMSzzPdLYdV+1CVBQOMSbn9JL+vZ1wSm5twVxvPd4BwwtFtULHYCxJvTiovnKf
+sH06fix2RTBunUVKaxLlOyXZU7nhyEM2L0ntPQPRXUCdJn3akS1JsZl62Gums0jlq+jX8NvhhvB1
+oJ+N7WelG3KOyyGGphAKykQiPU2z20whH9k96AyoiwXX/vz+g9PbCWFxpa0gZXA6jhi1C5NGh+hm
+NMUg6/g5YnwOKXaibhdTAkutjLpdrl3RcKeiA0UXJwnMbqgiJCQoKRi5zyXWnFr3Odg+HT8WuyIY
+t1cwyrdilEp6PrVvCaSCNY5cwbgPSqrF4taWr2inl1WKU/5fX39/6H03PAbjOgjPIdW/YHOn88R4
+en6y2WkcjgtAh+g2NbwMpTCf3Fd6NlsbwmeyHK367yiRGEdGDqreqLi9IKoVU0A4jjHQ+ogYeP2q
+4jVyuxHhGDAex0Y7SYNL7ejWLsVzSErb5jMkukrJxCvrPpsEqerT8WOxq0J7kuXi2lU/n349JR/Q
+RgE940RT5x4qs+AExnAg0D9dkfROWDhmLOlK9W19JW3It2QGQyrMp4LBe9ykkKPjPBiM8ZcX2vtb
+hCkgPIcURJto9Rx9n4duiClJHY4vgzE+B0M0eNGqmY3J8L9nh2PfcAXjk3sA5MEZv5VlVrHQRd0I
+8SXONx2bYws6xFs+dS0TaVWuGeUg/tJDzHLicyp3gM+sXwXDYYjpP2dAiDX1pd6Aw/F3oOxLD6DU
+zkiz1Nxwn3E4HPvFrgjGzWIwdHo5MUq7Oi1t/OSluNvkZQAwF6cqxzejK9dHf8q1yk5TS51uuHKF
+g8cD3AN+zq+H4TCkyY6YBSbHh7my6rgS6BBrZwyH5DYl8Rl1YT6Hw7Fr7Ipg3LLIHuf0ctohChWZ
+SPnBYQ3TvJ1X8r4PJF87qmxfqrYJIDNt5fohbQX1mz2L1LfDVaPrYRA3wZlSxWSAXgencI6rY3iJ
+bndSMyMHgX8iBsPhcPxc7Ipg3DKLlJnpLh7Myu1JhwkXo8hs51kR7gJ9hVrh3FBXrKhMdUrbdD09
+i9T3w42RqyG6QlHMOS+xYZ2rF47bQGpnDC9DeYZqNcPhcOwWuyIYt4zBMMbnUrQJAqf0e7qqQslE
+1Nja8c2wkRTrjFI6s1RWnxa7NVVEw/GNcGPkqhgOQ5wimeNvj79w3BrDYcD76zvoYAO/HQ7HfrEr
+gnFLBQOLCtzudNk9lf9bjFHjy5/W9V7Y6l6gTp/3WnFK13Qp+gZDyfmaWPR6e8d3wf9urgs6EHgm
+UM+gg2eOcnwTulI7Y3hx1czh2Dt2RTBuWgejkz0on/1qv3n2O/nyy1oCUgYixz1gZ8w4LzMxNd3a
+JWpVN2N2HeoecNXouqAuFc2aN/LoOxw3BB3o6qnkHQ7H42FXBOP2lbx1cHedaaiOvaiqQfdunN4P
+xWEtU1ClUOjltjpG/KZdqzzV8B3gMRhXx3AYgEOt7jkcDofDcR38794DuCYYjKFdb/KvUSomaOcn
+oRE2JoNza/nFUcHo3Nnj2uCFwfNW8Ty7VF8/rUbVy1vxGUWjCgjTsLrOZvue3HC7JjwG4+oY+sHP
+q8PhcDhuBq/kfQGkkrc1QFNtjDS7SguBu7Iu5v5WykdPGDp4vvkbIEwhXXsC9QBmAH2pUowUzMqw
+GlddwzteT0UnFs7VvGP7hLwP+yl9eUXkK2MBnp6f7lb59+nX0132e3M8SuGzDji9npyUOxwOx47g
+CsaFaM1mR0UiaRTdep3MakcFg8Gd55u/BYRQ8hTAkkZWUgLPWs3gimTo+hhyDUWT4lzNu+4h95k/
+4/3h5OI2eIQYDHrZSbC5ItwXLf8G8AKMzyNOLyfPaOVwOBw7wa4Ihp6Rviq6+BKMBufaQC2qRnsd
+I2VsyW40jmtjOAwIAPjI5jrVFUlsoUQGFgJ1bHQNeyW1c5yNs4FqgT5mSHHcAA8Qg0GQ2hE7wNZx
+3On4qI+xIONxxIDBA4AdDodjB9hVkPctK3nrqs+24F78VkagayaUb9GFxsnFLTEcBgwvlOqUiBJh
+K1isKnR39q5ZZ49qX1P5lO2cXNwQj+DGk9BKePwTfttMaJcuv/V39bTugeGFEKaA8Xn0WgkOh8Px
+w7ErgnHTOhi5/3XBva2MUtAvyb7QEcftMBwG0MsASkYptYjFolIKy7LUutTEiL+B6ppW6gUAd4u6
+Me7umpQVlHTfzIVsAkguc4/9Oz+3elsIlOdzyxWpntXxJ0LylfZIv2ORv/Q3lMaLHhheY5vw6iTD
+4XA4fjJ2FeQ9HkcM3XB1P96nX08p2DdinaOIYnG9rrzWdUaprHMcBs87/00wgd+KIFinpzr3VGt9
+dI9DZ3vJyoWTi5uDF8b4PN41yHt4sS5SBESjurf1bfS9g0dbLwkJ1Pe6/cpNqrXsi+vNvtD6e1N5
++SaAJ/a4DIfD4fihcAXjQuQX4LLy4o9rUyG+dZ2MZJR6HYxvRXSXOsXrsGi6YGdeo6LRcndTrlDp
+2iJvHeHk4pvwADEYAuX0CPR20gGAmcmnXs/ax/95Lt+L8a/0tbl8p2v335NZF49DOSslwoFqDLr/
+uN6OQY9f1Ip6P/nvay5tsiY4l7PKSfmgQ3SZGo8jxuMIh8PhcPws7Ipg3LSSd9qDGDs2nLyEbxda
+oV+6HoNxDwwHSmmB13EVSJ8M5FS0pJcZzQPQ1xhwcvGteKAYDJ7LXzHNvF7epztoLqkBSH2HGP2z
+cqtU39GL25BKT6C+f75/Uv2zcU2i9F3vK06GrMcQs7OlX2YMpPpNy4X4qOPKo+kpt8n0qVfnos+j
+yHEZPEcFy+ofDofD4Xhk7IpgfIeC0fbd125RaSQL27Yeg3EXRCVjiGd+QXX9CJoUmpiLpaYUrlzc
+C3ePwUgoBCL+Yj1739t7SqsF0g4o8RtFGbj1ek7r0zGoMXNqE4192V7peHp5r5aLCqFIglYqoOI6
+ChkTtaL8HRVFI21pVI20TMVlPD0H8OTPUIfD4fgJ2BXB+A4Fo8yEUzJYxUgFNOGISoeaGZ8ZrmDc
+B0OKfaEuXaVFKxnaWUpfP+vq5uTifniEOhiAcjdKM//l7zr9NoHLRQnLBjcA7ovjpFUpbrXeEo/V
+2NK6fBSJgIirVd0PQ1yvtLKRlst4lOtWXi8ERYjYXBOzSIQKYbF/kcNrJDHjcUSYwtnr5PgceOEY
+r+ZwOBxXxK4Ixs0UDKmDAT2PHUmEcZVS2Yf0C9xjMO6P4TBEdylTz0SZMIuaEQZQyKSTi7vj3jEY
+av9aEZC/67iclFJQxTj0RTkDkDMsUWNbE8PQl+kSVt+LSpG3sGpKQ2HgXkVbyNhq479oLkapyW5L
+zcxPyrVQBXMXNycT5VH+3vpCzPI2RsHQy9Pz9FBS2bpBfF2EKeDp+cnJm8PhuBp2RTBuXQdD9rIO
+CBZffj0zqB1sOL8kHfeD1MngVCfDqBedUi+yMVTuJicXd8S9YzDU/lkTgGx01waxUr20S1BWGeK2
+q1gLWZqNe1ZB20pf65VprmM5pE0VI1GM99KPNf7VOKpt9OhYuTyVOA31nNPpe/P+0E5JC0WU5Nm4
+UjBSH4qkoI+xVTynehn+VL0ahgMhHAPGY4DHuzgcjr/FrgjGLWMwgPWst3WfaasXWdXob+e+5bgc
+w2HA6WXIxfjK9SrXrxhhcTbPycV98TB/N+IapVK/ShxDMYgpKwsSe5Xpg4l1aMRSJGWjXp+3nz/Y
+HshGvlYwZBy597n0yUZNKWpFMfh1bIbUAcl7yMa/JQJsYzKqWI4VUVLxHYWccD7n5dhK8De9xn5H
+j8v4a1BXYnGGl3gVnn6NCH5eHQ7HX2BXBOM7YjB4qY3RomnUugUQZ8bLS90f2I8AksDvhYsLSXaJ
+YtAiV3BwcvEAeIi/mx7ZUGZtYM/lvtEz/iVYuorBgDWqs6qRlIutWI3itrSxvexv1S+q/ZMK2Obk
+4lXHjRSVxsZmpGOVbVQxvVLcD4XAzOrvalb71+cPsPEhmZwIgVETOlX8Bh2AweMy/hqcC8YiKUTi
+ijYiHMdYB8jhcDg+iV0RjNtnkYJJacrgVENBaRrV7zwrp90RHHeHzi5F+QWaDJ0OQA+c3oY7jc5h
+cO8YDCCRB0sErEIBM1PPRsUoM/OAUh/S9mW6gnK61zoWQyulpNv0th8bN1HaFLcn7Zq13o9101Ij
+y8cvx6FiM4DkMlVUivip3ZxUrQtDUApZqtUKVssAqFTA6invcRl/jeLoK+qRckUDMHpshsPh+AJ2
+RTBur2DEvcT/0546Um1YZR8qbYHi2+x4HAyHAUNPWWUSE4kAnF5cuXgYPNAMaikSl37PXC1nRQAY
+Jl5DgquzyhCXm1iMXF3bxmLoWhc5yFyrFMpgJ6MuFAXEGPo5CF3tZ6VgqG370ncmWErByDU1AJVZ
+qpyLEk/SIldttQLVsky0KgUEPXlcCnGb2QAAIABJREFUxl+A1TdLGgnDAaAXAk9+bh0Ox+ewK4Jx
+awXD1k8oLlFKYEZ2I9DqBeB1MB4Uw8uA4TDkLGGAx1w8Gu4egyEKSiYBxUjmXhnTmUDEtXUMho71
+WRnYOiPUrCYtcqantGyut1nHY9RZ63TFbxsUXsV1qGPJpKNST1grGcalSx+XCmyvjjESHuUwVpGs
+lVphxmndtVgvl7gMIBrCHj9wOTp1PwOr6zP0AB1SzMsvd0dzOByX4b8/f/78ufcgroXxOGLohvgw
+vCKefj0BXXFBKMShRF/YXxG0RHeb/KJM9RgeDeKDuz/oK1X/tv/zNMaX6VtKZZu3+fdA3WPdo7zE
+Ss7vv9/vsv+nX08x+LUv9wXNYlSz+R7diThnXOI5GfgzomognyBg5qwklOUR63u0fU+aJ47sy/RX
+9mOeUdX+pL0QHB2MHdfpSRWY7ePxS9voDrpertqXM2Wena2/UjOudCxSDdy4hIHzsYUJ4Ilxejld
+/V2wR8jf1/BmiUb1Nsv3TTgC1AHD6/BwzwqHw/E42BXBCMcAdNH15Zp4en6K2aA69SpT5IEBU1/B
+Eo/02ROGLpKMR8M/67/cobjf6O/n1l26zQ/GvQz5LTAY46/7E4ySPWqDfmoD30Ab59Y4ricmVsRi
+g5DQTNHVqjbAVya32o/uqzEpUivAQpzy0o3ta3N0i9AXYtPq05K21nGtznqTUJV1YYrPXXd3/AAL
+4+l5xPA22LvGkE4YgigkThRgh8PhqLErgnFLBYO64uDUMhfWL1f7wiY8roIxHkdQN6C4PWgfc5gC
+WtmVodfHWV5A9962zBqXoNP4slQuGtlYo/QS5TTzimKoVC9XmYVufurxtsYoJ7phgJpZ3uqY6mOv
+z9H1+2Pw8X6G/BYeR8HQisV6tj//vc8os+zV9bAGNZkA53g/slU8UN3bq3nlMrPfMgaNooDGmExb
+lExZFU0yhEURjazW5D7VMejjqqmZIRrtY2oRm6IOtSmZ6W8GeIp9RuP58Z69jwCjYDQJa/0mK/dB
+mOLZdjXD4XDU2BXBuJmCkVyk1qJx7bqw9cKML/mho8dUMJ4D+AAAlI0cAGuD+wGX5VlPM2YqpAHJ
+pSITivTC7LkYh/kTuW028iB9oWxv9lH2KX2s1iPdI5q4SNCuJiWr4yrHWrvZXLs/wSMSDCxRRbwb
+wXh+Ah0IgyFz2050dk2ZDS6uPS0Dfv0sySaz3LurWeVCHvQW1tSu+z3fujbqNWkyVctXikJLZdhy
+q6raniVdth99PtsuWmW5gF/jxMLp4C5TLTCA8dcTTm8lTiif7ercthQjdjXD4XA0sKsg79tnkTKU
+Qc2Qi+8qp5zhrJalWfOZVPvHAqsZTjE30FMMHlWfrWXUUzKuKRnV62VUbdtaVvd36T60alD65vKp
+yAWJoZZIxfpTh+4XNQf57HA+S3ppucpk1uc7oKdEgvS4y7mIY6yPq6wz62fbH6r+qOoPVX+00R9V
+Rtkj4e6Za3RMzlyeBSabkQq+Nqlm5a9e1LO53CmtbcoTTKXC7oESsK2eRL3tJ46P03rZV2qvU+PO
+pT+e815QAsDL/VBSw1Lels220qfsl1aZo2RvuSigahuPKfcCVlW7SxC7nqyx5yES7bxF+ZtVFcOH
+V4AOhPHowd9NLHI9IlhlRmNFKk26Y3U/SN0MngKenscdx/Q5HI7PYFcEozUzeC1wNjLUHN2i05um
+V18OBtc6B5IxcN2xXa83ijElyViPn5x9vLnnZBRk0yJ9kxl7TrP+qf3MeRl6eWFxMaxk++TuUPYl
+KgLb/YPVPtP2aR9QBIHy/lA+G+eLtBJgVADrciHngnR/lUtSeTXnO0CNsrQidZ6KsiH3hDover2c
+96So6POU+9Xb6/WpPaX+zP71eczX8THJL4Av1cG4xXNADKt8tXu1J1GvwNn4KoY4kIlIr+6U7FrF
+xTDOxn66qrO6I5Vxb2pG5IBsTYrFQBeCoCIZem3cF12gGI1FdShZsOQ49bGop2FV52I1Bk1MJCNW
+Xl6+Q/pTZCcbuXN5grKqLF4XO7TnJBnFfTSCx2nEeBzhKLCTKLD37yrlcEVG5f7oCfQaVb7x2c+x
+w+HYGcG4pYJRjBxLJuy+47f8el20QXDdcfHCCM/XeYgTOBaXU+42tasRp3iFYpBbtSDOiqft87YE
+yfoiMQ65jVpfZtKh2sgyUSPW+9fr0XN2lSLTb6VezKWdVjf08tqlatWvUjPKnF5xGinzyaVd8dJX
+s74QQ+/M+v6D9ee27z/uvyx74FnHLwTO8zNffSZVG8LFhcSeb22g51l0ISJ5Np+VEkJ2ll/ISNrG
+1MIwxj2qfrQyoMaQ+093ZFVh3LZJd4moJJkEq2PZ6JvU8eltNUmox1lIWroDm0pEUTTYkKGiZuhi
+h6T7mKs++lgvAzO8poNCmQqrlaxCQFfXMJ9neb+lc5zUDMzRtdAVI4fj38WuCMYtFQzAmpJxf8ql
+ALWpSdFoV7N913SRIiAH5/0tyitcficoskGVQV6rBdAGeZkrVf0Vg9yeOWmTDGBj2COTHlb7p2q9
+kI7V+NX38ppE/hZnjtckxMRrbCznM+1b5KQ+Jn1saByTjpdY33k1HdhYf0n/6tw+Kr4yacA936Ae
+QjKejVGsjHoxt8T4UrPoxWhOLZUyYOtJxGX6uSLfDAnItS+U/mUIiHK1argT1apDqfyt7qKm2tLe
+TpSRophoIz8dmxCdPAbOSt62EmF1QapIUR5HNdMurmW6j6wUvcZxeL0MgbonMrlV1x6avFLlJqcn
+M1Jf6RwPfVSMwjG425TD8Q9iVwTjO2IwZB5YL6WFzUtQDGj92JaA42tBG5J/SzIIDCgXKVLGbdug
+XRvsVG9r1Ir259rQXo+BqvWtfvns/qgysMXgh5nZbR1TPtaGMpL7UsY96XZbyzeUlVWcSNX+1uuz
+29UX3JFuja9MGhAAdMnv/mrGTXGdK0axehpodQDFGFsZzUDxc5/LU4KqOIla9dBxMqUaeDEDyWyj
+Xa30vkvsSGmrDUdSfWm1paFMzEXHM0pD7lOM/AbpSW21MauN1LK82r+eOTfkSisdqs8GwSEoA/jo
+heMUNYC5J5qxGEKI012vXAb1uSZQVDMO8dkzvjqZczj+NeyKYNw0BkPvw8ReAJwroVKK1dBjKDOA
+16U+ZNy2/oZkMAjUQRmj1rBfxSxgrRbURr4mB/Ws+YrINMjHuf7qfs/v77wqsTK4y1UtBKFJYCjH
+bGRPer2vreUV0VkrHG0lZE2QLl9fu4dtkhrgMet4fIn0JCO1I4x/66qh9s+QvwGtTFojTIx1meHP
+f/nKMMtuSKbqdZ5nL21F3VAz9ya4XMVf5DSxqxiIsj8dO9JWI7jRRmkq1bHnaROlNBjSgPKXoF1v
+miQofSeznMr+DVkoT6AcuzHnK7RWMdSx5jN+IAwv9O/WAUqQ9LL1eapjiUgR0EI+uFw/Odf6eoqa
+kYLsr0v4HQ7HI2NXBOP2CkbcCzoV6Ak9Y8mqXoZ6AVazg9cBq+w2A/gvSAaBwQspA5xLCsxc0Ity
+SteWEa7PBvJZ2Tbi9fqWwa3biStTNtSr5SuDWo1jS1WoKGIZT+O49fGX3+eJkqQl3SQ0+tw11q8U
+juqYqTrW+lyvYk70sW8QqofFV2IwskFKQDdgnP5iBtXsv+2qZOMhlOtQFcdQXEvWM/4rJSA/VwpB
+iNcvfSq3wJV6oseIYhDqcbbUCKi2ZMYmz7Cy77w3Zfi3+mEVi1ITrEKiyvI8mZPv24S+/GWjUixq
+spTdxTQZm8sZFbUHfZlljwVV8c9BDP54joByTyhXPXneZdKpIrfyea+VKq10pNgMAOE1uJrhcPwD
+8DoYF0DqYGiFRJtksrx8atO4zPxdtw4G4+nXqLJWFWPj9Pa5yrXhGEq8iJnZlhnWtgJQz75rEsHq
+s15fb2/2CUtu6k/q6/VQfeBMu/Un5TS3Zfu6PkZpp7bHetztwn0ff676rvbROncXf+Kyc2GI407q
+YIRjAM/KwAYAfK0WQi60B+Q6AC21NC9T11A/EfTfaW1elf7s2lYBR7lnmr3OYqRXf7er59P6KdUa
+37njtO1bo2k/MU1NFnH7Ut/XdS1Sb2Y5FQVF96P62qLNdlSKyE2RFP1r9TJ0ob36Hmld/ZylDjD3
+5fnrqfqaS5X14eAF+h4N43G012/1V2z/1uunxGfbY4YXatwpXMH45B4APVdfZi9lLhipBZayHHn2
+73pj40X2ZHUDxudjMhgcZ+6ykY5MLsqsaz6StE16aJzx969dcFqZnFYZm9SrrVZIAG34yCcD1QOt
+1a6psPRcXpCJGNT1MWoCQLPaXhlo5RPmKre+62XrcaqZxI24lXOuZXUMTW1kkVpaqzmPiq+4PWZ1
+TIHwFzEZPZB9/mf1t63jA2RZrk9hZ8yLe4ma8VXxCjKrrmfdc0rXKt4gtlwrF9qdqcRtsHFbsaqK
+crGarWrRrNlh+qHcX+26JGMr9zene1L58/flbtSz3myWq771zHg+B1QUkNn2ZdIDq1iZotDY79QV
+V55/NS6jxOukZ4O6v+XKWje5WnFqXc/cc35uDYnAxUD7f/NcPyp44viMnIGcdh7yHfE9L2pm+s2p
+LZDaz6q93FOzap+3Tetvarc57oVdEYzWfMtV0EFJ53qGJ72clvLyzzNAXWkPsHlRXgPaqImfmlql
+DDqf6S3FYJg4BtNC9maNURsr0XCHMjERhYSUOABkw7gV9GzjHjinpm0Rgdq1q85yVQdrrw1sO6tb
+SEjtHtXeZ/0p7bfabfXbck9r9fOZ9TY+pU0AHxZfiMGIBqd+caW/vo6+lj0oEzb5Wy7GbSEH5aVb
+DN+0lXEvURRAuQeJW492gSr3I1Dcp1CCsGWbvFwZefN544/VdzEcxZceoGxIsh5zIwZjq65GJkcS
+DK5iPNIRmjoYhdjI3Hk5l5YMFSJTyBtDp/Qt55/t+NW54HyM5XqJK0+YwlUy9P0E6JljUucNQLkn
+UAhbvC7KgU9c7sDqnlPXMxPpck9RD9BBapOk95XHZjwGOoAOFGNNe+RnRCzSGj9Jx4jJb3nG6N9q
+29yXeuZFPPYEl+Pr2BXBuJmCscDWwVj0a5LSuoaKkccEXLuSt52x124OZT+X1skgcI7BMEZnNqOU
+iqEM2boORU1MDPVRaoGNX9CGtl4O4260FQ/RihPR/dWz+x9nnZLxaQPVaFHlrOl9qXNlzo2+MkZ5
+aBEkPZb63FJ1blrnwK7/f3vXlt22rizrrHVHQ54/eCrKEKhhWBqGOARrKsbfJqez7wfQ3dUgaDuJ
+cmLTXWslkikSL4JgV7/gNyJ8q69QAfozZpH65RgM8OjT8/Ib2aXMgqF/gQV9p3Xn80Q4U6KSTONH
+QhpoldjsZD1aLzLVYUeTt26MpHlUIZFWqYUEcCYj0iou2xGX1upRa3RWGuoLWxsW/zRtx81Im42B
+9d/Ghvvsx7RtT9K+SttobqiVI6uFRTXsI76F4MsxGLlzH/VN14nBKMeZyNp9MYKdGyuGvauAstO6
+jPV3tRx9Kqzl3qQhYV6yvgfV7VKfYP9+9L+j/m7XsiShVpFK6j+xeivwG/i/v92ARyLRJH982UYh
+ygZ7mR6d9qyOj+86A3fg6frYdjUirHu0E4pm6EMxGYMt+bIscB1A7Z2zSMC5GLlPOV+ub4T6PWFf
+j98zgBl5TUiYgXvV0leyx+Vr29ry1nMhTkPqthOYgQswjzPSmjAjA9U3GGudSXfR6EI1tTrKl1wF
+usmTidbSIQusCHf3DAw+Fsc02omsLVAyIAJlprvdij3t7zou7b1ox036Nj4BY405+oT42Xal0+Qy
+ejn/8mrJuD1/3N9eX6Uyv/U+Z9OWC6ED4GIfxjr6o5UjArWVSWSWgvPlU89YrA3mtpW9yx9IWTBS
+70cSDahOzgilMUjcJkdcaKap1UDqqVeMzSpY2yft1tKqksH1AQDHkthzJERZjkMzb0n56LTHxslI
+i45mvS9yjj49I7Ss8+V88LgMIoUj38cyb907ZbG5rGut3sftfckaryH3yM4zaxkwncozOd9LAHj4
+5P9dlDWpzou7PDe0fro4P9h7bqG1rBcLCJgyS9a/JSOfgmQcEYcK8j5fz5iG6eEvAgvyZsGsFVqK
+SREDC3VEP0QL9qBFs1fH9lgVzpHeJBlnSdE4FCvGfgBzVuvGXoD3W+dvPkkgs8Wp1rs2mUacm1rt
+7fMEs46YJaAIWjPytV5/uiGdoG5TsuBhfUK+N4OxqafUlZ5vEFer0rezL39AEyDPJEEW2Bn5UknT
+87QZy/712zFlwasXwL0XlP5WEH0aCxkVDf9ngD5vnWeHn8XeNXuf/uko2tvby+1NYUaDvMd+ze0R
+IeJt8KvM8VbgwlJf4mx5knYO4mKA5ik3YU+P3OvnAEwNybegzToXgBLHJZpEJOBkVpNSvhBbIh2Q
+9qJuWEf9ALcfRHZoZFwSiM64+VVzf3yB7pkqxKo1dbvuAPmNvskzIfes9HVeMqbT9PAEIp8BeS37
+VNwuqZkrMo7dkS7vvQWYdS7Ib+2z11xNSh6eR3Jf5rU8D9PzMcf7s+Ppv0+YThORCVF7JDilCED/
+d+Shza9oyIVdP9V3aOBYOJSL1HYZfCAoBoP0jFQfk4sqrKytSGBm4QRj7G993/u0BZzFJl+b6Rnf
+C/zO5eHuxEDsBWjvbdjWO96moNVP6slmrwjp4WlCer4hjbfy+TwBp/r7dQZrR5zl4F6vH1C/y9iR
+YD1ImfXfKVV3uAmodWmdjlzkUqYsiCKwuRGlsUUCMGO+ZA3OL9dBhaHWimNuH/5Tyt5cQ+f0NkzU
+36gOvymiuYl8ZP79qc/+HN+e1zvGx+3a5D7tFxHGPxCTQS8+DaomlyGLB0gWU0DuTN5qYe1QoXwt
+8yLfyzn5XgSs+Q7ka8Z8z5jVnz1balyyKpTMPHMN0LQ1SP3gqV6spUw7twiZ+ZoxX6CuQi6+g2IY
+JAhU09wq8YKLweAxkLo5zkPPXGj94sBw8vlXH37nvkN1ibtXHdO8GedsbmXAbt+0/RSnIRvGHTUu
+IwE1KUn5y+3k7Vyb6lF2uYPNIbkP+sxpwH+zrpBLlf0m9yVpbIaM99Fd1D4dhirfaOxUKvdM7oOu
+RUIKG1KhrqH1HA7qBnQt0kiruo4EjodDEQxl2X8C6pYjgjGAVYQM5+ENfXQG+y0tsAe3npHpWvd9
+petACzZ9gv6WOkHtS5vf90lGsb5wKdglB+44jUibHaobRLxDRvh3/RRxUVyJ1Co1IYm7wpCrYOjJ
+SnGtQrE6jfXvpemf/K/uT8kLkkjA6LVnPNZlvKq1bJ1J6G/7C8z3M/J1LoRzkBKs7p6wDMC5obWk
+4a1d13sbA3JaUGmnvz+1jNHPxbfn4aPP8+foXWpfWHaHutfCleFEGXsJcmlDenufDCKFErhswn0i
+odqEbZfdiYRil1lpsRkFAOk5YTqVzd/kXzqV+vM1a7xD1vqSCm7F7Y4JtReUtd5LIS5a30vCdOG6
+CvnQFmtgeRUsL3XuD6CRtvMszsL6DggZsXvfJR3cXphwW8a7lkMkwZEAdo2SOgFw9iggNTEwvm9W
+ciEvSsiq+4/LfHQgodf15D7j/CNj/pFxvtRf7pV41rGf1zKHyrwrJeQ6r+Z7Rr7UMiSe4l6sHEZQ
+ZyXPWMtvxc5eyhJyOp3KnIzYjP8xRP4Q62hdY9JQ3ZlaMqAWy/p012dV11qx5APkStooisJ6cUgc
+imD8UQsGWCiqdQymxdlqRxsLxwglJK4MZGBNdG5CGug6/mU1vRHpYIFKEPpClQl5GXub8VXBlwVY
+EgO15DH5WAkW8RZbSPxOvg3pcLVK37ZiaFsvu/iUsZ/KGKzz9np5+Z+SudXcMyyYunUT4v5UqG99
+2lpuVllIffmSoWmzW3aNuUjP1U2tCmcSSC99zs1nTxT3RKo/du29a8tjlzqASEwVtNy8pRmXIMSK
+Slz9M5BXnslyPpnLVTCr563colwTKNj8zgBZAKw9ro5mNnG7dca4Z2xLboCPBn435ASZyKsI/KRJ
+ry9c1pyraD36HqH2lf8VwlHLugOzCMzyjIpgXcd5knoXeE1zncMzoHsFTfqcWl2puggWawoJ7vcZ
+56uRC6y21sg90pF11gEh6zQGjnTU6xa6P4t9avuIKLSacVuD/NgDcG5dqY6X1kNtVjKzWHuVsJLV
+JV1Kn86X39i48ZMh0Ro2L8mIJyoZpYyI+oYTEnkqx6dLQhoKYcBJrke9vj9Oqc7rdAEmwEgo3SvJ
+6pXvZSPEo4z5Z4dzb6rPUBqTyVjiNiVWDiT33KHKBABcQLe+hTSeoz7L33CDy++AQxGMP2nB2Ao4
+XmPaEovt73btRsQbTCRkkiICmZY39Oqrj+xg1yZXSqajpoFjZKS6DwY22YbYX9bOVl2lGxEnapJ/
+uWuxs2JwPWkbT0BltbtOlxd/LXll4gDVpMg5RWgqZbfCdqszVyxJ28mCfq59wFBfzK78reCfkKr7
+1aTCjbgjbK0TRqTaQO82DbB92n3apOHtlrf929kAWLACapA9zaOB5iaqax3PucEL9sllWEvkRljn
+z+CfkzwkGrkt+I7BnSdzoT870+BXByYmWra4S71BMhJSIwjBux91NOkJJjwB9sJlC4QDuSDIfZ/q
+HDOBnsbnXo+doIQ33+Hd7JZctM0ritVttDWIBf1UtcacGU9iLjCgCJ/1bE05KkRABX+QdYBJQ/Lj
+xX2g9qiCYqTyRlrHRiJ5I9Ux2n23tiQtS4iMCck8H5KWx+SG13M5dzqVcTrKfhluvo9Q4okTgLs7
+050H8JOPokAb7P7hVNebxi1UkHQ9YDJK91Gfr0JkdMyvX3/MPzv6qr7sSIbbiJfkAoHLTijEnr0T
+ylnl45PE/QUei0MRjD9pwTBaYZo7drdgylCEMn6AvMhvBIJeqgA9ol4gg/1lvynxyK5MIKtQyK9G
+1nVntCSjCoodF5we6dhL89r69e+dn7v1NNp5fYGRnrpNSwuo5SUzKZE4CrVQ1HLXeTPC7Sj6ey51
+8/0zrby1tX6/Axw0XdpZ7wsvtpuZQPV1XKzsPCMF9snjnZ3rU7uLM78qevE23CcjADzzm7mpLfO0
+zdNxnouOHjbH2jvRvLIWX5OK8ZLtS56lwa5P5Ffu7+iecgDvxmSoJlsFoXrUud7UEWysGDpqjRad
+0RIWFdakLN1gkywApOlPI4jwypn1+sa1yWv1TcBOat0gwe+5aqlHukNiiWjcxqQcExKTuUbQffDx
+FrQmknBfftORVXImc0Lq0B6Iqxa5rXGaXkkpzaSFLSbaA7kHkr6X2prrvjJFs/554zIkJuddiHDH
+RBMo/w95q11mAgwaT7JU6BO1FsVYu66XI/V3JqM0DxxhHGFjvsxhzfgZrMVd7efc+ur9UisEKYZq
+TMbM1uuFZAyK5wOgiggA6oWwUVP+psvh/OOM83XuvseBjHw94/yDf8/12X3C03/rvx/n4uLXXLtf
+tvyWkZGR72ecf7z1b1tGvp/x9OO4hPlQBONPWzBUsFF3JNLcgASXwQsygAm/0lIWLZ02Vd2oQFez
+U1W9jjS//NIWoZCvb4U9gbwYi6sLuqSht18Ck4g9MvLW+bv1MJasfaReb+9ubbf2c63evCfYXhLD
+VH3TiYiQuxS7dSlc20kg1/LNwoFhqpr6Wcu2/S18WZsFpu1XM26b2JE3yFwbGK6zo8kqZXsheOJk
+WmbfKqYcRhB4boLOkKNGSaQHTCfsWDuPt8+FCOX21NDzpcKL9JdeWoNvGdMMIyvWQ51jEpPReekJ
+gWj12j1Numn2s57rNytrdX6tMJvcb+KqotdIZqTqlqJk9FTbspqArdesRnZYgPOCO60fpIHkMTKi
+Yq00kkDrHlkE3Jgo6agluJiWeoaM1agjS+RLzsv6Kb8zaVGCBBCByI60bCwqQhABs5aQtUX3FxlT
+tQZ9zriMNCacr0V4elPAVJdSGMlYoK6g6h/frkW0diSgrMWV8JfrS5nlN1pjiKCkIVO6ZBtbI83Z
+PW/FTW3SHdfP1/Mv7ZPzrTAUFzMRdPM909rXhypt9NkQwlF+LfcuGckj4p6qJ4E8e/r+WExqkrg6
+XTt+04KRTiht6c0FiSs7Tfr+ENKAccL0fMPtuShV5uu5xqD50cgulqv9Td4uqVqAE6XIpmMuu2kh
+OPP1c60Zj8ahCMaft2DUCUPB2gA2sRgsZuk5KsA6nbwSChWO3H4U7P5hIkePPLTa2J7gxgKbXF12
+/M7kEuGFz/7u25k07Cak9t2OfK0bW81OEDnGVFyf2vbA6lMsNGb3ej/uGXmtmmh1Y5hLWsQ9YtRB
+dt+zpbVdZ8yX+tJea1D5mt2mVdvrudV8J/pjtCEAzXlFM94QCHfdltC048/3Sawg3AJ/hcxZEvyR
+6qJOrV19733SAnkJ0DOymrCfsLXA+fvReyaa9rnZkpqRqGW3SgHqrZTaExrN6kAkhQUgfRGRBWNM
+3WvN7cdKB+ACs8snypzmRAxiPRCLxkC/iVBwp5f8ksFJDGTc1JWpsWKYsGBj5mbTSuJlm9WK2y1X
+iwWDiRgJ/OYqlskyQmOC5AV/tigAzgKihGq0ey7jImXxbukbywqTFJo/vVgbcd/5jHEZaUhFubJk
+nK8zzuNZNf88r+0dVXo7/5DMZalsgldHYb6X32T+MXmbLzQ7LrNdLy6UQ8Z8yZivZLUay9ow/8hO
+U15+k9lgc8faWr5PL+U+PF2eDuGq9icxXYpj47zOOF/PePrPE+brvoWL5Qz3thDlCaol45QqYbHn
+3e5hmTm6PpObo6XXrnf0N8l5qnP3vGzLyfJOE8XLfca8Jkwvr4VYnFKx2j7fcHtOyNezJsKgUjbv
+Uqq99KumsdZ01tUd1Y7VdXTNmK+zWUXGtFvyV8ehCMaft2Dwy8jr73y93A7fHhKzyi/D9kG2pdr/
+xuU5E+Nq12y0syrwtu0uV+R6OgU2AAAgAElEQVRVXshpo+lus9xsLRJJfSqTq9l/sjC72ZHbxBTw
+stb+7bVlog3LRUt9SvWFV18yK2wfDdHciWZjybupWpveunqLYEwizT3XzRNrPZyylvvn9pvg0rdE
+zIvJfUK2+Wz2smitM+2nd1dLfr+Neo951HUurnSMs6Mhu7gJALppI5/vyDdZHcQK4Z4fZ4FLjWsZ
+Wfvcs8BtBv0m2tWGSDilAFsK6CkZEubLmYTN2mISNE04F3IgAhi1pBNzwe5D7YtLe6iuR3CauVJn
+nfNKeFEyPN1RXvh1jOcFlt1s5dJNu9+zYiT9nkyYX2jUBzvXYiJsPMqzjqZcdxZljIIK9fLdxo7G
+ZGzH3OYGW0B8LAbVvNjKpO0Qq2LnfgEJLhVuL9amXpdOwDQWy9dnEnbLjuSijQaworiF/CixDFkT
+h9TzLzVA+yTkogqKl3rsJeF2Kb/JeJVMZPbM6LkXlPvUu75mZZxeEqaXye4nEVC5dwCRWDfHyi7g
+6ZQwX2fM13MEC+9AMkClOqdTnavn61ktXLrGDFCNfbE6NnKIWydgJIPfceIGSmuGPC+8dlv7frOD
+Q7W0dVyccrVeTEBRDF7r3506Uz0+M+FZ4dYkhxXgmLBOidtDy4x5AW4vN0wn6HgeEbGT90cwwLKn
+uJq2Ao8KLGtuskGhnsWa1laozNvz1lRf5vXlqJv5kbZWU+huhVOxiLRnSO3peTLNexXUdROk6h5k
+G2OlvVaq+Kh1kfC62Txu5zpPpKyN4tYjQeCykJk/eh3/ey3neSpHR17IMvLlXAXljKn2z7l0dW49
+UQojU7JJHowClr0xzvWFnTGhtDM3BGC+J7t/nYxWTEwy/b39RNcK4+/d9tMH7nsLFYDiVkJxP9L3
+MsdSMyJyx9hysD1mpfH/7WzclgCZbXof2ysLcRSXRCBpKuDc1jZsa9fa9JlqCO6acfvnFbnuIK6U
+RF+e2Y8vYK5xI/VMExSQYKrf/ahq7xe4AEro73xX6i8DTBPZagLvQL7U77KJ5CJESJ7J2obqajff
+QTvrZnXtc7twr/Zk8folAohpKwHbqC3ruJnrlGgzs81bEBHm9YLK1birke4k96XGL/k4GL/u2qaH
+6N4vEcq1f3K/AdvkkK4r7kBl/4bPEohcXE9k/YRai4tFYka+ZJ8aWMZE7tli41HOgd7jds5LPBwA
+JQwZNubqOsPlA272ADa2mvIZ/r7a81fn1piRnlMRHO9PtQFbIfb7HfOw55iIfX2O5uuM83Iulo4V
+SCdTvej917WNVmghhgPMVYifydHWBCGbjaRU7v36uyQjYbpMxcLGZa0Z8wpNMQ2gJmjZLyeNCbjP
+mJ9vhZQMgOzbtRnhAXCJI7gkjj1inG54Pfk6j4pDEYwi2P2BnT9XE7BUeKr7LLjHZS2aw4ys5zvW
+f5JWenGaSUnRBtuyjCG7ciQbzlYor6/+FcgDl6uijZWx5nLOWEx35+tc2tuJj2AhvHxmt1N0KxAn
+Pl/a1WRF4nMkexILu2lMqpnNwCa1bFqAfD+Xh3usZIL2vuC9NNjlB2NSa0Y+UV3q8iVCQXJ9KnXy
+PbeXNgBzf6tuXRzrwWWoO8Zayxibe8hxEiwAd8pKRDJsPInM0d3v7RDeurkV8kREo5mnPWIM30ow
+oXBzdud6PsrfeK76BbqZxyjPiwk/mfae6ZxL/XLPXkOehEbf/nndLAVOVB7t/mgvRylfxrbWIcIQ
+5Dlpx5J7SKREtIV3lPlOcRi6nwXFX7i7c8l1Q7yavra6pOSVBHkRBEXoF432XQTSOv/au6cxYNy/
+etZo/feEQcbI7mq7n4gJNSzYG5lwc5rmn/RFylL3s4bACLFOo78fGhSuxI7XMRGmSCBSdzASou65
+7EB9mpAudc4KqWP8yWMDisvhkDSz3fwjWXC7CucJ0wm4Pb9aDAmYsNW7zRbN0Z4edpUxzXW1WjRW
+J0fGiWy6OaHzB3QvKtEof9HcSVR2rumboe4oqOfzc8XKif7xg52ncyKpe+V5PNN7uj5r9T0/vUzF
+zWhIeFqeynVMwAG/zkGeI14XqmIV9R2s7cn0t8kNbo1/RBapIWHCjHnJmDSbXi4xkiLQL0BeE6Y3
+3ZLkzVchMW69U1cApw71qArQt5Xd2eSgg+JQBOOPWTDAYlP9PmyFFsn4tBWochEe18lrSle7xgQd
+eSi3paBXrrZLyvBa2J5GOEse/LoYJ6AGinpBlt2l9o63logM046oiCpaMxVu0RAYXoDk5SHC+lyJ
+AZCWEkOh/prDVFPFZtute/QLsAkbRgxwn4HhtiVTNEbtnh9aZ1O+t+7IbzOw3Gg86jiMmXw7WzIB
+Igv2Ash6Hnx7aFESQYDJgtsIcee4aKc4i1RGIellfiZ1heFZ2JIP8N9rds8Gz9EMEX5a6gJ6HnrP
+T+mzPjtrdtmifFuYKLTnbulG+0zJkdfLllwAUEGcyQMfz9LW0QTpItjZOJnwa8KUoc4r0dSOsMwm
+NXuLCMu2maRe5e+TEIp7nS9DVVDcs7q18c7aWIqghhVIzyxUkFAuoysBwLVeFrghwsNGk2mCpMxL
+05RntZg6cuW0nqAyMpWR7dkBbL1BJgIDFWYx+nkrG4UJibDjZI+r9dh9s/IziiCT7xm3l9s2YLWn
+Lf2TxyQAf0iYLzNZq6oQPk5I/yR9T9JTVuI17oV82L2RdcqPsxDI/KO8U0p2IZhPfp2vup7Liibr
+GJEXnhNyjctKJu8OZHv2FmBey9y8yearDnt/f5Pz3P4l9jyKC+M0FK3/Zr6u9blXEs9rJMkEej9q
+LaPVpdZyeKICyPrQrFfrI0hGKnurXDPyydaVpMHd0qZ2zWVIO5LJZ79iwRjhtg7YbW9d8/bP+dqI
+GIwPItH/LM7wMUc2aGIlJPI9hH6mwa7hWviYCWCJfsVuvn8v6tc6eXO0NRdf2JNZeoTcbDMgGbnY
+O87iHW+It3GLat1xOoHd2l5ZlCTd5r3GOiDbQnS6mZZwyWaxGNI2tkJ9+FPp55ArYUibu2bg32Hu
+UUNSYWybgjdZitDV+q/+8jRbNDvH5q57sbydXe6T4y7ccu1nzKY8bjNjsTKKgMKzSEqrZI/nGP/N
+i+rqWwxABVubl9QjlxEq++tGrkNKsB4aTfOEIw1chz0L/WuKQP768toX4uSFAKi7oE/DmvQ3ANVi
+JYRBS9CylCSKxvde5nq+F1IxXzLOP7JaLyaygKorlGrtYbESKMIkTjY6+izUY7lumjffCwHBvQTg
+SmAiZ/Yx4bx9idZjLk6BiEanXSrkILvsT+q2UY+lWr6ucQu1Z1NG016ymug94VgMvR9Jn4dixaFz
+NGFCnTciLDXlAyguaEvG6z+vv50N59Eo8SAJt9OE23LD68srpufJvyc14YF9h7s3OqvIikRrLIB0
+SUVLLAT1VP/WsSZrkzwri3+GZZyVyMDalZt5MS/AfC1Xv768dshFgJEvxTqfhgmvzxNe/3ntk+EK
+sx7yGiL33QgHu8SpRUSv5d8ypbJNlFyhlvmgnbzTOJVy11zWtDXp2gJAyff8RtyDxlS6Nr1hwdD1
+qPNb/xepSeWGo+JQBKPReT4UvOMwi9UsEJk4Kr+YsG8aZxYRmYo0pkbQlHa7I9dldifff5d0iFC3
+Aul5cuRC65N0ryK0ci/JgsEuE/Z6qD1lsrBDKnqbxW32bVgycHlFOr0ivbwiPdfP080+T9TWcSrn
+P0+qGevvtQHg9Ip0edUALzdbasq6dJkaUgVMp1ekFxo3IS7kpoQFtR3ywmN6WHF6RXq5qYZ6L53v
+7h4i7s769rekpJ1dTGXRnFte4sleCvpybylPJve/OisHK8XNZSIMLMxre4dELTIh1axgpmnuzWt7
+XdUrV7mKnxa4680dyj9n8iS/vnRcLNUtqaUk8FaM+lLVs/g3JR0iwJKtj61Rd6gGWPetOJU9KFgg
+FuF2qkIdC+SAaSt1Z26pYASm53I836vl4G47NqfnZO4ENOIW9E2vTAmaVs2ljb/fDM/mku4rAWgg
+qYyL1rjQrBHhVARMdb/ZOQ+ABmx3x7/edxKgVQDiflD725SpJI4jX0r5t5e+xetvYr7PeH15xes/
+lVTsCpP0hNd4v3yp2aQu9fg941z7WuLNMs40V/OPcg8kwUC+1ntyzzjfS1nnS63lnnGWTFMXImoq
+zKbmuYIKt3lBTWaQcXu+YXr+Ay7RR8Qp4d+XSipO74+ZrWH0xLMVAnbfnBsVAN6Mz5LAoHEl9RLT
+w4Lzq5V2vpeMWTilhryUbE64zt06S4Y1kNVDCEpnH4y1pJXZI0ft+653hmbNPCgORTD+pAUDLpAa
+jSY0aapNEz+85teLYL6tRcAngQO5CgX1BT7Yb9mVUetgrTCg6V1taSiMfnpOG3KhbZEAPRGq9Wqz
+XDgLxo7A2gq+TpRj0mG9I/GOW53r94ztfhLZE4DFhAEAaK0LuteG77Gru6WEem4lXUKqVCRtyFN2
+pCmT1aQ3Hv0+M4XcHZuOFclnqkouZmNvX44egTFNrc1PfT2sfrS8CM8k289tRwDqJ5Nz90zJOWtT
+A2nR2lHhurMmPyBB25XftJOygmVkvF5ufTO9Sw/LGm7qH1kyAC88O+25WD5Gav9JsutMNatOzbRT
+P0Xgl2wuZS+Amn2Hy1JLASzPfD2v+FqLoFBiBMp6UD91I72k/eMngS1ukHaOierLvo1IJjjqfQMJ
+7slcjuq46YiKVaL2jdeZTCRqe57VoeUuVK6OVYbTkDfWFl1r3T2t81Y0+Eux+KTThNvLDZ8R02n6
+kGbfreEr1Od8ekmYYORTQYQ4nSqRfSn7CKRTeRem5zK68wLNHuXK0hSeVp5aSlpLnPwmVosxrBY/
+i+k07VhlOxhQrQ11DWgs23nJzjphChomEEYyXOrzPXegh1n+ypqG5Yz5njAN06a29FxIyPlCG+ut
+uWyUd52RTxNuJzq/eiWcf9Ssa9WrYr7MwDD5AHKCe6ftnGHuycfEoQjGn7RgtOWLe5MeJX9HAHWH
+YQCuRY1lgsVxJTD1fJcK1FMKFtBAdeh5FPiaAaQVmDqWC9ev1QvuqWruTbBvLBj6N1Tzvq+BN9Ki
+7e6Ux9miykhUaiZBYY2wbBYMb/1IFEzuRrljcdizIujfNO5+B20jF1uLzVbIb/u62fjunfP3sk25
+MWvu2c/011xAWvHf5idb8Ozs1mpmor2JbbW01a615Zctd7V8spAUgtnOWBIgyQy9JRJJiUSX5AzW
+z9fLnluUwQRUmKBMQn+mceHYGtbwp6ZtLOiWl7H0MDUuJOZSZYKzCGT1jJHGgVx6dFRGuycqlPM/
+MImx9UsIUtb22srmN8ODWgqErHIL9Nw6broKknXELBwZmZ8/siLkphwVWRYbq1QtSc7qt6chH/m+
+0X1y97SeW7X08zXXNJNfX4OeyAJZXEOSJQ2oFrLd3bxFOCJyq89RdUMtAhl0/lisFUj77Ulk/abr
+1HwpboO3l7Ba/HHU1Kv65GwSKlSIO9Ri67EjI/X3GRkaZ1DXhNZF6nd38nY4TSUl9wCyxjKKUkA2
+1jvXXbzP16yb7vnyyrGE2Xblvs6YUWNY9trhXH57SBSDcUwcimD8SQsGv5iLVku+1xeQ06wlJQhJ
+r7XrvdiQmuvrNWPanJ82ZcD1uHXgSEB1i+pbLkDXYUgdAZYFUS/gssC7m25VXxsmuG703qJZbctF
+Br1y3LVcpmgT08aaAHJtaO+jf+xZyG6tHr3MWi2p2FowtuW15bp29epzd7f95D7ROFQLBbuEuf42
+bl0btzSACJ7NX10It7PW5n93rnptswgyvg/0TMnnyCRG5g5cmSLES8zHtm6bMaYd8wSp/P0xcqFj
+6J63ZlwWau2GAGRz6VmobU2g5FZDLwI1WzEbwVkDmaUOqdfuqfaBtPVCcFyfhCDU4+UYnUNWC/st
+a1kmiNMzrq5UtKapiwRUUAGw6+9vmxXCzw93nJQ6XObSlN3RkAPJjXPmcVmI8K2lP7eXzxdv8auw
+zUFzk6FKhD9s3UCEgDhNtpQHDcJGfbcAKGl8T9sylAwq2SYL8L1aLU7VanGQMf/UEAVPE7xcvAVq
+pkUhCiLvlDM2ZIRjMsQ9VK5xyqoHxWAUJNz+ecXryw37syVher7h9Z8bbi833MSV8NSXIIulspR5
+e7lp+b29NAAAw4TXl1fc3rGypefXvlvuQXAogvGnLBi351txHzhNZSOiU0Ia6g6Nl0k3ZynfS3YG
+8ZueTgnpMqm5Oo2pLLRVayi7wBZSUb/LYl1NziV7TK7f60t1TPXFQNrcOgo6Fm+4RbXjVl7RewKt
+CbDvuei4jd1oqWFi4BxiFryh7UfXQuIE6D0Bfuf8rlafR65zTVvWZkdzHfV+23rWFCurOS5t2YlP
+ceRJBa06ph3LCbtd9axPG9JT/WTLHKumbiGL1VqUxlx8W+XvEyAZjuR4+Z51rrr5LXN+TJ35Xedc
+zUhTzpdsYQnplK0ucJ32uwZg6+wmgZJn9ZrfCOjeQ1VjOK1+q/UXDbkIxyIMN781rlMJXCZRCrKA
+CBFkQsOCMue4V7LgNPRGBowgZW2PWTvqd7IidOMcINYCTwh8nWRZYqsMab29FcNIklk6shEFMIER
+ctaxCEmZI5VN42JEpJavz2gCBzmjahnzvdRVyAUOBCJpAiEHd9T06qDNSk15w0RDlRyVrBUyUZ/9
+E4ob8R2b4Fm1trFVCUC+gDYkO64Q9ukg8aYcM7EAmlZdn59GeCYvBbE+ZqCJyaDjoDXyr22QWGS5
+Dz/PQ1LLd+B9HCpNbcaf2Qej+HomzUgj1gn9XTcmw0ZLq6bg58dOybyWIDt7SE2LWVKBzm+6Rbmy
+kJHWhHzaE2iTT/2InusOqBXe2kB6i+6nLj7uOLePPqtAXAR5LzC3KXT9nhH22XM5cud32s+Cetvu
+lgyZIEPHOmX3ymrHoreHxSYTV0PkeAw9vWt+b8YkPd+Qr+dP54JQ5voZrz/j6349mwYVgB+Barno
+7HPxHmT0/CZg9ZukzxRhfOQnU2on16M6V9SNEKAN3Ex4drurj9J6oNXYAzACKnUssDki87wtR1pH
+ljOtkTWSOtd6dYvmPxvRWLK1XZ4DEtwtDWZqAkC5Tn6eTPj0G/mB2uWvZQHJ9r3IRPLoGdLntz2/
+aNE/up5+PRC1GFLJvnNHIRdA0dKOqQTP/pDzUEjIyXTcSeZYnTcJCamWle71vp3Q7Eov8z6bcgY2
+3rdDjvdXgCkd9S6pdT036508h62FgubVCM0iJa68rrawTB0SYcH4orBUnfL4e4GS97l4tyykEkPy
+ASuAvQS2FgmzDngBONHf7Fa0tQS0eg2vI1HNq1oJzGKyiWOg9uXm0ywl3Ee2nPTLbS02bj+QXjtc
+vdD7Zf3qtdFD09j10vq+MaakM66ffkxai4ekF/2M+BVtsWihtyNcxmJvn4suqH5xnXFuTqJxV2E4
+mTZctO4aBF1/X9pzk76kS/sLzAUoNe5PgF610HwarXzTDouVxJ4rX464B7HVgj4hGsltH7gNQhq0
+HFU6NNaNpi/qOqFWjOwsOGYtAQVkJ3hriFmAbGylzNSQEFs3W3crJYN1HZuri86Rtegs3KURJSD7
+VBMNXCazsF+ST0JwKfcyvZBiZQTSi2isUaz4l5pU4FI3ODvVDfmAZrxRs6iF1eKvQjYLlngoiREY
+bZ1BfXZ0RVX30GTkQ86VTFIjkMapeF4s/o2XHxmDEfg0OBTByPa6OTzMb5ZeljUd5UfcolxZKBaM
+Nn6i1bCzLhxoLAswMtDegV62pff2wdDlp7FQbPbh6LhpiRaNSZe1jDS5zm3Kk4NN1qgdy8jHMjft
+kRNv5WhJk33CaXzaceel2QQrbMjimzEhCz4t8vrzz7QIyPwaS8A7+1zsQDWu5lLELlDsliSuJarX
+Fa2eEAURdMUlTd2EcuP3n/QJVEF/1F8pJkGITfJlkeC8lxpW2iNl6xXSt0YQN5cv34eMrMRmL92s
+3wvB94Xr0zWkIUYmiJLLlCMNfI6V7dPb2tiWo+3YWNlHjbfooX2XyDxn4dLcAvkNwPOJSKC7zsi1
+zA89X9acJZe9X2qsxVv7MwT+B5D9i8SNFjBlwcK2dpK5REG1VPv7SGuuWjHLtemUSuKNZfvcB46F
+QxGM72TBaHX7Igi0m+h9rKSkuysridhYGaCCqItPoJb0BF592YzbMvfiDJzFwxGdnfKdwNwK8yzE
+b0mAnk9kQgkVZ43aEKwPWDA6lo7WIrK5jslV89mO2571Ym8fkvd+/7QY8vvnNCj3y7Tpcvd+L6Au
+uzlue0MImQEsliIpYVBRi+ID9Bx9huRF2wrMcGRGj1IWJo0Hcc8jWSV0fjflNtYAb6HI23K0D/76
+pOcIcajXd+JB1AIEFuh5LJMJHnS+rCMqBC/Wbj2DLC9mHRFhiUZP4nx0bGQdSVb2vXweL95iC1u/
+6zfOCMWxQUQoba8RIrWA3ZcOGTaiSuUt0NiWEmQbVovPAHWJApwl0naFN0JvWZDsvjs3KndttXqd
+EuYaQ8pxkIFj4VAE4ztZMLwVoYpTv+gjXCwYaFyivAC6m4oWtjjoyJNmnDXl9oKqpKEjJLeWDZ9+
+tqlbym/64qwvHeG+m+5VSYxpvK1PRDrovLcsGKnp+14GKYkl0etaktP2h9v5RnxGj6xZFh8iLe7z
+cyL9QgBgEWasT8Utamefi58qV4TaHjmAN/2LdUCE8pHJSNLfpH0usNsJ4uUMp4V3FgVa9Zbk6te5
+vNgdl/ZYetbcLc9vcifWDdJeqzsXEYvGIlB+J/LiLBNcVivIiuWO1EbOasRtszYUQcbfl61bGbct
+mXsXtpr07wB+SuS+lHtJhJfd1ABnMXKucjTnVS3UsYIIiStjffs2Y/0lIO7SABEGgN9FcMqDhlTA
+3BR5Qz1THpTr0pAKuQQeuA9G4DPhUATjO1kw8mAPuGgLf1X7UywYaIRvdImCLA6l1qZN8qXj+sMB
+fK2VpE0B2/OaBy1gTE66lhEWmp3Qb2Rj64bUflq/+/t/NBYMvRNy3ZYwaZu5b01WqNZSxMvuhuwo
+OaPxfc+C0YyrJy2fE7/SNhaKNObiVzXRHIPBxEFmIwvSjaa+FYyhArAJzRt3HiUvIvC1Wniv0Qdy
+Y62g53ThMlgQB3T1aOIXlKYzsVCixMI6C6LSV3KBUTcwim3gcVkylUErd8/qsBtjobU1ArERC1+e
+ESVbO8s5s1otvpn/PyUmyXT/26xgch9Mc13H21k2mucA2FpByEIkqUEDnwii0OE1A/IcZ1rz6ruZ
+SAPHPNHZGsMlSq5SfqqucPmx+2AEPg0ORTC+kwVDHsgMYBqn38r8UywYaes21IlF+Eiw8f7+EB2N
+ehWwTUgmCwF/tkK+a38jLO9YLJyFoilv77MXS6FZs5gMaEu2xAcwopB6fYMfY7Zi9PYmSRtCwuXx
+cSNt2/uGTR8+L37+5VNGseRs/y1yATRZb5K7306AIqFW97HZuBdtNcJbbTq/0GE1qXtS1uB/JRJN
+MLgJ/FyuJwQ2X3z8Amr7tFVCJoiYbIOmrX1CHuxc/UbkDI5ouTgWtjrIwG/aaC46WooTiDvlEUFy
+7VtQ4y1Qdj3/btrU1cbQ7+vC9NKIRjnDxru1rGlZNPd1V/cLPv0O6N8d0/OkacDLfU2VoIstoqwF
++uZSK2PS7+3/7ILrfjslYJy+j9z2zXCoNLVspjs6pIe/EnPRKysP4pIEEzLkt8YiocLNJoYCJNx6
+tx3+TI2wmxt3KPl9E5vBJAK8YHlSwu4/7njrTrQ53ywQqdNnH3viCYvUxWZi/X1JlIVrS2QkNWnP
+hauXZreN88hEBDP6x/VeSh8boqVWq0+IX8sihbKD/T+P00SzBaD8LXPXBG3Q3QcA05qTQIZc7qOU
+O9LsoRe3CuZy/1WANkE98//V2pZVoK7zAHJtQwhAlh45Tyxn6i8NTybqVXqejkGdm/K8jW27pC7o
+s1eO19ESS55rDxy5LwIO9bOWp24YS9Yg8DZdruy7wgSwjFEubhrj93GJauGVNYCkFwbPN7rnQLV6
+1TnTzg9dp0ZbqzMycMnAONU4qOO/o78qvpX1LvBHERaML4oMPCwve0bSDFSAuFZg47LjNeNmiRBt
+bVvqezEWPZKyp2nvZ1zyx7cuRn1Lyn5WK6iQrb3ZWAMA9uXm+9F+T9ie15ud/vytZUO12NTP1nWt
+HZfctFXr6fRjr12fBb+yCVMaMqaX14euB6K7tdijVovL2tqtFtg2n5Tj3mJhm8clf99USy9ubkb8
+jS4mFdA3Wn+Ny4CznGgdHeuAv86sIlq3WkxkDFp/+7ZdpuHWGc3XcRwJBYOqhWLc9tNbVbJru8Vh
+CBlLaikqY10ItcYAPH9PcgHw+iNWCvpL3fDMuuWsXm4+1Tkx0lxYUAjcNWM63XB7DnIRCHwXHIpg
+fKcYDNlJ/CFloWqJ3wgQFmF/d3dsbAVqLwT3yvPko3URau+lupS09QAbd59U3a3aenqkpxu7IZ+d
+mIueG9V+Ktq+u1V/5/JsY+r6XcXDt2IrNgHxO+eRxYZ01CLmfU78gsvKdLr9oew/ZmUwspFNs1sF
+YJ295LYjQrIJxmwNASx+wYTl9+ppYxN0tmhsgpQrLlP2VFlgtZXvhEqxBhCJ2LpOGXExwb5HrmyO
+tel4VWsuo6NEK5NbGKhticqs2MRoSF2eCKmlcgXme8bt+fbtYwBsTyVSaCw8f8uvzvVO5pebT0RG
+6rH5Wr7d/nmtG9YGAoHvgkMRjO9kwXgkMnLREu/ESJj7EmnG67U9LX77CYmtYMtBI+QWza8XwtvA
+672dt/2+F97damshwb4bF3w57edb8RIbt6weieByOrEhLi5jhyTsZod6J/blPXJlqQY/H9InCgDc
+xGCMRAPYouA0u2Z14H0yTLBP5qOux+p5RCy6ZMAJeCbaqcafBOw2MJvtDD4AWlyLOmSeSJKRHTvu
+g4Qb65u2mQnY1oLBgl1xjeEAABQRSURBVGpq28LuXXRNasaBx8fIDoAlY76Uv19fQugF4PbBsHEz
+AmhjTDOXLUpk3coLylpzKUHzt+fvbR0KBL4zDkUwvpMF49FIQ0/jDe+GA7IivOOi46wJ8NfKi+u9
+nbiVhPSyP70h9LMmf2s54bb4/sKdl5q+9Ny42JLTkJEaCM7jpGMHG6ftjt99C4PvL5O3n7RgdPrB
+weifEX/9ie5kkQJYqBKBl452AqdzFZhbi0Rx40k0J4lMuHgP+718o/MAsi7ABEMV1k3wFuHfCBDp
+nSmQnNtqQr5ZDwA09SZ1R9rLOMVZpNjiYml0uTwjWM4ywuPH57MbFx1Tt6qlZooa8W3jLfrwa4pm
+/AE8ga33lb+LCxq/d4vbGfD6cgsCFwh8Y/zn33///fdvN+JROF/PmIYpFrWfxHydy+vhu2VPCTTI
+yNcZr/+8/u2GOOQ14/zj/Nfa9fTfJ0zPVXjWYGO25iW1ENgO3RKYDyUMTNQBUojwcQpwRnM+XyPl
+8zmeahMtozL1Oi1froK/Ugg/2rLl7O037j+ac7i+Vg0k1HlT3qYfMt52ZkvDuT5u83wH8j3j9jwh
+RRCrgzxft5dEY2gKGQugZ3VHE9SNjHwvRON2Of7mhIFA4H0cimDM1xkYIgvCz2K+z2XsfhcDXErP
+T4FHtakt52/09aN1/k5bh+I68tnw9N+nv04wLKC4oGcx3beidsTilqCgLZ+FOXEjREM6uEaxVtVf
+mNy8IXw74qAWwpZQVPDvkgVKLWBbouKyTYGJmVn6LFuWWYG2/dj2kzNTOeLWlKMpaC/fMAXtB/H0
+3ydML6mZMwU9UgnAuZvma8Z0+r106YFA4Fg4FMEIC0YgcDx8HgvGViiGCNmOMIDSeDba347FQcpR
+7T5bD3asHibgGzFwqWW59J12mRDfCOywYxyn9JYDat+KsW1D5xfXL1dWj8B1yvcWJF+n298C8V7o
+QZ6v6SVBR393Xvvj+Q4AGdPlFuQtEAg4RAxGIBAIvAV195BYC9LUu8DXcsz7rvuYCd540XzaJdai
+CXzW4xYnoYKdxBXImRzzIbVJTIJaEHy72lSunCLD0rtmi91oskZx/IfGVrQxGBoL4iIo1PLQxrEI
+CeJjFnORfJyLEq1Mv1lQ93wv5d1ebkEuPgAbU5lbdfxHiwArFosyt0qsRcLt5TXIRSAQ2OBQBCOy
+SAUCgYfD7eQNFwjNKVc1IBnw2XcWEsUXti1kIxZNhqfclJ8pWFuu8VmrpC5zw3IZl/i4C67WJMiW
+mtTtIG6EyARNGFGR4OyReyWEhc6D7UPBhMy+U6DxJrMUBcNzO+v5yRGLhLkKv7dTwhQZjD4MC/Im
+guuC6c1qke/A7eU13JEDgcAuDkUwwoIRCBwPn0U7qpmJNP1qa3loLQVVIB8bwbtN66lWhjbDU3LC
+80b4HzvCP2+ABxgZUnJglgkAlG4UZl2RmAgAsu8EkwkTPJkYEAHiPTh4fwqKqZAWpI21gsa5Eiwp
+NztrD1t1kpKyvGag7m8RwdwfgzxfOutGGn9251vZavGn9pkJBAJHwaEIRlgwAoHjIX+GfTBGUDCy
+6c+ZLPCu3G0aVXM98pYFtkZYPEZ2ArYK4wDt66Biv9t7wlLNJi3fkYOFrBDOesHOVSawt7ttS2vM
+7Sv71KVgQkWuW44Y2dk6puw6pgSndQOjMXVWnVrfpfTjFvtb/BTk+TL3O5nDNq/Pl/L5+k9YLQKB
+wMdwKIIRFoxA4ID4DJrSxb6aVrdHFsSSUL6X45Z2ltcnt+P0mFyZ71owaH8C2xSNYzMoVoPPcdfZ
+Fo+8uZ5ZG/z+GknLlDGRMslK4eI0fIyIlrhwHIa3uKhFB+zWZfX6+A7YuMb+Fr8Ni5UpkNSz4m4W
+YxsIBH4GhyIYYcEIBI6H9IlSH5uAa0K8HPNWBxaCzfUEINeebiwFuSyRS5KWuRHUIS3xsQj8t7Nw
+mIBf6uNrzI3JRUs0RMSsI3nbTgp0l/qZlFh8hnfRUrcq7oOLy/AuXrJpoQjA6ZRix+jfBM2CGiRf
+5s7tn9dwNwsEAj+NQxGMsGAEAsdD/ttKA7GgLCzgNhYMJ3hTPh5ngahiO2ehAnxmpE45ltGJ3Zea
+dixbAdGsI3yOF/Bd3Ei9xsVOOGtD60pToRYUakGPWMnfFKOhGaM4FsRZTCjQm6xIWHLZlXspVotw
+2/l1WAyGuJrlarW4YXq5/e2nLxAIfFEcimCEBSMQOCL+stJALCgk/DtfdRbeF4pZaCwQPui5xHJY
+0DRlRiJB3rlRgcmGb0drrfDWjEQkqG3DNh7EuWB1Mj05t6jFB6dv4iyofO1XE6OhY6hlc+A5WV6Y
+KPH+Fp8kCcBXhcRgzAuQf2RgTHj95xZxLIFA4LdwKIIRFoxA4Hj4TNlqNvEWZBUox71bTznLrA0c
+AyFxF0DexHXolc3eDko2xFrAFggq07tWZW+J4NSxFCuiliIOEnfWBqU4Rp5GT2O0D+JGNpqQ6giK
+jp2Pt2jT9bb7ZOQlI9/L99jf4jHQMb5nTC833J4nIMY1EAj8Jg5FMMKCEQgcD/nTxGD4oGchBiaM
+EwGh2IasQnqi3yxGo2cVyZQlSl2GmviE1uLh3ZS8a5Vmg3JB2N6lyZfdWhvSpn62xJR2QEaFiIfV
+6V2r/N4WSj6cFcV2LccIQOMtbhFv8UBkZEynhNfYMC8QCDwQhyIYYcEIBI6IzxGDYa5AJNCDXX/k
+PB/srC4/sskexWjsZaFiS0fqxCeY4J4oMFt2Fm9iMMglals3B5y3ZfusTRanUc5RQiFWCt6/A7BN
+BTfWGbKKsHsZ4LJIMXHJ9+LCU+ItQgh+JNIQGxIGAoHH41AEIywYgcAR8TliMCxeonxuYgOAZh8B
+H1+gblIby0HaCO4+W5WPT2jdp4R4kN2hsTb4c1zbutaPBLfPhWRtArzlgl3Amh2ffUxG6sdiLIna
+ykHuQtiSpaBdgNeItwgEAoEvg0MRjLBgBALHw2eKwXCuPR2h2W8Yp/mPKKWsWBnKdy1rbH/nLFHs
+WpR8atkFjkSYVYViMZa0OUcJhNt93CwYAMxCAjSb//l+5abf230x/I7QvCdH0jZS23SDt1xSper+
+FkEuAoFA4KvgUAQjLBiBwPHweWIwKCAWaLT55dMyQCVvHRDhnQRp0Lnl2vJXz1LihPbRHxfXJbOq
+gCwdcEHdLn0suyfRTt7tPh0W/7G1omz7DbT7YkjcSvd3Gh8b16zxFrfTLdx3AoFA4AviUAQjLBiB
+wBHxeZQGIowDaFLLtnEI2eIaWHhvyIFzTaI0rEmvN+G/jYGwwOxkrkW8qZ3GXqTGkkDWF81+xfEY
+7DZFFo6l+aQ4jN39O2CkoSUlibJSMRnLF4u3iFSpgUAg8DVxKIIRFoxA4HhIn0hpwDEXPnjZ4ip0
+zwuY+5MFM3diFjgjFJ+PxvqhwjlbGBqrSTdQvMl2Vcu0LFCdwHH4IHRnudiQhXp+sxGfxJa0u4az
+dUNzTdV4i/kCYAReX24RbxEIBAJfGIciGGHBCASOh/y3YzA0i5QXokXDzxmQxBLBGZxQr/DWCxb4
++zEPHJ/gyQuf7y0GrWVB3JMSfMyEi6Ugi4UPHDc3K47pSEieLNCeGNoDF0fSyZLlxg8Ub5EiBW0g
+EAgcAIciGGHBCAQOiL8dg8FZpEjzLxp+yxIl7j76q2n7N1YCFvjTVrhvrBZKAZoA8bYcC/r2MQ3e
+AoJN27TFFIxuQeZ8rhEHc4mqZVO/PFmq7QUsBmUxoiXxFtPphul5evd2BAKBQODz4z///vvvv3+7
+EY/CfJ2BAZhO8ZIKBA6DFXj68YTXf17/SvVP/30qVoyPEp33zv2Zsn4Wv1v277R977fecT42JNwu
+kYI2EAgEjoT/+9sNeCQyMiYEuQgEjoS/7fb4t4hNIBAIBAJfFYdykYoYjEDggPjbMRiBQCAQCAR+
+CociGBGDEQgcEH87BiMQCAQCgcBP4VAEIywYgcDxEL75gUAgEAh8LXz7GIx8nwsl0YDD+n2oOVBO
+H7GJZMzXmqfleXr//DVjXjLyvZKhMSENCdOvbCr1yLI+BTLyNSMPCelUKaP7O/DdkNdQGgQCgUAg
+8JVwKIIhFoyfE0NnzNc3fr4nTKfpbYF9zZjvs7bi9Xnv3Ix8n3G+ksA0ALhn5AGY71PNpvKRdj+y
+rF/EOmO+ZOTThNsDCU1e5tL+U6K/E26nyI8fCAQCgUAg8NlxKILxS1mk1rpn7fMN09iUt8zI11zS
+3443TF1hPSNfZmCo9GbZozgZ+TrjfM/AMOH2ksAZ9ctvM8534PauFeSRZf068n3GjIRpfHANrc/9
+CiBsF4FAIBAIBAJfAhGDMZR/qboW8b/pdMPtZQKQMV/mfskrMNfap1MqWv1758x7JkIwNRQkIT3f
+cDsBuO9c/6fK+h0MCfhT7istmYtMQt8WEYMRCAQCgcDXwqEIxi9lkVpztWLsYEjFcrHmri94Xmbk
+FUinSWME8n3bsnmdASRMl32LQinj9o5F4DfLWmecf5zx9N+n8u/HGfOdaVnG/OOM8726YP140nPP
+19LXYiUp5wDAfDnj/EMImFw/I9+lnrMSnbzOmN+sv4O9Dbx2ynJj9UZbAl8DEYMRCAQCgcDXwqEI
+xq9ZMIqL1Julnso5eWl/k+DqhOkEABPSCUXwbQXiSjrejIkYJtye0/txE79YVl7nSgQy0mnC9Dwh
+IWO+njVIXft1LYI5kMp5Q0JeZpwvMzJSIV6V3qSxDcAugdkWH5KRx2rd+TFjpvqnWv8mluS91KS1
+L3OnL0+bvjSxKo926QoEAoFAIBAIKCIG4wP+/Rbd0F6bC5E4mSVhGhJmlMxOk7h2rPXaR7h6rPkX
+y8rIP2bkIeF2uRnxOE3I16cSs3GacCPhPp1ei6sVAJyKNWCu2uR0mgA8AddUBHwmO9XKUVy1bPTm
+H4WcTC83u0unCbg+Yb7PmKWcmsXLlefIVHVZGxKmC8XGUF/m083KApCepS+hDf9qCDoYCAQCgcDX
+QlgwhowPC52NVl1Sw7oMUyIkX6klQ+5e/0sg0vJTWHOJFRm3maUKWcjm2jUAQEJyQe9iyUF1k4IG
+yO+1M7GlgMhYSwGnWv/M9XP/2r/XXNowTpvAe+nLvLBFhPsS4upXQ44YjEAgEAgEvhTCgvFW/IWW
+ixII3mrRJa7gPmNWIViIhaRaBVSofUigcv61sqrAvRcwmwBzAVtRhPK2jtYXfsjoCuwDgLW5/ifq
+z+9ZMJY6CvcznjbxLvXcO4DTTlsCXwsRgxEIBAKBwJfCoQjGL+2DoULyjrAMFAG3daWSDfoG2qyv
+Qb7PyNV9ahqAc9W87wq761y0+G9ulDchDTPyT5Sl8RED+v0UoX+sv+3FQGziVd6LX2HIue/Xnway
+kmh/7GtGVivLZpw27lSBr46wXwQCgUAg8LVwKILxO/tg7IsxNdXrkGifjGzHLr39MSxeoZCAVLTp
+17JPxl78RF5quafbm71IP1PW8w2v5ap9TbAeJ/ernpC+NuPU/q3HO9ePTR0/U39DeNKYgGsu7lZv
+bvCXg3AcAGG/CAQCgUDgayFiMPbcfAAAGXONpUinqcnIVGrsb75XNeuDuVGlsQRW5+vO3hTrXDI5
+vWm9QKeszgm6FwdtgqcpdLcjVDYHJPelNy0YgLlp7VgwetcPU63//Eb9O9dvCEcd915fJB2tZI36
+SEaqwOdGxGAEAoFAIPClEBaMasEou1KjCqQlJa3k30+D15Tn61lJxy7GhHTNyJiRcUMaEm6nqWQ4
+up6RVyEstDnfgLJ3xXsad1fWE5VV236vjmLPHASdMD0nnK8zzj+A2yUBS9nbY66b9k2SMaqr9c8a
+Y9ISshKDQq5Y3eul/ozzj7lklxpLW63+hI9ZHQoJm68zzj8yptNUgrgXIWklRW9YMA6CiMEIBAKB
+QOBL4VAE49diMMqHbJjnf0tFeG33eFhqbSfsY5gwDTPOKzDfcxGoTxNuI3C+5G3cRq1reqtMxmnC
+bUw4X85vlOXHIZ1uuGHGfC8kQ7T7to8EjclG65821p40TkiD1J9wG2+6M3rPauDqvwO4yvF36u+V
+R2XN17Pv++W9vgS+EsJ+EQgEAoHA18J//v3333//diMehfP1jGmYNJ1qYA9ZydReVqefwpqRh5/b
+Qz3fMzA+sH6gBLT/fmmBT4a8Zpx/nPH6z+vfbkogEAgEAoEPICwY3xIPTtv6C4L9Q0lgEItjI2Iw
+AoFAIBD4UjhUkHeQi0DggIgYjEAgEAgEvhQORTB+KYtUIBD41AiVQSAQCAQCXwuHIhhhwQgEjodQ
+GQQCgUAg8LVwKIIRFoxA4ICIGIxAIBAIBL4UDkUwwoIRCBwQEYMRCAQCgcCXwqEIRlgwAoHjIVQG
+gUAgEAh8LRwqTa1aMNafpxl13+fOsf1ffhePKeXt8h5dx+/gM7Ul8FUQ9CIQCAQCga+GQxGMhIT5
+OmPm3Zv3vjPe2jn6f/n9rTa+hz9RZiDwSfCQDRkDgUAgEAj8T3ConbwDgUAgEAgEAoHA38WhYjAC
+gUAgEAgEAoHA30UQjEAgEAgEAoFAIPAwBMEIBAKBQCAQCAQCD0MQjEAgEAgEAoFAIPAwBMEIBAKB
+QCAQCAQCD0MQjEAgEAgEAoFAIPAwBMEIBAKBQCAQCAQCD0MQjEAgEAgEAoFAIPAwBMEIBAKBQCAQ
+CAQCD0MQjEAgEAgEAoFAIPAwBMEIBAKBQCAQCAQCD0MQjEAgEAgEAoFAIPAwBMEIBAKBQCAQCAQC
+D0MQjEAgEAgEAoFAIPAwBMEIBAKBQCAQCAQCD0MQjEAgEAgEAoFAIPAwBMEIBAKBQCAQCAQCD0MQ
+jEAgEAgEAoFAIPAwBMEIBAKBQCAQCAQCD8P/A517XHTGX3DDAAAAAElFTkSuQmCC
+"
+     id="image2993"
+     x="0"
+     y="0" />
+</svg>
diff --git a/atmel-samd/modmachine.c b/atmel-samd/modmachine.c
index 1471ca981..6a8256753 100644
--- a/atmel-samd/modmachine.c
+++ b/atmel-samd/modmachine.c
@@ -32,6 +32,7 @@
 #include "py/runtime.h"
 
 #include "adc.h"
+#include "mpdac.h"
 #include "pin.h"
 
 #if MICROPY_PY_MACHINE
@@ -39,6 +40,7 @@
 STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_umachine) },
     { MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&adc_type) },
+    { MP_ROM_QSTR(MP_QSTR_DAC), MP_ROM_PTR(&dac_type) },
     { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&pin_type) },
 };
 
diff --git a/atmel-samd/mpconfigport.h b/atmel-samd/mpconfigport.h
index 545b2c40d..7682997ad 100644
--- a/atmel-samd/mpconfigport.h
+++ b/atmel-samd/mpconfigport.h
@@ -56,6 +56,8 @@
 #define MICROPY_PY_MACHINE          (1)
 #define MICROPY_MODULE_WEAK_LINKS   (1)
 #define MICROPY_REPL_AUTO_INDENT    (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_ENABLE_FINALISER    (1)
 
 // type definitions for the specific machine
 
diff --git a/atmel-samd/mpdac.c b/atmel-samd/mpdac.c
new file mode 100644
index 000000000..5f3308b93
--- /dev/null
+++ b/atmel-samd/mpdac.c
@@ -0,0 +1,152 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013, 2014 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+//
+// #include "py/nlr.h"
+#include "py/runtime.h"
+// #include "timer.h"
+#include "mpdac.h"
+// #include "dma.h"
+// #include "pin.h"
+// #include "genhdr/pins.h"
+
+#include "asf/sam0/drivers/dac/dac.h"
+
+/// \moduleref machine
+/// \class DAC - digital to analog conversion
+///
+/// The DAC is used to output analog values (a specific voltage) on pin PA02
+/// (Arduino Zero A0, Feather MO Bluefruit A0).
+/// The voltage will be between 0 and 3.3V.
+///
+/// *This module will undergo changes to the API.*
+///
+/// Example usage:
+///
+///     from machine import DAC
+///
+///     dac = DAC()             # create DAC 1 on pin PA02
+///     dac.write(512)          # write a value to the DAC (makes PA02 1.65V)
+///     dac.write_mv(1650)      # Also results in PA02 being 1.65V
+
+/******************************************************************************/
+// Micro Python bindings
+
+typedef struct _dac_obj_t {
+    mp_obj_base_t base;
+    struct dac_module dac_instance;
+} dac_obj_t;
+
+// create the dac object
+
+/// \classmethod \constructor()
+/// Construct a new DAC object for pin PA02.
+STATIC mp_obj_t dac_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    mp_arg_check_num(n_args, n_kw, 0, MP_OBJ_FUN_ARGS_MAX, true);
+
+    dac_obj_t *dac = m_new_obj(dac_obj_t);
+    dac->base.type = &dac_type;
+
+    struct dac_config config_dac;
+    dac_get_config_defaults(&config_dac);
+    config_dac.reference = DAC_REFERENCE_AVCC;
+    enum status_code status = dac_init(&dac->dac_instance, DAC, &config_dac);
+    if (status != STATUS_OK) {
+      // Throw error.
+      return mp_const_none;
+    }
+
+    struct dac_chan_config config_dac_chan;
+    dac_chan_get_config_defaults(&config_dac_chan);
+    dac_chan_set_config(&dac->dac_instance, DAC_CHANNEL_0, &config_dac_chan);
+    dac_chan_enable(&dac->dac_instance, DAC_CHANNEL_0);
+
+    dac_enable(&dac->dac_instance);
+
+    // return object
+    return dac;
+}
+
+/// \method deinit()
+/// Turn off the DAC, enable other use of pin.
+STATIC mp_obj_t dac_del(mp_obj_t self_in) {
+    dac_obj_t *self = self_in;
+
+    dac_disable(&self->dac_instance);
+    dac_chan_disable(&self->dac_instance, DAC_CHANNEL_0);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(dac_del_obj, dac_del);
+
+/// \method write(value)
+/// Direct access to the DAC output (10 bit).
+STATIC mp_obj_t dac_write(mp_obj_t self_in, mp_obj_t val) {
+    dac_obj_t *self = self_in;
+
+    dac_chan_write(&self->dac_instance, DAC_CHANNEL_0, mp_obj_get_int(val));
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(dac_write_obj, dac_write);
+
+/// \method write_mv(value)
+/// Direct access to the DAC output by specifying millivolts.
+STATIC mp_obj_t dac_write_mv(mp_obj_t self_in, mp_obj_t val_mv) {
+    dac_obj_t *self = self_in;
+    // TODO(tannewt): Sanity check that the mv value is less than the reference
+    // voltage.
+    // Dividing by 3301 instead of 3300 ensures that val_mv of 3300 actually
+    // produces a value of 1023 instead of 1024 which is out of range of the
+    // DAC.
+    uint16_t val = ((uint32_t) mp_obj_get_int(val_mv)) * 1024 / 3301;
+
+    dac_chan_write(&self->dac_instance, DAC_CHANNEL_0, val);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(dac_write_mv_obj, dac_write_mv);
+
+STATIC const mp_map_elem_t dac_locals_dict_table[] = {
+    // instance methods
+    { MP_OBJ_NEW_QSTR(MP_QSTR___del__), (mp_obj_t)&dac_del_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_write), (mp_obj_t)&dac_write_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_write_mv), (mp_obj_t)&dac_write_mv_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(dac_locals_dict, dac_locals_dict_table);
+
+const mp_obj_type_t dac_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_DAC,
+    .make_new = dac_make_new,
+    .locals_dict = (mp_obj_t)&dac_locals_dict,
+};
diff --git a/atmel-samd/mpdac.h b/atmel-samd/mpdac.h
new file mode 100644
index 000000000..931987cd9
--- /dev/null
+++ b/atmel-samd/mpdac.h
@@ -0,0 +1,27 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013, 2014 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+extern const mp_obj_type_t dac_type;