icl_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b8dc9916-a3cc-4fe5-af4b-3b199a773875",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d6217256",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
    "os.environ[\"PYGAME_HIDE_SUPPORT_PROMPT\"] = \"hide\"\n",
    "import copy\n",
    "import logging\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import tqdm\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "import tools\n",
    "device = torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73516917-eb72-4482-858c-93d751465916",
   "metadata": {},
   "source": [
    "# Seeding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c02ef1e3-53d8-4468-ab96-924d347b56ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def seed_fn(seed):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff80b4c4-91e1-4345-9370-8b7e39913e98",
   "metadata": {},
   "source": [
    "# Create environments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d91fb62-c9ff-4fe8-a053-3dc2eda25f99",
   "metadata": {},
   "source": [
    "* Create a 7x7 gridworld environment (similar to Gridworld A environment described in the ICL paper)\n",
    "* Agent starts in one of the start states in `s`\n",
    "* Agent terminates when it reaches cell $(6,0)$\n",
    "* Maximum episode length can be 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a554c47f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def create_env():\n",
    "    r = np.zeros((7, 7))\n",
    "    r[6, 0] = 1.0\n",
    "    t = [(6, 0)]\n",
    "    u = [(ui, uj) for ui in [3] for uj in [0, 1, 2, 3]]\n",
    "    s = [(ui, uj) for ui in [0, 1, 2] for uj in [0, 1]]\n",
    "    env = tools.environments.GridworldEnvironment(\n",
    "        start_states=s,\n",
    "        t=t,\n",
    "        r=r,\n",
    "        unsafe_states=u,\n",
    "        stay_action=False,  # no action to \"stay in current cell\"\n",
    "    )\n",
    "    env = tools.environments.TimeLimit(env, 50)\n",
    "    env = tools.environments.FollowGymAPI(env)\n",
    "    env.seed(1)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "406925f4-c13a-4935-9edf-ebd3aef1c757",
   "metadata": {},
   "source": [
    "# Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "492e8c2e-c5b6-43d3-8ec0-5463cb6f0831",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gridworld_imshow(m, fig, ax):\n",
    "    m = np.array(m).squeeze()\n",
    "    assert len(m.shape) == 2\n",
    "    divider = make_axes_locatable(ax)\n",
    "    cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "    im = ax.imshow(m, cmap=\"gray\")\n",
    "    # im.set_clim(0, 1)\n",
    "    ax.set_xticks(np.arange(m.shape[0]))\n",
    "    ax.set_yticks(np.arange(m.shape[1]))\n",
    "    cbar = fig.colorbar(im, cax=cax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6b512fd7-6550-4ee0-8ff3-a6188a1f6bf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_constraint(constraint_fn, fig=None, ax=None):\n",
    "    global gridworld_dim, n_actions\n",
    "    grid_for_action = []\n",
    "    for a in np.arange(n_actions):\n",
    "        grid = np.zeros((gridworld_dim, gridworld_dim))\n",
    "        for x in np.arange(gridworld_dim):\n",
    "            for y in np.arange(gridworld_dim):\n",
    "                grid[x, y] = constraint_fn(([x, y], a))\n",
    "        grid_for_action += [grid]\n",
    "    average_grid = np.mean(grid_for_action, axis=0)\n",
    "    if fig == None and ax == None:\n",
    "        fig, ax = plt.subplots(1, 1, figsize=(3, 3))\n",
    "    gridworld_imshow(average_grid, fig, ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e1c66b1e-8acd-4f56-85f0-59ed0700895b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_accrual(data, fig=None, ax=None):\n",
    "    global gridworld_dim, n_actions\n",
    "    accrual = np.array([np.zeros((gridworld_dim, gridworld_dim)) for _ in range(n_actions)])\n",
    "    for S, A in data:\n",
    "        for s, a in zip(S, A):\n",
    "            x, y = s\n",
    "            accrual[a][x][y] += 1\n",
    "    accrual = np.mean(accrual, axis=0)\n",
    "    accrual /= np.max(accrual)\n",
    "    if fig == None and ax == None:\n",
    "        fig, ax = plt.subplots(1, 1, figsize=(3, 3))\n",
    "    gridworld_imshow(accrual, fig, ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27a706f-e65d-4889-ac6e-c820cfa9902a",
   "metadata": {},
   "source": [
    "# Constraint functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8552b371-e2a4-4f28-8489-f144292b0fd0",
   "metadata": {},
   "source": [
    "Ground truth constraint function - $1$ in cells $\\{(3,0), (3,1), (3,2), (3,3)\\}$ and $0$ elsewhere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "37a7bd8c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def true_constraint_function(sa):\n",
    "    s, a = sa\n",
    "    x, y = s[0], s[1]\n",
    "    u = [(ui, uj) for ui in [3] for uj in [0, 1, 2, 3]]\n",
    "    if (x, y) in u:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bd2d7d9-0762-4150-87e2-40bde3f310b0",
   "metadata": {},
   "source": [
    "Current constraint function just uses the constraint neural network (input is state only for this example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9cc523b2-726b-46c2-a2d3-e0c1b0f9a2db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def current_constraint_function(sa):\n",
    "    global constraint_nn, device\n",
    "    s, a = sa\n",
    "    return constraint_nn(torch.tensor(s, device=device, dtype=torch.float))  # Change this depending on the constraint_nn input"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab201070-bf98-4a6c-8484-a8a5cc17a11f",
   "metadata": {
    "tags": []
   },
   "source": [
    "# PPO Penalty"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "584b2cac-aec1-470a-ae7f-73f20cad79e2",
   "metadata": {},
   "source": [
    "Make policy and value networks for PPO:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ab8d613",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def make_nn():\n",
    "    global obs_n, act_n, hidden_dim, device\n",
    "    value_nn = torch.nn.Sequential(\n",
    "        torch.nn.Linear(obs_n, hidden_dim), torch.nn.ReLU(),\n",
    "        torch.nn.Linear(hidden_dim, hidden_dim), torch.nn.ReLU(),\n",
    "        torch.nn.Linear(hidden_dim, 1),\n",
    "    ).to(device)\n",
    "    policy_nn = torch.nn.Sequential(\n",
    "        torch.nn.Linear(obs_n, hidden_dim), torch.nn.ReLU(),\n",
    "        torch.nn.Linear(hidden_dim, hidden_dim), torch.nn.ReLU(),\n",
    "        torch.nn.Linear(hidden_dim, act_n),\n",
    "    ).to(device)\n",
    "    return value_nn, policy_nn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a3f207a-a885-463c-81a3-752ab160cea9",
   "metadata": {},
   "source": [
    "Play an episode using the policy neural network and return states, actions, rewards and constraint values for the episode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1617e231-7c3e-4a21-8cf6-550c0c4e96e4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def play_episode(env, policy_nn, constraint_fn):\n",
    "    global device\n",
    "    S, A, R, C = [], [], [], []\n",
    "    S += [env.reset()]\n",
    "    done = False\n",
    "    while not done:\n",
    "        probs = torch.nn.Softmax(dim=-1)(policy_nn(torch.tensor(S[-1], device=device, dtype=torch.float))).view(-1)\n",
    "        action = np.random.choice(act_n, p=probs.cpu().detach().numpy())\n",
    "        A += [action]\n",
    "        next_state, reward, done, info = env.step(action)\n",
    "        C += [constraint_fn((S[-1], action))]\n",
    "        S += [next_state]\n",
    "        R += [reward]\n",
    "    return S, A, R, C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ebb15d0-d3c2-4d74-81df-9e4b443e62f6",
   "metadata": {},
   "source": [
    "Convert $r_0, r_1, r_2, \\cdots$ into $G_0, G_1, G_2, \\cdots$ where $G_k = \\sum_{t=k} \\gamma^{t-k} r_t$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "262096f1-bd33-4106-93fd-544521c56c9a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def discount(x, invert=False):\n",
    "    global discount_factor\n",
    "    n = len(x)\n",
    "    g = 0\n",
    "    d = []\n",
    "    for i in range(n):\n",
    "        if not invert:\n",
    "            g = x[n - 1 - i] + discount_factor * g\n",
    "            d = [g] + d\n",
    "        else:\n",
    "            g = g + x[i] * (discount_factor**i)\n",
    "            d = d + [g]\n",
    "    return d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bf9ebbd-a0ba-4136-8317-259e7ebbed64",
   "metadata": {},
   "source": [
    "PPO Replay Buffer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4aa7a3c9-6443-482b-a763-da1d31ea96a3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, N):\n",
    "        global obs_n, device\n",
    "        self.N = N\n",
    "        self.S = torch.zeros((self.N, obs_n), dtype=torch.float, device=device)\n",
    "        self.A = torch.zeros((self.N), dtype=torch.long, device=device)\n",
    "        self.G = torch.zeros((self.N), dtype=torch.float, device=device)\n",
    "        self.log_probs = torch.zeros((self.N), dtype=torch.float, device=device)\n",
    "        self.i = 0\n",
    "        self.filled = 0\n",
    "\n",
    "    def add(self, S, A, G, log_probs):\n",
    "        M = S.shape[0]\n",
    "        self.filled = min(self.filled + M, self.N)\n",
    "        assert M <= self.N\n",
    "        for j in range(M):\n",
    "            self.S[self.i] = S[j, :]\n",
    "            self.A[self.i] = A[j]\n",
    "            self.G[self.i] = G[j]\n",
    "            self.log_probs[self.i] = log_probs[j]\n",
    "            self.i = (self.i + 1) % self.N\n",
    "\n",
    "    def sample(self, n):\n",
    "        global device\n",
    "        minibatch = random.sample(range(self.filled), min(n, self.filled))\n",
    "        S, A, G, log_probs = [], [], [], []\n",
    "        for mbi in minibatch:\n",
    "            s, a, g, lp = self.S[mbi], self.A[mbi], self.G[mbi], self.log_probs[mbi]\n",
    "            S += [s]\n",
    "            A += [a]\n",
    "            G += [g]\n",
    "            log_probs += [lp]\n",
    "        return torch.stack(S), torch.stack(A), torch.stack(G), torch.stack(log_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "140c8897-ae5a-4657-8286-96a722b8a36c",
   "metadata": {},
   "source": [
    "PPO Penalty Code (for algorithm, see ICL paper appendix):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a56ee17c-93d3-4d09-9093-c6a6803768ac",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def ppo_penalty(n_epochs, env, policy_nn, value_nn, constraint_fn, additional_fn_condition=None, additional_fn_epoch_end=None):\n",
    "    # Additional function to be run when additional function condition is met\n",
    "    # Additional function takes in current policy_nn and current iteration number\n",
    "    global episodes_per_epoch, replay_buffer_size, learning_rate_feasibility, beta\n",
    "    global ppo_subepochs, minibatch_size, learning_rate, device\n",
    "    buffer = ReplayBuffer(replay_buffer_size)\n",
    "    value_opt = torch.optim.Adam(value_nn.parameters(), lr=learning_rate)\n",
    "    policy_opt = torch.optim.Adam(policy_nn.parameters(), lr=learning_rate)\n",
    "    pbar = tqdm.notebook.tqdm(total=n_epochs)\n",
    "    for epoch in range(n_epochs):\n",
    "        S_e, A_e, G_e, Gc_e, Indices = [], [], [], [], []\n",
    "        G0_e, Gc0_e = [], []\n",
    "        max_cost_reached = 0.0\n",
    "        max_cost_reached_n = 0\n",
    "        S_e_buf, A_e_buf, G_e_buf = [], [], []\n",
    "        for episode in range(episodes_per_epoch):\n",
    "            S, A, R, C = play_episode(env, policy_nn, constraint_fn)\n",
    "            start_index = len(A_e)\n",
    "            S_e += S[:-1]  # ignore last state\n",
    "            A_e += A\n",
    "            G_e += discount(R)\n",
    "            G0_e += [float(discount(R)[0])]\n",
    "            Gc_e += discount(C)\n",
    "            Gc0_e += [float(discount(C)[0])]\n",
    "            end_index = len(A_e)\n",
    "            Indices += [(start_index, end_index)]\n",
    "            # Only add those experiences to replay buffer which are before the constraint violation\n",
    "            inverted_discount = torch.tensor(discount(C, invert=True), dtype=torch.float, device=device)\n",
    "            good_until = len(inverted_discount)\n",
    "            for idx, item in enumerate(inverted_discount):\n",
    "                if item >= beta:\n",
    "                    good_until = idx + 1\n",
    "                    break\n",
    "            S_e_buf += S[:-1][:good_until]\n",
    "            A_e_buf += A[:good_until]\n",
    "            G_e_buf += discount(R[:good_until])\n",
    "            if Gc0_e[-1] >= beta:\n",
    "                max_cost_reached += 1\n",
    "            max_cost_reached_n += 1\n",
    "        pbar.set_description(\"Epoch %d:\\tG_avg = %.2f\\tGc_avg = %.2f\\tMaxCostReached = %.2f\"\n",
    "            % (epoch, np.mean(G0_e), np.mean(Gc0_e), float(max_cost_reached / max_cost_reached_n)))\n",
    "        S_e = torch.tensor(S_e, dtype=torch.float, device=device)\n",
    "        A_e = torch.tensor(A_e, dtype=torch.long, device=device)\n",
    "        G_e = torch.tensor(G_e, dtype=torch.float, device=device)\n",
    "        Gc_e = torch.tensor(Gc_e, dtype=torch.float, device=device)\n",
    "        S_e_buf = torch.tensor(S_e_buf, dtype=torch.float, device=device)\n",
    "        A_e_buf = torch.tensor(A_e_buf, dtype=torch.long, device=device)\n",
    "        G_e_buf = torch.tensor(G_e_buf, dtype=torch.float, device=device)\n",
    "        log_probs_e_buf = torch.nn.LogSoftmax(dim=-1)(policy_nn(S_e_buf)).gather(1, A_e_buf.view(-1, 1)).view(-1)\n",
    "        buffer.add(S_e_buf, A_e_buf, G_e_buf, log_probs_e_buf.detach())\n",
    "        feasibility_opt = torch.optim.Adam(policy_nn.parameters(), lr=learning_rate_feasibility)\n",
    "        # Penalty update on complete trajectories\n",
    "        for start_index, end_index in Indices:\n",
    "            Gc = Gc_e[start_index:end_index].view(-1)\n",
    "            log_probs = torch.nn.LogSoftmax(dim=-1)(policy_nn(S_e[start_index:end_index])).gather(1, A_e[start_index:end_index].view(-1, 1)).view(-1)\n",
    "            feasibility_opt.zero_grad()\n",
    "            feasibility_loss = (Gc[0] >= beta) * ((Gc * log_probs).sum())\n",
    "            feasibility_loss.backward()\n",
    "            feasibility_opt.step()\n",
    "        # Policy and value update from replay buffer\n",
    "        for subepoch in range(ppo_subepochs):\n",
    "            S, A, G, old_log_probs = buffer.sample(minibatch_size)\n",
    "            log_probs = torch.nn.LogSoftmax(dim=-1)(policy_nn(S)).gather(1, A.view(-1, 1)).view(-1)\n",
    "            value_opt.zero_grad()\n",
    "            value_loss = (G - value_nn(S)).pow(2).mean()\n",
    "            value_loss.backward()\n",
    "            value_opt.step()\n",
    "            policy_opt.zero_grad()\n",
    "            advantages = G - value_nn(S)\n",
    "            ratio = torch.exp(log_probs - old_log_probs)\n",
    "            clipped_ratio = torch.clamp(ratio, 1 - clip_param, 1 + clip_param)\n",
    "            policy_loss = -torch.min(ratio * advantages, clipped_ratio * advantages).mean()\n",
    "            probs_all = torch.nn.Softmax(dim=-1)(policy_nn(S))\n",
    "            log_probs_all = torch.nn.LogSoftmax(dim=-1)(policy_nn(S))\n",
    "            entropy = -(probs_all * log_probs_all).sum(1).mean()\n",
    "            policy_loss -= entropy_coef * entropy\n",
    "            policy_loss.backward()\n",
    "            policy_opt.step()\n",
    "        # Run additional function at epoch end if condition is met\n",
    "        # Just in case we need it for later! (and we will)\n",
    "        if additional_fn_condition != None and additional_fn_epoch_end != None:\n",
    "            if additional_fn_condition(epoch, policy_nn) == True:\n",
    "                additional_fn_epoch_end(epoch, policy_nn)\n",
    "        pbar.update(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4e045be-9ef0-4335-8a0b-2728d44e8e0a",
   "metadata": {},
   "source": [
    "* Collect $n$ trajectories using policy\n",
    "* If `only_success` is True, then only return a set of trajectories that do not violate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d34b176a-9b01-4cd8-8c1d-1d3d8b384fef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_trajectories(n, env, policy_nn, constraint_fn, only_success=False):\n",
    "    data = []\n",
    "    for traj in tqdm.notebook.tqdm(range(n)):\n",
    "        S, A, R, C = play_episode(env, policy_nn, constraint_fn)\n",
    "        while (not (discount(C)[0] <= beta)) and only_success:\n",
    "            S, A, R, C = play_episode(test_env, policy_nn, constraint_fn)\n",
    "        data += [[S[:-1], A]]\n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fa4ccdd-7b51-41d9-ad8b-64a8c70a0fbd",
   "metadata": {},
   "source": [
    "# Normalizing flow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc93af3d-a27d-4246-a2e8-adaf97657c7f",
   "metadata": {},
   "source": [
    "Convert any set of trajectories to data which can be used to train the normalizing flow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "68f31b98-2e97-4c07-b6b2-3bd307318f7b",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def convert_to_flow_data(data):\n",
    "    global device\n",
    "    flow_data = []\n",
    "    for S, A in data:\n",
    "        for s, a in zip(S, A):\n",
    "            flow_data += [s]  # Change this depending on your constraint_nn input\n",
    "    flow_data = torch.tensor(flow_data, dtype=torch.float, device=device)\n",
    "    return flow_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2b87b3c-9e85-4fda-acce-b53c79d8115f",
   "metadata": {},
   "source": [
    "Compute trajectory dissimilarity w.r.t. expert NLL:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "067ab115-b54a-453a-9513-fb6191abd018",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dissimilarity_wrt_expert(data, mean=True):\n",
    "    global flow, expert_nll, device\n",
    "    expert_nll_mean, expert_nll_std = expert_nll\n",
    "    sims = []\n",
    "    for S, A in data:\n",
    "        traj_data = S  # Change this depending on your constraint_nn input\n",
    "        traj_data = torch.tensor(traj_data, dtype=torch.float, device=device)\n",
    "        traj_nll = -flow.log_probs(traj_data).detach()\n",
    "        sims += [(traj_nll > expert_nll_mean + expert_nll_std).float().mean()]\n",
    "    if mean:\n",
    "        return np.mean(sims)\n",
    "    return torch.tensor(sims, dtype=torch.float, device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dc3c921-a313-4d06-874c-69dad7357ff5",
   "metadata": {},
   "source": [
    "# Constraint function adjustment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2b3a1d6-7fb5-4346-8cf5-cd5ca83cee46",
   "metadata": {},
   "source": [
    "Collect a set of trajectories using a mixture of policies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "203d24f6-6924-4b3b-9509-a818c4ddd32f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_trajectories_mixture(n, env, policy_mixture, weights_mixture, constraint_fn):\n",
    "    data = []\n",
    "    value_nn, policy_nn = make_nn()\n",
    "    normalized_weights_mixture = np.copy(weights_mixture) / np.sum(weights_mixture)\n",
    "    m = len(weights_mixture)\n",
    "    for traj in tqdm.notebook.tqdm(range(n)):\n",
    "        chosen_policy_idx = np.random.choice(m, p=normalized_weights_mixture)\n",
    "        policy_nn.load_state_dict(policy_mixture[chosen_policy_idx])\n",
    "        S, A, R, C = play_episode(env, policy_nn, constraint_fn)\n",
    "        data += [[S[:-1], A]]\n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0a7ba9d-d44b-448e-a2a1-f31b04b49261",
   "metadata": {},
   "source": [
    "Compute the discounted constraint value for each trajectory in a set of trajectories:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6a85568f-22cc-4311-912c-ba3850ac9997",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_current_constraint_value_trajectory(constraint_nn, data):\n",
    "    global device\n",
    "    Gc0 = []\n",
    "    for S, A in data:\n",
    "        input_to_constraint_nn = []\n",
    "        for s, a in zip(S, A):\n",
    "            input_to_constraint_nn += [s]  # Change this depending on your constraint_nn input\n",
    "        input_to_constraint_nn = torch.tensor(input_to_constraint_nn, dtype=torch.float, device=device)\n",
    "        constraint_values = constraint_nn(input_to_constraint_nn).view(-1)\n",
    "        Gc0 += [discount(constraint_values)[0]]\n",
    "    return torch.stack(Gc0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ccce44e-a0fa-4f39-a7df-f180cc112555",
   "metadata": {},
   "source": [
    "Constraint function adjustment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "bab98d84-3d52-41fd-afa5-74bd25468d7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def constraint_function_adjustment(n, constraint_nn, constraint_opt, expert_data, agent_data):\n",
    "    global beta, alpha\n",
    "    losses = []\n",
    "    for _ in range(n):\n",
    "        constraint_opt.zero_grad()\n",
    "        per_traj_dissimilarity = dissimilarity_wrt_expert(agent_data, mean=False)\n",
    "        per_traj_dissimilarity = per_traj_dissimilarity / per_traj_dissimilarity.sum()\n",
    "        agent_data_constraint_returns = compute_current_constraint_value_trajectory(constraint_nn, agent_data)\n",
    "        expert_data_constraint_returns = compute_current_constraint_value_trajectory(constraint_nn, expert_data)\n",
    "        loss1 = -(agent_data_constraint_returns * per_traj_dissimilarity).sum()\n",
    "        loss2 = ((expert_data_constraint_returns >= beta).float() * (expert_data_constraint_returns - beta)).mean()\n",
    "        loss = loss1 + alpha * loss2\n",
    "        loss.backward()\n",
    "        constraint_opt.step()\n",
    "        losses += [loss.item()]\n",
    "    return np.mean(losses)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f76450ce-3e8d-4aa8-a72f-a29519a9917e",
   "metadata": {},
   "source": [
    "At the end of each PPO Penalty epoch, update dissimilarity and mixture weights if necessary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5b704a6b-6f14-4cdf-be88-7930969c9875",
   "metadata": {},
   "outputs": [],
   "source": [
    "def condition(epoch, policy_nn):\n",
    "    if (epoch + 1) % policy_add_to_mix_every == 0:\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2a4bee65-e7fd-494e-9922-bb6f3220735c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def command(epoch, policy_nn):\n",
    "    global policy_mixture, weights_mixture, agent_data\n",
    "    global expert_data, test_env\n",
    "    agent_data = collect_trajectories(len(expert_data), test_env, policy_nn, current_constraint_function)\n",
    "    policy_mixture += [copy.deepcopy(policy_nn.state_dict())]\n",
    "    weights_mixture += [dissimilarity_wrt_expert(agent_data)]\n",
    "    print(\"Added policy with dissimilarity = %.2f\" % weights_mixture[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a57ec7c-08e5-46c9-8dfa-cbc1cfa05a03",
   "metadata": {},
   "source": [
    "Generate expert data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "43a250d2-9e42-4df7-919c-0c98b65346e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_expert_data(env, only_success=False):  # use only_success if the policy isn't great and you just want to get optimal trajectories\n",
    "    global ppo_iters, n_trajs\n",
    "    value_nn, policy_nn = make_nn()\n",
    "    ppo_penalty(ppo_iters, env, policy_nn, value_nn, true_constraint_function)\n",
    "    expert_data = collect_trajectories(n_trajs, test_env, policy_nn, true_constraint_function, only_success=only_success)\n",
    "    return expert_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "811b3dab-6b0f-42a6-89f5-e79f8b87ec6b",
   "metadata": {},
   "source": [
    "# Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "54844f68-90df-4401-a354-6335a1348af6",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    seed_fn(1)\n",
    "    gridworld_dim = 7\n",
    "    n_actions = 8\n",
    "    constraint_fn_input_dim = 2\n",
    "    hidden_dim = 64\n",
    "    env, test_env = create_env(), create_env()\n",
    "    obs_n = env.observation_space.shape[0]\n",
    "    act_n = env.action_space.n\n",
    "    discount_factor = 1.0\n",
    "    episodes_per_epoch = 20\n",
    "    ppo_subepochs = 25\n",
    "    replay_buffer_size = 10000\n",
    "    learning_rate = 5e-4\n",
    "    learning_rate_feasibility = 2.5e-5\n",
    "    minibatch_size = 64\n",
    "    clip_param = 0.1\n",
    "    entropy_coef = 0.01\n",
    "    beta = 0.99\n",
    "    alpha = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9e907ad5-f35b-4358-b197-d205878429d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    n_iters = 5\n",
    "    flow_iters = 20\n",
    "    ppo_iters = 500\n",
    "    policy_add_to_mix_every = 250\n",
    "    ca_iters = 20\n",
    "    n_trajs = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac6decdb-ab2d-4a12-b427-9ac7d2025325",
   "metadata": {},
   "source": [
    "# ICL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2ce15589-4320-44ea-9d64-4a97fa452c67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATcAAAEECAYAAABNzHMxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAiJ0lEQVR4nO3dfVRUZR4H8O/wMoMajCjKi4xASSgZSCAIWtnKRm4ZtmeL07Fk2cSjB9aMcpXdEtOtsdxFrDhAbUQd62D7QlqtmJHitkoo6Am19S2EURnAUgZIgWbu/tFhcuRtLs6dkTvfzzn3nObOvff3kPL1ufe597kKQRAEEBHJjIujG0BEJAWGGxHJEsONiGSJ4UZEssRwIyJZYrgRkSwx3IhIlhhuRCRLbvYuaDKZcOHCBXh6ekKhUNi7PJGsCYKA9vZ2BAQEwMXl577L1atX0d3dbdUxlEolPDw8pGqi3dg93C5cuACNRmPvskRORafTITAwEMBPwRYSEgK9Xm/Vvn5+fqivrx/xAWf3cPP09AQAjBs3zuJfFnv57rvv7F6zl0qlclhtR/aSHfHn3Kunp8dhta3tKUmh9/estx16vR4NDQ3w8vIadD+DwYCgoCB0d3cz3MTq/SVzcXFxyF96R/6SszZrS633UfH+ant6elqE3mD7y4Hdw42IHEMQhCHDi+FGRCMOw42IZInhRkSyZDKZYDKZhtxGLhhuRE6CPTcikiWGGxHJEsONiGTJ2cJtWHfR5ufnIzg4GB4eHoiLi0N1dbWt20VENtY7oDDUIheiw23btm3IyspCTk4OamtrERkZiaSkJLS0tEjRPiKykd6e21CLXIgOt9zcXKSnpyMtLQ3h4eEoLCzE6NGjUVxcLEX7iMhGGG6D6O7uRk1NDRITE38+gIsLEhMTceDAgX736erqgsFgsFiIyP4YboO4ePEijEYjfH19Ldb7+voOOJ2KVquFWq02L5zuiMgxGG42lp2djba2NvOi0+mkLklEA3CWYANE3gri4+MDV1dXNDc3W6xvbm6Gn59fv/uoVCqHzmNGRD9xtsevRPXclEoloqOjUVFRYV5nMplQUVGB+Ph4mzeOiGzH2U5LRd/Em5WVhdTUVMTExCA2NhZ5eXno7OxEWlqaFO0jIhtxtpt4RYdbSkoKWltbsXbtWuj1esyYMQPl5eV9BhmI6ObCcLNCZmYmMjMzbd0WIpIQw42IZMnZBhQYbkROgj03IpIlhhsRyRLDjYhkieFGRLLEcCMiWeJoKRHJEntudhIUFAQ3N/uXHzVqlN1r9vr+++8dVtuRf2kdWdtoNDqs9s2G4UZEsiWn8BoKw43ISbDnRkSyxAEFIpIl9tyISJacLdwkf4cCEd0cpJyJV8yL2ktKSqBQKCwWDw+PPtt98803ePjhh6FWqzFmzBjMnDkTjY2NVreJ4UbkJKQKt+G8qN3LywtNTU3mpaGhweL7M2fOYM6cOZg6dSr27t2Lr7/+Gi+88EK/ITgQnpYSOQmpTkuvfVE7ABQWFuLTTz9FcXEx1qxZ0+8+CoViwJdKAcCf/vQn/OpXv8Krr75qXnfbbbeJahd7bkROone0dKgFQJ8XqXd1dfV7zOG8qB0AOjo6EBQUBI1Gg+TkZBw7dsyinZ9++iluv/12JCUlYeLEiYiLi8NHH30k6udluBE5CTGnpRqNxuJl6lqttt9jDudF7WFhYSguLsb27duxdetWmEwmJCQk4Ny5cwCAlpYWdHR0YOPGjXjggQfw2Wef4ZFHHsGvf/1rVFZWWv3z8rSUyEmIOS3V6XTw8vIyr7flu4fj4+MtXgWakJCAadOmoaioCBs2bDD3HpOTk/HMM88AAGbMmIH9+/ejsLAQ9957r1V1RPfc9u3bhwULFiAgIAAKhUJ0V5GIHENMz83Ly8tiGSjchvOi9uu5u7sjKioKp0+fNh/Tzc0N4eHhFttNmzZN2tHSzs5OREZGIj8/X+yuRORAUoyW2uJF7UajEXV1dfD39zcfc+bMmThx4oTFdidPnkRQUJDVbRN9Wjp//nzMnz9f7G5E5GBSPX411IvaFy9ejEmTJpmv261fvx6zZs3ClClTcPnyZWzatAkNDQ1YsmSJ+ZirVq1CSkoK7rnnHtx3330oLy/Hxx9/jL1791rdLsmvuXV1dVmMtBgMBqlLElE/pLoVZKgXtTc2NsLF5eeTxEuXLiE9PR16vR7e3t6Ijo7G/v37LU5DH3nkERQWFkKr1WLFihUICwvDP//5T8yZM8fqdimEG3jeQqFQoKysDAsXLhxwm3Xr1uHFF1/ssz46Otoh87kNNIJjD5zPzf4GuoXBHhwxl1zv/+u2tjbzgIDBYIBarUZFRQXGjBkz6P6dnZ2YN2+exf4jleS3gmRnZ6Otrc286HQ6qUsSUT+kfPzqZiR510mlUtl0GJmIhsfZHpznfW5EToLhNoSOjg7z/SgAUF9fjyNHjmDcuHGYPHmyTRtHRLbDySqHcOjQIdx3333mz1lZWQCA1NRUlJSU2KxhRGRb7LkNYe7cubL6H0DkLBhuRCRLDDcikiWGGxHJEgcUiEiW2HMjIlliuBGRLDHciEiWGG5EJEsMNzuJiIiAUqm0e93//e9/dq/Z68cff3RYbWedbskR02r1UigUdq8pCMKAf88EQRhyNJThRkQjDntuRCRLDDcikiWGGxHJEsONiGSJj18RkSyx50ZEssRwIyJZYrgRkSwx3IhIlhhuRCRLzjZaKuqN81qtFjNnzoSnpycmTpyIhQsX4sSJE1K1jYhsyNneOC8q3CorK5GRkYGqqirs3r0bPT09uP/++9HZ2SlV+4jIRpwt3ESdlpaXl1t8LikpwcSJE1FTU4N77rnHpg0jItviNTcR2traAADjxo0bcJuuri50dXWZPxsMhhspSUTD5GzhJuq09FomkwkrV67E7NmzMX369AG302q1UKvV5kWj0Qy3JBHdgN753AZbhhtu+fn5CA4OhoeHB+Li4lBdXT3gtiUlJVAoFBaLh4fHgNsvW7YMCoUCeXl5oto07HDLyMjA0aNHUVpaOuh22dnZaGtrMy86nW64JYnoBkh1zW3btm3IyspCTk4OamtrERkZiaSkJLS0tAy4j5eXF5qamsxLQ0NDv9uVlZWhqqoKAQEBots1rHDLzMzEJ598gj179iAwMHDQbVUqFby8vCwWIrI/qcItNzcX6enpSEtLQ3h4OAoLCzF69GgUFxcPuI9CoYCfn5958fX17bPN+fPn8fvf/x7vv/8+3N3dRbdLVLgJgoDMzEyUlZXhiy++QEhIiOiCROQYYsLNYDBYLNdeN79Wd3c3ampqkJiYaF7n4uKCxMREHDhwYMC2dHR0ICgoCBqNBsnJyTh27JjF9yaTCU8++SRWrVqFO+64Y1g/r6hwy8jIwNatW/HBBx/A09MTer0eer0eV65cGVZxIrIfMeGm0WgsrpVrtdp+j3nx4kUYjcY+PS9fX1/o9fp+9wkLC0NxcTG2b9+OrVu3wmQyISEhAefOnTNv88orr8DNzQ0rVqwY9s8rarS0oKAAADB37lyL9e+88w5++9vfDrsRRCQ9MaOlOp3O4hKSSqWyWTvi4+MRHx9v/pyQkIBp06ahqKgIGzZsQE1NDbZs2YLa2tobesmOqHCT0zAxkbMR8/iVtdfHfXx84OrqiubmZov1zc3N8PPzs6pd7u7uiIqKwunTpwEA//nPf9DS0oLJkyebtzEajXj22WeRl5eHs2fPWnXcYY+WEtHIIsWAglKpRHR0NCoqKszrTCYTKioqLHpngzEajairq4O/vz8A4Mknn8TXX3+NI0eOmJeAgACsWrUKu3btsrptfHCeyElIdRNvVlYWUlNTERMTg9jYWOTl5aGzsxNpaWkAgMWLF2PSpEnm63br16/HrFmzMGXKFFy+fBmbNm1CQ0MDlixZAgAYP348xo8fb1HD3d0dfn5+CAsLs7pdDDciJyFVuKWkpKC1tRVr166FXq/HjBkzUF5ebh5kaGxshIvLzyeJly5dQnp6OvR6Pby9vREdHY39+/cjPDxcdO3BMNyInISUj19lZmYiMzOz3+/27t1r8Xnz5s3YvHmzqONbe53tWgw3IifhbPO5MdyInISzPTjPcCNyEgw3IpIlhpudhIaGDjrNiVQc+Ydny7u8xfrmm28cVru1tdVhtXt6ehxW+0burh+uwf5+M9yISLbkFF5DYbgROQmOlhKRLPG0lIhkieFGRLLEcCMiWWK4EZEscUCBiGSJPTcikiWGGxHJEsONiGTJ2cJN1DsUCgoKEBERYX55RHx8PHbu3ClV24jIhqR6KfPNSlTPLTAwEBs3bkRoaCgEQcC7776L5ORkHD58eNgvTiUi++Bo6SAWLFhg8fmll15CQUEBqqqqGG5ENzlnOy0d9jU3o9GIv//97+js7Bz0FV5dXV3o6uoyfzYYDMMtSUQ3wNnCTfR7S+vq6nDLLbdApVJh2bJlKCsrG/StNVqtFmq12rxoNJobajARDZ+zXG8DhhFuYWFhOHLkCL766issX74cqampOH78+IDbZ2dno62tzbzodLobajARDQ8HFIagVCoxZcoUAEB0dDQOHjyILVu2oKioqN/tVSqVQ2egJaKfcEBBJJPJZHFNjYhuTs52zU1UuGVnZ2P+/PmYPHky2tvb8cEHH2Dv3r3YtWuXVO0jIhthuA2ipaUFixcvRlNTE9RqNSIiIrBr1y788pe/lKp9RGQjDLdBvP3221K1g4gkxnAjIlliuBGRLHG0lIhkydl6bqJv4iWikUnKm3jz8/MRHBwMDw8PxMXFobq6esBtS0pKoFAoLBYPDw/z9z09PVi9ejXuvPNOjBkzBgEBAVi8eDEuXLggqk0MNyInIVW4bdu2DVlZWcjJyUFtbS0iIyORlJSElpaWAffx8vJCU1OTeWloaDB/98MPP6C2thYvvPACamtr8a9//QsnTpzAww8/LKpdPC0lchJSnZbm5uYiPT0daWlpAIDCwkJ8+umnKC4uxpo1a/rdR6FQwM/Pr9/v1Go1du/ebbHujTfeQGxsLBobGzF58mSr2sWeG5GT6B1QGGoBfpq959ploKeQuru7UVNTg8TERPM6FxcXJCYm4sCBAwO2paOjA0FBQdBoNEhOTsaxY8cGbXtbWxsUCgXGjh1r9c/LcCNyEmJOSzUajcVsPlqttt9jXrx4EUajEb6+vhbrfX19odfr+90nLCwMxcXF2L59O7Zu3QqTyYSEhAScO3eu3+2vXr2K1atX4/HHH4eXl5fVP6/DTktDQ0MxevRou9ft7u62e82bgbu7u8Nq19XVOax2a2urw2pfuXLFYbUHYu1pp06nswgSW05+ER8fbzEHZEJCAqZNm4aioiJs2LDBYtuenh489thjEAQBBQUFourwmhuRkxBzza33PSlD8fHxgaurK5qbmy3WNzc3D3hN7Xru7u6IiorC6dOnLdb3BltDQwO++OILUb02gKelRE5DitFSpVKJ6OhoVFRUmNeZTCZUVFQMOkP3tYxGI+rq6uDv729e1xtsp06dwueff47x48eLahfAnhuR05BqtDQrKwupqamIiYlBbGws8vLy0NnZaR49Xbx4MSZNmmS+brd+/XrMmjULU6ZMweXLl7Fp0yY0NDRgyZIlAH4Ktt/85jeora3FJ598AqPRaL5+N27cOCiVSqvaxXAjchJSPX6VkpKC1tZWrF27Fnq9HjNmzEB5ebl5kKGxsREuLj+fJF66dAnp6enQ6/Xw9vZGdHQ09u/fb35dwfnz57Fjxw4AwIwZMyxq7dmzB3PnzrWqXQw3Iich5eNXmZmZyMzM7Pe7vXv3WnzevHkzNm/ePOCxgoODbfIYGMONyEk427OlDDciJ8FwIyJZYrgRkSxxPjcikiX23IhIlpwt3G7oCYWNGzdCoVBg5cqVNmoOEUmFb5y30sGDB1FUVISIiAhbtoeIJMKemxU6OjqwaNEivPXWW/D29rZ1m4hIAs7WcxtWuGVkZODBBx+0mKBuIF1dXX0mviMi+xMEYciJKuUUbqJPS0tLS1FbW4uDBw9atb1Wq8WLL74oumFEZFs8LR2ETqfD008/jffff9/ibTWDyc7ORltbm3nR6XTDaigR3RhnOy0V1XOrqalBS0sL7rrrLvM6o9GIffv24Y033kBXVxdcXV0t9lGpVDadxZOIhsfZem6iwm3evHl9poxOS0vD1KlTsXr16j7BRkQ3D4bbIDw9PTF9+nSLdWPGjMH48eP7rCeimwsfvyIiWWLPTaTrJ6IjopsTw42IZInhRkSyxHAjIlliuBGRLHG0lIhkiT03IpIlhhsRyRLDjYhkieFmJ7fddhtuueUWu9dtb2+3e81eCoXCYbXd3d0dVtuRF6mPHj3qsNrfffed3WsKgoArV64M+N1QfxYMNyIacdhzIyJZYrgRkSwx3IhIlpwt3G7ovaVENHJIOc14fn4+goOD4eHhgbi4OFRXVw+4bUlJCRQKhcVy/WsLBEHA2rVr4e/vj1GjRiExMRGnTp0S1SaGG5GTGOrNV9Y8ntWfbdu2ISsrCzk5OaitrUVkZCSSkpLQ0tIy4D5eXl5oamoyLw0NDRbfv/rqq3jttddQWFiIr776CmPGjEFSUhKuXr1qdbsYbkROQqqeW25uLtLT05GWlobw8HAUFhZi9OjRKC4uHnAfhUIBPz8/8+Lr62vRzry8PDz//PNITk5GREQE3nvvPVy4cAEfffSR1e1iuBE5CTHhdv27hru6uvo9Znd3N2pqaizeYezi4oLExEQcOHBgwLZ0dHQgKCgIGo0GycnJOHbsmPm7+vp66PV6i2Oq1WrExcUNeszrMdyInISYcNNoNFCr1eZFq9X2e8yLFy/CaDRa9LwAwNfXF3q9vt99wsLCUFxcjO3bt2Pr1q0wmUxISEjAuXPnAMC8n5hj9oejpUROQsxoqU6ng5eXl3m9LV/PGR8fj/j4ePPnhIQETJs2DUVFRdiwYYPN6rDnRuQkxAwoeHl5WSwDhZuPjw9cXV3R3Nxssb65uRl+fn5Wtcvd3R1RUVE4ffo0AJj3u5FjAiLDbd26dX2GcKdOnSrmEETkIFIMKCiVSkRHR6OiosK8zmQyoaKiwqJ3Nhij0Yi6ujr4+/sDAEJCQuDn52dxTIPBgK+++srqYwLDOC2944478Pnnn/98ADee2RKNBFLdxJuVlYXU1FTExMQgNjYWeXl56OzsRFpaGgBg8eLFmDRpkvm63fr16zFr1ixMmTIFly9fxqZNm9DQ0IAlS5YA+GkkdeXKlfjzn/+M0NBQhISE4IUXXkBAQAAWLlxodbtEJ5Obm5uoriER3RykCreUlBS0trZi7dq10Ov1mDFjBsrLy80DAo2NjXBx+fkk8dKlS0hPT4der4e3tzeio6Oxf/9+hIeHm7f5wx/+gM7OTixduhSXL1/GnDlzUF5e3udm38EoBBE/zbp167Bp0yao1Wp4eHggPj4eWq0WkydPHnCfrq4ui2Fkg8EAjUaD2tpah0x5VFtba/eava6/UdGeGhsbHVb722+/dVhtZ53yqK2tzTwgYDAYoFarER0dPeSZ1o8//oiamhqL/UcqUdfc4uLiUFJSgvLychQUFKC+vh533333oHOkabVaiyFljUZzw40mouGR4tGrm5WocJs/fz4effRRREREICkpCf/+979x+fJlfPjhhwPuk52djba2NvOi0+luuNFEJJ5Uj1/drG5oNGDs2LG4/fbbzUO4/VGpVDa9R4aIhoezgojQ0dGBM2fOmIdwiejmJeWsIDcjUeH23HPPobKyEmfPnsX+/fvxyCOPwNXVFY8//rhU7SMiG3G2cBN1Wnru3Dk8/vjj+O677zBhwgTMmTMHVVVVmDBhglTtIyIbcbbTUlHhVlpaKlU7iEhiJpNpyDewcUCBiEYc9tyISJYYbkQkSww3IpIlhhsRyRLDjYhkiaOlRCRL7LkRkSwx3Ozktttuc8h8UQaDwe41ezly1uJrJwu0N6VS6bDajjzNcsRcciaTCVeuXBnwezmF11DYcyNyEuy5EZEsMdyISJasOUXnaCkRjTjsuRGRLDHciEiWGG5EJEsMNyKSJQ4oEJEssedGRLLEcCMiWXK2cBP9wOH58+fxxBNPYPz48Rg1ahTuvPNOHDp0SIq2EZEN8dV+g7h06RJmz56N++67Dzt37sSECRNw6tQpeHt7S9U+IrIRZ+u5iQq3V155BRqNBu+88455XUhIiM0bRUS252yjpaJOS3fs2IGYmBg8+uijmDhxIqKiovDWW28Nuk9XVxcMBoPFQkSOIdUpaX5+PoKDg+Hh4YG4uDhUV1dbtV9paSkUCgUWLlxosb6jowOZmZkIDAzEqFGjEB4ejsLCQlFtEhVu3377LQoKChAaGopdu3Zh+fLlWLFiBd59990B99FqtVCr1eZFo9GIaiAR2YZU19y2bduGrKws5OTkoLa2FpGRkUhKSkJLS8ug+509exbPPfcc7r777j7fZWVloby8HFu3bsU333yDlStXIjMzEzt27LC6XaLCzWQy4a677sLLL7+MqKgoLF26FOnp6YMmanZ2Ntra2syLTqcTU5KIbESqcMvNzUV6ejrS0tLMPazRo0ejuLh4wH2MRiMWLVqEF198Ebfeemuf7/fv34/U1FTMnTsXwcHBWLp0KSIjI63uEQIiw83f3x/h4eEW66ZNm4bGxsYB91GpVPDy8rJYiMj+xITb9ZeSurq6+j1md3c3ampqkJiYaF7n4uKCxMREHDhwYMC2rF+/HhMnTsRTTz3V7/cJCQnYsWMHzp8/D0EQsGfPHpw8eRL333+/1T+vqHCbPXs2Tpw4YbHu5MmTCAoKEnMYInIAk8lk1QIAGo3G4nKSVqvt95gXL16E0WiEr6+vxXpfX1/o9fp+9/nyyy/x9ttvD3q9/vXXX0d4eDgCAwOhVCrxwAMPID8/H/fcc4/VP6+o0dJnnnkGCQkJePnll/HYY4+huroab775Jt58800xhyEiB7DmlLN3G51OZ3GWpVKpbNKG9vZ2PPnkk3jrrbfg4+Mz4Havv/46qqqqsGPHDgQFBWHfvn3IyMhAQECARS9xMKLCbebMmSgrK0N2djbWr1+PkJAQ5OXlYdGiRWIOQ0QOICbcrL2E5OPjA1dXVzQ3N1usb25uhp+fX5/tz5w5g7Nnz2LBggXmdb29RTc3N5w4cQIBAQH44x//iLKyMjz44IMAgIiICBw5cgR/+ctfpAk3AHjooYfw0EMPid2NiBxMTLhZS6lUIjo6GhUVFebbOUwmEyoqKpCZmdln+6lTp6Kurs5i3fPPP4/29nZs2bIFGo0GV69eRU9PT583trm6uoq6D4/PlhI5CSnCDfjpto3U1FTExMQgNjYWeXl56OzsRFpaGgBg8eLFmDRpErRaLTw8PDB9+nSL/ceOHQsA5vVKpRL33nsvVq1ahVGjRiEoKAiVlZV47733kJuba3W7GG5ETkKqcEtJSUFrayvWrl0LvV6PGTNmoLy83DzI0NjYKPq9uaWlpcjOzsaiRYvw/fffIygoCC+99BKWLVtm9TEUgp0fJjMYDFCr1Whra3PIbSE1NTV2r9nr7NmzDqtdX1/vsNoXLlxwWO3jx487rLajXsrc1NRk8fvV+zvn7u4OhUIx6P6CIKCnp8dhv5+2xJ4bkZOQqud2s2K4ETkJhhsRyRLDjYhkieEmsWufXXOEjo4Oh9QFgB9++MFhta9eveqw2gM9l2gPP/74o8NqO2JutN6a/YWU3GbaHYrdw629vR0AOPURkYTa29uhVqsB/HTfmJ+f34DPel7Pz88PSqVSyubZhd1vBTGZTLhw4QI8PT2HHJa+nsFggEaj6fPcmz2wNmuPhNqCIKC9vR0BAQEW95ZdvXoV3d3dVh1DqVTCw8NDVN2bkd17bi4uLggMDLyhYzhy6iTWZu2bvXZvj+1aHh4esggsMUS//YqIaCRguBGRLI2ocFOpVMjJybHZ3FKszdqsLV92H1AgIrKHEdVzIyKyFsONiGSJ4UZEssRwIyJZGlHhlp+fj+DgYHh4eCAuLk7UC1qHa9++fViwYAECAgKgUCjw0UcfSV6zl1arxcyZM+Hp6YmJEydi4cKFfV6tKJWCggJERESYbySNj4/Hzp077VL7Whs3boRCocDKlSvtUm/dunVQKBQWy9SpU+1S+/z583jiiScwfvx4jBo1CnfeeScOHTpkl9pyNGLCbdu2bcjKykJOTg5qa2sRGRmJpKQktLS0SFq3s7MTkZGRyM/Pl7ROfyorK5GRkYGqqirs3r0bPT09uP/++9HZ2Sl57cDAQGzcuBE1NTU4dOgQfvGLXyA5ORnHjh2TvHavgwcPoqioCBEREXarCQB33HEHmpqazMuXX34pec1Lly5h9uzZcHd3x86dO3H8+HH89a9/hbe3t+S1ZUsYIWJjY4WMjAzzZ6PRKAQEBAhardZubQAglJWV2a3e9VpaWgQAQmVlpUPqe3t7C3/729/sUqu9vV0IDQ0Vdu/eLdx7773C008/bZe6OTk5QmRkpF1qXWv16tXCnDlz7F5XzkZEz627uxs1NTUW7yt0cXFBYmIiDhw44MCW2VdbWxsAYNy4cXatazQaUVpais7OTsTHx9ulZkZGBh588EGr31FpS6dOnUJAQABuvfVWLFq0CI2NjZLX3LFjB2JiYvDoo49i4sSJiIqKGvSN7DS0ERFuFy9ehNFoNL9Np5evr6/V07iMdCaTCStXrsTs2bP7vBpNKnV1dbjlllugUqmwbNkylJWVITw8XPK6paWlqK2thVarlbzW9eLi4lBSUoLy8nIUFBSgvr4ed999t3mqLql8++23KCgoQGhoKHbt2oXly5djxYoVePfddyWtK2eciXeEyMjIwNGjR+1y/adXWFgYjhw5gra2NvzjH/9AamoqKisrJQ04nU6Hp59+Grt373bILBbz5883/3dERATi4uIQFBSEDz/8EE899ZRkdU0mE2JiYvDyyy8DAKKionD06FEUFhYiNTVVsrpyNiJ6bj4+PnB1dUVzc7PF+ubmZvj5+TmoVfaTmZmJTz75BHv27Lnh6aLEUCqVmDJlCqKjo6HVahEZGYktW7ZIWrOmpgYtLS2466674ObmBjc3N1RWVuK1116Dm5sbjEajpPWvN3bsWNx+++04ffq0pHX8/f37/KMxbdo0u5wSy9WICDelUono6GhUVFSY15lMJlRUVNjtGpAjCIKAzMxMlJWV4YsvvkBISIhD22MymSSfMnzevHmoq6vDkSNHzEtMTAwWLVqEI0eOwNXVVdL61+vo6MCZM2fg7+8vaZ3Zs2f3uc3n5MmTCAoKkrSurDl6RMNapaWlgkqlEkpKSoTjx48LS5cuFcaOHSvo9XpJ67a3twuHDx8WDh8+LAAQcnNzhcOHDwsNDQ2S1hUEQVi+fLmgVquFvXv3Ck1NTeblhx9+kLz2mjVrhMrKSqG+vl74+uuvhTVr1ggKhUL47LPPJK99PXuOlj777LPC3r17hfr6euG///2vkJiYKPj4+AgtLS2S1q2urhbc3NyEl156STh16pTw/vvvC6NHjxa2bt0qaV05GzHhJgiC8PrrrwuTJ08WlEqlEBsbK1RVVUlec8+ePQKAPktqaqrktfurC0B45513JK/9u9/9TggKChKUSqUwYcIEYd68eQ4JNkGwb7ilpKQI/v7+glKpFCZNmiSkpKQIp0+ftkvtjz/+WJg+fbqgUqmEqVOnCm+++aZd6soVpzwiIlkaEdfciIjEYrgRkSwx3IhIlhhuRCRLDDcikiWGGxHJEsONiGSJ4UZEssRwIyJZYrgRkSwx3IhIlhhuRCRL/wcSI3/tV8eycgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 300x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    constraint_nn = torch.nn.Sequential(\n",
    "        torch.nn.Linear(constraint_fn_input_dim, hidden_dim), torch.nn.ReLU(),\n",
    "        torch.nn.Linear(hidden_dim, hidden_dim), torch.nn.ReLU(),\n",
    "        torch.nn.Linear(hidden_dim, 1), torch.nn.Sigmoid(),\n",
    "    )\n",
    "    constraint_opt = torch.optim.Adam(constraint_nn.parameters(), lr=learning_rate)\n",
    "    visualize_constraint(current_constraint_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "528fa7dd-0b8c-4fb5-8b02-7d957f21f77c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7c683e3686314d109812b061e271b2c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "febc268795964575a8abad5f8dadede7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    expert_data = generate_expert_data(env)\n",
    "    visualize_accrual(expert_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "eeb85fc1-2dcd-4747-bf8b-d1f14bf43d9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'avg_nll': 2.24755309178279, 'std_nll': 0.14424446043900727}\n",
      "{'avg_nll': 2.066843908566695, 'std_nll': 0.08905543378543862}\n",
      "{'avg_nll': 1.9754672646522522, 'std_nll': 0.07425115636972114}\n",
      "{'avg_nll': 1.867663167990171, 'std_nll': 0.1071869789911104}\n",
      "{'avg_nll': 1.686857397739704, 'std_nll': 0.10720399854009736}\n",
      "{'avg_nll': 1.454549592274886, 'std_nll': 0.1454145007086213}\n",
      "{'avg_nll': 1.2890073565336375, 'std_nll': 0.1241290860548404}\n",
      "{'avg_nll': 1.144765936411344, 'std_nll': 0.18100003533605957}\n",
      "{'avg_nll': 1.1555754840373993, 'std_nll': 0.5734541329946926}\n",
      "{'avg_nll': 1.4207507555301373, 'std_nll': 0.1951595117079672}\n",
      "{'avg_nll': 1.1500869324574103, 'std_nll': 0.16274897487443293}\n",
      "{'avg_nll': 0.9985516163019034, 'std_nll': 0.2507731558283449}\n",
      "{'avg_nll': 1.21943687246396, 'std_nll': 0.23286599721598253}\n",
      "{'avg_nll': 1.0024722172663763, 'std_nll': 0.16273307826036715}\n",
      "{'avg_nll': 0.8999180885461661, 'std_nll': 0.42540828668531366}\n",
      "{'avg_nll': 1.0993613600730896, 'std_nll': 0.27324144826001906}\n",
      "{'avg_nll': 0.8824206774051373, 'std_nll': 0.14356913749959077}\n",
      "{'avg_nll': 1.0270679833797307, 'std_nll': 0.9500063812704055}\n",
      "{'avg_nll': 1.6422188511261573, 'std_nll': 0.5345700620753423}\n",
      "{'avg_nll': 1.1967134659106915, 'std_nll': 0.12261583886355361}\n"
     ]
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    flow_data = convert_to_flow_data(expert_data)\n",
    "    flow_config = tools.data.Configuration({\n",
    "        \"normalize_flow_inputs\": True,\n",
    "        \"minibatch_size\": minibatch_size,\n",
    "        \"learning_rate\": learning_rate,\n",
    "    })\n",
    "    flow_config[\"t\"].device = device\n",
    "    flow = tools.functions.create_flow(flow_config, flow_data, \"realnvp\", constraint_fn_input_dim)\n",
    "    for flowepoch in range(flow_iters):\n",
    "        metrics = flow.train()\n",
    "        print(metrics)\n",
    "    nll = -flow.log_probs(flow_data)\n",
    "    expert_nll = (nll.mean(), nll.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c2d0d671-709f-4b71-b56f-5b9277af4777",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expert satisfaction = 0.00\n",
      "ICL iteration 0 ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f62878fe2d234e669de13a551e1acea9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73bf4f2cc77e43e5a56cceb03ed97b2b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.58\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a740547ae0fb4f729ce6d3403603ba1a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.60\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2048c739fe743eb854ac4d970d51566",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0aa4b0bef422401e96a747143ee81d31",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1fb32e1c441b4aa08b8ae678f2c4daba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expert satisfaction = 0.90\n",
      "ICL iteration 1 ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "68b491bc70e84af0b09fe35cd6fd159c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "46b00b89f16d406f93f607406d8542e6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.68\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da0d9881d40b448abc8748490adcd551",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.72\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e787d6b69c94a43b26855f5aed6dcb8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9849a0c1b72649c89c78bda4269eae88",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAESCAYAAAAsSmYhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAABt80lEQVR4nO3deVxU9f4/8NeAzKDAIC6AIopb7iso4b6QaC6X3JcSybRMSuVbV60UlxLLJSwX0lLrphfTtGvmcglFb4qpKOWS5oJKKrglKCooc35/8JvRcQaYgVnOfHg9H4/zeMThzPl8hpiXn/Pmcz5HIUmSBCIiIiIiIiIiIhtysncHiIiIiIiIiIio/GFRioiIiIiIiIiIbI5FKSIiIiIiIiIisjkWpYiIiIiIiIiIyOZYlCIiIiIiIiIiIptjUYqIiIiIiIiIiGyORSkiIiIiIiIiIrI5FqWIiIiIiIiIiMjmWJQiIiIiIiIiIiKbY1GKHFa3bt3QrVs3e3eDyOHws1O8gIAAjBkzxmbtZWRkwNXVFfv379ftGzNmDAICAmzWB1sYPnw4hg4dau9uEJGF2ToziYhMcfHiRSgUCqxdu9beXaESsChVDIVCYdKWnJxs767K0qlTpzBr1ixcvHjR3l0xsH79esTFxdm7G2RHa9euhUKhwJEjR+zdFTLTgQMHMGvWLNy5c8feXTGwfPlyswc/c+bMQXBwMDp27FjkMffv38esWbNk+e/NRx99hAEDBsDHxwcKhQKzZs0yetzUqVPx/fff47fffrNtB0l2tPlb1Hbw4EF7d7FY27dvL/L3nIjEtnz5cigUCgQHB9u7K0aVZhxCZG8V7N0BOfvXv/6l9/U333yDxMREg/1NmjSxZbccxqlTpzB79mx069bNKn/x/+9//1vq165fvx4nTpzA5MmTLdchIrKJAwcOYPbs2RgzZgwqV65s8fOfOXMGTk6l+5vN8uXLUa1aNZNnDdy4cQNff/01vv76a739q1atgkaj0X19//59zJ49GwBkN8vtgw8+gK+vL9q0aYNdu3YVeVybNm0QFBSERYsW4ZtvvrFhD0mu5syZg7p16xrsb9CggR16Y7rt27dj2bJlLEwRlUPr1q1DQEAADh06hHPnzskur8wdhxDJAYtSxXj55Zf1vj548CASExMN9j/r/v37qFSpkjW7JhxJkvDw4UNUrFjR5NcolUor9ojINh4/fgyNRsPfZyvRaDTIz8+Hq6urya9RqVRW7JG+b7/9FhUqVED//v319ru4uJTpvLm5uXBzcyvTOUyVnp6OgIAA3Lx5E9WrVy/22KFDhyImJgbLly+Hu7u7TfpH8tWnTx8EBQXZuxsms+XnytIcue9EcpGeno4DBw5g8+bNeP3117Fu3TrExMTYu1sOj9fOxNv3yqhbt25o3rw5UlNT0aVLF1SqVAnvvfceABR5G4Oxe+/v3LmDyZMnw9/fHyqVCg0aNMDHH3+s95fy4uzYsQNdu3aFh4cH1Go12rVrh/Xr1+sds3HjRgQGBqJixYqoVq0aXn75ZVy5ckXvmDFjxsDd3R1XrlxBeHg43N3dUb16dbzzzjsoKCjQOzYhIQGBgYG6Nlu0aIElS5YAKJyaP2TIEABA9+7dDW51DAgIQL9+/bBr1y4EBQWhYsWK+OKLLwAAa9asQY8ePeDt7Q2VSoWmTZtixYoVRn/2T88YSE5OhkKhwHfffYePPvoItWrVgqurK3r27Ilz587pve6nn37CpUuXdP0Sbe0WspwrV67g1VdfhY+PD1QqFZo1a4bVq1frHZOfn4+ZM2ciMDAQnp6ecHNzQ+fOnbFnzx6947T3ti9cuBBxcXGoX78+VCqV7lZXhUKBc+fO6WYAeXp6IjIyEvfv3zfo17fffqv7PFepUgXDhw9HRkaGwXErV65E/fr1UbFiRbRv3x7/+9//zHr/3377Ldq3b49KlSrBy8sLXbp0MZiluHz5cjRr1gwqlQo1a9bExIkTDW6t02blqVOn0L17d1SqVAl+fn745JNPDNr8/PPP0axZM12bQUFBujybNWsW3n33XQBA3bp1dZ9h7W3CCoUCUVFRWLduna5PO3fuBAAsXLgQHTp0QNWqVVGxYkUEBgZi06ZNBu0/m9HaW43279+P6OhoVK9eHW5ubnjppZdw48YNvdedPHkSe/fu1fWrpFlNP/zwA4KDgw0KNE+vKXXx4kVdsWf27Nm6c2v/fdHm9vnz5/Hiiy/Cw8MDo0aNKrZdSzInP1944QXk5uYiMTHReh0iYcTExMDJyQlJSUl6+8ePHw+lUqm7FVT77/+GDRvw3nvvwdfXF25ubhgwYIDRXPz111/Ru3dveHp6olKlSujatavemm4AdJl86tQpjBw5El5eXujUqRPGjBmDZcuWAdBf5qE4//nPf9C3b1/UrFkTKpUK9evXx9y5cw3GVdq+vfjii/Dy8oKbmxtatmypG1tpnT59GkOHDkX16tVRsWJFNGrUCO+//36JfQeKXlPQ2Dp2pmYmUXmxbt06eHl5oW/fvhg8eDDWrVtn9Lhbt27hlVdegVqtRuXKlREREYHffvvN6PpGp0+fxuDBg1GlShW4uroiKCgIW7du1TvGmuMQcz7npowJS7omtcS18+3bt/HOO++gRYsWcHd3h1qtRp8+fbg8gAPjTCkLuHXrFvr06YPhw4fj5Zdfho+Pj1mvv3//Prp27YorV67g9ddfR+3atXHgwAFMnz4d165dK3Hto7Vr1+LVV19Fs2bNMH36dFSuXBnHjh3Dzp07MXLkSN0xkZGRaNeuHWJjY5GVlYUlS5Zg//79OHbsmN4tMAUFBQgLC0NwcDAWLlyIn3/+GYsWLUL9+vUxYcIEAEBiYiJGjBiBnj174uOPPwYA/PHHH9i/fz8mTZqELl264O2338Znn32G9957T3eL49O3Op45cwYjRozA66+/jnHjxqFRo0YAgBUrVqBZs2YYMGAAKlSogB9//BFvvvkmNBoNJk6cWOLPc/78+XBycsI777yD7OxsfPLJJxg1ahR+/fVXAMD777+P7Oxs/PXXX/j0008BgH+xJ6OysrLw/PPP6wod1atXx44dOzB27Fjk5OTobv/MycnBl19+iREjRmDcuHG4e/cuvvrqK4SFheHQoUNo3bq13nnXrFmDhw8fYvz48VCpVKhSpYrue0OHDkXdunURGxuLo0eP4ssvv4S3t7fucwYUruEzY8YMDB06FK+99hpu3LiBzz//HF26dNH7PH/11Vd4/fXX0aFDB0yePBkXLlzAgAEDUKVKFfj7+5f4/mfPno1Zs2ahQ4cOmDNnDpRKJX799Vfs3r0bvXr1AlB48TN79myEhoZiwoQJOHPmDFasWIHDhw9j//79ejN+/v77b/Tu3RsDBw7E0KFDsWnTJkydOhUtWrRAnz59ABTetvb2229j8ODBmDRpEh4+fIjff/8dv/76K0aOHImBAwfizz//xL///W98+umnqFatGgDozdDZvXs3vvvuO0RFRaFatWq6C60lS5ZgwIABGDVqFPLz85GQkIAhQ4Zg27Zt6Nu3b4k/j7feegteXl6IiYnBxYsXERcXh6ioKGzYsAEAEBcXh7feegvu7u66C8Ti/j149OgRDh8+rMvVolSvXh0rVqzAhAkT8NJLL2HgwIEAgJYtW+qOefz4McLCwtCpUycsXLiw2L84Pnr0CNnZ2SW+XwCoUqVKqW9lNKZp06aoWLEi9u/fj5deesli5yXHlJ2djZs3b+rtUygUqFq1KoDCW0N//PFHjB07FsePH4eHhwd27dqFVatWYe7cuWjVqpXeaz/66CMoFApMnToV169fR1xcHEJDQ5GWlqabib1792706dMHgYGBuqKX9o9h//vf/9C+fXu9cw4ZMgQNGzbEvHnzIEkS2rRpg6tXrxpdzqEoa9euhbu7O6Kjo+Hu7o7du3dj5syZyMnJwYIFC3THJSYmol+/fqhRowYmTZoEX19f/PHHH9i2bRsmTZoEAPj999/RuXNnuLi4YPz48QgICMD58+fx448/4qOPPiq27+Yqa2YSiWbdunUYOHAglEolRowYoRvvtGvXTneMRqNB//79cejQIUyYMAGNGzfGf/7zH0RERBic7+TJk+jYsSP8/Pwwbdo0uLm54bvvvkN4eDi+//57g38nLT0OAUz/nJsyJjTlmhQo+7XzhQsX8MMPP2DIkCGoW7cusrKy8MUXX6Br1644deoUatasadb5SAYkMtnEiROlZ39kXbt2lQBI8fHxBscDkGJiYgz216lTR4qIiNB9PXfuXMnNzU36888/9Y6bNm2a5OzsLF2+fLnIPt25c0fy8PCQgoODpQcPHuh9T6PRSJIkSfn5+ZK3t7fUvHlzvWO2bdsmAZBmzpyp2xcRESEBkObMmaN3rjZt2kiBgYG6rydNmiSp1Wrp8ePHRfZt48aNEgBpz549Rn8GAKSdO3cafO/+/fsG+8LCwqR69erp7evatavUtWtX3dd79uyRAEhNmjSR8vLydPuXLFkiAZCOHz+u29e3b1+pTp06RfadxLdmzRoJgHT48OEijxk7dqxUo0YN6ebNm3r7hw8fLnl6eup+Vx8/fqz3OydJkvT3339LPj4+0quvvqrbl56eLgGQ1Gq1dP36db3jY2JiJAB6x0uSJL300ktS1apVdV9fvHhRcnZ2lj766CO9444fPy5VqFBBt1/7uW/durVe31auXCkB0PvsGHP27FnJyclJeumll6SCggK972mz5fr165JSqZR69eqld8zSpUslANLq1at1+7RZ+c033+j25eXlSb6+vtKgQYN0+/7xj39IzZo1K7ZvCxYskABI6enpBt8DIDk5OUknT540+N6z2ZKfny81b95c6tGjh97+ZzNa+7sSGhqqe++SJElTpkyRnJ2dpTt37uj2NWvWrMSfrda5c+ckANLnn39u8L2IiAi9jLpx40aR/6Zoc3vatGkmtavNSlM2Yz/johTXx6c999xzUp8+fUw+L4lH+5kytqlUKr1jjx8/LimVSum1116T/v77b8nPz08KCgqSHj16pDtG+zvt5+cn5eTk6PZ/9913EgBpyZIlkiQVZlfDhg2lsLAwvc/y/fv3pbp160ovvPCCbp82k0eMGGHQf2PjweIYG9e8/vrrUqVKlaSHDx9KklT470jdunWlOnXqSH///bfesU/3tUuXLpKHh4d06dKlIo8pru/Pjp20ns0cY/02NTOJRHTkyBEJgJSYmChJUuFnrlatWtKkSZP0jvv+++8lAFJcXJxuX0FBgdSjRw8JgLRmzRrd/p49e0otWrTQ5YD2vB06dJAaNmyo22etcYgkmfY5N2VMaMo1qSRZ5tr54cOHBv1IT0+XVCqV3jWsdtz99M+c5Im371mASqVCZGRkqV+/ceNGdO7cGV5eXrh586ZuCw0NRUFBAfbt21fkaxMTE3H37l1MmzbNYM0U7XTyI0eO4Pr163jzzTf1junbty8aN26Mn376yeC8b7zxht7XnTt3xoULF3RfV65cucy3YNStWxdhYWEG+59eV0r7V9SuXbviwoULJv11PzIyUm99ns6dOwOAXv+JSiJJEr7//nv0798fkiTpfTbDwsKQnZ2No0ePAgCcnZ11v3MajQa3b9/G48ePERQUpDvmaYMGDSpy7R1jn71bt24hJycHALB582ZoNBoMHTpUr0++vr5o2LCh7pZB7ef+jTfe0Ps8jBkzBp6eniW+/x9++AEajQYzZ840mCmjzZaff/4Z+fn5mDx5st4x48aNg1qtNsgWd3d3vTX5lEol2rdvb5Atf/31Fw4fPlxiH4vStWtXNG3a1GD/09ny999/Izs7G507dzb6/8iY8ePH692m07lzZxQUFODSpUul6uetW7cAAF5eXqV6/bNKmnGl1apVKyQmJpq0+fr6WqRvT9P+W0e0bNkyg9+5HTt26B3TvHlzzJ49G19++SXCwsJw8+ZNfP3116hQwXCy/+jRo+Hh4aH7evDgwahRowa2b98OAEhLS8PZs2cxcuRI3Lp1S5efubm56NmzJ/bt22ewbMKzmVwaT2fP3bt3cfPmTXTu3Bn379/H6dOnAQDHjh1Deno6Jk+ebPAAB23u3LhxA/v27cOrr76K2rVrGz3Gkn0va2YSiWTdunXw8fFB9+7dARR+5oYNG4aEhAS9W3F37twJFxcXjBs3TrfPycnJ4G6P27dvY/fu3Rg6dKguF27evIlbt24hLCwMZ8+eNVhmxdLjEMC0z7kpY0JTrkm1ynrtrFKpdP0oKCjArVu34O7ujkaNGjGfHBRv37MAPz+/Mi1SfPbsWfz+++9FXqRev369yNeeP38eQOGgrSjaoNLeHve0xo0b45dfftHb5+rqatAXLy8v/P3337qv33zzTXz33Xfo06cP/Pz80KtXLwwdOhS9e/cush/PMvbEHQDYv38/YmJikJKSYrCWTnZ2dokX1M8O1LQXfE/3n6gkN27cwJ07d7By5UqsXLnS6DFPfza//vprLFq0CKdPn8ajR490+439nhf1uw8U//urVqtx9uxZSJKEhg0bGn299nY57ef+2eNcXFxQr169ItvXOn/+PJycnIwWd7SKyhalUol69eoZDJJq1aplMDDx8vLC77//rvt66tSp+Pnnn9G+fXs0aNAAvXr1wsiRI9GxY8cS+6xV1M9327Zt+PDDD5GWloa8vDzd/pLWg9GyVrZIpbit5lkVKlRArVq1TDrWy8sLoaGhZW6ztCRJMvlnTmJr3769SQudv/vuu0hISMChQ4cwb968InPp2bxTKBRo0KCBbs25s2fPAoDR22i0srOz9QrFxeW1qU6ePIkPPvgAu3fv1v2B4en2ANPGc9oCfnHHPK2sfS9rZhKJoqCgAAkJCejevTvS09N1+4ODg7Fo0SIkJSXpbmG7dOkSatSoYXAb/bNP6Tt37hwkScKMGTMwY8YMo+1ev34dfn5+uq+tMQ4x5XNuypjQlAzTKuu1s0ajwZIlS7B8+XKkp6frFQW1t3+TY2FRygLMeWIcAIOFLTUaDV544QX885//NHr8c889V+q+lYazs3OJx3h7eyMtLQ27du3Cjh07sGPHDqxZswajR482eLR5UYz93M6fP4+ePXuicePGWLx4Mfz9/aFUKrF9+3Z8+umnJi38XlT/LXHhR+WH9nft5ZdfLvICRrumz7fffosxY8YgPDwc7777Lry9veHs7IzY2FjdP9JPKy4zSvr91Wg0UCgU2LFjh9Fj5bw+mimfzSZNmuDMmTPYtm0bdu7cie+//x7Lly/HzJkzMXv2bJPaMfbz/d///ocBAwagS5cuWL58OWrUqAEXFxesWbPG4KEQZem/ObQDJ0sUzJ/+q2FJ8vPzcfv2bZOOrV69ukn/Jpjj77//LrKoSmTMhQsXdAWl48ePl/o82lxfsGCBwVp/Ws9mqLljvGfduXMHXbt2hVqtxpw5c1C/fn24urri6NGjmDp1qskPtCkNY31XKBRGM+vZsaklMpNIFLt378a1a9eQkJCAhIQEg++vW7dOV5Qylfaz/8477xi9cwQwLGRZehxir895Wa+d582bhxkzZuDVV1/F3LlzdetfTp482aqZStbDopQVeXl5GTyBKj8/H9euXdPbV79+fdy7d69Uf7muX78+AODEiRMGwaVVp04dAIULi/fo0UPve2fOnNF931xKpRL9+/dH//79odFo8Oabb+KLL77AjBkz0KBBg1L9Je3HH39EXl4etm7dqvfXgGefYlZW/CsflaR69erw8PBAQUFBiZ/NTZs2oV69eti8ebPe75Y1HhNcv359SJKEunXrFluw1n6uz549q/e5f/ToEdLT0w0WCDbWjkajwalTp4q8eHs6W56efZWfn4/09PRSz8Zxc3PDsGHDMGzYMOTn52PgwIH46KOPMH36dLi6upbq8/v999/D1dUVu3btgkql0u1fs2ZNqfpYFHP6Vrt2bVSsWFHvr66WOG9JDhw4oLv9oCTp6ekWfTrp48ePkZGRgQEDBljsnCQ2jUaDMWPGQK1WY/LkyZg3bx4GDx6sW/D/adrClZYkSTh37pzuDwjaMZNarS7TbEFzPo/Jycm4desWNm/ejC5duuj2P/u5f3o8V1TftDl74sQJc7us4+XlZXQ5g2dnttoqM4kcwbp16+Dt7a178ubTNm/ejC1btiA+Ph4VK1ZEnTp1sGfPHty/f19vttTTTwIHnnyeXVxcLDp72Zx8MvVzbsqY0JRr0pKYeu28adMmdO/eHV999ZXe/jt37ugegEOOhWtKWVH9+vUN1oNauXKlQbV36NChSElJwa5duwzOcefOHTx+/LjINnr16gUPDw/Exsbi4cOHet/TVs2DgoLg7e2N+Ph4vWmZO3bswB9//FGqJ6ho10LRcnJy0g36tG24ubnp3oOptH8BeLrin52dbfFBkJubm8lPn6LyydnZGYMGDcL3339v9ALg6UfwGvu9/fXXX5GSkmLxfg0cOBDOzs6YPXu2wV/GJEnSfTaDgoJQvXp1xMfHIz8/X3fM2rVrTfpMhoeHw8nJCXPmzDH4q5O23dDQUCiVSnz22Wd6ffnqq6+QnZ1tkWxRKpVo2rQpJEnS3RZZ2mxRKBR6+Xvx4kX88MMPZvexOG5ubib3y8XFBUFBQThy5EiJx2oHtua856LYc02pU6dO4eHDh+jQoYNFz0viWrx4MQ4cOICVK1di7ty56NChAyZMmGB0XbJvvvkGd+/e1X29adMmXLt2Tfd0z8DAQNSvXx8LFy7EvXv3DF7/dK4Xx5wMMvbvQ35+PpYvX653XNu2bVG3bl3ExcUZnFf72urVq6NLly5YvXo1Ll++bPSYktSvXx+nT5/We6+//fYb9u/fb9BvW2Qmkdw9ePAAmzdvRr9+/TB48GCDLSoqCnfv3sXWrVsBAGFhYXj06BFWrVqlO4dGozEoaHl7e6Nbt2744osvDIougOl59CxzxiGmfs5NGROack1aElOvnZ2dnQ3OuXHjRoM1uMhxcKaUFb322mt44403MGjQILzwwgv47bffsGvXLoMK7rvvvoutW7eiX79+GDNmDAIDA5Gbm4vjx49j06ZNuHjxYpFVX7VajU8//RSvvfYa2rVrh5EjR8LLywu//fYb7t+/j6+//houLi74+OOPERkZia5du2LEiBHIysrCkiVLEBAQgClTppTqvd2+fRs9evRArVq1cOnSJXz++edo3bo1mjRpAgBo3bo1nJ2d8fHHHyM7OxsqlQo9evSAt7d3keft1auXbgbW66+/jnv37mHVqlXw9vY2GtilFRgYiA0bNiA6Ohrt2rWDu7s7+vfvb7Hzk+NYvXo1du7cabB/0qRJmD9/Pvbs2YPg4GCMGzcOTZs2xe3bt3H06FH8/PPPulug+vXrh82bN+Oll15C3759kZ6ejvj4eDRt2tTohU9Z1K9fHx9++CGmT5+OixcvIjw8HB4eHkhPT8eWLVswfvx4vPPOO3BxccGHH36I119/HT169MCwYcOQnp6ONWvWmLSmVIMGDfD+++9j7ty56Ny5MwYOHAiVSoXDhw+jZs2aiI2NRfXq1TF9+nTMnj0bvXv3xoABA3DmzBksX74c7dq101vU3FS9evWCr68vOnbsCB8fH/zxxx9YunQp+vbtq1vAODAwEADw/vvvY/jw4XBxcUH//v11F4rG9O3bF4sXL0bv3r0xcuRIXL9+HcuWLUODBg301rQqq8DAQKxYsQIffvghGjRoAG9vb4MZqk/7xz/+gffffx85OTlQq9VFHlexYkU0bdoUGzZswHPPPYcqVaqgefPmJq8t8zRLryn1r3/9C5cuXdKtAbhv3z58+OGHAIBXXnlFbzZuYmIiKlWqhBdeeMFi7ZPj2rFjh26h76d16NAB9erVwx9//IEZM2ZgzJgxun+j165di9atW+vWtnxalSpV0KlTJ0RGRiIrKwtxcXFo0KCBbsFhJycnfPnll+jTpw+aNWuGyMhI+Pn54cqVK9izZw/UajV+/PHHEvutzaC3334bYWFhcHZ2xvDhw40e26FDB3h5eSEiIgJvv/02FAoF/vWvfxlcUDk5OWHFihXo378/WrdujcjISNSoUQOnT5/GyZMndX+4/Oyzz9CpUye0bdsW48ePR926dXHx4kX89NNPSEtLK7Hvr776KhYvXoywsDCMHTsW169fR3x8PJo1a6a33pWtMpNI7rZu3Yq7d+8WOcP3+eefR/Xq1bFu3ToMGzYM4eHhaN++Pf7v//4P586dQ+PGjbF161bdmPHpmUzLli1Dp06d0KJFC4wbNw716tVDVlYWUlJS8Ndff+G3334zu7/mjENM/ZybMiY05Zq0JKZeO/fr1w9z5sxBZGQkOnTogOPHj2PdunUmjW9JpmzyjD9BGHsEcNeuXYt8fHlBQYE0depUqVq1alKlSpWksLAw6dy5c0YfnXv37l1p+vTpUoMGDSSlUilVq1ZN6tChg7Rw4UIpPz+/xL5t3bpV6tChg1SxYkVJrVZL7du3l/7973/rHbNhwwapTZs2kkqlkqpUqSKNGjVK+uuvv/SOiYiIkNzc3AzOr328sNamTZukXr16Sd7e3pJSqZRq164tvf7669K1a9f0Xrdq1SqpXr16krOzswRA2rNnjyRJhY/27Nu3b5HvpWXLlpKrq6sUEBAgffzxx9Lq1asNHk/+7GONtY+E3rhxo975jD0O9N69e9LIkSOlypUrSwAMHoNM4ivukeQApIyMDEmSJCkrK0uaOHGi5O/vL7m4uEi+vr5Sz549pZUrV+rOpdFopHnz5kl16tSRVCqV1KZNG2nbtm0Gj9jW/i4uWLDAoD/az9iNGzeM9vPp331JKnzkcKdOnSQ3NzfJzc1Naty4sTRx4kTpzJkzesctX75cqlu3rqRSqaSgoCBp3759RT4S3JjVq1frcsPLy0vq2rWr7nHIWkuXLpUaN24subi4SD4+PtKECRMMHmleVFY++zP64osvpC5dukhVq1aVVCqVVL9+fendd9+VsrOz9V43d+5cyc/PT3JyctL7+QCQJk6caPS9fPXVV1LDhg0llUolNW7cWFqzZo1BtkmS4aOHtf8PDh8+rHecNnO0uSZJkpSZmSn17dtX8vDwkACU+HPOysqSKlSoIP3rX/8q9uciSZJ04MABKTAwUFIqlXqPTS4qt21F+3hnY9vTPxtJkqTg4GDp5Zdftk9HSTZKyt81a9ZIjx8/ltq1ayfVqlVL73HnkiRJS5YskQBIGzZskCTpyWfx3//+tzR9+nTJ29tbqlixotS3b1/p0qVLBu0fO3ZMGjhwoC5n6tSpIw0dOlRKSkrSHVNUJkuSJD1+/Fh66623pOrVq0sKhcIgQ561f/9+6fnnn5cqVqwo1axZU/rnP/8p7dq1y+hn5JdffpFeeOEFycPDQ3Jzc5Natmwpff7553rHnDhxQnrppZekypUrS66urlKjRo2kGTNmmNR3SZKkb7/9VqpXr56kVCql1q1bS7t27TKaOaXNTCKR9O/fX3J1dZVyc3OLPGbMmDGSi4uLdPPmTUmSJOnGjRvSyJEjJQ8PD8nT01MaM2aMtH//fgmAlJCQoPfa8+fPS6NHj5Z8fX0lFxcXyc/PT+rXr5+0adMm3THWHIeY+jmXJNPGhCVdk1ri2vnhw4fS//3f/0k1atSQKlasKHXs2FFKSUkxGN8auwYkeVJIEld/JiIispexY8fizz//xP/+9z97d8Wq0tLS0LZtWxw9erTINSmISiM5ORndu3fHxo0bMXjwYHt3h4jIwA8//ICXXnoJv/zyi1lPFCYqD7imFBERkR3FxMTg8OHDBmu6iGb+/PkYPHgwC1JERCS0Bw8e6H1dUFCAzz//HGq1Gm3btrVTr4jki2tKERER2VHt2rUNFgUVkbHHaBMREYnmrbfewoMHDxASEoK8vDxs3rwZBw4cwLx581CxYkV7d49IdliUIiIiIiIiIrKAHj16YNGiRdi2bRsePnyIBg0a4PPPP0dUVJS9u0YkS7x9j4iKtG/fPvTv3x81a9aEQqEw6VHQycnJaNu2LVQqFRo0aIC1a9davZ9ERFR+devWDZIkcT0pkjWOqcqPkSNHIjU1FdnZ2cjLy8PJkydZkCKHYY+sYlGKiIqUm5uLVq1aYdmyZSYdn56ejr59+6J79+5IS0vD5MmT8dprr+keZU1ERERUHnFMRUSOwB5ZZfOn72k0Gly9ehUeHh5QKBS2bJpICJIk4e7du6hZsyacnJ7UlR8+fIj8/HyTXv/sZ0+lUkGlUhX7OoVCgS1btiA8PLzIY6ZOnYqffvoJJ06c0O0bPnw47ty5g507d5bYN7lgThGVTVlzSqlUwtXV1ZpddHjMKaKyKWtOac/BMVXxmFVEZWOvaz/Adlll8zWlrl69Cn9/f1s3SyScjIwM1KpVC0BhKNWtWxeZmZklvs7d3R337t3T2xcTE4NZs2aVuU8pKSkIDQ3V2xcWFobJkyeX+dy2xJwisozS5pSvry/S09NZmCoGc4rIMkqbUwDHVKZgVhFZhhyv/QDLZJXNi1IeHh62bpJISE9/lvLz85GZmYnLly9DrVYX+ZqcnBzUrl0bGRkZeseZUik3RWZmJnx8fPT2+fj4ICcnBw8ePHCYJ45of7b79u2Du7u7Tds+duyYTdvT+vHHH+3S7smTJ23e5o0bN2zeJlA4HdoeHj9+bPM2tZOwy5JT+fn5LEoVQ/uz7dq1KypUsO1wLiAgwKbtaRUUFNil3UuXLtm8TVNn6ljanTt37NKuPRQUFOD06dOlyimAYypTaX++Xl5eerM8bKF69eo2bU/LHpkBAA8ePLBLu2Qbcrz2AyyTVTYvSnHaJpFlGPsseXh4FFv41V4oqtXqEgdb5Zn2Z+vu7m7zQnqlSpVs2p6Wi4uLXdp1dna2eZv2+neovLVrbLo4YHpOUfG0P9sKFSrYvCilVCpt2p6WvYpStv75AoW3PNmDPTLZ3kqTUwDHVKbS/nydnJxsXpSy1+8zr3fJGkS+9rP9v7JEZDWSJBV7QWftiz1fX19kZWXp7cvKyoJarXaYv+gRkXXZO6eIiEpSUk5pj7EmjqmIqCRyGFNZIqtYlCISiEajKfavq9b+y2tISAi2b9+uty8xMREhISFWbZeIHIe9c4qIqCQl5ZT2GGvimIqISiKHMZUlssq2cyiJyKq01fLiNnPcu3cPaWlpSEtLA1D4yM+0tDRcvnwZADB9+nSMHj1ad/wbb7yBCxcu4J///CdOnz6N5cuX47vvvsOUKVMs9h6JyLFZOqeIiCzNlJzimIqI7M0aYyp7ZBVnShEJxNJTOI8cOYLu3bvrvo6OjgYAREREYO3atbh27ZouoACgbt26+OmnnzBlyhQsWbIEtWrVwpdffomwsDAz3wkRiUoOU82JiIpjjdv3OKYiIkuzxpjKHlnFohSRQCwdTN26dSv2NWvXrjX6Gns9QY6I5I9FKSKSO2sUpTimIiJLs8aYyh5ZxaIUkUB4sUdEcsecIiK5k8NC50REJRFlTMWiFJFA5LDYHRFRcZhTRCR3cljonIioJKKMqViUIhKIKNVyIhIXc4qI5I4zpYjIEYgypmJRikggogQTEYmLOUVEcseiFBE5AlHGVE6ledGyZcsQEBAAV1dXBAcH49ChQ5buFxGVAh+1/gRzikiemFP6mFVE8mNKTpWnrGJOEcmTKDlldlFqw4YNiI6ORkxMDI4ePYpWrVohLCwM169ft0b/iMgM2vuKi9vKA+YUkXwxp55gVhHJkyk5VV6yijlFJF+i5JTZRanFixdj3LhxiIyMRNOmTREfH49KlSph9erVRo/Py8tDTk6O3kZE1iFKtbysmFNE8mWtnDLnL/knT57EoEGDEBAQAIVCgbi4OINjZs2aBYVCobc1btxY75iHDx9i4sSJqFq1Ktzd3TFo0CBkZWWZ3Gdzsoo5RWQ7nCn1BMdURPIlSk6ZVZTKz89HamoqQkNDn5zAyQmhoaFISUkx+prY2Fh4enrqNn9//7L1mIiKJEowlQVzikjerJFT5v4l//79+6hXrx7mz58PX1/fIs/brFkzXLt2Tbf98ssvet+fMmUKfvzxR2zcuBF79+7F1atXMXDgQJP6bG5WMaeIbIdFqUIcUxHJmyg5ZVZR6ubNmygoKICPj4/efh8fH2RmZhp9zfTp05Gdna3bMjIySt9bIiqRo4dSWTGniOTPlJx69i/teXl5RZ7P3L/kt2vXDgsWLMDw4cOhUqmKPG+FChXg6+ur26pVq6b7XnZ2Nr766issXrwYPXr0QGBgINasWYMDBw7g4MGDJf4MzM0q5hSRbYlwoVdWHFMRyZ8IOVWqhc7NoVKpoFar9TYisg5R7iu2NeYUke2YmlP+/v56f22PjY01er7S/CXfVGfPnkXNmjVRr149jBo1CpcvX9Z9LzU1FY8ePdJrt3Hjxqhdu3aZ2zWGOUVkO1xTqvSYVUS2I0pOVTDn4GrVqsHZ2dlgvYSsrKxip78TkW2UVBV3pIp5aTGniOTN1JzKyMjQu5gpakZTcX/JP336dKn7GRwcjLVr16JRo0a4du0aZs+ejc6dO+PEiRPw8PBAZmYmlEolKleubNBuUTMInsasIpIvU2YZcEzFnCKyN1Gu/cyaKaVUKhEYGIikpCTdPo1Gg6SkJISEhFi8c0RkHlHuKy4L5hSRvJmaU8/+pb242+ysoU+fPhgyZAhatmyJsLAwbN++HXfu3MF3331nkfMzq4jki2tKFWJOEcmbKDll1kwpAIiOjkZERASCgoLQvn17xMXFITc3F5GRkdboHxGZQZRqeVkxp4jky9I5Zau/5FeuXBnPPfcczp07BwDw9fVFfn4+7ty5ozdbypx2mVVE8sSZUk8wp4jkS5RrP7OLUsOGDcONGzcwc+ZMZGZmonXr1ti5c6fBtHkisj1RgqmsmFNE8mXpnHr6L/nh4eEAnvwlPyoqqixd1XPv3j2cP38er7zyCgAgMDAQLi4uSEpKwqBBgwAAZ86cweXLl02eQcCsIpInFqWeYE4RyZco135mF6UAICoqyqIDPSKyjJIWtHOUxe4sgTlFJE/WyKmS/pI/evRo+Pn56RZLz8/Px6lTp3T/feXKFaSlpcHd3R0NGjQAALzzzjvo378/6tSpg6tXryImJgbOzs4YMWIEAMDT0xNjx45FdHQ0qlSpArVajbfeegshISF4/vnnTe47s4pIfkxZIJhjKiKyN1Gu/UpVlCIieRKlWk5E4rJGTpX0l/zLly/DyenJMppXr15FmzZtdF8vXLgQCxcuRNeuXZGcnAwA+OuvvzBixAjcunUL1atXR6dOnXDw4EFUr15d97pPP/0UTk5OGDRoEPLy8hAWFobly5eb3X8ikhfOlCIiRyDKtR+LUkQCESWYiEhc1sqp4v6Sry00aQUEBJTYTkJCQolturq6YtmyZVi2bJnJ/SQi+WNRiogcgSjXfixKEQlElGAiInExp4hI7liUIiJHIMqYikUpIoGIcl8xEYmLOUVEcsc1pYjIEYgypmJRikggolTLiUhczCkikjvOlCIiRyDKmIpFKSKBiBJMRCQu5hQRyR2LUkTkCEQZU7EoRSQQUYKJiMTFnCIiuWNRiogcgShjKhaliAQiSjDJRf369aFWq23a5pEjR2zanlalSpXs0i6VP8wpy7p16xacnZ1t2mZubq5N29O6c+eOXdr19/e3eZsVK1a0eZsA4OHhYZd269evb/M28/LycPLkSaPfY1HK8urXr48KFWx76ZmXl2fT9rQaNmxol3YzMjJs3ubt27dt3iYAm/+7Z0+SJBW5NpQoYyoWpYgEUlxoab9PRGRPzCkikruSckp7DBGRPYkypmJRikggolTLiUhczCkikjvOlCIiRyDKmIpFKSKBiBJMRCQu5hQRyR2LUkTkCEQZU7EoRSQQUYKJiMTFnCIiuWNRiogcgShjKhaliASi0WiKva+4pPURiIisjTlFRHJXUk5pjyEisidRxlQsShEJRJRqORGJizlFRHLHmVJE5AhEGVOxKEUkEFGCiYjExZwiIrljUYqIHIEoYyoWpYgEIkowEZG4mFNEJHcsShGRIxBlTOVk7w4QkeVog6m4rTSWLVuGgIAAuLq6Ijg4GIcOHSr2+Li4ODRq1AgVK1aEv78/pkyZgocPH5aqbSISi7VyiojIUkzJqdJkFcdTRGRJolz7caYUkUCssdjdhg0bEB0djfj4eAQHByMuLg5hYWE4c+YMvL29DY5fv349pk2bhtWrV6NDhw74888/MWbMGCgUCixevNjs9olILKIsyklE4rLGQuccTxGRpYly7ceZUkQCMbVanpOTo7fl5eUVec7Fixdj3LhxiIyMRNOmTREfH49KlSph9erVRo8/cOAAOnbsiJEjRyIgIAC9evXCiBEjSqywE1H5wJlSRCR35syUMnVMxfEUEVmaKNd+Zhel9u3bh/79+6NmzZpQKBT44YcfzD0FEVmJqcHk7+8PT09P3RYbG2v0fPn5+UhNTUVoaKhun5OTE0JDQ5GSkmL0NR06dEBqaqouiC5cuIDt27fjxRdftPC7LRpziki+WJQqxJwiki9zilKmjKkcdTwFMKuI5EyUaz+zb9/Lzc1Fq1at8Oqrr2LgwIHmvpyIrMjUxe4yMjKgVqt1+1UqldHjb968iYKCAvj4+Ojt9/HxwenTp42+ZuTIkbh58yY6deoESZLw+PFjvPHGG3jvvffMfTulxpwiki9RFuUsK+YUkXyZs9C5KWMqRx1PAcwqIjkT5drP7KJUnz590KdPH5OPz8vL05selpOTY26TRGQiU+8rVqvVesFkScnJyZg3bx6WL1+O4OBgnDt3DpMmTcLcuXMxY8YMq7T5LOYUkXxxTalCzCki+TJnTSlrjankMJ4CmFVEcibKtZ/VFzqPjY3F7Nmzrd0MEf1/lpxlUK1aNTg7OyMrK0tvf1ZWFnx9fY2+ZsaMGXjllVfw2muvAQBatGiB3NxcjB8/Hu+//z6cnOS3lB1zisi2ystsKEtiThHZFsdTpcOsIrItEbLK6mk2ffp0ZGdn67aMjAxrN0lUbll6rRalUonAwEAkJSXp9mk0GiQlJSEkJMToa+7fv28QPs7Ozrr+yRFzish25PD44pMnT2LQoEEICAiAQqFAXFycwTGxsbFo164dPDw84O3tjfDwcJw5c0bvmG7dukGhUOhtb7zxRqn6XxLmFJHtmLOmlCnKy3gKYFYR2ZIo135WnymlUqmKvGeRiCzLGmu1REdHIyIiAkFBQWjfvj3i4uKQm5uLyMhIAMDo0aPh5+enWzCvf//+WLx4Mdq0aaObwjljxgz0799fF1Byw5wish1r5JS5jy++f/8+6tWrhyFDhmDKlClGz7l3715MnDgR7dq1w+PHj/Hee++hV69eOHXqFNzc3HTHjRs3DnPmzNF9XalSJbP7bwrmFJHtmLOmlKnKw3gKYFYR2ZIo135WL0oRke1YI5iGDRuGGzduYObMmcjMzETr1q2xc+dO3QJ4ly9f1quOf/DBB1AoFPjggw9w5coVVK9eHf3798dHH31k/hsiIuGYmlPPrkNS3IXO048vBoD4+Hj89NNPWL16NaZNm2ZwfLt27dCuXTsAMPp9ANi5c6fe12vXroW3tzdSU1PRpUsX3f5KlSoVOaWdiByTNYpSHE8RkaWJcu3HohSRQKy1gHBUVBSioqKMfi85OVnv6woVKiAmJgYxMTGlaouIxGZqTvn7++vtj4mJwaxZswyO1z6+ePr06bp9JT2+uDSys7MBAFWqVNHbv27dOnz77bfw9fVF//79MWPGDKvNliIi2zBnoXNzcDxFRJYkyrWf2UWpe/fu4dy5c7qv09PTkZaWhipVqqB27dql7ggRlR0ftV6IOUUkX3J4fLG5NBoNJk+ejI4dO6J58+a6/SNHjkSdOnVQs2ZN/P7775g6dSrOnDmDzZs3l3hO5hSRfFljppSjYlYRyZco135mF6WOHDmC7t27676Ojo4GAERERGDt2rUW6xgRmU+UYCor5hSRfJmaU9Z8fLG5Jk6ciBMnTuCXX37R2z9+/Hjdf7do0QI1atRAz549cf78edSvX7/YczKniOSLRaknmFVE8iXKtZ/ZRalu3bo5zJsjKm9ECaayYk4RyZelc6o0jy82R1RUFLZt24Z9+/ahVq1axR4bHBwMADh37lyJRSnmFJF8sSj1BLOKSL5EufZzKvkQInIU2vuKi9uIiOzJ0jlVmscXm0KSJERFRWHLli3YvXs36tatW+Jr0tLSAAA1atQodbtEZH+m5BTHVERkb6LkFBc6JxKIKNVyIhKXHB5fnJ+fj1OnTun++8qVK0hLS4O7uzsaNGgAoPCWvfXr1+M///kPPDw8kJmZCQDw9PRExYoVcf78eaxfvx4vvvgiqlatit9//x1TpkxBly5d0LJlS7PfAxHJB2dKEZEjEOXaj0UpIoGIEkxEJC45PL746tWraNOmje7rhQsXYuHChejatavuqTIrVqwAUHjrytPWrFmDMWPGQKlU4ueff9YVwPz9/TFo0CB88MEHZvefiOSFRSkicgSiXPuxKEUkEFGCiYjEZa2cMufxxQEBAWW+4PT398fevXvN6iMROQYWpYjIEYhy7ceiFJFASrp32FHuKyYicTGniEjuTFmLhVlFRPYmypiKRSkigYhSLScicTGniEjuOFOKiByBKGMqFqWIBCJKMBGRuJhTRCR3LEoRkSMQZUzFohSRYBwlfBzB7t274ebmZtM2jxw5YtP2tC5dumSXdvPz823epqNMZbYUe2QCL+Zs5/Tp01AoFPbuhk3Y67Obnp5u8za1i/TbWlBQkF3aHTx4sM3bzM3NRXx8fJHfZ045vsaNG9ul3bNnz9ql3Ro1ati8zcePH9u8TaDw82sPBQUFdmm3OCJkFYtSRAIRpVpOROJiThGR3HGmFBE5AlHGVCxKEQlElMXuiEhczCkikjsudE5EjkCUMRWLUkQCEaVaTkTiYk4RkdxxphQROQJRxlQsShEJRJRgIiJxMaeISO5YlCIiRyDKmIpFKSKBiBJMRCQu5hQRyR2LUkTkCEQZU7EoRSQQUe4rJiJxMaeISO64phQROQJRxlQsShEJRJRqORGJizlFRHLHmVJE5AhEGVOxKEUkEFGCiYjExZwiIrljUYqIHIEoYyoWpYgEIkowEZG4mFNEJHcsShGRIxBlTMWiFJFARAkmIhIXc4qI5I5FKSJyBKKMqZzMOTg2Nhbt2rWDh4cHvL29ER4ejjNnzlirb0RkJu1id8Vt5QGziki+mFOFmFNE8mVKTpWHrGJOEcmbKDllVlFq7969mDhxIg4ePIjExEQ8evQIvXr1Qm5urrX6R0Rm0FbLi9vKA2YVkXwxpwoxp4jky5ScKg9ZxZwikjdRcsqs2/d27typ9/XatWvh7e2N1NRUdOnSxaIdIyLziTKFs6yYVUTyxZwqxJwiki/evleIOUUkb6KMqcq0plR2djYAoEqVKkUek5eXh7y8PN3XOTk5ZWmSiIohSjBZWklZxZwish3mlHHMKSL5YFHKOF77EcmLKGMqs27fe5pGo8HkyZPRsWNHNG/evMjjYmNj4enpqdv8/f1L2yQRlUCSpGLvKXaUYLIkU7KKOUVkO8wpQ8wpInkpKafKY1bx2o9IfkQZU5W6KDVx4kScOHECCQkJxR43ffp0ZGdn67aMjIzSNklEJRDlvmJLMiWrmFNEtsOcMsScIpIXrilliNd+RPIjSk6V6va9qKgobNu2Dfv27UOtWrWKPValUkGlUpWqc0RkHlGmcFqKqVnFnCKyHeaUPuYUkfzw9j19vPYjkidRxlRmzZSSJAlRUVHYsmULdu/ejbp161qrX0RUCqJUy8uKWUUkX9bKqWXLliEgIACurq4IDg7GoUOHijz25MmTGDRoEAICAqBQKBAXF1eqcz58+BATJ05E1apV4e7ujkGDBiErK8uk/jKniOSLM6UKMaeI5E2UnDKrKDVx4kR8++23WL9+PTw8PJCZmYnMzEw8ePDAWv0jIjOIEkxlxawiki9r5NSGDRsQHR2NmJgYHD16FK1atUJYWBiuX79u9Pj79++jXr16mD9/Pnx9fUt9zilTpuDHH3/Exo0bsXfvXly9ehUDBw40qc/MKSL5YlGqEHOKSN5EySmzilIrVqxAdnY2unXrhho1aui2DRs2WKt/RGSGkhbl1Gg0pTqvOTMQAODOnTuYOHEiatSoAZVKheeeew7bt28vVdulwawiki9r5NTixYsxbtw4REZGomnTpoiPj0elSpWwevVqo8e3a9cOCxYswPDhw4u8zaSkc2ZnZ+Orr77C4sWL0aNHDwQGBmLNmjU4cOAADh48WGKfmVNE8mVKTpUmqzieIiJLEuXaz6w1pRyl0kZUXlnjvmLtbIH4+HgEBwcjLi4OYWFhOHPmDLy9vQ2Oz8/PxwsvvABvb29s2rQJfn5+uHTpEipXrmx226XFrCKSL1Nz6tnHiBe1Tkl+fj5SU1Mxffp03T4nJyeEhoYiJSWlVH005Zypqal49OgRQkNDdcc0btwYtWvXRkpKCp5//vli22BOEcmXNdaU4niKiCxNlGu/Ui10TkTyZI1genq2AADEx8fjp59+wurVqzFt2jSD41evXo3bt2/jwIEDcHFxAQAEBASY3S4RicnUnHr2MeIxMTGYNWuWwfE3b95EQUEBfHx89Pb7+Pjg9OnTpeqjKefMzMyEUqk0GHT5+PggMzOzVO0SkTxYoyjF8RQRWZoo135m3b5HRPJm6n3FOTk5elteXp7R82lnCzw9E6CkGQhbt25FSEgIJk6cCB8fHzRv3hzz5s1DQUGB5d8wETkcU3MqIyND77HiT89aIiKyJnPWlDJlTMXxFBFZgyjXfixKEQnE1PuK/f394enpqdtiY2ONnq+42QJFzQS4cOECNm3ahIKCAmzfvh0zZszAokWL8OGHH1r2zRKRQzI1p9Rqtd5W1NpP1apVg7Ozs8FT77KysopcxLwkppzT19cX+fn5uHPnjsXaJSJ5MGdNKVPGVBxPEZE1iHLtx9v3iARi6hTOjIwMqNVq3f6iLvZKQ6PRwNvbGytXroSzszMCAwNx5coVLFiwADExMRZrh4gck6WnmiuVSgQGBiIpKQnh4eEACnMoKSkJUVFRpeqjKecMDAyEi4sLkpKSMGjQIADAmTNncPnyZYSEhJSqXSKSB3Nu37PWmIrjKSIqiSjXfixKEQnE1GDSzjwoSWlmINSoUQMuLi5wdnbW7WvSpAkyMzORn58PpVJpylshIkFZY/2D6OhoREREICgoCO3bt0dcXBxyc3N16yGMHj0afn5+ur8M5ufn49SpU7r/vnLlCtLS0uDu7o4GDRqYdE5PT0+MHTsW0dHRqFKlCtRqNd566y2EhISUuMg5EcmbOUUpU8ZUHE8RkTWIcu3H2/eIBGLqfcWmenq2gJZ2tkBRMwE6duyIc+fO6T2C9M8//0SNGjU4gCIii+cUAAwbNgwLFy7EzJkz0bp1a6SlpWHnzp266eeXL1/GtWvXdMdfvXoVbdq0QZs2bXDt2jUsXLgQbdq0wWuvvWbyOQHg008/Rb9+/TBo0CB06dIFvr6+2Lx5cxl+OkQkB+asKWUKjqeIyBpEufZjUYpIIKbeV2yO6OhorFq1Cl9//TX++OMPTJgwwWAGwtMLEE+YMAG3b9/GpEmT8Oeff+Knn37CvHnzMHHiRIu9TyJyXNbIKQCIiorCpUuXkJeXh19//RXBwcG67yUnJ2Pt2rW6rwMCAowO3JKTk00+JwC4urpi2bJluH37NnJzc7F582auJ0UkAHPWlDIVx1NEZGmiXPvx9j0igVjjtphhw4bhxo0bmDlzJjIzM9G6dWuDGQhOTk/q2/7+/ti1axemTJmCli1bws/PD5MmTcLUqVPNf0NEJBxr5BQRkSWZc/ueqTieIiJLE+Xaz25FqezsbJPuayTHolAo7N2Fcs8aF3RRUVFFLhj87MwCAAgJCcHBgwct3g9b27p1q82nyKenp9u0Pa2inqhhbffu3bN5m48fP7Z5mwCLLU/jz8JyHj58aO8uCK+oR2db05UrV2zeJgC7jc07depk8zZzcnKK/T7HU5aVn59v1iPiLcHNzc2m7Wm1bt3aLu3u27fP5m1acsFsc5T0+S1PRMgqzpQiEghnIBCR3DGniEjurDFTiojI0kQZU7EoRSQQUYKJiMTFnCIiuWNRiogcgShjKhaliARS0oJ2pV1AmIjIUphTRCR3piwQzKwiInsTZUzFohSRQESplhORuJhTRCR3nClFRI5AlDEVi1JEAhElmIhIXMwpIpI7FqWIyBGIMqZiUYpIIKIEExGJizlFRHLHohQROQJRxlQsShEJRJT7iolIXMwpIpI7rilFRI5AlDEVi1JEAhGlWk5E4mJOEZHccaYUETkCUcZULEoRCUSUYCIicTGniEjuWJQiIkcgypiKRSkigYgSTEQkLuYUEckdi1JE5AhEGVM5mXPwihUr0LJlS6jVaqjVaoSEhGDHjh3W6hsRmUkbTMVt5QGziki+mFOFmFNE8mVKTpWHrGJOEcmbKDllVlGqVq1amD9/PlJTU3HkyBH06NED//jHP3Dy5Elr9Y+IzKBd7K64rTxgVhHJF3OqEHOKSL5MyanykFXMKSJ5EyWnzLp9r3///npff/TRR1ixYgUOHjyIZs2aWbRjRGQ+UaZwlhWziki+mFOFmFNE8sXb9woxp4jkTZQxVanXlCooKMDGjRuRm5uLkJCQIo/Ly8tDXl6e7uucnJzSNklEJRAlmCzJlKxiThHZDnPKEHOKSF5YlDLEaz8i+RFlTGXW7XsAcPz4cbi7u0OlUuGNN97Ali1b0LRp0yKPj42Nhaenp27z9/cvU4eJqHiOfk+xpZiTVcwpIttiThViThHJlwjrtFgCr/2I5E2EnDK7KNWoUSOkpaXh119/xYQJExAREYFTp04Vefz06dORnZ2t2zIyMsrUYSIqmij3FVuCOVnFnCKyHebUE8wpInnimlJP8NqPSL5EySmzb99TKpVo0KABACAwMBCHDx/GkiVL8MUXXxg9XqVSQaVSla2XRGQSUaZwWoI5WcWcIrId5tQTzCkieeLte0/w2o9IvkQZU5V6TSktjUajd98wEdmPKMFkDcwqInlgThWNOUUkDyxKFY05RSQfooypzCpKTZ8+HX369EHt2rVx9+5drF+/HsnJydi1a5e1+kdEZhAlmMqKWUUkX8ypQswpIvliUaoQc4pI3kQZU5m1ptT169cxevRoNGrUCD179sThw4exa9cuvPDCC9bqHxGZoaRFOR0lmMqKWUUkX9bKqWXLliEgIACurq4IDg7GoUOHij1+48aNaNy4MVxdXdGiRQts375d7/sKhcLotmDBAt0xAQEBBt+fP3++Sf1lThHJlyk5VR7GVMwpInkTJafMmin11VdfWasfRGQBJS1o5yiL3ZUVs4pIvqyRUxs2bEB0dDTi4+MRHByMuLg4hIWF4cyZM/D29jY4/sCBAxgxYgRiY2PRr18/rF+/HuHh4Th69CiaN28OALh27Zrea3bs2IGxY8di0KBBevvnzJmDcePG6b728PAwqc/MKSL5MmWB4PIwpmJOEcmbKNd+Zj99j4jkS5RqORGJyxo5tXjxYowbNw6RkZFo2rQp4uPjUalSJaxevdro8UuWLEHv3r3x7rvvokmTJpg7dy7atm2LpUuX6o7x9fXV2/7zn/+ge/fuqFevnt65PDw89I5zc3Mzu/9EJC+cKUVEjkCUnGJRikggogQTEYnL1JzKycnR24paWDc/Px+pqakIDQ3V7XNyckJoaChSUlKMviYlJUXveAAICwsr8visrCz89NNPGDt2rMH35s+fj6pVq6JNmzZYsGABHj9+bNLPgYjki0UpInIEouRUmZ++R0TyIcpid0QkLlNzyt/fX29/TEwMZs2aZXD8zZs3UVBQAB8fH739Pj4+OH36tNE2MjMzjR6fmZlp9Pivv/4aHh4eGDhwoN7+t99+G23btkWVKlVw4MABTJ8+HdeuXcPixYuLfH9EJH9c6JyIHIEo134sShEJRJT7iolIXKbmVEZGBtRqtW6/SqWyet+Ksnr1aowaNQqurq56+6Ojo3X/3bJlSyiVSrz++uuIjY21a3+JqGy4phQROQJRrv1YlCISiCjVciISl6k5pVar9YpSRalWrRqcnZ2RlZWltz8rKwu+vr5GX+Pr62vy8f/73/9w5swZbNiwocS+BAcH4/Hjx7h48SIaNWpU4vFEJE+cKUVEjkCUaz+uKUUkEFHuKyYicVk6p5RKJQIDA5GUlKTbp9FokJSUhJCQEKOvCQkJ0TseABITE40e/9VXXyEwMBCtWrUqsS9paWlwcnIy+sQ/InIcXFOKiByBKDnFmVJEAhGlWk5E4rJGTkVHRyMiIgJBQUFo37494uLikJubi8jISADA6NGj4efnh9jYWADApEmT0LVrVyxatAh9+/ZFQkICjhw5gpUrV+qdNycnBxs3bsSiRYsM2kxJScGvv/6K7t27w8PDAykpKZgyZQpefvlleHl5mf0eiEg+OFOKiByBKNd+ditKeXp62qtpImGJEkxycfz4cVSoYNuYvH37tk3b08rJybFLuw8ePLB5m/Z6Opqj3NdvbdbIqWHDhuHGjRuYOXMmMjMz0bp1a+zcuVO3mPnly5fh5PRkcniHDh2wfv16fPDBB3jvvffQsGFD/PDDD2jevLneeRMSEiBJEkaMGGHQpkqlQkJCAmbNmoW8vDzUrVsXU6ZM0VtnisjR2Csfn525aAu5ublFfo9FKcsLDAyEUqm0aZsdOnSwaXtahw4dsku7zs7ONm/Tzc3N5m0C9hsvFxQU2KXdoohy7ceZUkQCkSSp2AtfRwkmIhKXtXIqKioKUVFRRr+XnJxssG/IkCEYMmRIseccP348xo8fb/R7bdu2xcGDB83uJxHJX0k5pT2GiMieRLn2Y1GKSCCiVMuJSFzMKSKSO86UIiJHIMqYigudEwnEWovdLVu2DAEBAXB1dUVwcLDJ05ITEhKgUCgQHh5eqnaJSDyiLMpJROKy1kLnHE8RkSWJcu3HohSRQKwRTBs2bEB0dDRiYmJw9OhRtGrVCmFhYbh+/Xqxr7t48SLeeecddO7cubRvh4gExKIUEcmdNYpSHE8RkaWJcu3HohSRQDQaTYmbuRYvXoxx48YhMjISTZs2RXx8PCpVqoTVq1cX+ZqCggKMGjUKs2fPRr169crylohIMNbIKSIiSzIlp8zNKo6niMjSRLn2Y1GKSCCmVstzcnL0try8PKPny8/PR2pqKkJDQ3X7nJycEBoaipSUlCL7MWfOHHh7e2Ps2LGWfYNE5PA4U4qI5M6cmVKmjKk4niIiaxDl2o9FKSKBmBpM/v7+8PT01G2xsbFGz3fz5k0UFBToHquu5ePjg8zMTKOv+eWXX/DVV19h1apVln1zRCQEFqWISO7MKUqZMqbieIqIrEGUaz8+fY9IICVd0Gm/l5GRAbVarduvUqks0v7du3fxyiuvYNWqVahWrZpFzklEYjE1p4iI7MWUArk1x1QcTxGRKUS59mNRikggJd07rP2eWq3WC6aiVKtWDc7OzsjKytLbn5WVBV9fX4Pjz58/j4sXL6J///4GbVaoUAFnzpxB/fr1TXovRCQmU3OKiMheTFmLxZwxFcdTRGQNolz78fY9IoFY+rYYpVKJwMBAJCUl6fZpNBokJSUhJCTE4PjGjRvj+PHjSEtL020DBgxA9+7dkZaWBn9//zK/RyJybLx9j4jkztJP3+N4ioisQZRrP86UIhKINW6LiY6ORkREBIKCgtC+fXvExcUhNzcXkZGRAIDRo0fDz88PsbGxcHV1RfPmzfVeX7lyZQAw2E9E5RNv3yMiuTPn9j1TcTxFRJYmyrVfmWZKzZ8/HwqFApMnTy7LaYjIQqwxA2HYsGFYuHAhZs6cidatWyMtLQ07d+7ULYB3+fJlXLt2zdJvxWKYU0TywplSxjGriOTD0jOlAMcfTwHMKSK5EeXar9QzpQ4fPowvvvgCLVu2tGR/iKgMrDUDISoqClFRUUa/l5ycXOxr165dW6o2LYE5RSQ/nClliFlFJC/WmCkFOO54CmBOEcmRKNd+pZopde/ePYwaNQqrVq2Cl5dXaU5BRFagXeyuuK28YE4RyRNzSh+zikh+TMmp8pRVzCkieRIlp0pVlJo4cSL69u2L0NDQEo/Ny8tDTk6O3kZE1sNbYgoxp4jkizn1hKlZxZwisi3eZvwEx1RE8iVCTpl9+15CQgKOHj2Kw4cPm3R8bGwsZs+ebXbHiMh8vC2mEHOKSL6YU0+Yk1XMKSLbsdbte46IYyoi+RJlTGXWTKmMjAxMmjQJ69atg6urq0mvmT59OrKzs3VbRkZGqTpKRCXjAsLMKSK5Y04VMjermFNEtmONhc4dEcdURPImSk6ZNVMqNTUV169fR9u2bXX7CgoKsG/fPixduhR5eXlwdnbWe41KpYJKpbJMb4moWCXdO+wo9xWXBXOKSN6YU4XMzSrmFJHtmLIWS3nIKo6piORNlDGVWUWpnj174vjx43r7IiMj0bhxY0ydOtUglIjItkSZwlkWzCkieWNOFWJWEckXb98rxJwikjdRxlRmFaU8PDzQvHlzvX1ubm6oWrWqwX4isj1RgqksmFNE8sacKsSsIpIvFqUKMaeI5E2UMZXZC50TkXyJEkxEJC7mFBHJHYtSROQIRBlTlbkolZycbIFuEJEliBJMlsacIpIP5lTRmFVE8sCiVNGYU0TyIcqYyqyn7xGRvGkXuytuIyKyJ2vl1LJlyxAQEABXV1cEBwfj0KFDxR6/ceNGNG7cGK6urmjRogW2b9+u9/0xY8ZAoVDobb1799Y75vbt2xg1ahTUajUqV66MsWPH4t69e6XqPxHJhyk5xTEVEdmbKDnFohSRQER5LCgRicsaObVhwwZER0cjJiYGR48eRatWrRAWFobr168bPf7AgQMYMWIExo4di2PHjiE8PBzh4eE4ceKE3nG9e/fGtWvXdNu///1vve+PGjUKJ0+eRGJiIrZt24Z9+/Zh/PjxZvefiOTFlJzimIqI7E2UnGJRikggogQTEYnLGjm1ePFijBs3DpGRkWjatCni4+NRqVIlrF692ujxS5YsQe/evfHuu++iSZMmmDt3Ltq2bYulS5fqHadSqeDr66vbvLy8dN/7448/sHPnTnz55ZcIDg5Gp06d8PnnnyMhIQFXr141+z0QkXywKEVEjkCUnGJRikggogQTEYnL1JzKycnR2/Ly8oyeLz8/H6mpqQgNDdXtc3JyQmhoKFJSUoy+JiUlRe94AAgLCzM4Pjk5Gd7e3mjUqBEmTJiAW7du6Z2jcuXKCAoK0u0LDQ2Fk5MTfv31V/N+KEQkKyxKEZEjECWnWJQiEogo9xUTkbhMzSl/f394enrqttjYWKPnu3nzJgoKCuDj46O338fHB5mZmUZfk5mZWeLxvXv3xjfffIOkpCR8/PHH2Lt3L/r06YOCggLdOby9vfXOUaFCBVSpUqXIdonIMXBNKSJyBKLkVJmfvkdE8iHKExiISFym5lRGRgbUarVuv0qlsnrfnjZ8+HDdf7do0QItW7ZE/fr1kZycjJ49e9q0L0RkW3z6HhE5AlGu/ThTikggokzhJCJxmZpTarVabyuqKFWtWjU4OzsjKytLb39WVhZ8fX2NvsbX19es4wGgXr16qFatGs6dO6c7x7MLqT9+/Bi3b98u9jxEJH+8fY+IHIEoOcWZUkQCEaVaLhfXrl2Dk5Nta/cPHjywaXtaDx8+tEu7jx49snmb2tuvbM1eU6jl9rm3dE4plUoEBgYiKSkJ4eHhAAp/1klJSYiKijL6mpCQECQlJWHy5Mm6fYmJiQgJCSmynb/++gu3bt1CjRo1dOe4c+cOUlNTERgYCADYvXs3NBoNgoODzXoPZaFUKqFQKGzWHlBYfLMHW+exPdt1d3e3eZsAULlyZbu0++mnn9q8zeL+/eFMKcsLDw+Hm5ubTdt8eh1AWypqDURr8/T0tHmb2j/U2JqtZ09r2eP/rSRJRY4hRbn2Y1GKSDCOEj5EVH5ZOqeio6MRERGBoKAgtG/fHnFxccjNzUVkZCQAYPTo0fDz89OtSzVp0iR07doVixYtQt++fZGQkIAjR45g5cqVAIB79+5h9uzZGDRoEHx9fXH+/Hn885//RIMGDRAWFgYAaNKkCXr37o1x48YhPj4ejx49QlRUFIYPH46aNWta9P0Rke1xPEVEjkCErGJRikggJS1o5yiL3RGRuKyRU8OGDcONGzcwc+ZMZGZmonXr1ti5c6duMfPLly/rzXbp0KED1q9fjw8++ADvvfceGjZsiB9++AHNmzcHADg7O+P333/H119/jTt37qBmzZro1asX5s6dq/fX2XXr1iEqKgo9e/aEk5MTBg0ahM8++8zs/hORvJiyQDDHVERkb6Jc+7EoRSQQUaZwEpG4rJVTUVFRRd6ul5ycbLBvyJAhGDJkiNHjK1asiF27dpXYZpUqVbB+/Xqz+klE8sfb94jIEYhy7ceiFJFARAkmIhIXc4qI5I5FKSJyBKKMqViUIhKIKMFEROJiThGR3LEoRUSOQJQxFYtSRAIR5b5iIhIXc4qI5I5rShGRIxBlTMWiFJFARKmWE5G4mFNEJHecKUVEjkCUMRWLUkQCESWYiEhczCkikjsWpYjIEYgypmJRikggogQTEYmLOUVEcseiFBE5AlHGVCxKEQlElPuKiUhczCkikjuuKUVEjkCUMRWLUkQCEaVaTkTiYk4RkdxxphQROQJRxlRO5hw8a9YsKBQKva1x48bW6hsRmUkbTMVt5QGziki+mFOFmFNE8mVKTpWHrGJOEcmbKDll9kypZs2a4eeff35yggqcbEUkF6JUyy2BWUUkT8ypJ5hTRPLEmVJPMKeI5EuUMZXZqVKhQgX4+vpaoy9EVEaiBJMlMKuI5Ik59QRzikieWJR6gjlFJF+ijKnMun0PAM6ePYuaNWuiXr16GDVqFC5fvlzs8Xl5ecjJydHbiMg6JEnSLXhnbCttMC1btgwBAQFwdXVFcHAwDh06VOSxq1atQufOneHl5QUvLy+EhoYWe7y1mJNVzCki27FWTjki5hSRPJWUU6XNKtHHUwCzisiWRLn2M6soFRwcjLVr12Lnzp1YsWIF0tPT0blzZ9y9e7fI18TGxsLT01O3+fv7m9VBIjKdNe4r3rBhA6KjoxETE4OjR4+iVatWCAsLw/Xr140en5ycjBEjRmDPnj1ISUmBv78/evXqhStXrpT17ZnM3KxiThHZjijrH5QVc4pIvqyxplR5GE8BzCoiWxLl2k8hlWH0d+fOHdSpUweLFy/G2LFjjR6Tl5eHvLw83dc5OTkMJyILyM7OhlqtBlD4ufL09ESbNm3g7Oxc5GsKCgpw7NgxZGRk6F4LACqVCiqVyuhrgoOD0a5dOyxduhRA4aNF/f398dZbb2HatGkl9rOgoABeXl5YunQpRo8ebc5btJiSsqqonPLz84OTk9kTSsvkwYMHNm1P6+HDh3Zp99GjRzZvs6CgwOZt2rNdexZ5ypJTT7+2PChtTimVSigUClt2FY8fP7Zpe1q2zmN7tuvu7m7zNgGgSZMmdmnX09PT5m0+evQI//3vf0uVU4D5Y6ryMJ4Cis6qH3/8EW5ubrbqKgDg1q1bNm1PKzEx0S7tnjhxwuZtpqam2rxNACV+Pq3l6d9tW9HOhhL52q9M/8pWrlwZzz33HM6dO1fkMSqVCmq1Wm8jIuswtVru7++v91es2NhYo+fLz89HamoqQkNDdfucnJwQGhqKlJQUk/p0//59PHr0CFWqVCn7GyylkrKKOUVkO5wpZRxzikg+zJkpZcqYqryMpwBmFZEtiXLtV6bHJ9y7dw/nz5/HK6+8UpbTEJGFaDSaYv9irtFoAMBotdyYmzdvoqCgAD4+Pnr7fXx8cPr0aZP6NHXqVNSsWVMv3GyNWUUkH6bmVHnDnCKSj5JySnsMYNqYiuMpIrIGUa79zCpKvfPOO+jfvz/q1KmDq1evIiYmBs7OzhgxYoQ5pyEiKzH1CQy2+svV/PnzkZCQgOTkZLi6ulq9PS1mFZF8ifKkmLJiThHJlzlP37PFmIrjKSIyRpRrP7OKUn/99RdGjBiBW7duoXr16ujUqRMOHjyI6tWrm91hIrI8S1/sVatWDc7OzsjKytLbn5WVVeLjgRcuXIj58+fj559/RsuWLc1qt6yYVUTyxaJUIeYUkXyZU5QyBcdTRGQNolz7mVWUSkhIMOvkRGRblg4mpVKJwMBAJCUlITw8HEDhNNCkpCRERUUV+bpPPvkEH330EXbt2oWgoCCz2rQEZhWRfLEoVYg5RSRfli5KcTxFRNYgyrVfmdaUIiJ5scbFXnR0NCIiIhAUFIT27dsjLi4Oubm5iIyMBACMHj0afn5+ugXzPv74Y8ycORPr169HQEAAMjMzARQ+ScheTxMiIvlgUYqI5M7SRSmA4ykisjxRrv1YlCISiDUWEB42bBhu3LiBmTNnIjMzE61bt8bOnTt1C+BdvnxZ73HZK1asQH5+PgYPHqx3npiYGMyaNcvs9olILFzonIjkzpyFzk3F8RQRWZoo134sShEJxFozEKKiooqcspmcnKz39cWLF0vVBhGVD9bKqWXLlmHBggXIzMxEq1at8Pnnn6N9+/ZFHr9x40bMmDEDFy9eRMOGDfHxxx/jxRdfBAA8evQIH3zwAbZv344LFy7A09MToaGhmD9/PmrWrKk7R0BAAC5duqR33tjYWEybNq1U74GI5MEaM6UAjqeIyLJEufZzKvkQInIU2mAqbiMisidr5NSGDRsQHR2NmJgYHD16FK1atUJYWBiuX79u9PgDBw5gxIgRGDt2LI4dO4bw8HCEh4fjxIkTAID79+/j6NGjmDFjBo4ePYrNmzfjzJkzGDBggMG55syZg2vXrum2t956y+z+E5G8mJJTHFMRkb2JklOcKUUkEK7VQkRyZ42cWrx4McaNG6db7yA+Ph4//fQTVq9ebXTW0pIlS9C7d2+8++67AIC5c+ciMTERS5cuRXx8PDw9PZGYmKj3mqVLl6J9+/a4fPkyateurdvv4eFR4hNpiMixWGumFBGRJYly7ceZUkQC0Wg0JW5ERPZkak7l5OTobXl5eUbPl5+fj9TUVISGhur2OTk5ITQ0FCkpKUZfk5KSonc8AISFhRV5PABkZ2dDoVCgcuXKevvnz5+PqlWrok2bNliwYAEeP35syo+BiGTMlJzimIqI7E2UnOJMKSKBiFItJyJxmZpT/v7+evuLWjDz5s2bKCgo0C3AqeXj44PTp08bbSMzM9Po8donxjzr4cOHmDp1KkaMGAG1Wq3b//bbb6Nt27aoUqUKDhw4gOnTp+PatWtYvHhxke+PiOSPM6WIyBGIcu3HohSRYBwlfBzB3bt3S3z6jqU9evTIpu1p2Wt2R0FBgc3btNdfjfjZfMKUn0VGRoZeAUilUlmzS0V69OgRhg4dCkmSsGLFCr3vRUdH6/67ZcuWUCqVeP311xEbG2uz/g4YMAAuLi42aUvrzTfftGl7Wjdv3rRLuxUq2H64HBwcbPM2gcJbWe0hIyPDLu0Wh5ltWXl5eXB2drZpm88+DcxWtm/fbpd2i1pH0ZqqVKli8zaBwtnL9mCPcWtJRMgqFqWIBCJKtZyIxGVqTqnVar2iVFGqVasGZ2dnZGVl6e3Pysoqcq0nX19fk47XFqQuXbqE3bt3l9if4OBgPH78GBcvXkSjRo1K7DsRyRNnShGRIxDl2o9rShEJRJQnMBCRuCydU0qlEoGBgUhKStLt02g0SEpKQkhIiNHXhISE6B0PAImJiXrHawtSZ8+exc8//4yqVauW2Je0tDQ4OTnB29vbrPdARPLCp+8RkSMQJac4U4pIICXdluQoi90RkbiskVPR0dGIiIhAUFAQ2rdvj7i4OOTm5uqexjd69Gj4+fkhNjYWADBp0iR07doVixYtQt++fZGQkIAjR45g5cqVAAoLUoMHD8bRo0exbds2FBQU6NabqlKlCpRKJVJSUvDrr7+ie/fu8PDwQEpKCqZMmYKXX34ZXl5eZr8HIpIPU3KIYyoisjdRrv1YlCISiChTOIlIXNbIqWHDhuHGjRuYOXMmMjMz0bp1a+zcuVO3mPnly5fh5PRkcniHDh2wfv16fPDBB3jvvffQsGFD/PDDD2jevDkA4MqVK9i6dSsAoHXr1npt7dmzB926dYNKpUJCQgJmzZqFvLw81K1bF1OmTNFbZ4qIHBNv3yMiRyDKtR+LUkQCESWYiEhc1sqpqKgoREVFGf1ecnKywb4hQ4ZgyJAhRo8PCAgosR9t27bFwYMHze4nEckfi1JE5AhEufZjUYpIIKIEExGJizlFRHLHohQROQJRxlQsShEJRJT7iolIXMwpIpI7rilFRI5AlDEVi1JEAhGlWk5E4mJOEZHccaYUETkCUcZULEoRCUSUYCIicTGniEjuWJQiIkcgypiKRSkigYgSTEQkLuYUEckdi1JE5AhEGVOxKEUkEFGCiYjExZwiIrljUYqIHIEoYyonc19w5coVvPzyy6hatSoqVqyIFi1a4MiRI9boGxGZSaPRlLiVB8wpIvliTj3BrCKSJ1NyqrxkFXOKSL5EySmzZkr9/fff6NixI7p3744dO3agevXqOHv2LLy8vKzVPyIygyjV8rJgThHJG3OqELOKSL44U6oQc4pI3kQZU5lVlPr444/h7++PNWvW6PbVrVu32Nfk5eUhLy9P93VOTo6ZXSQiU4kSTGXBnCKSN+ZUIXOzijlFZDssShXimIpI3kQZU5l1+97WrVsRFBSEIUOGwNvbG23atMGqVauKfU1sbCw8PT11m7+/f5k6TETF04aTsa08YE4RyV95zynA/KxiThHZVnE5VV6yimMqIvkTIafMKkpduHABK1asQMOGDbFr1y5MmDABb7/9Nr7++usiXzN9+nRkZ2frtoyMjDJ3moiME+W+4rJgThHJG3OqkLlZxZwish2uKVWIYyoieRMlp8y6fU+j0SAoKAjz5s0DALRp0wYnTpxAfHw8IiIijL5GpVJBpVKVvadEVCJONWdOEckdc6qQuVnFnCKyHVNyqDxkFcdURPImypjKrJlSNWrUQNOmTfX2NWnSBJcvX7Zop4iodEqaau4owVQWzCkieWNOFWJWEcmXKTlVHrKKOUUkb6LklFkzpTp27IgzZ87o7fvzzz9Rp04di3aKiEpHlGp5WTCniOSNOVWIWUUkX5wpVYg5RSRvooypzCpKTZkyBR06dMC8efMwdOhQHDp0CCtXrsTKlSut1T8iMoNGo4FCoSjy+44STGXBnCKSN+ZUIWYVkXyVlFNA+cgq5hSRvIkypjLr9r127dphy5Yt+Pe//43mzZtj7ty5iIuLw6hRo6zVPyIygyhTOMuCOUUkb8ypQswqIvni7XuFmFNE8iZKTpk1UwoA+vXrh379+lmjL0RURqJM4Swr5hSRfDGnnmBWEckTb997gjlFJF+ijKnMLkoRkXyJEkxEJC7mFBHJHYtSROQIRBlTsShFJBBRgomIxMWcIiK5Y1GKiByBKGMqFqWIBCLKYndEJC7mFBHJHRc6JyJHIMqYikUpIoGIUi0nInExp4hI7jhTiogcgShjKrOevkdE8matJzAsW7YMAQEBcHV1RXBwMA4dOlTs8Rs3bkTjxo3h6uqKFi1aYPv27aVql4jEI8qTYohIXNZ6+h7HU0RkSaJc+7EoRSQQawTThg0bEB0djZiYGBw9ehStWrVCWFgYrl+/bvT4AwcOYMSIERg7diyOHTuG8PBwhIeH48SJE2V9e0QkABaliEjurFGU4niKiCxNlGs/hWTj0V92djYqV65syyaJhHTnzh14enoCAHJycnT/bYqMjAyo1Wrd1yqVCiqVyuixwcHBaNeuHZYuXQqg8N5lf39/vPXWW5g2bZrB8cOGDUNubi62bdum2/f888+jdevWiI+PN7mP9qTNKQ8PjxLXlLC0R48e2bQ9rcePH9ul3YKCApu3qdFobN5meVWWnMrOztbLKdKnzal//OMfcHFxsWnbr732mk3b07p165Zd2q1QwfarXQQFBdm8TQD45JNP7NLuX3/9ZfM2Hz16hP/+979lyinA9DFVeRxPAU+y6ptvvkGlSpVs2vYLL7xg0/a03nzzTbu0m5KSYvM2c3Nzbd4mUPhZtYcHDx7YpV1A8Gs/ycYyMjIkANy4cSvjlpGRoftcPXjwQPL19TXpde7u7gb7YmJijH5e8/LyJGdnZ2nLli16+0ePHi0NGDDA6Gv8/f2lTz/9VG/fzJkzpZYtW5YlOmyKOcWNm2W20uaUr6+v9ODBAzumgPwxp7hxs8xW2pwCTB9TldfxlCQxq7hxs9Qm8rWfzf/0U7NmTWRkZJRqBkJOTg78/f0NKn3WZI822S7bLY4kSbh79y5q1qyp2+fq6or09HTk5+eb9PpnP3tFVcpv3ryJgoIC+Pj46O338fHB6dOnjb4mMzPT6PGZmZkl9k0uHC2nylu75em9Omq7Zc0ppVIJV1dXs/tcnjCn2C7btW9Oac9hypiqvI6nAGaV3NstT+/VUdstD9d+Ni9KOTk5oVatWmU6h1qttvmUfnu0yXbZblGMTdd0dXXlRZyFOGpOlbd2y9N7dcR2mVPWxZxiu2y37G0yp6yPWeUY7Zan9+qI7YqeVVzonIiKVK1aNTg7OyMrK0tvf1ZWFnx9fY2+xtfX16zjiYiIiETG8RQROQJ7ZRWLUkRUJKVSicDAQCQlJen2aTQaJCUlISQkxOhrQkJC9I4HgMTExCKPJyIiIhIZx1NE5AjslVW2f5xIGahUKsTExBR5D6QobbJdtisn0dHRiIiIQFBQENq3b4+4uDjk5uYiMjISADB69Gj4+fkhNjYWADBp0iR07doVixYtQt++fZGQkIAjR45g5cqV9nwbNlPefqeYy2yXHE95+51iu+K260g5xfGU+crT77K92i1P77U8tlsa9sgqhSRJklXeDREJY+nSpViwYAEyMzPRunVrfPbZZwgODgYAdOvWDQEBAVi7dq3u+I0bN+KDDz7AxYsX0bBhQ3zyySd48cUX7dR7IiIiIvvjeIqIHIGts4pFKSIiIiIiIiIisjmuKUVERERERERERDbHohQREREREREREdkci1JERERERERERGRzLEoREREREREREZHNOUxRatmyZQgICICrqyuCg4Nx6NAhq7a3b98+9O/fHzVr1oRCocAPP/xg1fa0YmNj0a5dO3h4eMDb2xvh4eE4c+aM1dtdsWIFWrZsCbVaDbVajZCQEOzYscPq7T5t/vz5UCgUmDx5slXbmTVrFhQKhd7WuHFjq7apdeXKFbz88suoWrUqKlasiBYtWuDIkSM2aZusz9Y5Bdgnq8pzTgHMKnJ8HFNZlxyyijlFjo5jKuuSQ04B4mcVc8o0DlGU2rBhA6KjoxETE4OjR4+iVatWCAsLw/Xr163WZm5uLlq1aoVly5ZZrQ1j9u7di4kTJ+LgwYNITEzEo0eP0KtXL+Tm5lq13Vq1amH+/PlITU3FkSNH0KNHD/zjH//AyZMnrdqu1uHDh/HFF1+gZcuWNmmvWbNmuHbtmm775ZdfrN7m33//jY4dO8LFxQU7duzAqVOnsGjRInh5eVm9bbI+e+QUYJ+sKq85BTCryPFxTCV+VjGnyNFxTCV+TgHiZxVzygySA2jfvr00ceJE3dcFBQVSzZo1pdjYWJu0D0DasmWLTdp61vXr1yUA0t69e23etpeXl/Tll19avZ27d+9KDRs2lBITE6WuXbtKkyZNsmp7MTExUqtWrazahjFTp06VOnXqZPN2yTbsnVOSZL+sKg85JUnMKhKDvbOKYyrrYk6RCOydU5LEMZW1lYesYk6ZTvYzpfLz85GamorQ0FDdPicnJ4SGhiIlJcWOPbON7OxsAECVKlVs1mZBQQESEhKQm5uLkJAQq7c3ceJE9O3bV+//sbWdPXsWNWvWRL169TBq1ChcvnzZ6m1u3boVQUFBGDJkCLy9vdGmTRusWrXK6u2S9TGnxM8pgFlFjo9ZJX5WMafI0TGnxM8poHxkFXPKdLIvSt28eRMFBQXw8fHR2+/j44PMzEw79co2NBoNJk+ejI4dO6J58+ZWb+/48eNwd3eHSqXCG2+8gS1btqBp06ZWbTMhIQFHjx5FbGysVdt5WnBwMNauXYudO3dixYoVSE9PR+fOnXH37l2rtnvhwgWsWLECDRs2xK5duzBhwgS8/fbb+Prrr63aLlkfc0rsnAKYVcwqMTCrxM4q5hRzSgTMKbFzCig/WcWcMl0Fe3eAijZx4kScOHHCJvfmA0CjRo2QlpaG7OxsbNq0CREREdi7d6/VwikjIwOTJk1CYmIiXF1drdKGMX369NH9d8uWLREcHIw6dergu+++w9ixY63WrkajQVBQEObNmwcAaNOmDU6cOIH4+HhERERYrV0iaxI9pwBmFbOKRCB6VjGnmFPk+ETPKaB8ZRVzynSynylVrVo1ODs7IysrS29/VlYWfH197dQr64uKisK2bduwZ88e1KpVyyZtKpVKNGjQAIGBgYiNjUWrVq2wZMkSq7WXmpqK69evo23btqhQoQIqVKiAvXv34rPPPkOFChVQUFBgtbafVrlyZTz33HM4d+6cVdupUaOGQcg3adLEJtPcybqYU+LmFMCsAphVomBWiZtVzCnmlCiYU+LmFFC+soo5ZTrZF6WUSiUCAwORlJSk26fRaJCUlGSze15tSZIkREVFYcuWLdi9ezfq1q1rt75oNBrk5eVZ7fw9e/bE8ePHkZaWptuCgoIwatQopKWlwdnZ2WptP+3evXs4f/48atSoYdV2OnbsaPCI1z///BN16tSxartkfcwpcXMKYFYBzCpRMKvEzSrmFHNKFMwpcXMKKF9ZxZwyg33XWTdNQkKCpFKppLVr10qnTp2Sxo8fL1WuXFnKzMy0Wpt3796Vjh07Jh07dkwCIC1evFg6duyYdOnSJau1KUmSNGHCBMnT01NKTk6Wrl27ptvu379v1XanTZsm7d27V0pPT5d+//13adq0aZJCoZD++9//WrXdZ9ni6Qv/93//JyUnJ0vp6enS/v37pdDQUKlatWrS9evXrdruoUOHpAoVKkgfffSRdPbsWWndunVSpUqVpG+//daq7ZJt2COnJMk+WVXec0qSmFXkuDimKj9ZxZwiR8UxVfnJKUkSN6uYU6ZziKKUJEnS559/LtWuXVtSKpVS+/btpYMHD1q1vT179kgADLaIiAirtmusTQDSmjVrrNruq6++KtWpU0dSKpVS9erVpZ49ewobSsOGDZNq1KghKZVKyc/PTxo2bJh07tw5q7ap9eOPP0rNmzeXVCqV1LhxY2nlypU2aZdsw9Y5JUn2yarynlOSxKwix8Yx1RqrtiuXrGJOkSPjmGqN1dqUJPnklCSJnVXMKdMoJEmSLD//ioiIiIiIiIiIqGiyX1OKiIiIiIiIiIjEw6IUERERERERERHZHItSRERERERERERkcyxKERERERERERGRzbEoRURERERERERENseiFBERERERERER2RyLUkREREREREREZHMsShERERERERERkc2xKEVERERERERERDbHohQREREREREREdkci1JERERERERERGRz/w+DqpAnLq4BqgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x300 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8b22b0969caf424fb08432ffc76513f7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expert satisfaction = 0.90\n",
      "ICL iteration 2 ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "897ce22968414863a9c9dd200f015396",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8e55bd6b44794f45a812b57b5549b410",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.52\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e5663622beb647af862d70b41a317d8b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.62\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "36e299a9ea4846ebbbd0974e9d3bfd2b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "973d6c09732d4f58a72d4792f0bfdf70",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c187296fbb704433ab3863e30ebe4923",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expert satisfaction = 0.88\n",
      "ICL iteration 3 ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "052d423727d04510a8f0d8a824ea6105",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5b1cc23bda254a519477d033103797e0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.35\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1215c1bd7cc2436597a5f5006a2da1bd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.28\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "56545b329b0c4a00af5928d08ae7c415",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ee6f1e49b1b4fe18d56d9b72af992a3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0f38ecacfd874c20bb9d2f1e1a534d96",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expert satisfaction = 0.84\n",
      "ICL iteration 4 ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "203fa6745832449784ef4a2ab7130a84",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "22bb275f1f6e45ec9c093f35086dc5d8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.46\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3d0c07c335df44409e7b9f3342cbe610",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added policy with dissimilarity = 0.19\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "acadb49e077d42f882718e985fcd999c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "14a6c3df74a84d10bce1a8cabd000dd7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e18363f60d9c482ca3dcf563dddd6898",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expert satisfaction = 0.80\n"
     ]
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    policy_mixture, weights_mixture = [], []\n",
    "    expert_satisfaction = (compute_current_constraint_value_trajectory(constraint_nn, expert_data) <= beta).float().mean()\n",
    "    print(\"Expert satisfaction = %.2f\" % expert_satisfaction)\n",
    "    for itr in range(n_iters):\n",
    "        print(\"ICL iteration %d ...\" % itr)\n",
    "        value_nn, policy_nn = make_nn()\n",
    "        ppo_penalty(ppo_iters, env, policy_nn, value_nn, current_constraint_function, condition, command)\n",
    "        agent_data = collect_trajectories(len(expert_data), test_env, policy_nn, current_constraint_function)\n",
    "        mixture_data = collect_trajectories_mixture(len(expert_data), test_env, policy_mixture, weights_mixture, current_constraint_function)\n",
    "        fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n",
    "        visualize_constraint(true_constraint_function, fig, ax[0])\n",
    "        ax[0].set_title(\"True constraint\")\n",
    "        visualize_constraint(current_constraint_function, fig, ax[1])\n",
    "        ax[1].set_title(\"Learned constraint (itr = %d)\" % itr)\n",
    "        visualize_accrual(expert_data, fig, ax[2])\n",
    "        ax[2].set_title(\"Expert accrual\")\n",
    "        visualize_accrual(agent_data, fig, ax[3])\n",
    "        ax[3].set_title(\"Agent accrual\")\n",
    "        fig.tight_layout()\n",
    "        plt.show()\n",
    "        mixture_data_constraint_returns = compute_current_constraint_value_trajectory(constraint_nn, mixture_data)\n",
    "        for _ in tqdm.notebook.tqdm(range(ca_iters)):\n",
    "            constraint_function_adjustment(ca_iters, constraint_nn, constraint_opt, expert_data, mixture_data)\n",
    "        expert_satisfaction = (compute_current_constraint_value_trajectory(constraint_nn, expert_data) <= beta).float().mean()\n",
    "        print(\"Expert satisfaction = %.2f\" % expert_satisfaction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "32275d90-47a8-49ee-97c3-d06551c63b08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2e88f9dd64b54677a8b99852cf30ce64",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e6561fb76cc4e7aacaedd97a12e7bfc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    value_nn, policy_nn = make_nn()\n",
    "    ppo_penalty(ppo_iters, env, policy_nn, value_nn, current_constraint_function)\n",
    "    agent_data = collect_trajectories(len(expert_data), test_env, policy_nn, current_constraint_function)\n",
    "    fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n",
    "    visualize_constraint(true_constraint_function, fig, ax[0])\n",
    "    ax[0].set_title(\"True constraint\")\n",
    "    visualize_constraint(current_constraint_function, fig, ax[1])\n",
    "    ax[1].set_title(\"Final constraint\")\n",
    "    visualize_accrual(expert_data, fig, ax[2])\n",
    "    ax[2].set_title(\"Expert accrual\")\n",
    "    visualize_accrual(agent_data, fig, ax[3])\n",
    "    ax[3].set_title(\"Final accrual\")\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89c35c2d-54b5-4fe6-a83f-6e67f03e2ff1",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}