trace_graph.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ca1725ea-0d55-4419-8772-59595b7998c2",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep rand = \"*\"\n",
    "\n",
    "/*\n",
    "------------------------------------------------------------------------------------------------\n",
    "Will be replaced with an import command once the project reachesd 1.0\n",
    "------------------------------------------------------------------------------------------------\n",
    "*/\n",
    "use rand::Rng;\n",
    "\n",
    "pub struct Neuron {\n",
    "    w: Vec<Value>,\n",
    "    b: Value,\n",
    "    nonlin: bool,\n",
    "}\n",
    "\n",
    "impl Neuron {\n",
    "    pub fn new(nin: usize, nonlin: bool) -> Neuron {\n",
    "        Neuron {\n",
    "            w: (0..nin).map(|_| Value::from(rand::thread_rng().gen_range(-1.0..=1.0))).collect(),\n",
    "            b: Value::from(rand::thread_rng().gen_range(-1.0..=1.0)),\n",
    "            nonlin,\n",
    "        }\n",
    "    }\n",
    "\n",
    "    pub fn forward(&self, x: &Vec<Value>) -> Value {\n",
    "        let out = (std::iter::zip(&self.w, x)\n",
    "            .map(|(wi, xi)| wi * xi)\n",
    "            .collect::<Vec<_>>()\n",
    "            .into_iter()\n",
    "            .reduce(|a, b| a + b)\n",
    "            .unwrap())\n",
    "            + self.b.clone();\n",
    "        if self.nonlin {\n",
    "            out.relu()\n",
    "        } else {\n",
    "            out\n",
    "        }\n",
    "    }\n",
    "\n",
    "    pub fn parameters(&self) -> Vec<Value> {\n",
    "        [self.w.clone(), vec![self.b.clone()]].concat()\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::fmt::Debug for Neuron {\n",
    "    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n",
    "        write!(f, \"{}Neuron({})\", if self.nonlin { \"ReLU\" } else { \"Linear\" }, self.w.len())\n",
    "    }\n",
    "}\n",
    "\n",
    "pub struct Layer {\n",
    "    neurons: Vec<Neuron>,\n",
    "}\n",
    "\n",
    "impl Layer {\n",
    "    pub fn new(nin: usize, nout: usize, nonlin: bool) -> Layer {\n",
    "        Layer {\n",
    "            neurons: (0..nout).map(|_| Neuron::new(nin, nonlin)).collect(),\n",
    "        }\n",
    "    }\n",
    "\n",
    "    pub fn forward(&self, x: &Vec<Value>) -> Vec<Value> {\n",
    "        self.neurons.iter().map(|i| i.forward(x)).collect::<Vec<_>>()\n",
    "    }\n",
    "\n",
    "    pub fn parameters(&self) -> Vec<Value> {\n",
    "        self.neurons.iter().flat_map(|neuron| neuron.parameters()).collect()\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::fmt::Debug for Layer {\n",
    "    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n",
    "        write!(\n",
    "            f,\n",
    "            \"Layer of [{:?}]\",\n",
    "            self.neurons.iter().map(|n| format!(\"{:?}\", n)).collect::<Vec<_>>().join(\", \")\n",
    "        )\n",
    "    }\n",
    "}\n",
    "\n",
    "pub struct MLP {\n",
    "    layers: Vec<Layer>,\n",
    "}\n",
    "\n",
    "impl MLP {\n",
    "    pub fn new(nin: usize, nouts: Vec<usize>, nonlin: bool) -> MLP {\n",
    "        MLP {\n",
    "            layers: (0..nouts.len())\n",
    "                .map(|i| {\n",
    "                    Layer::new(\n",
    "                        vec![nin].into_iter().chain(nouts.clone().into_iter()).collect::<Vec<_>>()[i],\n",
    "                        nouts[i],\n",
    "                        nonlin,\n",
    "                    )\n",
    "                })\n",
    "                .collect(),\n",
    "        }\n",
    "    }\n",
    "\n",
    "    pub fn forward(&self, x: Vec<Value>) -> Vec<Value> {\n",
    "        self.layers.iter().flat_map(|i| i.forward(&x)).collect()\n",
    "    }\n",
    "\n",
    "    pub fn parameters(&self) -> Vec<Value> {\n",
    "        self.layers.iter().flat_map(|layer| layer.parameters()).collect()\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::fmt::Debug for MLP {\n",
    "    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n",
    "        write!(\n",
    "            f,\n",
    "            \"MLP of [{}]\",\n",
    "            self.layers.iter().map(|l| format!(\"{:?}\", l)).collect::<Vec<_>>().join(\", \")\n",
    "        )\n",
    "    }\n",
    "}\n",
    "use std::cell::{Ref, RefCell};\n",
    "use std::collections::HashSet;\n",
    "use std::rc::Rc;\n",
    "\n",
    "#[derive(Clone, Eq, PartialEq, Debug)]\n",
    "pub struct Value(Rc<RefCell<Values>>);\n",
    "\n",
    "pub struct Values {\n",
    "    data: f64,\n",
    "    grad: f64,\n",
    "    op: Option<String>,\n",
    "    prev: Vec<Value>,\n",
    "    _backward: Option<fn(value: &Ref<Values>)>,\n",
    "}\n",
    "\n",
    "impl Values {\n",
    "    fn new(data: f64, op: Option<String>, prev: Vec<Value>, _backward: Option<fn(value: &Ref<Values>)>) -> Values {\n",
    "        Values {\n",
    "            data,\n",
    "            grad: 0.0,\n",
    "            op,\n",
    "            prev,\n",
    "            _backward,\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "impl Value {\n",
    "    pub fn from<T: Into<Value>>(t: T) -> Value {\n",
    "        t.into()\n",
    "    }\n",
    "\n",
    "    fn new(value: Values) -> Value {\n",
    "        Value(Rc::new(RefCell::new(value)))\n",
    "    }\n",
    "\n",
    "    pub fn data(&self) -> f64 {\n",
    "        self.borrow().data\n",
    "    }\n",
    "\n",
    "    pub fn grad(&self) -> f64 {\n",
    "        self.borrow().grad\n",
    "    }\n",
    "\n",
    "    pub fn zero_grad(&self) {\n",
    "        self.borrow_mut().grad = 0.0;\n",
    "    }\n",
    "\n",
    "    pub fn adjust(&self, val: f64) {\n",
    "        let mut value = self.borrow_mut();\n",
    "        value.data += val * value.grad;\n",
    "    }\n",
    "\n",
    "    pub fn add(a: &Value, b: &Value) -> Value {\n",
    "        let _backward: fn(value: &Ref<Values>) = |out| {\n",
    "            out.prev[0].borrow_mut().grad += out.grad;\n",
    "            out.prev[1].borrow_mut().grad += out.grad;\n",
    "        };\n",
    "\n",
    "        Value::new(Values::new(\n",
    "            a.borrow().data + b.borrow().data,\n",
    "            Some(\"+\".to_string()),\n",
    "            vec![a.clone(), b.clone()],\n",
    "            Some(_backward),\n",
    "        ))\n",
    "    }\n",
    "\n",
    "    pub fn mul(a: &Value, b: &Value) -> Value {\n",
    "        let _backward: fn(value: &Ref<Values>) = |out| {\n",
    "            out.prev[0].borrow_mut().grad += out.prev[1].borrow().data * out.grad;\n",
    "            out.prev[1].borrow_mut().grad += out.prev[0].borrow().data * out.grad;\n",
    "        };\n",
    "\n",
    "        Value::new(Values::new(\n",
    "            a.borrow().data * b.borrow().data,\n",
    "            Some(\"*\".to_string()),\n",
    "            vec![a.clone(), b.clone()],\n",
    "            Some(_backward),\n",
    "        ))\n",
    "    }\n",
    "\n",
    "    pub fn pow(&self, other: &Value) -> Value {\n",
    "        let _backward: fn(value: &Ref<Values>) = |out| {\n",
    "            let mut base = out.prev[0].borrow_mut(); // I want to remove this\n",
    "            base.grad += out.prev[1].borrow().data * (base.data.powf(out.prev[1].borrow().data - 1.0)) * out.grad;\n",
    "        };\n",
    "\n",
    "        Value::new(Values::new(\n",
    "            self.borrow().data.powf(other.borrow().data),\n",
    "            Some(\"^\".to_string()),\n",
    "            vec![self.clone(), other.clone()],\n",
    "            Some(_backward),\n",
    "        ))\n",
    "    }\n",
    "\n",
    "    // Negative power ie x^-1, this will allow us to divide\n",
    "    pub fn powneg(&self) -> Value {\n",
    "        let _backward: fn(value: &Ref<Values>) = |out| {\n",
    "            let mut base = out.prev[0].borrow_mut(); // and remove this\n",
    "            base.grad += -(1.0 / base.data.powf(2.0)) * out.grad;\n",
    "        };\n",
    "\n",
    "        Value::new(Values::new(\n",
    "            1.0 / self.borrow().data,\n",
    "            Some(\"^\".to_string()),\n",
    "            vec![self.clone()],\n",
    "            Some(_backward),\n",
    "        ))\n",
    "    }\n",
    "    pub fn tanh(&self) -> Value {\n",
    "        let _backward: fn(value: &Ref<Values>) = |out| {\n",
    "            let out1 = out.prev[0].borrow().data.tanh();\n",
    "            let mut outue = out.prev[0].borrow_mut();\n",
    "            outue.grad += (1.0 - out1.powf(2.0)) * out.grad;\n",
    "        };\n",
    "\n",
    "        Value::new(Values::new(\n",
    "            self.borrow().data.tanh(),\n",
    "            Some(\"tanh\".to_string()),\n",
    "            vec![self.clone()],\n",
    "            Some(_backward),\n",
    "        ))\n",
    "    }\n",
    "\n",
    "    pub fn exp(self) -> Value {\n",
    "        let _backward: fn(value: &Ref<Values>) = |out| {\n",
    "            out.prev[0].borrow_mut().grad += out.data * out.grad;\n",
    "        };\n",
    "        Value::new(Values::new(\n",
    "            self.borrow().data.exp(),\n",
    "            Some(\"exp\".to_string()),\n",
    "            vec![self.clone()],\n",
    "            Some(_backward),\n",
    "        ))\n",
    "    }\n",
    "\n",
    "    pub fn relu(self) -> Value {\n",
    "        let _backward: fn(value: &Ref<Values>) = |out| {\n",
    "            out.prev[0].borrow_mut().grad += (out.data > 0.0) as i8 as f64 * out.grad;\n",
    "        };\n",
    "\n",
    "        Value::new(Values::new(\n",
    "            self.borrow().data.max(0.0),\n",
    "            Some(\"ReLU\".to_string()),\n",
    "            vec![self.clone()],\n",
    "            Some(_backward),\n",
    "        ))\n",
    "    }\n",
    "\n",
    "    pub fn sum<I: Iterator<Item = Self>>(mut iter: I) -> Self {\n",
    "        // iter.fold(Value::from(0.0), |sum, val| sum + val) <- For some reason I couldn't get this\n",
    "        // to work\n",
    "        let mut sum = Value::from(0.0);\n",
    "        loop {\n",
    "            let val = iter.next();\n",
    "            if val.is_none() {\n",
    "                break;\n",
    "            }\n",
    "            sum = sum + val.unwrap();\n",
    "        }\n",
    "        sum\n",
    "    }\n",
    "\n",
    "    pub fn backward(&self) {\n",
    "        let mut topo: Vec<Value> = vec![];\n",
    "        let mut visited: HashSet<Value> = HashSet::new();\n",
    "        self._build_topo(&mut topo, &mut visited);\n",
    "        topo.reverse();\n",
    "\n",
    "        self.borrow_mut().grad = 1.0;\n",
    "        for v in topo {\n",
    "            if let Some(backprop) = v.borrow()._backward {\n",
    "                backprop(&v.borrow());\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn _build_topo(&self, topo: &mut Vec<Value>, visited: &mut HashSet<Value>) {\n",
    "        if visited.insert(self.clone()) {\n",
    "            self.borrow().prev.iter().for_each(|child| {\n",
    "                child._build_topo(topo, visited);\n",
    "            });\n",
    "            topo.push(self.clone());\n",
    "        }\n",
    "    }\n",
    "\n",
    "}\n",
    "\n",
    "impl std::fmt::Debug for Values {\n",
    "    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n",
    "        write!(f, \"Value(data={}, grad={})\", self.data, self.grad)\n",
    "    }\n",
    "}\n",
    "\n",
    "/*\n",
    "----------------------------------------------------------------------------------\n",
    "Rust requires this boilerplate for stuff like hashset, derefrenceing into etc.\n",
    "----------------------------------------------------------------------------------\n",
    "*/\n",
    "impl std::hash::Hash for Value {\n",
    "    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {\n",
    "        self.0.borrow().hash(state);\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::ops::Deref for Value {\n",
    "    type Target = Rc<RefCell<Values>>;\n",
    "\n",
    "    fn deref(&self) -> &Self::Target {\n",
    "        &self.0\n",
    "    }\n",
    "}\n",
    "\n",
    "impl<T: Into<f64>> From<T> for Value {\n",
    "    fn from(t: T) -> Value {\n",
    "        Value::new(Values::new(t.into(), None, Vec::new(), None))\n",
    "    }\n",
    "}\n",
    "\n",
    "impl PartialEq for Values {\n",
    "    fn eq(&self, other: &Self) -> bool {\n",
    "        self.data == other.data && self.grad == other.grad && self.op == other.op && self.prev == other.prev\n",
    "    }\n",
    "}\n",
    "\n",
    "impl Eq for Values {}\n",
    "\n",
    "impl std::hash::Hash for Values {\n",
    "    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {\n",
    "        self.data.to_bits().hash(state);\n",
    "        self.grad.to_bits().hash(state);\n",
    "        self.op.hash(state);\n",
    "        self.prev.hash(state);\n",
    "    }\n",
    "}\n",
    "\n",
    "/*\n",
    "------------------------------------------------------------------------------------------------\n",
    "This allows us to use Value + Value instead of Value.add(Value), just so it works like micrograd\n",
    "------------------------------------------------------------------------------------------------\n",
    "*/\n",
    "impl std::ops::Add<Value> for Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn add(self, other: Value) -> Self::Output {\n",
    "        Value::add(&self, &other)\n",
    "    }\n",
    "}\n",
    "\n",
    "impl<'a, 'b> std::ops::Add<&'b Value> for &'a Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn add(self, other: &'b Value) -> Self::Output {\n",
    "        Value::add(self, other)\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::ops::Sub<Value> for Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn sub(self, other: Value) -> Self::Output {\n",
    "        Value::add(&self, &(-other))\n",
    "    }\n",
    "}\n",
    "\n",
    "impl<'a, 'b> std::ops::Sub<&'b Value> for &'a Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn sub(self, other: &'b Value) -> Self::Output {\n",
    "        Value::add(self, &(-other))\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::ops::Mul<Value> for Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn mul(self, other: Value) -> Self::Output {\n",
    "        Value::mul(&self, &other)\n",
    "    }\n",
    "}\n",
    "\n",
    "impl<'a, 'b> std::ops::Mul<&'b Value> for &'a Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn mul(self, other: &'b Value) -> Self::Output {\n",
    "        Value::mul(self, other)\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::ops::Div<Value> for Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn div(self, other: Value) -> Self::Output {\n",
    "        Value::mul(&self, &other.powneg())\n",
    "    }\n",
    "}\n",
    "\n",
    "impl<'a, 'b> std::ops::Div<&'b Value> for &'a Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn div(self, other: &'b Value) -> Self::Output {\n",
    "        Value::mul(self, &other.powneg())\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::ops::Neg for Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn neg(self) -> Self::Output {\n",
    "        Value::mul(&self, &Value::from(-1))\n",
    "    }\n",
    "}\n",
    "\n",
    "impl<'a> std::ops::Neg for &'a Value {\n",
    "    type Output = Value;\n",
    "\n",
    "    fn neg(self) -> Self::Output {\n",
    "        Value::mul(self, &Value::from(-1))\n",
    "    }\n",
    "}\n",
    "\n",
    "impl std::iter::Sum for Value {\n",
    "    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {\n",
    "        Value::sum(iter)\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fb1bee0d-cc8e-492c-aa46-69a7275c89dc",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep petgraph = \"*\"\n",
    ":dep petgraph-evcxr = \"*\"\n",
    "use petgraph::graph::Graph;\n",
    "use std::collections::HashSet;\n",
    "\n",
    "use petgraph_evcxr::draw_graph;\n",
    "\n",
    "fn build(v: Value, nodes: &mut HashSet<Value>, edges: &mut HashSet<(Value, Value)>) {\n",
    "    if !nodes.contains(&v) {\n",
    "        nodes.insert(v.clone());\n",
    "        v.borrow().prev.iter().for_each(|child| {\n",
    "            edges.insert((child.clone(), v.clone()));\n",
    "            build(child.clone(), nodes, edges);\n",
    "        });\n",
    "    }\n",
    "}\n",
    "\n",
    "fn trace(root: Value) -> (HashSet<Value>, HashSet<(Value, Value)>) {\n",
    "    let mut nodes = HashSet::new();\n",
    "    let mut edges = HashSet::new();\n",
    "\n",
    "    build(root, &mut nodes, &mut edges);\n",
    "    (nodes, edges)\n",
    "}\n",
    "\n",
    "pub fn draw_dot(root: Value) {\n",
    "    let (nodes, edges) = trace(root);\n",
    "    let mut g = Graph::<String, String>::new();\n",
    "    let node_ids = nodes\n",
    "        .iter()\n",
    "        .map(|n| {\n",
    "            (\n",
    "                n.clone(),\n",
    "                g.add_node(format!(\"data {:.4} \\ngrad {:.4} \", n.borrow().data, n.borrow().grad)),\n",
    "            )\n",
    "        })\n",
    "        .collect::<Vec<_>>();\n",
    "\n",
    "    edges.iter().for_each(|(n1, n2)| {\n",
    "        let node_id1 = node_ids.iter().find(|(n, _)| n == n1).unwrap().1;\n",
    "        let node_id2 = node_ids.iter().find(|(n, _)| n == n2).unwrap().1;\n",
    "        g.add_edge(node_id1, node_id2, n2.borrow().op.clone().expect(\"REASON\"));\n",
    "    });\n",
    "    draw_graph(&g);\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f08e2f9a-7b47-4b59-b37a-4e2b81f08d27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let x = Value::from(1.0);\n",
    "let y = (x * Value::from(2) + Value::from(1)).relu();\n",
    "y.backward();\n",
    "draw_dot(y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ba0dda29-1a17-4abb-9253-2f80cb9f224f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvUAAAKlCAYAAABLzBN6AAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOydd1hUR/v+7116EwEFRJqKIkVQEBF7B1tiiTWWaCyvGkti7/paoqahiUlMvokhTexRYxSxoihiRUWsCIgiKKIgdWHv3x952Z8roAuyexY4n+vaC/bsnHmehec+88ycOTMSkoSIiIiIiIiIiIiISFVlt1RoD0RERERERERERERE3g4xqRcRERERERERERGp4ohJvYiIiIiIiIiIiEgVR1doB6oy+fn5ePr0KXJzc5GdnY2CggIAQFZWFgoLCwEAmZmZKCoqAgCYmppCT08PAFCrVi3o6OgAAGrXrg0dHR1YWlqiVq1aAnwTEZGKIZfLkZGRgefPn0Mmk+HFixcA/tVGTk4OACA3Nxd5eXkAAAMDAxgbGwMADA0NYWRkBAAwNjaGgYEBzMzMYGlpqdCGiEhVICsrC0+fPkVRUREyMjIAACTx7NkzAEBRUREyMzMBABKJBLVr1wYA6OjoKK75enp6MDU1hYGBASwtLRXaEBHRdnJycvD06VMUFBTg+fPnkMvlAKDQQlnxr6urCzMzMwD/v20wNjaGpaUl9PX1BfgmVR8xqX+FZ8+eISkpCUlJSUhMTERycjIeP36Mp0+fIiMjA0+fPlW8ipOWyqQ4ube0tISFhYXid0tLS9jZ2cHR0RGOjo5wcnJCvXr1xORHpNLJz89HUlIS7t+/r9BBampqifh/+vSpImmpbMzNzUvEv6WlJWxsbODo6AgHBwc4ODjAyclJTH5EKh25XI5Hjx4hMTFRoYXk5ORS24GMjAzIZLJK98HIyKjUdsDKygr29vZwdnaGg4MDHB0dYWVlVen2RWo2xblQYmJiiVzo1VfxoE1lYmpqWuL6b2VlpWgDXs6FDA0NK91+VUVSE1e/SU1NRWxsLGJjYxEXF6cI2qSkJGRlZSnKFV88bWxsSgTXyxdbIyMjmJmZQVf33z5SWb+XNYKfmZkJmUxWaoPx8is5ORkPHz5UNCC6urqoX78+HBwc4OzsjMaNG8Pd3R0eHh5o3Lixwq6IyKtkZ2cjLi4OsbGxuH79Ou7evatI4h89eqQoZ2RkBCcnJ9ja2pZIMKysrBS/16pVS2nkvazf8/LykJubW+bvxSOeZb1SU1ORmJiI7OxshY/W1taKJL9Ro0Zwc3NDs2bN4ObmphgFEhF5laKiIsTHx+PatWuIi4vDjRs3FAM6Dx48UNx51dHRQb169eDo6Fjq9f/ll56eHszNzQEAUqm01N/lcjmeP39e5u/Fd4BffRW3DWlpaUhOTkZaWpriuxgbGyuSfCcnJ7i5ucHDwwPu7u6oX7++xv6mIlWLjIwMXLt2TZEPJSQkICEhAUlJSYqRdQCoU6cOHBwcYG1trXTdf/Wlr68PCwsLAMoj8mXF/8sj+IWFhcjKylKM+r/8Sk9PV/wsbgOK7woDUEr0GzVqBE9PT3h4eMDNza2mDfrsrtZJfU5ODi5cuIArV64oLtzXrl1Deno6gH+Tdnd3dzRo0ABOTk6KUY/iJLl4moA2UVRUhJSUFKURpOLe9I0bN3Dv3j0UFRVBX18frq6uiiTfw8MDrVq1gr29vdBfQUSDyOVyxMXF4eLFi4oL9/Xr15GQkAC5XA4DAwO4ubnBxcVFaeSjWAt169YV+iuUSnp6ulLsF2vhzp07iIuLU9xFK05wPD094e7uDh8fH3h6eop3uGoYjx49QnR0NGJjYxVtQVxcHPLy8iCRSODs7IymTZsqEuPiNsDBwQH169fXygGS3NxcpTbg5VHV2NhYRdJfu3ZtRYLv4eEBLy8vtGzZUuzw1iCKiopw7do1XLhwQaGB2NhYPHjwAMC/d0bd3d2V2oHil7bmQk+fPlVc+18emC1uA/Lz86Gjo4OGDRuiWbNmcHd3R7NmzdCyZUs0bNhQaPfVRfVK6h8+fIjIyEicOnUKFy5cwPnz55Gfnw9zc3O4uLgoLmrFP6vjP1Ymk+HWrVu4fv26IoGLjY3FzZs3UVRUhHr16sHX1xe+vr5o164d2rZtW9N6stWazMxMXLlyRaGDM2fOID09HXp6enBwcFDSgK+vL5o2bVotE9yHDx+W0MDly5eRnZ0NExMTNG/eXKGBjh07wtraWmiXRSqJwsJC3Lx5U6ktiIuLA0nUq1dPqQ1wd3dH8+bNYWpqKrTblU5GRgbi4+MRGxuLCxcuKHSQkpICHR0duLq6KrUFLVq0gFQqrp1RHcjMzER0dLQi/iMjI5GRkQF9fX24uLgotQEeHh5o0KABJBKJ0G5XGoWFhUhKSlK6/hf/zMvLg42NDfz8/KpjHlS1k/pbt27h4MGDOHz4MKKiovD48WPo6+ujRYsW8Pf3R+vWrREQEABnZ2ehXRWcFy9e4Ny5czhz5gyioqJw9uxZpKWlQU9PDy1atECHDh0QGBiIdu3aifPTqhBPnz7F4cOHcejQIURGRuLmzZsgCRcXF7Ru3Vrx8vb21srRRk1SVFSE2NhYhQaioqIUf69GjRqhTZs2CAwMRPfu3cUkvwohk8lw+vRphIWF4cSJE7h48SLy8vJgaWmpaAdat24Nf39/xRSAmsyDBw+UNHDhwgXk5eXBwsICrVu3RpcuXRAYGIhmzZoJ7aqIijx79gyHDx9GWFgYTp06hZs3bwIAXF1dFXlQmzZt4O7uXqM7bnl5ebhw4QKioqIQGRmJqKgopKSkQE9PDz4+PujYsSOCgoLQtm3bqvqgbtVK6jMzM3HkyBGEhYUhLCwMCQkJMDc3R5cuXdCuXTu0bt0aPj4+YlKqInfv3lVc2I8cOYK4uDgYGxujU6dOCAwMRGBgIFxdXYV2U+QlioqKEB0drdDAuXPnIJFI4O/vj06dOimSGG2dNqNtZGRkKDq5J06cwOnTp1FYWIjmzZsrNNCmTRvFqlUi2sG9e/cUGjhy5AiysrLQqFEjdOvWDQEBAfD394erq2u1Gn1UFzKZDJcuXUJUVBROnz6NI0eO4MmTJ6hfv75CA926dYOlpaXQror8D5K4dOkSDh48iIMHD+LMmTMgCX9/f3Tu3BkBAQFo3bq1+AC1CiQkJOD06dM4c+YMwsPDcfPmTZiamqJr164ICgpCUFBQVRoY1v6k/tGjR9i+fTt27tyJyMhIyOVy+Pr6Ki42rVu3rvEjkJVFUlKSUkP57NkzODs745133sGQIUMQEBAgNpICkJ+fj4MHD2Lr1q04ePAgMjIy4OjoqNBA165dFQ8kibwdL168wNGjRxU6uHv3LszMzNC9e3cMHjwYffv21cr5pTWBixcvIjQ0FHv27MGtW7dgamqKzp07K3Tg4uIitIvVArlcjvPnzys0cPbsWZCEn58fBg4ciMGDB8PR0VFoN2scRUVFOH78OEJDQ7Fv3z6kpqbC1tYWPXv2RFBQELp37654SFWk4ty7d0/RWTp69ChevHiBpk2bYsCAARg2bBg8PT2FdvF1aGdSn56ejl27diE0NBQnTpyAsbEx3nnnHfTu3Rvdu3dHnTp1hHax2lNYWIizZ8/i4MGD2LlzJ+Li4uDk5ITBgwdj6NCh8PHxEdrFao1MJsPhw4exdetW/PXXX8jKykK7du3Qr18/BAUFwc3NTWgXawR37tzBoUOHsGfPHhw5cgSGhobo27cvhg4diqCgIBgYGAjtYrUmNjYWoaGh2Lp1K27fvo2GDRvivffeq+q3yKsUz549w5EjR/DPP/9g9+7dePbsGdq0aYMhQ4Zg0KBBsLW1FdrFas3Zs2exZcsWbNu2DSkpKfDx8VFooHnz5uJAmxopKCjAyZMnceDAAWzfvh1JSUlo1qwZhg4dimHDhqFBgwZCu/gqu0EtIT8/n1u2bGHPnj2pp6dHIyMjvvfee9yxYwdzcnKEdq/Gc/nyZc6fP58NGjQgADZu3JhLlixhYmKi0K5VK6Kjozlx4kRaWVlRIpHQ39+fX331FZOTk4V2rcaTmprKjRs3skOHDpRKpTQ3N+fo0aN54sQJoV2rVqSkpHDVqlX09PQkANrb2/Pjjz/m2bNnhXatxpOfn899+/ZxxIgRNDMzo46ODrt06cLNmzeL7XQlkpiYyEWLFrFRo0YEwKZNm3LZsmW8ceOG0K7VWORyOU+ePMnJkyezbt26lEgkDAgI4LfffsvMzEyh3Stml+BJ/f3797lo0SLa2tpSV1eXffr04e+//65NfySRV4iKiuLHH39MW1tb6ujosF+/fjx06BDlcrnQrlVJcnNz+csvv9DPz48A6OnpyU8//ZTx8fFCuyZSBsnJyfzyyy/ZsmVLAmCzZs343XffMSsrS2jXqiwnT57ksGHDqK+vTysrK06ePJkREREsKioS2jWRUsjJyeGOHTs4cOBA6uvr09LSkrNmzeKdO3eEdq3KcvToUQ4YMIA6Ojq0s7PjrFmzePHiRaHdEnkFmUzGf/75h6NGjaKxsTFr1arFqVOnakOnS7ik/uTJkxw0aBD19PRoY2PDuXPnMiEhQSh3RCpAfn4+t23bxm7dulEikdDFxYVr1qxhenq60K5VCZKTk7l06VLWrVuX+vr6HDRoEMPDw8XOURXj/PnznDBhAo2NjWlmZsYJEybwypUrQrtVJcjNzWVISAibN29OAPT19eWmTZuYnZ0ttGsi5SA1NZVr1qyhs7MzpVIpu3Xrxm3btlEmkwntmtZTrAEvLy+FBkJCQlhQUCC0ayIq8Pz5c27atIlubm4EwLZt2woZ+5pN6uVyOXfv3k1vb2/Fl//zzz+Zn5+vSTdE1MCVK1f4n//8h6ampjQ1NeW8efP45MkTod3SSq5fv85hw4ZRKpXS3t6eK1asYEpKitBuibwl6enp/Oyzz9ioUSNKJBL27duXFy5cENotreT58+dcsWIFLS0taWhoyNGjRzM6Olpot0TeksLCQu7evZvdu3enRCJhkyZN+Ntvv7GwsFBo17SOrKwsrlq1SqGBsWPHiqPyVZiioiLu27ePgYGBitj/448/NH2nUTNJvVwu519//cXmzZtTIpFw4MCBvHTpkiZMi2iY58+fc926daxbty7NzMy4YMECMbn/H3FxcRw+fDilUik9PDwYGhoqjmRVQ4ov7n5+fpRIJHz33XfF693/yMzM5MqVK2lpaUlzc3MuXbqUjx8/FtotETVw48YNjh49mrq6unR1deXvv/8uJvcks7Oz+dlnn7Fu3bqsVasWFy9eLLaR1YwbN25w5MiR1NHRoYeHB7dv366pO/DqT+r37t3LFi1aUCKRcMCAAYyJiVG3SREtICsri2vXrmWdOnVoZmbGRYsWMSMjQ2i3BOHWrVt8//33qaOjQ3d3d4aGhorzhGsI+/bto6+vLyUSCfv3719jp+W8ePGCq1atopWVFc3NzblkyRI+ffpUaLdENMCtW7c4atQo6ujo0M3NjVu2bKmRUwzz8/MZHBxMW1tbmpiYcO7cuWIyX825fv06hwwZQqlUyubNm3Pv3r3qNqm+pP7OnTvs2bMnJRIJ+/Tpw/Pnz6vLlIgW8+LFCwYHB9PGxoaWlpbctGlTjbmg5+TkcOnSpTQwMKCbmxtDQkLEkaoaSnh4OP38/CiVSjlhwgQ+f/5caJc0xt69e+nk5ERTU1POnTtXfOamhhIfH88JEyZQV1eXbdu2rVEd3IiICLq7u1NfX58TJkzgw4cPhXZJRINcu3aNgwYNokQiYa9evXjv3j11mar8pL6goIBr1qyhoaEhXV1defjw4co2IVIFycjI4LRp06ijo8MOHTrw2rVrQrukVo4cOUJXV1eamJhwzZo1YjIvQrlczpCQENatW5f16tVjSEiI0C6pleTkZL733nsEwEGDBvHRo0dCuySiBVy+fJkBAQHU1dXltGnTqvVKd0+fPuW0adMolUrVncyJVAEiIiLo4eFBIyMjLl26VB3Pk1ZuUn/48GE2adKEpqam/Oyzz8Snt0VKEB0dTV9fX+rr63PBggXMzc0V2qVKJTk5mQMGDCAADhkyhA8ePBDaJREt48mTJxw3bhwlEgl79OhR7ZYAlMlkXL16NY2Njenm5sZjx44J7ZKIllFUVMTvv/+eFhYWdHBw4O7du4V2qdL55ZdfWKdOHdrZ2XH79u1CuyOiJeTn53PFihU0NDSkl5cXo6KiKrP6yknqZTIZ586dq5g3mpSUVBnVilRTCgsL+fXXX9Pc3Jze3t68deuW0C5VCvv372edOnXYuHFjHjp0SGh3RLScyMhIenl50czMjFu2bBHanUrh/v37bNu2LY2Njbl69WpxZTOR15KamsrRo0dTIpFw4sSJ1WKQJysrS7EgwkcffVSjptqJqM7t27fZrVs36urq8vPPP6+saclvn9QnJyezffv2NDQ0ZHBwcGU4JVJDSExMZOvWrat8UlNYWMilS5dSKpVy5MiRfPHihdAuiVQRXh4QGTlyZJXelfPw4cO0sbGhq6trjZovLfL27NmzhxYWFmzevDlv374ttDsV5saNG/T09GSdOnV44MABod0R0XLkcjmDg4Opp6fHd955pzIWD3i7pP7IkSO0tbWlq6uruKqNSIWo6knNo0eP2K1bN7FTK/JW/PXXX7SwsGCLFi2qXFLzcqd2xIgR4q66IhWiqg/y7Nq1i+bm5mzZsqU4d16kXERERNDOzo5OTk5vu19HxZP64OBg8SIuUmls376d5ubmbNOmTZVZHePixYu0tbVl06ZNefXqVaHdEani3Llzh76+vrSwsOCJEyeEdkclsrKyGBQURCMjI/70009CuyNSxcnLy+OUKVMokUi4ZMmSKrNS2uLFiymRSDhjxgzxWUKRCpGSksJOnTrR2NiY+/btq2g15U/q5XI5Z8+eTYlEws8++6yihkVEShAXF0dnZ2e6ubkxMTFRaHdeS3h4OM3MzNi9e/dqvXqDiGbJzc3le++9R0NDQ+7cuVNod15LWloaW7ZsSRsbG547d05od0SqET/99BN1dXX54YcfavXKYUVFRYplOn/++Weh3RGp4shkMo4dO5a6uroVXR2t/En9jBkzqKenxz/++KMiBiuFo0ePsk2bNtTR0SnXeXl5eWry6F9+/vln9uzZkwkJCQwJCaGvr2+5dkvctGkT27Rpw6ioKKURirS0NDZq1Ii//fYbc3JyGBUVRTc3tzJXDCirntjYWJqYmNDe3p56enoEQB8fH6260/LgwQN6eXmxYcOGWvvAdXh4OI2MjPj+++8L+iCgNurgbWJMFf1osoxQFBUVccqUKdTV1dXaVTMeP37MZs2asVGjRoKu3iO0BsLDw9mjRw8C4LJly1Q+T4z1N/P333/TyMiII0eO1MrN+uRyOceNG0dDQ0Pu2bNHMD+E1kBZVCTuUlJS2KRJE/bq1Yvm5uYEwKlTp5ZZvrJynbLqEQK5XM558+ZRKpVWJLEvX1I/b9486urqcuvWreU1VOnMnj273EE8c+ZMtV0cYmNjaWZmprSpRI8ePThp0qQ3niuXy/nuu++yS5cupT79P3PmTAYFBSkdW716NV1cXMpVzyeffMIzZ86Q/PcB5yFDhhAA582bp9J31BTFCYOLi4vWrW198uRJGhsb8/3339eKESRt00FFY0wV/WiyjNDI5XJOmzaNenp6mtiFsFw8f/6cLVq0YIMGDbSi4y2kBnJzc3nv3r1yJfVirKvOoUOHaGhoyLFjxwqebL3K9OnTtUaf2tYOVDTuli5dqrjznZOTQy8vLxobG5dYQaiycp031SMkc+fOpY6ODnfs2FGe01RP6r/77jtKJBKt2TBlwYIF5QriK1eu0MTERG1B3LNnT/r4+CgdW7NmDfX19d/Y8K1bt442NjZMSUkp9fMhQ4bQ29tb6aK2fv16enp6qlxPRkYGd+3apXQsISGBEomEnTt3fq1/QpCamsrGjRvTz8+P2dnZQrtDkrx58yatrKzYv39/rUjoSe3SwdvEmCr60WQZbUAul3P8+PE0MTHRmuktMpmMPXr0YL169bTmYUChNVBQUFCupF6M9fKxf/9+6urqcvny5UK7omDDhg2USCQMDQ0V2hWSwmvgVSoad6/ePfj8889pYmJSIuGurFznTbmX0EyePJlGRkbleXh2lxQqcOzYMUydOhXLly/HqFGjVDml0pHJZNi2bRvmz5+PsLAwyOXyEmVu376N9evXY/ny5Thw4IDieGRkJPr06YPs7GyEhoZi+/btbzynvFy8eBFNmjRROubs7IyCggKEh4e/9ryFCxdi5syZsLW1LbVMly5dEBMTgyVLlgAACgsL8ccff2DGjBkq11O7dm30799f6ZiTkxM8PDzQuHFjlb+nprC2tsb+/fsRHx+PsWPHCu0OsrKy0LdvX7i4uOD333+Hjo6OIH5osw7eJsZU0Y8my2gDEokE3377Ldq1a4d33nkHqampQruETz75BJGRkdi3bx+cnZ0F8UHbNFDea4EY6+WjV69e+Oabb7Bs2TLs3LlTaHdw9OhRfPzxx1i1ahWGDBkiiA/apoFXqWjcGRgYKL1//PgxZsyYAUNDQ6W6KyPXUSX3EpoNGzagU6dO6NevH9LS0lQ6541J/ePHjzFixAi8++67WLx48Vs7WRGeP3+Onj17Ii4uDrNnz0Zqaiq+/PJLpTLTpk3Dhx9+iBEjRqBNmzbo3bs31q5dCwAgifbt2wMAzM3NYW5u/sZzysOTJ0+QmpoKKysrpePFjd69e/fKPPerr74CSTRo0AAffPABOnXqhJkzZ+L58+eKMmPGjEHnzp2xcuVKfPDBBxg/fjzGjRuHDz/8sFz1vIpcLse9e/cQGBhY7u+sCRo3bqy46Pzwww+C+jJp0iQ8e/YMu3fvhrGxsSA+aLsOSkOVGFNFP5oso03o6upi69atMDIywqhRo0ptvDXFX3/9hW+++QY//fQTfH19BfFBGzUgkUiUfr4OMdYrxsSJEzFx4kSMGzcOCQkJgvnx5MkTjBo1Cv3798f8+fMF8UEbNfAylRV358+fx61bt7BixQql45WV61SkHk2jo6ODLVu2wMDAAGPGjAHJN5/0prH89957j87OzszIyKjQ7YPKYPLkyezXr5/SsT59+ijdbjI3N+fKlSsV793d3dm6dWvF++XLlxOA0hSWN52jKkePHiUALlmyROn43bt3CYCjR48u89wmTZrQzs6OW7duZVZWFvfu3UsjIyN6e3tTJpMpyuXk5LBz586KBz5SU1MrVM/L7N69m/7+/lo3V/FVFixYQGNjY8bHxwtif+vWrZRIJDx48KAg9ovRdh2Uhioxpop+NFlGG4mOjqaenh6/+eYbQew/fvyYVlZWHDdunCD2i9FGDcjlcgJQaXqIGOsVJycnh82aNWOnTp0Ea7OGDRtGR0fHytgkqMJoowZe5m3jLisri5MmTaKRkREBcMaMGUoLUlRWrlOReoTizJkz1NXV5Q8//PCmoq+ffnPw4EHs2LEDGzduRO3atcvVw6hMfvzxR/To0UPpmJeXl9L7/fv3Y9KkSQCA6OhokERubu5r663IOaXB//We9PT0lI4X11XWrZ1nz57h9u3b6NKlCwYPHgxTU1P07dsXkydPRkxMDLZs2aIoGx0dDTs7O8yePRsXL16Ev78/7t+/X+56ipHJZPj0008REhKi0giTkCxduhTOzs6YPHmyxm1nZmbik08+wYcffijoHY20tDSt18GrqBpjquhHk2W0ET8/P8yaNQsLFizAgwcPNG5/1qxZ0NfXx+eff65x28VURQ28ihjrFcfIyAibN2/GyZMn8euvv2rc/okTJxAaGoqNGzfCwsJC4/aBqqGBt407U1NTbNy4EREREQgICEBwcDC2bdsGoPJynYrUIyStW7fGtGnTMG/ePDx+/Pi1ZctM6ouKivDxxx9j8ODB6NWrV6U7WR5kMlmJQHg1SWjbti1OnDiBkSNH4tatW3B2dn7jrYrynhMdHQ1nZ2el13fffQd7e3sAQEZGhlL57OxsAICnp2ep9WVkZIAk6tSpo3S8Xbt2AIDLly8DAKKiojB69Gh8++23WLduHb755hskJCQoklxV63mZGTNmYOnSpXB1dS3z+2oL+vr6+O6773Dw4EGNzwNdt24d8vLysGbNGo3afZWYmBit18GrqBpjquhHk2W0lcWLF8PS0hLLly/XqN1Lly7h119/xYYNGxS36oVAmzRQUcRYfzt8fX3xn//8B/Pnz1dLp6ssSGLGjBno06cP+vTpozG7r6JNGqjsfOjV79OyZUscOHAAVlZW+PvvvxV1VkauU5F6hGbZsmUwMDDAp59++tpyumV9EBoaitu3b2PPnj2V7lxFSElJee3nc+bMQVxcHLZv3w5DQ0OVHqgp7zk2NjYYM2aM0jEvLy84OzvD0tKyhI+JiYkAAA8Pj1Lrc3Z2hpmZGR4+fKh0PCAgAABgYmICANi4cSNatWqFWrVqAQCmTJmCpKQkfPXVV3jy5InK9RSzfv16+Pn5Cd5ZKw8dOnRAUFAQli5diu7du2vEZnp6OjZs2ID58+eXmB+oabKysgBotw5epjwxpop+NFlGWzEyMsLixYsVSU2DBg00Ynf58uXw8fHBwIEDNWKvLLRJAxVFjPW3Z/Hixdi8eTM2bdqktFiEOtm3bx9iYmLwyy+/aMReWWiTBio7HyoNc3NzdOzYEQUFBQBUz5mKKasdKm892oCZmRnmzZuH+fPnY86cOWXf8ShrYk7Lli05bNiwcs78UQ8A2KdPH6VjCxcupEQiIUmeP3+eAHjgwAHF5/369WOzZs0U74vnkBXPlVLlnPLw0Ucf0d7eXunYokWLWLdu3ddu8tC7d282btxY6di5c+cIgOHh4STJ7t27c+jQoUpliuenxcbGqlwP+e9OfevXr1cqJ5fLGRcXp+I3FY7IyEgCYFRUlEbsrVu3jrVr19aKzbliY2OrhA7IisWYKvrRZBltRSaT0cnJiTNnztSIvbt371IqlZZYIk4ItFUDRUVF5VrSUoz1t2f69Ols0KCBxjal6tq1K3v37q0RW69DWzLI8X8AACAASURBVDXwKpUZd23btmVwcLDifWXlOqrWo03k5OSwbt26XLFiRVlFSl+n/vLlywTA48ePq8+7chAUFEQA3Lx5M0kyPz+fvXv3JgAmJSXxypUrBMCJEydSJpMxPDycDRo0oL29PW/dusX4+Hh+++23ioQwIiKCFy9efOM55eH+/fu0tbVlREQEyX8f9rC2tuamTZsUZY4cOcKhQ4cyPT1dcSw+Pp5mZmb8/fffFceWLVvG7t27K95v3bqVpqamzMnJURzbsWMHvb29FRc1Ver57rvvGBAQwM2bN3Pz5s38+eefuWHDBvbq1Uvht7bTrFkzjh8/XiO2XF1dOWXKFI3YUoWqoANVYqw0HaiiH02W0WaWL19Oa2trFhQUqN3WwoULaWdnpzUPjmmjBnJzcwmAs2fPLvGZGOvqoTi51UTyde/ePUqlUkF3jX0ZbdTAq1QkH5LJZPzjjz94//59RZljx46xRYsWSg/KVlauo0o92sgnn3zChg0blvWweOlJ/ZIlS+jk5KQ1q6I8evSI7du3JwA2adKE77zzDkeMGEFTU1N+9NFHTE5O5siRIymVSmljY8Pvv/+eK1eupFQq5axZs0j++w+0sbGhhYUF/+///o8k33hOeTl79iy7du3KdevWcfjw4Uq9S5KcNWsWAfDs2bNKx/ft20c3NzeuXbuW06dP5/vvv6+04VJhYSHnz59Pb29vfvPNN1y4cCGHDh1aQmivq2fz5s0EUOqrQYMGWvO/fhNr165l3bp11T5Cc/XqVY3eFVAFbdeBqjFWlg7epB9Nl9FW4uPjCYBHjhxRuy03NzeN3RVQBW3TwOnTpzl58mQCoIuLCzdu3KjUARJjXX34+vpqZGfc4OBgWlpaak3HVts0UBblzYdSU1NpaWlJPT09vvvuu+zXrx+nTp2qNJhZTGXlOm/KvbSRCxcuEAAvXbpU2selJ/X+/v6cMGGCej2rAHfu3OHNmzcpl8sZHx9fYuvgtLQ0pdGrV5edKigoKBEgbzqnIsTHx5eadMpkMt65c6fUc/Lz8xkbG8sXL16UWW9eXh6vXbvGtLS0MsuoUk9VJiYmhgDUvsPmF198QSsrK63ZOfZlqooOyuJ1OiDL1o9QZbQRV1dXzpkzR602kpKStPZWdFXRgBjr6mPhwoVs2LCh2u307t2bAwcOVLud8lJVNFCefEgul/P27dsq7XZcWblOVcuZ5HI5ra2tuW7dutI+3iUhlR9vLiwshImJCX766SeMGDGi9In4IiICQRKWlpZYtWqVWpe4HDZsGLKzs7F371612RARqSjjx4/H3bt3cfToUbXZ2LlzJwYPHoysrCzBNlwTESmLQ4cOITAwEI8fPy6xikllYmNjg/nz52vsoVwRkTfRv39/6OnpKZb6fIndJZa0vHPnDgoKCuDu7q4Z70REyoFEIoG7uzvi4uLUauf69etVdnUIkeqPu7s7rl+/rlYbcXFxaNCggZjQi2glxTmKOnWQnp6OtLQ0MR8S0Sped/0vkdQXL0Pk6OioXq9ERCqIo6Oj2jfgefjwIRwcHNRqQ0Skojg6OiI1NRWFhYVqsyFqQESbqV+/PnR0dEosS1iZFNct6kBEm3BwcChzWdMSSf3z588BQLEmuoiItlGrVi1kZmaq1UZmZqaoARGtpXgTqOJ1q9VBZmamoJtNiYi8DolEAjMzM7W2BcV1i22BiDZhbm6OzMzMUjcHK5HUv247dxERbUGMU5GaTGkX86psR0REGxHbGRFtpPi6XFp8lkjqi3ukxSP2IiLahiZG0Yt7wiIi2khmZqZipFJdaOKOmIhIRSGJrKwstbYFYj4koo28LgcqkdTXr18fAJCUlKRer0REKkhCQoIiTtWFnZ2dYltrERFtIzExETY2NtDV1VWbjfr164saENFakpOTUVRUBHt7e7XZsLOzAyDmQyLaRWJiYpk5UImkvmHDhjAwMEBsbKzaHRMRKS8kERcXp/bVCNzd3UUNiGgtsbGxGtFAYmIisrOz1WpHRKQiFF+f1akDS0tL2Nraqn2lKRGR8nD9+vUy475EUq+rqwtfX19ERESo3TFtJDExEQsXLoSzs/Nb1bF69WrMmDEDv/zyC2QymcrnXrp0CYsWLcIPP/yAFy9eCF5G24iJicHz58/RqlUrtdrx9/fH6dOnUVRUpFY72kpl6AB4+xhLSUnB77//jk8//RR3795VHM/Ozsa3336LWbNmYcWKFbh582aF6nkbrQpJREQE/P391WqjVatWkMvlOHXqlFrtaCtCaiA7OxuhoaGYOXMmtmzZ8sZnGyorvsuqRxuJiIiAi4sLLC0t1WrHz8+vxmqgmIpo4dChQ9i/f3+57Ij5z5uRy+U4ffo0/Pz8Si9Q2pZUy5cvp4ODg9J2ujWFo0ePsk2bNtTR0anQ+bGxsTQxMaG9vT319PQIgD4+PszKynrjuT///DN79uzJhIQEhoSE0NfXl48fPxasjDayevVq2tjYqD02r1+/TgCMjIxUqx1t5W11QL59jG3atIlt2rRhVFSU0v87LS2NjRo14m+//cacnBxGRUXRzc2Nu3fvLlc9b6NVIbl9+zYB8Pjx42q35enpyRkzZqjdjjYilAZSUlLYpEkT9urVi+bm5gTAqVOnllm+suK7rHq0lebNm3PKlClqt/P111+zdu3aSjut1jTKo4Xw8HD26NGDALhs2TKVbYj5j2pER0cTAK9cuVLax7tKTeqvXbtGADxy5Ih6vdNSZs+eXeEL+SeffMIzZ86QJJOTkzlkyBAC4Lx58157XmxsLM3MzPjw4UPFsR49enDSpEmClNFW3NzcNOanh4cHJ06cqBFb2sjb6OBtYkwul/Pdd99lly5dmJubW+LzmTNnMigoSOnY6tWr6eLiUq56KqpVoVm8eDFtbW0pk8nUbmvp0qW0sbGpsQmNEBpYunQpMzMzSZI5OTn08vKisbExnz9/rlSusuL7TfVoI1euXCEAHj16VO22kpKSqKOjw127dqndljajqhZyc3N57969ciX1Yv6jOtOmTWPjxo3L6niXntSTZOvWrTlo0CD1eabFLFiwoEIX8oyMjBLCT0hIoEQiYefOnV97bs+ePenj46N0bM2aNdTX12dSUpLGy2gjJ06cIACeP39eI/a+/PJL1qpVi8+ePdOIPW2jojog3y7G1q1bRxsbG6akpJT6+ZAhQ+jt7a10UVu/fj09PT1VrudttCok+fn5tLe359y5czViLyEhgVKplNu2bdOIPW1DCA3k5eUpvf/8889pYmJSIuGurPh+k960kSlTptDFxUVjdxQCAwNLDCTUNMqjhYKCgnIl9WL+oxrZ2dm0srLi6tWryyqyq8Sc+mI+/vhj7Ny5U2seEMnJycGmTZuwYsUK7NixAxkZGSgqKlLMNbx79y4WL16MoqIi/P3331i3bp1i/uDt27exfv16LF++HAcOHChRt0wmw7Zt2zB//nyEhYVBLpdXyMfatWujf//+SsecnJzg4eGBxo0bv/bcixcvokmTJkrHnJ2dUVBQgPDwcI2X0Ub++9//okOHDvD19dWIvTFjxkAqlWL9+vUasacKVUEHQMVj7OLFi1i4cCFmzpwJW1vbUst06dIFMTExWLJkCQCgsLAQf/zxB2bMmKFyPW+jVSHZvHkzHj9+jMmTJ2vEnpOTEwYMGICVK1dqzZr11V0DBgYGSu8fP36MGTNmwNDQUKnuyohvVfSmbTx48AA//fQTpk+frrF15KdPn46wsDBcuHBBI/ZURVu1oKOjU67vIeY/qvHdd98hLy8P48aNK7tQWel+UVERPT092a9fv0rvbZSXx48fs1GjRgwJCWFBQQHnzJlDAHR2dma7du0YEhJCW1tbAuAvv/zCFi1aKOZDT506le3bt+eTJ0946NAhSiQSrlmzRlH3s2fP2LVrVy5btozp6ekMCQmhvr7+W82jfJmioiKamJhw586dr/1+AErMD4yKiiIALlq0SKNltJFDhw4RAI8dO6ZRu8uWLWPt2rWZmpqqUbulUVV08DYxNmLECOrq6nL79u0cPXo0O3bsyE8++UTpbklBQQE7d+5MABw9ejQ/+OAD/vDDD+Wu51VU0aqQZGVl0d7enpMnT9ao3atXr1IqlfL333/XqN3SqAkaeJlz586xf//+JUakKyu+K1KP0IwfP5729vYl7mioGz8/PwYGBmrU5uvQZi3I5XIC4PLly1X6HmL+82YyMjJobW3NOXPmvK5Y2dNvSPLYsWOUSCTcu3dv5XpXTmbMmMFatWop5pDev3+fALhgwQJFmYULFyqClyRv3LhBuVxOc3Nzrly5UlHO3d2drVu3VryfPHlyiY5Lnz59Ki2p3717N/39/V97m/Do0aMEwCVLligdv3v3riJx0WQZbSMvL49NmzYVpIOZnZ1NZ2dnjho1SuO2X6Wq6OBtYqxJkya0s7Pj1q1bmZWVxb1799LIyIje3t5Kc8hzcnIUib2Pj0+JTpeq9byMKloVkpkzZ9LCwkKQDub48eNpY2PDjIwMjdt+mZqgAfLfDtykSZNoZGREAJwxYwbz8/MVn1dWfFekHiE5e/YspVIp//zzT43bPnnyJCUSidZ0+rVZC+VJ6sX8RzWmTJlCKysrPnny5HXFyp5+AwCdOnXCsGHDMHnyZKSnp7+uqFq5ffs2pFKp4labvb09XFxclJaZMjIyAgAMGzYMAODq6gqJRIL9+/dj0qRJAIDo6GiQRG5uLgAgLS0NP/74I3r06KFkz8vLq1L8lslk+PTTTxESEvLa24T8360yPT09pePFftra2mq0jLaxcOFCPHjwABs2bNC4bWNjYwQHB+O3337D3r17NW7/ZaqKDioaY8+ePcPt27fRpUsXDB48GKampujbty8mT56MmJgYbNmyRVE2OjoadnZ2mD17Ni5evAh/f3/cv3+/3PUUo6pWhSIyMhLr16/H2rVrYW1trXH7a9euBQBMmzZN47ZfprproBhTU1Ns3LgRERERCAgIQHBwMLZt2wag8uK7IvUISXZ2Nj744AN069ZN8b/VJO3atcOoUaMwdepUPHnyROP2X6WqaOFNiPnPm4mIiMD333+PL774AlZWVq8t+9qkHgC+/vprSKVSfPDBB4LNqWzXrh2ePXuG6OhoAEB+fj4ePnwIHx8fRZmyGuK2bdvixIkTGDlyJG7dugVnZ2fF94iJiYFMJivxj3xTox4dHQ1nZ2el13fffVei3IwZM7B06VK4urq+tr7iHfEyMjKUjhdv+uLp6anRMtrEP//8gy+//BLffPMNHBwcBPHh3XffxZgxYzB27FhF4igEVUUHFY2xjIwMkESdOnVKfG8AuHz5MgAgKioKo0ePxrfffot169bhm2++QUJCgmKeuar1vIyqWhWCp0+fYvjw4ejZs+fr51KqEQsLC/z888/4/fffERISIogPQPXXwKu2W7ZsiQMHDsDKygp///23os7KiO+K1CMkH330EdLS0vDTTz8J5kNwcDD09PTw4YcfCv6MibZpoaKI+c/refr0KUaMGIG+ffti9OjRbyz/xj3GLS0t8eeff6Jz585YtGgRVq1aVSmOloePP/4YFy5cwJw5c7B06VLs2bMHbdq0wX//+983njtnzhzExcVh+/btMDQ0xM6dOxWfZWVlAfh3w43yYGNjgzFjxigde7UXu379evj5+aFXr15vrM/Z2RmWlpYl/Cjeot3Dw0OjZbSF69ev4/3338eoUaMwatQoQX3ZsGEDzp49i3fffRcREREwNTXVuA9VRQcVjTFnZ2eYmZnh4cOHSscDAgIAACYmJgCAjRs3olWrVqhVqxYAYMqUKUhKSsJXX32FJ0+eqFxPMeXRqqYpKCjAe++9B5LYvHmzoHcRevXqhVmzZmHSpElo0qSJ4u+pSaq7BkrD3NwcHTt2REFBAQDVdVJMWfFd3nqEZP369fj111+xZ88eRWImBLVr18Yff/yBzp07Y/ny5Vi2bJlgvmibFiqKmP+UjUwmw+DBgyGRSPB///d/qp2k6nyen3/+mRKJpMQDaZogPz+f06ZN47lz5xgWFsa4uLgSZVatWkUASvMOz58/TwA8cOCA4li/fv3YrFkzkv+uVwqAffr0Uapr4cKFlEgkFfb3p59+4vr165WOyeXyUv0u5qOPPqK9vb3SsUWLFrFu3bqKB4I0WUZoHj58yAYNGrBt27Zas3ZyfHw8ra2t2bt3b0HW7a5KOqhojPXu3ZuNGzdWOnbu3DkCYHh4OEmye/fuHDp0qFKZ4jmRsbGxKtdDVkyrmqKoqIijRo2imZkZY2JihHaHJFlYWMi+ffvS2tqat2/f1rj9mqCB0mjbti2Dg4MV7ysrvlWtR0h2795NHR0drl27VmhXFPz444+USCT89ddfBfNBm7VQVFRUriUtxfynJHK5nOPGjaOpqSkvXbqk6mmvf1D2VZYtW0apVMqQkJDye/gWrFixgt7e3ty1axePHj3KqKgoxsbGKj3Is2zZMgJQ2lCgeFfQiRMnUiaTMTw8nA0aNKC9vT1v3brF+Ph4BgUFEQA3b95M8l+h9O7dmwCYlJRU7oeFvvvuOwYEBHDz5s3cvHkzf/75Z27YsIG9evViREQESfLIkSMcOnQo09PTFefdv3+ftra2ijJZWVm0trbmpk2bBCkjJCkpKWzatCmbNm2qdbu8RUVF0dTUlAMHDtT4g2RVSQeqxFhpOoiPj6eZmZnSSivLli1j9+7dFe+3bt1KU1NT5uTkKI7t2LGD3t7eLCoqUrkeVbQqFHK5nBMmTKC+vj4PHjwoqC+vkpWVxVatWtHBwYF3797VqO3qrgGZTMY//viD9+/fV5Q5duwYW7RooZSYVVZ8q1KPkOzbt4/6+voaX/FJFebNm0ddXV3u2LFDEPvarIXc3FwC4OzZs0t8JuY/qjF9+nTq6emVd6Ga8iX15L+BrKOjwx9//LG8p1aYffv20dDQkACUXo6Ojjx06BB37NhBV1dXAuCgQYOURrVGjhxJqVRKGxsbfv/991y5ciWlUilnzZpFknz06BHbt29PAGzSpAnfeecdjhgxgqampvzoo4+YnJyssp+bN28u4WPxq0GDBopVB2bNmkUAPHv2rNL5Z8+eZdeuXblu3ToOHz5caWRGiDJCkJCQwKZNm9LV1VXpQqRNRERE0MTEhP3799foXYSqooNi3hRjZelg3759dHNz49q1azl9+nS+//77zM7OVnxeWFjI+fPn09vbm9988w0XLlzIoUOHMj4+XuV6VNWqEMhkMo4dO5b6+vqCrzxWFhkZGfT19aWjoyOvX7+uMbvVXQOpqam0tLSknp4e3333Xfbr149Tp05V6sC+/LeojPh+k96EYseOHTQwMOD48eO1dkWqjz76iHp6ety6davGbWurFk6fPs3JkycTAF1cXLhx40alToCY/7yeoqIiTps2jTo6OhWJq/In9SS5ZMkSSiQSlZYrqgy2b9/OLVu28MmTJ7x58yYvXrzIY8eO8euvv2anTp3eeH5aWprSdImnT5+WKHPnzh3evHmTcrmc8fHxJbbkrkxkMhnv3LlT5ufx8fGKEUdtKKMpYmJiaGdnRy8vL61N6IuJiIighYUF27dvX2o8qYOqqoOyYux1OsjPz2dsbCxfvHhRZr15eXm8du0a09LSyiyjSj3axIsXL9inTx+amJhw//79QrvzWtLT09mmTRtaWloyMjJSIzZrggbkcjlv376t0u6WlRXf2qaTr7/+mlKplFOnTtWa9qk05HI5p0+fTqlUyq+//lqjtquqFsT8p2zy8/M5fPhw6uvrV7SjWLGkniQ3bdpEXV1dDhgwQK0bVdy+fZvW1tal3u5JTU3lyJEj1WZbRHP8+uuvNDExYZcuXbR645OXuXbtGh0cHNiwYUOeP39erbZEHVR/rl+/Tk9PT9atW7fEKJa2kpOTw379+tHAwEDtSY2ogepPdnY2x4wZU2IzJG1n9erVlEgkHD9+vEbu3opaqH4kJSUxICCAtWrV4uHDhytaTcWTepI8ceIE7ezs6OTkxDNnzrxNVWVSvFnA0KFDeeLECSYlJTEpKYnh4eEcMmTIa3t8ItpPbm4up02bRolEwmnTpinNG60KPH78mEFBQTQwMFDrLTxRB9Wb3377jaampvTz8ysxjUjbkcvlDA4Opp6eHvv166e2O1eiBqo3N27coJeXF83NzQWbp/427N27lxYWFmzRooXaY1HUQvXi6NGjtLGxoaurK69evfo2Vb1dUk/+ewtH3UlNWFgYp06dSjc3NxoaGrJZs2acNWuWWqfIiKifmzdv0tvbm+bm5ty+fbvQ7lSY4qRGV1eX/fr1U9uum6IOqh9VvVP7MsePH1cM8kRFRanFhqiB6smOHTtobm7Oli1bVrlO7cskJCSwVatWrFWrltrbNFELVR+5XM41a9ZQR0eHw4cPZ1ZW1ttW+fZJPfnvxP7ly5dTR0eHgYGBal3qTFsfmBFRnYKCAq5du5YmJib09/dnQkKC0C5VCkePHqWtrS0dHR35119/qdWWqIOqz+HDh+nq6koLCwvu2bNHaHcqhUePHrFr1640MDDgokWLSn3As7IQNVD1SU5O5qBBgyiRSPjxxx8LslRwZZOTk8MPP/yQEomEY8eO5ZMnT9RuU9RC1ePq1ats27YtDQwMuHHjxsqqtnKS+mJOnTrFZs2a0dDQkMuXL9eqNT9FtIMTJ07Qw8ODRkZGXLFiRZUemSyN1NRUjhgxghKJhH379uW9e/eEdklEy0hJSeHw4cMJgP369VPpgciqRGFhIYODg1mrVi02bNhQ6x/4FdE8MpmMX375Jc3MzNioUSOtW7a1Mti2bRvt7OxYt25dhoSEiIm3CMl/nxuZN28e9fT02KpVq/KsQa8KlZvUk/+KNTg4WCHWlzc4EKm5pKenc8KECZRIJOzSpQtv3LghtEtq5eXOy9KlS8UOrgiLiooYEhJCKysr1q9fv0pPOVOFhw8fcuTIkYqNbKrLHTmRt+P8+fP08/Ojnp4e586dqzWbC6qDZ8+eKZYn7NChg2JzPJGaydGjR+nq6kpzc3MGBwezsLCwsk1UflJfzIMHDxQX9LZt2/L48ePqMiWixWRmZnLNmjWsXbs27ezsNL5xmZAUFBQwODiYpqamdHJy4qZNmzS+YZWI8Mjlcu7du5fNmzennp4ep02bVhlzJ6sMx44do5ubGw0MDDhhwgStX65WRD1cu3ZNsT56p06dNLq/gdBcvHhR0ZEZOXJklX5uQKT8xMTEcNCgQYoBDjXenVVfUl9MeHg427RpQwDs1asXo6Oj1W1SRAt49uwZly1bxtq1a9PS0pKrVq2qUYnMyyQmJnL8+PHU09Njo0aN+Msvv4jJfQ1ALpdz+/bt9PT0pFQq5fvvv8+bN28K7ZYg5Obm8quvvqKtrS1NTEw4e/bs1+4vIFJ9uHbtGgcNGkSpVMrmzZur/XkjbUUmk/GHH36go6MjDQ0NOX36dD569Ehot0TUyOXLl/nOO+9QIpGwdevWb7NUpaqoP6kv5uDBg2zdurWip6Ku1RFEhCU9PZ0rVqyghYUFLSws+N///ld8Gv9/xMfHc+zYsdTT02Pjxo0ZEhJS7Z4pEPl3TvmOHTvo5eVFqVTKoUOH1qhRydeRnZ3NL774gjY2NjQ1NeW8efOYkpIitFsiauDKlSscOnQopVIpvby8uHPnTnFeOf/dNO/rr79mvXr1aGxszDlz5ogaqGbExMRw8ODBlEgk9PHx4d9//60p05pL6ov5559/2KpVKwJgy5Yt+fPPP6t1hQQRzRAdHc0xY8bQyMiItWvX5rJly6rMJlKa5u7du/zggw+oq6tLGxsbLliwgImJiUK7JfKWpKSkcOXKlXRwcKBUKuWgQYN47do1od3SSrKzs/nZZ5/R2tqa+vr6HDJkCE+cOCG0WyJvSX5+Prds2cIOHToQAD09Pblt2zat2rVTW8jJyeEXX3yh0MDw4cN5+vRpod0SqSAymYzbt29nx44dFbEvQEdW80l9MefPn+eECRNoZGREc3NzTpgwQXyIpIqRl5fHbdu2sW3btgTApk2bMjg4uMZOsykvKSkpXLNmjSIJ7NatG7dt26aOh2dE1EjxtczQ0FBxLRNH5lWj+BrSrVs3AqCrqyvXrFmjtg2sRNTDgwcPuGbNGtrb2yuuZXv37hVH5lWgWAPF05R9fHy4adMmZmdnC+2aiAqkpqZyzZo1dHR01IbYFy6pLyY1NZWrVq1S/EG6dOnCH3/8kenp6UK7JlIKRUVFPHbsGCdOnEhLS0vq6+tz2LBhPHnypNCuVVkKCgq4detWRQ/fxcWFixcvFju5WsydO3e4cuVKenh4EABbtWrFX375pVqv5KFuzp8/z7Fjx9LIyIi1atXiBx98wIMHD4rPn2gpz58/56+//spevXpRR0eHtra2XLRoEe/fvy+0a1WWM2fOcPjw4dTX16eVlRWnTJnCkydPip0jLSM3N5c7d+7kwIEDaWBgQCsrK86ZM0cblrAWPqkvprCwkHv27OHAgQNpZGREPT099urVi7/++qs4J1tg5HI5T58+zenTp9POzo4A6O3tzTVr1ogP+lQyV69e5YwZM1i/fn0CYLNmzbhq1Spx228tICkpiZ9//jn9/PwIgNbW1pw8eTLPnTsntGvViqdPn/Krr75STNOsU6cO//Of//DYsWPiNA6Byc7O5tatWzlgwAAaGhpSX1+fffr0YWhoqPh8UCXy6NEjrl69mp6engRAR0dHzpkzp7LXNBcpBzKZjAcPHuTo0aNpbm5OHR0ddu3alZs3b9amwZxdEpKElpGVlYW9e/ciNDQUhw4dglQqRc+ePdG7d28EBgbC3t5eaBerPXl5eTh58iTCwsKwc+dOJCQkoGnTphgyZAiGDh2Kpk2bCu1itUYul+PUqVPYunUrduzYgbS0NPj5+aFfv34IDAxEixYt6O7tjwAAIABJREFUIJVKhXaz2nPlyhUcOnQIe/bsQWRkJGrXro3+/ftj6NCh6NKlC3R0dIR2sVoTHx+PrVu3YuvWrYiJiYGdnR0GDBiAoKAgdOrUCSYmJkK7WO1JTU1FeHg49u/fj7///hu5ubno0qULhg4div79+8PCwkJoF6s1V69eRWhoKLZs2YJ79+7Bzc0NAwYMQK9eveDv7y9eg9RIdnY2jh49in/++Qe7du1CWloa/P39MWzYMAwePBj16tUT2sVX2a2VSf3LZGRkYPfu3dixYweOHz+O3NxceHh4IDAwEIGBgWjfvj2MjIyEdrNaEBcXh7CwMISFhSEiIgI5OTlwd3fHO++8g6FDh8Lb21toF2skRUVFOHLkCLZt24Z//vkHKSkpqFu3Lrp3747AwED06NEDtra2QrtZLXjy5AkOHz6MsLAwHDp0CA8fPkTdunURFBSEwYMHo0ePHtDX1xfazRrJjRs3EBoaij179iAmJgb6+vpo166dQgNeXl6QSCRCu1nlKSgoQGRkJA4dOoSwsDBcvnwZenp6aNeuHQYOHIj33nsP1tbWQrtZ4yCJqKgohIaGYt++fbh37x4sLCzQrVs39OzZE0FBQdqYZFY5YmNjceDAAYSFheHkyZMoKCiAj48P+vXrh2HDhqFRo0ZCu/g6tD+pf5m8vDxEREQoEs/Y2FgYGRmhQ4cOaNu2LQICAtCqVSvUqlVLaFe1HrlcjtjYWERFReH06dM4evQokpKSYGFhATs7O4wZMwaDBw+Gg4OD0K6KvARJxehxWFgYTp06hYKCAnh7e6Njx45o3bo12rRpA0dHR6FdrRI8fPhQoYGIiAhcuHABUqkUAQEBioEDHx8f8a6IlvHo0SOFBsLDw/H48WPUq1cPXbt2VWigWbNm0NXVFdpVrSc7Oxvnz5/HmTNnEBkZiePHj+PFixdo3LixQgOdO3cW74poGTdu3MDcuXMRERGB/Px85OXlwdvbG506dUKbNm0QEBAgzmp4A3K5HHFxcYrYP3LkCO7fv486deqge/fu6NmzJ3r06AEbGxuhXVWVqpXUv0pycjLCwsJw5MgRREZGIikpCVKpFO7u7ggICEBAQABat24NV1fXGt8oP336FFFRUYiKisKZM2cQHR2NzMxMmJiYwM/PDx07dkRgYCCcnJzQsWNHZGVl4ffff0e3bt2Edl3kNWRnZ+P48eM4dOgQTp06hStXrqCwsBB2dnaK5Mbf3x++vr41/o5WQUEBLl26pNDB6dOnkZSUBB0dHbi7u6Ndu3bo3r07unbtKg4MVCHkcjkuXryIsLAwnDhxAmfPnlVc21q2bKloC/z9/atS46w27ty5gzNnzuDs2bM4ffo0rl69qrhmBAQEoGvXrggMDETDhg2FdlWkDJ4/f45x48bhr7/+wsKFCzF79mzFgOfJkycV7YCDg4NiwDMgIADNmzeHnp6e0O4LRlZWFqKjo3H69GmcOXMGZ86cwbNnz2BiYoJWrVqhU6dOCAoKQsuWLatqzli1k/pXefToEc6dO4cLFy4gMjISkZGRyM3Nhb6+PlxcXODh4QF3d3fFTzc3t6r6jyuTzMxM3L59G7Gxsbh+/bri571790AS9erVQ7t27dC2bVv4+vqiVatWJaYTZGVlYeLEiQgNDcXUqVPx+eef1+gLQVUiOzsbly5dUmggIiICqampAIB69eqV0ICPjw+MjY0F9rpyKSwsRFJSUgkNxMbGIi8vD7Vq1UKrVq0UGmjbti0sLS2FdlukEomPj8epU6cUOrh06RLkcjksLCyU4t/DwwOenp7VcvpaRkaGUuxfuHABV65cQVZWFnR1ddGkSROltsDDw0Nol0VU4Pz58xgyZAgKCgqwZcsWtGvXrkSZV9uB48eP4/Hjx9DV1YWjo6OSBnx9fdG0adNqNTdfJpPh1q1bJa7/N27cgFwuR7169eDr66uI/9LyoCpK9UrqX0Umk+Hy5cuIiYlR+ucmJycDAExNTeHm5oYGDRrAwcEBjo6OcHJygqOjIxwcHFCnTh2Bv0FJ8vLycP/+fSQlJeH+/ftITExEYmIikpKScPPmTaXv1rRpU3h6esLd3R2enp5o2bIl6tatq7KtX3/9FZMmTYKfnx/+/PNP2NnZqetriaiRu3fv4uLFi0oXt9u3b0Mmk0FXVxcNGzZEkyZN4OjoqIj9Yh3Y2dlp3cVeLpfj0aNHSEhIUNJCQkIC7t69W+K7eXp6ws3NDZ6enmjevDlcXV3Fudc1jIyMDJw7dw7Xrl1TagsyMzMBALa2tnBzcyvRBhS/18a7XBkZGUptQLEW7t27h7i4OKXv9nInxsvLCy1atIChoaHA30CkvPzwww+YOnUq2rdvjz/++EPlO08kcfPmTVy6dAlXr17F9evXce3aNdy7dw9yuRyGhoZwc3NDw4YNFTFf/HJ0dISVlZWav1n5eLkNSEpKUrwS/x97dx5XU/7/Afx127QqhWiMsiUlJUoqSxQlBhm0CzOMtRk7M0MGM8P8vjNjlq99mOyFLKUUyVKRKFox1K3sLSqt93Y/vz/8ur/uKIq651bv5+NxHzOde5bXzfl03/fc9zmHz8fdu3fx8OFDVFdXQ0lJCUZGRuIP7yYmJrCysmrN5x607qK+PkVFReI/7Onp6eIdIycnR3xUEwBUVVVhYGCAjh07QltbG9ra2ujQoYP4/2tPAwBlZWXxH39VVVW0a9cOwOsCu6ysDCKRCMDrP8bA6x2zqKgIAFBeXo6CggKJR2Fhofj/8/Ly8PjxYzx9+lScT0VFRTzounfvjj59+oj/eBsYGDRJ4ZKWloapU6fixYsXCAgIgJOT0wevk3Cv5khGTXHz8OFDcZH86NEjCAQCAICCggL09PSgp6dX535f+2dFRUXIyclBU1NTvKyGhgYAQElJCXJycqioqADw+khSVVUVgNffDAmFQgiFQol9vq7x8OTJEzx69Ei8rLy8PPT09MTjoEePHuIi3sjISDwGCalLdnY20tPTkZKSgnv37kkUyaWlpeL5OnXqBD09PXTq1OmNcVB7LNT0nbdv3178YVhLSws8Hg88Hg8aGhriYlsgEODVq1cAXh+sKS8vB/D6/am+MVDzXpCdnY2SkhJxvo4dO4o/hBgYGKBfv37iIp6+hWr5iouL8dlnn+HEiRP45ptvsHbt2ibpMigrKxPXQqmpqcjMzBQXyLVrDTU1Nejr67+x/+vo6EBHR0f8c83fe3V1dfG3+5qampCTk3tj/6+qqhKPsfLycvF7Q35+/lv3/6dPnyInJ0f8HlDzHqWvrw8DAwP07NlTXMT36dOnrZ1X0zaL+repqKiQOOqRnZ2NvLy8N4qNmp+b+tenpqZW74eHmh235o93Y466f4iSkhJ88cUXOHz4MLXjtAHV1dUSR0FycnLw9OnTNz5o1vxcWVnZpNtXVFSs94ND586dJY6m6unptbU/2kRKCgoKJL4FevLkCfLy8uocBzXFeVOqve/X/v+OHTuiW7du4oM5+vr6ra6Fjvy/mzdvYvr06SgpKcHBgweldp5bRUWF+Oh37Vro30V2fn6++OBkU5GXl6/zw3Pt9wADAwN6D3gTFfUfqrCwUHzkvbKyEmVlZQBefwKuKXaKi4uhqqoq3vFqjuzLy8uLT8hTUVGBtra2TB9ZrGnHGTx4MA4dOoSPPvqI60hEBpSWlqKgoAACgQCMMbx8+RKA5JHIzZs3o7CwED/++COA1x9ea3oYa47kKCgoQFtbG+rq6ty8EELek0AgQEFBgfjI46tXr8Tfdr18+RKMMVy/fh3ffPMNTp06BVVVVSgqKor3dRUVFXE7jKamJrS1talFjIjbbWxtbXHo0CGZPfejuroaBQUF4m+Patc/RUVFEIlEEIlEKCkpEX+Tq6SkJP5mq+b9gMfjQVtbWzwPaTQq6knjpKWlYdq0aXj27BkCAgLg7OzMdSTSAsyaNQtPnz7F2bNnuY5CCCfCwsIwbtw4FBcXi9sUCKlLcXEx5syZg2PHjjVpuw1p9YJpLyGNYmxsjGvXrmHs2LFwcXGBn5+f+IgUIYQQQt5fYmIiBg0ahIsXLyIsLAz+/v5U0JMGoz2FNJq6ujoOHDiAffv2Yffu3bCzs0NWVhbXsQghhJAWKyAgALa2tujWrRuSkpLg6OjIdSTSwlBRT96bj48PEhISUFZWBktLS2qtIIQQQhqppKQE7u7u8PX1xeLFi3H+/PnWfNlF0oyoqCcfpF+/foiPj8ekSZMwfvx4aschhBBCGigtLQ3W1ta4cOECwsLC8OOPP8rcvUFIy0FFPflgKioq2LVrF/bt24c9e/bAzs4OmZmZXMcihBBCZFZAQAAsLS3RqVMnJCUlYezYsVxHIi0cFfWkyfj4+ODGjRsoLy+HpaUlQkNDuY5ECCGEyJRXr17B09MTvr6++OyzzxAZGUl3bCdNgop60qT69euH69evw9XVFRMmTICfn5/4zm+EEEJIW5aeng5ra2tERETg7Nmz2Lp1K93MkTQZKupJk1NRUcHOnTupHYcQQgj5PwEBARg8eDB0dHSQlJQEJycnriORVoaKetJsaq6OU1FRgYEDB+L48eNcRyKEEEKkqry8HJ9//rm43eb8+fN0R3bSLKioJ83KyMgI169fx4wZMzB16lRqxyGEENJmZGRkYMiQIQgODkZISAi125BmRUU9aXYqKirYunWruB3H1tYWDx8+5DoWIYQQ0mxq2m2UlZWRkJCAcePGcR2JtHJU1BOpqWnHqaqqgoWFBY4dO8Z1JEIIIaRJVVRUwM/PD76+vpg9ezZiYmJgYGDAdSzSBlBRT6SqdjvOtGnTqB2HEEJIq3H37l0MGTIEf//9N4KCgqjdhkgVFfVE6pSVlbF161YEBATgr7/+onYcQgghLd6BAwcwePBgKCkpITExEVOmTOE6EmljqKgnnPHy8hK34wwcOBBBQUFcRyKEEEIapabdxsfHB7NmzUJMTAx69OjBdSzSBlFRTzjVt29fXL9+Hb6+vpg2bRrmzp1L7TiEEEJahHv37sHa2hr79u3D0aNHsXXrVigpKXEdi7RRVNQTztW04xw7dgxHjx6FjY0NHjx4wHUsQgghpF4nTpyAlZUVFBQUkJiYiKlTp3IdibRxVNQTmTFlyhTEx8dDKBTCwsICgYGBXEcihBBCJFRWVsLPzw9TpkzB9OnTERsbi549e3IdixAq6olsMTQ0xLVr1+Dr64vp06dj7ty5qKys5DoWIYQQAj6fj+HDh4vbbXbs2EHtNkRmUFFPZE5NO87x48cRGBhI7TiEEEI4d/LkSZibm0MoFOLmzZuYNm0a15EIkUBFPZFZrq6uuH79OkQiESwsLHD06FGuIxFCCGljatptJk+ejAkTJuDq1avo3bs317EIeQMV9USmGRoaIi4uDr6+vnBzc4OPjw/Ky8u5jkUIIaQN4PP5GDlyJPbu3YvDhw8jICAAKioqXMcipE5U1BOZV7sd58yZM7Czs8M///zDdSxCCCGt2KlTpzBw4EBUVlbi1q1bcHNz4zoSIW9FRT1pMVxdXZGYmAhFRUVYWFjgyJEjXEcihBDSygiFQqxatQqTJ0/G+PHjqd2GtBhU1JMWxcDAAJcuXcLMmTPh7u5O7TiEEEKaTHZ2NoYPH44///wTBw4cQEBAAFRVVbmORUiDUFFPWpx27dph69atOHHiBM6cOQNbW1tqxyGEEPJBzpw5g4EDB+Lly5e4du0aPDw8uI5ESKNQUU9arMmTJyMpKQlKSkqwsLDA4cOHm21bjDFYWVkhJiam2bbRltDvk7R1NAZkh1AohL+/PyZNmgQXFxckJCTAxMRE/Dz9W5GWgop60qLp6+uL23E8PT3h4+ODsrKyJlv/w4cPcevWLTDG8M8//yA/Px8vXrygP+7viX6fpK3LysqiMSBDcnJyMGLECGzZsgU7duyQaLehv1ekpaGinrR4tdtxQkJCYGlpidTU1CZZ9969e2FpaYldu3bBzs4OHTt2hJWVFdzd3Ztk/W0N/T5JW3fgwAEaAzIiJCQE5ubmKCgoQHx8PD777DOJ5+nvFWlpeIwxxnUIQpoKn8+Hm5sbUlNTsX379g/uiRQKhTh//jxCQ0Nx4cIFDBgwAI6Ojvjkk0/QqVOnJkrd+s2aNQtPnz7F6dOn6fdJ2qSwsDCMGzcOBQUFuH79Oo0BDgmFQmzcuBEbNmyAp6cntm3bBjU1tTrno79XpAUJpiP1pFXR19fH5cuXMX/+fHh5eX1wO86DBw8QEBCAmJgY9O7dGyKRCCdPnkR8fHwTpm476PdJ2rrMzEwaAxzKzc2Fvb09Nm/ejG3btiEgIKDOgh6gv1ek5aGinrQ6ioqK+PHHHxEcHPzB7TgBAQG4ffs2Tp06hUePHmHDhg3Q1dXFihUrmjh120C/T9LWHT58mMYARy5cuIDBgwfjxYsXiI+Px5w5c946P/29Ii0Ntd+QVi07Oxtubm5ITk7G9u3b4enp+V7rEQgEUFFRwcGDBzF9+vQmTtn61bTfnD17FgD9PknbU9N+U1xcDA0NDRoDUlRdXY0NGzZgw4YN8PDwwLZt26Curt7g5enfirQQ1H5DWrfu3bvj8uXLWLBgAby9vd+7HUdRURFbtmzBsGHDmiFl20O/T9LW0RiQjmfPnsHJyQmbN2/Gzz//jP379zeqoAfo34q0HHSknrQZp0+fxsyZM6Grq4vAwED079+f60htxr+P1BPS1vz7SD1pfhcvXoSHhwfat2+PoKAgDBgwgOtIhDQnOlJP2o5PPvkEiYmJ6NChA6ysrLB7926uIxFCCGli1dXV8Pf3h4ODA2xsbBAfH08FPWkTqKgnbUr37t1x6dIlrFixAnPnzoWPjw9KS0u5jkUIIaQJPH/+HM7OzuJ2m+PHj0NTU5PrWIRIBRX1pM1RUFCAv78/Tp48idDQUFhaWiI5OZnrWIQQQj5AdHQ0zM3NkZWVhbi4OPj5+XEdiRCpoqKetFkTJkxAUlISOnTogCFDhmDXrl1cRyKEENJIjDFs3rwZDg4OsLa2Rnx8PMzNzbmORYjUUVFP2rSPP/5Y3I7zxRdfUDsOIYS0IC9evICzszPWrVuH//znPzhx4gS0tLS4jkUIJ6ioJ21eTTvOqVOncPbsWQwePJjacQghRMZdunQJ5ubmyMjIwKVLl6jdhrR5VNQT8n/Gjx+PxMRE6OjoYMiQIdi6dSvXkQghhPwLYwxbt26Fo6MjLC0tkZiYiCFDhnAdixDOUVFPSC0ff/wxoqOjsWLFCixZsoTacQghRIbk5eVh3LhxWLZsGTZs2IDg4GB06NCB61iEyAQq6gn5l5p2nHPnziEiIgKDBw/GnTt3uI5FCCFt2uXLl2Fubo60tDRcuXIFK1euBI/H4zoWITKDinpC6uHg4ICEhAR07NiR2nEIIYQjNe02Dg4OGDRoEJKSkmBtbc11LEJkDhX1hLxFt27dcPHiRaxcuRJLliyBt7c3Xr16xXUsQghpE/Lz8zF+/Hhxu83Jkyep3YaQelBRT8g71LTjREREIDIyktpxCCFECm7cuCG+GtmlS5eo3YaQd6CinpAGGj16NBISEtC5c2dqxyGEkGZS025ja2uL/v37IykpCTY2NlzHIkTmUVFPSCN069YNUVFR4nacTz/9FEVFRVzHIoSQVqGoqAhTp07FsmXLsGbNGpw6dQra2tpcxyKkRaCinpBGqt2OExMTAysrK9y+fZvrWIQQ0qIlJCRg4MCBuH79OqKjo+Hv7w85OSpTCGkoGi2EvKfRo0cjKSkJ3bt3h7W1NbXjEELIe6jdbtOzZ08kJCTA1taW61iEtDhU1BPyAXR1dREeHi5ux5kyZQpevnzJdSxO/fXXX+DxeBKPvXv3Iiws7I3pmzZt4jouIU0uPz8f7dq1k9jXx40bBwBo3769xPSBAwdynJZbxcXFmD59OpYtW4bVq1cjIiICurq6XMcipEWiop6QDyQvLw9/f39ERkYiNjYWQ4YMQVJSEtexOOPq6gpFRcV3zsfj8eDu7i6FRIRIl46ODhwcHN7ZOtLWx8DNmzcxcOBAxMbGIioqitptCPlANHoIaSKjRo3C7du3oa+vj6FDh7bZdhwtLS04OztDQUGh3nl4PB4GDRqEnj17SjEZIdLj5eUFxtg755s2bZoU0sienTt3wsbGBgYGBkhISMCwYcO4jkRIi0dFPSFNqHPnzggLC8PKlSuxdOnSNtuO4+Xlherq6nqfl5eXh4+PjxQTESJdEydORLt27ep9Xk5ODkOGDIGBgYH0QsmAmnab+fPnY/Xq1YiMjESXLl24jkVIq0BFPSFNrHY7TlxcnPhqDm3JhAkToKqqWu/zIpGozR6hJG2DqqoqJk6cWG8rmpycXJv7YHvr1i1YWFggOjoaYWFh1G5DSBOj0URIM7G3t0dSUhIMDQ0xYsSINtWOo6ysXG9vvby8PEaOHEknw5FWz9PTEwKBoM7nGGOYMmWKlBNxJyAgAHZ2dujevTuSkpLg6OjIdSRCWh0q6glpRp07d0Z4eDjWr1+PpUuXwtXVtc2043h4eNRb0Hh7e0s5DSHS5+TkhPbt278xXV5eHg4ODujcuTMHqaSrpKQE7u7u8PX1xeLFixEZGYmuXbtyHYuQVomKekKaGY/Hw8qVK3H+/Hlcu3YN5ubmbaIdx8HBoc47QcrJyWHSpEkcJCJEuhQVFeHm5gYlJSWJ6YwxeHl5cZSq6fD5/Lc+n5iYCAsLC1y4cAHh4eH48ccfIS8vL6V0hLQ9VNQTIiUjR47E7du3YWRk9M52nKNHj+L48eNSTNf0FBQU4ObmJtGCo6CgABcXF2hpaXGYjBDpcXd3R1VVlcQ0BQUFfPLJJxwlahr5+fkYMmQITp48WefzNe02H330EZKSkjBmzBgpJySk7aGinhAp6tSpE8LCwsTtOJMnT0ZhYaHEPPfu3cPMmTMxZ84c5OXlcZS0abi7u0u04FRXV7eKI5SENNTw4cMlzh9RUFDAxIkT62zLaUkWLFiAZ8+ewdvbG5mZmeLpr169goeHB3x9fbFo0SJcuHABenp6HCYlpO2gop4QKavdjhMfH4+BAwfi2rVrAICKigq4urpCKBSipKQEX3zxBcdpP4ytra3EG7qKior4zpqEtAVycnLw8vISt+BUV1fD09OT41Qf5vTp0zh69CiA13+zJk+ejMrKSqSnp8Pa2hqRkZE4e/YstdsQImVU1BPCkZEjRyIpKQn9+vXD8OHDsXnzZixevBh3796FQCCAQCDA8ePHERgYyHXU98bj8eDt7Q0lJSUoKiri008/hYqKCtexCJGq2i04ampqcHJy4jjR+8vPz8esWbPEl6IUCoVITU3FhAkTMHjwYOjo6OD27dst+jUS0lLxWENueUcIaTYikQibNm2Cv78/RCKRxHM8Hg/t27fH3bt3W+wlIG/fvg1zc3MAQHh4OMaOHctxIkKkr1evXnj48CFmzZqFPXv2cB3nvU2bNg0nT56s88pWrq6uOHr06FvvJk0IaTbBdKSeEI7JycnB3d0dSkpK4PF4Es8xxlBWVobZs2dzlO7DmZmZoXfv3ujQoQNGjx7NdRxCOFFzGVd3d3eOk7y/U6dOISgoqM6CnsfjITw8HA8ePOAgGSEEoPYbQjhXWVkJV1dXVFdXo64vzgQCAUJDQ3Ho0CEO0jWNGTNmwNPTk47gkTbLy8sLXbt2hb29PddR3kteXh5mz55d7x1gGWMQCASYPHkyysvLpZyOEAJQUU8I5/z8/JCWllbvjZqA10fB5s6di9zcXCkmazru7u4t+gglIR+qd+/eLfrE0fnz56O4uPiNFsHaBAIB7t69i6VLl0oxGSGkBvXUE8KhwMBATJ8+HTwer86j9LUpKirC0dERoaGhUkr3Wn5+Pvh8Pp4+fYqCggLk5+fX+d+ioiLxtw01d80VCAR49eqVxPpUVVXRrl07AICmpibk5OQgJycHTU1NdOjQATo6OtDR0YG2trbEfzt37gx9ff02cRdOIjtEIhGePHmCrKwsFBQUvPVRXFwMoVAIACgqKoJIJJIYDzXk5eXFl7RUUlKCmpoaAEBZWRnt27eHtrZ2vQ9dXV10794dHTt2lNrv4Pjx4/j000/fOg+Px4OCggIEAgFMTEwQFhaGjz/+WEoJCSEAgqmoJ4RDL168wOnTp3H8+HFcuHABAoEAioqKb9yspgaPx8O+ffvg4+PTZBkEAgHS09Nx9+5d8Pl8ZGVlgc/nIzMzE3w+X6IoV1JSeqPorvn/Dh06gMfjiQt04PUHEXV1dYntlZaWil9fcXExqqurAQAvX74Uf0io/SgoKEBFRYV4eRUVFfTo0QP6+vowMDCAvr4+9PX10bdvXxgbG4s/MBDSUE+fPkVqaioyMzORnZ0NPp8PPp+P7Oxs5ObmSnyLpqKiIt7n//3Q0tISt6doaWmJz5Hp0KGDxPZqLlkLSH7wraqqEo+D2o+acVA7h6qqKgwMDNC9e3eJR58+fWBsbNxk18HPy8uDkZERCgsL6zyRX05ODtXV1TA0NIS7uzvc3NxgZGTUJNsmhDQKFfWEyIqysjJcuHABgYGBCA4ORmlpKRQVFSXeyHk8HlRVVZGenv5eR8Gys7ORkpKCO3fuIDk5GcnJycjIyIBAIICcnBz09PRgYGAgftQUzPr6+tDT03ujQJeW0tJSPH36VFxsZWVliR98Ph+PHj2CUCiEgoIC+vTpA1NTUwwYMACmpqYwNTWFgYHBGychk7anoKAAKSkpSEtLQ3JyMlJTU5GSkoL8/HwAgLq6unh/r10o10zr2LEjp5dkLSkpwdOnT8UfPLKzs5GVlYXs7GxkZ2cjJydH/IFZX18fxsbGMDU1hYmJCUxMTGBsbNzo/FOnTsWpU6fEf4fk5eXF3ypaWlrC3d0dU6ZMQbdu3Zr2xRJCGouKekJkUVVVFaKionDy5EkcP34ceXl5UFJSQlVVFXimyzjkAAAgAElEQVQ8HhwcHBAREfHWdVRWViIhIQExMTGIiYlBbGys+A613bt3Fxe8pqam6N+/P/r16wdFRUVpvLwmJxQKce/ePfEHlpSUFCQnJyMzMxOMMWhqasLGxga2traws7ODpaUlVFVVuY5NmpFQKERSUhLi4uIQFxeH2NhY8Pl8AK+PopuYmKB///7igtfU1BSdOnXiOPWHYYwhKytL/GElNTUVqampSE9PR0VFBeTl5WFiYoKhQ4fCxsYG1tbWMDQ0rHd9NW03NR+IFRQU4OjoiKlTp2LChAnQ0dGR1ksjhLwbFfWEyDqRSIRr167h5MmTOHr0KLKzswEAu3fvlrjUZXl5OS5evIhLly4hJiYGCQkJqKysRNeuXWFrawtbW1sMHjwY/fv3h5aWFlcvR6pKSkqQmpqKhIQExMbG4urVq8jJyYGioiIsLCxgY2ODESNGYPTo0Zx9C0GaRmlpKaKjo3HlyhXExcUhISEBZWVl0NbWhrW1NaytrWFlZQUTE5M2d1S5uroaDx48QHJyMq5du4a4uDjcvHkTFRUV6NixI4YOHYqhQ4di5MiRsLKygry8PPLy8mBiYoJXr15hwoQJmDJlCpydnWmcECK7qKgnpKVJTk7GyZMnERUVhe+//x5JSUkIDQ1FVFQUKioqYGxsLC7ibW1t0atXL64jy5ScnBxcuXJFXOQnJydDUVERw4cPh4uLC1xcXNC7d2+uY5IGSEtLQ1hYGMLDw3HlyhVUVVXB2NhY4ki0kZERtV7VoaqqCrdu3RIX+bGxscjNzYW2tjYcHR3RtWtXDBo0CFOnTqXzVAhpGaioJ6SlSUhIwLFjxxAaGoqUlBRoaGjA0dER48aNw7hx49C1a1euI7YoL168QHh4OEJDQxEREYHCwkIYGhrCxcUFrq6usLW1paJQRlRVVSEyMhKnT59GeHg4srOzoaOjgzFjxsDJyQljx45tsXdelgUZGRniD0mXL19GZWUlzMzM4OTkhMmTJ8PKyorriISQ+lFRT0hLkJWVhQMHDuDgwYPIyMhA7969MX78eLi4uGD48OFQUlLiOmKrIBQKERMTg7NnzyIkJARpaWno0aMHvLy84Onpib59+3Idsc0RiUS4fPkyDh8+jGPHjqGwsBCWlpZwdnaGk5MTLC0tW+y132VZWVkZoqOjERYWhrCwMDx48AC9e/cWX+HG2NiY64iEEElU1BMiq16+fInAwEAcOHAAV69eRceOHeHm5gYvLy86YiYld+7cwf79+3H48GE8evQIlpaW8PLygru7e4s/qVLW3bx5EwcPHkRgYCAePXoEc3NzcUHZvXt3ruO1OQkJCTh8+DACAwORm5sLMzMzeHh4wN3dna5HT4hsoKKeEFnz4MED7Nq1Czt27EBFRQUcHBzg4+ODSZMmtdir07R0IpEIsbGx2L9/P44cOYLKykpMmzYNy5Ytw4ABA7iO12pUVVXh1KlT2Lp1K2JiYqCvrw83NzfMmDED/fr14zoewf+PhaCgIBw5cgR5eXkYNWoUFi9ejPHjx1OrGiHcoaKeEFkRFRWFX3/9FaGhodDX18eiRYswa9Ys8Y2ciGwoLS3FgQMH8OuvvyIjIwMODg748ssv4ezsLL7xEGmc3NxcbNu2Dbt370ZhYSGmTJmChQsXwtbWluto5C0EAgGCg4Pxxx9/4MqVKzA2NsbChQvh7e1NV8khRPqC6R2IEA4xxnD8+HGYm5tj9OjRePnyJYKCgnD//n189dVXVNDLIDU1NcydO1d85RU5OTlMmDAB/fr1w99//y2+Qy55t5SUFEyfPh09evTAX3/9hS+++AJ8Ph+HDx+mgr4FUFRUxLRp03D58mUkJiZi6NChWLp0Kbp164bly5fj+fPnXEckpE2hop4Qjpw/fx5DhgzBtGnTYGRkhISEBFy+fBmurq504l8LwOPx4OTkhHPnziElJQV2dnb47LPPYGZmhlOnTnEdT6ZlZGTA3d0dZmZmuHv3Lv7++2/w+XysX7+ert7UQpmbm2P37t3Izc3FmjVrsH//fvTq1Qtr1qxBQUEB1/EIaROoqCdEym7cuAFHR0c4OjpCU1MTN27cwJEjRzBo0CCuo5H3ZGxsjD179iAlJQUWFhZwdXXFkCFDEBUVxXU0mZKVlYW5c+fC1NQUt2/fxt69e3Hz5k14eHjQFZxaCW1tbaxYsQIPHz7Exo0bsXfvXujr62PVqlV4+fIl1/EIadWoqCdESvLz8+Hj44MhQ4agvLwcly9fRmRkJCwsLLiORppI3759ERAQgPj4eGhpaWH06NGYPHkyHj9+zHU0Tr169QpLly5Fnz59EB0djX379iElJQU+Pj70rVQrpaqqCj8/P9y7dw+rVq3Czp070atXL+zevRt0Kh8hzYNOlCVECo4cOQI/Pz8oKirijz/+wKRJk7iORKTg/PnzmDdvHvLy8rBlyxZ89tlnbe7qIKdPn8aiRYtQUlKCH374AbNnz4aCggLXsYiUvXz5Et999x1+//13WFtbY/v27TAxMeE6FiGtCZ0oS0hzevLkCaZMmQIPDw+MHTsWd+7coYK+DXFwcMCdO3fg5+eHBQsWYPjw4cjIyOA6llQ8fvwYPj4+mDhxIoYMGYKMjAzMnTuXCvo2SktLCz///DMSEhIgFAoxcOBA+Pn5obS0lOtohLQaVNQT0kxOnz6Nfv36ITk5GRcvXkRAQAC0tbW5jkWkTEVFBf7+/oiLi0NJSQksLCwQEBDAdaxmFRgYCCMjI8TFxSEyMhKBgYHo3Lkz17GIDDAzM0NMTAx+/vln/P333xg0aBCSk5O5jkVIq0BFPSFNTCQSYe3atZg0aRKmTZuG27dvY8SIEVzHIhwbNGgQbty4gUWLFsHX1xeLFi2CQCDgOlaTqqqqgp+fH6ZPn44ZM2YgOTkZDg4OXMciMkZOTg4LFy5EamoqunTpAmtra/z9999cxyKkxaOeekKaUHFxMWbMmIGwsDD89ttvmDNnDteRiAw6ffo0fHx80L9/fwQFBbWKyzjm5uZi+vTpuHPnDnbt2gU3NzeuI5EWoLq6Ghs2bMCGDRvg6emJ7du3Q1VVletYhLREdEdZQpoKn8+Ho6MjysrKcOzYMVhbW3MdiciwlJQUuLq6oqysDBERETA2NuY60nu7evUqJk+eDF1dXRw7dgxGRkZcRyItzKlTp+Dr64uePXsiJCSkVXzQJUTK6ERZQpoCn8+Hvb091NTUkJCQQAU9eaf+/fsjPj4ePXv2xKhRo5CWlsZ1pPdy+vRpjBkzBsOGDcP169epoCfvZeLEiUhISEBpaSlsbW1x//59riMR0uLQkXpCPlBOTg7s7e2hrq6O8+fPo2PHjlLPwOfzsXPnThw8eBBZWVlS336NiIgICAQCuLi4NGj+0tJSnDlzBjdu3MDgwYPh5uYmccnHwsJChIaG1rnsgAEDMGDAAACvX//Bgwfx/PlzmJubw9PTE4qKivVuNzs7G+vXr8eOHTs4vxpLWVkZxo8fj9TUVFy4cAH9+/fnNE9jHD9+HG5ubpg1axb++9//cnLNeVnZ9+uSmJiI48ePo3v37vDw8IC6uvo7l3nXmPi3J0+e4MKFC8jJycG0adPQq1cvAI0fE/WtR9pevHgBFxcX5OTkIDo6Gn379uUkByEtUDAYIeS9ZWdns549ezIzMzOWl5fHWY6oqChmY2PD5OXlG7VcRUVFk2w/MjKSjRkzhgFg/v7+DVrmyZMnzNDQkI0bN45pamoyAGzRokUS8/zwww8MQJ2PoKAgxhhjqampTE1NjXXr1o0pKioyAMzCwoKVlJTUud3q6mo2cuRIBqDJXv+HKikpYcOGDWO6urosLS2N6zgNcubMGaakpMQWLlzIRCIRZzm43vfr89dffzFnZ2eWlZXF/v77bzZo0CD24sWLty7TkDFR244dO5iNjQ27du2axL9BY8dEfevhSnFxMbO2tmYfffQRe/DgAddxCGkpTlBRT8h7evXqFTMzM2OmpqbvfLOWhuXLlze6sFm6dCmrrq7+4G2Xl5ezzMzMRhX169atY8XFxYwxxsrKytiAAQOYqqoqKyoqYowxJhKJmLW1NQsMDGRpaWksMzOTZWZmsvj4eKaurs5KS0sZY4wtWbKExcXFMcYYy83NZdOnT2cA2KpVq+rc7k8//cRMTExkqqhn7HVhb2try3r06CET+9Pb3Lhxg6mqqrKZM2fKRBHI5b5fl9TUVKahocEeP34snjZmzBg2b968ty73rjFRQyQSsYkTJ7JRo0ax8vLyN9bT0DHxrvVwqbCwkA0cOJAZGRmxgoICruMQ0hJQUU/I+5oyZQrr1KkTy8rK4joKY4yxNWvWNKqwuXPnDlNTU2uywqaqqqpRRf2/C+r/+Z//YWpqauLiIjMzkyUlJb2x3I4dO9j06dMZY6/f+E+cOCHxfFZWFuPxeMze3v6NZW/fvs3c3d3Zpk2bZK6oZ4yx58+fMwMDA2Zvb8+EQiHXcer06NEj1rVrVzZmzBgmEAi4jsMY437f/zdnZ2dmYWEhMe3HH39kSkpKLDs7u97l3jUmamzZsoXp6uqyJ0+evLGOxoyJt61HFjx69Ih169aNOTg4yOx4IESGnKBb+xHyHnbt2oWTJ0/iwoUL0NfX5ySDQCBAcHAwEhMTMXLkSIhEojfmuX//Ps6ePYuXL1/CysoKzs7OAICYmBh4eHigtLQUR44cgaKiIqZOnfrWZd6lsf3U7dq1k/j5xYsX+PLLL6GsrAwAMDAwqHO5oKAgzJs3D8Dru1ROnjxZ4nl9fX2YmJigT58+EtMrKyuxfPlyHDp0CDt37mxUVmnp1KkTgoODYW1tjc2bN2PNmjVcR5IgEong4+MDDQ0NBAYGcnY+gqzt+/9269Yt2NvbS0wzMDBAVVUVIiMjMWvWrDqXe9eYqFn3119/jU2bNqFLly5vrKOhY+Jd65EFenp6OH36NGxsbPD999/j22+/5ToSITKNrn5DSCNlZWVhyZIlWL58OWc3lSoqKoKzszPS09OxfPlyPHv2DD///LPEPIsXL8bs2bPh5eUFGxsbuLi4YPPmzQAAxhiGDRsGANDU1ISmpuY7l3mXmpP53nZSX30SEhJw7949bNiw4a3z5eXlISEh4a3FlkgkQmZmJsaOHSsxfc2aNVi2bBl0dHQanU+azM3NsWnTJvj7++POnTtcx5Hwyy+/4MqVKzh8+LB4n5E2Wdz3a8vLy8OzZ8/e2M9qPqRmZmY2aD31jYlffvkFjDH06NEDvr6+GDlyJJYuXYqioqJ611XXmHif9XBh4MCB2LJlC7777jvEx8dzHYcQ2cbtNwWEtDyTJ09mRkZGrLKykrMM8+fPZ5MmTZKYNn78eIkWBE1NTbZx40bxz8bGxsza2lr88/r16xkAiZ7ody3zNiKRiAFg69evb/DrKCkpYfPmzWMqKioMAPvyyy/f+nvduXMnc3Nze+s6g4OD2ZAhQyRe1/nz59mSJUvEP3///fcy2X5To7q6mllbW7Nhw4bJRM86Y4zx+XympqbGvvvuO05zyOK+X1tUVBQDwNauXSsx/cGDBwwAmzFjxluXf9eYMDQ0ZHp6euzo0aOspKSEnT59mqmoqDAzM7N626HqGhPvsx6uiEQiNmrUKGZhYUFtOITUj3rqCWmMS5cuMQDs3LlznGV49uwZU1RUZP/9738lpv+7r/jq1assPz+fMcbY9evXWb9+/ZiZmZn4+boKm3ct8zbvU9TXLHfjxg02dOhQBoDt37+/3nkdHR3f6BeuraqqillZWbGMjAzxtIKCAubs7CxRwMt6Uc/Y65NR5eTk2LFjx7iOwhhjzM3NjRkaGnL6O5PVfb+2CxcuMABsw4YNEtNTUlIYALZy5cp3rqO+MVFYWMh4PB7z8vKSmH/p0qUMAAsICHhjXXWNifdZD9fS09OZkpIS27lzJ9dRCJFVJ6j9hpBG2LRpE+zt7TFmzBjOMty+fRsCgeCNPth/t73Y2tri0qVL8Pb2xr1792BgYAD2jttSvM8yH4rH42Hw4MEICwuDjo4OQkJC6pwvPz//na03X375JdatWydxbevVq1eDx+Nh9erVWLJkCZYsWSK+9v2KFSuwd+/epn1BTWTw4MFwdXXFxo0bm/3f4F3S09MRGBiIjRs3vtH3LU2ytO/Hx8fDwMBA4rFt2zZ069YNwOt7LNRWWloKAA26D0F9Y6KwsBCMsTfuhWFnZwcASEpKemNddY2J91kP14yMjDB79mxs3LgRVVVVXMchRCbRibKENFBKSgoiIiJw7tw5TnOUlJQAeH2zmLdZsWIF0tPTERQUBGVlZRw/fvyd636fZZqKpqYmRowYUe8bdnBwMJydnSVOGqxt69atsLS0xLhx4ySm6+jo4J9//pHoT3/69CkAIDk5GVpaWk30Cpre119/jYEDB+LixYsYNWoUZzn+85//oG/fvpgyZQpnGQDZ2vd1dXUxc+ZMiWkDBgyAgYEBtLW138jI5/MBACYmJu/MUuPfY8LAwAAaGhp4/PixxHxDhw4FAKipqUlMr29MNHY9smL16tXYs2cPjh49Cm9vb67jECJzqKgnpIH27dsHAwMDODo6cprDyMgIABAWFob58+dLPFdzFZCbN2/ip59+QlhYmEQRXNeRx+rqaigoKDRqmbrUzPchR5WfPXsmvhLJvx07dkx81Zt/++uvv8Dj8eDr6yuR5+7du9i0adMb8//www9Ys2YNwsLCOD3y/C7m5uawsrLC33//zVlR/+rVKwQGBmLTpk2Qk+P2y11Z2vf19fWxbt26Op/z8PDAyZMnJabduXMHnTp1grGx8TtepaTaY4LH42H48OFITEyUmCcnJwcAMHz4cPG0t40JIyOjBq9Hlnz88ceYMGEC/vrrLyrqCakDtd8Q0kBBQUHw8vJ6r6u7NCVjY2M4OTkhJCQE+/btAwBUVVUhKSkJjDHk5ORASUkJAHDy5EkIhUKcP38et2/fRmFhIe7fv4/MzEx06tQJwOsi6MqVK+KC7W3LvE3N0cSaNoPaoqKi4O7ujoKCAgCAUCjEoUOHkJubK54nOjoaZWVldRbuBQUFSEhIgJOT0xvPbd++Hbt370b79u2xb98+7N27F7///jvGjx+PFy9evOvXKfO8vLwQHBwMgUDAyfbPnDmDyspKeHp6crL92mR13/+3lStXQigU4sqVKwBefzDauXOnRPvS+46J33//HU+fPsXBgwfF00JDQ+Ho6AgHBwcADRsTDVmPLPL19cWlS5fe+JaBEAK6+g0hDXH37l0GgMXExHAdhTHG2NOnT9mwYcMYAGZoaMg++eQT5uXlxdTV1dnChQtZbm4u8/b2ZnJyckxXV5dt376dbdy4kcnJybFly5Yxxhh7+PAh09XVZR06dGC7d+9mjLF3LlOf2NhYNn/+fAaA9e7dm/35558SV9BYtmwZA8CuX7/OGHt9wqO2tjZTVFRkEydOZJMmTWKLFi1iZWVlda5/z549b5zUxxhje/fuZQDqfPTo0aPeK8e0hBNla9y7d48BYFeuXOFk+76+vmz48OGcbLsusrbv1+f69ets9OjRbMuWLczDw4P9+uuvEs9/yJg4c+YM69evH9u8eTPz8/Njnp6e4jssN2ZMvG09sqqsrIypqKiwffv2cR2FEFlzgscYx2dgEdIC7Nu3D/Pnz0dRUREUFRW5jiP24MEDVFdXo0+fPsjKyoKOjg7at28vfv7FixfQ0tISZy4sLESHDh3EzwsEAgiFQqioqDR4mfchFArB5/PRq1cv8TTGGB48eIB27drh448/fuvy9+7dg5qaGj766KMPytFSffzxx1i4cCFWrlwp9W336dMHnp6e8Pf3l/q236al7PuZmZnQ19d/o3XpQ8dEVVUV/vnnH+jr639QD3xTrUea7O3t0atXL+zevZvrKITIkmAq6glpgBUrVuD8+fO4desW11FIG+Tk5IQuXbqIW06kpaKiAurq6jh69CjnJ8kSUmPx4sVISEhAbGws11EIkSXB1FNPSANkZWWhZ8+eXMcgbVSvXr0a3dfdFLKyslBdXY3evXtLfduE1Kd37954+PAh1zEIkTlU1BPSAMXFxeLbyRMibZqamiguLpb6dmu2KcuX/SRtj5aWFoqKiriOQYjMoaKekAaoqqoSX1WDEGlr164dKisrpb7dmm3Svk9kibKyMiorKzm/KRshsoaKekIaQE1Nrc5LNRIiDa9evYKGhobUt6uuri7ePiGyori4GBoaGpxfXpgQWUNFPSEN0LFjRzx//pzrGKSNev78ObS1taW+3Y4dO4q3T4iseP78uXjfJIT8PyrqCWkAQ0ND3L17l+sYpI3KyMgQ301Vmrp16wZ1dXWkp6dLfduE1Cc9PZ2T8UCIrKOinpAGGDBgAPh8fqu4QylpWSorK5GSkgJTU1Opb5vH42HAgAG4ceOG1LdNSH1u3LgBMzMzrmMQInOoqCekAYYPHw4FBQVcvHiR6yhSx+fz8fXXX8PAwKDBy0RERCA0NLRR20lMTMQ333yDnTt31tvDLc15ZEVsbCzKyspgb2/PyfZHjx6NiIgITrYtK2gMyI7c3FzcvXsXo0eP5joKITKHinpCGkBDQwNDhw7FiRMnuI4idQ8fPkR0dDRyc3PfOe/58+cxduxYjB07FgkJCQ3ext69e/H111/j888/h7KyMkaOHIm8vDzO5pElwcHBMDIyQo8ePTjZvouLC7KysnDz5k1Oti8LaAzIjsDAQGhqasLOzo7rKITIHkYIaZBdu3YxZWVlVlhYyHUUqVu+fDmTl5d/53zl5eUsMzOTAWD+/v4NWndqairT0NBgjx8/Fk8bM2YMmzdvHifzyJLKykrWqVMntnHjRk5z9OvXT2Z/R9JCY0A2mJiYsC+++ILrGITIohN0pJ6QBpo2bRqUlJSwfft2rqNInaKiYoPmU1ZWxkcffdSodS9btgx9+vRB165dxdNGjRqFPXv2ICcnR+rzyJIDBw6gqKgIM2bM4DTH3LlzERAQ0KavgkNjgHuhoaFIS0vD3LlzuY5CiEyiop6QBmrfvj3mz5+PX375RSauWV9WVoYdO3Zgw4YNOHbsGAoLC1FdXS2+IcuDBw/w7bfforq6GiEhIdiyZQsEAgEA4P79+9i6dSvWr1+PsLCwN9YtEAgQGBiI1atX49y5cxCJRA3OJS8v36jXcevWLRgaGkpMMzAwQFVVFSIjI6U+j6wQCAT44Ycf4O3tjW7dunGa5fPPP4e6ujq2bNnCaY5/ozHQusdAbSKRCP7+/pgwYQLMzc25jkOITKKinpBGWLJkCaqqqvD9999zmiMvLw8DBgyAiooKVq1ahRs3bkBbWxu9e/fG8OHDERAQADs7O2zcuBEHDhzA2rVrsXLlSty4cQOLFy/G7Nmz4eXlBRsbG7i4uGDz5s3idRcVFcHZ2Rnp6elYvnw5nj17hp9//rnB2WpuCNOQG8Pk5eXh2bNn0NHRkZhec0JiZmamVOeRJX/88Qdyc3OxZs0arqNAVVUV33zzDX7//XdkZGRwHQcAjYHmmkdW7d27F0lJSdiwYQPXUQiRWVTUE9IInTp1gr+/P/7zn/9wWtxs2rQJL168gIeHBxQVFbFo0SIAgIeHB65cuQIfHx/Mnj1bPP+tW7eQkZGBoUOHIiAgAGPHjoWOjg4cHR3Rr18/nDx5UjzvmjVroKGhgXXr1kFbWxs+Pj4YM2ZMs7yO5ORkAHijyOjUqRMAICcnR6rzyIpHjx5h/fr1WLZsGXr27Ml1HADAvHnz0L9/f8ybN69RR62bC42B1j0Ganv69ClWrVqFBQsWYMCAAVzHIURmUVFPSCPVvLF4eXmJv8qXtvv370NOTk58JLBbt27o3bs3rl69Kp5HRUUFAODu7g4A6Nu3L3g8HkJDQzFv3jwAQHx8PBhjKC8vB/D6To27du16o4BprjfSmjaJf/cr1+Tp0qWLVOeRBYwx+Pr6okuXLli9ejXXccTk5eWxe/duxMXFyUQbDo2B1jsGaqsZD5qamnSUnpB3oKKekEZSUFDAgQMHkJGRgZUrV3KSwc7ODi9fvkR8fDyA1zcoevz4MSwsLMTz1PfVv62tLS5dugRvb2/cu3cPBgYG4jf727dvQyAQvPHm3pA2gvdR0yteWFgoMb3mnIX+/ftLdR5Z8MMPP+DSpUvYv38/VFVVuY4jYeDAgfjhhx+wdu1aREVFcZqFxkDrHQO1bdiwAVFRUTh06BA0NDS4jkOITFPgOgAhLZGhoSF27doFT09PDBgwAL6+vlLd/ldffYWbN29ixYoVWLduHU6dOgUbGxt8991371x2xYoVSE9PR1BQEJSVlXH8+HHxcyUlJQCAJ0+eNFv22gwMDKCtrf3G9vh8PgDAxMREqvNwLSQkBN9++y1+/fVXWFpach2nTl9++SXi4+Px6aefIi4uDn379uUkB42B1jkGajt69Cj8/f2xbds2WFlZcR2HEJlHR+oJeU/u7u5YtWoV5s6dW+fVM5oTj8eDnp4efvnlF4hEIixYsACRkZHvPJJ18+ZN/PTTT1iwYAGUlZXF02uOUhoZGQFAna+noX3UNeuq+e/bKCkpiXuga7tz5w46deoEY2Njqc7Dpbi4OLi5uWHmzJni/nBZxOPxsHfvXhgZGWHMmDHIysriLAeNgdY1BmoLCwvDjBkz4OfnR5ewJKShpHlVfEJaG5FIxGbOnMlUVVXZxYsXpbbdDRs2MDMzM3bixAkWFRXFrl27xlJTU5lAIBDP4+/vzwBI3GQmLS2NAWBz585lAoGARUZGsh49erBu3bqxe/fusYcPHzInJycGgO3du5cx9voGSC4uLgwAy87OlthGXcrLyxkAtnz58jeeu3DhAnNzc2P5+fniaTk5OaxLly7s8uXLjDHGSkpKWOfOndmOHTs4mYcLN2/eZFpaWuyTTz555+9XVhQUFDBzc3PWs2dPlpWVJfXt0xhoXTulNp4AACAASURBVGOgtvDwcKasrMx8fX1ZdXU113EIaSlOUFFPyAcSCoVs2rRpTEVFhYWGhkplm2fOnGHKysoMgMSje/fuLCIigh07doz17duXAWBTp05lt2/fFi/r7e3N5OTkmK6uLtu+fTvbuHEjk5OTY8uWLWOMMfb06VM2bNgwBoAZGhqyTz75hHl5eTF1dXW2cOFClpubW2+u2NhYNn/+fAaA9e7dm/35558SBdCyZcsYAHb9+nWJ5a5fv85Gjx7NtmzZwjw8PNivv/76xrqlOY80XblyhWlqarIxY8aw8vJyTrM01vPnz5mZmRn76KOPWHJyslS3TWOg9YyB2g4dOsSUlJSYj48PEwqFXMchpCU5wWOsAd8PEkLeqrq6GnPmzMH+/fvxxx9/YM6cOc26vWPHjkEoFMLR0RH5+fkoLS1FUVERUlJScPz4cVy8ePGty7948QJaWlriq2AUFhaiQ4cOEvM8ePAA1dXV6NOnD7KysqCjo4P27dt/UG6hUAg+n49evXrV+XxmZib09fUhJ1d/Z6A052lugYGBmDlzJsaOHYvDhw+jXbt2nGV5Xy9fvsTEiRNx584d7N+/H+PHj5fKdmkMtI4xUEMkEuH777/HunXr8NVXX+Gnn35qtpOTCWmlgulIPSFNRCQSsbVr1zIej8c+++wzVlFR0SzbuX//PuvcuXOdLQDPnj1j3t7ezbJd0nSEQiFbvnw54/F4bNGiRS2m5aY+5eXlzNfXl/F4PLZ69epmP8JKY6B1ycvLY87OzkxJSYn9+eefXMchpKU6QVe/IaSJ8Hg8rF+/HlZWVvDy8sKtW7dw4sQJ6OvrN+l2cnJy8Pz5c3h7e2PevHno0aMHAODu3bvYvXs3Nm3a1KTbI00rPz8f7u7uuHLlCnbv3o1Zs2ZxHemDKSsrY+/evbC3t8e8efMQExODI0eOoGvXrs2yPRoDrcfNmzcxdepUCAQCREdHY+jQoVxHIqTFovYbQprB3bt3MXnyZBQUFGDXrl2YMGFCk64/IiICISEhOH/+PDIzM9GnTx+MHTsW33777Qe3B5DmEx0djZkzZ4IxhhMnTkhcU721SEpKwqeffoqysjLs2LGjyff9GjQGWjaBQICff/4Za9euxahRo3DgwIE37nRLCGmUYCrqCWkmJSUlWLBgAfbv3w83Nzds3boVnTt3bvLtMMao91TGFRUVYcWKFeIPeHv27EHHjh25jtVsXr58iYULF+LgwYOYPHkyfvvtN/GNj5oDjYGWJS4uDnPnzsX9+/exdu1arFy5Uib6+glp4YJpFBHSTDQ0NBAQEICwsDDxTXp27tzZoGtXNwYVM7ItJCQEpqamOHXqFPbt24dTp0616oIeALS0tHDgwAFER0cjPT0dffv2xebNm1FdXd0s26Mx0DK8fPkSfn5+sLOzg7a2NhITE7F69Woq6AlpIjSSCGlmTk5OSElJEff/jh07FomJiVzHIs0sIyMDrq6u+OSTTzBq1CikpaXBx8eH61hSNWLECCQmJmLJkiVYu3YtLC0tER4eznUsImVVVVXYtm0bjIyMcPToUQQEBCA6Olp8oy9CSNOgop4QKVBXV8dvv/2Gq1evoqioCIMHD4a7uzv++ecfrqORJpabm4vPP/8cpqam+OeffxAREYF9+/ZBW1ub62icUFZWxoYNG5CUlAQ9PT04OzvDzs7unZecJC2fUCjEX3/9hb59++Krr77C9OnTkZ6eDk9PT66jEdIqUVFPiBQNHToU169fx7lz55CWlgZjY2PMnTsXjx8/5joa+UAFBQVYtWoVDA0Nce7cOfz5559ITEyEg4MD19FkQr9+/RASEoJr166hQ4cOGDVqFOzs7BAdHc11NNLERCIRgoKCYGJigi+++ALDhg1DWloatm7d+sa9AAghTYeKekI44ODggMTERBw8eBCRkZHo2bMnfHx8kJyczHU00kgPHz7EqlWr0KtXL+zevRvr1q3DvXv3MGfOHMjLy3MdT+YMGTIEZ86cQUxMDNq1awd7e3sMHjwYAQEBEAgEXMcjH6C4uBg7d+6Eqakp3NzcYGZmhtTUVAQEBKBnz55cxyOk1aOr3xDCsYqKCuzbtw9bt27F3bt3MXr0aPj5+WHcuHF0ApkMi4qKwq+//orQ0FB0794dCxcuxJw5c6ChocF1tBbl4sWL+O2333DmzBno6uriiy++wOeff44uXbpwHY00UHJyMv744w8cPHgQcnJy8Pb2xuLFi9G3b1+uoxHSltAlLQmRFYwxnDt3Dr/++isiIiLQp08fzJs3D+7u7tDV1eU6HsHrFpvAwEBs27YNd+7cwbBhw+Dn54dJkybRUfkPxOfzsX37duzevRvFxcX49NNPMWPGDIwePZp+tzKopKQEJ0+exJ49e3Dp0iUYGRlhwYIF8PHxofsEEMINKuoJkUVpaWn47bffcPjwYZSVlcHR0RFeXl6YNGkSVFVVuY7XplRWViI0NBT79+/H2bNnIS8vj6lTp8LPz69V3jyKaxUVFThy5Ah27NiBa9euQVdXF1OnToW7uzuGDh1Kl6/kUGVlJcLCwnDo0CGEhISguroaLi4umD9/PkaPHk3/NoRwi4p6QmRZeXk5Tp06hQMHDiAiIgLKysqYPHkyPDw8MHLkSLRr147riK2SUCjElStXcOTIEQQFBaGoqAijRo2Cl5cXXF1dqcVGSh48eIDDhw/j8OHDSEtLg76+Ptzc3PDpp5/CwsKC2tOkoKKiAtHR0QgMDERwcDCKi4sxYsQIuLu7Y8qUKW32qk6EyCAq6glpKQoLCxEUFISAgADExsZCRUUFNjY2GD9+PFxdXfHxxx9zHbFFy8vLw8WLF3HmzBmEhISgsLAQxsbGmDp1Knx9fWFgYMB1xDYtNTUVQUFBOHjwIP755x907NgR9vb2cHBwwPjx46Gnp8d1xFbj4cOHOH/+PM6fP4/w8HCUlJSIx8KMGTPQo0cPriMSQt5ERT0hLVF2djbOnj2L0NBQREVFoby8HObm5hg3bhwcHBxgZWVFbTrvUFlZiRs3biAqKgqhoaFISEiAoqIiRowYARcXF7i4uKBXr15cxyR1uHPnDsLDwxEeHo6YmBgIhUIMHjwYTk5OsLe3h6WlJdTU1LiO2WI8f/4ccXFxiIyMRHh4OB48eABNTU04ODjAyckJY8eOpYMGhMg+KuoJaenKy8tx6dIlhISEICwsDA8fPoSioiIsLCxga2uLYcOGwcbGBp07d+Y6KqcKCgoQGxuLq1ev4urVq0hISEBlZSW6deuGcePGiT8QUTHYspSUlODChQsIDw/HuXPnkJWVBQUFBZiZmcHGxgbW1tawtbWFvr4+11FlQnV1NVJTUxEbG4u4uDjExcXh/v37kJOTg7m5OZycnODk5IShQ4dCQUGB67iEkIajop6Q1iYnJwdXr15FTEwMrly5gpSUFIhEIvTt2xeDBg2CqakpTE1N0b9//1Zb6Dx69AgpKSm4c+cOUlJScPPmTaSlpQF4fRMkOzs72Nraws7Ojq6f3crk5uYiNjYWsbGxuHbtGm7dugWBQAA9PT1YWlrCxMQEpqamMDY2hpGREZSUlLiO3GyKi4uRlpaGlJQUpKamIjk5GTdu3EBxcTE0NDRgbW2NoUOHih+amppcRyaEvD8q6glp7YqLixETE4PY2FgkJiYiJSUFfD4fAKCpqYn+/fuLixwDAwPxQ9ZPBi0rK0NmZiaysrLA5/ORnp6O5ORkJCcno6CgAACgp6cHU1NTDBw4EDY2NrCxsYGOjg7HyYk0lZeXIyEhAXFxcbh58yZSU1Nx7949CAQCKCgooE+fPjAxMYGJiQl69eoFfX19dO/eHR999BEUFRW5jv9O5eXl4PP5yM7OBp/Px/3795GSkoK0tDTxOFdX/1/27jyupvz/A/irVUqWQhhT0UKLXUMLIzsVZixTyTaNGdswY2xjFltjZBkyzFhm7AaRtRDZhqSsbUjSgmgvpdS9dX5/+HW/miyhe8+tXs/Ho0fc+znnvO59fC7v87mf8zl1YGFhgTZt2qBz586wt7eHlZUVlwolql5Y1BPVRDk5OYiMjJSNZkdGRiImJgZpaWmyNnp6ejA2NoaRkRGMjY3RtGlT6OvrQ19fH3p6emX+XFnFT3FxMTIyMpCRkYHMzMwyvx89eoTExERZEf/frObm5mjbtq3sBGXixIlo164d9uzZw6X2qAyJRIKYmBhER0fLCuDSk93CwkIAgJqaGpo1awYjIyNZod+oUSPo6emV+Sn9DFTmVJWCggJkZma+9Kf0c5CUlISkpCSkpqbKttPV1YWpqansJMXa2hpWVlYwNjbmZ4Co+mNRT0T/8/TpUyQkJMgK59LfiYmJePz4MTIyMpCXl1duu7p166JOnTrQ0tKS/V1NTQ0qKiqoX79+mbZPnjxBcXExSkpKkJOTAwAoKipCXl4esrOzy+1bR0cHenp6MDAwkBVYL36j8KpvFS5cuIBevXphwYIFmDNnTmW8PVTNCYKAx48fIzExEdevX8fOnTthbW2N5ORkJCUlIT09HZmZmSgoKCi3bd26daGjo4PatWsDeN5vS6f2lH4eShUWFiI/Px/A82+cSk8kcnNz8fTpU9lz/91/6efA0NBQ9mNsbAxDQ0MYGRmhQYMGlf6eEFGVwaKeiN5OUVFRmRH00j/n5+fLipHc3FxIpdIyhXspXV1dqKurQ1VVVTaHV0tLS1a8v/hNgJ6enuxE4V34+Phg+vTpOHz4MJycnN79RVON8/nnn+PMmTOIiYkpN+/+VSPpBQUFePr0KYCyxXpOTg5KSkpk22tqasouyH6x+K9Xrx60tbXRoEGDct8IVIWpQEQkKhb1RFS9eXp64sCBAwgLC4OpqanYcagKiImJgbW1NbZu3Qp3d3ex4xARVQSLeiKq3p49e4bu3bsjNzcXoaGhqFu3rtiRSMkNGTIE8fHxuH79Ou9aS0RVxQH+a0VE1ZqWlhb8/PyQmZmJMWPGgOMY9DphYWE4fPgwvL29WdATUZXCkXoiqhGCg4PRs2dP/Pzzz/jhhx/EjkNKqmfPniguLsa5c+fEjkJE9DYO8HZxRFQj2NvbY/ny5fjmm2/Qrl07ODs7ix2JlExAQADOnDmDixcvih2FiOitcaSeiGqUL774Ar6+vggNDYWFhYXYcUhJlJSUoFOnTmjZsiX8/PzEjkNE9LZ4oSwR1SzPnj3Dxx9/jJycHISGhsqW1aSabceOHRg7diwiIiJgaWkpdhwiorfFop6Iap5Hjx6hc+fOsLGxwf79+3lBZA1XVFQES0tLODo6YuPGjWLHISJ6F1z9hohqnqZNm2Lv3r04duwYfvnlF7HjkMjWrVuHhw8f4ueffxY7ChHRO2NRT0Q1kp2dHVauXIl58+ZxDnUNlpeXh8WLF+Prr7/Ghx9+KHYcIqJ3xtVviKjGmjRpEq5fv45x48bBwsKCc6lroOXLl6OwsBCzZ88WOwoR0XvhnHoiqtEkEgl69uyJtLQ0Xjhbw6SlpcHU1BTff/895syZI3YcIqL3wTn1RFSzaWhowNfXF3l5eRg9ejRKSkrEjkQKsmjRIujo6GDq1KliRyEiem8s6omoxiu9cDYwMBALFy4UOw4pQEJCAjZs2ID58+dDW1tb7DhERO+N02+IiP7funXrMGnSJPj6+mLYsGFixyE58vDwQFhYGKKjo6GhoSF2HCKi93WAF8oSEf2/CRMm4Pr16/j8889hYWEBKysrsSORHERGRmLXrl3YvXs3C3oiqjY4Uk9E9AKJRIJevXohJSUFoaGhqF+/vtiRqJI5OTkhNTUVYWFhUFFRETsOEVFl4IWyREQvKr1w9unTp3B1dUVxcbHYkagSnT9/HkePHsWvv/7Kgp6IqhWO1BMRvcSlS5fQo0cPzJo1ixfPViP29vbQ0dHBiRMnxI5CRFSZOKeeiOhlunbtivXr12PcuHFo06YNhg8fLnYkek8HDx5ESEgILl++LHYUIqJKx5F6IqLXmDBhAnbu3ImQkBBYW1uLHYfeUXFxMdq1awdra2vs3r1b7DhERJXtAIt6IqLXkEgk6N27Nx49eoSwsDBeOFtFbdq0CV999RUiIyPRunVrseMQEVU2FvVERG+SkpKCzp07w9LSEkePHoWamprYkegtPHv2DK1atYKTkxP++OMPseMQEckDV78hInoTAwMD7Nu3D+fOncO8efPEjkNvac2aNUhLS8PcuXPFjkJEJDcs6omIKqBLly7YsGEDFi9eDF9fX7HjUAXl5ORgyZIl+Pbbb9G8eXOx4xARyQ1XvyEiqqDRo0cjNDQUnp6esLS05IWzVcDSpUtRUlKCGTNmiB2FiEiuOKeeiOgtSCQS9OnTB4mJibh8+TIaNmwodiR6hUePHsHMzAwLFizAd999J3YcIiJ54px6IqK3oaGhgT179kAqlcLd3Z13nFViCxcuRP369TFp0iSxoxARyR2LeiKit2RgYIDDhw/jwoUL+PHHH995P8XFxcjKyqrEZFQqNjYWf//9NxYtWoTatWuXe57vPRFVNyzqiYjeQYcOHbB+/Xp4e3tjz54977SPBw8eYPbs2ZWcjADgxx9/RMuWLTFq1KiXPs/3noiqG14oS0T0jkaNGoWwsDCMGzcOZmZm6Nixo9iRCEB4eDj27dsHPz8/qKvzvzkiqhk4Uk9E9B5WrlyJLl26YOjQoUhPTxc7DgGYMWMGOnfujMGDB4sdhYhIYVjUExG9B3V1dezbtw8qKipwc3PjhbMiO3v2LIKCgrBkyRKoqKiIHYeISGG4pCURUSW4ceMG7O3tMWXKFHh7e7+0zaZNm3Dt2jXZ33Nzc3HlyhU4OjqWaffjjz+iSZMmcs1bHQmCAFtbW+jr6yMgIKDMc3zviaiaO8DJhkRElaB9+/ZYv349Ro8ejQ4dOsDV1bVcm759+6Jr166yvycnJyM/P7/ckot6enpyz1sd7d27F5cvX8aVK1fKPcf3noiqOxb1RESVxMPDA1euXMHnn38OMzMzdOrUqczzzZs3L/N3HR0dNGjQAJaWloqMWS0VFxdj3rx5cHd3R4cOHco9z/eeiKo7FvVERJVo+fLliIiIwNChQ3H58mU0atRI7Eg1wl9//YV79+7B399f7ChERKLghbJERJVIXV0de/fuhaqqKtzc3CCVSsWOVO0VFBTAy8sLEyZMgImJidhxiIhEwaKeiKiS6evrY//+/QgJCcGcOXNe2a527dqwtrZWYLLqadWqVcjOzsbcuXMrvA3feyKqbrj6DRGRnPzzzz8YOXIkNm/ejLFjx4odp1rKysqCqakpvv76a8yfP1/sOEREYuHqN0RE8uLu7o4rV65g4sSJsLa2RufOncWOVO0sXrwYqqqqmD59uthRiIhExZF6IiI5Ki4uhrOzM27evIkrV67wwtlK9PDhQ5ibm+PXX3/F1KlTxY5DRCSmAyzqiYjkLDMzEzY2NjA2NkZgYCDU1fklaWXw9PTE6dOncfv2bdSqVUvsOEREYjrAC2WJiORMT08P+/fvR2hoKGbNmiV2nGohJiYG27Ztw6JFi1jQExGB02+IiBTGz88Pw4cPx99//41x48aJHadK++STTxAXF4cbN25AVZXjU0RU43GknohIUYYOHYrvvvsOkyZNwuXLl8WOU2WFhYXh0KFD+PXXX1nQExH9P47UExEpUElJCZydnREdHY3Lly+jcePGYkeqcnr16oWioiKcP39e7ChERMqCI/VERIqkqqqKHTt2QENDA59++imKiorEjlSlHDt2DKdPn8aSJUvEjkJEpFQ4Uk9EJIKIiAjY2dnB09MTPj4+YsepEkpKStC5c2cYGhri4MGDYschIlImvPkUEZEY2rZti23btmHYsGFo27YtPD09xY6k9Hbt2oWIiAhs375d7ChEREqHI/VERCKaPXs2Vq9ejXPnzuGjjz4SO47SkkgksLCwQPfu3bFp0yax4xARKRvefIqISEwlJSVwcXHB9evXceXKFTRr1kzsSErp999/x6xZsxATEwNDQ0Ox4xARKRsW9UREYsvKysJHH32Exo0b48yZM9DU1BQ7klLJy8uDqakpPDw8sHz5crHjEBEpI65+Q0QktgYNGuDw4cOIiorCd999J3Yc0RQXF2PGjBlIS0sr8/iKFSuQn5/Pu/ESEb0Gi3oiIiVgYWGBLVu2YO3atfjrr7/EjiOKhIQErFixAkZGRli4cCHy8vKQnp6O3377DbNnz+aa/kREr8HpN0RESmTu3Ln47bff8O+//5a7cDYmJgZ3796Fk5OTSOnk6+jRo7LXpq6uDl1dXbRr1w7R0dGIi4uDrq6uyAmJiJQWp98QESkTLy8v9O7dG0OGDEFycrLscX9/f3Tq1AmLFy8WMZ183bp1S3Y9gVQqRVZWFs6dO4eioiLs2rULxcXFIickIlJeLOqJiJSIqqoqtm/fDh0dHQwbNgyFhYVYtGgRBg0ahPz8fISEhOD+/ftix5SLmJgY/PfLY0EQ8OTJE0yYMAEWFhbYu3evSOmIiJQbi3oiIiXToEEDHDlyBFFRUbCwsMD8+fMhCAIEQYC6ujp27doldkS5iIqKgkQiKfd46WuPi4vDiBEjMGnSJBHSEREpNxb1RERKqHROeUJCAkpKSmSPSyQSbN26VcRk8nP79u3XPq+qqopOnTrBy8tLQYmIiKoOFvVERErm2LFj6NixI1JTU8tNRwGAmzdvIioqSoRk8pOZmYmsrKxXPq+urg47OzucOXMGenp6CkxGRFQ1sKgnIlISgiDgl19+gZOTE54+fQqpVPrSdhoaGtVuCs7rRunV1NQwcOBAnDhxgivgEBG9Aot6IiIlkZCQgH/++QcAyky5+a/SKTjVaUXi27dvQ01NrdzjqqqqGD9+PA4cOIBatWqJkIyIqGpgUU9EpCRatGiB8PBwrFy5ElpaWtDQ0Hhl24cPH+LSpUsKTCdfMTExUFdXL/f4zJkz8eeff0JVlf9dERG9Dv+VJCJSIurq6pg2bRpu3ryJHj16AABUVFTKtdPQ0JCN6lcHN2/eRFFRkezvKioq+O2337BkyRIRUxERVR28oywRkRI7cuQIxo8fj8zMzHLLPdavXx9paWkvHeGualq0aIGEhASoqqrK1up3dXUVOxYRUVXBO8oSESkzFxcXxMTEYMKECVBVVS1TwGdnZyMoKEjEdJVDIpHg/v37UFFRgaamJvz9/VnQExG9JRb1RERKrl69eli9ejXCwsJgaWkpu6BUXV0dO3fuFDnd+4uLi0NxcTF0dXVx5swZ9OvXT+xIRERVDqffEP1HdnY2MjIykJmZWe7n6dOnsjaCIKCkpAQ5OTkAAKlUitzcXDRo0ADA81U76tWrB+D5/Oc6deoAeF6g6enpQV9fH3p6emV+StsQvYpEIsGKFSswf/58FBYWonbt2khPT4e2tvZb7ys3NxeZmZlIT09HRkaGrN9nZGQgPz8fgiAgOztbdty8vDwAkD2no6MDANDW1patTFO3bl2oqamhdu3aZfq5vr4+GjZsCH19fdStW7dMjoMHD2LKlCkIDAyElZXV+7w9REQ11QEW9VSjpKamIikpSfaTkJAg+/ODBw+QlpZWbilBdXV1WdGto6MDFRUV1K9fH0DZwl1NTQ26urqyIujFgr+4uBhPnjwBAOTk5MhOEv5LU1MTjRs3hpGREYyMjGBoaCj7MTY2hqGhIdfpJgDAvXv3MGHCBJw8eRK7du0qN12lsLAQiYmJSExMREJCQpk/JyQkIDU1tcyFqcD/+rq+vj60tbWhpqYmK8BfPDHV0tKCqqoq8vPzATwv8gsLCwE8P1GQSqUoKCiQnSD891oAdXV1NG7cGMbGxjAyMkJhYSE6d+6MDh06wMjICMbGxqhdu7Zc3jciomqKRT1VT8nJyYiOjkZkZCRu3rwp+1060qiiooImTZqUK5wbNWokK2pKRxj/O6pYWQRBkBU9L34bkJKSgqSkJMTHx8tOOF6802ajRo3Qpk0bWFpawtraGtbW1rCyspKdaFDNcvDgQfj6+mLIkCGIiIhAVFQUIiMjER8fL1vHXldXV1YslxbSTZo0kfXz0lH00hPUyvbkyRNkZGTIvhEo7eelJxilJxulJ8EAYGRkBGtra7Rp0wZt27aFtbU1Wrdu/dplPomIajAW9VT1JSUl4eLFiwgJCcH169cRFRUlK4KbNGkiK3qtrKxgYmICQ0NDfPjhh1XqRja5ubmybxZiY2MRHR2NqKgo3Lx5U/YNQPPmzWFtbQ0bGxt07doVtra2sqlAVH3cvn0bFy9eRHBwMG7cuIHo6GgUFhZCXV0dZmZmsiLYwsJCVsDr6+uLHbtCsrOzkZiYiPj4eNy+fVt2knL79m1IJBJoaGjAwsIC7dq1g729Pezt7WFpack17ImIWNRTVVNYWIhr164hJCRE9vPw4UOoq6ujffv2sLGxkRXx1tbWVaaYeR+JiYmybyOioqIQGhqKO3fuQEVFBa1bt4atrS3s7Oxga2uL1q1bswCqQgoLC3H16lUEBwcjODgYFy9eRFpaGrS1tfHRRx/J+nvpNzdV6UT1bUgkEty6dUv2LcTVq1dx6dIl5Obmon79+rC3t4ednR0cHBxgY2PDqTtEVBOxqCfld+/ePQQFBSEoKAiBgYF48uQJ6tWrBxsbG9jb28PBwQF2dnbvdKFgdfXkyROEhYXhwoULuHr1Ki5cuIDs7Gw0bNgQjo6O6N27N1xcXNC0aVOxo9J/pKam4vjx4/D395f1dwMDA9jY2MDBwQH29vawsbGptgV8RRUXF+P27dsIDg7GhQsXcOHCBcTHx0NLSwsODg7o3bs3Bg8ejNatW4sdlYhIEVjUk/IpKCjAmTNncOzYMRw/fhx3795FvXr10Lt3b/Tv3x89evSAqamp2DGrFKlUivDwcAQFBeH48eMIDg5GcXExOnfujAEDBqB///746KOPOIovgpKSEoSG9buuzwAAIABJREFUhiIgIAABAQEIDw9H7dq10bt3bwwcOBC9evVif6+gxMREnDp1CkePHsXJkyfx5MkTWFpawsnJCQMHDoSDg0O1uFEXEdFLsKgn5VBcXIyQkBBs374du3fvxpMnT9CyZUs4OzvDxcUF3bt3h6amptgxq438/HxcvHgRR44cwaFDh5CYmIgPPvgAQ4cOxfDhw2Fvbw8VFRWxY1ZrN2/ehK+vL7Zt24b4+HgYGxujb9++6N27NwYMGMDlTd9T6b8p/v7+CAoKwtWrV6Gnp4dhw4Zh1KhR7ONEVN2wqCfxlJSU4MKFC9i1axf27t2LzMxM2NnZwdXVFUOHDuXUEAWKioqCr68vdu3ahbt378LMzAxubm5wc3Pj9IVKlJycjF27dmH79u0IDw+HkZERPDw84ObmxvXZ5ezu3bvYtWsXduzYgTt37qB169YYOXIkPDw8YGxsLHY8IqL3xaKeFC81NRUbN27E+vXrcf/+fbRr1w5ubm5wdXWFkZGR2PFqvMuXL2PXrl3w9fXFw4cPYWNjg0mTJsHV1RVaWlpix6tyBEHAqVOnsGrVKhw/fhy6uroYPnw4PDw80K1bN44WiyA0NBQ7d+7E7t27kZ6eDkdHR0ybNg3Ozs6cgkZEVRWLelKcsLAwrFmzBr6+vqhTpw48PT0xZswYWFpaih2NXqKkpAT//vsvNm7ciH379qFu3br44osvMHHiRBgaGoodT+k9e/YMO3fuhI+PDyIjI9GjRw9MnjwZzs7OPDlSEhKJBIGBgVi7di0CAwNhYmKCadOmYezYsZz+RERVDYt6kq/i4mLs2bMHPj4+CAsLQ/v27TFlyhS4u7tz2bkq5PHjx9iwYQPWr1+PlJQUDB48GN988w26desmdjSlk5GRAR8fH6xbtw45OTlwdXXFN998gw4dOogdjV7j9u3b8PHxwbZt26ChoYHx48fj22+/RbNmzcSORkRUESzqST5KSkrg6+uLBQsW4O7du/j0008xZcoUFoFVnEQigZ+fH9asWYPg4GD06dMHCxcuRNeuXcWOJrq8vDysWrUKy5cvh6amJiZMmIBJkyahSZMmYkejt5CZmYkNGzZgzZo1yMrKwtdff43Zs2fzRm5EpOwOcPIgVSpBEHDkyBF07twZI0eORJs2bRAdHY09e/awoK8GNDQ04OrqigsXLuD8+fOQSqWwtbVFnz59cPnyZbHjiUIikWDDhg0wNzeHt7c3JkyYgNjYWCxcuJAFfRWkp6eHOXPm4N69e1i5ciW2bNkCIyMjzJkzB7m5uWLHIyJ6JRb1VGnOnTuHTp06YciQITAzM0NkZCR8fX1hbm4udjSSAwcHB5w+fRrHjh3DkydP0KVLFwwdOhQJCQliR1MYPz8/mJubY9q0aXB3d0d8fDyWLFmCevXqiR2N3pOmpia+/PJL3LlzB99++y3++OMPtGrVClu2bAG/4CYiZcSint5beno6xo0bB0dHRzRp0gTXr1/Hnj17eAFsDdG/f3+Ehobi0KFDuHXrFqysrLB06VJIJBKxo8nNo0eP8Omnn2L48OHo0aMHYmNjsXz5cjRs2FDsaFTJ6tatiwULFiAuLg5Dhw7FF198gX79+iE+Pl7saEREZbCop/eyd+9eWFpaIjAwEFu2bMHRo0fRtm1bsWORCFxcXBAeHo7Fixdj4cKF6NSpE0JCQsSOVen27t2LNm3a4MaNGzhx4gQ2b96M5s2bix2L5KxRo0b4/fffcfnyZWRkZMDKygre3t4oLi4WOxoREQAW9fSOHjx4gJ49e8LNzQ2fffYZbt++jdGjR4sdi0SmoaGBadOm4caNG2jSpAkcHBzw9ddf49mzZ2JHe2+PHj1C79694ebmhrFjxyIqKgq9e/cWOxYpWIcOHRASEoI5c+Zg3rx5sLOzw71798SORUQErn5Db+3kyZMYOXIkGjZsiK1bt8LGxkbsSKSkdu7cicmTJ8PU1BR79+5FixYtxI70TkJCQjBs2DDUqVMHO3bsYJ8nAMDNmzfh4eGBxMRE/PPPP+jXr5/YkYio5uLqN1RxgiDA29sbAwYMgIODA0JCQljc0GuNHDkS4eHhUFVVRfv27eHn5yd2pLe2YcMG9OjRA+3bt0doaCj7PMlYWlri4sWLGDx4MAYMGIA5c+agpKRE7FhEVEOxqKcKyc7OxsCBAzFv3jz4+Phg//79XOGDKsTIyAjnzp3DsGHDMHz4cMydO7dKFD5SqVR2B93vv/8eR44cQf369cWORUpGS0sLmzZtwsqVK7FixQqMGDECBQUFYsciohqI02/ojR4+fIgBAwYgKysL+/fv50glvbNNmzZh0qRJ+PTTT7FlyxZoamqKHemlpFIp3N3dcezYMfzzzz9wcXEROxJVAefOncPQoUPRoUMHHD58mHfNJiJF4h1l6fXi4+Ph6OgIbW1tBAYG4sMPP1R4hsTERGzYsAE7d+5UujXQr1+/Dj8/PxgaGsLd3R116tR54zaJiYnYuXMnUlNT0b59e4wcORIaGhovbXvixAlIJBI4OTm9134AICkpCQsWLMD69euhrq5e8RdZyU6dOoVPPvkE9vb2OHDgALS0tETL8jLFxcUYPXo0Dh48CH9/fzg6Oio8g7L0+df1v1epyGfiTW0KCgqwf/9+XLt2DaampnB3dy/3zeDTp0+xdetW3Lt3D/Xq1cOIESPQqlWrd3uhlSg8PBy9e/eGpaUljh49Ch0dHbEjEVHNcAAC0Svcv39faNGihdC+fXshPT1dtBynT58W7OzsBDU1tbfa7tmzZ3JK9NymTZuEAQMGCAkJCcLWrVuFTp06CWlpaa/dJjo6WtDR0RGaN28uaGhoCACEjh07Crm5uWXanTx5Uujbt68AQJg/f/4776dUcXGx0KNHDwGA3N+Xirh8+bJQv359wcnJSSgsLBQ7joxUKhVGjhwpaGtrC6dPnxYth9h9/k3971Uq8pl4U5v09HShW7duwqpVq4Tk5GRh5syZgrm5uZCQkCBrk5qaKpiYmAjbt28X8vPzhUuXLgkWFhbCgQMH3v/FV4IbN24IDRs2FLp37y7k5eWJHYeIaob9LOrppbKysgRLS0vB0tJSSE1NFTuOMHPmzLcucL777juhuLhYLnmio6MFXV1dITk5WfZY3759hYkTJ752u+nTpwshISGCIAjCgwcPhM8++0wAIMyZM6dMu4KCAiE+Pv6VRVVF91Nq2bJlgpWVldIU9YIgCJcuXRLq1q0ruLu7CyUlJWLHEQRBEMaPHy/o6OgIZ8+eFTuKqH3+Tf3vZSrymahImzFjxgg9evSQ/b24uFho27atMGjQINlj3333ndC/f/8yx1+8eLFgampa8RcpZ9evXxf09fWFIUOGyO3fISKiF+znhbJUjlQqxfDhw5GdnY3AwEA0atRI7EivnVbyMpGRkVi3bp2c0gAzZsyAmZkZmjZtKnusZ8+e+Pvvv3H//v2XbpOdnQ0HBwd07doVAPDBBx/A29sbKioqCA0NLdNWS0sLH3zwwXvvBwAiIiJw7do1uLu7v9NrlZcuXbpg37598PX1hZeXl9hxsHr1avz999/YtWsXPv74Y7HjiNrnX9f/XqUin4k3tcnJycGOHTvKLA2pqqqKcePG4fDhwwgPDwfw/D4Zjx49gvDC7FEdHR2lmsrVvn17HDp0CEePHsX8+fPFjkNENQCLeipn3rx5uHjxIo4cOSLanTIlEgl8fX3x/fffIzAw8KWrpcTGxsLHxwcLFizAsWPHZI8HBwfD2dkZT58+xe7du7F37943bvO2rl27BnNz8zKPGRsbo6ioCCdPnnzpNvXr18cnn3xS5jEjIyNYWVnBzMysXHs1NbX33k9hYSFmzpyJ33//HSoqKm98XYrWp08frF69GvPnz3/l+6YIV69exYwZM+Dl5SXaRbHK1udf1f9epSKfiTe1uXPnDoqLi8tdYGphYQHg+Vx84PmJQHh4OH7++WcAzwcidu7ciW+++eatMsubvb091qxZAy8vLwQFBYkdh4iqORb1VMbZs2exZMkSrFq1Ch07dhQlQ05ODgYMGIBbt25h5syZSElJwW+//VamzdSpU+Hp6QkPDw/Y2dnByckJ3t7eAJ6vp9+tWzcAQL169WQX2L1um7eRnp6OlJQU6Ovrl3nc2NgYwPOLiyuqpKQE8fHxL71pTWkRXpFi/FX7mTt3LmbMmFEuqzKZOHEiPvvsM4wePRppaWkKP35BQQE8PDzQvXt3zJ49W+HHB5Szz79N/6vIZ6IiberWrQsAuHPnTpk2pUV+UlISAGDcuHFwdHSEl5cXxo4di/Hjx+OLL76Ap6dnhV6bIo0fPx7Dhw/H2LFjkZWVJXYcIqrGWNSTTGFhIb788ksMGjQI48ePFy3H3Llzoauri3nz5kFPTw+jR49G3759y7TZtm0b+vXrB319ffTp0wcWFhY4ePAgAMDBwUE2Gjhw4EDZtq/b5m1ERkYCQLnipHSa0qum37zM4cOHYW1tXW7k/W29bD+nTp0C8Hw0XNn9+eef0NDQwMyZMxV+7KVLl+Lhw4fYsmULVFXF+SdR2fv8m1TkM1GRNiYmJjA0NMQ///yD7OxsWZvHjx8DAAwMDAA8n5oUEBAAR0dHbN26FRERERg8eHClv67K8ueff0IqleKnn34SOwoRVWMs6klm2bJlePToEVavXi1ahtTUVGzcuLFcQdO2bdsyfw8ICMDEiRMBAGFhYRAE4Y03fHmXbV6mdB7vf+c8l+6rSZMmFdqPRCLBr7/+iq1bt77X1JiX7ScrKwsrVqzA4sWL33m/ilSvXj2sWrUK27ZtQ3BwsMKOm5SUBG9vb/z000+iTTWrCn3+TSrymahIG3V1dWzcuBFSqRSWlpZYsWIF5s+fjwULFgAArKysZNuFhYWhWbNmmDlzJq5du4YuXbq81Qm1Iunp6eHXX3/FunXrEBUVJXYcIqqmWNQTgOcXX65YsQKzZs0SZS36UuHh4ZBIJOUK4/8Wvfb29jh37hxGjRqFO3fuwNjYuMxFcy/zttuEhYXB2Ni4zM+ff/4pK/7++1X606dPAQDW1tYVeq3ffPMN5s2b995ra79sP99//z1UVFTw/fffY/r06Zg+fToCAgIAALNmzcLmzZvf65jy8Omnn6JHjx748ccfFXbMZcuWwcDAANOmTVPYMf9Lmfr8u6rIZ6Kin5u+ffsiMjISP/30Exo0aIAxY8YgMzMTZmZmsLe3BwBcunQJY8aMwR9//IGlS5dizZo1SEhIwKRJkyr9tVWWMWPGwNraGosWLRI7ChFVU+LdgYaUytq1awE8n4MrptzcXADAo0ePXttu1qxZuHXrFvbu3QstLS34+fm9cd9vu42BgQHGjRtX5rG2bdvC2NgYenp65TImJiYCKDua+Co+Pj6wsbHBwIED39j2Xfajr6+Pu3fvIiIiQvZY6RSGyMhI1K9f/72OKy/z58/Hxx9/jODgYFkBJy/p6en4+++/sWzZMlHvbKtMff5dVeQz8TafG2NjY9k3DJs3b0ZKSgp8fHxkJzpr167FRx99JJuDP3nyZCQlJWHlypVIT09Hw4YN5fI634eqqip++OEHuLm54e7duzA1NRU7EhFVMyzqCSUlJfjrr7/g6elZ7q6Nita6dWsAwLFjx8qNupWuBnL16lUsW7YMx44dK7OE3ctGIIuLi6Gurv5W25QyMjLCvHnzXvqcu7t7ubnJERERaNSoESwtLV/7Gjdt2gQVFRWMHTu2TI6YmBjZ638x26syvm4/v/zyS7n2v/76K+bOnYtjx46hVq1ar80olu7du8PGxgYbNmyQe1H/zz//QF1dvcz7JwZl6vMvelP/e5GmpuYbPxMVafNfOTk58Pb2xh9//IERI0bIHn/ZBbdfffUVli5ditTUVKUs6oHn30Y1bdoUW7ZsUYplXImoeuH0G8K///6LhIQEpVg5wtLSEv3794e/vz+2bNkCACgqKsKNGzcgCALu378vG1U9ePAgpFIpgoKCEB4ejqysLMTGxiI+Pl528d3Vq1dx/vx52QWQr9vmbcyePRtSqRTnz58HAOTl5WHDhg3w8vKSFcynT5+Gm5sbMjMzZdutW7cOf/31F+rWrYstW7Zg8+bN+P333+Hs7Fxu5ZeioiIA/5ue8KK32U9V8/nnn2Pfvn0vfd2VaceOHRg2bBh0dHTkepw3UdY+/7r+97K+XZHPREXalEpLS4OjoyO++OILTJgwocxzX3zxBfz9/ctcH3D9+nW0a9euzImxslFTU8PIkSOxY8cOsaMQUXWkqNtckfKaOXOmYGFhIXYMmcePHwvdunUTAAjm5ubCoEGDBA8PD6FOnTrClClThAcPHgijRo0SVFVVBQMDA2HdunWCl5eXoKqqKsyYMUMQBEG4d++eYGBgIDRo0ED466+/BEEQ3rjN2woNDRV69eolLF26VHB3dxdWrVpV5vkZM2YIAITQ0FBBEARh8+bNAoCX/rRo0aLMXVUvXrwoTJo0SQAgmJqaCmvXrhUkEslb7+dFixcvVqo7yr7K48ePBRUVFSEgIEBux0hPTxdUVVWFgwcPyu0Yb0PZ+vzr+p8glO/bpd70mahIm9DQUMHb21twdnYWtm/f/tJ8UqlU+P7774V27doJa9asEX744QfB1dVVuHfv3pvfbJEFBwcLAITbt2+LHYWIqpf9KoIgh6umqEqxsbGBra2tqKvevExcXByKi4thZmaGhIQE6Ovry+bQAs9H8urXry9bTSMrKwsNGjSQPS+RSCCVSsvcyOZN27yL+Ph4GBkZlVsOUSqVIjExESYmJu+1/5qoXbt26NOnD5YvXy6X/R84cADDhw9Henq6Ul1fUFX6/Jv69qs+E29qIwgCgoODYWxsjA8++OCNq0IVFhbi7t27aNy4sVLc+boipFIp9PX1sXTpUnz11VdixyGi6uMAi/oarqSkBHXq1MEff/wh+txiolLjxo1DcnIyAgMD5bL/RYsWYdu2bYiNjZXL/olex97eHh07dsTvv/8udhQiqj4OcE59DZeUlISCggKlnodKNU/r1q0RExMjt/3Hxsa+91KiRO9K3v2biGomFvU1XOmFblXlq2uqGRo1aoSMjAy57T8zM7Pc6ilEiqKvr19uvX4iovfFor6GK13ZQuwVQIhepKuri6dPn8rlRkkAkJ+fD21tbbnsm+hN6tSpg7y8PLFjEFE1w6K+hitdv/rZs2ciJyH6n/z8fGhpab3xQsl3VatWLRQWFspl30RvUlBQUOZiZiKiysCivoYrXfnjxfWmicSWmZkp11Vp6tWrh+zsbLntn+h1srOzRb/RHxFVPyzqazgjIyOoq6tzFRBSKnfu3IGpqanc9m9iYsI+T6K5c+cOl7olokrHor6G09TUhJmZGcLDw8WOQiQTEREBKysrue3f0tISsbGxnHZGCicIAqKjo2FpaSl2FCKqZljUE7p3747Tp0+LHUNUiYmJ+OGHH2BsbFzhbU6cOIGAgIC3Os7169fx448/YsOGDa+8UE6RbZRRbm4uLl++jI8//lhux+jWrRsKCwsREhIit2MoK/Z1cUVHRyMlJQXdunUTOwoRVTMs6gn9+vXDlStX8PjxY7GjiObevXs4e/YsHjx48Ma2QUFB6Nevn+x9q6jNmzfjhx9+wPjx46GlpYUePXogPT1dtDbK6vjx4ygpKUHv3r3ldgxDQ0OYmZm9daFaHbCvi+vo0aPQ09NDx44dxY5CRNWNQDVeYWGh0LBhQ8Hb21vsKKKaOXOmoKam9sZ2BQUFQnx8vABAmD9/foX2HR0dLejq6grJycmyx/r27StMnDhRlDbKbMCAAcLAgQPlfpyffvpJMDAwECQSidyPpWzY18XTpk0bYcKECWLHIKLqZz9H6gmamppwd3fHn3/+CYlEInYc0WhoaFSonZaWFj744IO32veMGTNgZmaGpk2byh7r2bMn/v77b9y/f1/hbZRVTEwMTpw4AU9PT7kfa8yYMUhLS8OhQ4fkfixlw74ujgsXLiAyMhJjxowROwoRVUMs6gkAMH36dCQnJ2Pbtm1iRykjPz8f69evx6JFi7Bv3z5kZWWhuLhYdlOiuLg4/PTTTyguLoa/vz+WLl0qOzGJjY2Fj48PFixYgGPHjpXbt0Qiga+vL77//nsEBgaipKSkwrnU1NTe6nVcu3YN5ubmZR4zNjZGUVERTp48qfA2ymrRokUwNzfHkCFD5H4sExMTfPLJJ/j111/lfqyKYF+v/n3dy8sL3bp1Q9euXcWOQkTVEIt6AvB8actx48Zh3rx5yM3NFTsOACA9PR1t27ZF7dq1MWfOHFy+fBl6enowNTVF9+7dsW3bNjg4OMDLyws7duzAzz//jNmzZ+Py5cuYOnUqPD094eHhATs7Ozg5OcHb21u275ycHAwYMAC3bt3CzJkzkZKSgt9++63C2UpvilSRmyOlp6cjJSUF+vr6ZR4vvVAxPj5eoW2UVVhYGHbt2oV58+ZBVVUx/zTNnTsX169fx549exRyvFdhX6/+ff3UqVMIDAzEzz//LHYUIqqmWNSTjJeXF549e4Z58+aJHQUA8MsvvyAtLQ3u7u7Q0NDA119/DQBwd3fH+fPnMXr06DLTNK5du4bbt2/D1tYW27ZtQ79+/aCvr48+ffrAwsICBw8elLWdO3cudHV1MW/ePOjp6WH06NHo27evXF5HZGQkAJQrPho1agQAuH//vkLbKCOpVIpJkyahe/fuGDFihMKO27FjR4wZMwYzZ84UddUU9vXq3dclEgmmTZsGFxcXuV4ATkQ1G4t6kmnYsCGWLVsGHx8fpVjiMjY2FqqqqrIRwubNm8PU1BQXLlyQtSm91bqbmxsAoFWrVlBRUUFAQAAmTpwI4PkIsCAIKCgoAACkpqZi48aN5Qqbtm3byuV1lE6f+O885tI8TZo0UWgbZbRo0SLcvHkTf/zxR4VGhCvTkiVLUFBQgOnTpyv0uC9iX6/efX3+/PlISEjAypUrxY5CRNUYi3oqY9y4cRg6dChGjx4t+hKXDg4OyM7ORlhYGACgsLAQycnJZZaCe1UBaG9vj3PnzmHUqFG4c+cOjI2NZUVAeHg4JBJJuf/05VVMNm/eHACQlZVV5vGnT58CAKytrRXaRtmcPn0av/zyC1asWAELCwuFH79x48ZYt24dNm7ciP379yv8+AD7urzaKIOzZ8/C29sbK1as4F1kiUiu1MUOQMpnw4YN6NKlCwYPHoyzZ8/KRggV7dtvv8XVq1cxa9YszJs3D4cOHYKdnR0WLlz4xm1nzZqFW7duYe/evdDS0oKfn5/sudJrBh49eiS37C8yNjaGnp5eueMlJiYCAKysrBTaRpnExsZi+PDhGDZsmGy0WQxDhw7FhAkTMHbsWJibmyu8IGRfr559PTExESNGjMAnn3yCr776Suw4RFTNcaSeyqlfvz78/f0RFxcHV1dX0Za5VFFRQbNmzbBy5UqUlJRg8uTJOHnyJHR1dV+73dWrV7Fs2TJMnjwZWlpassdLRy9bt24NAC9dJaSiq4KU7qv09+uULhl6/vz5Mo9HRESgUaNGsLS0VGgbZZGcnIyBAwfC1NQUmzdvFjsOVq9ejfbt28PFxQUPHz5U6LHZ16tfX8/MzISLiwuaNm2qFP2biKo/FvX0UmZmZjhy5AhOnz6NkSNHQiqVKjzD0qVLce7cOdy/fx8aGhrIycnBzZs3y2QpPeHIyMiQPaatrQ0AOHjwIKRSKYKCghAeHo6srCzExsaidu3a6N+/P/z9/bFlyxYAQFFREW7cuAFBEHD//v03vt6ioiIA//uq/0WnT5+Gm5sbMjMzZY/Nnj0bUqlUVoDk5eVhw4YN8PLyQq1atRTeRmyPHz9Gr169oKGhgSNHjoj2bdCLNDQ0sH//fmhra6Nv374KvSsp+3r16uu5ubkYOHAgcnJycOTIEdSpU0e0LERUgyjyVldU9Zw5c0bQ1tYWBg0aJOTn5yv02EeOHBG0tLQEAGV+DA0NhRMnTgj79u0TWrVqJQAQhg8fLoSHh8u2HTVqlKCqqioYGBgI69atE7y8vARVVVVhxowZgiAIwuPHj4Vu3boJAARzc3Nh0KBBgoeHh1CnTh1hypQpwoMHD16Z6+LFi8KkSZMEAIKpqamwdu3aMnclnTFjhgBACA0NLbNdaGio0KtXL2Hp0qWCu7u7sGrVqnL7VmQbsdy7d08wMzMTzMzMhIcPH4odp5wHDx4ILVq0EKysrMrcqVSe2NerT1/PzMwUunbtKhgYGAgxMTGiZiGiGmW/iiBU4DtVqtEuXrwIFxcXWFhYYP/+/WjcuLFCjrtv3z5IpVL06dMHGRkZePr0KXJychAVFQU/Pz+cOXPmtdunpaWhfv36stUxsrKy0KBBgzJt4uLiUFxcDDMzMyQkJEBfXx9169Z9r9xSqRSJiYmvvCguPj4eRkZGr12LXZFtFOnKlSsYNGgQmjZtiqNHj8LAwEDsSC91//599O3bFxKJBEePHi13g6PKxr5ePfr6gwcP4OTkhKysLJw8eRKtWrUSLQsR1TgHWNRThdy8eRMuLi4oLCzE7t274eDgINfj3b17F/b29nj48CHU1ctez52amooZM2Yo3d1v6fX+/PNPfPvtt3B0dMSePXveu6CUt9TUVAwaNAi3b9/G9u3b4eLiIpfjsK9XD+fOncOIESPQqFEjBAQEwMjISOxIRFSzHFCO4TtSepaWlrh+/Tq6du0KR0dHeHt7V+jCuXd1//59pKamYtSoUfj3339x//593L9/H0FBQZg6darS3CCL3qygoACenp6YPHkyvvnmGwQEBCh9QQ88X+qytFAbPHgw5syZU+GLS98G+3rVt2HDBvTp0wddu3ZFcHAwC3oiEgVH6umtCIKApUuX4scff4SLiws2btxY7o6OleXEiRPw9/dHUFAQ4uPjYWZmhn79+uGnn36qEkUhPb/DqKurK1JTU7EfQ2MSAAAgAElEQVRz50653clU3tavX4+pU6eib9++2Lx5Mxo2bFip+2dfr5pyc3MxceJE7N69G15eXpg9e7bCb55GRPT/OP2G3s25c+cwcuRIFBYWYvny5Rg9erRc/zMTBIH/WVYh+fn5WLRoEVasWAEbGxvs3r0bH374odix3ktISAg+++wzFBYWwsfHB66urnI5Dvt61VB6J99nz55hx44dVfaElYiqDU6/oXfz8ccfIyYmBp6envD09MTHH3+Mmzdvyu14LHKqjjNnzqBDhw74888/sWzZMvz7779VvqAHAFtbW0RFRcHV1RUjR46Ek5MTkpKSKv047OvKLSsrC1999RWcnZ3RtWtXREdHs6AnIqXAop7emY6ODpYsWYKLFy8iNzcXHTt2xM8//yy7iyXVLImJifjss8/Qs2dPtGvXDjdv3sS0adOgpqYmdrRKU7duXfj4+ODMmTO4e/cu2rRpg7Vr14p2gzZSnJKSEmzduhWtWrXCsWPH4O/vD19fXzRq1EjsaEREAFjUUyX46KOPcPnyZSxevBg+Pj5o2bIlli9fjvz8fLGjkQI8fPgQkydPhrm5Oa5evYqAgAD4+vqiWbNmYkeTm+7duyM8PByTJ0/G9OnTYWVlhT179sj14nESj7+/Pzp06ABPT0+MGDEC0dHRcHJyEjsWEVEZLOqpUqirq2P69OmIj4/H5MmTsWjRIhgbG8Pb2xsFBQVixyM5SE9Px5w5c2BmZobDhw9j6dKliI6OxsCBA8WOphBaWlpYvHgxYmNj4ejoiJEjR6Jt27bYu3ev2NGokly6dAmOjo5wcXFB48aNce3aNaxZswa6urpiRyMiKodFPVUqPT09zJ8/H7GxsfDw8MCCBQvQqlUrrFixAllZWWLHo0oQFxeH6dOnw9jYGFu3bsWSJUtw9+5dTJs2DbVq1RI7nsIZGhpi/fr1uHHjBlq0aIERI0agR48e8Pf3l8sSmCR/p0+fhpOTE2xtbaGiooJLly7h5MmTaNu2rdjRiIheiUU9yUXjxo3x22+/4e7du/jkk0+wcOFCNG/eHF9++SUiIiLEjkdvqaSkBMeOHYOTkxPMzc3h5+eHBQsWIC4uDlOnTq2Rxfx/WVtb4/Dhw7hw4QK0tLQwaNAgWFhYYO3atcjLyxM7Hr3Bs2fPsGnTJrRr1w69evVCbm4ujh8/jtOnT6NLly5ixyMieiMuaUkKkZubi23btmHt2rW4desWunfvjilTpmDQoEEsCJVYZmYmtm7dij/++ANxcXHo2bMnJk+ejEGDBlWrC2Dl4ebNm1i9ejW2b98OTU1NfPHFF5g4cSJatmwpdjR6wcOHD7F+/XqsW7cOOTk5+OyzzzBt2jR06tRJ7GhERG+D69ST4l24cAGrV6/GgQMHUKdOHbi4uGD48OEYMGAA1NXVxY5X4xUUFCAoKAjbt2/HoUOHUKtWLbi5uWHKlClo06aN2PGqnJycHGzZsgW//fYbkpKS0KlTJ4waNQru7u5cOUUkBQUF8Pf3x7Zt23D8+HE0aNAAn3/+OaZMmYLmzZuLHY+I6F2wqCfxPHz4EHv27MGuXbtw5coVNGnSBCNGjICbmxu6dOnC9boVqKioCMePH8euXbtw+PBhSCQS9O3bF66urhgyZAjq1KkjdsQqTyqV4vjx49i5cycOHTqEkpISODk5YdSoURgwYAC/sZIzqVSKkydPYseOHTh48CCkUikGDhwIDw8PODs78/0noqqORT0ph8TEROzevRtbtmzB7du3YWBggO7du8PZ2RkuLi5o0KCB2BGrnZSUFAQGBsLf3x8nT57EkydPYGtri+HDh8PV1RUGBgZiR6y2/jtSXKtWLdkqK87OztV6OVBFyszMxKlTpxAUFITDhw/j8ePH/KaEiKorFvWkfK5fv44jR47g+PHjCAsLg4qKCuzs7NC/f3/0798f7du35yj+OygsLMT58+dx/PhxHD9+HNHR0dDW1oajoyP69++PIUOGcOqBCB48eIADBw4gICAA586dQ1FRETp37gwnJycMHDgQHTt2hKoq1zSoqPDwcBw9ehRHjx5FSEgIVFVV0a1bNwwcOBCffvopWrRoIXZEIiJ5YFFPyu3FkbajR4/iwYMH0NXVRdu2beHg4AB7e3s4ODhwJP8lUlJSEBYWhqtXryI4OBjBwcEoKChAy5Yt0bt3bzg7O6NPnz7Q0tISOyr9v4KCAgQHB+PIkSM4ePAgkpKSoKuriy5dusj6ur29PWrXri12VKUglUoRHh6OCxcuIDg4GGfPnkVaWhoaNmwIR0dHODs7Y9CgQahfv77YUYmI5I1FPVUdgiAgIiIC58+fR0hICC5evIiEhASoqanB2toa9vb26Ny5M9q0aQMLCwvo6OiIHVlhMjIyEBkZiaioKISGhuLixYu4d+8e1NTUYGVlBXt7e9ja2uLjjz+GoaGh2HHpDSQSCb766ivs27cPP/74I65du4YLFy7g4cOHqFWrFjp16gQHBwdZfzc1Na32F5mXlJTg3r17iIiIwLVr13D+/HlcvnwZBQUFMDAwgJ2dHbp164bu3bujQ4cO/HaDiGoaFvVUtSUnJ8sK/JCQENy4cQMFBQVQUVFBixYtYGVlBSsrK1hbW8PKygomJiZV+m6QaWlpiI2NRVRUFKKjoxEdHY2oqCikpKQAeH7zr48++gi2trawtbVF165dq/TrrYlyc3Px2Wef4d9//8WuXbvg4uIiey4+Pl42Kh0cHIzbt29DKpVCS0sLlpaWsLa2hrW1Ndq1awcLCwt88MEHVa64FQQBycnJuHXrFqKiohAZGYnIyEhER0cjPz8fqqqqMDc3lxXxdnZ2MDc3Fzs2EZHYWNRT9VI6mlda9Jb+jomJQVFREQCgQYMGMDQ0hJGREYyNjWFoaAhDQ0M0b94cTZo0gZ6eHurVq6fw3JmZmcjMzERKSgoSEhKQmJiIpKQk2U9CQgIKCgoAALq6urC0tESbNm1kxZyVlRUvsKziHj58CGdnZ6SkpODIkSNvXCv92bNnuHnzpuxbmoiICERFRSE5ORkAoKmpiQ8//FDW10t/Gxsbo0mTJtDX14eenp5Cr1HJyspCenp6mX7+4u+kpCQUFhYCeH4TuzZt2qBNmzawtrZG27ZtYWVlBW1tbYXlJSKqIljUU80gkUgQFxeHuLi4MoVyaSHx6NEjlJSUyNqrqalBT08Penp6ssJHT08PWlpa0NbWli1/p6urK5v2UL9+faioqEAikcjuIPrs2TNZIf706VMUFRUhLy8PmZmZyMjIkP3Ozs4uk7dWrVr48MMPZSccL56AtGzZEsbGxgp410iRIiIi4OTkhHr16iEgIABGRkbvvK+MjAzcvn0bCQkJ5QrnxMREWdEMACoqKrI+rq+vL/uzlpYW6tSpAw0NDQD/69/q6uqyb3/y8vIgkUgAANnZ2RAEAVKpFLm5uSgqKkJGRkaZfp6RkVHmc1Z60vHfEw5jY2OYm5tzBSYioopjUU8EPC/6Hz16hJSUFNmI+ct+nj17VqZQz83NhVQqBfB8BBJAmaKnVq1ayMvLQ7169dCwYUOoq6ujTp06spOE/xZSenp6aNSoEZo2bcoVfmqQEydOYPjw4bCxsYGfn59cvykSBAGPHj1CamoqMjMzkZaWVu4ks7Sv5+fny04ASov2F09adXR0oKmpCQCyi9U1NTVlj794svBiX2/YsCEaN26Mpk2bVrnpQURESopFPZE8CYIAXV1d/P777xg3bpzYcUgJ/fXXX5g4cSI8PDywYcMG2cg4ERHRWzjAIRIiOSq9YDcuLk7sKKRkBEHA/Pnz8eWXX+KHH37A5s2bWdATEdE7q95roBEpAVNTU9y9e1fsGKRECgsLMXbsWOzfvx/btm2Dh4eH2JGIiKiKY1FPJGcmJiY4d+6c2DFISWRmZmLIkCGIiopCYGAgevToIXYkIiKqBjj9hkjOTExMOFJPAIC4uDjY2dnhwYMHCA4OZkFPRESVhkU9kZyZmpoiOzsbmZmZYkchEV26dAm2traoV68eQkJCYGFhIXYkIiKqRljUE8mZiYkJAHC0vgbz8/NDz549YW9vjzNnznD9dSIiqnQs6onkzMjICJqamlwBp4by8fHBiBEjMH78ePj5+fFuqEREJBe8UJZIztTU1GBoaMiR+hqmuLgYU6dOxfr167Fy5UpMnTpV7EhERFSNsagnUgBTU1OO1NcgeXl5cHV1xdmzZ+Hn54fBgweLHYmIiKo5FvVECmBiYoLw8HCxY5ACJCcnw8XFBcnJyThz5gxsbGzEjkRERDUA59QTKYCJiQlH6muAqKgo2Nra4tmzZwgJCWFBT0RECsOinkgBTE1N8ejRI+Tl5YkdheQkKCgIDg4O+PDDD3Hu3DkYGxuLHYmIiGoQFvVEClC6rOW9e/dETkLysGnTJgwcOBD9+vVDUFAQGjZsKHYkIiKqYVjUEylAy5Ytoaqqyik41YwgCJg/fz48PT0xceJE7N69G1paWmLHIiKiGogXyhIpgJaWFpo1a8aivhopLCyEp6cn9uzZg/Xr1+PLL78UOxIREdVgLOqJFITLWlYfmZmZ+PTTT3Ht2jUcOXIE/fv3FzsSERHVcCzqiRTExMSEN6CqBu7duwcnJyfk5ubi33//Rfv27cWORERExDn1RIrCZS2rvtDQUNja2kJTUxOXLl1iQU9EREqDRT2RgpiYmCApKQlFRUViR6F3cODAAfTs2RMdOnTAhQsX0Lx5c7EjERERybCoJ1IQU1NTFBcXIzExUewo9JZ8fHwwbNgwjBw5Ev7+/tDV1RU7EhERURks6okUxNTUFAA4r74KKS4uxtdff41vv/0WP/30EzZs2AB1dV6KREREyof/OxEpSN26ddGwYUPOq68inj59Cjc3N5w4cQL//PMPXF1dxY5ERET0SizqiRSIF8tWDY8ePYKLiwsSEhIQFBQEBwcHsSMRERG9Fot6IgUyNTXl9BslFx0dDScnJ6irq+PixYswNzcXOxIREdEbcU49kQJxpF65nTp1Cg4ODmjWrBlCQkJY0BMRUZXBop5IgUxMTHDv3j2UlJSIHYX+Y8uWLRgwYAB69+6NU6dOoVGjRmJHIiL6P/buPq7mu/Ef+Ot0pxvSDXNTdCjRrYxtunM7UpkZY5TcjrntsXWFyQybcYmZtmtuR9bY3IdJIzSU+1CRm6QS0r2U7s45nd8ffp2vVsjofM6p1/Px6GHOeX/e53XK47pe59P78/4Q1RlLPZESWVlZoby8HPfv3xc6Cv1/crkcixYtwsSJEzFt2jTs2LEDenp6QsciIiJ6JVxTT6RElpaWAJ5ua9muXTuB01BFRQU+/fRT/P777/j5558xbdo0oSMRERH9KzxTT6RErVq1QrNmzZ67rl4mk6GgoEDJqRqngoICeHh4IDw8HPv3739uoefPhIiI1AFLPZGSdezY8bml/t69e5g7d66SEzU+qampcHV1xa1bt3Dy5El4e3s/dyx/JkREpA5Y6omUjNtaCuvChQtwdnaGlpYWzp49i27dugkdiYiI6LWx1BMpGbe1FM7+/fvRp08fODo6IiYmhtc1EBFRg8FST6RkLPXCCAkJwfDhwzFq1ChERETA0NBQ6EhERERvDHe/IVIyS0tLPH78GDk5Ofjzzz9x6dIlxXNFRUW4ePEiZs6cWe2Yr776Cq1bt1Z21AZBLpdj8eLF+Oabb/D1119j0aJFLxy/efNm/kyIiEjtsNQTKZmVlRWAp9taDhw4ED179lQ89+DBA5SUlGD69OnVjjExMVFqxoairKwM48aNw/79+7F161b4+Pi89Bj+TIiISB2x1BMpWbt27dCkSROkpKTA2dm52nMGBgYwNjaGra2tQOkajry8PHz44Ye4fv06jhw5gl69etXpOHNz82p/58+EiIjUAUs9kZJpaGhALBZzXX09un37Nry8vCCTyXD69Gl07txZ6EhERET1ihfKEgmAF8vWn9OnT8PZ2RmmpqY4c+YMCz0RETUKLPVEAnjeXvV6enqwt7cXIFHDsGvXLvTv3x+9evXC8ePH8dZbb732nPyZEBGROmCpJxLA887Uv/XWW/D39xcgkfoLCQnBJ598gilTpmDXrl3Q09N7I/PyZ0JEROqAa+qJBGBpaYns7Gw8fvyY+6W/JqlUipkzZ+KXX37BTz/9hBkzZggdiYiISOlY6okEULWt5Z07d+Dk5CRwGvVVVFSETz75BCdPnsS+ffswePBgoSMREREJgstviAQgFouhqalZ67p6qpv79++jV69euHLlCk6cOMFCT0REjRpLPZEAmjRpAnNzc+6A8y8lJCSgZ8+ekEqlOHv2LLp37y50JCIiIkGx1BMJhNta/jtHjhyBu7s7OnfujJiYGLRv317oSERERIJjqScSyPO2taTn++WXX+Dt7Y1hw4YhMjISzZs3FzoSERGRSmCpJxIIz9TXnVwux6JFizBlyhTMnz8foaGh0NbWFjoWERGRyuDuN0QCsbS0xL1791BWVgZdXV2h46is8vJyjB8/Hnv37kVYWBjGjBkjdCQiIiKVw1JPJBBLS0tUVlYiLS0NXbp0ETqOSsrLy8NHH32Eq1ev4vDhw+jTp4/QkYiIiFQSl98QCaRqr3quq69dSkoKXFxccO/ePcTGxrLQExERvQBLPZFAmjZtilatWnFdfS3OnDkDZ2dnGBkZ4cyZM7CxsRE6EhERkUpjqScS0LMXyz569AhxcXHYuXMnTp8+LXAy4ezevRv9+/eHq6sroqOj0apVK6EjERERqTyRXC6XCx2CqLF4+PAhUlJScPv2baSkpGDr1q3Iy8uDSCRCYWGhYtyvv/6KsWPHCphUGCEhIQgICMDMmTPxww8/QEOD5x2IiIjqIJwXyhIpyZ9//okhQ4YAADQ0NKCtrQ2JRILKysoaY3v06KHseIKSyWSYNWsWNmzYgB9++AH+/v5CRyIiIlIrPFNPpCRyuRxvv/02EhMTIZPJnjtOT08PRUVF0NTUVGI64RQXF2PUqFH4+++/sW3bNnz44YdCRyIiIlI34fzdNpGSiEQiLF269IWFHgCcnJwaTaF/8OABevfujbi4OERHR7PQExER/Uss9URK5OnpiZ49e0JLq/aVbzo6OnB2dlZyKmEkJibC2dkZZWVlOHPmDN555x2hIxEREaktlnoiJVuyZAmkUmmtz0mlUnTv3l3Jid68ioqKFz4fFRUFd3d3WFpaIjY2FmKxWDnBiIiIGiiWeiIl69+/P9zd3Ws9W19ZWdkgSv3ChQvx/fff1/rc5s2b4e3tDQ8PDxw6dAhGRkZKTkdERNTw8EJZIgHExsbCzc2txuP6+vooKipS660cU1NT0blzZ0ilUuzcuRMff/wxgKcXCi9evBiLFy+Gv78/Vq9eDZFIJHBaIiKiBoEXyhIJwdXVFe+//z60tbWrPd6tWze1LvQAMHv2bEVZ9/X1xZkzZ1BeXg4/Pz989913WL9+PUJCQljoiYiI3iDuU08kkP/+97/VLg5tCBfJnj59Gnv37kXVLwBlMhkGDRqELl264Pr16/jzzz8xaNAggVMSERE1POp9SpBIjXXv3h1eXl6Ks/XqfpFsZWUlpk+fXm07TplMhpKSEsTHx+PQoUMs9ERERPWEpZ5IQMuWLVPshFNZWanWd5INDQ1FQkJCjZ19pFIpKisrMXv2bJSVlQmUjoiIqGFjqScSkIODA4YNGwYAaNq0KSwtLQVO9O8UFxfjyy+/fO7zEokEFy9ehJ+fHyorK5WYjIiIqHFgqScS2DfffAMNDQ28/fbbanvx6NKlS/Ho0SO8aDMtqVSK3bt346uvvlJiMiIiosaBF8oSCczW1hajR49G27ZthY7yr6SmpmLlypXPvaEWAMWOPlVbdpaWlkJPT09ZEYmIiBo8lnoiJZPJZMjPz0deXh6ePHmCkpISDBw4EKmpqdi7dy9kMhkqKytRWFgI4Gkhbt68OQCgSZMm0NfXBwAYGBhAR0cHzZs3R4sWLQS7iVNgYOBzf8Ogra0NiUQCBwcHTJ8+Hb6+vjAwMFByQiIiooaPpZ7oDSkpKUFaWhrS0tKQnp6OtLQ03L9/X1Hg8/PzkZubi0ePHtVpPmNjYwBPl60UFRW9dLympiZMTU1hYmJS7U8LCwvFl1gsRrt27Wrsj/9vnT59GuHh4dWW3VSdldfT04Ovry+mT5+Orl27vpHXIyIiotrxjrJEr6CyshJ37txBQkICEhMTce3aNUWRz8nJUYwzNjaGWCyGubk5TE1Nq321aNFCUbgNDAzQtGlTRclu3rz5C28+VVFRgSdPngAASktLUVZWhsLCQuTk5Cg+PFR9gMjLy0Nubi7u3r2L1NRUlJaWAnhautu2bQuxWAwrKyvY2dnB0dERDg4OaNOmzSt9L5ycnHDt2jVUVlZCW1sbUqkUzs7OmD59OoYPHw5dXd1/820mIiKiVxPOUk/0HOXl5YiLi8OFCxdw9epVxMfHIykpCU+ePIGGhgY6duwIBwcHdOjQAWKxWPFlYWEBQ0NDoePXkJ2drfgtQtVvEpKTk5GYmIjMzEwAgKmpKbp27Qp7e3s4OjqiZ8+esLGxqfWDRmhoKCZOnAjg6YeRTz/9FJMnT0bnzp2V+r6IiIiIpZ5IIS8vD6dPn0ZsbCxiY2Nx8eJFlJWVoUWLFoqi6+DgAEdHR9ja2jaoteF5eXmIj4/H1atXcfXqVSQkJODq1at48uQJjI2N4eLiAldXV7i5uaFHjx6QSqXo0qULOnXqhKlTp+Kjjz5CkyZNhH4bREREjRVLPTVeZWVlOHHiBA4ePIjjx4/j+vXrAAAbGxtFgXV1dVXbveNfl0wmQ3x8vOJDTkxMDO7fvw8dHR3Y2trC3d0dY8eOxdtvv/3CJUNERERU71jqqXG5d+8eDh06hIiICBw7dgxPnjyBk5MTPDw84ObmBhcXF5iYmAgdU2Wlp6cjJiYGJ0+eRGRkJDIyMtCqVSt4eXnB29sbAwYMUMmlR0RERA0cSz01fPfu3cPvv/+OP/74A1euXIGBgQHef/99eHl5wcvLC+bm5kJHVFvx8fGKD0lnz56FhoYG+vTpA19fXwwbNgzNmjUTOiIREVFjwFJPDVNhYSH27NmDrVu34sSJEzAyMsLIkSMxdOhQ9O7dm7uy1IO8vDwcPnwYu3fvxqFDh6ChoYGhQ4fC19cXHh4e0NLiDrpERET1hKWeGpbo6GisW7cOBw4cAAB4e3vDz88Pnp6e0NHREThd41FQUICdO3di69atiI2NRcuWLTFq1CjMmDED1tbWQscjIiJqaFjqSf2Vl5dj+/btWL16Na5cuQIXFxdMmDABH3/8sWB3WaX/k5qaim3btiE0NBRpaWnw8vLC559/jv79+wsdjYiIqKFgqSf1lZOTg82bN+N///sfsrKyMHToUHz++edwcXEROhrVorKyEhEREfjxxx9x9OhRWFtbY/r06Zg8eTL09fWFjkdERKTOWOpJ/RQVFWHNmjX47rvvoKGhgXHjxiEwMBDt2rUTOhrV0ZUrV7B27VqEhYXB1NQUs2fPxrRp07hEioiI6N9hqSf1UVJSgh9//BHBwcHQ1NTEvHnzMHXqVJ7lVWOZmZlYunQpNmzYALFYjG+++QYjR46ESCQSOhoREZE6CecdY0jlyWQyrF27FlZWVli6dClmzZqFlJQUBAQEsNCruTZt2uCnn37CjRs38N5778HHxwc9evTA0aNHhY5GRESkVljqSaUlJibC2dkZX3zxBT755BOkpKRg8eLFvMFRA9OhQweEhYXhypUrMDMzw4ABA+Dn54fc3FyhoxEREakFlnpSSRKJBMuXL0ePHj2gpaWFS5cu4YcffkDLli2Fjkb1yMHBAQcOHEBERAROnjwJa2trbNiwQehYREREKo+lnlTO2bNn0bVrVyxZsgQrV65ETEwMbG1thY5FSuTl5YXExESMGjUKU6dOxeDBg3H//n2hYxEREakslnpSKf/73//Qq1cvtG/fHlevXsWsWbOgocF/po2RoaEh1qxZgxMnTiA5ORndu3fHqVOnhI5FRESkktiWSCWUl5dj0qRJ8Pf3R0BAAA4dOgQLCwuhY5EKcHd3R1xcHNzd3dGvXz8sX75c6EhEREQqh1takuDu3buH4cOH48aNGwgLC8OHH34odCRSQXK5HMHBwZg/fz4++eQTbNy4kbsfERERPcV96klYycnJ6Nu3L5o1a4bw8HB06dJF6Eik4v766y/4+vrC1tYWkZGRaNq0qdCRiIiIhMZST8KpKvStW7dGVFQUjI2NhY5EauLGjRvo27cvrKysWOyJiIh48ykSyu3btwUv9NHR0XB1dYWWltYrHVdeXv5GXj80NBReXl5IT09HWFgYevTo8dJ92f/73/9CJBLV+rV7924AQF5eHnr16oWQkBBkZmZizpw56Ny5M9LT019pnmdVVlaib9++EIlEb+z9v44uXbogOjoat2/fhqenJ4qLi4WOREREJCieqSely8jIgIuLC8zMzHD48GE0b95csCxz5szBqlWrIJVK63xMYGAggoODX2tXnqSkJPTs2RM3b95EmzZtAAAeHh6wtLTEmjVraj1GLpfDxcUFAQEBsLe3h56eHgAgJycH/fr1Q1ZWFvT19TF+/Hikp6cjOjoawNNC3q1bN4jFYuzfv7/O8zxr5cqV2LJlC65du4aysjI0adLkX7/3NykxMRH9+/eHg4MD/vrrL2hrawsdiYiISAg8U0/KVVJSgqFDh8LIyEjwQg/glUtgYmIi1q1b99qvGxgYiE6dOikKPQD069cPmzZtQkZGRq3HpKenY926dRgxYgRsbGwgFoshFotx+fJleHt7Q19fH4WFhdi6dSs8PDwUx2loaGDChAk4cOAA4uPj6zTPsxISEnDp0iX4+Pi89vt+0xwcHBAVFYXz58/D399f6DhERESCebV1B0Svadq0abh79y7OnTsnSKGXSGxENJkAACAASURBVCQIDw/H5cuX0adPH1RWVtYYk5ycjEOHDuHRo0d499134enpCQCIjY2Fj48Pnjx5gu3bt0NbWxsjRox44THPc+nSJfTt27faY2KxGBUVFYiKisLEiRNrHCMWi2uda9euXZg2bRoA4NatW5DJZIqz71VsbGwAAJcvX8b48eNfOk+V8vJyzJ49G7///rvK3tm1a9euCAsLw/Dhw9GzZ0+MGzdO6EhERERKxzP1pDR79+7Fb7/9htDQUHTs2FHpr19YWAhPT09cv34ds2fPRlZWFlatWlVtjL+/PyZNmoQxY8bAxcUF3t7ein3R5XI53N3dAQDNmzdXfCh50TG1yc3NRVZWFkxNTas9XlXaU1NT6/yecnNzcfHiRcWHCENDQwBPy/2zqkr+3bt36zRPlaCgIAQGBtbIqmo++ugjBAQEYObMmUhOThY6DhERkdKx1JNSFBQUYOrUqZgyZQoGDx4sSIagoCA0a9YMCxcuhImJCcaOHYuBAwdWGxMWFgYPDw+YmppiwIABsLGxwb59+wAAbm5usLa2BgB4eXkpjn3RMbVJTEwEgBpFuWXLlgDw3OU3tQkPD8egQYMUpd3S0hLt27fH77//jkePHinGPXz4EADQqlWrOs0DAMeOHQMADBgwoM55hPTdd9+hQ4cOmDFjhtBRiIiIlI7Lb0gpFi5cCA0NDcHuBpqdnY2NGzciJCSk2uOOjo6IjIxU/D0iIkKxVOX8+fOQy+UoLS194dyvekzVten/XM9fdUzr1q3r+K5qLpnR0tLCxo0bMXz4cNja2uI///kPioqKsGvXLgCAnZ1dneYpKCjA999/j/Dw8DpnEVqTJk2wdu1auLu7Izw8HB999JHQkYiIiJSGZ+qp3t29exfr1q3DkiVLBLswNj4+HhKJpEZhFolE1f7u6uqKEydOwM/PD7du3YJYLMbLNoh61WPMzc0BPC3Oz3ry5AkAwN7evk7vKS8vr9YlMwMHDkRiYiIWLFgAY2NjjBs3Dvn5+ejUqRNcXV3rNM+8efMgEokwb948BAQEICAgABEREQCe7hgUGhpap4zK5urqilGjRmH+/Pm1Xi9BRETUUPFMPdW7lStXom3btoJewFhUVAQAyMzMfOG4OXPm4Pr169i1axd0dXWxZ8+el879qseIxWKYmJjUyFK1j/zzzqb/U3h4ODw9PaGrq1vra1SdeQ8NDUVWVhZCQkJqfIh53jympqa4ffs2EhISFI9VLeFJTEyEkZFRnTIKYcGCBbC3t0d4eDiGDx8udBwiIiKlYKmnelVSUoJff/0VixYtEnQP8S5dugAAIiMjMX369GrPVZ3RjYuLw4oVKxAZGVmt4NZ21l0mk0FLS+uVjqmio6MDHx+fGuvuExIS0LJlS9ja2tbpPe3evbvGbjX/VFhYiOXLl2PNmjUYOXJknef57rvvaoxbtmwZgoKCEBkZqTL71NfGxsYGH3zwAdauXctST0REjQaX31C9Cg8PR2lpKXx9fQXNYWtri0GDBuHgwYPYsmULAKCiogJXrlyBXC5HRkYGdHR0AAD79u2DVCrF0aNHER8fj4KCAiQnJyM1NVVxMWtcXBxOnTqluAHVi46pzdy5cyGVSnHq1CkAQHFxMTZs2IAlS5YoCvPx48cxevRo5Ofn1zg+Pz8fFy9exKBBg577nnNyctC3b198+umnmDp1aq1j6jKPOho/fjyio6Nf6aJjIiIidcZST/Xq4MGD6NOnD9566y2ho2DLli1wd3fHhAkT0LlzZ4wYMQLGxsZo2rQpgoODYWJiAj8/P2zcuBHm5uZISUnBpEmT8ODBA2zYsAEdOnTAoEGD0KpVK3h6euLWrVvo1q3bS4+pjbm5Ofbv34/FixdjxYoV+OyzzxAUFIQpU6YoxkRGRmL79u24fft2jeP37dsHT0/PWs+Ynz9/HsHBwZg4cSICAgIQGBj43O/Ji+ZRZ15eXtDX18ehQ4eEjkJERKQUIvnLrgIk+pfkcjnatGmDgIAAzJkzR+g4CikpKZDJZOjUqRPS0tJgamqq2N8deHqG28jISLFcqKCgAMbGxornJRIJpFJpte0fX3bMi6SmpsLCwkJx1r+KVCpFeno6LC0taxxz69YtGBgYwMzMrNrjcrkcsbGxEIvFMDMzq3UNfV3maQi8vb1hYGCAnTt3Ch2FiIiovoWz1FO9uXfvHtq1a4eTJ08qbtpEpCxLlizBli1bav1NBxERUQMTzuU3VG9u3LgB4P8uUiVSpi5duiAtLQ1lZWVCRyEiIqp3LPVUb7KysqCtra24uJRImczMzCCTyZCbmyt0FCIionrHUk/1pri4GM2aNRM6BjVSVf/2Hj9+LHASIiKi+sdST/VGJBLxrp4kmKp/e5qamgInISIiqn8s9VRvmjVrhuLi4hfeiImovlSdoedvi4iIqDFgqad6Y25uDqlUigcPHggdhRqh9PR06OjoqMQ9EoiIiOobSz3Vm6pdb5KSkgROQo3R9evXYWVlBS0tLaGjEBER1TuWeqo3LVu2RIcOHRATEyN0FKVLT0/H/PnzIRaL63zMkSNHEBER8Uqvc/nyZXz11VfYsGEDiouLBR+jSk6dOoX33ntP6BhERERKwVJP9ap///44cuSI0DGU7s6dO/j7779x7969l449evQoPDw84OHhgYsXL9b5NUJDQzF//nxMnjwZurq66NOnT43tG5U5RpUUFRXh7Nmz6Nevn9BRiIiIlIJ3lKV6FRERgQ8++ADJycmwtLQUOo5SzZkzB6tWrYJUKn3huLKyMjx8+BAdOnTAokWLsHDhwpfOnZSUhJ49e+LmzZto06YNAMDDwwOWlpZYs2aN0seomtDQUEydOhUPHjyAqamp0HGIiIjqG+8oS/XLw8MDrVq1QmhoqNBRlE5bW7tO43R1dWFmZvZKcwcGBqJTp06Kkg0A/fr1w6ZNm5CRkaH0Mapm8+bN+OCDD1joiYio0WCpp3qlpaWFqVOnYu3atSgqKhI6DkpKSrB+/Xp8++232L17NwoKCiCTyRTbbqakpGDBggWQyWQ4ePAggoODIZFIAADJyckICQnB4sWLERkZWWNuiUSCnTt3Yt68eTh8+PAr7dH/qnupX7p0CdbW1tUeE4vFqKioQFRUlNLHqJIzZ84gJiYG/v7+QkchIiJSGpZ6qnf+/v6QSCRYvXq1oDlyc3Ph6OgIPT09fPnll7hw4QJMTExgZWWFXr16ISwsDG5ubliyZAm2bt2Kr7/+GnPnzsWFCxfg7++PSZMmYcyYMXBxcYG3tzeWL1+umLuwsBCenp64fv06Zs+ejaysLKxatarO2UQiUbU/X/Y+srKyapyFrrooNzU1ValjVE1QUBDc3d3Rq1cvoaMQEREpDUs91TtjY2MEBQVh2bJlSE9PFyzHd999h5ycHPj4+EBbWxuzZs0CAPj4+ODUqVMYO3YsJk2apBh/6dIl3LhxA87OzggLC4OHhwdMTU0xYMAA2NjYYN++fYqxQUFBaNasGRYuXAgTExOMHTsWAwcOrJf3kZiYCAA1inbLli0BABkZGUodo0p27dqFEydOIDg4WOgoRERESsVST0rxxRdfoF27dpg2bZpgd5hNTk6GhoaG4my4ubk5rKysqm25qaenBwAYPXo0AKBz584QiUSIiIjAtGnTAADnz5+HXC5HaWkpACA7OxsbN26sUeIdHR3r5X1Uff/+uWa/Kk/r1q2VOkZV5OXl4fPPP8e4cePQs2dPoeMQEREpFUs9KUWTJk2wZcsWREVFCbZjipubGx49eoTz588DAMrLy/HgwQO8/fbbijHPW/7i6uqKEydOwM/PD7du3YJYLFYU3vj4eEgkkhoFty5Laf4Nc3NzAEBBQUG1x588eQIAsLe3V+oYVfHZZ59BU1PzlZY9ERERNRS81SIpjbOzM+bPn4///Oc/6NatG1xcXJT6+l988QXi4uIwZ84cLFy4EPv374eLiwu++eablx47Z84cXL9+Hbt27YKuri727NmjeK7qAuDMzMx6y/4ssVgMExOTGq9XtbTJzs5OqWNUwffff499+/bhyJEjMDY2FjoOERGR0vFMPSnV119/DQ8PDwwfPhxpaWlKfW2RSIS2bdvihx9+QGVlJWbMmIGoqCg0a9bshcfFxcVhxYoVmDFjBnR1dRWPV52p79KlCwDUuiNOXXfAqZqrLkuTdHR0FNcBPCshIQEtW7aEra2tUscILSIiAnPnzsXy5ct5sykiImq0WOpJqTQ0NLB161a0bt0aAwYMwMOHD5X22sHBwThx4gQyMjKgra2NwsJCJCUlVbs5VNX2lXl5eYrH9PX1AQD79u2DVCrF0aNHER8fj4KCAiQnJ0NPTw+DBg3CwYMHsWXLFgBARUUFrly5ArlcjoyMjJfegKqiogLA/y1redbx48cxevRo5OfnKx6bO3cupFKpomwXFxdjw4YNWLJkCZo0aaL0MUI5efIkRo4ciXHjxuE///mPoFmIiIgEJScSQFZWltza2lpuZ2cnf/DggVJe888//5Tr6urKAVT7at++vfzIkSPy3bt3yzt37iwHIB8xYoQ8Pj5ecayfn59cQ0ND3qpVK/m6devkS5YskWtoaMgDAwPlcrlc/vDhQ7m7u7scgNza2lo+ZMgQ+ZgxY+RNmzaVz5w5U37v3r3n5jp9+rR8+vTpcgByKysr+c8//yyXSCSK5wMDA+UA5OfOnat23Llz5+T9+/eXBwcHy318fOSrV6+uMbcyxyjbyZMn5YaGhvLhw4fLpVKp0HGIiIiEtFcklwu0FQk1evfu3cOAAQMgkUgQFRWFDh061Ovr7d69G1KpFAMGDEBeXh6ePHmCwsJCXL16FXv27EF0dPQLj8/JyYGRkZFiJ5iCgoIa67dTUlIgk8nQqVMnpKWlwdTUFIaGhq+VWyqVIj09HZaWlrU+n5qaCgsLC2hoPP8Xb8ocowyRkZH4+OOPMWjQIPzxxx/Q0dERNA8REZHAwlnqSVDZ2dnw9PTE3bt3sX37dvTv379eXuf27dtwdXXF/fv3oaVV/frw7OxsBAYGIiwsrF5em96sVatWYe7cuRgzZgx++eWXV74bLxERUQMUzjX1JKi33noLsbGx8Pb2hoeHB5YvX14v+9hnZGQgOzsbfn5+OHnyJDIyMpCRkYGjR4/C398fCxcufOOvSW9WWVkZxo8fjzlz5mDJkiXYvHkzCz0REdH/xzP1pDI2bNiAmTNnYtiwYdi0aRMMDAze6PxHjhzBwYMHcfToUaSmpqJTp07w8PDAggULXnuJDNWvu3fvYtiwYUhLS8Mff/yBAQMGCB2JiIhIlXD5DamWqt1MDAwMsH79erz//vv18jpyubzebg5Fb45cLsfGjRsxe/ZsdOzYEXv37q33ay+IiIjUEJffkGrp1asXLl26BAcHBwwcOBBTpkzBo0eP3vjrsNCrvps3b6J3796YMWMGpk+fjjNnzrDQExERPQdLPamctm3bYt++fdixYwcOHDgAOzs77Nu3T+hYpCQSiQRLly6Fk5MTnjx5ggsXLmDZsmXVbvxFRERE1bHUk8oaMWIEbty4gcGDB2PYsGFwc3OrcWdTajjkcjl27doFOzs7LFmyBHPnzsXZs2fh5OQkdDQiIiKVx1JPKs3IyAjr16/HqVOnIBKJ0Lt3bwwfPhzXr18XOhq9QYcPH0b37t0xatQoODs7IykpCYsWLVLcE4CIiIhejKWe1IKrqytOnTqFAwcOIDk5GQ4ODpg0aRJu374tdDR6DSdPnkTfvn0xaNAgmJubIz4+Hr/++ivEYrHQ0YiIiNQKSz2plcGDB+PKlSvYsmUL/v77b3Tu3Bkffvghjh8/LnQ0qqOKigqEhYWhe/fu6N27NyorKxETE4MDBw7A3t5e6HhERERqiaWe1I6GhgbGjBmD5ORk7Nu3DyUlJejfvz+6dOmCkJAQlJSUCB2RapGdnY3ly5fD0tISEydORNu2bRETE4MTJ07A1dVV6HhERERqjfvUU4MQFxeHkJAQ7NixA4aGhhg9ejR8fX3x3nvvCR2tUZNIJPjrr7/w22+/4cCBA2jatCmmTJmC6dOnw9zcXOh4REREDQVvPkUNS2ZmJjZt2oRt27bhxo0bsLa2xpgxYzBmzBjuca5EZ8+exdatW7Fjxw7k5+fDzc0NY8eOxejRo6Gvry90PCIiooaGpZ4argsXLiiKZXZ2NlxcXDB06FB4e3vDxsZG6HgNikwmw+nTp3Ho0CHs2bMHycnJsLW1xZgxY+Dr64v27dsLHZGIiKghY6mnhk8qleLIkSPYvn07IiMjkZubiw4dOsDLywuDBw9Gnz59eGOjfyE3Nxd//fUXIiIicOTIEeTn58PKygpDhgyBr68v3n77baEjEhERNRYs9dS4yGQynD9/HhERETh06BCuXLkCPT099OnTB66urnB3d8c777zDkl+L/Px8xMbGIjY2FidOnMCFCxegqamJXr16wcvLC97e3rC2thY6JhERUWPEUk+N2/3793Ho0CEcO3YMMTExuH//PnR0dNCjRw+4urrCzc0NPXv2xFtvvSV0VKWSy+W4c+cOTp8+jZiYGMTExChu+GVraws3NzcMHDgQAwYMQLNmzQROS0RE1Oix1BM968GDB4iNjUVMTAxiY2Nx+fJlVFZWwtjYGLa2trCzs4OtrS26d++Obt26wcDAQOjIr+3Ro0e4evUqkpKScO3aNSQlJeHKlSvIzc2FlpYWunbtqviA07dvX7Ro0ULoyERERFQdSz3RixQUFCAuLg6JiYmKr2vXrqG0tBSampro2LEjOnbsCLFYDAsLi2p/tmnTBiKRSOi3AIlEgoyMDKSnpyMtLQ3p6elITU1Feno6kpOT8eDBAwCAiYkJHB0dYW9vDwcHBzg6OsLJyYlLkYiIiFQfSz3Rq5LJZLhz5w4SEhKQlJSEO3fuKMryvXv3IJFIAABNmjRB27Zt0bJlS5iamsLU1BQmJiY1/ltDQwM6OjqKs/76+vpo0qQJAEBPTw+lpaUAgCdPnqCiogIAUFhYiMrKSlRUVCAvLw95eXnIz89X/HdeXh5yc3ORm5uLzMxMyGQyxXxisVjx4aNjx46KIm9mZqbsbyURERG9GSz1RG+STCbD/fv3kZaWhrS0NNy/f79G6X72T6lU+tqvqaurq/iA8OyHhhYtWqBFixYwNzdXlPhWrVq9gXdJREREKoalnkhIVWfcJRIJiouLAfzfGfnTp0/D398fJ0+ehL6+PgwMDKCjowMAMDY2BoBqZ/iJiIio0QrXEjoBUWPWvHlzxX//c4ed7OxsAICTkxN3mCEiIqIX0hA6ABERERERvR6WeiIiIiIiNcdST0RERESk5ljqiYiIiIjUHEs9EREREZGaY6knIiIiIlJzLPVERERERGqOpZ6IiIiISM2x1BMRERERqTmWeiIiIiIiNcdST0RERESk5ljqiYiIiIjUHEs9EREREZGaY6knIiIiIlJzLPVERERERGqOpZ6IiIiISM2x1BMRERERqTmWeiIiIiIiNcdST0RERESk5ljqiYiIiIjUHEs9EREREZGaY6knIiIiIlJzLPVERERERGqOpZ6IiIiISM2x1BMRERERqTmWeiIiIiIiNacldAAierEdO3ZAV1cXACASidCkSRMYGhrC3t4ebdu2faW5zp8/j1u3blV7TEtLC6NGjaoxdv/+/SgqKlL8XSQS4Z133oG1tTUAoKysDOHh4ZDJZAAADQ0N9OvXD61bt36lTERERPT6eKaeSMW1aNECY8eOxRdffIH8/Hzcu3cPQUFBaNeuHQICAlBaWlrnud59911YWFhg4sSJ8PPzg6GhIYYMGVLrWE9PTyQnJ8PPzw+zZ8+Gvb29otADgK6uLry8vBAVFYWlS5eiW7duLPREREQCYaknUnH9+/eHsbExWrZsiVmzZuHzzz/HxYsXMWrUKPzwww9YsWLFK83n7u4OMzMzmJqaYsiQIdDX1691nI6ODj7++GMAQI8ePdC1a9caY5o3bw4vLy94eHjAxsbm1d8cERERvREs9URqQEdHp8ZjkyZNAgBs3779X81X25z/ZGpqCgAwNDR84VzNmzd/5QxERET05nBNPZGaqiraHTp0qPHc48ePsWPHDly/fh0dO3bE+PHj0bRpU2VHJCIiIiXhmXoiNVRZWYmlS5cCACZPnlztueTkZIwZMwYWFhYYN24c1q9fDycnJzx69EiIqERERKQELPVEauLx48f49ddfsWTJEjg4OODBgwfYtWsXhg4dWm3cjBkzMHHiRAwcOBBdu3bFihUrkJKSglWrVgmUnIiIiOobl98QqQltbW1YWVnhwIEDSEpKQkREBLy8vKqNyczMRFRUFJycnHDu3DkAQHFxMXr06IGSkhIhYhMREZESsNQTqQk9PT24urrCzs4OcXFxGD9+PBISEqptI5mcnAwAmDNnDlq0aPHar1m1P35FRcVzx5SWlirGERERkTC4/IZIzRgZGWHbtm3Iz8/HuHHjIJfLFc9V7Whz6dKlGsc9eyOpl6n6cNC0aVNoaGggJyfnuWPz8vIUu+QQERGRMFjqidSQq6srvv76axw5cgQrV65UPN65c2doampi4cKF1c6u5+TkYNu2bdXmePbDwLMqKyuxceNGAE8/JFT9ZuB5N7k6duwY3nnnndd9S0RERPQaWOqJVJxUKkVubi4eP35c7fH58+fD3d0d8+bNQ0REBADA2NgYU6dOxdmzZ9G7d2/8/vvv2LJlC3x9fTF69GjFsZmZmcjNzUV5eXm1OcvLy+Hv7w+xWKx47JdffoFEIlHstvOsBQsWoGPHjnBycnqD75iIiIheFdfUE6m4CRMmQCqV4v79+5g2bRomTpyId955B5qamti2bRu6du2KoUOHYvDgwZgxYwaCg4NRVFSEsLAwnD17FoaGhvj111/RvHlznDt3Dj/99JNiKY6VlRXatGkDkUiEsrIypKamori4GBkZGYrXf/fddxEaGoqAgABERkbCxcUFeXl5yMzMhJOT0yvf0ZaIiIjePJH8eb+DJyJBRUZGwsvLC48fP0azZs1e+fjc3FzcvXsXNjY20NPTe+08EokEt27dQnZ2Njp37oy2bdu+9pxERET0RoTzTD1RA9WiRYs3sgNOFW1tbdjZ2cHOzu6NzUlERERvBtfUExERERGpOZZ6IiIiIiI1x1JPRERERKTmWOqJiIiIiNQcSz0RERERkZpjqSciIiIiUnMs9UREREREao6lnoiIiIhIzbHUExERERGpOd5RlkgFSKVSFBUVVXusuLgYAPDo0SNIpdJqzxkbGystGxEREak+lnoiFfDkyRO0adMG5eXlNZ5r3759tb+/++67OHfunLKiERERkRrg8hsiFdC8eXN4enpCU1PzheNEIhFGjx6tpFRERESkLljqiVTEmDFjUFlZ+dJxI0eOVEIaIiIiUics9UQqwtvbG/r6+s99XkNDA71790bbtm2VmIqIiIjUAUs9kYrQ1dXFxx9/DG1t7VqfF4lE8PPzU3IqIiIiUgcs9UQqxMfHBxKJpNbnRCIRhg4dquREREREpA5Y6olUSP/+/WFiYlLjcS0tLXh6etb6HBERERFLPZEK0dTUhI+PD3R0dKo9LpPJMGbMGIFSERERkapjqSdSMaNHj0ZFRUW1x3R1dTF48GCBEhEREZGqY6knUjHOzs4wNzdX/F1bWxvDhw9/4c44RERE1Lix1BOpmKpdbqp2wZFIJPDx8RE4FREREakykVwulwsdgoiqS0xMhKOjI4Cnd5vNycl57laXRERE1OiF80w9kQpycHBA586dAQC+vr4s9ERERPRCLPVEKmrs2LEAgE8++UTgJERERKTquPyGSEWlp6ejd+/euHPnDjQ0+PmbiIiInovLb4hUTWVlJQoKCmBoaIhvv/0WhYWFKCwsFDoWERERqTAtoQMQNTRyuRyZmZlIS0vDgwcPkJubi7y8POTn5yMvL6/afz969EixJ31hYSEqKytfOr+Ojg4MDAwAAAYGBjAyMoKJiQlMTU0Vf7Zo0QImJiZo0aIF2rVrBwsLC5iamtbr+yYiIiLhcPkN0b9QUVGBa9euISkpCampqUhLS0N6ejrS09Nx9+5dlJeXK8ZWFe2qr2f/bmJiAi2tp5+tjYyMIBKJIBKJYGRkVO31ZDIZHj9+DODpFpfFxcUAgLKyshofGPLy8pCbm4v8/HwUFRUp5mjWrBksLCwgFoshFothYWGBjh07wtHRER07duQSHyIiIvUVzlJP9BKpqam4evUqEhMTkZCQgMTERNy6dQtSqRQ6Ojpo3769oiz/szSbmZlBU1NTsOzl5eWKDxvPfvBIS0tT/CahsrIS+vr6sLOzg6OjIxwcHGBvb4+uXbuiRYsWgmUnIiKiOmOpJ3qWVCpFfHw8YmJiEBsbixMnTiA7OxsA0KZNG9jZ2cHW1hbdu3eHnZ0d7OzsoKurK3Dqf6+iogLJycmIi4tDUlISrl27hri4OGRmZgJ4+p7d3Nzg6uoKNzc3dOvWjWf0iYiIVA9LPTVuFRUVOHnyJI4dO4bY2FhcuHABZWVlaNWqFVxcXODm5oaePXvC3t4ehoaGQsdVmqysLFy5cgVnzpxBTEwMzp07h+LiYpiYmCi+LwMHDoSTkxNEIpHQcYmIiBo7lnpqfDIzM3Ho0CEcOnQIUVFRKCoqgo2NjeJstIuLCzp16iR0TJVS9RuM2NhYxMTE4NSpU3j48CHMzMzg5eUFLy8vDBgwQHEBLxERESkVSz01Djdu3MD27dtx8OBBXLp0Cbq6uujbty8GDx4MLy8vWFhYCB1Rrcjlcly+fBkRERGIiIjAhQsXoK2tjd69e2PIkCEYOXIkWrZsKXRMIiKixoKlnhqurKwsbN++Hdu2bcOFCxdgZmaGIUOGwNvbG/369YOenp7QERuMnJwcREZGIiIiApGRkSgrK4OHhwd8fX3x4Ycfm2Gl7QAAGxlJREFU8ntNRERUv1jqqWEpLy/Hnj17sG3bNhw5cgT6+voYNmwY/Pz80KdPH17kqQQlJSXYt28ftm7diqioKMXPYOzYsejTpw/X4BMREb15LPXUMGRnZyM0NBQ//fQTHj58iL59+8LPzw/Dhw/nOm8B5efnY/fu3QgLC0NsbCysra0xffp0TJ48Gfr6+kLHIyIiaihY6km9xcfHY82aNfjtt9+go6ODcePGITAwEO3atRM6Gv3DlStXsHbtWvz2229o2rQpJk6ciJkzZ8Lc3FzoaEREROqOpZ7U09mzZ7FgwQIcPXoUtra2+PzzzzFmzBiu3VYDDx8+xNq1a7Fu3To8evQIfn5++Prrr9G+fXuhoxEREamrcC4wJrVy7do1DB06FM7OzigvL8fhw4dx9epVTJ48mYVeTbRu3RqLFy9Geno61qxZg+PHj8Pa2hoBAQHIzc0VOh4REZFaYqkntZCRkYHPPvsMXbt2xe3bt7Fz506cPHkSAwcO5IWXakpXVxeTJk3CzZs38eOPP2L79u0Qi8X48ssvUVhYKHQ8IiIitcJSTypNIpHg22+/RadOnRAdHY2tW7ciISEBI0aMEDoavSHa2tqYMmUKkpOTERQUhPXr16NLly7Ys2eP0NGIiIjUBtfUk8o6f/48Pv30U6SkpODbb7/FrFmzoK2tLXQsqmf5+fmYM2cONm/ejKFDh+Lnn39GmzZthI5FRESkyrimnlRPaWkpvvzyS7i4uMDY2BiXL19GQEAAC30jYWJigl9++QUnTpxAUlISbGxsEBISgsrKSqGjERERqSyeqSeVcv36dXz00UfIzs7GypUrMWHCBK6Zb8RKSkrw9ddfY/Xq1fDy8sJvv/2G5s2bCx2LiIhI1fBMPamO8PBwvPfeezA1NUViYiImTpzIQt/I6evrY+XKlTh58iTi4uLw7rvvIikpSehYREREKoelngQnl8uxfPlyfPzxxxg9ejSio6NhZmYmdCxSIS4uLrhy5QrMzMzw3nvvYffu3UJHIiIiUiks9SSo8vJyfPjhh1i0aBE2btyI9evXQ0dHR+hYpIJatmyJv/76C2PHjsXIkSOxbNkyoSMRERGpDC2hA1DjVV5ejuHDhyM2NhbR0dHo2bOn0JFIxeno6ODnn3+Gra0tZs2aBblcjqCgIKFjERERCY6lngRRUVGBkSNHIiYmBocPH8Z7772n9Azp6enYsGEDtm3bhrS0NKW/PgBcvnwZe/bsQfv27eHj44OmTZu+cHxBQQEiIiJqfc7R0RGOjo4Anu4gtHfvXly6dAlWVlbw8fGpdoFpXed51t27d7F48WKsX78eWlrC/k/HjBkz0KRJE3z22WeQyWRYsGCBoHmIiIgEJydSsoqKCvmQIUPkzZs3l587d06wHMePH5e7uLjINTU1X+m4srKyN/L6mzdvlnt6esrT0tLkv/76q7x79+7ynJycFx6zbNkyOYBav3bt2iWXy+Xy3Nxcubu7u3z16tXyBw8eyGfPni23traWp6WlvdI8z5LJZPI+ffrIAbyx9/8mrF27Vi4SieTLli0TOgoREZGQ9nJLS1K6GTNmICwsDEePHhXkDP2z5syZg1WrVkEqldb5mMDAQAQHB0ND499fkpKUlISePXvi5s2bihsreXh4wNLSEmvWrKn1GLlcDhcXFwQEBMDe3h56enoAgJycHPTr1w9ZWVnQ19fH+PHjkZ6ejujoaABAZWUlunXrBrFYjP3799d5nmetXLkSW7ZswbVr11BWVoYmTZr86/f+pv3888+YNWsW/vjjD3zyySdCxyEiIhICt7Qk5dq4cSPWrl2LsLAwwQs9gFe+oVViYiLWrVv32q8bGBiITp06VbtTar9+/bBp0yZkZGTUekx6ejrWrVuHESNGwMbGBmKxGGKxGJcvX4a3tzf09fVRWFiIrVu3wsPDQ3GchoYGJkyYgAMHDiA+Pr5O8zwrISEBly5dgo+Pz2u/7/owY8YM+Pv7Y+LEiUhISBA6DhERkSBY6klpbt68ic8//xxBQUH46KOPBMkgkUiwc+dOzJs3D4cPH671LqXJyckICQnB4sWLERkZqXg8NjYWgwcPxpMnT7B9+3bs2rXrpcc8z6VLl2BtbV3tMbFYjIqKCkRFRdV6jFgsRteuXWs8vmvXLowcORIAcOvWLchkMsXZ9yo2NjYAnq7hr8s8VcrLyzF79mz89NNPKn3PgJUrV6J79+7w9fVFWVmZ0HGIiIiUjqWelKKyshLjxo2DnZ0dFi5cKEiGwsJCeHp64vr165g9ezaysrKwatWqamP8/f0xadIkjBkzBi4uLvD29sby5csBPF3+4u7uDgBo3ry54sLTFx1Tm9zcXGRlZcHU1LTa42KxGACQmppa5/eUm5uLixcvwtPTEwBgaGgI4Gm5f1ZVyb97926d5qkSFBSEwMDAGllVjZaWFsLCwpCRkSHYvy8iIiIhsdSTUoSGhiIuLg6bN29+5SUvb0pQUBCaNWuGhQsXwsTEBGPHjsXAgQOrjQkLC4OHhwdMTU0xYMAA2NjYYN++fQAANzc3xdl1Ly8vxbEvOqY2iYmJAFCjKLds2RIAnrv8pjbh4eEYNGiQorRbWlqiffv2+P333/Ho0SPFuIcPHwIAWrVqVad5AODYsWMAgAEDBtQ5j5DEYjGWLVuG1atX48aNG0LHISIiUiqWeqp3JSUlmD9/PmbMmAF7e3tBMmRnZ2Pjxo01Svw/t26MiIjAtGnTAADnz5+HXC5HaWnpC+d+1WOqrk3/54ebqmNat25dh3f01D+XzGhpaWHjxo2QSqWwtbXF999/j0WLFmHx4sUAADs7uzrNU1BQgO+//x5Lly6tcxZVMGXKFNja2mLu3LlCRyEiIlIq7lNP9W7Tpk0oKioS9CZB8fHxkEgkNQrzP9eJu7q6Ijw8HHv37oWHhwfEYjHu37//wrlf9Rhzc3MAT4vzs548eQIAdf7gk5eXV+uSmYEDByIxMRGRkZFo0qQJhg0bhvXr16NTp05wdXWt0zzz5s2DSCTCvHnzFI+dP38ewNMdg5ycnDBhwoQ65VQmTU1NLF68GEOHDkVCQkKt++0TERE1RCz1VK/kcjlCQkIwceJEvPXWW4LlKCoqAgBkZma+cNycOXNw/fp17Nq1C7q6utizZ89L537VY8RiMUxMTGpkSU9PB/D8s+n/FB4eDk9PT+jq6tb6GlW/PQgNDUVWVhZCQkJqvdi1tnlMTU1x+/btarvJVC3hSUxMhJGRUZ0yCuGDDz6Ag4MDVq9ejc2bNwsdh4iISClY6qlenTp1CikpKZg8ebKgObp06QIAiIyMxPTp06s9V7UDTlxcHFasWIHIyMhqBbe2WznIZDJoaWm90jFVdHR04OPjU2PdfUJCAlq2bAlbW9s6vafdu3crivvzFBYWYvny5VizZk2NnW1eNM93331XY9yyZcsQFBSk+A2AqhKJRJg0aRLmz5+PH3/88aV36SUiImoIuKae6tXu3bvh4OAg+DIIW1tbDBo0CAcPHsSWLVsAABUVFbhy5QrkcjkyMjKgo6MDANi3bx+kUimOHj2K+Ph4FBQUIDk5GampqYqLWePi4nDq1CnFDahedExt5s6dC6lUilOnTgEAiouLsWHDBixZskRRmI8fP47Ro0cjPz+/xvH5+fm4ePEiBg0a9Nz3nJOTg759++LTTz/F1KlTax1Tl3nU0ejRo1FaWoojR44IHYWIiEgpWOqpXh07dkxlCuOWLVvg7u6OCRMmoHPnzhgxYgSMjY3RtGlTBAcHw8TEBH5+fti4cSPMzc2RkpKCSZMm4cGDB9iwYQM6dOiAQYMGoVWrVvD09MStW7fQrVu3lx5TG3Nzc+zfvx+LFy/GihUr8NlnnyEoKAhTpkxRjImMjMT27dtx+/btGsfv27cPnp6etZ4xP3/+PIKDgzFx4kQEBAQgMDDwud+TF82jzlq2bIm3335bsYMPERFRQyeSv2idANFrKCwshLGxMQ4cOIDBgwcLHUchJSUFMpkMnTp1QlpaGkxNTRX7uwNPz3AbGRkpdqcpKCiAsbGx4nmJRAKpVFpt+8eXHfMiqampsLCwUJz1ryKVSpGeng5LS8sax9y6dQsGBgYwMzOr9rhcLkdsbCzEYjHMzMxeesOo583TEMyePRtHjx7F5cuXhY5CRERU38JZ6qnenD17Fs7Ozrhz585zz1gT1ZfQ0FDMmDEDxcXFNT4wERERNTDh/H86qjd3796FhoYGLCwshI5CjZClpSVKS0uRnZ0tdBQiIqJ6x1JP9ebx48do2rQpz5KSIKqWVFVtZ0pERNSQsW1RvZFKpTXumkqkLFW7GVVUVAichIiIqP6x1FO9MTAwQHFxsdAxqJF6/PgxAKBZs2YCJyEiIqp/LPVUb1q0aIHy8nI8evRI6CjUCGVlZUEkEsHU1FToKERERPWOpZ7qTdVdXG/evClwEmqMbty4gXbt2sHAwEDoKERERPWOpZ7qjYWFBYyMjHD+/Hmho1AjdOHCBXTt2lXoGERERErBUk/1RkNDA717926Ud/VMT0/H/PnzIRaL63zMkSNHEBER8Uqvc/nyZXz11VfYsGHDc69fUOYYVSGTyRAdHY1+/foJHYWIiEgpWOqpXnl5eSEqKkpx0WJjcefOHfz999+4d+/eS8cePXoUHh4e8PDwwMWLF+v8GqGhoZg/fz4mT54MXV1d9OnTB7m5uYKNUSXR0dHIz8+Hp6en0FGIiIiUgneUpXpVUFCAtm3b4n//+x8mTZokdBylmjNnDlatWgWpVPrCcWVlZXj48CE6dOiARYsWYeHChS+dOykpCT179sTNmzfRpk0bAICHhwcsLS2xZs0apY9RNWPHjsXNmzdx7tw5oaMQEREpA+8oS/XL2NgYI0aMwA8//IDG9vmxrnv06+rqwszM7JXmDgwMRKdOnRQlGwD69euHTZs2ISMjQ+ljVElGRgZ27NiBKVOmCB2FiIhIaVjqqd7NnTsXSUlJ2Lt3r9BRUFJSgvXr1+Pbb7/F7t27UVBQAJlMpvjAkZKSggULFkAmk+HgwYMIDg6GRCIBACQnJyMkJASLFy9GZGRkjbklEgl27tyJefPm4fDhw6isrKxzLk1NzVd6H5cuXYK1tXW1x8RiMSoqKhAVFaX0Mapk+fLlaNWqFfz8/ISOQkREpDQs9VTv7OzsMGrUKMydOxdlZWWC5cjNzYWjoyP09PTw5Zdf4sKFCzAxMYGVlRV69eqFsLAwuLm5YcmSJdi6dSu+/vprzJ07FxcuXIC/vz8m/b/27j8m6vqPA/iT36Ad8UOGGQHJb+THKlvJYWtjBEJrWMkCDlY0Y0n0Y0N0rGI5y5AV2E9B1xpgLDElE13IdChHQzAFjlKRATuC4OTHRYjiwbs/HJ/ka5p9hfsc8HxsN8bd+3Of1+fYuOfn83n/ePllqFQqhIWFITY2Frm5udJ76/V6rFmzBr/++is2btyIvr4+fPzxx3dcm5mZ2bSf/3YcfX19N82/PjUot6Ojw6htTElraysKCwvx7rvvSivKEhERLQQM9WQUeXl56Ovrw7Zt22Sr4f3334dOp0NiYiKsrKyQkZEBAEhMTMTJkyeRkpIyrd//zz//jHPnzmHVqlUoLi5GVFQUnJ2dERkZiYCAAFRUVEhts7OzoVAokJOTAycnJ6SkpOCpp56aleNoaWkBgJuCtouLC4Dr3U+M2cZUTE5OIj09HaGhoUhNTZW7HCIiIqNiqCejuP/++7Ft2zZ88MEHsg1ebGtrg7m5uXQ13M3NDd7e3qitrZXa2NnZAQASEhIAAH5+fjAzM0NlZSVeffVVAMCpU6cghMDY2BgAoL+/H7t27bopxIeEhMzKcUx1FfrfPvtT9SxdutSobUzFRx99hJ9++glFRUUwN+e/NiIiWlj4zUdGk56ejoiICCQkJMgyHWJ4eDiGh4elxbCuXr2Knp4ePPzww1KbW3V/USqVqKmpQXJyMi5cuABPT08p8DY1NeHatWs3Bdw76Urz/3BzcwNwfWahG42OjgIAgoKCjNrGFNTV1eHtt9/Gli1bpv09iYiIFgqGejIaMzMzlJSUQAiB+Ph4aQCqsbz11lt4/vnnkZWVherqamRmZiIsLAxbtmz5122zsrLw1VdfYdeuXVCpVLCxsZFeGxkZAQD09vbOWu038vT0hJOT00376+rqAnB9DIMx28itu7sbzz33HKKjo7Fx40a5yyEiIpIFQz0ZlYuLC77//ns0NjYiJSXlP80Qc7fMzMywbNky5OfnS/2vjx49CoVCcdvtTp8+jby8PKSnp8PW1lZ6fupKvb+/PwD844w4d3p8U+91J9N+WltbS+MAbtTc3AwXFxcEBgYatY2cLl26JI11KCkpYbcbIiJasPgNSEYXEhKCiooKVFRUIC0tzWjBfvv27aipqYFWq4WVlRX0ej1++eWXaYtDTd09GBgYkJ5btGgRAKCiogIGgwHV1dVoamrC0NAQ2traYGdnh+joaBw6dAhff/01AGB8fBxnz56FEAJarfZfF6AaHx8H8He3lhsdO3YMCQkJGBwclJ7btGkTDAaDFLb//PNPFBUVYevWrdJdBGO2kcPg4CCio6MxNjaGH3/8Efb29rLVQkREJDtBJJODBw8KGxsbkZiYKK5duzbr+/vhhx+Era2tADDt4e7uLqqqqsS+ffuEn5+fACDWrVsnmpqapG2Tk5OFubm5cHV1FTt37hRbt24V5ubmIjMzUwghxO+//y5Wr14tAAhfX1/xzDPPCJVKJe655x7x2muvie7u7lvWVVdXJzZs2CAACG9vb/H5559P+zwyMzMFAFFfXz9tu/r6ehERESG2b98uEhMTRUFBwU3vbcw2xtTb2yuCg4OFu7u7uHjxoqy1EBERmYD9ZkIssGU+yaRUV1cjLi4OSqUSZWVlcHJymrV97du3DwaDAZGRkRgYGMDo6Cj0ej00Gg2+++47HD9+/Lbb63Q6ODg4SDPBDA0NwdHRcVqb9vZ2TExMwMfHB52dnXB2dr7rK8gGgwFdXV3w8vL6x9c7Ojrg4eFx264nxmwz25qbm7F27VpYWlri6NGjcHd3l60WIiIiE3GAoZ5k19jYiGeffRZWVlbYv38/QkNDZ3wfFy9ehFKpxG+//QZLS8tpr/X39yMzMxPFxcUzvl+aWWVlZVi/fj0effRR7N27V5ovn4iIaIE7wD71JLuVK1fizJkzWL58OR5//HGpX/pM0mq16O/vR3JyMk6cOAGtVgutVovq6mq8/vrryMnJmfF90syZmJjA5s2bkZSUhKSkJFRVVTHQExER3YBX6slkGAwGbNq0Cfn5+UhLS0Nubu6MDn6sqqrCoUOHUF1djY6ODvj4+CAqKgrvvPMOB1masPb2dqSmpqKxsRFFRUVISkqSuyQiIiJTw+43ZHrKy8ul6SO//PJLxMbGzvg+hBCztjgUzQyDwYCCggLk5OTA29sbxcXFs9I1i4iIaB5g9xsyPevWrcP58+exZs0aPP3004iPj4dOp5vRfTDQm7aWlhYolUpkZ2cjIyMDDQ0NDPRERES3wVBPJsnR0RGFhYWorKxEfX09AgMD8emnn0rzudP8pNPp8Oabb+KRRx6BtbU1mpub8eGHH8La2lru0oiIiEwaQz2ZtJiYGGg0Grz44ovIysqCn58fSkpKjLoSLc2+kZERvPfee/Dy8sLevXvx2WefoaamRlqtl4iIiG6PoZ5MnkKhQF5eHtra2hAREYHU1FSEhobi4MGDcpdGd+nq1avYsWMHvLy8UFBQgM2bN6OtrQ2vvPKKrHPhExERzTX81qQ5w83NDbt374ZGo0FAQADi4uLg7++PHTt24PLly3KXR/+BTqdDbm4uvL29kZWVhbVr1+L8+fPIzs7G4sWL5S6PiIhozuHsNzRnnTlzBvn5+fj222/h4OCAtLQ0bNiwAUuXLpW7NLqFpqYmfPLJJ/jmm2+wePFirF+/HhkZGVi2bJncpREREc1lnNKS5r7e3l588cUXKCwshF6vR3x8PF566SU8+eST7MJhAi5fvoyKigrs3r0bx48fR2BgIN544w2oVCosWrRI7vKIiIjmA4Z6mj+uXLmCPXv2YOfOnWhsbISbmxsSExOhUqkQHBwsd3kLysTEBI4dO4bS0lIcOHAAY2NjiI6ORkZGBiIjIzmlKBER0cxiqKf56dy5cygtLcWePXvQ2dmJ0NBQqFQqxMXFwdvbW+7y5qXJyUk0NDSgvLwcZWVl6OnpwWOPPYakpCS88MILcHFxkbtEIiKi+YqhnuY3IQRqa2tRWlqK8vJyDA0NwdfXF7GxsYiJicETTzzBOdDvwvDwMKqqqlBZWYkjR45Ap9PBy8tLukPi6+srd4lEREQLAUM9LRwGgwFqtRqHDx/G4cOHodFooFAoEBkZiaioKISHhyMgIIBdQ25jfHwcp0+fxokTJ3DkyBGo1WoAgFKpRExMDGJjY7FixQqZqyQiIlpwGOpp4erq6kJlZSUqKytRU1OD0dFRODs7IywsDOHh4VAqlVi5ciVsbGzkLlU2er0earUadXV1OHnyJBoaGjA2NgZXV1dERUUhJiYGUVFRcHBwkLtUIiKihYyhngi4fhX/7NmzUKvVqK2thVqtRm9vL2xtbfHQQw8hJCQEwcHBCAoKQkhICBwdHeUuecZptVpoNBq0tLSgpaUFTU1NaG1txeTkJPz9/REWFobVq1dDqVTCx8dH7nKJiIjobwz1RLfS3t4OtVqNU6dOQaPRoLm5GUNDQwCuL4QVFBSE4OBgLF++HB4eHvDw8MCDDz4IOzs7mSu/taGhIXR2dqKrqwudnZ24cOGCFOSHh4cBAA888IB08rJq1SqEhYVxkCsREZFpY6gn+i+6u7ulgN/S0oLW1lZ0dHRIgRgAXF1d4eHhAU9PT7i5ucHZ2RnOzs5YsmQJnJycpN+dnJxm5ARgZGQEg4ODuHTpEgYGBqTH4OAgBgYG0NHRIYX4P/74Q9ruvvvug5eXF1asWIGQkBDpJGU+3oUgIiKa5xjqiWaCXq+XgvONj56eHilkT13lv5GlpSUUCgUAwNbWVgr5CoUClpaWUrsrV65gbGwMwPUQbzAYAOAf39PCwmLaicPUXQRPT89pP21tbWf8cyAiIiJZMNQTGcvk5OS0K+iDg4MYHR2FXq8HcOvgDkwP/Pb29rCwsICFhQXs7e2hUCikOwBLlizBvffea/yDIyIiIjkx1BMRERERzXEHzOWugIiIiIiI7g5DPRERERHRHMdQT0REREQ0x/0FOBHcn8p6NdsAAAAASUVORK5CYII="
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let n = Neuron::new(2, true);\n",
    "let x = vec![Value::from(1.0), Value::from(-2.0)];\n",
    "let y = n.forward(&x);\n",
    "&y.backward();\n",
    "draw_dot(y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbb2b584-1b81-4574-87a0-987288aba613",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}