diff --git a/.gitignore b/.gitignore
index 28163f7..1e0575e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 dataset
 .ipynb_checkpoints
+.pyc
diff --git a/season3/dezero/__init__.py b/season3/dezero/__init__.py
index 2ef8862..87157f9 100644
--- a/season3/dezero/__init__.py
+++ b/season3/dezero/__init__.py
@@ -1,7 +1,22 @@
-from dezero.core_simple import Variable, Function
-from dezero.core_simple import using_config, no_grad
-from dezero.core_simple import as_array, as_variable
-from dezero.core_simple import setup_variable
+is_simple_core = False
 
+if is_simple_core:
+    from dezero.core_simple import Variable, Function
+    from dezero.core_simple import using_config, no_grad
+    from dezero.core_simple import as_array, as_variable
+    from dezero.core_simple import setup_variable
+
+else:
+    from dezero.core import Variable, Function
+    from dezero.core import using_config, no_grad
+    from dezero.core import as_array, as_variable
+    from dezero.core import setup_variable
+    from dezero.core import Parameter
+    from dezero.layers import Layer
+    from dezero.dataloaders import DataLoader
+    from dezero.core import Config
+    from dezero.core import test_mode
+    from dezero.models import Model
+    from dezero import datasets
 
 setup_variable()
\ No newline at end of file
diff --git a/season3/dezero/__pycache__/__init__.cpython-37.pyc b/season3/dezero/__pycache__/__init__.cpython-37.pyc
index bcd9321..094053a 100644
Binary files a/season3/dezero/__pycache__/__init__.cpython-37.pyc and b/season3/dezero/__pycache__/__init__.cpython-37.pyc differ
diff --git a/season3/dezero/core.py b/season3/dezero/core.py
new file mode 100644
index 0000000..9134334
--- /dev/null
+++ b/season3/dezero/core.py
@@ -0,0 +1,328 @@
+import numpy as np
+import heapq
+import weakref
+import contextlib
+import dezero
+
+
+class Config:
+    enable_backprop = True
+    train = True
+
+
+class Variable:
+    __array_priority__ = 200
+
+    def __init__(self, data, name=None):
+        if data is not None:
+            if not isinstance(data, np.ndarray):
+                raise TypeError(f"{type(data)} dtype is not supported.")
+
+        self.data = data
+        self.name = name
+        self.grad = None
+        self.creator = None
+        self.generation = 0
+
+    def __len__(self):
+        return len(self.data)
+
+    def __repr__(self):
+        if self.data is None:
+            return 'variable(None)'
+        p = str(self.data).replace('\n', '\n' + ' ' * 9)
+        return 'variable(' + p + ')'
+
+    def set_creator(self, func):
+        self.creator = func
+        self.generation = func.generation + 1
+
+    def clear_grad(self):
+        self.grad = None
+
+    def backward(self, use_heap=False, retain_grad=False, create_graph=False):
+        if self.grad is None:
+            self.grad = Variable(np.ones_like(self.data))
+
+        funcs = []
+        seen_sets = set()
+        flag = -1e9
+
+        def add_func(f):
+            if f not in seen_sets:
+                if not use_heap:
+                    funcs.append(f)
+                    seen_sets.add(f)
+                    funcs.sort(key=lambda x: x.generation)
+                else:
+                    heapq.heappush(funcs, (-f.generation, flag, f))
+                    seen_sets.add(f)
+        add_func(self.creator)
+
+        while funcs:
+            if not use_heap:
+                f = funcs.pop()
+            else:
+                f = heapq.heappop(funcs)[2]
+            gys = [y().grad for y in f.outputs]
+
+            with using_config('enable_backprop', create_graph):
+                gxs = f.backward(*gys)
+                if not isinstance(gxs, tuple):
+                    gxs = (gxs,)
+                for x, gx in zip(f.inputs, gxs):
+                    if x.grad is None:
+                        x.grad = gx
+                    else:
+                        x.grad = x.grad + gx
+
+                    if x.creator is not None:
+                        add_func(x.creator)
+                        flag += 1
+
+                # 중간 출력값들의 기울기 삭제
+                if not retain_grad:
+                    for y in f.outputs:
+                        y().grad = None
+
+    def reshape(self, *shape):
+        if len(shape) == 1 and isinstance(shape[0], (tuple, list)):
+            shape = shape[0]
+        return dezero.functions.reshape(self, shape)
+
+    def transpose(self, *axes):
+        if len(axes) == 0:
+            axes = None
+        elif len(axes) == 1:
+            if isinstance(axes[0], (tuple, list)) or axes[0] is None:
+                axes = axes[0]
+        return dezero.functions.transpose(self, axes)
+
+    def sum(self, axis=None, keepdims=False):
+        return dezero.functions.sum(self, axis, keepdims)
+
+    def unchain(self):
+        self.creator = None
+
+    def unchain_backward(self):
+        if self.creator is not None:
+            funcs = [self.creator]
+            while funcs:
+                f = funcs.pop()
+                for x in f.inputs:
+                    if x.creator is not None:
+                        funcs.append(x.creator)
+                        x.unchain()
+
+    @property
+    def T(self):
+        return dezero.functions.transpose(self)
+
+    @property
+    def shape(self):
+        return self.data.shape
+
+    @property
+    def ndim(self):
+        return self.data.ndim
+
+    @property
+    def size(self):
+        return self.data.size
+
+    @property
+    def dtype(self):
+        return self.data.dtype
+
+
+class Parameter(Variable):
+    pass
+
+
+class Function:
+    def __call__(self, *inputs):
+        inputs = [as_variable(x) for x in inputs]     # nd-array만 들어올 경우, Variable 클래스로 변환
+        xs = [x.data for x in inputs]
+        ys = self.forward(*xs)
+        if not isinstance(ys, tuple):
+            ys = (ys,)
+        outputs = [Variable(as_array(y)) for y in ys]
+
+        # 역전파 활성모드
+        if Config.enable_backprop:
+            self.generation = max([x.generation for x in inputs])
+            for output in outputs:
+                output.set_creator(self)
+            self.inputs = inputs
+            self.outputs = [weakref.ref(output) for output in outputs]
+
+        return outputs if len(outputs) > 1 else outputs[0]
+
+    def forward(self, xs):
+        raise NotImplementedError("This method should be run outside of Function class.")
+
+    def backward(self, gy):
+        raise NotImplementedError("This method should be run outside of Function class.")
+
+
+class Add(Function):
+    def forward(self, x0, x1):
+        self.x0_shape, self.x1_shape = x0.shape, x1.shape
+        return x0 + x1
+
+    def backward(self, gy):
+        gx0, gx1 = gy, gy
+        if self.x0_shape != self.x1_shape:
+            gx0 = dezero.functions.sum_to(gx0, self.x0_shape)
+            gx1 = dezero.functions.sum_to(gx1, self.x1_shape)
+        return gx0, gx1
+
+
+class Mul(Function):
+    def forward(self, x0, x1):
+        self.x0_shape, self.x1_shape = x0.shape, x1.shape
+        return x0 * x1
+
+    def backward(self, gy):
+        x0, x1 = self.inputs
+        gx0 = x1 * gy
+        gx1 = x0 * gy
+        if self.x0_shape != self.x1_shape:
+            gx0 = dezero.functions.sum_to(gx0, self.x0_shape)
+            gx1 = dezero.functions.sum_to(gx1, self.x1_shape)
+        return gx0, gx1
+
+
+class Neg(Function):
+    def forward(self, x):
+        return -x
+
+    def backward(self, gy):
+        return -gy
+
+
+class Sub(Function):
+    def forward(self, x0, x1):
+        self.x0_shape, self.x1_shape = x0.shape, x1.shape
+        return x0 - x1
+
+    def backward(self, gy):
+        gx0, gx1 = gy, -gy
+        if self.x0_shape != self.x1_shape:
+            gx0 = dezero.functions.sum_to(gx0, self.x0_shape)
+            gx1 = dezero.functions.sum_to(gx1, self.x1_shape)
+        return gx0, gx1
+
+
+class Div(Function):
+    def forward(self, x0, x1):
+        self.x0_shape, self.x1_shape = x0.shape, x1.shape
+        return x0 / x1
+
+    def backward(self, gy):
+        x0, x1 = self.inputs
+        gx0 = gy / x1
+        gx1 = gy * (-x0 / x1 ** 2)
+        if self.x0_shape != self.x1_shape:
+            gx0 = dezero.functions.sum_to(gx0, self.x0_shape)
+            gx1 = dezero.functions.sum_to(gx1, self.x1_shape)
+        return gx0, gx1
+
+
+class Pow(Function):
+    def __init__(self, power):
+        self.power = power
+
+    def forward(self, x):
+        return x ** self.power
+
+    def backward(self, gy):
+        c = self.power
+        x, = self.inputs
+        gx = c * (x ** (c - 1)) * gy
+        return gx
+
+
+def add(x0, x1):
+    x1 = as_array(x1)
+    return Add()(x0, x1)
+
+
+def mul(x0, x1):
+    x1 = as_array(x1)
+    return Mul()(x0, x1)
+
+
+def neg(x):
+    return Neg()(x)
+
+
+def sub(x0, x1):
+    x1 = as_array(x1)
+    return Sub()(x0, x1)
+
+
+def rsub(x0, x1):
+    x1 = as_array(x1)
+    return Sub()(x1, x0)
+
+
+def div(x0, x1):
+    x1 = as_array(x1)
+    return Div()(x0, x1)
+
+
+def rdiv(x0, x1):
+    x1 = as_array(x1)
+    return Div()(x1, x0)
+
+
+def pow(x, power):
+    return Pow(power)(x)
+
+
+@contextlib.contextmanager
+def using_config(name: str, value: bool):
+    old_value = getattr(Config, name)
+    setattr(Config, name, value)
+    try:
+        yield
+    finally:
+        setattr(Config, name, old_value)
+
+
+def no_grad():
+    return using_config('enable_backprop', False)
+
+
+def test_mode():
+    return using_config('train', False)
+
+
+def as_array(x):
+    if np.isscalar(x):
+        return np.array(x)
+    return x
+
+
+def as_variable(obj):
+    if isinstance(obj, Variable):
+        return obj
+    return Variable(obj)
+
+
+# 오버라이딩 적용 함수
+def setup_variable():
+    Variable.__add__ = add
+    Variable.__radd__ = add
+    Variable.__mul__ = mul
+    Variable.__rmul__ = mul
+    Variable.__neg__ = neg
+    Variable.__sub__ = sub
+    Variable.__rsub__ = rsub
+    Variable.__truediv__ = div
+    Variable.__rtruediv__ = rdiv
+    Variable.__pow__ = pow
+    Variable.__getitem__ = dezero.functions.get_item   # avoid 순환 참조
+    Variable.max = dezero.functions.max
+    Variable.min = dezero.functions.min
\ No newline at end of file
diff --git a/season3/dezero/core_simple.py b/season3/dezero/core_simple.py
index 8e9b458..d8dc424 100644
--- a/season3/dezero/core_simple.py
+++ b/season3/dezero/core_simple.py
@@ -35,7 +35,7 @@ def backward(self, retain_grad=False, use_heap=False):
 
         funcs = []
         seen_sets = set()
-        flag = 0
+        flag = -1e9
 
         def add_func(f):
             if f not in seen_sets:
@@ -66,7 +66,6 @@ def add_func(f):
                 if x.creator is not None:
                     add_func(x.creator)
                     flag += 1
-            flag = 0
 
             # 중간 출력값들의 기울기 삭제
             if not retain_grad:
diff --git a/season3/dezero/cuda.py b/season3/dezero/cuda.py
new file mode 100644
index 0000000..863fd5a
--- /dev/null
+++ b/season3/dezero/cuda.py
@@ -0,0 +1,60 @@
+
+import numpy as np
+gpu_enable = True
+try:
+    import cupy as cp
+    cupy = cp
+except ImportError:
+    gpu_enable = False
+from dezero import Variable
+
+
+def get_array_module(x):
+    """Returns the array module for `x`.
+    Args:
+        x (dezero.Variable or numpy.ndarray or cupy.ndarray): Values to
+            determine whether NumPy or CuPy should be used.
+    Returns:
+        module: `cupy` or `numpy` is returned based on the argument.
+    """
+    if isinstance(x, Variable):
+        x = x.data
+
+    if not gpu_enable:
+        return np
+    xp = cp.get_array_module(x)
+    return xp
+
+
+def as_numpy(x):
+    """Convert to `numpy.ndarray`.
+    Args:
+        x (`numpy.ndarray` or `cupy.ndarray`): Arbitrary object that can be
+            converted to `numpy.ndarray`.
+    Returns:
+        `numpy.ndarray`: Converted array.
+    """
+    if isinstance(x, Variable):
+        x = x.data
+
+    if np.isscalar(x):
+        return np.array(x)
+    elif isinstance(x, np.ndarray):
+        return x
+    return cp.asnumpy(x)
+
+
+def as_cupy(x):
+    """Convert to `cupy.ndarray`.
+    Args:
+        x (`numpy.ndarray` or `cupy.ndarray`): Arbitrary object that can be
+            converted to `cupy.ndarray`.
+    Returns:
+        `cupy.ndarray`: Converted array.
+    """
+    if isinstance(x, Variable):
+        x = x.data
+
+    if not gpu_enable:
+        raise Exception('CuPy cannot be loaded. Install CuPy!')
+    return cp.asarray(x)
\ No newline at end of file
diff --git a/season3/dezero/dataloaders.py b/season3/dezero/dataloaders.py
new file mode 100644
index 0000000..f7c9239
--- /dev/null
+++ b/season3/dezero/dataloaders.py
@@ -0,0 +1,60 @@
+import math
+import numpy as np
+
+
+class DataLoader:
+    def __init__(self, dataset, batch_size, shuffle=True):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+        self.data_size = len(dataset)
+        self.max_iter = math.ceil(self.data_size / self.batch_size)
+
+        self.reset()  # init iteration count
+
+    def reset(self):
+        self.iteration = 0
+        if self.shuffle:
+            self.index = np.random.permutation(self.data_size)
+        else:
+            self.index = np.arange(self.data_size)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.iteration >= self.max_iter:
+            self.reset()
+            raise StopIteration("One epoch is finished. Iteration count is initialized.")
+
+        i, batch_size = self.iteration, self.batch_size
+        batch_index = self.index[i * batch_size: (i+1) * batch_size]
+        batch_x, batch_t = self.dataset[batch_index]
+
+        self.iteration += 1
+        return batch_x, batch_t
+
+    # checking for example batch data
+    def next(self):
+        return self.__next__()
+
+
+class SeqDataLoader(DataLoader):
+    def __init__(self, dataset, batch_size):
+        super(SeqDataLoader, self).__init__(dataset, batch_size, shuffle=False)
+
+    def __next__(self):
+        if self.iteration >= self.max_iter:
+            self.reset()
+            raise StopIteration
+
+        jump = self.data_size // self.batch_size
+        batch_index = [(i * jump + self.iteration) % self.data_size for i in range(self.batch_size)]
+        batch = [self.dataset[i] for i in batch_index]
+
+        x = np.array([ex[0] for ex in batch])
+        t = np.array([ex[1] for ex in batch])
+
+        self.iteration += 1
+        return x, t
+
diff --git a/season3/dezero/datasets.py b/season3/dezero/datasets.py
new file mode 100644
index 0000000..d3a4957
--- /dev/null
+++ b/season3/dezero/datasets.py
@@ -0,0 +1,109 @@
+import numpy as np
+from dezero.utils import get_file
+
+class Dataset:
+    def __init__(self, train=True, transform=None, target_transform=None):
+        self.train = train
+        self.transform = transform
+        self.target_transform = target_transform
+        if self.transform is None:
+            self.transform = lambda x: x  # identity function
+        if self.target_transform is None:
+            self.target_transform = lambda x: x
+        self.data = None
+        self.label = None
+        self.prepare()  # 자식 클래스에서 구현
+
+    def __getitem__(self, index):
+        # case when index is both integer and slicing
+        if self.label is None:
+            return self.transform(self.data[index]), None
+        else:
+            return self.transform(self.data[index]), \
+                   self.target_transform(self.label[index])
+
+    def __len__(self):
+        return len(self.data)
+
+    def prepare(self):
+        raise NotImplementedError(f"This method should be run outside of Dataset class.")
+
+
+class Spiral(Dataset):
+    def __init__(self, **kwargs):
+        super(Spiral, self).__init__(**kwargs)  # Python 2.x ver grammar
+
+    def prepare(self):
+        self.data, self.label = get_spiral(train=self.train)
+
+
+class BigData(Dataset):
+    # 100만개 데이터가 존재한다고 가정하고 정의한 예시 클래스
+    def __getitem__(self, index):
+        x = np.load("data/{}.npy".format(index))
+        t = np.load("data/{}.npy".format(index))
+        return x, t
+
+    def __len__(self):
+        return int(1e6)
+
+
+def get_spiral(train=True):
+    seed = 1984 if train else 2020
+    np.random.seed(seed=seed)
+
+    num_data, num_class, input_dim = 100, 3, 2
+    data_size = num_class * num_data
+    x = np.zeros((data_size, input_dim), dtype=np.float32)
+    t = np.zeros(data_size, dtype=np.int)
+
+    for j in range(num_class):
+        for i in range(num_data):
+            rate = i / num_data
+            radius = 1.0 * rate
+            theta = j * 4.0 + 4.0 * rate + np.random.randn() * 0.2
+            ix = num_data * j + i
+            x[ix] = np.array([radius * np.sin(theta),
+                              radius * np.cos(theta)]).flatten()
+            t[ix] = j
+    # Shuffle
+    indices = np.random.permutation(num_data * num_class)
+    x = x[indices]
+    t = t[indices]
+    return x, t
+
+
+class ImageNet(Dataset):
+    def __init__(self):
+        NotImplemented
+
+    @staticmethod
+    def labels():
+        url = 'https://gist.githubusercontent.com/yrevar/942d3a0ac09ec9e5eb3a/raw/238f720ff059c1f82f368259d1ca4ffa5dd8f9f5/imagenet1000_clsidx_to_labels.txt'
+        path = get_file(url)
+        with open(path, 'r') as f:
+            labels = eval(f.read())
+        return labels
+
+
+class SinCurve(Dataset):
+    def prepare(self):
+        num_data = 1000
+        dtype = np.float64
+
+        x = np.linspace(0, 2 * np.pi, num_data)
+        noise_range = (-0.05, 0.05)
+        noise = np.random.uniform(noise_range[0], noise_range[1], size=x.shape)
+        if self.train:
+            y = np.sin(x) + noise
+        else:
+            y = np.cos(x)
+        y = y.astype(dtype)
+        self.data = y[:-1][:, np.newaxis]
+        self.label = y[1:][:, np.newaxis]
+
+
+class DummyData(Dataset):
+    def prepare(self):
+        self.data = [np.array([0,1,2]), np.array([3,4,5]), np.array([6,7,8])]
+        self.label = [np.array([3,4]), np.array([6,7]), np.array([9, 10])]
\ No newline at end of file
diff --git a/season3/dezero/functions.py b/season3/dezero/functions.py
new file mode 100644
index 0000000..cbc7c4f
--- /dev/null
+++ b/season3/dezero/functions.py
@@ -0,0 +1,471 @@
+import numpy as np
+import dezero
+from dezero.core import Function
+from dezero.core import as_variable
+from dezero.core import as_array
+from dezero import utils
+
+
+
+class Sin(Function):
+    def forward(self, x):
+        y = np.sin(x)
+        return y
+
+    def backward(self, gy):
+        x, = self.inputs
+        gx = gy * cos(x)
+        return gx
+
+
+class Cos(Function):
+    def forward(self, x):
+        y = np.cos(x)
+        return y
+
+    def backward(self, gy):
+        x, = self.inputs
+        gy = gy * -sin(x)
+        return gy
+
+
+class Tanh(Function):
+    def forward(self, x):
+        y = np.tanh(x)
+        return y
+
+    def backward(self, gy):
+        y = self.outputs[0]()  # 캐싱된 출력은 현재 약한 참조 중!
+        gx = 1 - y ** 2
+        return gx
+
+
+class Reshape(Function):
+    def __init__(self, shape):
+        self.shape = shape
+
+    def forward(self, x):
+        self.x_shape = x.shape
+        y = x.reshape(self.shape)
+        return y
+
+    def backward(self, gy):
+        return reshape(gy, self.x_shape)
+
+
+class Transpose(Function):
+    def __init__(self, axes=None):
+        self.axes = axes
+
+    def forward(self, x):
+        y = x.transpose(self.axes)
+        return y
+
+    def backward(self, gy):
+        if self.axes is None:
+            return transpose(gy)
+
+        axes_len = len(self.axes)
+        inv_axes = tuple(np.argsort([ax % axes_len for ax in self.axes]))
+        return transpose(gy, inv_axes)
+
+
+class BroadcastTo(Function):
+    def __init__(self, shape):
+        self.shape = shape
+
+    def forward(self, x):
+        self.x_shape = x.shape
+        y = np.broadcast_to(x, self.shape)
+        return y
+
+    def backward(self, gy):
+        gx = sum_to(gy, self.x_shape)
+        return gx
+
+
+class SumTo(Function):
+    def __init__(self, shape):
+        self.shape = shape
+
+    def forward(self, x):
+        self.x_shape = x.shape
+        y = utils.sum_to(x, self.shape)
+        return y
+
+    def backward(self, gy):
+        gx = broadcast_to(gy, self.x_shape)
+        return gx
+
+
+class Sum(Function):
+    def __init__(self, axis, keepdims):
+        self.axis = axis
+        self.keepdims = keepdims
+
+    def forward(self, x):
+        self.x_shape = x.shape
+        y = x.sum(axis=self.axis, keepdims=self.keepdims)
+        return y
+
+    def backward(self, gy):
+        gy = utils.reshape_sum_backward(gy, self.x_shape, self.axis, self.keepdims)
+        gx = broadcast_to(gy, self.x_shape)
+        return gx
+
+
+class MatMul(Function):
+    def forward(self, x, W):
+        y = x.dot(W)
+        return y
+
+    def backward(self, gy):
+        x, W = self.inputs
+        gx = matmul(gy, W.T)
+        gw = matmul(x.T, gy)
+        return gx, gw
+
+
+class MeanSquaredError(Function):
+    def forward(self, x0, x1):
+        diff = x0 - x1
+        y = (diff ** 2).sum() / len(diff)
+        return y
+
+    def backward(self, gy):
+        x0, x1 = self.inputs
+        diff = x0 - x1
+        gx0 = 2 * diff * (gy / len(diff))
+        gx1 = -gx0
+        return gx0, gx1
+
+
+class Linear(Function):
+    def forward(self, x, W, b):
+        y = x.dot(W)
+        if b is not None:
+            y += b
+        return y
+
+    def backward(self, gy):
+        x, W, b = self.inputs
+
+        gb = None if b.data is None else sum_to(gy, b.shape)
+        gx = matmul(gy, W.T)
+        gW = matmul(x.T, gy)
+        return gx, gW, gb
+
+
+class Sigmoid(Function):
+    def forward(self, x):
+        y = 1 / (1 + np.exp(-x))
+        return y
+
+    def backward(self, gy):
+        y = self.outputs[0]()
+        gx = gy * y * (1 - y)
+        return gx
+
+
+class Exp(Function):
+    def forward(self, x):
+        y = np.exp(x)
+        return y
+
+    def backward(self, gy):
+        y = self.outputs[0]()
+        gx = gy * y
+        return gx
+
+
+class Relu(Function):
+    def forward(self, x):
+        y = np.maximum(x, 0.0)
+        return y
+
+    def backward(self, gy):
+        x, = self.inputs
+        mask = x.data > 0
+        gx = gy * mask
+        return gx
+
+
+class GetItem(Function):
+    def __init__(self, slices):
+        self.slices = slices
+
+    def forward(self, x):
+        y = x[self.slices]
+        return y
+
+    def backward(self, gy):
+        x, = self.inputs
+        f = GetItemGrad(self.slices, x.shape)
+        gx = f(gy)
+        return gx
+
+
+class GetItemGrad(Function):
+    def __init__(self, slices, x_shape):
+        self.slices = slices
+        self.x_shape = x_shape
+
+    def forward(self, gy):
+        gx = np.zeros_like(self.x_shape)
+        np.add.at(gx, self.slices, gy)
+        return gx
+
+    def backward(self, ggx):
+        return get_item(ggx, self.slices)
+
+
+class Clip(Function):
+    def __init__(self, x_min, x_max):
+        self.x_min = x_min
+        self.x_max = x_max
+
+    def forward(self, x):
+        y = np.clip(x, self.x_min, self.x_max)
+        return y
+
+    def backward(self, gy):
+        x, = self.inputs
+        mask = (x.data >= self.x_min) * (x.data <= self.x_max)  # 곱(*) 연산으로 and 논리 연산 수행
+        gx = gy * mask   # clipping 된 값은은 기울기가 0이 되도록
+        return gx
+
+
+class Log(Function):
+    def forward(self, x):
+        y = np.log(x)
+        return y
+
+    def backward(self, gy):
+        x, = self.inputs
+        gx = gy / x
+        return gx
+
+
+class Softmax(Function):
+    def __init__(self, axis=1):
+        self.axis = axis
+
+    def forward(self, x):
+        y = x - x.max(axis=self.axis, keepdims=True)
+        y = np.exp(y)
+        y /= y.sum(axis=self.axis, keepdims=True)
+        return y
+
+    def backward(self, gy):
+        # 수식으로 아직 이해 X
+        y = self.outputs[0]()
+        gx = y * gy
+        sumdx = gx.sum(axis=self.axis, keepdims=True)
+        gx -= y * sumdx
+        return gx
+
+
+class SoftmaxCrossEntropy(Function):
+    def forward(self, x, t):
+        N = x.shape[0]
+        log_z = utils.logsumexp(x, axis=1)
+        log_p = x - log_z
+        log_p = log_p[np.arange(N), t.ravel()]
+        y = -log_p.sum() / np.float32(N)   # average CEE
+        return y
+
+    def backward(self, gy):
+        x, t = self.inputs
+        N, CLASS_N = x.shape
+
+        gy *= 1 / N
+        y = softmax(x)
+        t_one_hot = np.eye(CLASS_N, dtype=t.dtype)[t.data]  # 레이블 값을 인덱스로하는 원소값이 1인 행 벡터들만 슬라이싱
+        y = (y - t_one_hot) * gy
+        return y
+
+
+def sin(x):
+    return Sin()(x)
+
+
+def cos(x):
+    return Cos()(x)
+
+
+def tanh(x):
+    return Tanh()(x)
+
+
+def reshape(x, shape):
+    if x.shape == shape:
+        return as_variable(x)
+    return Reshape(shape)(x)
+
+
+def transpose(x, axes=None):
+    return Transpose(axes)(x)
+
+
+def broadcast_to(x, shape):
+    return BroadcastTo(shape)(x)
+
+
+def sum_to(x, shape):
+    return SumTo(shape)(x)
+
+
+def sum(x, axis=None, keepdims=False):
+    return Sum(axis, keepdims)(x)
+
+
+def matmul(x, W):
+    return MatMul()(x, W)
+
+
+def mean_squared_error(x0, x1):
+    return MeanSquaredError()(x0, x1)
+
+
+def mean_squared_error_oom(x0, x1):
+    x0, x1 = as_variable(x0), as_variable(x1)
+    diff = x0 - x1
+    return sum(diff ** 2) / len(diff)
+
+
+def linear(x, W, b=None):
+    return Linear()(x, W, b)
+
+
+def linear_simple(x, W, b=None):
+    t = matmul(x, W)
+    if b is None:
+        return t
+    y = t + b
+    t.data = None  # t가 참조하는 데이터를 메모리에서 제거
+    return y
+
+
+def sigmoid(x):
+    return Sigmoid()(x)
+
+
+def sigmoid_simple(x):
+    x = as_variable(x)
+    y = 1 / (1 + exp(-x))
+    return y
+
+
+def exp(x):
+    return Exp()(x)
+
+
+def relu(x):
+    return Relu()(x)
+
+
+def get_item(x, slices):
+    return GetItem(slices)(x)
+
+
+def clip(x, x_min, x_max):
+    return Clip(x_min, x_max)(x)
+
+
+def log(x):
+    return Log()(x)
+
+
+def softmax_simple(x, axis=1):
+    if not isinstance(x, np.ndarray):
+        max_x = x.data.max(axis=axis)   # batch도 고려
+    else:
+        max_x = x.max(axis=axis)
+    x = as_variable(x - max_x)
+    y = exp(x)
+    sum_y = sum(y, axis=axis, keepdims=True)
+    return y / sum_y
+
+
+def softmax(x, axis=1):
+    return Softmax(axis)(x)
+
+
+def softmax_cross_entropy_simple(x, t):
+    # t는 레이블 인코딩 상태의 Dezero 인스턴스 객체
+    x, t = as_variable(x), as_variable(t)
+    N = x.shape[0]
+
+    p = softmax(x)
+    p = clip(p, 1e-15, 1.0)
+    log_p = log(p)
+    tlog_p = log_p[np.arange(N), t.data]  # 로직 이해 -> 블로그/책 필기 참조
+    y = -1 * sum(tlog_p) / N
+    return y
+
+
+def softmax_cross_entropy(x, t):
+    return SoftmaxCrossEntropy()(x, t)
+
+
+def accuracy(y, t):
+    y, t = as_variable(y), as_variable(t)
+
+    pred = y.data.argmax(axis=1).reshape(t.shape)
+    result = (pred == t.data)
+    acc = result.mean()
+    return as_variable(as_array(acc))
+
+
+def dropout(x, dropout_ratio=0.5):
+    x = as_variable(x)
+
+    if dezero.Config.train:
+        scale = 1 - dropout_ratio
+        mask = np.random.rand(*x.shape) > dropout_ratio
+        y = x * mask / scale
+        return y
+    else:
+        return x
+
+
+class Max(Function):
+    def __init__(self, axis=None, keepdims=True):
+        self.axis = axis
+        self.keepdims = keepdims
+
+    def forward(self, x):
+        y = x.max(axis=self.axis, keepdims=self.keepdims)
+        return y
+
+    def backward(self, gy):
+        x = self.inputs[0]
+        y = self.outputs[0]()
+
+        shape = utils.max_backward_shape(x, self.axis)
+        gy = reshape(gy, shape)
+        y = reshape(y, shape)
+        cond = (x.data == y.data)
+        gy = broadcast_to(gy, cond.shape)
+        return gy * cond
+
+
+class Min(Max):
+    def forward(self, x):
+        y = x.min(axis=self.axis, keepdims=self.keepdims)
+        return y
+
+
+def max(x, axis=None, keepdims=False):
+    return Max(axis, keepdims)(x)
+
+
+def min(x, axis=None, keepdims=False):
+    return Min(axis, keepdims)(x)
+
+
+from dezero.functions_conv import im2col
+from dezero.functions_conv import conv2d_simple
+from dezero.functions_conv import conv2d
+from dezero.functions_conv import pooling_simple
+from dezero.functions_conv import pooling
\ No newline at end of file
diff --git a/season3/dezero/functions_conv.py b/season3/dezero/functions_conv.py
new file mode 100644
index 0000000..83059d9
--- /dev/null
+++ b/season3/dezero/functions_conv.py
@@ -0,0 +1,367 @@
+import numpy as np
+from dezero import cuda
+from dezero import Function
+from dezero import as_variable
+from dezero.functions import linear
+from dezero.utils import pair, get_conv_outsize
+
+
+class Conv2d(Function):
+    def __init__(self, stride=1, pad=0):
+        super().__init__()
+        self.stride = pair(stride)
+        self.pad = pair(pad)
+
+    def forward(self, x, W, b):
+        xp = cuda.get_array_module(x)
+
+        KH, KW = W.shape[2:]
+        col = im2col_array(x, (KH, KW), self.stride, self.pad, to_matrix=False)
+
+        y = xp.tensordot(col, W, ((1, 2, 3), (1, 2, 3)))
+        if b is not None:
+            y += b
+        y = xp.rollaxis(y, 3, 1)
+        # y = np.transpose(y, (0, 3, 1, 2))
+        return y
+
+    def backward(self, gy):
+        x, W, b = self.inputs
+        # ==== gx ====
+        gx = deconv2d(gy, W, b=None, stride=self.stride, pad=self.pad,
+                      outsize=(x.shape[2], x.shape[3]))
+        # ==== gW ====
+        gW = Conv2DGradW(self)(x, gy)
+        # ==== gb ====
+        gb = None
+        if b.data is not None:
+            gb = gy.sum(axis=(0, 2, 3))
+        return gx, gW, gb
+
+
+def conv2d(x, W, b=None, stride=1, pad=0):
+    return Conv2d(stride, pad)(x, W, b)
+
+
+class Deconv2d(Function):
+    def __init__(self, stride=1, pad=0, outsize=None):
+        super().__init__()
+        self.stride = pair(stride)
+        self.pad = pair(pad)
+        self.outsize = outsize
+
+    def forward(self, x, W, b):
+        xp = cuda.get_array_module(x)
+
+        Weight = W
+        SH, SW = self.stride
+        PH, PW = self.pad
+        C, OC, KH, KW = Weight.shape
+        N, C, H, W = x.shape
+        if self.outsize is None:
+            out_h = get_deconv_outsize(H, KH, SH, PH)
+            out_w = get_deconv_outsize(W, KW, SW, PW)
+        else:
+            out_h, out_w = pair(self.outsize)
+        img_shape = (N, OC, out_h, out_w)
+
+        gcol = xp.tensordot(Weight, x, (0, 1))
+        gcol = xp.rollaxis(gcol, 3)
+        y = col2im_array(gcol, img_shape, (KH, KW), self.stride, self.pad,
+                         to_matrix=False)
+        # b, k, h, w
+        if b is not None:
+            self.no_bias = True
+            y += b.reshape((1, b.size, 1, 1))
+        return y
+
+    def backward(self, gy):
+        x, W, b = self.inputs
+
+        # ==== gx ====
+        gx = conv2d(gy, W, b=None, stride=self.stride, pad=self.pad)
+        # ==== gW ====
+        f = Conv2DGradW(self)
+        gW = f(gy, x)
+        # ==== gb ====
+        gb = None
+        if b.data is not None:
+            gb = gy.sum(axis=(0, 2, 3))
+        return gx, gW, gb
+
+
+def deconv2d(x, W, b=None, stride=1, pad=0, outsize=None):
+    return Deconv2d(stride, pad, outsize)(x, W, b)
+
+
+class Conv2DGradW(Function):
+    def __init__(self, conv2d):
+        W = conv2d.inputs[1]
+        kh, kw = W.shape[2:]
+        self.kernel_size = (kh, kw)
+        self.stride = conv2d.stride
+        self.pad = conv2d.pad
+
+    def forward(self, x, gy):
+        xp = cuda.get_array_module(x)
+
+        col = im2col_array(x, self.kernel_size, self.stride, self.pad,
+                           to_matrix=False)
+        gW = xp.tensordot(gy, col, ((0, 2, 3), (0, 4, 5)))
+        return gW
+
+    def backward(self, gys):
+        x, gy = self.inputs
+        gW, = self.outputs
+
+        xh, xw = x.shape[2:]
+        gx = deconv2d(gy, gW, stride=self.stride, pad=self.pad,
+                      outsize=(xh, xw))
+        ggy = conv2d(x, gW, stride=self.stride, pad=self.pad)
+        return gx, ggy
+
+
+# =============================================================================
+#  pooling(max-pooling) / average_pooling
+# =============================================================================
+class Pooling(Function):
+    def __init__(self, kernel_size, stride=1, pad=0):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.pad = pad
+
+    def forward(self, x):
+        col = im2col_array(x, self.kernel_size, self.stride, self.pad,
+                           to_matrix=False)
+
+        N, C, KH, KW, OH, OW = col.shape
+        col = col.reshape(N, C, KH * KW, OH, OW)
+        self.indexes = col.argmax(axis=2)
+        y = col.max(axis=2)
+        return y
+
+    def backward(self, gy):
+        return Pooling2DGrad(self)(gy)
+
+
+class Pooling2DGrad(Function):
+    def __init__(self, mpool2d):
+        self.mpool2d = mpool2d
+        self.kernel_size = mpool2d.kernel_size
+        self.stride = mpool2d.stride
+        self.pad = mpool2d.pad
+        self.input_shape = mpool2d.inputs[0].shape
+        self.dtype = mpool2d.inputs[0].dtype
+        self.indexes = mpool2d.indexes
+
+    def forward(self, gy):
+        xp = cuda.get_array_module(gy)
+
+        N, C, OH, OW = gy.shape
+        N, C, H, W = self.input_shape
+        KH, KW = pair(self.kernel_size)
+
+        gcol = xp.zeros((N * C * OH * OW * KH * KW), dtype=self.dtype)
+
+        indexes = (self.indexes.ravel()
+                   + xp.arange(0, self.indexes.size * KH * KW, KH * KW))
+
+        gcol[indexes] = gy.ravel()
+        gcol = gcol.reshape(N, C, OH, OW, KH, KW)
+        gcol = xp.swapaxes(gcol, 2, 4)
+        gcol = xp.swapaxes(gcol, 3, 5)
+
+        gx = col2im_array(gcol, (N, C, H, W), self.kernel_size, self.stride,
+                          self.pad, to_matrix=False)
+        return gx
+
+    def backward(self, ggx):
+        f = Pooling2DWithIndexes(self.mpool2d)
+        return f(ggx)
+
+
+class Pooling2DWithIndexes(Function):
+    def __init__(self, mpool2d):
+        self.kernel_size = mpool2d.kernel_size
+        self.stride = mpool2d.stride
+        self.pad = mpool2d.pad
+        self.input_shpae = mpool2d.inputs[0].shape
+        self.dtype = mpool2d.inputs[0].dtype
+        self.indexes = mpool2d.indexes
+
+    def forward(self, x):
+        col = im2col_array(x, self.kernel_size, self.stride, self.pad,
+                           to_matrix=False)
+        N, C, KH, KW, OH, OW = col.shape
+        col = col.reshape(N, C, KH * KW, OH, OW)
+        col = col.transpose(0, 1, 3, 4, 2).reshape(-1, KH * KW)
+        indexes = self.indexes.ravel()
+        col = col[np.arange(len(indexes)), indexes]
+        return col.reshape(N, C, OH, OW)
+
+
+def pooling(x, kernel_size, stride=1, pad=0):
+    return Pooling(kernel_size, stride, pad)(x)
+
+
+class AveragePooling(Function):
+    def __init__(self, kernel_size, stride=1, pad=0):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.pad = pad
+        self.input_shape = None
+
+    def forward(self, x):
+        self.input_shape = x.shape
+        col = im2col_array(x, self.kernel_size, self.stride, self.pad,
+                           to_matrix=False)
+        y = col.mean(axis=(2, 3))
+        return y
+
+    def backward(self, gy):
+        # TODO(Koki): This is simple implementation
+        N, C, OH, OW = gy.shape
+        KW, KH = pair(self.kernel_size)
+        gy /= (KW * KH)
+        gcol = broadcast_to(gy.reshape(-1), (KH, KW, N * C * OH * OW))
+        gcol = gcol.reshape(KH, KW, N, C, OH, OW).transpose(2, 3, 0, 1, 4, 5)
+        gx = col2im(gcol, self.input_shape, self.kernel_size, self.stride,
+                    self.pad, to_matrix=False)
+        return gx
+
+
+def average_pooling(x, kernel_size, stride=1, pad=0):
+    return AveragePooling(kernel_size, stride, pad)(x)
+
+
+def conv2d_simple(x, W, b=None, stride=1, pad=0):
+    x, W = as_variable(x), as_variable(W)
+
+    Weight = W
+    N, C, H, W = x.shape
+    OC, C, KH, KW = Weight.shape
+    SH, SW = pair(stride)
+    PH, PW = pair(pad)
+    OH = get_conv_outsize(H, KH, PH, SH)
+    OW = get_conv_outsize(W, KW, PW, SW)
+
+    # convert image to 2d-array(row vector)
+    col = im2col(x, (KH, KW), stride, pad, to_matrix=True)
+    # convert filter(all kernel) to 2d-array(column-vector)
+    Weight = Weight.reshape(OC, -1).transpose()
+    t = linear(col, Weight, b)
+    y = t.reshape(N, OH, OW, OC).transpose(0, 3, 1, 2)
+    return y
+
+
+def pooling_simple(x, kernel_size, stride=1, pad=0):
+    x = as_variable(x)
+
+    N, C, H, W = x.shape
+    KH, KW = pair(kernel_size)
+    SH, SW = pair(stride)
+    PH, PW = pair(pad)
+    OH = get_conv_outsize(H, KH, PH, SH)
+    OW = get_conv_outsize(W, KW, PW, SW)
+
+    col = im2col(x, kernel_size, stride, pad, to_matrix=True)
+    col = col.reshape(-1, KH * KW)
+    y = col.max(axis=1)
+    y = y.reshape(N, OH, OW, C).transpose(0, 3, 1, 2)
+    return y
+
+
+class Im2Col(Function):
+    def __init__(self, kernel_size, stride, pad, to_matrix):
+        super(Im2Col, self).__init__()
+        self.input_shape = None
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.pad = pad
+        self.to_matrix = to_matrix
+
+    def forward(self, x):
+        self.input_shape = x.shape
+        y = im2col_array(x, self.kernel_size, self.stride, self.pad, self.to_matrix)
+        return y
+
+    def backward(self, gy):
+        gx = col2im(gy, self.input_shape, self.kernel_size, self.stride, self.pad, self.to_matrix)
+        return gx
+
+
+def im2col(x ,kernel_size, stride=1, pad=0, to_matrix=True):
+    y = Im2Col(kernel_size, stride, pad, to_matrix)(x)
+    return y
+
+
+class Col2Im(Function):
+    def __init__(self, input_shape, kernel_size, stride, pad, to_matrix):
+        super(Col2Im, self).__init__()
+        self.input_shape = input_shape
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.pad = pad
+        self.to_matrix = to_matrix
+
+    def forward(self, x):
+        y = col2im_array(x, self.input_shape, self.kernel_size, self.stride, self.pad, self.to_matrix)
+        return y
+
+    def backward(self, gy):
+        gx = im2col(gy, self.kernel_size, self.stride, self.pad, self.to_matrix)
+        return gx
+
+
+def col2im(x, input_shape, kernel_size, stride=1, pad=0, to_matrix=True):
+    y = Col2Im(input_shape, kernel_size, stride, pad, to_matrix)(x)
+    return y
+
+
+def im2col_array(img, kernel_size, stride, pad, to_matrix=True):
+    N, C, H, W = img.shape
+    KH, KW = pair(kernel_size)
+    SH, SW = pair(stride)
+    PH, PW = pair(pad)
+    OH = get_conv_outsize(H, KH, PH, SH)
+    OW = get_conv_outsize(W, KW, PW, SW)
+
+    img = np.pad(img,
+                 ((0, 0), (0, 0), (PH, PH + SH - 1), (PW, PW + SW - 1)),
+                 mode='constant', constant_values=(0,))
+    # np.ndarray는 인자로 넣어준 shape의 텐서를 만들어줌
+    col = np.ndarray((N, C, KH, KW, OH, OW), dtype=img.dtype)
+
+    for j in range(KH):
+        j_lim = j + SH * OH
+        for i in range(KW):
+            i_lim = i + SW * OW
+            col[:, :, j, i, :, :] = img[:, :, j:j_lim:SH, i:i_lim:SW]
+
+    if to_matrix:
+        col = col.transpose((0, 4, 5, 1, 2, 3)).reshape((N * OH * OW, -1))
+
+    return col
+
+
+def col2im_array(col, img_shape, kernel_size, stride, pad, to_matrix=True):
+    N, C, H, W = img_shape
+    KH, KW = pair(kernel_size)
+    SH, SW = pair(stride)
+    PH, PW = pair(pad)
+    OH = get_conv_outsize(H, KH, PH, SH)
+    OW = get_conv_outsize(W, KW, PW, SW)
+
+    if to_matrix:
+        col = col.reshape(N, OH, OW, C, KH, KW).transpose(0, 3, 4, 5, 1, 2)
+
+    img = np.zeros((N, C, H + 2 * PH + SH - 1, W + 2 * PW + SW - 1),
+                   dtype=col.dtype)
+    for j in range(KH):
+        j_lim = j + SH * OH
+        for i in range(KW):
+            i_lim = i + SW * OW
+            img[:, :, j:j_lim:SH, i:i_lim:SW] += col[:, :, j, i, :, :]
+    return img[:, :, PH: H+PH, PW: W+PW]
\ No newline at end of file
diff --git a/season3/dezero/layers.py b/season3/dezero/layers.py
new file mode 100644
index 0000000..5885ddb
--- /dev/null
+++ b/season3/dezero/layers.py
@@ -0,0 +1,201 @@
+import os
+import weakref
+import numpy as np
+from dezero import Parameter
+from dezero import functions as F
+from dezero.utils import pair
+
+
+class Layer:
+    def __init__(self):
+        self._params = set()
+
+    def __setattr__(self, name, value):
+        if isinstance(value, (Parameter, Layer)):
+            self._params.add(name)
+        # avoid infinite callable
+        super().__setattr__(name, value)
+
+    def __call__(self, *inputs):
+        outputs = self.forward(*inputs)
+        if not isinstance(outputs, tuple):
+            outputs = (outputs,)
+        self.inputs = [weakref.ref(x) for x in inputs]
+        self.outputs = [weakref.ref(y) for y in outputs]
+        return outputs if len(outputs) > 1 else outputs[0]
+
+    def forward(self, x):
+        raise NotImplementedError("This method should be run outside of Layer class.")
+
+    def params(self):
+        for name in self._params:
+            obj = self.__dict__[name]
+            if isinstance(obj, Layer):
+                yield from obj.params()
+            else:
+                yield obj
+
+    def clear_grads(self):
+        for param in self.params():
+            param.clear_grad()
+
+    def _flatten_params(self, param_dict, parent_key=''):
+        for name in self._params:
+            obj = self.__dict__[name]
+            key = parent_key + '/' + name if parent_key else name
+
+            if isinstance(obj, Layer):
+                obj._flatten_params(param_dict, parent_key=key)
+            else:
+                param_dict[key] = obj
+
+    def save_weights(self, path):
+        param_dict = {}
+        self._flatten_params(param_dict)
+        array_dict = {key: param.data for key, param in param_dict.items() if param is not None}
+
+        try:
+            np.savez_compressed(path, **array_dict)
+        except (Exception, KeyboardInterrupt) as e:
+            if os.path.exists(path):
+                os.remove(path)
+            raise
+
+    def load_weights(self, path):
+        npz = np.load(path)
+        param_dict = {}
+        self._flatten_params(param_dict)
+
+        for key, param in param_dict.items():
+            param.data = npz[key]
+
+
+class Linear(Layer):
+    def __init__(self, out_size, nobias=False, dtype=np.float32, in_size=None):
+        super().__init__()
+        self.in_size = in_size
+        self.out_size = out_size
+        self.dtype = dtype
+
+        self.W = Parameter(None, name='W')
+        if self.in_size is not None:
+            self._init_W()
+
+        if nobias:
+            self.b = None
+        else:
+            self.b = Parameter(np.zeros(self.out_size, dtype=self.dtype), name='b')
+
+    def _init_W(self):
+        I, O = self.in_size, self.out_size
+        W_data = np.random.rand(I, O).astype(self.dtype) * np.sqrt(1 / I)
+        self.W.data = W_data
+
+    def forward(self, x):
+        if self.W.data is None:
+            self.in_size = x.shape[1]
+            self._init_W()
+        y = F.linear(x, self.W, self.b)
+        return y
+
+
+class Conv2d(Layer):
+    def __init__(self, out_channels, kernel_size, stride=1, pad=0,
+                 nobias=False, dtype=np.float32, in_channels=None):
+        super(Conv2d, self).__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.pad = pad
+        self.dtype = dtype
+
+        self.W = Parameter(None, name='W')
+        if in_channels is not None:
+            self._init_W()
+
+        if nobias:
+            self.b = None
+        else:
+            self.b = Parameter(np.zeros(out_channels, dtype=dtype), name='b')
+
+    def _init_W(self, xp=np):
+        C, OC = self.in_channels, self.out_channels
+        KH, KW = pair(self.kernel_size)
+        scale = np.sqrt(1 / (C * KH * KW))
+        W_data = xp.random.rand(OC, C, KH, KW).astype(self.dtype) * scale
+        self.W.data = W_data
+
+    def forward(self, x):
+        if self.W.data is None:
+            self.in_channels = x.shape[1]  # `x` shape must be (N, C, H, W)
+            self._init_W()
+
+        y = F.conv2d(x, self.W, self.b, self.stride, self.pad)
+        return y
+
+
+class RNN(Layer):
+    def __init__(self, hidden_size, in_size=None):
+        super(RNN, self).__init__()
+        self.x2h = Linear(out_size=hidden_size, in_size=in_size)
+        self.h2h = Linear(out_size=hidden_size, in_size=in_size, nobias=True)
+        self.h = None
+
+    def reset_state(self):
+        self.h = None
+
+    def forward(self, x):
+        if self.h is None:
+            h_new = F.tanh(self.x2h(x))
+        else:
+            h_new = F.tanh(self.x2h(x) + self.h2h(self.h))
+        self.h = h_new
+        return h_new
+
+
+class LSTM(Layer):
+    def __init__(self, hidden_size, in_size=None):
+        super(LSTM, self).__init__()
+
+        H, I = hidden_size, in_size
+        # Forget gate
+        self.x2f = Linear(H, in_size=I)
+        self.h2f = Linear(H, in_size=H, nobias=True)
+        # Output gate
+        self.x2o = Linear(H, in_size=I)
+        self.h2o = Linear(H, in_size=H, nobias=True)
+        # Input gate
+        self.x2i = Linear(H, in_size=I)
+        self.h2i = Linear(H, in_size=H, nobias=True)
+        # Main gate
+        self.x2g = Linear(H, in_size=I)
+        self.h2g = Linear(H, in_size=H, nobias=True)
+
+        self.reset_state()
+
+    def reset_state(self):
+        self.c = None
+        self.h = None
+
+    def forward(self, x):
+        if self.h is None:
+            f = F.sigmoid(self.x2f(x))
+            o = F.sigmoid(self.x2o(x))
+            i = F.sigmoid(self.x2i(x))
+            g = F.tanh(self.x2g(x))
+        else:
+            f = F.sigmoid(self.x2f(x) + self.h2f(self.h))
+            o = F.sigmoid(self.x2o(x) + self.h2o(self.h))
+            i = F.sigmoid(self.x2i(x) + self.h2i(self.h))
+            g = F.tanh(self.x2g(x) + self.h2g(self.h))
+        # 기억 셀
+        if self.c is None:
+            c_new = g * i
+        else:
+            c_new = (g * i) + (self.c * f)
+        # 은닉 상태
+        h_new = F.tanh(c_new) * o
+        self.c, self.h = c_new, h_new
+
+        return h_new
\ No newline at end of file
diff --git a/season3/dezero/models.py b/season3/dezero/models.py
new file mode 100644
index 0000000..596548c
--- /dev/null
+++ b/season3/dezero/models.py
@@ -0,0 +1,131 @@
+import numpy as np
+import dezero.functions as F
+import dezero.layers as L
+from dezero import Layer
+from dezero import utils
+
+
+class Model(Layer):
+    def plot(self, *inputs, to_file='model.png'):
+        outputs = self.forward(*inputs)
+        return utils.plot_dot_graph(outputs, verbose=True, to_file=to_file)
+
+
+class MLP(Model):
+    def __init__(self, fc_output_sizes, activation=F.sigmoid):
+        super().__init__()
+        self.activation = activation
+        self.layers = []
+
+        for i, output_size in enumerate(fc_output_sizes):
+            layer = L.Linear(output_size)
+            setattr(self, 'l' + str(i), layer)
+            self.layers.append(layer)
+
+    def forward(self, x):
+        for l in self.layers[:-1]:
+            x = self.activation(l(x))
+        return self.layers[-1](x)
+
+
+class VGG16(Model):
+    WEIGHTS_PATH = 'https://github.com/koki0702/dezero-models/releases/download/v0.1/vgg16.npz'
+
+    def __init__(self, pretrained=False):
+        super(VGG16, self).__init__()
+        # Block 1
+        self.conv1_1 = L.Conv2d(64, kernel_size=3, stride=1, pad=1)
+        self.conv1_2 = L.Conv2d(64, kernel_size=3, stride=1, pad=1)
+        # Block 2
+        self.conv2_1 = L.Conv2d(128, kernel_size=3, stride=1, pad=1)
+        self.conv2_2 = L.Conv2d(128, kernel_size=3, stride=1, pad=1)
+        # Block 3
+        self.conv3_1 = L.Conv2d(256, kernel_size=3, stride=1, pad=1)
+        self.conv3_2 = L.Conv2d(256, kernel_size=3, stride=1, pad=1)
+        self.conv3_3 = L.Conv2d(256, kernel_size=3, stride=1, pad=1)
+        # Block 4
+        self.conv4_1 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv4_2 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv4_3 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        # Block 5
+        self.conv5_1 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv5_2 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv5_3 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        # FC Layer
+        self.fc6 = L.Linear(4096)
+        self.fc7 = L.Linear(4096)
+        self.fc8 = L.Linear(1000)
+
+        if pretrained:
+            weights_path = utils.get_file(VGG16.WEIGHTS_PATH)
+            self.load_weights(weights_path)
+
+    def forward(self, x):
+        # convolution blocks
+        x = F.relu(self.conv1_1(x))
+        x = F.relu(self.conv1_2(x))
+        x = F.pooling(x, kernel_size=2, stride=2)
+        x = F.relu(self.conv2_1(x))
+        x = F.relu(self.conv2_2(x))
+        x = F.pooling(x, kernel_size=2, stride=2)
+        x = F.relu(self.conv3_1(x))
+        x = F.relu(self.conv3_2(x))
+        x = F.relu(self.conv3_3(x))
+        x = F.pooling(x, kernel_size=2, stride=2)
+        x = F.relu(self.conv4_1(x))
+        x = F.relu(self.conv4_2(x))
+        x = F.relu(self.conv4_3(x))
+        x = F.pooling(x, kernel_size=2, stride=2)
+        x = F.relu(self.conv5_1(x))
+        x = F.relu(self.conv5_2(x))
+        x = F.relu(self.conv5_3(x))
+        x = F.pooling(x, kernel_size=2, stride=2)
+        # flatten
+        x = F.reshape(x, (x.shape[0], -1))
+        # fc layer
+        x = F.dropout(self.fc6(x))
+        x = F.dropout(self.fc7(x))
+        y = self.fc8(x)
+        return y
+
+    @staticmethod
+    def preprocess(image, size=(224, 224), dtype=np.float32):
+        image = image.convert('RGB')
+        if size:
+            image = image.resize(size)
+        image = np.asarray(image, dtype=dtype)
+        image = image[:, :, ::-1]  # change order of channels(RGB -> BGR)
+        image -= np.array([103.939, 116.779, 123.68], dtype=dtype)
+        image = image.transpose((2, 0, 1))  # axis를 (channel, height, width)로 변경
+        return image
+
+
+class SimpleRNN(Model):
+    def __init__(self, hidden_size, out_size):
+        super(SimpleRNN, self).__init__()
+        self.rnn = L.RNN(hidden_size)
+        self.fc = L.Linear(out_size)
+
+    def reset_state(self):
+        self.rnn.reset_state()
+
+    def forward(self, x):
+        h = self.rnn(x)
+        y = self.fc(h)
+        return y
+
+
+class BetterRNN(Model):
+    def __init__(self, hidden_size, out_size):
+        super(BetterRNN, self).__init__()
+        self.lstm = L.LSTM(hidden_size)
+        self.fc = L.Linear(out_size)
+
+    def reset_state(self):
+        self.lstm.reset_state()
+
+    def forward(self, x):
+        x = self.lstm(x)
+        y = self.fc(x)
+        return y
+
diff --git a/season3/dezero/optimizers.py b/season3/dezero/optimizers.py
new file mode 100644
index 0000000..eac1678
--- /dev/null
+++ b/season3/dezero/optimizers.py
@@ -0,0 +1,142 @@
+import math
+import numpy as np
+from dezero import utils
+
+
+class Optimizer:
+    def __init__(self):
+        self.target = None
+        self.hooks = []
+
+    def setup(self, target):
+        self.target = target
+        return self
+
+    def update(self):
+        params = [p for p in self.target.params() if p.grad is not None]
+
+        # (optional) preprocessing gradients ex) gradient clipping, weight decay, ...
+        for f in self.hooks:
+            f(params)
+
+        # update parameters
+        for param in params:
+            self.update_one(param)
+
+    def update_one(self, param):
+        raise NotImplementedError("This method should be run outside of Optimizer class.")
+
+    def add_hook(self, f):
+        self.hooks.append(f)
+
+
+class SGD(Optimizer):
+    def __init__(self, lr=0.01):
+        super().__init__()
+        self.lr = lr
+
+    def update_one(self, param):
+        param.data -= self.lr * param.grad.data
+
+
+class MomentumSGD(Optimizer):
+    def __init__(self, lr=0.01, momentum=0.9):
+        super().__init__()
+        self.lr = lr
+        self.momentum = momentum
+        self.vs = {}
+
+    def update_one(self, param):
+        v_key = id(param)
+        if v_key not in self.vs:
+            self.vs[v_key] = np.zeros_like(param.data)
+
+        v = self.vs[v_key]
+        v *= self.momentum
+        v -= self.lr * param.grad.data
+        param.data += v
+
+
+class AdaGrad(Optimizer):
+    def __init__(self, lr=0.01, eps=1e-8):
+        super().__init__()
+        self.lr = lr
+        self.eps = eps
+        self.hs = {}
+
+    def update_one(self, param):
+        h_key = id(param)
+        if h_key not in self.hs:
+            self.hs[h_key] = np.zeros_like(param.data)
+
+        lr = self.lr
+        eps = self.eps
+        grad = param.grad.data
+        h = self.hs[h_key]
+
+        h += grad * grad
+        param.data -= lr * grad / (np.sqrt(h) + eps)
+
+
+class AdaDelta(Optimizer):
+    def __init__(self, rho=0.95, eps=1e-2):
+        super().__init__()
+        self.rho = rho
+        self.eps = eps
+        self.msg = {}
+        self.msdx = {}
+
+    def update_one(self, param):
+        key = id(param)
+        if key not in self.msg:
+            self.msg[key] = np.zeros_like(param.data)
+            self.msdx[key] = np.zeros_like(param.data)
+
+        msg, msdx = self.msg[key], self.msdx[key]
+        rho = self.rho
+        eps = self.eps
+        grad = param.grad.data
+
+        msg *= rho
+        msg += (1 - rho) * grad * grad
+        dx = np.sqrt((msdx + eps) / (msg + eps)) * grad
+        msdx *= rho
+        msdx += (1 - rho) * dx * dx
+        param.data -= dx
+
+
+class Adam(Optimizer):
+    def __init__(self, alpha=0.001, beta1=0.9, beta2=0.999, eps=1e-8):
+        super().__init__()
+        self.t = 0
+        self.alpha = alpha
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.eps = eps
+        self.ms = {}
+        self.vs = {}
+
+    def update(self, *args, **kwargs):
+        self.t += 1
+        super().update(*args, **kwargs)  # avoid infinite callable
+
+    @property
+    def lr(self):
+        fix1 = 1. - math.pow(self.beta1, self.t)
+        fix2 = 1. - math.pow(self.beta2, self.t)
+        return self.alpha * math.sqrt(fix2) / fix1
+
+    def update_one(self, param):
+
+        key = id(param)
+        if key not in self.ms:
+            self.ms[key] = np.zeros_like(param.data)
+            self.vs[key] = np.zeros_like(param.data)
+
+        m, v = self.ms[key], self.vs[key]
+        beta1, beta2, eps = self.beta1, self.beta2, self.eps
+        grad = param.grad.data
+
+        m += (1 - beta1) * (grad - m)
+        v += (1 - beta2) * (grad * grad - v)
+        param.data -= (self.lr * m / (np.sqrt(v) + eps))
diff --git a/season3/dezero/tmp_graph.dot b/season3/dezero/tmp_graph.dot
new file mode 100644
index 0000000..401ca03
--- /dev/null
+++ b/season3/dezero/tmp_graph.dot
@@ -0,0 +1,35 @@
+digraph g {
+140525492459792 [label="(100, 1) float64", color=orange, style=filled]
+140525493638032 [label="Linear", color=lightblue, style=filled, shape=box]
+140525441078992 -> 140525493638032
+140525498084944 -> 140525493638032
+140525498085072 -> 140525493638032
+140525493638032 -> 140525492459792
+140525441078992 [label="(100, 10) float64", color=orange, style=filled]
+140525498084944 [label="W: (10, 1) float32", color=orange, style=filled]
+140525498085072 [label="b: (1,) float32", color=orange, style=filled]
+140525440433936 [label="Sigmoid", color=lightblue, style=filled, shape=box]
+140525494228368 -> 140525440433936
+140525440433936 -> 140525441078992
+140525494228368 [label="(100, 10) float64", color=orange, style=filled]
+140525494601936 [label="Linear", color=lightblue, style=filled, shape=box]
+140525491536720 -> 140525494601936
+140525498084816 -> 140525494601936
+140525498084880 -> 140525494601936
+140525494601936 -> 140525494228368
+140525491536720 [label="(100, 25) float64", color=orange, style=filled]
+140525498084816 [label="W: (25, 10) float32", color=orange, style=filled]
+140525498084880 [label="b: (10,) float32", color=orange, style=filled]
+140525498085264 [label="Sigmoid", color=lightblue, style=filled, shape=box]
+140525441095888 -> 140525498085264
+140525498085264 -> 140525491536720
+140525441095888 [label="(100, 25) float64", color=orange, style=filled]
+140525496329616 [label="Linear", color=lightblue, style=filled, shape=box]
+140525492350800 -> 140525496329616
+140525440434128 -> 140525496329616
+140525497998928 -> 140525496329616
+140525496329616 -> 140525441095888
+140525492350800 [label="(100, 1) float64", color=orange, style=filled]
+140525440434128 [label="W: (1, 25) float32", color=orange, style=filled]
+140525497998928 [label="b: (25,) float32", color=orange, style=filled]
+}
\ No newline at end of file
diff --git a/season3/dezero/utils.py b/season3/dezero/utils.py
new file mode 100644
index 0000000..884955c
--- /dev/null
+++ b/season3/dezero/utils.py
@@ -0,0 +1,208 @@
+import os
+import subprocess
+import urllib.request
+
+import numpy as np
+
+
+# 변수 계산 그래프
+def _dot_var(v, verbose=False):
+    dot_var = '{} [label="{}", color=orange, style=filled]\n'
+    name = "" if v.name is None else v.name
+
+    if verbose and v.data is not None:
+        if v.name is not None:
+            name += ": "
+        name += str(v.shape) + ' ' + str(v.dtype)
+    return dot_var.format(id(v), name)
+
+
+# 함수 계산 그래프
+def _dot_func(f):
+    dot_func = '{} [label="{}", color=lightblue, style=filled, shape=box]\n'
+    txt = dot_func.format(id(f), f.__class__.__name__)
+
+    # 변수와 함수 간 edge
+    dot_edge = "{} -> {}\n"
+    for x in f.inputs:
+        txt += dot_edge.format(id(x), id(f))
+    for y in f.outputs:
+        txt += dot_edge.format(id(f), id(y()))
+    return txt
+
+
+# 계산 그래프 dot 언어로 표현
+def get_dot_graph(output, verbose=True):
+    txt = ""
+    funcs = []
+    seen_sets = set()
+
+    def add_func(f):
+        if f not in seen_sets:
+            funcs.append(f)
+            seen_sets.add(f)
+
+    add_func(output.creator)
+    txt += _dot_var(output, verbose)
+
+    while funcs:
+        f = funcs.pop()
+        txt += _dot_func(f)
+        for x in f.inputs:
+            txt += _dot_var(x, verbose)
+
+            if x.creator is not None:
+                add_func(x.creator)
+
+    return "digraph g {\n" + txt + "}"
+
+
+# 계산 그래프 이미지 변환 및 대화 셀에 출력
+def plot_dot_graph(output, verbose=True, to_file='graph.png'):
+    dot_graph = get_dot_graph(output, verbose=True)
+
+    tmp_dir = os.path.join(os.path.expanduser('~/Desktop/gitrepo/DeepLearningOnlyNumpy/season3'), 'dezero')
+    if not os.path.exists(tmp_dir):
+        os.mkdir(tmp_dir)
+    graph_path = os.path.join(tmp_dir, 'tmp_graph.dot')
+
+    with open(graph_path, 'w') as g:
+        g.write(dot_graph)
+
+    extension = os.path.splitext(to_file)[1][1:]
+    filename = os.path.join(tmp_dir, to_file)
+    cmd = "dot {} -T {} -o {}".format(graph_path, extension, filename)
+    subprocess.run(cmd, shell=True)
+
+    try:
+        from IPython import display
+        return display.Image(filename=filename)
+    except:
+        pass
+
+
+def sum_to(x, shape):
+    """Sum elements along axes to output an array of a given shape.
+    Args:
+        x (ndarray): Input array.
+        shape:
+    Returns:
+        ndarray: Output array of the shape.
+    """
+    ndim = len(shape)
+    lead = x.ndim - ndim
+    lead_axis = tuple(range(lead))
+
+    axis = tuple([i + lead for i, sx in enumerate(shape) if sx == 1])
+    y = x.sum(lead_axis + axis, keepdims=True)
+    if lead > 0:
+        y = y.squeeze(lead_axis)
+    return y
+
+
+def reshape_sum_backward(gy, x_shape, axis, keepdims):
+    """Reshape gradient appropriately for dezero.functions.sum's backward.
+    Args:
+        gy (dezero.Variable): Gradient variable from the output by backprop.
+        x_shape (tuple): Shape used at sum function's forward.
+        axis (None or int or tuple of ints): Axis used at sum function's
+            forward.
+        keepdims (bool): Keepdims used at sum function's forward.
+    Returns:
+        dezero.Variable: Gradient variable which is reshaped appropriately
+    """
+    ndim = len(x_shape)
+    tupled_axis = axis
+    if axis is None:
+        tupled_axis = None
+    elif not isinstance(axis, tuple):
+        tupled_axis = (axis,)
+
+    if not (ndim == 0 or tupled_axis is None or keepdims):
+        actual_axis = [a if a >= 0 else a + ndim for a in tupled_axis]
+        shape = list(gy.shape)
+        for a in sorted(actual_axis):
+            shape.insert(a, 1)
+    else:
+        shape = gy.shape
+
+    gy = gy.reshape(shape)  # reshape
+    return gy
+
+
+def max_backward_shape(x, axis):
+    if axis is None:
+        axis = range(x.ndim)
+    elif isinstance(axis, int):
+        axis = (axis,)
+    else:
+        axis = axis
+
+    shape = [s if ax not in axis else 1 for ax, s in enumerate(x.shape)]
+    return shape
+
+
+def logsumexp(x, axis=1):
+    m = x.max(axis=axis, keepdims=True)
+    y = x - m
+    np.exp(y, out=y)  # 'out' argument for inplace
+    s = y.sum(axis=axis, keepdims=True)
+    np.log(s, out=s)
+    m += s
+    return m
+
+
+def convert_dtype(*args):
+    if len(args) == 1:
+        return np.array(args[0], dtype=np.float64)
+    return np.array(args[0], dtype=np.float64), np.array(args[1], dtype=np.float64)
+
+
+def get_conv_outsize(input_size, kernel_size, pad_size, stride_size):
+    output_size = (input_size + 2 * pad_size - kernel_size) // stride_size + 1
+    return output_size
+
+
+def pair(x):
+    if isinstance(x, int):
+        return x, x
+    elif isinstance(x, tuple):
+        assert len(x) == 2
+        return x
+    else:
+        raise ValueError
+
+
+def get_file(url, file_name=None):
+    cache_dir = '/Users/younghun/Desktop/gitrepo/DeepLearningOnlyNumpy/season3/dezero/weights'
+    if file_name is None:
+        file_name = url[url.rfind('/')+1:]
+    file_path = os.path.join(cache_dir, file_name)
+
+    if not os.path.exists(cache_dir):
+        os.mkdir(cache_dir)
+
+    if os.path.exists(file_path):
+        return file_path
+
+    print("Downloading weights..." + file_name)
+    try:
+        urllib.request.urlretrieve(url, file_path, show_progress)
+    except (Exception, KeyboardInterrupt) as e:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        raise
+    print("Done")
+    return file_path
+
+
+def show_progress(block_num, block_size, total_size):
+    bar_template = "\r[{}] {:.2f}%"
+
+    downloaded = block_num * block_size
+    p = downloaded / total_size * 100
+    i = int(downloaded / total_size * 30)
+    if p >= 100.0: p = 100.0
+    if i >= 30: i = 30
+    bar = "#" * i + "." * (30 - i)
+    print(bar_template.format(bar, p), end='')
\ No newline at end of file
diff --git a/season3/hands_on/practice2/dezero/__init__.py b/season3/hands_on/practice2/dezero/__init__.py
new file mode 100644
index 0000000..9e13b41
--- /dev/null
+++ b/season3/hands_on/practice2/dezero/__init__.py
@@ -0,0 +1,14 @@
+is_simple_core = False
+
+if is_simple_core:
+    from dezero.core_simple import Variable
+    from dezero.core_simple import as_array, as_variable
+    from dezero.core_simple import using_config, no_grad
+    from dezero.core_simple import setup_variable
+else:
+    from dezero.core import Variable
+    from dezero.core import as_array, as_variable
+    from dezero.core import using_config, no_grad
+    from dezero.core import setup_variable
+
+setup_variable()
\ No newline at end of file
diff --git a/season3/hands_on/practice2/dezero/__pycache__/__init__.cpython-37.pyc b/season3/hands_on/practice2/dezero/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000..fb9d0ac
Binary files /dev/null and b/season3/hands_on/practice2/dezero/__pycache__/__init__.cpython-37.pyc differ
diff --git a/season3/hands_on/practice2/dezero/__pycache__/core.cpython-37.pyc b/season3/hands_on/practice2/dezero/__pycache__/core.cpython-37.pyc
new file mode 100644
index 0000000..ae7b878
Binary files /dev/null and b/season3/hands_on/practice2/dezero/__pycache__/core.cpython-37.pyc differ
diff --git a/season3/hands_on/practice2/dezero/__pycache__/core_simple.cpython-37.pyc b/season3/hands_on/practice2/dezero/__pycache__/core_simple.cpython-37.pyc
new file mode 100644
index 0000000..1c2b1e8
Binary files /dev/null and b/season3/hands_on/practice2/dezero/__pycache__/core_simple.cpython-37.pyc differ
diff --git a/season3/hands_on/practice2/dezero/core.py b/season3/hands_on/practice2/dezero/core.py
new file mode 100644
index 0000000..b48d6bc
--- /dev/null
+++ b/season3/hands_on/practice2/dezero/core.py
@@ -0,0 +1,261 @@
+import numpy as np
+import weakref
+import heapq
+import contextlib
+
+
+class Config:
+    enable_backprop = True
+
+
+class Variable:
+    __array_priority__ = 200
+
+    def __init__(self, data, name=None):
+        if data is not None:
+            if not isinstance(data, np.ndarray):
+                raise TypeError(f"{type(data)} dtype is not supported.")
+
+        self.name = name
+        self.data = data
+        self.grad = None
+        self.creator = None
+        self.generation = 0
+
+    def __len__(self):
+        return len(self.data)
+
+    def __repr__(self):
+        if self.data is None:
+            return 'variable(None)'
+        p = str(self.data).replace('\n', '\n' + ' ' * 9)
+        return 'variable(' + p + ')'
+
+    def clear_grad(self):
+        self.grad = None
+
+    def set_creator(self, func):
+        self.creator = func
+        self.generation = func.generation + 1
+
+    def backward(self, use_heap=False, retain_grad=False, create_graph=False):
+        if self.grad is None:
+            self.grad = Variable(np.ones_like(self.data))
+
+        funcs = []
+        seen_sets = set()
+        flag = 0
+
+        def add_func(f):
+            if f not in seen_sets:
+                if use_heap:
+                    heapq.heappush(funcs, (-f.generation, flag, f))
+                    seen_sets.add(f)
+                else:
+                    funcs.append(f)
+                    seen_sets.add(f)
+                    funcs.sort(key=lambda k: k.generation)
+
+        add_func(self.creator)
+
+        while funcs:
+            if use_heap:
+                f = heapq.heappop(funcs)[2]
+            else:
+                f = funcs.pop()
+            gys = [y().grad for y in f.outputs]
+
+            with using_config('enable_backprop', create_graph):
+                gxs = f.backward(*gys)
+                if not isinstance(gxs, tuple):
+                    gxs = (gxs,)
+                for x, gx in zip(f.inputs, gxs):
+                    if x.grad is None:
+                        x.grad = gx
+                    else:
+                        x.grad = x.grad + gx
+
+                    if x.creator is not None:
+                        add_func(x.creator)
+                        flag += 1
+                flag = 0
+
+                if not retain_grad:
+                    for y in f.outputs:
+                        y().grad = None
+
+    @property
+    def shape(self):
+        return self.data.shape
+
+    @property
+    def size(self):
+        return self.data.size
+
+    @property
+    def ndim(self):
+        return self.data.ndim
+
+    @property
+    def dtype(self):
+        return self.data.dtype
+
+
+class Function:
+    def __call__(self, *inputs):
+        inputs = [as_variable(x) for x in inputs]
+        xs = [x.data for x in inputs]
+        ys = self.forward(*xs)
+        if not isinstance(ys, tuple):
+            ys = (ys,)
+        outputs = [Variable(as_array(y)) for y in ys]
+
+        if Config.enable_backprop:
+            self.generation = max([x.generation for x in inputs])
+            for output in outputs:
+                output.set_creator(self)
+
+            self.inputs = inputs
+            self.outputs = [weakref.ref(output) for output in outputs]
+
+        return outputs if len(outputs) > 1 else outputs[0]
+
+    def forward(self, xs):
+        raise NotImplementedError("This method should be run outside of this class.")
+
+    def backward(self, gy):
+        raise NotImplementedError("This method should be run outside of this class.")
+
+
+class Add(Function):
+    def forward(self, x0, x1):
+        return x0 + x1
+
+    def backward(self, gy):
+        return gy, gy
+
+
+class Mul(Function):
+    def forward(self, x0, x1):
+        return x0 * x1
+
+    def backward(self, gy):
+        x0, x1 = self.inputs
+        return gy * x1, gy * x0
+
+
+class Sub(Function):
+    def forward(self, x0, x1):
+        return x0 - x1
+
+    def backward(self, gy):
+        return gy, -gy
+
+
+class Div(Function):
+    def forward(self, x0, x1):
+        return x0 / x1
+
+    def backward(self, gy):
+        x0, x1 = self.inputs
+        gx0 = gy / x1
+        gx1 = gy * (-x0 / (x1 ** 2))
+        return gx0, gx1
+
+
+class Neg(Function):
+    def forward(self, x):
+        return -x
+
+    def backward(self, gy):
+        return -gy
+
+
+class Pow(Function):
+    def __init__(self, power):
+        self.c = power
+
+    def forward(self, x):
+        return x ** self.c
+
+    def backward(self, gy):
+        x, = self.inputs
+        c = self.c
+        return c * (x ** (c-1)) * gy
+
+
+def add(x0, x1):
+    x1 = as_array(x1)
+    return Add()(x0, x1)
+
+
+def mul(x0, x1):
+    x1 = as_array(x1)
+    return Mul()(x0, x1)
+
+
+def sub(x0, x1):
+    x1 = as_array(x1)
+    return Sub()(x0, x1)
+
+
+def rsub(x0, x1):
+    x1 = as_array(x1)
+    return Sub()(x1, x0)
+
+
+def div(x0, x1):
+    x1 = as_array(x1)
+    return Div()(x0, x1)
+
+
+def rdiv(x0, x1):
+    x1 = as_array(x1)
+    return Div()(x1, x0)
+
+
+def neg(x):
+    return Neg()(x)
+
+
+def pow(x, power):
+    return Pow(power)(x)
+
+
+def as_array(x):
+    if np.isscalar(x):
+        return np.array(x)
+    return x
+
+
+def as_variable(obj):
+    if isinstance(obj, Variable):
+        return obj
+    return Variable(obj)
+
+
+@contextlib.contextmanager
+def using_config(name: str, value: bool):
+    old_value = getattr(Config, name)
+    setattr(Config, name, value)
+    try:
+        yield
+    finally:
+        setattr(Config, name, old_value)
+
+
+def no_grad():
+    return using_config('enable_backprop', False)
+
+
+def setup_variable():
+    Variable.__add__ = add
+    Variable.__radd__ = add
+    Variable.__sub__ = sub
+    Variable.__rsub__ = rsub
+    Variable.__mul__ = mul
+    Variable.__rmul__ = mul
+    Variable.__truediv__ = div
+    Variable.__rtruediv__ = rdiv
+    Variable.__neg__ = neg
+    Variable.__pow__ = pow
\ No newline at end of file
diff --git a/season3/hands_on/practice2/test.py b/season3/hands_on/practice2/test.py
new file mode 100644
index 0000000..551a87f
--- /dev/null
+++ b/season3/hands_on/practice2/test.py
@@ -0,0 +1,10 @@
+from dezero import Variable
+import numpy as np
+
+a = Variable(np.array([1,2,3]))
+b = np.array([4,5,6])
+y = b + a
+print(y)
+y.backward()
+print(a.grad)
+
diff --git "a/season3/hands_on/\354\240\2343\352\263\240\354\247\200.ipynb" "b/season3/hands_on/\354\240\2343\352\263\240\354\247\200.ipynb"
new file mode 100644
index 0000000..71f63fb
--- /dev/null
+++ "b/season3/hands_on/\354\240\2343\352\263\240\354\247\200.ipynb"
@@ -0,0 +1,2072 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cff360a3",
+   "metadata": {
+    "toc": true
+   },
+   "source": [
+    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
+    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Step25,-26\" data-toc-modified-id=\"Step25,-26-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Step25, 26</a></span></li><li><span><a href=\"#Step27\" data-toc-modified-id=\"Step27-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Step27</a></span></li><li><span><a href=\"#Step28~32\" data-toc-modified-id=\"Step28~32-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Step28~32</a></span></li><li><span><a href=\"#Step33\" data-toc-modified-id=\"Step33-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Step33</a></span></li></ul></div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49494306",
+   "metadata": {},
+   "source": [
+    "## Step25, 26"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 213,
+   "id": "fc556c56",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 변수를 DOT 언어로 변환하는 함수\n",
+    "def _dot_var(v, verbose=False):\n",
+    "    dot_var = '{} [label=\"{}\", color=orange, style=filled]\\n'\n",
+    "    \n",
+    "    name = '' if v.name is None else v.name\n",
+    "    if verbose and v.data is not None:\n",
+    "        if v.name is not None:\n",
+    "            name += ''\n",
+    "        name += str(v.shape) + ' ' + str(v.dtype)\n",
+    "    return dot_var.format(id(v), name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 214,
+   "id": "b071e4aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('..')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 215,
+   "id": "e64c1297",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140515753892176 [label=\"x\", color=orange, style=filled]\n",
+      "\n",
+      "140515753892176 [label=\"x(2, 3) float64\", color=orange, style=filled]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dezero.core_simple import Variable\n",
+    "\n",
+    "x = Variable(np.random.randn(2, 3))\n",
+    "x.name = 'x'\n",
+    "\n",
+    "print(_dot_var(x))\n",
+    "print(_dot_var(x, verbose=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 216,
+   "id": "c85adc0e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 함수를 DOT 언어로 변환하는 함수\n",
+    "def _dot_func(f):\n",
+    "    # 함수 네이밍 작성\n",
+    "    dot_func = '{} [label=\"{}\", color=lightblue, style=filled, shape=box]\\n'\n",
+    "    txt = dot_func.format(id(f), f.__class__.__name__)\n",
+    "    \n",
+    "    # 변수 - 함수 간의 edge 연결\n",
+    "    dot_edge = '{} -> {}\\n'\n",
+    "    # 함수가 캐싱해둔 입력 변수들을 활용해서 '입력변수 -> 함수' edge 연결\n",
+    "    for x in f.inputs:\n",
+    "        txt += dot_edge.format(id(x), id(f))\n",
+    "    # 함수가 캐싱해둔 출력 변수들을 활용해서 '함수 -> 출력변수' edge 연결\n",
+    "    for y in f.outputs:\n",
+    "        txt += dot_edge.format(id(f), id(y()))\n",
+    "    return txt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 217,
+   "id": "12dc7eb6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "140515740281168 [label=\"Add\", color=lightblue, style=filled, shape=box]\n",
+      "140515735010448 -> 140515740281168\n",
+      "140515754729424 -> 140515740281168\n",
+      "140515740281168 -> 140515708177232\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dezero.core_simple import Variable\n",
+    "\n",
+    "x0 = Variable(np.array(1.0))\n",
+    "x1 = Variable(np.array(1.0))\n",
+    "y = x0 + x1\n",
+    "\n",
+    "txt = _dot_func(y.creator)\n",
+    "print(txt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 218,
+   "id": "4cd84d42",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 이제 역전파 추적 방식과 유사한 방법으로 계산 그래프 그려보기\n",
+    "def get_dot_graph(output, verbose=True):\n",
+    "    txt = ''\n",
+    "    funcs = []\n",
+    "    seen_sets = set()\n",
+    "    \n",
+    "    def add_func(f):\n",
+    "        if f not in seen_sets:\n",
+    "            funcs.append(f)\n",
+    "            seen_sets.add(f)\n",
+    "    # 최종 출력변수를 만들어낸 마지막 함수 넣어두기\n",
+    "    add_func(output.creator)\n",
+    "    # 최종 출력변수에 대해서 계산 그래프 그리기 시작!\n",
+    "    txt = _dot_var(output, verbose)\n",
+    "    \n",
+    "    while funcs:\n",
+    "        f = funcs.pop()\n",
+    "        # 출력변수를 만들어낸 함수에 대해서 계산 그래프 그리기\n",
+    "        txt += _dot_func(f)\n",
+    "        # 함수의 입력변수들에 대해서 계산 그래프 그리기\n",
+    "        for x in f.inputs:\n",
+    "            txt += _dot_var(x, verbose)\n",
+    "            \n",
+    "            # 입력변수의 creator 함수가 있으면 계속!(없다는 것은 말단 입력변수까지 도달했음을 의미)\n",
+    "            if x.creator is not None:\n",
+    "                add_func(x.creator)\n",
+    "    # print('diagraph g {\\n' + txt + '}')\n",
+    "    return 'digraph g {\\n' + txt + '}'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 219,
+   "id": "b31fdea3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'digraph g {\\n140515762491664 [label=\"y() float64\", color=orange, style=filled]\\n140515761518032 [label=\"Mul\", color=lightblue, style=filled, shape=box]\\n140515761516688 -> 140515761518032\\n140515761517904 -> 140515761518032\\n140515761518032 -> 140515762491664\\n140515761516688 [label=\"x0() float64\", color=orange, style=filled]\\n140515761517904 [label=\"x1() float64\", color=orange, style=filled]\\n}'"
+      ]
+     },
+     "execution_count": 219,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from dezero.core_simple import Variable\n",
+    "\n",
+    "x0 = Variable(np.array(2.0))\n",
+    "x1 = Variable(np.array(5.0))\n",
+    "y = x0 * x1\n",
+    "\n",
+    "x0.name = 'x0'\n",
+    "x1.name = 'x1'\n",
+    "y.name = 'y'\n",
+    "\n",
+    "dot = get_dot_graph(y, verbose=True)\n",
+    "dot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 222,
+   "id": "49bebde2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 이미지 변환까지 한번에 하도록 하기!\n",
+    "import os\n",
+    "import subprocess\n",
+    "\n",
+    "def plot_dot_graph(output, verbose=True, to_file='graph.png'):\n",
+    "    # 1. 그래프를 DOT 언어로 표현한 문자열 얻기\n",
+    "    dot_graph = get_dot_graph(output, verbose)\n",
+    "    \n",
+    "    # 2. 문자열을 .dot 확장자 파일로 write\n",
+    "    tmp_dir = os.path.join(os.path.expanduser('~/Desktop/gitrepo/DeepLearningOnlyNumpy/season3'), 'dezero')\n",
+    "    if not os.path.exists(tmp_dir):\n",
+    "        os.mkdir(tmp_dir)\n",
+    "    graph_path = os.path.join(tmp_dir, 'tmp_graph.dot')\n",
+    "    \n",
+    "    with open(graph_path, 'w') as f:\n",
+    "        f.write(dot_graph)\n",
+    "    \n",
+    "    # 3. .dot 파일을 .png 확장자로 변경하는 cmd 명령어 실행\n",
+    "    extension = os.path.splitext(to_file)[1][1:]   # 확장자 기준(.)으로 경로 분할해줌!\n",
+    "    filename = os.path.join(tmp_dir, to_file)\n",
+    "    cmd = 'dot {} -T {} -o {}'.format(graph_path, extension, filename)\n",
+    "    subprocess.run(cmd, shell=True)\n",
+    "    \n",
+    "    # 대화형 인터프리터에서 그림 출력하도록 하기\n",
+    "    try:\n",
+    "        from IPython import display\n",
+    "        return display.Image(filename=filename)\n",
+    "    except:\n",
+    "        pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 223,
+   "id": "200c5393",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 223,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from dezero.core_simple import Variable\n",
+    "\n",
+    "x0 = Variable(np.random.randn(2, 2))\n",
+    "x1 = Variable(np.random.randn(2, 2))\n",
+    "y = x0 * x1\n",
+    "\n",
+    "x0.name = 'x0'\n",
+    "x1.name = 'x1'\n",
+    "y.name = 'y'\n",
+    "\n",
+    "dot = plot_dot_graph(y, verbose=True)\n",
+    "dot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 226,
+   "id": "9a0ecba8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRUAAAU8CAYAAACq23KNAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAFFaADAAQAAAABAAAFPAAAAABw/a8vAABAAElEQVR4AeydB5gURfrGP3LOQXKSnCRIzgqigChJBI6goHKAOYuK+Oc8xTOh4J0oKEg4EBUBUXLQUzIokoPkHJYcl3+9NdbSOzvD7uzOzHZ463l6O6dfzXZXv/WFNNdUERYSIAESIAESIAESIAESIAESIAESIAESIAESIAESSCKBtEncjpuRAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgCZAUZE/BBIgARIgARIgARIgARIgARIgARIgARIgARIggZAIpA9pazttHHtJ5NwekYvH1HBU5JIaXz4tcvWCCNZhSKM007SZ1JBRJF1mkUz5fENGNc5SSE0XtNMd8VpIgARIgARIgARIgASSQuDSCdX+O6LafjGqDagGjC+fUu3Ac6oNePn6cO2KOloa1RbMYBlUuzB9DpEMOUUy5lJjNWTMI5JZtQ3RZmQhARIgARIgARJwJwHqSGGvV/uLipdPipxYJ3JSDUeXqfFvSkzc62s4ps+mgPxlbHntqggajtdi1aCmRY11UbeoxcV0aqwGvb0KI4kG5zU1oAGZrbRIgXoieWqJ5K4ukqvSX9v5jsC/JEACJEACJEACJEACUSSAjuMz20RObxc5tUm1/9ar9t9ukQsQEpWgiDYdOo7RxtPRwdUf3Rb8qw0Yi4WmPahERbT/0qLNqAbskwZNYIzVCOHFsS8EyXRZfB3QaB/mKOtrF2Kc/WaRnOXVerQ9WUiABEiABEiABGxNgDpS1Konje0StaDn+cCPIgfnqGG+yPmDvgbetYsiVy5EDkwa1apMn913fKjXEBiLtBEp3EokX121HK1OFhIgARIgARIgARIggfARUJ3AEAyPqY5jdB4fW66ExC0+0Q/CHzqAryixL7VKWnUNEBrRDrxyXgmOyqIRHdAFGojkrSOSX40z5U+tq+N5SYAESIAESIAEQIA6Uqr9DuwhKl44IPLneDVMUg3LDarxpnqeryhXZt3znGps1HXAVQYNSdXgLdJOpHRPJTK2Vu1K1TvOQgIkQAIkQAIkQAIkEBoBWARCQDygOo/RiXx8jWprqfYWGn1XzoZ2rNTcOq1qC6Iz+qoSGjMqUbFgU9VGvEO1F+9UXjCFU/PKeG4SIAESIAES8AYB6ki2qOfUExXhqrz7K5EtI1SDcpWCoRpnaJjZtcBQMb2KvYNGb5leIuUfU24xyg2GhQRIgARIgARIgARIIDiBK6dE9nwrsmuKyKEFSkRU1n+w+tPxDoPv5rg1GSAyKsvKrEVEincUKdFFebvUc9xt8IJJgARIgARIwLYEqCPZrmqiLypeOSOy9WORDW/64hoiuYrTChrDcMkp0FCk2hA1Vr3TLCRAAiRAAiRAAiRAAj4CsRdF9iohcdtokcNLfV4oTmzzJbc+4dWSXnm7wHW6tOqMLtNHxeyumtyjcT8SIAESIAES8DYB6ki2rf/oiYqIibP1E5F1L/l6plMzPk44qwOuL/lU/MXaH/pi7ITz2DwWCZAACZAACZAACTiJwNmdIptVm2i7avPBCwUZmb1eTOZpJHyp/KLPipFZpr3+q+D9kwAJkAAJJIUAdaSkUErVbaIjKh5fIbK0s8jFY86Kl5PUqkEWQcSBLN1bpNY7ajprUvfkdiRAAiRAAiRAAiTgfALI0LzmWZVkb566l1jlBnzJ+fcUiTuAi3QaFUMSni7l+itXcNV+ZCEBEiABEiABEkhIgDpSQiY2XBJZURHBuNc8rSwU/6MalxHM3GwXsHBzQdzF5jN8GQHtcl28DhIgARIgARIgARKIBAEESV8+QCVd+cEX1gZtP5bECWTIpsTFjKozerhyje6rtkfwbhYSIAESIAESIAGhjuSoH0EERUXVSz27hsjp7co68ZyjoKT4YtNlFqmnhNRSKoYOCwmQAAmQAAmQAAm4jsA1lWxPuTmvVe68sSrEDQaW0AnAchGJ/xqMUzEXq4S+P/cgARIgARIgAVcRoI7kNB0pMqLipeMi31cXuXBINTJVlmevlobjlbD4N6/ePe+bBEiABEiABEjAjQTO7xdZ0kEkZoPqOFYJ+FhSRsCE0bnlDZEKT6TsWNybBEiABEiABJxKQOtItygd6SB1JAfpSOEXFS/HiPxYT1koblEJWVQvtpdLGuXKUnuESPlBXqbAeycBEiABEiABEnALgTM7VDuvrkrAotp7Xu44jkR9plcu0RUeFbnlH+roKl43CwmQAAmQAAl4hQB1pOs17TAdKfyi4pJ7VVydH70RQ/F6tQefSqfiLLZcpDJEqwY4CwmQAAmQAAmQAAk4lQAyO08v49Srd8Z1Iyt0kTYiTb9xxvXyKkmABEiABEggHASoI8Wn6CAdKbzdoDvHqax/81MsKJ5SIRjPqLwuscqd/kYFhpDrdiW+3Y2OYdbtUx7bf+w1c9fHF1WIoBNnr8+HPHX1vMji9opJSg4S8lm5AwmQAAmQAAmQAAmEj8D5fSpW9q1RyyeCtmCMGpJatipPqT3HRC6pqDuHlBFlpMoVlYdmg2ovBjoH2otoN6aoxKqs2Xu/VbEqX0jRYbgzCZAACZAACTiGAHWkhFXlIB0pfKLiNdWKW/NcimPrrN8j8sxEZex4UuQxpVGicRisQFCs8ZLI0s3Btkh8+X9/UYn31DGmLRfJninh9g9/KvLi5ITLQ1qCeEPbPgtpF25MAiRAAiRAAiRAAvYgoHpxf+qq2ninVWibyF/Rf1T/9Dcr1bBCZNzSG5/vvNLgmr4uMul/ItWeF8mpEimPXXzjfZKzFp3dz6r2aes3RTbuT9hmhKBYVTWDf0pBmzTedW1WSXAOzom3iDMkQAIkQAIk4DoC1JGCV6lDdKTwiYq7v1Img6rFlYKybJtPSHz3byLlCon0ay5y77uqDat6hQOVaiVUp7lqwDUsF2htwmXvzIq/7NHPRZ76UmTGM+q8d4qULBB//YzVqjH7U/xlyZq7olqa6/9PNcSD3EiyDsqdSIAESIAESIAESCAKBBDW5uQ61c5LqRle4tc6THn97j4q0rupSJ9mIjsOi3w8L/h+6BxGebWj8l75p0g21UGcLoWt2yUbRVZs9x0Xf2ExWXuwzxJyzosineqq82S+vh5Tz0wQ2a86xMNWrqqTLu+vDhcFFTdsF80DkQAJkAAJkECIBKgjBQfmEB0phc0uy/3vnqrMClPmb/LoF6pR2EH1/v7VUKtRSvU4q5CE44MIe2g03qmSA6VPd/06TG4YjM001n6tLBH/+d317aYuE/lorsinD4kUzXt9uZk6rowL0Yi9t7ZZksIxzFdPbUjhQbg7CZAACZAACZAACUSZwIZ/qcQsqmEU4bLtoMi/lZXi612un+hpFV4QQmMgd2NstULljcmb3bc9Oodzq1wnoRSE2rG6LB84IfK3UarJppptpsBrBZaKnygryECC5fSVIiXyma3DOL6o1NUjP4fxgDwUCZAACZAACdiMAHWkG1eIA3Sk8ImKKWz0zFrj6wFuWjE+086qN/j/VGPyqmr0WQusF0cqr5A6L4vMVPvC7WTQ5yKFBoh8tlA17h4TKa4S6CHuDWLswKX6tGog3q3axeh9HjpN5KacIjuPiLwwWWTBH9aj+ywY37hPJEP6+MuTP6dUzhQySv65uScJkAAJkAAJkAAJJIeAar8cDY+whdjVLd8QuflJEXTuot3WeKgyyPvLKnCYCiV4763xhbscWUQaVRB5e2bCax+zSHmsrBNZvVPkwf/4Bn/x8Qe1/rZ/iLQZLlL3FZFFlv7d5yeJPD5OpPkwEQiHKE9PUO3G4yIvq77y975Xrs77RKaoa61zs8gIZbBpLCl9W4scUx7h6IR+6R6zJIzjK+dUPCC6QIeRKA9FAiRAAiRgNwIp1EioI6V+hYZPVLx0IkV3g7iIFYuIpPW7ohL5fcIf3F+sBVm2a5QUWakakii5s4qUVj3Uh0+p3mw1LFYNx4xKEERDr7jqPX7iTl/vNVydMf+HaiSqZrIgFg96pW9XjdzZa/WhtFVjSXVeWEqGrUBhPn8gbIfjgUiABEiABEiABEgg4gQuqt5XNLrCUKoUE/lXd597M8S/zapZBI+RukqwQ1mySaRyUd+09S+sAOetty7xTT/Y3LdvYyU6jnnEN9yU6/p2EDE7ve87x/fPibStIXKXEhfRpkTsw+EzfVaREwaKjF6o2pDqmhCCB+Wt+0WebCMy/69OZ6zLn0Pkq+U+V2hj3fjklyJvqm3D1wntO7/+i7A5MQFu3LIJJ0mABEiABEjA0QSoI924+hygIynZzR5l835lOWhpCJqrKv6XazLWI86iKXA/Qa8xCtyc0d41DdGHb/M1/NBI3at6m00xTeINSlBEGd1PpH1tX/bo3/aoIN+/+I758XyR75/1bcO/JEACJEACJEACJOA2ApcvX5YrV67IpUuX9BjTWHb16lU9xrwezh2WAsevSVHl3RGOgg7bx1r7LASHdvJ1KOO4EOl2KW/fQG1BiIrI7mzae0m9jk8WiJQvLFKmoG+PXk1EXvta5IslIs/fLTJ5kEiWDGr8m289xMZSqoPaWiBMYpufX/O1NW+rIlLhGZG5v4tcUNdcKn+YO6GtJ+c0CZAACZAACZDADQlQR7ohnqisDJ+omDGPal0dSvZFw2IwUC9vgb8asSeVB0iwEqwDHZaKaPCZYrYzDdbMqpGIAuvIxuV9vc/DZ/ji5vQf41sHlxxs1/cTFUtHiZCBYun4tkzkbzrlv5NFtWxZSIAESIAESIAEXEngmlK9Ll68KBcuXNBiHcaYN8vMNIQ8M42xmbeOrdMQ98wxsdwMEADN/hAEsdwsw3ywAdukT59eMmXKJOnSpdPTmM+QIYMerMvSqYZP3xqXtRAYrkp74i5lETjb52ZsjglRMVZ1EmPwL2gLnlPtxEtXRDL91Xbz3ybQ/J/KyNJaSitxsaA6FpZnzeQ73j3vKtdn1RmNYj23tc2I9qSZh0iJY8xRoiIyVDev5Gsj+o7gc9PepDrCB95hlqRgnCadSK6qKTgAdyUBEiABEiABmxOgjnTjCnKAjhQ+UbFAI9U6/PrGQG6wFo201X8m3ACxElHgshyugh5r9DrjfHdU9x0VDcY82ZS4WCG+cAhBMZNahwaksXRM3nWovcGIhQRIgARIgARIIKIEIJqdO3dOzp8/rwczDWHOOm3WYwxxzroO22K5EQbNNOatA4Q77GfEPQh1mTNnlixZsmiBDvNmmZnGOiPqYVnGjBn1NmY55jHkyJEjbh0EP7PcOsZxMI97NtaGRpA012TuwVw37uXMmTNy9uzZeIN1+cmTJ/U67LMwewElKvopdCmowaGqudirsfIYUZaEfZqKNCinEvNlVXGxlcfKfhWSxr8geV4B5XociqCIYxRV/d2ItXT2wvVszelVR3Ix5QUzX3kVD/xcuWKP8IXD8T+nERGrKpftGBXBZvshFQvyJt9WaBciOcwjSow8ezH+nkgUgySD4Sgrd2WSwZ/8INnz/iHZs2fXvweMrUOuXLkkW7Zscetz5swZN501q4LKQgIkQAIkQAJ2JkAdKZHasb+OFD5RsUQXFcxQ+Q0nMwN01eK+hCv+RPcdV9mdVQPQuDZb15uGnBlfVD3YKMjkh4LlSOiCgh5pWDvGqAFxfB5TMRYR3PuF9r71y5RFYg+l+cEdGoMp6M3Opdpk/1TxclJUoDDnrJyiQ3BnEiABEiABEnA6AQhf/mIWRDmzDNOB5s1yI3xhbJZhbOYhpEHog6ACkQ6DmYb4AhEPy4zwZ90G6/Lnz6/XmfUYY38Id5gONBixEOOkFoh1p0+fllOnTsUbQ+yLiYnRyzB9+PBhPY1tMYAT1mMdBizDGNcFsQkiE+7JCE9GcMK8mcY9lipVSs9jmRmwDfbFPO4ZY8zLgR9UEELVzgtDBmgkxoPIN1G5Hm9TQl3/z1R87GE+bxW0BQ+cTEhwnxIabymZcDmWnFNtvcwZr6+DxaNp+3VrqGJrz/dZFXaoo0LiHBM5qNqAXRv4EsVgW2R1RlxvFGvGZ7T/IGQicUz5Qiosjoq7/WhrEbRLIXx2rS9SqahvP/MXyWQeaqHidIfJuLCsCiz+1Auvq/o9q+sYv3NT90ePHtXLUPf4DZnfgvl94HeB/wUI00Z4xLSZR11DgMRglmFslmGM/cwYv38WEiABEiABEgg7AepIN0bqAB0pjKJiZ5FVTyggqrWWjNJdNfxe/9oXPNvEvsFhZqge5k51VcMuZ/yDohGIrH0oSMZSQTX4Rs71zSN7IPZZvNHnyoJMf3BPKZxbpMpzIgjIjTg+j6iGbOf3RY6fVZaQqtf66Ta+/a1/4RqdVonDKSrpVbd11VeUqaNyY2EhARIgARIgAQcQgOWbESowTmyAmGG2gcBnBDAsM4IhxjguhAqIYEbMMgKWEbP8xa28efNqkQvbmXUQuzBvBus8rPoiVSCKQsSBuHPs2DE9xjQG3POJEyf0emxjtjPTGGMbbJtWNTCMiGMdQ8jBPWIZxoUKFZJy5crpebMdlpvBbIfjRawUVmpa7ltUFuhlyqzvrx7cZJzsf1tUB+5IkVc7+tyJkXBvlGrDdf3Q1zZ76i6RIdMSHnimagu+pvbxL7BC/N9W39IZq31xtCFAIlsz2oFNKqoMzn9TYuAXKkHfXl/s7I8fFKlewtcB/W917qrPq/iOqqO5rLJCRLtw4csiHZUA2W+0L+7iUNW8nfmsSM9RvsQyyCaNcDj+giKuAtaNxsLR/1pDnf92dUYpcvvTUqVKVSlcuLB2Uw/1GPhfw+8N/4Pmt2fm8Rs0v0tYpe7du1cwNsswxn74PZvfK/5v8+TJo397+J2aIXfu3HHio1mGMbbFPliPIRTRPdR75fYkQAIkQAIOJVCCOlLQmnOIjpRGxf8JEL0m6G3deMXOcSIrlGJ35cyNtwuydswikTV/inzYx7cBrApbvuHrzbYmafGtDf0v4jZCILS6z+AcKLBGjFjJrFqq92xXftVKXGQhARIgARIggQgRgGhnxAMzhohgncZ8oAECglluLP+s4pYRsTCGYAARz7oMgqB13giFWGbEQ4xTW1iAFSOEEgwQUYxoYuYhoGA5BjNtxuADNsZ6yyqgYNqIK1hvBiw30xhjGzBxnOXX+X0qiGCxCP1yrx/2rrdEXmwv0rSSbxnclN+aobxLlPiX3LjWsGbcecSXsCWLxeAOMRrRb4yY3pfVNI5vtNmTqsMZrszWckAJlsgAHSgGuHW7FE+rTuhOo0vK7tN5Zf/+/dpaFdalxYoVkyJFikjRokX1YKaLFy+u5/H7ilSBZS2eIxjw/2Ad8H9h/o+sy7Gt+b/C/1MapbiigwDXaf5fjOCI5WYZxEgsx9g6DVd/FhIgARIgARcSoI4UuFIdoiOFV1QEiiX3Kt+VH0WuKlPCZJR/TvdZJcJysZOyIkRvNmLtOLbAXLXlIpF8qsuchQRIgARIgAQCEDBioP8HOeatH/Lmgx4CoHWd2QZCnxGuIODBis1Yt5lpjPHBDtHPugxCl3Uex7JrQczA48eP6wGihRmwzEybMcQMLMcYyyAq+osVmDeChhmDkZk2YywDV8+Wi0qZ+0b5/F67HDgQYRjAQMwb+LnIKx18rs3PT1anfFIke+YwHNwJh4CpY4UnRGq9o64WkqdqUiuLw0OHDsmBAwdkz549sm/fPj1AcMQ0lu/atUtvC8ER4mOwAeJkahUIk3hu4f8QY/xPmgHz1v9TLMdzDW7e5n8XzyT8r0KAtIqOmDfLzf+2/zIImiwkQAIkQAI2JkAdKX7lOEhHCr+oeDlG5Md6Iqe3qQbn1fhgkjgH15IS+XwWhSYodhJ3tddm6ZX5Yw3V5V5eBQ5iIQESIAEScCUBuMPiIxkfvtYPZTNtHftPYx4DrPeM9Q4+hiHwmXmMrdMQuDCYbcx6jCPqAhuB2oPAB9EAYgJcic0AnmY51vkP2K9AgQKagxER/EUFszxfvnxx4iCWQUxlSQGBk7+pLCe3KdM+1d6LVeZ9ESiwIPxJxTm8qmJkN60Y38MkAqezzyHh5lT0bpFGf8X3CfHKIMJBZIQrMwaIjrt3746bxzJ0YJQsWVJbNsLC0X8oUaKE/n8J8dRR2dxqEYlnBZ4TGPB8wBjPUjw3rMuwDp0weF7i2WodILDimYBnBJabMZZjHsIlxcioVC1PQgIkQAK+dgV1JN8vwWE6UvhFRWC4qnyK/6saRmlVTKNY1Zvt1VLzbRV05xmv3j3vmwRIgAQcQ8B8rOJj1FjOmGn/sbGaMWNY3+DDFB+g+BA1loDGus06NuuNMGjGbnDrg1swPvTxUW8G6zym8YGPdZjGAHbmAx4f9GYwH/vgFWjwtLWgHf6rzu9XnikdVBjtP1TIG2VayJIyAmmU33W6TCobzT+UleKTKTtWInsj3inERYiNsHr0HyBKoqME4iIER4zNdKlSpbQFJOYjGbc0kVsIeTUiPRmh0dpBgWXmeYTl5hmF5UeOHNHhIPD8Mc8lM8bzyUybMTo5MI11TuvcCRkodyABEiCBSBGgjuQj6zAdKTKiIlBcPS+yoJXIibXea3DCxaLF9yKF7ozUvxuPSwIkQAIk4EcA1mv4MLR+PAabtm6HbYzVnxEHjWtdoLH/MuzrtoKPcDBC5mF8dOMD24z9p812YGA+qvFhbT68rdP48DaWQdgWAiyLUwmokNxbPhJZ+4KvA9nLncgpqcIM6vmRo7yK9TNOBfiukpIjhW1fWDwa0RFjMw0BEm7WECXxf20ER1g+QnDEPKYxoMPE6QVu56YDxDo2QqR1mXkOYhneEea5F2iM5yCWY1ywYEE+B53+Q+H1kwAJhJcAdSTH6UiRExXx04L785qnRbb+R4mMyYuxGN5faISPll7Fn0qvgmQ3VxHF89aJ8Ml4eBIgARJwJ4HY2FhtLWj9YLNO4+PNzGMaH3gQBmH1BqsSiFbGui3YtHU7bOMGS8HEfg1gBJEQoiDG1mmzzIzB11jomI9fM7Z+EGMaAwRCuhUnVgMuXX/hgMjyASqe9g8+cTGZoW9cSif4bcHVOa3KGlNruMog01dt55yYf3hGI46jERwhNGL6zz//1KIj5mGtZwRGq+CIaQx4brixmA4ZvJeCDaZjBu8vcESMWIiL5nlqHfsvx7wbBFs31j3viQRIIIwEqCOFEWbkDxVZUdFc//EVIks7i1w85k6rReO2Urq3L7B2OsZrMlXPMQmQgLcJ4OPT+mGFjykIVlhmhEH/MdyKER8QQlWgwYhdWIePL4iCGLxm9Qa24Hnw4EE9xscphEIkdPAfYxlchgsXLqyZ4sPUfKwGGkNATJcunbd/vLz70Aic2qSsFp9T4uJctZ8Khnj1Umj7e2VrWCamUeGBqr0mUq6/T1h04b2jEwPiohEcd+7cqachPGKAGzbExdKlS+uxdRrL8Hz3Srl48WJcJw+e6dbBdP6YZXhfIkakeYZjfNNNN8Wbty7DOie5qnulznmfJEACSSRAHSmJoFJ3s+iIirhHZArc+onIupfUtIrAfUXFXXRDSa8ah/lqidT+UCR3dTfcEe+BBEiABIISMNk4IQriI8cIhtZp6zoIhPg4hEhlLN3wwQMRMJBgiGUQDb0ckwrWKxAKIQQi0QLGZt46BmewKlSokBYLIbD6f0yaeXxYZsyorKJYSCDSBM7+KbJ5hGxc/G+JOZdG6pd2SXsvmdwOq3w2BfMoERFxxnOUFan8okjxjq4VE5OKCcIYxEWIjjt27NDTEB6xDGOEsyhTpozcfPPNWnSE0IgByzD2smW0ESEhOFo7kMy8dRneHwjRgQ4l6/sA7w28F8yAeQx8TyT1F8ztSIAEokaAOlLUUCf3RNETFc0VXjmjxMWPRTaorMixqhf78mmzxjnjtOlF0qihQEORqq+q1mIz51w7r5QESIAELASQXMN8iEAYNNMY+89DxMIHh1UgDDRtxEOMIXoxe6Yy2lKxufBxB2tCCIUQBzFtxtZpfCzj465o0aJxH4HmA9A6xgcirQktP2ZOpjoB/J4nT54s48aNk4Pq9z1t1ABpkGuxyOGlvkQkTmzzJZdqWmXpmy6LjF4gMmpBFun30EPSo9+zOt5ecg/ppf3QgQWxEaLjtm3btNAIsRHLMIYLMARHIzRCbDRDsWLF+N6x/FhM6Au8Z/AesnZUWefx/wuLdgiN5l0DMRLTGMw0xujE8nLnnwUvJ0mABKJFgDpStEiHfJ7oi4rmEmGtuPsrFeR7hMjxVWqpanwhKKddSxp1YYiXKCoweZleIuUf8wXWtuv18rpIgAQ8SQDiFcRAfBzgYwFCIMaBREJsBxdaiFMYjKVbsHkspxVD/J8V4meBL4RC62DEQ7MM9QCRFR+75oPN+oFmnc6cOXP8k3COBGxMAB0T06ZNky+//FKWL18unTp1ku7du0uLFi2uCztXTons+VZk1xSRQ0plQ+csYm27LbkLvFfQYZ61qLJG7CRSQoX+yVdP5s+fL59++qnMnj1b2rVrJ3379tV8bFyttr80PGNh1QjBEUKjdYCLMNypIToaa8eyZcvGiZB8xgavXgiQeKeZNgTaDsgIjnlr5xe2wzvN+u6yCo9FihTR6zDOlClT8BNyDQmQAAmESoA6UqjEIr596omK1ltDkO8/x6thksjJDfbpzU4HdxWVfAWxgYq0EyndU6Rwa2WlqARQFhIgARKIEgEjFFob+pj2n0ejH66zcCE2VgYYo+EfTDR0Y+bicFUL3O/wMYVMpxjMtHUM0RBiLIRCfDyZAR9aZhpjrKdVYbhqhsdJbQJ4Js2dO1cLibNmzZLGjRvL3/72N2nfvr1kyYJ2042KalMdXeZL7HLgR9WxvFa1+5Rr/jW1/MrZG+1or3VoCyI+IjrEM6r4fwWbqrbinaqdqIbMhQJeK57PEF8/++wzHVOwT58+ggHPCJbwEUC8RlgzYoDouH379rgxLB/xzIbgCKERoiPGGMqVK+e52LzJpX7lyhXdWWkVGq3CI9oneG/iHWncr8070fp+tE5TfExubXA/EvAwAepItqh8e4iKVhSXTqiGpmpkHlSBvg/OEzl/UDU2VQM19qKvV9u6bTin0yhTRPQwK0NEuaZ6mfPUUo3DNqpx2Er1MtdVC2GqyEICJEAC4SMQExOje/7RKDcNczTE0Qg3VgKYx4co3IiNhRvGZjDioVlHl6Sk1Q/ieRmxMJhgCO74CIJ1IQa4I/uPsYxB8JPGnFs5n8Dq1atl/PjxMmnSJG0JBiGxW7duKUyqocTEk7+LHFvuGyA4nt7iCzODUDOIpZSacbhhVYl2KNqBV5SAmCmPL4Y2QuDkrS2SX40z5Q+5cleuXKmtF6dMmSKNGjWSfv36Sdu2bT2RiT5kWGHcAdb5e/bs0UIjRMetW7dqwRHiI6bh/msVGY3YWL58eZ1ALIyX4plDwXIUbRxjuR9sGuIj3rEQGvFuxfsXY+uADlK6XXvmp8MbJYHQCFBHCo1XGLe2n6jof3OXT4qcWKcanL+pnu1ffQ3Pc3tVLEYV+Tq9yrKMnmItBF5VY+VSjZ5upCDHAKEQbtWIa6PHqmGoxUG1A1xu0FDNUli5qZRS8RHrKSFRNQ7zqGQrOSuq7dKqgYUESIAEQiMAd1i4FaPR7D+YXnzToIYYhcazGSAQohFtBEIjHEIopJVb0usBQezx0bh79+54A8RDLIOlIawsjFjoLxSaefBnPMikc+eW7iSA/5mJEyfqOIkXLlyQnj17aqtEWHVFtJzbI3JmuxIYt6lhs2oLKuHx3G6RC0dE8OGAtl1a5VaZRrXX0A7EH9P+g4dJrJpPo9qCSkTytQfVdtjWDGgXog2JpqJ6but9YXWYLrNIpnw+a0MkVsldTYW7UfeKaYzTZQvrbcN9fOrUqVpghKj14IMPygMPPKCt5sJ6Ih4sSQTwnobAaNyqN2/erMXGLVu26OQw+N1bB4iNmIcYyZIyAkZ8NB19ECHxvrYO6OxDW8kqNBrxsXjx4no5xnRxT1ldcG8ScAUB6khRq0b7i4rBUCBmDcTFi6pxefGYamCqAQHAtUXjJRny4Q/SoWUVqVG5pGoAqkZnWtVIzKh6lzOr3mS4qWRRrimZCgY7OpeTAAmQQAICiIuHxq1p6JoxPkKw3FgX5s6dO04oNIIhxmgIm3k0gr2cvTIB3BAWQLT1FwzNPFzbEOsJwmCJEiXiDSVLloz7EEEdsZAACQQmACtqWNDBVXf9+vXaGhFxEhs2VFZ5dikQFtEGRCfzJTVgfOW0tkB+97N58u7zbZVQqDqbY9WgOplPnr4iL30wV0YNvV+1CTOojukcqj2YS7kwq3jZGdRYtxFV2zBt6mVJh3AF1+jPP/9cKlasqK0XO3funASXcrtUiruvA+94CL/WAa7VEB7z5MkjEBjNAKER07B0TJ8eRg0s4SCADkHT9jJio5nHGG0BdCrC6hHiorXz0DqNdRSCw1EjPAYJOJAAdaSwV5pzRcVEUNxxxx3yzDPPCMYsJEACJHAjAoi/5N8zbm2kGiERjVSrS47pHUdD1VgXQjikO+yNaN94HeIYQhg0IqH/GOvwIeAvGJp5CIeoA1oY3pgz15KAPwF8rCM+Ityb58yZI61bt9YWiW3atHHUMw2i3OLFi7Vlpf89IowEBCBYf9u5oC5mzJihrRd/+eUXuf/++7XAWKuWCs3DYjsC8FBAGwKisBkgPGIaAhcErAoVKugBYjGmK1WqpOMd2+5mXHJB6AQGe9RLoAHrEMPRCI1oQ6CerGOsY5xHl/wgeBskEAIB6kghwPprU3adhc6Me5AACTiIAFxl0KAM1Lg0wiFc+tB4tAqGaFzWr18/LqYPBES606S84hHPCiKtCaLvP0amSdSFEQkxrlevnnTp0kUvg2hIC8+U1wOPQAKGAESrcePGyVdffSWVK1fW7s0Q5nLlUtZ7DizLli3Tz4xAl161alVteYnM1HYusGzr0KGDHvC8HDt2rM6qDVEU7tE9evQQWlvbpwbRiYU2A4bbb7893oUhqRHERYjZGH7++WcZM2aMbNy4UXd+GZERQqOZhnUjOyfjYQx5BgnqMNSsWTPovqZ9aNqI6MREAiq0FzGN/z1YoPqLjdZ5dGIyxmNQxFxBAiTgEQKutVS888475emnn5ZWrVp5pCp5myTgPQKIv2MVCwNNm55oNAJNjzSEKbghG0tDNBpZwkcAwqC/WIj5P//8UzfU0dAvXbp0wAEiIq0Mw1cXPBIJBCIAKypYJMK9Gc/IXr16aatEPCedXiAifPrpp1K7du0EtzJo0CAt3GDstAJruIULF8ro0aNl9uzZ0q5dO2292KxZMz4znVaZf10vQnls2rQpTnA007DIRzvFiIwQ+2HZiHHOnMpdnyUqBPA/B5d3IzIGGkOYNNaNqDPrYDpHM2ZMvZAKUQHFk5CAywhQRwq9Ql1rqQhrGLwMWEiABJxJ4PTp0/HcYNGYM6KhGWfJkkX3IBuxEB/EsEDBvBERGTMn/PV/9uxZHcQ+kHC4Y8cObUloFQ3hstepUyedLbZUqVJ0Jwp/lfCIJJAoAXTCIGszxESIFoiRCOtEN7nUIqs7rMKqV1dJ9wKUKlWqyJo1awKssf8idLbcdttteoCQAUH4scceEyR6Mcld0FnG4hwCcMPH0KRJk3gXjTAgSBRjRMYlS5bIqFGjZMOGDdpC1SoyYhoDOutYwksA/3MmDnbdunUDHvzSpUu6bYpOUzxXMSD8AsawdkR7FXVjFRut02grsZ0aEC0XkkCqEaCOFDp614qKoaPgHiRAAtEigIc1XI9No8saN88sQ0wpNLxMTy/EKLgVWQVDusFGrsZOnTqlg9GbLJjW8cmTJ3VMKNQNGsRlypTRdWOmEXuShQRIIPUJILTD9OnTtZAIt8u2bdvK66+/Li1btnRlRvkVK1ZIjRo1grqOwv0ZoqrTC9ygIShiwD3DXb1atWrSoEEDbb2IemZyEOfWMlyfYZmIwb+gvQRxEe7Tq1at0r9nzKO+/cVG7I+wLiyRIwArxJtvvlkPgc4CAxfT3kX7FsPvv/8uM2fO1NOYh7U42k9o5wYaowOdhQRIgATsTIDuz3auHV4bCTiUACzZ0GsbSCzEMjSw0DtvFQ2NeGiW0SU58pUPcRBWPVbBENNwjUTyGmSvRGwn/4EfKZGvG56BBJJLwLjJQjz75ptvdHzBnj17SseOHV0fj/TNN98UWGS+/fbbAfEhqzXeNRi7reCZjYzdcP3GM7xPnz7St29f/Rx3273yfhISgJuuERsxNtP4XUBshKCOMcRnTCMWIIs9CMAN3oSICTRG/NRAgiPETLSZGX/THvXIq3APAbo/h16XrhUVmbUn9B8D9yCBpBKAu5Vp+EA8tA5YDlER1mtwQfYXCzEPa0M2gpJKO2XbIQMiPjCtwqGZhzVo+fLlE4iGEBORzZqFBEjAOQT++OMPnXAFYiIEAwiJ3bp185R4cPfdd2sxDeEWghV8hC9YsCCoZVGw/Zy0HJ1FEBe/+OILHZevX79+0rlzZ6HFk5NqMTzXCld5CIxwpf7tt9+0ldz69et1iCiIi9YBgqNTEzSFh5Y9j3LgwAHdzjbtbjOGlSPa33DRRps70GD3TPf2JM6r8joB6kih/wIoKobOjHuQgOsJoGfbNFrQYLEOWI54h8ZFA72n1gHLCxYs6HpGdrpBa/wlE4PJjNOlS6c/nq3WhsYCkTGY7FSLvBYSCJ0ArL4nTpyoXSBheYw4iUi6EshtMvSjO2+PfPny6ezON4otCOERMQiRXdntBR1HM2bM0NmG4f5+//33a/doN8XRdHsdRur+Dh06pP9XIDCaAW658BKxCo2YhoUjBelI1UTKjovs4vAAQjzrQANiPgYSG9EmRNudHfwp48+93UmAomLo9UpRMXRm3IMEHE8AMQ0RPBoNkO3bt+sxxELMYwzXsBuJhrRiS52fANz6EEdp8+bNcQHcIR6itxrWN8gUabJFmjGFw9SpK56VBCJFAMlIpk2bpoVExFSDVR6sEpEF2MsFFtj4EMA77EbllVde0R/Sr7766o02c926ffv2ydixY3X8RbhTwjX6b3/7m0784bqb5Q0lmwA6kY3IaMZoc8DDBAmQIDLecssteoBYhWQmLPYlgPZ8ILERz0m0HYsUKRLnrQJ3atMBjWkKyfatV15ZZAlQVAydLxO1hM6Me5CAIwjAmtAIhlbxENPo1YQ1IRqEaDhg3L59e91rCTGRsXZSr4phWYI6MpaGGJtprIMFUoUKFbR4+MADD+gxGoHsbU69OuOZSSDSBGCNMmfOHO3ePGvWLJ3lvn///gKrOwT5ZxGBJR4SlSRW4OI5efLkxDZz3XrEwn355Zdl8ODB2v0byV0wjXc/BEaI0hSIXFftId8QrNcwtGvXLm5fPH8g2iPEwtq1a+Xzzz+XdevWCVyrITRiMEIjppnNOA5dqk/Anb1mzZp68L8YtCkhLJrwOPhmQKZxzKMdCstvq8hopuHtkiNHDv/DcZ4ESMDDBGip6OHK5607mwCC8cPa0CocohGAAcvgwmwEQ6t4iGk0GPkhmrr1j/qBWIhGOqwPTcwj9B7j489YGlqtD2khmrp1xrOTQLQJrFy5UlskwsUZ8U9hWda1a1dB9l+W+AQeeughnfl54MCB8Vf4zcHqqk2bNvo96bfKc7MnTpyQCRMmyCeffCKIlQy3cCR4gfUSCwkkRgAhFyAuIlYjxhjQpkEbBiKjVWxEu5PFOQTwjbF37954gqMRH/GdkTVrVp0ECu8liIxmDOGRFo7OqWdeaWACtFQMzOVGS10rKjJrz42qneucQgBuyqYX0STXwEsd03BRQS+iVTiEYGgERMY1tEctQzyEaIiGNoRDM4YrGhpiVapU0e5ExvoQyyj42qPueBUkkBoE8Gz/8ssvtZgICyG4NmPAs50lOAHEfYP4WqNGjeAbqTV4r8LKBtlyaW1zHdWKFSu0azQySDdq1EjHXmzbtq2kT0+npuuUOJUYATyzkCjIX2w8deqU/t+E0Ggs5+BKnTFjxsQOyfU2JIB4vvgWQV1bxxAckRzGiIzWMTyh6FVjw8rkJSUgQB0pAZJEF7hWVKTCnGjdcwObEEADLJhwCKs1uCKj5w9ik9X1APNsjNmkEtVlIFkKLGAQ6NzEIcIYDS80qiAe4qPXjFGXSKLCQgIkQAKw+IGYM27cOG3BjIQaEBLr1atHOEkgAH4lSpQQjNOmTZvoHnCT/te//qXFs0Q39tgGsFicOnWqzh4NsQBhNmDBiDYHCwkklwBcpeE6DatGDLDCxu8L3hhIHGQGWDjCCo7FmQTQaYMQS/5iI+Zh+Vi8eHHdJkZHuhnwG2DYJWfWt1uvmjpS6DXL7sfQmXEPEgiZgLE4RAPKDMbiEIKiv3DYvHlz3YCHFSKt1kLGHdEd4BKCOoN4aAREjFGfcO9BvC70vuNDDCIi6pDiYUSrhAcnAUcSQFbOmTNnaqvEefPmaZfcF154QdBDTuuw0Kr0p59+0gJsUgRFHBnWjKtXr6aoGAAzBJ3evXvrAULAmDFjpHHjxlr86devn3Tu3JnujQG4cdGNCSBkw2233aYHs+XFixe1wIj/RQyI1QhvDrSljMhorBqRXIjF/gTwDEb9YYAwYy3ofIclI9rL8NyBdTSs8hEKCO9DE/bHeO5gTO8dK0FOk4B9CdBS0b51wytzIAHEJ8LLEQ1xWK2ZAS9QxMPDCxMubMbqEGPMUzi0Z2Uj2Q0EQxMrCL3rmEfjFuKhERAxRgIV1qM965FXRQJ2IYBOCSQUGT9+vLYGg7iFOIkQanLmzGmXy3TcdUCMRRyvIUOGJOnaEUPw119/1YJZknbw+EZI6DBjxgxtvfjLL78ILGkhMEL4YSGBcBLAbw2CkxEa16xZoy0cEdIHvzeIjBjXrl1bu9mG89w8VuoRgCWrSUqIbyczbeKMG6ERbW18S6HTHiGgWEggEgRoqRg6VYqKoTPjHh4ngN40JEIxgqFVQDQ9bXB3NWb9GGM+c+bMHidn79tH76k12DiERMTcgruyyWoIAQACIrLpsZAACZBAUgngPQHXZlhlZM+eXbs29+jRQ4oVK5bUQ3C7GxBo0qSJDB06NJ4V1A02166XDz/8sBYubrQd1yUkgHjAY8eO1fEXYX0G12j8lmlJlpAVl4SHADpj8AyF0AiR0YyRZbpOnTpxw6233sr2WXiQ2+YoEJnRPjdCI34HJjY5QkBBZDQDhEZM871qm+pz7IVQVAy96igqhs6Me3iEAAQl01OGl5kRD5FxuWTJknGioVVAZHZe+/840EBBgwQNUzNATISVkDVTIYREWJIm1Z3O/nfOKyQBEogmgcOHD8ukSZO0VeKBAwekW7duWkzEs4UlfAQuXLigLVaOHDmS5FhscLuECBYTE8PYxMmsCgg9ixYt0pmjZ8+eLe3atZO+ffsKwrekSZMmmUflbiSQdALo4IcLrRkgNiLztFVohGUjsxEnnamTtsR7FYkQzQALV0yfOXNGWzL6i40IR8Rnk5NqOPWulaJi6OwZUzF0ZtzDRQTQKEamTfNCwhgvJQzIUAYrNQhLsDZEQxljvJQY78oZPwIEnIfFoREPMYagCJdzE6fnnnvu0a40tLJwRp3yKknAzgTwzPn222+1ReL//vc/wfPlzTfflNtvv50fMxGquGXLlmkL8lCSOyBUBToEEc4CbpQsoRPAx3mLFi30ANdFWOE+8cQTcvbsWW292KdPHylSpEjoB+YeJJBEAmiPY4A7Pgril6P9bkRG/CbR5sP/ulVohMcJ2/FJhGzjzQoXLiwYEKvTWpCwywiM+K77+OOP9XceOvrwW0Dcc3zfmTHiP1JstBLkNAmETsC1lopMBR76j8HNe8A6DQlSjHhoXjawRMyfP3+c6Tx6tWA+z1gdzvs14EMGvdSrVq3Srm0QEBGLBQ0HIyBiDCsh9lo7r355xSRgVwL4kJ0/f74WVaZPny4NGzbUcRLvvffeJFvO2fXenHBdw4YN0xaHb7/9dkiXi2RaqKuHHnoopP248Y0JQND57LPPdDbzRo0a6diLbdu2pYhzY2xcGyECCEuEzmUjNGIMd1q0BSE01qtXT+rXr6/FyQhdAg9rEwLnz5/XIvP69evjjdEpgu8+q9AIwZFu1DapuFS4DOpIoUN3rahIs9XQfwxu2AMuTUYwNFaHGMNFAi7L/qbwmEd8KxZnEUDDAKLhypUr9QAhEQIi3JdhdYK4OmgsIpgze6OdVbe8WhJwCgF8qCLhyoQJE/THBxKuwMUZCQVYokegdevW8uijj2r321DOOnLkSP1hOWrUqFB247ZJJACr3alTp+rkLujUheUi4i/CUoiFBFKTADqh0W6EwIh2JLLHI4xCgwYN9ACRsW7duoKYjSzuJ3Dq1Cn9LoBVq1VwxDPMWDNCcIQQDStXJohx/2+COlLodUxRMXRm3MMGBGB5iDiHePhbXwAIIA5XCH/xEG7LCOjL4jwCqGvEPFy+fLke0AhENm286CEeYoCQiHkKiM6rX14xCTiJwN69e7WICLc6ZIeHkNizZ08dGsNJ9+GWa8X7IU+ePIJYx6GGsEAWY4iREBVYIksAMak//fRTnawI7THEXrzvvvuYwC6y2Hn0EAjg+wHPBAzIDI+Oa/xWITAasRHhkFi8QwAWjOYb0wiO+F0g1AaMGDBAZMQYlo78znTPb4OiYuh1SVExdGbcI4oEEPMQbgpGPDRj9HojBgaEJNOLhDEaAEysEcUKisCpYHGIGFkQETFeu3atjoGIXmM07iAg4iWOmJcsJEACJBBpArBimDZtmrZKxPOoS5cuWkxs3Lgx4zBFGn4ix8fH/9///nctACSyaYLVsHiHxQnib/FjMAGeiCyACDxjxgztHg3xpmvXrto9ulatWhE5Hw9KAsklcPnyZR1SB88YIzaiIwkhE4zQCNdpejsll7Bz90MnFowdMCAuL8YwdoBRi7/YWKJECefeqIevnKJi6JVPUTF0ZtwjQgTQS2hEQzOGK3OBAgXixEMjIsISEYHWWZxNAB/raLBBPDTjzJkz6xg3EBHRYIMlIhttzq5nXj0JOI0AxA9ktIVFIsZoYHbv3l272FKAsk9tvvXWW4IMoO+//36yLgrubIj/h/cMS3QJ7N+/X8aMGaP5w8oU1ouw/A3V4jS6V82zeZnAwYMHBQm4jNCION4QkhA7FEPTpk2FIpI3fyGI3YlwW/5iI1ztITSamO41atTQ37T8hrX374SiYuj1Q1ExdGbcI4UEEKMCD13Eo8IAARHzEJOMaGjGiGGRI0eOFJ6Ru9uBAKxO4QKFBpnp9YVVIj7m0BgzAbORyY2FBEiABFKDADo4ECdx8uTJOowGRA5YU1HoSI3aSPycd999t47T16FDh8Q3DrAFkrTgHfTII48EWMtF0SCAtsGCBQu0uDhr1iwt3KNemjVrRkvgaFQAz5FsArBmxHcM2rRLlizRA8SiJk2aCCzZMcZ3DDMLJxux43c8duxYnNAIERreDvgWKlu2rEBgNANEx7x58zr+ft1yAxQVQ69J14iKEKpee+01QbwjFAgX+IdFwHQ0WJDlDz8QlugS2LVrV5x4iBcvxEOYjZuAt7ASwAMV8wx8G926ifTZ8D+J3lyriJgrVy7tOmLi06D+GQcx0jXB45MACdyIAEJswCIRYiLCZyBGIsREhNhgsS+Bq1ev6niK6JxKbvvh3//+t07WAGtFltQncOLECf2/CAtGuJoisQsSvBQpUiT1L45XQAJJIIDwTEuXLtXJXzA+evRoPJERnRgM35MEkC7eBFaNiNEIgdEMiNWIbyQjMppxmTJlKEpH4bdAHSnlkF0jKiImDoJ1ByroIWrVqpX8+OOPgVZzWRgIIGsa4koY60OIh3hQwm0VwpEZYAKOuIfp0qULw1l5CDsROHz4cLyGFNwA0POG+DMQETG+6aab7HTJvBYSIAGPEkAAdlgjQkzER2CPHj30AItpFmcQQNzdfv366c7K5F4xLEd69+6t2y/JPQb3iwwBJGWD2DtlyhTtzYC6btu2LTsiI4ObR40QgUOHDmkLRmSYhsiIJJMI72MsGdE2ZoifCMF32GHRQWZERjNGRwtizuJ7CjHlMV2xYkXmDwhz3VJHSjlQ14iKQHHbbbfJwoULE1CB++zMmTN1rIsEK7kgZAKIg4MeFauAiAch4hxaxUP0siTXeiDki+IOUSeAoMRoIJkeWYiKaCSZhhIaTeyNjXq18IQkQAJBCFy8eFG+++47LSSirdCuXTttkdi6dWt2dAVhZufFw4cP194pI0aMSPZlInZmzpw55ciRI5ItW7ZkH4c7Ro4ALEimTp2qs0ejAwCWi3CPRiw7FhJwGgFY4P78889xlozIPo/vJ8RjhMs/xsGMZJx2r7zelBOAqAiBEZ0sq1at0smDEEcY39gQGI3QiOzTNNhJGW/qSCnj5ypREVYHDz/8sHaZsGLBwxkxDRjTwkoladMQC9GTbx3A0YiHGMP6EC9EurEmjalTt4Kp/qJFi3SP6+LFi7VgiHgxJnYM4mDyf8yptcvrJgF3EkD4EzyvJk6cqIUJuJ7BtblTp060DnF4lcNqDeLSvffem6I7QUzfN998U7/LUnQg7hxxAohF9umnn+pQBeXLl9eWqp07d5YsWbJE/Nw8AQlEggBcYSEYQWhEbFETvqt58+aCASIjY/pGgrxzjxkTExP3XW6Ext27d+tvcyM0QmxEaDF+mye9nqkjJZ1VoC1dJSqiNxNBTmGNYAr+mQYMGCAffPCBWcRxAAKxsbE6cKwRD2GJiGmY5OMBZR2KFi0a4Ahc5CYC+BA3IiI+yCEmItYHGjgtWrTQ1oglS5Z00y3zXkiABFxEAOEXxo0bp60SYTHfq1cvuf/++xmbzSV1DAtDdBjjQyqlVj2PP/64FC9eXJ555hmX0HH/bSCeJqyOITAiSQb+t+EejbYqCwk4mQCebRAZ0e7GAJGxXLlyuu2N9jesGZnA0sk1HJlrP3PmTDyhEWIjDINg0YjOVIR2wQDXaRqABK4D6kiBuSR1qatERdw0eqynT58ed/9wZ4F7JmIRsPgI4IW1YcOGuIcPxEO4MiPenREPwQvTBQoUIDaPEMBvAr2kaMRASETPKERENGAwLlasmEdI8DZJgAScSODgwYPaIhFxEhHHChaJSLoCK2oWdxHAh/agQYN0OyaldzZp0iSZNm2afPXVVyk9FPdPBQL79u2TsWPH6viLaLfAerV79+607kqFuuApw0/AiIxol8+bN08nQKxWrZoO+XX77bfreOWZM2cO/4l5RMcTgEgGI6Fly5ZpoRpiNUJVQWREiCqIjBijU43FR4A6UvJ/Ca4TFWfNmiXdunWLc4FGxjg0OLxa8DJCAhX0WOBhAgERFmjIamkERIwhIsISjcU7BJCFGw2U+fPn6zF6PiEemoEWqd75LfBOScCpBM6ePStff/21FhORbb5Dhw5aTMRzDJmcWdxJYNiwYYLA6v/6179SfIPI/o3OM7wTWZxLAB4W6BhF5mh8CyBmKqwXUbe0zHFuvfLK4xOANx46VfBbR/sd33gQhiAwtmzZUgtGfPfFZ8a56wSQpA56ABKdmTHWGktG/JYwwPPTi4U6UvJr3XWi4uXLl7UrDD40MmbMKM8//7y8/vrrySfkoD3RoEK8GfOgwMMCFohIR1+vXr04ERFxELNmzeqgO+OlhoMAXiRITmCERHyQoRFiGiIQmllIgARIwO4E4Po4d+5c7do8Y8YMHXMK7s0QERhbze61F57rQ0B1uCu3adMmLAeEVwbaS+iIZnE+AbR3YLEM92hY6zz44IM6wQvr1/l1yzuITwCJX5YsWaIFRgiNu3bt0u36Vq1ayR133CGlS5eOvwPnSMCPADrUoBkYkRFjvBOhHWCoX7++Nj6CruL24mUdKaV16zpREUB69+6tGxP4drZ/xQAAQABJREFU8aMHp2zZsinlZMv98RCwCojIIIbYUehhMD0OCNTKjIa2rL6IXxQejOjN/OGHH7SQCMEZmZnRkwkhEe4T7L2PeDXwBCRAAmEiAEv78ePHC9xV0QkC92bEUsufP3+YzsDDOIHAhQsXpGDBggJ393B1kLZv316LTh07dnQCAl5jCATwgfzZZ5/JlClTdAfEAw88IEjywwQGIUDkpo4hgOciOt0wzJkzR38DQlyEyIj2P7Lds5DAjQjASGnz5s1aZMR3JLxAMI/4jBAYMTRo0MC1btNe0ZFu9BtIzjpXiorosWndurWUKFFC/xMkB4zd9kH2aquAiEYSilVAhJAIUZHFuwQQlBci4o8//qitEitUqCB33nmn/n/AbyVDhgzehcM7JwEScBwBJOKAxRGyN8PiCDESISYicD2LNwngYxkeKIiXHa7yxhtvCKzbwuFOHa5r4nHCSwDPD8TNHD16tGzdulWLyH379uWzJLyYeTSbEVi/fr0WF/HcRIZpGBTguwADYuvRuMBmFWbTy8HzEzoEBEYMSJCFjhkjMmKM35MbvEXcqCNF42cVVVHx/JVY+TPmXDTuSyrnzyEPDnpcnnltWMTPlzV9OimZK0vQ88ClBiIgYrskpSAOIiwyfvrpp7jgqhAVjfWhGTOwalJounsbPOTh7gAREcOpU6fiRET0TFJkdnf98+6cRyCa78Fo0knsPYhrgQVFoUKFEr2smJgYbVUEMREfRF27dtViInrGWUgAYW1goThkyJCwwUBokJdffll/dIftoDyQbQnAcwOu0V988YXOhorkLp06dQr6QXzfffcJPH/w2wtUvPxcD8SDy+xJ4NKlSzoRI4wPMCChGYxwjMjI5Jz2rDe7XhUMWYzIiDG8QytXrqyTBzVp0kRbhiMJbFIKrCMnTJigO42DbR/N56yddKRgPOy2PKqi4o87jsjZy1fsxiAs19O4eD4pmDVhrAG4aUFMRGDdvXv3BvygOn/+vFb80euOAf+YN998s06YYQTE8uXLszcpLDXl/IPgIT5z5kw94LeCniE0CjAgXiYLCZCAfQl48T0YGxsrcCvFuw6dH4EKwjXMnj1bxo0bp60q8DyDRSJi5tHCOhAx7y7DO+/999/X4TzCRQFxuPFBDUGbv7dwUbX/cdCJj7iscI+Gmx/CKaDNjgSGpsAoAImf8NH7xBNPCKxa/YsXn+v+DDjvPAIIo2UERsRbx7cm3rkID4DvT1oxOq9OU/OKoXUgMSwsGmHwAuMoiIp4fiJhFobChQsHvMTnnntO/vOf/+ht4JmSPXv2BNvxOZsAia0WRFVUXLTrqBy/cNlWAMJxMRnSppF6RfPGExXxj9W/f39tbQFrMsQ1hFsNlqFAzTduqkj1Xr16dYGqjwFx75iJORw1445jICkBHszISAUxEVareOEjKQE+vBkz0x31zLvwBgEvvQdRo0gIhWfVmjVrdAXDZQbvO1Pw/vv888/1uxLLe/ToIV26dOE70ADiOB4B/J4QTxPvwXTp0sVbl9IZWKJ9/PHHOqxMSo/F/Z1HYN++fTJ27FgtMObOnVvgGo2Ojccee0xb0KBzBBay8AKZPHmyZMqUKe4mvfZcj7txTriGAAR2GCpAZMf3xuHDh/W3Br438JtnLEbXVHXUbgTPzN9++00WLVqkLWSNyHjXXXcJBugdJvkLkmgdOHBAMmfOrBPuIh5o1apV410rn7PxcNhuhqJiGKrEX1Tcvn27/meBZSIsM0xBzyc+miAmQggyse4QONcNMQjMfXKccgL4cDIiIn4vsFw1QiJjoKScL49AAqlFwEuNok2bNgmy9CJWHTraEH9nwIABMmjQIJ1wBe7NePfhwx1iIuIgs5DAjQgg2QaS9eDDN9wFv8syZcrIU089Fe5D83gOIgCLRFjZwHoRHbmwokZyIFPwzEK8alh2mRAzXnquGw4cu5sAskjj949vEXjRwXIRHYRIauXWBKjurlF73B2sGOGVgmHDhg3SokULPQwePFjHzcZVwkIWnTYfffSR7twxV87nrCFhzzFFxTDUi1VU/Prrr6VXr15aTIRCby1wqYHbBNzA0HBlIQErAfSSf/vtt3pAbyEytRk3hGDm4tb9OU0CJGB/Al5pFOFjBLEQ0bGGj3RT0KGGASIixESrm6HZhmMSCEYAse+QaADWY+EuCFeDRB7Tpk0L96F5PIcSGDlypLzwwgty5syZeHeA9nzevHm19Q0ERq881+NB4IxnCOA9Pn/+fPn+++/1Nwq86SAu3nPPPTpRR9q0aT3DgjcaPgLocEZIHLg9w4sFMT+tBZbh+J2NGTNGd0DzOWulY79piophqBOIirUK5pDXn3tK96BbrROth0d8ADRQIDqykAAIbNy4Ub755hv9kt62bZvcfffdcu+992orVlqv8jdCAu4j4IVGETLzvvnmm/Es9U1N4j0I4QahG1hIIFQCJUuW1B8hFStWDHXXRLdHpvG6devqhEKJbswNPEEAcarhvheowJoGHSTaarZ0Vc+EdwrEgsu8QwCdhIib991338n06dO1y6qxYIQHHtxXWUggFAIwtEK+gEAF38KIywivvQOZ8/E5GwiSTZaxayEMFXH50kWpV7WSDjAfTFDEadDTiUxzLN4mgJcxer7Ru404JciIig/wI0eO6N9Hhw4d6A7v7Z8I754EHEkA7z/0Kr/11lsBBUXcFBJiwK2QhQRCJbB161Zt9RoJQRHXAvd7WKAF+7gJ9Xq5vbMJIEM04p8HKxBX0K6HkPLL/DnBNuNyEnAVAYjpCMOEzsN169YJEhnVrFlTG80UKlRIe+MhRAXCOLGQQGIEduzYoYXpYNuhXQlXfISP+3XhvGCbcbkNCNBSMQyVcHjXDhnc/V7JnSunNt1F/BWY8CLoLQbMI9kGGiAwEcc0i7cIQEicOnWqTkaAuGLIMAi3AQSGZyEBEvAOATdbKrYvX1gH3fZ3YQlUu0hgRmvsQGS4LBiBDz/8UH/Efvrpp8E2SfHybt26aSvaPn36pPhYPICzCUAUGThwoBw9elTH+sLHLQbEV0SMWAx41kFYRLijaZv2O/uGA1y9NbxTgNVcRALxCMTExGjrRXhgwV26QYMGWmSEBxaszVhIwJ8AYisi1BcsXPEcxWA0EyRjwzczxliGZy6fs/4E7TOf3j6X4twrKVS8pGzcvS9e9udAd2P+WQKt4zL3EVi9erUWESEm4oGIjKZ40cKdhoUESIAE3EgAVjt43pnGIDrSrNOwBENGP4xZSCAUAoi91Lt371B2CXlbZKNEhso+FBVDZue2HZABesKECUm6Lbd2FiXp5rkRCfxFALEWEeILAzoOIRgh18Dzzz+vLc06deoknTt3lqJFi5IZCWgCyAK9Z88e3SZEJmgzBGojztmyT85cD9FNgjYjQFExDBWSTqnoSSn4uGIw26SQcu42f/zxh0ycOFEmT56s6/q+++7TQd9r1Kjh3JvilZMACZBAEggcOnsx0c61JByGm5BAAgKwCFuyZImOW51gZRgXNGnSREaMGBHGI/JQJEACJOA9AkiyARERAzz2kFH9v//9r3abrlSpkja0oMDovd9FoDsuVqxYoMUJlmVUGaHlwuUEy7nAHgSSpobZ41p5FSRgSwJ79+4VZI1Ej/axY8ekZ8+eFBJtWVO8KBIgARIgAScSgPVglSpVJE+ePBG9fGSWPnTokBw+fFgKFiwY0XPx4CRAAiTgBQKwOkNyNgwQGOfNm6dDQiEuIwRGGGDAm6tw4cJewMF7JAFXEmCiFldWK28q0gQQNwRxnVq0aKHdmRFA/oMPPhBkj3zjjTeElomRrgEenwRIgARIwCsE5syZoxNiRPp+kYSgadOm2gU60ufi8UmABEjAawQgMMLldcyYMTpR5eDBg2XNmjU6LAq+qUaPHi0nTpzwGhbeLwk4ngBFRcdXIW8gWgSQdOe7777T8UCKFy8uiO/0+OOP66xVn3zyiTRr1kzwQcJCAiRAAiRAAiQQPgIzZ87UH6LhO2LwI0FUXLhwYfANuIYESIAESCDFBIzAOHbsWC0w4ptq7ty5UrJkSWnfvr0OJYXYjCwkQAL2J+BpUfGqEom2rFtt/1riFaYqgQ0bNsizzz4riPnw9ttvS7t27QQuz0jAgoxmCCrLQgIkQAIkQAIkEH4C8ACAS3KdOnXCf/AAR2zevLksWrQowBouIgESIAESiAQBCIz4ppoyZYrs379fu0N/8cUX2iUaYaVgyIEMwCwkYBcC1JHi14SjRMWvP/lQ+tSvKp0qFpHff/05/p2ouQuqN6PnrRX0+vefGSinTwY3n96ydpU83aGVDOndJcFxuIAETp06Jf/5z3+kfv360qpVK52VaunSpYIBWSFz5sxJSCRAAiQQVQJ4B/aoVVY6Vyoqr/bqJAPvaChvDXxQ/vfDjKheB09GAtEk8P3332srxWh5AtSsWVNnozx69Gg0b5Pn8igBPtc9WvG87aAEsmfPruPTI3v09u3bpWHDhvLqq68KvMRg5LF+/fqg+3IFCQQjQB0pGJnwLHeUqNjx4UelVrPb9J3PGvdpAgJLvpsm586clvSqt2PQP9+XHLmDB/QuX6O2tO3ZN8ExuMDbBBYvXqxfZHhxzZ8/X4YMGaI/LhAnsVy5ct6Gw7snARJIVQJ4B1asVVdy5csvr4+bJh/9+LMUKFpc3nniEfl1zvepem08OQlEigBExTZt2kTq8AmOmy5dOmncuLGgPcBCApEmwOd6pAnz+E4mkD9/fvn73/8uy5Yt02Ep4B2GmIzo/HnvvffkyJEjTr49XnsUCVBHiixsR4mKQJE9V27JV6iIrFw4Rw7t3R2PztypE/QHV8bMWbSwGG9lgJn0Gei2GgCL5xadPHlSRowYoTOQDRgwQFsn7ty5U5vg48WVNq3j/k08V4e8YRLwCoFsOXJKmr+eSbDcatern771VYvneQUB79NDBC5evKg/JO+8886o3jVdoKOK2/Mn43Pd8z8BAkgCgQoVKsg//vEPnRTz3Xffld9++02w7J577tEx7+kenQSIHt+EOlLkfgCOVEtgYXjt2jWZ/eWYODKbVq+QgsWKK8Hxejr6VYvny0NNa8mEd/8p58+elfefHaTdpzevWRm3Hye8S2DlypXSt29fKVWqlPz666+CZCt//PGHDBw4UPLmzetdMLxzEiABxxAwYT7wUYqyZulCFdajswx7qIc81/kuWb/sf3r5l++8ocODjH79Jdnxx28yoGV96de0pqz9aZFcvHBehwL55LUX9Lb8QwJ2IYDYhjVq1JDcuXNH9ZIoKkYVN0/mR4DPdT8gnCUBCwF0qCJTNBK8IMY9YjEOHz5cihYtKi+88IJs3brVsjUnSSA+AepI8XmEa86RomKlW+tJ6UpVZf5Xk7RYCBg/TPpC2vR4MB6X2s1ul/xFimqX6CzZskn3x59XcRaPy5XLl+NtxxnvEDh//rx89tlncuutt+ogwOXLl5dt27bJxIkTpUmTJt4BwTslARJwLIFYFaw85thR+WP5L/Lxq89Kzrz5pP0D/WX31s0y/NF+8vdh78jLoydI7eYttbh4cM8u6fTIYxIbe1UKlywlZapUlzvu7yWXlRVY1XqNJJOy7odLdfsH+zuWCS/cnQSi7fpsKMK1Dglijh07ZhZxTAIRJcDnekTx8uAuJZA1a1Z54IEH5KefftIhK2JjY3X4iqZNm8q4ceME330sJGAlQB3JSiN8044UFdFD0Va5fCF+4uLpUyXm+DHZv3ObVKnbIAGZDCr2gilx02p/Fm8R2Ldvn7z00ks6yO+sWbNk2LBhsmPHDnn++ecF8TpYSIAESMApBM6eipFRLz8tv8yZJfcNfFLHVsx7UyGZO+VLKVKqjBQqXlLfSvN7u8jlSxdl0TdTJIsKfN7gzrvllx9m6XX5CxeRMzEntaUi3qXn1VCoRCmnIOB1eoRAaomKjKvokR+YjW6Tz3UbVQYvxZEE4AoNi0V88z311FMybdo0KVasmDzxxBOyefNmR94TLzr8BKgjhZ8pjpg+MoeN/FEbt71Hxr39fzJr/Gdy9vQpadm5R+RPyjM4jgBcnBF344cfftAJWJYvXy5lypRx3H3wgkmABEjAEMiRJ6+8+PEXZjZufHjfnrhpTNxUrIS2YjTLb+90v7zco4Mc3P2nLPj6v1K2Wg1BgrPjhw9Jozb3xNuXMySQ2gSQ9RNWJrfcckuqXArc65CspWPHjqlyfp7UWwT4XPdWffNuI0cgffr02iUabtGwOEd4q2bNmunY+f3799fP9AwqqSuLdwlQRwp/3TvOUhGxFK8p0+YMGTPJHV17KgvF7TLzi9HStH2noHSwPYt3CCBQ79SpU6VRo0bSuXNnqVOnjvz555/ywQcfUFD0zs+Ad0oCniOQr2Ah2b1lo1w4dy7u3tOpxjWSm6FUql1PuT+Xls/+8YqOP9zx4UGyYsEcWTBtkjRo3TZuH06QgB0IfPvtt9KuXbtUu5TbbrtN5syZk2rn54lJAAT4XOfvgASST6BEiRLaO23Pnj2CZJwQGGG9OHjwYG3RmPwjc08nEqCOFLlac5yoeObkCe3uDCR3dust+GBq0q6jZFYxFVBOnzgul1TQ+cuXLun5fDcVlm3r12k3L3w8ocQc86WfxzaIYYIfGIvzCVy4cEFGjhwpZcuWlQ8//FCefvppgaXDk08+KTlz+pIYOP8ueQckQAJeJnBKvePOKev8QFkOG7e7V8VNjJV1Py/SiI4d3C8njxxWVojt45C16NhVVqskZnf3fljFXGyl350lyleSTFl879C4DTlBAqlM4LvvvpP27a//dqN9OYirePjwYX54Rhu8B8/H57oHK523HFUCsEzs0qWLzJ8/X5YuXSr4ZqxWrZp07dpVfv7556heC0+WegSoI0WOfbrXVInc4eMf+c+Yc3L+SvKtBr94a6gsmj5Ntv2+VoqWKSulKlbWlor39hsgOXLnkUkfvCX/+2GGDj5/YNdOHYA+rxIVf5j4ubZmLFGhksp6+bukSZtWu4R9Neo9OX7ogM58Wb1hU4GPfXJKOrVfsZxZJFuGdMnZnfukkMCpU6fkvffe0y+GS0oo/uijj3QPVKVKlSStqmsWEiABErALgZS8B7/6+ANZOutb3XF2SCVfqVCjtmTJlj3u1goUKSbZcuSQSe8Pl4vKbXT8v4ZJN5WgDEnLTLmpeAnZu32r3P3AI5I2XTo5ceSQNFOW/oixmJLC92BK6HFffwLHjx/XWTw//vhjgStbahS0CVevXq3bEchAzUICwQjwuR6MDJeTgP0I5MuXT1q3bq0tF/GuQcz9zz//XLJkySKVK1cWxNRlsR+BlDxncTfUkSJbp2mUlV7UzPQW7Toqxy9EP/PypYsXNMWMmTILpjEOZ8mQNo3UK5pXCma9nhQmnMfnsQITOHLkiBYT//3vf0vbtm3lxRdf1C+DwFtzKQmQAAmkPoFovAcvnj8nh/buEQiIyOzsX+Aebaz7rdP+24Uyz/dgKLS4bWIEkLVz+vTpOtB+YttGcv3o0aN1XMUvv/wykqfhsR1OgM91h1cgL9/TBCCFIPY+wmStW7dOEHdx0KBBAvGRxT4EovGcDXS31JECUUm4zBNmXBARjZBoxglRcIlTCOzfv18ee+wxKV++vMTExMiaNWtk/PjxFBSdUoG8ThIggYgSgCtziXIVAgqKOLERFP2nI3pRPDgJhEAgtV2fzaW2atVK5s6da2Y5JoFUI8Dneqqh54ldTgBW6XfddZcWFpGcC9mjb775Zhk4cKDs2LHD5XfP20uMAHWkxAj51ntCVEwaCm5ldwKwTHzqqaekatWqklXF0Ny0aZOOoViyZEm7XzqvjwRIgARIgARIIAkEEMYEQh48EFK7lCpVSnKokAK///57al8Kz08CJEACJBBhAjBYQTKXLVu2SJ48eaRu3bo6FuPy5csjfGYengScTYCiorPrzxNXj3gXcG2uUKGCTk6wceNGefPNN+Wmm27yxP3zJkmABEiABEjAKwQQSP+WW26R/Pnz2+KWW7ZsKfPmzbPFtfAiSIAESIAEIk+gYMGCOmv0rl27pEmTJnLfffdJixYt+C6IPHqewaEEKCo6tOK8cNlIwII8QuXKlZMTJ07Ib7/9puNdUEz0Qu3zHkmABEiABLxIwC6uz4Y9RUVDgmMSIAES8BaBbNmy6ZBb27dvl379+smjjz4q9evXl1mzZnkLBO+WBBIhQFExEUBcHX0Cly9flhEjRuiYieghWrVqlSAZS7FixaJ/MTwjCZAACZAACZBA1AggQcs999wTtfMldqLbb79dlixZImibsJAACZAACXiPADJC9+jRQzZs2CDPPPOMzhhdo0YNnUwsijlvvQeed+wYAhQVHVNV3rhQfExUrlxZZs+eLQsXLpSxY8cKYhqxkAAJkAAJkAAJuJsAOhFz586tPRTscqeIq4V2yS+//GKXS+J1kAAJkAAJpAIBJHXp3LmzzhI9bNgwGT58uFSvXl2++eabVLganpIE7EOAoqJ96sLTV7Jy5Upp1qyZDB48WEaNGqVFxUqVKnmaCW+eBEiABEiABLxEYOrUqdKhQwfb3XLr1q3l+++/t9118YJIgARIgARSh0C7du1k2bJl8vbbb8vrr78utWrV0t+vqXM1PCsJpC4Bioqpy9/zZ9+3b5/07NlT2rdvr8eIm9iqVSvPcyEAEiABEiABEvAaga+++kpbgdjtvu+66y5+LNqtUng9JEACJGADAnfeeaesWbNGXn75Ze0a3ahRI1m8eLENroyXQALRI0BRMXqseSYLAcQmeuutt7TJeJkyZWTr1q06AG7atPxJWjBxkgRIgARIgAQ8QQCdilevXpWaNWva7n7r1asne/fuFXSEspAACZAACZCAP4GOHTvK77//LgMGDNDftBAbMc9CAl4gQAXHC7Vss3tErMSqVavKTz/9JCtWrJChQ4cKsmuxkAAJkAAJkAAJeJPAtGnTpFOnTra8eXR4wgUa8Z5ZSIAESIAESCAQAbwrkNBl06ZNAvfoli1bSt++fWX//v2BNucyEnANAYqKrqlK+9/I0aNHpVevXtK7d295//33ZcaMGQIrRRYSIAES8AKB3bt3y9xvpnrhVnmPJBAyATuLirgZukCHXKXcgQRIgAQ8SQDZogcNGqQ98QoWLCjVqlWTV199Vc6ePetJHrxp9xOIqqh44WqsK4lejr3myvsK502NGzdOWyfiwbpx40bdOA/n8XksEiABErArgQsXLsiQIUOkRo0akj1fAbteZoqui+/BFOHz/M4IgXLs2DGpX7++bVnAlW3evHly5coV214jLyx1CLjx+2bDyl/l4pWrqQOUZyUBlxDImTOn/POf/5S1a9fKn3/+KeXLl5fx48e75O6iextufM6CoFvaz2muqRKtn8T5K7GyK+ZcRE834p/DpFW79lKpWvWInsd68CwZ0knJnFmsizj9FwHEIHr44Ye12fcXX3wht9xyC9mQAAmQgGcIIJvts88+Kw0aNNAZAvMVKhLx92BqwOV7MDWou+ec+OhCvMKPPvrI1jdVt25dGT58uDRv3tzW18mLiy6BaHzfRPeORP77+Wfy3X8nyqQvx2shJNrn5/lIwI0EVq9eLY888ohkyJBBRo0apTub3Xifkbin1HjORkNXckv7OX0kKj3YMbOkTysV82UPtjosyxfM/FYe7ds74ucJy8W6/CBjx46V559/Xh577DF54YUXJH36qP7cXE6Xt0cCJGBnAkg68eijj8rJkydlwoQJgmyApkT6PWjOwzEJOIUAXJ/ffvtt21+ucYGmqGj7qorqBUbj+yaqN6RONuTpxyV/5vS6Q+yll16SJ598UphMMdq1wPO5jUCtWrVk+fLlMmbMGB2nF3GEhw0bJnnz5nXbrYb9flLjOXvxxBE5tm2DVGzeMOz347YDRtX9ORrwELOqRIkS0TgVzxGEwOHDh+Wee+7RcRMXLVokL7/8MgXFIKy4mARIwF0Ejh8/ruPoIDh39+7dZc2aNfEERXfdLe+GBFJOYNeuXYKhadOmKT9YhI9gRMUIn4aHJwFbEBg4cKCsWrVKZs6cKY0bN5YtW7bY4rp4ESTgZAJp0qTRyVs2b94siL1YqVIlQZgwFvsRKF68uOzZs8d+F2bDK3KVqHjixAnJkiULMwmn4g8NmRHh4lylShVZuXKlVK5cORWvhqcmARIggegQuHr1qowcOVIqVKigO1Hw8QUXF1p2RIc/z+JcArBS7Nixo/64svtd1KtXTw4ePCgI7cJCAl4gUKpUKVmwYIHOaIswHu+9957ExrozRr4X6pP3aB8CuXPnlg8//FDmzp2r/6/uuOMOHXfRPlfIKylZsiTf90n8GbhKVERPd7FixZJ469wsnAQuX74sTz31lP6IxgfCG2+8oeNFhPMcPBYJkAAJ2JEALLKRhOXrr78WTCO7PRqLLCRAAokTmDhxonTt2jXxDW2wBSxM2rZtK99++60NroaXQALRIYDfvbFanDFjBq0Wo4OdZ/EIgerVq2tDHHi41K5dWwuM6KhmSX0CRYsWFXjBsiROwFWiIsxTYabKEl0CO3fu1DFXkNVq3bp10rAh4w5EtwZ4NhIggdQggIZGly5dpE+fPjJ06FCZP3++ttJOjWvhOUnAiQS2bdumrQCcFKMQ4V2mT5/uRNy8ZhJIEQGr1SLa+u+++y6tFlNElDuTgI8A3KCfe+45HW/xu+++k/r168vGjRuJJ5UJIKQeRcWkVYKrREW4o8BMlSV6BNBjCXegBx54QFvp5MmTJ3on55lIgARIIBUInD9/Xl577TVtnYge5k2bNmn3zVS4FJ6SBBxNYPLkyXLfffc5KkwAXNSWLVsmMTExjmbPiyeB5BKA1eKKFSsE4gdjLSaXIvcjgYQEbr75Zlm4cKH8/e9/13GGR4wYIdeuXUu4IZdEhQDdn5OO2VWiIpRkmKmyRJ4AHnCvvvqqzm4KYRENDBYSIAEScDuBqVOn6riJiJmIDM+vvPKKZM6c2e23zfsjgYgQmDRpknTr1i0ix47UQbNmzSrNmjUTxJBmIQGvEihdurQWP3r06KG9lRhr0au/BN53JAg8+OCD8uuvvwo63tCRtX///kichsdMhABydWTKlEmOHTuWyJZc7TpRkZmfI/+jPn36tM7ujNhhyAoHS0UWEiABEnAzAQiIcNEcNmyYTJgwQRAHjjF83VzjvLdIE1i/fr2gPYHkD04rdIF2Wo3xeiNBgLEWI0GVxyQBHwFYLS5dulS3PZEEFZ3aLNEnQBfopDF3lajImIpJq/SUbIVkOPgAwMc04ofly5cvJYfjviRAAiRgawLHjx+XAQMGCAJo33///bJmzRpp0qSJra+ZF0cCTiAACwz8TzmxtG/fXlsqIkkdCwl4nQBjLXr9F8D7jxQBxFocPHiw/Pjjj3o8aNAguXTpUqROx+MGIIB8HdCYWG5MgKLijflwrYXA8uXLtaCIOA+jRo1idmcLG06SAAm4i0BsbKyMHDlSuzqnT59e4O7cv39/R8V+c1eN8G7cRsCJrs+mDgoWLCiVKlWSxYsXm0Uck4DnCTDWoud/AgQQIQK1atWS1atXy4EDB3RCVCRHZYkOAYqKSePsGlERH4CIN0B3tKRVfKhbff/999KuXTv55JNPGD8xVHjcngRIwFEEENqhZs2aOvkUphEoO3fu3I66B14sCdiZAJI8QKzH/5lTC12gnVpzvO5IEvCPtfj+++8zQ3QkgfPYniGQPXt2mTZtmvTs2VPq1Kkj06dP98y9p+aNUlRMGn3XiIqHDh2S/PnzS8aMGZN259wqyQTGjRunszvD9BrCIgsJkAAJuJEAkn116dJF+vTpo7M7I8RDlSpV3HirvCcSSFUCTnZ9NuAoKhoSHJNAfALWWIvMEB2fDedIIKUEHn/8cZk1a5Y88cQT8vrrr6f0cNw/EQKIqbhv375EtuJq14iKzPwcmR/zRx99pLM8w8XHyRYFkaHDo5IACbiBwPnz52XIkCFSo0YNqV69umzatEk6dOjghlvjPZCA7Qhcu3ZNpkyZ4risz/4g4f6MTNCIs8pCAiSQkABjLSZkwiUkEA4CdevWlZUrVwo8Cbt16yYXLlwIx2F5jAAEYKlId/MAYPwWuUZUZJIWv5oNwywExXfffVd+/vlnqVixYhiOyEOQAAmQgL0IIJtehQoVdMxEZHh+5ZVXJHPmzPa6SF4NCbiIACyAb7rpJle0Kzp16iT//e9/XVQ7vBUSCD8BxloMP1MekQSQLBVGP7AMbtq0Ka3pIvSToPtz0sC6RlSEpSLMU1nCQ2D8+PHy6KOPyowZM6Ro0aLhOSiPQgIkQAI2IfD7779LixYtZNiwYTJhwgRB0gjG5LVJ5fAyXE0AIVV69erlintEuAR0TLCQAAncmIB/rMX33nuPsRZvjIxrSSBRApkyZZKJEycKwnE0bNhQNmzYkOg+3CA0Avg2QN4O5O9gCU7ANaIiLRWDV3Koa5DZGa6AO3fuZDyxUOFxexIgAVsTOH78uAwYMEBuu+027TIC18UmTZrY+pp5cSTgFgJnz57VweW7d+/uiltCyIS0adPqrJyuuCHeBAlEkIA11iKMFho3bqy9BCJ4Sh6aBDxBYPDgwfLOO+/oznIkQmMJH4EMGTLovB3IvM0SnABFxeBsPLkGFgTDhw/X5tSIhcJCAiRAAm4gcPXqVRk5cqR2dUbW2a1bt8rDDz+sBQE33B/vgQScQACZK5s1a6Yb6E643qRcI60Vk0KJ25DAdQKMtXidBadIIFwEOnfuLGPHjpW77rpLFixYEK7D8jiKAF2gE/8ZUFRMnJFntkB25+eee04wxj8PCwmQAAm4gcCiRYt0Epavv/5aMD1ixAjJnTu3G26N90ACjiLgJtdnA56ioiHBMQmERoCxFkPjxa1JIDECbdq0EYQwu/3222lBnxisENZTVEwclmtExb179wot6xKv8GBbwAUQMY6mT5+uLXmCbcflJEACJOAUAgiLgQ/+Pn36yNChQwUJIqpUqeKUy+d1koCrCKCdhrbG3Xff7ar7qlmzpiCj9dq1a111X7wZEogGAf9Yi0gQydhl0SDPc7iVACwVf/rpJ2nUqJHOjeDW+4zmfZUsWVLwTcESnIArRMXLly/LkSNHpGDBgsHvlGuCEjh06JAO8Prxxx9LvXr1gm7HFSRAAiTgBALnz5+X1157TVsnVq9eXTZt2iQdO3Z0wqXzGknAtQS+/PJLLfIjsLzbCq0V3VajvJ9oErDGWpw1axZjLUYTPs/lSgIQFJcsWSIPPvigzJs3z5X3GM2bQrIWJAVmCU7AFaIier+LFCnC2FjB6znomkuXLsm9994r/fr140d3UEpcQQIk4BQCyMRaoUIFLST+9ttv8sorr0jmzJmdcvm8ThJwLQE3uj6byqKoaEhwTALJJwCPM3gU9OjRQxo0aKATT9BqMfk8uae3CdSpU0d7IHbr1k2WLl3qbRgpvHu6PycO0BWiIjM/J17RwbZ46qmnBJY8r776arBNuJwESIAEbE8AAmLz5s1l2LBhMmHCBJk8ebIULVrU9tfNCyQBLxBYtWqVXLx4URo2bOjK261du7ZcuXJF1q1b58r7402RQDQJINYinhkzZ86k1WI0wfNcriOAd+63334rSOKyevVq191ftG6IomLipF0hKsIctUSJEonfLbeIR2DKlCkye/Zsefvtt+Mt5wwJkAAJOIXA8ePHZcCAAdKyZUu5//77dcy2Jk2aOOXyeZ0k4AkCsFJEbFM3l65duwraVSwkQAIpJ2DNEG2sFhG7lIUESCA0AnCFHjlypPZMPHjwYGg7c2tNgKJi4j8EV4iKtFRMvKL9t9i1a5cMGjRI917kzJnTfzXnSYAESMDWBK5evSqIAwtX5/Tp08uWLVukf//+DINh61rjxXmRwIULFwSi4gMPPODq24fLJu6Twoerq5k3F0UC1liLsFpEhyHe9SwkQAKhEYCl4sMPPyzt27cXvJNZQiNQqFAhgREDwsaxBCbgSFExJiZGsmbNKsgY1rRpU+3mtmPHDu3yhqCkZ8+eDXy3XKoJoMGLTM/PPvusVKtWjVRIgARIwFEEFi1apJOwTJs2TTA9YsQIyZ07t6PugRdLAl4hgDinsDRCoHM3l6pVq0revHl1cHw33yfvjQSiTcBYLXbv3l2HUGCG6GjXAM/nBgIvv/yylC1bVnfwsfMraTW6fft2QfKoTz75RPLnz69F2Ro1auhvjjfeeCNpB/HIVmnUj8qRtuTIHmhVi2GpYoLxI2nL5s2bPVKFod/m+++/rwO3LliwQNALyEICJEACTiCAUBdPP/20rFixQvBRwYzOTqg1XqPXCTRr1kwef/xxT/y/IpwMLKlGjx7t9Wrn/ZNARAjs3LlTiyL4Bvz888+lfPnyETkPD0oCbiSA2L8wyEJysSeffNKNtxi2e/r999913olcuXJpzen8+fNxx86YMaO89tpr8uKLL8Yt8/qEIy0VUWmNGzeOV3f4Jzlz5oxeNnTo0HjrOHOdADJl/9///Z9W3CkoXufCKRIgAfsSwIt8yJAh2joRiaU2bdrkCYHCvjXCKyOBpBHYunWrbNy4UffuJ20PZ28FSypYUCMpDQsJkED4CcBLbeHChfEyRDvUPib8cHhEEkiEAIywkMwQVnZr165NZGtvr4Y3Jzot4CFrFRRBBYZsjN8e//fhWFHxjjvuEKjE/iVHjhxy3333+S/m/F8EEEcRlj7lypUjExIgARKwPYGvvvpKx02E9Q8yPL/yyitxVum2v3heIAl4nMCnn36qE7TgQ8YLBRnna9asqbPWeuF+eY8kkBoE/GMtwtCEsRZToyZ4TicSgDCPsEFIbsiQcTeuweHDh0u2bNkSbHTu3DmpU6dOguVeXuBYUREvEOPubCowe/bsMmzYMAbqN0D8xujZW7dunTzzzDN+azhLAiRAAvYiAAERbpP/+Mc/dK/qpEmTXB+TzV41wKshgZQRuHz5snZPfOihh1J2IIftjYQtsARhIQESiCwBE2sR/3MNGzbUYVFiY2PjnRSebKdOnRKMWUiABHwEunXrpi3tEJqEJTgBJLZBLEX/gtiUCMXHcp2AY0XFW2+9VaASWwsqFwlIWBISwEsWD4533nknoIVnwj24hARIgAQiR+D/2TsPMCmKpo/XcYEsOWdEhJMcFQRRyQKCgAiKRFGyCqiooL5GMKAgBlQUAfUT9RUMBEVFFAReRUCQnHPOHBe/ql724u7dhsnz7+e529kJHX7V3TtTU121YMECWr58eZZIqadOnaJhw4ZR69atSZYS/vXXX1hioJ8YkDMI6Ebgm2++oRo1arhuZYRE2fzxxx/p9OnTurFFxiAAAh4CYrUo9wzia1nuKzJbLb7xxhtKKQDlCXoMCGQkMGXKFFq4cCH9/vvvGQ/gWyoBmV9eeuklEsM1b5J9t956q/crPq8QsK1SURSI6Zfwimmq+FJ0yxKbYHvw559/TuJoFIENgiWH80EABLQmIFY83bt3p86dO1NcXJzKPikpiaZPn66UEDKPy1Km+++/H8GktIaP/EDAIAKy9Hnw4MEGlWadYq666ipq3749yX0XEgiAgDEEfPla3L59O0nEW7Ga/vDDD+nrr782pjIoBQRsQEAUZaJ0l3ttWPL6F5i41UuvVBRXe61atfJ/gUuP2Db6s8hr5MiR6iFUHPSKwuzIkSMwRfXRkcVKsWbNmvTWW29Bs+6DD3aBAAgYR0DeiLZp00Y5Pc6XL5+yoBYfuTKflyxZkqZNm0axsbHGVQglgQAIaE5g3759VLduXTp48GAWVzWaF2bBDMVi6pVXXqFff/3VgrVDlUDA2QR2796tfLnKc6G8oPQuiRYDFInoKgpIJBAAAQ+Bdu3akdyHS8wFJN8E5KXEqFGjVFBgMWyTKPRlypTxfbJL99rWUlHkJVpi0RbLg6m8icLadt+9WAIdSMeHqa5vPtgLAiBgDIGdO3dShw4dUqOoiQuL1157je655x5lab506VIoFI0RBUoBAV0JzJw5U43rzL6vdS3UQpnLPCdRr0W5igQCIGAsAfG12KlTJ9q7d2+qQlFqIBFcO3bsSPHx8cZWCKWBgIUJvPfee/Tiiy/S4cOHLVxLc6vWt2/fVD2TWC1CoZhVHrZWKopTXolalCtXLuVPI2vzsEcIiM+EBx98EDBAAARAwDQC4l+sRYsWWSLNyZKLWrVqwTWDaZJBwSCgLQFZavjOO+/Q0KFDtc3YRrlFR0crpeqMGTNsVGtUFQScQUCWPU+YMCGL732xWNyzZw+NGDHCGQ1FK0BAAwIVK1ZUkaDlJT+SbwLilknc7IkBm+ifkLISsOby5wR2bh13hCj+1JU//p5whiiZ3yypvwT+5L+IXBRRawKNvPtGmjqxF1EUh/yOKcR/RYiiCxPlLkqUtyyfF5215S7Zs2rVKnVjK+b/4lgUyQIEpA9fZOuFyyf47zj3cf5MOEeUxL7lvH2c+zbl4qhSuWKIIvNwXy7m+Yvhz7ylebukBRqCKliaQBDzqJojc/E8Kf1Nh3lUlAziPP3vv//2aSEg1ubfffedsj63NNNQKofxHgo1e1wD2fqUk0Rq/+CDD1SwEp8nuGTnxo0b1ZIysVaUl9+OSej35ooS/HPkX6FCBTpw4ECWQHDeC/PmzUsff/wxSVCloJOF7q2CrrvbL8DY8dsDZLzIC/5t27b5jHbs90InHvAzxuPjLlLu2mNo3IAWNPnh1koPpffzk53wmqRUTCE6v5Po7Gb+20J08i/P56UDHkWLEBRFilcJlpJMlJLIf/LJfySfSfzJSrKISP7kmzVRwsi2+uP97GdRnZfIEaKjOGKPKGEKVCQqUp+o0HVEV9XgT/bbFc1KSAenIUOG0NVXX02PPvqog1tp0abJpHRqHdFp/ju+ij/XszJxPysQz3oUN9JvJUlfTu3f0q+lj0uK8vTrXFf6tTqf+7Uo1FP4Lw8rF/NXISrRlPt1A6LCdbhP1+TrHPTwojjgn28C9plHe/fuTfPnz09d9py5PfLCQ/4kWIttE8a7bUWXY8Uh2xwRpT9BXiCIb6Zu3bql3+3K7euvv54mTpyollzaDgD6vbkiA/+Q+csyTlml9e233yqfivLi8vz58xmWQsu+9evXq2ekjAXZ594qY73xLZUAxk4qimA2hg8frgKSTJo0KZjLbHguxrgeQjNGqXj5KNGRX4iOccjyo7+yAnETK0vYIkaUJYmXWEnClluGJVY4iiWOKB+TuOwYtmgs2oiodCui4s2JijXhY6zMcUAS3yFly5alTZs2Ye2/EfIUy9pDi4kOL+G/pey8hX1TROZlBeBl7udshahXEuW7KM4lyVgSBWPZjkRl2nj6syjfkexPwKbz6HPPPad8tYj/REmyhEBu5sWnkSwRrF27tloWLVFiq1WrZh85YbzbR1bB1hSyDZZY6vlijdylSxflxDwyku+zXJ4kAvb3339PX331lfVJoN+bKyPw14W/KBMlYNKiRYvUWBQ/i2KpKO6zJNDnxVO7KffplXhG1YW+QZli7GgC+tChQ8paUQIdScwKxySbPj/Zjb8+SsVkVqIc/pFo/9dEBxex9SErFXOx5aEs8STWDlsxeZeZJrPyp2hDovK38x+/ZS9Y3Yq1DahOEqBFnKXLDS2STgTiDhHtns1/n7IlIivLI3OzApH7udndPFKWsrJCU6wey3YiqtKXlYztPMp0nVAgW40JOGAe/WFvLLUd/IECU7x4cRUNtmXLltSwYUNq0KCB/V52YLxr3MktlB1kq4kw5OWArI4YP368JvnZPRNRaJQvX15ZS0l0e8sl9HtzRQL+hvM/deIw/fL1NFr4zZf03vwttOypKGp5XT48oxouiTALxNgJE6Dvy8UlgAR2tbVPZAc8P9lRD6WdUlEEKErEnbNYofiTR7liZSWi77GUtleUQ7KkWnzYVe5NVLU/L5mOTTtug60+ffooH2WyBBpJQwKyVHnvF0Rbp/LS/T854ytWrxoWoWlWYqgYdRX/Y01n1XuJqo+ytbJcUzZWy8yB8+iyf1OoTrXiVKTW3bacR5VrAox3q40UbeqDuVwbjldyOXXqFFWpUoUkSIK8REDyEBg0aBDVqFGDxo0bZw0k6PfmygH8jefvwHsruz+jhtQJMHZCwhbMRT/99BM99thjtHr16mAuM/9cjHHTZRC+UvH030Rb3iTaw5ZasmxY/MU5LeUS33Zs+VWgEtG1rJCpzFZf3uWmFm2rRFQtUaKEurkvVowVo0jhE0g8T7TtbaJNL3n8GiqlefjZGpqD6svcn0s0I6r9FH+2NLR4FOaHAOZRP2BM3I3xbiJ8nYuGbHUB/Oqrr9K6detUAARdCrBppitWrKCBAwfS5s2bzW0B+j34h0vAbveQuLcKV+LWuB5zl2FykAjp5cqVo2XLllH16jZYrYkxbljfyKmg0JWKR9gacd0THIhiPStY2EpRBU7JqTgHHI9mf4wSBKb6CKIaD3OwjFKWbNTKlStp2LBhtHbtWkvWz1aVkqAo22Zwf3+cZc9WihL8xwlJFOPFGhA1nOYJ8uKENtmtDZhHrTePYrzbbRQFXl/INnBWQZ4pvslk2fNnn31GTZo0CfJq558eGxtLM2bMIAliY3hCvzcceYYCwT8DDkO+4N7KevdWoQgeYycUamFf8/DDD5MYJD3xBOt5rJowxi03xoNXKp5cQ/THYKILO9gq8YJVu5r+9ZLl0RJl99rhRLXY4stilovPP/88nTlzhiZPnqw/CyeXIP19eQ9PVPJEB/Z3WeIvfblKP6IGr/I2+5VB0p8A5lEPY6vNoxjv+vd9s0qAbHUlL76bn3rqKVqzhn8zkbIQeO2111Sk2Y8++ijLMV13oN/rijfHzME/R0SaniC88Yzqua+38DNqQDLH2AkIkx4nLV26VCkU//jjDz2yDy9PjHEPP6s9P3GtAlcqxp/giXogR7f9wRM1Obwu4ZyrozgYhiyNbvIWUaW7LdOuTp06kfjx6daNg80gBU9ALG/XjmELxXe5v+sYuTn4mulzhfRj8bvY6hsOVNRYnzKQKxHmUd+9wOx5FOPdt1ycsBeyNUSKHTt2pF69elG/fvyCCikLgePHj6ulZLt27aJChQplOa75DvR7zZEGlSH4B4Ur7JPl3mrlAE+Q0KRLYWfnmAzMvrcKBSTGTijUNL1GXKiJpeK+ffvoqqvEJ78FEsa4byFYaIwHplQ8MJ9oBd8oJvNEnRTvu1Fu3xuVn6jkTUQ3fEiU2/wIf6VKlaI///xTRR10u2iCb38y0cJ6ROfYGtcpS50DhRDJUdqbsiK1Mgd0QdKWAObRnHmaMo9ivDt3vEO2Rsh2w4YN1LZtW9q7dy9FR/NLViSfBO69916qU6cOjR071udx7Xai3xvR7/3LC/wN5Y97K/9d0XvElHsrb+HBfGLsGDp2shFNmzZtaPTo0SRGSqYnjPGcRWCBMZ6zUnH9BKLNr7lPuZKz+LKeERnD1l78BrrNrxwpukbW4wbtOXToEDVo0IDkEylIAvEnib6vQxR3hJXo7D/RranZbFYs3uPW1mvfbsyjgTM1ch7FePfIxYnjHbI1TLZinVizZk0VMTLwge6+M2Vp+J133kk7duygXLnY9YgeCf3eQ9WsOQ38jeWPe6vAZxEj760Cr1XamWrs1OXnr8N4/rLA85e4M5H0zDPPpMnIjC2M8cCpmzzGs7+r2TCR6J/noFAMVJxixXn5ONEiXj56cV+gV2l+3rZt25TDdM0zdnqGCWeIljQjunTQ3T9oIueV9xJt5ajuSOETwDwaHEOj5lGM9zS5OG28Q7aGyfbAgQP0zTff0AMPPJBWJrZ8EmjcuDGVLFmSvvvuO5/Hw96Jfp+G0Iw5DfyN5Y97qzTegWwZdW8VSF0yn5M6dg7g+cuMuSuzPPi7GCeZHuwVY9yHZLLZZfIY969UXMuRjTchyEc2ovNzKIWVsOeJvq7Iy2e3+jlH393yFvzaa6/VtxAn5r6yHwcg2uOJ7u3E9gXTJolwvvYRohOrg7kK52YmgHk0M5EAvxswj2K8p8nCaeMdsjVMtm+88Ybyo1i4cOG0MrHll8CIESPozTd1emGHfp/G3Yw5DfyN4497qzTWQW0ZcG8VVH2unIyxk0bNjLkrrfTULVl9sGnTptTvhm9gjIeI3Lwx7lupuOtDDlAxg/0nXg6xQWmXnb1IdJ7jXCSzm4RAUgKvOF3Heh257igbjl1OCOSq0M45wCtdN+7Peq2UeSrcQL8REUQ/tuII2dwIg9P+/fupbNmyBpdq8+J2fcwOnpeGHZQl0P4uvxnSzwMdF9nR1a0fi7PrZV2YSbiDIbvaO/gY5lHrzqMY71kHnlPGO2RrmGzPnTtHH3zwAT344INZy8QenwQkmI1Yf2zdqvFLZ/T7rLyNnNPA3zj+uLey7r1V1l6Q8x6MnayMjJy7spau9lStWpVEn5CsxYOqnzL87sYYt+UYz6pUvHyMaM0otrYLX5HwD68AHvsJB4w+TTSKdTbxObioW81xMdq8SPTWjxyAdghR2eFEB0757XIhH/i/lWzW+zjRl2yEVSB31myGvE80/rOs+4PaI1qjeG743+ODukyLk48ePaqW2GiRlyvySOGOKVZ5YmEaRgqmv4tCsR73weVbQi/QkH4sTLZ/EHol3Xol5lGy7DyK8e5/VNp9vEO2hsr2vffeUwFaKlWq5L9cHMlAICYmhoYMGaKttSL6fQbGGb4YMaeBfwbkGb5ozR/3Vta9t8og+AC/YOz4B6X12PFfks8jUVFRVKRIETpyhGMMGJkwxm07xrMqFf99lZd/5qD9C6BzrdruUSS+dg/RNaWJBrci6voa622S/F/8zJdEPZoSvTuIaMZgNpBivVwuNvgLJ72ayXXNyI+IHp5D9M1Yrl97okolMub+zV9EH/+WcV/I3+RNw84PPUE/Qs4k+AuPHz9OEv0ZKUACe79gk0E2pw0jBdvfa/Pq+IWsx2x2TWCFmtaP5eXCP8/ynJDNwA2sCe46C/OodedRjHf/Y9Hu4x2yNUy2iYmJNGXKFBo3bpz/MnHEJ4GhQ4fS7Nmz6fz58F5kpmaOfp+KIsuGEXMa+GfBnrpDa/64t7LuvVWq0IPYwNjxD0vrseO/JL9HRJcgOgVDE8a4bcd4JqUia/F2vB/2ElDpfCNnEU3sxpaAeTxdsV5lDoicl2h2Ngo7sVQskv/K+SG8+L4U77nW+/8rtkR8cYH3G9G8VURv/kD0/n1E5Yqm7fduneT7u7d/ZOVnQ+8eLT4Z8Z5Ptcgo4Dzi4uIoOjo64PNdf+LeeWxVGt4y9WD7eyR3i/Yc5CwqMo2+GLdKkk/vtnw3vR+LcvzsJqkKUkAEMI9aeh7FeM++F9t5vEO2hsn2888/p2rVqiln7tkXiqOZCZQrV47atGlDH330UeZDoX1Hv8+em95zGvgbxB/3Vpa+t8q+F/g+irHjm4t3r95zl7ccP58FChSgM2fCez72k7Wf3Rjjdh7jGZWKF3ZrolD8bi3RvhNELWtk7DM9mhA9+18uwod/xaEziY6zUu/dpUQD3yV6mq0W0yfxG9eNLR1vZ0PK+rxs9Pmv0/zRLfiT6N63iQbN8CxrPsRLpqV8WXp9jvUhnV/hFd2ssBRLyFJXEe3iFd6PfUb008b0JXgsGF+4kyg6KuP+sL4lXeQ13N+FlUWwF1++fJly5/axrjvYjNxy/rHfw2ppsP1drHWnLyFq/CTRtzxWxH/niI+ISg8j+uBnooqjiCqM5DhJ+63Sj3mSD5NRWIDtdjHmUbL0PBpmX8Z4t/CAhGxzEI52c/nLL78MK8UcaGd3WNOALej32aHmY9r1e58Fgb9PLGk7NeKPeytr31ulCTzwLYydHEvQ3agAAEAASURBVFhpNHZyKMXfYdEliE7BsIQxbusxnkmpuJcoInwLN/ETV6MsL13OmDtVLO5R6O08mrV7vj2Qi+bdD3Ugmnk/KxW7p50jPkJFMShKyvljiGY94FE6TmPFjKQHWCHZvDrRJyM8ZX65hpUyxYgebE9UmC0fZamzfN94QN1akFg0iuLx1hd4CerfnjzEGqwS108sKjVPElHYwCTRn+PjuZFIgRGI584QRgq2v0sMn3qViP63y1No4XxEVUpwYKKzREf4b9kEohhWbMvbCkv0Y3lTdulQGIRcdukFzKOWnkcx3rMfkHYe75CtIbL94YcfSJY/d+zYMfvycNQvgZYtW1KePHlo8eLFfs8J+AD6ffao9J7TwN8Y/ri3csQzaobOgrGTAUeWL3rPXVkKzLhDArVIQDbDEsa4rce4ljZ5qX1uy0G2CCyU+jV1o0JRz6YcFz+LgaYV2ziOBuvlPmcLLkl1KhLVZaWMWDWOZsWhLGduUJnod1ZmHmOlzK50SktRVEraxApFSe8NJurS0GPluJ4DyXy6ki3GrmYFDuf1/TjPOXb/Lz4Q8ublteZIhhAItr/L0mfpc5JkmbMoGWPLeb4PuYWoeEGiJnx8/0nPPvnvxn6c1np3bgXbr3KihHk0J0KBHQ9WLhjvgXG1wlmQbWBSeOqpp+jJJ9nUHiksAo8++ii98MIL1K5du7DyCfdi9PtwCYZ3PfiHxy/Yq4PlnVP+uLfKiZB+x4OVJe7HgpOFXfUJwfaLnKhgjOdEyHOc1RvpUn7W1qUkpNsR2qZYAiazsiRzKsFLjyWd5hXBwaQ9PnyEXl+NaDcvY5YkVl59efnzOjYQEsuu9GWLwkaSV8mZ54ohplhR3sjWjT9sIJr8DdF5jtMhFo+yhFp8O/7yr2fb11JtT45B/M/PGlADU758+dhKNKNoDSzefkXFFAmrzuH0d2//zFwBsVRMP4S855nSjyNZQZ23TOYq4rs/AphHrT2PYrz767me/XYe75Ct7rJdunQpnTx5knr27Jl9WTiaI4E777yT9uzZQ6tWrcrx3GxPQL/PFg/pPaeBvzH8cW9l7Xur7HuB76MYO765ePfqPXd5y/Hzabg+AWPc1mM8o+Ypf2WiyDx+ulbgu6uz/uGgjxWl4jtOkij+gkllC3vOXskWi94UxTWXYCuiDLztZaIBLYmGtSHyKg2953k/q5ZkvQgrFP/a7d3jWWIqgWFuvJaoVU2ikqz0lD/JIzcrdWTbayGWdlWQW5G8trXcbUFeFN7pEayBkj+kAAmUaB7gib5P07q/+y7Fs9ecfsx9KUxG2bXJcccwj1p7Hg2zL2O8W3jEQrY5CCf8ufyZZ56hCRMm4MVlDqQDORwZGan8Ur700kuBnO7/HPR7/2zUkfD7fbYFgH+2eNSTVJiMVAG4t7L2vVUOvcDn4TD7Be7HfFLVbKfh+gSMcVuPcVadpU/8w3v1YKItb4QVsKVWBU8AivQ5y7YEWxFloHepZ/rjcWzdKJZZicmevZcTPZ9iKXjDNUSV2d/hwnVskdjCs38VWxPezbog8c8ogVdEYSn5b+AlzWK5eJatIfPl9lhFnuHtI2eIRvFSacnjsS4Z85Dl0PLnTWIBWSgfR46+y7snnE9uQKXe4WQQ9LUpvKZW/pACJFCRLS6OLA05AnQo/f3CZU/dvJ/e/i7+QyXJfgnoIsn0fixvyq6K9VQG/wMggHlUIFl2HsV4z74P23m8Q7a6ynbZsmV06NAhuusuTW6Osq+rS44OHDiQRFG7ZcsWuvZafsMdSkK/z56a3nMa+BvEH/dWAtqy91bZ9wLfRzF2fHPx7tV77vKW4+fTeH0CxriIwq5jPKOlorSk5hh+qZRJ1yj7g0h9mrF+hpWCmQOyfLOWqHsTNnpiC8DM6YnPPXumLuJlzHuIXlrg+S5RniUa87zRRLKmfeRHnijQYu34aGei2hWImrHScfTHnuXLnRsQzfmdSIK1iPVhGbZyvO4RDsxymqM/d/coHHu8TnTL82wxyZaOYzpmrokn2Esu7tdhJ5kMqg5g08dSYWcVTAbJrJmCUjEIYhV7sNBDt9ANtr+Lde2jn3rqJ8FY1u7iaNA/eL4/x/19GS+9lz/p779sMrkfR+UnqjWB54TIIIDiVMyjFp5HMd79D1C7j3fIVlfZPvvss/T444+TWNghaUNA/F+PHDmSJk+eHHqG6Pf+2Rkxp4G/cfxrcuRNPKOSnZ9RM3QWjJ0MODJ8MWLuylBg1i+m6BOgh1KBju04xiNY+ZTVpG3Xh0RrRrKp1JX1yln7WY57Zv7CypLdRNP6e04Va8HWHG1ZIjQHE6TFc7Xnv1hxbTtMJEuWS2YKBHOBFTX5r+iFLifw8uVozzXi704E4/0ue6UuksQaUbcky4/zlCbqxNqh6EyV1a1QT8bt27enMWPGUJs2bXQuyUHZ72Kt9Jrh3OfPh9QoPfp7+oqY1o9FIX77DnaLwIMOKTgCmEeD4+XrbL3mUYx3X7Q9L8DsPt4hW11ku2LFCrr77rtp27ZtFBUV3otn3xV0795Tp05R1apVaePGjVS2bNnQQKDf++Zm1D0M+BvHH/dWvlkHs1eve6tg6uA9F2PHSyLjp1FzV8ZSM3wzTZ+AMZ5BDiF9MWGMRz7NKUtli9RnU0OOjnL8jyyHAt1Rv7LH4nDLIaIafI9051S2PuRVwBK1OdQkfCQyrld5mD4fCWzhTVHpXqJH83b673KO+Ez053vRm0fYn1EFiNqtZEeO5cLOKtgM5syZQ82aNaOrr7462Evde36RukQnVvO64z28Dv/K2vsgaOjR39MXb0o/FkvbWxbzgKuSvirYDpQA5tFASfk/T695FOM9K3OnjHfIVhfZ3nfffXT//fdT48aNs+aPPWEREGvFI0eO0OrVq6lt27ah5YV+n5WbkXMa+BvHH/dWWVkHu0eve6tg6yHnY+xkpWbk3JW19NQ9pukTMMZTZRDyhglj3LelorcFq+4j2sPrNMOwWFzEPgwr8lJlsRS8mo2eHJ9E8ynGn11ZOZWvoinNlZvSsWPHhn5zakqtLVBoAjveXNyU6Nx2luEVh4ZBVssx/T2KzXjrTSKqzqbFSOERwDwaPD8j5lGM9zS5OG28Q7aaylaUXT169KAdO3ZQdDTfzCFpTmD//v1Uu3Zt2r17NxUqFOLqFvT7NLmYMaeBv7H8cW+VxjvQLSPurQKtS/rzMHbSaJgxd6WVnmHLdH0CxngGeQT0xcQxnr1SUWq/nv2pbX6NFYtX1gwH1CKXnhQZw0udCxO1+ZWo4LWmQWjXrp1SKmL5cwgiSOJ+/n+81DcXPzgl8zp6t6b6L7N/VfZdg6QNAcyjgXM0ch7FePfIxYnjHbLVTLZdunShDh060NChQwMfxzgzaAL9+vWj2NhYevTRR4O+NvUC9HsPCrPmNPA3lj/urVKHfo4bRt5b5VgZHydg7HigmDV3+RCJJfQJGOM+JONnl8ljPGuglsz1rPMsUfNPPH4BpbJIvgmIQ9VSrYlu22CqQlEqZ3y0Jt9IbLk3ki30erFisVgTXjfvQj+C8objloVQKGrdeTGPBkbU6HkU49254x2y1US2v/32G61fv54GDRoU2BjGWSETeOKJJ+iVV16hs2fPhpwHod9r0u9DFgD4G8sf91aBdVWj760Cq1XGszB2jB07Gen7/GYJfQLGuE/ZZNlpgTGes1JRal3udk+whjLtOWAD+1ljvQPSFQLCI5rDWTd5h8P0fsfrvEuajiZXrlwUIcohpNAIiExbLyOqNpj7+5XoP6HlZJ+rorjN4hS43Sqi0jzOkbQngHnUP1Mz51GMd/9ysfsRyDZsCY4bN46ef/55ionBS+WwYeaQQfXq1em2226jKVOm5HBmDofR73MApPNh8NcZcKbsvfdWpdvhGTUTGvXMbrFn1MxVzPAdYycDDrO/WEafgDHuvyvImLHIGA9MqShNiWHHiC3n89JeVrYUqu1OK670Io3M7fnxupZ9znU7QFT5nvRHTd02JQS8qS3WofAIjvDT4HXPUvb87BvTqVaLETwFiEKxSj9+cbCTqCic8OvQm9KyxDyaxkK2rDKPYrxnlIuTvkG2IUtz/vz5dOHCBerTp0/IeeDC4Ag89dRTNHXqVJKI0GEl9Puw8IV9MfiHjTCoDOTe6qYFeEb1QrPKvZW3PsF8YuwEQ0vXcy2lT8AYzyhrC47xnH0qZmxC2rcjSzm885NEp9bzetvL7H8utMAWaRnaZIuVS5Pmx1PhKjdT71HT6aqS1SxXcfGBINYFrVvzcmyk8AmksG/FbTO4vz/OfZ0jQzvFv6hEhirWgKjhNKLCdcLnhByCJ+DieZQHkycQUI2HPVaywdPT5wqMd324WiFXyDZgKSQlJanAIa+++qrypxjwhTgxbAJDhgyhEiVKKAvRsDOTDNDvNcEYcibgHzK6kC/EvRWR1e6tQhEmxk4o1DS7xtL6BIxxy43x0JWK3i57+m+irdOJdrPfxYgoooSz3iPO+czF7YrgwB0FKhFdO5o2XmhITz83mZYsWUJdu3alAQMG0E033WSZJcemR2tyjuQztiTxPCsX3ybaNImV6PHc189lPG6Hb6ovc38u0Yyo1kSikjfZodbOr6ML51Fl3S2KbasmjHerSib8ekG2OTKcOXMmffzxx/TLL7/keC5O0JbAvn37qG7durR161YqXry4dpmj32vHMpScwD8UauFdg3ur8PhZ5WqMHVMkYQt9QroxnkKRdOT4OSrNMXMdlTLpoaz6/BS+UtErtWS2Vtz/NdHOWUSHf/Isa1NKF7ZGsWMSs1JZGirmtpV7E1XtT3RVbIaWnDhxgj755BN677336Pz58zRw4EDq378/lS9fPsN5Rn9p3749jRkzhhD9WSfyYq249wtWpk8lOvknF8JLpZMu6VSYBtlGcB5R7PdTLMOq3svWYaM4mFB1DTJGFpoTcOE8qjlDrTPMNN6Pnc1FifFxVKaI1gVplB/Ge+AgM8kWc7kHXVxcHF1zzTX0xRdfUNOmTQPniTM1IzBixAjKmzcvvfzyy5rlmZoR+n0qClM2bMZ/5TaiG2Jtfg+JeytTurrmhdps7KgYFDZ+/rKLPkECynz91Tx66omxNH1YWWpRkg3eRI/jcD2U5uMrzAy1Uyqmr4hM3od/9CgZDy0mijtClIsDXlhZuBLZWuqYHEdUpCFRBQ5OU75bwMqXP//8kz788EOlZGzcuLFSMIoVY+7c3KkNTrZ4s2AwE92KizvEVrqz+e9TotOb0k1iupUYWMaRbFmbi30lUjJR2U7sM7EvUZl2rChnBSiSPQi4cB61umB++O4z6j9gCG2YXomKJm3FeLe6wIKpH+byVFoSgXjFihX01Vdfpe7DhrEEDh06RLGxsbR582YqVYqDqOmV0O/1IhtYvjbg/+ziyrTxWBGa8fF8uqqQVd+mBYZbnYV7qyBgWfhUG4wduz9/2UGfIL6fxRdxZGQk/ec//1HBzghj3JSBq49SMXNTLh8lOvIL0fEV/LmM6Oy/nuXEYgmYxEo8WUpqVJKoyBK2XpQrUnYM/0AWa0RUqhVR8ea8zYEqZBl3iEne8P/3v/8lWTr0119/Ue/evWnQoEFUv379EHMM/jI7TALBt8oGV8SzY3VRoh/+waNUv3SY+xor9mRyk76mV5I+LctIxSg4hcdSEfaTWLYjKxHbcH9uwjvFdAnJ9gRcNI9aTVYJCQk0YcIEmjt3rloSevPNNxNhvFtNTNrVx8WyPXPmDFWrVo2WL19ONWrU0I4pcgqawMMPP0zi2/KNN94I+tqQLnBxvw+Jl9YXWZR/YmISPfTQQ/Ttt9+q38Bmzdh9jpMS7q3sL02Ljh27P39ZWZ+wYMECpUyUCNVPP/00de7c2X8/xhj3z0bDI8YoFbNUmLUf53excnGz5+/kWs9n3EG2ajzOZ/NxUcaIskRSCltbicmzfIrllQSFkW05riyvWDkpCkrZzsV/KXId55HC5yVdZIVLQQ4EUJIofyWObsvKvULX8VJmvlm+qiaH4S4kJeiS9u7dSx999JFSMBYpUkT5XrznnnuoaNGiupTnzVQcq44dOxbLn71AzPpMOM2BjNaxBeN6Vqj/wZ8biC7uZ4vdM9wnryi2uZuqfurt39Jn5U/1/Sv9WZZXiz8FpRzkC5I5cIw4L85bhihfZfaPyMvTxLq2SB1PvyYeC0guIMB9wQXzqNmC3L59O/Xq1YsqVqxI77//PhUrxi4xfCWMd19UnLHPRbIdP348HT9+XLl1cYbw7NuKo0ePKsXuhg0bqFy5csY3xEX93ni4AZRoMf4LFy5ULp6GDx9OTz75JMnDvDMT7q1sL1eLjR278rSiPkFebohlorxwe+aZZ+j2228PAS/GeAjQcrzEJKViDvUSpUscW3nJm4d4VszIpwSAEYsvUah4/0TxkkuWLctST/4UC8SYwlf+ivAnK+/ylmVdTOiWhznUNKDDstZfnJ1/8MEH9M0335AMUvG/KG8A9PhRtvKbhYCAOf0kscwV5eLlY/x3gvs3/4lrAGXRGE9PTVtE3VpfR/ViK3Gf5uXzsixfLGrzsMN28fGZtzRRblaSI4FAdgQCmEefmraY+1qsp69ZfB7Nrql6HZOXQo888oi6cRk6dGhoxeQw3pWlvrwUU79hGO+hQTbpqhxka7e5fNeuXSTuW9atW2eOEsskMVq5WFHeyAtqCZpjmeSwfm8ZroFWJAf+ev6mHD58mMQ4Qqz358yZQxUqVAi01s45D/dW9pVlDmPHbr/ZegvCSvqE77//Xt2Ly4pQsUzs1q2bfs0PYIwrXZRN9FD6gcqYs7natox1Sfsm1oM6WhCmFWTMVgR3OlkuJ3+ytOjTTz+liRMn0uDBg5X1okSPrlq1qmaVkfLkD8miBER5UIDlLX8+0sodS6l5ty5ENdv6OIpdIBAggQDm0ZU7fuK+xm/50NcyQJV5+v7776eNGzfSr7/+Gt4y0BzGe4aC8cVeBHKQrd3mclluK0HeTLGKs5fkDavtY489poLmiN/uhg15RYIVksP6vRWQBlWHHPgHlVeQJ5cuXZp++OEHEr+rDRo0oHfeeYe6d+8eZC42Px33VvYVYA5jx26/2XoLwgr6hEWLFimdyaVLl5RSUZSJuus4AhjjerO3Y/657FhpO9e5UKFC9MADD9Dq1atJBsrFixdVdMVWrVqpN9HyPdwklpHyhwQCIAACIBAcgRUcoKJu3bpUokQJWrNmTXgKxeCKxtkgYBoBURTIMltRLCJZh0CBAgXoueeeowcffNA6lUJNXE1AHujHjRunnmEeffRRuu+++9SzjKuhoPEg4EACZuoTlixZQuK/VV50yoqh9evX0x133KG/QtGBcjSqSVAqGkXaRzm1atWiV199lQ4ePEijRo2izz//XFkIyA/0H3+wDz4kVxKQJfG6v4VxJVk0OjMB9LU0InLz9Oyzz6qbljfffJOmTZtGefKw6wEkEAiRgF3Gl/gmEqXVlClTKHduXoKPZCkCsprl3LlztonGbZd+bykh27AyYjn7999/q6XQ9erVU24TbNgMXaqMMaALVt0zhdx0R5xjAfKCU5SJck8iAaL++ecf6tGjB56LcyRn/glQKpovA4qOjlYPsuJ8dNOmTSry4r333ks1a9ZUSwzEWTeSewgkJyfD0tQ94ja1pehrHvz79u2jm266Sfm+Xbt2LXXq1MlUuaBwZxCwy/h6/vnn1X1HttETnSESW7ZCHnSnT5+uXj6LctHqyS793uoc7VA/saQV38PyQk78r8mLCayUYhfpuI+3Q/fNUkfILQsSw3b89NNPdOONN6rfOTG0EmViz549oUw0TALhFwSlYvgMNc2hTJkyJMsJtm7dqiKNbt68WfnTkehG8+fPp8REjoKdQ8KblhwA4TAIgAAIXCHw5ZdfKl9lXbp0oR9//JFkDkYCAbcQ2LJlC73xxhv01ltvuaXJtmxn8+bNqX379jRhwgRb1h+VdjaBXr16KbdOsuKqY8eOBGMIZ8sbrXMHASP0CT///DO1bNmSJKr8sGHDlC/zu+66S5dAtu6QmnmthFLRPPY5liw3ke+//75aHt21a1dltSgO1MWXiSgb/SW8afFHxh77jZjE7UECtdSbgJv7mvivHTJkiHqJI1Hlxo4dizeienc4l+Vv9fElFkXibuWZZ55BcBYb9M3JkyfTJ598opacWrm6Vu/3VmZn57pVqlSJfvvtN2rUqBHVqVOHFi9ebOfmhFV3jIGw8Jl2MeSWEb2e+oRly5aRxJOQoIhyLy4rNfv06QNlYkYR2OoblIo2EFf+/PlVlOjly5erH+yoqCgVSVp8Drz33nvK144NmoEqBkhAz0k8wCrgNJcQcGtfE4fP9evXp8uXL6sHdHkIQgIBrQlYfXzJ/UNCQoKyENC67chPewJFixalSZMmqYcw6VtWTVbv91bl5oR6RUZGqqXQ8+bNo8GDB6vATzLHuC1hDNhT4pCb/nITXcYtt9xCgwYNooEDB9K///5L99xzD17q649e9xKgVNQdsbYFXHPNNfTiiy/S/v376cknn1TR18qXL0/ig1G0/mJ5gDct2jJHbiAAAs4gIPPj66+/Tq1bt1bWWbNmzSLxCYUEAm4jsHPnTho/fjzJGEBgMPtIX4K2FCpUSCkX7VNr1NRtBFq0aKGite7Zs4euv/56EjcLSCAAAvYioKU+4ffff6dbb72V+vXrR/3791dzgugu5EUEkjMIRDmjGe5rhQxC8Vsif8ePH6c5c+bQiBEjSJb0yQPCsWPH3AcFLQYBEAABPwTEx5PcyJw6dYrWrFlDslQLCQTcSECsMeTGXvzzVa9e3Y0IbN3mDz74QFlai6/t2NhYW7cFlXcugSJFipD4LBY3TuLOSaxsxToJCQRAwB4EtLDcXLFiBT399NO0bds2mjhxojKCgiLRHvIPtpawVAyWmAXPL168uAq9vmHDBvq///s/taRP/BOIwlGcJsfHx1uw1qgSCIAACBhDQHw71a1blxo0aECy9AIKRWO4oxRrEhBrXXn5OHr0aGtWELXKlkCFChXUihVRDCclJWV7Lg6CgNkEZBm0+FqcOnWqiuZ6+vRps6uE8kEABHQm8Mcff1C7du3o7rvvJgm8IkpFsbSHQlFn8CZmD6WiifD1KFp8g9WsWZM+++wz6tu3L82YMUNFM5Xw7OvWrdOjSOQJAiAAApYkIL6cxowZo3w7yQuX5557jsQnLRIIuJWAvHx86aWX6OOPP8ayZxt3AgmwIy+UX3jhBRu3AlV3C4EaNWqo6NASbFKCuIiSEQkEQMB5BFavXk0dOnQgiQjfo0cP2rp1q/KdiHtv58k6c4ugVMxMxAHfxQIhd+7c1Lt3b/rxxx/pr7/+InHw3blzZ2WpM23aNMKbQusKWksfFtZtJWpmBQJO7mtyIyO+nHbt2qV8O7Vs2dIKyFEHFxGw2vi6dOmSshQSS8XKlSu7SBLObOqHH35Ib775JolFiJWS1fq9ldi4uS7yXCJzz7vvvquUDRJ13qmWthgD9uzpkFtGuYk+Qf4CSeJW6LbbblNju2vXrrR9+3aSl1/R0dGBXI5zHEAASkUHCDFzEyQYgfx5kyz1E38G4jB58uTJ6ga0SpUqyhxZlgWKzwQk6xDQwoeFdVqDmliZgFP7mvgcu+GGG1SU1K+++orEtxMSCBhNwGrj6+GHHyZZzdCnTx+jUaA8HQiULl1arUYReZ4/f16HEkLL0mr9PrRW4Cq9CIgVk6ycWrlyJcnLPnk2cVrCGLCnRCG3jHLLrE/IeNTz7c8//1RGS3fccQd16tRJKRPvv/9+KBN9wXL4PigVHS7g9M2Ttw0S9XTu3Lm0e/du9WMuEaRF6SgO28WiBwkEQAAE7EpALLDvvPNO5btJIs2Jb1kkEAABovnz59OSJUvo7bffBg4HEZBgLXJfJy5ukEDALgRKlSpFixYtIlFENG7cWPl/t0vdUU8QAAGitWvXklgkym9Q+/btaceOHTR06FCKiYkBHpcSgFLRpYIvVKgQDRs2TEVB/f7779Vbbvlhv/nmm2n27NkUFxfnUjJoNgiAgB0JiI8m8dVUpkwZ5btJfDghgQAIkPJpJMES5s2bRwULFgQShxGQJaWrVq2ijz76yGEtQ3OcTkB8HotyUQwcBg4cSBcuXHB6k9E+ELA1gb///lspE2Wpc5s2bZQycfjw4VAm2lqq2lQeSkVtOFoqF7FIFL8QgabatWvTlClT6NChQzRixAgV5EWcKYv5sjhcRQIBEAABqxIQn0zi3kEcQouvpjfeeEP5lLVqfVEvEDCSwMWLF6lbt24qWrBEP0dyHoF8+fIphfG4ceNo06ZNzmsgWuRoAjIvidWTPLvUq1dP+YF3dIPROBCwCYH0+oT169cry+KOHTvSLbfcolY3ijJRfKUigYAQCFzzBF62ISA+EMQvRLBJnKl2796dvvvuO/rnn3+oMjtyF1891113Hb366qt09OjRYLPE+SAAAiCgG4G9e/fSTTfdRCtWrFA+msRXExIIgEAaAbFQlIBF8onkXAKxsbH08ssvq0A8okhGAgE7EcifPz+JL2SJZt6uXTt65ZVXMviGt1NbUFcQcAoB0SfIsmZ5aS/jUnyg7ty5U7nbgDLRKVLWrh1QKmrH0lE5yRLC8ePHK4er77zzjlIyVq9eXZk8L1iwgBITEx3VXjQGBEDAXgRkKWfDhg3VnCQBp8RHExIIgEAagenTpyvLNflEcj6B/v37K/904tcKCQTsSKBnz54kgR++/vprpcQ4fPiwHZuBOoOA7Qls3LiRxDpRdAHNmjVTysQHH3yQ8uTJY/u2oQH6EIBSUR+ujsq1RYsW9OGHH9L+/fupS5cuKoJ0+fLl6ZFHHqEtW7Y4qq1WaIwsXReTcyQQ0JuAHfua+FwaNGgQPf744yTKxLFjx2K86N1RkH9IBMwcX3/88Qc988wz9N///hcPASFJz54XyUtgeRCcOnWqaQ0ws9+b1mgUrBmBihUr0rJly5QiQ5ZDi993uyWMAbtJzFNfyI3o33//pd69e6slzldddZXy1fvwww9T3rx57SlU1NowAlAqGobauIL0mhQLFCigHClLQIRff/1V+W2UpYfyBuP999+nc+fOGddIB5ckS9fF5BwJBPQmYLe+Jn6X6tevr8aHOIuGjzi9ewjyD4eAWePr+PHjahnszJkzqUqVKuE0AdfajIBYkYiV1/PPP0/Lly83pfZm9XtTGotCdSEQGRmpfCV/+eWXKqLs6NGjKT4+Xpey9MgUY0APqvrn6Wa5bd68WSkT5bleVgHt2rWLqlatCmWi/t3OMSVAqegYUaY1xIhJUZZCv/TSS3TgwAFlMSRvEsV6sV+/fqbdyKYRwBYIgICTCIiSXfy6tm/fnp577jkSZYn4YEICARDISEB+/++66y7q27cvderUKeNBfHMFgUqVKtGcOXNUP5AAfEggYFcCzZs3V/6SpR83adKERPGBBAIgoB2BrVu30t133638JYplsCgTZQWQBAAzQp+gXUuQk9kEoFQ0WwI2L1/eJsqDy1dffaWcucqEJNGgqlWrphwui9IRCQRAAARCJXDkyBGlTJQ55n//+x/deeedoWaF60DA8QRGjhypljuL8h3JvQTatGlD4v9K7s8uXbrkXhBoue0JFC5cmD7//HMSa0VRMs6YMcP2bUIDQMBsAqJMlJePMqZq1aqlfCY++uijeGFvtmBsXD6UijYWntWqXrx4cXrooYeUP59PPvmEJDJr7dq1SSKySlAFOy1dsBpb1AcE3Ehg4cKFVLduXRW9VlwuVKhQwY0Y0GYQCIiA+NP7+eef6dNPP1XuSQK6CCc5lsC4ceNIokIPGDDAsW1Ew9xDQPrxypUr6e2336Y77riDTp065Z7Go6UgoBGB7du3q1WFokysUaOGUiZKMBZxcYYEAuEQgFIxHHq41i8BWaYgDzhiqXjPPfeo7bJly6o3jRs2bPB7HQ6AAAiAgLyAECub+++/n7744gsVcEKsopFAAAR8E5DABhKY5dtvv6WCBQv6Pgl7XUfggw8+oD179qiVI65rPBrsOALiemnVqlXKV2ydOnWUf3fHNRINAgEdCOzYsUMFObz++uvVasKdO3fSE088gfsFHVi7NcsI9lWFiBAOk774HRszZgzJ8hcrpd27d6so0rNmzaJixYqpoC/ix0GWNrg5Xbx4UTmklujaklasWKEm/JIlS6qAFPJ2tm3btm5GhLZrRMAOfc3rLFpcKLz33nuunx80Ej2yMYCAUeNLFEUdO3akMmXKqFZt2bKFbrzxRqWAFyfrSCCQnsDhw4epcePGyi9tevcR4lJCLL7CTUb1+3DrieudRWDx4sVKSSL3yE899RRFRUWZ1kCMAdPQh1WwG+QmPhLFHcr8+fNp1KhR6oW9RHUOJFlVnxBI3XGOCQREqYjkLAKsTEzhH1vLNoodv6YsWbIkhZ3Jp/DEpj7le1JSkmXrrGfFeAmHKPZ9/kVERKSwQlHP4pG3iwhYva+xr6QUfuGQwtHkXSQVNNUpBIwYXxz1XP1W8EunFF7GlHLs2LGUypUrp/DLOqdgRDt0ILB+/foUdlGTwi8tVe5sCa76EVu3hl2aEf0+7EoiA0cSOHr0aAorPlLY+iqFlSemtRFjwDT0YRXsZLmxIU/K4MGDU4oWLZoyceLElNOnTwfNyur6hKAbhAt0JYDlzyYoct1eJCvKlBWl+H0S60WxsHjssceIH4yIJz7li9FNjMRS8+abb/bZZPFxIebpSCCgBQEr9LXly5eTzAFz585NbRLf2FH37t1p+vTp9Pvvvyvrg9SD2AABmxAwYnxNnjyZxBXA8ePHqX79+nTLLbcoFyP33nuvTSihmmYQEP/Ws2fPpq5du1Lnzp1Tg11MmTKFEhMTw6qSEf0+rAriYscSKFGiBH3//ffUq1cvatSokfIn622s9OvcuXNT3rx5w+7j3jz9fWIM+CNj7f1OlJvEMxgyZIgaD6VLl1ZBVMU1SqFChawtDNTO9gSgVLS9CO3dgCJFiqho0X/++afyBXX27Flq2LAh3XrrrTRnzhzXRC2UHwBffrBkOUeLFi3sLWTU3lIEzOxrJ0+epC5duigeUg+JPicBWMQ3UqVKlWj16tV07bXXWooXKgMCwRDQc3yJ8l2WrLJVP7HFP507d049MLRq1SqYKuJclxKQpfEyv/74448ky/4kSV+SPhVu0rPfh1s3XO9sAvKSUnwwL126VPmV7devnwoMOXLkSLUkOleuXPT444/rDgFjQHfEuhTgFLnt27ePHnjgAapXrx6J+6xt27bRs88+CxdCuvQaZOqLAJSKvqhgnykERLHw+uuv08GDB9XEKBGky5Urp7bXrFljSp2MKlQULZmjY4tCsW/fvsqqy6h6oBznEzCzr0nQJu/DbFxcnLKYER9fvNyZXnvtNYqJiXG+ANBCRxPQc3yJj1F5gE6fZDyJ5Rm7EEm/G9sgkIGAzLfNmjUjuZeSbW8SxfQLL7zg/Rryp579PuRK4UJXEahbty799ddfyjpx4MCBJP7bZX6UvzfffFP5K9cTCMaAnnT1y9vuchN//CNGjCDp/7zUmSS6s/hQFCtMJBAwkgCUikbSNqgseejI/OBhUNGaFBMdHU09e/ZUSxokUnTFihWJ/S9SrVq1lNJRln05LeXLl4/EIW76JMs2+vfvn34XtkEgbAJm9TW5wZcItV7luVhayZvV2267jdq1axd2u5ABCFiBgF7jS8bLq6++6tN6/9KlSxhDVhC+hesgy+Q3btyYQaHora5YjLPPRe/XkD716vchVQYXuZaA9ENRqHz99dcZ5kqZIyUo0fnz53VjgzGgG1pdM7ar3A4cOKCUiWKQI4FXxDJRXhCJYlGrZHd9glYckE9gBKBUDIyTrc5iL5wqarCtKu2nsmKpKMsWduzYQW+99Za68b366qvVzcG3336rlu74udR2u++7774MS6DF/4X4zEICAa0JGN3XxMfLsGHDUq0Uve2RG33xrQorKy8RfDqBgB7ja+HChRkekr2c8ufPT+I3Kb2PUu8xfIKAl8AjjzxCldlvtfSXzEle9EyaNCnz7qC/69Hvg64ELnA1AXn+Ef/M3peX6WGcOXOG7r///vS7NN/GGNAcqSEZWk1uO3fuVLEH5N45czp06JCK4ix+ckUhKi+FRJnIQQ4znxr2dyfpE8KGgQxyJAClYo6IcIJVCLRs2ZJmzpxJYurdsWNHNYmWL19eBXmRSdXuiaM8Kz9Z0g5ZBjpo0CC7Nwn1tygBI/uaWFiJhcDly5d90vBaWYm/RSQQcAIBPcbXiy++qHwoevlI8AHxwysPE/Lg0adPH+8hfIJAFgISoGXLli3K1YQEt0ivXBS/il9++SWFOwfr0e+zNAQ7QCAbAhLI6rfffqOEhIQsZ8myf7FgnD9/fpZjWu3AGNCKpLH5WEluYlEufhGlH4sbMG86fPgwjR49mkSZKM+IMp9Lfy9evLj3FHyCgKkEoFQ0FT8KD4WAPEgNHjxY+Uf5+eeflSJOFI4S0ESUjnoubwilvoFeI8u+5Q2rOJWWP0TzDJQczguWgJF9TSxg/v333yxWxTKOpR4SsVGssLRcshEsD5wPAloS0Hp8iY8kCWYmSR4mRKEoQQhk+dOoUaPUONKy/sjLmQRkKZu4kpF+I0tECxQooPqStFbuOd59992wGq51vw+rMrjYlQQeeughEqszUbSIFZe4EUqfxL+i+Co/evRo+t2abWMMaIbS0IysIjcxkGnevLl6gShK8Oeff165CZJ+XbNmTRV4SO6nX3nlFZKXQ0ggYCUCUCpaSRqoS9AEatSood7UiPXio48+SgsWLCCxXhwwYIB6yxN0hiZfINaJ8tAofiSrVatmcm1QvJMJGNHXxCfqM888o5Y9S+AheYiVP/GZ+uGHH9KJEydU4IDM/kSdzB1tcwcBLceX+FIUa7I8efKQBDYSdyCirBfFPBIIBEtAHqAlWq4soxPLF+lXiYmJStEoluXhJC37fTj1wLXuJCD3zzNmzKBjx46pe4unn35aBbCQ/XLvIUmUNb169dINEMaAbmh1zdhsue3atYtuuOEGOnv2bGo7ZT5u1aqV+r5582blVxnKxFQ82LAYgSiL1QfVAYGQCIjColOnTupP3kDOnj2bhgwZopZASBQ4UTKK3yl/Sc6V6Fni8NZXupSYTLvPXPR1SNN9Ja5roG54bmzbgf49oZ9DaW+l80VFUqVCeb1f8WkBAk7pa+LTqN6V8VS+UmXq3K079burJzVp0sTWgaQs0EVQhTAI2G18xbPbgHfeeYeuq1uPJr39PlWtfi2d5vafzvT7gLk8jE7hgkv99ft7xz5BHe+9j177zwT6+rNP6JOFP1LD65uFTAT3MCGjw4UaE4iNjSX5e+yxx+jUqVO04Lvv6eO5n9Dvv/ykgsY9P+1tuqNPX41LJcIY0Bapv7lL21LMlZsELWzatCmdPn06Q0wEsaw9cuQIPfvss6lKca3bjfxAQCsCEeyEM0WrzJCPNQiI1c+YMWOUk1dr1Mi8WqxatUotiZ43b556AyQKxi5dumRYLvbDDz+Q+BuS5T/fffcdyVLqzGnxzmN0ISEx825HfL+xQjEqmS/GEW1xQiOc1Ne2b1hHRUqWpGKlyijRoK85oYfauw12HF/HDx2g4mXK5Qge4ytHRK49IZB+f3T/PipZvoLtGKHf205kplTYOwbE6nvL2jVUrXY9ismdx5S6aF2ok8eAV25aM7NCfiK35LMnqUGDBmpJvvTNzEmW8YtifMKECZkP6f4d+gTdETuqACx/dpQ4PY0Rc2noij0s5M2P+Ak6ePCg8iX05ptvUtmyZUn8U8jSTElTp05VyzPFF6NMoOKXMXPKHRmReZcjvkfncma77CwcJ/W1arXrpioU0dfs3CudU3c7jq9AFIoYX87po3q0JJB+b0eFIvq9Hr3FmXl6x0BkZCTFNrreMQpFp48Br9yc1itFbsd5mb48p8pyfV8KRWmzWCtOnDiRLly4YDgC6BMMR27rArH82dbi8115sbgTh9xIaQTEZ5A4Z5a/nTt3Kn9uEkG6WLFiKoiE90yJRCvLoP/55x/luwIcvWTwCQIgAAIgAAIgAAIgAAIgAAIgEA6B82dOU8sOLegML3kWRbdYJIpBkCgRZbtcuXLKt36tWrWoc+fOlD9//nCKC+la6BNCwubai6BUdKDo8WYhe6FWrVpV+aeQABISQXPbtm0k/t+8SRSLYt0oEba+/PJLNbl7j+ETBEAABEAABEAABEAABEAABEAABEIhcPTAfqrXoCFVv7oqSdBReTatUqWK+hOlohUS9AlWkIJ96gClon1khZpqTEDewCxZskS9Fcqctbwp+uWXX5Sfi59//pkPR2c+Bd9BAARAAARAAARAAARAAARAAARAIGACVWNr0Sf/XQCf9gETw4lWJwCfilaXUAj1g7lyYNDWrVtHe/fu9XtyXFwc7dixg6677jo6wm+UkEAABEAABEAABEAABEAABEAABEDAyQSgT3CydLVvG5SK2jM1PUeYKwcmApksxY9FqVKlqEiRIlSgQAES34uyT5J3Mj116hTd1bx+YJniLBAAARAAARAAARAAARAAARAAARCwKQHoE2wqOJOqjeXPJoFHseYTqF27ts+lz96aiZ/Fy5cvk1gsfr3aEynaewyfIAACIAACIAACIAACIAACIAACIAACIOBmAlAquln6aHu2BGJiYkj+ChYsSNfUqkMn4xKyPR8HQQAEQAAEQAAEQAAEQAAEQAAEQAAEQMAtBLD82YGSjoiIUEt3Hdg0NAkEQAAEQAAEQAAEQAAEQAAEQAAEQEAnAtAn6ATWodlCqehAwaakpJD4QUACARAAARAAARAAARAAARAAARAAARAAgUAJQJ8QKCmcJwSgVEQ/AAEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQCIoAlIpB4bLHyd6oxfaorftqmcABYI7u30fyBujMieMBAzi4a0fA5+JEENCKQFJiIm1d95dW2SEfEACBdAQwvtLBwKZrCKDfu0bUaKgfAhgDfsDouBvPX8HBhT4hOF5uPxtKRQf2AISAt65Q5055iZ7oczvNmvwM3X9zY3qwUyu6cPZMthU+sHM7PXx7a3pm4F3ZnoeDICAEvpoxjfpfX4u61yhLG/74PQuUuIsXqW+ja9Xx18cOp3OnT2U5x7tj699/0phubeipfj29u/AJAq4mgPHlavG7tvHo964VPRp+hQDGgL27Ap6/gpcf9AnBM3PzFVAquln6aLuhBI7s30tfvTuVxrz+Lo2b+j5N/mIh5c6bl04dO5ptPcpVrUYtOnXN9hwcBAEvgTuGjKQGN92ivn738fve3amfvy74ki6eP0dR0dE04sXXqWDhIqnHMm9Ur9eQbus7KPNufAcB1xLA+HKt6F3dcPR7V4sfjWcCGAP27QZ4/rKv7FBz+xCAUtE+sgq4pojWFDAqQ0/csHK5Ku/4wQPqs3DxEtT1vhGsVDySYz2iomNSz5Fl00ggkB2BAoUKU7HSZel/Py8huZlKn36YN5dqNGhCMXnyKsVi+mO+ttP3PV/HsQ8E3EYA48ttEkd7hQD6PfqB2wlgDNizB+D5KzS5QZ8QGje3XgWlogMlj2hN1hRq/Za3kPineHFoP1q9dJGqZOsefZSC5+iB/TSh7x00qkNLtX/JZ7NpcMv6NPe1F1Mbk5yUxMum/0P9b6hFw9s2g5+7VDLY8EVALAxlLlg4Z2bq4c1/raGS5SuwwrFM6r4/ly2l+1o2UH3t0oUL9Pq4EWr59Ja1/0s9BxsgAAIZCWB8ZeSBb+4ggH7vDjmjlf4JYAz4Z2PVI3j+Ck0y0CeExs2tV0Gp6FbJo92GEyhWqgwNevI5uhx3iSYNH0hTHxlJSUmJFB0TQyXLlacmt7Zn/3YnVb3a3tWXipYspZapeit68uhhKs7WZ+Pf+kgpi2a99Iz3ED5BIAuBmo2aUpWatWjpF5+SKAslLfp0FnW8e2CGcxvedCsVL1tO9bW8+fNTn9GPqn6YmJCQ4Tx8AQEQSCOA8ZXGAlvuIYB+7x5Zo6W+CWAM+OZi5b14/rKydFA3pxCAUtEpkkQ7bEGgfZ/+9NL/fUfiJ3EZ+7Z7uv+ddOn8eVV3US6mT9HRudN/ZcVjBbrt3sFs2diYug4eTlv+/h+dPXUiwzn4AgJeArJsQfqL+E9cNn8enTl5gg7u2k7XNbnBe0rqZ/q+l7rN1yOBAAj4JoDx5ZsL9jqbAPq9s+WL1uVMAGMgZ0ZWPAPPX1aUCurkJAJQKjpJmlfaksTLZCMjIx3YMns36dwpjxXi1bXqcJCWRdT4lnYk0XVXLvkuoIZFRkWlnle9bn1lrbhny+bUfdgAgcwEbrztdrqqaDH6bvYH9CP7Umzd4+7Mp+A7CIBAiAQwvkIEh8tsTQD93tbiQ+U1IIAxoAFEA7PA85eBsFGUawlAqehA0cfHx1NMJqs3BzbTdk2aNv5BunDurKp3nnz5qN+jE9X29g1/p7Yl0BgscRcvqmvKVq6Sei02QMBLQPygpCQn89L63NS2V1+2UNxB3856j1p26e49JcunnI8EAiCQMwGMr5wZ4QznEUC/d55M0aLgCGAMBMfLKmfj+csqkkA9nEwASkUHShdKRWsKNX/Bq2jWpP9Q8hXljTfqc4tOXVWFxeeH+FTc9e8/tH/HNjrAiqAzJ4+nNiYxMc3H3ZqfligfjBLhFwkEMhM4f/qUWu4s+9v37kdi5dqi0x0kymxJ8tY2nn17JvALCEnS97b/s47OnzlN0rcknTlxTH3KORIkSG6mkUAABIgwvtAL3EgA/d6NUkeb0xPAGEhPwz7beP6yj6xQU/sSiHyak32rj5r7IjB9+nTq0aMHlS5d2tdh7AuBwO4zF+lSYniWXLs3b6R1vy+j5d/+lzavXUM///dzanfXvdTq9p6qRiXLV6Q/eCn0V+9Oo8N7d1OhYsUp7uIFqlCtBit9Sitlz9rlP18JvHGehr/wGuXOkzeE1qRdEsl+88pflZfyR2O5fBoVc7fC7WuzJj1Dv8z/ksQCVnx3Vq4RqywVuw4eRgULF6FP35hEKxZ9QwmXL9OhPbuoVtPmVJSVios++UhZM1a8tibt3LiBIjhSuSyd/uKtKXTyyCEVYKhOs5Yk/oRCSehroVDDNVoTwPjSmijyswMB9Hs7SAl11JMAxoCedPXLO1y5Sc3w/BWafGbPnk3NmjWjq6++OrQMcJWrCESw9QnMTxwm8tjYWPriiy9IPpG0IfDLnuN0Mi7NUjCUXM+x9Vg+tlYUq6/jhw5Q6YqVfSpoxFqsQKHCFH85jmJy58lQlOQRkydP2MpEb6bRuSKoabmiVDJfxiAx3uP4NJ6AFn0tlFpLf5Mkfc5X3wslz/TXoK+lp4FtswhgfJlFHuWaSQD93kz6KNsKBDAGrCCF4Oughdzw/BU8d7mibdu2NHbsWPUZWg64yk0E0iI/uKnVDm8rlj9bU8BiJSZJguiUqeTfF6IoFCVlVijKPm8eso0EAloSSN/f0m9rWQbyAgG3Ekg/ptJvu5UH2u0OAun7evptd7QerQSBjPfyGAPm9AjvsxOev8zhj1LdQQA+FR0o58u8rDF37twObBmaBAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgYAUCUCpaQQoa1yExMRFKRY2ZIjsQAAEQAAEQAAEQAAEQAAEQAAEQcDqBXOxbPVQ/6k5ng/ZlJQClYlYmtt9z+vRpKliwoO3bgQaAAAiAAAiAAAiAAAiAAAiAAAiAAAgYRyA5OZkQesM43nYvCUpFu0swU/0vXbqk9uTNG15U4EzZ4isIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIpBKAUjEVhTM2Tp48SUWLFnVGY9AKEAABEAABEAABEAABEAABEAABEAABEAABSxKAUtGSYgm9UlAqhs4OV4IACIAACIAACIAACIAACIAACIAACIAACARGAErFwDjZ5iwoFW0jKlQUBEAABEAABEAABEAABEAABEAABEAABGxLAEpF24rOd8WhVPTNBXtBAARAAARAAARAAARAAARAAARAAARAAAS0IwClonYsLZETlIqWEAMqAQIgAAIgAAIgAAIgAAIgAAIgAAIgAAKOJgClosPEe/r0aSpWrJjDWoXmgAAIgAAIgAAIgAAIgAAIgAAIgAAI6E0gV65cFBERoXcxyN8hBKBUdIggvc04cOAAlSpVyvsVnxoRiEtK1igna2WTkJxirQqhNoS+hk4AAvoRwPjSjy1yti4B9HvrygY1M4YAxoAxnLUuBXLTmmjg+SUnJ1NKCp4TAyfm7jOj3N1857V+3759dP311zuvYSa36KaKxWnPmYsm18J38Z99+D5dvnyZ+j0w3PcJ2ezNGx1JJfPFZHMGDhlNwKi+tnPrFvrq0zk09qlnDWki+pohmFFIDgT0GF9Tnn2aWt/WmWo3aJhD6fodxvjSj60Tctaj3/vjYuRvC/q9Pylgf2YCRo4BKXtUv7vptQ9mUVSUvo/aTh8DRslt8YL/UtylOLq9V+/MXUeX706Xmy7QkKmlCeg701m66c6snCgVK1So4MzGmdiqvFG5qEaxAibWwH/RjwwbQvXr16cG1atSz549/Z+II7YgYFRfOxR3lnZs+Nuy/doWwkIlbUdA6/F18OBBmvfxTJo2+QWKicELGtt1CJdUWOt+nx22i7kj6K/fluG3JTtIOGY4ASPHgDRuze+/UrmYFCpSxJrPDoYLIMQCjZLb7O2bKV++fJi3QpQTLgMBLH92WB/Yv38/lS9f3mGtQnOyIyA/gnPnzqXhw4eTPOAigUAgBMS6NXfu3IGcinNAAAT8EPj888+pa9euUCj64YPd7iMgvyvy+4IEAm4mkD9/frpw4YKbEdiq7SIrkRkSCIBAaASgVAyNmyWvSkpKoiNHjlDZsmUtWT9USj8CjRo1otGjR9OAAQP0KwQ5O4pAfHw85c2b11FtQmNAwGgColTs06eP0cWiPBCwLIE8efJQQkKCZeuHioGAEQQKFixIFy9a022SEe23WxmXLl2iAgVgVWo3uaG+1iEApaJ1ZBF2TSRIS+nSpSkyMjLsvJCB/Qg89thjdPbsWZo6dar9Ko8aG05AbqCwXNNw7CjQQQR2795N27Zto5tvvtlBrUJTQCA8AvK7Ir8vSCDgZgLy0vb8+fNuRmCrtp87d04tf7ZVpVFZELAQAfhUtJAwwq0Klj6HS9De14syWZZBN2nShFq3bk2xsbH2bhBqrysBLH/WFS8ydwGBzz77TPmxxYs8FwgbTQyYgFgqxsXFBXw+TgQBJxLA8md7SRXLn+0lL9TWegRgqWg9mYRcI7FUrFixYsjX40L7E6hatSpNnjyZ+vbti+VH9henri0QpaL440QCARAIjcD//d//Ue/exkSKDK2GuAoEjCeA5c/GM0eJ1iMgS2lhsWs9ufirEZY/+yOD/SAQGAEoFQPjZIuztm7dSqJUQnI3gYEDB6oI4BMmTHA3CLQ+WwJiSRIdHZ3tOTgIAiDgm8CWLVuUD+Mbb7zR9wnYCwIuJSCBWuBLzqXCR7NTCchLW1lSi2QPAlj+bA85oZbWJQClonVlE3TNRKlYvXr1oK/DBc4j8P7779OsWbNo+fLlzmscWqQJASx/1gQjMnEpAVn63KtXL4qIiHApATQbBHwTEJ+KEqglJSXF9wnYCwIuIIDlz/YSMpY/20teqK31CECpaD2ZhFwjsZy49tprQ74eFzqHQPHixWnmzJl0zz33qOAtzmkZWqIVAbFUlGVqSCAAAsETEKXiXXfdFfyFuAIEXEBArBXlxRUSCLiVAJSK9pI8lIr2khdqaz0CUCpaTyYh1wgXhEQbAABAAElEQVSWiiGjc+SFHTp0oE6dOtGoUaMc2T40KjwCsFQMjx+udi+BdevWqUAUTZs2dS8EtBwEsiEApWI2cHDIFQSgVLSXmKFUtJe8UFvrEYBS0XoyCalGx48fV9eJhRoSCHgJvPzyy7Ry5UqaN2+edxc+QUARgFIRHQEEQiMgAVpk6TMSCICAbwKIAO2bC/a6hwCUivaSNZSK9pIXams9AlAqWk8mIdUIS59Dwub4i8RR9Ny5c2n48OF08OBBx7cXDQycgCgVEf05cF44EwS8BGTpc58+fbxf8QkCIJCJQN68eSk+Pj7TXnwFAfcQKFiwIAIW2UjciP5sI2GhqpYkAKWiJcUSfKWw9Dl4Zm65olGjRmoJtESFRgIBLwFEf/aSwCcIBE5g9erVJIEo6tSpE/hFOBMEXEZAxog8pCOBgFsJiGL9/Pnzbm2+rdotc1V0dDQCr2WSmgSiy5ULqqJMWPDVDwH0FD9g7LZ7+/btCNJiN6EZWN/x48ergC1vvPGGgaWiKCsTwPJnK0sHdbMqAQRosapkUC8rEYBPRStJA3UxgwCWP5tBPbQysfTZN7eUlBRKTk72fRB7QSATASgVMwGx69e///6brrvuOrtWH/XWmUBkZCTNmTOHnn32Wdq0aZPOpSF7OxBA9Gc7SAl1tBIBucEWf4qI+mwlqaAuViQApaIVpYI6GUkASkUjaYdXFpSK4fHD1SAgBKBUdEg/kGiUdevWdUhr0Aw9CFStWpUmTZpEd999N3wd6QHYZnnCUtFmAkN1TSfw22+/kQRDq1Gjhul1QQVAwMoEoFS0snRQNyMIQKloBGVtyoBSURuOyMXdBKBUdID8T5w4QefOnaPKlSs7oDVogp4EBg0aRJUqVaKJEyfqWQzytgEBKBVtICRU0VIEsPTZUuJAZSxMANGfLSwcVM0QAlAqGoJZk0KgVNQEIzJxOYEol7ffEc2Xpc/16tVzRFvQCP0JvP/++1S7dm267bbbqEWLFvoXiBIsSQBKRUuKBZWyKIGkpCSaN28erVq1yqI1RLVAwDoEYKloHVmgJuYQyJcvH6I/m4M+6FKhVAwaGS4AgSwEYKmYBYn9dmDps/1kZmaNZfnezJkz6Z577lHBW8ysC8o2j0B8fDxJdEIkEACBnAn88ssvJC4kqlSpkvPJOAMEXE5ALBUTEhJcTgHNdzOBggULQqlokw4g0Z8LFChgk9qimiBgTQJQKlpTLkHVCkrFoHDhZCbQoUMH6tSpE40aNQo8XEpAbqJiYmJc2no0GwSCI/Dpp5/SnXfeGdxFOBsEXEpALBUvXrzo0taj2SBAJJaK4poKyfoEzp8/j5fs1hcTamhxAlAqWlxAgVQPSsVAKOGczARefvllWrlypVrSl/kYvjufAJY/O1/GaKE2BMTi6quvvqJevXppkyFyAQGHE8DyZ4cLGM3LkQCWP+eIyDInYPmzZUSBitiYAJSKNhaeVD0xMZG2b99OtWrVsnlLUH2jCcgNz9y5c2n48OF08OBBo4tHeSYTiIuLI1mihgQCIJA9gcWLF6vf2HLlymV/Io6CAAgoAlAqoiO4nQACtdinB0CpaB9ZoabWJQClonVlE1DN1q5dS9WqVYNyICBaOCkzgUaNGqkl0P369aOUlJTMh/HdwQRgqehg4aJpmhJA1GdNcSIzFxCAUtEFQkYTsyUgPqvlPis5OTnb83DQfAJQKpovA9TA/gSgVLS5DP/44w+6/vrrbd4KVN9MAuPHjyfxJzJt2jQzq4GyDSYApaLBwFGcbQgcOHAg9UFQLHq/+eYb6tmzp23qj4qCgNkExApexg4SCLiZAKwV7SF9KBXtISfU0toEoqxdPdQuJwKrVq2iW2+9NafTcBwE/BKIjIxUy6CbNGlCrVu3ptjYWHWuOFnfu3cv1ahRw++1OGAfAvv27aPu3btTsWLFlGWzPPA98sgjVLhwYeVQ/D//+Q9FR0fbp0GoKQjoRKBixYokD4N9+vQh2Za5sUSJEjqVhmxBwBkEli1bphTwcu+wZs0aSkpKot9++00pF+U+YurUqc5oKFoBAtkQeOedd5RLodOnT6tgeHfddZeyWJTvkyZNwjNbNuyMOiSBCvv27UtHjx5VUZ/l/ljuhcXAolChQiqQZb169YyqDsoBAUcQiOAlj1jzaGNRytJnsaKoWbOmjVuBqluBwAcffEBvvvkmiaJagv9IhGhJx48ft0L1UIcwCfzyyy908803+8xFlqpNmTKFhg4d6vM4doKAmwgUKFCAxHJBXriIxZWMD3kAuffee6lBgwZuQoG2gkDABCIiIvyeK+NIHuSRQMDJBFasWEHNmzf32UQZA5MnT6aRI0f6PI6dxhLwN1/JfvmTlyJuT23btqWxY8eSfCKBQE4EsPw5J0IWPn7ixAk6duwYLMksLCM7VW3QoEFUpUoVuuWWW6hly5Yk/Uus2f799187NQN19UOgRYsWyvrKz2GlNPF3DPtBwE0EvA8b8lAhysWTJ0/S9OnT1cPiY4895iYUaCsIBEzgxRdf9OnfOyYmhsTNChIIOJ1As2bNyF9AL7HhueOOO5yOwDbtGzZsGOXKlVUNIqsUxNoUCQRAIDgCWUdTcNfjbBMJiD/Fpk2bqjcqJlYDRTuEwI4dO2jbtm0kwX+8vpDkoXrhwoUOaaG7myFWV507d84CQRQoXbp0UUtAshzEDhBwIQGvUjF90xMTE9UDSO/evdPvxjYIgMAVAgMGDEj1RZoeSlRUFHySpgeCbUcTePDBB0mCtGROFSpU8KtwzHwuvutPQPwkiwIxc5LfenF9ggQCIBAcASgVg+NlqbNlmaooFZFAIFwC7733HtWuXZs2bdpE4g/Jm0S5+Pnnn3u/4tPmBO6++2666qqrMrRCbqpGjBiRYR++gICbCfhSKspD4ty5c6lu3bpuRoO2g4BfAqVKlfK59FN8lcFFj19sOOAwAr6U6+KvWnwrIlmHwI033kiiQEyf5OX7nXfe6VPZmP48t2yLJaev+yG3tB/tDI4AlIrB8bLU2eIIG5GfLSUS21bm448/VnVPTk7O0gaxXIQvpCxYbLmjTZs2ymF4+srny5dPLXdPvw/bIOBmAplvomWMDB8+nLp27epmLGg7CORIYNSoUVSwYMHU88RKEda9qTiw4QICEgyvXbt2GZQx4pcXS5+tJXyZm+SeOH0SOYmlKZKHgDwTIvQGekOgBKBUDJSUxc6Ttyu///47if8OJBAIl4AE8XjooYd8LtkQ59JyHMn+BOSGKX20eJGtKEuQQAAE0gik97Mk/uAkCqRE7UQCARDInkCnTp0yPITKb0yvXr2yvwhHQcBhBOR+Ov3SWrFUrF+/vsNaaf/myAuP9C9BxB8m5GR/uaIF5hCAUtEc7mGX+ueff1LVqlWpSJEiYeeFDEBATP6ff/55+uGHH6h48eIq2qmXyrlz52j+/Pner/i0OQGJYuu9iZI3kBKgBwkEQMA3gUKFCtE333zj06G77yuwFwTcS0Csf/r370/yKUmUKY0bN3YvELTclQRatWqVep8llu/itxrJegQ6dOiQ6kNelMBjxoyxXiVRIxCwCQEoFW0iqMzVXLZsGd10002Zd+M7CIRFoHnz5rR9+3Zq27YtyZI/SaJ4WrBgQVj54mLrELjttttSl0A3atQIjsOtIxrUxCIEvJaK4kdx8eLFVLRoUYvUDNUAAesTGDp0qFImyjjq0aOH9SuMGoKADgS8AVvkJS6sdXUArEGW8tKwTp06KicJTCl+x5FAAARCIwClYmjcTL8KSkXTReDYCsiPrCgRp02bppZDy4PB6dOnadeuXY5ts5saJje4TZo0IVmWNnr0aDc1HW0FgYAIyIsUGR/Tp0/HUqiAiOEkEEgjEBsbS5UrVyZxHQB/imlcsOUuAgMHDqSEhAQV/PCWW25xV+Nt1FpRJIprIHkBUqBAARvVHFUFAWsR8KxPsFadcq5NcjzRxX1El0/w33GieP5MOEeUFEckx+QvgvWluXLzXwxRZB6i3MU8fzH8mbc0b5fMuRyLniGOU3/77TeaNWuWRWuoc7VcLn+d6aZmLzdELVu2pM6dO9Pu3bvp+++/9/jfSzhNFHeEx92pK3/8PeFM2thLTuBt/pMxGBHNY1D+eBxG5SeKKcR/vGQ/ujCPQbb+yVvWc05qqdgIm0AA8rm9aT6eQ+Koa/VtRJtfg3zChu4jA8xTPqAYuCuAceBvnjp58iT16NSSBnStx/caezBP6S02+S25fMzzOxLPvyXye5Jwlu/pLnp+S7y/KSkSqTPiym9K+t8WDgwSzVHt5fcl+spvTB6+z5PfHSR9COQwvgZ0rESPvPov3VR8OdGm1VdkhvsAzYWB3xnNkQaVYTbjoDjLpnDB3HTyzEXKvf1l3A8HBVajk7ORj0dfkEDdax2jhy9fpke6F8f9sEbYkY07CUTwG/kUyzZdJoNT64hO89/xVfy5nm/w93tuNkVBQVcMLVOSeI0m32ymcORa2SZvBFvWmSrlYiR/8p86n5srN6gp/Cc3nfmrEJVoSlSkAVFhNoEuVDMtX96yYhJ/iv369aN//vnHitXTrk6Qv3Ysg8qJx8j5nURnN/PfFko4+j8aPflHql/hMt13U5wnJ1HUs58YldS4844/GXveccjHveNOKRivjEO5Tk07fF4iPzRG8ZtBUfIXqMjjsD6PweuIrqrBn7GeB0RPKfifSiCjfOjkX0pOdOmA50WLnAf5pNLSfQPzlO6IfReAceCbiwX3ykvg89uJzu3w/K6c5nuXi3v55ZQoElmhKL8T8hJYfidYrOqfuq+7cj+XLDu993byu8PnsQW9+lS/LfJ+nL/LIfltkWtFIRmZ1/MyWe71Clbz3OPJZ4Gr+TemOh+X+0gk3wQwvnxzMWkvfmdMAo9xYBL4AIuFfAIEFdJp4gpr7NixyiVWSBngIlcRsJZSUd5WH1pMdHgJ/y0lunTYc1OYcpmVD1eUGXqIR5QcotiQJG/9RMFYtiNRmTZExZrwTrlTtU567bXXaMeOHWpplnVqpUFNIH8NIIaQxeWjREd+ITr2O9HRX/mhbxN3ebYoyMUPeomXPGMihGxDu0TGIj/oyUNmEpcdwxaNRRsRlW5FVLy5ZzxGyAOkixLkYy1hY54yRx4YB+ZwD6pUflEkCsMT/BJYXgSfYAu1c1t5Puc5W/7kZa68SDIr5eI6iKJR7unkty13EY+iscQN/DvDwUSK82fu4mbVztxyMb7M5Z+5dPzOZCZizHeMA2M4h1oK5BMquZCua9euHY0bN45at24d0vW4yF0EzFcqxh0i2j2b/z7lm1FWZkTy2+pEXsrMLx9MTZGytEZuPvkmuWwnoip9WcnYzqPsMLViRN26daM+ffpQz549Ta6JBsVD/hpADDKLZFbSH/6RaP/XRAcXsXUbKxVzseWhuBAwfeD5aYvXjUEyv1wo2pCo/O38142tT9jaxGkJ8rGeRDFPGS8TjAPjmQdbolgEigLxEL8IlhfCJ9fybwnfO8nvSOKFYHMz73x5gSYvltWLLFYqlmzJ93tt+d6vPa9oKWNevfQsGeNLT7qh5Y3fmdC4hXMVxkE49PS/FvLRn3E2JcBSMRs4OJSFgDlKRVmqvPcLoq1T+Sb0T67UFaukLNWzyA4xVIxifz1yo1z1XqLqo0xTZiQmJqpIlBI0o1gx9g9pxwT5Gy81+WEWJeLOWaxQ/MmjvLeyEjEnQvLyQZa9iY/Uyr15XPbn5WyxOV1l3eOQj/Vkg3nKeJlgHBjPPNgSE88S7ePfkj2fs4U7/5aI9Z9Y/cl4cVKKFiUjW1bmK0tU4Q6iivwSt1hTe7cQ48t68sPvjPEywTgwnnkwJUI+wdDS9VwoFXXF67jMjVUqJp4n2vY2O21+iQ0A+WZNKTVsxlRuoGUZT4lmRLWf4k9+o21gWr58OT300EP0v//9z8BSNSoK8tcIZBDZnP6baMub/ADIlsDSb8X5vdOSGpNsHVOgEtG1rPCvzFbFXncGVm8r5GM9CWGeMl4mGAfGMw+mRO9D3vb32EXG8nQvpYLJxMbnijuOKF65Ikunq/CLZXmJVaiWfRqE8WU9WeF3xniZYBwYzzyYEiGfYGgZci6UioZgdkwhxigVxY/OthlE6x73vM0206eOlqITxUWxBkQNp3n88miZt5+8JkyYQElJSfTCCy/4OcOCuyF/44UiFiTrnuBAR+tZgc9WiiqAkfHVMLzEaPbHKI76q48gqvEwL10rZXgVAioQ8rGefDBPBdR1NT0J48B64yC9gC/s4pdSfH+zg+/fZEWJE19KpW9vINuyvFv+JOBL7HiPFaNVo0xjfFlvfOF3JpBRpu05GAfWGwfpJQz5WFY+UCqm76jYzomA/krFk2uIlvfwRCW1k4+dnMh5j8sSTFmKWaUfUYNXeTuf94gun02bNqVJkyZRq1atdMlf80whf82RZpuh8P5jMNGFHfwAaCOfVtk2KoSDMiYlGui1w4lqPWUdy0XIxyNMq8kH81QIgyyMSzAOrDkOvCI9u5lo7TiP713xK50U7z2Cz/QEZIl0BCsYZdXKNQ/wT4787lggYXx5hIDfGWM7o8HPQzk2DuPAmuPAKzjIx9ry4dpBqejtrPgMhIB+SkWxjFo7hi0U3+UbUh0jNwfSSiPOkaUx4nex1TeeKII6lHnq1CmqWLEinTx5kqKj+UbWygnyN1Y68SdYmTiQneX/4HE2b2zp1i1NxqU89DV5i6jS3ebVE/Lxzd5s+WCe8i0XvfbKOFg5wKOskqAYSB4CZo8DrxwkUMTqYfw7wgG8xEWNWyzcve0P9VMs5CNi+MXyZF4aPYhziQg1p/Cuw/jyzc/s8YXfGd9y0WsvxoFvsmaPA2+tIB8viYyfVpFPulpBqZgOBjZzJKCTUpHfbC+sR3SOraWcstQ5R5RXTojkKLpNWZFamf3uaJzmzZtHs2bNom+//VbjnLXODvLXQ/5+pXRgPtEKtpRN5od0WJT4xhTFD30lbyK64UOi3CV9n6PXXsgnZ7KmyAfzFOapnLumoWeYMg6khSkcOI+XOf/Ny3lFmSh/SMETEMvFgtX5d+Zj9rl4XfDXh3MFfmdypmfK+MLvDH5ncu6ahp5hyji40kLMUzmL2kz5ZKpd+/btacyYMdSmTZtMR/AVBLIS4PWBGqf4k0RfVyQ686/7FIqCUqwyRcGze47GYImWLFmiTJE1z1jLDCF/3eTvU0zrJxD93oeXOp+BQtEnoCs7xfXCkR+Jvq1FJEv7jEqQT2CkjZYP5inMU4H1TGPPMnocSOsuHSRafD0rFJ/w3LNBoRi6zBM4GOEpDo62uDH7onw99HyCvRK/M4ERM3p84XcGvzOB9UxjzzJ6HHhbh3nKSyL7T7Pk46NWycnJ7KaeXzoigUAABLRVKopiY0kzz01qcmIAxTv4lJX38pt/jrqrYVq0aBF16NBBwxw1zgryTwOqg/zTMr+ytWEi0T/PuVN5nwVGADvEivPycaJF/MB3cV8AF4R5CuQTHECj5IN5Kk0umKfSWFhly6hxIO09v5Po+zqsCPuLf0dYIYYUPoGUZGbJqwbWPcl/bPkpPin1TPidCY6uUeMLvzNpcsHvTBoLq2wZNQ687cU85SUR2KfR8gmsVjgLBLIloK1ScSVb6F3Y44m+mm2xLjgomv21jxCdWK1JY9euXUt58+ala665RpP8dMkE8k/DqrH80zK+srWWIxtvYv9NSEES4HEpD89fV2T3DFuDvDaI0yGfIGClP9UA+WCeSgOOeSqNhaW2DBgHEtl5wdWeIHpufwmsh+zF2uTf14h+7a5H7p488TsTIlsDxhd+Z9Jkg9+ZNBaW2jJgHEh7MU+FKHWD5BNi7XAZCGQmoJ1ScdfH7Hx9qWf5b+ZSgvh+9iK/POcVxGxxm22S36h1rL/M6bxsM7ly8ACv2N64P+uZl9mt0Cm+Lww5iSP6ZV2YSTiZeEoXP4qdOnUKuSq6Xwj5Z0WsofwzZL7rQw6ANIP71eUMu0P5Euh48+adwAbIMu7kuqNsmCxjRK+k27j8f/bOBF6q+f3jD+2IkkIpZavIUlKKVEJR2bKvSfZC9uy7rNnXULYsyZIle4UoWeMXqag/LUIILar5P+/vdG5z587cO3PnzJkzM8/39TpzzpzzPd/l85zv9nyfhQKvpYb03+4SVRv3uwJGn8z6zWzSx/qpsl+79VNlMUnjTl72U0t+VrvXbQPzJ8J48aceqYbv54v8n/r0Wa7jzQIdZ7IVVqg/wf/p3C9RHsz9Mh7fVql0/E8vqmr5Rf5XwcYZG2dWf1XFth4q1ZisHYS3HUAoo0+46VOqMdkfQyAzBPxhKkZ05odUXobqM1+rRuJ5T6njwT9EzlQeJRPKZAHGxk4Xi7z/XbIYFd9/5iN11qdpPK/ChOvVKBv/5GEig58uez+tO2Ay4+G0XkkUecyYMdK7d+9Ej3J/z+ifnAY+0b8kg2ULRT45U9ta5ozqdNob+U+eKbL3DSL3vq0Ozk8WaXiGyM+LSkrm20Ug7ZJZ+HLtaHBM4Gcw+ogv/WY26GP9VPIv3fqp5NgkeZK//ZT2fR8crmPIYuefJUn1fLv9gO41vzBFj09EHnu//GSXKA9uj6tFRk4U2f5CkfVPFHl0fPnvVOYpG9fn61yz+xAVJpxbdv4HQ7GVTmk/yGB+Wapc36kTnPlvlrqV0R8bZ2ycifmAim09VFJ1awfhbQcQyegTbvqUNCS7MAT8QcAfpuKcUSoyqLO0DMKkGVFG4m3HiGy9iUj/LiIHquYIO8mJwvaqvfi6Tvo6pqgNfOurpVMZOFzkHPWlMuY8zbeHyOb1Sz8f85lOgD8ofa9S/2D+fH2NTt6TVCSFRBcsWCDTp0+XTp06pRA7B1GM/slB94H+pRKfdqt+SytK3arMn3TbG3lc9bzIIe1FHtCF3oP9VVBS16Zrq8BfJiFn7ZJCI6E1S6U+ly7IpAql3zX6+NNvZoM+1k+V/lZj/1k/FYtGmeuC6qfmvSHyx5c6Z8uimPlqBK99QWSOmrE9fg+Rvp21u/1F5D7dlEoWYNQSLj9YJeJ1A2td3eytkuEsdcI03YebGU2XXyQmd1afNEhCvql7Sn3aaT411zzn6rwnRebqnpNvYaVmOvlUTU4HTT+CjTM2zsR8R8W0Hoqptu4I2HzYl3UqoNp8uNSnlehPQc0DElXQ7hkCGSKQ4XRtde5znlOpn8x0VAaO0InkQbpjvHpyt1NT3aWuJfJ4EsYeE80eO4pUrbIGAYRbCJy9a/6PVknEG17mKhqemyRy91siw04SabShd3fN+XcVLmTie+DOa+5ldEVn/df/Kp3Eq6++Kt27d5eqVatWOo2svmj0Lx/eDOm/JnH9sGcO08E/MwY+6aXb3ngHScW663KlUsKbR8/p/CKFEhty3i5dYbQjmT0ytlgZXBt9fO03/aaP9VPlf9vWTzl8Cr6f+t8tavZBJzlZDjPmi9z/jsjVh67J6Nz9RGA0JlI3JtYns1QKfr1ofDZ666web9akUP4V5nBiVZbnqST9Mffq9EunYF5AkhpJxQd1cywRw/KlKSJN6nmxfTzjJGzhhz4kaOOMjTOlP6NiWg+tqbm1g1C3AzZQbL3iHx/Bffh+rlfWtCS7MgT8QsAfpmKGE6VXP4/uGu/RonS1DtEd5Gt0ArpSJ4qxAenFe1STZJdLRV7RdxepMOCA4SKbnC7y8Hs6IVTt0MYDo7Zy2I1GpXqxTip761yaHWskrjZeX009LBS56GmRd7+JTT0qwXj9YSLVfOPhaeeaAUahVn0GugzqxutGf1BIIfzzoy8MxXTxpmSnPSLyq65DUWXr94DIldqGYgN2xQ66TeSAW0VaXyxynZqR8uydvvypyHH3iZz4YNTcAAu9cLRLrQESJD+/GluVyl8bfcTfftNn+lg/VcG3ndk4VZK4tYMQtwOl8a9+MLZUyu8r1So5R6StzsOmKDOQQB/fY4jyLFco81DHgAPblmbc1daN4t2ai9z8SjR+7O8j41T7RAUoP/shOsYwzsQzH8fq8z2vE9nvJpF2l4mM+9+aFC7UvaGzHhPpcq04lTOenPukjjU6Nl2q+95DX1PBpp9FntVN5V22FLlTBTY9SUovld9UI5yF+sUHeHd8PK/QsWaeTlwzDda+Qty+lLg2zlTwhds4Y/PhCj6RmMe2XokBw8/1Skyy5V2uvfbaaoI+Q5W08jKwZwWFgD9MxeXKJcggYBexRUNVpYwrTZONoow/VGZiA983klJTdPJJqLOOSDPd1f7lL52E6jFeJ5vVlSHI5LCx7jif3SO6442qM/+/0YmlDmuCRAIMjm7X62T2C5eUk2rcXPNFUtK3gATIknmVSm758uUybtw46dmzZ6XeD+Qlo3/5MGdA/1IJ/zNHDetXK3WrMn/SbW/kcV+/qE3/QfuKPHKKMhX7rMkZ5iEMezYFXjpXZMSpUabjXavXT6cqQ3K3bUSeGhBt489/EpJ26VUBj/V+BKOPv/2mRxO/6GP9lIdo4rP1U4XfT2HjyqcFwj47iOyuDEIYf62bRj+pTTZQxp7Ot9iQnfCtyLaNyn5qSAG+/XXZ+/26KKNQmX2kyRjDsbGm5wWc6fW5Paph8toFIj13EtlXmYvMD7F9eNMrUanIJ88Qeei9qCMxzOkQbjxCZNB+Iu+s3kDGydhGtUVGTY6qQnvSjYOeEBmicf3bUI7m734xgfNngorHREnp0sYZG2diPpRiWg/FVFvE2kG424HRJ9z0KdWYkv9ZpQu8SKzqZ/Ko9sQQkDg2Xm4Q+W5u6cmjV4rGG0aveB4bEPVnp5nAt86g6k1eT95TZIsG0cnpT7pD7QWPz/4/ZSgSHuqvu9jKp3tUJ64wKEd+pBv4i5V5opJYlx4YjROG37Fjx0rr1q2lbt26YShOVspg9M8KrEkTTRfvpAmtfjDxe/XTpHy53m2iN3ZoIrKjtimkGgmYGThgZ5EPdeG3UJn+P+gi0Av52i698mfjbPTJBqqZp5kuXYppnMoc3bIppIt32RRK37F+qjQefvxjk4l5FirDhPHKSNx7+6gK8uxfE8/rYCri3TnddcqD74pss2l0fkdex3VSc7j/6SbWBJWAbyrytG5a1dI9tze+4mmU2Ri9WvMLY5I4H14pcupeKrV4ZlQC/62pymBUCcamfm8or8k6dFfWvkJHElegdOli40xmdEwX74pys3GmIoTSe270SQ8vi20I5BIBf5iK1TNjeCExuEqZg/Gh/vrRO3+o1kiykGzTHUnF2CS9eN7Od02dWBKQjtxdpaiYVN40JmprB8kq1HiwITduWvQ6XgU7+naKv1Vq6UxWZ8OVCKNHj5aDDz64Em8G+IrRv3ywM6B/qYTXVW5dRFdRGYZM2luirFk8xoddtxL5UYViCEgRH6vqz1/OiUooxrb1nLbLaPHUSr9yQP0IRh9/+02PJn7Rx/opD9HEZ+unCr+fqqGdcbrcvMRfi7vLBlLXbaM2qj//Mcrcw841kn/087F9vZcM87p/dc63XFWk0wneeOK900w3jxtoWtxfp0Y0vQNui94jTmzeseMMc0PvP0xK0nhT539IKWISh7kfBwE1bUzt+BLWUmA2aJV5UjbO2DiT5Cvyvuv4x4WyHipVL2sH4W4HRp9w06dUY7I/hoA/CPjDVKy/W0alYWI3N4EGNbYSCags+xWQYmSn+rMf16TIgIsDCtRuurSMTjKZaMJ4rKHPuPYkqta8lc6Vvl0JjFasWCHYUzzooIPSySz4uJWoW2whjf6xaJRzvW5TNVBVs5wIqT3yG++GdaL5fvT9mvyras+CEyQM4ve8WeSEPURO3zvaptbEWnOVm3ap+VdZRwvac01BMrky+ri+0r9+02f6WD9VwddduXGqTKLWDkLcDpTGG2U2X4un95ndRd77n8gVo0SOXp30+tqtogqdaF6HI7z6qnpcY/XGbnx6yf430r3rqbox9Y+OKV5gnNlMx5l3VKv4jOEizwxUm4vbeU/XnD1mS6vNVANZrdHMXLDmGXM8nMOcsmc0LeZ7HAQcxeAw0JdQVUHZdJ/Mk7L2FeL2peS1caaCb9zGGZsPV/CJxDy29UoMGH6uV2KStUtDwC8EdDrlQ2hyqBrWUV3HSnqAbtU46nAlviQ4f2DS6Kk2xz7/Z1n0n3detnrX23MOwX0cuhDYxUba8U89sP9zptr8wSD4RftHn09SiUQmw/vvHD2id6M74BvoPPAGtbGTUUACZP1t007ivffek2222UYaNWqU9ruBvmD0Lx/uStK/bKI6Gduyv8h3d2TksKUy7W2pSpYg+btiVbRUXntDgrfD1lG1MdrUsZ2iz702hb0rpD/YIKA9T/2/qOTiX9oWc94uXVG1ApsfGS10xr9GHyBEcsiXftPRw0f6WD9V/hdu/VRx9FPbnify+yTfPEDv3ybap9O3t99qzSfGODPvjzX/vaufdQMZ8xiJwr86b6tZfc0TJB69edyRHaPmaZAqPGgXVbv+TWS+zucO7yDynFaHuGxiYTOYEOvxmT4JRiaOY7bZROS1L0QGKjOUMQnG5+G7irSMm2YhpXhSV7W57YNwoStQjY0yZji5dNjitnmAjTPRj8H9eusg7+zNzwppPRRT3dWX1g4AIrTzLeun3HcaXvqsbkZ2MgR8REBZdj6EJoeoHnHlJaiO0skiqjDxDlnGfK6GudvpPGz90mVk4oinPwLOWD7/QVVU3or+x+PgeFVZ5sC2Bd4BkT7cVKWptrsgOsm9qk90EnzI7VFPgthuPHe/6Puxv6hGr63jVkahqm51t7pMRR1V9SXNkBeqz9TJ6J+cshnQP2GiLc/TbymzvYB02xvluOTZaGnuHKtqzLPVmP3L0f94ecao/XNnRdvbwOFRL9BIF1/YW2R7XVh2VKYjXjkxK4DdxSc+FMFZS07bJcWHibLFCbqK3ThaGT9+jT7OpETG/WY26GP9VPIv3Pqp4umnNlVuWp0dMx5HvI+JedLxupmEjcPYcM6+Iu9+E3snev2KzutO61b2Pl4+mbPxzpjPonM7GJB4a54+T6RTC/XgfIwyA0dEvTZ3v1Hj9BNBBbuPMhmRKGx1oci3aoN7K+3ST3k4qmZ9sD7r/5A6Cpuom9Q6DXvlfJEndQwaMFyk8zUiD+o+XTxDkdIh3ehJOJYtbZp3kDBpdz+ppvlikug2ztg4s/rTKJb1UMKWYO0gvO0Aghl9wk2fhI3KbhoClUdgLfXqgwBS5uEH5Rp8coZuK/9dqbQeGafMwR9F7uobfR2pwr2uj3qM3XqT6L1MfrEjx0I3VuWGPAhI1WQtwLA4YKYyMJS5mEbA4xISih988IFsueWWabyZo6hG/8TAV5L+iRNbffeHR7WtqZ7Xin/KjVbew2y0N3bFMcCPKYEGG5TOHZW1dWtG7yFR4rXDnLVLVos1tWPpNU25onGFLV309P8ZfdLHLP6NbNHH+ql4pKP/rZ9yOBRNP7XkZ5EXNkv8LVTiLhu0N6rA95Y63YkN+yrjb/D+Inu0jN5FTfnGMaopcqFOiZQZWZmANCPS785kRoxUIxvTsOzY5PpPr0kfhifhDx0qUWWODfOUYYkH6Kx4eo7NiA3lrU8VaXt37N3Mr22cyRxDG2dKMAzzeqikkIkurB0kQiW9e9lqB5TC6JMeLRLFziZ9EuUXc69Hjx5y7rnnyt577x1z1y4NgcQIVLlSQ+JHad6tu6PIb5PV4M1s1ZPUGV2aoXXTqATUd7oj3aKhyGF3qjSUTlKTqcmkmbxU03kdu9SxAdtfHFkLSELt+YZyU5qlncXEiRNlwoQJMnjw4LTfzckLRv+ysGdA/7KJxdyp21pFe39Vt5Ufx9xM7zIb7Y1xj0WaxzyMLRF2S70Q2w5z0i4pSFU1otX9IzWw2sgrln9no0/mWGaLPtZPlaWN9VMlmBRNP1VN1T+2OUNNaSg3UHQ3qBLhF1U9vutNtU+tmiI468KbcnzopUPV1S+olojyL+donCtHKy9zUGbzLpiA2Dxk7IgNMBE9RiVnxiMvxKpUe/dq6/TMi+/d8/1MIZqfJbIzOMcUyI+MbJzJHEUbZ0owDPN6qKSQiS6sHSRCJb172WoHlMLokx4tEsXOJn0S5Rdz77HHHpOOHTvmh3BTTLntMjcI+CepSPn/01nmG+1FFs9QxuLKStVo7JeqTauqk0gyxe96VyrBXL2EUe6ddJt+mwGVKsGZZ54pDRo0kEsvvbRS7+fkJaP/GtgzpP+ahMq5mnSSruZGZiSxWDDtrRyYSj1ikYdw9oGz1aij6s1lMxh90kc3CPpYP7WGLtZPrcEiTFdBtAPq+8dX6uVkz+jcbVV6m8FTZqlzu6uiDu4eOVnnbRslBhAJwg++UzPAyrvco8UaKfXEsQvoLiYFGqkNkN10jM5msHEmfXSDaF82zqyhi40za7AI01UQ7cCrr/VTHhKpn4OkT5JS7bPPPnLeeecJZwuGQEUI+MtUJLeVqlP8jE6m1lau4CrVcyzW0PrmqD2JStQf1eeGDRs61eetttqqEink8BWjfxT8DOifFvW+ukyNSN2mjMXVuvxpvVxkkauorly1OiJ7TxCp3TyYyht9Usc5SPpYPxWli/VTqX+fQcUMsh1QpyVzRSYcpJ7svkl7gwo146yrDweFu1/5rIXIZA1Vs7lOpRRVLDOIYONM6igH2b5snInSxcaZ1L/PoGIG2Q68Olk/5SFR8TkX9ElQKmMqJgDFbiVFQGc/PgcMUh+uDI567VTFUJmLxRbYWdjz9UozFIFr3Lhxstlmm0neMRQpvNE/Y/oDY8phh2tUEuIpXdltoNgr08xCYgToizZW/byeU4NjKFISo09iesTfDZo+1k9ZPxX/DYbhf9DtgDrXUnsz3dWUxk436JxN529sCKcYjKEYB1Q1NatRdyfF85PgGIoUwcaZOEIk+Rt0+7JxxsaZJJ9iTm8H3Q68ylo/5SFR/jlX9Cm/VPbUEKgQAf+ZimSJjaa9xqsLvv56XbPCQhREhKpaZ4zdd58kskmPjKr09NNPyxFHHJFRGjl92egfLPyNDog6A9pUvzuwV762hdUIgAf2w/C82eVV1b1rEDw0Rp/kmOeSPtZPJadLNp547WCT7tZPxeOby3bgyqKDxjbq/Gv/GSINe0bnbWvHGS2ML7P9X4MAi8DqG6rtxKEiPaao97/t1jwL6sraV3Kkc9m+bJxJTpdsPLF2kBzVXLYDr1RGHw+Jsucw0KdsqeyOIZAyAv6rP8dn/bvu2L5/iMiy39JWrYlPKpT/PVWXZseLtLlVJ+O6059B+O+//2TTTTeVzz//XBo3bpxBSiF51egfLCHA++MTRf5Wg1cZeIcOttBZyA31M9E9k+Zq07TV5VHHLFnIJu0kjT5RyMJGH+un0v6UM3rB2kE424FH1MVqBPHzC0TmqScWHLmsXO49sbMisEJNhjuHY0gmrqWSndtfqR6eT9Ehh3EnBMHaV5QINs4E+zH6vB7KuPDWDsLZDjzCGn3CTR8tnak/ex+rnVNBIPtMRUoRUduK3z+o7p0vjnqGLhT7b3hkqtdGd6fvEqmzQyp4Vxjntddek+uvv97ZU6wwcr5EMPoHT6kF72h7u1RkkRrijyzTdaGugoohIDEi6ogFB0ktzolKD4ex3kaf8NHH+qngW4q1g/C1g9VfwYIFC2TEQ0PliREPy4JffpUFw1Ti+7+/gv9GwpajqoffMVbk0mdWyh4ddpCTz7xUuvfoKTVrhlArx9pX+NqXjTPBt2hrB+FrB7FfgdEntPTp0aOHnHvuubL33nvHUsyuDYGECATDVPSyXvG3MhfvE/nfjcrk0J3v/xZ7T/LnvHZV3ZnWo37HqARUg86+lv24446Tdu3ayYAByhQptGD0D56if3whMv0ekR/V7iLfbSEuCl2bVGmR9TZXycSzRJoeEx7JxIoobvSpCKHgn1s/FTzm1g6Cxzwux+XLl8tHH30ko0aNktGjRwtMxapVq8puu+0mF12gi4qWOl+b8ZDIL++rRoZK5OXj/C2uzin/RRUc1TTM+ahWyvLNjpbr7n5RnnzySfnxxx9lLbWlvf3228uxxx4r3bt3l2233TblpAOJaO0rEJjTysTGmbTg8iWytQNfYMxaIkafrEFb2YRNUrGyyBXne8EyFT2MI+oycM4oZXbcKfL7p3pXJ2wrl3hPw3fGRl1V3aVHAmqL41QK6kx19rCN7+VcsmSJ8/o8ffp0qV+/vu/phyZBo3/wpFil0oo/vSgya4TI/HdjFoX6TedjYFGLqk31espEPFLbZV+R9UO2kEsHV6NPOmgFE9f6qWBwjs3F2kEsGlm//uyzz+Ttt98WNCRgKFarVk1WrVrlpBLOOuss6dKli6y9dpzp7RUqrfh/OpbMflZkgY4lbOqsXKobxaqRUkgBTRQ2v9dpJNK4j0gTNeNTr32ZGi5cuNAxFx966CGZMWOGVK9e3eG47777OtUxJDwaNmxY5r2c3LD2lRPYy83Uxply4cnKQ2sHWYHVt0SNPr5BmWlCxlTMFMHiej83TMVYjJfOUymqx/UYKfLH/2KYHbGRcnBdRSWf1tadaewJNeylu9PHimzaXRkZygDNUmDX+6mnnpJXX1WHEsUSjP7BU5oBe/7bUSbjvDdEli7Qb10lMJzkSUiZjHi2poyrdPFad2dd5Klzms0OygpzP3iCxOUYQ5+ls8fK/a/Mk7N7qVq30ScOqAD/Wj8VINirs4ppB2L9VMb4Y6/5008/lffff18mTJjgzrVq1XJMwz///FMOOuggOeaYY6Rbt25OQjG1DHV+9Osktb2o+sBKo+W/fC73vLWWDOqpjMZ8sumr87q3/ldD1qu+XDq00g3dBnvovK+Hzvn0qLlJalBorHnz5slzzz0nw4cPFzaHN954Y/ntt99ko402kj322MMdnTt3lmbNmqWcZtYiWvvKGrSVTtjGmUpDV+kXrR1UGrpAXjT6BAJzskyMqZgMGbufCIHcMxVjS7V8kZuYyvy3okyPJfOVyaiMPToVdsKzFVR1RdiVhp8S0Z3pum10QrmfTijVhkC9dnpTnwcQsF3Qt2/f/Pb8nAlORU7/TKDL6N1lv6jEyThdHE7U83iRv6bpJ69MdSQBnQSKtomgAm0RZ0cw78m7el1tg21FNu4istFuer2LPtMFaxGEr776So488kjpc0APufpUlZAx+oSD6tZP5YYO1k+lhfsvv/wikyZNcsfkyZOdJGLTpk2lQYMG8uuvv8rs2bOlZ8+ecvjhhwtzDyTsMgkff/yxnHBCX+nacQe592KdO/02OcpwXDw92mfTb2NPLpc2tZGqZE7JnG6FasfU0PEFe9hqzmbu8qayc8+L5NDDDpchQ4bIOuvoOJRBmDNnjjzzzDPy7LPPyg8//ODUo6tUqSL/+9//HCMX5mL79u3dsdNOO0mNGip9n8tg7SuX6JfN28aZspgEcSek7eClSf9Kr/YbSpUGOgcuwvlwCelDSp9CXa8YU7Hky7OLFBAIF1MxvsD//aGOJr5UCcavdHL6sZ6nivz7k0rs/KlMwNWMB8cIVCcUqBBEdNc8wrUeMCdQq8YWjp6Xrazi7N5Uhx+Bmg6T21qbqmpLU51Q6oId6ae6Orlcv4VGiFP30TvZDvPnz5eWLVvK3LlzBekBC4qAj/R3KlqOOawfTAjpHy56K0Z//6DMxW+jx++fR89L56pU469aVH3Owsy1Mf7S7la3PyR7aX+qQueeO8lebU8wKLmmPUZom5oG8Vb+q225tkqDNBBZd3ORDVuLbLBdtB2u31Kk2gbhgiaA0kQiERk6dKhz2HT77bc76aHS2Sp2Rp/SkOTyn/VTOULf2oEH/KJFiwRV5i+++KKEiYj0IUwrGFYrVqyQqVOnumeo48JI7NWrly/ORf755x8ZPHiwPP/883LHHXfIIYeomnB8+Pf/tM+aKbJ4hh7f6byOudwcHU8WisA80XFhpVSXpf+tLevWiBkfGCMYU1YprdeKGVeYo7kxZfWZuZ6OLys03rLlEU1D38GkDjYQa9SLShvW3koZiNurdPvWeug15yoqAR4TwPGcc86R9957T1Bn9ss4PWrRTz/9tGMyQhcWao0aNRKP8fvdd99Jq1atpGPHjtKmTRt3tGjRQmBC5i5Y+8od9glytnEmAShB3ApHOxhy/1iZ/OlXrh/JdAMoCNSCy6Ni+kRUy+nvZWtJ7Vo6tth6JS3SGFMxLbiKPnK4mYrJyIOdG5iLy3RCuuw3nZTqgWqgk2jUZzxnwrm27rxje007lHGfzpXzrh8pU8Y/p8xEVWepoUyMEIVbb73V7WA//PDDISpVSItSAf2vuGusHLTXdrLTtpuX0N9JvNXcKGqDL4T0DynSiYsFU3+pShGzGFyujH/OOICh/cGwhT6rVsiot76RJXrr2IOUae/aom4EVK+z+qir5w21LTbUtgqn3wIIsKmAsf+lS5c6Uwibb67fcLohRfo4pi90UW+mRp90QU4hvvVTKYCUxSgptIMr7npTx4pto2NFnrQDNiBRY4aJ+Pnnn7vz77//Lq1bt5add97ZHTgN+fbbb90CFJuJXbt2dYzEAw44QNZdtzQjLRMKkPaJJ54oe+65p9sIqVNH+/fKBB1D2nXoLOcPOFIO3VclcaDdCp3ToULtxhQ2gnXjSseV6GYVfVbMwcZUdd2Aqra+tOt+upx/zhly6FEnRvu1SpTnnXfekX79+jnc2NipdL0S5D1t2jQZOXKko83KlSsdXQ488EDBUQ6SpVOmTHE0/fnnn2WHHXZwDEaPrjiAwXlOKEKBtq9QYJtOIWycSQct/+Om0A5K+q0M5lv0FYceeqgsW7bMOdLKuWSz/0hmJ0Wlz8UXXSB//7VI7ry6X9L1is2HE8NvTMXEuNjdxAjkJ1MxcV3KvUuHjNrPl19+KZtttlm5cXPxEGkCJq8YRreQGQLWCWaGn19v33///U5yhrOFihFA0ueMM86QgQMHOsmfMg4SKk7CYuQRAtZP5Z5YYaYBcxYk2JA+5GDuwpnAfAGJNhiJnLfcckvHlBo7dqxjVuF4pUOHDs6UCrYSN9hAGW4+BiT6Bg0aJOPGjfNFom/MmDFy6aWXuvrhSTmT8OabbwpOZr755puyTmbSSBgJzIsvvtjZSLzzzjsTS2CmkV6iqDCFUZFGihENFSRIMXnRvHlzWbx4cQnTGCYytJ85c6bzLA3dvQPGo5+M4kTlrOy9MLevytYp394zGuQbxZKXlzHhuOOOk3///VeeeOKJ0Lb75DUI/gkOUFnzf/LJJ7LFFlsEX4A8z7F79+5y3nnn+Sa1n+dwWPErQCAkW54VlNKHx6iRsEv/4osvyoABA3xI0b8kvv76a2GSbgxF/zC1lHKPQL169ZyR+tyXJNwl+Pvvvx0jEQcKOGlCKsWCIWAIFA8CqMTCNMSOKvMBpBBhiqEiCwOR48wzz3Rn7nkB5ytvvfWWXHPNNfLyyy87BuNhhx0md999t9D/ZiOw+cEcinywD5ip7UHMPVx22WWuDpkyFKkvTJT69es7j8xIfVc2wKhDnfvoo4+W448/3qV33333ySabqKaLT8FjDGLDESlFGIx77bWXbLjhho4hDJMRBy9egJnANwIzkuPRRx91NGjcuHGJhOqOO+7ovpNNN1XzPhYMAUOgYBBgHfv444/Lqaee6vo5No/83jAqGLBWV2TEiBHSqVMnYyhWkrCMzxwWDIFUECgapiJgoGKCNGDYmIqPPPKIU3lMhWAWp2IEkPDyY3FScU4WozwEWNT+8YeqR1tIigDODZBMwXYXi8VMF+hJM7IHoUPA+qnckyRoGmDbEK/A2Df0mIi0e9SXkTjjgCmENArX662nDuTiAtIq2PyDATV69Ghnixnm04033ugrwysuW0Ht+vTTT3dMLPJFEtKPQFqo8u2///5+JOfSuO6665z68lFHHZWxXcJ27do5Wl177bXO7uFNN93k0vatsKsT8py23Hbbbc4zN9KLYNykSZMSBiMSN7vuuqs7vPz5plB19yRaed+TaOVbgnGJOjzHdtttl7FDHi/fVM5Bt69UylRscYwGhUVx6Pnggw+6TaZu3brJG2+8kbUNpEJAjjX/sGHDCqEqVgdDIPQIFBVTkR3sY445xk3g2QkOQ0DSgJ0ndqkt+IPAKnUSYjsr/mCZSSp169Z1XkYzSaNQ34UxwML3nnvuceqDfi6oCxWzQquX9VO5p2g2aYB3ZZiHSB5ycA1DESYRDEOYPP3793fXzZo1K3cjjPHsww8/dLb4nnvuOWnatKlTlQ3KnAvSHqhAISEDs8svRwHgj5Qijqn8DEimgBGSfGCcaaC+V199tbNpdsIJJzipRexfk0c2AuXnQO0aFXMw55vBmR+M0j59+pQwkLGxiJMXDua3Xpg3b55jhvLdoRZ/8803u+8PVXm+PY+BDaORemRjIzab7curp53LR8BoUD4++fqUvgEHWWi4vfvuu046O1/rkq1yo/mDxPnuu++erSwsXUPAEIhBoKiYijVr1nQSQdjvQZ0lDAGVJSaDZushDNSwMviJgKk/J0Zz1qxZbmGI8X+YAn6q0yXO0e4aAoZAthCAeYgaMOrK3hlnHOuvv75j3jC+I4mMV2EcbTAPSTWw2QhDCanEjTfe2Kkccw8mZBDhhx9+kJNOOslJnOO8BEaUn+Gpp55yUjbYbfI7IFmIYwOkPv1igsKMA3+YoLvssotccsklTmII6aFsBNQdkUbiQPUaVfdnn33W2Z9EAhEJVbxtJ1J1R/2Zo0ePHiVFYxObbxNGIxKypMk1krIwFzk8BiXnhg3VkZoFQ8AQCCUCN9xwg2OasQGB06ww+gvIJXBIbTPuWjAEDIFgECgqpiKQYrQcdZuwMBVRfcbLoAX/EDB1D/+wzCQlU38ui97w4cOdxM/ll1/uFqNlY9idYkHA+qncUzpVGiBZPGPGDMeQQdUUxgxOVJBAZHMAZiEMGdRVkYyDIQNTsTIB1VUYiRw47zjiiCOcujPOO4IKSDchCQNj7sILL5Rzzz03I6cnicoNpkj/IfGXjYA6MbYoSf+0007zLQsYfUhtHnzwwW7uhidnJCL5BrIZkEjcd9993YHzs9dff90xmy+44AL33cFgZH5bnqfqatWqOcYwzGFsRXrhr7/+ct8yjHG+aSR8+MZxVkO9Yg++bZgXqUg2ptq+vHLY2X8EjAb+YxqmFHFwVbt2bSfZjMRiUBtOYcIgUVnoyxijGT8tGAKGQDAIFB1TsVevXm6CiUcoJuy5DHPnzpWJEyfKqFGjclmMgsvb1D3CQVLUDpYuXeq8kvolKRKOmqVfCiRBTj75ZDfJGT9+vGNApJ+KvVFICFg/lXtqxtMAG7AwDVmMcHz//fdO+hCGIs4wUD9t0aKFdO7c2c0j+O+HoXwkHJFAg0GFNBkLIbQY/JYMTAVxyoKKL/MjbL5utdVWqbyWdhw2WFAFR8omW+Gqq64S5nx9+/b1fb6Hdgm2LR966CHnTAVHOqgjwrjLdsAGJTbCOXDe8sorrzgG49lnn+2+Tb4fTGokssmZqGwwwDt27OiO2OeMW3wP3oH9NtrHb7/95jxUe+2BNuEdsfWPb1+xadt1MAgYDYLBOZe54O0eCXicOiGxGOQGVC7rXV7et9xyi5xxxhkZ29QtLw97ZggYAqURKDqmIru47GAzOWJClsuAnSI8KOaauZlLDCzvwkYA26UsTIpZxZfdY1TwkCRB3a/YGayF/cVb7cKOABuKMAlhGKLei4oU3pNhIvIM5giLMg7GZ+8aRo6fgTJ4qs0wM3HY9MQTTzi1Wj/zSTUtHH5cf/31TkKRM2rPqUijpZp+bLzly5c7KUXUurMZUBFGevTee+910pZ+5wU+bBb17NnT2ZskP5ilbdu29TurpOnh3IvvlGPxSb57TQAAQABJREFU4sXy0ksvue8K6UzsiDPuUL7KzDMZv7FHFm+TjHw8iV3OMMM5055Qmd5mm21cu/m///s/56UaSUe8lmfre0oKjj0wBIoEgVNOOcW1cWwsYiYBieJiDQsWLJAXXnjB9UfFioFf9TZJZ7+QLI50io6pCFlhJr744os5Zyqi+sxkzIIhUKgIeHYVi5GpyML54osvdhJIbCBgF8uCIWAIZB8BmB4zZ850zEPOHNgyhXG4cOFCwVnF1ltv7aQCYSKiysp/bNBlM2B/EYlEmIk///yzYwShyoqUWC4ZLp988omceOKJsvnmmzs7rzCAshlQSUYKE0/G2Q4wjPfcc08nWQoDLhsBvLDVDV2REIRBTL7Zyi9ZHVCDxFkLx6JFi5ypHzzFopIPYxEGIzYWM93YIh9sSnLEBqTiaGs4JKKt0Q7ZSLv77rud0zav3dHWvAOJT9SpWbxaMAQMgcojwOY1fQ42fOmPgtzcqHyp/X+TTSTMO+As0kJmCJikc2b4FdvbRclUxO4MNs2w6YN9nFwERNRRTSnWTj8XmFuewSPgSSoGn3Nuc8SeC146UR3EGYtNbnJLD8u9sBDAGzIMOiSjYBZ6Z+4hgYgtOBgYtD/Obdq0cQwV/qNy6zHwkOTab7/9nNpYthDCCy8mTmCuIJ0IAxPVLFSoc81IQTITm1xISN51112OyZktHLx0MYmBrUYWvUEEVHRhKt5+++1ukyebeaJ2zDeFKjSSQjBPu3btms0sk6bNmAOjmANGOt8gUrnYE2djHcYnuGCr0a/A9+wxC2Fi4nUa+5Nggpq2JyFMG0W1njbB9a+//uo8UNNWPcYjDG7sw/E/aOasX3hYOoZA0AjguAmpZMY1hGfYsCqmwPiCA6oPPvigmKptdTUEQoGAf7OJUFQntUKwq8xEZcKECTmb8LF7jNqMBUOgkBEoRqYii3McENx4443mhKmQP26rW9YQwK7gTz/9JHPmzHEMwx9//NExETlzYI8Yb8gwHZB04swiimuOXEtGe0wcJNfwsgsj8corr3TSyn4ycTIhAPYAYTix6MRmXiIPwpmkn+xdpEiQUITRG1QAe+qJjS0/bGCWV27GPJi0OFJBcgjP1rfeemvW8y2vTPXr13eSmqhEw+RGWhZ7k2x89enTx9nwzDaTG8Yg0qmJ7ITCCGBzwJMqhvmIiSI2C7iHzUfaOJsC2DZt2rSpk6rlzP10PKqXh5M9MwQKAQEY+jDskZqmrbN5UCzh8ccfdybOMMFgwRAwBIJFoCiZikDMJB/bM7nYRf7ll1+czYthw4YFS+0iyc1sQISH0MXkARo7LkiBoHaGFAYbFxYMgWQIFGs/hTrN/PnzHdMQxiF211AFRsoQJiIHTDlssyGtxAHzALtuqHVyzT0/mHN+0sBTN8VO4OTJk526KVJaMJUyVTdN9g1V5j6efvHmjBTZAw884JixlUmnMu8gQcpmC3ZmgwxIz/Xu3dtJ6sFMCyLgqRlm7UUXXeQc/IA1Zch1QMUfxw4ctDW+V75T2iJ2GZG29EsdP9X2BVPQ8zCdCB/6CxiMnnTy559/7qSw2GCg/4BhCbMRKWTvoI9AgADVavoSP/qLRGUL+71UaRD2elj50kNgr732cm0EzbzHHnvMeY1PL4X8jI1E+j333JOfhbdSGwJ5jkDRMhVR/0Algw4o6IAtRUTU2X214D8CZgPCf0wrmyJSGzAICj3gqfXUU091zg0wrZArswqFjnMh1a8Q+ymcMsEA4IBRyIFUoXfAuOAZmw0s9jlgBnAgueYxBGACsBjOdsiUBtiMo+1jG/n99993cwo0ENiwrIxjjGzXl3INGDDAMbdgeGEbL8iAbT0Wu9ttt12Q2bq8rrjiCmcDEGYa41IQAXxZ4KJqjFQoUjRg0KBBgyCyrzAP2tv555/vDiQCkaxlHMNxEPYXKffOO+9cYTrJImTavrx0kTzmwOlOosBGPcxFb1OCM3ZCOdPnsOG30UYblfQ3pEUfA4M19kwczzRConzy8Z5fNMjHuhd7mdmIe+2115zEIv0OUsmFHNgow/t8F3VWY8EQMASCR6BomYrY2WHS/9lnnwWqhoMtKFSfEUm3YAgUOgKFrv6MnahBgwY5yePRo0cH4nig0L8Zq1+4EECyDZtnMAY9hiGLdO+as/d/3XXXdYt/b6HumRrp1KlTicQQz5j452ugzb/yyiuOAYNtZLQdUCOFIYOd5DAGmC4DBw50nngp52677RZ4MfmObr75Zvnoo48Cz5sMkVxjMxdJSY4gA4t71OBRw8bWIurQxx57bJBFqDAvJOsvueQSd8Bw5jvB2QGmCGAwIsGYSHW5woQDiACTliMZAxT76fRTMBjpx7zNDjYC+I9KOGe+UY/hSN9FmphZ8NL3rjnXqVMngJpZFoZAZgjgTAlTAkjMY2aANl2oYejQoW4+Xqj1y0W9TNI5F6jnb55Fy1SEZIiF43Y+SNs+77zzjtslNwct+dtorOSpIwBTEWmBQgxTpkxxkhws0HHGErTUTyFianXKLgJI1qGmi0Qh0kgwm5AkhmmY7Ixqore49iSGWFSzWIn9z3WNGjWyW4Ecpb5s2TJnIw9VUSQ/kJiCyfLoo4/m1FZeKnAgHYe6c79+/QQv9LmyP4eTENR/UUXOVcApDUy9c845xzGLgiwHbeOGG25wKsYnnHCCPPnkk26DGWnBsAVUkbELzIGqMd899tnYiPcYjHhNz5eA5gBMQo7ywvLly0sYjDAhYTayYTJ16lTXV3JNn8kZJ0ex/SLS1xxIOya7LtT+sTxM7VnuEWAzABu63bp1cw6TTjrppNwXyucS4ByRjZugHID5XPzQJmeSzqElTSgLVvRMxf79+8s111wTGHFw4oB6iQVDoBgQYHL922+/FVRVGWSHDBniTCfgdADpFwuGQLYRQMr977//lj///NNJ1CQ7wzDk8JiHnL1rmAJ4hYXZ7y18ceLAQhgmAWfvv3cOkz3AbGMcmz4SWkgiIrGFinPr1q0dQwU1MrALe2AzB1VsmCNIqlD+XAW+R+Y+n376aa6K4PJFSha7tzD3cmH6hkJABzakkNpkQxvpRRzIhFXtlvJyMOZNmjTJMRhhTtBXwGBEShc7p4UQ6OuQaOWoKLDR4DEY2ZDhYK7DBg2q2N41Z+8apiISjhz0w945/pr+mU1KTCR5Bw6G8lnCuyI87Xl2EWB8RzIXpy1I22MGopACUor0o8U6XykkWlpd8heBomYqtm/f3k0AsCUThFMFJvl06ixSLBgCxYBAoak/YygeZxFM7pHgqEjyoRhobHUsjQDSLkzakx1IuPCMhSdmMD744APHLIRhmOggLlKFSBnikIDFJQvNRGcWp3g9pN15zEPO3nWxOisoTaHk/1CTRKIDySzMGSCxhfMK1GWRxMyHAPOZzQ5sCCKhiM28XNP9pptucjiGgfk0ePBgx0AHl1z139CDcuAwEFuLeGpF6rV58+ah/sSYM3Ogvk2/RTvBkzc2UZHchcmIndRiCDAIPXuwqdYXR0UwGOnP2ejxzt41Xq+5ZsOIZ6hjewf3+G48JiNn+nXGBMwuxB8wJbkH4xNmPqYpOIjP4V2b9GSq1Mv/eFtssUUpxiJ9UCEEGPnPPfec8yBfCPWxOhgC+YpAUTMV2RnGYQsq0Hi/y3a47777pG/fvqE04J7tulv6xYlAITEVUVc7++yz5cILL3SL9bBKlhTTlwYDL9GBlBmSJBw8z/RMGjADsUkUf8TeJx7fhbdwS3RGWpD7ntQh6o8sxOMXhd5/Foee1EoQzkuK6fuhrjDhvM0+FiYwvmCOYNIg3xgk3333nVNzpl4ffvhhKJhUMDUeeughhyflynVAZRUJzmuvvVaYk+UywETk26MceFyGCXzBBRfknAlcESb0cdhJ5bjzzjsdI57N8h133NF5uqb9HHrooRUlU3TPPcZeZVXeGWs8JqN3ZrMpfjMKJgvesrmPrUj6NezAwtT0Nru86xUrVjgGI2MMDEbGp0QHZhMS3ffuxT5nfOO/dxDHu+aZjWO5+/RhhHsSi3wD9IP5HthEo8/JBw2CfMfaym8IlIfAWjqhjpQXodCfvfnmm85uDLuu2QwsaunMJ06cKFtttVU2syr6tHv06OEm53vvvXfRY5FrAJDGYuHx448/5roolc4fCYHTTjtNvvjiC+fllYVTMQbUvlmQeJJ28cy1RP9hsnHfY/DFnj1mXzzDj/uJDhiFsff5j8Qo6i7xBwsYpDpYJPEs0zOLItLxFkax59gFE9epLpisn8ptK8I7LIwPFuUwD5G04mjWrFluC1aJ3GEMoE6LBNlVV10lp59+emjUabFfyDQT9bSwBKTBkOhFDTkVVdcgys1YCbMTJhBSi0Ha+varfvTJb731lpNgxGQAfSGS/UjNssFoIXgEKhpnkM72GIze+M4YH38wjsffi/0f+5wxnTS9OQHxvGvywMYlY2js2Bn/n2cwIDmXdxAHZq0X3/vP2btOdUwOnjq5yxGJ2b322ss5GsPebb4G5oT04ePGjQvFJlq+4pis3Pvss48TuuJswRCoCIGillQEHDw3ot6E4WWMz2croObGJNEYitlCeE26Zlh2DRa5vkI9h13zfA0TJkxwi6IDDjjAeYpn4hv2wAQ+VoqBayQWmOTHSjTE/+c9nnsLC86x1ywYmaQjQQeTLpaxluyaiT6MP+JzeNIQsUw+rokHEzCeORj7PxEDMey0KK981k+Vh052nrExgEQVB98yi1tUm7GtnK8BMww4/kA9+7PPPpPKSkFlo/542cU5DN6EwxQYl7C/deWVVzoGXhjKxqbz66+/Lk888YTACIKmOEqhf8yXQB+93377uQPGEqrSSPyidomaNNJEOEg0z8nBUbSicYY+0FOpDqpUzCU8JqTHbIz/z3yEb4g5CdfewXzGc5TDPeYovOvNXfgfyyTlmnmEJyXqaQBw5l7sf67Bwjt7uMSemcPkwzywIloi1QcjDq/Q+BXAiVU+at+gQbTTTjsZQ7EiglfyOQz5fPwuKlldey1DBIqeqehNgl566SW3S5whnklfR73l4osvTvrcHhgChYgAkzNPuoyJXb4EJr0sOB955BG36GSRF0RAogfJSCRpPDtL3rV3xtZSvL0lJtq8xznW7hKLN2/i7J1jJ9EwImL/e7v93hnGi3edT4vbIGhleeQHAjC0YCJi/412jTQiUlR4xGT3PUxMuHQQZSEN02nYsGFOQvHYY49N5/VA4qJah6fRbG7YVrYiSFDC7Pr+++9z6pE6vvxI9rHQHzhwoPtGoS/S/vkWGC9QNce0EOXHKyttEBMinTt3du0Qj9KMPxaKCwHWXRww6IIIHsMyXlU8fmMVxiQSfLNmzSrZmGVOFXuQBoxa5lbYNebsHWxWeNfe2bNv7DlG435YmDSUH2dkvXr1cv0gEtIwmfMpIJ2fK6db+YRTZcta0aZEZdO19woTgaJnKkJW7CoOHz48a0xFPOaxs8YOrgVDoNgQ8Owq5oujA+yS4dESyZGpU6c6L5eVoRkqiZ7XR6Q1vSPRPc9jL4xBJtpMTr0JqnftnVH1IE7s7jnXnuMOJusWDIFiRgDnayNHjnRMDBjwSEghAbbLLrsUBCyYa+nXr5/Tfvj6668d8yZsFftRTV5gy43+NIyBPhMbhqjm4iglTAHP6zDCYcTBBIf5hrOboJgwfmPBxhQaQRwwZdjEB/NTTz3VMfapI4yNQpAA8xs7Sy9zBDxNCuZQfgQ2yvmOmbd5m7ycvY1grn/66Sf3jDkdcz/mfRy8B2PRYzJyZo7MmXbvHTDkOfhPX5WtAFN/7NixgjbOkUceKUj+5cscEoYoATVuC4aAIZB7BIypqDSA2YcHPjr7bEzaMGQ9YMCAlG1t5f6zsBIYAv4hwGSJyVQ+MBXvv/9+pwZy3XXXySmnnFIGBFRr5s2bJ/Pnz3cHTgi45szB5gFnJpHsblP3jTbaqNTBPWy4obIR+8zb2Tb7P2VgtxuGQIUI4JkdSSgO2ughhxwitGccYIRFMqTCSlQQgTkKjqJefPFF59yDhWBYA1KUqBjT34U1nHnmmU5a8ZtvvpHtttsudMXs3bu37LHHHs6DN57IH3jggbzfnGaOjTQmB8wXvKw/+OCDTqKVuTgbAGgG5JNmQ+g+HCtQVhHg26Rfq0zfhg1LmI8ek5EzzEnvzIbYwoULS+aUXKMG7jEZPUYj82muOXMgDb7ppptWahMcpisbGNgYxiP9888/nxftDzu9gwYNyiqtiz1xU38u9i8gvfobU1HxYqeGidtrr73mJjSIwH/11VduMZIenNHY2PlgZ5YAkwE7Obn2Mhgtmf0aAsEj4EkqBp9z6jkiVYMNK4zks2hnd5nJCswJ7tGOsQ/GhJCJmzeR45qd5O23395N8JjYMdHjDJPQgiFgCGQPAdon9oqR6poxY4b06dNHbrnlFunSpUvBMBI99JifsNEBw2XatGlOMtl7FoYzfSieswmoFLNIhSZhDpiEoL+//PLL3UKasqLuNX36dGnRokUoio4EOky39957z21+d+jQQe64445KMQ9CUaGYQjBGInHLAVOFtozTiOOPP95pEMFgRAoJkx4WDIFCQAD1Ym8zOdX6wFT0Nq45e0xHxj9s6rKx7W1ow7BkXtqwYUN35ppNbM6NGjUqOeLnpzBKYSbC7EcIBpVizN+EKeBYq23btq5ISMDjbI1NCQvZQ8DUn7OHbSGmXPTenz2iwvRDXYqAujLi7XRaeAhMJ/AOk1EYEueff77cc889jkFx1113pZOMxU0DAaTHsH+HugHB87ANcwcbdTCLzHNVGoD6EPXjjz92TgPYgUXNCcYiO15MhnbffXd56KGHfMgltSSYZPFt4F2Tg2sYhFxzZjGMzR0mWXh2ZjIWOyHz/sNIzIYkc2q1sFj5joD1U/5QEClg1GqRSMQJBOZLUJ/s1q1bhcyHfKQBzBbs0H344Yfy8MMPO+dy/iDpXyos7GDowgQaMmSIXHLJJU7yLx/sSNP3b7nlls7OJkxQbC2ykcTcIWyBDevLLrtMHn/8cUEDBrzDFPxqX95mAW0cBq/3beFYsVCkjrNFN79okK3yWbrZRYC1q7cZztk7vHkvc14O7AtjSgdGI0xHzP1w5mB+DpPyjTfeyKrqdTpITJ482Tl+onw4lYGhyDVrPwv+IYDZJjatWBcRUI1HaILvhMCGj8fYdTfsxxCIQaDomYoYeX3sscfk22+/dXYkMNxLQHoRT4pbb711DFwVX5IWdmLg7hOQWGQBZDYfKsausjFQoUlmK4UJ6N577+0Gx8qmb++lh4BHD1Qq2GGNX5ztu+++Tio4vVQTx0ZyEOYgqo9z5swpOXPt/cc+DJMPJk3exAnnDKiuwPBksc4ZZqcFQyBbCHjtIlH61k8lQmXNPTYGYFzBZEBagT6kMmqS+UYDJDDPOussN5G/6qqrSjQg1iATjqvTTjvNqZojUYYkDtLb49SzKMy6fAgXXXSRKz/jCZoqSOgwJ2S8CGOgDSDdB1MAFX9vwZfrsmajfTGO0+45YIagoknbLySzBn7SLRs08LN8llY4EGCtC6OR9uVtunuMR+bTCMgwd2/evLk0a9bM9TXMtbEzjkMXhGfYaA8qIMWM0y/MCiFhDlMUiUqEd4IsR1D1zVU+bNoyficKzFN32203ef/99xM9tnuGgNBpFG3QRQpb0QkPnVRGtANNGxs1ph3RiXVJmjrBjihzJaIMi4hOUtNOz15IDQHdwS7BPJamKlkWGT9+fGqJWCzfENBJf0QlE8vQBHqoIeiU89FFXkQnOBFdoEbUE3NE1dQixx13XETNFUSUMejamqrcRdS7ZOToo4+OqGRMRBdZEVUVjKiKYERtkEV0ly2ii9uIMvpL8lWVkYhOiiLqkCWik/CS+3ZhCGQTAeunUkdXFw8R3aSL9OzZM6KG6iNqIzGiG3QRlSxLPZEEMcNEA5UiibRr1y6iHqpLlVQXdxF1XBFRO38RldAo9SyMf+h/Y8dd3chx8x7dYI2ovcIwFtmVSb2AR3TRHNFN5FLlV5XjiKobh7bcFEwX1RFlNEdUC8CNebHjG891sR1R1W4uAw3ZbF8qSRq55pprIq1atYroRmFEHe1EVGIp0PrlQ2bZpEE+1N/K6A8CyrSLbLXVVhHddI8cdNBBbr7NmlY1+CLKeIqoh3fXf6ot1IhuLEVuvvnmyKhRoyIqkOP7vPruu+92Y0rsOEP+HNdee60/FbZUHALKOCw1HnqYs35T5ziGkiGQFIGiZiqCiko8uE7JazTeGUagqmomBS7Zg4EDByZsjF66s2bNSvaq3c8AAVVdj9DheTh7Z5VgLMVMyiALezUNBL744ouISumWoYfabYmoTZhSKalkSIT4MPlhyrMQVXV1N5khvkphRDp37uyYiTAVYS6+++67EdoSC6vygtpniuiuZoRNguuvv959C+ShNm3cRKm8d+2ZIeA3AtZPlY+oqu5FVCLJLWDoz9XrrduEYHPArxAWGqiaWmSHHXaIwICDsUiAMaTOOCIqRe0YRsTJh6AmIsr09YzBLPjUo2hoq+DNE+LPjBmqAhjacscWDIZ0+/bt3Uab2rJ0j2C0gT3zWJV2jY2e9eug2hfMalUFj6g2UUQlqSKDBw+OqDmErNcvHzIIigb5gIWVMTMEVL04suuuu5aaz7PZRVBpR7dp9Oqrr0bUxFdEzX5F1ByJG9fYqGGevcsuu0TUPElETWK4uTtCHipxnHahmPurpFyZccYT4lFTS2mnaS8kRoDN3PiNNsZINncR9LBgCCRDoOiZikgpqe29Mh0VE/3KLGRYBMVPUPkPU0PVLJPRwe5niACDG5PoWOwZbNS7Y4Yp2+uVRUC9G5eiB7ShralXUMcgZDdMHZq4hQ+SB+p1LqL2rCLsSCJpiGRvJlJJqqZRaiLEAku9kTqpRqQfLRgCQSNg/VRZxGnjL7zwQgTpZiTEunfvHlH1Kt8lHbycw0IDNk+YF9AvwsRCwprNExiMYZbu83D0ziwykF6JHXu5Zg6FNJmqrntRQ3eGgZ1o84vF63nnnRe68iYrEDRQxwpOahFJIaT3PXrwjcVLwiZLx4/7uWhfaB4glanq4BH1kh254oornKaCH/XJxzRyQYN8xMnKXDECw4cPj7C57/UnnBmv1AFphS+rKm3ko48+ijzxxBNukwwtI+b9bELR77Kpxryftjts2DCnVYb0fqJw4oknlioD5UAbSlWfI+qoJtErdq+SCMD7iKc5YzxzFguGQHkIFL1NRe2YnI0mvD9jBDs26ETNOZeIvVfRte7KuPRi42FX8ZVXXpE999wz9rZd+4wABvtfeumlklR14HO2H1q3bl1yzy6yhwAG7/H6iWF1jrfeekt0V7LEvig54/hI1RhFVSqcvS3OOELxO2DLEZsv2IbRDrAkebzucU8XWiX37MIQCBIB66fE2UOif8BOmqqgCn00zlboG3DqlO2QaxpQb2zi4VTBC8wT8ESMIw6cWuVLwCZXy5YtS9VFFySC3VpdUIbeSzFOT/CqHT//w7kbjgryKWBcH0P62Fz0vi3sYGFzEY/h2AoPIuSyfeHQAVuktDHGe+wv0rdsscUWQVQ9NHnkkgahAcEKkhEC+ANQRqBzZBifEPNr+pTKBmzXsl7AORZn75g5c6aza4stR9YL3lmFDZwTTi8/+jVs6eP7QDcTvNt29gkBVWkXZRyXpMZ6Wk2CCDwOC4ZAUgTK4zgW0zN12OJ2XxQotxvCDkhlAnbevDQ4sxuDaLiF7COgjNtSKtDshlnwHwHsfb3zzjtOohBJUCSLkIxAUlQXl27n8YILLnBqfIjLe+2Ba2Uk+F+gBCnqIjGhBArtkR1PC4ZArhAo1n4KaSraf//+/Z1EFRIL6sE2kkwyIZv0ySUNkBrzJBS9vpEzkvXq0C2b1c5K2owFSJh6dUEiHDu2+WSrFtMbjA1eHTgrEyoreGUzUb4t8I+tB9fcw0ZnUCGX7curI6YEJkyY4LQT0JBQj6WRW265pVK20r008+kcBhrkE15W1tII0JfQdySyjc59pBXHjBlT+iWf/jF2TJo0KaIbPhH19Bw57LDDyvTPSMLzjDlFZdSpfSpqwSaD9kisSTH6UAuGQEUImKSi9o5eYGdaJyHOYy077Ug7pRu0EbpdFt5D8gBv0EhfWMg+AngDY+dKVT8E+iH1oaq22c+4AHNASpcdQ51YOC+Y7Eh6BztWqmLkdhG9nUTPQ5yKyJdCY8iQIY4GSIHoJEBUrF6U+Vgqjt9/xo4dK6pSUUbyxMuHMiLRqg4gvFt2NgQCQ6CY+imdgMgHH3zgJIeef/55J72G5BAHHtlzFXJFA6QzkOrDiy3YxAckqNVmrMMn/llY/z/44IOitrScZBxzHmUoitq8dR46w1rmROV68803BekuT2KRcQrp+3wJykRz2DNOJ/u21MmJqImRrFcpV+0rWcWYz4xTb+RIML744otO+ok+CE/Sheo5Nmw0SEYbux9eBPAGTd+uzEPXp6iN31KFRdMICcMgggouOC0j8qJvVv8Fbq2tZpKcZhRrC9YlHIyx3jWeqy2kjwC0rlOnjhsPWbupUyy54YYb0k/I3igqBIypGENu3R1xjBJ10OImxCwA0glMXGh8TOiYXKuNJCc6nk4aFjczBFD9UfsdjqmoNvWcmm1mKRb220w8mRTAPFQ7Xu7MNerLqBTALETNgUHaOxhoUg1qT8upN7M4U2PPTh0u1XcrE4+2q4bb5c8//yz1OqoSMPwph9p6FBaQKl1TKo79MQSCQqDQ+ymVMihRQVQvkU79UB12CAuDsIRc0EClxUQl+xIyq5gz0B+jXjRx4sSwwFRhOWBSDR061JmUUIchTmUq2xtHFRaqkhFggKvkvWOQUgdUu1VCo5KpBfsaaoA777yzqEaAW2zDZIwPfGOYHVAp4fhHvv/PRftKpRLM01FrjzW9AIORzX91kJRKEnkTJ6w0yBsAraAOATbB1LOzsIHEXNozrYCAAestNmOyHVh3MK+nD2P+vvvuu5fKkrUGaxcONla8a3Xg4tYwardd1MFMyWEq06XgS/iHORv9pEq6y6effurWgAkj2k1DYDUCxlSM+xRYDGFfEUk3dj7SCWos1jFikIRSr7OiRk3Ted3i+oAAkqYsCrDn9N133/mQYmEkwQIDycOvv/665GDQhaHI4MquHgOut7sHA9GvhSETWwYmpCTOP//8rALatWtXUYdIbnHOQIhtMqR/1IGSHHTQQc6uqdlTzCoJLPEUECjEfko9r4p6HXXMRCb+2DHjYGMijCFoGqjqpagnTSdJDx70QyzQOGDywHBk7qHG68MIV9Iyqcq2k0bde++9RVWmRNW4k8bNhwcsnhhHmP/B3O3QoUM+FNuVES0N7BjDuEZin81BvjPuw0wjsDhnbpRtZmnQ7ctVLs0ftJGwG8b8RJ3DOVqzkD7ggAMcTmkmF7ro+UCD0IFmBUqKAH3ivffeKzfeeKObYyN4g61S7CIyjmUzkD5zesaYHj16pJwVfZ+37kFwwjsQIkKqHmYjZ+/ADquFKAKMI71793bS3LNmzTJYDIEKEch7puKSFavkxz/XGDuvsMYpRBh+711y0+UXy9QFf0i8Omd5r08c9670P+QAueDq66Xv6QPLi1rhs3WqVpHNN6hVYbx8iZANOiWr+7Yb1ZZ+A86S8668NlkU3+6HkU7qcU3UG6KwyP/qq6/cgMrO3aabbuoGUAZRbyBtsuXWMnfJCt/wSJTQjzNnyH7tW8tL70+SrVtumyiKL/cevedOufmKS2RtZepvv1NrOe6oIwVjw0haWjAEUkHA+qlUUFoTh40JzynCihUrSpwiZMIYK0QafDllshzZo5sDDkc0MA/pmziny3QNEp81lE5+ddqRh8gfi36XJ197OyMHM36NpX7g8/230+SA3dvJw8+PkQ6duySvfIBPKoMPqtwwRjGwr7a93YKaxflK3WScOn9R1kufT3MxpK/UDqHgnAJJKPXE7jZFYDAikeVn8OMbTbU8+USDVOtk8YJBINl3ylj/6vPPyd03Xic/z5ktdz02Urrt1ytrhZo9a6bs224neWzMG9K2Q8eM86EvrSPLXX/IGgmtNu9AmAIGI3OYHXfc0TmRQ8giTJtlyeiSMTBxCaB1uV399eWIfifJ5TfdFvfU/7+VGeP8L4WlmAkCec9UfGPWQvnnv+wyRTIBOJN3d29cTxqsUz2TJELzrtEpO6Rg9wgGIscXX3zhDnYP8abapk2bEiYiUoiJJPQKiS6L/1gk3372iezQYXepUWsdKaT2k52vx1KNR6CQ2kN83cprD6gVIbWTivQSUgkwEll8o1rk2Uj0yytgodLgg9dekqN67CltW24TT5q0/ocNnx+mfS3NWrZKqw7JIpf3jSZ7J/6+X/j88vNP0qBR7ux+xteL/5nig52su198U5auXCUt2hSeF89M8fEwRyILu8v0c6jEI4VLP4cdZqSwKwqoojP/Shb8+kaTpZ/L+37RIJd1sLyjCKTynX754XjZcbfOeQdZsu8UVW8YjEg30o5ZW82ePdtpcrGuwnwSbRuGYyp9QTaASYUu2cg3iDST0SWIvC2PzBHIbz0VrX+NKmspUzFzIMKWQrW1sytKHnR9jU6ZI44E4uTJkwUVfe+M/SRvN029qroBr2kadssKiS6169SVXfbcxwFdaO0n86/HUkgFgUJqD7H1La89oA6E5PK+++7rVABj3/OumVQ/++yzbpHNpFu9Mcp9993n1AX9VnsqVBp07XWgNGm0oQdppc9hw8cvhmJ532g6YPmFT9gYin7gg1mfNu13ld+XFt6k2Q98vO8M+8vHHHOMO9hwGTVqlLMnxxwLMwX0f6hggmd8QLUc25annXaaqHf7hBJOfn2j8Xnn+r+fNMh1XSz/1NbX+chQLO87bdSokXDEqlgjxYzmlye8MWLECMd4RAsKO8Ic7dq1czYH/Z4PJfoOrf9IhIrdCwMCec9UDAOIVgZDIBkC2DLEKDgL9nQC9o8YxNgl//jjj92BVBDSQAxgTFiHDx8uG2+8cTrJWlxDwBAwBEoQQBKnX79+zh4SHnuxC+x5Q503b55bTD/11FPOZhKODLALiFogtkotGAKGgCFQ6Ajg0O3EE090B47g8GKPzXRsReOgArux3bp1K2EestmCqiSMBzZ/UTu3eVqhfyVWv0JGAC0vbOvG2tdF6hsmI0IeOL+67rrrZMGCBY65iFNK7CQTPx3HlmDIOo8Dz9oWDIF8Q8CYivlGMStv3iCAmuDBBx/sdrSwadSlS5ekZUfdBuYhTEQcjTBQ4UAFD2fY3rriiiucZ/IgdsGSFtIeGAKGQEEggE2kM888021MYHeNgP3gxx9/XNZbbz3nuIBNDfqvK6+8stSiuSAAsEoYAoaAIZAmAniyxwEjB5suSG9fffXVcvTRR0ufPn0cg5E+lP6Vgz4Ue2wwFmMZEmlma9ENAUMgZAggpexJKXpFgxnI2o2DDdhPPvlE0ByDwchajnNFmmRs3rJevP32290czdZ8Hrp2zgcEjKmYD1SyMuYVAhi3veOOO2Tw4MHCbhZSPWPGjCnFVFy0aJHgmW/cuHHy/vvvy7fffutUZhh4zjnnHOnYsWPaO1x5BZIV1hAwBHKCALvpbFTQ53gMRQqCig8TYbz50gclU+/LSaEtU0PAEDAEQoQAju/OOussd8yZM8dtxMBsZM7nBRiLzPWQZMRj7sCBmTlw9NK1syFgCIQPAZywoZXmaabR/rF1j6DIiy++KOeff76TYmadh5AJWh+xjtr+++8/F5eaXXzxxfLkk08629UImFgwBPIBAWMq5gOVrIx5gwC2x9hpwivq0qVLS8r98ssvu50qmIjjx48XHKzAOGRgueeee5zh32rVqpXEtwtDwBAwBPxG4KOPPnLOBnDmxAQ2PmA/bMiQIdK4ceP4R/bfEDAEDAFDIAECTZo0cQyDmTNnyrBhw8rEYPPmoosuchvIqEVbMAQMgcJHADMIbdu2dQcbEIQff/zRSSKyFrz++uudgzyYixwwJWvWrOk2JtjkxVHMtttuK0OHDpWTTz658AGzGuY9AmYYKe9JaBUICwIPPPCAU3XBzgYDQmxgILn33nudAWDiISY/duxYN9FEhN4YirFo2bUhYAj4jcCw++51EjNIziRiKJIfqjYjR470O2tLzxAwBAyBgkYA+9n0ndjDThSYE6KxssMOO8jvvyxIFMXuGQKGQIEjgPrzCSec4Gyusi5koxfJRlSlkU6MXTvSl/B/0KBB0qlTJ8FJngVDIMwImKRimKljZcsLBObN/VkO7nusM9obq04YW3gM/eJcBRtlFgwBQ8AQCBKBH6Z9I5ecN0jwaorjAUw0eCH2mv4Lg+MXXHCB99jOhoAhYAgYAhUgMGXKFPnrr79cH+tFjbWH5l3PnTtX+rRrJc9/O9eLZmdDwBAoUgRgMnLg+KlVq1bOFms8FDAWsbmPqjTCKU067xcfxf4bAqFAwJiKoSCDFSJfEZj/f3Nk/27tnZODZDvU1I3J5iuvvGJMxXwltJXbEMhzBJ4a/ZLUqVlNkKiBkcg50dGuXbs8r6kV3xAwBAyBYBGg38QhC073YCBiSzvZMe6bGcEWznIzBAyBUCNAvzF9+vSkZfScP+GJvmnzlnLj828kjWsPDIFcIWBMxVwhb/kWBAJL//1Hjjr+BFn291+CA4Rff/3VqTbDRFy2bJmzj4FdDa7xCvjII48URL2tEoaAIZA/CDRruZ20b7ShNFinev4U2kpqCBgChkAeIYADrFRCzZY6T1xa1qZtKu9aHEPAECg8BJB0xiyNp0nCNetGTGOhYYK9xY022kgaNGggcxb+XngAWI0KAgFjKhYEGa0SuUKAHaPD770/4WKdnSWYjN5hzg9yRSXL1xAwBAwBQ8AQMAQMAUPAEDAEDIFwIdC1a1dnc7VWrVpSv359x0CEiVi9etmN4HGzbVMiXNSz0ngIGFPRQ8LOhoDPCCChuMkmm7jD56QtOUPAEDAEDAFDwBAwBAwBQ8AQMAQMgTxHoFevXnleAyt+sSNg3p99/gJWqnTa9C8/8zlVS85vBIxOfiMaTW/xH4tSSniFivbPm/1DwrjlPUv4gt00BAoUAeunck9Yo0HuaWAlKFwErH3lnrZGg9zToBhKYOuDcFLZ6BJOuuRjqYqeqTj6wbuk766tpE+LhjL14w/L0HCpel06tm1z9/z2886Q8hrf9C8+lXMP2luuOP7QMunYjcwQMDplhl9Qb1/Z9zD5eVb5Rsg/Hf+OnLLnLvLU0CFlilXeszKR7YYhEDIErJ/KPUGMBslpADZHt9lKDmnZSC4/ro+csU9HufGMfjJx7JjkLxXRE8OnYmJb+6oYo2zHMBpkG2FLPxsI2PogG6hmnqbRJXMMLYUoAkXPVDz45IHSpvOeDo1XHxtW5ruY8PLz8u/fi6WqGksdcMPtUrtO3TJxvBvb7LSz9Dz2RO+vnX1EwOjkI5hZSgoJ3R+//UbeePqxcnPYuXM3adG6rVRR9fD4UN6z+Lj23xAIGwLWT+WeIkaD5DQAmxZt2skG9TaSqx97Xu5+40Op36ix3Hr2KfLxm68lf7FInhg+FRPa2lfFGGU7htEg2whb+n4jYOsDvxH1Jz2jiz84WipRBIqeqQgM621QR+pt0lCmvPemLPhpTqlv463nnnST8Oo1aznGYqmHCf5UrVbWqGqCaHarEggYnSoBWoCvvPnM49K0xXby3uhnZNmSfxPmvGrVKuGoUqWqrLXWWqXilPesVET7YwiEGAHrp3JPHKNBchqsW3t9WWvt6NSPPrjXcf1d5E/Hv538pSJ6YvhUTGxrXxVjlO0YRoNsI2zp+4mArQ/8RNO/tIwu/mFpKYkYU3H1V4CEYSQSkdefeKTku/j2s0+kwWaNleG4ack91DNP2qONPHnbDbLkn3/k9vMHOPXp7z6fUhLHLrKHgNEpe9hmkvI/i/9yas+nXDnESfZOGDO6VHK0rcdvuU5uPvMkueHU42TqpDWmBsp7VioR+2MI5AkC1k/lnlBGg9Ro4Jl0gZlG+Pz999SEyyFy7UlHywWH7CtfT5ro7j9x6/XOFMxDV18ss775Sk7fa1fpv0dr+eKDcbJs6RJn9uXBKy9ycQvpx/BJTE1rX4lxCfKu0SBItC2vyiJg64PKIpfd94wu2cW3GFM3puJqqrds216atWwl74wa6ZiF3B47coTsd3S/Ut8F6pkbNWzkGCe11l1XjjrrQrWz+LvgXMJC9hEwOmUf48rkgJmATj0PFEwANN66uYx9akSpZF57/GH59tPJcsFdw+Sie4e7Z56kYnnPSiVifwyBPEHA+qncE8pokJwGq1aulD9/+1W+mfyR3Hf5+bL+hvVk/xNOlTnffyc3Dewvp117q1z60JOyc5e9HHNx/v/Nlj6nnKlS5itl082byhbb7SD7HHGc/LdsmbRqv5vUUE0OVKr373dq8kzz6InhUzGxrH1VjFG2YxgNso2wpe8HArY+8ANF/9MwuviPabGnaEzF1V8ADI6eqgaE/cTxLz0nf/7+m8z9YYZs165DmW+kWvU1Ks4l13GqnGVeshu+IGB08gVG3xN574VnpVPvg126ex1ylLOtGCu9+8qIh2SnTl2cyjO2FLfdZdeSMpT3rCSSXRgCeYSA9VO5J5bRIDkN/vnrT7n30nPlozdflcPOGORsK2648Sby1rNPSMOmW8gmjTd3L3c58FD5b/kyGaf9e6311pMOPXrLR2Nfdc822rSh/P3nH05SkXnTEj02adI0eaZ59MTwqZhY1r4qxijbMYwG2UbY0vcDAVsf+IGi/2kYXfzHtNhTLOspoYgR2b3nAfLYzdfIqypVhVjwXoccXcRohLfqRqdw0Qbm4W/z58p1pxzrCrZq5QpZu0oVlVYcLs3VIQuqcb/8/H9Sb+M1ZgSqrF1FlMNY7rNw1dJKYwikh4D1U+nhlY3YRoPEqNauu6EMvq+0NDkx6adjw8abNXFSjN79bn2OkEuPPkjmz/lR3lXbuVttv5Mg7fD7Lwtkt/0OiH01r68Nn9TIZ+0rNZyyGctokE10Le1MEbD1QaYIZud9o0t2cC32VE1SUb8AbLpF1HlEteo1ZJ/Dj1UJxZmC9NQe+/dJ+n0Q30KwCBidgsU71dzeUDMBZ950lwx55hV33DRqrLTtuo9MHPuKk/ilXdWp30C+jbM7yi57ec9Szd/iGQJhQsD6qdxTw2hQORrUa7CJzJk+TZb+u8bRFpLlOLIjtNy5vao/N5OHr7vM2Zo++OQB8sm7b8q7z4+UDt17Vi7TPHrL8IkSy9pX7j9ao0HuaWAlqBgBWx9UjFEuYhhdcoF64edpTEWl8d9/LHLMD8jd48jjhUl0p14HS8111nFfwOJFv8tylbb6b/ly9x+Jqxlff+lUf5hQE/78baE7Ewd7PAz4FvxFwOjkL55+pLZIJVS++eRj2X7X3Uslt+fBh6ud0eUy9slHZW31NNq+Ww9dfL4hv8772dkfnfvjLPl9wXwXJ9mz5cuWlkrT/hgC+YCA9VO5p5LRIDkN/tL5zL+qibFS5ynxYfdeB6rdxFXy5Yfj3CMk0P9Y+ItKIe5fErWr9u2fqcO63sefrDYX93bzpCbbtJQataLzpZKIeXph+FRMOGtfFWOU7RhGg2wjbOlnioCtDzJFMDvvG12yg6ulKlLlSg35DMSPf/4rS1ZUXmpwxI1XybiXnpcZU7+QRltsJU1bbOskFQ/sf7rUrlNXRt5xo0pcjXEGyefN/sEZJd9QmYqodiLN2KR5S/WEOFXWUsYJxs5H3TtUmSXznFrnDh33cDbkKoNvFZXi2mz9WrJuNVUTLYBgdAonETOhyyJdbF6jHkIX/vyT2tLaXDbXtkBYtuRfGTPiQflh2tcy85svnWTLrt17yeS3X5dn77lNPnz1JVm5IqoiXb/hZtJ2z32SPkMqpjKh0NpPZTCwd9JHIJP2QG42nqSPefwbRoN4REr/zwSfUffdIe+/+qLbJF2gzleaq2OtWuuuV5IB/fG6tWvLyNtv0n58iTx+y7VypDqjw0GdFzZu3ER+mvm99D7hFGfmYtHCBdJZtTqwsZhJ8KvPNnzKp0Im+JCy9XHl45vKU6NBKihZnFwjkMl3auuD7FHP6JI9bC3lzBBYSyXq8lqkbtzsX+X3pcF7XvakqKrXqClcc/YzVFt7LWnfaENpsM4apzB+ph90WkanoBFPLb+g6YLHUZjvqNfhPT02lPcsNl4q14XWflKps8XJHIGg24NXYhtPPCREjAZrsEh0FQQ+bAwt+On/BAYinp3jA/23p8kRex0fL53/fvXZhk/5qAeBT6ISWB+3BhWjwRos7Cq8CAT9nZa3BijvWboI+jXWpJuvX/GNLn4haen4jYA5aqkkorFMxNjrSiZnr2UJgVjaxF5nKTtLtgIENqi3kYsRz1DkZnnPKkjWHhsCeY1AbN8Ue53XlcqzwsfiHnudZ9XwpbioMjfZunnStDyGIhFir5O+UGAPDJ/0CRrbpmKv00/J3qgsArG4x15XNj17zxDwE4Hy1gDlPfOzDJZWWQTKw768Z2VTsjuFjoDZVCx0Clv9DAFDwBAwBAwBQ8AQMAQMAUPAEDAEDAFDwBAwBAwBnxEwpqLPgFpyhoAhYAgYAoaAIZA6AsvVwdnLL78sRxxxhIx9bmTqL1pMQ8AQMAQMAUPAEDAEDAFDwBDIKQKm/pxT+C1zQ8AQMAQMAUOg+BDAnPP7778vTz75pIwaNUpatWolRx11lDTr2kv+zmtLz8VHS6uxIWAIGAKGgCFgCBgChkDxImBMxeKlvdXcEDAEDAFDwBAIFIFZs2bJiBEj5LHHHpP11ltP+vbtK19++aVsttlmrhwYIZccOF8LFATLzBAwBAwBQ8AQMAQMAUPAECgQBIypWCCEtGoYAoaAIWAIGAJhRGDJkiXy3HPPybBhw2TatGly9NFHy+jRo6V169ZhLK6VyRAwBAwBQ8AQMAQMAUPAEDAEUkTAmIopAmXRDAFDwBAwBAwBQyB1BL766it58MEH5amnnpIOHTrIeeedJ/vtt59UrWpTj9RRtJiGgCFgCBgChoAhYAgYAoZAeBEwRy3hpY2VzBAwBAwBQ8AQyCsEcLryxBNPSMeOHaVnz55Sv359gbn46quvyv77728MxbyiphXWEMgPBObPmS3HHHKQTJ8+PT8KbKU0BAwBQ8AQMAQKCAFjKhYQMa0qhoAhYAgYAoZALhD46aef5NJLL5XGjRvL448/LhdffLHMnj1brrjiihJ7ibkol+VpCBgChY/AJk02l46d9nAS0WeddZb8/vvvhV9pq6EhYAgYAoaAIRASBIypGBJCWDEMAUPAEDAEDIF8Q2Dy5Mly+OGHy0477SSLFy92Hp3feOMN6dWrl6y9tk0x8o2eVl5DIF8ROP2sQU5ScdWqVdKyZUtneoFrC4aAIWAIGAKGgCGQXQRsxp9dfC11Q8AQMAQMAUOgoBCIRCLy0ksvSadOnRxDEVXnOXPmyB133CHbbLNNQdXVKmMIGAL5g0C9evXkrrvukrfeestJTLdt21YmTZqUPxWwkhoChoAhYAgYAnmIQN5bS1+6sjB3If9bFcnDzyl5kY1OybHJ5ROjSy7Rt7zDhkB8e/hn8V9So2YtqVqtWtiKmlZ5/BpPsJc4YsQIueWWW6ROnTrO8crBBx8sVapUSas85UWOp0F5cfPpmV80MHzKp3qh4LNw7k+y4cablrQt+37Kp3s8PjvssIOTmh45cqT06dPH2XcdMmSI1K1bt/yEAnhaKN9oPFTxNIh/bv/zCwH7TsNJL6NLOOlipRJZSyUO8pp7tWTFKpn957+B0PKuIdfJXj17S8vtd8h6frWqVZHN16+V9XyCyiAoOs2a/p2MHvmEnHfFNYFULd/pFBRdIIa1n0A+ScskAwRi28O0qV/JmX2PltcnfZ73zkUy7aeWLFkiDz30kNx0002y/fbby2WXXeYcsWQAddJXY2mQNFIePsiUBl6V/cRnyb//ymVnnyFX3HK71F5/Ay+LnJzDiE9OgFid6fffTpOrzx8ktz40XBpssokYPuVTozx8MMuAjdfnnntObr31Vjn66KPLTyzLT/1sw1kuqkx4+01557VX5JzLr5IN6pTPkC2PBtkup6XvPwJBfqe2PkidfkHSJcg1tfUfqX8DYY2Z95KKtaquLS3qrRcIvt9/+akcsHfXwPILpFIBZRIUneYt/UtmTv3CaJQiXYOiC8Wx9pMiUSxazhDw2gMMtMGDB8t9990nrTauk7Py5Drjf/75R+6++2657bbbZLfddpOXX35Z2rRpk9VieTTIaiZ5nLif+Nz55CNSu3pV2aVZozxGpHTR/cSndMrB/mux2y7y5X495LBuuztv6nvttZcvBSgUfNIBo3bt2k4lum/fvtK/f3+H5wMPPCBNmjRJJxnf4uYTDVocfrD8/sN0OfGAfWX8+PGCermF4kAgyO/U1gepf1NB0uXfGmvJZx+MtzV16uQp6phmU7GoyV94lV+2bJnUqFGj8CpmNTIEDIGsI/CvSm4de+yxcuedd8pHH30khx56aNbzDGMG9KNDhw6VLbbYQqZOnSrvvfeejB49OusMxTBiUchluueee+SMM84o5Crmdd3wpv7MM8/IcccdJ5dffrnkuWJRzmmx8847y5QpU5wtWDZH+P4N04rJctFFF0nv3r2lR48ezhlXxW9YDEPAECgEBFhPMx+0YAikgoAxFVNBaXUcPFmutdZaabxhUYNGAJtftWoVjtp40PhlMz9rP9lE19LOFIFp06bJLrvsItXUfiIejbfeeutMk8y79//77z+5//77HTNxwoQJ8s477zipnm233Tbv6mIFLh8BGMU1a9aU3XffvfyI9jSnCHTu3Fm++OILmThxonTr1k3mz5+f0/Lke+bYf0UV+sMPP5SnnnpKkADFyZSF8hG44YYbpF27ds6e7tKlS8uPbE8NgTQRsPVBmoAFFJ05AvNCC4ZAKggYUzEVlFbHWbVqle1qpoFXLqJi+6t69eq5yNryrAABaz8VAGSPc4YAi8s99thDzj//fHnkkUeKcmMCe2MtWrSQF1980Xl2fuGFF6RVq1Y5o4llnF0EkNI69dRTs5uJpe4LAg0aNJA333xTunbtKq1bt5Z3333Xl3SLOZHmzZvLBx98IPvss48gwfjoo48WMxwp1R1TGDNnznSOb4zRkBJkFilFBGx9kCJQAUdDUhENHguGQCoIGFMxFZQsTt4gYOrPeUMqK6ghkHME6C9OO+00ueKKK9xCHZtbxRY+/vhj6dChg1x//fXOs/PYsWOlbdu2xQZDUdV37ty5TgoVVX8L+YEAkjw4SGIDBEcjV111lbAQt1B5BNA8uvDCC515B0xe4CV60aJFlU+wwN8ErxEjRjhpfr5B+/4KnOBWvaJHwNSfi/4TSAsAYyqmAZeJZ6cBVo6iwiRYZ511cpS7ZVseAtZ+ykPHngWNwA8//OCYab/99pt8/vnnzqtx0GXIZX6zZs2Sww47TA455BDHWP3ss89MFTaXBAkwbxwRHXPMMbLeesE4uQuwagWfFdKKqEOPGzdO9t57b1m4cGHB1znbFUQi+5NPPpHNN9/cjQNgayExAqiPP/vss/L777/LySefbNpbiWGyu2kiYOuDNAELKLqpPwcEdIFkY0zFNAhp4tlpgJWjqNh6wSaahfAhYO0nfDQp1hKh4ot0Xr9+/dwCqZiYK/SRSGZiH2vHHXeU77//3jmCMHvBxdEaVqxY4exmIqFrIT8R2HjjjZ2kKfYwUYfGK6+FzBCoWrWq83KP+Quk8K688kqTxEsCKSaGxowZI9ghvvnmm5PEstuGQOoI2PogdRe0IqAAAEAASURBVKyCjGnqz0Ginf95GVMx/2loNYhBwNSfY8CwS0PAECiFAAyV8847T84++2x59dVXZcCAAaWeF/of6tyyZUu3GMSr8yWXXFKU9iMLnc7l1Q+G+jbbbCPmfKc8lML/DMkeVKBRRz388MPl2muvNSaYD2TDxiKSoDBqkQT95ZdffEi18JLAIeJrr73m1PFhwFowBAyBwkOADQTsp0YikcKrnNXIdwSMqeg7pJZgLhFACgdxbQuGgCFgCMQi8PPPPztnLN9++61Td8Y4f7GE2bNny/777y+DBg0SVF9RX9t0002LpfpWzxgEcNByxhlnxNyxy3xGAI/QmG946623pEePHqYO7QMx69ev7yRBd9ttN2nTpo3zFO1DsgWXxAYbbOC+u5EjR8rQoUMLrn5WIUPAEBAxu4r2FaSKgDEVU0XK4uUFAiapmBdkskIaAoEiwIKbxeEBBxzg1Lbq1q0baP65yozdZTx27rLLLk7d++uvv5a99torV8WxfHOMAOqKMNUPOuigHJfEsvcTATYI8AjtmTSYMGGCn8kXZVpIgl599dXOKzTt5f777y9KHCqqNAzY9957T3B08/DDD1cU3Z4bAoZAniFgTMU8I1gOi1s1h3lb1oaA7wjAVKxdu7bv6VqChoAhkH8IYKcHFUHsZI0aNUo6deqUf5WoZImnT5/ubEbCWJw4caJstdVWlUzJXisUBO6991456aSTzO5woRA0ph440EAFunPnzs4BEyYe8GxstlJjQKrEJSrQH330kZP0xrnXNddcI6gEWliDQMOGDeXtt992mgDYJ0Yd34IhYAgUBgJo/6EFiGSyBUOgPARMUrE8dOKemXeqOEBC+Ne8P4eQKKuLZO0nvLQpxJJhC4sF4fvvvy94Ni4WhuLKlSvlpptuko4dO7rF3QcffGAMxUL8wNOs0z///CNPPPGEnHLKKWm+adHzCQH6PPo77N3tu+++8uuvv+ZT8UNZ1i233FImT54sM2bMENTN8XxsoTQCYPTGG2/IWWed5ewVl35q/wyB8hGw9UH5+OTyKfZTly9fnssiWN55goAxFdMglHmnSgOsHEU17885Aj6FbK39pACSRfEFARiJeEXFJhYSFKhoFUPAdmKXLl2cnaspU6bIwIEDTVKpGAifQh2feuop2XPPPaVRo0YpxLYo+YwAkmPjxo1zfeBOO+1kNgF9IOa6664rzz//vBtTUDOHwWihNAKtWrVy5kVOOOEE9/2Vfmr/DIHkCNj6IDk2uX6CZPaSJUtyXQzLPw8QMKZiHhDJipg6AmZTMXWsLKYhUIgIIKV36KGHOltY2MRiB7wYwjPPPONsJ2I3EhuSTZs2LYZqWx1TROCuu+6S008/PcXYFi3fEaDfu+GGG2TYsGFy8MEHy4033pjvVQpF+YcMGSKDBw+W3XffXZACt1AaAez3YmoEFWg2tiwYAoZAfiNgNhXzm35Blt5sKgaJtuWVdQTM+3PWIbYMDIFQIrBo0SLp27evoPbMYmazzTYLZTn9LtTixYtlwIAB8vHHHzv1MyQ0LRgCsQh8+OGHziYSqpsWigsBPEJ/+umnJaYQhg8fLvXq1SsuEHyu7YknnijNmjVzDo8effRR6dWrl8855Hdye+yxh/Cd7bfffs6BEBKMFgwBQyA/ETCmYn7SLRelLg4Rjlwga3nmBAGTVMwJ7JapIZBTBD755BOn6rf11ls7G4rFwlCcOnWqoN6IIe3PP//cYZBTQljmoUQABy0mpRhK0gRSKPrD8ePHC8wd+gscj1jIDAFMCbz++uvSv39/efzxxzNLrADfxp7n3XffLd27dzdV8QKkr1WpeBAwpmLx0DrTmpqkYqYI2vuhQsCYiqEihxXGEMg6Avfcc4/z8Pzggw/KgQcemPX8wpLByJEjnc3E++67z6l7h6VcVo5wIbBw4UJ55ZVXBMaiheJFoGrVqk4dGodVmEi44IIL5NxzzzWbqxl8Em3btnXM2n322Uf++OMP1x9nkFzBvXrYYYfJ33//7ZzbIC1dLJt9BUdIq1BRI+B5fy5qEKzyKSFgTMWUYLJI+YKAMRXzhVJWTkMgMwRYrKCGNn36dKf6u8UWW2SWYJ68/d9//8n555/vDOLjjMFUy/KEcDkqJjb1sDG6wQYb5KgElm2YEEAlFXVovgmkFx977DGpW7dumIqYV2Vp3ry5TJw4UWDWrlixQgYNGpRX5c92Yfv16yd//fWXcxIFY7FYnKZlG1dL3xAICgGTVAwK6fzPx9Sf06ChubxPA6wcRcXtfa1atXKUu2VbHgLWfspDx56lg8DXX3/tVH1ZDGNLsFgYitiL7Nq1q1Mn++yzz4yhmM5HU4RxI5GIPPDAA87mZhFW36qcBIHGjRs7JyMwxHbccUfXhyaJardTQACP6hMmTHDOcJ599tkU3iiuKGeffbYcddRR4kl0FlftrbapIGDrg1RQyk0cJBXZzLZgCFSEgDEVK0Io5rm5vI8BI6SXuL2vXr16SEtX3MWy9lPc9Per9hiA79Kli1N5vv/++4Vd1GII06ZNc96dcbwwZswYkzwrBqJnWEfUnjfZZBNnRy/DpOz1AkMAdehbbrlFMB+x//77y9ChQwushsFWB9XeSZMmOYc4t99+e7CZ50FuV155pRu3e/bsKf/8808elNiKGCQCtj4IEu308mKO/e+//6b3ksUuSgSMqViUZC/cSpv6c+HS1mpW3AiwYYC680033eScsSD5UCwBNUUYqdddd51ceumlZgetWAifYT3NQUuGABbB671795YpU6YINlqxtbho0aIiqHV2qrj55pvLrFmzHIOWzS8LpRGAcd2iRQtn+5i5ugVDwBAIPwKm/hx+GoWlhMZUDAslrBy+ILB06VLnCdWXxCwRQ8AQCAUCM2bMkPbt2wsLETw9t2zZMhTlCqIQLPYPOeQQefrpp+WYY44JIkvLowAQgLlBWzn88MMLoDZWhWwi0KRJE8HeHWYkWrdu7b6bbOZXyGk3a9ZM3n77bRk8eLCMHj26kKtaqbph47VevXrOSdDKlSsrlcb/s3cdYE5UXfvAsvTee5Nqo4qKgkhTFERQAUGKgCCKYFfAhl2sgP5+IIiIigUrIkVAFBEREQFRVKQovfe2wP7nnZDdbDY9k8lk8p7nSTKZuXPLe+6dO/fcU3gTESAC1iFAoaJ1WCd6SRQqJjoHWf8sCFBTMQsc/EMEEh6Bjz76SJo2bWr4hXvnnXekQIECCd+mUBvw7LPPyvDhww1/XfClSCICoSKAqOAIkpAs7gFCxYXpfCOQmppqaNiNHj1aEMxl7NixvhPybFAEatasaQgWBw0aZDy7g96QRAly5MghU6ZMMTQ6+/TpI/D7SiICRMC+CFCoaF/e2K1mFCrajSOsT1QIUKgYFXy8mQjYBgEEXRoyZIg8+OCD8vXXX8uAAQNsUzcrKvLoo4/K5MmTDT9dyaSZaQW2Tixj8+bNGc2Cxv6kSZMEQg0SEQgHAZhAQ8MVgp/OnTvL/v37w7mdac8gcM4558i7775rRNmGpj0pEwEIsKHF+e+//8rtt9+eeYFHRIAI2A4BBGrBOwWJCARDIIfuEnGbyA9KcEwK58KbNm0yUvzwww9So0YNKV26tLG7dvPNNxvRzPzcztMWIADe4MUX5hR48M2fP9/w11K0aFHJnz+/PP7444IXGJL1CHD8WI+5U0rcuHGjdOnSRcqXLy9vqW+qIkWKOKVpIbUDgtSvvvpK5s2bJ6VKlQrpHiZKXgTgbxTzHaL5PvDAA3Ly5En59NNPjT6UvKiw5dEggGif99xzjxEUatq0adKoUaNoskvaeydOnCjPPPOM/PTTT1K8ePGkxcFXww8dOiStWrUSRM+mqbgvhJx7jusDe/MWfrwREBB8wiYTXBUgGBWEi9jkhkY7iQh4I0ChojciHv/37dsnxYoV8ziTeQgV/jZt2sjs2bMzT/LIcgQWLFgg/swCobINx9DU1rCcLUaBHD/xwT3RS4UwDWZREKzdfffdid6csOsPU2+8uEGg6G/+CTtT3uBoBP777z8jAAIWAAULFhRo+cKXIrRdzzrrLEe3nY2LLQIQ9gwcONDoS4MHD45tYQ7NHcG1Fi9eLHPmzJGUlBSHtjKyZu3Zs0eaN28uPXr0MPxQunNBhOgNGzYIND5JzkOA6wN78xQyDn+UL18+RoP2B06Sn6f5c4AOAG03fwIrvLiPGDEiwN28ZAUCzZo1C+hjrWfPnlZUg2X4QIDjxwcoPOUXAeyEwrn9rbfeKl988UVSChQ9F58UKPrtKrzghcCBAwcyhBXQ/oFQEYF9zj33XLniiiu8UvMvEQgdAViCLFmyxDCnh/Y4+hopPARgMQNhItcM2XGD9iYC2yCAC6LVg2By37hxY7nssssMrevsd/FMoiPA9YG9OQjtalj/eVPu3LmNDX/v8/xPBIAAhYpB+gH8eBUqVChbqly5cgkEWqT4IoAXtQ4dOmSrBHZZrrnmGkNrI9tFnrAMAY4fy6BOiIJglokdapjWedLWrVulZcuW8ssvv8ivv/4qF110keflpDgeOXKkzJgxQ/bu3SslS5ZMijazkeYgAEFPzpxZX+cwxqDxCu2o5cuXm1MQc0lKBBAVGu5/ypYtK/Xr12d/CrMXYGxOnTrV+Hz22Wdh3u385OhXcF0EQcZrr70mF1xwgRHIBT7SEZyN5EwEuD6wL1/h3u306dPZKgjZxw033JDtPE8QASCQ9S2UmGRDAIIp7Pp7EgYVNOACqQd7pudxbBG46aabpHDhwlkKQYRYmupkgSQufzh+4gK7bQuF43r4P73xxhsz6vjNN98Y/rpat24ts2bNSkq/U9DQwOIJ7jSwg08iAuEg4C+YBjQNEOSoQYMG4WTHtEQgGwJwJzNmzBgZNWqU4Usc0cXdBAE23rnw7KKbdjcqWX8x78FHGQQp69aty3qR/6RKlSqGD9jhw4fL+vXrjXUXtK4fU7/2JGciwPWBfflapkwZueSSS7JVEM94Bg7MBgtPnEGAQsUgXQHOz6+88sosqfBy1Ud9fpHsgQCEEd6CX/ANflpI8UWA4ye++Nup9G3bthmCfux+zpw5U8aPHy/PPvusdO/e3RCoPfzww0m5UfPBBx/I008/bQh/EASMRATCRQCait5aBfB79MYbbwjmRxIRMAuB66+/3vAPOG7cOMNvJ3zfQVAGYSKEi88995xZRTkun/PPP98wHYRSgvd4dVxjw2wQ/MIiaAv6Eywa3LRr1y7DPNr9n7/OQYDrA3vzcsiQIVksNaFQhfd1EhHwhwCFiv6Q8Th/yy23ZBlYiETKnX8PgOJ8CCEvTCfdBO2M22+/3f2Xv3FGgOMnzgywSfFYSMGcCYSAEnfeeacgqihMnj3Hr02qa0k1EIwFOOC3atWqlpTJQpyHADQV4ZPUTVisQUgPLX4SETAbgRo1ahh+FuEPD1GhsTGCCOR4rsN/4Jo1a8wu0jH53XXXXYJ3VmyokTIRqFy5suzevTvLcwxXIWSktmImTk474vrAvhxt3759Fs1zrK0RAI5EBPwhQKGiP2Q8zrdt2zZjVxFOSvv16+dxlYd2QKBXr14Zgl/smJNHduCKqw4cP/bhRbxq8t577xnaLZ6+FLEI3bRpU8BAS/GqrxXlbty40Yh4CWxq165tRZEsw6EIQFPRPbYgUMR8iKBHJCIQKwQgGLv77rtlg0boxbPcTfDjCW1GauK5Ecn6C7dJeOaPHj2avik9oIGA2ldgCCRZtmyZ/PHHHx6peegUBLg+sC8noZkIq0z8glJTU40ASvatMWsWbwQoVAyBAxhI1113neEIHQ6X8cJOshcCV199teGUHrVC1LgKFSrYq4JJXBuOnyRmvjZ9586dRkRnaBx4E4K2JOPOJzR6OnbsKPAfdfnll3vDwv9EICwEoKkIoSJMntGf3FFUw8qEiYlAGAhAeNiuXbsMYbb7VmzqQtBIM2g3Itl/EZgE+MBsnMJXFz7QUoRbFJiIwz+nJ8Ec+qmnnvI8xWOHIMD1gb0ZOWjQIEOYCNkHNotIRCAQAhQqBkLH4xo036ClCBV9mH6Q7IVAwYIF5cILLzR2OocOHWqvyrE2huYox09ydgTsdLrNnr0RwAIUwVkQWTSZCJH14EIDPmtIRCBaBCC4x+Ls3HPPlY8//jgpfZNGiyHvDw8BbK7/888/PoVi2ECiGXRgPDEvQquYGwCZOMEP+ooVKwy3KLVq1coQLkKoCFcp8K9Ich4CXF/bl6dnn3224ZoH6zfPAIv2rTFrFk8EXDqt8ayBXcpO2ydybLvIib360WP8pu0XOa2Rn/XTvGSaoQnX8ZJSIr+rI+qU3CI5UkVy6Y5a7iL6Kaa6wRq1M09xkXzlXdfs0jYn1CMIf+R0mnS8ML98//0xubbW3yJ/vkz+WMn3IPzh+LGSGT7KCsIfjB/jk0P3mfBcM+n5BgHHggULsgRScps4lS9f3tD6xuK0WrVqPirtzFPQUEF0y4ULF9qngZjnjvwncny3fnThdkJ/0w6KnDqWMQcK+kbOPPrRuS8lr851JVyf3Pqbr6weM8hMxAyNcnxOfutNQ2Ns3vRJkic394oj5gPHQcjQvfnmm4KIxh9++KHxfIfmomeADWwkQbMFQqKUlJTQ8o1yHCTaeziClSHCaufOnQXzIcmFAIJj/vnnn/Lpp58KfFBCmIi+9corr8iTTz6ZHaYk6zfZAbD5mSD84fogzvwLwp+br6oi97/4h1xWUt9Zf//JtPVBnFttv+Id8P6RQzVF0u2HbCxqpM08tE7kgDqQPvCnyJ5fXL9HN7sWUigSCyX1d2JQ+mmRdI1AZvzqseA/HKHr9Rz6goQFlmABjmN89LwBpaY7eUSFjQVF8uoiq0BlkWINRIqcI1K4jv6ercJHFUKSvBAgf7wAsdlf8sdmDPGqjv34A3OmaiosPHjwoGGWCTMv/IeGRpcuXZJKkOhm1s8//2yYDGKhHZdFJF4e964Q2aefXUv0d6UKE3UOxAYaNsgwp4Ew12XMf5j3MAeCdB/SEC6emfeM9Nr3IJRO109eFS4WUAFxqQt13msoUvR8nfPq6n3JLuiy3/g02JmsXxwHpnIePu8gXISvQDz38ayHUBGaeCNGjDDcPLgK5DjwBv6hhx4SRD6ePHmy9yX+VwTQl95/f6oMHny77N27X06sHCWpB3X+wjqO6zeb9BGOa5swwk81yB8/wMTntIPfP5wrVDy+Q2T7AnXotUhkx3c6Af2uiyHVsMipi6GT6lQaEmHLSAWOWLBB+HhKy86tGo3FG4uUbSFS8hKREk30WpIpjZI/lvW+iAoifyKCzbKbEoA/nZ7cKJ/NW60+ks6Tvn37GVoryezrFH4U69WrJ88884x1vmmgcb91tsi2OfqZp4uwbbp5lk8FgMd1HlQtxFgRNtmwsQbCXAsBY/mrRMq1cc132JxzMiXA+Eyq9w+OA8tGGzTMPvroI5kyZYqsW/ePapidkt8/uknqFviN7+E+uHDo0CGpWbOmzJgxQxo21OckSRU9sq/fTp5OlWUbRC6sBqsKrt/i2k188Ifr67hyJGvh5E9WPOL9L4neP5wjVDyti6Rtc0U2fSayZZZrUsqpmocw4RKV0tuR3GZkp3VxV7yRSMWO+ukkUqiWHWsbXZ3In+jwi/Xd5E+sEY4u/wTkz9b9qZIzVx4pU1gXAE5/voXA3VtvvdWIkhpzjZRjW0U2TNHPVNVE1M20FDVZPqnzYLynwZRU3dRTgSa0Hsu3F6nWU4WMV7g220LAz9ZJEnB8ZpixO/X9g+PA+iHjNQ42bdkuc1alSM+Lj0mqXffNbfAe/sYbb8i7775ruAqxnmk2KNGr3xhCRa7fbMCYM1Ugf+zDC181IX98oRLfc0n6/pHYQkUMJAgR16nZwLb5rsWTnYWIwbo4Fn8wLYOPqqo3ilTvoybTZwe7y77XyR/78gY1I3/IHysRcNrzLQzs5syZY0TA/u233wyTwDBuDS0pTJX/nSby1xh17bFM7zmjFR/a3dangqJirsL6pZLO6r1EamnAmkTbTOPz0/p+E6xEjoNgCJl/neMgakzhhQpa7Ihw3KFDh6jzS4gM2G/szSbyh/yxEgEnrA/4/iGJKVTc96sG4nhVZKNqYsBsOO2AlV3fmrJywneVanYUrCJSWxdcVVWrw21OZk0NIi+F/IkcOyvuJH+sQDnyMsifyLGz4Z3wLYaovKNHj5arrlITYDPp5CGRv19X59nP6iaBmoUZm2pmFmBBXsZcp/NdqaYi5z2qv80tKDSKIjg+owAvRrdyHMQI2ADZchwEACf8SzNnzpR7771XVq1aJTlzOtgHLftN+J3DyjvIHyvRDr8s8id8zGJ9B98/MhBOLKHidtVGXDFCHc2vdGlZGYFTMtri3INU9ceIIDC1BovUuVud4ZexZ1vJH/LHjj2T48eOXMmsU6LwJ7PGYR099thjAg3FadNUk9AsQlCUv8frfDhc5wbVUkRwMCcQNs5KNBRpNNYV5MVObeL8Zr/5jePA+hHCcRCzcdC0aVMNSDJYunfvbj1fY10i+03M+o0prCN/yB9TOpLJmdh5fcD3j2zMTgyh4p6lIj/2Fzn8j2piHM7WiKQ5AfVgRNGsfbvIuarRYRfNRfLH1QXJH3sPRfKH/LEYgbVr1woWioj2XK5cOXNKx/N24fXqN3i3ChMdOB/CBQjGarXeIg1f1OP85uAWaS6c31zI2e35yXEQaY+O7D6Og5iPg/nz58vAgQNlzZo1kpKiLiycQOw3Me83UXUT8of8iaoDWXQz3z8sAvpMMRG+h9tbqHhCF00/9tXolV+7oiZbC6l9S8ulzu5hGt3k/0Sq9IhfPckf39iTP75xsctZ8scunPBdD7vwx3ftwjrbuXNnufjii+W+++4L6z6fiaGZv/we1VAcp/NhDCM3+yw8DifRD+B3scV0DfRzgfUVwPy2+GZXALhTR60v364lxnt8chxY2zM4DnzjHaNx0KpVK+nVq5f07q2bKolM7De+uRejfuO7sABnyR/f4JA/vnGxy9l484fvHwF7gn2Fips/F/lBJ9XT+jJ/6kTARiTtxVxqFl36MpGLJ4nkKW0tDORPcLzJn+AYxTMF+RNP9IOXHU/+BK9d0BSLFy+Wrl27yl9//SV58+YNmj5wgtMiM+uLHFRtfaeYOgducObVFMXuQhWkVtWALlYR57fgSMdlfHIccBwE75qWpjB5HCxcuFBuvvlmY95IWN+KfH4G74Im95vgBXqkIH88wPBzSP74AcYmp+PCH75/BHv/sKdQcdUjIn+o2VOyLZ4iGaspuVWbo4hIm+80UnSdSHII/x7yJ3TMyJ/QsYpHSvInHqiHXmY8+BN67QKmvOSSSwxTNmidREUn9oh8db7Ise26yab+E5OVmk5RweJNsW8957fQMbZyfHIcuPjCcRB6/7QqpcnjAHPH0KFDpUuXLla1wLxy+PwMHUuT+01IBZM/IcFkJCJ/QscqHimt5I/x/lFP38O38T08wHu4/YSKeOCteiIe3TOBy8yhgkXVWmz/u0j+SrFtB/kTAb7kTwSgWXgL+WMh2BEUZSF/Iqidr1umT58ujzzyiPzyyy+SI4fWP1JK2y8y+0LVUPzLFawr0nyccB9wbDTGFbAsVu3h/BYBshaMT46DTL5wHGRiYasj88bBl19+KQ8//LAsX77cVi0MWhk+P4NClD2Bef0me95eZ8gfL0BC+Uv+hIJS/NJYwB++f2SyN8j7h3pEtxEt18jGq0fZqEKJUpV01eo8JPJZZdfiM1bVJn8iRJb8iRA4i24jfywCOsJiLOJPhLXzddtTTz0lDz30UHQCRWS8uLcGKNtIgSKwSNd+sPx+kd0/4Z/5xPktQkwtGJ8cB5m84TjIxMJWR+aNg/bt20taWprMnj3bVi0MWBk+PwPC4/+ief3Gfxl6hfwJCI//i+SPf2zscMUC/vD9I5PRQd4/7CNUXD9JHdCPV7XS45mVj/DowBGRQ+rH/vTp0DJIU4uyFbpuw307VDHkeFpo90WSarNasq3elP1OlLk32kCekCDPbaERsrURZhP5Q/746VMcP36A8TzN8WPv8ePJqyiP582bJ/v37xcEaYmK1r+tQULmRR2UJdT5EO8KmAdDnTcDtS1m8xwCpnx7jWIS7WTpVXuOT/uOT44Dr86qfzkOsmMSxpmYPZ9QB5Pew4cPHy4vvqhuoBKB+Py07/MT/Yf8IX/8PEe4fvMDjPs03z/cSGT+Bnj/sIdQ8fhOkaVDVNsu+oXCb/+J3PueBozeJzJE12Qngrig+kn93rd5RuT/5mqAyQEi5W8X2bw3Ezuzjj5YLNJwuMjHqmRRME/2XAdMEBn2fvbzYZ3BqvCENvzXYWHdFjQx+SPkj+9ewvHjG5csZzl+7D1+sjAr+j9PP/20DBs2LDotxXSduKCVBw30KCic+RACxfo6Ry38M/ICLZnngMnaiZFX0vtOjk/7jk+OA+/emvmf4yATixCPLHk+mfQefsMNN8jKlSvl999/D7F1cUrG56d9n5/oEuQP+ePn0cD1mx9g3Kf5/uFGIvuvn/cPewgVEZQFzIuSlqx1CRJfukmkZlmR/i1Ern1J12Wn/Gc88mOR69Vl1bh+IuP76wawyuVyqsJfNPTijKx33/GWyN3viEy/V+t3pUiVUlmvT/9F5O3vs56L+B8kyOtU6xNO/c0i8of88dOXOH78AON5muPH3uPHk1dRHv/888+yfv16uekmnYSioX+nqcqgqttHQeHOh+ep94yZKsdsWjO0QuM2z2Hz8Tf1u5weYGIPrQmuVByf9h2fHAf+ezLHgX9s9Ercnk+olQnv4ampqXLbbbfJ6NGjA7Yz7hf5/LTv8xOdg/whf/w8JLh+8wOM+zTfP9xIZP/18/5hA6GiSvH+maCTcHQLKLT4jskij3RSTcC8rvbXr6oBkfOJTAkgsIOkvpjGOAHVr+L6Def76ImsqT9RTcRnvsg899ESkVe/Fplwi0iF4pnn3Ud7VOni9bkq/GzkPmPGr7J141QzMtI8yB/yx39X4vjxj43rCsePvcdPMP6Fd/3VV1+VQYMGSc6cUU6t/36kWufRubEIdz5M0SpfqcHtcqVkthlKNyD8uo/xP+7zHBbtB8zQ4OH4tPX45DjAcPNPHAcGNk59D7/11lvlgw8+kL17Y2A+5b9XhXGFz09bPz+5fuP6mvKPMJ5nXkn5/uEFiNdfH+8fUa58vAqI5O/hDaYIFGdokLT/dos0r5O1Etc3EXniUy3Ch3/FQW+K7FKh3rh5In3HiTymWoueBL8rnVTTsaMqUjZQs7CnPsv0N/XFMpFer4v0G+8ya96qcz7Kh+n1QV3vdHhBLbpVYImdgDKF1aWFWng/+L7I/NWeJbg0GJ/uIpKaK+v5qP6dOqI23F7qkpFmSP4I+cPxE+nwEY4fe4+fiBmb/cZdu3bJ559/Lv36qdp7tLRzUVQ5hDsfQpv/tTkiFzwk8qXOpfDvO/gtkbK3iUz8RqTyEJFKd4j8vsku85wuZqPEyACY49Pe4zNKHnMchPgY4Tiw5TgoXbq0dOrUSSZNmhQiIy1Oxn5jy36T0QvIH/KH8o+M4RD2Ad8/gkCW/T3cBkLFf9WxcWqQige/DD9Qdcqr6bJXiyqXdAn01u3InsfrfbVoPX1XO5E3B6pQ8brMNHBWD8EghJSf3yMy+VaX0HGsLrxAt6pA8pJaIu8NdpX58VJddJUQufNKkaKq+QhTZ/xfvdnQ9RPspELw2OppNTH71ZUHtD2qaP2gUWk6IWKoGXSY/CF/1KKe4yey0cTxY+/nW2Rc9XnXhAkTjOAsxYsX93k9rJMndLKIgsKdDxFbAJr6P693FVo0v0i1Uhq47IDIdv18+7BIbt34glaGLeY57JAe3RoFQmdu5fi09/jkOAjcxzkOHP8efsstt8i4car1YEfi89Pez0/yh/xRhSau3yJ8ePL9IzBwPt4/zNSPC1x4jK/+uUU1AotkL6TSmfUdrsPPYqj0w9/qJ1/lch+qhgbo/Moi9XTRBa3GoSo4hDlzw6oii1SYuVMXXes9hC4QVIJ+V4Ei6I3+Itc0cmk5rvxPZOpi1Qg5SxdomtdX97nSOP2b/LE3h8kf8ofPt8j7QLraBo8fP14+/VS3hW1A4Y5nmD5jTgLBzBlCxrMruP4PaClSspBIE72+aY/rHL45z2ViES7emXf6PuL7h29cwj0bLl84DsJFOGv6cPHOenf2fxwH6uO2aVNJSUmRhQsXSrNmzbKD5IAz7Df2ZiL5Q/5wfRB+Hwh33Djh/UOXEnGmAiqtS0+LuhLQBDytiyFvKqWmx6B9ahEcDm3clT31RTVENqjUHwQtjp5q/rxCFfmgueFZNhZkILeQM+8ZRUxoUV6q2o1frxIZNV3kkLqRhMYjTKjhm27BH65jX6barhzD+C6gElAziPwhf7QfcfxEOJg4fuw9fiJkq/dt3377rRQqVEjq1avnfSmy/7mLRXbfmbuimQ/d85d3BaCp6DnFutPFZZ5LUWfJ+cp5VzH8/xyf9h6fHAeB+zTHQVK8hw8cONCe2op8ftr7+Un+kD86g3D9Fnga9XuV7x9+oTEu+Hj/sIFQsapISt7AFQ/hai1dX2zxYTEG31AgCP7CofJFXakXq8aim3IpWgi2AmHg1c+L3Nxc5LY2Im6hoTud+7d6aV33qEDxlw3uMy4TMgSGubS2SIu6IqVV6IkP8sijizYcuzVAMu8K8yhFbdcqXB3mTX6SF6hK/pA/HD9+hkfQ0xw/9n6+BWVgaAkmT54svXv3Di1xKKlKXRJKKr9pzJ4P/RakF+Izz+ksGSVGRps4Pu09PqPkMcdBoJHrcY3jwNbjoE+fPjJjxgzZvz+64F0eHDfnkP3G1v1GyB/yR0c65R8RPu74/hEEuOzv4SrGijdppc7qL/Ln6KgCtpxbyeVg3rs1CLYCYaDblMvz+jHVboTmxcnTrrPHT7p+oSl4cU2RqurvcOYK1Ug8Y3GwRLUJe+haD/4JEHgFAkvkv+o/l+biAdWGzJ/HtSuwX4+36/w/RE2lkceD17jyducBc2h83AQNyCL5NXJ0N/eZaH61AVVujCYDj3vJH4BB/nh0iTOHHD/ZMcl+huMHmNh3/GTnWLhnDh8+bJg9P/fcc+He6j995Rt0ApkXcQToSObDw8dd1XH/uudD+BcG4TwCuoDiPs9hh7Tw2a7KRPXN8Qn4bDs+OQ4C926Og6R4Dy9SpIi0bt1aPvzwQ4GPRfsQn5/ghW2fn1BR4fqa/KmQ/YnB9Vt2TLKd4ftHNkiynPDx/hF/TUXUsK5GNckRnXyze1Ndf6lQ0Nsh6fTlItc1UaUG1TbzphEfus6MmaVmzBtFnv3C9R9RnhGN+aOhIvDpcsdbrijQkPY/0EHkvErq50SFjkPfdpkvd2go8s4iEQRrgfZhOdVyPOd+DcyyT6M/X+cSOF7/ikjLp3THQDUd77nKuyauYC859fkfNYHJ1W9W1ccyUWeVkQH5YwQAIn8yeoRxwPGTFQ+//zh+7D1+/DIutAuI+Ny8eXNBpE7TqPL1OilErsEf7nwI7fsHprpqj2Asy9drNOivXf+f1PnwW3XNgQ/mwwW/x3mey1VA5NyH9Z0hxRy4OT7tOz45Dvz3cY6DpHoP79mzp0yZMsV/f4jXFT4/7fv8RJ8gf8gfyj8iezry/cM/bn7eP3Kog3lPN0n+M4j1lfWTRJbeoaoQZ+yVIyjvzQW6GNogMraP62ZoC7bWaMuI0BxOkBbX3a5vaGn8vU0EJsuli3heUc0NXYgVOLPuO56m5supruvwZwUBlPs/zqIuIGgjxozg5CpvWZH2uvpL9apstIWSP9EiqItg8scTRI4fTzSCH/P5FsPxExx+vyk6d+4sHTt2NNf8GaWt112rpbfrnHjIb9mBLsSiv3iWF7d5DhtmHf9Rtxw6KZtFnN+iRzJW8xvHgW/ecBwYuCTLe0RaWpqUK1dOli1bJlWqVPHdJ+J1ls/P6JGP1fMTNSN/yJ8IEKD8A2OH7+E+u46f94+Ux5R83mD1yWINVNVQo6Ps+jHikhtUdWkc/rlVpE55kS5jVPtQrYARtShSwnMekS/dwkPPfOC43k25PJQmUvXY8z/SwGeiP9+L7jyi/s1VUOSKxerIsULUWWXLgPzJBknYJ8ifLJBx/GSBI+gfPt9i+HwLir7vBDB9vv322w0n+nnzntlh8p00/LPF6ons/kl3rzaqn44zvjnCyCUW/cWz+LjMc9DEbzlbJ+RqnlWJ/pjzW/QYxmp+4zjIzhuOgwxMkuU9AhGgN23aJOvWrTM04zMAsMMBn5/RcyFWz0/UjPwhfyJAgPIPjB2+h2frOgHeP+yjqeiu9ZJbRDaqHVYUGouz1IdhZTVVhqbgWarU4HjCyIfC6bW6+MxfObbNJX/Cx5f8CR8zK+8gf6xEO/yyrORPmLWDj6tJkybJzJkzw7wzxORp6ph39oUiB9fqM/6MQ8MQb3Unc8x8mEvV/Os/J1JLTQ9iRZzfwkfWivHJcZDJF46DTCzsdGTBOFi0aJEMGjRIVq5caaeWZ9aFz89MLEI9sqDfZFSF/MmAIuQD8idkqOKS0Ar+8P0jk7VB3j/sJ1RE1Veqv6Q1L6lg8YzNcGZzeOSNQEpuNXUuKtLmO5FCtb2vxuY/+RM6ruRP6FjFIyX5Ew/UQy8zHvwJvXZy4403Sps2baRv375h3BVm0lM6D36gpr45dZfstPrZSFZq8LzLP1Ss28/5LXSErRyfHAcuvnAchN4/rUpp0TiAt6qKFSvK/PnzpXZti973w8WQz8/QEbOo32SpEPmTBY6Af8ifgPDE/aKV/OH7h4vdQd4/7ClURNU3f65e4XvrIuqoRoVWJ4Wk7AjAUWbpyzRU9SRVyyyd/Xosz5A/wdElf4JjFM8U5E880Q9edjz5E7x2curUKSlVqpSsXr3a8HUVwi2RJzml8+D8NiJ7f41Kiz/yCsTxTuxEX/6VSNkrrasE57fgWMdjfHIccBwE75nWprB4HAwdOtSYdx566CFr2xlOaXx+BkfL4n6TpULkTxY4fP4hf3zCYpuT8eAP3z+Cvn/YV6iInntit8iPqgGy9WuXcFEtfEmKAOzZobVywWsiVW+KHyTkj2/syR/fuNjlLPljF074rodd+OO7dhlnYYo2ePBgWb58eca5mB7A/Hn5PRo5bJxutGmUMKdTLp3ncmnYwhbTRYpfYH1rMb8tvllk21y+f3iiH+/xyXHgyY3YH3Mc+MY4TuPg+++/N/z4rlihfp7sTOw3vrkTp36TrTLkTzZIjBPkj29c7HI23vzh+0fAnmBvoaK76nuWqnCxn8ihdcmnpeHGAL8pefQrp0ht9Sl17iO64NLABXYg8sfFBfLHDr3Rfx3IH//Y2OGKXfnjB5sRI0YYV5566ik/KWJ0Gs/bhdeLHFehVxS+h2NUu+izzaFzHPpCNbVUaPiiHqsvxXgS5zcX+nYbnxwH1o4KjgPbjIMKFSrIwoULpXr16tb2gUhKY7+xTb/xyT7yh/zx2TFsdpLvH9YyJML38MQQKrqh3D5Pwzuryv9edVKcfly1ByJzXO/OLmF+oeYrqqYJB/V17tYw0mXsWXXyh/yxY8/k+LEjVzLrlCj8yayxcdS4cWMZM2aMNG3a1OuKBX/T1bfi3+N1PhyuU8NJ5/gfxkZZiYYijcaKFD3fAiDDKILzm/3mN46DMDqwSUk5DuI+DgYMGCB169aVu+66yySmWpAN+03c+01ALpM/5E/ADhKni3ZeH/D9I1unSCyhorv6+9Sv1F9q+rvhPZEcuUTSDrivOOc3p7Yrh5o4F6yimolDXWbOdtFMDIYy+RMMofheJ3/ii3+w0smfYAjF/fq+ffukUqVKsmfPHklN1ed0vOjkIRUuvi7yu0ZFPq2+h9MOxqsmkZdrzHU635VS4Sw08OEn2M7E8Wk/7nAcWM8TjgPrMT9T4vTp0+Xll182ArbErRKRFsx+Eyly1txH/liDc6SlkD+RIhe7+/j+kYFtYgoV3dU/rdqKmz4TWTdZ/R7Nd5lMGYsq1epLRIJ6L1ROc5dQIeKNItX7iBQ+OxFb4qoz+WNv3pE/5I+VCDjo+fbFF1/Iq6++KnPmzLESQf9lQVvx32m62TZGZM8yTZeifhc1uItdSWOvGP4SoYFfvZdq4Q8RKVTLrrX1XS8+P33jEs+zHAfWo89xYDnmR48elTJlysi///4rRYsWtbx8UwpkvzEFxphlQv7EDFpTMiZ/TIHR1Ey83j92HsgpJ08ck3LFTC3FvMxi8B6e2EJFT2gxwOBQHULGrbNFjm1X94N5z2hu2FTIiHDoWsdJ8w9LibI15JouN4tU7JR4iytPPvg7TmD+yGkNilCskUiljuSPP/5afH7ZepF61VIlV6oGcyB/LEY/xOLOPN+cyB+YnZUuXVqGDRsWIhgWJju2VbX4p+hnqsi+3z022yysg6+iUlSjM6eOVzktUr69+kzsKVLuCt1IUwFoohPnN/tx0MbjYPHaVLm4lm4gcxzEv98k6DzVqVMn6dq1q3Tr1i3+GEZbAz4/o0UwtveTP7HFN9rcyZ9oETT9/q9nvC99bh4gq16rIsVP/ZU07+HOESp6d4njO0S2LxDZ9YP+fity4A+XOTE0ARE5E6ZiVlEOFQfD2TwWTyg7t4qtSzQWKdNCpOQlsvVERWnW/HLDN9fYsWOlSJEiVtUsfuUkEH+khEYehZl9MpHN+fPdpmry8JTtMm3Kq1Kqdlvyx8bPNyeOn4YNG8rrr78uF154ob2fCif2ujbZtn3t2nQ7uk3nIgjidRMulhGkMefBXQf289J1ri2mfhLLX6VCxDY69zXRk3rdyeT1/Px15WrjGVVfN0Ls9v7hxPGZrWvZbBwMGb1SylWvr5sSw7NV1VEnvMaBnd/DE20cYP5ZsmSJvPXWW47qMkZj2G/szVMv/pzSzcvX9RVjcDtV5LHZ+jrRxrUpjPfiD5+7pqAaUiZpaWny8MMPy7vvvitvv/22XH755SI2e/+I5Xu4c4WK2divq5tDqt50YI3rs2e56/fYFtVq3KWp9ToWW1gMgdJVmwKqrPiFZgXCiJ/WX1w3NCtUOAkBJY5z6icd92keSHfqiC6oCmlAldIiBaqIFG8gUuQcNWWuo5+6IqnZhYZHjhyRBx98UD799FMZP368tGvXDrVIIlLsbMyfJGKEn6bajz94cOOhjTEDIU9yU/j8OXIsTfLkOi0pOfXeGD/fnMQbPKtLliwp8KuYO7dqmycSpe3TQGcrVINxpW64/ai/q0SObFKN/v06Z53Z+NLuYPQH9/yHvoGPMTeeme9gXq2+EA+qhXUhnTbltAaOgdPqfOVE8ldV/4gqbIV2dzENtoJ5T3SuTFL68ccfpUOH9vL38rlSNKe+b+AdxGbvH0nHGpPHgQ4OhVAHTojjYP/+/cZiA/PW//73P8mVK1k2LcOfp46fwLPltORJ5TzlOU7XrVsnl1yiSglbVTPd8RR+vwl3/Xbw6GkpmOeU5Ditk1qY6zfHwx+ggSdPnpSbbuoh59euJMMHtuT8FgCr+F2K/fgx5r8I5R/xw8XckteuXWtoj1euXFkmTJggJUqoKztfFOf3D19VMutcEgkVg0CGRdWxbS6J8gldeEGyjAAw0OjAiyI0G0+rkBELq5y6kMwJUy79hQZibvVpYnyK6W9xXViV13SRvSR+99130rt3b2nZsqW88sorUqiQCidJrkVvEP48OnaOdGp9ttQ/u0rM+ENW+EEgTuPnk08+kYEDBxpjpUePHn4qx9OG0Mhj/Jw4tFPlPf1k+w9PScF8KvCx6PnmBE4sWLBAhg8fLj/88IMTmuNqA/gP4eLxnfrZrfOffuCf2NBoxNynH2yiGXNeHv3Nq3NdMbms65Ny75B+0qFzN5E8uolGyoLAt99+K9dff7288847csUVaurtj+L0/PRXnaQ9H+E4kLwldTzoAiJf2ZDHweHDh40FyPHjxwXzGN/1tNf5GAetuo2Ue/u2kHbNanKe8hqYNWrUMDZVzzvvPK8rSfbXR78Jd/027JkpcvDIKXn1fxMjXr8lGepy6tQpufHGG+XQoUMCP9N+N0dM4I9h4Rfl+jrZ+BNye0PgD9fXgdGExvj9998vI0eOlEGDBgVO7O+qhe8f/qoQ7XkKFaNFMAb34wF93333yVdffSUTJ06U1q1bx6AU52XZtm1buffeewW/pORBYPXq1dKxY0eBj6Fnn31WUlJUi4oUEIFFixbJ0KFD5eeffw6YjhezI4A+tmPHDnnppZeyX0yyMzDB+/777w1TjyRretDmIogPNjqmTZsml112WdD0TJB8CJxW6xc8hyF8njFjhhFRPvlQ8N9iCC0QiOS///5L3IAk/psX9ZXbbrtNzjrrLLnnnnuizivZM8CcXqtWLfn777+lVKlSyQ5H0PbDzPOBBx6Qv/76y9gUSTirjaAtZAJPBLi+9kQj8xhWB1BswTr0o48+kjp1YJmTvJS8Nkk25nnBggUNf12TJk2Svn37yq233mrsBNm4yqwaEYgbAuecc44sXbpUVq1aZWgD7dmzJ251SZSCoRHdokWLRKmureoJP1YwOyOJ3HDDDTJz5kw5duwY4fBA4PPPP5devXrJ9OnTKVD0wIWHWRHImTOnwI92v379DP+sv/zyS9YESf4Pc3q1atUoUPTTD6D9PG/ePD9XeTocBBB4rXv37obVSzj3JWPaEydOGBr469evNzRlKVBMxl7ANsNaqV69esYmBNagyS5QRI+gUNHG46KlmkD/9ttvAp8V5557rsDsjuQfAbyg53D7xPSfjFcciECxYsUM4UajRo0En5Ur1WccyS8C0Ixp1qyZ3+u84B8BLPzr16/vP0ESXYFvyQsuuMAQniVRswM29f333zd2rmfNmiUXXXRRwLS8SASAALQVofULbRAIokkuBBYuXCgXX3wx4fCDAOZwaIpDo5MUPQLQvBs3bhyVOAJACXcN1113nWHqDC381FR1BUZyPAJcX2eyOD09XZ544gnp3LmzvPrqq8bGYN686hKIRKGi3ftA4cKFDYefcOYNU6ohQ4YIAgWQsiMAUyIMdlJyIgCB8nPPPWeYQLdq1cowO0xOJAK3GgsQ7LBRqBgYJ19XoQWLAC3Vq1f3dTkpz3Xt2lU++OCDpGy7d6NhXQBTRGgPUfDsjQ7/B0IALjwgiB4wYIC89tprgZImzTXMU02bNk2a9obb0OLFixuanMuWLQv3Vqb3gUCVKlXkyiuv5PjzgQ1OQUMRboYgQMGcT1dDfoBy4Gmur11MhSsOuLOBktfy5culffv2DuR25E2ipmLk2Fl6Jya633//XQ4cOCBwyozdSRIRIALZEYCQY+7cuYbT3GHDhmnQdkRwJ7kRwESIl2csSEjhIQDsICyiRnQmbtit/frrr+XgQQ3sksSEjb9HH33UeNmESwYSEQgXgcaNGwvcK0Br8c4770z6uQu+f+lqInAvghsTLHBJ5iDw4IMPyssvvyzQyCNlIgAXJw899JAUKVJEoI3vNyhL5i08IgKOQuDjjz82LOGuueYaY41Zrlw5R7XPjMZQqGgGihblgYc5IgwhKnSXLl3k7rvvlqNHj1pUuv2LoXq2/XlkVQ3h5wJBSLBAu/rqqw3tMqvKtns5MClj4IjIuLRixQpp2LBhZDc79C4EUrj88suT2mzz+eeflxdeeEEwtmrW1Ci1JCIQIQKVK1c2NMnhTxAC+2S1TNmyZYvhqxURjkn+EcCzl0JF//iEewWupi688EKZPHlyuLc6Nj3WmdDI2rp1q7zzzjvUUHQsp/03LJnX15iDYUEA9wgIoIuAsFQs8N1XKFT0jYutz3bo0MHwtbht2zbDSeiPP/5o6/paVTmqZ1uFdGKUA008aFDBeS78vkHTlyRGpFGaPkfWExDhrW7dupHd7OC7sMn13nvvObiF/ps2cuRImThxoiFQhAYwiQhEiwDc3sAUGgL75s2by/bt26PNMuHuh4CeWorB2QaMYCZO1z/BsQo1BbQVn3nmGfqqVMAgULnqqqukQoUK8vbbb1OgGGoncli6ZF1fwz9/gwYNDM3lX3/9VWBNQPKPAIWK/rGx9RUITLCIgw+5a6+9VjAJUl3f1ixj5eKAAHy+wJTlkUceMbTzEJU1mQkLD0R+pqZiZL0AQkWatmbHDuYgEALs3bs3+0UHn8HONUxi0HaawjiY0XFoGgIgwDIF73dNmjRJuk0x+lMMrdOVKlVKEDDrjz/+CO0GpgqKAIIDVapUST788MOgaZ2c4PDhw9KuXTvDbyf8BVM7y8ncZts8EcBaCVahrVu3FmwcQ3O5YMGCnkl47AMBChV9gJJIp+A0FxGi161bZ0jTYfJJIgJEICsCPXv2NDQ/EGUTfs+SdVcfzwosQMqWLZsVIP4LCQFou5599tkhpU2mRHjZuuKKK+TTTz9Nimbj+QGBIgKyIJI6FvYkIhALBODHDFpTLVu2lPnz58eiCFvmSX+KobMFwWwghCWZh8Dw4cONoH/m5ZhYOcFHMt6ba9WqZWjiw/yVRASSAYEdO3YYbrMQjGjp0qXSrVu3ZGi2KW3kU8IUGOObCYQE2FGDsARq6ngJRZQuEhEgApkINGrUyJggvvnmG0GkTQQ9SjaCliLM6UjhI7B582YpVKiQFCtWLPybk+AOBEiaOnWq41sKM6D+/fsbi3g8S9gfHM/yuDewe/fuMm3aNGNxA+1FpxNMLqF5hzmbFBwBChWDYxRuCgTHBMGHWrIR3o2xSVimTBkZP348NRSTrQMkcXtnz55tuJWD73RYoNClTXidgULF8PCydWos6qCJhA/s/hGplEQEiEAmAtAognYRTFvgjPuvv/7KvJgERxQqRs7kv//+W84666zIM3D4nQiI9NNPP8nOnTsd29KTJ09Kjx49ZMOGDTJnzhxDyOzYxrJhtkLg0ksvle+//14ef/xxefjhh21VN7MrgwBr9evXlzx58pidtSPzg1ARGjUkcxEYNmyYoSVsbq72zg0CxbZt2xoB6RCFnibP9uYXa2cOAmlpaXLPPfcYG8bQUHzyyScZ4TwCaClUjAA0O99SunRp+eyzz+T+++83dprwAoqFUDJQMkenSgb+mtVG+Kp67bXXjAhecHI+c+ZMs7K2fT7YeWvRooXt62nHCv7zzz8UKgZgTN68eQ0NYGhUOZHw0nnDDTcIzMKgvZIvXz4nNpNtsjECMEWE4H7u3LmGn2CnWqQg+CCEqKTQEIBLDsxP8IFHMg8BBCBDQMzFixebl6mNc9q3b59h8o0N91dffdXGNWXVrEbAyetrKJdcdNFFsn79ekFgFlpzRd67KFSMHDtb33nTTTfJihUrjN1LRL5dtWqVretrRuWSNTqVGdglYx79+vWTL7/8UgYMGCBPPfWU4yGApl2uXLmkcuXKjm9rLBq4du1aqVGjRiyydkye0JZ3YhToo0ePGv6lEPgJfiOpQeWYLptwDYG7G5jdr1mzRlq1aiV79uxJuDYEqzA2vxAsgxQaApjXzz//fPnll19Cu4GpQkIAgpT77rvP0FoK6YYEToTnCJ4n2KgYPXp0AreEVY8FAk5dX0+cONGYawYOHCiffPIJ3dlE2XkoVIwSQDvfjmiU06dPlyFDhhhOvp9++mk5deqUnavMuhEBSxHAjizMhiBcvP766x2904+AEoz6HHn3QjCsmjVrRp5BEtwJsylEyIb/SafQoUOHDF/FECTCLAaaziQiEE8EoBUMP9owe8UcBi01pxCCIEEzDG0jhY4AXB4xUGPoeIWask+fPrJs2TJHK2bs3r3bEChCqPjCCy+ECg3TEYGERQBaudBEHjNmjCAoGJRLSNEjQKFi9BjaPoebb77Z8K+4YMECQ8XAtKFuAABAAElEQVQXDrBJRIAIuBBAJGQI3IoWLSpNmjQxIqk7ERv6U4yOqxs3bjR8cUaXi7PvhsCtc+fOhvDNCS3Fi2ebNm0MYfLkyZMFmookImAXBJ577jnD1Q3ceDjFRPP3338XaGPClQ8pdATw7gLhF8lcBHLnzm34WkMEdicSfCDDJU67du1k1KhRTmwi20QEsiAA38TQ7IbiFdyJ1KlTJ8t1/okcAQoVI8cuoe6sWLGi4Vj+lltukWbNmsnzzz8vUGcmEQEiIIIXxwkTJsgdd9xhaH4gCIPTiELF6Dj677//0nQ8BAi7desm77//fggp7Z0E2hstW7Y0NuIQAZNEBOyIAN7pIPC+5ppr5KOPPrJjFcOq0w8//EAtxbAQcyU+77zzDH9gEdzKW4IgMGjQIJk1a5bhcy1I0oS6vGPHDkOgiI1AWLKRiICTEYCl5mOPPWZYpY0bN84w86crG3M5TqGiuXjaPjeo+GI3E8EpYF6SbNFvbc8gVjCuCNx6661GoKPevXsbgve4VsbEwv/77z85cuSI1K5d28Rckycr+BmCkAk7m6TACFx++eVGdGQ4vU5UgnN+bL5dddVV8vLLLydqM1jvJEHgiiuukHnz5sndd9+d8NpGMEWD5iUpPATq1q0r8JucLIEZw0MnutQFCxaU2267LeHHlicK27dvNwJSYBNw5MiRnpd4TAQchwCUAuD+CZtWiDcBzVyS+QhQqGg+prbPsUqVKsYLaK9evQzBIhZN1Fq0PdtYQYsQwIIGvongP6179+6CIA2JTvSnGB0H4SMQ2t5w3E4KjABMhBElOVG1FSGAR+TZnj17JoWD/sDc5NVEQQDmXEuWLDECJcHpfKIKl6ipGFmPg59NBGGjokBk+AW7684775SpU6cKhHGJTlu3bjU2zbB5/vDDDyd6c1h/IhAQAWjwN2rUSK699lqZPXu2lClTJmB6XowcAa6QIscuoe/MkSOHsfMGfwKIZgkJfqI7+3ZyyPuE7mwJWPkKFSoYznsRVfGiiy4yNK8SsBkZVYYPEQZpyYAj7AO8hNPHV+iwQRgPoXyiEYLxQEMRwc2GDRuWaNVnfZMcgfLlywue9RCMt2/fXhBkKJFo165dgs+5556bSNW2TV2B22+//Wab+jipIvDzCSHcK6+8ktDN2rJli6Gh2L9/f85xCc1JayufiOvrw4cPS79+/WT48OGGMPHee+8VyD5IsUOAQsXYYZsQOVevXt0IUoHIt4gi+OqrryZEvX1V0qkh7321ledijwB8bbz99tvGpATB4jfffBP7QmNUAurevHnzGOXu/GwhVKTpc+h8hmsNCAcSKSjYmjVrDIHiiBEjDKFi6K1lSiJgHwRgqjl9+nTBux207jdt2mSfygWpCUyf8R5KigwBChUjwy3UuyCU+N///if79+8P9RZbpcNmAzaX4ebn/vvvt1XdWBl7I5Bo6+vly5dLgwYNJD09XX799Vdp2LChvQF2SO0oVHQII6NpBiT3Q4cONaIHvvfee9KqVStBpFMSESACYggYYMoJ7avRo0cnHCQw14FDbjhyJ0WGAHzsIUo4KTQEMKd07do1YUyg4WOndevWhs8sBL4gEYFERgAuCP7v//5P+vTpYwjpsKhKBKI/xei4RKFidPgFu7tSpUpGQKTXXnstWFLbXXf7lEMwwnvuucd29WOFiIAZCECI+OKLL8qVV15puK958803pUCBAmZkzTxCQIBCxRBASpYkNWvWNExn4Jwe/gcY8TJZOM92BkOgRYsWsnTpUpk0aZKxUDt27FiwW2xzHVGfYdJJtf/IWQKhLDUVw8MPQsVEMIGGC5C2bdvK2LFjpUePHuE1kqmJgI0RuOuuuwzrEwjMv/rqKxvX1FU1+lOMjkUUKkaHXyh3P/jgg8bmciL52t6wYYPxDohATnDtQSICTkQAChQQJn7yySeGX/wuXbo4sZm2bhOFirZmj/WVg98E7GItXLhQ3njjDWnTpo3hn8f6mrBEImAvBBCoY/HixQKBIgI5JIpZGYSKNH2Ori/BlLd48eLRZZJkdzdp0kQQNdvOWlLwPwffc9gs6NSpU5JxiM1NBgTQryFQhG8paC/alfCsgMkazZ8j5xAUA2DimkibnpG3Nj53Iso23HtMnDgxPhUIs9T169cb73/wETx48OAw72ZyIpAYCMycOVPq1atn+MDHmgdaxSTrEaBQ0XrME6JETJw//vijtGzZ0vBFABViEhFIdgTy5ctnmHR269ZNLrjgAiOYi90wOX78uPzyyy8ZEd0pVIyeQxAqwlE7KTwEME7cUaDhkwfmjXahefPmGdEAUT9o55OIgFMRgIAfWoBjxoyR++67L2NuiHd7EakYriVAy5Ytkzp16tBULQqmILAc3t0TyZdtFM2N260Q0D3//PMZEdZPnTolcKFhN1q7dq3AygYRnuFHkUQEnIYANqMQmX3gwIEybdo0GTlypMD9Byk+CORQ+/P0+BTNUhMFAUST69WrlyCyIEyi8WsHOnLkiDz22GMZGmN4aa5Ro4YRpRXd+uabbzbM2uxQV9bBeQh8/fXX0rNnT3n00Udl0KBBtmng448/bvgSgdZx/fr15c8//5Qvv/xSsLBMTU21TT3tXBEsdGESi2A9CHwAf0S1atWSqlWrStGiReX2228XaK6SAiMALcV27doZfqggvDtw4IBMmTJFbrrppsA3xvgqxgOiX8JMBlonJCKQDAjs27fP0MiF1vU777wj2CSLJ8ElB+YkPFPhXgKf5557zvD/i/mLFD4CCLoIsz+a/oWPXTh3QOEC7jKgFYp1CDYeMb8VKlQonGxilhYCe9TxySefNFz2xKwgZuxIBBJhfY3gejfeeKOx7odlJeYRUpwRgFCRRASCIZCWlpauwor0UqVKpWtE3GDJLbm+d+9eCMR9fvRlNV2FApbUg4UkLwLr1q1LP+ecc9JVQJGuGoIZQKhWVvrq1avT1ZdNOo6tpJdeeik9d+7cGeMCx4ULF07XxVu6amSlq98RK6uTkGVpdMcM/LyfMboLmq5+WxKyXVZVWjUk0jX4V3qJEiXS8+fPn64CAgNPFWKkqwmmVdVInz17droKf9N3796dUeaHH36YXrp06fSff/454xwPiECyIIB3ORXqp6umfZa5QIUj6epvzdJxoZs0WZ6zeD6oUMaYv1QbLFlYYmo7Napv+tNPP21qnswsKwIqPExXN1HpefPmTdcgEEYfRr9dtWpV1oQW/StSpIhRB90MNUpUTdV0Vf5If+uttyyqAYtxGgJ2X1+rgpPxfjlhwgSnQZ/Q7eFWYJyFuolSPMwqoEI/Z84cQ+2/Y8eOAqeongSNj0suucTzVEyPsStx+eWX+ywD2kUjRozweY0niYBZCFSrVk2WLFkie/bsMfzWbN261ch6/vz5Aqfp8A+lizizigspH2h7QMPOTTAPwA466gHfWnbZSXfXz46/KoSVxo0b+6yaCmkNbRqfF3nSML2DxjgiZKowT7DjDdNnN1mpgQSt3S1bthhmlfCBqhtiosJOmTt3rhGMzF0n/hKBZEEA73LQFr766quN+QmmshifeKcbN26cpYEcvLW9Efzi4MGDhvkaNL9I4SNQvXp10c3O8G/kHSEhoJu2UqZMGcM/KbQUDx8+bNyHeW3z5s0h5WFmIripwrsdTD5hmYLxDA1FaPz27t3bzKKYVxIhYIf1NWI7QJv93XffzUBehZ1y3XXXGe+XcKcDX8Ek+yBAoaJ9eJEQNcGkBd83559/vmGi4vaXBVMa+BSBuduoUaMsa8uAAQN8Cknw4oyItyQiEGsEdKdaPv74Y8PEE4Io1YAyfLXpdpOxQIL5iZUE9wS+BDcwdVuwYEHcTd6sxCKasmDa5Ms8sEqVKsbzL5q8nXwvfHrBrw2Er96EF0R8rCC4w0DgBwhMIPSHD1RE7vzmm2+MucuKOrAMImBXBOC2A0L3yy67zAjggAUc/PHiHW7GjBmWVPuss87yWY5axBiLRp8XeTIgAhQqBoQnqosYGwhkCeG3d/TnkydPGhtYURUQwc2qmWrUBX4dd+7caSh2PPTQQ3F3MRJBU3iLzRCI5/oa72zXXHONgQjqAXN++IeH7AHv4D/99JPUrl3bZoixOhQqsg+EjQB84DzxxBOCaEv4xYCHTzlopOCDl1UMeCsIDx1oYnkSBIrwdWfV4tWzbB4nLwLDhw+XsWPHGkEfMA5A+IVDbzjMtoqgqYgXTE9SMx1jdw8LSFJoCEBzB4JhT4IG9L333ut5isc+EHjkkUeMxY2nxqw7mS+Bt/uamb933XWXMf6Qp3vBBW0OBtwxE2XmlcgI4D0JPqnUTDJjrGDOuuWWWyzRsEe0Ym+n+tjIee+99+j/N8KORaFihMCFcBuUKiB897XZCCEjtOGtJCh4YBPb/Z6CeQ6avmr+ns2SzMp6sSxnIBDP9TX8brvXUdAI7tChg+EnVs2dBdrCvjatnYF6YreCQsXE5l9ca9+oUSMjyixMPTHo3YTj9u3bC9SUY03qr0vUv1mWYrCQ7dOnT5Zz/EMErEBg4sSJxkudp7knhN5YvFlF0FT0HI8oF0JFmKOSQkcApu3QmPEkaCNgEU4KjgC0dyHA89zcsUpTETvaCDDmSVhwwWUHXHRYMTd5ls1jImBHBOAOAw7uvbWu4C7jlVdeiXmVK1WqlEVAg3c3BBqx0o1OzBtpcQHQ4oEZLuYqkvkIXHrppYZChbdgEe98//zzj/kFBsgRWore73rgO+a58847T3bs2BHgbl4iAoERiNf6evLkyfLtt99mKAxhbP3333+Gy44rrrgicKV5Na4IUKgYV/gTv3D4OkCkVO8XGLyUdu3a1ZIGYlfd00+cOi2WBg0aWFI2CyECbgTgcxQTofdLHiZEdeCdxS+I+55Y/MIc21MbDC8G8CUHP4Gk8BDAMwyazyBo1HTr1k2AJyk4AngmI0K6N16efTN4LpGl8NRS9MwBvqcQDd0q807PsnlMBOyEANzVwK+it0ARdYSfuMfORLSNZZ0hVPTUVIRQccyYMbEs0vF5Y76Cr8oNGzY4vq3xaiAsPr788sssAnHUxUrMMX4XL16coaXoiQXGEbQXNeCc52keE4GwEbB6ff3vv//KbbfdlqGl6K4w5qmpU6cacR3c5/hrPwQoVLQfTxKmRtgNHThwYIajYs+KwzcPfFpBTTnWpFGeMwIBQCWajltjjTjz94UAfLVBgOi5SHKnwyINE+W+ffvcp2L6W7x4cSN/jIdWrVoZpgMxLdChmXfu3Dlj4YAXdQT5IIWOAPwrwrTSrdUBTcVYCxWhOQ/BoTfBdB2ap9DAgr9MEhFIZgTq1atnaAVijnCPT088oNkL/3GxJAgVUQ4Imw/QmkSAAFJ0CNAEOjr8QrkbwVA+++yzLGPHykAt8A+MdZYnYY4rW7asMcchaCDcC5CIQDQIWLm+xvoJ79ze/dpdfwgWoakIf4skeyJAoaI9+ZIQtcIAxwSGl1JPTUF35SFIQQRm+PyIJcHHI6JBYbGKT69evWJZHPMmAj4R+P77740gEH379jXGg/eYwEQ5ZMgQn/eafbJ06dJGlhibMMkmRYYAone7/RVB+wM+lUjhIQBzRvjddWsseppDh5dTaKnvvPPOLBtd0NyFQ2+MAyy0IBiOdR1CqylTEYH4IvDRRx8JNEPwnoaIthBKuMcG5qsPP/zQ0LKPVS3xTMV7JDbiEOSsS5cusSoqqfKtVasWI0BbwHEIXODmwy2UR6AUK2j16tWyQIPuQQgDwhyHoEeY4yDY7N+/f4aFhRX1YRnORcDK9TUiliN6uXujyY0q1lKoB+YIxHJwK024r/PXPghQqGgfXiRcTWrUqGH4OYCvg/Hjx0v37t0NTRD4b8MkB4IpKExsYq2GD+1ECFAqV64sqBeJCMQDAQihMBbgsw0LNuy6YTxgUsQiDeegwRtrwmINk/Drr7+ezS9grMt2Uv7YpMDzCzxkgJbIOfviiy8aPp4goI2lpuKcOXMMv1YQUoBnMFODqfOaNWsMgYUvLeLIW8U7iUDiIwBhIoSKELh//vnnhj9saGVDUII5K5aWHxijGJP4wEUHyRwEEKzN6qAh5tQ88XJp166dIXxHX8Y6x1sgEosWQUsRrjywUQdXT9OmTTOCAUIoH8v5NRZtYZ72R8CK9TVcRI0cOdIwe4YLB2xw4XPDDTfIpEmTZPfu3bJ06dJsMRTsj15y1TCHvuRnDW+ZXO1na2OAAPyKzJ071zANgI85aCzWPb+eTJu3MAalZWZ5dslC0nfwULn3sSczT8boKH+uFKlSJF+Mcme2TkDg6MnTsmH/ETmmmhjzZ86QDyZPlKWLvjea9vuugzFtYs8OV8gOXSTO/nml6eU4ru+nqUn6se0iJzSw1Ak9xm+a+iI6rVHl9fP+lz/Ljfd9IEd+fkQX2upPMSW3SI5UkVy6cZK7iH6KiaSqyV4eNTnPV951zXTUrc/Q3X/NKvnQwQPSpFoFGTriERl4131mZZslH8wBoKs6XS+D7ntAzqpVJ8t1/HFc/83WQp4gAuEh4D3W9+3ZLZ9OfVfe/t9rsn3rFpkw7XNp2qJleJmGmBpjdsjwR+TWu81/JiTrWIfG2qJFi+TNN98MkQvJm8y770eKxK9Ll0j3dq3lgzkL5LyGjSLNJuh9GI+Xn1db6l/QRO5//Gn9vdDnPcna932C4dCTZvXdUOCJ5foawSzrly9hVKNilarSodN10rvbDdKkSZMMzflQ6sg08UeAQsX488DRNZi9bqf8/tsqya27eOWqVHNUWy+tVEJK51cBA4kI+EAAff9wWtYIjAf37ZWdm/+T6uec7+OOxDmVWH1f980OrRM5sEY/6mtvzy+u36ObRY7vdoGekleFgTlcx+lqUpSufDN+9VjwH36/9HqOFP1AwV8/xjH+63ljb07TnTyiwsaCGm5bzc8LVBYppgGjipwjUliFW0XOVuGjCiEThHz1X7tX/Y9lS6Rs5WpSrJTL/N9ffROr//prBc8TAXMQCDTW//p1mdSqHzshiTkt8J9LMo51mAiOHj1aZs2a5R8YXjEQCNT37QrRzi2bpFT5ikGrl4x9PygoDkqQiH3XH/xrV62QYuq2qUSZckYS9l1/SNn7fC57V4+1S3QE8qTkkCq16yZ6M7LVPzXnGQFEtis8QQRcCKDvH07LikahosUEn0Qm2/f94ztEti8Q2blIZMd3KkD8XQV/KvzPqQLAk0ddGojeDIBWYlBS4SSEjcEo7YBqOurn4FqRbd+4NBohgDylZedWjcbijUXKthApeYlIiSZaN3tOw776b7Cmx/t63Ua+tTY862X7/utZWR4TAQsQCDTWE1mgmKxjHebPMGcnBUcgUN8Pfnd8UoQiUEzWvh8fjsSn1ETsu/6QqnFevYxL7LsZUCTcgT1XMwkHIytMBIgAESACcUHgtEZA3DZXZNNnIltUMwNCxZyqeZgGE3O3d49QhIaxqL2Wf/JQZsbHtG5bvnLVF9qRp4+pkFG1gCp21E8nkUK1MtPyiAgQASJABIhAmAiUL19etmzZEuZdTE4EiAARIAJEIHIEKFSMHDveSQSIABEgAvFAAIJECBHXTVYB3Xz1c5gnqxDxVLyEiCGCccZfo5F652KXSfaqkarJqH5lqt4oUr2PmkyruTSJCBABIkAEiEAYCJQqVUr27dtnBPNAwDYSESACRIAIEIFYI0ChYqwRZv5EgAgQASJgDgL7fhX581WRjVNdZsMwMwZByJjIdOpM/U9uElnzsquNBauI1B6iQsaeLj+Nidw+1p0IEAEiQAQsQSCH+vktW7asYQJdubL69iURASJABIgAEYgxAvA4TyICRIAIEAEiYF8Etqs24pyLRWarH8J1b7kCorgFivatdWQ1O61+G+F/cb8GllmuEVE/KSPy6wOuCNWR5ci7iAARIAJEIIkQoAl0EjGbTSUCRIAI2AABChVtwARWgQgQASJABHwgsGepyFfqwPm7a0R2/ajCtiNnIjH7SOvEU2mHXQLUP0eLfF5NhYsqZPT00ejENrNNRIAIEAEiEBUCFStWlG3btkWVB28mAkSACBABIhAqAhQqhooU0xEBIkAEiIA1CJzYrYJEDV7y9WUi+1aqv0QVriUzwTwa2ot/vSbyaQU1/343mdFg24kAESACRCAAAsWKFZNdu3YFSMFLRIAIEAEiQATMQ4BCRfOwZE5EgAgQASIQLQKbP1etvLNEtmokZwjSSJkInFQ8YPa9ZKDIgqtdka4zr/KICBABIkAEiIAUL15c9uzZQySIABEgAkSACFiCAIWKlsDMQogAESACRCAoAqseEVnUXQVn+1WgaPMIzkEbE8MEJ1Vzc/tckS/PFTmgvhdJRIAIEAEiQATOIEChIrsCESACRIAIWIkAhYpWos2yiAARIAJEwDcCECiuesLlQ9B3Cp71RABC1+Nq3jbrApEj/3le4TERIAJEgAgkMQIwf967d28SI8CmEwEiQASIgJUIUKhoJdosiwgQASJABLIjsPxukdWjsp/nmSAIpLsCt3xWWeTgX0HS8jIRIAJEgAgkAwLUVEwGLrONRIAIEAH7IEChon14wZoEQSDtxAnZsek/SU9Pl/27Q3dAvWX9P0Fy5mUiYH8EDu4LTevgZFqabN243meDAl3zeYMVJ9dPEvl7vMhpDUYSJR3Q4NCHjmlWp0PLKO2kyIqNakGs9+1Qi+vjaaHdF0mqzereavWm7HeizL3RxqHJkUNkbguX2Xj2Ihxx5tTJk/LXil8c0RY2gggQAf8IcKz7xybUKxQqhoqUeem4RjEPS+ZkPQKOXWNYD2XSlkihYtKyPrEa/u7Lz8qI7h1l8qiRMvDyC+TO9i3k8AGVAgSgzevWyt0dW8vIvt0CpOIlIpAYCDzWp4ugTweiZd/Ok4EtL5D3dLx4U6Br3mkt+398p8jSIaptF61UTeQ3tQC+9z2N77JPZMjbIidUYBiIftK9hjbPiPyfuiYsPkCk/O0im0OT2wbKNtu1DxaLNBwu8vFPIgXzZLssAyaIDHs/+/mwzuhGi5zQhv86LKzbYpn4k/Fjpc9F58p1dcrLqh8XZSvq2JEj0rNxbeP6K/feLoFeaP/6dZnc06mNPNr7hmz58AQRIALxRYBjPb74+yqdQkVfqMTuHNcoscOWOVuDgCPXGNZAx1LOIEChIruC7RHYvulf+WTcGLnnlXFy35gJMmraTMmTL5/s3bkjYN0rVK8hzdpfGzANLxKBREAAGlob1qyW2e+rtCwANbqsldRp0FhScuXKlirQtWyJrTrxx4si6UGkfyHUZclalyDxpZtEapYV6d9C5NqXVFZ5yv/NIz8Wuf5CkXH9RMb317gwKpfLqQp/0dCLM7LefcdbIne/IzL9Xq3flSJVSmW9Pl0V797+Puu5iP8hUvY61fo8tj3iLMy8sfOAO6ThZS2NLGe8rZJTL/rui4/lyKGDkis1VQY/84oUKlrMK0Xm31r1G8nVPZVRJCJABGyHAMe67VjC6M8WsoRrFAvBZlExQcCxa4yYoMVM/SFAoaI/ZHjeNgisWrzQqMuuLZuN36IlS8m1twxWoWLwxXOu1NwZ7YDZNIkIJCICcz6YIlXrnCPffPKBHD+qtro+6LTa/OKTkpJLcsAc1oMCXfNIZvGhjsd/VNh0Su2Vo6Q7Jos80kk1AfO6MqpfVaRwPpEpAQR20FQsVuBM+irhV+CoxknxpE9UE/GZLzLPfLRE5NWvRSbcIlKheOZ599GeQyKvz1XhZyP3GTN+dUrfONWMjEzJo2CRolKibHn5+Zs5goWXJ3390btSp2ETyZ03nyFY9Lzm69jzWe7rOs8RASIQPwQ41uOHva+Soam4f39gax5f9/Fc+AhwjRI+ZrzDXgg4c41hL4yToTYUKiYDlxO8jQ2at5ScOXPKM4N6y0/zZhmtaX19d2NBumPzJnm4Z2cZ0q65cX7O+1Okf/MG8u5Latd4hk6fOqVm049Ln4vPldvbNqVfLjcw/E0IBA4fPGCYPQ987FlDs+u76Z9kqTeE5VNeeEqeH3KLPHNrL1m1JNPUNNC1LJnE48/hDaYIFGcsF/lvt0jzOlkbcX0TkSc+1SJ8+Fcc9KbILhXqjZsn0necyGOqtehJ8H/YSTUdO6oiZQM1XX7qs0w/jV8sE+n1ukg/dQMJs+atajKN8mF6fVCVBTu8oBbdKrCEJmSZwiLr1cL7wfdF5q/2LMGlwfh0F5HUXFnPR/XvlAqcN3upS0aVYfQ3Q8MQ/XDmOwr6GVrzy1IpXbGSChzLuU8JzPNvad7QeHYfPXxYXrlvsGE+/efynzPS8IAIEAH7IsCxbh/eFChQQA4cOGCfCjm4JlyjOJi5SdA0x64xkoB3dmsihYp24wjrkw2BEmXKSb+HnpTjx47Kc7f3lTH33yGnTp2U1Ny5pXSFitKk1ZXqj0ulAEptu/WU4qXLGMIXd0Z7dmyTkqotM+z/3jIWt5OfHem+xF8iYHsEYCba7OprBSaglWrWllnvqVqeB301ZaKsWfaT3D92gjyofRzk1lQMdM1IGM+vw6q5liM16hos/FNE3fbpxkPWrCqXdAn01vnwkvB6Xy1ak9/VTuTNgSpUvC7zXgR5gWAQQsrP7xGZfKtL6Dh2jivNrSobu6SWyHuDXWV+vFSkUgmRO68UKaqajzB1xv/VqlgN3WhoNELw2OppkZm/uvKAVmMVrR80Kk2nwxtNzzKaDOs2vlCq1T1X5k2bKhAWgmZNnSxX9VAmeBDM80uWr2A8u/Ppgrj70AeM5zqCC5GIABGwPwIc6/bhETbic+s78rFj0VsC2KdV9qwJ1yj25AtrFRoCjl1jhNZ8pjIRAa9lmIk5MysiYCICV3bvI89+MEPgJ/FbFbLAoezRQ6pqpAThoielpmaNhlC6QiW5uld/1Wy8QK7tf7v8+evPcmCvqhaRiEACIPDNpx9Ksw6djZpCQxe+FT21t76c/IbUb9bCECTCl+LZF1yU0apA1zISJfjBn1tUI7BI9kZUOmNyjOvh0A9/iyxXuVyHhq67zq8sUk/No6HVCII5c8dGIotUmLlTFUHWewgtIagE/a4CRdAb/UXuuVpkkgou62seUxerhuRBNXvWvB5KEnevEHDj+Qv/id9+/pHs37NbtqxfK+c0udgFkse357M849jLlN8jOQ+JABGwEQIc6zZihlYlf/78ckQDYpFijwDXKLHHmCXEBgGuMWKDazLmSqFiMnI9wdp8cK9LC/Gsc8/XIC2z5IKWVwiigS6eE5qZn2fQilr1Ghjaihv/XJNgKLC6yYgAhIe7t22Rpwb2lAe7tpfvpn8sOVNSVFvxLQMOaO/u2PyfYKfcTSk5U6CqaGj2+rvmThvX3wIqrUuPXgsNmoCnoRLoRaXU9Bi0L8w11cZdrvs8vy+qIbJBzZhB1UqJ9FTz5xX/ujQSPct2y7/cQs68ZxQxoUV5aS2Rr1eJjJouckiVR6DxCBNq+HZc8Ifr2JeptqvUML4LqPTSZnTp1R2lcPESMkO1aueqL8XW1/ewWQ1ZHSJABMxAgGPdDBTNyQMm0IfPaIebkyNz8YUA1yi+UOG5REDA0WuMRGCAw+pIoaLDGOrE5owddqfA5wMor+689n7gEeN47aoztoT6L9QYLMfO7NqWr1rNyINfRMDOCMxWM9Eho8aqlu6XxgdC9caXt5UfZn1paHyl5s4jRUuVljVefuegMRLomi3aXKCqSEreqKtSS+WpW9S82Jv2uixtDVNk72uB/pcv6rq6WDUW3ZRLZ0oEW4Ew8OrnRW5uLnJbG30enREautO5f6uXFsmn137Z4D4jklt9JyIwzKW1RVrUFSmtQk98kEcevYZjt6Zj5l1hHqXk14qqaqRNCL4U09WeHH2xbdeeqqH4j0B7tvk11/mtIdKTiAARSCwEONbtxy8KFa3hCdco1uDMUsxHwNFrDPPhYo5BEKBQMQhAvBx/BAoUKiyTn3vciGyL2rijPjdr77IfhJYWfCqu/+M32fTP37JZF67792SqG508makNtXT+HMMHIyKSkoiAnRHYu2O7rF76o5x30aVZqtmyc1c5mXZCZr07yQhgdKH6FF06f7bs2rpZz6fJlg3rZM/2bUYaf9dOHFfpWNxJRWhnqX1wlILFcyv5Fioi2AqEgWdXyN7QY6rdCOXGk2fkV8dPutJAU/DimiJV1d/hzBWZ9y1RbcIel4jAPyMCr0BgifxX/ecSNB5Qbcj86nUBWpH79YPALUPUx6KvPK5ppFGiu2V+GqhiIcrEOW+/kJk1CPVIG1DlxlATxzzdoX17DeE3Crryxt4CrfFm7Tsbm0M4Bw2PE6ptm3ZCGaKEZ/na31bIof37tE/PMc7t362AKyENgm5BeEEiAkTAXghwrNuLH6gNzZ+t4QnXKNbgzFLMRcD5awxz8WJuwRFIeUwpeDKmIAKRIbBBV9hH3Sv3yLIwfMitWPStLPzyU9XIWirw/3BFt17SouMNRo6lK1aWH9UU+pNxY2XbvxukSImScuzIYalUo44uUssai9PlC785EyjgkNz+9EuSJ2++CGvjui1FNcEqFs4nBVLV1JREBHwgEE3f37tzhzxxSw/ZqdHNy1auIlVqq2qb0vGjR2T65PGGAP2f1SukXJVqctEV7eWnuTPlw9dekkUzPpdTJ08aJtKlyleUxi3b+r2GeyMhU/t+sfoif45V+2WXUCmS+tRWTcXRs0SubezSBHTn8cY3IiULifRu7j6T+fvAVJHFa10BVBopDIgS/edWV/Tmay8QaVZH5MWvRP7Zrn4R52u+BUVe6KFKgMVcJswTNG+kb6j3vrtIBJqJl+k9n/0sMna2Bow6X02kVRb8/Z8i73wv8j/1oQgNyOdU3pfL65Hxqd4DrcarG2TWL6KjFH2mVb9ZhYpdI7rd+6Zo+i/ymvzcSFnw+ccCjXL4wq1a52xDU/Ha/rdJoaLFZOro51TjdrqkHT8uWzeul3MvvESKq1ARpv3QZqysfX7d6lWSQyWtMJ2e9n8vq7B8q2HWf37T5hnBiLzrHey/qf03WGG8TgQSAAGO9QRgUgRVfOedd6R58+ZSpYruXJF8IhBt30em8HPNNYpPeHkyhghE03eTZo0RQ/yZdXYEcuiuP7f9s+PCMyYhsEAdlO05lqkpGEm2B1XbJb9qK0JLBdpYZStX9bmghHZLwSJFBVpYufNkNatEHrnz5o1amOiuf2rOHHKh2kOWzp81SIz7On+JgBl9PxwU9+/eZQhfYOKP6LmeFOiaZ7pQjk3v++sniSy9Q9UGz9grh1IJrzRvLtDgKhtUoNfHdQHagq2fdkVorlnWdS7cb1jh/r3NJags7RUI5vAxkQJnHjHH9fGWR4WCIPh31EdDxn+cQ11ARdQyOWakmxySVxvaXp0zpnpVNsJCre6/7mq6tWjxDPf1LHeni/TX9P4baUV4HxGwCQIc6zZhhMnVaNeundx1113Stm1bk3N2TnZm9H2uUZzTHxKpJWb03XDaG2gdEehaOGUgLd/RwkXMPulp/mwfXrAmfhCAVkuKBqdANFBoV8FfnC+CQBHkLVDEOeQRrXYi8iERAbsiAA1djA1vgSLqG+ha3NtTTbXrag6Iqhp9W6gmoGoRQoPwyHGRbqr8OKa3ZhuhQBGVgSly7fLq69CHjM4tUEQ6t0ARx/l0j8HzP85BmBhTgSIKSVEhcusFpgkUkWW8CM9v9zPc/RuvurBcIkAEYocAx3rssEXOefLkYfTn2EJs5M41igUgs4i4IxBoHRHoWtwrzgpYhgCFipZBzYKIABEgAkTAJwINXnL5V8yVVcPSZ1o/J4d1FKmowVQQpfnVPi4/hX6SOue0e4Ol/WrdOanlnHaxJUSACBABIhAVArnUh+1JdYdCIgJEgAgQASIQawQ05iSJCBABIkAEiECcEbjwDVX1U9XCNSpgPHnGZjjMKl1ZL8wbEjl5iqpFpqp2dpvv1CN/5URuCetOBIgAESACJiNAoaLJgDI7IkAEiAAR8IsANRX9QsMLRIAIEAEiYCkC5z8hcsl7LjNeCM1IvhGARmeZ1hrdZZVqKNb2nYZniQARIAJEIGkRoFAxaVnPhhMBIkAELEeAQkXLIWeBRIAIEAEi4BeBCmrH3PEfkXJXqq9AjWjs24Wq39sdfQF4pBYWafI/kRYz1GmWhp0mEQEiQASIABHwQiA1NVXS0qILlOiVJf8SASJABIgAEfCJAIWKPmHhSSJABIgAEYgbArlLiDT/XE17v9UoJ+eJROFrMW5tMLPglDwuAWvtwSKdNotUvcnM3JkXESACRIAIOAwBaio6jKFsDhEgAkTAxgjQp6KNmcOqEQEiQASSGoHiF4hctVJk+zyRFQ+J7NXjdA3vfPpUcsBiCFPTRWqpMLHO3SJ5yyRHu9lKIkAEiAARiAoBChWjgo83EwEiQASIQBgIUKgYBlhMSgSIABEgAnFAoEwrkbb62feryF+vaYhn9buYQ6evtANxqEyMi8yp7cqRKlKwikjtoS6txFwFY1wosycCRIAIEAEnIUChopO4ybYQASJABOyNAIWK9uYPa0cEiAARIAJuBIrWV3+CGiW68asimz4TWTdZZNt8NQ1W8+C0g5pKtfoSkVD/HOqNBGbfVW8Uqd5HpPDZidgS1pkIEAEiQARsgAB8Kp4+fdoGNWEViAARIAJEwOkIUKjodA6zfUSACBABpyGQU4Vwlbu6PqfVHHrbXJeQcetskWPbRXLmtbeQEZGtUcfTx0SKNRKppMFpKnbSSM61nMYptocIEAEiQATigMCpU0niJiQO2LJIIkAEiAARyIoAhYpZ8eA/IkAEiAARSCQEIGAsf7Xrg3of36E+GBeI7PpBfzXQy4E/XObE0AQ8pUK80yesa12OHKpFmV/LT3GVnbuYSInGImVaiJS8RI/VZyTMuElEgAgQASJABExEAFqKOXMyHqeJkDIrIkAEiAAR8IMAVzN+gOFpcxA4dsqZphdppxPUzNIctjKXEBBg3w8BpFgkyVNaNRi7uD5G/jpWD61X4eIa12fPctfvsS2q1bhLU+j1lHwq3FMBIChdn1npJ12/gmPV9oAJGa5DOCi6SIOAEsc59ZOO+zQPpDt1RCNVF9KAKlqHAlVEijfQ6NXnqClzHf3UFUktghISgth/E4JNrCQRiBoBjvWoIbRlBhQqBmcL+35wjJjCngiw79qTL8lcKwoVk5n7FrT9ssolZeN+XWjbjJ4Z8YC0uqq9NLmkWUQ1y5eaIqXzqwkjiQj4QSAefX/W55/K8WPHpGNX9csXI0q8vq9Cv4LVXZ/yV2VHJW2/Che3iZzYq599rl8EgIFZ9ek0Q7Ox1wMfyIAuF8iljWuqIFGDqOTUsQ8NxNxFz3xUAzF3cZF85VXY6Ixp1cr++8Btt0iXXjdLo4uaZuePyWcSr/+aDACzIwJeCFg51kcMuU2u69FTGl54sVctzP+b7GM9PT1d98LObJaZD68jcrSy74999ilpfXUHqXve+THHLtn7fswBtkEBZvXdT99/V07ouqFrn342aJW+RnN9bQs+RFIJZ6x+Imk577EEgXy5ckqdEvaLXDp0QD+58sorZc2aNVK8uAoDSETAZATi0fd/yZsiX8yZJxDSkEJEANqDQTQItx3/Ro6UuUGkbtsQM038ZFb236N7d0spldXaca5IfE6yBUQgMAJWjvWDO7dJyVzpHOuBWWLKVWoqBofRyr7/94pl0rHN5ez7wdnCFCEgYEbf3bVrlzz/8DBZuXKlVLThWj0EGJjERgjQ2YaNmMGqWIdAw4YNpUePHnLPPfdYVyhLIgIxRqBatWqyfr2a+pJMRQB+qajxYSqkWTIjvlng4B8iQASIQNQIUKgYNYTMgAg4GoHnn39ebrzxRqlYsaKj28nGWYMANRWtwZml2BCBp556SurWrSvffvutXHbZZTasIatEBMJDoHr16rJx48bwbmLqoAhgcQZTMlJsECC+scGVuRIBuyHADQTrOELzZ+uwDqUk9v1QUGIaqxDYvXu3TJw4UVasWGFVkSzH4QhQU9HhDGbz/COQP39+ee2116R///5y/Lj6TyMRgQRHoEyZMrJ//345fPhwgrfEXtXnYiC2/CC+scWXuRMBuyDADQTrOAGhYq5c1B2xDvHAJbHvB8aHV61FYNSoUdK1a1epUKGCtQWzNMciQKGiY1nLhoWCQPv27aVevXoCrUUSEXACAjSBNp+LXAyYj6lnjsTXEw0eEwEiQASiR+CYBl9ITVVntSQiQASIgAcC8KX4xhtvyLBhwzzO8pAIRIcAhYrR4ce7HYDA2LFjZdy4cUbQFgc0h01IcgRgAr1hw4YkR4HNJwJEgAgQASKQvAicOHFCcufOnbwA2Kzl1Mi3GUOSuDovvPCCdO/enb4Uk7gPxKLp1IuPBarMM6EQKFeunDzyyCMyYMAAw78iAzIkFPtYWS8EqlatKuvWrfM6y7/RIMDFQDToBb+X+AbHiCmIgBMQ4Fi3jotpaWnUVLQO7qAlUSM/KERMYAEC0FIcP368EfHZguJYRBIhQE3FJGI2m+ofgUGDBgl2deG0lkQEEhkBCBWpqWguB7kYMBdP79yIrzci/E8EnIkAx7p1fIWv8Hz58llXIEsiAkTA9ggw4rPtWZSwFaSmYsKyjhU3EwHsnsO/RMuWLeWaa66R0qVLm5k98yICliEAn4qLFi2yrDwWRASIABEgAkSACNgLgaNHj0qePHnsVSnWhggQgbgh4PaluHLlyrjVgQU7FwFqKjqXt2xZmAicd955csstt8jdd98d5p1MTgTsgwADtZjPC7hEwMYDKTYIEN/Y4MpciQARSF4EEKglb968yQsAW04EiEAWBKilmAUO/jEZAWoqmgwos0tsBB5++GE5++yzZc6cOdK2bdvEbgxrn5QIUKhoPtvT09MFZnuk2CBAfGODK3MlAnZDgD4VreMIzJ/z589vXYEsiQgQAdsiQC1F27LGMRWj6oVjWMmGmIEA/M/AgS2CtsB0hEQEEg2BYsWKGVp1+/fvT7Sqs75EgAgQASLgYAToU9E65h46dIg+Fa2DO2hJFKgHhYgJYogAtRRjCC6zNhCgUJEdgQh4IdCmTRtp1qyZjBw50usK/xKBxEAAwVrWrl2bGJVlLYkAESACRIAIEAFTETh8+LAUKFDA1DyZWeQIUKAeOXa8MzoEdu/ebQQiHT58eHQZ8W4iEAABChUDgMNLyYvASy+9ZDyA6cw2eftAIrecJtCJzD3WnQgQASJABIhAdAhQqBgdfrybCDgFgVGjRknXrl2lQoUKTmkS22FDBOhT0YZMYZXij0CpUqXk2WefNQK3LF68mEEa4s8S1iAMBChUDAOsEJIykEgIIEWRhPhGAR5vJQJEgAj4QODIkSNSqFAhH1d4iggQgWRBgL4Uk4XT8W8nNRXjzwPWwKYI9O3bV/LkySOvv/66TWvIahEB3whQqOgbl0jPMpBIpMiFdh/xDQ0npiICiY4A/cpZw0FEfgbWKSkp1hTIUogAEbAlAvSlaEu2OLJS1FR0JFvZKDMQgPbMG2+8IU2bNpVOnTpJ+fLlzciWeRCBmCMAoeKMGTNiXg4LIAJEgAgQASIQKgL0KxcqUtGlO3DggBQuXDi6THg3ESACCY0AtRQTmn0JV3lqKiYcy1hhKxGoXbu2DB48WO644w4ri2VZRCAqBBCoZcOGDVHlwZuJABEgAkSACBCBxEMAkZ+LFCmSeBVnjYkAETANAWopmgYlMwoBAQoVQwCJSZIbAUTL+u233+SLL75IbiDY+oRB4KyzzpKNGzcmTH1ZUSJABIgAESACRMAcBPbv3y8FCxY0JzPmYgoCNP03BUZmEiICiPg8YcIEYcTnEAFjsqgRoFAxagiZgdMRgF9FPJihrYhoeiQiYHcE8ubNazho37p1q92ryvoRASJABIhAkiBAwYo1jN63b58ULVrUmsJYSkgI0PQ/JJiYyCQEEPG5W7dujPhsEp7MJjgCFCoGx4gpiIA0a9ZMWrVqJSNGjCAa/8/eeYBJUTxt/D0uk5NHDqJwgKAigiJIUEEUScKnKJKUjGDCgGLOCgYMKJgwof5FCYqIqAQBEVGCZEmSc4Y7Ln1Vs+zFvbvNOzP79vPs7exMT3f1r/pmZmurukjAEgSYrMV/auIXYf+xdNUS+bqiwn0kYD8CNKwER6c0KgaHM3shATMScK6lOGrUKDOKR5lsSoBGRZsqlsPyP4ExY8Zg8uTJWLZsmf8bZ4sk4GcCNCr6Dyi/CPuPpauWyNcVFe4jARIgAe8IaPhz2bJlvTuZZ5EACViaANdStLT6LCs8sz9bVnUUPNgE9AFt7Nix6N+/P/78809ERkYGWwT2RwJuE6BR0W1UrEgCJEACJEACtiGg66kx/Nk26uRASMBtAk4vxZUrV7p9DiuSgD8I0FPRHxTZRtgQuO2221CuXDm8/vrrYTNmDtSaBGhUtKbeKDUJkAAJkAAJeEpg37590LBnLYcPH0aZMmU8bYL1SYAELEZg//79OSSml2IOHPwQRAL0VAwibHZlDwITJkxAkyZN0K1bN9SoUcMY1IIFC4x1F+0xQo7CqgQyMjKwZs0abNmyBatXr8b8+fNx1VVXYevWrca+TZs2oVatWlYdHuUmARIgARKwMAGunxoY5WkSwQoVKiA6OhppaWmIj483PBVnzpyJypUrY+jQocazQGB6Z6uuCJw6dQpPPPEEduzYYRzesGEDNHnGRx99BH1W69evH9q1a+fqVO4jAbcJtGzZElFRURg3bhwaNmyIiRMngl6KbuNjRT8SoFHRjzDZVHgQUKPMyJEjjYe0Tz75BEOGDMFXX31lvL/99tvhAYGjNCWBESNGGJnKNWN5cnIykpKS8O+//2bKWqpUqcxtbpAACZAACZBAMAlw/dTA0C5WrJjxg+HmzZuNDtTIqK+dO3can5csWYLt27cHpnO26pLAmTNnoF5j2cu2bduMjxERETh06BCNitnhcNtjAmqc3rhxo/FDQseOHY11VHv27ImqVat63BZPIAFfCTD82VeCPD8sCTz44IOG0UYv3NOmTTMY/PDDD2HJgoM2D4Hbb78d+rCqi7SrQTF7SUhIMEL3s+/jtnsElKl62LAEhgD5BoYrWyUBEggfAtdff71x/889YjU4fv7557l383OACeialm3atHHZS/HixfHII4+4PMadJOAugV27diEmJsaorj8i6A8HH374IRo1aoQ5c+a42wzrkYBfCPBbkl8wspFwIqChpVdccQV+//13nD592jAu6vj1F+Hjx4+HEwqO1WQE9EFC56YaaXIXDdln8Y6A/hqsHjYsgSFAvoHhylZJgATCh8C1116LEiVK5Blw9erVuTxPHirB2TFw4ECXOtFw1SuvvDI4QrAX2xLQ76NOo6JzkGpcXL58Odq2bevcxXcSCAoBGhWDgpmd2ImAhj8vXbrUCC3JPq6iRYsahsbs+7hNAsEmMGbMGMTFxeXoVsOhr7766hz7+IEESIAESIAESMAeBHRtNf2hO3tRjzhd148lNAQ6deoEDYPOXtSg2KtXL5c//mavx20SKIyArpeua6jmLvp9tE+fPrl38zMJBJQAjYoBxcvG7UigZs2aeYw2Ok79dUgTtrCQQCgJXHzxxXm8FdWoeNlll4VSLPZNAiRAAiQQ5gSYqCVwE6BkyZI499xzc3SgCVs0qSBLaAiocad9+/Y5Otfnsb59++bYxw8k4A0BTb6oCYGyF51z+j+vCYFYSCCYBGhUDCZt9mULApr44tZbb4VeuLOX1NRU/Pjjj9l3cZsEQkIgt7eiPnRccsklIZGFnZIACZAACZCAEmCilsDOgw4dOmSu/6trKT788MOIjIwMbKdsvUACAwYMyBECrQnzdKkaFhLwlcDq1atzLM2j//O33XYbPv74Y1+b5vkk4DEBGhU9RsYTwp2APqBNnDgRb775Zh6PxRUrVuS4wIc7K44/NATUW7F58+aZ4TW6plLukOjQSMZeSYAESIAESIAEAkGgXbt20JBnLbpWbf/+/QPRDdv0gIDqxLkms65/d8cdd3hwNquSQP4ENPOzs6ijiyZrfPfdd527+E4CQSVAo2JQcbMzOxHo168ffvvtNyOjbnR0tDE0fWD4559/7DRMjsWiBF5++eVMQ2KLFi0sOgqKTQIkQAIkQAIk4A4BTf6hkQn6LDp48OBMA6M757JOYAjo9wMNR9XQf3317t07MB2x1bAjsGPHDmPMalAcPnw4xo0bF3YMOGDzEKBR0Ty6oCQWJNC4cWOsXbsWF110kREOrSHQCxcutOBIKLLdCDi9FXVNpdatW9tteEEdD9cBCyxu8g0sX7ZOAiQQHgQ0/PH88883koPcd9994TFoC4xSvRPV0KtRI6ofFhLwlYAmaDlw4AD0Gf+BBx7ACy+84GuTPJ8EfCIQ5dPZPJkESADnnHMOFi9ebPxKNGHCBHz77bcY0v8WIGkvcOawvI443lOOyoJCkgXOeKXIu7wixK4fIV6OkTGO96hiQEwpeZUBoksDsWWB+MqOY2RNAvkRSJE55mK+vX5PE1wwZw4uLbMc+Ocpzrf8+BWyn+uAFQLIx8Pk6yNAnk4CFiHAHxC8VFQ+93hXz5RX1C+OamXroPKJb4DNfKb0krhnpxWin5blU5CUlITOzc8B1rzIZ37P6NqvdiHzxfh+WMh3xF17kwwuTzz+KB54cJT9GHFEliNAo6LlVEaBzUEgAzixGTi2Tl7rEXXoL4zvvB5NI0tgzvI5wJQK8tAQJ0acCIe4GemywE2qvPRdXtD3NHmX4xGyiLYaF6EGRt3Wl+yX9XCMeqmS2StK1siJSwCKVQfKyALPpS4AStaV9/pifBQjJIvNCeScb5D5pvMOp3cCyQcdY3cx3+rLXMuYLEbrpLeAVZxvNp8kHB4JkAAJmJoAf0DITz3e3eNdPVO+/39nnyn/vp/PlPnh9ni/7/rJ+Fw7XQSsXCJ64TO/xyqw1Am+z5fCviNWk++IPzwch/bVRwP/Ey9Ffke01Ayxo7A0KtpRqxyT/wkk7wP2zgX2S2jzvvli0FkjDwXiXVhEHt5STzu8D6XXflc4Xpm/Hhcqidx41NhYWEk5Bujr+L/Anl/FyCi/PqvxMU36jhGPxrKXAhVbA+WbA+WayjH+axeG1NTH3ZxvOcagHrCFFs63QhGxAgmQAAmQAAkEkgDv8YGk63vb1I/vDMOphRDNl/biXwJ5rDe+H/I7YjjNOFOOlZYHU6qFQoWcQHqyGO/mADumArtmiTeYGBWLiOdhynERTa/gWtwx4jhq+vev9J96IqvJJJFt10yHvOqtli4u8WUbA1U7y6srUKJOVl1umZMA55s59UKpSIAESIAESMBXArzH+0owsOdTP4Hla7fWOV/splGOxw8EaFT0A0Q2YRMCepNQI+LmSWKg+0XCl2NzGhHTQmVEdJOvc71Grb5/MYwQ2VVPiidjOaDmLUCtvhIyLeHSLOYgwPlmDj1QChIgARIgARLwNwHe4/1N1L/tUT/+5Wn31jhf7K5hjs9HAjQq+giQp9uAwBFJYrH+TWDbZEfYsLqQa9EbiJVL2ln5U3cA6151jLF4DSBxhBgZeznWabTy+KwqO+eb5TTH5AKBVRn5BpYvWycBEggiAd7jgwjbi66oHy+ghfEpnC9hrHwO3RMCulIsCwmEJ4G94o04uxnwo6xDuPkjCSk+5ViXwo400mXdRl1/8agkltHFu7+RRDLLH3RkDLbjeM04Js43y843JhcI7D8U+QaWL1snAbMQsPUPCLzHm/seT/2YWz9muUg55eB84XxxzgW+u0WARkW3MLGSrQgcWgrMvAiY3wk48LsY28SYaGRittUo8x9MykmHAXX968C0c8W4KEbG7Gs05n8mj3hDgPON882bCsTrEQAAQABJREFUecNzSIAESMBmBGz5AwLv8ea+x1M/5taP2a5xnC+cL2abkxaRh0ZFiyiKYvqBwJmDYkiU5CU/tQKOrBSvRDGuhXPR8Gj1XtzwFvBtFQn//iycafh/7JxvOZlyvuXkwU8kQAIkQALWJaD3+Hny4zSfKR06NNs9nvrJ+b9lNv3klC70nzhfcuqA8yUnD34qlACNioUiYgVbENg5TbzyzgN2SyZnNaSxZBFIFR66juSSQcDcDo5M11lHueUNAc63/KlxvuXPhkdIgARIgATMT8B5j9/zI58pc2vLDPd46ie3VrI+m0E/WdKYY4vzJX89cL7kz4ZHchCgUTEHDn6wJYFVjwELbxXD2VF5+DN5BudQKiBVPDf3zgG+awAck7UXWbwjwPnmHjfON/c4sRYJkAAJkIB5CPAe754uQnWPp37MrR/3pAteLc4X91iH6v/ZPelYywQEaFQ0gRIoQgAJ6M1i1dOO9SEC2I1tmlaja/IBYFYT4NR22wwraAPhfPMMNeebZ7xYmwRIgAQsTMDyiVp4j/ds9gX7Hk/9mFs/nkkX+NqcL54xDvb/s2fSsXaICdCoGGIFsPsAEvj7XmD1SwHswK5NZ4gR9gQwtTpwfINdB+n/cXG+ecnU/PPN8l+EvdRMsE4j32CRZj8kEFoClk7Uwnu8l5MnSPd46sfc+vFSuoCdxvniJdog/T97KR1PCx0BGhVDx549B5LAlg+BjROAdElG4mM5JsmhTyRJU+nuNZSSCqzYJhHEct4+ibhOTnHvPG9q7TwkdtMdec/UPg/7mocmIgKY09oRNp63C+7JToDzzdbzzdJfhLPPU5Nuk69JFUOxSIAEHAR4jzf3PZ76Mbd+zHYd4XzhfDHbnLSBPDQq2kCJHEIuAsn7gaUjxNvOV6sa8I9EAI/8XPK7HAFGfAycEYNhQeWPTUDb54G3ZWnCsgOBysOAnYcLOsO7Y18uBi55GJjyB1A8Nm8bA98DRn2Rd79HezLk16gzMvDlozw6Lewqc76B8y3sZj0HTAIkQALhQYD3eHPf46kfc+vHbFcJzhfOF7PNSZvIQ6OiTRTJYWQjsHYskFGI9S9b9fw2l/zrMCS+chtQuyLQvzXQ5RWxVabldwbw5BSg+2XAu3cAE/pLXhixyxURhz9fytjvc549/CPg3k+BGSNFvvZAjXNyHp/xF/Dxbzn3ef1JM2VvFq/PpL1eN2H7EznfON9sP8k5QBIgARIIUwK8x5v7Hk/9mFs/ZrtscL5wvphtTtpEHhoVbaJIDsNJQKx4m8RNL03ilX0swycBj3UVT8A4R0MX1wRKxgOfFGCwU0/FMsXO1q/huQCnJU9K9vKNeCI+Pz1rz/+WAG/+BLw3AKhSNmu/c+uQLIU4fo4YPxs79/jjXS4T2yb7oyEbtsH5xvlmw2nNIZEACZAACQgB3uPNfY+nfsytH7NdRDhfOF/MNiftIw+NivbRJUeiBE5u9YtB8fu/ge0HgZZ1c2Lt3hR4+lvpwsX6ikM+AA6IUe/dn4Hb3wWeEK/F7EXXP+wqno6dxZGykYQuPzs1a53G6cuA3uOBO2QZSA1r3i0h09q/hl4fF2fBjmMkolsMluoJWaEksEUivB/6AvhldfYeHB6Mz90EREfl3O/TpzRZHHJnLndJnxq00cmcb+B8s9F85lBIgARIIIAELJeUifd4c9/jqR9z6yeA1xKvmuZ84XzxauLwJHcI0KjoDiXWsQ6Bk/8BEdE+y7tgPVC3soQu5/oPqV7eYdDbvC9vF+Nvl65l9z3XAR8MEqNit6w6muRFDYNqpJx2HzBpsMPo+MZsR53BYpBsXgf4/E5Hn1OWAtXKAXe3B0qL56OGOuvn1TuN382hHo1qeLz6OeCH5Y421KuxhsinHpV+Lye3+b1JWzTI+cb5ZouJzEGQAAmQQOAJWC4pE+/x5r7HUz/m1k/gLyme9cD5wvni2YxhbQ8I5DKZeHAmq5KAjQms3yUegaXyDrBaWcc+Pe5JWbQR+Fvsch0vcZx1YXXgohoOr0bdo+HMnRsDC8WYuf+YGC6zGS3VUKlljRgUtUzsD9zXAfhQDJcXSxuTF4uH5HEJexYPydFdHHX411oEON+spS9KSwIkQAIkQALuEuA93l1SoalH/YSGu1V75XyxquYodyAJ0KgYSLpsO/gEiom1LiPF537VEzBdlt7IXc6R0GMtRyQi2JOy7UDe2pefD2yVMGYt50qylV4S/rziP4dHYva+I85aFZ1GzrizjpjqRdlCvBt/WgW8NAM4IctIqsejhlDr2o5z1zq2XYVqO3r14G8xsV6y5CXA+cb5lndWcA8JkAAJkIAdCPAeb+57PPVjbv2Y7RrA+cL5YrY5aSN5aFS0kTI5FCFQrCYQGeczijqVgF0SXpy7HD7p2KOhyJ6UyqUdtReLx6KzRMl/nyZbUWNgh5eBfi2BoW0Bp9HQWc/5XisBiBeD4l9bnXuAGFk7URPDtEgEWtcDEsToqS9tI1aO6bbT0zHrLA+3IouKoOIayZKXAOcb51veWcE9JEACJEACdiDAe7y57/HUj7n1Y7ZrAOcL54vZ5qSN5KFR0UbK5FCUgJjQzpP4YB8Niw2quTYqarIVNQbWr5KXdpJ4N6pzY2q641hyquNdPQWb1QZqynqHP6zIOm+JeBP2bA7o+oyaeEUNltr+qu0OQ+Mx8YYsGuvwijwq25q4ZYSsseiqjU6NJUt0j6xXI3Es1D51X+51IbMkcHdLBlDjFncrh1k9zjedY5xvYTbtOVwSIAESCAsCvMeb+x5P/ZhbP2a7SHC+cL6YbU7aRx4aFe2jS47ESaCeZDWJEDc9H8qtVwBnxCiYOyHLjL+Bbk0BZxh09i4e+crxadwsCWPeBrww3fFZszxrNub/3QXo2orDP3JkgVZvxwc7Ag3FgHmFGADv+tgRvqzrLn66ENBkLep9WEm8HC94QBKzHJHsz90codLdXwOuelZCpcXT8b7rs0vh2FZDYhG5d/pcIuOBWv3E9bGCz03ZtgHON8Nwzflm2xnOgZEACZCAXwhYLvuzjpr3eHPf46kfc+vHL1cOPzbC+cL54sfpxKayCERkSMn6yC0SsAmBLR8CS4eL2+DZeGUvhvXBXEmushV4o6/jZPUWvEayLWuG5toVHfs8/atZoDfucYQsJ+RKBHMySaK34xwtJqdI+HK0Y1vXd1SDjfOz7lVZtJQq6ngPyF9dzDFOBnqDLM4YnUvYgHRo4UY533xXnonnW7t27TBy5EjoO4v/CZCv/5myRRIwIwHL/q/zHu/7dArkPZ76Mbd+fJfOvy1wvvjOM5D/z75LxxZCQICeiiGAzi6DQOBc8a6rPdCnjm5vDVQuI5mZfwVOJQM93gDG9fHeoKjCqAdhYmVZ69CFjc5pUNR62Q2I8TE5P+txNSYG1KConUTKYo3XzKVBUVkUVjjfCiNU+HETzzdLetcUTtw0NcjXNKqgICRAAq4I8B7viopn+wJ5j6d+PNOFq9qB1I+r/kK5j/PFd/rhNF98pxUWLdCoGBZqDtNBNnrFsb5ilBjHvCyjOgNVJcRYszS/2dexTqGXTVnnNP31ScsNq4ESdRzb/Fs4Ac63whm5qmGB+ZYuLsZ06nelPP/sI1//cGQrJEACASTAe7x3cIN1j6d+zK0f76QL3FmcL96xDdb/s3fS8awQEvBt4bkQCs6uScAtApdNlJTJEsK7TgyMqWdjht06MatS+4uytm2/FSlukdGyiGPb+ZIlprrth+v3AXK+eYaU880zXqxNAiRAAiQQOgK8x3vGPtj3eOrH3PrxTLrA1+Z88YxxsP+fPZOOtUNMgJ6KIVYAuw8CgQufBpp/7gjj1Qsii2sC6tFZ4RqgwyrxUEx0XYd7CyfA+VY4I63B+eYeJ9YiARIgARIwDwHe493TRaju8dSPufXjnnTBq8X54h7rUP0/uycda5mAAI2KJlACRQgCgSoSx9x5k6RSbi9rBUpG47MRvkHo2fxdKI/okkDTdyTd9PeygGOC+WU2u4Scb/lriPMtfzY8QgIkQAIkYH4Cznt8xWv5TJlbW2a4x1M/ubWS9dkM+smSxhxbnC/564HzJX82PJKDAI2KOXDwg60JxJQDWk6T0N55kuWkocNTytYDLmRwkbGOh+FESWfddSdQ87ZCTuBhjwhwvuXExfmWkwc/kQAJkAAJWJeA3uNbTeczpVODZrvHUz9OzTjezaafnNKF/hPnS04dcL7k5MFPhRLgmoqFImIF2xEo2wS4fiWw92dgxWjgsGxnSHrn9DTbDdXlgNSFHRlAHTEm1r0XiKvgshp3+okA5xvnm5+mEpshARIgARIwGQHe40UhJn6mpH7MrR+T/TuD84XzxWxz0iLy0KhoEUVRzAAQqHA10E5eR5YDG96SFM+y7mKE/EukHAtAZyFusoiMKyIaKF4DSLzL4ZUYVTzEQoVZ95xvllV4kSJFEOHMeGfZUZhXcPI1r24oGQmQgJsEeI93E1SIqlE/IQJv0W45XyyqOIodKgI0KoaKPPs1D4HSF8t6gpIl+tI3gR1Tgc2TgD2/SGiwhAenHBc55RdYi5UdB4Eq58QgokgkoC79NW8BavUFSta32EhsKK4N55uhJf1/iZAVNWw439LT05GRYb3rgFX+e8jXKpqinCRAAoUS4D2+UEQhrUD9hBS/5TrnfLGcyihwaAjQqBga7uzVjASKiFGk+s2OV7qEQ++Z4zAy7v4RSNoLFIkzt5FRM1urjOlJ+C+1DnqOPYl333kLdRtfZ0balMlG8w1lGgPVJBlS1a6SObwOdUsCJEACJEACeQiElVcy7/F59G+qHW7oZ922Y6hb2VRSZwmT7Zmfz2BZWAK25cZ8MbUjCudLwKYGG3YQoFGRM4EEXBHQm0flDo6XHk/eJ2swzgUOLJJ3SfRybK0jnFg9s9KSxJB3xlUrgdmnYZiRRaV/8ULUvmPKAOUuBSq0Bso3l+0muELCuG+KeQstru2FYcOG4eGHH0ZsrIyJxZwELDTfBr4fiZF9mqLOJTdkzjdj2QBzkqVUJEACJEACJiEQtl7JFrrHu3qmtP093oV+vv7gBTz5zsdY9UY10z/z214/Jrl+ZYrhYr7k/o6YlhGFfcciUKmkfD802XdEzpdMTXLDjwRoVPQjTDZlYwKxCeLBeJPjZQxTQiFPbJEHjXWO16G/He9Ju8Sr8YDUkOOR8WL4EwOglox0eaU63qHbkhRGQiqN42ochBgn1UCp2xqynKHnSRtaL+2UZKouIQlVRIZiNYCyjSR79QUSylxXXvWA6FLaQ56ixsQbb7wRd999Nxo0aIB3330XV111VZ563GFCAiaebz0SluHKW27B1KnPo1ndZiaER5FIgARIgARIwMQEgnCPP3UmAjHRkYiKlq96fnimNDFNv4qmhu/RT76Gzz6bgh9+mA/U12WD5Hnc5M/8foXAxjwjkOv/effuXWjZ4goM690Od7eU72om/I7o2QBZmwQKJ0CjYuGMWIMEXBAQo1/xWo5X5evzHk85KsbFPcCZw/I64njXBDAaVp2e4vjVKl2MjGp0LKJhy5JERd/VAzGm9NmXeCDGlAXiJfZCE8h4USpVqoQvv/wS33//Pfr164c2bdrg5ZdfxjnnnONFazwldATMM9/UMP3xxx+jY8eOeO+999ClS5fQYWHPJEACJEACJGB5Av6/x48d/zOOn0rDS48N9NszpeUxFzKAY8eO4eabb0ZSUhL++usvlCsna5Ibxf/6CcQzfyHD4+EgENi/f79817oK/QcOwd0PPui6R5N8R3QtHPeSgHcEvLNUeNcXzyKB8CGg3oP5eBCGAkKHDh2wdu1aPPnkk4bX4vPPP28YGZnRNhTaCECfQZ5v1157LX766SfovNqzZw8GDx4cgEGZp8mwWgcsBNjJNwTQ2SUJkIB1CHhxj2/Z9RI8qEYNXeuYpVAC+ozcuXNn47lmzJgxiIzUKCI3ixf6cbNlVrMQgUOHDhkRYbdINI/xv5ef7Jwv+ZHhfgsTkHhLFhIggXAgULRoUbz44ouYPXu2EQrdqlUrrFsn4dssJOAFgUaNGmHRokV47bXXMGrUKFtnRw7bdcC8mBfenEK+3lDjOSRAAiSQP4HLL78ca9aswalTsoQOS4EEpk2bhiuvvBKPP/44Xn31Vc8MigW2zIPhQuDo0aNo164d+vfvb8yjcBk3x0kCTgI0KjpJ8J0EwoTARRddhMWLF6NHjx5o0aIFHn30USQnS1g2Cwl4SKBmzZrGXJo7dy569+6NlBQJ7WchARIgARIgARIIKQFNzqfPe/rjH4trAhkZGXjiiSdw55134scff0TPnj1dV+ReEiiAwPHjx9G2bVuos8Zdd91VQE0eIgH7EqBR0b665chIIF8CGm44dOhQrFq1CuvXr8eFF16IX375Jd/6PEAC+REoU6YMfv31V+hD1XXXXYcTJ07kV5X7SYAESIAESIAEgkRAjRzz5s0LUm/W6kafVTTc+eeff8ayZcvQuHFjaw2A0pqCwMmTJ41n3yZNmmDs2LGmkIlCkEAoCNCoGArq7JMETEJAE7l89dVXRgirJnJRbzNdZJiFBDwhEBcXh2+++QaJiYlGCNGuXbs8OZ11SYAESIAESIAE/EygZcuWmD9/vp9btX5zGzduRNOmTVGtWjXjB/WEhATrD4ojCDoBTejTqVMnXHDBBXjrrbeC3j87JAEzEaBR0UzaoCwkECIC6mGmi1RXqFDBuDl+8MEHtl4jL0SYbd2ter/qQ9Wtt96Kyy67zFjLydYD5uBIgARIgARIwMQEmjdvbmQxPnPmjImlDK5oM2fOxBVXXIH777/feGaJjo4OrgDszRYEdNkoNShWrVoV48ePt8WYOAgS8IUAjYq+0OO5JGAjAprI5eWXX8acOXMyE7mooZGFBDwhoA/qL730krG2jF08JJid2JMZ4Hld8vWcGc8gARIggcIIFCtWDPXq1cOSJUsKqxoWx5977jkMGDAAM2bMgEbnsJCANwR0/fBu3bqhbNmyUCcMfYZhIYFwJ8D/gnCfARw/CeQioOsrOhO5aOiMZsNjIpdckPixQAK33HKLEVavD11ff/11gXWtcJDZiQOrJfINLF+2TgIkEL4EGAIN6Lp3w4YNw/Tp0/Hnn39CM2OzkIA3BFJTU3HzzTcjJiYGn376KTOFewOR59iSAI2KtlQrB0UCvhHQX900kcvKlSuxbt06NGjQgIlcfEMadme3adPGmDP33nuvsWZn2AHggEmABEiABHIQoFdyDhxB+RDuRsXNmzcbS7Loj+MaPaFribOQgDcENFt4r169jGWidD36qKgob5rhOSRgSwI0KtpSrRwUCfiHgD58ffnll5mJXPRmykQu/mEbDq00bNgQixYtwoQJE6DGRX0gYyEBEiABEghPAvRKDr7er7zySuM+nJaWFvzOQ9zjTz/9ZHglqpfie++9Z3iXhVgkdm9RAvr82qdPHxw8eBCjR4+mQdGieqTYgSNAo2Lg2LJlErANgQ4dOhiJXNTIqFnO3n//fRqIbKPdwA5EF7FWw6KGHGnICEPpA8ubrZMACZAACZCAk0CZMmVQq1YtLFu2zLkrLN7HjBmD3r1745tvvsGQIUPCYswcZGAIqEFx4MCB2L59O6ZNm4bY2NjAdMRWScDCBGhUtLDyKDoJBJOAJnLRBByayGXixIlGIo7169cHUwT2ZVECpUuXNuaNit+2bVscPXrUoiOh2CRAAiRAAiRgLQKtWrXCb7/9Zi2hvZT29OnTuPPOO/HFF19g6dKlaNGihZct8TQScBDQ+aSJK7/77jvEx8cTCwmQgAsCNCq6gMJdJEAC+RPQRC7qedajRw9oWM1jjz1G77P8cfHIWQK6qLWG0jdp0gRXXHGF8Ysv4ZAACZAACZAACQSWgD6rzZ07N7CdmKD1bdu2oVmzZjh+/LhhRNVICRYS8IXAyJEjoclZZs2aBc2mzkICJOCaAI2KrrlwLwmQQAEEsidy0V/vmMilAFg8lEkgIiICY8eOxaBBg4x1jjQRkBUKkwsEVkvkG1i+bJ0ESCC8CWiylgULFth62Zpff/3VSMjSr18/TJo0CXFxceGtdI7eZwIPP/ywkXDwxRdfRPHixX1ujw2QgJ0J0KhoZ+1ybCQQYAIVK1bE//73PyZyCTBnuzU/YsQIvP7667j66qstkVWcyQUCOwPJN7B82ToJkEB4E6hQoQISEhKwatUqW4LQ54lbbrkFkydPxl133WXLMXJQwSXw5JNPGuHOmuxHl/BhIQESKJgAjYoF8+FREiABNwi4SuTixmmsEsYEunfvbiygrslbPvvsszAmwaGTAAmQAAmQQGAJ6LqK8+bNC2wnQW49KSkJffv2xYcffoglS5agTZs2QZaA3dmRgK4frwZqXUO+XLlydhwix0QCfidAo6LfkbJBEghPArkTubRu3Rrr1q0LTxgctVsEdJ2n+fPnY9SoUdDwEhYSIAESIAESIAH/E9AQaL3f2qXs2LHDWNdbDYuLFy9GjRo17DI0jiOEBNTrdcKECdBwevXuZSEBEnCPAI2K7nFiLRIgATcJOBO53HTTTUbWPSZycRNcmFarV6+e4WGg3oqaYU9DYVlIgARIgARIgAT8R8BOnoqaybpp06bQ50zN8syMvP6bJ+Hc0vjx443lnDSpUaVKlcIZBcdOAh4ToFHRY2Q8gQRIoDACzkQuun6PJnK54IILLLF2XmHj4vHAENCHt4ULFxpzpVu3blDPAxYSIAESIAESIAH/EKhWrZqRbGLDhg3+aTBErajh58Ybb8RHH32E+++/P0RSsFu7Efjggw/w/PPPGx6KzBpuN+1yPMEgQKNiMCizDxIIUwJqLNJELuPGjYNm5OvVqxf2798fpjQ47IIIlChRArNmzYKG0WsCl4MHDxZUPajHNGu1GspZAkOAfAPDla2SAAmQQHYCLVq0sOy6imfOnIGuwfzWW2/h999/R7t27bIPjdsk4DUBjZR5/PHHDYNizZo1vW6HJ5JAOBPgt6Rw1j7HTgJBInD99dcbXmhqZFSvRV1UOyMjI0i9sxurEIiOjjaStuhi65dffjm2bNliCtF1rjIsO3CqIN/AsWXLJEACJOAkYNUQ6N27d0NlT01NNZZLqVWrlnNIfCcBnwh89dVXhserZnk+77zzfGqLJ5NAOBOgUTGctc+xk0AQCWRP5KKLIDORSxDhW6yrZ555Bvfddx+uuOIK/PXXXxaTnuKSAAmQAAm4IkCvZFdUgrfPisla1CuxSZMmuOGGGzBlyhQUK1YseMDYk60JTJs2DcOHD8fs2bNRt25dW4+VgyOBQBOgUTHQhNk+CZBADgK5E7k8+uijSE5OzlGHH0hg8ODBePfdd40QJw2LZiEBEiABErA2AXolh1Z/tWvXhoYRb9u2LbSCuNn7+++/j06dOhnPAo888oibZ7EaCRROYObMmRg4cKCx7E6DBg0KP4E1SIAECiRAo2KBeHiQBEggEATUW2HYsGHQRC7r1683QqJ//vnnQHTFNi1MQL9MfPfdd+jTpw8mTZpk4ZFQdBIgARIgARIIPYHsIdCHDx/G8uXLQy9ULglSUlJw5513YsyYMdBMzx06dMhVgx9JwHsC+n3j9ttvN54vGzVq5H1DPJMESCCTQIT8asiFzTJxcIMESCAUBPQXw6FDh+LKK6/Eq6++ivLly4dCDPZpUgIbN27EtddeayT7Uc/WQBf9onXHHXfg0KFDRlc7duxAmTJljLArXVtRjZx6nMU7AuTrHTeeRQJWJ6DJNUaOHMkkGyFS5N69e/HEE09gwYIFOHHiBHbt2gU14GlitLJly4ZIqpzd7tu3D927dzfk+fjjj1GyZMmcFfiJBDwg8PfffyO74XD+/PlG9vDp06cbS+x40BSrkgAJFEAgqoBjPEQCJEACQSGgiVzWrFljPOw2bNgQzz77rGFAUo9GFhLQkK0lS5YYhsXt27dj/PjxiIyMNMDo9hdffAFdZDsmJsYvsDRhzLfffuuyLc0CXaFCBRoVXdJxbyf5useJtUiABEjAHwR0zTj9MUx/KIuNjcXx48czm9V7mv5oFsxy+vRpI3mfJlwpXbp0ZtfLli1D165djee/J598MnM/N0jAGwIdO3Y0vBEXL15sJP9btGiRYbD++uuvaVD0BijPIYECCDD8uQA4PEQCJBA8As5ELvrwq2vpuUrkopn/XnnlFcyYMSN4grEnUxA455xzDO+K//77z1hjKSkpyTAmakKXpUuXGkZFfwlavHhxXHfddS6b03l6//33uzzGne4RIF/3OLEWCZAACfiDwIYNG6Ae4rqeYnaDoratnoDB/gFX10nW5CsanaIyafnkk0/Qvn17jBs3DjQoGkj4xwcC//zzD5zLKl199dXQBJFdunTBZ599Zny/8KFpnkoCJOCCAMOfXUDhLhIggdAS0BBT9UB7/PHHMWTIEIwePdr4dV1/xW7WrJnxAKzr7OhDKUt4EVDDsi6ufeDAAcOQqMZFLVWrVsWWLVsQFeUfB/ypU6eid+/eeb6AJSQkQEPIWHwjQL6+8ePZJGBFAgx/Dp3WrrrqKuOHOb2HZi/nn38+dImRYBUNu65evbph5IyPjzc8x+rXrw9NyqLZeHWbhQR8JdCtWzfoc4Z+n9CiERLvvfee8Vzna9s8nwRIIC8BeirmZcI9JEACISag4Ti5E7moQfGWW24x1v/RX7Z1jT1de4clvAio0VC9E9Wj1WlQVALqhaEerv4qGpKf+8uXPpTq4t4svhMgX98ZsgUSIAEScJeAegK6WiKkcuXK7jbhl3rq6a/hz1r0fcqUKUb0iUYc0KDoF8Rh34guk/P9999nGhQViK4dOnjwYCPbc9gDIgASCAABGhUDAJVNkgAJ+IdApUqV8NVXXxnhMOqdpouKO4v+2q2GRX1QYAkfAjt37oRmr3SGTDlHfvLkSYwaNQrHjh1z7vLpXb98de7cOUdYmBo01XuRxXcC5Os7Q7ZAAiRAAu4SqFKlCsaOHWskHMt+To0aNbJ/DOj2X3/9hY8++ijHD4KnTp2C7l+9enVA+2bj4UPgueeey2FQdI5cjdi6tI1+f2AhARLwLwEaFf3Lk62RAAkEgMCFF15oLOqthiNnUWPi+vXrjV8enfv4bn8C1apVM7wSMzIy8gxW58QTktnSX6V///7Q9f+cpWLFiqhXr57zI999JEC+PgLk6SRAAiTgAYFBgwYhMTERGg2iRddSPPfccz1owfuqGoaq0SbZIwycrek+Nfbs2LHDuYvvJOAVAU1GpIZrVw4HxYoVg3rmunp+9KoznkQCJJBJgEbFTBTcIAESMCuBvn37unxA0F8dNfOvrpPCEh4E/v33XzRv3hxxcXF5Qrn0i4muxanJXPxR2rRpk9mM9jdgwIDMz9zwnQD5+s6QLZAACZCAuwTUiPjll19m3jt1TUP1YAxGef3116GRBq6KJkDTBDKrVq1ydZj7SMBtAq+++mqeuvrjsK4d+vnnnxtzUI2LLCRAAv4lQKOif3myNRIgAT8T0LAYzeAWGRnpsmUNnRk+fDj++OMPl8e5014EatWqhfnz5xueq6p3fVjM7k2o6yDeddddfhm0enP07NnTmHv6y/Ztt93ml3bZiIMA+XImkAAJkEBwCahx5bHHHoMa8nSdYF1mJtBFjYmacC97tElsbKyRgK9hw4Z4+eWXjeRr6q3IQgLeElBHg9deey3TG1aNhzrfNeOzJiPq1KmT0bTTU9fbfngeCZBAXgI0KuZlwj0kQAImInDJJZdg5cqV0DVSNHNk6dKlDS+1EiVKZEqpHmq6viKz8mYisf1GzZo1MWbMGGioy8SJE9GoUSOo14WWmTNn4s8///QLA/WSVYO2hoxp6DWLfwmQr395sjUSMDMB/TKv3nIsoSXwwAMPoGrVqobxJRiJWu644w5jHWRdl1gNPZr9WY2MGzZsMJ7vhg4dinLlyoUWCnu3PAGNWtIflnWO1a5dG5MnT85hTLT8ADkAEjAxgQjxvsi7MJWJBaZoJEACJKDhrYsWLcIvv/yCX3/9FVu3bjUMP8nJyVi55zD0wdVOpWhUJGqUchjM7DQuX8ZyOjUdW4+eytHEpg3r8PE7b+F/H3+EGrXOww9/LM9x3NsP9cuXwPCHRmPIyAe9bcLt82yn65QjQNJe4Mxhecm2vqccBdLPnH2lIOKCh/HUnVfh0SHtgMgYWegrGoiS8KSYUvIqA0SXBmLLAvGSpVSPsZAACViSgP4wOHLkSOMHQksOIARCu7rX+UOMHdu2ol3jhpi1dAWqn1vLH026bGPJgvno17UDiklUwY239kJXedVt0BC2u9e5HL21dwZq7gWKysVVyhtNv/r+x2jT/vp8u+HcyxcND5CA1wRoVPQaHU8kARIwCwENgV66dCmW7j6KWo2amEUsv8rRolo5JBQVgwuLQeDHzftxMiXVJY3k06dw+MB+VKwWvKyWLgXxcqe1dC2/S57YDBxbJ6/1wKG/HO+nZe2s5IMOApFxmhHAsZ2RDmSI3ox32YZ+TpN3OR4hSxxEaACFvIxt/Sz7jd8+pV6qGJGjJHFOXAJQrDpQphFQ6gKgZF15ry/GRzFCspAACZiWAI2KnqumoHud562F5oy1f/2BuvJslttL1Vr3utCwC2WvVpt7+3ZsR0JV9yJKOPdCObPYtx0J2Mudx44a4phIgAQKJaBrA7Vq1QoZ2w7gUFJKofWtViG6CMPFcussNjJCjIq59zo+x8YXtaxB0fS6Tt4H7J0L7F8I7JsvBsQ1YvgTY3cRMQCmnnZ4H+ZWi3olFlrEOKnGxsJKyjHxdJTX8X+BPb86PBrVAJkmfceIR2PZS4GKrYHyzYFyTUU2PuYUhpTHSYAEzEugoHudeaXOKVm9S+RanKuY/l6XS95w/Gi1ueeuQZFzLxxnM8ccaAJ82g40YbZPAiRAAiRAAlYlkJ4sxrs5wI6pwK5Z4n0oRsUi4nmYclxGJIZAo7hjNDxb1a9v0n/qiawWk0S2XTMd8qp3ZHqSGBkbA1U7y6srUKJOVl1ukQAJkAAJkAAJkAAJkAAJ+EyARkWfEbIBEiABEiABErARATUkqhFx8yQx0P0i6xzG5jQipoXKiOgmY+d6jVp9/2JHSPaqJ8WTURIB1LwFqNVXQqYlXJqFBEiABEiABEiABEiABEjAJwI0KvqEjyeTAAmQAAmQgE0IHFkOrH8T2DbZETasYcZa1Mho5ZJ2Vv7UHcC6Vx1jLF4DSBwhRsZejnUarTw+yk4CJEACJEACJEACJEACISKgK6KzkAAJkAAJkAAJhCuBveKNOLsZ8KOsQ7j5I0dCFKdB0W5M0mXdRl1/8agklvn7fuCbCsDyBx0Zqu02Vo6HBEiABEiABEiABEiABAJMgEbFAANm8yRAAiRAAiRgSgKHlgIzLwLmdwIO/C7GtlNnMzGbUlr/C5Vy0mFAXf86MO1cMS6KkTH7Go3+75EtkgAJkAAJkAAJkAAJkICtCNCoaCt1cjAkQAIkQAIkUAiBMwfFkCjJS35qBRxZKeslinEtnIuGR6v34oa3gG+rSPj3Z+FMg2MnARIgARIgARIgARIgAbcJ0KjoNipWJAESIAESIAGLE9g5TbzyzgN2SyZnNaSxZBFIFR4a9r1kEDC3gyPTddZRbpEACZAACZAACZAACZAACeQiQKNiLiD8SAIkQAIkQAK2JLDqMWDhrWI4OyoGRZNncA6lAlLFc3PvHOC7BsAxWXuRhQRIwC8EIiIiUKQIv3r4BSYbIQESIAESIAGTEOCd3SSKoBgkQAIkQAIkEDACalBc9bRjDcGAdWKjhtXomnwAmNUEOLXdRgPjUEggdAQyMjKQnp4eOgHYMwmQAAmQAAmQgN8J0Kjod6RskARIgARIgARMRODve4HVL5lIIKuIkuFI3DK1OnB8g1WEppwkQAIkQAIkQAIkQAIkEDQCNCoGDTU7IgESIAESMCOBlDNnsG/HdqgXzdGD4p3mZtm1ZZObNUNYbcuHwMYJQLokI/GxHJPk0CeSpCk3HY1SUoEV2ySCWM7bJxHXySk+ClDA6TsPid10R94K2udhX/PQSMgm5rR2hI3n7YJ7SIAESMAyBI4fOeyWrKkpKdi9bYvLugUdc3kCd5IACZAACdiaAI2KtlYvB0cCJOAugW8mvIGel5yP7vWq4LHe3TCs3RV4cdjtWDRrhrtNsJ4FCXz26gt45NbOmPTSkxjUpgnuvqE1Th4TC1gBZefmf3Fv52vw5O09CqhlgkPJ+4GlI8TbzlerGvCPRACP/FzyuxwBRnwMnBGDYUHlD7G3tn0eeFuWJiw7EKg8DNjp3nfZgprNc+zLxcAlDwNT/gCKx+Y5jIHvAaO+yLvfoz1ibMYZGfjyUR6dxsokQAIkYDYCT/S9CXoPK6gsm/czBl3VBJ/L/TF3KehY7rr8HL4E+EwdvrrnyMOTAI2K4al3jpoESCAXgRsHDkfdS5qiVLnyeOrjKXjzx4U4p0o1jL17EH6fPTNXbX60A4G9O/7DN++Ow32vvYv7x72Hl77+AbHx8Ti8f1+Bw6tS63xceUOXAuuY4uDasUBGIdY/NwRdIt8/1ZD4ym1A7YpA/9ZAl1fEVpmW/8lPTgG6Xwa8ewcwob/khRG7XBFx+POljP0+59nDPwLu/RSYMVLkaw/UOCfn8Rl/AR//lnOf1580U/Zm8fpM2ut1EzyRBEiABEJJYMOKv7B13Wr8+IVc0AsojVtdjbqNLkVkVFSeWgUdy1OZO8KWAJ+pw1b1HHiYEqBRMUwVz2GTAAnkJVCsRElEnM1MqVkqb+gt1hApy+bNyVuZeyxPYNXiBcYYDuzaabyXLn8Ougy4U4yKhRuOoqJjMsevYdPmKyLTpvfEmifxyj6W4ZOAx7qKJ2Cco6GLawIl44FPCjDYqadimWJn69fwXIDTkicle/lGPBGfn561539LgDd/At4bAFQpm7XfuXXoBDBe/m27NHbu8ce7PDJtm+yPhtgGCYQlAWZ/Dq3aZ3/5CWrWvQC/fvMlkk/LuhQuiibS0VdkZBRUX9lLQcey1+M2CSgBPlNzHpBA+BCgUTF8dM2RkgAJeEjAufaQPhhp+XvBr3i8T3c8M6AnHuh+Hf5ZssjY/+nY59Dr0kRMfOphbF69EkOvuRz9WzbC8t/mIjnptJzzf5jwxENGXf4xD4FGLa9CETEiPz+kD/74eZYh2DXdbzU8Vvft3IFHe92IEde1NPbP/uITQ6efvSIxvWdLelqahE0/hb7NGhjh8uoFYppycqtfDIrf/w1sPwi0rJtzZN2bAk9/K124WF9xyAfAATHqvfszcPu7wBPitZi96PqHXV8BOosjZSMJXX52atY6jdOXAb3HA3fIMpAa1rxbQqa1fw29Pi7Ogh3HSES3GCzVE7KC/FtukQjvh74AflmdvQeHB+NzNwHReR1tclb05FOafAnfmctd0pPzWZcEwpwAsz+HbgKcPH7MCHse9MQLOHXiOObP+CaHMKqbT8Y8i5dHDMDzg3tj1ZKFmccLOpZZiRskUAgBPlMXAoiHScDCBGhUtLDyKDoJkID/CaihSJN1rP5jMcY/dj9Kli2HTv0G47+N6/HS8P4Y8sxYjJ74GRq3vsYwLu7Zvg3dBo2QX/bTUKlGTdS64EK069EbKcnJaHBZc8TGxRsh1Z1uH+x/YdmiTwTKVaiEO0Y/Yxh+df3McQ8MR1paKqJjYpBQpSqaXt0ex4+IBUxKux69UDahgvFlzNnpoX17UL5iZYx6+yMjycukF550Hgr9+8n/gIhon+VYsB6oW1lCl3M9LVQv7zDobXYRKT7+dulaer7nOuCDQWJU7JYlhiZ5UcOgGimn3QdMkn8LNTq+MdtRZ7AYJJvXAT6/09HnlKVAtXLA3e2B0uL5qKHO+nm1OJeqf6h6NKrh8erngB+WO9pQr8YaIp96VPq9nNzm9ybZIAmQAAkEmsD86VNwZYcuqHNxY1SrnYhZn0/K0eXMT97HumV/4IE33sNDb39kHHN6KhZ0LEcj/EACuQjwmToXEH4kAZsSyPU1waaj5LBIgARIwE0CmqTj7dH3YfHs73HTsHuMtRXLVqiIn776FJVr1kLFao5YztZd/g8pZ5Ix99uvEF+8OJq174jFsxxeTOUrVcaJo0cMT0X1CDgtr4rVa7opAasFk0D7W/vihS+/h66TOE++dOki9qdPiJudFDUuZi/R0TkzgSTImpsdJES+7iVN0KX/MKxf/ieOHRa3OhuV9bvEI7BU3gFVOxtyrMc9KYs2isev2OU6XuI468LqwEXyL6VejVo0nLlzY2ChGDP3HxPDZTajpRoqtawRg6KWibI6wX0dgA/FcHmxtDF5sXhIHpewZ2lrtAWWvHSMgn9JgARIIPAEfpVnlSs73mh0pB75urbi+r//zOz4u0kTcfGVrY2QZ11LsX6Ty906llmJGyTgggCfqV1A4S4SsCEBfwYG2RAPh0QCJBBuBEqUKYtR43P+gq8M9u2U9LfZSoWq1Q0vRuf+q7v1wOieXbHnv634RdYrOr/hxVDPgEP79qL59Z2znclNsxA4fvgQVN/nNbhQkrTMwmsjh2HpLz8aBuWrbry5UDGzL2Jf56JGhrfitvXr0PDy5oWeG/AKxcRal5HiczfqCegqhPgcCT3WcsT1slyOgy7+bjuQd+fl54tH41zH/nMl2UovCX/ueqnDIzE9I6u+c3kvp5EzLtpxTL0oW9QBvhYPxZdmACeSAPV41KJrO2o9DafWhDGRvv6UWkyslywkQAIkYCECajw8uGcXnh3Uy5A6XTzyi0RGirfiR0iUhCy6TIs+y6j3vrNEFokUl/OIAo856/KdBPIjwGfq/MhwPwnYi4Cvj9f2osHRkAAJkEA+BMolVMR/G9Yi6VSWFUWNSuUk/FVLvcaXSfjzuXj/2UdlXyXcOPBOMVDNxi9TJqPZteJOxWI6Am+Muhu6zpSWuKJF0efBx4ztf1edjaOVT+7mYHHOi8o1zzXaCPmfYjXFghbnsxh15DvmLgkvzl0On3Ts0VBkT0rl0o7ai8Vj0Vmi5ElEk62oMbDDy0C/lsDQtg5joLNO9vdaCUC8GAr/2pq1N0Z+ItXEMC0Sgdb1gAQxeupLDYqxcky3nZ6OWWd5uBVZVATl/7KH1FidBEggxAR+nDwJI156Q7zyvzNe+iPapW3aYdGs73D00EHxyo9F6XMSsC6b56KKrOHPBR0L8bDYvYUJ8Jnawsqj6CTgggCNii6gcBcJkEB4EjgmnmunxMiUJusq5i4tbuhiZERcsXCucUh/9T+yf594IXbKrNpGvNv+mvczOvYZKGsutjUMVdXr1ENsvBgjWExHQBPwTHrxKUOvKpwz6/OVomst6rWhaypuWfsPdmzaiJ1bNskXsCxXu9TULE9ANSDrGoxOI7PRQEj/iAntPHXN882w2KCaa6OiJltRY2D9KnkHmSTejepgmJruOJac6njXpC7NagM1Zb3DH1ZknbdEvAl7Ngd0fUZNvKIGS21/lTgHq6HxmNjxi0rkuXpFHpWXJm4ZIWssumqjk4ROP98j69VIHAu1T92Xe13ILAnc3ZIB1LjF3cqsRwIkkIsAsz/nAhKEj4clWmL10t/Fg75Fjt7UGz815QxmffahkbDsMrl/qaf+gd07ZX8Kdm3djEN79xh18jt2Jlku0CwkkA8BPlPnA4a7ScCGBCKfkGLDcXFIJEACYUhgq1gcTjstGR6O/+vxr2PB91NxRsKA9krylURZzDy+WPHMVs6pXBXFSpTA5NdeQvLp05Il8RnccteDaNzq6sw6FapVN4xPHfsNMkKL1EjVqlM36BqLvpRI8RaoWjIexaIlHInFIOCLrp0IdU2pFQvnYcF334qHxlLomlPXSpKd1p3/z6iSICHuv8vamt+8+4YR1l6qXHnxVD2JaufXFYNjRcMTVTOC//z1ZJw+eQLDnnvFSMzjbN+bd7/quszFwPo3JLWyWPm8LIniqfj6LKCLhCOrJ6CzTPwVKF8C6CNehbnLg5OBxf86Eqg0FsdNzRK9frcje3OXJsCVdYGxM4FNe2VdxF+kXfk3G9NTnADLAD+tknUVpW2tf4mc+9lCQD0TW8k5U/+UhC4/StKcCyVEWr4f/7Ye+PQ34J2fAfWAfFHsfVG5/kW+lXPUq7FDo9xSevg5Ml4E6SdGxcLD4j1smdVJIGwIfPLJJ2jWrBnOO++8sBmzrwP15V53WH74fHpAT+zfuUPWda6BGonixi0l+fQpzJg0wfjBbNPqFUaUxeXX3oA/5vyAr956BQu/n4a0VEeItD77XHpVu3yPaYSGN8Wv9zpvBOA5hRLwZe7xmbpQvKxAArYiEJEhxVYj4mBIgATClsBcWbDtUFKW91ggQOjD+N4d26EGRM3snLtoGKyG0mrJvp27niefo4tE4DKJD00omjNxiCdt2K2uP3R9/MhhFBVvRc1OqN4ZmkzHme0yOy9NulO8VGmoV0ZMbE7PP20jJi7O5VzI3oa7237X9ZYPgaXDxW3wbLyyu4Jkq/fBXEmuslUMen0dO9Vb8JrnHBmaa1d07PP0r2aB3rjHYahMyJUI5qQ4vxQ7izlZ/p1jxSioRdd3lH+FzM+6T2XRUiqQzsBi1EecDPSGtbLAZC5hHd3zLwmQgBsE2rVrh5EjR0LfWdwj4I97nXs9OWodPXjAWC9an1/ii2X7JUkOF3TMkz60rt/vdZ4KwPqFEgjG3OMzdaFqYAUSsAQBhj9bQk0UkgRIwCwENJS5eu3EfI1IToOiypt92yzyU44sAiVKl0GkLFavWZ7V28KVQVFrq0FRS26Dou7TNlwZl/WYKcq54l1Xe6BPotzeWjwBxYtQPQhPJQM9xPlxXB9p1kuDogqjociJ4sCb26Cox5wGRd12GhR1O15s6tk/6z41JgbUoKidRMoX62vm0qCoLFhIgARsTUA98vVemNugqIMu6JitoXBwASPAZ+qAoWXDJBBUAjQqBhU3OyMBEiABEiCBIBNo9IpjfcWonF4nnkgxqjNQVZKpbN0PvNnXsU6hJ+dbsq56KGq5YbVYj+s4tvmXBEiABEiABEiABEiABEggk4DkRGQhARIgARIgARKwNYHLJoqrn7gWrhMDY+rZmGEPB9z+Ig9PsHL1SHGLjBYP1bbzJUtMdSuPhLKTAAmQAAmQAAmQAAmQQMAI0FMxYGjZMAmQAAmQAAmYiMCFTwPNP3eE8arRjMU1AfXorHCNZHeRrDElEl3X4V4SIAGPCRSRdQ/yW2bC48Z4AgmQAAmQAAmQgCkI0KhoCjVQCBIgARIgARIIAoEqEsfceRNQqb2sFSiJhs5G+AahZ/N3oTyiSwJN3wFafy8LOEraaRYSIAG/EUiXDE3MD+k3nGyIBEiABEiABExBgEZFU6iBQpAACZAACZBAkAjElANaTpPQ3nmy8n5DwIe1FoMkcWC7iYx1GFgT7wS67gRq3hbY/tg6CZAACZAACZAACZAACdiEANdUtIkiOQwSIAESIAES8IhA2SbA9SuBvT8DK0YDh2U7Q9I7p6d51IxlKxvG1AygjhgT694r6dorWHYoFJwESIAESIAESIAESIAEQkGARsVQUGefJEACJEACJGAWAhWuBtrJ68hyYMNbkuJZ1l2MkMeDlGNmkdB/chSRcUVEA8VrAIl3ObwSo4r7r322RAIkQAIkQAIkQAIkQAJhRIBGxTBSNodKAiRAAiRAAvkSKH2xrCcoWaIvfRPYMRXYPAnY84uEBkt4cMpxOU28+qxYVP4IWe1Fw75r3gLU6guUrG/FkVBmErA0AU3SoslaWEiABEiABEiABOxDgEZF++iSIyEBEiABEiAB3wkUESNc9Zsdr3QJh94zx2Fk3P0jkLQXKBJnbiOjZrZWGdOTgDKNgWqSnKZqV8nkXMd3NmyBBEjAawKapEWTtbCQAAmQAAmQAAnYhwCNivbRJUdCAiRAAiRAAv4loAbGyh0cL205eZ+swTgXOLBI3iXRy7G1jnBi9QRMEyNe+hn/9l9Qa+L1hMii0n+ko++YMkC5S4EKrYHyzWVb1ozUMG4WEiABEiABEiABEiABEiCBgBDg03ZAsLJREiCBUBBISrOnB0RKukXDTgM4CajrAMItqOnYBPFgvMnxMurJ3DyxRYyL6xyvQ3873pN2iVfjAakhxyPjxbgnBkAtGfI/mpHqeIduS1IY9VzS42ochBgn1UCp20XklaHnSRtaL+2UZKouIQlVRIZiNYCyjSR79QUSylxXXvWA6FLaAwsJkAAJ2IYA73W2UaXlBsK5ZzmVUWASCBkBGhVDhp4dkwAJ+JtAq+rlse2oGB5CVH798QfMnzMbj7/8ql8liI+OREJRCelkySQQCl2P6NMTr7w/CVFRgbt1Wk/XYvQrXsvxqnx9pn4yN1KOinFxD3DmsLyOON4lAcwHX83D9l0H8fjQ1mJUFCOjGhWLyBwvIklU9F09EGNKn32JB2JMWSC+stQLHPtMmblBAiRAAiYhEMx73RsvPItrOnREvYYXBnz01rvXBRyJ6Trwde498+B9qFKjJvoNHW6qsXHumUodFMYmBPh0bhNFchgkQAJic4gqgrrlQpfJtVKHdnhw8B14/83XUbSoGEVYAkYgFLpev2o5ip8+gpo1awZsXLZrWL0HXXgQLtn2Fy66qAVQf6jthswBkQAJuCagSVo0WQuL+wSCea/buGIZOrdtE9LnKPfJsGagCfgy92bPno2FP8/G2rVrERcnaxyzkAAJ2JqAxBixkAAJkAAJ+INAqVKl0LRpU/z000/+aI5tmIxA5cqVsWuXhPWy+Exgw4YNqFtXwpZZSIAEwoaAJmnRZC0sJEAC9iWQnJyMIUOGYMKECTQo2lfNHBkJ5CBAo2IOHPxAAiRAAr4R6NKlC2bMmOFbIzzblASqVKmCPXsklJfFZwLqvZCYmOhzO2yABEiABEjAPwToSeofjuHeylNPPYUmTZqgbdu24Y6C4yeBsCFAo2LYqJoDJQESCAaBTp06Ydq0aZJ7QpJPsNiKQMWKFbFz505bjSkUgzl69ChOnz4NNdKykAAJkAAJmIMAPUnNoQcrS7Fu3Tq88847eO2116w8DMpOAiTgIQEaFT0ExuokQAIkUBCB6tWro2rVqli0aFFB1XjMggQY/uwfpemXjtq1a/unMbZCAiRAAiRAAiRgCgKDBg3Cs88+C/0RloUESCB8CNCoGD665khJgASCRKBz586Gt2KQumM3QSKgRkWGP/sOW42KXE/Rd45sgQSsRoDhtebWGPVjbv2YXboPP/zQiEIYOHCg2UWlfCRAAn4mQKOin4GyORIgARLQdRW/++47grAZgUqVKjH82Q86Xb9+PerVq+eHltgECZCAlQgwvNbc2qJ+zK0fM0t36NAhPPzww0ZyFjVOs5AACYQXAf7Xh5e+OVoSIIEgELj44otx8uRJaDIKFvsQYPizf3Spnop16tTxT2NshQRIgARIgARIIKQERo4ciR49ekCff1lIgATCj0BU+A2ZIyYBEiCBwBNwhkDTIyvwrIPVg3oq7t69O1jd2bYfhj/bVrUcGAmQAAmQQJgRWLBgAWbPng29t7OQAAmEJwF6Koan3jlqEiCBABPQLNDTp08PcC9sPpgEypcvj+PHjyM5OTmY3dqqLw2v27JlCxITE201Lg6GBEiABEiABMKNQGpqKgYPHoy33noLxYsXD7fhc7wkQAJnCdCoyKlAAiRAAgEg0KZNGyP8ed++fQFonU2GigC9FX0jv2nTJijDmJgY3xri2SRAApYjwEQgllMZBSaBAgm89NJLqFWrFjQ6h4UESCB8CdCoGL6658hJgAQCSCAqKgrXXXcds0AHkHEomq5atSpDoH0Az9BnH+DxVBKwOAEmAjG3Amn0Nbd+zMvCvokAAEAASURBVCbd5s2bMXbsWMNL0WyyUR4SIIHgEqBRMbi82RsJkEAYEWAItP2UXbFiRWaA9kGtNCr6AI+nkgAJkEAACdDoG0C4Nmx66NCheOihh1C9enUbjo5DIgES8IQAjYqe0GJdEiABEvCAwPXXX4958+YZmaA9OI1VTUyA4c++KWf9+vVcT9E3hDybBEiABEiABEJK4KuvvjJ+YL3nnntCKgc7JwESMAcBGhXNoQdKQQIkYEMCJUuWxOWXX25kxbPh8MJySJUrV8auXbvCcuz+GPSGDRvAjOj+IMk2SIAESIAESCD4BI4dO4a7774bEyZMgC71w0ICJEACNCpyDpAACZBAAAl07doVM2bMCGAPbDqYBOip6BvtNWvW0FPRN4Q8mwQsS4Br9llWdRScBDIJPProo+jYsSOaNWuWuY8bJEAC4U2APy+Et/45ehIggQAT0AcvfQBLS0tDZGRkgHtj84EmQE9F7wkfPHgQqampqFChgveN8EwSIAHLEuCafZZVHQUnAYPAn3/+iS+//BJr164lERIgARLIJEBPxUwU3CABEiAB/xPQbME1atTAwoUL/d84Www6ARoVvUfOJC3es+OZJEACJEACJBBKAvrj+MCBAzFmzBiUKVMmlKKwbxIgAZMRoFHRZAqhOCRAAvYj0LlzZ0ybNs1+AwvDEalRce/evWE4ct+HTKOi7wzZAgmQAAkEigDD0wNF1h7tvvnmmyhdujRuu+02ewyIoyABEvAbARoV/YaSDZEACZCAawJdunThuoqu0Vhub7ly5XD06FEkJydbTvZQC8zMz6HWAPsnARIggfwJMDw9fzbhfmTnzp14+umn8c4774Q7Co6fBEjABQEaFV1A4S4SIAES8CeBCy+8EGfOnMHq1av92SzbChEBJmvxDrxmfq5fv753J/MsEiAByxOgJ5zlVcgBhCmBu+66C8OGDUOdOnXClACHTQIkUBABGhULosNjJEACJOAnAgyB9hNIEzTDdRW9U4JmfuYXEu/Y8SwSsAMBesLZQYscQ7gR+OGHH7By5Uo88sgj4TZ0jpcESMBNAjQqugmK1UiABEjAFwI0KvpCz1zn0qjouT5SUlKwbds2nH/++Z6fzDNIgARIgARIgASCTuDUqVMYMmQIxo8fj5iYmKD3zw5JgASsQYBGRWvoiVKSAAlYnEDLli2xceNG7N692+IjofgMf/Z8Dvz7779GFvTo6GjPT+YZJEACJEACJEACQSfw1FNPoXnz5rj66quD3jc7JAESsA6BiAwp1hGXkpIACZCAdQn07t0bV155JQYMGGDdQYSp5Pv378fvv/+OXbt2YerUqdizZw+KFy9uGIlPnz6NTZs2IS4uLkzpFD7sb7/9Fh9++CGmT59eeGXWIAESsAWBAwcO4KabbsKxY8eM8ezduxclS5ZEfHw8NBS6T58+0LXaWEJDQL3QnnjiCezYscMQYNGiRYY3eUJCAvTrYb9+/dCuXbvQCMdeQ05A1wFv1aoVdOkSnRMsJEACJJAfgaj8DnA/CZAACZCAfwl07NjRMKzQqOhfrsForVatWoiIiEBaWhrUiJj997jSpUvToFiIEpj5uRBAPEwCNiRQtGhR/Prrry5HFhkZiT///NPlMe4MDgFNIPfyyy/n6EyXqdCi97tDhw7RqJiDTvh80GecgQMH4tlnn6VBMXzUzpGSgNcEGP7sNTqeSAIkQAKeEbjuuuuwYMECnDhxwrMTWTvkBF566SXDs0Y9O7IbFFWw66+/PuTymV0ANSoy87PZtUT5SMC/BNSo2KlTJ5eNqmf3Pffc4/IYdwaHgP4g1qZNG5edqSc+E3O4RBMWO99//33jR1Q1LLKQAAmQQGEEaFQsjBCPkwAJkICfCOhDeosWLTBr1iw/tchmgkXg9ttvh3rW5C6q0/bt2+fezc+5CKxdu5aZn3Mx4UcSCAcC6plfokSJPEMtVaoULrnkkjz7uSO4BNRo5Eo/UVFRxnItwZWGvZmBwMGDBzF69GhMnDjR8Fg1g0yUgQRIwNwEaFQ0t34oHQmQgM0IMAu0NRUaGxuL+++/31gLLPsINBxak/CwFExg3bp1qFu3bsGVeJQESMB2BK699lrD4yn7wDSLrP5QwxJ6AupJqmHQ2YsaFHv16kWDUnYoYbStHsSq/4YNG4bRqDlUEiABXwjQqOgLPZ5LAiRAAh4SUKPizJkzjVBaD09l9RATGD58eB4JNLyvRo0aefZzRxYBTc6gX1LLlSuXtZNbJEACYUFAM75369YNRYpkfeXQbU1cxhJ6AnoPy+1trz+i9e3bN/TCUYKgE5g7dy709YQk8GEhARIgAXcJZN3h3T2D9UiABEiABLwmUKlSJZx33nmYN2+e123wxNAQ0HA9DRVTLxtn0XB2loIJ0EuxYD48SgJ2J6BeicWKFcscZrVq1VC7du3Mz9wILYHcIep6r2vUqFFohWLvQSegHqv6jPPWW2/l+H8NuiDskARIwHIEaFS0nMooMAmQgNUJMATauhp86KGHMkPC9Esyk7QUrktmfi6cEWuQgJ0J6BIRzjVp4+PjoUYsFvMQaNeuXWb0hP5odscdd5hHOEoSNAIvvviikVCtY8eOQeuTHZEACdiDAI2K9tAjR0ECJGAhAjQqWkhZuUStWLEiunfvboTz6iGup5gLkIuP9FR0AYW7SCCMCGi4s67RpoZFXYe2Z8+eYTR68w81e4g6Q9PNr69ASPjvv//i9ddfxxtvvBGI5tkmCZCAzQnQqGhzBXN4JEAC5iPQoEEDw9tt1apV5hOOEhVK4PHHHzf0l5GRweQjhdICNmzYgHr16rlRk1VIgATsSqBPnz7GdVPvf5UrV7brMC07LvVOVC/F6tWr4/zzz7fsOCi4dwSGDh2KRx99FLo0AQsJkAAJeEogytMTWJ8ESIAESMB3Ak5vRWbX851lwFpIOQIk7QXOHJaXbOt7ylHUzjiDEkWjcPT4aeCfp4AI+X0uIhqIlLUW9T1K1g6LKSWvMkB0aSC2LBAvX6L1WBiWtWvXok6dOmE4cg6ZBMKIQD7XS6RLZmF5NY5PQWpqKm5uVR5Y8yKvl8GeGoXop2X5FCQlJaFz83Oon2DrJsT9TZ48GZpQ7c477wyxJOyeBEjAqgQixNMiw6rCU24SIAESsCqB+fPnY+TIkfjjjz+sOgQbyC23vxObgWPr5LUeOPSX4/30TiD5oGN8kXFiDIxwbGekAxmp8tJ3eUHf0+RdjkdEykud/9XAqNv6kv3GLVbqpZ4SY2NxIC4BKFYdKCOL4Je6AChZV97ri/FRjJA2LMnJyShZsiROnTqVuaaaDYfJIZFAGBDg9dLcSqZ+zK0fc0p39OhRJCYmYvr06WjatKk5haRUJEACpidAo6LpVUQBSYAE7EhA15VKSEjAypUrUaVKFTsO0XxjSt4H7J0L7F8I7JsvBsQ1YvgT78IiYgBMFa9D9agJWhGDo3o0qvExTfqOEY/GspcCFVsD5ZsD5eThPsL6wQQa4n/zzTdjzRphzUICJGAdArxemltX1I+59WMR6YYMGWIsS/D2229bRGKKSQIkYEYCNCqaUSuUiQRIICwI9O7dG82aNYM+1LEEgEB6MrBnDrBjKrBrlngfilGxiHgephyXzkzqpF9EjJzqHZmeJEbGxkDVzvLqCpSwZvjw119/jc8++wzffvttABTMJkmABPxGgNdLv6EMSEPUT0CwhnOjGinTqVMnrF+/HqVK2TNaIpz1y7GTQDAJ0KgYTNrsiwRIgASyEZgyZQomTpyIWbPE4MXiHwL6xUuNiJsniUHxFzHQxZrbiFjYqFV+DauOKQfUvAWo1VdCpiVc2iLlmWeewcmTJ/H8889bRGKKSQJhRIDXS3Mrm/oxt34sLJ1GyzRq1AgPP/wwevToYeGRUHQSIAEzEKBR0QxaoAwkQAJhSUCNLRUrVsSuXbtQokSJsGTgt0EfWQ6sfxPYNtkRNpxyzG9Nm6ahIhIOrcleitcAEkeIkbGXY51G0wiYVxD1xr3mmmug7ywkQAImIcDrpUkUkY8Y1E8+YLjbXwTGjh2LH3/8EbNnz/ZXk2yHBEggjAnQqBjGyufQSYAEQk/ghhtuQN++fdG9e/fQC2NFCfaKN+KKR4DDKyVkWLwUjcQpVhyIhzJHy3qMmgSmjmRrrHuvJICp4GEDwanepEkTvPHGG7j88suD0yF7IQESyJ8Ar5emvl6C+jG3fvL/z7LUkR07dhheikuWLEGtWrUsJTuFJQESMCcBGhXNqRdKRQIkECYEJkyYgHnz5hnrzoXJkP0zzENLgd/7Ayc3SXjzSf+0acVWNDxaM04nDgMaPG46z8XixYtj586dXK/JinOLMtuHAK+XDl2a9XpJ/ZhbP/a5Ehgj6dKlCxo3boxHH33UZiPjcEiABEJFgEbFUJFnvyRAAiQgBPbs2YN69eph//79iIqyfrbfgCv1zEExJt4O7P7JkTU54B1apIOoeEdodFPJ4FijpymEVmOifnHROc5CAiQQAgJ6vVzcz5GwSrPMszgImOV6Sf24npFm0Y9r6Sy9d/r06bj//vuxatUqxMRIYjgWEiABEvADAXFvYCEBEiABEggVAV1TMTEx0fBWDJUMlul35zRg2nliUJTENvyCnFNtqWIw0HUklwwC5nZwZLrOWSPonzSjpM5tFhIggRAQcF4v9/zI62Vu/Ga4XlI/ubWS9dkM+smSxjZbuo73sGHDoBEyNCjaRq0cCAmYggCNiqZQA4UgARIIZwKdO3fGtGliMGPJn8Cqx4CFt4rh7Kh8QT6Tf71wP5IqoeB75wDfNQCOrQspjXXr1qFu3bohlYGdk0BYEuD10j21h+p6Sf2YWz/uSWe5Wo8//jiuuuoqtGrVynKyU2ASIAFzE6BR0dz6oXQkQAJhQIBGxUKUrF/AVj0NpJ4qpCIPGwTU6Jp8AJjVBDi1PWRQaFQMGXp2HM4EeL30TPvBvl5SP+bWj2fSWab2ypUrMWnSJGjWZxYSIAES8DcBGhX9TZTtkQAJkICHBOrXr4+4uDisWLHCwzPDoPrfktl49UthMFB/D1EyQ6eeAKZWB45v8HfjbrW3ceNGY71QtyqzEgmQgO8EeL30kmGQrpfUj7n146V0Zj8tIyMDAwYMwAsvvIDy5cubXVzKRwIkYEECNCpaUGkUmQRIwH4EOnbsiKlTp9pvYL6MaMuHwMYJQHqyL60Y5x4TJ8cTSdJUuntNpaQCK7ZJBLGct08irpNT3DvPm1o7D4nddEfeM7XPw74mto6IAOa0doSN5+0ioHvWrFmDOnXqBLQPNk4CJHCWAK+X5r5eUj/m1o+NLyS6hmJsbCzuuOMOG4+SQyMBEgglARoVQ0mffZMACZDAWQIMgc41FZL3A0tHiLedr1Y14B+JAB75ueR3OQKM+Bg4IwbDgsofm4C2zwNvy9KEZQcClYcBOw8XdIZ3x75cDFzyMDDlD6B4bN42Br4HjPoi736P9oiHAs7IwJeP8ug0XyufPn0ae/fuRc2aNX1tiueTAAkURoDXS5j6ekn9mFs/hf1/Wfi43odHjx6N8ePHW3gUFJ0ESMDsBGhUNLuGKB8JkEBYEGjevDn+++8/bN8eujXwTAV6raz7k1GI9c8NgZf86zAkvnIbULsi0L810OUVsVWm5X/yk1OA7pcB78qP+hP6S14YscsVEYc/X8rY73OePfwj4N5PgRkjRb72QI1zch6f8Rfw8W8593n9STNlbxavz6S9Xjfh6Yma+bl27dooUoSPGZ6yY30S8JgAr5fmvl5SP+bWj8f/cNY54d577zU8FC+44ALrCE1JSYAELEeAT/uWUxkFJgESsCMBNb5oCDSzQKt2xYq3Sdz00iRe2ccyfBLwWFfxBIxzNHRxTaBkPPBJAQY79VQsU+xs/RqeC3Ba8qRkL9+IJ+Lz07P2/G8J8OZPwHsDgCpls/Y7tw7JUojj54jxs7Fzjz/e5Xa/bbI/GnKrDSZpcQsTK5GAHwjwemnu6yX1Y279+OFf0KRNzJkzBwsXLoRmfWYhARIggUASoFExkHTZNgmQAAl4QKBLly747rvvPDjDplVPbvWLQfH7v4HtB4GWdXNy6t4UePpb6cLF+opDPgAOiFHv3Z+B298FnhCvxexF1z/sKp6OncWRspGELj8ry2A612mcvgzoLRFGd8gykBrWvFtCprV/Db0+Ls6CHcdIRLcYLNUTskJJYItEeD/0BfDL6uw9ODwYn7sJiI7Kud+nT2myOOTOXO6SPjVY8MnqqZiYmFhwJR4lARLwnQCvlzD19ZL6Mbd+fP8PNGULycnJGDRokBH2HB8vv6SykAAJkEAACdCoGEC4bJoESIAEPCHQtm1bLFq0CEePSmaQcC4n/wMion0msGA9ULeyhC7nutNVL+8w6G3el7eL8bdL17L7nuuADwaJUbFbVh01HqphUI2U0+4DJg12GB3fmO2oM1gMks3rAJ/f6ehzylKgWjng7vZAafF81FBn/bx6p+GLCfVoVMPj1c8BPyx3tKFejTVEPvWo9Hs5uc3vTebXID0V8yPD/STgZwK8Xpr7ekn9mFs/fv53NEtzzz33HBo1aoTrrpOHGRYSIAESCDCBXF+1AtwbmycBEiABEsiXQNGiRdG6dWvMnDkz3zo84D6B9bvEI7BU3vrVzoYc63FPyqKNwN9il+t4ieOsC6sDF0l4tHo1atFw5s6NgYVizNx/TAyX2YyWaqjUskYMilom9gfu6wB8KIbLi6WNyYvFQ/K4hD1LW6O7OOpY+S+NilbWHmUPRwK8Xppb69SPufVjJuk2bNiAN998E+PGjTOTWJSFBEjAxgRoVLSxcjk0EiAB6xHo1KkTpk+fbj3B/SlxMbHWZaT43KJ6AqbLcla5yzkSeqzliEQEe1K2Hchb+/Lzga0SxqzlXEm20kvCn1f85/BIzN53xFmrotPIGXfWEVO9KFuId+NPq4CXZgAnZBlJ9XjUEGpd23HuWse2q1BtR68e/C0m1ssglAzJOK3hz3XriksnCwmQQGAJ8Hpp7usl9WNu/QT2vzMkrWvYs66jWLly5ZD0z05JgATCjwCNiuGnc46YBEjAxATUqPjDDz8gJcV3o5qJh1mwaMVqApFxBddx42idSsAuCS/OXQ6fdOzRUGRPSuXSjtqLxWPRWaLkLqrJVtQY2OFloF9LYGhbwGk0dNZzvtdKAOLFoPjXVuceIEbWTtTEMC1kCcLW9YAEMXrqS9uIlWO67fR0zDrLw63IoiKouEYGoWgG8zJlyqB48eJB6I1dkECYE+D10tzXS+rH3Pqx2eXjk08+wbFjxzBs2DCbjYzDIQESMDMBGhXNrB3KRgIkEHYEEhISUL9+fcydOzfsxp41YDGhnSfxwT4aFhtUc21U1GQragysXyWrR+dWkng3qnNjarpjT3Kq4109BZvVBmrKeoc/rHDWBpaIN2HP5oCuz6iJV9Rgqe2v2u4wNB4Tb8iisQ6vyKOyrYlbRsgai67a6NRYskT3yHo1EsdC7VP35V4XMksCd7dkADVucbeyT/UY+uwTPp5MAh4S4PVSr5HmvV5SP+bWj4f/biaufvjwYYwcORITJkxAZGSkiSWlaCRAAnYjQKOi3TTK8ZAACVieQNeuXRkCXU+ymkSIm54P5dYrgDNiFMydkGXG30C3poAzDDp7F4985fg0bpaEMW8DXjgbia5ZnjUb8//uAnRtxeEfObJAq7fjgx2BhmLAvEIMgHd97Ahf1nUXP10IaLIW9T6sJF6OFzwgiVmOSPbnbo5Q6e6vAVc9K6HS4ul43/XZpXBsqyGxiHwf9blExgO1+onrYwWfm3KnARoV3aHEOiTgRwK8Xho/vJj2ekn9mFs/fvxXDGVTDz74IG666SY0biy/ULKQAAmQQBAJRMjaRy5WnAqiBOyKBEiABEggBwFdZLtNmzbYuXNnjv1h92HLh8DS4eI2eDZe2QsAH8yV5CpbgTf6Ok5Wb8FrnnNkaK5d0bHP07+aBXrjHkfIckKuRDAnk4BicY4Wk1MkfDnasa3rO+oXXudn3auyaClV1PEekL+6mGOcDPQGWZwxOpewAekQRthVYmIiRowYEaAe2CwJkEAeArxe5kHi8Y5AXi+pH4/VkeeEQOonT2fW2rFo0SL83//9H9auXYuSJWXNFBYSIAESCCIBeioGETa7IgESIAF3CNSpUwclSpTAsmXL3Klu3zrnindd7YE+je/21kDlMpKZ+VfgVDLQ4w1gXB9p1kuDogqjHoSJsv55boOiHnMaFHU7uwExPibnZz2uxsSAGhS1k8hiYkWdGzSDonapRvF69cQ9k4UESCB4BHi99J11IK+X1I+59eO7dCFrITU1FQMGDMDrr79Og2LItMCOSSC8CdBTMbz1z9GTAAmYlICGscTGxuKpp54yqYRBFGvJAGDbZJ88FmfJOojVJVRZDX3nBScKOIiAXHSlHh0aiNBlmyzqWN1FhcDtqlq1KhYuXIgaNf6fvbuAk6rq/zj+3SSlSxRQUUDE4CEUBRSRkhDEbgGxwMDAeKw/j2KLySMmygOKRUoZSCiICoggGJSidMfC1v+cOyxsuezu1L13Puf1Gmf2zr0n3me8y/z2RJ3wFULOCCCQvwD3y/xdCjoayfsl/VNQT+T/XiT7J/8auProk08+qS+//NLZ5M/VFaVyCCDgWwGCir7tWhqGAAJeFrBTWW688UYtXJhtVxAvNyjYuv/4gLT0WRNY3D9nONj8/Hx9ghkWmWQWcWw3QzrMbCkdwbRz507ZzYZ27dqlOPtFkIQAApEX4H5ZePNo3C/pH3f3T+FrF/UzV69e7ayhOG/ePB111FFRrw8VQACB2BQwk7hICCCAAAJuEzjttNP0999/a9UqM9KMJJ00SDpjZGAar/0SSMpfINFMd65+jtR5UcQDirZCdpMWu54iAcX8u4ejCEREgPtl4Zijdb+kf9zdP4WrnSvOuummmzRgwAACiq7oDSqBQOwKEFSM3b6n5Qgg4GKBeLNwX9euXTV27FgX1zLCVTviPOm8381Wyh3NWoFmR2MGwh3sAOuRZBZnb/5fs930RDPPu9rB9yL4atmyZU5QMYJFUhQCCOQnkHW/rNGB+2VuHzfcL+mf3L1y8Gc39M/B2rj21ccff6zly5frzjvvdG0dqRgCCMSGAEHF2OhnWokAAh4UOO+88wgq5u63ZLMwYmsTaG33ldnl5ETJjjSJ5ZRQIhAwqN9P6mF2Cz/qiqhq2JGKDRo0iGodKBwBBPYL2PvlmeO4X2Z9IFx2vxT9k9UzgWe39U/O2rnqJ7vUSP/+/TVs2DAlJZnFokkIIIBAFAVYUzGK+BSNAAIIFCSwZ88e1ahRQytXrlTFihULOjV231v3ubTw39KWH83GJGZ754z02LBwgqlmI5Z6JpjYYIBU0h27z1x44YXq2bOnLrnkktjoB1qJgJcEuF+66n6Z56ND/7i7f/J0WPQO3H777dq2bZvefPPN6FWCkhFAAIH9AgQV+SgggAACLhbo3r27bKDm8ssvd3EtXVC1rQukX16WVpp1F+MSpdTtLqhUiKsQb9oVZ0YklDW7Kte/NTAqMbFsiAsJLrtTTjlFw4cP18knnxxcRlyNAALhE+B+GT7bUORM/4RC0bd5zJ8/Xx07dtSSJUtUubIZjUxCAAEEoixAUDHKHUDxCCCAQEECb731liZNmqTRo0cXdBrvZQlkmNGKf46Rlg+X1n5hpgab6cGpO8y7ZlSfF5Otf5xZqcROkzvqUumYa6RyDV3ZkoyMDJUuXVpbtmxRqVJmjUcSAgi4W4D7Jf0TSQEP/T6LJEtRysrMzNSpp56qfv366aqrrirKpZyLAAIIhE2AoGLYaMkYAQQQCF5g48aNqlu3rjZs2KDkZHY9LpKo/cK89rNAkPHvKVLKOim+pLuDjHZna1vHjBSpYhOpltmc5sgeZifnekVqejROtgvGt2nThh3Lo4FPmQgEK8D9MljB8F5P/4TX1yO5v/TSS/rggw/01VdmXWkSAggg4BIBgoou6QiqgQACCPyTwFlnnaV77rnHme7yT+dwvBACe9dL66ZLG782z+Yf5Nt/DkwntiMB000QL2NfITIJ0SlxcWYUZWlTfkKg7GSzZmblplL1s6QqZ5jXzcx7Zrqzh5IdUfvcc89p6tSpHqo1VUUAgXwFuF/my+Kag/SPa7oiUhVZu3atTjjhBM2ePZsN0SKFTjkIIFAoAYKKhWLiJAQQQCB6Ak8//bR+//13DR06NHqV8GXJZkr0zhUmuLg08Ng8P/Cc8pcZ1bjRtNi8n2Cm8doAoE2ZGeaRFniWfW02hTFTfp33bXBQJjhpA5T2dbx5ZNrrTB72vPTdZqfqw8yGKtW0JaOm+r60Vjdd211tOphRiOWOl5LK2xI8nWxAccWKFXrhhRc83Q4qjwAC+QlE7n45df4uVSpfRk1POFwqU0eq1Fgqf4K5V5qd5X1yv8xPOLhjgf759quxeuzZN/TKLfVVs8Rq87ssvL/P6J/geq0oV1988cU67rjj9J///Kcol3EuAgggEHYBgophJ6YABBBAIDiB3377Ta1bt9aaNWtM/Gp/gCu4LLm6MAKp28wXsrXSvi3msTXwbDeAsdPQMlIDIxszTJDR9kl8snmYTVTssx2BmFxh/8OMQEyuJJWqac47OPLwxx9/1DnnnKMJEyaoefPmhamN68+5/vrrnQ1abrrpJtfXlQoigECIBUJ4v/xzU4ZOadxUc+bM0bHHHhviivo3uwULFqhdu3YaP368TjvttJwNDWH/5P59lrMgfgqHgJ0BYH/H/vzzzypZ0iyRQkIAAQRcJHDwG46LKkVVEEAAAQQOCtgvVRUqVNB3332nZs3MtFhSZATs6MEwjSA86aSTZDfhsbt7z507V7Vq1YpMm8JYyi+//CI7koKEAAIxKBDC++WR5u8y9957r26++WZNmWLWwyUdUuCPP/5Qly5d9Oqrr+YNKNqrQ9g/h6wMJ4RUICUlxQko2r4loBhSWjJDAIEQCZh5WiQEEEAAAbcLnHfeeRo7dqzbq0n9iiDQuXNnDRw4UN26ddOuXbuKcKU7T7UjKOrXr+/OylErBBDwlMBtt90mu4ac3ZSCVLDAjh07ZH+f3HXXXTr//PMLPpl3PScwaNAgZ8fn9u3be67uVBgBBGJDgOnPsdHPtBIBBDwuYKeBXXfddVq0aJHHW0L1cwv07dvX+fI8ZswYxcd7829927Zt0xFHHKGdO3fmbh4/I4AAAsUS+Oabb9SzZ08tW7ZMhx1m1qQl5RFITU11NnFr1KiRnn/++Tzvc8DbAvaz37JlS/3000+qXr26txtD7RFAwLcC3vz24tvuoGEIIIBA/gKnnnqqNmzYoOXLl+d/Akc9K/DKK684wbi7777bs21YunQpu1F6tveoOALuFGjRooUzAu/f//63Oyvoglr16dPHCbjajbJI/hOw/fvII48QUPRf19IiBHwlQFDRV91JYxBAwK8CdoMWO02WKdD+6+HExER99NFHzuL6r7/+uicbSFDRk91GpRFwvcCTTz6p0aNHy25CQsopYINNdtmJkSNHenaUe84W8VN2Abvu8t69e3XDDTdkP8xrBBBAwHUCBBVd1yVUCAEEEMhfgHUV83fxw9GKFSvq008/1QMPPKDp06d7rkkEFT3XZVQYAU8I2Hvj4MGDZZeJyMjI8ESdI1HJESNG6J133tHEiRNVurTZ2YbkK4FNmzY5ay4PGzaMgLGvepbGIOBPAYKK/uxXWoUAAj4UaNu2rebPn6/Nmzf7sHU0qW7dunrvvfd00UUX6ddff/UUiK1vgwYNPFVnKosAAt4QuOaaa5ScnCwbYCFJX3zxhQYMGOD8Iapq1aqQ+FDAbrpz+eWX65RTTvFh62gSAgj4TYCgot96lPYggIBvBUqWLCkbWLQjE0j+FDjzzDP1+OOP69xzz9WWLVs808glS5aw87NneouKIuA9ARtQtGsrrl+/3nuVD2GNFy9erIsvvthZMqN+/fohzJms3CIwc+ZMTZ06VXbXZxICCCDgBQGCil7oJeqIAAII7BdgCrT/Pwq9evXS+eefrwsvvFBpaWmub3B6erp+//131atXz/V1pYIIIOBNgYYNG8puWmFHcMVqWrt2rbNxzUsvvaRWrVrFKoOv221/59s1FG0fly1b1tdtpXEIIOAfgbhMk/zTHFqCAAII+FvAjl475phjtG7dOmc6mL9bG7uts2uHde/eXTVq1HD9lD879blDhw7sTB67H1dajkBEBHbv3q3jjz9eb7/9ttq0aRORMt1SyM6dO51Aoh2leM8997ilWtQjxAKPPfaYvvnmG2fjthBnTXYIIIBA2AQYqRg2WjJGAAEEQi9gF60/+eSTNW3atNBnTo6uEYiPj9eoUaM0d+5cPfvss66pV34VYZOW/FQ4hgACoRawG5LYEVx2JNe+fftCnb1r87Ojwe3I9ebNmxNQdG0vBV+x5cuX65lnntHLL78cfGbkgAACCERQgKBiBLEpCgEEEAiFAFOgQ6Ho/jzKlCnjrJ/59NNPa8KECa6tMEFF13YNFUPAdwJdu3aVnQptgy+xkm666Sanqa+88kqsNDkm22n72Y5CrV27dky2n0YjgIB3BQgqerfvqDkCCMSogJ0WO3bsWLF6hf8/AEceeaQzDcqus7ho0SJXNnjZsmVs0uLKnqFSCPhT4Pnnn5f9Y8uKFSv82cBsrXryySc1b948ffjhh0pISMj2Di/9JDB69GitWbNGt99+u5+aRVsQQCBGBAgqxkhH00wEEPCPwNFHH62qVavq22+/9U+jaMk/CjRp0kR2hErnzp1lF+p3W/rll1+cdc7cVi/qgwAC/hSwI7kGDhyom2++2Z8N3N+q999/35nubUeq25HrJH8KbN++XbfddpuzfnJiYqI/G0mrEEDA1wIEFX3dvTQOAQT8KsAUaL/2bP7tuuCCC9S3b19169ZNKSkp+Z8UpaNLlixhpGKU7CkWgVgVGDBggFatWqWPPvrIlwQzZ85Uv379NGnSJNWsWdOXbaRRAYH7779fXbp0UYsWLSBBAAEEPCnA7s+e7DYqjQACsS5gRylee+21Wrx4caxTxFT7L7/8ctlF++0mLnFxcVFv+6ZNm1S3bl1t3bo16nWhAgggEFsCs2bN0iWXXCK7rmvZsmV903i7pETr1q01cuRItW3b1jftoiF5BX744QcnoGj/OFehQoW8J3AEAQQQ8IAAIxU90ElUEQEEEMgt0KxZM23ZskW//fZb7rf42ccCb775plavXq2HH37YFa1kkxZXdAOVQCAmBVq2bKl27drpoYce8k37N2zYoI4dO8qupUhA0Tfdmm9D7B8I+/Tp4/Q1AcV8iTiIAAIeESCo6JGOopoIIIBAdgE7Ss1OhbUbtpBiR6BEiRJOnw8fPtwZrRjtlhNUjHYPUD4CsS3w1FNP6d1339WPP/7oeYg9e/bo3HPP1TXXXKOrr77a8+2hAQULvPTSS87oxCuuuKLgE3kXAQQQcLkAQUWXdxDVQwABBP5JgHUV/0nG38ftJj0TJ07ULbfcojlz5kS1sez8HFV+Ckcg5gWqVKmiwYMH64YbbvC0RUZGhjOV+4QTTvDVyEtPd0oYK293eh40aJD++9//hrEUskYAAQQiI0BQMTLOlIIAAgiEXMBOjVqwYIHsunak2BKwXzz/97//qWfPns506Gi1np2foyVPuQggkCXQq1cv5+Vrr72Wdchzz3bjmcaNG+v111/3XN2pcNEFbr31Vmf38nr16hX9Yq5AAAEEXCZAUNFlHUJ1EEAAgcIKJCcnq0OHDho/fnxhL+E8Hwm0b99eAwcOVOfOnbVjx46otIydn6PCTqEIIJBNwC4H8uqrr+q+++7Txo0bs73jjZfPPfecPv/8c91+++1KTEz0RqWpZbEFPv30U+cPwvbzSkIAAQT8IMDuz37oRdqAAAIxKzBixAiNGTNGH374YcwaxHrDb7zxRv3xxx/OWosJCQkR40hNTXV2XN25c6eSkpIiVi4FIYAAAvkJ3HnnnU5Q8e23387vbVce++STT9SvXz9nKYtatWq5so5UKnQCdt3Mhg0b6o033tDZZ58duozJCQEEEIiiAEHFKOJTNAIIIBCsgN0B+qijjtLatWtVqlSpYLPjeg8KpKWlOYv72y8qQ4YMiVgLfv75Z9l1Pe0UaBICCCAQbYFdu3apfv36ziZWrVq1inZ1Dln+3Llz1aVLF02dOtWZ+nzICzjB8wL33HOP80dAu3wJCQEEEPCLANOf/dKTtAMBBGJSoGLFimrSpIk+++yzmGw/jZYzXc6OVLVfTIcNGxZWku3btyszM9Mpg52fw0pN5gggUESBMmXK6IUXXnA2bbEjqbOS/QOI29Ly5ct1/vnny842sGspkvwvYD+Hb775ZkT/+Od/VVqIAAJuECCo6IZeoA4IIIBAEALsAh0Enk8uLVeunCZMmKAHHnjAWZsrq1n2i/U777yT9WPQz+XLl5ddy7Nu3bp6/PHHVaJECb333nvO+lDp6elB508GCCCAQDACNlBnR+8/++yz2rp1q+wmLnYU97hx44LJNqhr7TqP2de93bx5s7Me8kMPPeQ8B5U5F7tW4JlnntG6deuc+tk/xvXp08fZ8blq1aqurTMVQwABBIojwPTn4qhxDQIIIOAigVWrVqlZs2bOFOj4eP5W5KKuiXhVZs2apR49esg+2y8udjOX77//3llvsVu3bkHXx+5U+euvvx7Ix37e7Ogg+4WpZMmS2rBhw4H3eIEAAghEQ+Cvv/5S27ZttWbNGu3bt0979+7VFVdcoXfffTfi1fn7779Vs2ZNHXPMMZoxY4aqVKnirKXXunVrDR48OOL1ocDICPzwww/OLBL7+/HJJ5901h226yh+8803shsLkRBAAAE/CbDFmJ96k7YggEBMCtSpU0eHH364s9D76aefHpMGNDog0LJlSz399NNq166d80XajtSx6fnnn1cogopNmzbNEVTMyMhwRuDYL052J2oSAgggEC0BOzLbTiu+8sornXXr7BqLWWnmzJlZLyP6PHToUGdE9+rVq3XyySc7gabatWvrsccei2g9KCyyAjZ4aNe5tp/Bu+++23k9atQoAoqR7QZKQwCBCAkwpCVC0BSDAAIIhFOAKdDh1PVW3kceeaQ2bdrkjBq0o3Rsmj17ttavXx90Q2zQ2o5IzJ3ssf79++c+zM8IIIBAxATmzJmjBg0aOKOzswcUbQXsqMXcx8JdMftHl5deesn5A4/dUMvel21w007JZrRauPWjm/+0adNkd3q2yX7ubN937drV2embEf3R7RtKRwCB0AsQVAy9KTkigAACERcgqBhxclcWOHLkSOeLy+7duw9sqGIraqcpDx8+POg625E2dh3F7Kls2bLO6Mjcx7Ofw2sEEEAg3AI1atRQ6dKl8y3Gjqb+9ttv830vXAcnTZokG0zMnmygyf6+tqPWSP4VsCMVsye7REhKSopef/11XXTRRdnf4jUCCCDgeQHWVPR8F9IABBBAICBwxBFH6Msvv5Rd944UmwIFjX6xU+7s+pvBJLv7s10TLPvOqjbfFStWOIHLYPLmWgQQQCBYgZUrVzrrKdp1FW0QJyslJSXJboxy//33Zx0K+/PZZ5/t/E7+p4JsoInkPwE7EtHOGMiaKZDVQvsZtJuq2bU17eZBJAQQQMAvAoxU9EtP0g4EEIh5AUYrxvxHwFkE3m4IYEfl5E52+tW8efNyHy7Sz/YLUYUKFQ5cY8ux0/vYIOgACS8QQCCKAnbn5x9//FFnnnlmjlGL9g8hn3/+ecRqZqdbf/3113nKsyO67X3z0UcfzfMeB/whYEcp5l4mxI6gPemkk7R06VICiv7oZlqBAALZBAgqZsPgJQIIIOBlAYKKXu690NT9tNNOczZSefzxx50vrsnJyQcytqN2Xn755QM/F/fFiSeeeOBSG8C060SREEAAAbcI2KDd5MmTdeeddzobZGTV67vvvst6GfbnV199NUcZ9g8vNtBkd6G2I8bvu+++HO/zg38E7EjEnTt3HmiQDShedtllzmZ6dqQ/CQEEEPCbANOf/dajtAcBBGJWwE61qV69upYtW6Zq1arFrAMNDwjYkYkDBgzQ6NGjnY0C7FQ7uxvl5s2b84yiKIrZgw8+6OxcakfcTJkyRXbHaRICCCDgRoFx48bpkksucaZC23uW/f1ol2wIZ7IbtFStWtW519pybFCpcePGeu2113T88ceHs2jydoGA7esFCxY4NbG/c1988UX17t3bBTWjCggggEB4BBipGB5XckUAAQQiLmBHpXXs2FETJ06MeNkU6D6BypUrO5uz2Cl4jRo1ckYu2jUXP/nkk6Aq+69//Uv2s9asWTMCikFJcjECCIRboFu3brIjFO0f3OxowdwbaISjfLtBix0ZbkdM2rX1PvzwQ82aNYuAYjiwXZZnenq6Fi9erMTERGepELvONQFFl3US1UEAgZALMFIx5KRkiAACCERPwO4oaR92dAbJ/wJ70jK0ctvuQzbUjlIc+/5I/fuWm1SzVm1N/X7RIa/5pxNWr1iujs1O1qRvF6jOMXX/6bSgjpdOTFCd8qWCyoOLEUDAXwKFvd/l1+ptW7foyi4ddP3td6lzzwvzOyVkxy5o20pLFi7QvY8+oUt793UCTAVlzv2uIJ0IvJe6VUpZJ+3bYh7mtX1O3SZl7Nv/SDXP5hFnxuLEJUkJZlkR+5xo1i5OLm8eFaUks9ZwiUqav3SdTmvRSscdd5ymTZumww8/PAINoAgEEEAgugIEFaPrT+kIIIBASAW2bdumWrVqae3atTkWqQ9pIWTmGoEpyzdoV2paoeuzx6zztO7PVTqqwQmFviZaJ7asVVnVSh9cEzJa9aBcBBBwh0BR73e5a21HkWWkpykpuUTut0L68+pfl6lSteoqW94EmgqZuN8VEqpYp5ldtncul7YvNY9l0uYfAs971kh7NwVyTChpAoVxgdeZGVKm+b3qPJvXsj+nm2fzflyCediJfjbAaF/bhznu7OSdob827NLNbyfo/XvqKLlCHaliY6m8+X1broF5Njs+J5kgJAkBBBDwmQBBRZ91KM1BAAEEzjnnHPXv31924xaSvwWmr9qozSlmBIXPUlJ8nE49ohJBRZ/1K81BIBgB7nfB6MXQtXvXS+umSxtmS+tnmADiEhP4M3+gijcBwLQ9gdGHEeMwAUc7otEGH9NN2ckm0FypqVTjLKnKGVLl5ua9xIjVhoIQQACBcAhwFwuHKnkigAACURTI2gWaoGIUO4GiEUAAAQQQQCD8Ahl7pbWfSX+Okf6abEYfmqBivBl5mLrDlG1GKTrJTGWOSjLlpx3cCVoppm5/fRqorx0dmZFigoxNpCPNH4GP7CEdVi8qtaRQBBBAIBgBRioGo8e1CCCAgAsFVq9erSZNmmjdunXOwvQurCJVCpEAI3dCBEk2CCDgegHud67voshV0AYSbRBx+XAToPvCrHNoprTnCCJGriohKcnW306rTq4sHXWpdMw1Zsq0mS5NQgABBDwgYBeFICGAAAII+Eigdu3azo6TX5tdf0kIIIAAAggggIAvBLYukOb2kT6sZJ77mlF/k8xoPxNgTN1umpc1KtGDLU03bbBTs3f/KS19TppkpkhPPF76bWjOkY4ebBpVRgAB/wsQVPR/H9NCBBCIQYGsKdAx2HSajAACCCCAAAJ+ElhnRiNObSFNMesQLn/bBNp27w8k+qmR+9uSYTaJsesvbjMby8y/S/q4urRgYGCHah82lyYhgID3BQgqer8PaQECCCCQR4CgYh4SDiCAAAIIIICAlwQ2z5M+PVma0U3aOMcE20ww0dmJ2UuNCKKuqbsCAdRlz0tjjzbBRRNkzL5GYxBZcykCCCAQKgGCiqGSJB8EEEDARQKNGzdWSkqKfv75ZxfViqoggAACCCCAAAKHENi3SfrKBBKnnSlt/dGMSjTBtVhOdnq0Hb34y8vSJ0dIq/4Xyxq0HQEEXCZAUNFlHUJ1EEAAgVAJMFoxVJLkgwACCCCAAAIREVgz1ozKq2s2YJkSCKRFpFCPFGLXXbTrR869XpreObDTtUeqTjURQMC/AgQV/du3tAwBBGJcoFu3bho3blyMK9B8BBBAAAEEEPCEwKIHpdmXmcDZNhNQ3OeJKkelkmlm5Oa6z6QJjaTtZu1FEgIIIBBFAYKKUcSnaAQQQCCcAmeffbaWLVum9evXh7MY8kYAAQQQQAABBIITsAHFRYMCawgGl1NsXG2Drns3SpObmV2j/4iNNtNKBBBwpQBBRVd2C5VCAAEEghdISEhQhw4dNHasmUpEQgABBBBAAAEE3Cgwf4C0+Ek31szldcoMbNwypra04xeX15XqIYCAXwUIKvq1Z2kXAgggYARYV5GPQVEEdmzdUqjT01JT9feqFfmeW9B7+V7AQQQQQCAKAtzvooCeX5Er3pJ+HSZlmM1IgkzbzebQO1NMVhmFyyg1TVq4yswgNtetNzOu96YW7rrinLVms4mb/pn3SlvmlmD3oYmLkz47KzBtPG8RHEEAAQTCKkBQMay8ZI4AAghEV6BTp06aMWOGdu0K9l+s0W0HpUdG4OFrLtKa5b8VWNj3X32u689uppHPPZ7nvILey3MyBxBAAIEoCnC/iyJ+VtF7N0jzbjGj7YL/N8pPZgbwnSOlv7dKt7wj7TMBw4LSt79L7QZLr5ilCSv1lWreLK0p3N/VCso2z3vvfyP96z7po2+lsiXyvK2+r0v3vpf3eJGOZJoRi/tMwxfcW6TLOBkBBBAIhQBBxVAokgcCCCDgUoFy5crptNNO09SpU11aQ6rlFoFfFv6glUsXa8p75ttYAanJmW3VoHFTJSQm5jmroPfynMwBBBBAIEoC3O+iBJ+72J+fkTIPEf3LfU0+P8/9LRBIfPYK6bgaUp+zpO7Pmlhlej4n7z/0yEfSBadKr/aWhvUx+8KYuFy8GfAXTHpmYs6r+78tDRghjb/T1K+jVKdqzvfH/yC9MyvnsWL/lG52hl5uRn2mrCt2FlyIAAIIFEeAoGJx1LgGAQQQ8JAAU6A91FlRrOrU99/VUQ1O0Jcfv6+9e8xcsHxShplTZh8JCYmKs9OtsqWC3st2Gi8RQACBqAtwv4t6F5gKmCje72aYXrqZrxxk6j9cerCHGQlYMpDRKUdJ5UpJ7xYQsLMjFSuW2X9+naJXYM++nNd8bEYiDh538NgHc6WXpkmvXycdUeng8axXm3dKQz8zwc8mWUdC8Wy+2q8aFYqMyAMBBBAotEBioc/kRAQQQAABTwp0795djzzyiBMMio/nb0me7MQwV3rXju3OtOfrH35c917SVTPGf6x2F5khH/tTpplaNeKZx/TXyuVK27dXv/20UKeccabzbkHvZV3PMwIIIOAWAe53LumJXStDElCcOF/6Y5PUukHOdl3QXLrbxNeuaiUl5Pqnz41vShtNUO/Vz6XPfzKvd+S81q5/2O9tszajiXuuNnnbvO7tZkYymnzGfS99aAKIdhTk0r+kiXeZ12YNRzv1eocZLNj16UCA046ErF5OWmFmeN/zntT+ROnsEw6WY0cwPnaReWQLRB58t5iv0s0fBNeY4ZL1bytmBlyGAAIIFF0g1y226BlwBQIIIICAuwWOOOII1apVS7NmFfAne3c3gdqFWWDGuI/UqnN31TuliWodV1+TR5phH9nSp+++oaXff6u7X3xd97zytvNO1kjFgt7LlgUvEUAAAVcIcL9zRTdIu1ZLcUlBV2bmMqlBzUDAL3tmtasEAnrL12c/Gng9tJcp2ry8vZP05vXSwz0PnmM3ebGBQRukHHuHNPwG874JEL64fxWZG0xA8ox60sh+gTI/mifVqizd1lGqYEY+2qnO9ufFa5yxmLIjGv82azW2fUyatCBQjh3VWMfUz46oDHnatSrkWZIhAgggUJAAQcWCdHgPAQQQ8IkAU6B90pFhasaXn4xWq67nO7mfc8FlztqKy+Z/d6C0CcNf0ymtznKmPNu1FBs2O61Q7x04iRcIIICASwS437mkI0JUjWVmtGD18nkzq7V/yrF9vyjp61+l+SYu1/VfgatOqi2dbKZH21GNNtnpzOc1kWabYOaG7SZwmS1oaQOVNi0xAUWbXusj3dFZessELk8xeYz6JjAqcqjJ69/dA+fwXwQQQMDrAkx/9noPUn8EEECgEAI2qNizZ08988wzhTibU2JJwAYPN639S49ef6XT7Iz0NMUnJJjRim+rvtmQZW/KHq1f84cqVz/8AEtCfIIZ5hFX4HsHTuYFAggg4BIB7ncu6QhbjTImWpeZGnSF7EjApHy+0VY1U49t2mpmBBclrdqY9+zTjjUjGqcHjh9tNlu5cqjUo2lgRKKdIp2VspYazgpyltw/ENNOm25pRjfaadNPjpd2mmUk7YhHm+zajva83sMCG8bknqodOKsI/y1jopckBBBAIIICjFSMIDZFIYAAAtESOPnkk5WWlqbFixdHqwqU61KBKaOG65YnX9Tj709wHk9+OFlN27TX15MnaNvmTUpKLqEKVatpabaRi7YpdvpzQe+5tLlUCwEEYliA+52LOr/MUWaxw5JBV6ie+XvXX2Z6ce60ZVfgiJ2KXJRUs0Lg7G/MiMWslGi+MdvNVmwwsPNT0rWtpZvaBYKBWedkfz6mmlTKBAp/WHnwaLIJfNqNYVrWl846Xqpmgp72YQOKJcx79nXWSMeDVxXxVUJpU1EzNJKEAAIIRFCAoGIEsSkKAQQQiKYAU6Cjqe/OsresX6fF8+boxNNa5qjg2edfrLTUfZr8v7fMwvTxOrVtR837Yoo2/r3GHE91NmzZvG6tc84/vbdvr/n2RUIAAQRcIsD9ziUdcaAaJoRWt0/QgcVGtfIPKtrNVmwwsOERBwo88CLFjG60AwztBis27U0LPKebn1scJx1l1juctDBwzP53rhlNePkZkl2f0W68YgOWNv9FfwQCjdvNaMjSJQKjIreZ13bjmFvMGov55dHNTJ0efMnBR2MzsNCWaY8Fv5eeaUCdSw9WnFcIIIBABAQIKkYAmSIQQAABNwjYXaDHjRvnhqpQBxcIbNmwXoOuu1xbN27QrIljDtRo757d+vbzyc7P4976rxmxOF7det+owypU1M3tT9eAbm21LyVFKea8n+Z+XeB7BzLlBQIIIBBFAe53UcQvqOjjza4mcWaYXhDpstOlfSYomHtDlvFmV+iezaWsadDZi7h/dOCnF8yvuoVm/cTH9//T6FHzq9BOpf7gVsmurdj/bTPN+dnANOeBXaUTTQDzdBMAvPWdwPRlu+7iiNmS3azFjj483IxyPOFuszHLVumRnpKdKn3BELPr86MmDzPS8Y5zs9ci8NoGEuODHqJo8kooJR1zrRn6WD1vIRxBAAEEwigQl2lSGPMnawQQQAABlwjY6c/VqlVzpkAffvjB9fFcUj2qUQyB6Wbxp80pqcW4sniXbNu0UeUqVVbK7t0qVcbM48qWCnov22mFeplkvmGdauaaVSudXKjzOQkBBPwvwP3Op3284i1pXn8zbHD/fOViNPPN6WZzlZVmh+ZrAhfb0YLnPBbYofm4GoFjRf2v3QX617WBKcvVcm0EsyvFLAlZMpDjXvMruERS4LVd39EGCLN+tkdtXWwqb2Ymhy3ZxRxLmoZ2+dlERXNVNmyFkjECCCAQEGCkIp8EBBBAIEYEEs2uveeeey6jFWOkv8PRzPKVqzhrKeYOKNqyCnovHHUhTwQQQCCcAgXd0wp6L5x18mXeR5vRdcf1Dappvc6SalY0OzN/Ke3eK13yovTC1SbbYgYUbWXsCML6Nc1ah/nE6LICiva87AHEUubvYNl/tu/bYGJYA4q2kATzR75zphNQtBZcJsJ4AABAAElEQVQkBBCIuABBxYiTUyACCCAQPQHWVYyePSUjgAACCCCAQD4Cjc0cY7u+YmLOEfD5nPmPh+49TzrSTDFeuUF66ZrAOoX/eLJf3sjabrrLYumwen5pFe1AAAGPCRBU9FiHUV0EEEAgGIFOnTpp5syZ2rlzZzDZcC0CCCCAAAIIIBA6gVNfkxrcbgKLxZ8n3PFkszHLkSY+GQvLCibYYZFm0cauS80uMbVD1w/khAACCBRRgKBiEcE4HQEEEPCyQNmyZdW6dWtNnTrVy82g7ggggAACCCDgN4GTBklnjAxM47VBM1L+AnZEZ/VzpM6LzAjF+vmfw1EEEEAgQgIEFSMETTEIIICAWwS6du2qTz75xC3VoR4IIIAAAggggEBA4Agzj/m836UaHQI7Gps9SEj7BewOz0nlpOb/NdtNTzQjFatBgwACCERdgKBi1LuACiCAAAKRFbDrKk6YMEHp6emRLZjSEEAAAQQQQACBQwkkV5bOHCe1+8rscnJiUGstHqooT7yfUCIQYK3fT+qxRjrqCk9Um0oigEBsCBBUjI1+ppUIIIDAAYHDDz9cxx13nGbMmHHgGC8QQAABBBBAAAFXCVRqJp37owkwjpWqnGYCa2a9xfgEV1UxrJWx05ztGpP1bzWjN1dIpzxpfi4b1iLJHAEEECiqAEHFoopxPgIIIOADgW7dumncODMKgIQAAggggAACCLhZoHpbqf03UofZ0jHXBgJtdhqwH1N8YmBUYvkG0r+els5fZ4KJT0glY2H3GT92KG1CwP8CBBX938e0EAEEEMgjYKdAjx1r/vJPQgABBBBAAAEEvCBQ4RSznqDZJfqCzdKpw6SanczIRTM12AkwenjxRTu9OdGsl1jabF1td8Du9J3ZhOVn6dgbGJnohc8ldUQgxgXMn0JICCCAAAKxJnDiiScqPj5eP/30kxo1ahRrzae9CCCAAAIIIOBVARtIrH1x4JGxV1r7mfTnGOnvKVKKGdkXX1JK3WFal+nOFtqdrW0dM1Kkik2kWmZzmiN7mJ2c67mzvtQKAQQQKECAoGIBOLyFAAII+FnA7gI9ZswYgop+7mTahgACCCCAgJ8FbICxZufAw7Zz73pp3XRp49fm2Wz0st2M+ItLMg8zQS/dBPEy9kVOI86MnrTrQMaZdSBt2ckVpcpNpepnmTUizzCvzZqRcXwdj1yHUBICCIRDgLtYOFTJEwEEEPCAgJ0Cfdddd+nf//63B2pLFfMTSEnPyO+w54+lZrh0dInnZWkAAt4V4H7n3b6LaM1LVDMjGC8KPJyCze+TnSv01ZQP9No7o/X8TXVVOc5sepLyl3lsNGeY9xPM1GMbALQp0/xezUwLPMu8zkgPvLbv2+CgTHDSBijta7tpTKa9zuSRac5L322mKx9m1j80dShTR6rU2OxefYJUzqyPWO54M027vC2BhAACCPhKIC7TJF+1iMYggAACCBRKID09XdWqVdOPP/6oI444olDXcJK7BPakZWjVNvMlJgLpxccf1Tmdu+r4E08Ke2mlkhJUp5z5kkdCAAEE9gtwv+OjUFyBr776ShdeeKG++OKLvLMzUreZ4OJaad8W89gaeE7dboKJZlp1RurBhw0qxttpy2bUo322IxCTK+x/mBGIyZWkUjVNsJExO8XtJ65DAAFvCnDX82a/UWsEEEAgaIGEhAR17tzZ2QX6xhtvDDo/Moi8QKnEeDWoXDYiBf+68Hud165NxMqLSKMoBAEEPCPA/c4zXeWqii5ZssQJKL7//vt5A4q2pnb0ICMIXdVnVAYBBLwlwO7P3uovaosAAgiEVKBHjx4aP358SPMkMwQQQAABBBBAINoCa9euVadOnfT888+rTZs20a4O5SOAAAK+FCCo6MtupVEIIIBA4QTat2+vmTNnascOu0siCYF/FrC7hcdlrTn1z6fxDgIIIOB5Ae53nu9C5981HTp00E033aRLL73U+w2iBQgggIBLBQgqurRjqBYCCCAQCYEyZcqodevWmjRpUiSKowwPC2RkZIhlmD3cgVQdAQQKLcD9rtBUrjwxNTVVdiZGq1atNHDgQFfWkUohgAACfhEgqOiXnqQdCCCAQDEF7C7QY8eOLebVXIYAAggggAACCLhHoFevXipbtqxeeOEF91SKmiCAAAI+FSCo6NOOpVkIIIBAYQW6deumTz/9VGlpaYW9hPNiUIDpgDHY6TQZgRgV4H7n3Y5/8MEH9dtvv+m9996T7UcSAggggEB4BbjThteX3BFAAAHXC9SoUUPHH3+8ZsyY4fq6UsHoCTAdMHr2lIwAApEV4H4XWe9QlTZs2DCNGjXK2YCuZMmSocqWfBBAAAEEChAgqFgADm8hgAACsSLQtWtXjRkzJlaaSzsRQAABBBBAwEcCEyZM0EMPPaQpU6aoSpUqPmoZTUEAAQTcLUBQ0d39Q+0QQACBiAiwrmJEmCkEAQQQQAABBEIs8O2338quozhu3Dgdc8wxIc6d7BBAAAEEChIgqFiQDu8hgAACMSLQsGFDJScna8GCBTHSYpqJAAIIIIAAAl4X+P3339W9e3cNHz5czZo183pzqD8CCCDgOQGCip7rMiqMAAIIhEeA0YrhcSVXBBBAAAEEEAi9wIYNG9SuXTsNGjRInTp1Cn0B5IgAAgggcEgBgoqHJOIEBBBAIDYE7F/6x48fHxuNpZVFFmA31CKTcQECCHhUgPud+ztu9+7dTiDxqquuUu/evd1fYWqIAAII+FSAoKJPO5ZmIYAAAkUVOP3007Vq1SqtXr26qJdyfgwIsBtqDHQyTUQAAUeA+527Pwjp6em64IILdPLJJ+vhhx92d2WpHQIIIOBzAYKKPu9gmocAAggUVsCOzOjSpYuz0Hlhr+E8BBBAAAEEEEAgkgI33HCDs37isGHDIlksZSGAAAII5CNAUDEfFA4hgAACsSrAuoqx2vO0GwEEEEAAAfcLPPLII5o/f77uvvtuJSQkuL/C1BABBBDwuQBBRZ93MM1DAAEEiiLQvn17zZ07V9u2bSvKZZyLAAIIIIAAAgiEVeCNN97QO++8o08//VRlypQJa1lkjgACCCBQOAGCioVz4iwEEEAgJgRKly6tNm3aaNKkSTHRXhqJAAIIIIAAAu4XsIHE+++/X1OmTFG1atXcX2FqiAACCMSIAEHFGOlomokAAggUVqBbt24aM2ZMYU/nPAQQQAABBBBAIGwC8+bN09VXX+2s+XzssceGrRwyRgABBBAougBBxaKbcQUCCCDga4GuXbtq8uTJSk1N9XU7aVzRBOxGPnFxcUW7iLMRQAABDwpwv3NPp/3++++y6z3bac/Nmzd3T8WoCQIIIICAI0BQkQ8CAggggEAOATutqGHDhpo+fXqO4/wQ2wIZGRnKzMyMbQRajwACMSHA/c4d3bx+/Xq1a9dOgwYNUqdOndxRKWqBAAIIIJBDgKBiDg5+QAABBBCwAt27d3emGaGBAAIIIIAAAghEWmDXrl3q2LGjrrnmGvXu3TvSxVMeAggggEAhBQgqFhKK0xBAAIFYEmBdxVjqbdqKAAIIIICAewTS0tLUo0cPNWvWTA8++KB7KkZNEEAAAQTyCBBUzEPCAQQQQACBBg0ayO4E/cMPP4CBAAIIIIAAAghETKBPnz46/fTTNXTo0IiVSUEIIIAAAsUTIKhYPDeuQgABBHwvYBdGHzt2rO/bSQMRQAABBBBAwB0C9913n5YtW6a7775bdsMcEgIIIICAuwXizKLrrLru7j6idggggEBUBGbPnq0bb7xRjz/+uN577z29++67mjVrls4444yo1IdCIyuwe/duPfzww/rzzz+dgr/++msde+yxshv52H86XHvttWrfvn1kK0VpCCCAQBgEuN+FAbUYWb7yyisaMmSIvvnmG1WuXLkYOXAJAggggECkBQgqRlqc8hBAAAGXC+zYsUNjxozRiBEj9OWXX6pkyZLauXOnkpKSnH/s20Ajyf8CW7duVcWKFfNtaFxcnLMj55QpU/J9n4MIIICAlwS430W/tz7++GP169fPCSjWqVMn+hWiBggggAAChRJILNRZnIQAAgggEBMCixYt0kknnaSyZcs6gUTb6NTUVKftycnJKlWqVEw40EipQoUKatOmjRNYzu1hPx/3339/7sP8jAACCHhSgPtddLtt5syZuv766/XZZ5+JgGJ0+4LSEUAAgaIKsFBFUcU4HwEEEPCxwIknnqiOHTseCCRmb6pd28hu3kKKHYG+ffvqsMMOy9PgxMREtWrVKs9xDiCAAAJeFeB+F52eW7JkiS644AKNHj1aJ598cnQqQakIIIAAAsUWIKhYbDouRAABBPwpYP9hb0dt5E52yitBxdwq/v65W7du2rdvX45G2oDilVdeKft5ICGAAAJ+EeB+F/me/OOPP5y1eV944QVnZHzka0CJCCCAAALBChBUDFaQ6xFAAAGfCdiRaRMnTnTWUszdNKY/5xbx9882iGxHrmZPJUqU0DXXXJP9EK8RQAABzwtwv4tsF27ZssUJKN555526+OKLI1s4pSGAAAIIhEyAoGLIKMkIAQQQ8I9AkyZNNGjQIJUpUyZHoxipmIMjJn647rrrckyBLl++vBo3bhwTbaeRCCAQWwLc7yLT3ykpKercubO6du2q2267LTKFUgoCCCCAQFgECCqGhZVMEUAAAe8L2NEDzZo1k92gxabMzEw2avF+txa5Be3bt1dGRoZznf0s9O7du8h5cAECCCDgBQHud+HvpfT0dGdkYt26dfXEE0+Ev0BKQAABBBAIqwBBxbDykjkCCCDgbYGPPvrowGhFG1RkpKK3+7M4tU9KSlLPnj1lN+qxj6uuuqo42XANAggg4HoB7nfh76Ibb7zR2QzurbfeYm3e8HNTAgIIIBB2AYKKYSemAAQQQMC7ApUqVdLYsWOdEYqpqakEFb3blUHV3I5OtKMUa9eurWOPPTaovLgYAQQQcLMA97vw9c5DDz2kH374wdnp2W76RUIAAQQQ8L4Ad3Pv9yEtQAABBMIjkLpVSlmnVg2TdOf13TVoyCiV/Os9abeZDp1hdgTOSA084szfp+KSpHj7MO8lmnUYk8ubR0UpyewiXaKSVKpm4Jzw1JRcgxXY39fat0XaZ/rdPqdu29/P+9S6SqrsGljnnVFVWmKmq9HXwYpzPQIIREuA+11U5F999VWNGDFCc+bMUdmyZaNSBwpFAAEEEAi9QJyZzpYZ+mzJEQEEEEDA/QLm9r9zubR9qXkskzb/EHjes0bauylQ/YSSJhgY57z+a1OaKpdNV4lEc12mXWPPPDLTzbN5Py7BPNvgon2Y187DHHd+xZjz0nabYKP5ElGymlSmtlTRbPRR/gSpXAPz3NAEH00QkhRGgaL1tdO/mWmBfqavw9gvZI0AAqEX4H4XetPgcvz444/Vr18/zZ49W0cffXRwmXE1AggggICrBAgquqo7qAwCCCAQRoG966V106UNs6X1M0wAcYkJ/pmRhfEmCJi2JzAqLYzF58zaBBztiEYbfEw3ZSebEY2Vmko1zpKqnCFVbm7eYzB9TrMi/ERfFwGLUxFAwNMC3O9c3X0zZsxw1uWdNm2aTjnlFFfXlcohgAACCBRdgKBi0c24AgEEEPCGQMZeae1n0p9jpL8mm9GHJqgYb0Yepu4w9TcjOdyY7PRpOzoyI8UEGZtIR55nHj2kw+q5sbbuqRN97Z6+oCYIIBBeAe534fUNYe6LFi3S2Wef7ayh2KZNmxDmTFYIIIAAAm4RIKjolp6gHggggEAoBOyXLRtEXD7cBBS/MAG6Eu4OIh6qzbb+dkp1cmXpqEulY64xU6bNdGmSCbzS13wMEEAgRgS433muo1etWqXTTz9dQ4YM0YUXXui5+lNhBBBAAIHCCRBULJwTZyGAAALuFti6QFr2krRqVGDacOp2d9e3OLWLN9Oh7YYwZetI9W8xQcYrA+s0FicvL19DX3u596g7AggURYD7XVG0XHPupk2b1KJFC91yyy3OWoquqRgVQQABBBAIuQBBxZCTkiECCCAQQYF1ZjTiwvulLT8GRq45G6dEsPxoFZVk1mO0m8DU6yc1GGA2gKkerZpErlz6Onb6OnKfKkpCwJ0C3O88e7/bvXu3zjzzTHXo0EH/+c9/3Pn5olYIIIAAAiETIKgYMkoyQgABBCIosHmeNKePtOt3M715VwQLdllRdnq03XW6/s1So4f8OXKRvg586GKhr132vxfVQSDiAtzvAuQevd+lp6erS5cuatiwoZ555pmIf3woEAEEEEAg8gIEFSNvTokIIIBA8QX2bTLBxF7S39MCuyYXPyd/XZlYKjA1uvkrUp3L/dE2+jr/fvRjX+ffUo4iEDsC9n73zbWBzcXS98ROuw/VUg/d7zLN7IErr7xS27dv1yeffKKEhIRDtY73EUAAAQR8IEBQ0QedSBMQQCBGBNaMlb6+2kxzNl+40vfFSKOL2MxEMy262plSi7ekEtWKeLGLTqevD90ZfunrQ7eUMxDwtwD3u0P3rwfudwMGDNC8efM0depUlSpl/tBHQgABBBCICQGCijHRzTQSAQQ8L7DoQelnM5UobbfnmxL2BiQkm2nQ5aV2M8xO0Q3CXlzIC6CvC0/q9b4ufEs5EwF/CnC/K3y/uvh+98QTT2jEiBGaOXOmKlSoUPg2cSYCCCCAgOcFCCp6vgtpAAII+F7AfulaNMj3zQxtA+NMYNGMWuyyRCpdK7RZhzM3+roYuh7t62K0lEsQ8JUA97tidKf77ndvv/22HnroIc2ZM0eHH354MdrEJQgggAACXhYgqOjl3qPuCCDgf4H5ZmfjZWadwIy9/m9ruFrYdZl0WL1w5R66fOnr4C290tfBt5QcEPC2APe74PvPBfe7CRMmqHfv3po1a5aOO+644NtEDggggAACnhMwW2aSEEAAAQRcKbDCrAv467CQBBS3m1nTO1NMVhmFa2lqmrRwlWSvW79N2ptauOuKc9aazdLiP/NeacvcEuzG1nFmVMdnZ5kdsk0j3Jzo69jpazd/DqkbApEQ4H7ni/vd7Nmzde2112rixIkEFCPx/w1lIIAAAi4VIKjo0o6hWgggEOMCezdI824xaygGG1WTfvpDunOk2TB6q3TLO9I+EzAsKH37u1mOcLD0ymdSpb5SzZulNVsKuqJ4773/jfSv+6SPvpXKlsibR9/XpXvfy3u8SEfMbpTaZxq+4N4iXRbRk+lrxUxfR/SDRWEIuFCA+50v7nc//fSTevTooVGjRqlp06Yu/KBRJQQQQACBSAkQVIyUNOUggAACRRGwm7JkHiL6V4j85v4WCCQ+e4V0XA2pz1lS92dNrDL9ny9+5CPpglOlV3tLw/qYjaZNXC7eDPgLJj0zMefV/d+WBoyQxt9p6tdRqlM15/vjf5DemZXzWLF/Sje7ZS83oz5T1hU7i7BeSF/HTl+H9YNE5gh4QID7nefvd6tWrVKHDh300ksv6ZxzzvHAh44qIoAAAgiEU4CgYjh1yRsBBBAoloCJ4v1uhumlm/nKQab+w6UHe5iRgCUDGZ1ylNkQuZT0bgEBOztSsaLZ48SmU+oEnovy3z37cp79sRmJOHjcwWMfzJVemia9fp10RKWDx7Nebd4pDf3MBD+bZB0JxbP5dbdqVCgyCnEe9HXs9HWIPzpkh4DnBLjfef1+t3HjRieQeN999+miiy7y3CeQCiOAAAIIhF6AoGLoTckRAQQQCE5g18qQBBQnzpf+2CS1bpCzOhc0lwZ9YorIZ33FG9+UNpqg3qufS71elR42oxazJ7v+YQ8z0vE8M5CysZm6/OiYg+s0jvteumqo1NssA2mnNf9tpkzb8u3U6x1msGDXp82MbhOwtCMhq5eTVpgZ3ve8J32xOHsJgRGMj5nvKkmJOY8H9VO6WRxyTa7hkkFlGKKL6WvFTF+H6CNDNgh4VoD7nafvd7t27dK5556ryy67TDffbNZFISGAAAIIIGAECCryMUAAAQTcJrBrtRSXFHStZppNjxvUNDf6XHf62lUCAb3l6/MWMbSXKdocvr2T9Ob1JqjY8+A5dpMXGxi0Qcqxd0jDbwgEHV+cGjjnBhOQPKOeNLJfoMyP5km1Kku3dZQqmJGPdqqz/XnxGjOz21xiRzTawGPbx6RJCwJ52FGNdUz97IjKkKddq0KeZdAZ0tex09dBf1jIAAGPC3C/8+z9bt++ferSpYuaNGmiRx55xOMfRKqPAAIIIBBKgVxfNUOZNXkhgAACCERTYNlfZkRg+bw1qLV/yrF9vyjp61+l+SYu1/VfgatOqi2dbKZH21GNNtnpzOc1kWabYOaG7SZwmS1oaQOVNi0xAUWbXusj3dFZessELu0U61HfmBGSO8y0Z5PXv7sHzuG/hRegrwtvxZkIIOBtAe53ke2/DPMXxYsvvljVqlXTyy+/HNnCKQ0BBBBAwPUCBBVd30VUEAEEYk6gjInWZaYG3Ww7EjDDDgnMlaqaqcc2bTUzgouSVm3Me/Zpx0orNwSOH202W7nSTH9euDowIjF72XH7o4pZQc6S+wdi2lGULc3oxmmLpCfHSzvNMpJ2xKOdQm3Xdpz+c+B1flO189bmEEfKmOil2xJ9HTt97bbPHvVBINIC3O88eb/r27ev7NTnd99918x84KtjpP+3oTwEEEDA7QL8ZnB7D1E/BBCIPYEyR0kJJYNud73Dpb/M9OLcacuuwBE7FbkoqWaFwNnfmBGLWSnR/Baxm63YYGDnp6RrW0s3tZOygoZZ52U9H1NNKmUCij+szDoiJZu1E+3GMC3rS2cdL1UzQU/7sHmUMO/Z11kjHQ9eVcRXCaVNRc3QSLcl+jp2+tptnz3qg0CkBbjfee5+ZzdkWbhwoT755BMlJydH+hNDeQgggAACHhAwX9dICCCAAALuEjAhtLp9pGXPB7VhS6Na0oT5eVtmN1uxwcCGR+R9L8WMbrSDG9MyAu/tTQs825GCLY6TjjLrHU5aaEYktgocn2tGE15+hmTXZ7Qbr9iApc1/0R+SHbm43YyGLF0iMCpym3m9bpt0i1lj0eZxT7eceXRrItlHVrIjIMubWODgS7KOBPNsGlDn0mAyCNO19LWFjY2+DtNHiGwR8IwA9zvbVV653z377LNOMHHWrFkqU8b85Y+EAAIIIIBAPgKMVMwHhUMIIIBA1AWON7uaxAX3d5/LTpf2maBg7g1ZxptAY8/mUtY06OxtvX904KcXJptpzKukx8cFfra7PNvdmD+4VbJrK/Z/O7ALtB3tOLCrdKIJYJ5ugo63vhOYvmzXXRwxW7KbtdjRh4ebUY4n3G02Ztlqdn/uGQg4XjBEOvtRM1XajHS849zstQi8trOs4s130KBTQinpmGvN0MfqQWcVlgzoa2czoZjo67B8gMgUAQ8JcL/zxP3unXfe0ZAhQzRt2jRVrmx+0ZMQQAABBBD4B4G4TJP+4T0OI4AAAghEU2DFW9K8/mbY4P75ysWoy5vTzeYqK6UXrwlcbEcLnvNYYIfm42oEjhX1v3YX6F/XBqYsVyuf8+pdKVKZkoFje1PN9OWkwGu7vqMNGmX9bI/authkRyOGLdnFHEuahnYxizMm5aps2AotRsb0dTHQcl3ilb7OVW1+RCDmBLjfBd/lYbzfjR8/Xtddd52++uor1a9v1iUhIYAAAgggUIAAQcUCcHgLAQQQiLrA/AHSz88FVY3BYwOjEu3IxZ5mdOCD5wemMgeVqVcuTiwrdfpeOszsBuP2RF8H10Ne6uvgWsrVCHhfgPtdcH0YpvvdjBkz1LNnT02ePFlNmmRbjyS42nI1AggggICPBQgq+rhzaRoCCPhEYO510qpRQY1YnGzWMKxtZjDZkYJ1XToLOKS9ZUdx2IH43VeZRR1rhzTrsGZGXxed16t9XfSWcgUC/hLgflf0/gzj/c5uyNK2bVt98MEHatOmTdHrxhUIIIAAAjEpQFAxJrudRiOAgOcEfnxAWvqsCSzunzPsuQZEsMIJZofKpApSuxlmhKIHp27R14X/sHi9rwvfUs5EwJ8C3O8K369hvN/9/vvvatWqlV555RV179698HXiTAQQQACBmBcgqBjzHwEAEEDAMwJrzDzmr6+WMvaYXaHNIoWkvAKJZofKamea+d1mPcoS1fK+75Uj9PWhe8ovfX3olnIGAv4W4H536P4N4/1uzZo1OuOMM/Tggw+qV69eh64LZyCAAAIIIJBNgKBiNgxeIoAAAq4X2LdJmmP+0f/3tEBw0czwJRkBu8NzvJnb3exl6agr/EFCX+ffj37s6/xbylEEYkfA3u++uVZa+xm/27L3epjvd5s3b3YCir1799add96ZvWReI4AAAgggUCgBgoqFYuIkBBBAwGUCm+eZ4GJvaefyoNZadFmril6dhBLmmnipfj+p0YOSXbzeb4m+DvRoLPS13z67tAeBogpwvwuIReB+t3PnTmftxHbt2umxxx4rak9xPgIIIIAAAo4AQUU+CAgggICXBdZ9Li38t7TlR7MxyV4zwiPdy60pfN3tVDCZYZr1TDCxgdkhu2QM7D5DX8dOXxf+/wTORMCfAtzvwnq/27t3rzp27KgGDRpo6NCh/vwM0SoEEEAAgYgIEFSMCDOFIIAAAmEW2LpA+sVM/V05UopLlFK3h7nAKGQfb9oVZ6Y4l61jRibeGpjm7MeRiYeipa8PJcT7CCDgFwHudyHvyYyMDPXs2dMJKNoRinF2R2kSAggggAACxRQgqFhMOC5DAAEEXCmQYUYr/jlGWj7crE31hVlr0EwPTt1hqurRxRdN/Z8Yl67+3aqpdP3LpWOukco1dCV9xCvlw75WnJnKnlzZBIwvpa8j/oGiQARcLMD9LiSdk5mZqauuukp2LcUxY8YoKcn8oY6EAAIIIIBAEAIEFYPA41IEEEDA1QL2S5hd9N4GGf+eIqWsM8sPlnR3kDEhOVDHjBSpYhOp1nm64an5mjB1lgYPHqwrr7zS1eRRq5xP+lpH9pAOqxc1RgpGAAEPCHC/K3Yn9e/fXwsXLtSUKVNUqpTZ4IyEAAIIIIBAkAIEFYME5HIEEEDAMwJ710vrpksbvzbPX0nbfw5MJ7ajw9JNEC9jX+SaYqdbJZQ25ScEyk6uKFVuKlU/S6pyhnndLDCNe3+N5syZo1tvNVOeTRoyZIhatGix/x2e8hXwcF/n2x4OIoAAAv8kwP3un2RyHH/wwQc1YcIETZ8+XeXKlcvxHj8ggAACCCBQXAGCisWV4zoEEEDA8wJmSvTOFSa4uDTw2Dw/8JzylxnVuNG0zryfYEYyZK23lJlhDqWZh3mWedhNYexr+74NDtpdmG2A0r6ON49Mc9zmkWnOS99tdmY+zGyoUk0qU0eq1Fgqf4KZytzAPI6Xksqbcw+dRo0apbvuukstW7bUk08+qdq1ax/6Is4wAqYfPNbXdBsCCCBQPAHud7ndnnvuOf33v//V7NmzVaVKldxv8zMCCCCAAALFFiCoWGw6LkQAAQR8LpC6zQQX10r7tpjH1sCz3QDGTj3LSD34sEHF+GTzMGsz2Wc7AjG5wv6HGYGYXEkqVdMEG81GKyFIe/bs0VNPPeWMWLz55ps1cOBAlS1bNgQ5x3AWhejrh16coh7nNNQpDU1QOEJ9HcM9QtMRQCBcAjF2v3vjjTf0f//3f05A8cgjjwyXKvkigAACCMSoAEHFGO14mo0AAgh4XeCvv/7S/fffr8mTJ8vuYHnttdd6vUmurn/79u115513yj6TEEAAAT8L+OV+N3r0aN12222aMWOGjj32WD93GW1DAAEEEIiSgJmnRkIAAQQQQMB7AjVr1tRbb73lrBH1+uuvq0mTJs4XJ++1hBojgAACCCAQWoFPP/1U/fr109SpUwkohpaW3BBAAAEEsgkQVMyGwUsEEEAAAe8J2GCiXSfqnnvucXaH7tmzp1asWOG9hri8xvHx8Wb5TLtOJgkBBBDwt4DX73dfffWVM3rfBhYbNWrk786idQgggAACURUgqBhVfgpHAAEEEAiVwIUXXqhffvlFTZs2dR42yLh9u1kDkhQSgYyMDGVmmg0QSAgggIDPBbx8v5s7d67sH9c++OAD53ehz7uK5iGAAAIIRFmAoGKUO4DiEUAAAQRCJ1CiRAnde++9Wrx4sTZu3Kh69erptddek/2CSEIAAQQQQMDPAgsXLlTXrl01YsQItW7d2s9NpW0IIIAAAi4RIKjoko6gGggggAACoROoUaOG7DqLdhMX++XqlFNO0RdffBG6AmIwJ69PB4zBLqPJCCBQTAEv3u+WLl2qjh076r///a/zXMymcxkCCCCAAAJFEiCoWCQuTkYAAQQQ8JKADSbataUefvhh9enTR+edd55+/fVXLzXBNXX18nRA1yBSEQQQ8ISA1+53K1eulN2x+umnn9b555/vCWMqiQACCCDgDwGCiv7oR1qBAAIIIFCAgP2SZUdxtGzZUi1atNCAAQNYb7EAL95CAAEEEPCGwB9//KEzzzxTDzzwgC6//HJvVJpaIoAAAgj4RoCgom+6koYggAACCBQkkJycrLvuuks///yzdu/e7ay3OHToUKWnpxd0Ge8hgAACCCDgSoG///5bbdq00R133KHrrrvOlXWkUggggAAC/hYgqOjv/qV1CCCAAAK5BKpWreqsOfXZZ5/pww8/1EknnaSpU6fmOosfEUAAAQQQcK+A3YzMBhRtMPGWW25xb0WpGQIIIICArwUIKvq6e2kcAggggMA/CTRq1Eiff/65Bg8erJtvvlmdO3d2pkj/0/kcRwABBBBAwA0CW7duVdu2bXXRRRdp4MCBbqgSdUAAAQQQiFEBgoox2vE0GwEEEEAgINCtWzctWbJE55xzjlq1auWM+Ni8eTM8uQS8uBtqribwIwIIIFAoATff73bs2KF27do5G7P83//9X6Haw0kIIIAAAgiES4CgYrhkyRcBBBBAwDMCSUlJuv32252RinbXzwYNGuill15SWlqaZ9oQ7op6bTfUcHuQPwII+FfArfc7ux5wp06d1Lx5cz311FP+7QBahgACCCDgGQGCip7pKiqKAAIIIBBugcqVKzvBxOnTp2vixImyU6Q//fTTcBdL/ggggAACCBQosG/fPtmR9WeddZZefvnlAs/lTQQQQAABBCIlQFAxUtKUgwACCCDgGYGGDRtq0qRJevbZZzVgwAB16NBBixcv9kz9qSgCCCCAgH8EsgKK1atXF1Oe/dOvtAQBBBDwgwBBRT/0Im1AAAEEEAiLwLnnnquffvpJXbp0cXbZvOmmm2R33CQhgAACCCAQCYHU1FRdcMEFOuyww/TOO+/IrvdIQgABBBBAwC0C/FZyS09QDwQQQAABVwokJiaqf//+WrZsmZKTk531Fp955hnWW3Rlb1EpBBBAwD8C6enpuuSSS5xA4siRI5WQkOCfxtESBBBAAAFfCBBU9EU30ggEEEAAgXALVKxYUUOGDNHXX38tu+ainSI9bty4cBdL/ggggAACMShgN4u54oortGfPHo0ePVp2QzESAggggAACbhMgqOi2HqE+CCCAAAKuFqhXr57Gjx+voUOH6t5771Xbtm31448/urrOoaicnXIXFxcXiqzIAwEEEHC1QLTvd5mZmbr22mud5TY+/vhjZ5S8q8GoHAIIIIBAzAoQVIzZrqfhCCCAAALBCGQFE+1aV+3atVPfvn21fv36YLJ09bV21Iz9oktCAAEE/C4Qzfudvc9ef/31WrVqlcaOHauSJUv6nZv2IYAAAgh4WICgooc7j6ojgAACCERXwK5vdeONN+qXX35RuXLldPzxx+uJJ57Q3r17o1sxSkcAAQQQ8KTALbfcIrvcxsSJE1W6dGlPtoFKI4AAAgjEjgBBxdjpa1qKAAIIIBAmgfLly+vpp5/Wt99+qzlz5jjBRTtljYQAAggggEBhBW6//Xbn98j999+vMmXKFPYyzkMAAQQQQCBqAgQVo0ZPwQgggAACfhOoW7euPvnkE73xxhsaNGiQzjzzTM2fP99vzaQ9CCCAAAIhFrj77rs1c+ZMTZkyxRn5HuLsyQ4BBBBAAIGwCBBUDAsrmSKAAAIIxLJAmzZt9MMPPzg7d3bq1Em9evXS2rVrY5mEtiOAAAII/IOAHZk4depUTZs2TRUqVPiHsziMAAIIIICA+wTizGLArLruvn6hRggggAACPhHYsWOHHn30UQ0bNkx33HGH8/DCwvu7d+/Www8/rD///NPpia+//lrHHnusqlWr5mzYYncmbd++vU96iWYggEAsC0Tqfrdy5UodddRROaj/7//+Tx9++KGmT5+uSpUq5XiPHxBAAAEEEHC7AEFFt/cQ9UMAAQQQ8IWA/TJ51113ae7cuXrqqad08cUXu7pdW7dudTYLyK+ScXFxzo7XdpoeCQEEEPC6QCTud6tXr1adOnX0zTff6LTTTnPI7B+cRowYoRkzZqhq1apeZ6T+CCCAAAIxKEBQMQY7nSYjgAACCERPYNasWbK7e9pdPYcMGaKmTZtGrzKHKPnss8/Wl19+meesww47TBMmTFDr1q3zvMcBBBBAwIsC4b7fnXPOOfriiy9UqlQpff755/rqq6/05ptvOgHF6tWre5GMOiOAAAIIICDWVORDgAACCCCAQAQFWrZsqe+//17XXXedunbtqquuukpr1qyJYA0KX1Tfvn1lA4i5U2Jiolq1apX7MD8jgAACnhUI5/1uyZIlmj17trN0hJ1qbTfxGjt2rHOMgKJnPzJUHAEEEEDACBBU5GOAAAIIIIBAhAXs9OGrr75av/32m2rXrq2TTjpJdl2tPXv25KiJXc/QTomzm75EI3Xr1k379u3LUbQNKF555ZWybSAhgAACfhEI5/3ugQceUGpq6gEqe19dsGCBli5deuAYLxBAAAEEEPCiAEFFL/YadUYAAQQQ8IVAmTJl9J///Efz58/XsmXLdNxxx+l///ufM5rFNvCRRx7R9u3bnWnGP//8c8TbbKdod+zYMUe5JUqU0DXXXJPjGD8ggAACXhcI1/3Orqc7ceJEpaen5yCyf0Tq0KGDfvrppxzH+QEBBBBAAAEvCRBU9FJvUVcEEEAAAV8K2NGKNpj4wQcf6Pnnn3cW8Z86daqzgL8d0ZI1XW7dunURb7+dpp19CnT58uXVuHHjiNeDAhFAAIFwC4Tjfmf/OJSRkZFv1e3xwYMH5/seBxFAAAEEEPCCQKIXKkkdEUAAAQQQiAWBFi1aOLtD2wBjr169Dkw9zszM1JYtW3TWWWc56zHaETWRSu3btz/whTg5OVm9e/eOVNGUgwACCERUINT3u7Vr1+q9997LMfXZNqhs2bKyayk+8cQTbHgV0R6mMAQQQACBUAswUjHUouSHAAIIIIBAEAJ2rcIqVao4QcTso1vS0tJkp9HZzV1yT6MLorhDXpqUlKSePXsqPj7eediNZUgIIICAHwVCfb97/PHHDyxnYb3skhcNGjTQyJEjnTV17b3VrptLQgABBBBAwKsCcWb0Q6ZXK0+9EUAAAQQQ8JuADRgeffTR+uOPP/Jtmh2leOmll+r111/P9/1wHJwxY4az9pedpm3XfiQhgAACfhUI1f1u69atOvzww5WSkuIEE+vWraunnnpKdjQkCQEEEEAAAb8IMP3ZLz1JOxBAAAEEfCEwe/ZsJ6Bo1zHcuXNnjlEutoF2fcVRo0Y5m7rccsddWrltd9jbXfWEfzlfjFu276SfN+0Me3mlExNUp3ypsJdDAQgg4B2BPWkZnrrfPXbffc5988TGTXTHQ4PUvGUrBzv3PZT7nXc+g9QUAQQQQCCvACMV85pwBAEEEEAAgagK/PLLL/ruu++cx5w5c7RkyRLZnUJLlizpfEm1m7fYaXoDnnpRzTt2i2pdw1V4y1qVVa10criyJ18EEPCYwJTlG7QrNc0ztV6/5k9tWb9W9Rs3PWSdud8dkogTEEAAAQRcKkBQ0aUdQ7UQQAABBBDILrBx40YtXLjQedjRjPPmzdP6DRv04uRZqlyjZvZTPf86KT5Opx5RiaCi53uSBiAQOoHpqzZqc0pq6DJ0SU7c71zSEVQDAQQQQKBYAgQVi8XGRQgggAACCERfgC/Z0e8DaoAAApER4H4XGWdKQQABBBBAoCgC7P5cFC3ORQABBBBAAAEEEEAAAQQQQAABBBBAAAERVORDgAACCCCAAAIIIIAAAggggAACCCCAAAJFEiCoWCQuTkYAAQQQQAABBBBAAAEEEEAAAQQQQAABgop8BhBAAAEEEEAAAQQQQAABBBBAAAEEEECgSAIEFYvExckIIIAAAggggAACCCCAAAIIIIAAAgggQFCRzwACCCCAAAIIIIAAAggggAACCCCAAAIIFEmAoGKRuDgZAQQQQAABBBBAAAEEEEAAAQQQQAABBAgq8hlAAAEEEEAAAQQQQAABBBBAAAEEEEAAgSIJEFQsEhcnI4AAAggggAACCCCAAAIIIIAAAggggABBRT4DCCCAAAIIIBASgfS0NP2y8IeQ5EUmCCCAgJsFuN+5uXeoGwIIIIBApAQIKkZKmnIQQAABBBBwmcDHw17UNac1Us8GNbVozuw8tUvZvVtXNq3vvD/kzpu1Y+uWPOdkHfhlwfe6o0c7PXT1hVmHeEYAAQRcI8D9zjVdQUUQQAABBHwkQFDRR51JUxBAAAEEECiKwPl9++tfZ57tXDLxndfzXDpj3EfavXOHEpOS1G/wEB1WoWKec7IO1DuliTpf2TvrR54RQAABVwlwv3NVd1AZBBBAAAGfCBBU9ElH0gwEEEAAAQSKI1C2fAVVrlFT3305Vev+XJ0ji2kf/E8N/tVcySVLOYHFHG/m80NiUnI+RzmEAAIIuEOA+507+oFaIIAAAgj4R4Cgon/6kpYggAACCCBQLAE7wjAzM1OTRrx54PqlP8xTtSNrmYDj4QeOff/V57qu9b/0v2cHa8+uXRpyVz9n+vSy+d8dOIcXCCCAgJsFuN+5uXeoGwIIIICA1wQIKnqtx6gvAggggAACIRY4vumpOvr4Rvr8w1FOsNBmP3nUcJ17ea8cJTU5s62q1DzCmRJdqkwZXXbrQLPO4malpabmOI8fEEAAAbcKcL9za89QLwQQQAABLwoQVPRir1FnBBBAAAEEQigQFxenzlf1cYKFX439QNs2b9JfK37TCc1b5CklKfngFOcDr831JAQQQMALAtzvvNBL1BEBBBBAwCsCBBW90lPUEwEEEEAAgTAKtOx8nspVqqyJ776hz8xaiudccHkYSyNrBBBAIHoC3O+iZ0/JCCCAAAL+EiCo6K/+pDUIIIAAAggUScCupZiZkaGk5BJqf/GVZoTi75ow/DW17tbzH/Ox55MQQAABrwlwv/Naj1FfBBBAAAG3CxBUdHsPUT8EEEAAAQTCKLBz6xZnurMtouOlVyshMVGtupyvkqVLO6Xu2LJZ+1L2KHXfPufnytUP128/LdTObVs174upzrFtmzY4z/acjPR0Z9MX5wD/QQABBFwkwP3ORZ1BVRBAAAEEfCGQ8LBJvmgJjUAAAQQQQCDGBFZu2609acUfNTj8iUc0fexH+m3RAh1xzLE6qkFDZ6Ri9z436bAKFTXq+Sf09eTxSt27V3+vWqFGp56hSiaoOHnk285oxtr1j9fyxYsUFx/vTJ3+8JXntHnd39prgpAnnd5adu2y4qQEc92R5UqpTFJCcS7nGgQQ8KEA9zsfdipNQgABBBDwvECcmQaQ6flW0AAEEEAAAQRiUGD6qo3anBL5nZf37U1xtJNLlJR9bZ9DmZLi43TqEZVUrfTBTWFCmT95IYCA9wS433mvz6gxAggggID/BRL930RaiAACCCCAAAKhFMgeRMz+OpRlkBcCCCDgBoHs97jsr91QN+qAAAIIIIBAtAVYUzHaPUD5CCCAAAIIIIAAAggggAACCCCAAAIIeEyAoKLHOozqIoAAAggggAACCCCAAAIIIIAAAgggEG0BgorR7gHKRwABBBBAAAEEEEAAAQQQQAABBBBAwGMCBBU91mFUFwEEEEAAAQQQQAABBBBAAAEEEEAAgWgLEFSMdg9QPgIIIIAAAggggAACCCCAAAIIIIAAAh4TIKjosQ6juggggAACCCCAAAIIIIAAAggggAACCERbgKBitHuA8hFAAAEEEEAAAQQQQAABBBBAAAEEEPCYAEFFj3UY1UUAAQQQQAABBBBAAAEEEEAAAQQQQCDaAgQVo90DlI8AAggggAACCCCAAAIIIIAAAggggIDHBAgqeqzDqC4CCCCAAAIIIIAAAggggAACCCCAAALRFiCoGO0eoHwEEEAAAQSKKZCSnlHMK919WWpGprsrSO0QQCDiAtzvIk5OgQgggAACCBxSIC7TpEOexQkIIIAAAggg4DqBPWkZWrVttyvqNfb9UdqbskcXXd0r6PqUSkpQnXKlgs6HDBBAwD8CkbjfLf9lmT4a+a7uevg/EYPjfhcxagpCAAEEEAiDQGIY8iRLBBBAAAEEEIiAQKnEeDWoXDYCJR26iEoXnKd69erpxisvVdWqVQ99AWcggAACRRCIxP1u6bo/tHH1CtfcV4vAw6kIIIAAAghERYDpz1Fhp1AEEEAAAQT8JVCtWjVddtllGjJkiL8aRmsQQCBmBNavXy97LyMhgAACCCCAQOEECCoWzomzEEAAAQQQQOAQAgMHDtSrr76qnTt3HuJM3kYAAQTcJ7BhwwbVqFHDfRWjRggggAACCLhUgKCiSzuGaiGAAAIIIOA1gTp16qhjx456+eWXvVZ16osAAgho3bp1qlKlChIIIIAAAgggUEgBgoqFhOI0BBBAAAEEEDi0wD333KPnnntOe/fuPfTJnIEAAgi4SIDpzy7qDKqCAAIIIOAJAYKKnugmKokAAggggIA3BBo1aqRTTz1Vb7/9tjcqTC0RQACB/QIbN25U9erV8UAAAQQQQACBQgoQVCwkFKchgAACCCCAQOEE7GjFxx9/XOnp6YW7gLMQQAABFwisXbuW3etd0A9UAQEEEEDAOwIEFb3TV9QUAQQQQAABTwi0aNFCtWvX1vvvv++J+lJJBBBAwAow/ZnPAQIIIIAAAkUTiMv8f/buA06q6vz/+HcLuyxLRxZBASsgYAEUBcSOkagYhGjsoAixRPlHEyQayy8mtlixRKNGsJDYYrBBFFQUVIjSRAWVJqCIVFnYvv/nzLDLdnZ22p25n/t6zc7MLeee837uXpfHc+6xJbRD2BsBBBBAAAEEEKhb4M0335SbDXrhwoV178hWBBBAwAMCJSUlysjICDwPNi0tzQM1ogoIIIAAAgh4X4Ceit6PETVEAAEEEEAg4QQGDx6slJQUvfHGGwlXdyqMAAL+E9iwYYNatmwpEor+iz0tRgABBBBouABJxYbbcSQCCCCAAAII1CEwfvx43XbbbXXswSYEEEDAGwIMffZGHKgFAggggEBiCZBUTKx4UVsEEEAAAQQSRuCXv/yl1q5dq1mzZiVMnakoAgj4U2D9+vXM/OzP0NNqBBBAAIEwBEgqhoHHoQgggAACCCBQu4AbRlg2E3Tte7EFAQQQiL/AunXrmPk5/mGgBggggAACCSZAUjHBAkZ1EUAAAQQQSCSBiy66SHPnztWiRYsSqdrUFQEEfCbA8GefBZzmIoAAAghERICkYkQYKQQBBBBAAAEEahJws6lec801PFuxJhzWIYCAZwRIKnomFFQEAQQQQCCBBEgqJlCwqCoCCCCAAAKJKHDZZZdp6tSpWr58eSJWnzojgIAPBEgq+iDINBEBBBBAIOICJBUjTkqBCCCAAAIIIFBRoGnTprr88st15513VlzNZwQQQMAzAiQVPRMKKoIAAgggkEACJBUTKFhUFQEEEEAAgUQVGDt2rCZPniw3GQILAggg4DUBkopeiwj1QQABBBBIBAGSiokQJeqIAAIIIIBAggvssccecpO23HvvvQneEqqPAALJKPDjjz+qXbt2ydg02oQAAggggEDUBFJKbYla6RSMAAIIIIAAAgjsFPj22291yCGHaMWKFWrRogUuCCCAgGcE3D1p5cqVatmypWfqREUQQAABBBDwugA9Fb0eIeqHAAIIIIBAkgh07NhRQ4YM0UMPPZQkLaIZCCCQDAL5+fnasWMHCcVkCCZtQAABBBCIqQA9FWPKzckQQAABBBDwt8AXX3yh4447LtBbMSsry98YtB4BBDwh4HpR9+vXT6tXr/ZEfagEAggggAACiSJAT8VEiRT1RAABBBBAIAkEDjroIPXv319PPPFEErSGJiCAQDIIMElLMkSRNiCAAAIIxEOApGI81DknAggggAACPhYYP3687rrrLhUVFZUrMCt0OQUfEEAgxgIkFWMMzukQQAABBJJGgOHPSRNKGoIAAggggEDiCJxwwgkaOXKkunfvrhtuuEFTp06V+4d927ZtE6cR1BQBBBJWYPDgwfrqq68CMz4XFxeroKBA5557rnJycnTEEUfI9apmQQABBBBAAIG6BdLr3sxWBBBAAAEEEEAg8gJnn322rrnmGm3btk15eXlq1qyZlixZQlIx8tSUiAACNQhs3rxZ33zzTeBVtvmzzz5TRkaGcnNzA/em7Ozssk28I4AAAggggEANAiQVa0BhFQIIIIAAAghER+DDDz/UJZdcolWrVgX+4V7xLGvWrKn4lc8IIIBA1ARcr8T58+cH/qdG2UkKCwuVkpKiyy67TCQUy1R4RwABBBBAoHYBkoq127AFAQQQQAABBCIosGDBgsAkLTUVmZ+fr7Vr19a0iXUIIIBAxAWOP/54paWlVSvXJRXHjRtXbT0rEEAAAQQQQKC6ABO1VDdhDQIIIIAAAghEQeDQQw/VlClT1Lhx42qlu+eZrVixotp6ViCAAALREOjZs2egV2LFsl1C8aSTTlLnzp0rruYzAggggAACCNQiQFKxFhhWI4AAAggggEDkBU4//XQ999xzNSYWv/7668ifkBIRQACBWgQGDhxYaUtWVpZuuummSuv4ggACCCCAAAK1C5BUrN2GLQgggAACCCAQBYGhQ4dq0qRJcv+Ar7isXr264lc+I4AAAlEVOOOMM9SkSZPycxx44IGBmZ/LV/ABAQQQQAABBOoUIKlYJw8bEUAAAQQQQCAaAr/85S/15JNPVkosfv/999E4FWUigAACNQqccMIJ5eubNm2qW265pfw7HxBAAAEEEEBg9wIppbbsfjf2QAABBBBAAAEEIi/wzDPP6NJLLw3MwJqeni43+yoLAgggECuBVq1aafPmzdpzzz3lZqBPTaXPRazsOQ8CCCCAQOIL8F/NxI8hLUAAAQQQQCBhBc4//3w9/PDDgR6LJSUl2rRpU8K2hYojgEDiCbjeipmZmbr++utJKCZe+KgxAggggECcBdLjfH5OjwACCCCAAAI+Fxg5cqQapxfr3Asv1f9mPK1B/btIBZZcLNwilRTsfFkPxhJ7pdj/D01pJKW6V4aUni1ltLBXK6lRSymztZTVIbiPz12j0nwXj+3fSvkb7PWjxcneC3+SivN2xcrFKDUzGJ80m+k7s03wlWHvWXva55yoVI1CEagkULhZylsXvJcU2Oda7in99s3Vy/n5GjUwV1r6IPeUSogR+MI9IwKIFIEAAgh4V4Dhz96NDTVDAAEEEEAgiQTsaSvblklbv7TXEmnjp8H3HWuCCSrXUpeASkkJtrm0RCotspd7t5fce7G92/aUNHt3yUX3ss+Bl60PPNHF9ivabomBplJjS15ld5Ja9ZJa9JCad7P37pZ8tCQkS90CLiGzaYG02V4/fmzvCy2ZaLFyiV6XyHX+bnExKY+Ti4+LlVvs/1sHkos74xPY364BlxgutVdjSy5m7yu1PdLi01tqeYjF5iA7bme5gTL4gUBdAtxT6tKJ+TbuGTEn54QIIICAeK/q/QAAQABJREFUFwRIKnohCtQBAQQQQACBZBPI/0Fa9660fpb0w0xLIH5uSSbrWZhqSaaiHcFebTFrsyUcXSLMJR+L7dwZ1qOx9eHSnsdJewyQ2vS1bT4fvOF6cX03Tfr+v/aaLu2wSXPSbHbu0nyLl/VCjNbiksguAewW16PJJRg7/FxqPygYF5dEZkHACXBP8dZ1wD3DW/GgNggggECcBEgqxgme0yKAAAIIIJBUAiWWfPr+bWn1K9LaqcEEQKr1PHRDY+XROeHc8GnXO7LEkmat+0h7n2GvoVIzG37thyXvO2nF0/aabD0RLembZkOWiyxe8Q5XWiNLPltC0/V67HCatO8FlmT8WTAp7Ie40MagAPcU710J3DO8FxNqhAACCMRZgKRinAPA6RFAAAEEEEhYAfePfpdEXDbREoozgkkpLycRdwftkmpuyK579t8+50j7jbAh0zZcOpkWN1R51Yv27LgHbAj6J9aynb03vdpG11Exvbn9sEznfhdKXa7yT9LXqzGJZr24p0RTt2Flc89omBtHIYAAAj4RIKnok0DTTAQQQAABBCImsHm+tMQmNFhpPdzcsOHCrREr2jMFpbpnAlqPuaadpa6WyNrHesuVDdP1TCVDqEjRNumrR6TPb7cOgPZMw0DyN4TjvbBrICYWl7b9pYNvsvdjvFAr6hAJAe4pkVCMbBncMyLrSWkIIIBAkgqQVEzSwNIsBBBAAAEEIi6wznojLrjeJvBYaIkp66UYmDgl4mfxXoGN7HmMbhKYLldK3X5rk4y0814da6uRmxTlq8csbn+wNlgvRTeJTTIsLsHbprfUZ0JwkpdkaJMf28A9xXv3FO4ZfvxNpM0IIIBAgwVIKjaYjgMRQAABBBDwicDGudJHo6Tcb6yHW65PGl1DM93waDc7cdcrpJ7WU87rPRdd3N4fHpxduygJ4+aGqruY7HuR1Ptu+9ykhqCxypMC3FOCYfHaPYV7hid/XagUAggg4GUBkopejg51QwABBBBAIJ4CBRukD0cGJ2BxsyazBAXSbRIRNzS678NS5/O8p+J6kM67xnooPmqzXUdx5mavtNzFwz138bhXbcKdI7xSK+pRkwD3lJpU7PqN8z2Fe0bNcWEtAggggMBuBUgq7paIHRBAAAEEEPChwJr/SLOtB1iJJROLC3wIUI8mp9uw6JxjpX7/kDJz6nFALHYpkd48TPrJepUmy1Dn+rK5mbyPtETqPjahC4v3BLin7D4mcbmncM/gnrH7S5M9EEAAgdoESCrWJsN6BBBAAAEE/Cqw6EbpCxtO6rekVEPinZZhvYxaSINm2kzR3RpSQuSOKdgovXGIlLfOksH2/ES/Lv2ftsTi+X5tvTfbzT2l/nGJ5T2Fe0YwLtwz6n99sicCCCBQRYCkYhUQviKAAAIIIOBrAfeP/0V/8jVB6I1PscSi9Vo87XOpScfQD4/EEYVbpGlHWg/FpcFJZSJRZqKWkWLx6PNAcGKdRG1DMtWbe0oDohmDewr3jF1x4Z6xy4JPCCCAQIgC9oRrFgQQQAABBBBAwATm2czGi++EImSBUuvVuU16pVMwqRfy8RE44EMbqp67koSio3Qzdc/7vbRhTgRgKSIsAe4pDeSLwT2Fe8au2HDP2GXBJwQQQCBEAZKKIYKxOwIIIIAAAkkpsPwfNrHHYzZsNj/s5m3dLm2z+UFK7FFd9VkKbaTuAsuHueN+sA53+YX1Oaph+6yxEcKLV1c/1p1zU7gTJLveLm8fZzNkWyNiuSyfZJPpTA97Upb6xs39+9vFq77xrYsiavFwEwu9N8RMwg1qXbVnW50C3FO8e0/hnlH90uWeUd2ENQgggEA9BEgq1gOJXRBAAAEEEEhqgfz10tyrrLdd+AmYz76Vrn1O+m6zdJXlugp282i/OTafyKDbpIfftol7R0sdrpDWbIq89r8+lHr/QXrJOq81zaxe/ujHpfH/rL4+pDUu21ZgDZ8/PqTDwtq51IBdrzzXUzKMJZS4uYTiYWb5/pKGnzAm8XAmXz/R8EpyZMMFuKfIs/cU7hm1X9fcM2q3YQsCCCBQiwBJxVpgWI0AAggggIBvBNykLO4fmmEuH38dTCTec7504J7SqOOkX9xj+a7i2gu+5SVpuD0K8NFLpMdGWccyy8ulWoe/cJa7X6989G+ekn77jPTqtVa/U6TObStvf/VTadIHldc1+Jvr7bLMen26yVJisax60boMWrfQMJZQ43awjfJ+0/KY/Q+s30njFg+XJP/Mng9aWscFWL8msFeoAtxTvHtP4Z5R+9XMPaN2G7YggAACtQiQVKwFhtUIIIAAAgj4Q8CyeN88HvbQWWf1m4nSjUOtJ2DjoNxh+9iEyFnS03Uk7FxPxVY2x4lbDuscfA/l546Cynu/bD0Rb5uya90LH0sPviU9fqm0V+td68s+bbTObI+8bcnPPmVrIvFuf16tnByJgnZfxqoXrHdkeMOtQ41bmjXvlENtbpq0XdVznTTd4t7LPrvvcY+HS/Ju/dxVhSVmAtxTPH1P4Z5R928C94y6fdiKAAIIVBEgqVgFhK8IIIAAAgj4SiB3RUQSiq/Pk77dIB3TrbLe8L7Sn/5tp6jh+YqXPSn9aEm9R6dLFz8q3Wy9Fisu7nl7Q62n4xnWkbKXDbf98yu7nuM35RPpwkekSx4LDmv+zoZMu/O7odc/WR7p9L/aiG5LWLqekO2aS8tthPd1/5RmLK54hmAPxr+cJTVKr7w+rG/F220Md5XukmEVWMfB62fVsXH3m0KNm+t1+tB/pSNukF6zmLvnUF75lLTn5dIT70idrpI6/kb6fLVX4mEJrjCNdq/IHpUEuKfI0/eUMH8fuGdUutr5ggACCPhegKSi7y8BABBAAAEEfC2Qu0pKaRQ2gXu+XrcONnS5yl8WnfYIJvSW/VD9FI9cbKe21f9vsPTkGEsqDtu1j5sExCUGXZLyP9dIE38dTDpOsISWW35tCckBXaTnrgye86W5lsxqI409RWppPR/dUGf3ffEa6zln+7sejS7xeOJfbOju/EARgV50na1+rkdlxBc3E3MslgJrVBhLqHFzc9G4HqX/Wx48acsm0r5tbYKdrdI6e733RynDErSup5Yn4uF6He34LgwhDg1ZgHuKt+8p3DPqvqS5Z9Ttw1YEEECgikAk/798laL5igACCCCAAAJ+EViy1noEtqje2o6tg+vcdvecxfous7+y+UcsL/e89XxzyyGdpEMtmeV6NV5tiUM3nLn3PtIsS2aut2TW8gpJS5eodMvnllB0y99HSUP6BHs5LrSJZCZ/aD3t9rfEl5X1xu+C+/j1Z6hxc0OfnZ1b3DBnl2Tsvlfw++gTpD2aSX1t++qNwXXuJ/HYZcGn+guEem3urmTuKbsTqt/2UOPCPaN+ruyFAAIIJKpAlf4EidoM6o0AAggggAACDRLItmxdaWGDDq14kOsJWGJJpqpLWxt67JbNNiI4lGXlj9X3PuoAaYUNY3aL6x13gQ1/XrAq2COu4rldosstZUnOxjs7YrpelEdb78a3Fkl3vipts/lNXI9HN4TaPdvx3S+Cn2saqh0sMYSf2ZYBjcWS0Sqss4QTtzLnqhVwPRUrXgpl+8UlHmn2UM+s9lWryPdoCnBP8fY9hXtG3Vc/94y6fdiKAAIIVBEgqVgFhK8IIIAAAgj4SiB7HymtcdhN7mJ5m7U1jMR1z9xzixsKG8rSoWVw7w+tx2LZkm5/tbjJVlwy8NS7pJHHSJcPksqShmX7lb3vl2P5JEsofrqibE1waK6bGObortJxB0k5lvR0L1dGpiXD3OeynnW7jgrxU5qNCd7r1BAPauDubQc08MDgYZGOW12ViU88LJphGtXVJrbVIMA9xdv3lDB/H7hn1HDNswoBBBDwsYD9+cyCAAIIIIAAAv4VsKTL/qOkJfeHNWFLz47BiTuqOrrJVlwysGyIbMXteda70fVoKyoJrs0vCr67noL9DpT2secdvrnAeiQODK7/2HoTnmc5NPd8RjfxiktYuvIX2ZBm13Nxq/WGbJIZ7BW5xT6v2yJdZUOlXRnXDalchhsO7V5li+sB2cJygbf9qmxNOO/WgM7nhFNA/Y/t9Etr6PQGzwDdkLjl5gerV/ZeFjf3HEy3uPVuQhe3xD0ertdR8+7ByvAzRgLcUxy0Z+8p3DPq/j3gnlG3D1sRQACBKgL0VKwCwlcEEEAAAQR8J3CQzWqSEt7/Zzy3v+W1LClYdUKWV+dJw/paZzHrAVh1uf754JoHptow5pXS7VOC390sz2425heultxz0H7zVHAWaNfbcdzp0sEdpf6WdLx6UnD48um9pWdmSW6yFtf7sL31cuzxe5uYZbPN/jwsmHAcfp90wp+tx6T1dLzm51VrEpzsJdVyIWEv7h+k+420ro/twi6qXgV0Gm6Vb3hP01Dj5nqJjpscrJmbjGXecpsN+q3g91stbu/ZEHL3cnF79/M4xyM9W+r5R7u20+pFyU4RFOCeEpi0ypP3FO4ZtV/o3DNqt2ELAgggUItASqkttWxjNQIIIIAAAgj4RWD5P6S5v7EuZjvHKzeg3U++a0mmFdKEEcGDXW/Bk2y2ZTdDcyiTtASPDv50vd+++l5yQ5ZzqkwEk2sJruyd+bT8Qhu+3Ch4jHtOoPvHfNl3t9bVxS2uN2LUFvfwwMZ7SqdZVq1RlcpG7aRW8HLLrs69wmK3rUFniUbcKlYkbvFwid0zvrHh/XbxsMRegHtK+ObRuqdwz6g5NtwzanZhLQIIIFCHQNrNttSxnU0IIIAAAggg4AeBVr2sq6HNjvLjRw1uba99gj0Ol3wndesgnfWA9T60UcBu1uaGLu7f1G5G4bLkYcVy3IQgZUt6hc5ojexzxe9uH/fMxNqevVhWRtjv6U2ln31oD3LcK+yiQiqg1aHShjk27niljSffOYY8hAKiEbeKp49LPFyP0ROm2YWzb8Wq8DmWAtxTwteO1j2Fe0b12HDPqG7CGgQQQKAeAvRUrAcSuyCAAAIIIOAbgY8vlVba+NYweixOtWcYdrKhyq6n4P7WWSzpF5f5dAM/fmFJvSad4tPcQnuA5LQjpZ++trrsfKBhiDVJmrilW3fUw+6QulgXWZb4C3BPCT0GsbincM/YFRfuGbss+IQAAgiEKEBSMUQwdkcAAQQQQCDpBRbac+i+vMcSizvHDCd9g8NoYFqGDXVuKQ2aKTXrGkZBETi02OL1Lxvqm2rZ3BIbD+7XpdddknumH4t3BLin1D8WsbyncM8IxoV7Rv2vT/ZEAAEEqgiQVKwCwlcEEEAAAQQQMIE1/7HZNi6y5NQOmxXaHlLIUl3APdQ/51ibqvof1i0zp/r2eKwptnjNGGRTY88Pq7dpPKoe9jld767j35D2PCXsoiggCgLcU3aPGo97CvcM7hm7vzLZAwEEEKhVgKRirTRsQAABBBBAwOcCBRukD0dK39s0vy65aCN8WUzAPXvL9QY84iFpn/O9R+KGP8+7xma4edQSwjabTbIv6RaPdJte/LhXpdZHJHtrE7t93FNqjl+87yncM2qOC2sRQAABBHYrQFJxt0TsgAACCCCAgM8FNs6VPrpE2rbMf73fKoY+LdO+pUpd7Vl9PW+0RJZNzOLlxcXt/eFSviWHw3hGpmebmGKxcDHZ13rU9r7bPkdzam/PKiRmxbinBOPmtXsK94zE/H2i1ggggEAcBUgqxhGfUyOAAAIIIJBQAuum2/TON9jQ2oXWazHfei82bEKQhGqzq6wbkui6abqJP7r91qaRbpc4TSi1Zyt+9ZjF7Q/WhKLkeU6mS+i26S31mSC1PCRx4kFNKwtwT/HePYV7RuVrlG8IIIAAAnUKkFSsk4eNCCCAAAIIIFBNYLM9r2+pDf1d8ZyUki4Vbq22S8KvSLV2pdgQ56adrWfi1cFhzl7vmVgXetE2Sy4+In1usyKX2DMyC3+qa29vbgvExOLStn+wp6h7niVLcghwT/FeHLlneC8m1AgBBBDwoABJRQ8GhSohgAACCCCQEAIl1ltx9SvSson23MUZwaGogWSV9epLxMUNRXRDajPaWBLxHGm/EVLz7onYktrr7HorrnrRksIPSBs/sf3S7LmL9rxMry4290rgeYmup+h+F1pv0atslu0uXq0t9QpXgHtKuIKRP77KPWP91lQVFeSpfavInyoiJXLPiAgjhSCAAAL1FSCpWF8p9kMAAQQQQACB2gVcMsBN6OKSjN9Nk/LW2eMHG+/sEefRJGNaRqCOD7yeq6LMvTX2qjFK7TTMP0mrvO+st+nT9posbf68QlK49jDHZEua9RBNtclXVCJ1OM2emXiB1P5nlvC1BCiLfwQS+J6iEpsgqVUfqeMZ0t5Dk+ae8tbr/9SIkaO16KHOal28lHuGf34baSkCCCBQqwBJxVpp2IAAAggggAACDRbI/0Fa967042x7f0/a+kVwOLHrCehmJHZDcGO1pFjXFTeJh0tKuXNnWBebNodL7Y6T9higLelddMYvhqmgoEATJ07UgQceGKuaeec8BZuCyeDv3womh3d8b2aW2HOJnWjOIO1i44aVu7xzqV0Trew5iR1+bknEQRajvrbSdTtiQcAEEuieojY2C7l7NESSLIWFhfrjH/+oZ599VpMmTdLxxx8vcc9IkujSDAQQQCA8AZKK4flxNAIIIIAAAgjUS8CyRtuWW3Lxy+Br47zge95a69X4o5Vg210SyyWZ3FJqvdTcsDv37nqsuUlh3Ge3PdBjzZKTLkHpPqfaq9QdZ2WU2n7F2y1R1cwmVMmRsjtLrXtJLXrYUOZu9jpIatTCnaHSUlpaqocffli33HKLrrvuOo0dO1apqVa+X5fCzTYhzwLrwbjQEsMf2fsiaftq63m6xWx3JmiNO+BdFidn716BGO6Mixte7Z6FGEgO2gElNnGMmwgiq73UZB97PuKRwR5drWyyFRcfN7s2CwL1ErDrycP3lHo1IQF2+vrrr3X22WerU6dOevzxx9WmjT0eoqaFe0ZNKqxDAAEEkl6ApGLSh5gGIoAAAgggkAACLlmVZ73jXO+XAktouXc3AYzrKecSUWUvl7BKdcOW3RBZe3c9EDNa7ny1svfWlrDqYDmshvUSWrFihUaMGOHvXot1XS6uh6lLLuavt9cGi5O93HM0Az0aC3TThKkaelIPHdbdkrnuGZVuCLzrGdp4D3u3ZETWnlKmJXtZEIi2QD3uKTdNmGbXa/fg9Rqle0q0mxnN8p966in9/ve/D/zPlssuu6xhp9rNPSPQa939D6LA/Zx7RsOQOQoBBBCIn0DD/uKOX305MwIIIIAAAggko4DrPVhDD8JYN3WfffbRO++8E+i1OGDAAHotVg2A+4d/0/2Cr6rb7PuH30zXgKFDpINOrmErqxCIoUA97ikffjPDrtczuF6rhGXLli0aM2aMFi9erJkzZ6pbN9eLuIHLbu4ZDSyVwxBAAAEEPCLAGBOPBIJqIIAAAggggIA3BFKsN+QVV1yhOXPmaMqUKTr66KO1dOlSb1SOWiCAAAJRFJg9e7YOPfRQtW3bVnPnzg0voRjFelI0AggggIA3BEgqeiMO1AIBBBBAAAEEPCZQ1mvxvPPOU79+/XT33XfLPXuRpXYB9xxKl5RlQSARBLhed0XJ3dv+9Kc/6cwzz9SDDz6oCRMmqHFje3wBCwIIIIAAAnUIkFSsA4dNCCCAAAIIIOBvgbJei5988olee+01DRw4kF6LdVwSJSUlJF7r8GGTtwS4XoPx+Pbbb3Xsscfq3Xff1bx583Taaad5K1DUBgEEEEDAswIkFT0bGiqGAAIIIIAAAl4RcL0WZ8yYIddrsX///rrnnnvkEhIsCCCAQCILvPTSS+rTp4+GDBmit99+W+3b28zsLAgggAACCNRTgKRiPaHYDQEEEEAAAQT8LeB6LboZUN1zxnjWYs3XAsNJa3ZhrTcF/Hy9bt++XaNHj9a4ceP0xhtv6Nprr+XRBd68TKkVAggg4GkBkoqeDg+VQwABBBBAAAGvCey7776BGaJ51mL1yDCctLoJa7wr4NfrdeHCherVq5fy8/M1f/58HX744d4NEjVDAAEEEPC0AElFT4eHyiGAAAIIIICAFwV41qIXo0KdEECgLgE3Gct9992nk046SbfccosmTpyopk2b1nUI2xBAAAEEEKhTgKRinTxsRAABBBBAAAEEahcoe9biueeey7MWa2diCwIIxFnghx9+0Kmnnqp//etfgUc4/OpXv4pzjTg9AggggEAyCJBUTIYo0gYEEEAAAQQQiJuA67V4+eWX86zFuEWAEyOAQF0C06ZN06GHHqrevXvr/fffV+fOnevanW0IIIAAAgjUW4CkYr2p2BEBBBBAAAEEEKhdoKZnLTJDdO1ebEEAgegKFBYW6pprrtGoUaMCPRRvvfVWpaenR/eklI4AAggg4CsBkoq+CjeNRQABBBBAAIFoClR91uLRRx+tr776Kpqn9FTZfp5N11OBoDL1Ekjm63Xp0qU66qijtHz5crmJWY455ph6mbATAggggAACoQiQVAxFi30RQAABBBBAAIF6CJQ9a9HNED1gwADdc8898kOvRb/OpluPS4JdPCiQrNfrE088oX79+mnMmDF6+eWX1apVKw/qUyUEEEAAgWQQIKmYDFGkDQgggAACCCDgOYGyXotz5szRlClT5Hotut5DLAgggEA0BDZv3qyzzjpLDzzwgGbNmqXRo0dH4zSUiQACCCCAQLkAScVyCj4ggAACCCCAAAKRF3C9Ft955x25Xov9+/f3Ta/FyEtSIgII1CbwwQcf6JBDDlH79u3l/kdGt27datuV9QgggAACCERMgKRixCgpCAEEEEAAAQQQqFmgrNfi3Llz6bVYMxFrEUCgAQLFxcW6+eabNXz4cD366KO6//77lZmZ2YCSOAQBBBBAAIHQBUgqhm7GEQgggAACCCCAQIMEmCG6QWwchAACNQisWrVKxx57rGbPnq0FCxZo8ODBNezFKgQQQAABBKInQFIxeraUjAACCCCAAAIIVBMo67X4ySef6LXXXuNZi9WEWIEAArsTeOGFF9SnTx/94he/0LRp09SuXbvdHcJ2BBBAAAEEIi5AUjHipBSIAAIIIIAAAgjsXqDiDNFupta777474WeITk1NlUuasiCQCAKJeL3m5ubqkksu0R/+8IdAMvHaa6/ldy4RLjbqiAACCCSpAEnFJA0szUIAAQQQQAAB7wvU1Gvx66+/9n7Fa6lhSUmJSktLa9nKagS8JZBo1+u8efPUq1evwO/Y/Pnz1bt3b2+BUhsEEEAAAd8JkFT0XchpMAIIIIAAAgh4TaBqr8V77rkn4Xstes2Y+iCQqAIuUe96Mp9yyim69dZb9eSTTyo7OztRm0O9EUAAAQSSSICkYhIFk6YggAACCCCAQOIKlPVa/N///scM0YkbRmqOQEQF1q1bF0gmvvzyy3L3hrPOOiui5VMYAggggAAC4QiQVAxHj2MRQAABBBBAAIEIC3Tu3FnvvPOOzjvvPPXv31/0WowwMMUhkCACb775pg499FAdddRRmjlzpjp27JggNaeaCCCAAAJ+ESCp6JdI004EEEAAAQQQSBiBsl6Lc+fOpddiwkSNiiIQGYGCggKNHTtWY8aM0YsvvqhbbrlFaWlpkSmcUhBAAAEEEIigQIo9o4OnaUcQlKIQQAABBBBAAIFICrg/1R5++GHdeOONuuGGG3T11VfLzVrrhWX79u26+eabtXr16kB1Zs+erQMOOEA5OTmBySRGjhypk08+2QtVpQ4IKBGu1y+//FLnnHNO4Pfo73//u1q2bEnkEEAAAQQQ8KwASUXPhoaKIYAAAggggAACuwRWrFihiy++WHl5eXrqqafUpUuXXRvj9Gnz5s1q1apVjWd3vS0HDRqkadOm1bidlQjEWsDr16tLIo4fP1533HGHLrnkkljzcD4EEEAAAQRCFvDG/+YOudocgAACCCCAAAII+Eug4gzRNT1rcdmyZXKJvClTpsQMxvWiOv7442s8X9OmTXX99dfXuI2VCMRDwAvX6/vvvx/4PX322WfLCTZt2qRhw4bpoYce0qxZs0golsvwAQEEEEDA6wIkFb0eIeqHAAIIIIAAAghUELjiiitU9VmLJSUlOuOMMwLDot3Qya+++qrCEdH9OHr0aDVr1qzaSdLT0zVw4MBq61mBQDwF4nm9bty4UUOGDAk039Vj6dKlgQlYDjnkELkJmubMmaOuXbvGk4dzI4AAAgggEJIAScWQuNgZAQQQQAABBBCIv8C+++5bPkN0v3799Lvf/U7Lly+XSy664dGDBw8OvMeipi5J4iaWqLi4hOIFF1wQ6JFVcT2fEYi3QDyv1/PPPz/wXEdn4H5PTz/9dJ111ll6/PHHA7O8Z2RkxJuH8yOAAAIIIBCSAEnFkLjYGQEEEEAAAQQQ8IZA2QzRzz//vB588EHl5uYGKuYSi2vXrg3MHBuLmjZp0kSnnHJKpVNlZmZqxIgRldbxBQEvCMTrep04caLee++98gS8+z399ttvdeqpp+pnP/uZF2ioAwIIIIAAAiELkFQMmYwDEEAAAQQQQAABbwi4xMTYsWNVVFRUqUI7duzQiy++qIrPbau0Q4S/XHrppZWGQLdo0UK9evWK8FkoDoHICMT6el21apUuv/zy8l6KZa1wv6eTJ0/Wf//737JVvCOAAAIIIJBQAiQVEypcVBYBBBBAAAEEENgl8H//93/65ptvAsOed60Nftq+fbtc8mTJkiVVN0X8+8knn1xeBzeEk5lrI05MgREUiOX16hL/Z555pvLz82tsgUssup6K7nmLLAgggAACCCSaAEnFRIsY9UUAAQQQQAABBHYKHHDAAXJJvKysLLlhnVWXsucrusRFNJdGjRoFZq9NTU0NTBZz4YUXRvN0lI1AWAKxvF7vuOMOffHFFyouLq5UZze5kavH4YcfrjfffFOtW7eutJ0vCCCAAAIIJIJASqktiVBR6ogAAggggAACCCBQs4DrrThjxgxNmTIl8Nw21zvKvVwysXHjxho6dKiee+65mg+O0NqZM2cGelx16tQpJr0jI1RtivGpQCyu10WLFumII44I9FJ0kxe530W3uImUzj77bLkekzXNnO7TkNBsBBBAAIEEFCCpmIBBo8oIIIAAAggggEBdAp9//nlgduhXXnlFH3zwQWCm2Ucmv6hjB0V3QojuezTTxVderWtvvrWu6kVkW5P0NHVukRWRsijEOwI7ikq0Ysv2mFQomtermxH9sA5tAu3Yu/M+On3oMF30q1+qb9++zIoek+hyEgQQQACBWAiQVIyFMudAAAEEEEAAAQTiJDD1mx/0+eJF2qdr9zjVIHqnPbpjG+U0yYjeCSg55gLTlq1XbmHliYdiXokInfDrRQvUKidHbdq1D5TI9RohWIpBAAEEEPCMQLpnakJFEEAAAQQQQAABBCIu0Dg9NSkTio1SUyJuRYHxF8hMS7GkYvzrEYkaHHDwoeXFcL2WU/ABAQQQQCCJBJioJYmCSVMQQAABBBBAAAEEEEAAAQQQQAABBBCIhQBJxVgocw4EEEAAAQQQQAABBBBAAAEEEEAAAQSSSICkYhIFk6YggAACCCCAAAIIIIAAAggggAACCCAQCwGSirFQ5hwIIIAAAggggAACCCCAAAIIIIAAAggkkQBJxSQKJk1BAAEEEEAAAQQQQAABBBBAAAEEEEAgFgIkFWOhzDkQQAABBBBAAAEEEEAAAQQQQAABBBBIIgGSikkUTJqCAAIIIIAAAggggAACCCCAAAIIIIBALARIKsZCmXMggAACCCCAAAIIIIAAAggggAACCCCQRAIkFZMomDQFAQQQQAABBBBAAAEEEEAAAQQQQACBWAiQVIyFMudAAAEEEEAAAQQQQAABBBBAAAEEEEAgiQRIKiZRMGkKAggggAACCCAQbYGfNm+q1ymKCgv13crlNe5b17YaD2AlAg0U4HptIByHIYAAAgggUA8Bkor1QGIXBBBAAAEEEEAAgaDAzSPO0pplX9fJ8cl70zXmhCP03L23V9uvrm3VdmYFAmEKcL2GCcjhCCCAAAII1CFAUrEOHDYhgAACCCCAAAII7BJYuuBTrfhysab9c9KulTV86nPsierW63ClpadX21rXtmo7swKBMAS4XsPA41AEEEAAAQTqIUBSsR5I7IIAAggggAACCCAg/fdfT2ufbj30zsv/Uv6O7TWSlJSUyL3S0tKVkpJSaZ+6tlXakS8IRECA6zUCiBSBAAIIIIBAHQLV//dxHTuzCQEEEEAAAQQQQMCfArk/bQ0Mex5z8+0a/6vTNfPVlzXorPPLMUpLS/XM3X/R2hXLVFSQr68/W6DDBhwb2F7XtvIC+IBABAW4XiOISVEIIIAAAgjUIkBSsRYYViOAAAIIIIAAAgjsEpg55SUNPPUX6nJYH3U8sKumPjexUlLxjaef0JefzNGtz72ikuJijTqmV3lPxbq27ToDnxCInADXa+QsKQkBBBBAAIHaBBj+XJsM6xFAAAEEEEAAAQTKBd759/MaePqZge8nDT838GzFJfP+V779tYl/12EDjwskEt2zFLsfcVS9tpXvxAcEIijA9RpBTIpCAAEEEECgFgF6KtYCw2oEEEAAAQQQQACBoIBLHm74fq3+POaCwIqS4iKlpqVZb8Wn1NUmZMnP26Ef1nyrNu3al5OlpabJMox1bivfmQ8IRFCA6zWCmBSFAAIIIIBAHQL0VKwDh00IIIAAAggggAAC0rTJE3XVnRN0+79eC7zufHGqDj/+ZM2e+pq2bNygRhmZatk2R19W6Lno3NxELXVtwxaBaAhwvUZDlTIRQAABBBCoLkBSsboJaxBAAAEEEEAAAQR2Cmz6YZ0Wz/1IBx91dCWTE848W0WFBZr67D+UmpqqI088RXNnTNOP362x9YWBCVs2rvs+sE9t2wry8yqVyRcEwhXgeg1XkOMRQAABBBCovwBJxfpbsScCCCCAAAIIIOArgU3rf9CfLj1Pm39crw9ef6W87fk7tmvO9KmB71P+8TfrsfiqhlxymZq1bKUrTu6v3w45UQV5ecqz/T77eHad28oL5QMCYQpwvYYJyOEIIIAAAgiEKJBSakuIx7A7AggggAACCCCAQIIIvLvyR23MK4xZbbds+FHNW7dR3vbtysrOrnTeurZV2rEeXxqlpujIvVorp0lGPfZml0QR4HpNlEhRTwQQQAABBCQmauEqQAABBBBAAAEEEIiYQIs2ewTKqppQdCvr2haxClAQAiEI1HVN1rUthFOwKwIIIIAAAkkrwPDnpA0tDUMAAQQQQAABBBBAAAEEEEAAAQQQQCA6AiQVo+NKqQgggAACCCCAAAIIIIAAAggggAACCCStAEnFpA0tDUMAAQQQQAABBBBAAAEEEEAAAQQQQCA6AiQVo+NKqQgggAACCCCAAAIIIIAAAggggAACCCStAEnFpA0tDUMAAQQQQAABBBBAAAEEEEAAAQQQQCA6AiQVo+NKqQgggAACCCCAAAIIIIAAAggggAACCCStAEnFpA0tDUMAAQQQQAABBBBAAAEEEEAAAQQQQCA6AiQVo+NKqQgggAACCCCAAAIIIIAAAggggAACCCStAEnFpA0tDUMAAQQQQAABBBBAAAEEEEAAAQQQQCA6AiQVo+NKqQgggAACCCCAAAIIIIAAAggggAACCCStAEnFpA0tDUMAAQQQQAABBKS84pKkZCgsKU3Kdvm9UVyvfr8CaD8CCCCAQCIJpJTakkgVpq4IIIAAAggggAAC9RfYUVSilVu21/+AGOx5xx/H68Sfn6bD+w1o8NmyGqWpc/OsBh/Pgd4UiPb1+sBttwauvR6HHhZTAK7XmHJzMgQQQACBGAmQVIwRNKdBAAEEEEAAAQQQCArMmjVL55xzjpYsWaKsLBKDXBexE2jfvr3mzp2rvffeO3Yn5UwIIIAAAggkqQDDn5M0sDQLAQQQQAABBBDwqsCAAQPUv39/3XXXXV6tIvVKQoENGzZox44dJBSTMLY0CQEEEEAgPgIkFePjzlkRQAABBBBAAAFfC7iE4oQJE/Tdd9/52oHGx05g8eLFOuSQQ2J3Qs6EAAIIIIBAkguQVEzyANM8BBBAAAEEEEDAiwIdO3bUmDFjNG7cOC9WjzolocCiRYvUvXv3JGwZTUIAAQQQQCA+AiQV4+POWRFAAAEEEEAAAd8LjB8/XtOnT9ecOXN8bwFA9AU+++wz9ezZM/on4gwIIIAAAgj4RICkok8CTTMRQAABBBBAAAGvCWRnZ+u2227T2LFjvVY16pOEAm7488EHH5yELaNJCCCAAAIIxEeApGJ83DkrAggggAACCCCAgAlccMEFKigo0OTJk/FAIKoCbvhzjx49onoOCkcAAQQQQMBPAiQV/RRt2ooAAggggAACCHhMICUlRffff3/g2YpuZl4WBKIhsGbNGmVmZmqPPfaIRvGUiQACCCCAgC8FSCr6Muw0GgEEEEAAAQQQ8I7AgAED1L9/f7kZoVkQiIaAG/pML8VoyFImAggggICfBUgq+jn6tB0BBBBAAAEEEPCIgEsoTpgwQWvXrvVIjahGMgkwSUsyRZO2IIAAAgh4RYCkolciQT0QQAABBBBAAAEfC3Ts2FFjxozRdddd52MFmh4tAZKK0ZKlXAQQQAABPwuQVPRz9Gk7AggggAACCCDgIYHx48dr+vTpmjNnjodqRVWSQeDzzz9n5udkCCRtQAABBBDwlEBKqS2eqhGVQQABBBBAAAEEEPCtwKRJk/Too49q1qxZvjWg4ZEVcP/cadq0qb7//ns1a9YssoVTGgIIIIAAAj4WoKeij4NP0xFAAAEEEEAAAa8JXHDBBcrPz9fkyZO9VjXqk6ACy5cvD8z6TEIxQQNItRFAAAEEPCtAUtGzoaFiCCCAAAIIIICA/wRSUlJ0//33a9y4cdqxY4f/AGhxxAV4nmLESSkQAQQQQACBgABJRS4EBBBAAAEEEEAAAU8JDBgwQP3795ebEZoFgXAFSCqGK8jxCCCAAAII1CxAUrFmF9YigAACCCCAAAIIxFHgzjvvDPRYXLNmTRxrwamTQWDx4sXq0aNHMjSFNiCAAAIIIOApAZKKngoHlUEAAQQQQAABBBBwAp06ddJll10mNyM0CwLhCNBTMRw9jkUAAQQQQKB2AWZ/rt2GLQgggAACCCCAAAJxFMjNzVWXLl3073//W3379o1jTTh1ogoUFxerefPm2rhxozIzMxO1GdQbAQQQQAABTwrQU9GTYaFSCCCAAAIIIIAAAtnZ2br99ts1duxYMBBokMDSpUu11157kVBskB4HIYAAAgggULcAScW6fdiKAAIIIIAAAgggEEeB888/XwUFBZo8eXIca8GpE1WAoc+JGjnqjQACCCCQCAIkFRMhStQRAQQQQAABBBDwqUBKSkpgwpZx48Zpx44dPlWg2Q0VIKnYUDmOQwABBBBAYPcCJBV3b8QeCCCAAAIIIIAAAnEUGDBggPr376+77rorjrXg1IkoQFIxEaNGnRFAAAEEEkWAiVoSJVLUEwEEEEAAAQQQ8LHAqlWr1KtXLy1cuDDwjDwfU9D0OgRKS0sDW10PV7d07do1MNFP9+7dA9/5gQACCCCAAAKRE6CnYuQsKQkBBBBAAAEEEEAgSgKdOnXSZZddpvHjx5efYcmSJXrrrbfKv/MBAffszdTU1MCs4cOGDdOGDRu0YsUKrV69GhwEEEAAAQQQiLAAPRUjDEpxCCCAAAIIIIAAAtERyM3NDSSLJk2apBdffFFPPvlkYBKX4uLiQCIpOmel1EQScNfEVVddJXetuCUjI0NZWVmB68Q9k9P1dD344IMTqUnUFQEEEEAAAc8KpHu2ZlQMAQQQQAABBBBAAIEKAo0bN9bFF1+s0047LbDWzQqdnZ2tb775RgceeGCFPfnoV4EePXooLS2tvPnuGnEvt2RmZmr//fcv38YHBBBAAAEEEAhPgOHP4flxNAIIIIAAAggggEAMBKZOnar99ttP9957r/Ly8gIvd1qXQJo/f34MasApEkHAJRW3b99eraou+fzwww+rSZMm1baxAgEEEEAAAQQaJkBSsWFuHIUAAggggAACCCAQQ4HBgwfLTdZSNqy17NTbtm3Tp59+WvaVd58LNG3aVM2bN6+m0K5dO40YMaLaelYggAACCCCAQMMFSCo23I4jEUAAAQQQQAABBGIkMHv27MCz8aqerqSkRLNmzaq6mu8+FujWrVul1rtein/729947mYlFb4ggAACCCAQvgBJxfANKQEBBBBAAAEEEEAgygL9+vXT+++/rxYtWlR6Zp477eLFi6N8dopPJIG+ffuWV9fNBN2rVy8NGjSofB0fEEAAAQQQQCAyAiQVI+NIKQgggAACCCCAAAJRFujTp09g9t4OHToEZvUtO91PP/2kTZs2lX3l3ecChx12mNwwaLe4yVkeeeQRn4vQfAQQQAABBKIjQFIxOq6UigACCCCAAAIIIBAFgU6dOmnRokVyiaOsrKzAGdzkG0zWEgXsBC3STdbieihmZGTozDPPVM+ePRO0JVQbAQQQQAABbwuQVPR2fKgdAggggAACCCCAQBUBNwT6gw8+0KmnnhqYzdfNBr1gwYIqe/HVrwLdu3fX1q1bA4nFv/71r35loN0IIIAAAghEXSA96mfgBAgggAACCCCAAAIIRFigUaNGeuGFF3T99dfrtttu0/S3pmrsJYOlAhsGXbA5+F64RSop2PkqtHd7pdj/U09pJKW6V4aUni1ltLBXK6lRSxsv21rK6hDcJ8J1prgwBAotpnnr6hXfJi6+towcerj23P6mtJr4hiHPoQgggAACCNQqkFJqS61b2YAAAggggAACCCCAgCcE7E/WbcukrV/aa4m08dPg+441evzNH7RgZakmjLLn6KWkBGtbWiKVFtnLvdtL7r3Y3m17Spq9u+Sie9nnwMvWB/4stv2Ktluy0cpqnCNld5Ja9ZJa9JCa26zCLbpb8tGSVCwRFqg9vsrfEDxXWmOLFfGNMDzFIYAAAggg0GABkooNpuNABBBAAAEEEEAAgagJ5P8grXtXWj9L+mGmJRA/t4SS9SxMtSRg0Y5g78OonbxqwZbIcj0aXfKx2M6dYT0aWx8u7XmctMcAqY3NNpzCAKCqanV+J7518rARAQQQQACBRBAgqZgIUaKOCCCAAAIIIIBAsguU5Evfv21DVV+R1k6VXNIp1XqmFf5kLffowBo3fNr1nivJsyRjH2nvM+w1VGrWJdmjFXr7iG/oZhyBAAIIIICAxwVIKno8QFQPAQQQQAABBBBIWgGXaHJJxGUTLaE4wxJ0md5OIu4uEK7+bkh1Rhtpn3Ok/UbYkGkbLu3Xhfj6NfK0GwEEEEDAJwIkFX0SaJqJAAIIIIAAAgh4RmDzfGnJg9LKycFhw4VbPVO1iFUk1YZDuwlDmnaWul5lScYLgs9pjNgJPFwQ8fVwcKgaAggggAACkRMgqRg5S0pCAAEEEEAAAQQQqEtgnfVGXHC9tGmhDRm2XoqBiVPqOiBJtjWy5zG6SWC6XCl1+61NANMuSRpWpRnEN7njWyXcfEUAAQQQQICkItcAAggggAACCCCAQHQFNs6VPhol5X5jw5tzo3suL5fuhke7Wae7XiH1vCl5ei4S3+BVl6zx9fLvFHVDAAEEEIirAEnFuPJzcgQQQAABBBBAIIkFCjZIH44MTsDiZk1mCQqkZwWHRvd9WOp8XuKqEN+aY5cs8a25daxFAAEEEECgXICkYjkFHxBAAAEEEEAAAQQiJrDmP9Lsi2yYsyUTiwsiVmxSFZRuw6JzjpX6/UPKzEmsphHf3ccrkeO7+9axBwIIIIAAAiKpyEWAAAIIIIAAAgggEFmBRTdKX9wtFW2PbLnJWFpahg2DbiENmmkzRXdLjBYS3/rHKRHjW//WsScCCCCAgM8FSCr6/AKg+QgggAACCCCAQEQFXMJp0Z8iWmTyF5ZiiUXrtXja51KTjt5uLvFtQHwSKL4NaB2HIIAAAgj4V4Ckon9jT8sRQAABBBBAAIHICsyzmY2X2HMC3czOLA0TOH2J1KxLw46N9lHEN3xhL8c3/NZRAgIIIICAzwRs+jkWBBBAAAEEEEAAAQTCFFhuzwX86rGIJBS32qjpbXlWVEn96lRYJC1YKbnjftgi5RfW77iG7LVmo7R4dfUj3Tk3hTuxdYr1aHv7OJsh2xrhtYX4Jnd8vXa9UR8EEEAAgYQQIKmYEGGikggggAACCCCAgIcF8tdLc6+yZyiGm1WTPvtWuvY56bvN0lWTpAJLGNa1zPnGHkd4m/Tw21Lr0VKHK6Q1m+o6omHb/vWh1PsP0ktzpKaZ1csY/bg0/p/V14e0prTUGmwNnz8+pMOivjPxVVLHN+oXECdAAAEEEEhWAZKKyRpZ2oUAAggggAACCMRKwE3KUrqb7F896vLx18FE4j3nSwfuKY06TvrFPZarLK794FtekoYfKT16ifTYKJto2vJyqdbhL5zl7tcrH/2bp6TfPiO9eq3V7xSpc9vK21/9VJr0QeV1Df5WbLNlL7Nen3nrGlxExA8kvskd34hfMBSIAAIIIOAXAZKKfok07UQAAQQQQAABBKIiYFm8b6ybXrGNVw5z+c1E6cah1hOwcbCgw/axCZGzpKfrSNi5noqtbI4TtxzWOfgeys8dBZX3ftl6It42Zde6Fz6WHnxLevxSaa/Wu9aXfdq4TXrkbUt+9ilbE4l3+xN95eRIFBSBMohvcsc3ApcIRSCAAAII+FaApKJvQ0/DEUAAAQQQQACBCAjkrohIQvH1edK3G6RjulWu0/C+0p/+baeo4fmKlz0p/WhJvUenSxc/Kt1svRYrLu75h0Otp+MZ1pGylw1d/vMru57TOOUT6cJHpEvsMZBuWPN3NmTand8Nvf7JOgue/lcb0W0JS9cTsl1zabmN8L7un9KMxRXPEOzB+JezpEbpldeH9a3YHg65pkp3ybAKDONg4qukjm8YlwaHIoAAAgggQFKRawABBBBAAAEEEECg4QK5q6SURg0/fueR79ukx9062NDlKn+ddtojmNBb9kP1UzxysZ3aVv+/wdKTYyypOGzXPm6SF5cYdEnK/1wjTfx1MOk44b/BfX5tCckBXaTnrgye86W5Usc20thTpJbW89ENdXbfF6+xkd12iOvR6BKPJ/5FenN+sAzXq7Gz1c/1qIz4krsy4kU2qEDim9zxbdBFwUEIIIAAAggEBar82QYLAggggAACCCCAAAKxF1iy1noEtqh+3o47hxy77aEss7+S5lle7vTewaMO6SQdasOjXa9Gt7jhzGf0kWZZMnP9VktcVkhaukSlWz63hKJb/j5KuuZU6R+WuHRDrCd/aD0kf7Jhz1bWDb8I7sPPugWIb90+bEUAAQQQQCARBUgqJmLUqDMCCCCAAAIIIOAVgWzL1pUWhl0b1xOwxHUJrLK0taHHbtlsI4JDWVb+WH3vow6QVtgwZrfsa5OtXGDDnxesCvZIrHjulJ1ZxbIkZ+OdHTFdL8qjrXfjW4ukO1+VttljJF2PRzeE2j3b8d0vgp9rGqodPGsIP7Mte+mFhfgmd3y9cI1RBwQQQACBhBUgqZiwoaPiCCCAAAIIIICABwSy95HSGoddkS7tpbU2vLjqsik3uMYNRQ5l6dAyuPeH1mOxbEm3v3zdZCsuGXjqXdLIY6TLB0llScOy/cre98uRsiyh+OmKsjVShj070U0Mc3RX6biDpBxLerqXKyPTtrnPZT0ddx0V4qe0JlZR6xrphYX4Jnd8vXCNUQcEEEAAgYQVIKmYsKGj4ggggAACCCCAgBcELIW2v40PDjOx2LNjzUlFN9mKSwZ236t6W/Osd6Pr3FhUEtyWXxR8dz0F+x0o7WPPO3xzwa7jPrbehOcNkNzzGd3EKy5h6cpf9G0w0bjVekM2yQz2itxin93ELVfZMxZrKmNIH5sl+le7Xr2sY6E7p1tX9bmQu2pQ30/WgM7n1HfnKO9HfF1Mkze+Ub58KB4BBBBAIKkFSComdXhpHAIIIIAAAgggEAOBg2xWkxTrphfGcm5/qcCSglUnZHl1njSsr1Q2DLriKa5/Pvjtgak2jHmldPuU4Hc3y7ObjfmFqyX3bMXfPBWcBdr1dhx3unSwJTD7WwLw6knB4cvuuYvPzJLcZC2u92F76+XY4/c2Mctmm/15WHCo9PD7pBP+bEOlrafjNT+vWIvgZ5dITA27i6KVlZYl7TfSuj62q36SeK0hvoFEcdLGN17XFedFAAEEEEh4gZRSWxK+FTQAAQQQQAABBBBAIL4Cy/8hzf2NdRvcOV65AbV58l2bXGWFNGFE8GDXW/Akm23ZzdB84J7BdaH+dLNAf/V9cMhyTpWJYHLzpOzGwRLzC234cqPgZ/d8R5dAKvvu1rq6uKVFk+B7VH66hzk2toaeZg9nbFSlslE5YQiFEt8QsGrZ1cvxraXKrEYAAQQQQKAuAZKKdemwDQEEEEAAAQQQQKD+AvN+K31xb/33r2HP2/4T7JXoei4Os96BN54ZHFZcw67Jtyq9qTT4E6mZzQbjxYX4hhcVr8c3vNZxNAIIIICADwVIKvow6DQZAQQQQAABBBCImsDHl0orJ4fVY3GqPQexkw1Vdj0F9/fQKOCombkebG7w0C9W2kMdO0XtNBEpmPiGzphI8Q29dRyBAAIIIOBjAZKKPg4+TUcAAQQQQAABBKIisPCP0pf3WGJx55jhqJwkSQpNy7Chzi2lQTOth6JNKZ0IC/Gtf5QSMb71bx17IoAAAgj4XICkos8vAJqPAAIIIIAAAghERWCNjWOefZFUskMqtocUslQXSM+Wco618d32PMrMnOrbvbyG+O4+Ookc3923jj0QQAABBBAQSUUuAgQQQAABBBBAAIHoCBRskD4cKX3/djC5aCN8WUzAzfCcamO7j3hI2uf8xCUhvjXHLlniW3PrWIsAAggggEC5AEnFcgo+IIAAAggggAACCERFYONc6aNLpG3LwnrWYlTqFstC0zLtbKlSV5vOuueNkpu4IxkW4huMYrLGNxmuUdqAAAIIIBAVAZKKUWGlUAQQQAABBBBAAIFqAuumSwtukDYttIlJ8q33YnG1XZJyhRsGK+um2cWSid1shuzGSTr7DPFN7vgm5S8njUIAAQQQCEeApGI4ehyLAAIIIIAAAgggELrA5vnSUhv6u+I5KSVdKtwaehlePyLV2pViQ5ybdraeiVcHhzknS8/E3dkT390JsR0BBBBAAIGkECCpmBRhpBEIIIAAAggggEACCpRYb8XVr0jLJtpzF2fYswZteHDhT9aQBH34oqt/ig1vzmhjScRzpP1GSM27J2BgIlRl4hshSIpBAAEEEEDAmwIkFb0ZF2qFAAIIIIAAAgj4S8AloNyELi7J+N00KW+dPX6wsbeTjGkZwTqW5Emt+kgdz5D2Hio16+Kv2NWntcS3PkrsgwACCCCAQEIJkFRMqHBRWQQQQAABBBBAwCcC+T9I696Vfpxt7+9JW78IDid2PQGLLYlXUhA7iJQU60XZxM6fFjx3RiupzeFSu+OkPQbY5yNsmw13Zqm/QA3xLS5N1w9bU9S+ucWW+Nbfkj0RQAABBBCIkwBJxTjBc1oEEEAAAQQQQACBUARsSPS25ZZc/DL42jgv+J631no1/mgF2fa0LEvuWQLQLaUl9ioKvss+u0lh3Dq33SUH3SzMLkHpPqfaq9QdZ2WU2n7F221m5mZ6/5tmyk/L0UmDTpRa9LChzN3sdZDUqIU7A0sEBb77bq2OObq/rrjwZI0925xjEF81zpGyO0utexHfCMaSohBAAAEE/CNAUtE/saalCCCAAAIIIIBA8goUbrHk4vdSwSZ7bQ6+u7IIec0AACX3SURBVAlg3LDbksJdL5dUTHXDlm0SFffueiBmtNz5sh6IGa2lrA6WbExXXl6ejjzySF155ZW69NJLk9cuzi1bv369Bg4cqJEjR2rcuHE11yYK8a35RKxFAAEEEEAAgfoKkFSsrxT7IYAAAggggAACCPhOYMmSJTr66KP1zjvvqGfPnr5rf7QbvHHjRh177LEaPny4brrppmifjvIRQAABBBBAIIICNuaDBQEEEEAAAQQQQAABBGoS6Nq1q+6//36dddZZ2rFjR027sK6BAlu2bNHJJ5+sUaNGkVBsoCGHIYAAAgggEE8BeirGU59zI4AAAggggAACCCSEwMUXX6ySkhI99dRTCVFfr1fyp59+0oknnhgY9nz33Xd7vbrUDwEEEEAAAQRqEKCnYg0orEIAAQQQQAABBBBAoKLAgw8+qI8//lhPP/10xdV8boBAbm6uBg8erCOOOEIkFBsAyCEIIIAAAgh4RICeih4JBNVAAAEEEEAAAQQQ8LbA4sWLA8//mzVrltywaJbQBdzkN6eeeqoOOOAAPfroo6EXwBEIIIAAAggg4BkBeip6JhRUBAEEEEAAAQQQQMDLAj169NAdd9yhs88+W/n5Nqs0S0gCzmzIkCHae++99cgjj4R0LDsjgAACCCCAgPcE6KnovZhQIwQQQAABBBBAAAEPC5x77rlq3ry5/va3v3m4lt6qWmFhoYYOHaqmTZvq2WefVVpamrcqSG0QQAABBBBAIGQBeiqGTMYBCCCAAAIIIIAAAn4WcMN2p0+frueff97PDPVue1FRUaB3Z0ZGhp555hkSivWWY0cEEEAAAQS8LUBPRW/Hh9ohgAACCCCAAAIIeFBg4cKFGjRokD788EPtt99+HqyhN6pUWloq17PTPUPxpptuUnp6ujcqRi0QQAABBBBAIGwBkophE1IAAggggAACCCCAgB8FHnroIT355JOBxKLrhcdSWcAlFC+66CJ9//33evXVV5WZmVl5B74hgAACCCCAQEILkFRM6PBReQQQQAABBBBAAIF4CgwbNiww8cj9998fz2p47twuoTh69Gh9/fXXeuONN5SVleW5OlIhBBBAAAEEEAhPgKRieH4cjQACCCCAAAIIIOBjgS1btujQQw+VSyqeccYZPpao3PQrrrhCCxYs0LRp05SdnV15I98QQAABBBBAICkEmKglKcJIIxBAAAEEEEAAAQTiIdCiRQu9+OKLGjNmjFatWhWPKnjunNdee63c5CxTp04loei56FAhBBBAAAEEIidAT8XIWVISAggggAACCCCAgE8F7rnnnsBs0B988IGvJyP5wx/+EEgmzpgxQy1btvTp1UCzEUAAAQQQ8IcASUV/xJlWIoAAAggggAACCERZ4LTTTlP37t115513RvlM3iz+lltu0UsvvaR33nlHbdq08WYlqRUCCCCAAAIIREyApGLEKCkIAQQQQAABBBBAwM8CGzduDDxf8bHHHtPgwYN9ReESqW4m7JkzZyonJ8dXbaexCCCAAAII+FWApKJfI0+7EUAAAQQQQAABBCIuMGvWLJ155pmaN2+eOnToEPHyvVigm6RmwoQJev/999W+fXsvVpE6IYAAAggggEAUBJioJQqoFIkAAggggAACCCDgT4EBAwbo6quv1jnnnKPi4uKkR3jkkUd033336d133yWhmPTRpoEIIIAAAghUFiCpWNmDbwgggAACCCCAAAIIhCUwfvx4ZWRkyD1jMJkXN9z5tttuCzxDce+9907mptI2BBBAAAEEEKhBgOHPNaCwCgEEEEAAAQQQQACBcATWr1+vXr16adKkSTrhhBPCKcqTxz777LO67rrrAj0U999/f0/WkUohgAACCCCAQHQFSCpG15fSEUAAAQQQQAABBHwq4GZBPu+88wLPV2zXrl3SKDz//PMaO3asZsyYoW7duiVNu2gIAggggAACCIQmQFIxNC/2RgABBBBAAAEEEECg3gI33XSTZs+erWnTpik1NfGfPPSf//xHo0eP1vTp09WzZ896O7AjAggggAACCCSfQOL/ZZN8MaFFCCCAAAIIIIAAAkkicOONN6qwsDDw7MFEb9Ibb7wRSChOnTqVhGKiB5P6I4AAAgggEAEBeipGAJEiEEAAAQQQQAABBBCoTWDt2rXq3bu3XnzxRR199NHlu7nnLrZt27b8u5c/uJ6Jbij3q6++qiOOOMLLVaVuCCCAAAIIIBAjAXoqxgia0yCAAAIIIIAAAgj4U6BDhw566qmndM4552jDhg0BhJdeekk5OTn69ttvPYcyb968SnWaOXOmzj77bL388sskFCvJ8AUBBBBAAAF/C5BU9Hf8aT0CCCCAAAIIIIBADAROOeUUnXvuuTr//PM1atQoXXjhhUpLS9NDDz0Ug7PX/xSnn356oFflRx99FDjIPQ9y+PDhgV6W/fv3r39B7IkAAggggAACSS/A8OekDzENRAABBBBAAAEEEPCCwNKlS3Xcccdp48aNys/PD1SpU6dOWrlypReqp88++0x9+/bVjh071KRJE91777264YYb9Oyzz2rQoEGeqCOVQAABBBBAAAHvCJBU9E4sqAkCCCCAAAIIIIBAkgo8//zzGjlypPLy8lRSUlLeysaNGweSefvvv3/5unh9GDZsmF555ZXy+jVq1EiPP/54oFdlvOrEeRFAAAEEEEDAuwIMf/ZubKgZAggggAACCCCAQJIIuGcSbt++vTxhV7FZ7vmK8V7csx1ff/31SvVzs1b/+te/lpvtmQUBBBBAAAEEEKgqQFKxqgjfEUAAAQQQQAABBBCIsMBVV10l1yux6uJ6Lj7zzDNVV8f8+1/+8pdKCcWyCrih0IMHD9a2bdvKVvGOAAIIIIAAAggEBBj+zIWAAAIIIIAAAggggEAMBObMmaMzzzwz8ExFl6wrWzIyMrR69Wq1bdu2bFVM390zHvfaa6/A0OyqJ87OzlaLFi305ZdfqlmzZlU38x0BBBBAAAEEfCxAT0UfB5+mI4AAAggggAACCMROwE2C8tVXX+miiy6q1GvRPbtwypQpsatIlTO5CVmqLk2bNtUBBxyg5557TmvWrJFLLrIggAACCCCAAAIVBeipWFGDzwgggAACCCCAAAIIxEDg/fff1/Dhw7V169ZAD8FjjjlG7733XgzOXPkUrsdkTk5O+fBmlzxs37697r77bg0ZMqTyznxDAAEEEEAAAQQqCNBTsQIGHxFAAAEEEEAAAQQQiIXAwIEDtWzZMv3qV78K9FqcOXOmcnNzY3HqSudwszsXFRUFeiIeeOCBmjx5cqA3JQnFSkx8QQABBBBAAIEaBOipWAMKqxBAAAEEEEAAAQQQaIjAjqISrdiyPaRDZ7/3jkYNG6JXZn6kLt17hHRsuDsfttcegSLufWKSjj/l57UW1yQ9TZ1bZNW6nQ0IIIAAAggg4D8Bkor+izktRgABBBBAAAEEEIiSwLRl65VbWBRy6Xnbt6txkyYhHxfuAT+s/lY5e3esVzFHd2yjnCYZ9dqXnRBAAAEEEEAg+QUY/pz8MaaFCCCAAAIIIIAAAjESyExLadCZ4pFQdBWtb0KxUWrD2tUgDA5CAAEEEEAAgYQQIKmYEGGikggggAACCCCAAAIIIIAAAggggAACCHhHgKSid2JBTRBAAAEEEEAAAQQQQAABBBBAAAEEEEgIAZKKCREmKokAAggggAACCCCAAAIIIIAAAggggIB3BEgqeicW1AQBBBBAAAEEEEAAAQQQQAABBBBAAIGEECCpmBBhopIIIIAAAggggAACCCCAAAIIIIAAAgh4R4CkondiQU0QQAABBBBAAAEEEEAAAQQQQAABBBBICAGSigkRJiqJAAIIIIAAAggggAACCCCAAAIIIICAdwRIKnonFtQEAQQQQAABBBBAAAEEEEAAAQQQQACBhBAgqZgQYaKSCCCAAAIIIIAAAggggAACCCCAAAIIeEeApKJ3YkFNEEAAAQQQQAABBBBAAAEEEEAAAQQQSAgBkooJESYqiQACCCCAAAIIIIBA6ALFRUVauuDT0A/kCAQQQAABBBBAYDcCJBV3A8RmBBBAAAEEEEAAAQRiJfDyYxM04qieGtatgxZ9NKvaafO2b9cFh3cNbL/v2iv00+ZN1fYpW7F0/ie6Zugg3XTRL8tW8Y4AAggggAACCERMgKRixCgpCAEEEEAAAQQQQACB8ATOHP0b9T72hEAhr096vFphM6e8pO3bflJ6o0a68rb71Kxlq2r7lK3oclgfnXrBJWVfeUcAAQQQQAABBCIqQFIxopwUhgACCCCAAAIIIIBAeAJNW7RUmz076H/v/FfrVq+qVNhbLzyrbr37KqNxViCxWGljDV/SG2XUsJZVCCCAAAIIIIBA+AIkFcM3pAQEEEAAAQQQQAABBCIq4HoYlpaW6s1nniwv98tP5ypn746WcGxfvu6T96br0mN669l7btOO3Fzd97srA8Onl8z7X/k+fEAAAQQQQAABBKIhQFIxGqqUiQACCCCAAAIIIIBAGAIHHX6k9j2op6a/ODmQLHRFTZ08UT8/7+JKpfY59kTt0WGvwJDorOxsnXv1OHvO4kYVFRZW2o8vCCCAAAIIIIBApAVIKkZalPIQQAABBBBAAAEEEAhTICUlRadeOCqQLHzvPy9oy8YNWrv8a/Xo269ayY0ydg1xLv9sx7MggAACCCCAAALRFCCpGE1dykYAAQQQQAABBBBAoIECR596hpq3bqPXn35Cb9uzFE8afl4DS+IwBBBAAAEEEEAg8gIkFSNvSokIIIAAAggggAACCDRYwD1LsbSkRI0yMnXy2RdYD8Vv9NrEv+uYIcNqLdPtz4IAAggggAACCMRSgKRiLLU5FwIIIIAAAggggAACuxHYtnlTYLiz2+2Ucy5SWnq6Bp52pho3aRI48qdNG1WQt0OFBQWB723atdfXny3Qti2bNXfGfwPrtmxYH3h3+5QUFwcmfQms4AcCCCCAAAIIIBAhAZKKEYKkGAQQQAABBBBAAAEEwhWYeMct+uitN/X0X2/Vwg/fV6ucdhoweIgGnzciUPTk++/Qkvn/C0zEMuG6q21Slk06cfi5+m7FMv36hL7a9OMPyspuqv+985a++GSO/vvPSbZvQaA81wOSBQEEEEAAAQQQiJRAiv1xwV8XkdKkHAQQQAABBBBAAAFfC7y78kdtzIv9zMsF+XkB94zMxnKf3Xskl0apKTpyr9bKabJrUphIlk9ZCCCAAAIIIJB4AumJV2VqjAACCCCAAAIIIIAAAhUFKiYRK36uuA+fEUAAAQQQQACBSAow/DmSmpSFAAIIIIAAAggggAACCCCAAAIIIICADwRIKvogyDQRAQQQQAABBBBAAAEEEEAAAQQQQACBSAqQVIykJmUhgAACCCCAAAIIIIAAAggggAACCCDgAwGSij4IMk1EAAEEEEAAAQQQQAABBBBAAAEEEEAgkgIkFSOpSVkIIIAAAggggAACCCCAAAIIIIAAAgj4QICkog+CTBMRQAABBBBAAAEEEEAAAQQQQAABBBCIpABJxUhqUhYCCCCAAAIIIIAAAggggAACCCCAAAI+ECCp6IMg00QEEEAAAQQQQAABBBBAAAEEEEAAAQQiKUBSMZKalIUAAggggAACCCCAAAIIIIAAAggggIAPBEgq+iDINBEBBBBAAAEEEEAAAQQQQAABBBBAAIFICpBUjKQmZSGAAAIIIIAAAgj4WiCvuCQp219YUpqU7aJRCCCAAAIIINBwgZRSWxp+OEcigAACCCCAAAIIIIBAmcCOohKt3LK97GtU3yfc/meddOrpOujgQ6J6Hld4VqM0dW6eFfXzcAIEEEAAAQQQSByB9MSpKjVFAAEEEEAAAQQQQMDbAlnpqerWpmlMKvnVgk90xqDjY3a+mDSKkyCAAAIIIIBAwggw/DlhQkVFEUAAAQQQQAABBBBAAAEEEEAAAQQQ8IYASUVvxIFaIIAAAggggAACCCAQkkBqaqpSUlJCOoadEUAAAQQQQACBSAmQVIyUJOUggAACCCCAAAIIIBBDgZKSEvF49BiCcyoEEEAAAQQQqCRAUrESB18QQAABBBBAAAEEEEAAAQQQQAABBBBAYHcCJBV3J8R2BBBAAAEEEEAAAQQ8KMDwZw8GhSohgAACCCDgIwGSij4KNk1FAAEEEEAAAQQQSB4Bhj8nTyxpCQIIIIAAAokoQFIxEaNGnRFAAAEEEEAAAQQQQAABBBBAAAEEEIijAEnFOOJzagQQQAABBBBAAAEEEEAAAQQQQAABBBJRgKRiIkaNOiOAAAIIIIAAAggggAACCCCAAAIIIBBHAZKKccTn1AgggAACCCCAAAIIIIAAAggggAACCCSiAEnFRIwadUYAAQQQQAABBBDwvQCzP/v+EgAAAQQQQACBuAqQVIwrPydHAAEEEEAAAQQQQKBhAsz+3DA3jkIAAQQQQACByAiQVIyMI6UggAACCCCAAAIIIIAAAggggAACCCDgGwGSir4JNQ1FAAEEEEAAAQQQQAABBBBAAAEEEEAgMgIkFSPjSCkIIIAAAggggAACCCCAAAIIIIAAAgj4RoCkom9CTUMRQAABBBBAAAEEEEAAAQQQQAABBBCIjABJxcg4UgoCCCCAAAIIIIAAAggggAACCCCAAAK+ESCp6JtQ01AEEEAAAQQQQACBZBJITU1VSkpKMjWJtiCAAAIIIIBAAgmQVEygYFFVBBBAAAEEEEAAAQTKBEpKSlRaWlr2lXcEEEAAAQQQQCCmAiQVY8rNyRBAAAEEEEAAAQQQQAABBBBAAAEEEEh8AZKKiR9DWoAAAggggAACCCCAAAIIIIAAAggggEBMBUgqxpSbkyGAAAIIIIAAAggggAACCCCAAAIIIJD4AiQVEz+GtAABBBBAAAEEEEAAAQQQQAABBBBAAIGYCqTYw515unNMyTkZAggggAACCCCAAAKhC2zfvl0333yzVq9eHTh49uzZOuCAA5STkxOYsGXkyJE6+eSTQy+YIxBAAAEEEEAAgQYIkFRsABqHIIAAAggggAACCCAQa4HNmzerVatWNZ42JSVFgwYN0rRp02rczkoEEEAAAQQQQCDSAgx/jrQo5SGAAAIIIIAAAgggEAWBli1b6vjjj6+x5KZNm+r666+vcRsrEUAAAQQQQACBaAiQVIyGKmUigAACCCCAAAIIIBAFgdGjR6tZs2bVSk5PT9fAgQOrrWcFAggggAACCCAQLQGSitGSpVwEEEAAAQQQQAABBCIsMGTIEBUUFFQq1SUUL7jgArkh0CwIIIAAAggggECsBEgqxkqa8yCAAAIIIIAAAgggEKZAkyZNdMopp1QqJTMzUyNGjKi0ji8IIIAAAggggEC0BUgqRluY8hFAAAEEEEAAAQQQiKDApZdeWmkIdIsWLdSrV68InoGiEEAAAQQQQACB3QuQVNy9EXsggAACCCCAAAIIIOAZgZNPPlklJSWB+mRkZOiSSy7xTN2oCAIIIIAAAgj4R4Ckon9iTUsRQAABBBBAAAEEkkCgUaNGGjZsmFJTUwOvCy+8MAlaRRMQQAABBBBAINEESComWsSoLwIIIIAAAggggIDvBVzvxP/f3r0HWVnXcRz/7IXlIrCwiIrCggiKgopGamJGEo6lZqYUmlZqXvIyaqKF2sVmFLOsUUkmRSXHYcxLeU9Ns3LEMCXMK4ICitzkzi4s7AJ9vvsssovA7OWcPWfPef9mnn3O5Xl+v+d5Pfxx+M739/tGlmJ5ebkGDBiQ9x4AIIAAAggggEDrCxS3/pCMiAACCCCAAAIIIIAAAjsUqFktrVssVa+qt62RaiqkTdW129E9qlVVVaWTjuwpvX2jVNiubiuR2nX1VppsJd6XlEkddpcK+Om/Q3O+QAABBBBAAIEmCxRsdmvyWZyAAAIIIIAAAggggAACzRNYv0RaM7tumymteEOqnCtVOZC4Ybn7LJCKOnjvSUV+qfi5vnljsslrKW6Kn+9+H69rD/BxngqdHB/nOHhY4H3tr/w4t8aHr5OKd5Ha7+oAYy+pdD9vB0pdnOVYuw30OQ5M0hBAAAEEEEAAgUYKEFRsJBSHIYAAAggggAACCCDQZIEIFi6dKi17NdmvejvJNixs764cGKypdNCvNvrX5K5bfEKRsxoLO3r8CFRWSR0dbCw7VOo53PthUo/DHNzs1OJh6AABBBBAAAEEclOAoGJuPlfuCgEEEEAAAQQQQCATAhXOQFzwtLenHER82XHD9Q7cOXOw2lOXk9TBTFxV08aMYGORg401a6XO/aVex0p7jPI2kiBj0yQ5GgEEEEAAgZwWIKiY04+Xm0MAAQQQQAABBBBIr4Cz/Ba/IM17QJr/qIOHq5PhYrpxrrQCz8Eu7pJMoS47ROr7banPaKlTn1y5Q+4DAQQQQAABBJohQFCxGWicggACCCCAAAIIIJDnAsumSe/f42DiFK9F6KBbtQupZGoac2s/iuK6KdNdB0kDznOQ8TQXg+ne2lfBeAgggAACCCCQYQGCihl+AAyPAAIIIIAAAggg0EYEIvtw3v3SW+NdnXlhkrkXBVTyuUXxlygE0/sUafCVUreh+azBvSOAAAIIIJBXAgQV8+pxc7MIIIAAAggggAACTRaIYOJ7t0pvXO9TXVSlJtZHpDUQKCzy2pGuWF06WBp2i4u8HNHga94ggAACCCCAQO4JEFTMvWfKHSGAAAIIIIAAAgikRMABxFkTpRnjkmy8KFxC27mAZ4LXVoyOKtKHT5K67Lfz4/kWAQQQQAABBNqsAEHFNvvouHAEEEAAAQQQQACBtAmsnCFN/a5U8YEzEyvTNkzOdlxQ6MxFV5Hef6w05Fq/bp+zt8qNIYAAAgggkK8CBBXz9clz3wgggAACCCCAAALbEXB24uw7pdculzZ52nO+FF/ZjkRKPirqJHXuKx3zrNSxd0q6pBMEEEAAAQQQyA4BgorZ8Ry4CgQQQAABBBBAAIFsEJh6hjT/L85OZKpzyh5HrLdY5IIuIx6Xeh6dsm7pCAEEEEAAAQQyK0BQMbP+jI4AAggggAACCCCQLQKvXSrNdEEWWnoECoulE2dJu/RLT//0igACCCCAAAKtKuDFTmgIIIAAAggggAACCOS5wPTLXOF5QtoRNm2SKqukVY1MhKyukV6fJ6328UtWSeur03eJMca/HfPbXlvssVvcNvlmHt1bWvNei7uiAwQQQAABBBDIvABBxcw/A64AAQQQQAABBBBAIJMCS/7hKs9eR3GzI35pbOs2SOffJS1aKf3kfg+5aOeDvfK+NGq8dPtzUtl50p4XSR+v2Pk5zfn2nY+Tca5+QNq4HYInpksHXNmcnrdzThRwefFUf7GdgbZzOB8hgAACCCCAQPYKEFTM3mfDlSGAAAIIIIAAAgikXcCFWV650NG0RqYONvN61q6Xjv+1dPYIaZ89pN956cZLJksR0NtRu+5h6dTDpT+cI93xA1+iL7WwYEdHN+7zm59seNxzb0pDx0nnflma8H1p+H4Nv1/hwtfnTnK8teHHzX8XgdvKudKHDzW/D85EAAEEEEAAgawQIKiYFY+Bi0AAAQQQQAABBBDIiMDy16R1H6V96Akufjyol/SFgclQHUocrDtG+tF9Ox46MhW7u75JtKEuoNzUFpmR9dufX5HGP7b1k5jSfMbvpdOHS986Yuvn9V/F9Z0zQmphLLN+l1L1Guntmxp+xjsEEEAAAQQQaHMCXi2ZhgACCCCAAAIIIIBAngosft4zcbeJvjWT4rJ7pelzpQG7S7MXJ1OVI8tw+L7STU9ID3vZxvrtG8OkMbdJ02ZLhw+o/430w7ulpRXOUvTlPe9swqWOw9VvHy+XLp7sS3cK4YfLnNF4mDTu685kdMrAY46TPuQAYs1G6d0F0pOeulzjBMGxU7yc4TrXSvmN9LOTpb++Li1e7czJ3ZLp2P29P+toqV3d/xAeeVXqu6s0uHf9kVP0euX/fPFeXLKwQ4o6pBsEEEAAAQQQaG0BMhVbW5zxEEAAAQQQQAABBLJHYOXbnlecmqBigdP5/vlTaeLZybqJe5RKIwc7Kc9TnJc5QLhtcK7Iv8T37C7FFORtW/QR2YGXf1W6+3zpF6dsPSKKvURg8OhBrntyhfTHC/y9p0rf5mzIaBc4IBmBzCkXJ0HGh/8j9ekhXXac1M2Zj4+PlT6/z9ZxFzljcdfO/v7eZM3H6COCmBOfk645Kd6loRU5mLh2J3O/0zAkXSKAAAIIIIBAagX8U4aGAAIIIIAAAggggECeCkQkMEXtV6c5EOjubvQU4zmfJGshxvv3FkpF3vdw4G7bVu5gX3zflDbVFZr/O8+BxUOTsw4qlw729OjIaow26VzppM9JL82UPnEm4pwlyefx15fxaYtg5xme+hxrKY49QbraAcQIQG6oSQKMN47ZmrX46Um8QAABBBBAAAEE6gQIKvJPAQEEEEAAAQQQQCB/BUr3d8SvJCX3X+Jpw7MXOaj4uHTF8dKQPkm3UaQlCp3EVOVtW8+uUhRDaUqbt/SzRx/h6dNzHciMtndP6cyJ0usfJhmK9cetH0PdzWN3aJecE38j83G1p0dP/leSxRjrQJ5zh6tP/83Tpj1TOV7HOo8paRvdYae9UtIVnSCAAAIIIIBAZgQIKmbGnVERQAABBBBAAAEEskFg95GeI5yaoGLcTqxz2Kub9PNvJje3aKW0rwu0RGBviacZb9uWe1p0TE1uStvT/Ud72RmLW1qxf9XvVSZVOFYXVaZjbcQLRzUMGm45dsv+QAc9X5uz5Z3Uvi7AGOsonvUlKYKOsUWxmJiqHa9LirYe36JX3Q5iPcUWAXIyAggggAACmRcgqJj5Z8AVIIAAAggggAACCGRKoMzzhDvWpRS28BoenCY984Yz+85yl45TRjGVW56WDnBCXqHnHS9wgHHb9vGKZOrytp9XbUiyG6PASrT1npIcbaPfRwXpfg78RaGVLW2aMwi/M1z6wFOdY+p1ZD/G+G98lAQaV691YmB7aaX3q7zFlOsrPeX5rfnSRy70Ei2ClFFl+tgDXSV6zNbtzKN8ru8nPhvar/bQlv1p18UoV7WsD85GAAEEEEAAgYwLEFTM+CPgAhBAAAEEEEAAAQQyJ+Bo32G3OxWvU4suobpuHcIIvkXl5dMnSEddJ8X05h6OoX3vi9Lf32o4xMwFyZqHpx/Z8PN4d80DyWe3Oij5+rxkncb45PpHknUOH7xUirUVL5ksnfzbJNvxxydKkX14pIOOl96bFGyJdRfveylZK3GEZ3pHFuVgx/MWOsA5rL9013nS6FuSqc13vuDiLhcl60Imo6fhb4H/+7FLP6n81DR0TpcIIIAAAggg0JoCBZvdWnNAxkIAAQQQQAABBBBAIOsEpl8mvevoWpraQmckjrxBmjHeU4i99mK0C+5KMgMv+Eryvql/owr0LK/hGNOTdytteHZllWN3HZLP1ldvndq8zhmQkTW5ZapzHFGz0VOzXdAlKlGnvUWW4nGvSl32TftQDIAAAggggAAC6RUgqJheX3pHAAEEEEAAAQQQaCsCL3ohxIXPOMrm+cFpaDG9eJKzASeeLd38pBQBvl+OTsNA2dzlCU7X7HpANl8h14YAAggggAACjRQgqNhIKA5DAAEEEEAAAQQQyHUBp/5NPVOa7znGaQosRnXoyDCcvUT62tBc96y7v0JXdynq7FTN56VYw5KGAAIIIIAAAjkhQFAxJx4jN4EAAggggAACCCCQGgGvDDT7TpdFvtzRv3WulsJKQS1yjbUqO/eVjnnW1Wt6t6grTkYAAQQQQACB7BIgqJhdz4OrQQABBBBAAAEEEMgGgZUzkqzFijnOWqzMhitqW9cQBVkKS6T9x0pDrvVrl56mIYAAAggggEBOCRBUzKnHyc0ggAACCCCAAAIIpE7AWYqzJrq6yjhnLLq8c5qmRKfuerOgJxeBqa2kXeay04e7Eg0FWbLgoXAJCCCAAAIIpEeAoGJ6XOkVAQQQQAABBBBAIFcENnoa9Hu3Sm9e7ztyoLG6IlfuLHX3EesmRjZi6RBpmKto9zgidX3TEwIIIIAAAghkpQBBxax8LFwUAggggAACCCCAQNYJRHDxwz85uHiDSzcvlOL95o1Zd5mtekHFXjMxDHqfIg2+Sup2cKsOz2AIIIAAAgggkDkBgoqZs2dkBBBAAAEEEEAAgbYqsGya9P490rwpUoHn/FavcXDNWYz50Io6+l5dwrp0kDTwfKl8jFTSPR/unHtEAAEEEEAAgXoCBBXrYfASAQQQQAABBBBAAIGmCTi4tvgFBxcfkOY/6nUXVzvg5h4iizFXWgRNi7sk91R2iNTXQcTy0VRzzpXny30ggAACCCDQTAGCis2E4zQEEEAAAQQQQAABBD4jsGaWtPAZacFT0tKXHYhb77UGi+vWYWwjmYxFrtoc2YhRmKZzf6nXsdIeo7yNTIqwfOam+QABBBBAAAEE8lGAoGI+PnXuGQEEEEAAAQQQQKB1BCrnOrg4VVr2arJf9Y4zGTd4yrSLmshrEdZUZm7adAQPC+umMm+qcuZhLymqNvcc7v0wF1s5jCBi6/wrYRQEEEAAAQTapABBxTb52LhoBBBAAAEEEEAAgTYrsP4TKTIa18z2NlNa+aZUMUeqWiJtWJ7cVlEH7wsdfPQu1mqMYii1m6dbq27b5H1MTa49Lo7dsrkSc4G32sTIOLcmmbpc1Fnq0MObg4exHmJUau4yoG4b6HPauS8aAggggAACCCDQOAGCio1z4igEEEAAAQQQQAABBFpHINZlXLfYU6ZX1dtcCKamwvFEBwg3V3sfm19HUDGCgYX1tnZdpXalyVbifUmZA4m7+zhPw6YhgAACCCCAAAIpEiComCJIukEAAQQQQAABBBBAAAEEEEAAAQQQQCBfBDxHgoYAAggggAACCCCAAAIIIIAAAggggAACCDRegKBi4604EgEEEEAAAQQQQAABBBBAAAEEEEAAAQQs8H+qNjkzQkSVXQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 226,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "\n",
+    "def goldstein(x, y):\n",
+    "    z = (1 + (x + y + 1)**2 * (19 - 14*x + 3*x**2 - 14*y + 6*x*y + 3*y**2)) * \\\n",
+    "        (30 + (2*x - 3*y)**2 * (18 - 32*x + 12*x**2 + 48*y - 36*x*y + 27*y**2))\n",
+    "    return z\n",
+    "\n",
+    "x = Variable(np.array(1.0))\n",
+    "y = Variable(np.array(1.0))\n",
+    "z = goldstein(x, y)\n",
+    "z.backward()\n",
+    "\n",
+    "x.name = 'x'\n",
+    "y.name = 'y'\n",
+    "z.name = 'z'\n",
+    "\n",
+    "plot_dot_graph(output=z, verbose=True, to_file='graph.png')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6fc4d91c",
+   "metadata": {},
+   "source": [
+    "## Step27"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8bbd7792",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('..')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "89ce947f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Sin 함수 클래스 정의\n",
+    "import numpy as np\n",
+    "from dezero import Function\n",
+    "\n",
+    "\n",
+    "class Sin(Function):\n",
+    "    def forward(self, x):\n",
+    "        y = np.sin(x)\n",
+    "        return y\n",
+    "    \n",
+    "    def backward(self, gy):\n",
+    "        x = self.inputs[0].data\n",
+    "        gx = np.cos(x) * gy\n",
+    "        return gx\n",
+    "    \n",
+    "def sin(x):\n",
+    "    return Sin()(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f0da677f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7071067811865475\n",
+      "0.7071067811865476\n",
+      "0.7071067811865476\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dezero import Variable\n",
+    "\n",
+    "x = Variable(np.array(np.pi/4))\n",
+    "y = sin(x)\n",
+    "y.backward()\n",
+    "\n",
+    "flag = np.cos(np.pi/4)\n",
+    "\n",
+    "print(y.data) # sin(pi/4)\n",
+    "print(x.grad) # cos(pi/4)\n",
+    "print(flag)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "8989577e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 테일러 급수\n",
+    "import math\n",
+    "\n",
+    "def taylor_sin(x, threshold=0.0001):\n",
+    "    # y(sin(x)의 값)의 초기값\n",
+    "    y = 0 \n",
+    "    for i in range(int(1e5)):\n",
+    "        c = (-1) ** i / math.factorial(2*i + 1)\n",
+    "        t = c * x ** (2*i + 1)\n",
+    "        y = y + t\n",
+    "        if abs(t.data) < threshold:\n",
+    "            break\n",
+    "    return y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "bfb61761",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7071064695751781\n",
+      "0.7071032148228457\n",
+      "0.7071067811865476\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 테일러 급수\n",
+    "import math\n",
+    "from dezero import Variable\n",
+    "\n",
+    "def taylor_sin(x, threshold=0.0001):\n",
+    "    # y(sin(x)의 값)의 초기값\n",
+    "    y = 0 \n",
+    "    for i in range(int(1e5)):\n",
+    "        c = (-1) ** i / math.factorial(2*i + 1)\n",
+    "        t = c * x ** (2*i + 1)\n",
+    "        y = y + t\n",
+    "        if abs(t.data) < threshold:\n",
+    "            break\n",
+    "    return y\n",
+    "\n",
+    "# Test\n",
+    "x = Variable(np.array(np.pi/4))\n",
+    "y = taylor_sin(x)\n",
+    "y.backward()\n",
+    "\n",
+    "print(y.data)\n",
+    "print(x.grad)\n",
+    "print(np.cos(np.pi/4))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "f95cdc4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-2.0 400.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dezero import Variable\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "def rosenbrock(x0, x1):\n",
+    "    y = 100 * ((x1 - x0**2) ** 2) + (1 - x0) ** 2\n",
+    "    return y\n",
+    "\n",
+    "x0 = Variable(np.array(0.0))\n",
+    "x1 = Variable(np.array(2.0))\n",
+    "y = rosenbrock(x0, x1)\n",
+    "y.backward()\n",
+    "\n",
+    "print(x0.grad, x1.grad) # (-2.0, 400.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "1b7f648c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "variable(0.0) variable(2.0)\n",
+      "variable(0.002) variable(1.6)\n",
+      "variable(0.0052759968) variable(1.2800008)\n",
+      "variable(0.009966698110960038) variable(1.0240062072284468)\n",
+      "variable(0.01602875299014943) variable(0.8192248327970044)\n",
+      "variable(0.02324750923068761) variable(0.6554312504220874)\n",
+      "variable(0.031290846214210376) variable(0.5244530896747561)\n",
+      "variable(0.039780241951514035) variable(0.41975829515116514)\n",
+      "variable(0.04835473570612382) variable(0.3361231296508763)\n",
+      "variable(0.05671405943493354) variable(0.26936613981374286)\n",
+      "variable(0.06463840226323121) variable(0.2161362087585121)\n",
+      "variable(0.07198937826156711) variable(0.17374459161623834)\n",
+      "variable(0.07869927242171229) variable(0.14003216740948807)\n",
+      "variable(0.08475507379959696) variable(0.11326444902353183)\n",
+      "variable(0.0901819257435144) variable(0.0920482437257805)\n",
+      "variable(0.09502862514911821) variable(0.07526515092678615)\n",
+      "variable(0.09935624532071949) variable(0.062018208660975245)\n",
+      "variable(0.10322996680416148) variable(0.05158889962562639)\n",
+      "variable(0.10671369002607195) variable(0.04340240490977877)\n",
+      "variable(0.1098668207990641) variable(0.03699948625561913)\n",
+      "variable(0.11274262494960549) variable(0.03201373266699403)\n",
+      "variable(0.11538764053266892) variable(0.028153166029700707)\n",
+      "variable(0.11784175359713205) variable(0.02518539434129985)\n",
+      "variable(0.12013865426676833) variable(0.022925651251209316)\n",
+      "variable(0.12230648099884178) variable(0.02122718025077347)\n",
+      "variable(0.12436852976526466) variable(0.019973519259482785)\n",
+      "variable(0.12634395394997353) variable(0.01907232164678093)\n",
+      "variable(0.1282484140138362) variable(0.01845041625736735)\n",
+      "variable(0.13009465753201185) variable(0.018049864145306748)\n",
+      "variable(0.13189302352188503) variable(0.017824815299919687)\n",
+      "variable(0.13365187272584245) variable(0.017739006170684652)\n",
+      "variable(0.13537794963550165) variable(0.01776376955317268)\n",
+      "variable(0.13707668389502906) variable(0.017876453492040627)\n",
+      "variable(0.1387524392100837) variable(0.018059166247164044)\n",
+      "variable(0.14040871760835422) variable(0.01829778087508083)\n",
+      "variable(0.142048326222364) variable(0.018581146296149178)\n",
+      "variable(0.14367351292424496) variable(0.01890046243343437)\n",
+      "variable(0.14528607626959172) variable(0.019248785609946133)\n",
+      "variable(0.1468874543769993) variable(0.01962063727951963)\n",
+      "variable(0.14847879661778002) variable(0.020011694674286713)\n",
+      "variable(0.15006102133058338) variable(0.020418546348442188)\n",
+      "variable(0.1516348622093103) variable(0.02083849910330931)\n",
+      "variable(0.15320090553406496) variable(0.02126942557009475)\n",
+      "variable(0.15475962001493504) variable(0.0217096439473673)\n",
+      "variable(0.15631138068706021) variable(0.022157823155327255)\n",
+      "variable(0.15785648802277605) variable(0.022612908070720816)\n",
+      "variable(0.15939518320338006) variable(0.02307406061875362)\n",
+      "variable(0.1609276603110473) variable(0.023540613380690717)\n",
+      "variable(0.16245407605350454) variable(0.02401203307519014)\n",
+      "variable(0.1639745575141926) variable(0.02448789182543168)\n",
+      "variable(0.16548920832370836) variable(0.024967844562740395)\n",
+      "variable(0.1669981135700812) variable(0.025451611264513865)\n",
+      "variable(0.16850134370239783) variable(0.02593896299880424)\n",
+      "variable(0.16999895763156478) variable(0.026429710964946115)\n",
+      "variable(0.17149100519123509) variable(0.026923697891120604)\n",
+      "variable(0.1729775290892046) variable(0.027420791285196526)\n",
+      "variable(0.17445856645334548) variable(0.027920878142118546)\n",
+      "variable(0.17593415005512397) variable(0.02842386079548611)\n",
+      "variable(0.17740430927692585) variable(0.028929653667512663)\n",
+      "variable(0.17886907087595724) variable(0.029438180724014763)\n",
+      "variable(0.18032845958673732) variable(0.029949373482417455)\n",
+      "variable(0.1817824985956147) variable(0.030463169453319075)\n",
+      "variable(0.1832312099138898) variable(0.030979510921788193)\n",
+      "variable(0.1846746146706643) variable(0.03149834399473214)\n",
+      "variable(0.18611273334218942) variable(0.03201961785653738)\n",
+      "variable(0.18754558593101972) variable(0.03254328418765009)\n",
+      "variable(0.18897319210552455) variable(0.03306929671056197)\n",
+      "variable(0.19039557130811852) variable(0.03359761083535987)\n",
+      "variable(0.19181274283883154) variable(0.034128183383036866)\n",
+      "variable(0.193224725919458) variable(0.03466097236950064)\n",
+      "variable(0.19463153974242753) variable(0.03519593683693044)\n",
+      "variable(0.19603320350767164) variable(0.03573303672204598)\n",
+      "variable(0.19742973645007114) variable(0.03627223275313283)\n",
+      "variable(0.19882115785952467) variable(0.036813486369455174)\n",
+      "variable(0.20020748709524674) variable(0.03735675965808455)\n",
+      "variable(0.20158874359556317) variable(0.03790201530426632)\n",
+      "variable(0.20296494688420175) variable(0.038449216552300595)\n",
+      "variable(0.2043361165738636) variable(0.03899832717458184)\n",
+      "variable(0.2057022723676926) variable(0.03954931144696299)\n",
+      "variable(0.20706343405912744) variable(0.04010213412901687)\n",
+      "variable(0.20841962153051746) variable(0.04065676044808522)\n",
+      "variable(0.2097708547508001) variable(0.041213156086253006)\n",
+      "variable(0.21111715377247406) variable(0.04177128716957866)\n",
+      "variable(0.2124585387280508) variable(0.04233112025906102)\n",
+      "variable(0.21379502982612708) variable(0.04289262234294055)\n",
+      "variable(0.2151266473471906) variable(0.04345576083002335)\n",
+      "variable(0.2164534116392447) variable(0.044020503543787184)\n",
+      "variable(0.21777534311332014) variable(0.04458681871708341)\n",
+      "variable(0.21909246223892623) variable(0.04515467498729159)\n",
+      "variable(0.22040478953948148) variable(0.045724041391816336)\n",
+      "variable(0.2217123455877551) variable(0.04629488736384169)\n",
+      "variable(0.22301515100134317) variable(0.04686718272827818)\n",
+      "variable(0.2243132264381976) variable(0.047440897697852924)\n",
+      "variable(0.2256065925922217) variable(0.04801600286930516)\n",
+      "variable(0.22689527018894262) variable(0.048592469219658666)\n",
+      "variable(0.2281792799812679) variable(0.04917026810254959)\n",
+      "variable(0.22945864274533237) variable(0.049749371244593645)\n",
+      "variable(0.23073337927643808) variable(0.05032975074178093)\n",
+      "variable(0.23200351038509087) variable(0.05091137905588967)\n",
+      "variable(0.2332690568931344) variable(0.051494229010912725)\n",
+      "variable(0.23453003962998273) variable(0.05207827378949265)\n",
+      "variable(0.2357864794289515) variable(0.052663486929362374)\n",
+      "variable(0.23703839712368746) variable(0.05324984231978978)\n",
+      "variable(0.23828581354469575) variable(0.05383731419802521)\n",
+      "variable(0.23952874951596384) variable(0.05442587714575167)\n",
+      "variable(0.24076722585168123) variable(0.05501550608553761)\n",
+      "variable(0.24200126335305341) variable(0.05560617627729298)\n",
+      "variable(0.24323088280520894) variable(0.05619786331472917)\n",
+      "variable(0.24445610497419773) variable(0.05679054312182359)\n",
+      "variable(0.24567695060407943) variable(0.05738419194929007)\n",
+      "variable(0.24689344041410002) variable(0.05797878637105591)\n",
+      "variable(0.24810559509595506) variable(0.058574303280746885)\n",
+      "variable(0.249313435311138) variable(0.05917071988818111)\n",
+      "variable(0.25051698168837166) variable(0.059768013715873085)\n",
+      "variable(0.2517162548211216) variable(0.060366162595548854)\n",
+      "variable(0.25291127526518925) variable(0.06096514466467345)\n",
+      "variable(0.25410206353638354) variable(0.06156493836299162)\n",
+      "variable(0.255288640108269) variable(0.06216552242908296)\n",
+      "variable(0.25647102540998923) variable(0.06276687589693222)\n",
+      "variable(0.25764923982416327) variable(0.06336897809251604)\n",
+      "variable(0.2588233036848543) variable(0.06397180863040668)\n",
+      "variable(0.2599932372756082) variable(0.06457534741039381)\n",
+      "variable(0.26115906082756074) variable(0.06517957461412519)\n",
+      "variable(0.2623207945176121) variable(0.06578447070176686)\n",
+      "variable(0.2634784584666665) variable(0.06639001640868375)\n",
+      "variable(0.2646320727379365) variable(0.06699619274214118)\n",
+      "variable(0.265781657335309) variable(0.06760298097802825)\n",
+      "variable(0.2669272322017733) variable(0.06821036265760332)\n",
+      "variable(0.26806881721790765) variable(0.06881831958426253)\n",
+      "variable(0.2692064322004252) variable(0.06942683382033162)\n",
+      "variable(0.270340096900776) variable(0.07003588768388172)\n",
+      "variable(0.2714698310038043) variable(0.07064546374556957)\n",
+      "variable(0.2725956541264607) variable(0.07125554482550246)\n",
+      "variable(0.27371758581656636) variable(0.07186611399012857)\n",
+      "variable(0.27483564555162904) variable(0.07247715454915273)\n",
+      "variable(0.27594985273770894) variable(0.07308865005247832)\n",
+      "variable(0.2770602267083339) variable(0.07370058428717531)\n",
+      "variable(0.2781667867234619) variable(0.07431294127447492)\n",
+      "variable(0.2792695519684901) variable(0.07492570526679113)\n",
+      "variable(0.28036854155330926) variable(0.07553886074476915)\n",
+      "variable(0.28146377451140203) variable(0.07615239241436125)\n",
+      "variable(0.2825552697989845) variable(0.07676628520393007)\n",
+      "variable(0.2836430462941892) variable(0.07738052426137944)\n",
+      "variable(0.28472712279628903) variable(0.07799509495131306)\n",
+      "variable(0.2858075180249609) variable(0.07860998285222105)\n",
+      "variable(0.28688425061958767) variable(0.07922517375369452)\n",
+      "variable(0.28795733913859783) variable(0.07984065365366809)\n",
+      "variable(0.28902680205884174) variable(0.08045640875569077)\n",
+      "variable(0.29009265777500315) variable(0.08107242546622478)\n",
+      "variable(0.29115492459904563) variable(0.08168869039197285)\n",
+      "variable(0.2922136207596922) variable(0.08230519033723346)\n",
+      "variable(0.293268764401938) variable(0.08292191230128461)\n",
+      "variable(0.2943203735865944) variable(0.08353884347579557)\n",
+      "variable(0.2953684662898642) variable(0.08415597124226695)\n",
+      "variable(0.29641306040294657) variable(0.08477328316949889)\n",
+      "variable(0.2974541737316715) variable(0.08539076701108729)\n",
+      "variable(0.2984918239961621) variable(0.08600841070294811)\n",
+      "variable(0.29952602883052454) variable(0.08662620236086965)\n",
+      "variable(0.3005568057825649) variable(0.08724413027809257)\n",
+      "variable(0.3015841723135315) variable(0.08786218292291774)\n",
+      "variable(0.30260814579788275) variable(0.08848034893634177)\n",
+      "variable(0.30362874352307906) variable(0.08909861712971995)\n",
+      "variable(0.30464598268939846) variable(0.0897169764824567)\n",
+      "variable(0.30565988040977554) variable(0.09033541613972322)\n",
+      "variable(0.30667045370966206) variable(0.09095392541020224)\n",
+      "variable(0.30767771952690953) variable(0.09157249376385979)\n",
+      "variable(0.3086816947116725) variable(0.09219111082974375)\n",
+      "variable(0.3096823960263322) variable(0.09280976639380904)\n",
+      "variable(0.31067984014543976) variable(0.09342845039676924)\n",
+      "variable(0.3116740436556785) variable(0.09404715293197459)\n",
+      "variable(0.3126650230558446) variable(0.09466586424331604)\n",
+      "variable(0.3136527947568453) variable(0.0952845747231552)\n",
+      "variable(0.314637375081715) variable(0.09590327491028011)\n",
+      "variable(0.3156187802656474) variable(0.09652195548788646)\n",
+      "variable(0.31659702645604404) variable(0.09714060728158416)\n",
+      "variable(0.3175721297125786) variable(0.09775922125742914)\n",
+      "variable(0.318544106007276) variable(0.09837778851997989)\n",
+      "variable(0.31951297122460626) variable(0.09899630031037884)\n",
+      "variable(0.32047874116159236) variable(0.09961474800445828)\n",
+      "variable(0.3214414315279319) variable(0.1002331231108704)\n",
+      "variable(0.3224010579461317) variable(0.10085141726924156)\n",
+      "variable(0.32335763595165506) variable(0.10146962224835024)\n",
+      "variable(0.3243111809930814) variable(0.10208772994432881)\n",
+      "variable(0.325261708432278) variable(0.1027057323788885)\n",
+      "variable(0.32620923354458214) variable(0.10332362169756765)\n",
+      "variable(0.3271537715189956) variable(0.10394139016800287)\n",
+      "variable(0.3280953374583886) variable(0.10455903017822293)\n",
+      "variable(0.3290339463797143) variable(0.10517653423496512)\n",
+      "variable(0.32996961321423346) variable(0.10579389496201383)\n",
+      "variable(0.3309023528077481) variable(0.10641110509856123)\n",
+      "variable(0.33183217992084424) variable(0.10702815749758966)\n",
+      "variable(0.33275910922914376) variable(0.10764504512427564)\n",
+      "variable(0.3336831553235642) variable(0.10826176105441515)\n",
+      "variable(0.33460433271058687) variable(0.10887829847287009)\n",
+      "variable(0.3355226558125328) variable(0.1094946506720355)\n",
+      "variable(0.3364381389678458) variable(0.11011081105032747)\n",
+      "variable(0.33735079643138277) variable(0.11072677311069148)\n",
+      "variable(0.33826064237471104) variable(0.11134253045913084)\n",
+      "variable(0.33916769088641185) variable(0.1119580768032551)\n",
+      "variable(0.34007195597239054) variable(0.11257340595084821)\n",
+      "variable(0.3409734515561922) variable(0.11318851180845607)\n",
+      "variable(0.3418721914793235) variable(0.11380338837999344)\n",
+      "variable(0.3427681895015799) variable(0.1144180297653698)\n",
+      "variable(0.3436614593013775) variable(0.11503243015913403)\n",
+      "variable(0.34455201447609074) variable(0.11564658384913769)\n",
+      "variable(0.34543986854239433) variable(0.1162604852152166)\n",
+      "variable(0.34632503493660954) variable(0.11687412872789062)\n",
+      "variable(0.3472075270150551) variable(0.11748750894708125)\n",
+      "variable(0.34808735805440194) variable(0.11810062052084704)\n",
+      "variable(0.34896454125203197) variable(0.11871345818413631)\n",
+      "variable(0.3498390897264002) variable(0.11932601675755727)\n",
+      "variable(0.3507110165174007) variable(0.11993829114616508)\n",
+      "variable(0.3515803345867355) variable(0.12055027633826577)\n",
+      "variable(0.3524470568182864) variable(0.12116196740423679)\n",
+      "variable(0.35331119601849037) variable(0.12177335949536391)\n",
+      "variable(0.35417276491671684) variable(0.12238444784269435)\n",
+      "variable(0.35503177616564796) variable(0.12299522775590588)\n",
+      "variable(0.3558882423416612) variable(0.12360569462219165)\n",
+      "variable(0.3567421759452141) variable(0.12421584390516072)\n",
+      "variable(0.357593589401231) variable(0.1248256711437538)\n",
+      "variable(0.35844249505949166) variable(0.12543517195117426)\n",
+      "variable(0.359288905195022) variable(0.12604434201383416)\n",
+      "variable(0.36013283200848584) variable(0.12665317709031482)\n",
+      "variable(0.3609742876265786) variable(0.1272616730103423)\n",
+      "variable(0.36181328410242236) variable(0.12786982567377703)\n",
+      "variable(0.3626498334159615) variable(0.12847763104961765)\n",
+      "variable(0.3634839474743603) variable(0.12908508517501904)\n",
+      "variable(0.3643156381124008) variable(0.12969218415432393)\n",
+      "variable(0.36514491709288194) variable(0.13029892415810831)\n",
+      "variable(0.3659717961070193) variable(0.1309053014222402)\n",
+      "variable(0.3667962867748453) variable(0.1315113122469517)\n",
+      "variable(0.3676184006456103) variable(0.13211695299592427)\n",
+      "variable(0.3684381491981835) variable(0.1327222200953867)\n",
+      "variable(0.369255543841455) variable(0.13332711003322595)\n",
+      "variable(0.3700705959147371) variable(0.1339316193581105)\n",
+      "variable(0.3708833166881668) variable(0.1345357446786261)\n",
+      "variable(0.3716937173631074) variable(0.1351394826624239)\n",
+      "variable(0.37250180907255037) variable(0.13574283003538024)\n",
+      "variable(0.37330760288151743) variable(0.13634578358076874)\n",
+      "variable(0.37411110978746187) variable(0.13694834013844392)\n",
+      "variable(0.3749123407206699) variable(0.1375504966040364)\n",
+      "variable(0.3757113065446617) variable(0.13815224992815947)\n",
+      "variable(0.3765080180565917) variable(0.13875359711562693)\n",
+      "variable(0.37730248598764843) variable(0.1393545352246821)\n",
+      "variable(0.3780947210034542) variable(0.13995506136623762)\n",
+      "variable(0.37888473370446357) variable(0.14055517270312606)\n",
+      "variable(0.3796725346263615) variable(0.14115486644936132)\n",
+      "variable(0.3804581342404605) variable(0.14175413986941018)\n",
+      "variable(0.3812415429540969) variable(0.1423529902774746)\n",
+      "variable(0.3820227711110268) variable(0.1429514150367838)\n",
+      "variable(0.38280182899182014) variable(0.14354941155889664)\n",
+      "variable(0.38357872681425464) variable(0.14414697730301385)\n",
+      "variable(0.3843534747337082) variable(0.1447441097753)\n",
+      "variable(0.3851260828435503) variable(0.14534080652821504)\n",
+      "variable(0.38589656117553256) variable(0.14593706515985547)\n",
+      "variable(0.38666491970017747) variable(0.1465328833133047)\n",
+      "variable(0.3874311683271667) variable(0.1471282586759927)\n",
+      "variable(0.3881953169057274) variable(0.14772318897906483)\n",
+      "variable(0.38895737522501783) variable(0.1483176719967595)\n",
+      "variable(0.38971735301451116) variable(0.14891170554579466)\n",
+      "variable(0.3904752599443781) variable(0.14950528748476316)\n",
+      "variable(0.39123110562586816) variable(0.15009841571353646)\n",
+      "variable(0.3919848996116893) variable(0.150691088172677)\n",
+      "variable(0.39273665139638636) variable(0.15128330284285885)\n",
+      "variable(0.39348637041671763) variable(0.1518750577442964)\n",
+      "variable(0.39423406605203015) variable(0.1524663509361816)\n",
+      "variable(0.3949797476246335) variable(0.15305718051612857)\n",
+      "variable(0.39572342440017155) variable(0.15364754461962668)\n",
+      "variable(0.39646510558799325) variable(0.154237441419501)\n",
+      "variable(0.3972048003415212) variable(0.15482686912538052)\n",
+      "variable(0.39794251775861894) variable(0.15541582598317397)\n",
+      "variable(0.39867826688195623) variable(0.15600431027455292)\n",
+      "variable(0.39941205669937296) variable(0.1565923203164424)\n",
+      "variable(0.4001438961442411) variable(0.15717985446051855)\n",
+      "variable(0.400873794095825) variable(0.15776691109271349)\n",
+      "variable(0.40160175937964) variable(0.15835348863272716)\n",
+      "variable(0.40232780076780894) variable(0.15893958553354617)\n",
+      "variable(0.40305192697941744) variable(0.15952520028096928)\n",
+      "variable(0.40377414668086675) variable(0.16011033139313977)\n",
+      "variable(0.4044944684862253) variable(0.16069497742008423)\n",
+      "variable(0.405212900957578) variable(0.16127913694325816)\n",
+      "variable(0.40592945260537416) variable(0.16186280857509772)\n",
+      "variable(0.40664413188877296) variable(0.16244599095857792)\n",
+      "variable(0.4073569472159877) variable(0.1630286827667771)\n",
+      "variable(0.40806790694462763) variable(0.16361088270244747)\n",
+      "variable(0.4087770193820383) variable(0.16419258949759183)\n",
+      "variable(0.40948429278563975) variable(0.16477380191304614)\n",
+      "variable(0.41018973536326286) variable(0.16535451873806803)\n",
+      "variable(0.410893355273484) variable(0.16593473878993115)\n",
+      "variable(0.41159516062595736) variable(0.16651446091352523)\n",
+      "variable(0.4122951594817459) variable(0.16709368398096172)\n",
+      "variable(0.4129933598536499) variable(0.16767240689118504)\n",
+      "variable(0.4136897697065338) variable(0.1682506285695893)\n",
+      "variable(0.4143843969576512) variable(0.16882834796764043)\n",
+      "variable(0.41507724947696767) variable(0.1694055640625036)\n",
+      "variable(0.41576833508748184) variable(0.16998227585667586)\n",
+      "variable(0.41645766156554453) variable(0.170558482377624)\n",
+      "variable(0.4171452366411759) variable(0.17113418267742753)\n",
+      "variable(0.41783106799838066) variable(0.17170937583242654)\n",
+      "variable(0.41851516327546123) variable(0.1722840609428747)\n",
+      "variable(0.41919753006532934) variable(0.17285823713259696)\n",
+      "variable(0.41987817591581517) variable(0.1734319035486521)\n",
+      "variable(0.42055710832997506) variable(0.1740050593610001)\n",
+      "variable(0.4212343347663969) variable(0.17457770376217416)\n",
+      "variable(0.42190986263950375) variable(0.1751498359669571)\n",
+      "variable(0.42258369931985557) variable(0.17572145521206267)\n",
+      "variable(0.42325585213444894) variable(0.17629256075582095)\n",
+      "variable(0.4239263283670149) variable(0.17686315187786847)\n",
+      "variable(0.42459513525831477) variable(0.1774332278788424)\n",
+      "variable(0.4252622800064343) variable(0.17800278808007924)\n",
+      "variable(0.4259277697670756) variable(0.17857183182331757)\n",
+      "variable(0.4265916116538472) variable(0.17914035847040505)\n",
+      "variable(0.42725381273855256) variable(0.17970836740300938)\n",
+      "variable(0.42791438005147625) variable(0.18027585802233353)\n",
+      "variable(0.4285733205816684) variable(0.18084282974883467)\n",
+      "variable(0.4292306412772273) variable(0.18140928202194725)\n",
+      "variable(0.42988634904558004) variable(0.18197521429980976)\n",
+      "variable(0.4305404507537613) variable(0.18254062605899546)\n",
+      "variable(0.43119295322869033) variable(0.18310551679424675)\n",
+      "variable(0.4318438632574459) variable(0.1836698860182133)\n",
+      "variable(0.4324931875875395) variable(0.18423373326119377)\n",
+      "variable(0.43314093292718675) variable(0.18479705807088115)\n",
+      "variable(0.43378710594557673) variable(0.18535986001211166)\n",
+      "variable(0.4344317132731398) variable(0.18592213866661714)\n",
+      "variable(0.4350747615018131) variable(0.1864838936327808)\n",
+      "variable(0.435716257185305) variable(0.18704512452539657)\n",
+      "variable(0.43635620683935666) variable(0.18760583097543143)\n",
+      "variable(0.4369946169420029) variable(0.18816601262979143)\n",
+      "variable(0.4376314939338304) variable(0.1887256691510907)\n",
+      "variable(0.43826684421823436) variable(0.1892848002174238)\n",
+      "variable(0.4389006741616739) variable(0.18984340552214107)\n",
+      "variable(0.4395329900939247) variable(0.19040148477362723)\n",
+      "variable(0.44016379830833074) variable(0.19095903769508302)\n",
+      "variable(0.44079310506205366) variable(0.1915160640243098)\n",
+      "variable(0.4414209165763208) variable(0.19207256351349716)\n",
+      "variable(0.44204723903667137) variable(0.19262853592901358)\n",
+      "variable(0.4426720785932005) variable(0.1931839810511997)\n",
+      "variable(0.4432954413608023) variable(0.1937388986741647)\n",
+      "variable(0.44391733341941036) variable(0.19429328860558545)\n",
+      "variable(0.4445377608142374) variable(0.19484715066650835)\n",
+      "variable(0.4451567295560124) variable(0.1954004846911539)\n",
+      "variable(0.44577424562121654) variable(0.19595329052672406)\n",
+      "variable(0.44639031495231746) variable(0.19650556803321217)\n",
+      "variable(0.4470049434580015) variable(0.19705731708321558)\n",
+      "variable(0.4476181370134045) variable(0.1976085375617507)\n",
+      "variable(0.44822990146034114) variable(0.19815922936607075)\n",
+      "variable(0.44884024260753197) variable(0.19870939240548602)\n",
+      "variable(0.44944916623082976) variable(0.19925902660118644)\n",
+      "variable(0.4500566780734433) variable(0.19980813188606675)\n",
+      "variable(0.45066278384616015) variable(0.20035670820455398)\n",
+      "variable(0.4512674892275676) variable(0.20090475551243736)\n",
+      "variable(0.451870799864272) variable(0.20145227377670047)\n",
+      "variable(0.45247272137111644) variable(0.20199926297535575)\n",
+      "variable(0.45307325933139725) variable(0.2025457230972814)\n",
+      "variable(0.4536724192970782) variable(0.2030916541420602)\n",
+      "variable(0.45427020678900376) variable(0.20363705611982094)\n",
+      "variable(0.45486662729711075) variable(0.2041819290510816)\n",
+      "variable(0.45546168628063793) variable(0.204726272966595)\n",
+      "variable(0.45605538916833477) variable(0.20527008790719645)\n",
+      "variable(0.4566477413586681) variable(0.20581337392365343)\n",
+      "variable(0.45723874822002764) variable(0.20635613107651735)\n",
+      "variable(0.4578284150909297) variable(0.20689835943597745)\n",
+      "variable(0.4584167472802198) variable(0.20744005908171648)\n",
+      "variable(0.45900375006727334) variable(0.20798123010276856)\n",
+      "variable(0.4595894287021951) variable(0.20852187259737884)\n",
+      "variable(0.46017378840601725) variable(0.20906198667286507)\n",
+      "variable(0.46075683437089565) variable(0.20960157244548125)\n",
+      "variable(0.4613385717603052) variable(0.2101406300402828)\n",
+      "variable(0.461919005709233) variable(0.2106791595909939)\n",
+      "variable(0.46249814132437106) variable(0.2112171612398764)\n",
+      "variable(0.46307598368430664) variable(0.2117546351376007)\n",
+      "variable(0.46365253783971166) variable(0.21229158144311822)\n",
+      "variable(0.46422780881353093) variable(0.21282800032353563)\n",
+      "variable(0.4648018016011683) variable(0.21336389195399094)\n",
+      "variable(0.4653745211706722) variable(0.2138992565175311)\n",
+      "variable(0.46594597246291913) variable(0.21443409420499138)\n",
+      "variable(0.46651616039179644) variable(0.21496840521487617)\n",
+      "variable(0.4670850898443832) variable(0.2155021897532418)\n",
+      "variable(0.46765276568112985) variable(0.21603544803358055)\n",
+      "variable(0.46821919273603696) variable(0.21656818027670638)\n",
+      "variable(0.4687843758168321) variable(0.21710038671064233)\n",
+      "variable(0.4693483197051455) variable(0.21763206757050924)\n",
+      "variable(0.46991102915668487) variable(0.2181632230984161)\n",
+      "variable(0.47047250890140824) variable(0.21869385354335183)\n",
+      "variable(0.4710327636436961) variable(0.2192239591610786)\n",
+      "variable(0.47159179806252194) variable(0.2197535402140265)\n",
+      "variable(0.47214961681162143) variable(0.22028259697118968)\n",
+      "variable(0.4727062245196608) variable(0.22081112970802394)\n",
+      "variable(0.4732616257904035) variable(0.22133913870634556)\n",
+      "variable(0.4738158252028757) variable(0.22186662425423162)\n",
+      "variable(0.4743688273115309) variable(0.2223935866459217)\n",
+      "variable(0.474920636646413) variable(0.22292002618172077)\n",
+      "variable(0.47547125771331805) variable(0.22344594316790345)\n",
+      "variable(0.4760206949939553) variable(0.22397133791661966)\n",
+      "variable(0.47656895294610635) variable(0.22449621074580137)\n",
+      "variable(0.47711603600378377) variable(0.22502056197907072)\n",
+      "variable(0.4776619485773882) variable(0.22554439194564935)\n",
+      "variable(0.4782066950538643) variable(0.22606770098026896)\n",
+      "variable(0.4787502797968556) variable(0.22659048942308307)\n",
+      "variable(0.4792927071468581) variable(0.22711275761957997)\n",
+      "variable(0.47983398142137307) variable(0.22763450592049675)\n",
+      "variable(0.48037410691505805) variable(0.22815573468173472)\n",
+      "variable(0.48091308789987747) variable(0.2286764442642757)\n",
+      "variable(0.48145092862525163) variable(0.2291966350340996)\n",
+      "variable(0.4819876333182049) variable(0.2297163073621031)\n",
+      "variable(0.48252320618351235) variable(0.23023546162401934)\n",
+      "variable(0.483057651403846) variable(0.23075409820033874)\n",
+      "variable(0.4835909731399192) variable(0.23127221747623092)\n",
+      "variable(0.4841231755306308) variable(0.23178981984146754)\n",
+      "variable(0.4846542626932071) variable(0.23230690569034643)\n",
+      "variable(0.48518423872334415) variable(0.23282347542161638)\n",
+      "variable(0.4857131076953477) variable(0.2333395294384033)\n",
+      "variable(0.48624087366227287) variable(0.23385506814813714)\n",
+      "variable(0.48676754065606265) variable(0.2343700919624798)\n",
+      "variable(0.4872931126876851) variable(0.23488460129725416)\n",
+      "variable(0.48781759374727) variable(0.2353985965723739)\n",
+      "variable(0.48834098780424395) variable(0.23591207821177446)\n",
+      "variable(0.4888632988074648) variable(0.23642504664334452)\n",
+      "variable(0.48938453068535526) variable(0.23693750229885893)\n",
+      "variable(0.4899046873460348) variable(0.23744944561391224)\n",
+      "variable(0.4904237726774516) variable(0.237960877027853)\n",
+      "variable(0.49094179054751236) variable(0.23847179698371934)\n",
+      "variable(0.4914587448042123) variable(0.23898220592817498)\n",
+      "variable(0.4919746392757634) variable(0.23949210431144635)\n",
+      "variable(0.4924894777707219) variable(0.24000149258726058)\n",
+      "variable(0.4930032640781149) variable(0.24051037121278415)\n",
+      "variable(0.4935160019675662) variable(0.2410187406485624)\n",
+      "variable(0.4940276951894208) variable(0.24152660135846007)\n",
+      "variable(0.49453834747486897) variable(0.24203395380960233)\n",
+      "variable(0.49504796253606875) variable(0.24254079847231672)\n",
+      "variable(0.49555654406626837) variable(0.24304713582007595)\n",
+      "variable(0.49606409573992694) variable(0.24355296632944143)\n",
+      "variable(0.49657062121283496) variable(0.24405829048000743)\n",
+      "variable(0.4970761241222334) variable(0.24456310875434611)\n",
+      "variable(0.4975806080869322) variable(0.24506742163795328)\n",
+      "variable(0.4980840767074279) variable(0.24557122961919486)\n",
+      "variable(0.49858653356602006) variable(0.24607453318925407)\n",
+      "variable(0.4990879822269274) variable(0.24657733284207928)\n",
+      "variable(0.4995884262364026) variable(0.2470796290743326)\n",
+      "variable(0.5000878691228463) variable(0.24758142238533917)\n",
+      "variable(0.5005863143969207) variable(0.24808271327703715)\n",
+      "variable(0.5010837655516618) variable(0.24858350225392828)\n",
+      "variable(0.5015802260625909) variable(0.24908378982302917)\n",
+      "variable(0.5020756993878257) variable(0.2495835764938233)\n",
+      "variable(0.5025701889681902) variable(0.2500828627782135)\n",
+      "variable(0.5030636982273234) variable(0.25058164919047526)\n",
+      "variable(0.5035562305717887) variable(0.25107993624721053)\n",
+      "variable(0.5040477893911804) variable(0.2515777244673021)\n",
+      "variable(0.5045383780582312) variable(0.25207501437186886)\n",
+      "variable(0.505027999928918) variable(0.25257180648422123)\n",
+      "variable(0.505516658342567) variable(0.2530681013298176)\n",
+      "variable(0.5060043566219584) variable(0.2535638994362212)\n",
+      "variable(0.5064910980734301) variable(0.25405920133305737)\n",
+      "variable(0.5069768859869803) variable(0.25455400755197166)\n",
+      "variable(0.5074617236363702) variable(0.25504831862658844)\n",
+      "variable(0.507945614279225) variable(0.2555421350924699)\n",
+      "variable(0.508428561157135) variable(0.2560354574870758)\n",
+      "variable(0.5089105674957553) variable(0.2565282863497235)\n",
+      "variable(0.5093916365049052) variable(0.25702062222154914)\n",
+      "variable(0.5098717713786666) variable(0.2575124656454684)\n",
+      "variable(0.5103509752954819) variable(0.25800381716613857)\n",
+      "variable(0.5108292514182511) variable(0.25849467732992076)\n",
+      "variable(0.5113066028944281) variable(0.2589850466848428)\n",
+      "variable(0.5117830328561166) variable(0.2594749257805623)\n",
+      "variable(0.5122585444201648) variable(0.25996431516833085)\n",
+      "variable(0.5127331406882601) variable(0.2604532154009579)\n",
+      "variable(0.5132068247470223) variable(0.26094162703277574)\n",
+      "variable(0.5136795996680968) variable(0.26142955061960477)\n",
+      "variable(0.514151468508247) variable(0.26191698671871905)\n",
+      "variable(0.5146224343094455) variable(0.2624039358888126)\n",
+      "variable(0.5150925000989656) variable(0.262890398689966)\n",
+      "variable(0.5155616688894709) variable(0.2633763756836134)\n",
+      "variable(0.5160299436791055) variable(0.26386186743251)\n",
+      "variable(0.516497327451583) variable(0.26434687450070016)\n",
+      "variable(0.5169638231762745) variable(0.26483139745348566)\n",
+      "variable(0.5174294338082965) variable(0.2653154368573946)\n",
+      "variable(0.517894162288598) variable(0.26579899328015055)\n",
+      "variable(0.5183580115440468) variable(0.2662820672906422)\n",
+      "variable(0.5188209844875159) variable(0.2667646594588934)\n",
+      "variable(0.5192830840179679) variable(0.2672467703560337)\n",
+      "variable(0.5197443130205399) variable(0.26772840055426933)\n",
+      "variable(0.5202046743666282) variable(0.2682095506268541)\n",
+      "variable(0.5206641709139705) variable(0.2686902211480612)\n",
+      "variable(0.5211228055067298) variable(0.2691704126931554)\n",
+      "variable(0.5215805809755759) variable(0.2696501258383653)\n",
+      "variable(0.5220375001377672) variable(0.27012936116085606)\n",
+      "variable(0.5224935657972319) variable(0.2706081192387027)\n",
+      "variable(0.5229487807446487) variable(0.2710864006508634)\n",
+      "variable(0.5234031477575258) variable(0.27156420597715364)\n",
+      "variable(0.5238566696002812) variable(0.2720415357982202)\n",
+      "variable(0.5243093490243209) variable(0.2725183906955158)\n",
+      "variable(0.5247611887681174) variable(0.2729947712512741)\n",
+      "variable(0.5252121915572869) variable(0.2734706780484848)\n",
+      "variable(0.525662360104667) variable(0.27394611167086946)\n",
+      "variable(0.5261116971103927) variable(0.2744210727028573)\n",
+      "variable(0.5265602052619729) variable(0.27489556172956137)\n",
+      "variable(0.5270078872343653) variable(0.2753695793367553)\n",
+      "variable(0.5274547456900518) variable(0.27584312611085016)\n",
+      "variable(0.5279007832791127) variable(0.2763162026388716)\n",
+      "variable(0.5283460026393008) variable(0.27678880950843743)\n",
+      "variable(0.528790406396114) variable(0.27726094730773554)\n",
+      "variable(0.5292339971628692) variable(0.2777326166255019)\n",
+      "variable(0.529676777540774) variable(0.2782038180509991)\n",
+      "variable(0.5301187501189986) variable(0.278674552173995)\n",
+      "variable(0.530559917474747) variable(0.27914481958474185)\n",
+      "variable(0.531000282173328) variable(0.27961462087395555)\n",
+      "variable(0.5314398467682255) variable(0.28008395663279523)\n",
+      "variable(0.5318786138011683) variable(0.2805528274528432)\n",
+      "variable(0.5323165858021992) variable(0.281021233926085)\n",
+      "variable(0.5327537652897443) variable(0.28148917664489004)\n",
+      "variable(0.5331901547706807) variable(0.281956656201992)\n",
+      "variable(0.533625756740405) variable(0.28242367319047007)\n",
+      "variable(0.5340605736829005) variable(0.28289022820373005)\n",
+      "variable(0.5344946080708038) variable(0.2833563218354858)\n",
+      "variable(0.534927862365472) variable(0.2838219546797411)\n",
+      "variable(0.5353603390170478) variable(0.28428712733077155)\n",
+      "variable(0.5357920404645259) variable(0.2847518403831069)\n",
+      "variable(0.5362229691358175) variable(0.2852160944315136)\n",
+      "variable(0.5366531274478149) variable(0.2856798900709772)\n",
+      "variable(0.5370825178064564) variable(0.2861432278966859)\n",
+      "variable(0.5375111426067892) variable(0.28660610850401325)\n",
+      "variable(0.5379390042330332) variable(0.28706853248850184)\n",
+      "variable(0.5383661050586436) variable(0.28753050044584694)\n",
+      "variable(0.5387924474463734) variable(0.28799201297188043)\n",
+      "variable(0.5392180337483357) variable(0.288453070662555)\n",
+      "variable(0.5396428663060646) variable(0.28891367411392826)\n",
+      "variable(0.5400669474505772) variable(0.2893738239221476)\n",
+      "variable(0.5404902795024332) variable(0.289833520683435)\n",
+      "variable(0.5409128647717966) variable(0.29029276499407164)\n",
+      "variable(0.5413347055584941) variable(0.29075155745038367)\n",
+      "variable(0.5417558041520758) variable(0.2912098986487272)\n",
+      "variable(0.5421761628318736) variable(0.2916677891854742)\n",
+      "variable(0.5425957838670601) variable(0.2921252296569982)\n",
+      "variable(0.5430146695167065) variable(0.29258222065966044)\n",
+      "variable(0.5434328220298411) variable(0.29303876278979596)\n",
+      "variable(0.5438502436455062) variable(0.2934948566437002)\n",
+      "variable(0.5442669365928152) variable(0.2939505028176154)\n",
+      "variable(0.5446829030910099) variable(0.29440570190771786)\n",
+      "variable(0.5450981453495157) variable(0.2948604545101044)\n",
+      "variable(0.5455126655679986) variable(0.2953147612207799)\n",
+      "variable(0.54592646593642) variable(0.2957686226356445)\n",
+      "variable(0.5463395486350924) variable(0.29622203935048147)\n",
+      "variable(0.5467519158347334) variable(0.2966750119609445)\n",
+      "variable(0.5471635696965209) variable(0.29712754106254585)\n",
+      "variable(0.5475745123721467) variable(0.2975796272506446)\n",
+      "variable(0.5479847460038703) variable(0.29803127112043454)\n",
+      "variable(0.548394272724572) variable(0.2984824732669329)\n",
+      "variable(0.5488030946578061) variable(0.29893323428496876)\n",
+      "variable(0.5492112139178534) variable(0.299383554769172)\n",
+      "variable(0.5496186326097734) variable(0.29983343531396206)\n",
+      "variable(0.5500253528294561) variable(0.3002828765135371)\n",
+      "variable(0.5504313766636735) variable(0.3007318789618632)\n",
+      "variable(0.5508367061901309) variable(0.3011804432526639)\n",
+      "variable(0.5512413434775179) variable(0.3016285699794097)\n",
+      "variable(0.5516452905855583) variable(0.3020762597353075)\n",
+      "variable(0.552048549565061) variable(0.302523513113291)\n",
+      "variable(0.5524511224579691) variable(0.3029703307060103)\n",
+      "variable(0.55285301129741) variable(0.30341671310582224)\n",
+      "variable(0.553254218107744) variable(0.30386266090478065)\n",
+      "variable(0.5536547449046134) variable(0.30430817469462673)\n",
+      "variable(0.5540545936949912) variable(0.3047532550667799)\n",
+      "variable(0.5544537664772287) variable(0.3051979026123283)\n",
+      "variable(0.5548522652411038) variable(0.3056421179220197)\n",
+      "variable(0.5552500919678683) variable(0.3060859015862526)\n",
+      "variable(0.5556472486302955) variable(0.3065292541950673)\n",
+      "variable(0.5560437371927263) variable(0.30697217633813734)\n",
+      "variable(0.5564395596111167) variable(0.3074146686047606)\n",
+      "variable(0.5568347178330834) variable(0.3078567315838512)\n",
+      "variable(0.55722921379795) variable(0.30829836586393083)\n",
+      "variable(0.5576230494367929) variable(0.30873957203312097)\n",
+      "variable(0.5580162266724861) variable(0.30918035067913435)\n",
+      "variable(0.5584087474197467) variable(0.30962070238926737)\n",
+      "variable(0.5588006135851796) variable(0.310060627750392)\n",
+      "variable(0.559191827067322) variable(0.3105001273489483)\n",
+      "variable(0.559582389756687) variable(0.31093920177093654)\n",
+      "variable(0.5599723035358084) variable(0.31137785160191017)\n",
+      "variable(0.5603615702792837) variable(0.31181607742696804)\n",
+      "variable(0.5607501918538175) variable(0.31225387983074737)\n",
+      "variable(0.5611381701182645) variable(0.31269125939741654)\n",
+      "variable(0.5615255069236724) variable(0.3131282167106681)\n",
+      "variable(0.5619122041133242) variable(0.31356475235371195)\n",
+      "variable(0.5622982635227803) variable(0.3140008669092684)\n",
+      "variable(0.5626836869799207) variable(0.3144365609595615)\n",
+      "variable(0.5630684763049862) variable(0.31487183508631267)\n",
+      "variable(0.5634526333106202) variable(0.3153066898707339)\n",
+      "variable(0.5638361598019096) variable(0.3157411258935216)\n",
+      "variable(0.5642190575764253) variable(0.3161751437348502)\n",
+      "variable(0.5646013284242634) variable(0.31660874397436606)\n",
+      "variable(0.5649829741280847) variable(0.3170419271911814)\n",
+      "variable(0.5653639964631556) variable(0.31747469396386835)\n",
+      "variable(0.5657443971973871) variable(0.3179070448704529)\n",
+      "variable(0.5661241780913747) variable(0.3183389804884093)\n",
+      "variable(0.5665033408984376) variable(0.31877050139465435)\n",
+      "variable(0.5668818873646574) variable(0.3192016081655418)\n",
+      "variable(0.5672598192289174) variable(0.31963230137685666)\n",
+      "variable(0.5676371382229408) variable(0.3200625816038101)\n",
+      "variable(0.5680138460713287) variable(0.3204924494210341)\n",
+      "variable(0.5683899444915982) variable(0.32092190540257587)\n",
+      "variable(0.5687654351942207) variable(0.32135095012189313)\n",
+      "variable(0.5691403198826588) variable(0.32177958415184876)\n",
+      "variable(0.5695146002534035) variable(0.32220780806470606)\n",
+      "variable(0.5698882779960117) variable(0.3226356224321236)\n",
+      "variable(0.5702613547931428) variable(0.3230630278251508)\n",
+      "variable(0.570633832320595) variable(0.32349002481422273)\n",
+      "variable(0.5710057122473419) variable(0.32391661396915594)\n",
+      "variable(0.5713769962355686) variable(0.3243427958591436)\n",
+      "variable(0.5717476859407074) variable(0.3247685710527511)\n",
+      "variable(0.5721177830114733) variable(0.32519394011791164)\n",
+      "variable(0.5724872890899) variable(0.325618903621922)\n",
+      "variable(0.5728562058113743) variable(0.32604346213143814)\n",
+      "variable(0.5732245348046715) variable(0.3264676162124712)\n",
+      "variable(0.57359227769199) variable(0.3268913664303834)\n",
+      "variable(0.5739594360889858) variable(0.3273147133498837)\n",
+      "variable(0.574326011604807) variable(0.32773765753502426)\n",
+      "variable(0.5746920058421275) variable(0.3281601995491964)\n",
+      "variable(0.5750574203971811) variable(0.3285823399551267)\n",
+      "variable(0.575422256859795) variable(0.3290040793148734)\n",
+      "variable(0.5757865168134232) variable(0.3294254181898227)\n",
+      "variable(0.5761502018351801) variable(0.32984635714068505)\n",
+      "variable(0.576513313495873) variable(0.33026689672749177)\n",
+      "variable(0.576875853360035) variable(0.33068703750959155)\n",
+      "variable(0.5772378229859579) variable(0.331106780045647)\n",
+      "variable(0.5775992239257245) variable(0.3315261248936312)\n",
+      "variable(0.5779600577252401) variable(0.3319450726108248)\n",
+      "variable(0.5783203259242654) variable(0.3323636237538124)\n",
+      "variable(0.578680030056448) variable(0.33278177887847965)\n",
+      "variable(0.5790391716493536) variable(0.33319953854001)\n",
+      "variable(0.5793977522244977) variable(0.3336169032928819)\n",
+      "variable(0.5797557732973769) variable(0.3340338736908656)\n",
+      "variable(0.5801132363774996) variable(0.3344504502870204)\n",
+      "variable(0.5804701429684168) variable(0.3348666336336917)\n",
+      "variable(0.580826494567753) variable(0.3352824242825082)\n",
+      "variable(0.5811822926672365) variable(0.3356978227843794)\n",
+      "variable(0.5815375387527292) variable(0.3361128296894926)\n",
+      "variable(0.5818922343042572) variable(0.33652744554731046)\n",
+      "variable(0.5822463807960404) variable(0.33694167090656846)\n",
+      "variable(0.5825999796965222) variable(0.3373555063152723)\n",
+      "variable(0.5829530324683989) variable(0.3377689523206954)\n",
+      "variable(0.583305540568649) variable(0.33818200946937677)\n",
+      "variable(0.5836575054485625) variable(0.3385946783071182)\n",
+      "variable(0.5840089285537696) variable(0.33900695937898234)\n",
+      "variable(0.5843598113242696) variable(0.3394188532292903)\n",
+      "variable(0.5847101551944593) variable(0.3398303604016194)\n",
+      "variable(0.5850599615931618) variable(0.3402414814388013)\n",
+      "variable(0.585409231943654) variable(0.3406522168829194)\n",
+      "variable(0.5857579676636956) variable(0.3410625672753073)\n",
+      "variable(0.586106170165556) variable(0.34147253315654646)\n",
+      "variable(0.5864538408560428) variable(0.3418821150664643)\n",
+      "variable(0.5868009811365289) variable(0.3422913135441324)\n",
+      "variable(0.58714759240298) variable(0.3427001291278645)\n",
+      "variable(0.5874936760459818) variable(0.3431085623552148)\n",
+      "variable(0.587839233450767) variable(0.34351661376297604)\n",
+      "variable(0.5881842659972423) variable(0.34392428388717794)\n",
+      "variable(0.5885287750600148) variable(0.3443315732630853)\n",
+      "variable(0.5888727620084186) variable(0.3447384824251965)\n",
+      "variable(0.589216228206542) variable(0.34514501190724195)\n",
+      "variable(0.5895591750132521) variable(0.3455511622421823)\n",
+      "variable(0.5899016037822225) variable(0.3459569339622071)\n",
+      "variable(0.5902435158619582) variable(0.3463623275987333)\n",
+      "variable(0.5905849125958217) variable(0.3467673436824038)\n",
+      "variable(0.5909257953220585) variable(0.3471719827430859)\n",
+      "variable(0.5912661653738225) variable(0.3475762453098702)\n",
+      "variable(0.5916060240792014) variable(0.347980131911069)\n",
+      "variable(0.5919453727612418) variable(0.3483836430742153)\n",
+      "variable(0.5922842127379742) variable(0.34878677932606134)\n",
+      "variable(0.5926225453224375) variable(0.34918954119257745)\n",
+      "variable(0.5929603718227042) variable(0.3495919291989509)\n",
+      "variable(0.5932976935419044) variable(0.34999394386958466)\n",
+      "variable(0.5936345117782508) variable(0.3503955857280964)\n",
+      "variable(0.5939708278250622) variable(0.3507968552973176)\n",
+      "variable(0.5943066429707881) variable(0.35119775309929196)\n",
+      "variable(0.5946419584990325) variable(0.3515982796552751)\n",
+      "variable(0.5949767756885777) variable(0.3519984354857331)\n",
+      "variable(0.595311095813408) variable(0.3523982211103417)\n",
+      "variable(0.5956449201427331) variable(0.3527976370479855)\n",
+      "variable(0.5959782499410115) variable(0.35319668381675695)\n",
+      "variable(0.5963110864679737) variable(0.3535953619339557)\n",
+      "variable(0.5966434309786455) variable(0.3539936719160876)\n",
+      "variable(0.5969752847233708) variable(0.354391614278864)\n",
+      "variable(0.5973066489478345) variable(0.3547891895372011)\n",
+      "variable(0.597637524893085) variable(0.3551863982052192)\n",
+      "variable(0.5979679137955568) variable(0.35558324079624193)\n",
+      "variable(0.5982978168870933) variable(0.35597971782279564)\n",
+      "variable(0.5986272353949685) variable(0.35637582979660887)\n",
+      "variable(0.5989561705419095) variable(0.3567715772286117)\n",
+      "variable(0.5992846235461186) variable(0.35716696062893516)\n",
+      "variable(0.5996125956212947) variable(0.35756198050691074)\n",
+      "variable(0.5999400879766557) variable(0.3579566373710698)\n",
+      "variable(0.6002671018169597) variable(0.3583509317291433)\n",
+      "variable(0.6005936383425268) variable(0.3587448640880611)\n",
+      "variable(0.6009196987492601) variable(0.35913843495395165)\n",
+      "variable(0.6012452842286673) variable(0.3595316448321416)\n",
+      "variable(0.6015703959678816) variable(0.3599244942271555)\n",
+      "variable(0.601895035149683) variable(0.3603169836427152)\n",
+      "variable(0.6022192029525187) variable(0.3607091135817398)\n",
+      "variable(0.6025429005505245) variable(0.3611008845463452)\n",
+      "variable(0.6028661291135446) variable(0.361492297037844)\n",
+      "variable(0.6031888898071531) variable(0.36188335155674506)\n",
+      "variable(0.6035111837926737) variable(0.36227404860275325)\n",
+      "variable(0.6038330122271999) variable(0.36266438867476947)\n",
+      "variable(0.6041543762636158) variable(0.3630543722708903)\n",
+      "variable(0.6044752770506157) variable(0.363443999888408)\n",
+      "variable(0.6047957157327238) variable(0.3638332720238101)\n",
+      "variable(0.6051156934503149) variable(0.3642221891727796)\n",
+      "variable(0.605435211339633) variable(0.36461075183019476)\n",
+      "variable(0.6057542705328114) variable(0.36499896049012903)\n",
+      "variable(0.6060728721578924) variable(0.3653868156458509)\n",
+      "variable(0.6063910173388463) variable(0.3657743177898241)\n",
+      "variable(0.6067087071955906) variable(0.3661614674137075)\n",
+      "variable(0.6070259428440096) variable(0.36654826500835497)\n",
+      "variable(0.6073427253959727) variable(0.36693471106381575)\n",
+      "variable(0.6076590559593541) variable(0.3673208060693342)\n",
+      "variable(0.6079749356380509) variable(0.36770655051335005)\n",
+      "variable(0.6082903655320023) variable(0.3680919448834985)\n",
+      "variable(0.6086053467372079) variable(0.3684769896666102)\n",
+      "variable(0.6089198803457463) variable(0.36886168534871155)\n",
+      "variable(0.6092339674457934) variable(0.36924603241502485)\n",
+      "variable(0.6095476091216407) variable(0.3696300313499683)\n",
+      "variable(0.6098608064537137) variable(0.37001368263715634)\n",
+      "variable(0.6101735605185893) variable(0.37039698675939986)\n",
+      "variable(0.6104858723890146) variable(0.3707799441987064)\n",
+      "variable(0.6107977431339242) variable(0.3711625554362804)\n",
+      "variable(0.6111091738184581) variable(0.3715448209525234)\n",
+      "variable(0.6114201655039793) variable(0.3719267412270344)\n",
+      "variable(0.6117307192480914) variable(0.3723083167386102)\n",
+      "variable(0.6120408361046562) variable(0.3726895479652456)\n",
+      "variable(0.6123505171238107) variable(0.3730704353841338)\n",
+      "variable(0.6126597633519847) variable(0.3734509794716667)\n",
+      "variable(0.6129685758319177) variable(0.37383118070343535)\n",
+      "variable(0.6132769556026761) variable(0.3742110395542302)\n",
+      "variable(0.6135849036996703) variable(0.3745905564980415)\n",
+      "variable(0.6138924211546711) variable(0.37496973200805994)\n",
+      "variable(0.614199508995827) variable(0.37534856655667675)\n",
+      "variable(0.6145061682476803) variable(0.3757270606154844)\n",
+      "variable(0.6148123999311845) variable(0.3761052146552768)\n",
+      "variable(0.6151182050637201) variable(0.37648302914605)\n",
+      "variable(0.615423584659111) variable(0.37686050455700254)\n",
+      "variable(0.6157285397276412) variable(0.37723764135653604)\n",
+      "variable(0.6160330712760709) variable(0.3776144400122555)\n",
+      "variable(0.6163371803076524) variable(0.37799090099097016)\n",
+      "variable(0.6166408678221463) variable(0.37836702475869366)\n",
+      "variable(0.6169441348158374) variable(0.3787428117806449)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "variable(0.6172469822815506) variable(0.37911826252124836)\n",
+      "variable(0.6175494112086666) variable(0.37949337744413486)\n",
+      "variable(0.6178514225831375) variable(0.37986815701214205)\n",
+      "variable(0.6181530173875027) variable(0.380242601687315)\n",
+      "variable(0.618454196600904) variable(0.38061671193090685)\n",
+      "variable(0.6187549611991012) variable(0.3809904882033794)\n",
+      "variable(0.6190553121544876) variable(0.38136393096440374)\n",
+      "variable(0.6193552504361048) variable(0.381737040672861)\n",
+      "variable(0.6196547770096585) variable(0.38210981778684283)\n",
+      "variable(0.6199538928375329) variable(0.3824822627636522)\n",
+      "variable(0.620252598878806) variable(0.382854376059804)\n",
+      "variable(0.6205508960892646) variable(0.3832261581310258)\n",
+      "variable(0.6208487854214191) variable(0.3835976094322585)\n",
+      "variable(0.6211462678245181) variable(0.38396873041765706)\n",
+      "variable(0.621443344244563) variable(0.38433952154059126)\n",
+      "variable(0.6217400156243229) variable(0.3847099832536463)\n",
+      "variable(0.6220362829033488) variable(0.3850801160086237)\n",
+      "variable(0.6223321470179882) variable(0.38544992025654196)\n",
+      "variable(0.6226276089013995) variable(0.38581939644763735)\n",
+      "variable(0.6229226694835657) variable(0.3861885450313647)\n",
+      "variable(0.6232173296913095) variable(0.38655736645639804)\n",
+      "variable(0.6235115904483067) variable(0.3869258611706317)\n",
+      "variable(0.6238054526751007) variable(0.38729402962118076)\n",
+      "variable(0.6240989172891158) variable(0.38766187225438203)\n",
+      "variable(0.6243919852046719) variable(0.38802938951579496)\n",
+      "variable(0.6246846573329976) variable(0.3883965818502022)\n",
+      "variable(0.6249769345822443) variable(0.3887634497016107)\n",
+      "variable(0.6252688178575001) variable(0.38912999351325234)\n",
+      "variable(0.6255603080608025) variable(0.389496213727585)\n",
+      "variable(0.6258514060911528) variable(0.38986211078629324)\n",
+      "variable(0.626142112844529) variable(0.3902276851302892)\n",
+      "variable(0.6264324292138996) variable(0.39059293719971355)\n",
+      "variable(0.6267223560892363) variable(0.3909578674339363)\n",
+      "variable(0.6270118943575277) variable(0.39132247627155775)\n",
+      "variable(0.6273010449027923) variable(0.3916867641504093)\n",
+      "variable(0.6275898086060914) variable(0.39205073150755443)\n",
+      "variable(0.6278781863455424) variable(0.39241437877928964)\n",
+      "variable(0.6281661789963314) variable(0.39277770640114523)\n",
+      "variable(0.6284537874307264) variable(0.3931407148078864)\n",
+      "variable(0.6287410125180899) variable(0.39350340443351406)\n",
+      "variable(0.6290278551248915) variable(0.3938657757112658)\n",
+      "variable(0.6293143161147207) variable(0.3942278290736169)\n",
+      "variable(0.6296003963482997) variable(0.39458956495228126)\n",
+      "variable(0.6298860966834954) variable(0.3949509837782122)\n",
+      "variable(0.6301714179753323) variable(0.39531208598160367)\n",
+      "variable(0.6304563610760046) variable(0.3956728719918911)\n",
+      "variable(0.6307409268348888) variable(0.3960333422377524)\n",
+      "variable(0.6310251160985558) variable(0.3963934971471088)\n",
+      "variable(0.6313089297107829) variable(0.39675333714712624)\n",
+      "variable(0.6315923685125663) variable(0.39711286266421586)\n",
+      "variable(0.6318754333421327) variable(0.39747207412403535)\n",
+      "variable(0.6321581250349517) variable(0.39783097195148986)\n",
+      "variable(0.6324404444237476) variable(0.398189556570733)\n",
+      "variable(0.6327223923385111) variable(0.3985478284051679)\n",
+      "variable(0.6330039696065114) variable(0.39890578787744807)\n",
+      "variable(0.6332851770523077) variable(0.3992634354094787)\n",
+      "variable(0.6335660154977608) variable(0.3996207714224175)\n",
+      "variable(0.6338464857620452) variable(0.39997779633667574)\n",
+      "variable(0.6341265886616599) variable(0.4003345105719195)\n",
+      "variable(0.6344063250104408) variable(0.4006909145470704)\n",
+      "variable(0.6346856956195712) variable(0.4010470086803069)\n",
+      "variable(0.6349647012975937) variable(0.4014027933890653)\n",
+      "variable(0.6352433428504217) variable(0.40175826909004075)\n",
+      "variable(0.6355216210813501) variable(0.40211343619918827)\n",
+      "variable(0.6357995367910667) variable(0.40246829513172405)\n",
+      "variable(0.6360770907776637) variable(0.4028228463021262)\n",
+      "variable(0.6363542838366483) variable(0.4031770901241362)\n",
+      "variable(0.6366311167609536) variable(0.40353102701075966)\n",
+      "variable(0.6369075903409506) variable(0.40388465737426754)\n",
+      "variable(0.6371837053644576) variable(0.40423798162619723)\n",
+      "variable(0.637459462616752) variable(0.4045910001773538)\n",
+      "variable(0.6377348628805812) variable(0.40494371343781066)\n",
+      "variable(0.6380099069361727) variable(0.40529612181691127)\n",
+      "variable(0.6382845955612451) variable(0.40564822572326975)\n",
+      "variable(0.6385589295310187) variable(0.4060000255647722)\n",
+      "variable(0.6388329096182263) variable(0.40635152174857786)\n",
+      "variable(0.6391065365931232) variable(0.40670271468112007)\n",
+      "variable(0.6393798112234982) variable(0.4070536047681075)\n",
+      "variable(0.6396527342746835) variable(0.40740419241452525)\n",
+      "variable(0.6399253065095654) variable(0.407754478024636)\n",
+      "variable(0.6401975286885944) variable(0.408104462001981)\n",
+      "variable(0.6404694015697955) variable(0.4084541447493815)\n",
+      "variable(0.6407409259087785) variable(0.4088035266689396)\n",
+      "variable(0.6410121024587482) variable(0.4091526081620394)\n",
+      "variable(0.6412829319705138) variable(0.40950138962934846)\n",
+      "variable(0.6415534151925) variable(0.40984987147081847)\n",
+      "variable(0.6418235528707561) variable(0.4101980540856868)\n",
+      "variable(0.6420933457489664) variable(0.4105459378724775)\n",
+      "variable(0.6423627945684597) variable(0.41089352322900236)\n",
+      "variable(0.6426319000682196) variable(0.4112408105523621)\n",
+      "variable(0.642900662984894) variable(0.4115878002389477)\n",
+      "variable(0.6431690840528047) variable(0.41193449268444143)\n",
+      "variable(0.6434371640039573) variable(0.4122808882838179)\n",
+      "variable(0.6437049035680509) variable(0.41262698743134546)\n",
+      "variable(0.6439723034724871) variable(0.4129727905205871)\n",
+      "variable(0.6442393644423804) variable(0.4133182979444019)\n",
+      "variable(0.644506087200567) variable(0.41366351009494595)\n",
+      "variable(0.6447724724676146) variable(0.4140084273636737)\n",
+      "variable(0.6450385209618313) variable(0.41435305014133916)\n",
+      "variable(0.6453042333992758) variable(0.41469737881799673)\n",
+      "variable(0.6455696104937657) variable(0.4150414137830028)\n",
+      "variable(0.6458346529568874) variable(0.4153851554250167)\n",
+      "variable(0.646099361498005) variable(0.41572860413200197)\n",
+      "variable(0.6463637368242695) variable(0.4160717602912275)\n",
+      "variable(0.6466277796406281) variable(0.41641462428926873)\n",
+      "variable(0.646891490649833) variable(0.4167571965120087)\n",
+      "variable(0.6471548705524505) variable(0.41709947734463954)\n",
+      "variable(0.6474179200468698) variable(0.4174414671716634)\n",
+      "variable(0.6476806398293123) variable(0.4177831663768938)\n",
+      "variable(0.6479430305938401) variable(0.4181245753434565)\n",
+      "variable(0.648205093032365) variable(0.41846569445379117)\n",
+      "variable(0.6484668278346571) variable(0.4188065240896523)\n",
+      "variable(0.648728235688354) variable(0.41914706463211043)\n",
+      "variable(0.6489893172789689) variable(0.4194873164615533)\n",
+      "variable(0.6492500732898997) variable(0.4198272799576871)\n",
+      "variable(0.6495105044024373) variable(0.4201669554995377)\n",
+      "variable(0.6497706112957744) variable(0.42050634346545185)\n",
+      "variable(0.6500303946470137) variable(0.42084544423309833)\n",
+      "variable(0.650289855131177) variable(0.42118425817946914)\n",
+      "variable(0.6505489934212129) variable(0.42152278568088075)\n",
+      "variable(0.6508078101880056) variable(0.42186102711297524)\n",
+      "variable(0.6510663061003832) variable(0.4221989828507216)\n",
+      "variable(0.651324481825126) variable(0.42253665326841683)\n",
+      "variable(0.6515823380269747) variable(0.42287403873968726)\n",
+      "variable(0.6518398753686387) variable(0.4232111396374896)\n",
+      "variable(0.6520970945108043) variable(0.4235479563341122)\n",
+      "variable(0.6523539961121428) variable(0.42388448920117633)\n",
+      "variable(0.6526105808293187) variable(0.4242207386096374)\n",
+      "variable(0.6528668493169975) variable(0.42455670492978603)\n",
+      "variable(0.6531228022278539) variable(0.42489238853124944)\n",
+      "variable(0.65337844021258) variable(0.4252277897829924)\n",
+      "variable(0.6536337639198928) variable(0.4255629090533187)\n",
+      "variable(0.6538887739965427) variable(0.42589774670987224)\n",
+      "variable(0.6541434710873206) variable(0.4262323031196381)\n",
+      "variable(0.6543978558350664) variable(0.42656657864894415)\n",
+      "variable(0.6546519288806764) variable(0.4269005736634618)\n",
+      "variable(0.6549056908631112) variable(0.42723428852820744)\n",
+      "variable(0.6551591424194035) variable(0.42756772360754375)\n",
+      "variable(0.6554122841846656) variable(0.42790087926518067)\n",
+      "variable(0.655665116792097) variable(0.4282337558641767)\n",
+      "variable(0.6559176408729923) variable(0.42856635376694024)\n",
+      "variable(0.6561698570567486) variable(0.4288986733352305)\n",
+      "variable(0.6564217659708727) variable(0.4292307149301592)\n",
+      "variable(0.656673368240989) variable(0.4295624789121912)\n",
+      "variable(0.6569246644908471) variable(0.42989396564114607)\n",
+      "variable(0.6571756553423286) variable(0.43022517547619926)\n",
+      "variable(0.6574263414154551) variable(0.43055610877588324)\n",
+      "variable(0.6576767233283952) variable(0.4308867658980887)\n",
+      "variable(0.6579268016974719) variable(0.4312171472000659)\n",
+      "variable(0.6581765771371696) variable(0.4315472530384256)\n",
+      "variable(0.658426050260142) variable(0.4318770837691406)\n",
+      "variable(0.6586752216772186) variable(0.4322066397475467)\n",
+      "variable(0.6589240919974124) variable(0.43253592132834395)\n",
+      "variable(0.6591726618279267) variable(0.4328649288655981)\n",
+      "variable(0.6594209317741622) variable(0.4331936627127413)\n",
+      "variable(0.6596689024397242) variable(0.4335221232225739)\n",
+      "variable(0.6599165744264297) variable(0.43385031074726516)\n",
+      "variable(0.6601639483343142) variable(0.43417822563835484)\n",
+      "variable(0.6604110247616388) variable(0.4345058682467541)\n",
+      "variable(0.660657804304897) variable(0.43483323892274683)\n",
+      "variable(0.6609042875588216) variable(0.43516033801599097)\n",
+      "variable(0.6611504751163918) variable(0.4354871658755195)\n",
+      "variable(0.6613963675688398) variable(0.43581372284974174)\n",
+      "variable(0.6616419655056577) variable(0.43614000928644453)\n",
+      "variable(0.661887269514604) variable(0.4364660255327936)\n",
+      "variable(0.6621322801817108) variable(0.43679177193533447)\n",
+      "variable(0.6623769980912901) variable(0.43711724883999387)\n",
+      "variable(0.6626214238259407) variable(0.43744245659208086)\n",
+      "variable(0.6628655579665547) variable(0.4377673955362881)\n",
+      "variable(0.663109401092324) variable(0.4380920660166928)\n",
+      "variable(0.6633529537807473) variable(0.43841646837675835)\n",
+      "variable(0.6635962166076362) variable(0.43874060295933515)\n",
+      "variable(0.6638391901471219) variable(0.4390644701066619)\n",
+      "variable(0.6640818749716615) variable(0.43938807016036685)\n",
+      "variable(0.6643242716520449) variable(0.439711403461469)\n",
+      "variable(0.6645663807574005) variable(0.4400344703503792)\n",
+      "variable(0.6648082028552023) variable(0.4403572711669014)\n",
+      "variable(0.6650497385112758) variable(0.44067980625023384)\n",
+      "variable(0.6652909882898046) variable(0.44100207593897034)\n",
+      "variable(0.6655319527533364) variable(0.44132408057110123)\n",
+      "variable(0.6657726324627896) variable(0.44164582048401485)\n",
+      "variable(0.6660130279774592) variable(0.4419672960144984)\n",
+      "variable(0.6662531398550232) variable(0.4422885074987395)\n",
+      "variable(0.6664929686515488) variable(0.44260945527232703)\n",
+      "variable(0.6667325149214985) variable(0.4429301396702525)\n",
+      "variable(0.6669717792177362) variable(0.4432505610269113)\n",
+      "variable(0.6672107620915333) variable(0.44357071967610356)\n",
+      "variable(0.6674494640925747) variable(0.4438906159510358)\n",
+      "variable(0.667687885768965) variable(0.44421025018432164)\n",
+      "variable(0.6679260276672342) variable(0.4445296227079834)\n",
+      "variable(0.6681638903323441) variable(0.4448487338534529)\n",
+      "variable(0.668401474307694) variable(0.4451675839515729)\n",
+      "variable(0.6686387801351266) variable(0.4454861733325981)\n",
+      "variable(0.6688758083549338) variable(0.4458045023261965)\n",
+      "variable(0.6691125595058628) variable(0.44612257126145044)\n",
+      "variable(0.6693490341251219) variable(0.4464403804668577)\n",
+      "variable(0.6695852327483862) variable(0.4467579302703329)\n",
+      "variable(0.6698211559098034) variable(0.44707522099920843)\n",
+      "variable(0.6700568041419995) variable(0.44739225298023577)\n",
+      "variable(0.670292177976085) variable(0.4477090265395866)\n",
+      "variable(0.6705272779416596) variable(0.448025542002854)\n",
+      "variable(0.670762104566819) variable(0.4483417996950535)\n",
+      "variable(0.6709966583781597) variable(0.44865779994062444)\n",
+      "variable(0.6712309399007853) variable(0.4489735430634309)\n",
+      "variable(0.6714649496583116) variable(0.4492890293867631)\n",
+      "variable(0.6716986881728721) variable(0.44960425923333824)\n",
+      "variable(0.6719321559651242) variable(0.44991923292530206)\n",
+      "variable(0.6721653535542541) variable(0.4502339507842297)\n",
+      "variable(0.6723982814579823) variable(0.4505484131311268)\n",
+      "variable(0.6726309401925696) variable(0.45086262028643104)\n",
+      "variable(0.672863330272822) variable(0.45117657257001287)\n",
+      "variable(0.6730954522120963) variable(0.45149027030117683)\n",
+      "variable(0.6733273065223057) variable(0.45180371379866274)\n",
+      "variable(0.6735588937139247) variable(0.4521169033806468)\n",
+      "variable(0.6737902142959951) variable(0.4524298393647427)\n",
+      "variable(0.6740212687761306) variable(0.45274252206800275)\n",
+      "variable(0.6742520576605227) variable(0.4530549518069192)\n",
+      "variable(0.6744825814539455) variable(0.4533671288974251)\n",
+      "variable(0.6747128406597612) variable(0.4536790536548957)\n",
+      "variable(0.6749428357799255) variable(0.45399072639414945)\n",
+      "variable(0.6751725673149924) variable(0.4543021474294491)\n",
+      "variable(0.6754020357641195) variable(0.45461331707450287)\n",
+      "variable(0.6756312416250734) variable(0.4549242356424657)\n",
+      "variable(0.6758601853942344) variable(0.4552349034459402)\n",
+      "variable(0.676088867566602) variable(0.45554532079697796)\n",
+      "variable(0.6763172886357999) variable(0.4558554880070804)\n",
+      "variable(0.6765454490940807) variable(0.4561654053872003)\n",
+      "variable(0.6767733494323315) variable(0.4564750732477425)\n",
+      "variable(0.6770009901400784) variable(0.45678449189856535)\n",
+      "variable(0.677228371705492) variable(0.4570936616489816)\n",
+      "variable(0.6774554946153917) variable(0.45740258280775964)\n",
+      "variable(0.6776823593552513) variable(0.4577112556831247)\n",
+      "variable(0.6779089664092036) variable(0.45801968058275977)\n",
+      "variable(0.6781353162600454) variable(0.45832785781380675)\n",
+      "variable(0.6783614093892422) variable(0.4586357876828678)\n",
+      "variable(0.6785872462769331) variable(0.45894347049600603)\n",
+      "variable(0.6788128274019359) variable(0.45925090655874706)\n",
+      "variable(0.6790381532417519) variable(0.45955809617607973)\n",
+      "variable(0.6792632242725699) variable(0.45986503965245756)\n",
+      "variable(0.6794880409692723) variable(0.46017173729179955)\n",
+      "variable(0.6797126038054386) variable(0.4604781893974915)\n",
+      "variable(0.679936913253351) variable(0.46078439627238704)\n",
+      "variable(0.6801609697839985) variable(0.4610903582188086)\n",
+      "variable(0.6803847738670821) variable(0.4613960755385488)\n",
+      "variable(0.680608325971019) variable(0.4617015485328711)\n",
+      "variable(0.6808316265629474) variable(0.46200677750251146)\n",
+      "variable(0.6810546761087314) variable(0.4623117627476789)\n",
+      "variable(0.6812774750729652) variable(0.4626165045680569)\n",
+      "variable(0.681500023918978) variable(0.4629210032628045)\n",
+      "variable(0.6817223231088383) variable(0.4632252591305571)\n",
+      "variable(0.6819443731033584) variable(0.46352927246942793)\n",
+      "variable(0.6821661743620994) variable(0.46383304357700883)\n",
+      "variable(0.6823877273433749) variable(0.4641365727503715)\n",
+      "variable(0.6826090325042565) variable(0.46443986028606843)\n",
+      "variable(0.6828300903005774) variable(0.46474290648013417)\n",
+      "variable(0.683050901186937) variable(0.4650457116280863)\n",
+      "variable(0.6832714656167057) variable(0.4653482760249264)\n",
+      "variable(0.6834917840420289) variable(0.46565059996514135)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dezero import Variable\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "def rosenbrock(x0, x1):\n",
+    "    y = 100 * ((x1 - x0**2) ** 2) + (1 - x0) ** 2\n",
+    "    return y\n",
+    "\n",
+    "x0 = Variable(np.array(0.0))\n",
+    "x1 = Variable(np.array(2.0))\n",
+    "lr = 0.001\n",
+    "iters = 1000\n",
+    "\n",
+    "for i in range(iters):\n",
+    "    print(x0, x1)\n",
+    "    \n",
+    "    y = rosenbrock(x0, x1)\n",
+    "    \n",
+    "    x0.clear_grad()\n",
+    "    x1.clear_grad()\n",
+    "    \n",
+    "    y.backward()\n",
+    "    \n",
+    "    x0.data -= lr * x0.grad\n",
+    "    x1.data -= lr * x1.grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "44f3b129",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 variable(2.0)\n",
+      "1 variable(1.4545454545454546)\n",
+      "2 variable(1.1510467893775467)\n",
+      "3 variable(1.0253259289766978)\n",
+      "4 variable(1.0009084519430513)\n",
+      "5 variable(1.0000012353089454)\n",
+      "6 variable(1.000000000002289)\n",
+      "7 variable(1.0)\n",
+      "8 variable(1.0)\n",
+      "9 variable(1.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "\n",
+    "# 4차항 함수\n",
+    "def f(x):\n",
+    "    y = x ** 4 - 2 * x ** 2\n",
+    "    return y\n",
+    "\n",
+    "# 4차항 함수를 2차 미분한 도함수\n",
+    "def gx2(x):\n",
+    "    return 12 * x ** 2 - 4\n",
+    "\n",
+    "x = Variable(np.array(2.0))\n",
+    "iters = 10\n",
+    "\n",
+    "# 뉴턴 메소드로 x 갱신\n",
+    "for i in range(iters):\n",
+    "    print(i, x)\n",
+    "    \n",
+    "    y = f(x)\n",
+    "    x.clear_grad()\n",
+    "    y.backward()\n",
+    "    \n",
+    "    x.data -= x.grad / gx2(x.data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c540aa18",
+   "metadata": {},
+   "source": [
+    "## Step28~32\n",
+    "- 고차미분 이론/구현 설명 내용으로 실습 코드 X"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "607a4683",
+   "metadata": {},
+   "source": [
+    "## Step33"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "87e0dae6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('..')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "07716cc4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "variable(24.0)\n",
+      "variable(68.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "\n",
+    "def f(x):\n",
+    "    y = x ** 4 - 2 * x ** 2\n",
+    "    return y\n",
+    "\n",
+    "x = Variable(np.array(2.0))\n",
+    "y = f(x)\n",
+    "\n",
+    "# 1차 미분 수행 및 미분값\n",
+    "y.backward(use_heap=True, create_graph=True)\n",
+    "print(x.grad) \n",
+    "\n",
+    "gx = x.grad\n",
+    "# 2차 미분 수행 및 미분값 -> 그런데 2차미분 값은 44임. 왜 68? 이유는 1차미분값에 2차미분값이 더해졌기 때문..\n",
+    "# -> 따라서 1차,2차 미분 사이에 미분값 초기화 작업 추가해야 함\n",
+    "gx.backward()\n",
+    "print(x.grad)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4c6980ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "variable(24.0)\n",
+      "variable(44.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "\n",
+    "def f(x):\n",
+    "    y = x ** 4 - 2 * x ** 2\n",
+    "    return y\n",
+    "\n",
+    "x = Variable(np.array(2.0))\n",
+    "y = f(x)\n",
+    "\n",
+    "# 1차 미분 수행 및 미분값\n",
+    "y.backward(use_heap=True, create_graph=True)\n",
+    "print(x.grad)\n",
+    "\n",
+    "gx = x.grad\n",
+    "# 2차 미분 수행 및 미분값\n",
+    "x.clear_grad()\n",
+    "gx.backward()\n",
+    "print(x.grad)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "14cf6c79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 variable(2.0)\n",
+      "1 variable(1.4545454545454546)\n",
+      "2 variable(1.1510467893775467)\n",
+      "3 variable(1.0253259289766978)\n",
+      "4 variable(1.0009084519430513)\n",
+      "5 variable(1.0000012353089454)\n",
+      "6 variable(1.000000000002289)\n",
+      "7 variable(1.0)\n",
+      "8 variable(1.0)\n",
+      "9 variable(1.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 뉴턴 메소드를 활용한 최적화 \n",
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "\n",
+    "def f(x):\n",
+    "    y = x ** 4 - 2 * x ** 2\n",
+    "    return y\n",
+    "\n",
+    "x = Variable(np.array(2.0))\n",
+    "iters = 10\n",
+    "\n",
+    "for i in range(iters):\n",
+    "    print(i, x)\n",
+    "    \n",
+    "    y = f(x)\n",
+    "    x.clear_grad()\n",
+    "    \n",
+    "    # 1차 미분값\n",
+    "    y.backward(use_heap=True, create_graph=True)\n",
+    "    gx = x.grad\n",
+    "    x.clear_grad()\n",
+    "    \n",
+    "    # 2차 미분값\n",
+    "    gx.backward()\n",
+    "    gx2 = x.grad\n",
+    "    \n",
+    "    x.data -= gx.data / gx2.data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "bb52188d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1차 미분값: variable(0.5403023058681398)\n",
+      "\n",
+      "2차 미분값: variable(-0.8414709848078965)\n",
+      "3차 미분값: variable(-0.5403023058681398)\n",
+      "4차 미분값: variable(0.8414709848078965)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Dezero의 Sin, Cos 고차미분 수행하기\n",
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "from dezero import functions as F\n",
+    "\n",
+    "x = Variable(np.array(1.0))\n",
+    "y = F.sin(x)\n",
+    "\n",
+    "# 최초 1차 미분 수행\n",
+    "y.backward(use_heap=True, create_graph=True)\n",
+    "print('1차 미분값:', x.grad)\n",
+    "print()\n",
+    "\n",
+    "# 2,3,4차 미분 수행\n",
+    "for i in range(3):\n",
+    "    gx = x.grad\n",
+    "    x.clear_grad()\n",
+    "    gx.backward(create_graph=True)\n",
+    "    print(f'{i+2}차 미분값:', x.grad)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "64f91b0a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from dezero import Variable\n",
+    "from dezero import functions as F\n",
+    "\n",
+    "x = Variable(np.linspace(-7, 7, 200))\n",
+    "y = F.sin(x)\n",
+    "\n",
+    "# 1차 미분 수행\n",
+    "y.backward(use_heap=True, create_graph=True)\n",
+    "\n",
+    "logs = [y.data]\n",
+    "\n",
+    "for i in range(3):\n",
+    "    logs.append(x.grad.data)  # 미분값 = 역전파를 하나의 순전파 그래프로 보았을 때의 y값이잖아!\n",
+    "    gx = x.grad\n",
+    "    # n차 미분 수행\n",
+    "    x.clear_grad()\n",
+    "    gx.backward(use_heap=True, create_graph=True)\n",
+    "    \n",
+    "# 시각화\n",
+    "labels = [\"y=sin(x)\", \"y'\", \"y''\", \"y'''\"]\n",
+    "for i, _ in enumerate(logs):\n",
+    "    plt.plot(x.data, logs[i], label=labels[i])\n",
+    "plt.legend(loc='lower right')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "51effbed",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Tanh 함수 추가한 후 순전파가 아닌 미분 즉, 역전파의 계산 그래프 시각화\n",
+    "import sys\n",
+    "sys.path.append('..')\n",
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "from dezero import functions as F\n",
+    "from dezero.utils import plot_dot_graph\n",
+    "\n",
+    "x = Variable(np.array(1.0))\n",
+    "y = F.tanh(x)\n",
+    "x.name = 'x'\n",
+    "y.name = 'y'\n",
+    "# 1차 미분 수행\n",
+    "y.backward(use_heap=True, create_graph=True)\n",
+    "\n",
+    "iters = 0\n",
+    "\n",
+    "for i in range(iters):\n",
+    "    gx = x.grad\n",
+    "    x.clear_grad()\n",
+    "    gx.backward(use_heap=True, create_graph=True)\n",
+    "\n",
+    "# 계산 그래프 시각화\n",
+    "gx = x.grad\n",
+    "gx.name = 'gx' + str(iters+1)\n",
+    "plot_dot_graph(gx, verbose=True, to_file='graph2.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "23dbc50b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "variable(0.41997434161402614)\n",
+      "variable(0.41997434161402614)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Tanh 함수 추가한 후 순전파가 아닌 미분 즉, 역전파의 계산 그래프 시각화\n",
+    "import sys\n",
+    "sys.path.append('..')\n",
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "from dezero import functions as F\n",
+    "from dezero.utils import plot_dot_graph\n",
+    "\n",
+    "x = Variable(np.array(1.0))\n",
+    "y = F.tanh(x)\n",
+    "x.name = 'x'\n",
+    "y.name = 'y'\n",
+    "# 1차 미분 수행\n",
+    "y.backward(use_heap=True, create_graph=True)\n",
+    "print(x.grad)\n",
+    "\n",
+    "# 2차 미분 수행\n",
+    "gx = x.grad\n",
+    "x.clear_grad()\n",
+    "gx.backward(use_heap=True, create_graph=True)\n",
+    "print(x.grad)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "a6990740",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1차 미분값: variable(0.41997434161402614)\n",
+      "2차 미분값: variable(0.41997434161402614)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "from dezero.utils import plot_dot_graph\n",
+    "import dezero.functions as F\n",
+    "\n",
+    "x = Variable(np.array(1.0))\n",
+    "y = F.tanh(x)\n",
+    "x.name = 'x'\n",
+    "y.name = 'y'\n",
+    "\n",
+    "# 1차 미분\n",
+    "y.backward(create_graph=True)\n",
+    "gx = x.grad\n",
+    "print('1차 미분값:', x.grad)\n",
+    "\n",
+    "# 2차 미분\n",
+    "x.clear_grad()\n",
+    "gx.backward(create_graph=True)\n",
+    "gx2 = x.grad\n",
+    "print('2차 미분값:', x.grad)\n",
+    "\n",
+    "# 계산 그래프 시각화\n",
+    "gx2.name = 'gx2'\n",
+    "plot_dot_graph(gx2, verbose=True, to_file='graph2.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd14f675",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "96ef6820",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "variable(100.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "sys.path.append('..')\n",
+    "import numpy as np\n",
+    "from dezero import Variable\n",
+    "\n",
+    "x = Variable(np.array(2.0))\n",
+    "y = x ** 2\n",
+    "y.backward(create_graph=True)\n",
+    "gx = x.grad\n",
+    "x.clear_grad()\n",
+    "\n",
+    "z = gx ** 3 + y\n",
+    "z.backward()\n",
+    "print(x.grad)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f00ec09",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "hide_input": false,
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.7"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": true,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  },
+  "varInspector": {
+   "cols": {
+    "lenName": 16,
+    "lenType": 16,
+    "lenVar": 40
+   },
+   "kernels_config": {
+    "python": {
+     "delete_cmd_postfix": "",
+     "delete_cmd_prefix": "del ",
+     "library": "var_list.py",
+     "varRefreshCmd": "print(var_dic_list())"
+    },
+    "r": {
+     "delete_cmd_postfix": ") ",
+     "delete_cmd_prefix": "rm(",
+     "library": "var_list.r",
+     "varRefreshCmd": "cat(var_dic_list()) "
+    }
+   },
+   "types_to_exclude": [
+    "module",
+    "function",
+    "builtin_function_or_method",
+    "instance",
+    "_Feature"
+   ],
+   "window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/season3/test.py b/season3/test.py
index 856f38d..68235d9 100644
--- a/season3/test.py
+++ b/season3/test.py
@@ -1,14 +1,46 @@
-# 현재 파일이 전역변수에 있는지 확인하고 있다면, 부모 디렉토리를 모듈검색 경로에 추가!
-if '__file__' in globals():  # 딕셔너리 형태로 반환됨 {'변수명': 변수값, ... , }
-    import os, sys
-    sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+# # 현재 파일이 전역변수에 있는지 확인하고 있다면, 부모 디렉토리를 모듈검색 경로에 추가!
+# if '__file__' in globals():  # 딕셔너리 형태로 반환됨 {'변수명': 변수값, ... , }
+#     import os, sys
+#     sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
 import numpy as np
-from dezero import Variable
+import dezero.functions as F
+from dezero.datasets import SinCurve
+from dezero.dataloaders import SeqDataLoader
+from dezero.models import BetterRNN
+from dezero.optimizers import Adam
 
-x = Variable(np.array(1.0))
-y = (x + 3) ** 2
-y.backward()
+max_epoch = 100
+batch_size = 30
+hidden_size = 100
+bptt_length = 30
 
-print(y)
-print(x.grad)
\ No newline at end of file
+train_set = SinCurve(train=True)
+train_loader = SeqDataLoader(train_set, batch_size)
+seqlen = len(train_set)
+
+model = BetterRNN(hidden_size, out_size=1)
+optimizer = Adam().setup(model)
+
+for epoch in range(max_epoch):
+    model.reset_state()   # reset state per each epoch
+    loss, bptt_cnt = 0, 0
+
+    for x, t in train_loader:
+        # predict and get loss
+        y = model(x)
+        loss += F.mean_squared_error(y, t)
+        bptt_cnt += 1
+
+        # Truncated BPTT
+        if bptt_cnt % bptt_length == 0 or bptt_cnt == seqlen:
+            # 1. 현재 상태 기울기 초기화
+            model.clear_grads()
+            # 2. 역전파 수행
+            loss.backward(use_heap=True)
+            # 3. 다음 BPTT 대비 위해 앞단 Variable의 창조자 삭제
+            loss.unchain_backward()
+            # 4. 기울기 갱신
+            optimizer.update()
+    avg_loss = float(loss.data) / bptt_cnt
+    print('Epoch:', epoch, '-> Loss:', avg_loss)