relu_attn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7821e58b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "import triton\n",
    "import triton.language as tl\n",
    "\n",
    "try:\n",
    "    from flash_attn.flash_attn_interface import \\\n",
    "        flash_attn_qkvpacked_func as flash_attn_func\n",
    "    HAS_FLASH = True\n",
    "except BaseException:\n",
    "    HAS_FLASH = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2c13728",
   "metadata": {},
   "outputs": [],
   "source": [
    "# relu_attn bf16 fwd implementation\n",
    "# from https://gist.github.com/mitchellnw/17d529b1a5eabd38ca345e41f5002074\n",
    "\n",
    "@triton.jit\n",
    "def relu_attn_(q_ptr,\n",
    "               k_ptr,\n",
    "               v_ptr,\n",
    "               o_ptr,\n",
    "               Dh: tl.constexpr, # head dim\n",
    "               L: tl.constexpr,  # seqlen\n",
    "               Nh: tl.constexpr, # num heads\n",
    "               B: tl.constexpr,  # batchsize\n",
    "               sm_scale: tl.constexpr, # 1/sqrt(Dh)\n",
    "               relu_scale: tl.constexpr, # 1/L\n",
    "               is_causal: tl.constexpr,\n",
    "               is_squared: tl.constexpr,\n",
    "               BLOCK_SIZE: tl.constexpr,  # Number of elements each program should process.\n",
    "               ):\n",
    "    # Q, K, V is of size [B, L, Nh, Dh]\n",
    "    pid = tl.program_id(axis=0) # current program id\n",
    "    currB = (pid * BLOCK_SIZE) // (Nh * L) # current batch idx\n",
    "    currL = (BLOCK_SIZE * pid) % L\n",
    "    currNh = ((BLOCK_SIZE * pid) // L) % Nh\n",
    "    # Common offsets\n",
    "    block_start = currB*Nh*L*Dh + currL*Nh*Dh + currNh*Dh\n",
    "    bsz_offset = tl.arange(0, BLOCK_SIZE)\n",
    "    common_offset = tl.arange(0, Dh)[None, :] + bsz_offset[:, None]*(Dh*Nh)\n",
    "    # Always keep q in mem\n",
    "    q = tl.load(q_ptr + block_start + common_offset)\n",
    "    # Accum.\n",
    "    acc = tl.zeros((BLOCK_SIZE, Dh), dtype=tl.float32)\n",
    "    # Loop over seqlen in BLOCK_SIZE chunks\n",
    "    upper = currL + 1 if is_causal else L\n",
    "    for l in range(0, upper, BLOCK_SIZE):\n",
    "      common_kv_offset = currB*Nh*L*Dh + l*Nh*Dh + currNh*Dh + common_offset\n",
    "      k = tl.load(k_ptr + common_kv_offset)\n",
    "      v = tl.load(v_ptr + common_kv_offset)\n",
    "      qk = tl.dot((q * sm_scale).to(tl.bfloat16), tl.trans(k)) # TODO: why is bfloat cast required\n",
    "      # causal masking and relu\n",
    "      mask = (qk >= 0)\n",
    "      if is_causal:\n",
    "        mask *= ((currL + bsz_offset)[:, None] >= (l + bsz_offset)[None, :])\n",
    "      qk = tl.where(mask, qk, 0.)\n",
    "      if is_squared:\n",
    "        qk *= qk\n",
    "      acc += tl.dot((relu_scale * qk).to(tl.bfloat16), v) # TODO: why is bfloat cast required\n",
    "    tl.store(o_ptr + block_start + common_offset, acc)\n",
    "\n",
    "\n",
    "def relu_attn(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, is_causal: bool = True, is_squared: bool = False):\n",
    "    output = torch.empty_like(q)\n",
    "    B, L, Nh, Dh = q.shape\n",
    "    BLOCK_SIZE = min(L, 64)\n",
    "    grid = lambda meta: ((B * Nh * L) // BLOCK_SIZE, )\n",
    "    relu_attn_[grid](q, k, v, output, Dh, L, Nh, B, 1./np.sqrt(Dh), 1./L, is_causal=is_causal, is_squared=is_squared, BLOCK_SIZE=BLOCK_SIZE, num_warps=4, num_stages=1)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d53e7d98",
   "metadata": {},
   "outputs": [],
   "source": [
    "# relu_attn2 bf16 implementation by me\n",
    "\n",
    "# Main changes:\n",
    "# - block pointers (better for optimization)\n",
    "# - 2d \"block grid\"\n",
    "# - autotune\n",
    "\n",
    "\n",
    "@triton.autotune(\n",
    "   configs=[\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64}, num_stages=4, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 256, 'BLOCK_N': 64}, num_stages=3, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 256, 'BLOCK_N': 32}, num_stages=3, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 256, 'BLOCK_N': 32}, num_stages=3, num_warps=4),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 32}, num_stages=3, num_warps=4),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 32}, num_stages=4, num_warps=4),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64}, num_stages=3, num_warps=4),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64}, num_stages=4, num_warps=4),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64}, num_stages=3, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64}, num_stages=7, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 32}, num_stages=7, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 32}, num_stages=6, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 32}, num_stages=5, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 32}, num_stages=4, num_warps=8),\n",
    "       triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64}, num_stages=6, num_warps=4),\n",
    "   ],\n",
    "   key=['L'],\n",
    ")\n",
    "@triton.jit\n",
    "def relu_attn2_(\n",
    "       q_ptr, k_ptr, v_ptr, o_ptr,\n",
    "       qb_stride, qh_stride, ql_stride, qd_stride,\n",
    "       kb_stride, kh_stride, kl_stride, kd_stride,\n",
    "       vb_stride, vh_stride, vl_stride, vd_stride,\n",
    "       ob_stride, oh_stride, ol_stride, od_stride,\n",
    "       B: tl.constexpr, Nh: tl.constexpr, L: tl.constexpr, Dh: tl.constexpr,\n",
    "       sm_scale: tl.constexpr, relu_scale: tl.constexpr, # 1/sqrt(Dh), 1/L\n",
    "       is_causal: tl.constexpr,\n",
    "       BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr\n",
    "   ):\n",
    "\n",
    "    # Q, K, V is of size [B, Nh, L, Dh]\n",
    "    L_pid = tl.program_id(axis=0) # current pid in L dim\n",
    "    BNh_pid = tl.program_id(axis=1) # current pid in B * Nh dim\n",
    "\n",
    "    currL = L_pid\n",
    "    currB = BNh_pid // Nh\n",
    "    currNh = BNh_pid % Nh\n",
    "    # move to current sample & head\n",
    "    qkv_offset = currB * qb_stride + currNh * qh_stride\n",
    "\n",
    "    # block pointers (better for perf)\n",
    "    Q_block_ptr = tl.make_block_ptr(\n",
    "        base = q_ptr + qkv_offset,\n",
    "        shape = (L, Dh),\n",
    "        strides = (ql_stride, qd_stride),\n",
    "        offsets = (currL * BLOCK_M, 0),\n",
    "        block_shape = (BLOCK_M, Dh),\n",
    "        order = (1, 0),\n",
    "    )\n",
    "    V_block_ptr = tl.make_block_ptr(\n",
    "        base = v_ptr + qkv_offset,\n",
    "        shape = (L, Dh),\n",
    "        strides = (vl_stride, vd_stride),\n",
    "        offsets = (0, 0),  # will be iterated over so start from 0\n",
    "        block_shape = (BLOCK_N, Dh),\n",
    "        order = (1, 0),\n",
    "    )\n",
    "    K_block_ptr = tl.make_block_ptr(\n",
    "        base = k_ptr + qkv_offset,\n",
    "        shape = (Dh, L),  # load transposed\n",
    "        strides = (kd_stride, kl_stride),  # load transposed\n",
    "        offsets = (0, 0),  # will be iterated over so start from 0\n",
    "        block_shape = (Dh, BLOCK_N),  # load transposed\n",
    "        order = (0, 1),  # load transposed\n",
    "    )\n",
    "    O_block_ptr = tl.make_block_ptr(\n",
    "        base = o_ptr + qkv_offset,\n",
    "        shape = (L, Dh),\n",
    "        strides = (ol_stride, od_stride),\n",
    "        offsets = (currL * BLOCK_M, 0),\n",
    "        block_shape = (BLOCK_M, Dh),\n",
    "        order = (1, 0),\n",
    "    )\n",
    "\n",
    "    # initialize offsets\n",
    "    offs_m = currL * BLOCK_M + tl.arange(0, BLOCK_M)\n",
    "    offs_n = tl.arange(0, BLOCK_N)\n",
    "\n",
    "    # initialize accum\n",
    "    acc = tl.zeros([BLOCK_M, Dh], dtype=tl.float32)\n",
    "\n",
    "    # load q block\n",
    "    q = tl.load(Q_block_ptr)\n",
    "\n",
    "    lo = 0\n",
    "    hi = (currL + 1) * BLOCK_M if is_causal else L\n",
    "    \n",
    "    # for start_n in range(lo, hi, BLOCK_N):\n",
    "    for start_n in range(lo, hi, BLOCK_N):\n",
    "        start_n = tl.multiple_of(start_n, BLOCK_N)  # maybe (very) slightly improves perf\n",
    "\n",
    "        k = tl.load(K_block_ptr)\n",
    "        qk = tl.dot((q * sm_scale).to(tl.bfloat16), k)  # already transposed in make_block_ptr\n",
    "\n",
    "        # causal masking and relu\n",
    "        mask = (qk >= 0)\n",
    "        if is_causal:\n",
    "            mask *= offs_m[:, None] >= (start_n + offs_n[None, :])\n",
    "        qk = tl.where(mask, qk, 0.)\n",
    "\n",
    "        # update acc\n",
    "        v = tl.load(V_block_ptr)\n",
    "        acc += tl.dot((relu_scale * qk).to(tl.bfloat16), v)\n",
    "\n",
    "        # advance pointers\n",
    "        V_block_ptr = tl.advance(V_block_ptr, (BLOCK_N, 0))\n",
    "        K_block_ptr = tl.advance(K_block_ptr, (0, BLOCK_N))\n",
    "\n",
    "    tl.store(O_block_ptr, acc.to(o_ptr.type.element_ty))\n",
    "\n",
    "\n",
    "def relu_attn2(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, is_causal: bool = True, is_squared: bool = False):\n",
    "    assert is_causal, \"For now only causal = True\"\n",
    "    o = torch.empty_like(q)\n",
    "    B, Nh, L, Dh = q.shape\n",
    "\n",
    "    # BLOCK_M, BLOCK_N = 64, 32\n",
    "    # num_warps, num_stages = 4, 4\n",
    "    grid = lambda meta: (triton.cdiv(L, meta['BLOCK_M']), (B * Nh), 1)\n",
    "\n",
    "    relu_attn2_[grid](\n",
    "        q, k, v, o,\n",
    "        *q.stride(),\n",
    "        *k.stride(),\n",
    "        *v.stride(),\n",
    "        *o.stride(),\n",
    "        B, Nh, L, Dh,\n",
    "        1./np.sqrt(Dh), 1./L,\n",
    "        is_causal=is_causal,\n",
    "        # BLOCK_M=BLOCK_M, BLOCK_N=BLOCK_N, num_warps=num_warps, num_stages=num_stages,\n",
    "    )\n",
    "    return o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27de504b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# benchmarking code\n",
    "\n",
    "# default vals\n",
    "BATCH, N_HEADS, N_CTX, D_HEAD = 4, 48, 4096, 64\n",
    "\n",
    "# vary seq length for fixed head and batch=4\n",
    "configs = []\n",
    "for xval in [\"N_CTX\", \"H\"]:\n",
    "    x_names = [xval]\n",
    "    x_vals=[2**i for i in range(10, 18)] if xval == \"N_CTX\" else [2*i for i in range(12, 48)]\n",
    "\n",
    "    args={\n",
    "        \"BATCH\": BATCH,\n",
    "        \"D_HEAD\": D_HEAD,\n",
    "        \"dtype\": torch.bfloat16,\n",
    "    }\n",
    "    if xval == \"N_CTX\":\n",
    "        args[\"H\"] = N_HEADS\n",
    "    else:\n",
    "        args[\"N_CTX\"] = N_CTX\n",
    "\n",
    "    # for mode in [\"fwd\", \"bwd\"]:\n",
    "    for mode in [\"fwd\"]:\n",
    "        args[\"mode\"] = mode\n",
    "\n",
    "        configs.append(\n",
    "            triton.testing.Benchmark(\n",
    "                x_names=x_names,\n",
    "                x_vals=x_vals,\n",
    "                x_log=True,\n",
    "                line_arg=\"provider\",\n",
    "                line_vals=[\"relu\", \"relu2\"] + ([\"flash\"] if HAS_FLASH else []),\n",
    "                line_names=[\"ReLU\", \"ReLU-2\"] + ([\"Flash-2\"] if HAS_FLASH else []),\n",
    "                styles=[(\"red\", \"-\"), (\"green\", \"-\"), (\"blue\", \"-\")],\n",
    "                ylabel=\"ms\",\n",
    "                plot_name=f\"fused-attention-batch{BATCH}-d{D_HEAD}-{mode}-xval{xval}\",\n",
    "                args=args,\n",
    "            ))\n",
    "\n",
    "        \n",
    "@triton.testing.perf_report(configs)\n",
    "def bench_flash_attention(BATCH, H, N_CTX, D_HEAD, mode, provider, dtype=torch.bfloat16, device=\"cuda\"):\n",
    "    print(N_CTX, H)\n",
    "    assert mode in [\"fwd\", \"bwd\"]\n",
    "    warmup = 25\n",
    "    rep = 100\n",
    "    if provider == \"relu\":\n",
    "        q = torch.randn((BATCH, N_CTX, H, D_HEAD), dtype=dtype, device=\"cuda\", requires_grad=True)\n",
    "        k = torch.randn((BATCH, N_CTX, H, D_HEAD), dtype=dtype, device=\"cuda\", requires_grad=True)\n",
    "        v = torch.randn((BATCH, N_CTX, H, D_HEAD), dtype=dtype, device=\"cuda\", requires_grad=True)\n",
    "        fn = lambda: relu_attn(q, k, v, is_causal=True, is_squared=False)\n",
    "        if mode == \"bwd\":\n",
    "            o = fn()\n",
    "            do = torch.randn_like(o)\n",
    "            fn = lambda: o.backward(do, retain_graph=True)\n",
    "        ms = triton.testing.do_bench(fn, warmup=warmup, rep=rep)\n",
    "    if provider == \"relu2\":\n",
    "        q = torch.randn((BATCH, H, N_CTX, D_HEAD), dtype=dtype, device=\"cuda\", requires_grad=True)\n",
    "        k = torch.randn((BATCH, H, N_CTX, D_HEAD), dtype=dtype, device=\"cuda\", requires_grad=True)\n",
    "        v = torch.randn((BATCH, H, N_CTX, D_HEAD), dtype=dtype, device=\"cuda\", requires_grad=True)\n",
    "        fn = lambda: relu_attn2(q, k, v, is_causal=True, is_squared=False)\n",
    "        if mode == \"bwd\":\n",
    "            o = fn()\n",
    "            do = torch.randn_like(o)\n",
    "            fn = lambda: o.backward(do, retain_graph=True)\n",
    "        ms = triton.testing.do_bench(fn, warmup=warmup, rep=rep)\n",
    "    if provider == \"flash\":\n",
    "        qkv = torch.randn((BATCH, N_CTX, 3, H, D_HEAD), dtype=dtype, device=device, requires_grad=True)\n",
    "        fn = lambda: flash_attn_func(qkv, causal=True)\n",
    "        if mode == \"bwd\":\n",
    "            o = fn()\n",
    "            do = torch.randn_like(o)\n",
    "            fn = lambda: o.backward(do, retain_graph=True)\n",
    "        ms = triton.testing.do_bench(fn, warmup=warmup, rep=rep)\n",
    "\n",
    "    return ms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6635b136",
   "metadata": {},
   "outputs": [],
   "source": [
    "bench_flash_attention.run(save_path=\".\", print_data=True)"
   ]
  },
  {
   "attachments": {
    "fused-attention-batch4-d64-fwd-xvalN_CTX.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "b5f4284e",
   "metadata": {},
   "source": [
    "![fused-attention-batch4-d64-fwd-xvalN_CTX.png](attachment:fused-attention-batch4-d64-fwd-xvalN_CTX.png)"
   ]
  },
  {
   "attachments": {
    "fused-attention-batch4-d64-fwd-xvalH.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtmElEQVR4nO3dZ3RUVRuG4XuSkAYk9B6adJAiIIL0KiAC0qWEJoKICNJEEbEAoiKoVAGR3ntHpChFKSK9SZfeEpKQOvP92IYQQT8QkpPMPNdaWc45c5K8M0TysPfZ77Y5HA4HIiIiIuIy3KwuQEREREQSlwKgiIiIiItRABQRERFxMQqAIiIiIi5GAVBERETExSgAioiIiLgYBUARERERF6MAKCIiIuJiFABFREREXIwCoIiIiIiLUQAUERERcTEKgCIiIiIuRgFQRERExMUoAIqIiIi4GAVAERERERejACgiIiLiYhQARURERFyMAqCIiIiIi1EAFBEREXExCoAiIiIiLkYBUERERMTFKACKiIiIuBgFQBEREREXowAoIiIi4mIUAEVERERcjAKgiIiIiItRABQRERFxMQqAIiIiIi5GAVBERETExSgAioiIiLgYBUARERERF6MAKCIiIuJiFABFREREXIwCoIiIiIiLUQAUERERcTEKgCIiIiIuRgFQRERExMUoAIqIiIi4GAVAERERERejACgiIiLiYhQARURERFyMAqCIiIiIi1EAFBEREXExCoAiIiIiLkYBUERERMTFKACKiIiIuBgFQBEREREXowAoIiIi4mIUAEVERERcjAKgiIiIiItRABQRERFxMQqAIiIiIi5GAVBERETExSgAioiIiLgYBUARERERF6MAKCIiIuJiPKwuIDmz2+1cuHCB1KlTY7PZrC5HREREHoLD4eD27dtky5YNNzfXHAtTAHwMFy5cICAgwOoyRERE5D84d+4cOXLksLoMSygAPobUqVMD5gfIz8/P4mpERETkYQQHBxMQEHD397grUgB8DLHTvn5+fgqAIiIiyYwr377lmhPfIiIiIi5MAVBERETExSgAioiIiLgY3QOYwBwOB9HR0cTExFhdistyd3fHw8PDpe/1EBERuZcCYAKKjIzk4sWLhIWFWV2Ky/P19SVr1qx4enpaXYqIiIjlFAATiN1u59SpU7i7u5MtWzY8PT01AmUBh8NBZGQkV69e5dSpU+TPn99lm36KiIjEUgBMIJGRkdjtdgICAvD19bW6HJfm4+NDihQpOHPmDJGRkXh7e1tdkoiIiKU0FJLANNqUNOjPQUREJI5+K4qIiIi4GAVAERERERejACj3ad++PTabDZvNRooUKciTJw/9+vUjPDz8oT7/9OnT2Gw29u7de99zmzZtwmazcevWrfuey507N6NGjXq84kVEROT/0iIQeaAXXniB7777jqioKHbv3k1gYCA2m41PP/3U6tJERMRVOBygDhoJQiOA8kBeXl5kyZKFgIAAGjVqRM2aNVm/fj1gWtwMGzaMPHny4OPjQ4kSJViwYIHFFYuIiFPZvh1KloQTJ6yuxClpBDAxORxgRVNoX9/H+hfUgQMH2LZtG7ly5QJg2LBhzJgxg/Hjx5M/f362bNlCmzZtyJgxI1WqVHlSVYuIiCuKjoahQ+HDDyEmBgYMAA0yPHEKgIkpLAxSpUr87xsSAilTPtKnrFixglSpUhEdHU1ERARubm588803REREMHToUH744QfKly8PQN68efn555+ZMGGCAqCIiPx3p09Dmzawdas5btUKxo61tCRnpQAoD1StWjXGjRtHaGgoX375JR4eHjRp0oSDBw8SFhZGrVq14l0fGRlJqVKlLKpWRESSvVmzoFs3CA6G1KlN8GvTxuqqnJYCYGLy9TWjcVZ830eUMmVK8uXLB8CUKVMoUaIEkydPplixYgCsXLmS7Nmzx/scLy+v//t1/fz8AAgKCiJNmjTxnrt16xb+/v6PXKuIiCRjwcHQvTvMmGGOy5c3j/PmtbYuJ6cAmJhstkeeik0K3NzcGDhwIL179+bYsWN4eXlx9uzZ/zTdG7sX7+7du+/eUwhw8uRJgoKCKFCgwJMsXUREkrLffoMmTeDUKXBzg0GD4L33wEPxJKHpHZaH0qxZM/r27cuECRPo06cPvXr1wm63U7FiRYKCgti6dSt+fn4EBgbe/ZyjR4/e93WKFi1K586defvtt/Hw8ODpp5/m3Llz9O/fn+eee44KFSok5ssSERGrXL4M9evDxYuQKxfMnAnPP291VS5DAVAeioeHB2+88QYjRozg1KlTZMyYkWHDhnHy5EnSpEnDM888w8CBA+N9TsuWLe/7OufOnWP06NEMHz6c/v37c+bMGbJkyUKtWrX45JNPsKnfk4iI84uJgVdeMeGvcGHYtg3+dluQJCybw+FwWF1EchUcHIy/vz9BQUF3722LFR4ezqlTp8iTJw/e3t4WVSix9OchIpKEDB5s2rz4+sLOnVCkSKJ++3/7/e0q1AhaREREEs+6dfDRR+bxxImJHv7EUAAUERGRxHH+PLRubTZGeO0181gsoQAoIiIiCS8qClq0gGvX4JlnYNQoqytyaQqAIiIikvAGDDCLPfz9Yf580P3YllIAFBERkYS1eDGMHGkeT52qJs9JgAKgiIiIJJw//oD27c3jt9+GRo2srEb+ogAoIiIiCePOHWjWzGz39vzzMGyY1RXJXxQARURE5MlzOKBbN7PdW4YMMGcOpEhhdVXyFwVAERERefLGj4fvvzd7/M6dCzlyWF2R3EMBUERERJ6s7duhZ0/zePhwqF7d2nrkPgqAcp/27dtjs9mw2WykSJGCPHny0K9fP8LDwx/q80+fPo3NZmPv3r33Pbdp0yZsNhu3bt2677ncuXMz6l/6Qv3++++0atWKgIAAfHx8KFy4MKNHj37IVyUiIoni8mVo2tT0/WvaFPr0sboieQAPqwuQpOmFF17gu+++Iyoqit27dxMYGIjNZuPTTz+1rKbdu3eTKVMmZsyYQUBAANu2baNLly64u7vzxhtvWFaXiIj8JTraNHu+cAEKF4YpU8Bms7oqeQCNAMoDeXl5kSVLFgICAmjUqBE1a9Zk/fr1ANjtdoYNG0aePHnw8fGhRIkSLFiwIMFr6tixI6NHj6ZKlSrkzZuXNm3a0KFDBxYtWpTg31tERB5C//6weTOkTg2LFpn/SpKkEcBE5HA4CIsKS/Tv65vCF9tj/AvswIEDbNu2jVy5cgEwbNgwZsyYwfjx48mfPz9btmyhTZs2ZMyYkSpVqjypsh9KUFAQ6dKlS9TvKSIiDzB3bvxmz4UKWVqO/DsFwEQUFhVGqmGpEv37hrwTQkrPlI/0OStWrCBVqlRER0cTERGBm5sb33zzDREREQwdOpQffviB8uXLA5A3b15+/vlnJkyYkKgBcNu2bcydO5eVK1cm2vcUEZEHOHgQOnUyj/v3h5dftrYe+b8UAOWBqlWrxrhx4wgNDeXLL7/Ew8ODJk2acPDgQcLCwqhVq1a86yMjIylVqtQT+/5169blp59+AiBXrlwcPHgw3vMHDhygYcOGDB48mNq1az+x7ysiIo8oKAgaN4bQUKhRAz7+2OqK5CEoACYi3xS+hLwTYsn3fVQpU6YkX758AEyZMoUSJUowefJkihUrBsDKlSvJnj17vM/x8vL6v1/Xz88PMFO3adKkiffcrVu38Pf3B2DSpEncuXMHgBR/axx66NAhatSoQZcuXXjvvfce+bWJiMgTEhFhwt/x4xAQALNng4eiRXKgP6VEZLPZHnkqNilwc3Nj4MCB9O7dm2PHjuHl5cXZs2f/03Rv/vz5cXNzY/fu3XfvKQQ4efIkQUFBFChQAOC+cBnr4MGDVK9encDAQD755JP/9oJEROTx2e1mj9+NG81ij2XLIGNGq6uSh+TSAfCDDz5gyJAh8c4VLFiQI0eOWFRR0tWsWTP69u3LhAkT6NOnD7169cJut1OxYkWCgoLYunUrfn5+BAYG3v2co0eP3vd1ihYtSufOnXn77bfx8PDg6aef5ty5c/Tv35/nnnuOChUq/GMNBw4coHr16tSpU4fevXtz6dIlANzd3cmov3RERBJXv35mezcPD7Pit2RJqyuSR+DSARBMIPnhhx/uHnto6PqBPDw8eOONNxgxYgSnTp0iY8aMDBs2jJMnT5ImTRqeeeYZBg4cGO9zWrZsed/XOXfuHKNHj2b48OH079+fM2fOkCVLFmrVqsUnn3zyr6uVFyxYwNWrV5kxYwYzZsy4ez5XrlycPn36ib1WERH5P778Er74wjz+7juoWdPaeuSR2RwOh8PqIqzywQcfsGTJkgfuWPEwgoOD8ff3Jygo6O69bbHCw8M5deoUefLkwdvb+wlUK49Dfx4iIk/I3LkQ+w/8Tz81I4HJzL/9/nYVLt8I+vjx42TLlo28efPSunVrzp49+4/XRkREEBwcHO9DRETEZWzcCO3amcdvvgl9+1pbj/xnLh0Ay5Urx9SpU1mzZg3jxo3j1KlTVKpUidu3bz/w+mHDhuHv73/3IyAgIJErFhERscj+/dCoEURGmj1+R47UNm/JmEtPAf/drVu3yJUrFyNHjqRTbEPLe0RERBAREXH3ODg4mICAAE0BJwP68xAReQxnz0L58maP30qVYN06SMZ/l2oKWItA4kmTJg0FChTgxIkTD3zey8vroXrdiYiIOI3ISGjQwIS/IkVg6dJkHf7EcOkp4L8LCQnhjz/+IGvWrFaXIiIikjSMHAn79pkef2vWQNq0VlckT4BLB8A+ffqwefNmTp8+zbZt22jcuDHu7u60atXK6tJERESsd/o0fPihefzFF2a3D3EKLj0FfP78eVq1asX169fJmDEjFStWZMeOHWoqLCIiAmal7507UKUKtGljdTXyBLl0AJwzZ47VJYiIiCRNy5bB8uVmp4+xY7Xi18m49BSwiIiIPEBoKPToYR6//bZZ/CFORQFQHknVqlV56623nsjXOn36NDab7T/vxCIiIgnko49M65dcuWDQIKurkQSgACj3ad++PTab7b6Pf2qPk9gWLVpErVq1yJgxI35+fpQvX561a9daXZaIiHM4dChun9+vvoKUKa2tRxKEAqA80AsvvMDFixfjfeTJk8fqsgDYsmULtWrVYtWqVezevZtq1arRoEEDfvvtN6tLExFJ3hwOeP11iI42vf9eesnqiiSBKADKA3l5eZElS5Z4H+7u7vddN336dMqUKUPq1KnJkiULr7zyCleuXLn7/M2bN2ndujUZM2bEx8eH/Pnz891338X7GidPnqRatWr4+vpSokQJtm/f/q+1jRo1in79+lG2bFny58/P0KFDyZ8/P8uXL38yL15ExFVNnw6bN4OPjxn9E6fl0quAE5vDAWFhif99fX0TbvFWVFQUH330EQULFuTKlSv07t2b9u3bs2rVKgAGDRrEoUOHWL16NRkyZODEiRPcuXMn3td49913+fzzz8mfPz/vvvsurVq14sSJE3h4PNyPp91u5/bt26RLl+6Jvz4REZdx8yb06WMev/8+5M5taTmSsBQAE1FYGKRKlfjfNyTk0W/hWLFiBanuKbZu3brMnz//vus6dux493HevHn56quvKFu2LCEhIaRKlYqzZ89SqlQpypQpA0DuB/yF0qdPH+rXrw/AkCFDKFq0KCdOnKBQoUIPVevnn39OSEgIzZs3f5SXKCIi9xo4EK5ehcKFoXdvq6uRBKYpYHmgatWqsXfv3rsfX/3DVMDu3btp0KABOXPmJHXq1FSpUgWAs2fPAtCtWzfmzJlDyZIl6devH9u2bbvvaxQvXvzu49ht+GKnkVOlSnX3o2vXrvd97qxZsxgyZAjz5s0jU6ZMj/eiRURc1a+/woQJ5vHYseDpaW09kuA0ApiIfH3NaJwV3/dRpUyZknz58v3rNaGhodSpU4c6deowc+ZMMmbMyNmzZ6lTpw6RkZGAGTk8c+YMq1atYv369dSoUYPu3bvz+eef3/06KVKkuPvY9tdctd1uB4jXIsbPzy/e958zZw6dO3dm/vz51KxZ89FfpIiIwLlz0KKFuU+pbVuoWtXqiiQRKAAmIpvNuVbTHzlyhOvXrzN8+HAC/tofcteuXfddlzFjRgIDAwkMDKRSpUr07ds3XgD8N/8UQmfPnk3Hjh2ZM2fO3eljERF5RBcvQo0aZs/ffPni2r+I01MAlP8sZ86ceHp68vXXX9O1a1cOHDjARx99FO+a999/n9KlS1O0aFEiIiJYsWIFhQsXfqzvO2vWLAIDAxk9ejTlypXj0qVLAPj4+ODv7/9YX1tExGVcuWLC3/HjpuHzhg2QMaPVVUki0T2A8p9lzJiRqVOnMn/+fIoUKcLw4cPvG9nz9PTknXfeoXjx4lSuXBl3d/fH3oN54sSJREdH0717d7JmzXr3o2fPno/1dUVEXMaNG1CrFhw+DNmzw48/Qs6cVlclicjmcDgcVheRXAUHB+Pv709QUNB996eFh4dz6tQp8uTJg7e3t0UVSiz9eYiI/CUoCGrWhF27IHNm2LIFChSwuqpE9W+/v12FRgBFRERcxe3bULeuCX8ZMphpXxcLf2IoAIqIiLiCsDCzvdv27ZA2LfzwAxQtanVVYhEFQBEREWcXHg6NG5tt3vz8YO1aKFHC6qrEQgqAIiIizsxuhzZtYN0604ts9WooW9bqqsRiCoAiIiLO7L33YOFCs7vH8uVQoYLVFUkSoACYwLTIOmnQn4OIuKRp02DYMPN48mSoVs3aeiTJUABMILHbm4WFhVlciUDcn8O9286JiDi1n3+Gzp3N44EDzTSwyF+0E0gCcXd3J02aNFy5cgUAX1/fu/vcSuJxOByEhYVx5coV0qRJg7u7u9UliYgkvJMnzaKPqCho0gT+tkuTiAJgAsqSJQvA3RAo1kmTJs3dPw8REacWFGTavVy7BqVLm2lgN034SXwKgAnIZrORNWtWMmXKRFRUlNXluKwUKVJo5E9EXEN0NLRoAYcOQbZssHQp+PpaXZUkQQqAicDd3V0BREREEl7v3qbHn48PLFtm9vkVeQCNCYuIiDiDsWPh66/N4xkzzPSvyD9QABQREUnu1q+HN980j4cOhZdftrYeSfIUAEVERJKzU6fMfX8xMdCuHQwYYHVFkgwoAIqIiCRX4eHQtCncvAnPPgsTJ4JajslDUAAUERFJrnr2hD17IH16mD8fvLysrkiSCQVAERGR5Oj77+NG/GbOhJw5ra5IkhEFQBERkeRm3z7o2tU8HjwY6tSxth5JdhQARUREkpOgILO9W3g4vPACDBpkdUWSDCkAioiIJBcOB7RvDydOmCnfGTOcdps3hwNWr7a6CuflnD81IiIizuiLL2DJEvD0hAULzOIPJ+RwmLaG9erBhx9aXY1zUgAUERFJDrZsievxN2oUlC1raTkJxeGAPn3gm2/M+pbcua2uyDkpAIqIiCR1Fy/GNXtu0yZuAYiTcThg4EAYOdIcT5xoelvLk6cAKCIikpSFhUHLlnDpEhQtCuPHO22z5yFDYPhw83jsWOjc2dp6nJkCoIiISFJ18iRUqGCmf1OnhoULIWVKq6tKEEOHmgAIZoa7WzdLy3F6CoAiIiJJ0Zo1UKYM/P47ZMwIK1ZAwYJWV5UgPv8c3n3XPB4xwmxwIglLAVBERCQpsdvh44/NEtjYPX737IHKla2uLEF89RX07Wsef/RR3GNJWB5WFyAiIiJ/CQqCtm1h+XJz/NprMHq00+7xO2FC3GjfoEHw3nvW1uNKFABFRESSggMH4OWX4fhxE/jGjoWOHa2uKsHMmBF3n1+/fnH3/0ni0BSwiIiI1ebNg+eeM+EvZ074+WenDn9LlpgNTRwOeOMNs/L37wubr4Vdo9uKboRGhlpRotPTCKCIiIhV7Haz+iG290mNGjBnDmTIYG1dCWj9+riWhoGBZob77+HvauhVak6vyb7L+7gRfoO5TedaU6wT0wigiIiIFaKiTAKKDX/9+5uVv04c/n7+GRo2hMhIaNIEJk26fyvjK6FXqD6tOvsu7yNLqiwMqaq54YSgEUAREZHEFhICTZvC2rXg7g6TJ5sw6MR274b69eHOHXjhBZg1Czz+lkKuhF6h+vfVOXj1IFlTZWVj4EYKZnDO1jdWUwAUERFJTFeumCS0axf4+sKCBVC3rtVVJahDh6BOHQgONt1sFi4ET8/411wOuUz1adU5dPUQ2VJnY2PgRgqkL2BNwS5AAVBERCSxnDxpktCJE5A+PaxcCeXKWV1Vgjp5EmrWhOvXoWxZ0+HG1zf+NRdvX6T6tOocuXaE7KmzszFwI/nT57emYBehewBFREQSw2+/mW3dTpyA3Llh61anD3+//QZVqsDFi1CsGKxeDX5+8a+5ePsi1b6vxpFrRwjwC2Bz+80Kf4lAAVBERCSh/fijSUKXL0OJErBtm9Nu6xZr4UKoWBHOnzcvdd06M+h5rwu3L1D1+6ocvX6UnP452dR+E0+le8qSel2NAqCIiEhCmjvXrHq4fRuqVoXNmyFrVqurSjAOh9nSrWlTCAuD2rVh+/b7X/Kt8FvUnl6bY9ePkcs/F5sCN5E3bV5rinZBCoAiIiIJZdIkaNnStHxp1sy0efH3t7qqBHPnDrzyCrz/vjl+801zm2PatPGvi4iOoPHcxhy8epBsqbOxqf0m8qTNk/gFuzAtAhEREUkIS5eavXwBunc3HY/d3a2tKQFduGB6/O3aZdq7jBkDXbrcf53dYafD0g5sOr2J1J6pWfXKKnKnyZ3o9bo6BUAREZEnbetWM/Jnt0PnzvD11/dvd+FEdu0y4e/CBUiXztz/V7Xqg68duGEgsw/MxsPNg4XNF1IiS4lErVUMBUAREZEn6dAhaNAAwsPNf8eNc+rw9+OPpq1heDgULmzavDz1D+s4xu4cy6dbPwVgUoNJ1HqqViJWKvfSPYAiIiJPyp9/mgUfN2/Cc8+ZfX3/vt2FE9m3Dxo3NuGvTh2z2OOfwt+yo8vosboHAB9V+4jAks6980lS57w/lSIiIonp1i0T/s6dM31PVqy4v+OxEzl3DurVi9vdY8kS8PZ+8LW/nP+FlgtaYnfY6VyqM+9WejdRa5X7aQRQRETkcYWHm5vgDhww/U7Wrr2/6Z0TuXXL7F73559QpMi/h78TN07QYHYD7kTfoW6+uox7cRw2J54STy4UAEVERB5HTAy0bQtbtphtLlavhly5rK4qwUREmGnfgwdN1l29+v42L7GWHFlC5e8qczXsKs9kfYZ5zebh4abJx6RAfwoiIiL/lcMBPXvCggXg6WmGwko476pWux3at4dNmyB1ahP+cua8/7o/g/+kx+oeLD6yGIBCGQqx8pWVpPJMlaj1yj/TCKCIiMh/NXy4aXhns8H06VCtmtUVJagBA+LWtSxadH/WtTvsjN05lsJjCrP4yGI83DwYWHEge7rsIUuqLNYULQ+kEUAREZH/YvJkGDjQPB41Cpo3t7SchPb11/DZZ+bxlClQs2b85w9eOUiXFV3Ydm4bAOWyl+PbBt/ydOanE7lSeRgKgCIiIo9q4sS4XT769TN7njmxRYvMTDfA0KHmlsdY0fZoPtz8IcN/Hk6UPYrUnqkZVmMYXct0xd3NeXc+Se4UAEVERB7FN99AD9PPjp49zTSwE1u+HFq1Mrc7du1qpoHv1Xttb77+9WsAXir4EmPqjSGHXw4LKpVHoQAoIiLysL78Enr3No/79IERI5x6l4/Fi6FFC4iKgmbN7t/R7vu9398Nf983+p62xduqxUsyoUUgIiIiD+PTT+PC38CBTh/+FiwwtzVGRZltjWfNir+pye4Lu3lthZkGH1xlMO1KtFP4S0YUAEVERP6fjz+Om/v84ANz7MRhZ84cE/qio6FNG7PA+d7wdzX0Ko3nNiYiJoIGBRrwfpX3rStW/hMFQBERkX/icMD778OgQeb4449h8GCnDn8zZkDr1qa/dfv2MHVq/PAXbY+m+YLmnAs+R4H0BZjeeDpuNsWJ5EZ/Yn8ZPnw4NpuNt956y+pSREQkKXA4zFTvRx+Z4xEj4F3n3sN26lRo1840fO7c2XS6cf/bQt5+6/ux6fQmUnmmYkmLJfh7+1tSqzweLQIBdu7cyYQJEyhevLjVpYiISFLgcJhFHiNHmuMvvwQnHyCYNAm6dDEvvVs3s9jZ7W/DRDP3zeTLHV8CMK3RNApnLGxBpfIkuPwIYEhICK1bt+bbb78l7T9tZigiIq7DbjftXWLD3zffOH34GzMGXn3VhL8ePczx38Pfbxd/49XlrwLwXqX3aFy4sQWVypPi8gGwe/fu1K9fn5p/b2kuIiKuJzoaOnY0/U4AJkyA7t2trSkBORwwZAi88YY57tULRo++/xbHa2HXaDy3MXei71Avfz0+qPpBotcqT5ZLTwHPmTOHPXv2sHPnzoe6PiIigoiIiLvHwcHBCVWaiIgktvBw0/F4yRJz49uUKeaGOCdlt5sNTMaMMceDBz94fUt4dDjN5zfnTNAZ8qXLx8yXZ2qHDyfgsgHw3Llz9OzZk/Xr1+Pt7f1QnzNs2DCGDBmSwJWJiEiiCwmBRo1gwwbw9IR586BhQ6urSjCRkSbbzp1rAt9XX8WNAt4rPDqcRnMasfH0RlKmSMniFotJ450m0euVJ8/mcDgcVhdhhSVLltC4cWPc71neFBMTg81mw83NjYiIiHjPwYNHAAMCAggKCsLPzy/RahcRkSfoxg2oVw9++QVSpoRly6B6daurSjAhIdCkCaxbBylSwLRppuff34VHh9N4bmPWnFiDbwpfVrdeTeVclRO/4AQQHByMv7+/S//+dtkRwBo1arB///545zp06EChQoXo37//feEPwMvLCy8vr8QqUUREEtrFi1C7Nhw4AOnSwerV8OyzVleVYK5dg/r14ddfTdZdtMi8/L+LiI6gybwmd8PfqldWOU34E8NlA2Dq1KkpVqxYvHMpU6Ykffr0950XEREndOoU1KwJJ09C1qywfj0ULWp1VQnm3DkT9o4cMVl31SooV+7+62LD36rjq/Dx8GFFqxVUyV0l8QuWBOWyAVBERFzYwYNQq5YZAcyb14S/vHmtrirBHDliwt+5c5Ajh5n+LfyAFn4R0RE0nd+UlcdX4u3hzYpXVlAtT7XEL1gSnALgPTZt2mR1CSIiktB27oQXXjD3/hUrZtJQ1qxWV5Vgduww0743bkChQrB2LeTMef91kTGRNJvfjBXHVuDt4c3yVsupnsd574V0dS7fB1BERFzIjz+aBR43bpj5z82bnTr8rVwZ93KffRZ++umfw1/z+c1Zfmw53h7eLGu5jJp51R/XmSkAioiIa5gzx4z8hYRAjRrwww/mZjgn9d13ppPNnTtQt67Jvhky3H9dSGQIjec2ZunRpXi5e7G05VJqPVUr8QuWRKUAKCIizm/UKNPkOSoKmjWDFSsgVSqrq0oQDgcMG2Y2NImJgcBAWLrUrPr9uz+D/6TSd5VYdXwV3h7eLGm5hNpPPWBZsDgdBUAREXFedjv07Wv2OAOz0e2cOfCQGwAkN3a72bZ44EBz3L+/GQlMkeL+a3+/9DvlJpVj76W9ZEqZiU2Bm3gh3wuJWq9YR4tARETEOUVGmmGwmTPN8fDh0K/f/XudOYmICLO7x7x55vjLL00YfJBVx1fRYkELQiJDKJyhMCtfWUmetHkSrVaxngKgiIg4n9u3zXYX69eDhwdMnuzU+/oGB0PjxuY+v3/b3QNg7M6x9FjdA7vDTvU81VnYfKG2d3NBCoAiIuJcLl82W7vt2WNufFuwwCz+cFJhYVCnjmn3kioVLF5s+lv/XYw9hn7r+zFyx0gAOpTswPgXx+Pp7pnIFUtSoAAoIiLO4/hxE/ZOnoSMGU0flLJlra4qwdjtZmBzxw6zoHndOihd+v7rQiNDab2oNUuPLgXgk+qf8E7Fd7A56XS4/H8KgCIi4hx27jQdj69ehTx5TMfj/PmtripBvfMOLFwInp6wZMmDw9+fwX/ScE5Ddl/cjZe7F1MbTaVlsX+YHxaXoVXAIiKSvNntMGECVKtmwt8zz8D27U4f/r79FkaMMI+nTIFKle6/ZteFXZT9tiy7L+4mg28GNrTboPAngEYARUQkOTt4EF57DbZuNce1apkhsdSpra0rga1fD926mccffACtW99/zbyD8whcEkh4dDhFMxZleavlWukrd2kEUEREkp/wcBg0CEqVMuEvZUrT7Hn1aqcPfwcOQNOmpslzmzbw/vvxn3c4HAzZNIQWC1oQHh1Ovfz12NZpm8KfxKMRQBERSV42bjSjfsePm+OXXoJvvoGAAGvrSgSXLsGLL5q2L5Urw6RJ8dsa3om6Q4elHZh7cC4AvZ/rzYhaI3B3c7eoYkmqFABFRCR5uH4d+vSBqVPNcdasJvg1buy0zZ3vFRZmsu6ZM+b2xkWLwMsr7vkLty/QaE4jdl7YiYebB+Prj6fTM52sK1iSNAVAERFJ2hwOmDEDeveGa9dM2OvWDYYOBX9/q6tLFHY7tG1rFjqnS2e626RPH/f8not7eGn2S/x5+0/S+6RnYfOFVMldxbqCJclTABQRkaTrzz+hfXv44QdzXKwYTJwI5ctbWlZicjjMnr6LFsW1e7l3gfOMfTN4dfmrhEeHUzhDYZa3Ws5T6Z6yrF5JHhQARUQkabp+3WxpceQIeHub1Q59+pi9zlzEiRNmsDM2/97b7iUqJoq+6/sy+pfRANTLX49ZL8/C39s1RkXl8SgAiohI0hMWBg0amPCXPbtZ+OHkff3uFRkJn30GH30EERHmXr/PP49r93Il9ArN5zdn85nNAAyqPIgPqn6Am03NPeThKACKiEjSEh0NrVqZZs5p0rjEjh73+ukns8j58GFzXLMmjBsH+fKZ451/7uTleS9zPvg8qT1TM63xNBoVamRZvZI8KQCKiEjS4XBA9+6wbJkZ9lq2DIoWtbqqRHHjhrnXb9Ikc5wpE3z5pcnCsYucp+6dStcVXYmIiaBg+oIsbrGYwhkLW1e0JFsKgCIiknR8+KFZ5OHmBrNnP3h/MyfjcMDMmWaR89Wr5tyrr8Lw4WbFL0BkTCS91vRi7K6xALxU8CWmNZqm+/3kP1MAFBGRpGHiRLOvGcT193NyERFmN48FC8xxkSJmW+OKFeOuuRJ6hSbzmvDz2Z8BGFJ1CO9Vfk/3+8ljUQAUERHrLVsWt7nte+/FPXZiYWHQpAmsWWPauwwebBY5e3rGXXPo6iHqz6rP6Vun8fPyY+bLM3mxwIvWFS1OQwFQRESstW0btGhhuh137GimgZ3c7dtmV49Nm8DXF5YuNYs97rX+j/U0nd+U4Ihg8qbNy8pXVlIoQyFL6hXnowAoIiLWOXzYbG4bHm7+O2GC02/rdusW1K0LO3ZA6tSwalX8KV+ACbsm0H1Vd2IcMVTMWZHFLRaTwTeDJfWKc9INBCIiYo0//4QXXoCbN6FcOZgzBzyce1zi6lWoVs2Ev3Tp4Mcf44e/GHsMb699m64ruxLjiKFt8bb80PYHhT954pz7/zQREUmaYofBzp6FAgVgxQpImdLqqhLUhQtQqxYcOmRavPzwAzz9dNzzIZEhtF7UmmVHlwHwUbWPeLfSu9icfERUrKEAKCIiievqVbPCd/9+yJLFNHrO4NwjXGfOQI0a8McfZmOTDRugYMG4588Hn6fB7AbsvbQXL3cvvm/0PS2KtbCuYHF6CoAiIpJ4duyAZs3g/Hnw84PVqyF3bqurSlDHj5vwd+4c5Mljwl+ePHHP/3bxN16c/SIXbl8go29GlrZcSvmA8tYVLC5B9wCKiEjCczjg66+hcmUT/goWNKt/S5a0urIEtX+/ecnnzpmX/NNP8cPftnPbqPp9VS7cvkCRjEX4pfMvCn+SKBQARUQkYYWEwCuvwJtvQlQUNG0KO3c6/RZvy5ZBhQpw6RIULw6bN5vp31gbT22k9vTaBEcEUyVXFbZ13EaetHn++QuKPEEKgCIiknAOH4Znn41b4fvllzBvnul/4qQcDhg2DBo1Mtm3WjXYuBEyZ467Zs2JNdSbVY/QqFBqP1WbVa1XaVs3SVS6B1BERBLG3LnQqROEhkLWrCb4/b3hnZO5c8e85NmzzfHrr8OoUZAiRdw1S44sofn85kTZo2hQoAHzm83Hy8PLknrFdWkEUEREnqzISOjZE1q2NOGvWjX47TenD39//mnu95s92wx2jhsHY8bED39zD8yl6bymRNmjaFakGQuaL1D4E0toBFBERJ6c8+eheXPYvt0cDxgAH33k9A2ef/3VTPlevAjp08OCBVC1avxrvt/7PR2XdcTusNO2eFumNJyCh5tzvy+SdOknT0REnowffzSjflevgr8/TJtmNrx1cjNnmmnfiAizrmXZMsibN/4143eNp9vKbgB0eaYL414ch5tNk3BiHf30iYjI45s8GerUMeGvRAnYvdvpw19MjBngbNPGhL8GDUxnm7+Hv1E7Rt0Nf28++ybjXxyv8CeW00+giIj8d3Y7DBwInTtDdDS0amWmf596yurKElTsNsaffmqO33kHliwxva1jRcVE0W99P3qt7QXAgOcHMOqFUdraTZIETQGLiMh/Ex4O7dub1b4AgwbBkCHg5AFn4ULo0gVu3AAfH5g0ybQ5vNfpW6dptbAVO87vAGBI1SEMqjxI4U+SDAVAERF5dNeumVUPW7eaBR4TJ0KHDlZXlaBu3zaLm7/7zhyXLm3u/7t3T1+AxYcX03FZR26F38Lfy58pDafwcuGXE79gkX+hACgiIo/m+HGoVw9OnDCLPRYtgurVra4qQe3YYe71++MPM8A5YAB88AF4esZdEx4dTt91fflm5zcAlMtejjlN55A7TW5Lahb5NwqAIiLy8H76yYz83bgBuXPDypVQpIjVVSWY6Gj45BPTySYmBnLmhOnTTb+/ex27fowWC1qw99JeAPpW6Msn1T8hhXuK+7+oSBKgACgiIg9n1iwzzRsZCWXLwvLl8fc3czInT5pRv9iWhq+8Yho7p0kT/7qZ+2bSdWVXQiJDyOCbgWmNplE3f91Er1fkUWgVsIiI/DuHwwyDtW5twl/jxrBpk1OHv1mzTDeb7dvNyt6ZM83HveEvNDKUTks70WZxG0IiQ6iSqwp7X9ur8CfJgkYARUTkn0VFwWuvxa18ePtt0/vE3d3auhLQtGkQGGgeV6pkpnxz5Yp/zaWQS9SfVZ89F/dgw8b7Vd5nUOVBuLs57/sizkUBUEREHuzSJTPvuXEjuLnB11/D669bXVWCWrgwbjHzG2/AqFH3Z93DVw9Td2ZdzgSdIYNvBuY1nUe1PNUSvVaRx5Esp4C///57Vq5cefe4X79+pEmThgoVKnDmzBkLKxMRcRKrVkHx4ib8pUxp9jdz8vC3erXpY223Q8eOMHr0/eFvy5ktVJhSgTNBZ8iXLh/bO21X+JNkKVkGwKFDh+Lj4wPA9u3bGTNmDCNGjCBDhgz06tXL4upERJKxiAh46y2oX99s61a8OPz6qzl2Yps3w8svmxnv5s1NW0O3v/2GnL1/NrWm1+JW+C3K5yjP9k7byZcunzUFizymZDkFfO7cOfLlM//TLVmyhCZNmtClSxeef/55qlatam1xIiLJ1eHDZgjs99/N8Ztvmvv9vL2trSuB7dxp9vENDzc5d/r0+CN/DoeDEVtHMGDDAABeLvwyMxrPwCeFj0UVizy+ZDkCmCpVKq5fvw7AunXrqFWrFgDe3t7cuXPHytJERJIfhwO+/dZsbfH775AhA6xYYeZAnTz87d8PdeqYXT6qVYP58+M3d462R9N9Vfe74a/Xc72Y13Sewp8ke8lyBLBWrVp07tyZUqVKcezYMerVqwfAwYMHyfX3pVoiIvLPbt6EV181qx8AatY0y2CzZrW2rkRw/DjUqmXegnLlYOlSs7dvrNDIUFoubMmKYyuwYePLOl/S87me1hUs8gQlyxHAMWPGUL58ea5evcrChQtJnz49ALt37+aVv+/ILSIiD/bTT6bZ3cKFZj/fESNg7VqXCH9nz0KNGnD5snkLVq+G1Knjnr8UcokqU6uw4tgKvD28Wdh8ocKfOBWbw+FwWF3EfxEeHs6+ffu4cuUKdrs93nMvvfRSotQQHByMv78/QUFB+Pn5Jcr3FBF5bNHRZm+zjz82S17z5YPZs6FMGasrSxSXLpn+fidOQMGCsGULZMoU9/yWM1tovag154PPk8E3A8tbLee5HM9ZV7A8cfr9nUyngNesWUO7du24fv06f8+vNpuNmJgYiyoTEUnizp0zCz22bjXHgYGmv9+9w19O7OJFqF3bhL9cuWD9+rjwF22PZsimIQz9eSh2h50C6Quw8pWVWukrTilZTgH36NGDZs2aceHCBex2e7wPhT8RkX9w8CCUL2/CX+rUZm+zqVNdIvyFhMCQIZA/Pxw4YGa5N2yAgADz/Kmbp6j8XWU+/ulj7A47HUp2YHeX3Qp/4rSS5Qjg5cuX6d27N5mdeB9KEZEnascOqFfPrHgoUgSWL4e8ea2uKsFFR8PkyTB4sLnfD+DZZ+H77+Gpp8zx7P2z6bqyK8ERwfh5+THhxQm0LNbSuqJFEkGyHAFs2rQpmzZtsroMEZHkYc0as+Lh5k147jlz05uThz+Hw6zqffpp6NrVhL+nnoJ580wWLlQIbkfcpsPSDryy6BWCI4KpEFCB37v+rvAnLiFZLgIJCwujWbNmZMyYkaeffpoUKVLEe/7NN99MlDp0E6mIJHmzZ0O7dmYorE4ds+I3ZUqrq0pQv/wCffuaRc4A6dObEcDXXovr8bfrwi5aLWzFiRsncLO58V6l9xhUZRAebslyYkwekX5/J9Mp4NmzZ7Nu3Tq8vb3ZtGkTNpvt7nM2my3RAqCISJI2Zgz06GGGw1q2NPOe93Y5djJ//AHvvGOaOYPpYd2rF/TvD/7+5pzdYefzbZ/z7o/vEm2PJsAvgJkvz6RSrkrWFS5igWQZAN99912GDBnCgAEDcPv7Zo0iIq7O4TArHoYMMcfdu8NXX92/ua2TcDhg3DizhXFUFNhs0L49fPgh5MgRd92lkEu0XdyWH07+AECTwk34tsG3pPVJa0ndIlZKlgEwMjKSFi1aKPyJiPxdTIzZw3fsWHP8wQfw/vsmFTmhyEh44w2zkx2YFi+ffQbFi8e/bs2JNbRb3I6rYVfx8fBh9Auj6fxM53gzSCKuJFkmqMDAQObOnWt1GSIiSUtkJLRubcKfzWamgAcPdtrwd/kyVK9uwp/NZjYyWbMmfviLjImkz7o+1J1Zl6thVymeuTi7u+zm1dKvKvyJS0uWI4AxMTGMGDGCtWvXUrx48fsWgYwcOdKiykRELBISAk2awLp1kCIFTJ8OLVpYXVWC2bMHGjUyfa39/c1al7p1419z4sYJWi5oye6LuwHoXrY7n9f+HG8P78QvWCSJSZYBcP/+/ZQqVQqAAwcOxHtO/6ITEZdz/TrUr2+Wv/r6wuLFZi7USc2eDR07Qng4FCgAy5aZLd3uNWPfDLqt7EZIZAhpvdMypeEUGhVqZEm9IklRsgyAGzdutLoEEZGk4fRp0+D58GFIlw5WrYJy5ayuKkHExMB778Hw4ea4bl2YNQvSpIm75nbEbd5Y/QbTfp8GQOVclZnReAYB/gGJX7BIEpYs7wEUEXF5EREwbBgULWrCX44cpvGdk4a/oCBo2DAu/PXrZzYzuTf87b6wm9ITSzPt92m42dz4oMoH/NjuR4U/kQdIliOAIiIubd0609/v2DFz/PzzZigsZ05r60ogx46Z8HfkiOntN3kyvPJK3PN2h51RO0Yx4IcBRNmjyOGXg1kvz1JvP5F/oQAoIpJcnD0LvXub3TwAMmc2PU/atHHalb5r15q1LEFBZpBzyRIoXTru+Yu3L9J+aXvW/bEOgEaFGjH5pcmk80lnTcEiyYSmgEVEkrqICBg6FAoXNuHP3R169oSjR6FtW6cMfw6H6V1dr54JfxUqwM6d8cPfimMrKD6+OOv+WIePhw/j649nUfNFCn8iD8GlA+C4ceMoXrw4fn5++Pn5Ub58eVavXm11WSIicdauhaefhnffhbAwqFTJ9EAZNSpufzMnExUFXbuajGu3m109fvwRsmQxz9+JukOPVT1oMLsB18KuUSJzCXZ32c1rZV5TJwiRh+TSU8A5cuRg+PDh5M+fH4fDwffff0/Dhg357bffKFq0qNXliYgrO3PGbGS7eLE5zpIFPv/c3PzmxCHn+nVo2hQ2bYpr7vz223Ev+cCVA7Ra2IoDV0wLsF7P9WJYjWF4eXhZV7RIMmRzOBwOq4tIStKlS8dnn31Gp06d/u+1wcHB+Pv7ExQUhJ+fXyJUJyJOLyLCBL1PPoE7d8x075tvmi3dnPzvmcOHoUED+OMPSJXK9Pt78UXznMPhYMzOMfRZ14eImAgypczE942+54V8L1hbtCRL+v3t4iOA94qJiWH+/PmEhoZSvnx5q8sREVe0a5fZyi12dW/lymY7t2LFrK0rEaxZYxZ7BAdD7tymxUvsy74aepWOyzqy4tgKAOrmq8t3Db8jc6rM1hUsksy5fADcv38/5cuXJzw8nFSpUrF48WKKFCnywGsjIiKIiIi4exwcHJxYZYqIM7PbzWre996D6GjImtWMArZq5dTTvRC32KN3b/M2VKpk1rlkzGhG/RYcWsCba97kUsglPN09+azWZ/R4tofu9RN5TC4fAAsWLMjevXsJCgpiwYIFBAYGsnnz5geGwGHDhjFkyBALqhQRp/Xnn9CunVnlAOYGuIkTIW1aa+tKBFFR8MYb5uUCdOgA48eDpyf8+uev9Frbi23ntgFQJGMRZjeZTfHMxS2sWMR56B7Av6lZsyZPPfUUEyZMuO+5B40ABgQEuPQ9BCLyGBYvhs6d4cYNs4fv11+bFOQCo1t/X+zx2WdmFPBc8FkGbhjIzP0zAfDx8KHf8/3o93w/fFP4Wlu0OA3dA6gRwPvY7fZ4Ie9eXl5eeHlppZmIPKbQUJN2Yoe+Spc2O3kUKGBtXYlk0yaTc0+fhtSpzWKPyjVvM2jjp3yx/QvCo8MBCCwRyCfVPyG7X3ZL6xVxRi4dAN955x3q1q1Lzpw5uX37NrNmzWLTpk2sXbvW6tJExFn99ptp5XLkiBn66tsXPvrIzHs6udBQGDAAvvnGHOfJA0uWxvBr1Hfk//o9LodeBqBKrip8UfsLSmcr/S9fTUQeh0sHwCtXrtCuXTsuXryIv78/xYsXZ+3atdSqVcvq0kTE2djtpnnzgAHm5rds2WDaNKhRw+rKEsXmzdCxI5w8aY5few3qvb6RtlvfYt/lfQDkS5ePz2p9RsOCDbXIQySBuXQAnDx5stUliIgruHjRbGexzuxXS6NGMGkSpE9vZVWJIjQUBg40K30BAgJg1NjbzAgNpOFfTa7TeKdhcJXBvF72dTzdnX8kVCQpcOkAKCKS4FasMDe8XbsGPj7w5ZfQpYtLLPT46Sfz0v/4wxy/+ip06n+Y1isb8MfNP/Bw86B72e4MqjyI9L7OH4ZFkhIFQBGRhHDuHHz8cdxCjxIlzGqHwoWtrSsRhIWZrYtHjzZ9/nLkMAOeYTkXU3NeO0IiQ8jln4vFLRZTKmspq8sVcUluVhcgIuJUDh0y071588aFv1694JdfXCL8bd0KJUua2x0dDujUCfbtt7PV831envcyIZEhVMtdjV1ddin8iVhII4AiIk/Ctm0wfLjZwyxWtWrw/vtQtaplZSWWU6fg009N5nU4IHt2+PZbqFAtiDaL29zdxu2tcm/xWe3P8HDTrx8RK+n/QBGR/8rhgFWrTPD7+WdzzmaDxo2hf3949llr60sEBw+alz97NsTEmHMdOsDIkXA5+ijlJjXk6PWjeLl7MbHBRNqVaGdtwSICKACKiDy6qCiYO9cMeR04YM6lSGG2dOvbFwoWtLa+RPDLLzBsGCxdGneuVi1z71+VKrD86HLaLG5DcEQwOfxysLjFYspkK2NdwSISjwKgiMjDCg2FKVPg88/h7FlzLlUq6NYN3nrL9PZzYg4HbNhggl/s1sU2G7z8smlvWKYM2B12Ptr8Ce9veh+ASjkrMb/ZfDKnymxh5SLydwqAIiL/z+3bpn3LV1+ZTWwBMmWCnj1N+Eub1tr6Epjdbkb6hg6FXbvMOQ8PaNPGzHQXKmTO3Y64Tful7Vl0eBEA3ct2Z2SdkertJ5IEKQCKiPybo0fNPX2HD5vjvHnNNG9goOnr58QcDjPT/eGHcS/fx8f083v7bciZM+7aH0/9yGsrXuPEjRN4unsytt5YOj3TyZrCReT/UgAUEfkny5ZB27YQHGyWtX7+OTRtaoa/nFxoqBncnD7dHPv7wxtvmEHPjBnjrrsedp0+6/swde9UALKnzs6C5gt4LsdziV+0iDw05/9bTETkUdntZthryBBzXKkSzJ8PmV3jPrbDh6FZM7PC180N3nvPjPj5+cVd43A4mH1gNm+teYurYVexYeP1sq8ztMZQ/Lz8/vmLi0iSoAAoInKvoCBzc9sK07eOHj3giy/MKl8XMHu2meINDYUsWWDOHLOq916nbp6i28purP1jLQBFMxbl2wbfUj6gvAUVi8h/oQAoIhLr0CFo1AiOHwcvL5gwwdzr5wLCw6F3bxg3zhxXrw6zZsUf9Iy2RzN6x2je3/Q+YVFheLl7MajyIPo+31cLPUSSGQVAERGAhQvNFm4hIWZ1w6JFULq01VUlipMnzZTvnj3m+L334IMPwN097po9F/fw6vJX2XPRXFQ1d1UmvDiBAukLJH7BIvLYFABFxLXFxMCgQaa5HZjt2+bOjb/SwYktXWoGOYOCIH16mDEDXngh7vnQyFAGbxrMlzu+xO6wk9Y7LZ/X/pwOJTtgs9msK1xEHosCoIi4rhs34JVXYK25l4233zb7mrnAKt+oKBg40CxsBihf3uTegIC4azad3kTHpR05desUAC2LtWRUnVFq6iziBJz/bzkRkQfZt8/09zt50jS3mzwZWrWyuqpE8eef0KIFbN1qjnv1MrnX86/b+EIjQ3lnwzt8/evXAOT0z8m4+uOol7+eRRWLyJOmACgirmfOHOjUCcLCIE8eWLwYSpSwuqpEsWwZdO4MV6+ati5Tp5ocHGvr2a20X9qeEzdOANDlmS58XvtzUnultqZgEUkQCoAi4jqio+Gdd+LmPWvXNn1P0qWztq5EcPYsvPmmuecPoFQp09rwqafM8Z2oOwzaOIiR20fiwEEOvxxMfmkytZ+qbV3RIpJgFABFxDX8+qvZ2iJ2qeuAAfDxx/GXujqhqCizjfGQIWbA08MD+vSBwYPB29tc88v5X2i/tD1Hrh0BoH3J9nxZ50vSeKexrnARSVAKgCLi3G7eNKsdJkwwm9v6+8OkSWZLNyf3008m8x48aI4rVzZ9/ooUMccR0REM2TyET7d+it1hJ0uqLHzb4FteLPCidUWLSKJQABQR5+RwwLRp0LevueENoF07GDHC6bd0u3YN+vWD774zxxkymFnvdu0gtnPLnot7CFwSyIErBwBo/XRrvqr7Fel8nH86XEQUAEXEGR04AK+/bobAwAx5jR17/55mTsZuN6GvXz/T4QagSxfT4jD2NsfImEg+2fIJn/z0CTGOGDL6ZmTCixNoXLjxP39hEXE6CoAi4jxCQszNbl9+aRo8+/qaLS3eesvp9/Ldvx+6doVt28xx8eIwfrzp7wdmkcfk3ybz2bbPOBt0FoBmRZoxpt4YMqZ0jabXIhJHAVBEkj+Hw2zd9tZbcP68Ode4MYwaZbZ1c2J/z7ypUsGHH0KPHmbBR3BEMON2jmPkjpFcCb0CQJZUWRhVZxQtirWwuHoRsYoCoIgkbydOmLSzZo05zpMHvv4a6te3tq5EsHYtvPYanDljjps0MZk3Rw64Hnad0T+N5utfv+ZW+C0Acvnnov/z/elQqgPeHt6W1S0i1lMAFJHkKTwcPv3U3OAWEWG2sejf3/T58/GxuroEde0a9O4N06eb41y5zC2O9erBhdsXeHvtF0zYPYHQqFAACmUoxDsV36FVsVakcHfuqXAReTgKgCKS/KxdC927wx9/mOOaNWHMGChQwNq6EpjDYTYx6dnTLGy22czjjz6CK1En6bpiBN/t/Y7ImEgASmUpxcBKA2lcqDHubs7d71BEHo0CoIgkH/v3m1G+1avNcdasZs6zWbO4/iZO6tw509Nv5UpzXKyYaWeYscBJuq0fzOz9s4lxxADwfMDzvFvpXV7I9wI2J39fROS/cbO6ABGR/+v8eejY0ezXu3q1Wd3QqxccOQLNmzt1+LPbzfRu0aIm/Hl6mkUev+6MYYdjNE+Pe5oZ+2YQ44ihzlN12Nx+Mz93/Jm6+esq/InIP9IIoIgkXUFBpnHzl1/CnTvmXLNmMHQo5MtnbW2J4MgR6NwZtm41xxUqwLffglumI9Sc1Ylt50zPl6q5q/JZrc8ok62MhdWKSHKiEUARSXoiI81K3nz5TNi7cwcqVoTt22HePKcPf5GRZpviEiVM+EuVyrwdGzdHs/zGp5QcX5Jt57aR2jM14+uPZ0O7DQp/IvJINAIoIkmHwwELFpiVvLELPAoWNKt9X3rJqad6Y+3YYXbv2L/fHNetaxo6B3ntp8KUDuy+uBuAOk/VYWKDieT0d+4+hyKSMDQCKCJJw08/mW0rmjc34S9zZpN8DhyAhg2dOvxFRMCsWWaQs3x5E/4yZICZM2Hxski+OzmE0hNLs/vibtJ4p+G7ht+xuvVqhT8R+c80Aigi1jpyBAYMgKVLzXHKlNC3L7z9tpn7dGJnzsCECWY179Wr5pyHB7RuDZ9/Dmcid/PspI7su7wPgJcKvsS4+uPIljqbhVWLiDNQABQRa1y6ZPYw+/Zbs4eZu7tZ8fDBB5Ali9XVJRi7HdatMyt7V6wws94A2bObXT06d4a0GcP5cPOHjNg6ghhHDOl90vNNvW9oUbSFVvaKyBOhACgiicvhgNGj4b33INTsVEHDhmZHj8KFra0tAV2/Dt99B+PGwcmTcedr1oTXX4cGDczo3/Zz26kxoROHrx0GoEXRFnxV9ysypcxkUeUi4owUAEUk8Vy5Ah06wKpV5rhcOfjsM6hUydq6EojDATt3mtG+OXPMvX4A/v7mbeja1axxATgffJ6BGwYyfZ/Z3y1zysyMqz+OxoUbW1S9iDgzBUARSRw//ABt25qpX29vGDnSJCAnndI8cMBM6W7bFneuVCmzg13LluZWR4DQyFBGbB3BZ9s+40606XUYWCKQkXVGks4nnQWVi4grUAAUkYQVFQXvv29auTgcUKQIzJ1r9jJzQtHRpnf1kCGmn5+XF7RoYaZ5n302Lu/aHXam/z6dgT8O5MLtCwBUzFmRkbVHUjZ7WQtfgYi4AgVAEUk4p05Bq1bwyy/m+LXXzMifr6+1dSWQAwegfXvYbVr18eKLppNN9uzxr9t8ejO91/Vmz8U9AORJk4cRtUbQpHATLfIQkUShACgiCWPuXNPRODgY0qQxq32bNrW6qgQRFRU36hcVZV7uV19BmzbxZ7hP3DhBv/X9WHxkMQB+Xn68V+k9epTrgbeHtzXFi4hLUgAUkScrNBR69oTJk81xhQqmy3GuXNbWlUD27zejfnvMYB4NGpjeflmzxl1zK/wWH2/5mK9++YooexRuNje6PNOFIdWGaHWviFhCAVBEnpy9e80Kh6NHzdDXu+/C4MGmv4mTiYoytzV++KF5nDatGfVr3Tpu1C/aHs2EXRMYvGkw1+9cB8wWbl/U/oKimYpaWL2IuDrn+1tZRBKfwwHffAN9+piVD9mymX3Mqla1urIEsW+faeMSO+r30kvmXr/YUb+wqDCm/T6NkdtHcvzGcQAKZyjMF7W/oG7+uhZVLSISRwFQRB7P9evQsSMsW2aOGzSAKVPMZrZOJioKhg+Hjz6KG/X7+mt45RUz6nfx9kXG7BzDuF3juHHnBgDpfdLzYbUP6VK6Cx5u+itXRJIG/W0kIv/dpk1mpcOff4Knp9nA9o03nLK337595l6/334zxw0bmlG/LFlg76W9fLnjS2bvn02UPQowK3t7lutJx1IdSe2V2rrCRUQeQAFQRB5ddLRZ8vrJJ2b6t2BBs9VFyZJWV/bE3boFQ4fCqFFm1C9dOjPq16KlnTUnVjNy3Uh+PPXj3eufD3ie3uV707BgQ9zd3C2rW0Tk3ygAisjDczhgyRKzsGP/fnOuY0ez+iF2awsnERlptnD76CO4YWZzadQIvvgqjHWXp1F07CiOXj8KgLvNnaZFmtLruV6Uy1HOuqJFRB6SAqCI/H8Oh9m/9/3341Y++PvDuHGm0bMTcThgwQIYMABOnjTnihaFAR/c4HDakZSdHXd/n5+XH12e6UKPcj3I6Z/TwqpFRB6NAqCI/DOHw+zh+/77sGOHOZcypenz9/bbZj7UiWzdahYyx77ULFngvcERnMz1Ph13fRnv/r63nnuLDiU76P4+EUmWFABF5MG2bIFBg8x/AXx8zAKPvn0hY0Zra3vCjh0zI36LzQYdpExpXmahBivpt+V1zv56FtD9fSLiPBQARSS+7dvNiN8PP5hjLy/o2tUkpCxZrK3tCbt61axlmTDBrGtxc4POneHV3n/y8W/d+WD5UgByp8nNN3W/oX6B+hZXLCLyZCgAioixe7cZ8Vu92hynSGHS0MCBkCOHtbU9YXfumFW9w4bB7dvmXP368MmwaDaEfEXVhe8TGhWKh5sHfcr3YVCVQfim8LW0ZhGRJ0kBUMTV7dtnRvyWmtEu3N0hMNCEwdy5LS3tSbPbYcYMs0Pd+fPm3DPPmPaFPvl3ELiiK79f/h0w073jXxxPsUzFLKxYRCRhuFldgIhY5NAhaN4cSpQw4c/NDdq2hSNHYPJkpwp/0dFmZ7pixUy2PX8ecuY0YXDdlpvMC+1GhckV+P3y76TzScekBpPY0mGLwp+IOC2NAIq4mmPHTHO7mTPNKl+AFi1Mb7/Cha2t7QmLijIvc+hQOG625CVNGnjnHejRw8HiE7MpMq4XV0KvABBYIpDPan1GxpTOtchFROTvFABFXMX+/SYJzZtn5kLBdDYeMgSKF7e0tCctMhK+/97c43fqlDmXPj307g3du8OV6OO8tOB1fjhpFroUylCIcfXHUTV3VeuKFhFJRAqAIs5u506zZVvsPX4AL74IH3wApUtbVlZCCA83s9effgrnzplzmTKZ3n7duoGHdzif/vwpw34eRkRMBN4e3rxX6T36VOiDl4eXtcWLiCQiBUARZ/XTTyb4rV1rjm02aNrUrOp1sj17w8Jg4kQYMQIuXjTnsmaFfv2gSxfw9rEza/8s3v3xXc4GmZ5+tZ+qzdh6Y3kq3VMWVi4iYg0FQBFnErtzx8cfxzVwdneH1q3NjW+FCllb3xMWEmJ2o/v8c7hibuMjIAD694dOncDbG9b/sZ5+P/Rj76W9AGRPnZ0van9B86LNsdls1hUvImIhBUARZ+BwwPLlJvjt3GnOpUgBHTqYNJQ3r7X1PWHBwfDNNzByJFy/bs7lyWMybmAgeHrC3kt76be+H+tPrgfMvr3vVHyHN8u9qZ5+IuLyFABFkrOYGFi40Ez17ttnzvn4mHnPPn2croFzdLQZ8Rs8GG7eNOfy5zez2q1bm8x75tYZ3lv5HjP3zcSBgxRuKehetjvvVn6XDL4ZrH0BIiJJhAKgSHIUFQWzZpllrkePmnOpUpklrr16QebM1taXADZuhDffhAMHzHHhwvDee6aVoYcH3Lhzg6Ebh/L1r18TGRMJQKtirfi4+sfkTetcI6AiIo9LAVAkOYmIgO++M8tcT58259KmhZ49oUcPSJfO0vISwpkz0LcvzJ9vjtOnNwOenTub2xvDo8MZte0bPvnpE26F3wKgWu5qjKg1gjLZylhXuIhIEqYAKJIcxC5z/ewzuHDBnMuUyTS269YN/PysrS8B3LljXu7w4eaxmxu8/rppW5guHdgddqb/PpP3Nr53d2Xv05me5tOan/JCvhe0wENE5F8oAIokZcHBMHasWe1w9ao5lz276W/SuTP4Ot9iBocDFi822fbMGXOuShX46ivTr9rhcLD2xDr6/9D/7r69Ofxy8FG1j2hbvC3ubu4WVi8ikjwoAIokRdevm8Tz1Vdw65Y5lycPDBhglrl6OWfT4oMHzWz2hg3mOCDAtHhp1gzAwerja/hoy0dsP78dAH8v/7sre31S+FhWt4hIcqMAKJKUXLpkRvvGjTNN7sD07hs4EFq1MqsdnNCtW2Zjkm++MQubvbzMIGf//uDja2fp0WV8vOVjdl/cDYC3hzfdynTj3Urvkt43vaW1i4gkR8752+QhDRs2jEWLFnHkyBF8fHyoUKECn376KQULFrS6NHE1586ZG96+/dbsZwZQooRZ5tq4sVnt4IRiYsyalnfegWvXzLnGjeGLLyBnrhgWHl7Ix1s+Zv+V/QD4pvDl9TKv83aFt8mSKouFlYuIJG8uHQA3b95M9+7dKVu2LNHR0QwcOJDatWtz6NAhUqZMaXV54gr++MOs6J061bR2AShXzgS/+vXN9m1Oavt2s3B5txnUo3BhGD0aqtWIZvb+2QwdN5Qj144AkNozNT2e7UGv8r3Uy09E5AmwORwOh9VFJBVXr14lU6ZMbN68mcqVK//f64ODg/H39ycoKAg/J1yFKQno0CHTw2/WLLDbzbmqVU3wq17daYPf1auwaBHMnWv6+oFZwDxkCLzaNZLZh6Yx7OdhnLx5EoA03ml4q9xbvFnuTdL6pLWwchFxJvr97eIjgH8XFBQEQLp/6KUWERFBRETE3ePg4OBEqUucyN69pondwoVmuStA3brw7rvw/POWlpZQrl83q3rnzYMffzTTvrE6doT3Pwxn5YUpFBn/6d12Lhl8M/B2+bd5vezr+Hm55l/OIiIJSQHwL3a7nbfeeovnn3+eYsWKPfCaYcOGMWTIkESuTJzC9u0m+K1cGXeucWMT/EqXtq6uBHLzJixdakb6fvjBbOEWq3Rps3vHi43usPb6eMrP+YyLIRcByJIqC30r9OW10q+R0lO3YYiIJBRNAf+lW7durF69mp9//pkc/7B/6oNGAAMCAlx6CFn+RWQkrFgBY8aYoS8w3YxbtjSrHv7hHxrJVXCwCX3z5sHatXG3NIJZz9KihWnn4pv5At/u/pYxO8dwNcz0NgzwC6D/8/3p9EwnvD28LXoFIuIqNAWsEUAA3njjDVasWMGWLVv+MfwBeHl54eWk/dfkCdq/3yxtnT49bmmrh4fp3zdgAOTLZ219T9Dt27B8uQl9a9aYnepiFStmRvqaN4cCBRxsPL2RATvHsuTIEmIcZh44T5o8vFPxHQJLBuLp7mnRqxARcT0uHQAdDgc9evRg8eLFbNq0iTx58lhdkiRXt27B7NkwZQrs2hV3PmtWaNfObNeWK5dl5T1pGzaYDUpWrYrrWgOmZWGLFib0FSkCQeFBTPt9Go3Gjr27ohegUs5KdCvTjWZFm+Hh5tJ/DYmIWMKl/+bt3r07s2bNYunSpaROnZpLly4B4O/vj4+PdhWQ/8NuN0tZp0wxS1tjk1CKFPDSS9ChA9Sp41TNm/ftM82Z16yJO5cvnwl9LVqYUT+bDfZe2stry8cxY/8MwqLCAEjlmYq2xdvSrUw3ns78tEWvQEREwMXvAfynzeK/++472rdv/38/X/cQuKjTp+H77800b+xmtWDST6dO0Lo1ZMxoWXkJ4fx5GDTIvGyHw2Ta114zL7dkSRP6IqIjWHBoAWN3jWXbuW13P7doxqK8XvZ12hRvoxW9IpIk6Pe3i48AunD2lUd1547pZTJlStxGtQD+/vDKK6afSenSTte/LyjI9Kn+8su4Ac5mzWDo0LhbGU/fOs2EXROY9NskroWZex493DxoUrgJr5d9nUo5K/3jP7ZERMQaLh0ARf6Vw2G2qZgyxTRs/qtPJAA1a5rQ16gROOHtApGRMGECfPhh3DqWihXh88/NRiV2h53Vx9cydtdYVh5biQPzj6kcfjl4rfRrdH6ms7ZqExFJwhQARf7u6lWYMcNM8e7fH3c+Vy5zX19gIOTObVl5CcnhMD2q33kHTpww5woWNKOAL70E4dF3GL/re0ZuH8nxG8fvfl6tvLV4vezrvFjgRS3qEBFJBvQ3tUisI0dgxAgT/mKb2Hl5QZMmZrSvWjXTx89Jbd0KffrAjh3mOHNms0Vbp05wI+IKQzaPZczOMXenedN4p6FDyQ50LdOVAukLWFi5iIg8KgVAkV27zL68ixfHbc9WpowJfS1bQlrn3oP26FEz4rd4sTn29YW+feHtt+FCxFG6rx7JtH3TCI82NwHmTpObXs/1omOpjqTyTGVh5SIi8l8pAIprcjhMC5dhw8xeZbEaNjTNmp97zrraEsnly2aEb+JEsz+vmxt07gyDBzv4I+pn2qz8nGVHl929vmy2svSt0JfGhRtrmldEJJnT3+LiWux2s1/Z8OHw66/mnLu7Wcnbvz8ULWptfYkgOBhGjzaz3SEh5lyDBvDx0GiO2BbReNUX/PqneW9s2Hip4Eu8Xf5tKuasqNW8IiJOQgFQXENUlFnJ++mncPiwOeftbYa8+vRxql06HiQsDFauhDlzzH9jt2wrWxY+HBrGsdSTaLjhS07fOg2Al7sX7Uu2p9dzvSiYoaB1hYuISIJQABTnFhYGkyaZ/iXnzplz/v7QvTv07AmZMllbXwKKjIS1a03oW7oUQkPjnitSBHr0vcmZ7J/TavdYboXfAiCDbwa6l+3O62VfJ1NK531vRERcnQKgOKebN2HMGDPXGdvILnNm6NULunY1IdAJRUebWxvnzDG70926FfdcnjxmTUuJGodZfXsEb+6fSdQZs9o5f7r89C7fm3Yl2uGbwtea4kVEJNEoAIpzuXjRbFsxblzcDW558kC/ftC+vZn2dTJ2O2zbZkLf/Plw5Urcc1mzmj16G7wcygmfWXz720SG/bzr7vMVc1akT/k+NCjYADeb87a4ERGR+BQAxTn88YdZ1TB1qpn7BHj6abOit3lzs3mtE4ndpGTOHJg71+zVGyt9erNdW8uW4JN3N5P3TqThz7MIiTSBOIVbCl4u/DJvPfcWz+Vw/tXOIiJyP+f6rSiu5/ffzYreefPMUBhAhQqmsV39+k63N++BAyb0zZljMm8sPz94+WUT+so8H8yCI7PpvWciezbtuXtNgfQF6PJMF9qVaEfGlBktqF5ERJIKBUBJfoKDzX5l06bBpk1x5+vWNcGvUiXLSksIMTGwfLlZx7J1a9x5X1+zPVvLllC7toMDN3YxcfdEmnw1m9Aos+LD092TpkWa0uWZLlTOVVltXEREBFAAlOQiOto0bJ42DZYsgTt3zHk3NzPfOWAAlCxpZYVPXFgYfP+9uaXx+F/b7qZIAfXqmdDXoAFEuwcxa/8sKkybyN5Le+9+bqEMhejyTBfalmhLBt8M1rwAERFJshQAJWn7/XcT+mbNgkuX4s4XKgRt20KbNpAzp3X1JYArV8wC5jFj4Pp1cy5tWujWDd54A7JkcfDrn7/y5g8TmXNwDmFRYYDp3desaDO6PNNFTZtFRORfKQBK0nPhggl806bB/v1x5zNkgFatTPArU8bp7u87ehRGjjSjfrGNmvPkMZ1rOnSAaI9bzNw3k4lLJ7Lv8r67n1c4Q2FeK/0abUu0JZ1POouqFxGR5EQBUJKG0FAztTttmpnqjV3Q4elpbnRr2xZeeMEcOxGHA376Cb74ApbFbbtL2bLQty80bGTnp3MbeW3dFBYdXkR4dDgA3h7eNC/anC7PdKFCQAWN9omIyCNRABTr2O1mEce0aWZRR2zfPoDnn4d27cz9fWnTWlZiQomONo2aP/8cdu4052w2k3XffhtyPn2W73+fSr+x393dng2gWKZidHmmC22KtyGtj/O9LyIikjgUACXxHToE06fDjBnxG9jlzWtCX5s28NRT1tWXgEJCYMoUs7Dj9GlzztsbAgOhe49IDrOEj3+bzPof1+PAAYCflx+vFHuFTs90onTW0hrtExGRx6YAKInjyhXTvG7aNNPBOFaaNGarirZtTf8+Jw03Fy/C11+bDUpit2fLkMFsSVyl6UEWn5tA1ZUzuXHnxt3PqZa7Gh1LdeTlwi9rezYREXmiFAAl4URGwooV8N13sGaNmfcEsytHvXpmtK9+fafcng3MQo7Nm816llmzIMpsu0v+/NCtRyi2kjOYfngiQxbGNWvO4ZeD9iXa075ke55K55yjoCIiYj0FQHnyDh2CyZPNNO/Vq3Hny5Y1oa9FC8jonDtRXLsGq1aZxs1r1sS/rbFiRQe12uzjSPrPGHh0IeE/mgUdKdxS0KhQIzqW6kitvLVwd3O3qHoREXEVCoDyZAQHm01pJ0+GX36JO581q7nBLTDQ9O5zQkePmhW8y5bBtm1xC5gBsmSBqrVDSFVuLj9EfczgS6fhr3aGT2d6mk6lOtG6eGs1axYRkUSlACj/ncMBP/9sQt/8+WbrCjBTvC++CJ06mdYtHs71YxYdbbZkW77chL7YXTpiFS8O1evcxr3wan6xj2Hu+Z9wXNWCDhERSTqc6zezJI4LF8xijilT4qefQoVM6GvbFjJntq6+BBAUBGvXmsC3ahXcvBn3XIoUUK0aVKkdTEz+JWy4MYXRZ7bgOOu4e40WdIiISFKiACgPJyoKVq40o32rV0NMjDmfKpW5p69TJ3juOadaxXv6dNwo36ZNcWtYANKnN+tYKte+RXD2Baw4O4tBZzZj/y1u/ve5HM/RvEhzmhZpSoB/QKLXLyIi8k8UAOXfHT5sRvqmTTOtXGJVrAgdO5pGzalSWVffE3bkiGlPuGxZ/F3oAAoWNI2aK9W8xTm/eSw8NpfXTm7C/kdc6Hs2+7N3Q1+uNLkSuXoREZGHowAo97t9G+bNM6N927fHnc+c2Szm6NjRpCEnERpqbmGcNMnc2xfL3d3k3AYNoGLNG+yLXsi8Q/MYuWMjMY6Yu9eVzVaW5kVN6MudJnfivwAREZFHpAAohsNhlrBOnmzCX2ioOe/ubhZ0dOwIdeuaG96cgMNhtmCbPBlmzzaZF8zLrVfPzGqXq3KDTVcWMf/QfPov3RAv9JXOWprmRZvTrEgz8qTNY9GrEBER+W8UAF3dpUtxCzqOHo07X6CAua+vXTvTy8RJXL9upngnTYIDB+LOP/WUebmNWgSxPWgh0w/Oo/13G4i2x934VypLqbuhT02aRUQkOVMAdEWhobBkiUlC69bFNa5LmRKaNzdJyIm2ZbPb4ccfTehbvNhsUAJmA5KmTaFdh0hCsq5i5v4ZDJm1goiYiLufWzJLSZoXaU6zos3Ily6fRa9ARETkyVIAdBUxMSYFzZgBixbF36KifHkT+po3h9SpravxCTt3DqZONYObp0/HnS9VCjp1spOn0g6WnZ1Gi53zuBke19elaMaitCrWimZFm1EgfYFEr1tERCShKQA6u337zJZss2aZ/n2xnnoK2rQxH/mcZ2QrMtK0bpk0yfTtc/zVis/fH1q3huovn2IPk/hs/0zOLD5z9/Oypc7GK8VeoU3xNhTPXFwNmkVExKkpADqjP/80gW/69Pi9TNKlM6sb2rQxo35OFHIOHzYLOqZNi7/9cNWq0LT1TULyTWfese8Z+/Oeu8+l9kxNkyJNaPN0G6rmrqo9eEVExGUoADqL27fN1O706WaqN3boy9PTrOJt29Ysb/X0tLbOJyg4GBYuNKN927bFnc+aFV5pE0HmSqtYf2scb57agP1Pc5+jh5sHdfPVpU3xNjQo0ACfFD4WVS8iImIdBcDkLDoa1q83oW/JErhzJ+65ihVN6GvWDNKmtazEJ+3YMbMhyYoV8NNPZoMS+Kt9S307pert4WjaUYw9vog7e+Lej/I5ytOmeBuaF21OBt8MFlUvIiKSNCgAJjcOB/z2mwl9s2fD5ctxzxUoYEJf69aQxzl600VGwpYtJvStXBl/62GAQoUcVG98jjtFJrDi4rcsv3QVLpnn8qfLT5vibWj9dGu1bREREbmHAmBycfYszJxpgt/hw3HnM2SAli1N8Ctb1inu67t0yWw3vGKFGeCMbdIMpg915cp2ijx/msi8i9kQPJ6xN07AH+b5jL4ZaVWsFW2Kt6FMtjJazCEiIvIACoBJWVAQLFhgQt/mzXHnvbygYUMT+urUSfa7c9jtsGdP3NTurl3xn8+cGWrUCSdjiV/5M9NUNvy5hA3hN+G0ed7Hw4fGhRvT5uk21MxbkxTuyfv9EBERSWgKgEnRhg0wYQIsWwYRcU2JqVrVrOBt2tT0NUnGbt82o3srV8KqVWbU715lyjgoXeUybgVW8ZttMnMu7sB+2w5/jQam9U5LnXx1eDH/i7xU8CVSezlP/0IREZGEpgCYFK1ZA/Pnm8eFC8fd15czp7V1PaYTJ8wI38qVZkAzdgEHQKpUUK1GNDnL7uNm9llsujGbXbcvwMW4a4pnLk69fPWoX6A+z+V4Dg83/fiKiIj8F/oNmhS1b29W+LZta7atSKb3sdntpj3L4sUm+B07Fv/5p56CijVv4lPkR46lmszaCxuIjI6Ev/oz+6bwpUaeGtTPX596+esR4B+Q+C9CRETECdkcjtiGcfKogoOD8ff3JygoCD8/P6vLSRJiYkx7lgULTFvCi/eM4Hl4wPMV7RQsf5zwvAvZFjaVEzfjL+vNmzYv9fPXp37++lTJXQVvD+9EfgUiIuLs9PtbI4DyBERHw6ZNJvQtXgxXrsQ95+cHNeuGkbHUds5nmsLmS8vYHBkCf5rnPdw8qJyr8t1RvoLpC2rlroiISAJTAJT/JDLSbDiyYIHpQX39etxzadM6qFLnFqlLreVgqq9YdHU7hANnzfNZUmW5ey9fzbw18fNyzX99iYiIWEUBUB5aRIRZubtgASxdCrduxT2XIYODCrUu4/n0cn7zGcmSoCNwB7gDNmw8m/1Z6uWvR/389SmVtRRuNjerXoaIiIjLUwCUf3XnDqxda0Lf8uVm/91YmTM7KF3jLBRewK4UI1kWfgEigUjwdPekVt5aNCrUiAYFGpA5VWbLXoOIiIjEpwAo9wkNNTtxLFhgVu+GhsY9lzWrneLVjhNRYBY7PUaxKjoYYoAY8Pfyp36B+jQq2IgX8r2g3nwiIiJJlAKgAKYx86pVpv3gqlVm5C9WthzRFKp0kJB8U9njPpa1RJonoiFb6mw0KtiIRoUaUSV3FTzdPa15ASIiIvLQFABd2MWLsG6dWcSxZg2Eh8c9lyNXJHkr7OFangkcSjGVC/cszC2coTCNCjWicaHGlM5WWvfziYiIJDMKgC7kzh3To2/dOvOxf3/853PkvkOO53ZwMefXnPFZzPl7Ql/5HOVpVKgRDQs2pGCGgolbuIiIiDxRCoBOzOGAffviAt9PP8XfWthmc5CvaBB+RbdyJvtIzqf+8W7o83T3pEaeGncXcWRNndWaFyEiIiJPnAKgk7l0ybRqWbfO/Pfy5fjPZ80eTZ7SxwnPtYxDqb7huNf5u8+l9kx9dxFH3fx11Z9PRETESSkAJnOx07qxoW/fvvjP+/o6KPHcTVIW2sqZ9JM47raMi/dM7ebwy0H9/PVpXKgxVXNXxcvDK3FfgIiIiCQ6BcBkxuEw9+7FTutu2fL3aV0oXjKKnM8cJSRgEb95jGV7dNwwoJvNjfI5ypv9dgvU5+lMT2vrNRERERejAJgMxE7rxn5cuhT/+ezZHZSpdAOvAls4mfZb9gSv5XeH3TwZDel80vFCvheon78+dZ6qQ3rf9In/IkRERCTJUABMgu7cgZ9/jhvlu39aFypWjiag1GGCsi9gW/hklob8aZ4MMv8pnrm4GeXLX59yOcrh4aY/ahERETGUCpKgHj1g8uT45555BspWuolH/h854jOFTRd+IDImEq6Z531T+FIjTw3q569Pvfz1CPAPSPzCRUREJFlQAEyCatY0W7HVrBVDjpKHuZ51LhuvzmPC9WN3Ax9A3rR5747yVcldBW8Pb+uKFhERkWRDATAJ8i6+nHIjp7L45HpuB92+O63r4eZBpZyV7i7gKJi+oBZwiIiIyCNTAEyCdl/6lcVHFgGQOWVm6uavS/389amVtxb+3v4WVyciIiLJnQJgEtSsaDM83DyoX6A+z2R9RnvtioiIyBOlAJgEFc9cnOKZi1tdhoiIiDgpDS2JiIiIuBgFQBEREREXowAoIiIi4mIUAEVERERcjAKgiIiIiItx6QC4ZcsWGjRoQLZs2bDZbCxZssTqkkREREQSnEsHwNDQUEqUKMGYMWOsLkVEREQk0bh0H8C6detSt25dq8sQERERSVQuPQIoIiIi4opcegTwUUVERBAREXH3ODg42MJqRERERP4bjQA+gmHDhuHv73/3IyAgwOqSRERERB6ZAuAjeOeddwgKCrr7ce7cOatLEhEREXlkmgJ+BF5eXnh5eVldhoiIiMhjcekAGBISwokTJ+4enzp1ir1795IuXTpy5sz5fz/f4XAAuhdQREQkOYn9vR37e9wV2Rwu/Oo3bdpEtWrV7jsfGBjI1KlT/+/nnz9/XvcBioiIJFPnzp0jR44cVpdhCZcOgI/Lbrdz4cIFUqdOjc1ms7ocl1S2bFl27txpdRkuSe/9w3G198mZXm9yey1Jud6kUltwcDABAQGcPXsWm81GtmzZcHNzzeUQLj0F/Ljc3Nxc9l8OSYW7uzt+fn5Wl+GS9N4/HFd7n5zp9Sa315KU601qtfn7+yepeqzgmrFXnEb37t2tLsFl6b1/OK72PjnT601uryUp15uUa3NVmgIWERERlxAcHIy/vz9BQUEaAbS6ABEREZHE4OXlxeDBg9XSDY0AioiIiLgcjQCKiIiIuBgFQBEREREXowAoco/GjRuTNm1amjZtanUpLkfvvTyIfi5EEoYCoMg9evbsybRp06wuwyXpvZcH0c+FSMJQABS5R9WqVUmdOrXVZbgkvffyIPq5EEkYCoCS4MaNG0fx4sXx8/PDz8+P8uXLs3r16if6PbZs2UKDBg3Ili0bNpuNJUuWPPC6MWPGkDt3bry9vSlXrhy//vrrE60jKRs+fDg2m4233nrriX5dvffJ059//kmbNm1Inz49Pj4+PP300+zateuJfX39XEhycu7cOapWrUqRIkUoXrw48+fPt7qkBKcAKAkuR44cDB8+nN27d7Nr1y6qV69Ow4YNOXjw4AOv37p1K1FRUfedP3ToEJcvX37g54SGhlKiRAnGjBnzj3XMnTuX3r17M3jwYPbs2UOJEiWoU6cOV65c+W8vLBnZuXMnEyZMoHjx4v96nd5713Dz5k2ef/55UqRIwerVqzl06BBffPEFadOmfeD1+rkQZ+fh4cGoUaM4dOgQ69at46233iI0NNTqshKWQ8QCadOmdUyaNOm+8zExMY4SJUo4mjZt6oiOjr57/siRI47MmTM7Pv300//7tQHH4sWL7zv/7LPPOrp37x7ve2XLls0xbNiweNdt3LjR0aRJk0d4NUnb7du3Hfnz53esX7/eUaVKFUfPnj0feJ3ee9fRv39/R8WKFR/qWv1ciCsqXry44+zZs1aXkaA0AiiJKiYmhjlz5hAaGkr58uXve97NzY1Vq1bx22+/0a5dO+x2O3/88QfVq1enUaNG9OvX7z9938jISHbv3k3NmjXjfa+aNWuyffv2//x6koPu3btTv379eK/9QfTeu45ly5ZRpkwZmjVrRqZMmShVqhTffvvtA6/Vz4UkBw9zy8HD3m6we/duYmJiCAgISOCqraUAKIli//79pEqVCi8vL7p27crixYspUqTIA6/Nli0bP/74Iz///DOvvPIK1atXp2bNmowbN+4/f/9r164RExND5syZ453PnDkzly5duntcs2ZNmjVrxqpVq8iRI0ey/0U0Z84c9uzZw7Bhwx7qer33ruHkyZOMGzeO/Pnzs3btWrp168abb77J999//8Dr9XMhSd3/u+XgYW83uHHjBu3atWPixImJUbalPKwuQFxDwYIF2bt3L0FBQSxYsIDAwEA2b978jyEwZ86cTJ8+nSpVqpA3b14mT56MzWZL8Dp/+OGHBP8eieXcuXP07NmT9evX4+3t/dCfp/fe+dntdsqUKcPQoUMBKFWqFAcOHGD8+PEEBgY+8HP0cyFJWd26dalbt+4/Pj9y5EheffVVOnToAMD48eNZuXIlU6ZMYcCAAQBERETQqFEjBgwYQIUKFRKlbitpBFAShaenJ/ny5aN06dIMGzaMEiVKMHr06H+8/vLly3Tp0oUGDRoQFhZGr169Huv7Z8iQAXd39/tuWL98+TJZsmR5rK+dVO3evZsrV67wzDPP4OHhgYeHB5s3b+arr77Cw8ODmJiYB36e3nvnlzVr1vv+8VW4cGHOnj37j5+jnwtJrh7mdgOHw0H79u2pXr06bdu2tarURKUAKJaw2+1EREQ88Llr165Ro0YNChcuzKJFi9iwYQNz586lT58+//n7eXp6Urp0aTZs2BCvhg0bNjzwXkRnUKNGDfbv38/evXvvfpQpU4bWrVuzd+9e3N3d7/scvfeu4fnnn+fo0aPxzh07doxcuXI98Hr9XEhy9jC3G2zdupW5c+eyZMkSSpYsScmSJdm/f78V5SYaTQFLgnvnnXeoW7cuOXPm5Pbt28yaNYtNmzaxdu3a+6612+3UrVuXXLlyMXfuXDw8PChSpAjr16+nevXqZM+e/YEjDyEhIZw4ceLu8alTp9i7dy/p0qUjZ86cAPTu3ZvAwEDKlCnDs88+y6hRowgNDb07JeBsUqdOTbFixeKdS5kyJenTp7/vPOi9dyW9evWiQoUKDB06lObNm/Prr78yceLEB973pJ8LcQUVK1bEbrdbXUbisnoZsji/jh07OnLlyuXw9PR0ZMyY0VGjRg3HunXr/vH6devWOe7cuXPf+T179jjOnTv3wM/ZuHGjA7jvIzAwMN51X3/9tSNnzpwOT09Px7PPPuvYsWPHY7225Obf2sA4HHrvXcny5csdxYoVc3h5eTkKFSrkmDhx4j9eq58LSU74W9uhiIgIh7u7+32tiNq1a+d46aWXEre4JMTmcDgciR87RURERJ48m83G4sWLadSo0d1z5cqV49lnn+Xrr78GzMh2zpw5eeONN+4uAnE1mgIWERGRZO3/3XKg2w3upxFAERERSdY2bdpEtWrV7jsfGBjI1KlTAfjmm2/47LPPuHTpEiVLluSrr76iXLlyiVxp0qEAKCIiIuJi1AZGRERExMUoAIqIiIi4GAVAERERERejACgiIiLiYhQARURERFyMAqCIiIiIi1EAFBEREXExCoAiIiIiLkYBUERERMTFKACKiPylffv28TaQj7Vp0yZsNhu3bt1K9JpERBKCAqCIiIiIi1EAFBEREXExCoAiIiIiLsbD6gJERJKSFStWkCpVqnjnYmJiLKpGRCRhKACKiNyjWrVqjBs3Lt65X375hTZt2lhUkYjIk6cAKCJyj5QpU5IvX754586fP29RNSIiCUP3AIqIiIi4GAVAERERERejACgiIiLiYmwOh8NhdREiIiIikng0AigiIiLiYhQARURERFyMAqCIiIiIi1EAFBEREXExCoAiIiIiLkYBUERERMTFKACKiIiIuJj/AT7yhY2r4VmJAAAAAElFTkSuQmCC"
    }
   },
   "cell_type": "markdown",
   "id": "012d4e25",
   "metadata": {},
   "source": [
    "![fused-attention-batch4-d64-fwd-xvalH.png](attachment:fused-attention-batch4-d64-fwd-xvalH.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "471230e6",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}