{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0caed09d-661f-46a0-bc5e-74c69a72fcb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import OrderedDict\n",
    "import scipy.io as sio"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27b25e5-b907-4922-bff0-ee13ed60f246",
   "metadata": {},
   "source": [
    "# Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b2f9d1c8-fc8f-4829-b27e-84d9ed014593",
   "metadata": {},
   "outputs": [],
   "source": [
    "## DEFINE INPUT PARAMETERS\n",
    "# defining velocity, density, and viscocity for fluid\n",
    "u0 = 1 # lid velocity\n",
    "rho0 = 1\n",
    "nu0 = 0.01\n",
    "N = 4400 # number of collocation data points [x,y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "afa29b5a-5efc-449f-b0e7-1cdfc9089c28",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Uniform_with_Cylinder(u0, N_col=10000, N_circ=200, r=0.5):\n",
    "    \"\"\"\n",
    "    Create collocation points inside a 1by1 box with a cylinder in the middle\n",
    "\n",
    "    Args:\n",
    "        u0 : Inlet velocity\n",
    "        N_col : number of collocation points # note the acc number is slightly less as we are removing points in the cylinder\n",
    "        N_circ : Number of points along cylinder boundary\n",
    "        r : Cylinder radius \n",
    "    \n",
    "    Returns: \n",
    "        Tensors of:\n",
    "        X_col : Collocation points [x, y]\n",
    "        BC_X : Boundary points [x, y]\n",
    "        BC_Y : Boundary condition values [u, v]\n",
    "    \"\"\"\n",
    "\n",
    "    # setting up domain size\n",
    "    xc, yc = 0, 0  # cylinder center\n",
    "\n",
    "    # CREATING collocation points\n",
    "    # set random points across the domain using the random normal distribution function hence *3 or *10 to change standard dev and get distribution centred round cylinder\n",
    "    y = 1*np.random.randn(N_col,1)\n",
    "    x = 4*np.random.randn(N_col,1)\n",
    "    print(x,y)\n",
    "    xy = np.hstack((x, y))  \n",
    "    print(xy)\n",
    "\n",
    "    # Distance from cylinder center\n",
    "    dist = np.sqrt((xy[:, 0] - xc)**2 + (xy[:, 1] - yc)**2)\n",
    "\n",
    "    # Keep only points outside the cylinder. Boolean mask for cylinder and BCs\n",
    "    valid_col = (dist > r) & (xy[:,0]>-10)\n",
    "    xy_outside = xy[valid_col]\n",
    "\n",
    "    X_col = torch.tensor(xy_outside, dtype=torch.float32)\n",
    "\n",
    "    # CREATING Boundary condition locations\n",
    "    # domain currently set y = -7 to 7 : x = -10 to 25\n",
    "\n",
    "    # evenly distribute BC points along the sides\n",
    "    N_BC = int(np.sqrt(N_col) // 2)\n",
    "    y = np.linspace(-7, 7, N_BC)\n",
    "    x = np.linspace(-10, 35, N_BC)\n",
    "\n",
    "    # turn those points into x,y co-ords\n",
    "    b_left   = np.column_stack([(np.ones_like(y)*-10), y])\n",
    "    b_right  = np.column_stack([np.ones_like(y)*35, y])\n",
    "    b_bottom = np.column_stack([x, np.ones_like(x)*-7])\n",
    "    b_top    = np.column_stack([x, np.ones_like(x)*7])\n",
    "\n",
    "    # cylinder BCs\n",
    "    theta = np.linspace(0, 2*np.pi, N_circ)\n",
    "    cylinder_x = (r * np.cos(theta) + xc)\n",
    "    cylinder_y = (r * np.sin(theta) + yc)\n",
    "    cylinder_xy = np.column_stack([cylinder_x, cylinder_y])\n",
    "\n",
    "    # Add all BC points\n",
    "    BC_X_np = np.vstack([b_left, b_bottom, b_right, b_top, cylinder_xy])\n",
    "    BC_X = torch.tensor(BC_X_np, dtype=torch.float32)\n",
    "\n",
    "    # CREATING the BC_Y essentially 0s everywhere except inlet\n",
    "    # tensor of zeros for all walls except inlet\n",
    "    walls_Y = torch.zeros_like(torch.tensor(np.vstack([b_top, b_bottom, b_right]), dtype=torch.float32))\n",
    "\n",
    "    # inlet velocity\n",
    "    inlet = torch.zeros_like(torch.tensor(b_left, dtype=torch.float32))\n",
    "    inlet[:, 0] = u0\n",
    "\n",
    "    # Cylinder no slip so 0\n",
    "    cylinder_uv = torch.zeros_like(torch.tensor(cylinder_xy, dtype=torch.float32))\n",
    "\n",
    "    # Combine boundary velocities\n",
    "    BC_Y = torch.cat([inlet, walls_Y,  cylinder_uv], dim=0)\n",
    "\n",
    "    return X_col, BC_X, BC_Y\n",
    "\n",
    "def Data():\n",
    "    \"\"\"\n",
    "    loads data from benchmark file\n",
    "\n",
    "    Args:\n",
    "        \n",
    "    Returns: As Tensors (dim = Nx2)\n",
    "        X_D : coordinates of data points [x,y], dim = [N*2]\n",
    "        U_D : training output [u,v] at data points, dim = [N*2] \n",
    "        NEED TO ADD PRESSURE DATA\n",
    "    \"\"\"\n",
    "\n",
    "    ## Read file holding training data\n",
    "    xy_data = sio.loadmat(\"xstar.mat\")\n",
    "    uv_data = sio.loadmat(\"ustar_Aug24.mat\") \n",
    "\n",
    "\n",
    "    uv_data_np = np.array(uv_data[\"ustar\"][:,:,0])\n",
    "    u_np = uv_data_np[:,0]\n",
    "    v_np = uv_data_np[:,1]\n",
    "    \n",
    "    xy_data_np = np.array(xy_data[\"xstar\"])\n",
    "    x_np = xy_data_np[:,0]\n",
    "    y_np = xy_data_np[:,1]\n",
    "\n",
    "    x = torch.tensor(x_np, dtype=torch.float32)\n",
    "    y = torch.tensor(y_np, dtype=torch.float32)\n",
    "    u = torch.tensor(u_np, dtype=torch.float32)\n",
    "    v = torch.tensor(v_np, dtype=torch.float32)\n",
    "\n",
    "    X_D = torch.column_stack((x, y))\n",
    "    U_D = torch.column_stack((u,v))\n",
    "    \n",
    "\n",
    "    # print(X_D.size(), U_D.size())\n",
    "\n",
    "    return X_D, U_D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8adfc689-3737-4439-9c96-5e83f62f0451",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.08741689]\n",
      " [-3.73043205]\n",
      " [-2.53147409]\n",
      " ...\n",
      " [-1.91331674]\n",
      " [ 3.20642596]\n",
      " [-7.84856638]] [[-0.55483643]\n",
      " [ 0.55973006]\n",
      " [ 0.62996564]\n",
      " ...\n",
      " [ 0.24907043]\n",
      " [-0.68852152]\n",
      " [-0.15616116]]\n",
      "[[-0.08741689 -0.55483643]\n",
      " [-3.73043205  0.55973006]\n",
      " [-2.53147409  0.62996564]\n",
      " ...\n",
      " [-1.91331674  0.24907043]\n",
      " [ 3.20642596 -0.68852152]\n",
      " [-7.84856638 -0.15616116]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x222aa18ee90>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_col, BC_X, BC_Y= Uniform_with_Cylinder(1)\n",
    "\n",
    "plt.scatter(X_col[:,0].numpy(),X_col[:,1].numpy(),marker='.')\n",
    "plt.scatter(BC_X[:,0].numpy(),BC_X[:,1].numpy(),marker='x')\n",
    "#plt.xlim(-2,5)\n",
    "#plt.ylim(-2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "97417112-23ad-4ca5-85d4-639a02e083a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Compute gradients\n",
    "def grad(outputs, inputs):\n",
    "    return torch.autograd.grad(\n",
    "        outputs, inputs,\n",
    "        grad_outputs=torch.ones_like(outputs),\n",
    "        create_graph=True,\n",
    "        retain_graph=True\n",
    "    )[0]\n",
    "def compute_gradients(model, xy):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        model : PyTorch neural network, with three models inside it (u,v and p) for input xy\n",
    "        xy    : tensor of shape (N, 2), # when setting up model set requires_grad=True\n",
    "\n",
    "    Returns:\n",
    "        p_grads : (p, p_x, p_y) as a tuple\n",
    "        u_grads : (u, u_x, u_y, u_xx, u_yy) as a tuple\n",
    "        v_grads : (v, v_x, v_y, v_xx, v_yy) as a tuple\n",
    "    \"\"\"\n",
    "    # create a clone so we dont change the original tensor\n",
    "    # detatch the xy data from previous gradients so it can be evaluated in isolation\n",
    "    xy = xy.clone().detach().requires_grad_(True)  \n",
    "    x = xy[:, 0:1]\n",
    "    y = xy[:, 1:2]\n",
    "\n",
    "    # Make a fwd pass that goes through the combined mini models collecting all coefficients needed for derivatives\n",
    "    u_v_p = model(torch.cat([x, y], dim=1))\n",
    "    u = u_v_p[:,0:1]\n",
    "    v = u_v_p[:,1:2]\n",
    "    p = u_v_p[:,2:3]\n",
    "\n",
    "    \n",
    "    # First-order derivatives\n",
    "    p_x = grad(p, x)\n",
    "    p_y = grad(p, y)\n",
    "\n",
    "    # Second-order derivatives\n",
    "    u_x = grad(u, x)\n",
    "    u_y = grad(u, y)\n",
    "    v_x = grad(v, x)\n",
    "    v_y = grad(v, y)\n",
    "\n",
    "    # Third-order derivatives\n",
    "    u_xx = grad(u_x, x)\n",
    "    u_yy = grad(u_y, y)\n",
    "    v_xx = grad(v_x, x)\n",
    "    v_yy = grad(v_y, y)\n",
    "    \n",
    "    p_grads = (p, p_x, p_y)\n",
    "    u_grads = (u, u_x, u_y, u_xx, u_yy)\n",
    "    v_grads = (v, v_x, v_y, v_xx, v_yy)\n",
    "\n",
    "    return p_grads, u_grads, v_grads"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4fb1aef-ab4e-424f-9937-e87a719e9d88",
   "metadata": {},
   "source": [
    "# Model Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "dc8538d5-9dfa-44a1-8e38-7009b7b8a3fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "## LOSS EQUATIONS\n",
    "def navier_stokes_loss(model,X):\n",
    "    \"\"\"\n",
    "    calculates steady navier stokes residuals at collocation points\n",
    "\n",
    "    Args: \n",
    "        model : whatever model calls this function\n",
    "        X : input collocation [x,y] coords as defined in models data creation\n",
    "\n",
    "    Returns: \n",
    "        tensor of all collocation point residuals\n",
    "    \"\"\"\n",
    "    p_grads, u_grads, v_grads = compute_gradients(model, X)\n",
    "    _, p_x, p_y = p_grads\n",
    "    u, u_x, u_y, u_xx, u_yy = u_grads\n",
    "    v, v_x, v_y, v_xx, v_yy = v_grads\n",
    "\n",
    "    #compute PDE residuals\n",
    "    u_eqn = u*u_x + v*u_y + p_x/rho0 - nu0*(u_xx + u_yy)\n",
    "    v_eqn = u*v_x + v*v_y + p_y/rho0 - nu0*(v_xx + v_yy)\n",
    "    \n",
    "\n",
    "    # combine into one tensor\n",
    "    # [u_residual, v_residual, continuity]\n",
    "    return torch.cat([u_eqn, v_eqn,(u_x+v_y)], dim=1)\n",
    "    \n",
    "def BC_loss(model,BC_X):\n",
    "    \"\"\"\n",
    "    calculates u and v at boundary conditions\n",
    "\n",
    "    Args: \n",
    "        model : whatever model calls this function\n",
    "        BC_X : Input Boundary conditions [x,y] coords as defined in models data creation\n",
    "        \n",
    "    Returns: \n",
    "        tensor of u,v at all boundary condition coords\n",
    "    \"\"\"\n",
    "    _, u_grads, v_grads = compute_gradients(model,BC_X)\n",
    "    u, u_x, u_y, u_xx, u_yy = u_grads\n",
    "    v, v_x, v_y, v_xx, v_yy = v_grads\n",
    "    return torch.cat([u, v], dim=1)\n",
    "def Data_loss(model, X_D):\n",
    "    p_grads, u_grads, v_grads = compute_gradients(model,X_D)\n",
    "    p, p_x, p_y = p_grads\n",
    "    u, u_x, u_y, u_xx, u_yy = u_grads\n",
    "    v, v_x, v_y, v_xx, v_yy = v_grads\n",
    "    return torch.cat([u, v], dim=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7661146-5baf-4d1f-bf77-1c08c047291b",
   "metadata": {},
   "source": [
    "## Define sub models and combine into 1 model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "4a15f79e-0281-40e5-881c-ddd351dccc1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CREATING THE MINI MODEL FOR u,v AND p AND THEN COMBINE THEM INTO ONE MODEL\n",
    "\n",
    "# sub model for u,v and p \n",
    "class submodel(nn.Module):\n",
    "    def __init__(\n",
    "            self,\n",
    "            N_input,\n",
    "            N_hidden_arr,\n",
    "            N_output,\n",
    "            activation = nn.Tanh\n",
    "    ):\n",
    "        super(submodel, self).__init__()  # Create network\n",
    "\n",
    "        # Create input layer w/ activation function\n",
    "        layers = [('Input', nn.Linear(N_input, N_hidden_arr[0]))]\n",
    "        layers.append(('Input activation', activation()))\n",
    "\n",
    "        # Create hidden layers\n",
    "        for i in range(len(N_hidden_arr)-1):\n",
    "            layers.append(\n",
    "                (\"Hidden %d\" % (i+1), nn.Linear(N_hidden_arr[i], N_hidden_arr[i+1]))\n",
    "            )\n",
    "            layers.append(('Hidden activation %d' % (i+1), activation()))\n",
    "        layers.append(('Output', nn.Linear(N_hidden_arr[-1], N_output)))\n",
    "        layerdict = OrderedDict(layers)\n",
    "        self.layers = nn.Sequential(layerdict)\n",
    "\n",
    "    def forward(self, x):\n",
    "        y = self.layers(x)\n",
    "        return y\n",
    "\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self, N_input, N_hidden_arr, N_output, activation = nn.Tanh):\n",
    "        \n",
    "        super(Net, self).__init__()  # Create network\n",
    "        # creates three models using submodel as the blueprint\n",
    "        self.model_u = submodel(N_input, N_hidden_arr ,N_output, activation)\n",
    "        self.model_v = submodel(N_input, N_hidden_arr, N_output, activation)\n",
    "        self.model_p = submodel(N_input, N_hidden_arr, N_output, activation)\n",
    "\n",
    "\n",
    "    # combine the outputs of all the models into a single output\n",
    "    def forward(self, xy):\n",
    "        out_u = self.model_u(xy)\n",
    "        out_v = self.model_v(xy)\n",
    "        out_p = self.model_p(xy)\n",
    "        combined = torch.cat((out_u, out_v, out_p), dim=1)\n",
    "        return combined\n",
    "\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c185db0a-8994-4f80-87bf-4715cee2d15c",
   "metadata": {},
   "source": [
    "## Defining the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "435525da-d488-4ccf-b370-a140cf1a538a",
   "metadata": {},
   "outputs": [],
   "source": [
    "## create neural network\n",
    "\n",
    "class PINN:\n",
    "    def __init__(self):\n",
    "        ### Need to change this to check if gpu available as well\n",
    "        device = torch.device(\"cpu\")\n",
    "        print(\"Using CPU\")\n",
    "        self.model = Net(\n",
    "            N_input=2,\n",
    "            N_hidden_arr=[32,16,16,32],\n",
    "            N_output = 1\n",
    "        ).to(device)\n",
    "    \n",
    "        # DATA CREATION \n",
    "        self.X, self.BC_X, self.BC_Y =  Uniform_with_Cylinder(u0)\n",
    "        self.X_D, self.U_D = Data()\n",
    "\n",
    "        # copy and seperate tensors into format for loss calculations\n",
    "        self.X = self.X.clone().detach().requires_grad_(True)\n",
    "        self.BC_X = self.BC_X.clone().detach().requires_grad_(True)\n",
    "\n",
    "        self.X_D = self.X_D.clone().detach().requires_grad_(True)\n",
    "        \n",
    "        \n",
    "        # OPTIMISERS\n",
    "        self.optimiser = torch.optim.LBFGS(\n",
    "            params=self.model.parameters(),\n",
    "            lr=1.0,\n",
    "            max_iter = 75*10**3,\n",
    "            max_eval = 75*10**3,\n",
    "            history_size=50,\n",
    "            tolerance_change=1e-7,\n",
    "            tolerance_grad=1e-7,\n",
    "            line_search_fn=\"strong_wolfe\"\n",
    "        )\n",
    "        self.adam = torch.optim.Adam(self.model.parameters())\n",
    "\n",
    "        \n",
    "        self.loss_fn = nn.MSELoss()\n",
    "\n",
    "        # Counter for printing loss\n",
    "        self.iter =1\n",
    "        \n",
    "    # Loss\n",
    "    def compute_loss(self):\n",
    "        # Compute PDE residuals at collocation points\n",
    "        residuals = navier_stokes_loss(self.model, self.X)\n",
    "        ru, rv, conservation  = residuals[:, 0:1], residuals[:, 1:2], residuals[:, 2:3]\n",
    "\n",
    "        # PDE loss (residuals against tensor of zeros)\n",
    "        pde_loss = self.loss_fn(ru, torch.zeros_like(ru)) + self.loss_fn(rv, torch.zeros_like(rv))+self.loss_fn(conservation, torch.zeros_like(conservation))\n",
    "\n",
    "        # BC loss\n",
    "        bc_loss = BC_loss(self.model,self.BC_X)\n",
    "        bc_loss = self.loss_fn(bc_loss,self.BC_Y)\n",
    "\n",
    "        # Data Loss\n",
    "        data_loss = Data_loss(self.model, self.X_D)\n",
    "        data_loss = self.loss_fn(data_loss, self.U_D)\n",
    "        \n",
    "        \n",
    "\n",
    "        if self.iter <= 500:\n",
    "            total_loss = data_loss\n",
    "        elif self.iter > 500:\n",
    "            total_loss = pde_loss + bc_loss +data_loss\n",
    "        # print the loss\n",
    "        if self.iter % 100 == 0:\n",
    "            print(f\"Iteration {self.iter:5}, Total Loss {total_loss:.9f}, Data loss {data_loss:.9f},pde loss {pde_loss:.9f}, BC loss {bc_loss:.9f}\")\n",
    "            \n",
    "        self.iter+= 1\n",
    "        \n",
    "        return total_loss\n",
    "    \n",
    "    def train(self, adam_epochs=300, lbfgs_epochs=10):\n",
    "        self.model.train()\n",
    "\n",
    "        for epoch in range(adam_epochs):\n",
    "            self.adam.zero_grad()\n",
    "            loss = self.compute_loss()\n",
    "            loss.backward()\n",
    "            self.adam.step()\n",
    "\n",
    "            # extra printing of loss for when adam optimiser in use\n",
    "            if epoch % 50 == 0:\n",
    "                with torch.inference_mode():  \n",
    "                    print(f\"[Adam] Step {epoch:4}, Loss = {loss.item():.6e}\")\n",
    "        \n",
    "        for epoch in range(lbfgs_epochs):\n",
    "            def closure():\n",
    "                self.optimiser.zero_grad()\n",
    "                loss = self.compute_loss()\n",
    "                loss.backward()\n",
    "                return loss\n",
    "\n",
    "            self.optimiser.step(closure)\n",
    "            \n",
    "    def eval(self):\n",
    "        self.model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "8baeb469-b77c-48cc-b8af-f1bcaa59b1d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using CPU\n",
      "[[ 2.58071142]\n",
      " [ 1.97567147]\n",
      " [-3.89849924]\n",
      " ...\n",
      " [ 1.81451307]\n",
      " [ 3.95799807]\n",
      " [ 2.38203676]] [[0.08219575]\n",
      " [1.26471561]\n",
      " [0.57198989]\n",
      " ...\n",
      " [0.97251789]\n",
      " [1.08304126]\n",
      " [0.36311786]]\n",
      "[[ 2.58071142  0.08219575]\n",
      " [ 1.97567147  1.26471561]\n",
      " [-3.89849924  0.57198989]\n",
      " ...\n",
      " [ 1.81451307  0.97251789]\n",
      " [ 3.95799807  1.08304126]\n",
      " [ 2.38203676  0.36311786]]\n"
     ]
    }
   ],
   "source": [
    "test = PINN()\n",
    "#print(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d2f57190-7a40-43ca-b5c5-6f042448c11d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Adam] Step    0, Loss = 3.585058e-01\n",
      "[Adam] Step   50, Loss = 4.644452e-02\n",
      "Iteration   100, Total Loss 0.041922711, Data loss 0.041922711,pde loss 0.004104901, BC loss 0.400600314\n",
      "[Adam] Step  100, Loss = 4.186129e-02\n",
      "[Adam] Step  150, Loss = 3.915045e-02\n",
      "Iteration   200, Total Loss 0.035384454, Data loss 0.035384454,pde loss 0.007421933, BC loss 0.377475053\n",
      "[Adam] Step  200, Loss = 3.528712e-02\n",
      "[Adam] Step  250, Loss = 3.050849e-02\n",
      "Iteration   300, Total Loss 0.027729675, Data loss 0.027729675,pde loss 0.010988547, BC loss 0.310287625\n",
      "Iteration   400, Total Loss 0.020060629, Data loss 0.020060629,pde loss 0.070955701, BC loss 0.263436466\n",
      "Iteration   500, Total Loss 0.015574658, Data loss 0.015574658,pde loss 0.108718723, BC loss 0.246479377\n",
      "Iteration   600, Total Loss 0.065942593, Data loss 0.046912409,pde loss 0.008525928, BC loss 0.010504254\n",
      "Iteration   700, Total Loss 0.042954303, Data loss 0.033342179,pde loss 0.004833593, BC loss 0.004778531\n",
      "Iteration   800, Total Loss 0.038351364, Data loss 0.030026807,pde loss 0.004617108, BC loss 0.003707452\n",
      "Iteration   900, Total Loss 0.036607347, Data loss 0.028858328,pde loss 0.004728824, BC loss 0.003020197\n",
      "Iteration  1000, Total Loss 0.035613663, Data loss 0.028170014,pde loss 0.004722381, BC loss 0.002721268\n",
      "Iteration  1100, Total Loss 0.035047539, Data loss 0.027700566,pde loss 0.004693774, BC loss 0.002653200\n",
      "Iteration  1200, Total Loss 0.034640756, Data loss 0.027434362,pde loss 0.004641565, BC loss 0.002564828\n",
      "Iteration  1300, Total Loss 0.034220163, Data loss 0.027103316,pde loss 0.004583475, BC loss 0.002533371\n",
      "Iteration  1400, Total Loss 0.033813570, Data loss 0.026711226,pde loss 0.004684734, BC loss 0.002417610\n",
      "Iteration  1500, Total Loss 0.033432920, Data loss 0.026575079,pde loss 0.004499265, BC loss 0.002358575\n",
      "Iteration  1600, Total Loss 0.033129178, Data loss 0.026203470,pde loss 0.004533322, BC loss 0.002392384\n",
      "Iteration  1700, Total Loss 0.032841899, Data loss 0.025885919,pde loss 0.004651531, BC loss 0.002304449\n",
      "Iteration  1800, Total Loss 0.032515790, Data loss 0.025723156,pde loss 0.004616836, BC loss 0.002175799\n",
      "Iteration  1900, Total Loss 0.032183588, Data loss 0.025377408,pde loss 0.004618173, BC loss 0.002188006\n",
      "Iteration  2000, Total Loss 0.031967543, Data loss 0.025238767,pde loss 0.004568947, BC loss 0.002159829\n",
      "Iteration  2100, Total Loss 0.031735446, Data loss 0.024854146,pde loss 0.004625751, BC loss 0.002255550\n",
      "Iteration  2200, Total Loss 0.031457987, Data loss 0.024509737,pde loss 0.004750640, BC loss 0.002197609\n",
      "Iteration  2300, Total Loss 0.031040084, Data loss 0.023957632,pde loss 0.004983697, BC loss 0.002098755\n",
      "Iteration  2400, Total Loss 0.030611960, Data loss 0.023539441,pde loss 0.004967565, BC loss 0.002104955\n",
      "Iteration  2500, Total Loss 0.030135594, Data loss 0.023022780,pde loss 0.005056637, BC loss 0.002056178\n",
      "Iteration  2600, Total Loss 0.029731533, Data loss 0.022504821,pde loss 0.005127432, BC loss 0.002099278\n",
      "Iteration  2700, Total Loss 0.029405614, Data loss 0.022055611,pde loss 0.005262215, BC loss 0.002087789\n",
      "Iteration  2800, Total Loss 0.029117413, Data loss 0.021661758,pde loss 0.005411365, BC loss 0.002044289\n",
      "Iteration  2900, Total Loss 0.028835531, Data loss 0.021383688,pde loss 0.005391460, BC loss 0.002060383\n",
      "Iteration  3000, Total Loss 0.028445065, Data loss 0.020957267,pde loss 0.005508474, BC loss 0.001979325\n",
      "Iteration  3100, Total Loss 0.028125640, Data loss 0.020595226,pde loss 0.005559430, BC loss 0.001970985\n",
      "Iteration  3200, Total Loss 0.027849231, Data loss 0.020298593,pde loss 0.005553959, BC loss 0.001996679\n",
      "Iteration  3300, Total Loss 0.027612232, Data loss 0.020031519,pde loss 0.005571716, BC loss 0.002008998\n",
      "Iteration  3400, Total Loss 0.027293688, Data loss 0.019574605,pde loss 0.005746636, BC loss 0.001972447\n",
      "Iteration  3500, Total Loss 0.027014229, Data loss 0.019453956,pde loss 0.005574853, BC loss 0.001985421\n",
      "Iteration  3600, Total Loss 0.026790127, Data loss 0.019299923,pde loss 0.005549945, BC loss 0.001940260\n",
      "Iteration  3700, Total Loss 0.026543731, Data loss 0.019116560,pde loss 0.005484467, BC loss 0.001942704\n",
      "Iteration  3800, Total Loss 0.026290013, Data loss 0.019033743,pde loss 0.005329417, BC loss 0.001926853\n",
      "Iteration  3900, Total Loss 0.026025131, Data loss 0.018690431,pde loss 0.005430879, BC loss 0.001903821\n",
      "Iteration  4000, Total Loss 0.025707567, Data loss 0.018400211,pde loss 0.005420877, BC loss 0.001886480\n",
      "Iteration  4100, Total Loss 0.025436765, Data loss 0.018231727,pde loss 0.005343284, BC loss 0.001861753\n",
      "Iteration  4200, Total Loss 0.025151053, Data loss 0.017877765,pde loss 0.005459124, BC loss 0.001814164\n",
      "Iteration  4300, Total Loss 0.024874382, Data loss 0.017738767,pde loss 0.005367877, BC loss 0.001767737\n",
      "Iteration  4400, Total Loss 0.024609182, Data loss 0.017629994,pde loss 0.005185963, BC loss 0.001793224\n",
      "Iteration  4500, Total Loss 0.024357503, Data loss 0.017459072,pde loss 0.005118375, BC loss 0.001780056\n",
      "Iteration  4600, Total Loss 0.024112042, Data loss 0.017283913,pde loss 0.005100410, BC loss 0.001727720\n",
      "Iteration  4700, Total Loss 0.023840507, Data loss 0.017077465,pde loss 0.005083463, BC loss 0.001679580\n",
      "Iteration  4800, Total Loss 0.023609819, Data loss 0.017003644,pde loss 0.004933100, BC loss 0.001673075\n",
      "Iteration  4900, Total Loss 0.023332812, Data loss 0.016644796,pde loss 0.005019570, BC loss 0.001668445\n",
      "Iteration  5000, Total Loss 0.023140533, Data loss 0.016558571,pde loss 0.004947308, BC loss 0.001634654\n",
      "Iteration  5100, Total Loss 0.022944486, Data loss 0.016390616,pde loss 0.004953131, BC loss 0.001600739\n",
      "Iteration  5200, Total Loss 0.022762012, Data loss 0.016173009,pde loss 0.004983466, BC loss 0.001605538\n",
      "Iteration  5300, Total Loss 0.022556372, Data loss 0.016043734,pde loss 0.004923780, BC loss 0.001588857\n",
      "Iteration  5400, Total Loss 0.022309685, Data loss 0.015829895,pde loss 0.004908004, BC loss 0.001571787\n",
      "Iteration  5500, Total Loss 0.022116914, Data loss 0.015743997,pde loss 0.004811614, BC loss 0.001561304\n",
      "Iteration  5600, Total Loss 0.021947440, Data loss 0.015582969,pde loss 0.004813872, BC loss 0.001550598\n",
      "Iteration  5700, Total Loss 0.021778245, Data loss 0.015461860,pde loss 0.004781587, BC loss 0.001534798\n",
      "Iteration  5800, Total Loss 0.021621808, Data loss 0.015320800,pde loss 0.004750548, BC loss 0.001550460\n",
      "Iteration  5900, Total Loss 0.021511018, Data loss 0.015242812,pde loss 0.004703421, BC loss 0.001564784\n",
      "Iteration  6000, Total Loss 0.021390669, Data loss 0.015228800,pde loss 0.004613702, BC loss 0.001548168\n",
      "Iteration  6100, Total Loss 0.021248437, Data loss 0.014994205,pde loss 0.004719225, BC loss 0.001535007\n",
      "Iteration  6200, Total Loss 0.021135587, Data loss 0.014989066,pde loss 0.004613793, BC loss 0.001532728\n",
      "Iteration  6300, Total Loss 0.021028552, Data loss 0.014882637,pde loss 0.004624730, BC loss 0.001521184\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[70], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[68], line 96\u001b[0m, in \u001b[0;36mPINN.train\u001b[1;34m(self, adam_epochs, lbfgs_epochs)\u001b[0m\n\u001b[0;32m     93\u001b[0m     loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[0;32m     94\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m loss\n\u001b[1;32m---> 96\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimiser\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclosure\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\optim\\optimizer.py:487\u001b[0m, in \u001b[0;36mOptimizer.profile_hook_step.<locals>.wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    482\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    483\u001b[0m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m    484\u001b[0m                 \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must return None or a tuple of (new_args, new_kwargs), but got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    485\u001b[0m             )\n\u001b[1;32m--> 487\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    488\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_optimizer_step_code()\n\u001b[0;32m    490\u001b[0m \u001b[38;5;66;03m# call optimizer step post hooks\u001b[39;00m\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\utils\\_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[0;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[1;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\optim\\lbfgs.py:444\u001b[0m, in \u001b[0;36mLBFGS.step\u001b[1;34m(self, closure)\u001b[0m\n\u001b[0;32m    441\u001b[0m     \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mobj_func\u001b[39m(x, t, d):\n\u001b[0;32m    442\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_directional_evaluate(closure, x, t, d)\n\u001b[1;32m--> 444\u001b[0m     loss, flat_grad, t, ls_func_evals \u001b[38;5;241m=\u001b[39m \u001b[43m_strong_wolfe\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    445\u001b[0m \u001b[43m        \u001b[49m\u001b[43mobj_func\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx_init\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloss\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mflat_grad\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgtd\u001b[49m\n\u001b[0;32m    446\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    447\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_grad(t, d)\n\u001b[0;32m    448\u001b[0m opt_cond \u001b[38;5;241m=\u001b[39m flat_grad\u001b[38;5;241m.\u001b[39mabs()\u001b[38;5;241m.\u001b[39mmax() \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m tolerance_grad\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\optim\\lbfgs.py:48\u001b[0m, in \u001b[0;36m_strong_wolfe\u001b[1;34m(obj_func, x, t, d, f, g, gtd, c1, c2, tolerance_change, max_ls)\u001b[0m\n\u001b[0;32m     46\u001b[0m g \u001b[38;5;241m=\u001b[39m g\u001b[38;5;241m.\u001b[39mclone(memory_format\u001b[38;5;241m=\u001b[39mtorch\u001b[38;5;241m.\u001b[39mcontiguous_format)\n\u001b[0;32m     47\u001b[0m \u001b[38;5;66;03m# evaluate objective and gradient using initial step\u001b[39;00m\n\u001b[1;32m---> 48\u001b[0m f_new, g_new \u001b[38;5;241m=\u001b[39m \u001b[43mobj_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     49\u001b[0m ls_func_evals \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m     50\u001b[0m gtd_new \u001b[38;5;241m=\u001b[39m g_new\u001b[38;5;241m.\u001b[39mdot(d)\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\optim\\lbfgs.py:442\u001b[0m, in \u001b[0;36mLBFGS.step.<locals>.obj_func\u001b[1;34m(x, t, d)\u001b[0m\n\u001b[0;32m    441\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mobj_func\u001b[39m(x, t, d):\n\u001b[1;32m--> 442\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_directional_evaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclosure\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\optim\\lbfgs.py:296\u001b[0m, in \u001b[0;36mLBFGS._directional_evaluate\u001b[1;34m(self, closure, x, t, d)\u001b[0m\n\u001b[0;32m    294\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m_directional_evaluate\u001b[39m(\u001b[38;5;28mself\u001b[39m, closure, x, t, d):\n\u001b[0;32m    295\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_grad(t, d)\n\u001b[1;32m--> 296\u001b[0m     loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mfloat\u001b[39m(\u001b[43mclosure\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[0;32m    297\u001b[0m     flat_grad \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gather_flat_grad()\n\u001b[0;32m    298\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_param(x)\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\utils\\_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[0;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[1;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[68], line 92\u001b[0m, in \u001b[0;36mPINN.train.<locals>.closure\u001b[1;34m()\u001b[0m\n\u001b[0;32m     90\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mclosure\u001b[39m():\n\u001b[0;32m     91\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptimiser\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m---> 92\u001b[0m     loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     93\u001b[0m     loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[0;32m     94\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m loss\n",
      "Cell \u001b[1;32mIn[68], line 58\u001b[0m, in \u001b[0;36mPINN.compute_loss\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m     55\u001b[0m bc_loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss_fn(bc_loss,\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mBC_Y)\n\u001b[0;32m     57\u001b[0m \u001b[38;5;66;03m# Data Loss\u001b[39;00m\n\u001b[1;32m---> 58\u001b[0m data_loss \u001b[38;5;241m=\u001b[39m \u001b[43mData_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mX_D\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     59\u001b[0m data_loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss_fn(data_loss, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mU_D)\n\u001b[0;32m     63\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39miter \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m500\u001b[39m:\n",
      "Cell \u001b[1;32mIn[61], line 43\u001b[0m, in \u001b[0;36mData_loss\u001b[1;34m(model, X_D)\u001b[0m\n\u001b[0;32m     42\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mData_loss\u001b[39m(model, X_D):\n\u001b[1;32m---> 43\u001b[0m     p_grads, u_grads, v_grads \u001b[38;5;241m=\u001b[39m \u001b[43mcompute_gradients\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43mX_D\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     44\u001b[0m     p, p_x, p_y \u001b[38;5;241m=\u001b[39m p_grads\n\u001b[0;32m     45\u001b[0m     u, u_x, u_y, u_xx, u_yy \u001b[38;5;241m=\u001b[39m u_grads\n",
      "Cell \u001b[1;32mIn[37], line 39\u001b[0m, in \u001b[0;36mcompute_gradients\u001b[1;34m(model, xy)\u001b[0m\n\u001b[0;32m     37\u001b[0m \u001b[38;5;66;03m# Second-order derivatives\u001b[39;00m\n\u001b[0;32m     38\u001b[0m u_x \u001b[38;5;241m=\u001b[39m grad(u, x)\n\u001b[1;32m---> 39\u001b[0m u_y \u001b[38;5;241m=\u001b[39m \u001b[43mgrad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mu\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     40\u001b[0m v_x \u001b[38;5;241m=\u001b[39m grad(v, x)\n\u001b[0;32m     41\u001b[0m v_y \u001b[38;5;241m=\u001b[39m grad(v, y)\n",
      "Cell \u001b[1;32mIn[37], line 3\u001b[0m, in \u001b[0;36mgrad\u001b[1;34m(outputs, inputs)\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mgrad\u001b[39m(outputs, inputs):\n\u001b[1;32m----> 3\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautograd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgrad\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m      4\u001b[0m \u001b[43m        \u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m      5\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgrad_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mones_like\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m      6\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m      7\u001b[0m \u001b[43m        \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\n\u001b[0;32m      8\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m]\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\autograd\\__init__.py:496\u001b[0m, in \u001b[0;36mgrad\u001b[1;34m(outputs, inputs, grad_outputs, retain_graph, create_graph, only_inputs, allow_unused, is_grads_batched, materialize_grads)\u001b[0m\n\u001b[0;32m    492\u001b[0m     result \u001b[38;5;241m=\u001b[39m _vmap_internals\u001b[38;5;241m.\u001b[39m_vmap(vjp, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m, allow_none_pass_through\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)(\n\u001b[0;32m    493\u001b[0m         grad_outputs_\n\u001b[0;32m    494\u001b[0m     )\n\u001b[0;32m    495\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 496\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[43m_engine_run_backward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    497\u001b[0m \u001b[43m        \u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    498\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgrad_outputs_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    499\u001b[0m \u001b[43m        \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    500\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    501\u001b[0m \u001b[43m        \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    502\u001b[0m \u001b[43m        \u001b[49m\u001b[43mallow_unused\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    503\u001b[0m \u001b[43m        \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m    504\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    505\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m materialize_grads:\n\u001b[0;32m    506\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(\n\u001b[0;32m    507\u001b[0m         result[i] \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_tensor_like(inputs[i])\n\u001b[0;32m    508\u001b[0m         \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(inputs))\n\u001b[0;32m    509\u001b[0m     ):\n",
      "File \u001b[1;32mC:\\anaconda\\envs\\workshop\\Lib\\site-packages\\torch\\autograd\\graph.py:825\u001b[0m, in \u001b[0;36m_engine_run_backward\u001b[1;34m(t_outputs, *args, **kwargs)\u001b[0m\n\u001b[0;32m    823\u001b[0m     unregister_hooks \u001b[38;5;241m=\u001b[39m _register_logging_hooks_on_whole_graph(t_outputs)\n\u001b[0;32m    824\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 825\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mVariable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[0;32m    826\u001b[0m \u001b[43m        \u001b[49m\u001b[43mt_outputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[0;32m    827\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Calls into the C++ engine to run the backward pass\u001b[39;00m\n\u001b[0;32m    828\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[0;32m    829\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m attach_logging_hooks:\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "test.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "83234dda-bea2-4038-bc04-157290073412",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6.03905981]\n",
      " [1.67557759]\n",
      " [2.10070433]\n",
      " ...\n",
      " [4.58959721]\n",
      " [2.16145338]\n",
      " [0.41555437]] [[-0.43248082]\n",
      " [-0.08888687]\n",
      " [-1.31230289]\n",
      " ...\n",
      " [ 0.61538775]\n",
      " [-0.77192089]\n",
      " [ 0.75780147]]\n",
      "[[ 6.03905981 -0.43248082]\n",
      " [ 1.67557759 -0.08888687]\n",
      " [ 2.10070433 -1.31230289]\n",
      " ...\n",
      " [ 4.58959721  0.61538775]\n",
      " [ 2.16145338 -0.77192089]\n",
      " [ 0.41555437  0.75780147]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnoAAAHVCAYAAABmCFaqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqQJJREFUeJzs3XlcVOX+B/DPMDALM8woIouJQGWKoqlgAuZeuGSpLWIWqbmmZkrdrmQlWjdarNQUl65Bahm/e9XUJJMyUy9oSaClxrXSCyqokDIMywwM5/fHeI5nZs5sMMP6fb9e8yrOPOfMMyMeP/OsIoZhGBBCCCGEkDbHo7krQAghhBBC3IOCHiGEEEJIG0VBjxBCCCGkjaKgRwghhBDSRlHQI4QQQghpoyjoEUIIIYS0URT0CCGEEELaKAp6hBBCCCFtFAU9QgghhJA2ioIeIYQQQkgbRUGPEEIIIYTnyJEjePjhh9GlSxeIRCJ8+eWXNsvv2rULDz74IDp37gyVSoWYmBh88803FuV27tyJXr16QSqVolevXti9e7eb3sFtFPQIIYQQQngqKytx7733Yt26dQ6VP3LkCB588EFkZmYiNzcXI0aMwMMPP4y8vDyuTE5ODuLj45GQkIBTp04hISEBkydPxokTJ9z1NgAAIoZhGLe+AiGEEEJIKyUSibB7925MnDjRqfN69+6N+Ph4vP766wCA+Ph4aDQafP3111yZMWPGoGPHjtixY4crq2zC021XJoS0SDU1NdDr9Q6VlUgkkMlkbq4RIYQ0jDP3M4ZhIBKJTI5JpVJIpVKX16u+vh4VFRXw9fXljuXk5GDJkiUm5UaPHo3Vq1e7/PX5KOgR0o7U1NQgTC5HiYPlAwMDceHCBQp7hJAWx9n7mVKphFarNTm2fPlyJCcnu7xu77//PiorKzF58mTuWElJCQICAkzKBQQEoKTE0XfQMBT0CGlH9Ho9SgAUyTyhslNWAyC4pAR6vZ6CHiGkxeHuZ14ejt3PtFoUFRVBpbpd2h2teTt27EBycjL27NkDf39/k+fMWxSFWhldjYIeIe2QCoDK3s2Fhu8SQloBZ+5nKpXKJOi5WkZGBmbOnIl//etfeOCBB0yeCwwMtGi9u3btmkUrn6vRrFtCCCGEkEbasWMHpk+fjs8//xwPPfSQxfMxMTHIysoyOXbw4EHExsa6tV7UokdIe+QrBzzsfAOuZ4ArFU1TH0IIaShfb8fuZ1e1tsvwaLVa/P7779zPFy5cQH5+Pnx9fdGtWzckJSXh8uXL2Lp1KwBjyHvmmWewZs0aREdHcy13crkcarUaAPDCCy9g6NCheOeddzBhwgTs2bMH3377LY4dO+bkG3YOtegRQgghhPCcPHkS/fv3R//+/QEAiYmJ6N+/P7dUSnFxMQoLC7nymzZtQl1dHRYsWICgoCDu8cILL3BlYmNj8cUXXyAtLQ19+/ZFeno6MjIyMGjQILe+F1pHj5B2RKPRQK1Wo7yLD1R2vgFr6hmor1SgvLzc4TEtqampeO+991BcXIzevXtj9erVGDJkiGDZY8eO4e9//zt+++03VFVVISQkBHPnzrVYfoAQQoRw97MApWP3s6tap+5nbQV13RJCXCIjIwOLFy9GamoqBg8ejE2bNmHs2LE4e/YsunXrZlFeoVBg4cKF6Nu3LxQKBY4dO4a5c+dCoVBgzpw5zfAOCCGk7aEWPULakYa06AktRyC0JMGgQYMwYMAAbNiwgTsWHh6OiRMnIiUlxaH6Pfroo1AoFNi2bZuD74gQ0l5Ri55jaIweIe2Rrxzo5G374SsHAAQHB0OtVnMPodCm1+uRm5uLuLg4k+NxcXHIzs52qEp5eXnIzs7GsGHDGv/+CCHth1oCdJDafqglzV3LZkNdt4QQmxxZYLS0tBQGg6FBq7537doV169fR11dHZKTkzFr1izXVJwQQggFPUKIbc4sMNqQVd+PHj0KrVaL48ePY+nSpbj77rvx5JNPNri+hBBCbqOgRwhpND8/P4jF4gat+h4WFgYA6NOnD65evYrk5GQKeoQQ4iI0Ro8Q0mgSiQSRkZEWq75nZWU5teo7wzDQ6XSurh4hpC3r6G1cNNnWo6N3c9ey2VCLHiHtUUc54Gnne15dvVOXTExMREJCAqKiohATE4PNmzejsLAQ8+bNAwCLleTXr1+Pbt26oWfPngCM6+qtWrUKzz//vPPvhxBCiCAKeoQQl4iPj0dZWRlWrlyJ4uJiREREIDMzEyEhIQAsV5Kvr69HUlISLly4AE9PT9x11114++23MXfu3OZ6C4QQ0ubQOnqEtCPculNDQqCy06KnqauH+uj/2uW6U4SQlo+7nw3q6tj97MSldnk/ozF6hBBCCCFtFHXdEkIIIaT16igDvMS2y9QamqYuLRC16BHSHnWUGXe+sPXoKGvuWhJCSLM4cuQIHn74YXTp0gUikQhffvml3XN++OEHREZGQiaT4c4778TGjRtNnk9PT4dIJLJ41NTUuOldGFHQI4QQQgjhqaysxL333ot169Y5VP7ChQsYN24chgwZgry8PLzyyitYtGgRdu7caVJOpVKhuLjY5CGTufdLNXXdEkIIIaRd0Gg0Jj9LpVLBbR3Hjh2LsWPHOnzdjRs3olu3bli9ejUAIDw8HCdPnsSqVavw2GOPceVEIhECAwMbVvkGohY9QgghhLReKhmgtvNQGVvNgoODoVaruUdKSopLqpCTk4O4uDiTY6NHj8bJkydRW1vLHdNqtQgJCUHXrl0xfvx45OXlueT1baEWPUIIIYS0C0VFRSbLqwi15jVESUmJxXaPAQEBqKurQ2lpKYKCgtCzZ0+kp6ejT58+0Gg0WLNmDQYPHoxTp06he/fuLqmHEAp6hLRHHeWAxM4sNX37naVGCGmbVCqV29bRE4lEJj+zyxSzx6OjoxEdHc09P3jwYAwYMAAfffQR1q5d65Y6AdR1SwghhBDSKIGBgSgpKTE5du3aNXh6eqJTp06C53h4eGDgwIE4f/68W+tGQY8QQgghpBFiYmKQlZVlcuzgwYOIioqCl5eX4DkMwyA/Px9BQUFurRt13RJCCCGk9eooAyR24oy+zqlLarVa/P7779zPFy5cQH5+Pnx9fdGtWzckJSXh8uXL2Lp1KwBg3rx5WLduHRITEzF79mzk5ORgy5Yt2LFjB3eNFStWIDo6Gt27d4dGo8HatWuRn5+P9evXO1U3Z1HQI4QQQgjhOXnyJEaMGMH9nJiYCACYNm0a0tPTUVxcjMLCQu75sLAwZGZmYsmSJVi/fj26dOmCtWvXmiytcvPmTcyZMwclJSVQq9Xo378/jhw5gvvuu8+t70XEsKMFCSFtHrcJ+AsxUEltf8/T6OqgXpPTLjcBJ4S0fNz9bG4UVHZa9DT6Oqg3nWyX9zMao0cIIYQQ0kZR0COEuExqairCwsIgk8kQGRmJo0ePWi27a9cuPPjgg+jcuTNUKhViYmLwzTffNGFtCSFtgs+tBZFtPXza797dFPQIIS6RkZGBxYsXY9myZcjLy8OQIUMwduxYk3EsfEeOHMGDDz6IzMxM5ObmYsSIEXj44YebZKV4QghpL2iMHiHtSEPG6AmtJC+0mvygQYMwYMAAbNiwgTsWHh6OiRMnOrzNUO/evREfH4/XX3/dwXdECGmvuPvZS/c7dj9bdYzG6BFC2gm1HOhg56GWA3Bsb0i9Xo/c3FyLvR7j4uKQnZ3tUJXq6+tRUVEBX1/fxr8/QgghAGh5FUKIHY7sDVlaWgqDwSC416P5avHWvP/++6isrMTkyZMbV2FCCCEcCnqEEJuc2RtSaK9H82NCduzYgeTkZOzZswf+/v4NqichpJ3qIANkwrtPcGpqm6YuLRAFPUJIo/n5+UEsFgvu9WjeymcuIyMDM2fOxL/+9S888MAD7qwmIYS0OzRGjxDSaBKJBJGRkRZ7PWZlZSE2NtbqeTt27MD06dPx+eef46GHHnJ3NQkhpN2hFj1C2iO1DJDb6eqodq6rIzExEQkJCYiKikJMTAw2b96MwsJCzJs3DwAs9obcsWMHnnnmGaxZswbR0dFca6BcLodarXb+PRFCCLFAQY8Q4hLx8fEoKyvDypUrUVxcjIiICGRmZiIkJAQALPaG3LRpE+rq6rBgwQIsWLCAO87uJUkIIQ5RSO1/cRW33w5MCnqEEJeZP38+5s+fL/iceXg7fPiw+ytECCHtXPuNuIQQQgghVjizpSMArF+/HuHh4ZDL5ejRowc3TIVv586d6NWrF6RSKXr16oXdu3e7q/ocCnqEEEIIITzObum4YcMGJCUlITk5GWfOnMGKFSuwYMEC7Nu3jyuTk5OD+Ph4JCQk4NSpU0hISMDkyZNx4sQJt74X2gKNkHaE2zLo48eg8rY9pkVTVQv17J3tcssgQkjLx93PPnwIKjtj9DTVtVAv2e+2LR1jY2MxePBgvPfee9yxxYsX4+TJkzh27BgA4zhmjUaDr7/+miszZswYdOzYETt27HD8jTuJWvQIIYQQ0nqpbm3ZaOuhcu+WjjqdDjKZzOSYXC7Hjz/+iNpa4woGOTk5FtccPXq0w9tENhRNxiCEEEJIu+CuLR1Hjx6Nf/7zn5g4cSIGDBiA3NxcfPLJJ6itrUVpaSmCgoJQUlLSqG0iG4qCHiGEEELaBXdt6fjaa6+hpKQE0dHRYBgGAQEBmD59Ot59912IxeIGXdNVqOuWEEIIIeSWhmzpKJfL8cknn6CqqgoXL15EYWEhQkND4ePjAz8/PwBAYGBgg7aJbCwKeoS0RyopoJLZeVh2aRBCSFvX0C0dAcDLywtdu3aFWCzGF198gfHjx8PDwxi1YmJiLK558OBBu9dsLOq6JYQQQkjrpZQA3hLbZTyc6x51dkvH//73v/jxxx8xaNAg3LhxAx988AF+/fVXfPrpp9w1X3jhBQwdOhTvvPMOJkyYgD179uDbb7/lZuW6CwU9QgghhBAeZ7d0NBgMeP/991FQUAAvLy+MGDEC2dnZCA0N5crExsbiiy++wKuvvorXXnsNd911FzIyMjBo0CC3vhdaR4+QdoRbdypjKlR2vgFrqvRQx39O6+gRQlokup85hsboEUIIIYS0UdR1S0g7pFUp4KGw/Q1Y62l7pXlCCGkJKpVyiO3czyo9xDafb8uoRY8QQgghpI2ioEcIcZnU1FSEhYVBJpMhMjISR48etVq2uLgYU6dORY8ePeDh4YHFixc3XUUJIaSdoKBHCHGJjIwMLF68GMuWLUNeXh6GDBmCsWPHmsxM49PpdOjcuTOWLVuGe++9t4lrSwgh7QMFPUKITRqNxuSh0+kEy33wwQeYOXMmZs2ahfDwcKxevRrBwcHYsGGDYPnQ0FCsWbMGzzzzDNRqtTvfAiGEtFsU9JpAeno6RCIR9/D09ETXrl0xY8YMXL58ubmrR26pqqpCcnIyDh8+3NxVcTuttxQVCpnNh9bbuDNGcHAw1Go190hJSbG4nl6vR25uLuLi4kyOx8XFITs7u0neE2n7kpOT3bovqND1U1NTkZ6e7rbXbEpnz55FcnIyLl682NxVcalKbxm0CrnNR6W3rLmr2Wxo1m0TSktLQ8+ePVFdXY0jR44gJSUFP/zwA3755RcoFIrmrl67V1VVhRUrVgAAhg8f3ryVaUGKiopM1p2SSi23RistLYXBYLDYszEgIMBib0dCWqpZs2ZhzJgxJsdSU1Ph5+eH6dOnN0+lXOjs2bNYsWIFhg8fbrKQL2nbKOg1oYiICERFRQEARowYAYPBgDfeeANffvklnnrqKcFzqqqq4O3t3ZTVbLTq6mrI5fLmrkar1BI/O5VK5fACo+atIQzDuLUFhhBX6tq1K7p27drc1WizDAYD6urqBL8sEvehrttmFB0dDQD43//+BwCYPn06lEolfvnlF8TFxcHHxwejRo0CYOwae/PNN9GzZ09IpVJ07twZM2bMwPXr102ueejQIQwfPhydOnWCXC5Ht27d8Nhjj6Gqqoors2HDBtx7771QKpXw8fFBz5498corr3DPW+seYbug+c3+oaGhGD9+PHbt2oX+/ftDJpNxrWIlJSWYO3cuunbtColEgrCwMKxYsQJ1dXUOfT6ff/45YmJioFQqoVQq0a9fP2zZssWkzCeffIJ7770XMpkMvr6+mDRpEs6dO2dShv1cf//9d4wbNw5KpRLBwcF48cUXufFmFy9eROfOnQEAK1as4LrZ+d/ijx07hlGjRsHHxwfe3t6IjY3F/v37TV7LVZ9da+Pn5wexWGzRenft2jWLVj7SekyfPl2w5ceRLtTFixdDoVBAo9FYPBcfH4+AgADU1tZyxzIyMhATEwOFQgGlUonRo0cjLy/Pbh3r6+vx7rvvcvdGf39/PPPMM7h06ZJF2QMHDmDUqFFQq9Xw9vZGeHi4yVAE8/cVGhqKM2fO4IcffuDuCaGhodBqtejQoQPmzp1r8RoXL16EWCzGe++9Z7PeOp0OK1euRHh4OGQyGTp16sRtm8WqqalBUlISwsLCIJFIcMcdd2DBggW4efOmybXYe8mBAwcwYMAAyOVy9OzZE5988glXJj09HU888QQAY0MD+3743dKO3E+HDx8u2ONh/rty8eJFiEQivPvuu3jzzTcRFhYGqVSK77//3ubnQlyPgl4z+v333wGACxiAMdA98sgjGDlyJPbs2YMVK1agvr4eEyZMwNtvv42pU6di//79ePvtt5GVlYXhw4ejuroagPEv1kMPPQSJRIJPPvkEBw4cwNtvvw2FQgG9Xg8A+OKLLzB//nwMGzYMu3fvxpdffoklS5agsrKywe/j559/xt/+9jcsWrQIBw4cwGOPPYaSkhLcd999+Oabb/D666/j66+/xsyZM5GSkoLZs2fbvebrr7+Op556Cl26dEF6ejp2796NadOmcaEYAFJSUjBz5kz07t0bu3btwpo1a3D69GnExMTg/PnzJterra3FI488glGjRmHPnj149tln8eGHH+Kdd94BAAQFBeHAgQMAgJkzZyInJwc5OTl47bXXAAA//PADRo4cifLycmzZsgU7duyAj48PHn74YWRkZLj0s2uNJBIJIiMjkZWVZXI8KysLsbGxzVQr0pyeffZZVFVV4f/+7/9Mjt+8eRN79uzB008/DS8v46Lcb731Fp588kn06tUL//d//4dt27ahoqICQ4YMwdmzZ22+znPPPYe///3vePDBB7F371688cYbOHDgAGJjY1FaWsqV27JlC8aNG4f6+nps3LgR+/btw6JFiwQDIWv37t2488470b9/f+6esHv3biiVSjz77LP47LPPUF5ebnJOamoqJBIJnn32WavXraurw9ixY/HGG29g/Pjx2L17N9LT0xEbG8vNUmcYBhMnTsSqVauQkJCA/fv3IzExEZ9++ilGjhxpMSnq1KlTePHFF7FkyRLs2bMHffv2xcyZM3HkyBEAwEMPPYS33noLALB+/Xru/Tz00EMAnLufOmPt2rU4dOgQVq1aha+//ho9e/Zs8LWsqfaWOvRotxjidmlpaQwA5vjx40xtbS1TUVHBfPXVV0znzp0ZHx8fpqSkhGEYhpk2bRoDgPnkk09Mzt+xYwcDgNm5c6fJ8Z9++okBwKSmpjIMwzD//ve/GQBMfn6+1bosXLiQ6dChg836Ll++nBH61WDfx4ULF7hjISEhjFgsZgoKCkzKzp07l1Eqlcz//vc/k+OrVq1iADBnzpyx+vp//vknIxaLmaeeespqmRs3bjByuZwZN26cyfHCwkJGKpUyU6dO5Y6xn+v//d//mZQdN24c06NHD+7n69evMwCY5cuXW7xedHQ04+/vz1RUVHDH6urqmIiICKZr165MfX09wzCu+ezcqby8nAHA/HzyJeb8b8tsPn4++RIDgCkvL3fo2l988QXj5eXFbNmyhTl79iyzePFiRqFQMBcvXmQYhmGWLl3KJCQkmJyTl5fH5OXlMZGRkczUqVOZvLw8m78bpGlNmzaNCQkJsThu7ffc3IABA5jY2FiTY6mpqQwA5pdffmEYxvh31tPTk3n++edNylVUVDCBgYHM5MmTrb7uuXPnGADM/PnzTc49ceIEA4B55ZVXuGupVCrm/vvv5/6uChF6X71792aGDRtmUfaPP/5gPDw8mA8//JA7Vl1dzXTq1ImZMWOG1ddgGIbZunUrA4D5+OOPrZY5cOAAA4B59913TY5nZGQwAJjNmzdzx0JCQhiZTGZyv62urmZ8fX2ZuXPncsf+9a9/MQCY77//3uSaztxPhw0bJvh5mP+uXLhwgQHA3HXXXYxer7f6PhuDvZ+dPpHIXDiTZPNx+kSiU/czhmGY9evXM6GhoYxUKmUGDBjAHDlyxGpZ9t8Z80evXr24Muy/A+aP6urqRn0O9lCLXhOKjo6Gl5cXfHx8MH78eAQGBuLrr7+26Noyb9X56quv0KFDBzz88MOoq6vjHv369UNgYCA3S7Rfv36QSCSYM2cOPv30U/z5558Wdbjvvvtw8+ZNPPnkk9izZ4/JN96G6tu3L+655x6LOo8YMQJdunQxqfPYsWMBGFvIrMnKyoLBYMCCBQuslsnJyUF1dbXFAOng4GCMHDkS3333nclxkUiEhx9+2KLe/BZCayorK3HixAk8/vjjUCqV3HGxWIyEhARcunQJBQUFdq8jROiza63i4+OxevVqrFy5Ev369cORI0eQmZmJkJAQAMYFks3X1Ovfvz/69++P3NxcfP755+jfvz/GjRvXHNUnbjBjxgxkZ2eb/P1IS0vDwIEDERERAQD45ptvUFdXh2eeecbkXiGTyTBs2DCbs+DZbkDz+8B9992H8PBw7j6QnZ0NjUaD+fPnu2zM6J133onx48cjNTUVDMMAMA43KSsrw8KFC22e+/XXX0Mmk9ls9Tt06BAAy/f2xBNPQKFQWNzj+vXrh27dunE/y2Qy3HPPPQ7d45y9nzrjkUce4VpuWxNn1wVds2YNiouLuUdRURF8fX257nKWSqUyKVdcXAyZzL0zginoNaGtW7fip59+Ql5eHq5cuYLTp09j8ODBJmW8vb0tBr5fvXoVN2/ehEQigZeXl8mjpKSEC2t33XUXvv32W/j7+2PBggW46667cNddd2HNmjXctRISEvDJJ5/gf//7Hx577DH4+/tj0KBBFl1uzggKCrI4dvXqVezbt8+ivr179wYAmwGTHXdoa1B0WVmZ1dfu0qUL9zzL29vb4i+TVCpFTU2N1ddg3bhxAwzDWH0tfn2cJXTN1mz+/Pm4ePEidDodcnNzMXToUO659PR0i3+0GYaxeLS1pR/as6eeegpSqZQbB3b27Fn89NNPmDFjBlfm6tWrAICBAwda3C8yMjJs3iscvQ84ck9piBdeeAHnz5/n7p/r169HTEwMBgwYYPO869evo0uXLvDwsP5PcFlZGTw9PU2G9gDGL62BgYEW95xOnTpZXEMqlXJDe2xx9n7qjNZ6j3N2XVC1Wo3AwEDucfLkSdy4ccPkdx24/efHf7gbzbptQuHh4dysW2uEvm36+fmhU6dO3Bgycz4+Ptz/DxkyBEOGDIHBYMDJkyfx0UcfYfHixQgICMCUKVMAGL9lz5gxA5WVlThy5AiWL1+O8ePH47///S9CQkK4QKTT6UxmR1m74Vqrc9++ffGPf/xD8Bw2IAlhb2yXLl1CcHCwYBn2plZcXGzx3JUrV+Dn52f1+s7q2LEjPDw8rL4WAO71XPHZEdJSyGQywQWyHe0J6NixIyZMmICtW7fizTffRFpaGmQyGZ588kmuDPt359///jfX+uso/n3APMTx7wP8e4orjRw5EhEREVi3bh2USiV+/vlnbN++3e55nTt3xrFjx1BfX2817HXq1Al1dXW4fv26SdhjGAYlJSUYOHCgy96HM/dTmUxmMS4RaD33OPPJQVKp1GIWMLsu6NKlS02OO7Mu6JYtW/DAAw9Y/E5rtVqEhITAYDCgX79+eOONN9C/f/8GvBPHUYteKzB+/HiUlZXBYDAgKirK4tGjRw+Lc8RiMQYNGoT169cDMA76N6dQKDB27FgsW7YMer0eZ86cAQBu5tTp06dNyu/bt8+pOv/666+46667BOtsK+jFxcVBLBZb/eYEADExMZDL5RY31UuXLuHQoUPcbGVnsH/Zzb8BKxQKDBo0CLt27TJ5rr6+Htu3b0fXrl257ldXfHaEtBShoaG4du0a1+oGGP8R/Oabbxy+xowZM3DlyhVkZmZi+/btmDRpEjp06MA9P3r0aHh6euKPP/4QvFfY+nI8cuRIALC4D/z00084d+4cdx+IjY2FWq3Gxo0buW5WR9lrFVu0aBH279+PpKQkBAQEWHTVCRk7dixqampsLsTM1t38ve3cuROVlZUuvcc5cz8NDQ3Ff//7X5MvAGVlZc26MHqlTAqtXGbzUSlzfAH4xq4LWlxcjK+//hqzZs0yOd6zZ0+kp6dj79692LFjB2QyGQYPHtyoyS6OoBa9VmDKlCn47LPPMG7cOLzwwgu477774OXlhUuXLuH777/HhAkTMGnSJGzcuBGHDh3CQw89hG7duqGmpoabXv/AAw8AAGbPng25XI7BgwcjKCgIJSUlSElJgVqt5r4hjhs3Dr6+vpg5cyZWrlwJT09PpKeno6ioyOE6r1y5kptxuWjRIvTo0QM1NTW4ePEiMjMzsXHjRqvdKKGhoXjllVfwxhtvoLq6Gk8++STUajXOnj2L0tJSrFixAh06dMBrr72GV155Bc888wyefPJJlJWVYcWKFZDJZFi+fLnTn7OPjw9CQkKwZ88ejBo1Cr6+vvDz80NoaChSUlLw4IMPYsSIEXjppZcgkUiQmpqKX3/9FTt27OC+tbris2sKlTIZRHLb40Iq61rWN3HS9OLj4/H6669jypQp+Nvf/oaamhqsXbsWBoPB4WvExcWha9eumD9/PkpKSiy6skJDQ7Fy5UosW7YMf/75J8aMGYOOHTvi6tWr+PHHH6FQKKwuO9SjRw/MmTMHH330ETw8PDB27FhcvHgRr732GoKDg7FkyRIAgFKpxPvvv49Zs2bhgQcewOzZsxEQEIDff/8dp06dwrp166zWv0+fPvjiiy+QkZGBO++8EzKZDH369OGef/rpp5GUlIQjR47g1VdfhUQisfuZPPnkk0hLS8O8efNQUFCAESNGoL6+HidOnEB4eDimTJmCBx98EKNHj8bf//53aDQaDB48GKdPn8by5cvRv39/JCQkOPLxm2DHRW7evBk+Pj6QyWQICwtDp06dHL6fJiQkYNOmTXj66acxe/ZslJWV4d1333V4rc3m5sgC8KyGrguanp6ODh06YOLEiSbHo6OjuWXVAGDw4MEYMGAAPvroI6xdu9bBd9AAbp3qQRiGuT3T5qeffrJZbtq0aYxCoRB8rra2llm1ahVz7733MjKZjFEqlUzPnj2ZuXPnMufPn2cYhmFycnKYSZMmMSEhIYxUKmU6derEDBs2jNm7dy93nU8//ZQZMWIEExAQwEgkEqZLly7M5MmTmdOnT5u83o8//sjExsYyCoWCueOOO5jly5cz//znPwVnjj700EOCdb5+/TqzaNEiJiwsjPHy8mJ8fX2ZyMhIZtmyZYxWq7X7uW3dupUZOHAg93779+/PpKWlmZT55z//yfTt25eRSCSMWq1mJkyYYDFr09rnKjTD7ttvv2X69+/PSKVSBgAzbdo07rmjR48yI0eOZBQKBSOXy5no6Ghm3759Ftd1xWfnLuwstaO/vsrk/e9Nm4+jv77q9Cw10vZkZmYy/fr1Y+RyOXPnnXcy69atc3jWLeuVV15hADDBwcGMwWAQLPPll18yI0aMYFQqFSOVSpmQkBDm8ccfZ7799luujNDrGgwG5p133mHuuecexsvLi/Hz82OefvpppqioSPC9DBs2jFEoFIy3tzfTq1cv5p133rF5/YsXLzJxcXGMj48PA0BwFvL06dMZT09P5tKlSw5/JtXV1czrr7/OdO/enZFIJEynTp2YkSNHMtnZ2SZl/v73vzMhISGMl5cXExQUxDz33HPMjRs3TK5l7V4iNEN29erVTFhYGCMWixkAJvdUR+6nDGP8dyQ8PJyRyWRMr169mIyMDKuzbt977z2HPxNnsfeznFNJzC9/rrD5yDmV5PD9TKfTMWKxmNm1a5fJ8UWLFjFDhw61eW59fT1z9913M4sXL3boPcyaNYsZM2aMQ2UbSsQwTrZjE0JaLY1GA7VajaO/vgqlj+0WPW1FDYZEvIny8vJW822dkKam1+sRGhqK+++/32LNQOJe7P0s51SSQ/ezmHtTHL6fDRo0CJGRkUhNTeWO9erVCxMmTBDs7mUdPnwYI0aMwC+//MK1oFrDMAzuu+8+9OnTx2Rxa1ejrltCCCHESdevX0dBQQHS0tJw9epVi4H7pOlUyaQQyWwviFxV61ybVmJiIhISEhAVFYWYmBhs3rwZhYWFmDdvHgAgKSkJly9fxtatW03O27JlCwYNGiQY8lasWIHo6Gh0794dGo0Ga9euRX5+PjeW3l0o6BFCCCFO2r9/P2bMmIGgoCCkpqbaXVKFtC7x8fEoKyvDypUrUVxcjIiICLvrgpaXl2Pnzp0mS5rx3bx5E3PmzEFJSQnUajX69++PI0eO4L777nPre6GuW0LaEbar48Afb0Jhp6ujsqIGY+56lbpuCSEtEns/+64g2aH72ageye3yfkbLqxBCCCGEtFEU9AghhBBC2igao2dHfX09rly5Ah8fnxa3wjchLIZhUFFRYXdbJdK+0f2MtAbO3s8qJVLAxnp4AFCpa7+j1Cjo2XHlyhWr23AR0tIUFRW5fD9P0nbQ/Yy0JnQ/cw0Kenaw+8iar6bd1qzAt42+RmW95TcqrcF0lXhtnZfNayg9ax0ua/LatcayO1V97JRsmzQaDYKDg032PbZFK5Gg3s434CpdvSuqRlqQ9nI/w+zB1p/T1Lj2tW7YuF5H2xME7MrIbdz5rZSz9zNiGwU9O9juDZVK1SJvjOvqXbNAZ5id5ys8LENBBUxvYrW8oMcGPH7Mq6iTwF50k3jquf/3tVenuttX73DrvzPxX6vl2TDIylTda+cVWh/qjiO2tPT7GRbFmP58w/oeszZJxNaf81OY/lzeiOD3VzXgaaNrsUIP+Mobfv2nHVx2Qy0DtuU3/HVaKLqfuQYFvRYkvXab0+co3VAPPq3YGN586o0bWPMDnw9quLCnFQh5fPxQZgtbzudW4FOK9YLltAYJV8aR6wGAwqvW5Lknqk8KnmMeCFltMRi6WmpqKt577z0UFxejd+/eWL16NYYMGWK1/A8//IDExEScOXMGXbp0wcsvv8wtSEpaOfPQ1hAdeSGpoaFPSGPCHesvB+vzV3Xjwp496ltfuBP6OXdeGwqG1RIJRBLbPRTVkvbbQ0FBrxk5E+yUdTqXvrbW0/ZfCu51DTou7AHGwCfUusddtxEhz/wcH089dz1+4FN66KD0MH4eWjvdxY6EQfM6mgdCFj8YWguDQPsNhBkZGVi8eDFSU1MxePBgbNq0CWPHjsXZs2fRrVs3i/IXLlzAuHHjMHv2bGzfvh3/+c9/MH/+fHTu3BmPPfZYM7wD0iiuCHathaMhj1++sWFP3chuYHOOBsM2FAjbKwp6TaghLXYsNpi5KvCx13Ek8JmHPWfYCnmVtV5WQ5U5rUEi2LrHBr6GcDYQ2gqD/OA3TnOK+/+2EPo0Go3Jz1KpFFKB8X0ffPABZs6ciVmzZgEAVq9ejW+++QYbNmwQ3Bty48aN6NatG1avXg0ACA8Px8mTJ7Fq1SoKeq1BUwU7V7bkAY1vzXM25AHOhzxXh7rG4AdCCn2tUqtZhyElJQUDBw6Ej48P/P39MXHiRBQUFNg85/DhwxCJRBaP3377rUnqnF67zeThClpPqcOtcY5Q1ukaHB7Nx+hZPG8l5FXWetlsEQNMg5dSrDcJedp6qUlLng9qTB5BHuUI8ijnWv74Dz72urYe5nViH+bvx5pxmlMmj5ai0kvm0AMAgoODoVaruYdQaNPr9cjNzUVcXJzJ8bi4OGRnZwvWIScnx6L86NGjcfLkSdTWOvYFoLVqjfczAMZwxz6aSkc3dns6qyEhryFc0bXsDgn9TB+kVWg1LXo//PADFixYgIEDB6Kurg7Lli1DXFwczp49C4VCYfPcgoICk4HHnTt3dmtdXRXqbOGHPVe08inrdA0OkELdp45yplWPDWo+sH8T9KnXwQeW4wod+WrDfz9s2OO3/vEDrL3AyqfwqjXp/v2XPMrhc5uT+QxNoda80tJSGAwGBAQEmBwPCAhASUmJ4HVLSkoEy9fV1aG0tBRBQUEuqH3L1JruZy2iS5YNe65u3XNEU4U7vuZo0XMmULN/DtTa1yq0mqB34MABk5/T0tLg7++P3NxcDB061Oa5/v7+6NChg0Ovo9PpoNPdDk7m3VbWNEW4s0brKXVZ2GOv5y6OBCPz1jzAMuSxk0McwS8rGP5g2jqp9NBZnVzSkJDnyJi/lhz6nJmhaT5LjmEYmzPnhMoLHW9rWvr9DEDLCHjmmjrwtcWQ54oWUvNr3Khu1tBX4SWFwcvOclFe7XcyRqvpujVXXl4OAPD1tbcIB9C/f38EBQVh1KhR+P77722WTUlJMemmsre4qCu7ZRvD1d251jg6EUOo29aZ1i/AesgzKWPQOfVg2QqKbMjTGiR235OrPFF90uTR2vj5+UEsFlu03l27ds2i1Y4VGBgoWN7T0xOdOnVyW11bopZyP2uWrtmG6Ch3b5fuX9XNE/Jcif2MzB9N8Vr836OW/rtkQ2pqKsLCwiCTyRAZGYmjR4/aLK/T6bBs2TKEhIRAKpXirrvuwieffGJSZufOnejVqxekUil69eqF3bt3u/MtAGilQY9hGCQmJuL+++9HRESE1XJBQUHYvHkzdu7ciV27dqFHjx4YNWoUjhw5YvWcpKQklJeXc4+ioiLBci0l4PG5evyeKzkb8mxxpjWPjz+hhB9Y+UvE8EMeX2NCXkPee2sLfRKJBJGRkcjKyjI5npWVhdjYWMFzYmJiLMofPHgQUVFR8PJy3e9LS9cS7met9h9kdwQYVwc8dy6tIsTdIbghWmHoY1cRWLZsGfLy8jBkyBCMHTsWhYWFVs+ZPHkyvvvuO2zZsgUFBQXYsWMHevbsyT2fk5OD+Ph4JCQk4NSpU0hISMDkyZNx4sQJt74XEcP2lbQiCxYswP79+3Hs2DGnt0d5+OGHIRKJsHfvXofKazQaqNVqlJeXQ6VStbhwZ40runL5oZENSWxAsrV+nnkoshd0+F2b5uvnCbXm8YMev5VO8D0IzBa2FvK4c5wIefz3xn8f5u/Z0XGIQvhd2Z94CYcm899Ta9hyqaWbIFfZ/segWlON+X5z7V6TlZGRgYSEBGzcuBExMTHYvHkzPv74Y5w5cwYhISFISkrC5cuXsXXrVgDG5VUiIiIwd+5czJ49Gzk5OZg3bx527NjRrmbdNuf9rDX9w+sUW127tiY6uKMVrylm3La0YOeotTmCh529n/3z2jp427mfVWmqMct/ocP3s0GDBmHAgAHYsGEDdyw8PBwTJ04UnJB24MABTJkyBX/++afVlvn4+HhoNBp8/fXX3LExY8agY8eO2LFjh906NVSrGaPHev7557F3714cOXKkQXvgRUdHY/v27U6f91ntF5DXtp6/TK4Yt+fMBA2h9fMA17bkAY0LeUIBr7GsBbjGBDvA+nIvz9aazmC1FvyaQ3x8PMrKyrBy5UoUFxcjIiICmZmZCAkJAQAUFxebfBsOCwtDZmYmlixZgvXr16NLly5Yu3Ztuwp5zXU/w8ujAEmru/07ztZYPrVMOOy1xpDXWgMey/yLhpXg50qOLBfFriKwdOlSk+O2VhHYu3cvoqKi8O6772Lbtm1QKBR45JFH8MYbb0AuN/455eTkYMmSJSbnjR49mltiyl1azd90hmHw/PPPY/fu3Th8+DDCwuxt2iUsLy+vTc/m47MX9hS1t2927FIajdXQGamAY615jnIm5DW0Nc/VHF3cmY8NfqthvcuvKc2fPx/z588XfC49Pd3i2LBhw/Dzzz+7uVYtD93Pmoijkzeshby/qmyf5+tt5XgDApgzIa8pAp6KVx9X7w9sDRv83vzGqdOqxFIwYtufX7XYOBnDfJzq8uXLkZycbHKsIasI/Pnnnzh27BhkMhl2796N0tJSzJ8/H3/99Rc3Ts/aSgPWrukqrSboLViwAJ9//jn27NkDHx8f7oNRq9VcWjbvGlq9ejVCQ0PRu3dv6PV6bN++HTt37sTOnTub7X00NWthjx/y+D87EvjMuzuFumxd3ZIHWI7N04qlFq16jnbVcuXtbN3mbg0Jd6T1o/tZE+sotx72hEKevYDHL2ct7NnTXF20qga8rtA5TRX+XMyR5aJYzqwiUF9fD5FIhM8++wxqtRqAcRH5xx9/HOvXr+f+Xju7MoErtJqgx/aTDx8+3OR4Wloapk+fDsCya0iv1+Oll17C5cuXIZfL0bt3b+zfvx/jxo1z+vUVdTp413m02MkOQhrSdWse+Pjdt/zA5GjI0+pMA59SatqlyXZxNrQ1z96OHY6GPGt8PPUuadWjQEf4mvt+1qY4GkL4Yc9q962DAc8W89a8xiyX0tBg15Aw1xSv0QLCoSPLRTVkFYGgoCDccccdXMgDjGP6GIbBpUuX0L17d6srDVi7pqu0mqDnyJwR866hl19+GS+//LJL68EPTy019LliIoaitsZu6555yLMV8PjHzcOeIxoy09bmUjBmIc9Wa55QSGPfc3MFOKHt4JyhFUtgsBOSq8WGRr0Gsa6l3M9aPWthw/w4GzBstuzdCnk3bdxrOti55/NDnrWA58pu16YIdK7kSH1bQBjkryIwadIk7nhWVhYmTJggeM7gwYPxr3/9C1qtFkqlEgDw3//+Fx4eHtz4W3alAf44vYMHD1pdmcBVWk3Qa4maYoFhZzgS8My7bAHAR2d5XoVUahL2lAYdKjykqIDMuAwJL+SxAc9auDNnLey5YmweV38bCyI3ZicPVlMHvMYGO0LaFGcDDlteU2Ma9thu27+qbAc8a/jdtmzI4wc8a6FOJbsdaNj/59eRX2dXa6kTOBqxCHa1WAJGbLvnpUZc59Q1ExMTkZCQgKioKG4VgcLCQsybNw+A5dCKqVOn4o033sCMGTOwYsUKlJaW4m9/+xueffZZrtv2hRdewNChQ/HOO+9gwoQJ2LNnD7799lscO3asAe/acRT0XKAltPLZC3mOBjz+c2zYAyzfl1DA01bbDnpKuXBLnqtDk62QZ41SrG+WMXpCW6zxjxNCzNgLQEJBhg0R/IDF4oe8MrOu2042xt+xIU+oFY+tg3ld+XUz/39+HZ3RUoMbACh592KtnSDdwt6Hs6sIKJVKZGVl4fnnn0dUVBQ6deqEyZMn48033+TKxMbG4osvvsCrr76K1157DXfddRcyMjIwaNAgt74XCnou1hytfM6GPPOAp6y23XLG78LV1ktRrFOistYLWp0XtNVeqLAT8HxuBTxttZfVsMfVxc66ebYIddU6s4yKtdDVWI6ENgp2hNjRkIBn/tyN6tvXYcfo3dRZBjwhbLettYAnFO7YY0oH/j1wJhS5miP1a6rXaI79jK1wdhWBnj17WiwCb+7xxx/H448/7orqOYyCnps0VStfY0IeP+Apqy3/cimrq6GVy6GQ3t5xQ2swtuSdL1ZDW2kMeJWVnlAoLJvFlQpjqKuo9uLCnkndeGvNNTboNDbk8VHoIqSFcKR1Syjg2QoV/AkZ1pZVYVvyrIU7ay135sFO7UTQA24HPDXvPZW3nODjMLWTrXOt8T22IhT0moA7WvkaMh7PXshTVAq37LGrdBV7qVBRJ8H5YjX+OO8DH40YAKBVGaAt94RSfTvsKRR1XBBUKmq5sGfeqsfvtm3o2Dxbky6IMK2HFHV2PrcaD5qMQZqQK7os+YHKXtgQajnq5G0Md77exlBnr6WO/5pmoa7Sx/izVnG7bLW35d85eRXvvlx5u06KimrT6zd1K5+rKaXW3wP/z6roZpNUpz2hoNeEzMNZQ4Nfo3e8sBHyfMzCnk9lDSoUNdDKZfCp1+Gq1hvXcjug3ynjX8yS0FutdmZhr7LS+KvFBj62dc/VrIU8W615Sg+dSyZkEEKc1NgJBta6Z4UCHu8YG7oU7LHLN43/Zbtvo7oAoR2B2DBcvdv41ZYNZdaCGEsoyGnlxvdZKXPgPtMRUNToLF6TvS73mj7y2+HPnoaEwubuvm1EkK0QSVErsvPFVdR+v7i2uqCXmpqK9957D8XFxejduzdWr16NIUOGWC3/ww8/IDExEWfOnEGXLl3w8ssvc7Nmmpujwa8x6+GxhCZeCIU8ZXml8UnegGXlrecq7pVCKa2Fd89K/B6sQ/9tvigJvXV9jZgLewBMAh/brWutC7ehXaWNacljWw9beuBj68lq6fUlzmlL9zMA7pkp6ki4A+y2qFV7S3G9cwcAgDzQFwF3/AVEh+LX3mF4q8sYHP8j0Hi6vBbesjr4+1QhQFYJf08tvFGLgLoKKAy37pW11u/JFV6m9ao027GBvQb/OpXSW/+9FQwVcuPPyuoaVHtLubBpEf4EKCqqmya0OYj9c7DGouWSuJzTQW/69Ol49tlnMXToUHfUx6aMjAwsXrwYqampGDx4MDZt2oSxY8fi7Nmz6Natm0X5CxcuYNy4cZg9eza2b9+O//znP5g/fz46d+7cIvfTdMX6d86yGvLKq4Gbtx4AlKcuY+yvl9B9ZAn+NWAg1v4cZXKdCpXptyXzwOfKVj1XdtWaBymWI4HK2rnuxH9NCn2NR/czJzTFmm32Zl5aC3e85/gBj9/CVimTolIqxVWFCpViGarEEvzzYn9odwUi4H9eYJesrVLV41pHA87cUQutqg4B/jr4d6rhwp/SqxYKmR4KsfF+phA5fh/wRi3g6QMf5lawu/UlV+FVA59aHaokUnjrdaiUSqHQ6VApk0JRo4NWLrM7aQ4wBkB7waql4ddXUVHd4mbftgVOB72KigrExcUhODgYM2bMwLRp03DHHXe4o24WPvjgA8ycOROzZs0CYNwS6JtvvsGGDRuQkpJiUX7jxo3o1q0bt2FweHg4Tp48iVWrVrXIoNcimIe8P8qMA5ZvDVoOjOgKn+4647i7jsa9A81DHos/Zq8xnA12DZ2EwdccIc5Z/FbJl+uPNnNtWie6nwloykV4HflH3Va44z3vaMC74OmLCzpfHMq/A2FbO0Nh9nLeGg94azwQ8D8vVKnqAShR0dGA68p6nAjWwVthgI+iDt7eBq71DwAU5rv+SIw/K29NOlOwoU5ciyqRlzH0ie2/fUeYt/g1FVsti3y26iV4jY/o32dXcjro7dy5E2VlZdi+fTvS09OxfPlyPPDAA5g5cyYmTJgALy/X73EKGLf/yc3NxdKlS02Ox8XFITs7W/CcnJwcxMXFmRwbPXo0tmzZgtraWsG66nQ66HjdnBqNxgW1b1pCa+Y57WY1cKPqdsj7bxlwTycoyyuhNOi4LthKB8Ocu8boEWPg+8vJc7SQotZOINah7Y9pofsZT0tosWMJdeMJtN4Bwl20/IBXJZGiwkuK6xIVroqU+EUbgB9/80fY1s7WX/6GB7zLRbidxIyfbZVaDm3HelSp6rnwp1UboFXVwVth/PtiHgKvwRgCAxTGsKcQ6eCNWvgwOngb9ILdwd56yy+abOsecHsMINvKZz7Jgz+u0J1cESzNr2EevB1RDU/Uw/bfVV3rG6nmMh4NOalTp0544YUXkJeXhx9//BF33303EhIS0KVLFyxZsgTnz593dT1RWloKg8FgsSdcQECAxd5xrJKSEsHydXV1KC0tFTwnJSUFarWaewQHB7vmDbRW7HICnW7dTNXGv4ZKeS0qO1gPAkKteT7yWrvr6BHS1Oh+doumxr3bTzUm5JkTGLjPbxlSVtdAUaODQqczCU2VjPHa3t4GXA0Rvhcpb9z+Z1H5lwiBv3sg8HcP3HlSjIjvPNH3Wy9E75IiZrcc9+33RvR+JfpmKxFwUgnVb964ek2KqqrbTXX+PlW4U3UT/pJKhHreQACjxZ266+is1yCwphwBlRoEVGrgrTfWtXOFBgqdjnuw2JDHf49tEo3Vc7lGRdzi4mIcPHgQBw8ehFgsxrhx43DmzBn06tUL7777rsl+bq4iEolMfmYYxuKYvfJCx1lJSUlITEzkftZoNO0z7HXg3ZTv9jU+AFQobn/rr+hQb/cyQuvr2cN2vTZkCzRXdNu2RopW0NXMd+PGDSxatAh79+4FADzyyCP46KOP0KFDB6vn7Nq1C5s2bUJubi7KysqQl5eHfv36uaxOdD9jC9n4e9eYVj+h5UyEwp95iGP/4bey1ppCqzMJB8rK6tuTFqprcLWjGgHQwKdWB2+ZHp2VWgTcU4k/AzWoSr7HanWr1MbPVuvLQPmX6eer9WWg9WVQpWZwLaTO2Lp3Ry0Ud1eiT6cadFZXI0BRBX9JJTqLtPBhdOisv1UH/e0AZx7eHCEU8NzdgseGaK1CbhKohVr0zLtim7o7mVhyOujV1tZi7969SEtLw8GDB9G3b18sWbIETz31FHx8fAAAX3zxBZ577jmX3hj9/PwgFostvu1eu3bN4lsuKzAwULC8p6cnOnXqJHiOVCqFVNq6v1FUeskc7r6tVMgs18/jd5F0kANht/4/xBd/BAeh2EvFPa0ov/0rZG2snj1ag8S4BVm91GRsnDOBr70GvNZq6tSpuHTpEg4cOAAAmDNnDhISErBv3z6r51RWVmLw4MF44oknMHv2bJfUg+5nTrIWAhsaAK3tgsAPgELLbiilgsGPH/rYwBeAcq6rs7NMgzulUtwrkQISoOSD03hrzQQE/M/Y7Xc1pBZXQyxfzueGsYWuoqPxHletrEfJrfF6AZ118O9YjQjeLN0ARmsMdpW3WuhqdFxAsxXKhNbZE2LrGo6Om2sI82s78lpO10ctB0q1zp1DbHI66AUFBaG+vh5PPvkkfvzxR8Fv1KNHj7b5zbwhJBIJIiMjkZWVhUmTJnHHs7KyMGHCBMFzYmJiLP7hOHjwIKKiotw29qa1YlvqlPyD/MCnkiG/79042vlufFJwL/4474NA/vm8kMd227Kteebj85RS69235mEPoBDX3MzHdTU2PJw7dw4HDhzA8ePHuT0eP/74Y8TExKCgoAA9evQQPC8hIQEAcPHixQa/tjm6n7mIuwOgecsfG/7MW/vUckCrMxnnpayshvxWq1Jn3jFFRTWg1WHWHV/h10d74lBoL/yJTrimV0Bb64VKvelnyp9coRAbZ90qRDoEMFp4G/QIrCmHt0YH/3INlNU1kFfpbr+OHew4Q35rpCMcDVEOr7/nJtw6ho7WQ9G6G1taGqeD3ocffognnngCMpn1v8AdO3bEhQsXGlUxIYmJiUhISEBUVBRiYmKwefNmFBYWcutIJSUl4fLly9i6dSsAYN68eVi3bh0SExMxe/Zs5OTkYMuWLdixY4fL69bSmLfqVUil3Fp67FR9rVwOZXU116rH75aF+vatskIhQ6VCht87B6C4Xo0g3ypou3ihBLfXzwNgsTMGn9D6eQBQUSeBj6eea9UDbi8b0hpmvrZWlfVS1NpZnkVfb/wzNO/qW758OZKTkxv82jk5OVCr1SYbeUdHR0OtViM7O9tq0HMHup+5mVAAbEj4Y4OfI4HvVtgDbg/sNwkYWp2xXNFN4H83gPIaROw/i4iOXwMhHYE7OqAyqAOud+7AtQSa47fOmYQ59tr8upmcKDyD2Lz72RnNHeJMWOl2d3cdKxkp6hjbn5+Occ0qEK2R00GP/VbdHOLj41FWVoaVK1eiuLgYERERyMzMREiIsa29uLgYhYWFXPmwsDBkZmZiyZIlWL9+Pbp06YK1a9fS0ioCBMPereNauRxauQxaT2NrW4CyClo/47p42kovMLxdMPjYljw25PEnYrD73PK3QDMn1LpHml5RURFUqtvd9Y3tCiwpKYG/v7/FcX9/f6sTEdyF7mfNgB/+nA19N6yss8YPSvwuXTb4mR/X6m4tJVVjXFXg9zKTyyl8vY0h0XwbtIZi36e1+guE0wZpaduktbT6OMnZBc1Z//nPfzBs2DBEREQgPz+fO56eno4ZM2ZYlK+urrb5ZbOxWt184/nz52P+/PmCz6Wnp1scGzZsGH7++Wc316plstWqx9LK2UHLxpY9c2zIK1GqoRVL4YMaBEm1QGfgqtYbWrkXKhTC3Ub8Vjw25NnqthXCXxSYQl/zUKlUJkHPmuTkZKxYscJmmZ9++gmA8OQBexMR2qJ2fz9jQ58zgc9e6x4fO5aP/xx7vnn38E0dUFZl/P8/bhj/28nbtEwH3pccX7PngNurFADGgGhOJTOtPxtQzbqeubpb42iAsjKBpcmZr33YUuplg7MLmrPKy8vxzDPPYNSoUbh69arF8yqVCgUFBSbH3BnygFYY9IhrmK/DxAY+oXIVZi04Sg8dgm4dUkq9oJQbg562+nbgE1pGhQ15jrTmCdal3rIepOVYuHAhpkyZYrNMaGgoTp8+LXgDvH79utWJCKSNc2Xg4xMKePzXs4cNfkJu6iyD362F5eErv72Prlp2uyVPU2PZumfeGsmGoqYOc44EzIZqQcHO0THHzi5ozpo7dy6mTp0KsViML7/80uJ5kUiEwMBAyxPdiIJeO2Peqscfg3I79MlMyld63QqFhlvneRgfQVJA6ylBhZcElbVeDrXWWQt5Ddnvllr7jN7CaGigwQfNXA8/Pz/4+fnZLRcTE4Py8nL8+OOPuO+++wAAJ06cQHl5OWJjY91dTdKSNSbwOXP9G9W3gxhfJ2/b4a6syrSVjx/2/qq63cr3V7Vp6x77mrbCHmDZumfOkcDU2O7S5u5ufTET0GiAJWqHT6kyeKHOYHtCkv7W846MOW7IguYAkJaWhj/++APbt2/Hm2++KVhGq9UiJCQEBoMB/fr1wxtvvIH+/fvbrHtjUdBr44SWWhHqwgVgMfCY35Kn9TT9xuODmgYut+2akGeuPYa+tzC6wedqDRJIDBKbZfQG9yxuHR4ejjFjxmD27NnYtGkTAOPyKuPHjzeZiNGzZ0+kpKRws1L/+usvFBYW4sqVKwDAdX8EBgY2+Tdk4maNGcdn75rWgmEHqTG4WQt75t24Qvhhj1VeY9mNKxT2AOtjDW1paDBzdF3DhnKkxZXvxUzXvbYNjow5bsiC5ufPn8fSpUtx9OhReHoKR6uePXsiPT0dffr0gUajwZo1azB48GCcOnUK3bt3b8S7so2CXjvFD3HmoY//HNuax+dTr+P2n21sqHJFyDPX1kNfYwJeS/HZZ59h0aJF3JZejzzyCNatW2dSpqCgAOXl5dzPe/fuNRnIzHYTN3YWMGnhGtLKJ3S+Lb7expDGD3vNxd4MXEeCnTOtnK44rzHXfPN717+mDY6OOQYcX9DcYDBg6tSpWLFiBe65x/oi3NHR0YiOjuZ+Hjx4MAYMGICPPvoIa9eudfAdOI+CXivEb11T1tn/S29vAWXzMXj888xfj88HNaiAzCRMae20Erkj2NnSlkJfWwh4LF9fX2zfvt1mGXbXB9b06dMxffp0N9aKtGgNCXzmIY8NHULdtiw27NnTQeC+KDRBw/z12RYua616gHOtdO4IZ65ia3mdJg54znB2QfOKigqcPHkSeXl5WLhwIQCgvr4eDMPA09MTBw8exMiRIy3O8/DwwMCBA92yzSIfBb1WRChwscfsBT42tDmyY4ZQKx4AaMWWr88Pe9p6aZMHOWe01vX52lLAI6RJCAUMe4GIbdUDboc4ocAnFPBcwdrSK7bKO8rZPYxVMvfte9yCAx7L2QXNVSoVfvnlF5NjqampOHToEP79738jLCzM4hzA+GU2Pz8fffr0ce0bMENBz0ET5dNwEP/XbK9vrVWN/7yjrXuAcOATCnj2XpePDXstXWsIfBTuiFu9+x3wahv8HbMWThwNRfywBzgX6uy15rmKo++lMUHN1SFvbY5rr2emyuCFWju9SbUG5xohnFnQ3MPDAxERESbn+/v7QyaTmRxfsWIFoqOj0b17d2g0Gqxduxb5+flYv369U3VzVqsIehcvXsQbb7yBQ4cOoaSkBF26dMHTTz+NZcuWQSKx/oc7ffp0fPrppybHBg0ahOPHj7u7yi7laNhyNOwB1lvtrL0uvzWPHZ8nRCjsNSRQNUVgbEnduk0d7LR1XvCqs3NjrGu5rbOtWXu/n7mFM8HEvNvWV357WRTAMuw5wl7IE5qQAZh23wK2W/UcCXjuaoVzlpuDXVNwdkFzR9y8eRNz5sxBSUkJ1Go1+vfvjyNHjnCrD7hLqwh6v/32G+rr67Fp0ybcfffd+PXXXzF79mxUVlZi1apVNs8dM2YM0tLSuJ9t3UhbImda1NjyjoY9R1/T0ZDHckXLHhu8GnId/nZqDp/TxKGPWuzarxZzP1ubAyyKafj5LYW9cNOQMWwNCXuOstdFa/58awh4bSDYCXF2QXO+5ORki0liH374IT788EMX1c5xrSLojRkzBmPGjOF+vvPOO1FQUIANGzbYvTFKpVKnll7Q6XTQ8Wah8hdXfFw+C/+u/qcTNW8cZ0Oe+XkNCXy2Qp4zXBWWnA2N7GQQ/qSQhoQ+V4c9CnaE1VLuZ61WU4UaR8OeO7psm6J7tjHaaLBrq1pF0BNSXl4OX19fu+UOHz4Mf39/dOjQAcOGDcM//vEPwX02WSkpKXa3cWoKDQ155tdwNOwJTvQwC3lCrXkVcO/WLa7gbOhzRcijYEec0dbvZy7RkAkC5oHJ2mxb8+5b7rgLQxy/+9ba7FtnNGXIa+HBTlvrBa9a2wsm19p5vi0TMeZrGLQCf/zxBwYMGID333+f255ESEZGBpRKJUJCQnDhwgW89tprqKurQ25urtWN2YW+AQcHB6O8vJxbe8fdrXquCHksW0HP1uvYC3lNHfAa0qpni7XA52zIY+u11mO4U+e5mkajgVqtNvk9tVVuQsn38FIpbV6zVqPFnsARdq9JGqe572etpvuWDUPOBBxHgx4gHPQay3x3DP44PX73bEsLes0c7Jy9n425fMSh+9mBO4a2y/tZs7boOboJelRUFPfzlStXMGbMGDzxxBM2b4qAcTAlKyIiAlFRUQgJCcH+/fvx6KOPCp5jbd87PnbGqiMTGpqbUKue3Rm8LSzkAa6d0WurVc98Rq611+SCXQN3B2lulfQN2OVa6/2sVXBFyAOMQctWqx7gnsDHstWqBzge+FrZrFjSvJo16Dm6CTrrypUrGDFiBDfV2VlBQUEICQlp9OKEY1ULrT7nitY+Npi5qmXP4Vm7AuPxHJl80VQcDXtKsd5qq56j4/XMX6e5W+xIy9da72c2/5FvztY+V2191tJYC3uAe7Z+E0LBrl1p1qDn6CboAHD58mWMGDECkZGRSEtLg4eH800pZWVlKCoqQlBQkNPnOupxue1v5YDjYZDfEufK7lxz1iZcWAt57CLJLZlQ2HNmUgYFO+Kstng/cygQuCsMCo1dc3Scnq3JDLZa9QDr4/WcYd5la4u1WbiN3fqNpZK1ikWKifu0iskYV65cwfDhw9GtWzesWrUK169f557jz0Djb4Ku1WqRnJyMxx57DEFBQbh48SJeeeUV+Pn5max03RwaEgaVdTq3hL2GzqptrrDnTBcuP+zZC3kU7EhTaWv3M7eGwYaEHVdsCdbQsOdIwBNaT49fZ/PQ5+xkjXYY7Kr0XvDU2x5qUmfn+basVQS9gwcP4vfff8fvv/+Orl27mjzHn0vC3wRdLBbjl19+wdatW3Hz5k0EBQVhxIgRyMjIgI+PT5PWvyEcCYPptdsafP2GBjy+pgh7rhiXJxTyKNiR5tIe72eNDoNs2HHV2DR7rXqA82HPXsgTCniOMg+85sGvnQU74pxWOeu2KZWXl6NDhw4oKipq1TN1Pqv9gvt/rdixRVa1DozP06LxQazSjbtgsC16qV6D3PYaLQE7m/LmzZtQq9U2y6nVasT8cQKePrZnqdVVaJFz16B2OUutrWor9zO8PMr28zccCISOhkZ71+roQIBzpEXOkev43Crz2n77ZVsxZ+9nQy/kwNPOrNs6jRZHwmLa5f2sVbToNaeKigoAQHBwcDPXhDTGZ81dgSZSUVFh88ZI2je6n7URq9rH33G6n7kGBT07unTpgqKiIvj4+EAkEjV3dVoE9ttWq28VcLHm/FwYhkFFRQW6dOnSpK/bUDdu3MCiRYuwd+9eAMAjjzyCjz76CB06dBAsX1tbi1dffRWZmZn4888/oVar8cADD+Dtt99uNe+5JaD7mSW6nwmj+1nbQUHPDg8PD4txNMRIpVLRjVFAc30uremb79SpU3Hp0iUcOHAAADBnzhwkJCRg3759guWrqqrw888/47XXXsO9996LGzduYPHixXjkkUdw8uTJpqx6q0b3M+vofiasNdzPKvVe8NTRZAxrWulyr4SQpqLRaEwe/J0WGuLcuXM4cOAA/vnPfyImJgYxMTH4+OOP8dVXX6GgoEDwHLVajaysLEyePBk9evRAdHQ0PvroI+Tm5qKwsLBR9SGEECGpqakICwuDTCZDZGQkjh49arXssWPHMHjwYHTq1AlyuRw9e/bEhx9+aFFu586d6NWrF6RSKXr16oXdu3e78y0AoKBHSLtUWe0FrZ1HZbXxG3BwcDDUajX3SElJadRr5+TkQK1WY9Cg2xNkoqOjoVarkZ2d7fB1ysvLIRKJrHb3EkJIQ2VkZGDx4sVYtmwZ8vLyMGTIEIwdO9bqF0uFQoGFCxfiyJEjOHfuHF599VW8+uqrJouh5+TkID4+HgkJCTh16hQSEhIwefJknDhxwq3vhbpuidOkUimWL1/eNrZWcqG2+rmYj9Fp7PsrKSmBv7+/xXF/f3+UlJQ4dI2amhosXboUU6dOpe420iht9e9tY7XVz0Wj0Zj8bG2bwA8++AAzZ87ktiZcvXo1vvnmG2zYsEHwy27//v3Rv39/7ufQ0FDs2rULR48exZw5c7hrPPjgg0hKSgIAJCUl4YcffsDq1auxY8cOl71Hc9SiR5wmlUqRnJzc5m4AjdVWPxd2jA77sPb+kpOTIRKJbD7Y8XRCEwEYhnFogkBtbS2mTJmC+vp6pKamNu7NkXavrf69bazW9LlU14hRVeNp81FdIwbgWA+FXq9Hbm4u4uLiTI7HxcU53OuQl5eH7OxsDBs2jDuWk5Njcc3Ro0c71ZPRENSiRwhxCUf3ej19+jSuXr1q8dz169cREBBg8/za2lpMnjwZFy5cwKFDh6g1jxDiFEd6KEpLS2EwGCzuRwEBAXZ7Hbp27Yrr16+jrq4OycnJXIsgYOzNaMg1G4uCHiHEJRzd6zUmxrho6Y8//oj77rsPAHDixAmUl5cjNjbW6nlsyDt//jy+//57dOrUyWV1J4S0D87MIjbvYXCk1+Ho0aPQarU4fvw4li5dirvvvhtPPvlko67ZWBT0CGmHtDWe8PC0vdxAfY17bg/h4eEYM2YMZs+ejU2bNgEwLq8yfvx49OjRgyvH3+u1rq4Ojz/+OH7++Wd89dVXMBgM3LdgX19fSCSO7fZCCCH2+Pn5QSwWW7S0Xbt2zW6vQ1hYGACgT58+uHr1KpKTk7mgFxgY2KBrNhaN0SOENLnPPvsMffr0QVxcHOLi4tC3b19s22a6dzN/r9dLly5h7969uHTpEvr164egoCDu4e7xLYSQ9kUikSAyMhJZWVkmx7Oysmz2OphjGMZkOaqYmBiLax48eNCpazYEtegRQpqcr68vtm/fbrMMfxvu0NBQ0LbchBAhlTVeDvRQOLdgcmJiIhISEhAVFYWYmBhs3rwZhYWFmDdvHgDjjNnLly9j69atAID169ejW7du6NmzJwDjunqrVq3C888/z13zhRdewNChQ/HOO+9gwoQJ2LNnD7799lscO3bMqbo5i1r0iNOcWUSyLTpy5AgefvhhdOnSBSKRCF9++aXJ8wzDIDk5GV26dIFcLsfw4cNx5syZ5qksIcQmup/R/UxIfHw8Vq9ejZUrV6Jfv344cuQIMjMzERISAgAoLi42WVOvvr4eSUlJ6NevH6KiovDRRx/h7bffxsqVK7kysbGx+OKLL5CWloa+ffsiPT0dGRkZJmuKugMFPeIUZxeRbIsqKytx7733Yt26dYLPv/vuu/jggw+wbt06/PTTTwgMDMSDDz7IbShPCGkZ6H5G9zNb5s+fj4sXL0Kn0yE3NxdDhw7lnktPT8fhw4e5n59//nn8+uuvqKysRHl5OX7++Wc899xz8PAwjVmPP/44fvvtN+j1epw7dw6PPvqo29+HiKH+EOKEQYMGYcCAAdiwYQN3LDw8HBMnTmz0jgmtkUgkwu7duzFx4kQAxm+/Xbp0weLFi/H3v/8dAKDT6RAQEIB33nkHc+fObcbaGhcLVavV8P/hHDyUPjbL1msrcG1YOMrLy2kZE9Im0f3MVGu9n4Wc+NWh+9n/BkW0y/sZtegRh7liEcm27sKFCygpKTH5jKRSKYYNG0afESEtCN3P7Gst97OqKrFDj/aKgh5xWGMWkWwv2M+BPiNCWja6n9lH97O2gYIecVpzLPjY2tBnREjrQH9X7aPPqHWjoEcc1phFJNuLwMBAAKDPiJAWju5n9tH9rG2goEcc5qpFJNuysLAwBAYGmnxGer0eP/zwQ4v6jKqqPFFZaftRVUXLbJK2i+5n9rWW+xmxje7kxCn2FpFsD7RaLX7//Xfu5wsXLiA/Px++vr7o1q0bFi9ejLfeegvdu3dH9+7d8dZbb8Hb2xtTp05txloTQszR/axt3M+0VZ4QiWzHGaYdf3Ftv++cNEh8fDzKysqwcuVKFBcXIyIiwmQRyfbg5MmTGDFiBPdzYmIiAGDatGlIT0/Hyy+/jOrqasyfPx83btzAoEGDcPDgQfj42J7+TwhpWnQ/o/tZe0Dr6BHSjrDrTim/Pg+RwvaNmqmsgHZs93a57hQhpOVj72fy/Y7dz6ofap/3MxqjRwghhBDSRlHXLSHtkFbjCVEdjWkhhLR+1VViAHYWRKYFkwkhhBBCCCs1NRVhYWGQyWSIjIzE0aNHrZYtLi7G1KlT0aNHD3h4eGDx4sUWZdLT0yESiSweNTU1bnwXFPQIIc3gxo0bSEhIgFqthlqtRkJCAm7evGnznOTkZPTs2RMKhQIdO3bEAw88gBMnTjRNhQkh7UpGRgYWL16MZcuWIS8vD0OGDMHYsWNRWFgoWF6n06Fz585YtmwZ7r33XqvXValUKC4uNnnIZDJ3vQ0AFPQIIc1g6tSpyM/Px4EDB3DgwAHk5+cjISHB5jn33HMP1q1bh19++QXHjh1DaGgo4uLicP369SaqNSGkvfjggw8wc+ZMzJo1C+Hh4Vi9ejWCg4OxYcMGwfKhoaFYs2YNnnnmGajVaqvXFYlECAwMNHm4Gw3CIYTYpNFoTH6WSqWQSqUNvt65c+dw4MABHD9+HIMGDQIAfPzxx4iJiUFBQQF69OgheJ75ul0ffPABtmzZgtOnT2PUqFENrg8hpP1w5H6m1+uRm5uLpUuXmhyPi4tDdnZ2o15fq9UiJCQEBoMB/fr1wxtvvIH+/fs36pr2UIseIe2Qj8YDPhqxnYfx9hAcHMx1sarVaqSkpDTqtXNycqBWq7mQBwDR0dFQq9UO30T1ej02b94MtVpts5uEENL2KTRiKDWeNh8KjXEyhiP3s9LSUhgMBott3gICAiy2g3NGz549kZ6ejr1792LHjh2QyWQYPHgwzp8/3+BrOoJa9AghNhUVFZmsO9WY1jzAuG+mv7+/xXF/f3+7N9GvvvoKU6ZMQVVVFYKCgpCVlQU/P79G1YcQ0n44cz8TiUQmPzMMY3HMGdHR0YiOjuZ+Hjx4MAYMGICPPvoIa9eubfB17aEWPUKITSqVyuRh7caYnJwsOKOM/zh58iQAyxso4NhNdMSIEcjPz0d2djbGjBmDyZMn49q1a41/k4SQdsGR+5mfnx/EYrHFF89r165ZtPI1hoeHBwYOHEgteoSQ1mHhwoWYMmWKzTKhoaE4ffo0rl69avHc9evX7d5EFQoF7r77btx9992Ijo5G9+7dsWXLFiQlJTWq7oQQwpJIJIiMjERWVhYmTZrEHc/KysKECRNc9joMwyA/Px99+vRx2TWFUIseaRLXr19HYGAg3nrrLe7YiRMnIJFIcPDgwWasGXEVPz8/9OzZ0+ZDJpMhJiYG5eXl+PHHH7lzT5w4gfLycsTGxjr1mgzDQKfTufqtEGIT3c9aFoVGDGW57Qc7Rs9RiYmJ+Oc//4lPPvkE586dw5IlS1BYWIh58+YBAJKSkvDMM8+YnJOfn4/8/HxotVpcv34d+fn5OHv2LPf8ihUr8M033+DPP/9Efn4+Zs6cifz8fO6a7kIteqRJdO7cGZ988gkmTpyIuLg49OzZE08//TTmz5+PuLi45q5eu+Ot8YRHre2//vXVnqhww2uHh4djzJgxmD17NjZt2gQAmDNnDsaPH28y47Znz55ISUnBpEmTUFlZiX/84x945JFHEBQUhLKyMqSmpuLSpUt44okn3FBLQqyj+1nbFx8fj7KyMqxcuRLFxcWIiIhAZmYmQkJCABgXSDZfU48/ezY3Nxeff/45QkJCcPHiRQDAzZs3MWfOHJSUlECtVqN///44cuQI7rvvPre+FxHDMIxbX4EQngULFuDbb7/FwIEDcerUKfz0009uXyyS3MZuAh7w/mV4yG1v7F1frcHVF+9wyybgf/31FxYtWoS9e/cCAB555BGsW7cOHTp04MqIRCKkpaVh+vTpqKmpwdSpU3HixAmUlpaiU6dOGDhwIF599VUMHDjQpXUjxFF0P2te7P3M/8NLDt3Pri3p6pb7WUtHQY80qerqakRERKCoqAgnT55E3759m7tK7UpLCXqEtAV0P2teFPQcQ2P0SJP6888/ceXKFdTX1+N///tfc1eHEEIajO5npDWgMXqkyej1ejz11FOIj49Hz549MXPmTPzyyy8una5OCCFNge5nLYe80gMeBtvtVvU17bddi4IeaTLLli1DeXk51q5dC6VSia+//hozZ87EV1991dxVa3eU5R4Q62zf+Aw1HrBcBIUQAtD9jLQe7TfikiZ1+PBhrF69Gtu2bYNKpYKHhwe2bduGY8eOWd0kmhBCWiK6n5HWhFr0SJMYPnw4amtrTY5169YNN2/ebJ4KEUJIA9H9jLQm1KJHCCGEENJGUYseIYQQQlot5U0xxFLbO18YdM7tjNGWUNAjpB1SlIshrqEbIyGEtHXUdUsIIYQQ0kZR0COEEEIIaaOo65YQQgghrZa8wgOedtYFrdO333at9vvOCSGEEEKsSE1NRVhYGGQyGSIjI3H06FGb5X/44QdERkZCJpPhzjvvxMaNGy3K7Ny5E7169YJUKkWvXr2we/dud1WfQ0GPkHZIedMDPjdsP5Q36fZACGmfMjIysHjxYixbtgx5eXkYMmQIxo4di8LCQsHyFy5cwLhx4zBkyBDk5eXhlVdewaJFi7Bz506uTE5ODuLj45GQkIBTp04hISEBkydPxokTJ9z6XkQMwzBufQVCSIuh0WigVqsRO60UnhKVzbJ1eg2yP/VDeXk5VCrbZQkhpKmx97Ooudcdup+d3NTZ4fvZoEGDMGDAAJOdTsLDwzFx4kSkpKRYlP/73/+OvXv34ty5c9yxefPm4dSpU8jJyQEAxMfHQ6PR4Ouvv+bKjBkzBh07dsSOHTvs1qmh6Cs7IaTJ3bhxAwkJCVCr1VCr1UhISHBqV4G5c+dCJBJh9erVbqsjIaTt0Wg0Jg+dTmdRRq/XIzc3F3FxcSbH4+LikJ2dLXjdnJwci/KjR4/GyZMnuV1UrJWxdk1XoaBHCGlyU6dORX5+Pg4cOIADBw4gPz8fCQkJDp375Zdf4sSJE+jSpYuba0kIaQ2UNzwcegBAcHAw9wVTrVYLts6VlpbCYDAgICDA5HhAQABKSkoE61BSUiJYvq6uDqWlpTbLWLumq9CsW0KITRqNxuRnqVQKqVTa4OudO3cOBw4cwPHjxzFo0CAAwMcff4yYmBgUFBSgR48eVs+9fPkyFi5ciG+++QYPPfRQg+tACGmfioqKTLpubd3LRCKRyc8Mw1gcs1fe/Liz13QFatEjpB1S3BBB+Zfth+KG8ebjyDdgZ+Tk5ECtVnMhDwCio6OhVqttdmHU19cjISEBf/vb39C7d+9G1YEQ0j6pVCqTh1DQ8/Pzg1gstmhpu3btmkWLHCswMFCwvKenJzp16mSzjLVrugoFPUKITUVFRSgvL+ceSUlJjbpeSUkJ/P39LY77+/vb7MJ455134OnpiUWLFjXq9QkhxBaJRILIyEhkZWWZHM/KykJsbKzgOTExMRblDx48iKioKHh5edksY+2arkJdt4QQm9hvvvYkJydjxYoVNsv89NNPACy7LwDbXRi5ublYs2YNfv75Z7d3cxBCWhe5RgQvL9v3hdpa5+4biYmJSEhIQFRUFGJiYrB582YUFhZi3rx5AICkpCRcvnwZW7duBWCcYbtu3TokJiZi9uzZyMnJwZYtW0xm077wwgsYOnQo3nnnHUyYMAF79uzBt99+i2PHjjn5jp1DQY8Q4hILFy7ElClTbJYJDQ3F6dOncfXqVYvnrl+/brUL4+jRo7h27Rq6devGHTMYDHjxxRexevVqXLx4sVF1J4QQvvj4eJSVlWHlypUoLi5GREQEMjMzERISAgAoLi42WVMvLCwMmZmZWLJkCdavX48uXbpg7dq1eOyxx7gysbGx+OKLL/Dqq6/itddew1133YWMjAyTYSzuQOvoEdKOsOtOPfhIGby8bLfS1dZqkLW3k8vX0Tt37hx69eqFEydO4L777gMAnDhxAtHR0fjtt98EJ2OUlZWhuLjY5Njo0aORkJCAGTNm2JzAQQhpm9j72dgxfzl0P/v6gG+7XBeUWvQIaYeUNzzg5Wl7iG5tnXuG8IaHh2PMmDGYPXs2Nm3aBACYM2cOxo8fbxLYevbsiZSUFEyaNAmdOnXiBjSzvLy8EBgYSCGPEEJsoMkYhJAm99lnn6FPnz6Ii4tDXFwc+vbti23btpmUKSgoQHl5eTPVkBBC2gZq0SOENDlfX19s377dZhl7o0poXB4hBACUN0Tw8rQzGaOu/U7iohY9QgghhJA2ioIeIYQQQkgbRV23hLRDihsiSMS2uzL0hvbb1UEIIW0FBT1CCCGEtFr0xdU26rolhBBCCGmjKOgRQgghhLRRFPQIIYQQQtooGqNHSDuk+EsEqYftMSu6+vY7poUQQtoKCnqEEEIIabXk5fa/uIrb8RdX6rolhBBCCGmgGzduICEhAWq1Gmq1GgkJCbh586bNc3bt2oXRo0fDz88PIpEI+fn5FmWGDx8OkUhk8pgyZYrT9aOgRwghhBDSQFOnTkV+fj4OHDiAAwcOID8/HwkJCTbPqaysxODBg/H222/bLDd79mwUFxdzj02bNjldP+q6JYQQQki7oNFoTH6WSqWQSqUNvt65c+dw4MABHD9+HIMGDQIAfPzxx4iJiUFBQQF69OgheB4bBO3t2e3t7Y3AwMAG1w+gFj1C2iXlX4CyzM7jr+auJSGE2OfM/Sw4OJjrYlWr1UhJSWnUa+fk5ECtVnMhDwCio6OhVquRnZ3dqGsDwGeffQY/Pz/07t0bL730EioqKpy+BgU9QkiTa8iYlunTp1uMV4mOjm6aChNC2oSioiKUl5dzj6SkpEZdr6SkBP7+/hbH/f39UVJS0qhrP/XUU9ixYwcOHz6M1157DTt37sSjjz7q9HWo65YQ0uSmTp2KS5cu4cCBAwCAOXPmICEhAfv27bN53pgxY5CWlsb9LJFI3FpPQkjbolKpoFKp7JZLTk7GihUrbJb56aefAAAikeWMXoZhBI87Y/bs2dz/R0REoHv37oiKisLPP/+MAQMGOHwdCnqEkCbV0DEtgHE8TWPHqxBCiD0LFy60O8M1NDQUp0+fxtWrVy2eu379OgICAlxapwEDBsDLywvnz5+noEcIsU0HDcA4UAauH7xsb0yLraB3+PBh+Pv7o0OHDhg2bBj+8Y9/CHabEELaD2fuZ47y8/ODn5+f3XIxMTEoLy/Hjz/+iPvuuw8AcOLECZSXlyM2Ntap17TnzJkzqK2tRVBQkFPnUdAjpB2RSCQIDAzEupJgh8orlUoEB5uWXb58OZKTkxtch4aOaRk7diyeeOIJhISE4MKFC3jttdcwcuRI5ObmNip4EkJaJ/Z+ttbB+1lgYKDLh3uEh4djzJgxmD17Nrf0yZw5czB+/HiTL609e/ZESkoKJk2aBAD466+/UFhYiCtXrgAACgoKuDoGBgbijz/+wGeffYZx48bBz88PZ8+exYsvvoj+/ftj8ODBTtWRgh4h7YhMJsOFCxeg1+sdKi80zsRaqHL3mJb4+Hju/yMiIhAVFYWQkBDs37+/QQOUCSGtm7P3M4lEAplM5vJ6fPbZZ1i0aBHi4uIAAI888gjWrVtnUqagoADl5eXcz3v37sWMGTO4n9luYvaLtEQiwXfffYc1a9ZAq9UiODgYDz30EJYvXw6xWOxU/UQMw9hp8CSEEPtKS0tRWlpqs0xoaCg+//xzJCYmWsyy7dChAz788EOTm5893bt3x6xZs/D3v/+9IVUmhJA2j1r0CCEu0dRjWsrKylBUVOT0eBVCCGlPaB09QkiT4o9pOX78OI4fP47Zs2cLjmnZvXs3AECr1eKll15CTk4OLl68iMOHD+Phhx+Gn58fN+aFEEKIJQp6hJAm99lnn6FPnz6Ii4tDXFwc+vbti23btpmU4Y9pEYvF+OWXXzBhwgTcc889mDZtGu655x7k5OTAx8enOd4CIYS0CjRGjxBCCCGkjaIWPUIIIYSQNoqCHiGEEEJIG0VBjxBCCCGkjaKgRwghhBDSRlHQI4QQQghpoyjoEUIIIYS0URT0CCGEEELaKAp6hBBCCCFtFAU9QgghhJA2ioIeIYQQQkgbRUGPEEIIIaSNoqBHCCGEENJGUdAjhBBCCGmjKOgRQgghhLRRFPQIIYQQQtooCnqEEEIIIW0UBT1CCCGEkDaKgh4hhBBCSBvl2dwVIIQ0rZqaGuj1eofKSiQSyGQyN9eIEEKIu1CLHiHtSE1NDcLkcqjVaoceYWFhqKmpcfj6qampCAsLg0wmQ2RkJI4ePWq17OHDhyESiSwev/32myveKiGEEFCLHiHtil6vRwmAIi8PqOyU1QAILimBXq93qFUvIyMDixcvRmpqKgYPHoxNmzZh7NixOHv2LLp162b1vIKCAqhUt2vTuXNnx94MIYQQu0QMwzDNXQlCSNPQaDRQq9Uo9/KASiSyXZZhoK6tR3l5uUkQs2bQoEEYMGAANmzYwB0LDw/HxIkTkZKSYlH+8OHDGDFiBG7cuIEOHTo4/V4IIYTYR123hBCbNBqNyUOn01mU0ev1yM3NRVxcnMnxuLg4ZGdn27x+//79ERQUhFGjRuH77793ad0JIaS9o6BHSHuklgEd7DzUxu7a4OBgk3F7Qq1zpaWlMBgMCAgIMDkeEBCAkpISwSoEBQVh8+bN2LlzJ3bt2oUePXpg1KhROHLkiOvfLyGEtFM0Ro8QYlNRUZFJ161UKrVaVmTWHcwwjMUxVo8ePdCjRw/u55iYGBQVFWHVqlUYOnRoI2tNCCEEoBY9QogdKpXK5CEU9Pz8/CAWiy1a765du2bRymdLdHQ0zp8/3+g6E0IIMaKgRwhpNIlEgsjISGRlZZkcz8rKQmxsrMPXycvLQ1BQkKurRwgh7RZ13RLSHvnKALGd73mGeqC0yuFLJiYmIiEhAVFRUYiJicHmzZtRWFiIefPmAQCSkpJw+fJlbN26FQCwevVqhIaGonfv3tDr9di+fTt27tyJnTt3NvhtEUIIMUVBjxDiEvHx8SgrK8PKlStRXFyMiIgIZGZmIiQkBABQXFyMwsJCrrxer8dLL72Ey5cvQy6Xo3fv3ti/fz/GjRvXXG+BEELaHFpHj5B2hFtH7x5fqOy06GkM9VD/9y+H19EjhBDS8tAYPUIIIYSQNoq6bglpj1QywNPO97y6+qapCyGEELehFj1CCCGEkDaKgh4hhBBCSBtFQY8QQgghpI2ioEcIIYQQ0kbRZAxC2iM1TcYghJD2gFr0CCGEEELaKAp6hBBCCCFtFAU9QgghhJA2isboEdIeqaSAl9h2mVpD09SFEEKI21CLHiHEZVJTUxEWFgaZTIbIyEgcPXrUofP+85//wNPTE/369XNvBQkhpJ2hoEcIcYmMjAwsXrwYy5YtQ15eHoYMGYKxY8eisLDQ5nnl5eV45plnMGrUqCaqKSGEtB8ihmGY5q4EIaRpaDQaqNVqlE8Kh8pO162m1gD17nMoKiqCSqXijkulUkilUovygwYNwoABA7BhwwbuWHh4OCZOnIiUlBSrrzNlyhR0794dYrEYX375JfLz851/Y4QQQgRRix4h7ZFKCqjtPFTGMBccHAy1Ws09hEKbXq9Hbm4u4uLiTI7HxcUhOzvbajXS0tLwxx9/YPny5a59f4QQQgDQZAxCiB1CLXrmSktLYTAYEBAQYHI8ICAAJSUlgtc9f/48li5diqNHj8LTk25FhBDiDnR3JYTYpFKpTIKeLSKRyORnhmEsjgGAwWDA1KlTsWLFCtxzzz0uqSchhBBLFPQIIY3m5+cHsVhs0Xp37do1i1Y+AKioqMDJkyeRl5eHhQsXAgDq6+vBMAw8PT1x8OBBjBw5sknqTgghbRkFPULaow5yQGrnr7+uzuHLSSQSREZGIisrC5MmTeKOZ2VlYcKECRblVSoVfvnlF5NjqampOHToEP79738jLCzM4dcmhBBiHQU9QohLJCYmIiEhAVFRUYiJicHmzZtRWFiIefPmAQCSkpJw+fJlbN26FR4eHoiIiDA539/fHzKZzOI4IYSQhqOgRwhxifj4eJSVlWHlypUoLi5GREQEMjMzERISAgAoLi62u6YeIYQQ16J19AhpR7h19F6IgcpO161GVwf1mhyUl5c7PBmDEEJIy0Lr6BFCCCGEtFHUdUtIe+QjBWR2/vrX2N45gxBCSMtHLXqEEEIIIW0UBT1CCCGEkDaKgh4hhBBCSBtFY/QIaY98pIDMy3YZr9qmqQshhBC3oRY9QgghhJA2ioIeIYQQQkgbRUGPEEIIIaSNojF6hLRHCikgtzNGT0zfAwkhpLWjOzkhxGVSU1MRFhYGmUyGyMhIHD161GrZY8eOYfDgwejUqRPkcjl69uyJDz/8sAlrSwghbR+16BFCXCIjIwOLFy9GamoqBg8ejE2bNmHs2LE4e/YsunXrZlFeoVBg4cKF6Nu3LxQKBY4dO4a5c+dCoVBgzpw5zfAOCCGk7RExDMM0dyUIIU1Do9FArVajfN0jUNnputVU10K9cC/Ky8uhUqnsXnvQoEEYMGAANmzYwB0LDw/HxIkTkZKS4lD9Hn30USgUCmzbts2h8oQQQmyjrltCiE0ajcbkodPpLMro9Xrk5uYiLi7O5HhcXByys7Mdep28vDxkZ2dj2LBhLqk3IYQQCnqEtE8qGaCW236oZACA4OBgqNVq7iHUOldaWgqDwYCAgACT4wEBASgpKbFZla5du0IqlSIqKgoLFizArFmzXPc+CSGknaMxeoQQm4qKiky6bqVSqdWyIpHI5GeGYSyOmTt69Ci0Wi2OHz+OpUuX4u6778aTTz7ZuEoTQggBQEGPEGKHSqWyO0bPz88PYrHYovXu2rVrFq185sLCwgAAffr0wdWrV5GcnExBjxBCXIS6bgkhjSaRSBAZGYmsrCyT41lZWYiNjXX4OgzDCI4BJIQQ0jDUokdIO1TvLUW9QmK7DGx3uZpLTExEQkICoqKiEBMTg82bN6OwsBDz5s0DACQlJeHy5cvYunUrAGD9+vXo1q0bevbsCcC4rt6qVavw/PPPN+AdEUIIEUJBjxDiEvHx8SgrK8PKlStRXFyMiIgIZGZmIiQkBABQXFyMwsJCrnx9fT2SkpJw4cIFeHp64q677sLbb7+NuXPnNtdbIISQNofW0SOkHWHX0bvx7wSo7LToaSr16Pj4NofX0SOEENLy0Bg9QgghhJA2irpuCWmHqhQyeNpp0aui74GEENLq0Z2cEEIIIaSNoqBHCCGEENJGUdAjhBBCCGmjKOi1YRcvXoRIJEJ6enqTXT87OxvJycm4efOmW16zqb311lv48ssvm7saLlclk6BSLrX5qJLZHsNHCCGk5aOgRxosKCgIOTk5eOihh7hj2dnZWLFiBQU9QgghpAWgWbekwaRSKaKjo5u7Gm1aVVUVvL29m7sahBBCWilq0XOhL7/8EiKRCN99953Fcxs2bIBIJMLp06cFzz116hREIhG2bNli8dzXX38NkUiEvXv3csfOnz+PqVOnwt/fH1KpFOHh4Vi/fr1D9Tx27BhGjRoFHx8feHt7IzY2Fvv377cod/nyZcyZMwfBwcGQSCTo0qULHn/8cVy9ehWAZddtcnIy/va3vwEwblQvEokgEolw+PBhzJw5E76+vqiqqrJ4nZEjR6J37952633gwAGMGjUKarUa3t7eCA8PR0pKikmZvXv3IiYmBt7e3vDx8cGDDz6InJwckzLJyckQiUQ4c+YMnnzySajVagQEBODZZ59FeXk5V04kEqGyshKffvop916GDx/OPf/rr79iwoQJ6NixI2QyGfr164dPP/3U5LXS09MhEolw8eJFk+OHDx/mPhvW8OHDERERgSNHjiA2Nhbe3t549tln7X4uhBBCiDUU9Fxo/Pjx8Pf3R1pamsVz6enpGDBgAPr27St47r333ov+/ftbPdff3x/jxo0DAJw9exYDBw7Er7/+ivfffx9fffUVHnroISxatAgrVqywWccffvgBI0eORHl5ObZs2YIdO3bAx8cHDz/8MDIyMrhyly9fxsCBA7F7924kJibi66+/xurVq427Kty4IXjtWbNmcfuU7tq1Czk5OcjJycGAAQPwwgsv4MaNG/j8889Nzjl79iy+//57LFiwwGa9t2zZgnHjxqG+vh4bN27Evn37sGjRIly6dIkr8/nnn2PChAlQqVTYsWMHtmzZghs3bmD48OE4duyYxTUfe+wx3HPPPdi5cyeWLl2Kzz//HEuWLOGez8nJgVwux7hx47j3kpqaCgAoKChAbGwszpw5g7Vr12LXrl3o1asXpk+fjnfffdfme7GluLgYTz/9NKZOnYrMzEzMnz+/wdcihBBCwBCXSkxMZORyOXPz5k3u2NmzZxkAzEcffWTz3LVr1zIAmIKCAu7YX3/9xUilUubFF1/kjo0ePZrp2rUrU15ebnL+woULGZlMxvz1118MwzDMhQsXGABMWloaVyY6Oprx9/dnKioquGN1dXVMREQE07VrV6a+vp5hGIZ59tlnGS8vL+bs2bNW6yt0/ffee48BwFy4cMGi/LBhw5h+/fqZHHvuuecYlUplUh9zFRUVjEqlYu6//36ufuYMBgPTpUsXpk+fPozBYDA519/fn4mNjeWOLV++nAHAvPvuuybXmD9/PiOTyUxeQ6FQMNOmTbN4vSlTpjBSqZQpLCw0OT527FjG29ub+/NPS0sT/Dy+//57BgDz/fffc8eGDRvGAGC+++47q59FY5WXlzMAmNMnEpkLZ5JsPk6fSGQAWPye2bJ+/XomNDSUkUqlzIABA5gjR45YLbtz507mgQceYPz8/BgfHx8mOjqaOXDggCveJiGEkFuoRc/Fnn32WVRXV5u0jqWlpUEqlWLq1Kk2z33qqacglUpNZrHu2LEDOp0OM2bMAADU1NTgu+++w6RJk+Dt7Y26ujruMW7cONTU1OD48eOC16+srMSJEyfw+OOPQ6lUcsfFYjESEhJw6dIlFBQUADB2F48YMQLh4eEN/SgsvPDCC8jPz8d//vMfAMZ9V7dt24Zp06aZ1MdcdnY2NBoN5s+fD5FIJFimoKAAV65cQUJCAjw8bv9aK5VKPPbYYzh+/LhFt/Ejjzxi8nPfvn1RU1ODa9eu2X0vhw4dwqhRoxAcHGxyfPr06aiqqrLoLnZUx44dMXLkyAad29wyMjKwePFiLFu2DHl5eRgyZAjGjh2LwsJCwfJHjhzBgw8+iMzMTOTm5mLEiBF4+OGHkZeX18Q1J4SQtouCnov17t0bAwcO5LpgDQYDtm/fjgkTJsDX19fmub6+vnjkkUewdetWGAwGAMZu2/vuu48bw1ZWVoa6ujp89NFH8PLyMnmwXbulpaWC179x4wYYhkFQUJDFc126dOGuDwDXr19H165dG/AJWDdhwgSEhoZyYwnT09NRWVlpt9v2+vXrAGCzPmy9rb23+vp6iy7nTp06mfwslUoBANXV1XbeifH1HPkcnSV0zdbigw8+wMyZMzFr1iyEh4dj9erVCA4OxoYNGwTLr169Gi+//DIGDhyI7t2746233kL37t2xb9++Jq45IYS0XTTr1g1mzJiB+fPn49y5c/jzzz9RXFzMtcg5cu6//vUvZGVloVu3bvjpp59M/qHs2LEj1wJnLSCFhYUJHu/YsSM8PDxQXFxs8dyVK1cAAH5+fgCAzp07m4x/cwUPDw8sWLAAr7zyCt5//32kpqZi1KhR6NGjh83zOnfuDAA268OGNmvvzcPDAx07dmxE7S1fz5HPUSaTAQB0Op1JOWth3FqLZXPSaDQmP0ulUi4Us/R6PXJzc7F06VKT43FxccjOznboderr61FRUWH3CxEhhBDHUYueGzz55JOQyWRIT09Heno67rjjDsTFxTl0blxcHO644w6kpaUhLS0NMpkMTz75JPe8t7c3RowYgby8PPTt2xdRUVEWD/OWKpZCocCgQYOwa9cuk1ar+vp6bN++HV27dsU999wDABg7diy+//57rivXUfZaxWbNmgWJRIKnnnoKBQUFWLhwod1rxsbGQq1WY+PGjWAYRrBMjx49cMcdd+Dzzz83KVNZWYmdO3dyM3GdJZVKBd/LqFGjcOjQIS7YsbZu3Qpvb29u2ZnQ0FAAsJhtzZ9B3RwqZVJo5TKbj0qZ8c8yODgYarWae5jPdAaMwdVgMCAgIMDkeEBAAEpKShyq0/vvv4/KykpMnjy58W+QEEIIAGrRc4sOHTpg0qRJSE9Px82bN/HSSy+ZjBuzRSwW45lnnsEHH3wAlUqFRx99FGq12qTMmjVrcP/992PIkCF47rnnEBoaioqKCvz+++/Yt28fDh06ZPX6KSkpePDBBzFixAi89NJLkEgkSE1Nxa+//oodO3ZwLUorV67E119/jaFDh+KVV15Bnz59cPPmTRw4cACJiYno2bOn4PX79OnD1XHatGnw8vJCjx494OPjw302zzzzDDZs2ICQkBA8/PDDdj8TpVKJ999/H7NmzcIDDzyA2bNnIyAgAL///jtOnTqFdevWwcPDA++++y6eeuopjB8/HnPnzoVOp8N7772Hmzdv4u2333bo8xd6P4cPH8a+ffsQFBQEHx8f9OjRA8uXL8dXX32FESNG4PXXX4evry8+++wz7N+/H++++y73ZzZw4ED06NEDL730Eurq6tCxY0fs3r1bcBZwS1VUVASVSsX9bN6ax2feIskwjEOtlDt27EBycjL27NkDf3//hleWEEKICWrRc5MZM2bg2rVr0Ov1mD59utPn6nQ6XL9+XbDLt1evXvj5558RERGBV199FXFxcZg5cyb+/e9/Y9SoUTavPWzYMBw6dAgKhQLTp0/HlClTUF5ejr179yI+Pp4rd8cdd+DHH3/E+PHj8fbbb2PMmDF4/vnnUV5ebrNrbfjw4UhKSsK+fftw//33Y+DAgcjNzTUpw77Oc88953AAnjlzJjIzM2EwGDBr1iyMHz8eq1evRrdu3bgyU6dOxZdffomysjLEx8djxowZUKlU+P7773H//fc79Drm1qxZg+7du2PKlCkYOHAg5s6dC8DYgpidnY0ePXpgwYIFmDhxIn799VekpaVxawkCxuC+b98+9OzZE/PmzcMzzzwDqVSKdevWNag+zUGlUpk8hIKen58fxGKxRevdtWvXLFr5zGVkZGDmzJn4v//7PzzwwAMurTshhLR3IsZaXxghbvLiiy9iw4YNKCoqstrNTNxDo9FArVYj51QSlD4ym2W1FTWIuTcF5eXlJi161gwaNAiRkZHcWoOA8UvJhAkTBLt7AWNL3rPPPosdO3Zg4sSJTr0XQggh9lHXLWkyx48fx3//+1+kpqZi7ty5FPKaUZVMCpHMehcsAFTVOvcdMDExEQkJCYiKikJMTAw2b96MwsJCzJs3DwCQlJSEy5cvY+vWrQCMIe+ZZ57BmjVrEB0dzbUGyuVyi+EKhBBCGoaCHmky7ISI8ePH480332zu6hAXi4+PR1lZGVauXIni4mJEREQgMzMTISEhAIwzovlr6m3atAl1dXVYsGCByQzyadOmmawlSQghpOGo65aQdoTtuv2uIBkKO123lRU1GNUj2eGuW0IIIS0PTcYghBBCCGmjqOuWkHaoWiKBh0Rip0x9E9WGEEKIu1DQs6O+vh5XrlyBj49Pi9y1gBDAuF5dRUUFunTp4vCSNYQQQto+Cnp2XLlyxWLjekJaqqKiIpfvUUwIIaT1oqBnB7ujg/nuAG3Rq4zpjhpKUW2Dr6VlvBpbHafrsRSjXfaarY1Go0FwcDD3+0oIIYQAFPTsYrtr2V0BWpqV2O+ya/nBC96MnnfEE1Ui2+O4zFUwxvK2V2gDqm6V8xbpbT4PALUCZXwEjm1mvnOojvJb73GBR7ydkq0PDS8ghBDCR0GvBWlMaDMNaK5j7bpCAbCCsR0Kq+w8z/IR6eEj0qOCkaDq1sMhVjKO+XuoFkkgZ/RYX59h95IKg/Hc6V4JjtWhlajykgASOwsme9FkDEIIae0o6DUjV7bGVYkkjQ57coHzq6206Hkzeouwx4Yzi7rZCGpVjMRqq5554AOAaoOxS7gaXpCLTbt0rV7LiUYu88+gUiyBwqBHeu022+cZbp8XL5vp+AsSQgghbkRBrwn9jcky+dnHRb1s7gh41p7jBz+hsMdyuBXODm9GD2/oAZExzFaIjKGv2uDFhT6T+jkYACsgEez+FSS2PKQwWD+XHwrbWksgIYSQ1qXVBL2UlBTs2rULv/32G+RyOWJjY/HOO++gR48eVs85fPgwRowYYXH83Llz6NmzpzuryzEPd3wVjBNh4xZXddHaCnf2zrPWymev67axvBlj4PMR6VFxqw5s6KsSCH0mBMKaowFQsLVUfDvsyQ16KGt1AACtl2l3aHrtNlSKb38ubXFcICGEkJar1QS9H374AQsWLMDAgQNRV1eHZcuWIS4uDmfPnoVCobB5bkFBgclEis6dO7u1rrbCnbmGhL3GcibksWGGH1b4Yc9Wq56jbHXfOsKiBc/ghYpaL/h41Zoc8xYLzN4VCIDmfER6k7AnZ/SCIY+P/bzY8YCs9fUZ3Gf3kmiS/Rd3E62XFPVeNEaPEELaulYT9A4cOGDyc1paGvz9/ZGbm4uhQ4faPNff3x8dOnRw6HV0Oh10utv/cGs0Gofr6EzA43Mm7DV2LJ61kGerK5J9nh/2mht/PKBQF66PVy0qak2Pm4c/wEoAvBX++OHTVshT6I2/L5VWJjeUeShNrsFaxezmQvLreEj4jbYyqampeO+991BcXIzevXtj9erVGDJkiGDZ4uJivPjii8jNzcX58+exaNEirF69umkrTAghbVyrCXrmysvLAQC+vr52y/bv3x81NTXo1asXXn31VcHuXFZKSgpWrFjhcD0W1P8AwPoyIY5yd8uerVY8eyGPX44Ne7a6cF3J0WDL77o1D3jVei+T/5dLhNfl4wc+9s/TR6S3CHnsxAt+yLOngpGgAhLumubYiTlseH1P9KBD121JMjIysHjxYqSmpmLw4MHYtGkTxo4di7Nnz6Jbt24W5XU6HTp37oxly5bhww8/bIYaE0JI2ydiGIZp7ko4i2EYTJgwATdu3MDRo0etlisoKMCRI0cQGRkJnU6Hbdu2YePGjTh8+LDVVkChFr3g4GCUl5ebdP+yAQ9ofMjjczTsOdOq54qQx8dv2WPDXpVIYjJGryGTMfifo/nnINRFzM7GZcfo8QMeP9wBQJXeE96SOpNjbOBjW/nYoCcX18L71oxfeyFPrr9dz2qJBJUSKbReUlSLJagUS1Atkph8NvzPxZHfmypGgvUew+yW02g0UKvVFr+n1sp9cvUjeKvktl9bU41nA563WCxcKpVCKrVsvRw0aBAGDBiADRs2cMfCw8MxceJEpKSk2Hyt4cOHo1+/ftSiRwghLtYqW/QWLlyI06dP49ixYzbL9ejRw2SyRkxMDIqKirBq1SqrQc/aP2IsfsADXBvyANe27Nkbi2ce8uQOhL7qW8uN2OrGtRbyhLpYzcfXWb2mE62HbMir0pv+erM/s4GPbd0T6tI1x/+szEOeokaHSpm9JaJ59eMtEcOy9Tnwf+ccCX2OqBFLILLTFV8jNgCAxRaAy5cvR3JysskxvV6P3NxcLF261OR4XFwcsrOzG19hQgghDdLqgt7zzz+PvXv34siRIw3a0zM6Ohrbt293+rwX649BUm866cPVIc8ZjR2r15CQx5ZzJOzxCQU8/nNsyHFmUoa1Gb7WQh6fUOseYH3CBhuYzcfkAcaQx/+vBXayh8iyzvzuZvb/BSeM8DxruB2aqgxe+EI20GZ5VxBq0TNXWloKg8GAgIAAk+MBAQEoKSlxex0JIYQIazVBj2EYPP/889i9ezcOHz6MsLCwBl0nLy8PQUFBja5Pc4Y8dxOaRcrSekm5sAeYjtWztmCyPfywx7LXsunIa1XVWP56e8uMAY8Ne7bG7Nki1+uhqNFBWV0DANDKZU5fA7AcT8j+bK+FkTWl5icAwGZYX2aosZzZ/s98CzaGYWhbNkIIaUatJugtWLAAn3/+Ofbs2QMfHx+ulUCtVkMuN441SkpKwuXLl7F161YAwOrVqxEaGorevXtDr9dj+/bt2LlzJ3bu3NmourSUkNfQVj1brXnmIU+h15nMJlXW6riwB8Buq161QKsVH9uCxYa9xi61Athpzavx5MIenyPdt/wuW37IA2Dy/xbExj8ra2v+mY8nND8mFEQdDYJNxc/PD2Kx2KL17tq1axatfIQQQppOqwl67ADv4cOHmxxPS0vD9OnTARiXaygsLOSe0+v1eOmll3D58mXI5XL07t0b+/fvx7hx4xpcj5YS8hxhvoabPfyQZ9I9KTCz1HxhYMHXtxPy2OPWuisbM16Rbc3TVt9+XaW8lnvOW1bnVKsePwzzQ568yvKzqZZIuM+s2koQrqj1Mglz5uGU37Xc0FbHpiSRSBAZGYmsrCxMmnR7fcCsrCxMmDChGWtGCCHtW6sJeo5MDk5PTzf5+eWXX8bLL7/sphq1DK7Y49YcG1L4M0ptEt+uixBrS5+wrVJs2Gtoqx7b7WveDWpOW+1lEfYcwW8B5X8m5iGP/3Opyof7f2eXoREaP+hqlWIv1NtrjRU7V4/ExEQkJCQgKioKMTEx2Lx5MwoLCzFv3jwAli3uAJCfnw8A0Gq1uH79OvLz8yGRSNCrVy/n3hAhhBBBrSboEetshT1nW/VY/BmltlhrsWJb89iQJxTC+OPRbLXs2eIt0nOzfH28agW7QfnYFj4u8PEmZrD1sTYDlg3AyuoaLtQpqm9/PpXy262ccr3epMvb1nhCW13NrUl8fDzKysqwcuVKFBcXIyIiApmZmQgJCQFg2eIOGNe4ZOXm5uLzzz9HSEgILl682JRVJ4SQNqtt/AvTRFpyt60zYa/y1qxZIeYzSm2OPYOxC9faOD3zkGcewtjuSP74OPNWPVvdt0ITMuSSWstlVapu73Pm7W24fZzXqsfvHq02eMHb8/b6ecDtbm1+8OWHPP7PWrkM1RLLz0Ro9nFbCXms+fPnY/78+YLPmbe4A4611BNCCGm4tvWvTDtXxdt/tjH4kw2EWq7kch2U3lJc7aiGUqJDqcS4xRd/AWOWecjjr2XHHmMDVmNa9SDmLVFyq4Xu2g3LBYGrqsTw9jZw3bjsWD5HukvZVk55lY77PLwrbwfhKoXpzFuhEMwu7Gyt5VGoHi19fB4hhJCWi4JeC9TYRZOFWvecadXjU1Tr4F1ZA49KHVBeDQBQquXQ+quhlctQqvThXhO8xhnzQGNr8WK2jHmrnhD++6oSSUxa9bgZvPrb3bP8yRjceWZhzx65QW/SbcvVpdJ2aye/nmhhDVc1IglgZ+xgjcj9YwUJIYS4FwW9Fqopw161WCK4YLK86lbIu3ITKLgG3KgyPhHSEfBXAzC2WlXf2uLLfDsyfsiztqad0Bg5bysLKJu/H3ZbNO5zutWqJ9h9W337Z295HRf2nKGo0XGteVz4vaVeYXsWsvluIXKJcTyht6TOYscOQgghxFUo6LVg/PFnDQl9Ql25tiZnsEum8GeWelTqgOJy4FQxkFcMdJIDHb0BAP/z80OR1BdXoURZ3e1dQ/jdr+ZdlPzJEPxlTgDLLkqhkCdUd/5sX2+xcUszb0mdYLgEjKGPDXvm+OvT2eoC54c8RwktMdPWxugRQghpWTyauwLOSk1NRVhYGGQyGSIjI3H06FGb5X/44QdERkZCJpPhzjvvxMaNG5uopq5VwUhMHs6oEklMwlC1SMIt+cGOIePPnrWYSKDRAYU3gZu3uirvC8Gng4fgsLI7rkIJH5EeoV43TB7B0psIkFXBX1EFb0mdxVImbOCzFsZYPiK9zZAnZ4zP+4j08BbpIRfXcmHNW1YHpbwW3t4GeMtNX5/fwmeL4ta2Z3K9HsrqGq41D4CxK/vWw6NSZ9GVWy2WcK2dLGsTUwghhBB3cLo5Yfr06Xj22WcxdOhQd9THpoyMDCxevBipqakYPHgwNm3ahLFjx+Ls2bPo1q2bRfkLFy5g3LhxmD17NrZv347//Oc/mD9/Pjp37ozHHnusyevvSkJhz16rn3kLH7e+m2XDFnBrx6vOpeXwUN3qluwgw8V/z8b68BHGblXouSBmHsK8RRL4eOlxVXxroobEC4BxcgQb8myNkfMWWV7b6phC3n6yVYwE3uLa2xM87ARJcxW19ieE2GvNq5RJTZZWAazv98t21zZ1y16VSIJ6GqNHCCFtntP/ulRUVCAuLg7BwcGYMWMGpk2bhjvuuMMddbPwwQcfYObMmZg1axYA4xZn33zzDTZs2ICUlBSL8hs3bkS3bt2wevVqAEB4eDhOnjyJVatWtfqgJ8Q8/FkLfiZdnby9aiE2tvBViyVcN25hN3+EVuqAp/qhPjIE68NHWLymN4Rb2oBb3a8SAPAGlAAgN3bXsrNdZXXwltRBLjG2xHmLa9HJs9Ik5CkMeott2ix25ri1zZi3SI9qeHFr6nnL6rhg6S2vs2jJY7tv7S2ezI7PM2nNayCh1jxr4/Mc3f5sRk1ug+tDCCGk7XI66O3cuRNlZWXYvn070tPTsXz5cjzwwAOYOXMmJkyYAC8v93RJ6fV65ObmYunSpSbH4+LikJ2dLXhOTk4O4uLiTI6NHj0aW7ZsQW1trWBddToddLrbLTYajcYFtW8e9rp4fUR6k9DHTuCo9pRALjZO0riqUOFiQGdgOLDfN8JY7tZ12ckS7DWEulbZsFktvvVZK28HHTbcyCW1CJBVQS6uhbdIjwBoIa+/HfC4NezMtmWrlEhNAp83o0cFJMZ1+HiTMrjFkc3G5LFj9YBba+pZCVtCW8ABALS3jiuNdahSyFDtbX9rOEIIIaSpNKi/qFOnTnjhhRfwwgsvIC8vD5988gkSEhKgVCrx9NNPY/78+ejevbtLK1paWgqDwWCxQXpAQIDFRuqskpISwfJ1dXUoLS1FUFCQxTkpKSlYsWKF6yreggkFwQrcOiYC4AlUiSWAxPZi0RWMxFgewmEPMN1twserFrg1d8NbXGsa8BjTgGdtOzb+frLcMU/jDFy2+1ZoUoZQq54tQrORUV59O+TZUCmWtMilVQghhLQfjRoYVFxcjIMHD+LgwYMQi8UYN24czpw5g169euHdd9/FkiVLXFVPjkgkMvmZYRiLY/bKCx1nJSUlITExkftZo9EgODi4odVtMcyX9zBnPoaMv0RKqca4EPDo0D9NyrM7WHCs/zFwixrzA5/5ODw/vZYLd45swWY+aUR+a7kVtvuWex1et2xVlZgLe+YTNMzxQys7EcPR2bYWXcstjJbxQq2d3wkdQws1E0JIa+f0rNva2lrs3LkT48ePR0hICP71r39hyZIlKC4uxqeffoqDBw9i27ZtWLlypUsr6ufnB7FYbNF6d+3aNYtWO1ZgYKBgeU9PT3Tq1EnwHKlUCpVKZfJoyapurV9n72Gu2uBl8gCM4a7K4IWrNd64VumNolIfXLzqgzMFatR+3kXwGvx6VDASXIWSm+XLdun63Ap0AR5aBHhoESb6C71QglDmL3Sr/QvBur8QWlmGgEoN/LQV8NNUIOBGOQJulENZXWPycIbQWDaWvZDHH99o3ppoj9D2Z64ktG9wS9FeZ8UTQkhL5XSLXlBQEOrr6/Hkk0/ixx9/RL9+/SzKjB49Gh06dHBB9W6TSCSIjIxEVlYWJk2axB3PysrChAkTBM+JiYnBvn37TI4dPHgQUVFRDRpLaL6Ab1Oz1yrnCMH9VgX2pC3VyKCt9kJpmRS+VySQazxQEjsKtd/nopOkymr9zPenNV8ahT+xgt96x7bc8cMcu/1aY8a9mS+e7O1tsLr3LWAMh/xWR3Z8oMlEDIFu23qFFJVyKbRymcVz7J9bSw5orkCz4gkhpOVxOuh9+OGHeOKJJyCTWf6DxurYsSMuXLjQqIoJSUxMREJCAqKiohATE4PNmzejsLAQ8+bNA2Dsdr18+TK2bt0KAJg3bx7WrVuHxMREzJ49Gzk5OdiyZQt27Njh8rq5i7vCHWC6gC8/5FXpPaGt9kJVlRiVlWJIAVSr6lHarR6Y1h97Jlfg3thrCO1onKhia7syewEPALevLh8b8oRUyoSDX7WV5UL4kyy01V4W4U4prxWcdcsu52LSfSw021Ztuacuu4YeS2ix5LaGZsUTQkjL43TQS0hIcEc9HBIfH4+ysjKsXLkSxcXFiIiIQGZmJkJCQgAYxwwWFhZy5cPCwpCZmYklS5Zg/fr16NKlC9auXdui/xFxRbBjORLwAMuQx5+8oFAYoFUb4K31wMW+gFzjgdDfZDgFf1wLlyM0oMJk1qwQoZDHPWdlDJ5QKx6/taxaIuFm3VaLJdzCz87ir+MntJSJ/QvcnnEL3A6hcoMecvHtJWbYWcetsVXPfOa5VCqFVGr659NUs+IJIYQ4p9XtvzR//nzMnz9f8Ln09HSLY8OGDcPPP//sstd3R/dtU4Q77rVshDxz3t4GVFV7Qq8w4NodgLK8Hrg1UVmvMKC0zPiPvX9HYyuXj1et3Rm6LGfGvbEBjw1R/JAnxNbnqZTXmmzDBtxeyw8wzgL25u3GYbG0Ctt6p9VxIY/d57baWwpFjY4bo6cw6G/PBBZLnG7VsxY8bY09dFQ1I4HBzu+d/tZkDPPJSMuXL0dycrLJsaaaFU8IIcQ5rS7otQSuCHuuDHeA/YAHONd9yAYidtJCJQDtref0CgMUCuO2YmxYqtbfWqTY4MXtVCG0kDJXX4kEcr0elTJjOBIa28ZnHvK469xqzau+NfmDXTLGWutiVY2n1d04nHIr5LHBjx2fx98Vg21lNF/Ghg1wrWUbtKKiIpNJSeateXzunhVPCCHEORT0GqghYc/V4Q5wLOABwiHPWjcif+cKgDdDVWEc2+Z16xg71o3d2cLiNc22WGO7byslUij0OpOwBwh34/LH4/FDHttlK1j/W2vpWRyX3F4cmf9eWQ1tKeMvlMy25rF1qxJJUFUv4f6c2NeoqPVyWeD7QjYQGr0Guxp1FescmX3eVLPiCSGEOIeCXiOYhwl+8HNHqONzNOABjZsIwM5S5S9HwgY8a5MYrGHDj7JWZxL2AJgEPovzzJYr4XfZmo/N87k165erK69lr1rvJbj7hbUdMaziTb7gz7ZlW/O0XlKulVGoLlUGL5cEvi9kA52rtxu1hFnxhBBCLFHQcyF3hzvAuYDXWNa6OM3HttmbxFAtkgDiW2PWBFrh+IHPGn53LQCrrXl8cnGtRUsaG/bYJVf427BZe125TA+ltxRVChm8zZ5nW/MqZVJUSyRcSyPblczuisF2JVcbvBwKfLY+U1cEvGqDFwx2fpf0Tv6utcdZ8YQQ0tJR0GslmjLgAabdt0KBz7wlz1q3J7t/LmBsfWPDntygd3r3CGvlhZZV4Xffet/a+9ZaHW12O/NUyo2td4pqnckxbrKI5PYMYP5i0dw1GYlTgc/cfp9+gsdbivYwK54QQlobEcOOfiaCNBoN1Go1Zt3YD4lK0Sx1aEzIs9Vtyx+jx+825C8wDAiPaTNvCWODCn/vWgDcFmeA6aLJLPO9ZNkFivnMAx7bmsd227JBjw1XbHcpG/T4O3+Yv2+Wj1etSd19RHp0qtfCT69FQKWGW9RZWV1jssZftbcUVzuqUS2R4KpChWqxBKWeytufHS8w8rtxzevGr595HR0JeOzvaXl5uc3xdGy5p0oP2v191msq8ZlfnN1rEkIIabmoRc9B73vcjyTkNelrNnUrHovftQlYtt5Z6+70tjbT9VarXrVIAjmj5wIavyuXDXy2Wvn43bXOrJvHduHyW/b4QUoo5LHhtFRiDG0BuL2WnPkMYXaSCNuaxwbaal5rZpXo9m4hFbcm8rAtfOyfM1u/ilqvFt96RwghpHVoFUHv4sWLeOONN3Do0CGUlJSgS5cuePrpp7Fs2TJIbIztmj59Oj799FOTY4MGDcLx48fdXeVGa66Qx+JmqPIDH2/SAj/kCXWJWpuVzIY9AIKBzxH8kGfemmePUDeutZDH1g0wdstWSqTcTGHg9iQR/pp+XPlbgc+8W5nf2lh9a29hgDfuzguA7ZVmXKLa4Ik6O79jtYZWcXsghBBiQ6u4k//222+or6/Hpk2bcPfdd+PXX3/F7NmzUVlZiVWrVtk8d8yYMUhLS+N+thUMWwpXhTxHZ9vamu1pb0aqvSVJ2H1v+WP1+GEPMA189giFPGexYY/9f6GQJ2f03I4ebHcyu3hyqdLHbh25yRgwfgb8JVaqDF7GYOcBY7AjhBBC3KRVBL0xY8ZgzJgx3M933nknCgoKsGHDBrtBTyqVIjAw0OHX0ul00Oluj8Hib/+03mMYFtT/4ETNnddULXkN2YrLvKvWvFXMGeZhDzANcfzQ50w3rfnixLaYhzwWP+TxXVVYjlPjL9gMgFu0uYoxzrhlW+24YAdQuCOEENJkWkXQE1JeXg5fX1+75Q4fPgx/f3906NABw4YNwz/+8Q/4+/tbLZ+SkoIVK1a4sqoOc3XI47dc2dKQPV4dWVyY7b4VatUDbrfImQc+wH6447fmOdpty2evJY/PfHFm/iQQ/m4cVYwE1XW8YAdQqx0hhJBm1Spn3f7xxx8YMGAA3n//fcyaNctquYyMDCiVSoSEhODChQt47bXXUFdXh9zcXKvbOAm16AUHB5vMPHRHq567WvKsBb2GtOixzEOeeWsef/sx/jg9ttXMWyDYAcKBz5xQd63QzFbzNQ3NP19HQx5gGezY12HH2QHAJ16xduvuTs7Oun306iF4qZRWywFArUaLXQEjadYtIYS0Ys3aopecnGy39eynn35CVFQU9/OVK1cwZswYPPHEEzZDHmBc14sVERGBqKgohISEYP/+/Xj00UcFz5FKpTb38nSHpp540dCQ19AtwsyZt+yxhEKc0IQG82uxHO22tRbyAOsTPcy7Yz/xigVEuN0d28pU1HrBy87vQW0jvgwQQghpGZo16C1cuBBTpkyxWSY0NJT7/ytXrmDEiBHcqvvOCgoKQkhICM6fP+/0uXzrPYZZfc6Z1j53Bzxn9rcV4qpgx702c3uJETagWWvdYzka8hxlbXateVeweXcsF+yAVhvuCCGEtD/NGvT8/Pzg5+fnUNnLly9jxIgRiIyMRFpaGjw8nP/XtqysDEVFRQgKCnL6XEfZCoGsZ2uz3fb6rIbsb+vqYAdYLrPCD3uAaVizF/pMrmtl2RJbzCdeCF3DJNjh/9u7/5imznAP4N9DkYIox2lXKhkME5WigjozoG7LNHMdm8xonEpw3Y+46maIYS7TTe9is9zIXLyb24zOuRnvkD/cH8Postvpsl8aaBG1F7ch0cwfMFfsFA6IYhF6/3Bw7YDT1kJLT7+f5PzBOe9pH04ieXzO+z4vIrpqR0REFBGLMS5fvow5c+YgLS0NW7duhcvl6r1294pavV6P0tJSLFq0CNevX4fFYsHixYsxfvx4XLhwARs2bIBGo/HadD0c/JnPda/JoK+dMAYjmfO1wvZm1wiveXq9W5Hd1TC4x0BJX+939ZP8BVPJ6/Hvfna9FTsmdkREpCARkegdPnwY586dw7lz5/DAAw94Xbt7LUl9fT0kSQIAqFQqnD59Gl9++SVaWlowfvx4zJ07F/v378fo0fJ90IYDf5PBQCp3ckleoO1R7kV/TZR7Eq7R/TRXBnwndf7Oy+v53hv/VO16K69Rmth1dI7AbZn+iQBwm3P0iIgiXkSuug0lSZIwZswYNDQ0ROzKw5c7TvR7PkEl3ww5EAl+JooJAyR0vtwMoD9ef/4r5tGg7h/uelaHt7S0QBRF2XGiKOKx8zbEjpZfdXu77TqOTsgbklW3zc3NWLNmDQ4ePAgAWLBgAT755BOMGTNmwHu+/vpr7Nq1CydOnMDVq1dx6tQpzJgxY1DjIiJSmoio6IVTW1sbACA1NTXMkVAwPg93ACHS1tYmm+gNF0VFRWhsbITVagUArFy5EiaTCYcOHRrwnvb2djzyyCNYsmQJzGZzqEIlIopoTPR8SElJQUNDA0aPHg1BEHzfEAV6qkeRXOUcCuF8Lh6PB21tbUhJSRn0z757dxgg+BZEdXV1sFqtsNlsyM3NBQDs3r0bBoMB9fX1yMjI6Pc+k8kE4M7e10RE5B8mej7ExMT0mRdIdyQlJTHR60e4nksglbwb7ljEuuX/+d/+5/q/q9mbNm2CxWIJOL4eVVVVEEWxN8kDgLy8PIiiiMrKygETPSIiChwTPSKS9e8KZbANxZ1OZ7/bEGq1WjidzqA+m4iIvEXhekMiCkRPhbLnGCjRs1gsEARB9qipqQGAfqdBeDweTo8gIhpkrOhRwNRqNTZt2hTyreKGu2h/Lv7udFNbW4umpqY+11wuF5KTk4cqPCKiqMREjwKmVquDmqOlVJH0XG52qKAaIf/Pv6tDFdBn+rvTjcFggCRJqK6uRk5ODgDAbrdDkiTMnu27fyQREfmPr26JKKQyMzORn58Ps9kMm80Gm80Gs9mMgoICr4UYer0eFRUVvT9fu3YNDocDv//+O4A7DdIdDgfn9RERyWCiR0QhV15ejqysLBiNRhiNRmRnZ6OsrMxrzN073QDAwYMHMXPmTMyfPx8AUFhYiJkzZ+LTTz8NaexERJGEO2MQRZGenTGm/O8pqHxsBdjV1obfp88ckp0xiIgoNFjRIyIiIlIoLsYgikLtHSMQEztCdkx3h/x1IiIa/ljRo4Dt2LEDEyZMQHx8PGbNmoWjR4+GO6SQ+uWXX/Dss88iJSUFgiDgwIEDXtc9Hg8sFgtSUlKQkJCAOXPm4LfffgtPsEREFNWY6FFA9u/fj5KSEmzcuBGnTp3CY489hqeffhqXLl0Kd2gh097ejunTp2P79u39Xn///ffxwQcfYPv27Th+/Dh0Oh2efPJJtLW1hThSIiKKdlyMQQHJzc3FQw89hJ07d/aey8zMxMKFC1FaWhrGyMJDEARUVFRg4cKFAO5U81JSUlBSUoL169cDAG7duoXk5GRs2bIFq1atCmO0/78Y40H7r4gZJb8Yo/t6Gy7mTuNiDCKiCMaKHvnN7XbjxIkTMBqNXueNRiMqKyvDFNXwcv78eTidTq9npFar8fjjjw+rZ3Tjhsqvg4iIIhsTPfLb33//ja6urj7bVCUnJ7Np7T96ngOfERERDQdM9Chg/954npvR98VnREREwwETPfKbRqOBSqXqU5m6cuUKN6P/h06nAwA+IyIiGhaY6JHf4uLiMGvWLBw5csTr/JEjR7gZ/T8mTJgAnU7n9Yzcbjd+/vnnYfWMbnbE4sZN+eNmB9tsEhFFOiZ6FJC1a9fi888/x549e1BXV4fXX38dly5dwquvvhru0ELm+vXrcDgccDgcAO4swHA4HLh06RIEQUBJSQk2b96MiooK/Prrr3jppZcwcuRIFBUVhTfwYaS5uRkmkwmiKEIURZhMJrS0tAw4vrOzE+vXr0dWVhYSExORkpKCF154AZcvXw5d0EREEYj/ZaeALFu2DFevXsW7776Lv/76C9OmTcO3336LBx98MNyhhUxNTQ3mzp3b+/PatWsBAC+++CL27t2LdevW4ebNm1i9ejWam5uRm5uLw4cPY7SPvWWjSVFRERobG2G1WgEAK1euhMlkwqFDh/odf+PGDZw8eRLvvPMOpk+fjubmZpSUlGDBggWoqakJZehERBGFffSIokhPH71R/3MWQqJ84ulpb8P1pyehoaHBq4+eWq2GWq2+5xjq6uowZcoU2Gw25ObmAgBsNhsMBgPOnDmDjIwMvz7n+PHjyMnJwcWLF5GWlnbP8RARKRlf3RJFofZ2lV8HAKSmpva+YhVFMejG2FVVVRBFsTfJA4C8vDyIohhQr0FJkiAIAsaMGRNUPERESsZXt0Qkq7+KXjCcTie0Wm2f81qt1u9egx0dHXjrrbdQVFTEXTuIiGSwokdEspKSkryOgRI9i8UCQRBkj575dP31FPS312BnZycKCwvR3d2NHTt2BPfLEREpHCt6RDQoiouLUVhYKDsmPT0dtbW1aGpq6nPN5XL57DXY2dmJpUuX4vz58/jhhx9YzSMi8oGJHhENCo1GA41G43OcwWCAJEmorq5GTk4OAMBut0OSJNlegz1J3tmzZ/Hjjz9i3LhxgxY7EZFS8dUtURSKuxGDuHaV/HFjaP48ZGZmIj8/H2azGTabDTabDWazGQUFBV4rbvV6PSoqKgAAt2/fxnPPPYeamhqUl5ejq6sLTqcTTqcTbrd7SOIkIlICJnpEFHLl5eXIysqC0WiE0WhEdnY2ysrKvMbU19dDkiQAQGNjIw4ePIjGxkbMmDED48eP7z0CWalLRBRt+OqWiEJu7Nix2Ldvn+yYu1t8pqengy0/iYgCx4oeERERkUKxokcUhRJbVYjpVMmO6b6pwq0QxUNEREODFT0KCZfLBZ1Oh82bN/ees9vtiIuLw+HDh8MYGRERkXKxokchcf/992PPnj1YuHAhjEYj9Ho9nn/+eaxevRpGozHc4RERESkSEz0KmWeeeQZmsxnLly/Hww8/jPj4eLz33nvhDouIiEixmOhRSG3duhXTpk3DV199hZqaGsTHx4c7pKg0sj0GMV3yMze6O2JwLUTxEBHR0OAcPQqpP/74A5cvX0Z3dzcuXrwY7nCIiIgUjRU9Chm3243ly5dj2bJl0Ov1WLFiBU6fPu1zf1MiIiK6N6zoUchs3LgRkiTh448/xrp165CZmYkVK1aEOywiIiLFYqJHIfHTTz9h27ZtKCsrQ1JSEmJiYlBWVoZjx45h586d4Q6PiIhIkZjoUUjMmTMHnZ2dePTRR3vPpaWloaWlBa+99loYI4tOCW0qjPRxJLTJN1QORnNzM0wmE0RRhCiKMJlMaGlpkb3HYrFAr9cjMTER9913H+bNmwe73T5kMRIRKQETPSIKuaKiIjgcDlitVlitVjgcDphMJtl7Jk+ejO3bt+P06dM4duwY0tPTYTQa4XK5QhQ1EVHkETzcKZwoarS2tkIURUz6DydU8UmyY7s6WnH2P3WQJAlJSfJjA1FXV4cpU6bAZrMhNzcXAGCz2WAwGHDmzBlkZGT49Tk9v8v333+PJ554YtDiIyJSElb0iEhWa2ur13HrVnA74FZVVUEUxd4kDwDy8vIgiiIqKyv9+gy3243PPvsMoihi+vTpQcVDRKRkTPSIolBCWwwSWn0cbXf+PKSmpvbOpRNFEaWlpUF9t9PphFar7XNeq9XC6XTK3vvNN99g1KhRiI+Px4cffogjR45Ao9EEFQ8RkZIx0SMiWQ0NDZAkqfd4++23+x1nsVggCILsUVNTAwAQBKHP/R6Pp9/zd5s7dy4cDgcqKyuRn5+PpUuX4sqVK8H/kkRECsWGyUQkKykpya85esXFxSgsLJQdk56ejtraWjQ1NfW55nK5fDbPTkxMxMSJEzFx4kTk5eVh0qRJ+OKLLwZMPomIoh0TPSIaFBqNxq/XqAaDAZIkobq6Gjk5OQAAu90OSZIwe/bsgL7T4/EEPWeQiEjJ+OqWKAqNaonB6Gb5Y1TL0Px5yMzMRH5+PsxmM2w2G2w2G8xmMwoKCrxW3Or1elRUVAAA2tvbsWHDBthsNly8eBEnT57EK6+8gsbGRixZsmRI4iQiUgImekQUcuXl5cjKyoLRaITRaER2djbKysq8xtTX10OSJACASqXCmTNnsHjxYkyePBkFBQVwuVw4evQopk6dGo5fgYgoIrCPHlEU6ek9N/vFvxEbJz/v7ra7FZX/rRn0PnpERBQ6rOgRERERKRQXYxBFoZGtAmJHyLcyud0pf52IiIY/VvSIiIiIFIqJHhEREZFCMdEjIiIiUigmekREREQKxcUYRFEooVXAiFj5xRadt7kYg4go0rGiR0RERKRQTPSIiIiIFIqJHhEREZFCcY4eURRKkATE+Zij5+YcPSKiiMeKHhGFXHNzM0wmE0RRhCiKMJlMaGlp8fv+VatWQRAEbNu2bchiJCJSAiZ6RBRyRUVFcDgcsFqtsFqtcDgcMJlMft174MAB2O12pKSkDHGURESRj69uiUhWa2ur189qtRpqtfqeP6+urg5WqxU2mw25ubkAgN27d8NgMKC+vh4ZGRkD3vvnn3+iuLgY3333HebPn3/PMRARRQtW9Iii0MhWASMlH0frnTl6qampva9YRVFEaWlpUN9dVVUFURR7kzwAyMvLgyiKqKysHPC+7u5umEwmvPnmm5g6dWpQMRARRQtW9IhIVkNDA5KSknp/DqaaBwBOpxNarbbPea1WC6fTOeB9W7ZsQWxsLNasWRPU9xMRRRNW9IhIVlJSktcxUKJnsVggCILsUVNTAwAQhL4rej0eT7/nAeDEiRP46KOPsHfv3gHHEBFRX6zoEdGgKC4uRmFhoeyY9PR01NbWoqmpqc81l8uF5OTkfu87evQorly5grS0tN5zXV1deOONN7Bt2zZcuHAhqNiJiJSKiR5RFEq8JkAdI18Zu9UdWOVMo9FAo9H4HGcwGCBJEqqrq5GTkwMAsNvtkCQJs2fP7vcek8mEefPmeZ176qmnYDKZ8PLLLwcUJxFRNGGiR0QhlZmZifz8fJjNZuzatQsAsHLlShQUFHituNXr9SgtLcWiRYswbtw4jBs3zutzRowYAZ1OJ7tKl4go2nGOHhGFXHl5ObKysmA0GmE0GpGdnY2ysjKvMfX19ZAkKUwREhEpAyt6RBRyY8eOxb59+2THeDwe2eucl0dE5BsrekREREQKxYoeURQaKQFqH2stVPIFNSIiigCs6BEREREpFBM9IiIiIoXiq1uiKHQLrYCPV7O30BqaYIiIaMgw0SOKInFxcdDpdPjYmerXeJ1Oh7i4uCGOioiIhorg8dXDgIgUpaOjA26326+xcXFxiI+PH+KIiIhoqDDRIyIiIlIoLsYgIiIiUigmekREREQKxUSPiIiISKGY6BEREREpFBM9IiIiIoViokdERESkUEz0iIiIiBTq/wBY+YcBbc2G6gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.gridspec import GridSpec\n",
    "\n",
    "X, BC_X, BC_Y = Uniform_with_Cylinder(u0)\n",
    "    \n",
    "X = X.clone().detach().requires_grad_(True)      \n",
    "\n",
    "\n",
    "# forward pass of the model !!! fwd pass outside eval/inference is okay as long as you dont .backward()\n",
    "# we have to call .model() because our model is nested inside class PINN\n",
    "y_preds = test.model(X)\n",
    "u = y_preds[:, 0:1]   # u velocity\n",
    "v = y_preds[:, 1:2]\n",
    "p = y_preds[:, 2:3]     #pressure\n",
    "\n",
    "\n",
    "# convert to array for postprocessing\n",
    "p_np   = p.detach().numpy()\n",
    "u_np   = u.detach().numpy()\n",
    "v_np   = v.detach().numpy()\n",
    "x_np   = X[:, 0:1].detach().numpy()\n",
    "y_np   = X[:, 1:2].detach().numpy()\n",
    "\n",
    "\n",
    "def tricontour(gs, x, y, z, title):\n",
    "    \"\"\"\n",
    "    this is an explanation for tripcontour() and tripplot() which are two different methods for plotting contour type plots\n",
    "\n",
    "    Args:\n",
    "        grid: plot position in subplot\n",
    "        x: x-array (x coords)\n",
    "        y: y-array  (y coords)\n",
    "        z: z-array (engineering value at [x,y])\n",
    "        title: title \n",
    "    \"\"\"\n",
    "    plt.subplot(gs)\n",
    "    tcf = plt.tricontourf(x, y, z, levels=50, cmap='rainbow')\n",
    "    plt.colorbar(tcf)\n",
    "    plt.gca().set_aspect('equal')\n",
    "    plt.title(title)\n",
    "    plt.xlabel('x')\n",
    "    plt.ylabel('y')\n",
    "    \n",
    "\n",
    "# note we have to squeeze the arrays as they are in column vector format(ML format)\n",
    "gs = GridSpec(2,2)\n",
    "tricontour(gs[0,0], np.squeeze(x_np), np.squeeze(y_np), np.squeeze(p_np), 'Pressure contour')\n",
    "tricontour(gs[0,1], np.squeeze(x_np), np.squeeze(y_np), np.squeeze(u_np), 'u velocity contour')\n",
    "tricontour(gs[1,0], np.squeeze(x_np), np.squeeze(y_np), np.squeeze(v_np), 'v velocity contour')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "\n",
    "def tripplot(gs, x, y, z, title):\n",
    "    plt.subplot(gs)\n",
    "    plt.tripcolor(x, y, z, cmap='rainbow')\n",
    "    plt.colorbar()\n",
    "    plt.title(title)\n",
    "    plt.xlabel('x')\n",
    "    plt.ylabel('y')\n",
    "\n",
    "gs2 = GridSpec(2,2)\n",
    "tripplot(gs2[0,0], np.squeeze(x_np), np.squeeze(y_np), np.squeeze(p_np), 'Pressure contour')\n",
    "tripplot(gs2[0,1], np.squeeze(x_np), np.squeeze(y_np), np.squeeze(u_np), 'u velocity contour')\n",
    "tripplot(gs2[1,0], np.squeeze(x_np), np.squeeze(y_np), np.squeeze(v_np), 'v velocity contour')\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "214c5b6d-493f-440e-815e-573500df97a3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.11.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}