Model_Architecture_Discussions/llama3/llama3-from-scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 从头开始实现llama3\n",
    "在这个文件中，我逐个张量和矩阵地从头实现了llama3。\n",
    "<br>\n",
    "此外，我将直接从meta提供给llama3的模型文件中加载张量，你需要在运行此文件之前下载权重。\n",
    "这是下载权重的官方链接: [点击这里下载权重](https://llama.meta.com/llama-downloads/)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/archi.png\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "https://hf-mirror.com/NousResearch/Meta-Llama-3-8B\n",
    "https://gitee.com/hf-models/Meta-Llama-3-8B-Instruct/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 分词器\n",
    "我不打算实现一个BPE分词器（但是Andrej Karpathy有一个非常干净的实现）。\n",
    "<br>\n",
    "他的实现链接: [点击这里查看他的实现](https://github.com/karpathy/minbpe)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/karpathyminbpe.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: HF_ENDPOINT=\"https://hf-mirror.com\"\n"
     ]
    }
   ],
   "source": [
    "%env HF_ENDPOINT = \"https://hf-mirror.com\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install blobfile -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world!'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "import tiktoken\n",
    "from tiktoken.load import load_tiktoken_bpe\n",
    "import torch\n",
    "import json\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "tokenizer_path = \"./tokenizer.model\"\n",
    "special_tokens = [\n",
    "            \"<|begin_of_text|>\",\n",
    "            \"<|end_of_text|>\",\n",
    "            \"<|reserved_special_token_0|>\",\n",
    "            \"<|reserved_special_token_1|>\",\n",
    "            \"<|reserved_special_token_2|>\",\n",
    "            \"<|reserved_special_token_3|>\",\n",
    "            \"<|start_header_id|>\",\n",
    "            \"<|end_header_id|>\",\n",
    "            \"<|reserved_special_token_4|>\",\n",
    "            \"<|eot_id|>\",  # end of turn\n",
    "        ] + [f\"<|reserved_special_token_{i}|>\" for i in range(5, 256 - 5)]\n",
    "mergeable_ranks = load_tiktoken_bpe(tokenizer_path)\n",
    "tokenizer = tiktoken.Encoding(\n",
    "    name=Path(tokenizer_path).name,\n",
    "    pat_str=r\"(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?\\p{L}+|\\p{N}{1,3}| ?[^\\s\\p{L}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+\",\n",
    "    mergeable_ranks=mergeable_ranks,\n",
    "    special_tokens={token: len(mergeable_ranks) + i for i, token in enumerate(special_tokens)},\n",
    ")\n",
    "\n",
    "tokenizer.decode(tokenizer.encode(\"hello world!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取模型文件\n",
    "通常，读取模型文件取决于模型类的编写方式以及其中的变量名。\n",
    "<br>\n",
    "但由于我们是从头开始实现llama3，我们将逐个张量地读取文件。\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/model.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以在这里下载模型：https://gitee.com/hf-models/Meta-Llama-3-8B-Instruct/blob/main/original/consolidated.00.pth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2024-05-25 16:24:15--  https://lfs.gitee.com/api/lfs/storage/projects/34266234/be52262c9289304f3e8240e0749bf257bc04264405a86cd4de38efb9068724ee?Expires=1716626632&Signature=xgDOu9JHNM6ECazR3nA4NQHwXs%2BiG%2BCtnzza6ekSuqs%3D&FileName=consolidated.00.pth\n",
      "Resolving lfs.gitee.com (lfs.gitee.com)... 180.76.198.180\n",
      "Connecting to lfs.gitee.com (lfs.gitee.com)|180.76.198.180|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 16060617592 (15G) [application/octet-stream]\n",
      "Saving to: ‘be52262c9289304f3e8240e0749bf257bc04264405a86cd4de38efb9068724ee?Expires=1716626632&Signature=xgDOu9JHNM6ECazR3nA4NQHwXs+iG+Ctnzza6ekSuqs=&FileName=consolidated.00.pth’\n",
      "\n",
      " 0% [                                       ] 105,193,134  453KB/s  eta 11h 21m^C\n"
     ]
    }
   ],
   "source": [
    "!wget 'https://lfs.gitee.com/api/lfs/storage/projects/34266234/be52262c9289304f3e8240e0749bf257bc04264405a86cd4de38efb9068724ee?Expires=1716626632&Signature=xgDOu9JHNM6ECazR3nA4NQHwXs%2BiG%2BCtnzza6ekSuqs%3D&FileName=consolidated.00.pth'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我的机器12s可以载入，接下来仅用cpu进行推理，我这边内存30G足够了，然后cpu推理一个词大约30s，稍微慢了一些，不过我们主要理解原理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      "    \"tok_embeddings.weight\",\n",
      "    \"layers.0.attention.wq.weight\",\n",
      "    \"layers.0.attention.wk.weight\",\n",
      "    \"layers.0.attention.wv.weight\",\n",
      "    \"layers.0.attention.wo.weight\",\n",
      "    \"layers.0.feed_forward.w1.weight\",\n",
      "    \"layers.0.feed_forward.w3.weight\",\n",
      "    \"layers.0.feed_forward.w2.weight\",\n",
      "    \"layers.0.attention_norm.weight\",\n",
      "    \"layers.0.ffn_norm.weight\",\n",
      "    \"layers.1.attention.wq.weight\",\n",
      "    \"layers.1.attention.wk.weight\",\n",
      "    \"layers.1.attention.wv.weight\",\n",
      "    \"layers.1.attention.wo.weight\",\n",
      "    \"layers.1.feed_forward.w1.weight\",\n",
      "    \"layers.1.feed_forward.w3.weight\",\n",
      "    \"layers.1.feed_forward.w2.weight\",\n",
      "    \"layers.1.attention_norm.weight\",\n",
      "    \"layers.1.ffn_norm.weight\",\n",
      "    \"layers.2.attention.wq.weight\"\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "model = torch.load(\"/data1/ckw/consolidated.00.pth\")\n",
    "print(json.dumps(list(model.keys())[:20], indent=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dim': 4096,\n",
       " 'n_layers': 32,\n",
       " 'n_heads': 32,\n",
       " 'n_kv_heads': 8,\n",
       " 'vocab_size': 128256,\n",
       " 'multiple_of': 1024,\n",
       " 'ffn_dim_multiplier': 1.3,\n",
       " 'norm_eps': 1e-05,\n",
       " 'rope_theta': 500000.0}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open(\"./params.json\", \"r\") as f:\n",
    "    config = json.load(f)\n",
    "config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 我们使用这个配置来推断模型的细节，比如：\n",
    "1. 模型有32个Transformer层\n",
    "2. 每个多头注意力块有32个头\n",
    "3. 词汇表大小，等等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim = config[\"dim\"]\n",
    "n_layers = config[\"n_layers\"]\n",
    "n_heads = config[\"n_heads\"]\n",
    "n_kv_heads = config[\"n_kv_heads\"]\n",
    "vocab_size = config[\"vocab_size\"]\n",
    "multiple_of = config[\"multiple_of\"]\n",
    "ffn_dim_multiplier = config[\"ffn_dim_multiplier\"]\n",
    "norm_eps = config[\"norm_eps\"]\n",
    "rope_theta = torch.tensor(config[\"rope_theta\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 将文本转换为标记\n",
    "这里我们使用tiktoken（我认为是OpenAI的一个库）作为分词器\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/tokens.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[128000, 1820, 4320, 311, 279, 17139, 3488, 315, 2324, 11, 279, 15861, 11, 323, 4395, 374, 220]\n",
      "['<|begin_of_text|>', 'the', ' answer', ' to', ' the', ' ultimate', ' question', ' of', ' life', ',', ' the', ' universe', ',', ' and', ' everything', ' is', ' ']\n"
     ]
    }
   ],
   "source": [
    "prompt = \"the answer to the ultimate question of life, the universe, and everything is \"\n",
    "tokens = [128000] + tokenizer.encode(prompt)\n",
    "print(tokens)\n",
    "tokens = torch.tensor(tokens)\n",
    "prompt_split_as_tokens = [tokenizer.decode([token.item()]) for token in tokens]\n",
    "print(prompt_split_as_tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 将标记转换为它们的嵌入向量\n",
    "这是代码库中我唯一使用内置神经网络模块的部分。\n",
    "<br>\n",
    "无论如何，我们的[17x1]标记现在是[17x4096]，即长度为4096的17个嵌入向量（每个标记一个）。\n",
    "<br>\n",
    "<br>\n",
    "注意: 跟踪形状，这样可以更容易理解所有内容\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/embeddings.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_layer = torch.nn.Embedding(vocab_size, dim)\n",
    "embedding_layer.weight.data.copy_(model[\"tok_embeddings.weight\"])\n",
    "token_embeddings_unnormalized = embedding_layer(tokens).to(torch.bfloat16)\n",
    "token_embeddings_unnormalized.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 然后我们使用RMS归一化来标准化嵌入向量\n",
    "请注意，在此步骤之后，形状不会改变，只是值被标准化了。\n",
    "<br>\n",
    "需要记住的一些事情，我们需要一个norm_eps（来自配置），因为我们不希望意外地将RMS设置为0并除以0。\n",
    "<br>\n",
    "以下是公式：\n",
    "<div>\n",
    "    <img src=\"images/rms.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def rms_norm(tensor, norm_weights):\n",
    "#     rms = (tensor.pow(2).mean(-1, keepdim=True) + norm_eps)**0.5\n",
    "#     return tensor * (norm_weights / rms)\n",
    "def rms_norm(tensor, norm_weights):\n",
    "    return (tensor * torch.rsqrt(tensor.pow(2).mean(-1, keepdim=True) + norm_eps)) * norm_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 构建Transformer的第一层\n",
    "\n",
    "### 标准化\n",
    "你会看到我从模型字典中访问layer.0（这是第一层）。\n",
    "<br>\n",
    "无论如何，所以在我们标准化后，形状仍然是[17x4096]，与嵌入向量相同，但是标准化了\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/norm.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "token_embeddings = rms_norm(token_embeddings_unnormalized, model[\"layers.0.attention_norm.weight\"])\n",
    "token_embeddings.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 从头实现的注意力机制\n",
    "让我们加载Transformer第一层的注意力头\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qkv.png\" width=\"600\"/>\n",
    "</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "&gt; 当我们从模型中加载查询（query）、键（key）、值（value）和输出（output）向量时，我们注意到它们的形状为[4096x4096]、[1024x4096]、[1024x4096]、[4096x4096]\n",
    "<br>\n",
    "&gt; 乍一看这有点奇怪，因为理想情况下我们希望每个注意力头的q、k、v和o都是分开的\n",
    "<br>\n",
    "&gt; 代码的作者将它们捆绑在一起，因为这样做容易并行化注意力头的乘法。\n",
    "<br>\n",
    "&gt; 我要将所有东西解开..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4096, 4096]) torch.Size([1024, 4096]) torch.Size([1024, 4096]) torch.Size([4096, 4096])\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    model[\"layers.0.attention.wq.weight\"].shape,\n",
    "    model[\"layers.0.attention.wk.weight\"].shape,\n",
    "    model[\"layers.0.attention.wv.weight\"].shape,\n",
    "    model[\"layers.0.attention.wo.weight\"].shape\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 解开查询\n",
    "在下一节中，我们将从多个注意力头中解开查询，结果形状为[32x128x4096]\n",
    "<br><br>\n",
    "这里，32是llama3中的注意力头数量，128是查询向量的大小，4096是标记嵌入的大小"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 128, 4096])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_layer0 = model[\"layers.0.attention.wq.weight\"]\n",
    "head_dim = q_layer0.shape[0] // n_heads\n",
    "q_layer0 = q_layer0.view(n_heads, head_dim, dim)\n",
    "q_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 我要实现第一层的第一个注意力头\n",
    "在这里，我首先访问第一层的第一个注意力头的查询权重矩阵，该查询权重矩阵的大小为[128x4096]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_layer0_head0 = q_layer0[0]\n",
    "q_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 现在我们将查询权重与标记嵌入相乘，以获得每个标记的查询\n",
    "在这里，你可以看到结果的形状为[17x128]，这是因为我们有17个标记，对于每个标记，都有一个长度为128的查询。\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/q_per_token.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token = torch.matmul(token_embeddings, q_layer0_head0.T)\n",
    "q_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 位置编码\n",
    "现在我们处于这样一个阶段：我们在我们的提示中为每个标记都有一个查询向量，但是如果你想一想--每个单独的查询向量并不知道在提示中的位置。\n",
    "<br><br>\n",
    "查询：\"生命、宇宙和一切的终极问题的答案是\"\n",
    "<br><br>\n",
    "在我们的提示中，我们使用了\"the\"三次，我们需要所有3个\"the\"标记的查询向量都根据它们在查询中的位置有不同的查询向量（每个大小为[1x128]）。我们使用RoPE（旋转位置编码）来执行这些旋转。\n",
    "<br><br>\n",
    "### RoPE\n",
    "观看这个视频（这是我看的）以理解数学原理。\n",
    "[点击这里观看视频](https://www.youtube.com/watch?v=o29P0Kpobz0&t=530s)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/rope.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "q_per_token_split_into_pairs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在上述步骤中，我们将查询向量分成一对对，对每对应用旋转角度偏移！\n",
    "<br><br>\n",
    "现在我们有一个大小为[17x64x2]的向量，这是128长度的查询分成64对，对于提示中的每个标记！每个这样的64对将通过m*(theta)进行旋转，其中m是我们正在旋转查询的标记的位置！\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qsplit.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用复数的点积来旋转向量\n",
    "<div>\n",
    "    <img src=\"images/freq_cis.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0000, 0.0156, 0.0312, 0.0469, 0.0625, 0.0781, 0.0938, 0.1094, 0.1250,\n",
       "        0.1406, 0.1562, 0.1719, 0.1875, 0.2031, 0.2188, 0.2344, 0.2500, 0.2656,\n",
       "        0.2812, 0.2969, 0.3125, 0.3281, 0.3438, 0.3594, 0.3750, 0.3906, 0.4062,\n",
       "        0.4219, 0.4375, 0.4531, 0.4688, 0.4844, 0.5000, 0.5156, 0.5312, 0.5469,\n",
       "        0.5625, 0.5781, 0.5938, 0.6094, 0.6250, 0.6406, 0.6562, 0.6719, 0.6875,\n",
       "        0.7031, 0.7188, 0.7344, 0.7500, 0.7656, 0.7812, 0.7969, 0.8125, 0.8281,\n",
       "        0.8438, 0.8594, 0.8750, 0.8906, 0.9062, 0.9219, 0.9375, 0.9531, 0.9688,\n",
       "        0.9844])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero_to_one_split_into_64_parts = torch.tensor(range(64))/64\n",
    "zero_to_one_split_into_64_parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1.0000e+00, 8.1462e-01, 6.6360e-01, 5.4058e-01, 4.4037e-01, 3.5873e-01,\n",
       "        2.9223e-01, 2.3805e-01, 1.9392e-01, 1.5797e-01, 1.2869e-01, 1.0483e-01,\n",
       "        8.5397e-02, 6.9566e-02, 5.6670e-02, 4.6164e-02, 3.7606e-02, 3.0635e-02,\n",
       "        2.4955e-02, 2.0329e-02, 1.6560e-02, 1.3490e-02, 1.0990e-02, 8.9523e-03,\n",
       "        7.2927e-03, 5.9407e-03, 4.8394e-03, 3.9423e-03, 3.2114e-03, 2.6161e-03,\n",
       "        2.1311e-03, 1.7360e-03, 1.4142e-03, 1.1520e-03, 9.3847e-04, 7.6450e-04,\n",
       "        6.2277e-04, 5.0732e-04, 4.1327e-04, 3.3666e-04, 2.7425e-04, 2.2341e-04,\n",
       "        1.8199e-04, 1.4825e-04, 1.2077e-04, 9.8381e-05, 8.0143e-05, 6.5286e-05,\n",
       "        5.3183e-05, 4.3324e-05, 3.5292e-05, 2.8750e-05, 2.3420e-05, 1.9078e-05,\n",
       "        1.5542e-05, 1.2660e-05, 1.0313e-05, 8.4015e-06, 6.8440e-06, 5.5752e-06,\n",
       "        4.5417e-06, 3.6997e-06, 3.0139e-06, 2.4551e-06])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freqs = 1.0 / (rope_theta ** zero_to_one_split_into_64_parts)\n",
    "freqs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['axes.unicode_minus'] = False\t\t# 显示负号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams[\"font.sans-serif\"]=['simhei']\n",
    "freqs_for_each_token = torch.outer(torch.arange(17), freqs)\n",
    "freqs_cis = torch.polar(torch.ones_like(freqs_for_each_token), freqs_for_each_token)\n",
    "freqs_cis.shape\n",
    "\n",
    "# 查看freqs_cis的第三行\n",
    "value = freqs_cis[3]\n",
    "plt.figure()\n",
    "for i, element in enumerate(value[:17]):\n",
    "    plt.plot([0, element.real], [0, element.imag], color='blue', linewidth=1, label=f\"Index: {i}\")\n",
    "    plt.annotate(f\"{i}\", xy=(element.real, element.imag), color='red')\n",
    "plt.xlabel('实部')\n",
    "plt.ylabel('虚部')\n",
    "plt.title('freqs_cis的一行的图示')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 现在我们为每个标记的查询元素有了一个复数（角度变化向量）\n",
    "我们可以将我们的查询（我们分成对的那些）转换为复数，然后进行点积来根据位置旋转查询\n",
    "<br>\n",
    "说实话，这样想真的很美 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "q_per_token_as_complex_numbers.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_as_complex_numbers_rotated = q_per_token_as_complex_numbers * freqs_cis\n",
    "q_per_token_as_complex_numbers_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 在获得旋转向量后\n",
    "我们可以通过将复数视为实数来重新获取我们的查询对"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers_rotated)\n",
    "q_per_token_split_into_pairs_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "旋转后的查询对现已合并，我们现在有一个新的查询向量（旋转后的查询向量），其形状为\\[17x128\\]，其中17表示标记数量，128表示查询向量的维度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "q_per_token_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 键（几乎与查询相同）\n",
    "<div>\n",
    "    <img src=\"images/keys.png\" width=\"600px\"/>\n",
    "</div>\n",
    "我太懒了，所以我不打算为键做数学推导，你需要记住的几点是：\n",
    "<br>\n",
    "&gt; 键生成的键向量也是128维的\n",
    "<br>\n",
    "&gt; 键的权重数量只有查询的四分之一，这是因为键的权重在4个头中共享，以减少计算量\n",
    "<br>\n",
    "&gt; 键也会旋转以添加位置信息，与查询一样，因为同样的原因"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 128, 4096])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_layer0 = model[\"layers.0.attention.wk.weight\"]\n",
    "k_layer0 = k_layer0.view(n_kv_heads, k_layer0.shape[0] // n_kv_heads, dim)\n",
    "k_layer0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_layer0_head0 = k_layer0[0]\n",
    "k_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token = torch.matmul(token_embeddings, k_layer0_head0.T)\n",
    "k_per_token.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "k_per_token_split_into_pairs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "k_per_token_as_complex_numbers.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)\n",
    "k_per_token_split_into_pairs_rotated.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "k_per_token_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 在这个阶段，我们现在对于每个标记都有了旋转后的查询和键的值。\n",
    "<div>\n",
    "    <img src=\"images/keys0.png\" width=\"600px\"/>\n",
    "</div>\n",
    "每个查询和键现在的形状都是[17x128]。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 下一步我们将对查询和键矩阵进行相乘\n",
    "这样做将为我们提供一个将每个标记相互映射的分数\n",
    "<br>\n",
    "这个分数描述了每个标记的查询与每个标记的键之间的关系。\n",
    "这就是自注意力机制 :)\n",
    "<br>\n",
    "注意力分数矩阵的形状（qk_per_token）是[17x17]，其中17是提示中的标记数量\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qkmatmul.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 17])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5\n",
    "qk_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 现在我们需要对查询键分数进行掩码处理\n",
    "在llama3的训练过程中，未来标记的查询键分数是被掩码的。\n",
    "<br>\n",
    "为什么？因为在训练过程中，我们只学习使用过去的标记来预测标记。\n",
    "<br>\n",
    "因此，在推理过程中，我们将未来的标记分数设置为零。\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/mask.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def display_qk_heatmap(qk_per_token):\n",
    "    fig, ax = plt.subplots(figsize=(30, 8))  # 设置图像大小为12x8英寸\n",
    "    im = ax.imshow(qk_per_token.to(float).detach(), cmap='viridis')\n",
    "    ax.set_xticks(range(len(prompt_split_as_tokens)))\n",
    "    ax.set_yticks(range(len(prompt_split_as_tokens)))\n",
    "    ax.set_xticklabels(prompt_split_as_tokens)\n",
    "    ax.set_yticklabels(prompt_split_as_tokens)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "\n",
    "display_qk_heatmap(qk_per_token)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = torch.full((len(tokens), len(tokens)), float(\"-inf\"), device=tokens.device)\n",
    "mask = torch.triu(mask, diagonal=1)\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qk_per_token_after_masking = qk_per_token + mask\n",
    "display_qk_heatmap(qk_per_token_after_masking)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "    <img src=\"images/softmax.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "display_qk_heatmap(qk_per_token_after_masking_after_softmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 值（注意力机制的最后一步）\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/value.png\" width=\"600px\"/>\n",
    "</div>\n",
    "这些分数（0-1）用于确定每个标记使用多少值矩阵\n",
    "<br>\n",
    "&gt; 就像键一样，值的权重也在每4个注意力头中共享（以节省计算）\n",
    "<br>\n",
    "&gt; 因此，下面值权重矩阵的形状是[8x128x4096]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 128, 4096])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_layer0 = model[\"layers.0.attention.wv.weight\"]\n",
    "v_layer0 = v_layer0.view(n_kv_heads, v_layer0.shape[0] // n_kv_heads, dim)\n",
    "v_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一层，第一个注意力头的值权重矩阵如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_layer0_head0 = v_layer0[0]\n",
    "v_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 值向量\n",
    "<div>\n",
    "    <img src=\"images/v0.png\" width=\"600px\"/>\n",
    "</div>\n",
    "我们现在使用值权重来获取每个标记的注意力值，其大小为[17x128]，其中17是提示中的标记数量，128是每个标记的值向量维度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_per_token = torch.matmul(token_embeddings, v_layer0_head0.T)\n",
    "v_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 注意力机制\n",
    "<div>\n",
    "    <img src=\"images/attention.png\" width=\"600px\"/>\n",
    "</div>\n",
    "与每个标记的值相乘后得到的注意力向量的形状为[17x128]。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "qkv_attention.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 多头注意力机制\n",
    "<div>\n",
    "    <img src=\"images/heads.png\" width=\"600px\"/>\n",
    "</div>\n",
    "我们现在得到了第一层和第一个头的注意力值\n",
    "<br>\n",
    "接下来，我将运行一个循环，为第一层的每个头执行与上面相同的数学计算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qkv_attention_store = []\n",
    "\n",
    "for head in range(n_heads):\n",
    "    q_layer0_head = q_layer0[head]\n",
    "    k_layer0_head = k_layer0[head//4] # key weights are shared across 4 heads\n",
    "    v_layer0_head = v_layer0[head//4] # value weights are shared across 4 heads\n",
    "    q_per_token = torch.matmul(token_embeddings, q_layer0_head.T)\n",
    "    k_per_token = torch.matmul(token_embeddings, k_layer0_head.T)\n",
    "    v_per_token = torch.matmul(token_embeddings, v_layer0_head.T)\n",
    "\n",
    "    q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "    q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "    q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis[:len(tokens)])\n",
    "    q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "\n",
    "    k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "    k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "    k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis[:len(tokens)])\n",
    "    k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "\n",
    "    qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5\n",
    "    mask = torch.full((len(tokens), len(tokens)), float(\"-inf\"), device=tokens.device)\n",
    "    mask = torch.triu(mask, diagonal=1)\n",
    "    qk_per_token_after_masking = qk_per_token + mask\n",
    "    qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "    qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "    qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "    qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "len(qkv_attention_store)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "    <img src=\"images/stacked.png\" width=\"600px\"/>\n",
    "</div>\n",
    "我们现在得到了第一层上所有32个头的qkv_attention矩阵，接下来我将把所有注意力得分合并成一个大小为[17x4096]的大矩阵。\n",
    "<br>\n",
    "我们快要完成了 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)\n",
    "stacked_qkv_attention.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 权重矩阵，最后的步骤之一\n",
    "<div>\n",
    "    <img src=\"images/weightmatrix.png\" width=\"600px\"/>\n",
    "</div>\n",
    "对于第0层注意力机制，最后要做的一件事是将注意力值与权重矩阵相乘。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4096, 4096])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w_layer0 = model[\"layers.0.attention.wo.weight\"]\n",
    "w_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 这是一个简单的线性层，所以我们只需要进行矩阵乘法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_delta = torch.matmul(stacked_qkv_attention, w_layer0.T)\n",
    "embedding_delta.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "    <img src=\"images/afterattention.png\" width=\"600px\"/>\n",
    "</div>\n",
    "我们现在得到了注意力机制后的嵌入值变化，这个变化应当加到原始的标记嵌入上。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_after_edit = token_embeddings_unnormalized + embedding_delta\n",
    "embedding_after_edit.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 我们对嵌入增量进行归一化，然后通过一个前馈神经网络进行处理\n",
    "<div>\n",
    "    <img src=\"images/norm_after.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[\"layers.0.ffn_norm.weight\"])\n",
    "embedding_after_edit_normalized.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载前馈网络权重并实现前馈网络\n",
    "<div>\n",
    "    <img src=\"images/swiglu.png\" width=\"600px\"/>\n",
    "</div>\n",
    "在llama3中，他们使用了SwiGLU前馈网络，这种网络架构在模型需要时非常擅长添加非线性。\n",
    "<br>\n",
    "如今在大型语言模型中使用这种前馈网络架构是相当标准的做法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w1 = model[\"layers.0.feed_forward.w1.weight\"]\n",
    "w2 = model[\"layers.0.feed_forward.w2.weight\"]\n",
    "w3 = model[\"layers.0.feed_forward.w3.weight\"]\n",
    "output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T)\n",
    "output_after_feedforward.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 我们终于在第一层之后得到了每个标记的新编辑嵌入\n",
    "只剩下31层就完成了（只需一个循环）\n",
    "<br>\n",
    "你可以想象这个编辑后的嵌入包含了第一层所有查询的信息\n",
    "<br>\n",
    "现在，每一层将编码越来越复杂的查询，直到我们得到一个了解下一个需要标记的所有信息的嵌入。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_0_embedding = embedding_after_edit+output_after_feedforward\n",
    "layer_0_embedding.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 天啊，一切都在一起\n",
    "<div>\n",
    "    <img src=\"images/god.png\" width=\"600px\"/>\n",
    "</div>\n",
    "没错，就是这样。我们之前做的一切，现在一次性完成，对每一层都一样。\n",
    "<br>\n",
    "\n",
    "# 祝你阅读愉快 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_embedding = token_embeddings_unnormalized\n",
    "for layer in range(n_layers):\n",
    "    qkv_attention_store = []\n",
    "    layer_embedding_norm = rms_norm(final_embedding, model[f\"layers.{layer}.attention_norm.weight\"])\n",
    "    q_layer = model[f\"layers.{layer}.attention.wq.weight\"]\n",
    "    q_layer = q_layer.view(n_heads, q_layer.shape[0] // n_heads, dim)\n",
    "    k_layer = model[f\"layers.{layer}.attention.wk.weight\"]\n",
    "    k_layer = k_layer.view(n_kv_heads, k_layer.shape[0] // n_kv_heads, dim)\n",
    "    v_layer = model[f\"layers.{layer}.attention.wv.weight\"]\n",
    "    v_layer = v_layer.view(n_kv_heads, v_layer.shape[0] // n_kv_heads, dim)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    for head in range(n_heads):\n",
    "        q_layer_head = q_layer[head]\n",
    "        k_layer_head = k_layer[head//4]\n",
    "        v_layer_head = v_layer[head//4]\n",
    "        q_per_token = torch.matmul(layer_embedding_norm, q_layer_head.T)\n",
    "        k_per_token = torch.matmul(layer_embedding_norm, k_layer_head.T)\n",
    "        v_per_token = torch.matmul(layer_embedding_norm, v_layer_head.T)\n",
    "        q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "        q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "        q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis)\n",
    "        q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "        k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "        k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "        k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)\n",
    "        k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "        qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5\n",
    "        mask = torch.full((len(token_embeddings_unnormalized), len(token_embeddings_unnormalized)), float(\"-inf\"))\n",
    "        mask = torch.triu(mask, diagonal=1)\n",
    "        qk_per_token_after_masking = qk_per_token + mask\n",
    "        qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "        qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "        qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "    stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    embedding_delta = torch.matmul(stacked_qkv_attention, w_layer.T)\n",
    "    embedding_after_edit = final_embedding + embedding_delta\n",
    "    embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[f\"layers.{layer}.ffn_norm.weight\"])\n",
    "    w1 = model[f\"layers.{layer}.feed_forward.w1.weight\"]\n",
    "    w2 = model[f\"layers.{layer}.feed_forward.w2.weight\"]\n",
    "    w3 = model[f\"layers.{layer}.feed_forward.w3.weight\"]\n",
    "    output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T)\n",
    "    final_embedding = embedding_after_edit+output_after_feedforward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 我们现在有了最终的嵌入，这是模型对下一个标记的最佳猜测\n",
    "嵌入的形状与常规标记嵌入相同，为[17x4096]，其中17是标记数量，4096是嵌入维度\n",
    "<div>\n",
    "    <img src=\"images/last_norm.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_embedding = rms_norm(final_embedding, model[\"norm.weight\"])\n",
    "final_embedding.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 最后，让我们将嵌入解码为标记值\n",
    "<div>\n",
    "    <img src=\"images/finallayer.png\" width=\"600px\"/>\n",
    "</div>\n",
    "我们将使用输出解码器将最终嵌入转换为标记。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128256, 4096])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model[\"output.weight\"].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 我们使用最后一个标记的嵌入来预测下一个值\n",
    "希望在我们的例子中是42 :)\n",
    "注意：42是《银河系漫游指南》一书中“生命、宇宙及一切的终极问题的答案”的答案，大多数现代大型语言模型在这里都会回答42，这应该验证我们的整个代码！祝我好运 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128256])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits = torch.matmul(final_embedding[-1], model[\"output.weight\"].T)\n",
    "logits.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型预测下一个标记为2983号标记，这是42的标记号吗？\n",
    "希望这里让你兴奋起来了，这是最后一个代码单元，希望你玩得开心 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2983)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next_token = torch.argmax(logits, dim=-1)\n",
    "next_token"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# lets fucking go\n",
    "<div>\n",
    "    <img src=\"images/42.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.decode([next_token.item()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 谢谢你，我爱你们，亲爱的读者 :)\n",
    "\n",
    "这就是结尾了。希望你喜欢阅读！\n",
    "感谢datawhale小伙伴的相关支持和赞赏。\n",
    "我们是A10 Research，很荣幸这个工作帮到大家。\n",
    "如果你想支持我的工作\n",
    "\n",
    "1. 在推特上关注我 [https://twitter.com/naklecha](https://twitter.com/naklecha)\n",
    "2. 或者，请我喝杯咖啡 [https://www.buymeacoffee.com/naklecha](https://www.buymeacoffee.com/naklecha)\n",
    "\n",
    "老实说，如果你能看到这里，你已经让我非常开心了 :)\n",
    "\n",
    "## 是什么激励我？\n",
    "\n",
    "我的朋友和我正在执行一个使命——让研究更易于访问！\n",
    "我们创建了一个研究实验室，叫做A10 - [AAAAAAAAAA.org](http://aaaaaaaaaa.org/)\n",
    "\n",
    "A10的推特 - [https://twitter.com/aaaaaaaaaaorg](https://twitter.com/aaaaaaaaaaorg)\n",
    "\n",
    "我们的论点：\n",
    "<div>\n",
    "    <img src=\"images/a10.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们目前的主要目标是让研究变得更易获得。这个领域非常混乱，大家似乎都在分享低熵的高层次见解（哈哈，最近的流行语信息熵为0）。我们希望深入探讨话题，并与大家分享。除此之外，我们还会推出一些很棒的开源项目，并训练/微调模型（在过程中分享我们的进展）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 备注：预测\"datawhalechina is a group for \"的下一个词"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[128000, 695, 1336, 1604, 81236, 374, 264, 1912, 369, 220]\n",
      "['<|begin_of_text|>', 'data', 'wh', 'ale', 'china', ' is', ' a', ' group', ' for', ' ']\n"
     ]
    }
   ],
   "source": [
    "prompt = \"datawhalechina is a group for \"\n",
    "tokens = [128000] + tokenizer.encode(prompt)\n",
    "print(tokens)\n",
    "tokens = torch.tensor(tokens)\n",
    "prompt_split_as_tokens = [tokenizer.decode([token.item()]) for token in tokens]\n",
    "print(prompt_split_as_tokens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10, 4096])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_layer = torch.nn.Embedding(vocab_size, dim)\n",
    "embedding_layer.weight.data.copy_(model[\"tok_embeddings.weight\"])\n",
    "token_embeddings_unnormalized = embedding_layer(tokens).to(torch.bfloat16)\n",
    "token_embeddings_unnormalized.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里需要由17改10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAHFCAYAAAAKbwgcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACR30lEQVR4nO2dd1hT9xfG3wiyVBTcAxW3bbVa99aKdY9grVptbdWf1Wrd1NW696yjjqrgrNaFe8+6ByrujYriwAWobO7vj9OwRxKSfO+9OZ/nyaOE5ObcBMibs16NJEkSGIZhGIZhFE4W0QEwDMMwDMOYAhY1DMMwDMOoAhY1DMMwDMOoAhY1DMMwDMOoAhY1DMMwDMOoAhY1DMMwDMOoAhY1DMMwDMOoAhY1DMMwDMOoAhY1DMMwDMOoAhY1DMMwevD27VtERESIDoNhmHTQsE0CwzBy58mTJ8iVKxeyZ8+e5PrAwEA4OjoiT548Zo9h4MCBOHHiBI4fPw5HR0dERUVBo9Ega9asSW4XFRWFmJgYODk5pThGQEAAChUqBHt7+yTX37t3D/nz50eOHDlSfeyYmBi8f//e4JidnZ2RJUvCZ1dJkhAREQF7e/sk1ydGkiRER0cjS5YssLW1NfgxGUYknKlhGEb2zJs3D59//jmSfwZbtWoVihUrhtevX5v18W/cuIGFCxdi6NChcHR0BABMnjwZdnZ20Gg0SS729vb48ssvUz3OsGHD0Lx58xTXT5s2DeXLl0dMTEyq9zt16hRcXFwMvty8eTPJcR49egQnJyfY2NikiFt3yZIlC+zt7bF169bMPWkMIwAWNQwjkOvXr6NOnTpwcHBAvnz5sGfPHtEhmZyxY8eiYcOGmTrGjRs30KZNG2g0miTX79u3D1qtFrlz587U8dPj48eP6Ny5M1q2bIlOnTrFX9+/f388evQIQUFBePbsGZ49e4agoCAEBARg48aNaZ5H27Ztk1wnSRL279+PH374Ic3MiO76sLAwSJIESZLw5s0bjBs3Dq9fv46/TncJDAwEANjZ2SU5TpEiRRAQEIDnz58jODg41cvLly/x+PFjNGvWzOjnjGFEwblFhhFI9+7dUbJkScyYMQPPnj1Drly5RIdkcnr16oXOnTsbdd8nT54gIiIC169fh1arxb179wAAJUqUwMOHD3HixAn06tULixcvjr+Pi4sLOnbsaJLYAaBnz5548uQJ9u3bl+R6V1dXuLq66nWMgIAAxMTE4O7duyhbtizu3bsHGxsbuLu74+jRo3j8+DEkSUpyHkWLFkWLFi0AIEWJC6Dszty5c9G0aVOULVs2/vqcOXPG/9/GxibJfWxtbVG8eHG9YmYYJcI9NQwjkKxZs2Lv3r1o3Lix6FBkSe3atXH69OkU13/8+BGTJk3C3Llzk7yhv3r1Cs7Ozrhy5YpJHv/Zs2coU6YMNm7ciPr166N58+YYM2ZMmuWltChUqBCePXuW5Lp8+fLhxYsX6Nq1K/bs2QN3d/f47wUFBaFq1arYvn07AODy5cuoXLkywsLCkD17dvj7+6N69eqIiopKcswKFSrg8uXLCAoKgpubGwICAljEMFYFZ2oYRiAxMTEpPk0zCdjb22PMmDEYO3YsAODEiROoV68eIiMjsXjxYowZMwZDhw6Nv/2SJUuwdOlSkz1+wYIFcfXqVRQvXhy///47Tp8+DRsbGzx79gzPnz9Ps+E2OjoasbGxqFSpUvx5+Pj44IcffgAArFmzBiNHjsTDhw+xceNGrF27Fl9//XX8/UeMGIG7d++mGtOrV6/QoUMHREdH49ChQ/jyyy9x7tw5NG7cGMuXL0+zAfju3buwtbVNNeuTGpIkISoqCgUKFEC2bNn0ug/DiIZ7ahjGwhw9ejS+KRMAGjVqBI1Gk+QTtUajwdGjR7F9+3bUqFEjRXPplStX4OHhAScnJ5QoUQJ//PFHku8HBASgWbNmyJEjBz777DNMmzYtST9KTEwMhg4disKFCyNbtmyoX7++wdmNp0+fon379siePTsKFiyIvn37pjqhk15PzYoVK1C2bFk4OjqifPny2LRpU5LvpyX4Jk2aBGdnZ/Tr1y/J9dHR0Ukmiz58+IDw8PA0G3CTI0kSYmJi8OHDh/jrihcvjgcPHmDmzJn45Zdf0KBBA6xatQq1atVCnTp1ULduXdStWxdffPEFKlSogLp166J27dpJelJSO48sWbLAy8sLVatWRfv27dM9j8SMHDkS+fLlw/r166HVajFz5ky0bdsWixYtQrVq1dI8t2rVqqFEiRJwc3PT61K0aFGUKlUKx48f1+u5Yxg5wJkahrEwVapUwfnz5wHQG83ixYtRpUqVFG9iGzZsgK+vL3766Sd8/vnn8de/fv0aX375JerVq4fdu3fjypUrGDx4MHLkyIEePXogJiYGzZo1g5OTEzZs2ICAgAB4eXklOfaCBQswf/58/PXXXyhcuDDmzZuHb775Brdu3dLrHD58+ICGDRsie/bs+OeffxAeHo4BAwbgw4cPWLFihV7HuHjxIrp3745ff/0VLVq0wO7du/Htt9+iRo0acHNzi79dVFRUvFgKDw8HAAwfPhzffvstBg0ahIYNG8b30ERFRcHBwSH+vnXq1IG/v79e8SRHV5mPiYlB165dERERgZ49ewKgKaZhw4Yluf3w4cNx4sQJnDhxItXjRUZGxp9HZGQkAGDWrFkICQlBhw4dMHjwYNSuXTvV80jM/PnzERkZiYiICFSuXBleXl744osv0hU0AAldOzu7FAJrxYoVmDNnTornKTY2FmFhYXB2dk73uAwjJ1jUMIyFyZEjB6pWrRr/ddmyZZN8rWPDhg04e/YsSpYsmeT6BQsWIEuWLPjnn39gZ2eHhg0b4ujRo1i1ahV69OiBvXv34s6dO7h48SIqV64MgEZ5p0+fHn+MgIAA5MuXD9999x2yZMmCzz77DH5+fpAkKcWEUWqsW7cOAQEBuHfvXnyGKTo6GgcPHtT7eXj06BEkSUL37t1RpkwZ1KpVC3Xr1o0fmdYxZcoUTJkyJcl1uXPnRu7cuWFjY4Px48fjm2++gUajSSEGSpYsibi4OGTNmlWvsoskSYiNjU2yZK9Pnz7xo9H6PDdp0bt3b/Tu3Tv+62LFiqFo0aIAgIiICEyYMCF++i0tURMeHo5Nmzbh0KFD2LJlC1q1aoUzZ87gr7/+wmeffYaqVauiVq1a+O6771Lc18XFJf7/27ZtQ6tWrWBjYwNbW1toNJr4x7tz5w7KlCkDAFx2YhQHl58YRqb8+uuvKQQNQKWn4OBg2Nvbx5exfH1943sw7t27h6xZs8b3cwCUsUjMd999h5CQEHz22Wfo27cvjh49Cg8PD73ftC9evIgiRYokKZl17twZy5cv1/v8PDw8ULp0adSvXx/ff/89li1bhho1aqRYpOfl5RU/brxz584k3xs0aBBu3rwZ31AbERGRRAxs3rwZV65cgZ+fH86cOZPh5ezZs7hw4QKuXbsGADh48CCWL1+OuXPn6n1eaTF//vz481i0aFGS7w0ePBh79+6Nz5YkPw8dDg4O2Lt3L/Lnz49z584hW7Zs6NOnD6pVq4aLFy+iVatWeP36NfLmzZtmHLt27UK7du1STHMBwN69e/H555/j3LlzmTxbhhEDixqGkSnVq1dP93uXLl1Kctm/fz8A6tXQ7SvRERcXl+T+VatWxd27dzF8+HBER0ejd+/eqF+/vkG9J8l59+4dTpw4EV8iyogcOXLA398fS5YsQf78+TFr1iyUK1cOjx49SnI7Jycn5MmTB3ny5EkyrgxQJqZhw4ZYt24dAJqKSm2Tr7F4eHhg586d8aPVmSF79uzx55F8M3KjRo1QokSJDM9Do9Fg/fr1mDlzJsqWLYupU6fC09MTY8aMwY4dOzBq1CisXLkyzRgkScLvv/+OZs2apXpOzZo1Q4cOHdCuXTsEBQVl8owZxvKwqGEYhfHZZ5/h8ePHKF++PCpVqoRKlSrhzp078TtOSpcujZiYGPj5+cXf59ixY0mOMX36dNy5cwfff/89/vrrL2zcuBHnzp3D1atX9YqhcuXKePLkCR4+fBh/na+vL+rXr4/o6Gi9jrFlyxasX78ebdu2xYwZM3D58mW8f/8eW7Zs0ev+Ov7888/4N/L379+bvAfEFIImI3TZtsmTJwPQ7zw8PDzQpk0b2Nra4vDhwxg4cGCGj+Pj44ObN29i/vz5ad5m8eLFyJ07Nzw9PVOMjDOM3GFRwzAK45dffkFkZCQ6deqEQ4cOYd26dfj555/jR3m/+uorlC9fHj169MDu3buxYMGCFGPOd+/eRd++fbF9+3acOHECPj4+sLOzQ5EiRfSK4dtvv0XRokWh1Wqxe/dubNq0CWPHjkWnTp30FhXh4eEYNGgQVqxYgVOnTuHPP/9EVFQUSpQokeR27969w8OHD/Hw4UM8f/48xXHKly8f32T99u1b2Ta2vnr1Kv48Xr16leL7FStWjH8Nk59HbGxsitsvXboUnp6eWLt2bfyEW3ISZ+gePHiAwYMHY8yYMShVqlSacTo5OWHTpk24evUqBg0aZNA5MoxouFGYYRRGnjx5cOjQIQwZMgStWrWCq6srevTogQkTJgCg8WHd1JRWq0XZsmUxYcIEDB48OP4Ys2bNgpeXF/r06YPXr1+jbNmy2LhxY7q9GInJnj07jh07hv79+6NDhw7IlSsXOnTogIkTJ+p9Hl26dEFQUBAmT56MwMBA5MuXD5MmTUpiIxAXF4e5c+em6GmJi4tLdR/LzZs3k0yKmQpduS29XaXJS3zJv+fl5ZVkCi3xhFdioqOjce/evSSlNl1Z8MGDB/FlKY1GA09PT3h6euLMmTMoVKhQ/MZlnfhLXE6cNGkS3N3dk+z1ARImsRJTtmxZzJkzB3v27EFUVFQKuwWGkS0SwzCq58iRI5K+v+6xsbFSdHR0mpfY2FgzR5tAnTp1pDFjxsR/ffz4cQmAFB4eHn/dX3/9JfXv319q0KCBBEA6c+aMyeMICgqSAEj+/v4pvnf48GFp0KBBUpEiRaTGjRunev/ChQtLPj4+8V+vXr1ayp8/f5LbTJ06VerXr59UpUoVydbWVnry5En8906ePCkBMPhy/fr1+GPExcVJQUFB8V/v3btX+uqrryQXFxfpyy+/NPapYRhZweUnhmGS0L179/gR6NQuiTM+5qZ9+/aoWbNm/NclS5bE/Pnzk+xa0Wg02LBhA5ydnbF7927UqFHD5HHoshmpNUF//vnnWLlyJUqVKoXffvst1fv/+OOP+OSTT+K/rl69eoqs1vv377Ft2zaULFkSJ06cQOHCheO/p8u4JDa0TO+iM7RMnKnRaDQoWLBg/Nd169ZFlixZ0L9/f6xfv97Qp4RhZAl7PzEMk4THjx/jzZs3aX4/b968Sd5wGfMTHh6Op0+fomTJkpnalcMwaodFDcMwDMMwqoDLTwzDMAzDqAIWNQzDMAzDqAKrGemOi4tDUFAQcuTIwTVphmEYhlEIkiQhLCwMhQoVSnWVQ2KsRtQEBQWluReCYRiGYRh5ExgYmOGCUKsRNTly5ABAT4pcN44yDMMwDJOU0NBQuLm5xb+Pp4fViBpdycnZ2ZlFDcMwDMMoDH1aR7hRmGEYhmEYVcCihmEYhmEYVcCihmEYhmEYVcCihmEY9fHuHXD2LPD2rehIGIaxICxqGIZRFxs3AsWLAz17AkWK0NcMw1gFLGoYhlEPISHAzz8D//4LXL0K/Pkn4OUlOiqGYSwEixqGYdRDaCjwxx9AxYr09RdfAK9fCw2JYRjLwaKGYRj14OYGdOlC/4+OBubMAbRasTExDGMxrGb5HsMwVoS/P/Dll4CdHXDzpuhoGIaxEJypYRhGfVSsCOzfD5QuTQ3DDMNYBUJFzatXr+Du7o6HDx/qdftjx46hfPnyyJMnD2bPnm3e4BiGUS4aDVClCrByJbBlC414MwyjeoSJmlevXqFVq1Z6C5rg4GC0adMGnTt3xunTp7F27VocOXLEvEEyDKMsjh1LOu1kZ0cCJwsnpRnGGhD2m96pUyd8++23et9+7dq1KFSoEH7//XeULl0ao0ePxvLly80YIcMwiqNMGeCvv+gSGAiMHAl89RXAJrYMYxUIEzVLly5F//799b69v78/GjVqFO/SWb16dfj5+aV5+8jISISGhia5MAyjTnx9gRkzABQsCGzaBMydC3z6KfDxI7BqlejwGIaxEMJEjbu7u0G3Dw0NTXIfZ2dnBAUFpXn7KVOmIGfOnPEXNzc3o2NlGEbeHD8O+Pj890WTJsD167SzZuNGIG9eobHJlmbNgBUrREfBMCZFMYVmW1tb2Nvbx3/t4OCAjx8/pnn7ESNGICQkJP4SGBhoiTAZhhGAoyMQHi46CgWxdi2wb5/oKBjG5ChmT42rqyuCg4Pjvw4LC4OdnV2at7e3t08ighiGUS8sagzgzRtgyBCgbFnRkTCMyVFMpqZatWo4ffp0/NeXLl1C4cKFBUbEMIxccHKi9hlGD4YMoS3LNWuKjoRhTI7sRE1oaCiio6NTXN+mTRucPHkSBw8eRHR0NKZPn46mTZsKiJBhGLnBmRo9OXIEOHQImD5ddCQMYxZkJ2oqVqyIXbt2pbg+T548mDNnDlq0aIH8+fPj9u3b+O233wREyDCM3HB0BGJiyO6JSYOICOCnn4BFi4AcOURHwzBmQXhPjSRJSb5Obxlf79690bRpU9y6dQv16tVD9uzZzRwdwzBKwMmJ/g0PB7JmFRuLbJkwAahWDWjZUnQkDGM2hIsaQ3F3dzd4HJxhGHXj6Ej/hofznr00+ftvIDgYyJWLvv74EdiwATh3Dli4UGhoDGMqFCdqGIZhkpNY1DBpcPw41eh0DB1KzcI//CAsJIYxNbLrqWEYhjEUnajhCaiUxMQAffsC/q+LAMWLJ1yyZwfy5KELw6gEztQwDKN4EvfUMEm5d4+qS+3bJ/sGbxNmVAhnahiGUTxcfkobf3/6t2JFsXEwjCVgUcMwjOLh8lPaXLkCFCrEVSbGOmBRwzCM4uHyU9r4+wOffy46CoaxDCxqGIZRPFx+SpsrV7j0xFgPLGoYhlE8LGpS580bIDCQMzWM9cCihmEYxWNjA9jZcU9Ncq5epX85U8NYCyxqGIZRBWxqmRJ/f8DeHihbVnQkDGMZWNQwDKMKWNSkxN8f+PRTwJY3kjFWAosahhHFtm1AiRL0jlOpEnDzpuiIFI2TE5efksNNwoy1waKGYURw/z7w44/A1KnA06dAmTJAz56io1I0nKlJSkwMcO0aNwkz1gWLGoYRwc2bJGi++QbInx/o0we4dEl0VIqGRU1S7t0DIiI4U8NYF1xpZRgRtGqV9Ovbt4HSpcXEohIcHbn8lBi2R2CsEc7UMIxooqKAWbOA3r1FR6JonJw4U5MYtkdgrBEWNQwjmjFjgGzZuKcmk3D5KSlsj8BYIyxqGEYkhw8Df/4J/P03kDWr6GgUDZefksKTT4w1wqKGYUQREAB07kyi5pNPREejeLj8lADbIzDWCjcKM4wIwsOpWbhtW0CrBd6/p+uzZQM0GrGxKRQuPyXA9giMtcKZGoaxILdvA7VqAS/X7Adu3ACWLgVy5Ei4PHokOkTFwqImAbZHYKwVFjUMY0EKFgQuXgTWfWwLSFLKS/HiokNULLxROAG2R2CsFRY1DGNBnJ0BDw/A11d0JOqDMzUJWF2TcP/+VLbVXUqVEh0RIwgWNQxjYbRa4PhxIDhYdCTqgkUNYZX2CBcuALt2AW/f0oW3c1stLGoYxsK0aUP/bt8uNg61oZt+kiTRkYjF6uwRYmKA69eB+vWBXLnokiOH6KgYQbCoYRgLky8fULcusGWL6EjUhaMj/RsRITYO0VidPcLVq0BcHDndOzoCzZoBjx+LjooRBIsahhGApydw8CAQGio6EvWgEzXWXoKyOnuEGzdozGv1ajp5W1ugVy/RUTGCYFHDMAJo144sn3bvFh2JetCJGmufgLI6e4QuXainplYtMoVduBA4cIA/MVgpLGoYRgDFigFVqnAJypQ4OdG/nKmxotJTauTLR+WoZ89ER8IIgEUNwwhCq6VMjbX3gJgKLj9ZqT2Clxd5p+k4fRrIkgVwcxMXEyMMFjUMIwhPT+DDB8qUM5mHy09Wao/w+efAb78Bhw4B+/cDvXsD33+fkLpjrAoWNQwjiPLlqb+RF/GZBi4/WZ89wtatQM+jXRH7dUegfXsyiG3WDFiwQHRojCB4iTbDCMTTE/jrL1q1wSvtMweXn6zPHmHRIvKCtTk5BZg+RXQ4jAzgTA3DCESrBV6/pg3DTOZgUWNdTcKPHlHptkcP0ZEwcoJFDcMIpGpVoEgRnoIyBbryk7X21FibPcLKlfSad+ggOhJGTrCoYRiBaDSUrfH1pSlUxnjs7Oj5tNZMjTXZI8TFAT4+QMeO7IjAJIVFDcMIxtMTePqU9ocxxqPRWLeppTXZIxw5Ajx8CHTvLjoSRm6wqGEYwdStC+TOzVNQpsDJyXrLT9Zkj+DtTRNetWuLjoSRGyxqGEYwtrZA27bUV2PtDtOZxdozNdbQT/P2LbB5M2VpNBrR0TByg0UNw8gArRa4cwe4eVN0JMrGmkWNtUw+rVtHTdHffy86EkaOsKhhGBng4QFkz85TUJnF0dE6y0/WZI+wfDnQsiVQoIDoSBg5wqKGYWSAgwPQogX31WQWJyfrzNRYiz3C5cvAxYvcIMykDYsahpEJnp70B/vhQ9GRKBdrLT9Ziz2Cjw+QPz99AGCY1GBRwzAyoXlz2rWydavoSJSLtZafrMEeITISWLOGemmyZhUdDSNXWNQwjExwdgaaNOG+msxgreUna2gS3raNeoe49MSkB4sahpERWi1w4gTw4oXoSJSJNZafrMUeYfly2ktTrpzoSBg5w6KGYWREmza0e2P7dtGRKBNrFDXWYI/w+DGbVzL6waKGYWRE3rxAvXo8BWUs1rhR2BrsEVasYPNKRj9Y1DCMzPD0BA4eBEJCREeiPKwxU6N2ewSdeeU337B5JZMxLGoYRma0awdERwO7d4uORHlYo6hRuz2CzrySS0+MPrCoYRiZUbQoULUqT0EZgzWWn9Q++cTmlYwhsKhhGBmi1QJ79lhf1iGzWFumRu32CGxeyRgKixqGkSGensCHDzTxweiPoyONOEdHi47EMqjdHoHNKxlDYVHDMDKkXDmgfHmegjIUR0f611qyNWq3R/D2ZvNKxjBY1DCMTNFqaV9NTIzoSJSDkxP9a02iRq32CP7+gJ8fbxBmDEOYqLl27RqqVasGFxcXeHl5QZKkdG8vSRL69OkDV1dX5MqVCz/88APCreUvF2OVeHpSz8S//4qORDlYW6ZGzU3C3t5sXskYjhBRExkZidatW6NKlSq4cOECbty4gRUrVqR7n9WrV+P27du4dOkSjh8/juvXr2PKlCmWCZhhBPDFFzQJxVNQ+qMTNdYwAaVmewQ2r2SMRYio2bNnD0JCQjB79myULFkSkydPxvLly9O9z7lz5/D111+jWLFiqFChAtq1a4d79+5ZKGKGsTwaDZWgtm6lBWRMxlhT+UnN9ghsXskYixBR4+/vj5o1a8Lpv79AFStWxI0bN9K9z6effoo1a9bgxYsXePToEdavX48mTZqkefvIyEiEhoYmuTCM0tBqgadPgfPnRUeiDKyp/KRmewRvbzavZIxDiKgJDQ2Fu7t7/NcajQY2NjZ4+/Ztmvfp2bMn3r9/jwIFCqB48eJwd3dHt27d0rz9lClTkDNnzviLm5ubSc+BYSxB3brkB8VTUPphTaJGrfYIjx8D+/dzloYxDiGixtbWFvb29kmuc3BwwMd0CuFz585Frly58OjRIzx+/BgxMTHw8vJK8/YjRoxASEhI/CUwMNBk8TOMpbCxIefuLVuADHrpGSSUn6yhp0at9ggrV9Lr+M03oiMxA8OGAa1bi45C1QgRNa6urggODk5yXVhYGOzs7NK8z9q1a+Hl5YWiRYvCzc0NU6ZMSbcPx97eHs7OzkkuDKNEPD2Bu3eBDCq0DKwvU6O20lNcHJWeVGleeeUKsHAhMHeu6EhUjRBRU61aNZw+fTr+64CAAERGRsLV1TXN+8TFxeHly5fxXz9//hyxsbFmjZNh5EDjxvQHnqegMsZaRI1a7RGOHlWpeWVcHNCrFzBoEFCihOhoVI0QUVO/fn2EhobCx8cHADB58mR4eHjAxsYG7969S1Ws1KtXD1OnTsWKFSvw119/4eeff0abNm0sHTrDWBx7e9qqyn01GWNjQyPAai8/XblC/6otU7N8OVCmjArNKxcvJk+L4sVpo2ZUlOiIVIuwnpply5ahX79+yJMnD7Zt24Zp06YBAFxcXHBVZ2iSiIkTJ6JWrVr49ddfMWDAAFSoUAFzOY3HWAlaLXDpEhAQIDoS+ePkpP5MzZUr6rNHUK155fv3wJgxlKF59AiYM4cmANT+QyoIYcu127Rpg/v378PPzw81a9ZE7ty5ASDNzcK5cuXCqlWrLBkiw8iG5s3pTWzrVspgM2ljDU7darRHUK155ZYt5E575AiNqsXEABUqAKtXU0mKMSlCvZ8KFCiAli1bxgsahmFSJ0cOoEkT7qvRB0dH6yg/qa305O1NlggFC4qOxMQ8eQLUrJkwe29rSy8eL481C2xoyTAKwdMTOHkSePFCdCTyRu3lJzXaI+jMK1XXIAwARYqk/IF89AgoXFhMPCqHRQ3DKITWranXYNs20ZHIG7WXn9Roj6BW88pr14CYpi1pH8PixZS1mTePVJynp+jwVAmLGoZRCHnyAA0acAkqI9ReflKbPYJazStfv6bf19FzcwO7d9NWwTJlaE/Nhg0Ab7k3CypqM2MY9aPVAkOGAO/eAblyiY5Gnqi9/KQ2ewS1mlf+/juVCvv3B1CgDpBoNxtjPjhTwzAKol07IDoa2LVLdCTyRe3lJ7XZI6jRvPLSJWDJEmDcOKBAAdHRWBcsahhGQbi5AdWq8SK+9FC7qFHT5JMazSslCejXDyhfHujbV3Q01geLGoZRGJ6ewJ496n7jzgxOTurtqVGbPYIazSvXrAFOnQLmz1dXj5BSYFHDMApDq6U37f37RUciT9ScqVGTPUJcHODjoy7zytBQwMsL6NgRaNRIdDTWCYsahlEYZcsCn3zCU1BpoXZRoxZ7hKNHyfZDTaWnceOAsDBg5kzRkVgvLGoYRoFotcCOHdQ0zCRFzSPdarJH8PamCec6dURHYhquX6dp7d9+o317jBhY1DCMAvH0JAPAY8dERyI/1DzSrZYm4Xfv1GVeKUk0uu3uDgweLDoa64ZFDcMokMqVgWLFeAoqNdRaflKTPcK6dZRlVIt55aZNwOHDtCzY3l50NNYNixqGUSAaDZWgfH2p4ZJJQCdqJEl0JKZFTfYIy5erx7zywwfKzrRpAzRvLjoahkUNwygUrRZ49gw4d050JPLCyYn+jYgQG4epUYs9gs68Ui0NwpMnA8HBwJw5oiNhABY1DKNY6tQB8ublKajkODrSv2orQanFHsHbG8iXD2jZUnQkmefePZp0GjYMKFFCdDQMwKKGYRSLjQ3Qti2VoNRWaskMahU1arBHUJt55cCBVEIbNkx0JIwOFjUMo2A8PenT4rVroiORD7ryk9rGutUw+bR9u3rMK3fuJA+2OXMSfuYY8bCoYRgF8+WXtI2Vp6ASUGOmRi32CMuXA7VqkS+SkomIAAYMAL76ikxmGfnAooZhFIy9PdCqFffVJEaNokZnj6BkURMYSNYePXqIjiTzzJxJ5zNvnjr27KgJFjUMo3C0Wuq3ePBAdCTyQI3lJ509QpkyoiMxnhUr1GFe+egRTTwNGqQOuwq1waKGYRRO8+b0hsclKEKNmRql2yOoybxyyBAgVy6yQ2DkB4sahlE42bNTbZ9FDaFGUaP0JmG1mFceOED2DjNnKl+cqRUWNQyjAjw9gVOngOfPRUciHp2oUUv5SQ32CGowr4yKIn+nevWAzp1FR8OkBYsahlEBrVsDWbIA27aJjkQ89vbUvKmWTI3S7RHUYl45bx5w5w6wYIGyz0PtsKhhGBWQOzfQoAFPQQH0hqMmU0ul2yOowbwyKAgYNw7o21e5r4O1wKKGYVSCpyc5Bb97JzoS8Tg6qqf8pHR7BG9v5ZtX/vor/UyNHy86EiYjWNQwjEpo1476L3buFB2JeJyc1JWpUWo/zZUrwIULym4QPn4cWLsWmDqVpp4YecOihmFUQuHCQI0aPAUFqKv8pOTJJ6WbV8bEAP36AdWrAz/8IDoaRh9Y1DCMitBqgT171FN6MRa1iBol2yNERgKrVyvbvHLJEuDqVWoOzsLvloqAXyaGURFaLb2Z798vOhKxODmpQ9gp2R5B6eaVwcG0YK9nT6BaNdHRMPrCooZhVESZMrR51tqnoNSSqVGyPYLSzStHjqRJusmTRUfCGAKLGoZRGZ6ewI4dNEZrrahF1CjVHkFnXqnULM25cyTKJkxQ4NTZihWkxpJfVqwQHZlFYFHDMCpDq6Wx7qNHRUciDjWVn5TYJLxyJQnLjh1FR2I4cXHUHFyxIvDTT6KjMYJvvwXevk24BAaSMqtXT3RkFoFFDcOojEqVgOLFrXsKSg2ZGqXaI8TF0dSTUs0rfXyA8+epOVhpGTIAgJ0dzZ7rLqtW0SedkiUFB2YZWNQwjMrQaOhv2Nat9AZjjahB1CjVHuHYMTKv7NFDdCSG8/YtMHw40LUrULeu6GhMQEQEMHcuNQhZCSxqGP149QpwdwcePhQdCaMHnp7As2fA2bOiIxGDGjYKK9UeYfly5ZpXjh5NOmD6dNGRmIi//6blVcWLi47EYrCoYTLm1SugVSsWNAqiVi1aematU1Bq2CisRHsEJZtX+vsDCxcCY8cq29IhCYsXA717i47CorCoYTKmUydqPmMUg40N2Sb4+gKSJDoay6OG8pMS7RGUal4pScAvvwBlywL9+4uOxkTcu0eXJk1ER2JRWNQwGbN0qYp+060HrRa4f582olobaig/KXHyydsbaN5ceZmOdevI42nePOVuP07Bhg2UYVfNCekHixomY9zdRUfAGMGXXwLOztY5BaX08pMS7RF05pVKaxAOCwOGDgW+/hrw8BAdTeZIIuT37gUaNhQVijBY1DCMSrGzow9q1thX4+hII9ExMaIjMQ4l2iMo1bxywgTqBZo1S3QkmePePZra3rsXpOjPngVq1xYdlsVhUcMwKsbTk94g798XHYllcXSkf5WarVGaPUJkJLBmjfLMK2/dAubMAUaNAooWFR2N8YSEAG3aADlzAjVrgn4BIiOBcuVEh2ZxWNQwjIpp1gxwcLC+EpSTE/2r1L4apdkjbN8OvH6tLFsEXXNw0aLAkCGiozGe2FigSxcgKIheh1y5REckFhY1DKNismUDmja1vhKUGjI1SmoS9vZWnnmlry9w8CDtpnNwEB2N8YwcCezZQ33BSsnsmRMWNUyqBARQjxmvplE+Wi1w+jQt47MWlCxqlGaPEBgI7NunrCzNx4/AoEHU/9OqlehojGf1aloUOGsW8NVXoqORByxqmFTJnh14/Jh+4UNC/rtSkqxqM6VaaN2a9tZs3So6Esuh5PKT0uwRdOaV33wjOhL9mToVeP4c+OMP0ZEYz9mzwP/+B/z4IzBggOho5AOLGiZV8uYFdu0Cnjwhp12lTpEwgKsrZd2sqa9GyZkaJdkjJDavdHYWHY1+3L9P2Q0vL6BUKdHRGMfTp5SBrVIFWLRIedubzQmLGiZNypcHNm2iuvOAAda5mVYteHoCR46QYZ81oGRRoyR7BJ15pZJKT4MG0ej5iBGiIzGO8HDaFm5rS71y9vaiI5IXLGqYdPHwoE8CCxcC8+eLjoYxlrZtKdu2c6foSCyDTtQosfykJHsEb2+gdGnlOFrv3g3s2AHMnk1N9EpDkmi54Y0bwLZtQP78oiOSHyxqmAz53/9o5HHQIOt5U1QbhQvT/gprmYLS9dQoMVPj76+M0tO7d5TJVYp5ZWQkZZwbNwbatxcdjXFMm0aWDitWAJUri45GnrCoYfRi2jRqOO3UKaHmzygLrZamVD58EB2J+VFq+enNG+pjU0KmZv16Mq/s1k10JPoxezZNc86bpwwRlpwdO2h8e/RooEMH0dHIFxY1jF7Y2ABr19IehFatrGs8WC1otfQmv2+f6EjMj40NbbZVWvlJSfYIy5crx7wyMBCYOJEyNZ98Ijoaw7l2Dfj2W/odHjNGdDTyhkUNozfZstGnhbg4ytpYwyd+NVG6NPDZZ9YzBaVEU0ul2CMozbxy6FCazho9WnQkhvP6NVkglChB4/NZ+F07XfjpYQyicGHqq7l5E/juOxI4jHLw9CRhGhUlOhLz4+ioPFGjFHsEJZlXHj5M23anT1fO2LmO6GhyD3//niwQsmcXHZH8YVHDGEzlytSstnWrcscirRWtlpYpHj0qOhLzo0RRowR7BJ155Xffyd+8Mjqa/J3q1AG6dhUdjeEMHAicPEkN/sWKiY5GGQgTNdeuXUO1atXg4uICLy8vSHouQYmLi0Pt2rUxS+k+8QqnTRtazT19OtXWGWXw+eeAu7t1TEE5OSmrp0Yp9ghKMq9csICcuBcsUF5z8OLFtEpj4ULljMzLASGiJjIyEq1bt0aVKlVw4cIF3LhxAytWrNDrvosXL0ZISAj69+9v3iCZDBk4EPjpJ6B3b0rxMvJHo6Fszdat5O6rZpSWqVGKPYK3N60HkHvD7fPn1FTbuzdQqZLoaAzj6FHKMPXvD/TsKToaZSFE1OzZswchISGYPXs2SpYsicmTJ2O5Hh/3g4KCMHLkSMyfPx9Z5Z73tAI0GlrI16gR7X24dUt0RIw+eHoCL14AZ86IjsS8KE3UKMEeQWdeqYQG4WHDADs7YMIE0ZEYxoMH1EfTsCFlwxnDECJq/P39UbNmTTj9tyGrYsWKuHHjRob3GzhwIIoVK4bAwECcOnUq3dtGRkYiNDQ0yYUxPVmzUhNeoUI06v3qleiImIyoVYs2kap9Ckpp5Scl2CMoxbzy1Clg1SpgyhTyPlMKYWG0/dvFBfjnH/k3jMsRIaImNDQU7u7u8V9rNBrY2NjgbTrGNKdPn8bGjRtRpEgR3L9/H926dUO/fv3SvP2UKVOQM2fO+Iubm5tJz4FJIFcumogKDaXSRmSk6IiY9MiShbxjtmxRt5+XEjM1cu6niYsDfHzkb14ZGwv06wdUraqMvh8dcXHUzPz4MfUtKUmMyQkhosbW1hb2yVy4HBwc8DGdj1VLly5FjRo1sHPnTowfPx6HDx/GwoULcfv27VRvP2LECISEhMRfAgMDTXoOTFLc3alP4/x5qgGr+c1SDWi1ZESoW/amRpQoauRcejp2jEojchcKS5cCly5Rc7CNjeho9Of332ndwrp1ZCbMGIcQUePq6org4OAk14WFhcHOzi7N+zx58gQtWrSA5r8Wdjc3N+TNmxf3799P9fb29vZwdnZOcmHMS+3a9EluzRpg0iTR0TDp0agRkDOnuqegHB2VU35Sgj2CEswrX78GRo0i4VWjhuho9GfdOmDyZJombdFCdDTKRoioqVatGk6fPh3/dUBAACIjI+GaTr6tSJEiCE/0sev9+/d48+YNChcubNZYGcPo3BkYN44+daxfLzoaJi3s7KgHSs19NUraKCx3ewSlmFeOGkXlpylTREeiPxcu0PP63XdkHMxkDiGipn79+ggNDYWPjw8AYPLkyfDw8ICNjQ3evXuH2FRmTTt37oylS5fi0KFDePToEX7++WeUK1cOFeWcr7VSfv+dasM//AAk0q6MzPD0BK5epVFiNaKk8pPc7RHWr6ct1N9/LzqStPHzA/76i6ad8uUTHY1+PHtG/W2ff06xy1kwKgVhPTXLli1Dv379kCdPHmzbtg3Tpk0DALi4uODq1asp7tOkSRNMmzYNffr0Qbly5XD37l1s2rQpvhzFyAeNBli2DKhWjTr5AwJER8SkRtOm9Mav1myNkspPcrdH8PamskihQqIjSZ24OGoO/uwzoE8f0dHoR0QE9bYB9Dvo4CA2HrUg7FeoTZs2uH//Pvz8/FCzZk3kzp0bANLdLNyjRw/0UMKCBAb29vSLWqMGlTlOnaIeDkY+ZMtGwmbLFsDLS3Q0pkdp5Se5Jp2vXqUBADn3X61aRXuXjh6VrzBMjCQBvXqRmD1+XBlO50pBqPdTgQIF0LJly3hBw6iLPHmAXbuAoCCgQwfyYWHkhacnvRkEBYmOxPQopfwkd3sEnXllq1aiI0mdd+9o0V7nzkCDBqKj0Y9Zs4DVq+m5rVpVdDTqgg0tGbNSrhw1GB45Qiu/edRbXrRqRZ9st24VHYnp0Ykauf/MydkeITKS3nzlbF45dizw4QMwY4boSPRj927g11+BkSNJiMmeZcsANzdKfTZsSHP9MoZFDWN2GjcGFi0ig7a5c0VHwyTGxYXGu9XYV/PfwnJERIiNIyPkbI+wY4e8zSuvXqV9NKNHA0oYhL15k4RMmzYKsW+4fx8YPx7Yto18cEqWpAkQGcOihrEIPXtS38bgwfSHkpEPWi1l0t68ER2JaXF0pH/lXoKSsz3C8uXyNa+UJDJ9LFmSzHXlzps3JGaKFqXsVxYlvPteukQ/AF98QYF37y77cUklPK2MSpg6laahOncGLl8WHQ2jo107mh7ZuVN0JKZFKaJGrvYIOvNKuWZp/vmHthzPn097l+RMTAzQsSPw9i1ZIOTIIToiPfnkE+DwYfqDHRICLFwINGkiOqp0YVHDWIwsWWjbcLly1MuhxuZUJVKwIH0Yk/N0izHoyk9yH+uWqz2CzryyY0fRkaTk/Xtg6FDKMn71lehoMmbIEJrM2rSJLGUUwyefkGV45cpk8nf6NDBzpuio0oVFDWNRsmWjTyoaDdC6NTX4MeLx9KRP5Wp6PZSQqZGrPYLOvLJDB3maV06aRL0+s2eLjiRjli0D5s2jjFLDhqKjMZBz56hf4MwZGjPr3JkWFsm4+55FDWNxChWi35Pbt2nzcFyc6IgYrZYaavfuFR2J6VCCqJGrPcK//9KQixzXgt25QyPRI0YAxYuLjiZ9jh8Hfv6ZFgL27i06GiNYtw7o1IkWjuXMCUycSM3Duu52GcKihhFCpUq0en37dmD4cNHRMCVLUglETVNQOlEj5/KTXO0Rli+Xp3mlJNFqiMKF5b8w8tEjoH17eg4VO/UZFwe8fJnwdVgY/UKlYmUkF1jUMMJo1YrSxzNmAEuXio6G0WqpWTgqSnQkpkHXUyPnTI0c7RFCQuRrXrl9O5VJ//gjQbTKkffvadIpe3Zg40b57vhJjyVLgFfl61Gz3Zw5wN9/01RBgQLybAL7DxY1jFD696fU7M8/A4cOiY7GuvH0pDe0I0dER2IalFJ+ktv7w7p18jSvDA+n0e1mzUgwyJW4OKBbNyrf7dgBKG1hviTRYsDevYE14e0plf7HH7Sf5t07SufKWKXJ6PMBY41oNNREd/8+pWpPnwbKlxcdlXVSoQJQogR9MGvaVHQ0mUfu5SedPUKXLqIjSYpczSunTweePqVMjdwySIkZN47e97dtoyyckoiNpQ+Yf/1FQ04DB2kA/A78/rvo0PSGMzWMcGxtgQ0bgCJFqCQVHCw6IutEo6FszbZtsi6Z6429PZ2TXDM1crRH0JlXym03TUAA7bkaMkR+/UeJ2biRFvBOmkTTnUoiMpJ6gpctI2E7ZIjoiIyDRQ0jC3LmpH6O9+8TJnEYy6PVAi9eUMZM6Wg08ja1lKM9grc3kDcv0LKl6EiSMngwlXFGjRIdSdpcukRlp86dlTf88P49faDcsQPYvBn48UfRERkPixpGNhQvTlmCCxdolFTGqxBUS82a1AeolikoOYsaudkj6Mwrv/9eXht69+4lw9VZs6jxVo68eEHb0j/9lCbH5FweS87r1+TPd/YsPdft2omOKHNkWtRERUXh3r17iONlI4wJqFmTNpn+/bdCDN9URpYs9EdtyxZ1iEonJ/n21MjNHkGO5pVRUcCAAbS07ptvREeTOpGRVLaNiSHxJeeprOQ8eQLUq0flvaNHFbgcMBX0EjXjx4/H1KlTcTmZYc/KlStRqFAhlC1bFpUqVUKUWmZBGaF07EiCZswYEjeMZfH0BB4+lPV+Lb2Rc6ZGbvYI3t7yM6/84w8aIpg/X57ZD0mi6U0/P8puKsEpXMft20CdOrRF/MQJ8qxUA3pNP50/fx4vX77ErFmzYG9vjxYtWsDe3h779u3Dxo0bUalSJZQrVw7btm1Dhw4dzB0zYwWMGkWbQ3/8kcpStWuLjsh6aNiQbF62bKEliUpGrqJGbvYIT57QVNHixaIjSeDpU2q6/eUX4LPPREeTOnPnkp3E6tW0dFcp+PkBzZtT/9S+fTSkoRb0Lj/NmTMHwcHB2LdvHz799FNER0fj/PnzaNSoEVxcXNC8eXM4ODiYM1bGitBoaCFfjRpUDnnwQHRE1kPWrDS5oQaDS7mWn+Rmj7ByJeDgIC/zSi8v8oobO1Z0JKmzbx9NCP36K9m9KIUjR4BGjWh9w7//qkvQAIBGkjKunLdu3Rru7u4onshoQ5IkaNLIBw4ePNhkAZqK0NBQ5MyZEyEhIXCWo0MbkyqvXlFK3M4OOHWKMgiM+fH1pTLU7dvyHqHNiMaNgXz5aKGcnJg3j94M378Xv004Lo4sEerVA1asEBuLjmPHKGPo40M73+TGnTtA9epkgbBtG2BjIzoi/di6lYRrgwb0oUWujdfJMeT9W69fp7p16+LWrVt4+PAhbP579TQaDZLrodjYWETwLC5jQvLkAXbtImHToQOwe7esl1mqhqZNqXTj6wsMGyY6GuORa/lJTvYIOvNKHx/RkRAxMUC/fvQ7L7etxgAt1W3dmibX/v5bOYLGxwfo2ZOWnK5eTXuc1Ihev1JeXl6YNWsWvP5zEIuIiEDdunVx4cIFswbHMABQtix9qvjqK6qvL1okz6ZBNeHkROvo1SBqQkJER5ESOdkjLF8OlCpFmRo5sHAhcP06LQHMIrOlI7GxtKAuOBg4dw5QStJ/5kwq5/30E/Dnn8oRYsag149MlixZMGbMGHTo0AF//PEHPn78iEePHgEA6tWrh08++QQVKlTAJ598gnpy+c1gVEWjRrS6e8kS8lZjzI+nJ+2uePpUdCTG4+Qkv0yNzh5BDv00cjOvfPGCNvL36gVUqSI6mpT8+itw8CBtDi5VSnQ0GSNJtAjQy4uGLxYtUregAfQUNeHh4bCzs0Pt2rVx8OBBlChRIr6f5smTJ1i9ejV8fHzw5s0bLFq0yKwBM9bLjz9S1mDoUKpjM+alZUsqj2zdKjoS45Fj+UlO9gjr19MumG7dREdCjBhBP3OTJomOJCUrVgCzZ9OYeePGoqPJmNhYEofTplHcEyfKQ7iamwxFzZo1a+Du7g5bW1sMGjQIO3fuRGBgYJLbVKlSBVWrVoWdnR0+k+vsHaMKJk+mVf7ffgtcvCg6GnXj4gJ8+aWyp6AcHeU3/SQne4Tly2m0Vw7mlWfOUN/HpEnyc7Y+dYpKN//7H9C3r+hoMiYigpYV+vjQZNugQaIjshwZipqXL19i06ZN0Gg0CA8Px4wZM/Drr79aIjaGSUGWLNTk9skn1Kyn5NKIEtBqaRLl9WvRkRiHHMtPcrFH0JlX9ughNg6Asgr9+gGVK5NwkBOBgVSKrVEDWLBA/tmOsDDKsu7aRR9I5NhsbU4yFDWDBw9G3bp1ERUVhT59+mDlypWoXLly/PdjYmJQpkwZlClTBs+ePUODBg3MGjDDODkB27dTbbh1axqLZcxD27Y08rtjh+hIjEOO5Se52CPIybxy+XJaCLdggbx6Pj5+pN8BBwcyepSTJ1ZqvHpF2dULF2iPTps2oiOyPHpNP8XGxiJ//vxYvHgxHBwcEBsbi2H/jUTs3LkTcXFxyJo1K2JiYtLcXcMwpqRgQXqjrVsX6NKFPpHI6Y+hWihYEKhVi6ag5LgvJCPkKmq6dBEbQ1QUZTx/+EH8G/WbN8DIkdTXI6fN4ZJEfXx37lD5KW9e0RGlT2Ag0KQJ8PYt+Tglyj1YFXo1CtvY2ODOnTsI+W82UqPRYMd/H90+//xzVK5cGZ999hkqVaqE4OBg80XLMIn4/HNqdNy5U9ljx3LH05M+9SkxIya3jcJysUfYvp1Kij/+KDYOgKadoqOBqVNFR5KUSZOADRtI/Mmh/yk9bt0iH6eICPJxslZBAxjo0v3555+jZs2aCAkJQe3/JHVsbCzmzJkTb2bZRfRHEMaqaNmSRrxnzaJxb8b0aLXkRLx3r+hIDMfRkUaoY2JER0LIxR7B25t6RD79VGwcly6R39S4cUCBAmJjSYyvL4mt8ePp51/OXLhAGWtnZ+DkSdoObc1kKGqioqLQ8r+iq4ODA0aPHo379+8jT5488PHxQVBQENasWYNy5crh4sWLcFSS7zqjCn75hSYS+vYFDhwQHY36KFGC3oSVOAWl+3MklxLUlSu0yVWk9YTOvFJ0g7AkUXNwuXLymii6cgX47jvaYP7bb6KjSZ/Dh2mHV+nStBlaSS7h5iJDUZM1a1Y8fPgQAJWdqlWrhpw5c2Lnzp1YtmwZ3Nzc4OfnhwULFsDFxQVZ5LYCklE9Gg3tjmjShP4Q3bghOiL1odXSNEVkpOhIDEMnauRSgpKDPYJczCvXrKFelfnz5WN9EhxMzbVlytBeGjm3iG7ZQuP4tWvTQkBXV9ERyYMMFYhGo4n3ewKAM2fOwMfHB7Vr10ZUVBR69eqFli1bYvHixejfvz9CQ0PNGjDDpIatLfDPP4CbG9CqFfDypeiI1IWnJxAaSp8MlYSTE/0rp0yNyP6MuDgqPXXoIHbFf2gobbn95hua1pEDUVHkixQeTss9dT87cmT5cnoNtVoamMiWTXREyfDxAT77jByIO3emsSwLYfDnhYIFC8ZnbgCgXbt2iIiIgI2NDSRJwqVLl0wZH8PojbMzNQ3XqAG0a0dvwA4OoqNSB599BpQsSb0GzZuLjkZ/5FR+0tkjiGw7lIt55bhxtE9l5kyxcejQlcLOngWOHKEPR3Jl+nQajOjdW34j8AAobdS/P6WSypYF+vQh9XX8uEUeXq9aUUxMDF6+fAlJkuDi4oKHDx/i9evX0Gg0KFq0KNzc3OIvXH5iRFKsGH3KunSJ/GySGckzRqLRULZm61ZalKYU5FR+koM9gre3ePPK69eBuXOpX0Uu4uHPP4GlS2nYQE5j5YmRJPKeGjaMmpgXLpShoAGAVatoV0CTJkDRosCMGTSS9eaNRR5er0zNvXv3UK5cOYSEhKB06dLQaDQoUKAAevbsiXHjxuHKlSvxmZr3Spz7ZFRFjRr0e/XNN1QbHztWdETqQKulv0+nTsnH0Tkj5FR+Em2PoDOv/P13cb0ikkQf4t3dgcGDxcSQnEOHgIEDKR657mKKiSGbBm9v6h8cMEB0ROnw6hVQoULC1zrlZSEFppeo0Y1rlyhRAg8ePICtrS3evHmDHDlyAAAkScKBAwdQoUIF1KlTx3zRMoyedOhAeyZGjaLJAN40kHlq1KBlfFu2KEfUyKn85O8v1h5h/Xpq9Ba5Nn/TJioL795NU2CiuXeP/lZ4eJDxoxyJiCCvu+3b6cPad9+JjigDvviC+gCGDCFfmxUrgGrVgJw5LfLwRtWKcubMibt37wIA7t69izJlyqBHjx64fv06IiIiTBogwxjLiBG0pbR7d9rfwGSOLFkoW+Prq5yynpxEzZUrYvfT6MwrRY39fvhA2ZA2beTRlxUSQrHkzUuCT+REWlqEhgItWgB79lDpV/aCBgCGDqWO9C++oHXkU6fS3g0LYbCoefv2LRYtWoS8efNCkiSUKlUKc+bMwePHj+Hh4YGscpnNY6wejQb46y/6vWrXDrh/X3REykerBR49op4lJaArP8mhp0ak55POvLJ7dzGPDwBTptDI9Jw54mLQERtL2dugIMqA5MolOqKUBAfTZJifH7B/P011KoJcuagpeNMm+oEvV45STRbCIG368eNHFC1aFDY2NoiOjkZUVBSyZ8+OTz/9FIcOHUKLFi0QEBBgrlgZxmDs7MiIrlYt+qNw6hTg4iI6KuXSoAE9f76+9EFM7sglU6OzRxDVT+PjQxkJUW+M9+5RP9bw4bTMUTQjR1L2Y/duGtCRG48fU59tSAhw7BhQqZLoiIygUCGqVf/1l0U7mg3K1Dx//hxhYWF49+4dPnz4gIiICNy+fRvjxo2Di4sLfv75Z5QoUQJPnjwxV7wMYzC5c1OJ98UL4OuvyWeGMY6sWckZXSnbhW1sKGbRokakPYLOvPK778SZVw4cSP1YcvBoW7OGxqJnzgSaNhUdTUpu3iQfp6goGhpSkqB5/Jh6gADQVsVy5ShNbkEyNX9tY2ODfPnyoXHjxhg9ejRu3bqF2bNno0iRIqaKj2FMQpkylF04fhz4+Wfl9ITIEU9P2tp8+7boSPRDDqaWIu0RduyggRRRpaedO2kb9ezZ4hfanT0L9OxJRp4DB4qNJTXOnaMm/Fy5qA+wVCnREenPP/9QJnLKFJBV+PTpZMpnYUy6VMbGxgaenp6mPCTDmIwGDSgTumyZkN811fDVV/Tm5OsrOhL9cHQUn6kRaY+wfLk488qICBo/btJEvDHk06cUQ5UqwKJF8rNAOHiQemjKlKEliYUKiY5IP8LCSCR26gQ0awYMGgSqUb9+TVNPFoY35TFWxQ8/0FTUr7/SNAFjOI6ONL3CokZ/RNkjiDavnDmTShLz5okVEeHhVAWxtaXSqRzGyROzeTPQsiVlaQ4cUE7f3/nz1Fu3cSP1ba1bJ77pmkUNY3VMnEgeL1260GQBYzhaLaXKldA+5+gotvyks0cQ0U+zciW9gYswr3z0CJg8mT65lytn+cfXIUkk6q5fp23j+fOLiyU1li6lRaHt21N8svNxSoW4OKou1a5NIubSJfrAKIfsF4saxurIkoWWWH32GTW9KuGNWW60bEkNuErIdjk5ic3UiLJHEG1eOWQIveH9/rvlHzsx06ZRBmHlSqByZbGxJEaSaIVLr15kj7RmjbhGbkN4+pTKicOH02t88iQtOJULLGoYq8TRkT4V6aZ52N3DMHLlovq/EqagRJefRNkj6MwrRZSeDhygksrMmcB/i+eFsGMHjW+PHk3iTi5IErmUjxgBjBlDg0JKsE3cto0yjjdv0ms8dar8hJgCnkaGMQ8FCtBkxv37tBtKSUaNcsDTk944X70SHUn6iC4/ibJHEGVeGRVF/k716gGdO1v2sRNz/Tr9XrdrR8JBLsTE0CTarFnUazR2rDzKNunx8SNNjbZrR+PmV64AjRuLjip1WNQwVk2FCjSKuGsXfXJi9KdtWypx7NghOpL0EV1+EmGPoDOv7N7d8m+Y8+YBd+4ACxaIe7N+/ZosEEqUoFKzXLIgERG0K2vNGrpY0D3AaK5coSEmHx9yBt+6VZx/mT7I5KVmGHE0bw7MnUvr2xcvFh2Ncsifnz61yX0KSg7lJ0uLGlHmlc+eAePGAX37itueHB1NpaawMLJAyJ5dTBzJCQmhkef9+6mMI3eTXUmislj16rTE8sIF6v2Re1aJRQ3DAOjXjz419etHf3QY/dBq6fkKCxMdSdqIFDWi7BG8vcWYV/76Kz3f48db9nETM3AgbeLdvBkoVkxcHIl5+RJo1Ai4fJl+X1q0EB1R+rx8SZYa/fsDP/1Ek44i9hwZA4sahvmP2bNpbXqHDlSPZzJGq6WMwN69oiNJG5EbhUXYI1y7Rm9Clt4gfPw4lVSmThW3q2TxYiqRLFxo+V6itHj0CKhbl7JY//5L/5cz+/aRCD9/nnoO584FHBxER6U/LGoY5j9sbSltX6wYjSy/eCE6Ivnj7k7eNHKeghKZqRFhj+DtbXnzypgYynJWr077SkRw9ChlW3/5hawQ5MCNG1SijY2l7JGokpw+REbSiHazZiTC/f3p76DSYFHDMInIkYM+nUREUKe/6E20SsDTkxqtIyNFR5I6IkWNpe0RRJlXLlkCXL1KzcEimnIfPKAG3IYNKeMqB86epWyRqysJmpIlRUeUNrduATVrUg/NrFnkYF6woOiojINFDcMko2hRmujx9ydPk7g40RHJG62WemoOHRIdSeqILj9Z8tO5CPPK4GDgt99oH44Aqx+EhdEknosLTTKK8NdKzoEDNPJcvjxw7Jh8BYIkkRdelSok/M+eBQYPls+0mDEoOHSGMR/VqtEn3n/+oT0STNp8+iltFJXrFJSoTI0IewRvb8ubV44cSf9Onmy5x9QRF0dZqcePadLJ1dXyMSRn40Yq29SvT03BcvVxevOG+gf/978Eyxg5bVw2FmGi5tq1a6hWrRpcXFzg5eUFSZL0vu+7d+9QsGBBPHz40HwBMlZP+/bAlCnAhAkkcJjU0WgoW7NtmzwXGOpEjQF/YkyCpe0Rnj6lhm1LZmnOnSMX8IkTqY/H0vz+O4mZdesoKyKaJUvIZ6tDB/p9cHISHVHqHDtGYvvwYdpn9NdfyvCc0gchoiYyMhKtW7dGlSpVcOHCBdy4cQMrVqzQ+/5eXl54/vy5+QJkmP8YNoxKUD170nQHkzqenlSGOHlSdCQpcXSkfyMiLPu4lrZH0JlXdupkmceLi6Pm4IoVaezX0qxbR9mhadPEj0hLEsXSuzft6Fm9mixY5EZ0NAnBRo2ox8ffnz68qQpJAL6+vpKLi4v04cMHSZIk6fLly1KdOnX0uu+xY8ekfPnySblz55YCAgL0fsyQkBAJgBQSEmJMyIwVExkpSQ0bSlLu3JJ0967oaORJbKwkFSokSQMGiI4kJZs3SxIgSa9fW/ZxR4yg58QSxMZKUsmSkvT995Z5PEmSpGXL6Hk9ftxyj6nj/HlJcnCQpO++k6S4OMs/fmJiYyVp0CB6LsaNEx9PWty/L0k1a0qSjY0kTZwoSTExoiPSH0Pev4Vkavz9/VGzZk04/Zebq1ixIm7cuJHh/SIjI/HTTz9h3rx5yC6XNZGM6rGzo0VeuXNTrfztW9ERyY8sWagE5etr+TJPRugyNZbuq7GkPcLx4+RhZinzyrdvyaW5a1fL71159owmEz//nMomIjfcRkdTJvePP2jya/RoeW7cXbuWVi+8eEGTWKNG0ZZgNSJE1ISGhsLd3T3+a41GAxsbG7zN4N1i8uTJKFOmDDp27JjhY0RGRiI0NDTJhWGMxdWVRr1fvaJ0bVSU6Ijkh1ZLDZsXL4qOJCk6UWPpCShL2iMsX25Z88oxY6icN326ZR5PR0QE/ZxJEglokUvhwsPpb8Hff5No6NtXXCxpERpKjdRdu5IX1uXLNLqtZoSIGltbW9jb2ye5zsHBAR/T+atz8+ZNLF68GIsWLdLrMaZMmYKcOXPGX9zc3DIVM8PoJnxOnCDHWrllJERTvz6JP7kt4tM1a1oyU2NJewSdeeWPP1omS3DlCvDnnzQVaMlRZUkCevUisbhtm9gxaZ2P08GD1Kgs0o08Lc6coezMtm3U47NmDeDsLDoq8yNE1Li6uiI4ODjJdWFhYbBLY1uUJEno1asXJk6ciEKFCun1GCNGjEBISEj8JTAwMNNxM0z9+rTXYflyYMYM0dHIi6xZgdat5TfaLaL8ZEl7BJ15Zbdu5n8sSaLm4LJlyRfIksyaRW/O3t5A1aqWfezEvHhBS/6uXCFR07y5uFhSIzaWmpbr1gXy5QMuXaJMjdVg/haflBw6dEgqWbJk/NcPHjyQHBwcpJg0OpcePnwoAZBy5swZf9FoNFKOHDmktWvX6vWY3CjMmJJRoyRJo6EmVCaBbduoYfLmTdGRJHD3LsV05IjlHnPuXEmyt5ek6GjzP1b16pLUooX5H0eSJGntWnouDxywzOPp2LWLft9GjrTs4yYnIECSSpWSpIIFJenKFbGxpMbjx5LUoAE9V6NGSVJUlOiITIPsG4Xr16+P0NBQ+Pj4AKBeGQ8PD9jY2ODdu3eITbbsonDhwggICMDly5fjL4UKFcLu3bvRpk0bEafAWDnjx9Muiq5dgQsXREcjH5o0oX0XcsrW6MpPluypsZQ9gs680hINwmFhwNCh1Efi4WH+x9Nx8yaVd1q3pp1Rorh2jXycJIlK0BUqiIslNbZsoczg/fvAkSO0O0iOY+XmRlhPzbJly9CvXz/kyZMH27Ztw7Rp0wAALi4uuHr1aorbFy9ePMnF1tYWRYoU4SkoRghZsgArVlDPROvWAFc3CUdHSsfLqa9GVPnJEv00ljSvnDABePeOykCW4s0banB1c6OeEFHr+0+fptJz3rwkaEqUEBNHanz4QL1G7dvT/hl/f6BBA9FRiUPYRuE2bdrg/v37WLlyJW7evIlPPvkEAPXPVKpUKcP7P3z4EMWLFzdvkAyTDo6O1IRnb09vKmFhoiOSB1otZa8ePxYdCWFpUWMpewRLmlfeugXMmUOWCMWKmfexdMTE0Hbet2+pGTdHDss8bnL27aPM1KefkhN4gQJi4kiNS5fIt2nNGhpv37RJHlYRIhHq/VSgQAG0bNkSuXPnFhkGwxhN/vw06h0QQClyOdoEWJqWLSntvXWr6EgIe3uaCrJU+clS9giWMq+UJOCXX8jodehQ8z5WYoYMIRGxaZO4zMg//1AmtlEjEje5comJIzlxcSQya9Yk0X7xInk4yXFHjqVhQ0uGySSffUYmdnv30h9iaydnTnIolktfjUZjWVNLS9kjWMq80teXpnzmzrXcXphly4B58+jSsKFlHjM5ixbRB5WOHek5kIuP0/PnZAsxeDBNop05A5QrJzoq+cCihmFMQNOm9Ad47lxg4ULR0YjH0xP491/yg5IDlhY1hQoBefKY7zEsZV758SMwaBBl3yzRtwMk7IHq04culkaSqMn2559pbH3lSvk03O7eTWXNy5fp9Z81izKRTAIsahjGRPz8MzBgAP0h3LtXdDRiadOG3hx27BAdCeHoaLnykyXsEXTmlXosV88UU6dSZuCPP8z7ODoePSJBXKcOfUCwNHFxJOJ+/50ao+fMEdecnJiICGDgQBKXVavSz1jTpqKjkicyeLkYRj3MmkWbRr/5hppFrZX8+Wn5l1ymoJycLJupMaeokSQqPXXoQKU+c/HgAdkgeHmRBYO5ef+exHD27FTOtXR2JDqaFhjOm0fZ1t9+k0ePyo0bVGZctIiE3s6dtFSPSR0WNQxjQmxsgHXrAHd3Ste/eCE6InFotcCBA/KYCrNU+ckS9gj//ku7SMxdeho0iN48R4ww7+MAlCHp1o2E1Pbt5i3dpUZ4OGWI/vmHfn9FlL2SI0nA4sU03RQTA5w/T1lgOQgtOcOihmFMTI4c9GkqMhJo29by7tByQaulsePdu0VHYrnykyXsEby9KXNSv775HmP3bhIXs2bRMkVzM348NeOuXUuN95bk3Tsq5Rw+TOVSc5f09OHVK/r96dOHPL3On7fM3iM1wKKGYcyAmxv9gbxyhT6BxsWJjsjyFC8OVK4sjykoS5WfrlyhXpcyZcxz/JAQKs2Y07wyMpJ6w778Evj6a/M8RmI2bgTGjQMmTaLykyV5/pymq65dowkvOfSpHD5Movj4cVqLsHChfCavlACLGoYxE1Wr0ifPTZuA0aNFRyMGT09g1y5qdBSJpcpP5rZH+Ocf85tXzp4NPHwIzJ9v/lLHpUt0Lp07A8OHm/exkhMQQH1fL19SSa9WLcs+fnKio+k58PAgw9ArVyjTyxgGixqGMSNaLU2QTJoErFolOhrL4+lJDaCHDomNw1Kixtz2CMuXUyN64cLmOX5gII0z9+8P/Lfk3Wy8eEFv2p9+SudlyV6Rq1dpwkqjAU6etHzJKzn37lE8s2YBU6ZQL5q5XmO1w6KGYcyMlxcZDvbsSZ8IrYny5akUI3oKysnJ/D015rZH0JlXmrNBeOhQ6gkbM8Z8jwFQtsnTk7ITW7cmWFlYglOnqB8pf37aiePubrnHTo4k0Xh+5cpkB3HqFDBsGA0cMMbBooZhzIxGQ3XxevUoc3P3ruiILIdGQ29e27fTm74oLJGpMbc9grc3TQW1bm2e4x8+DGzYAMyYATg7m+cxAHoj79MH8PMjQWPJjMTevVTeqViRLBjy57fcYyfn3Tvg22+BH36g3qWLF4Fq1cTFoxZY1DCMBbCzo96avHlpgdabN6IjshxaLU1znDghLgZLiBpz2iOY27wyOpr8nerUAbp2Nf3xEzN3LuDjAyxdSvtXLMW6dSQIPTxI3Jhzx09GnDoFVKpEU2br1tHzIcqwU22wqGEYC+HiQqPeb94A7dvTG5U1ULUqUKSI2CkoS5SfzGmPsHOnec0rFywgJ+4FC8zb27J/P/mjeXmRQLMUf/4JdOlCmZHNmy1b7kpMTAyNr9erRxkqf3+gUycxsagVFjUMY0FKlaI391OngN69KRWvdrJkAdq1o/MWdb6WyNSY0x5h+XKgenXzNLQ+f049NL17U/bAXNy5QztgmjWjZlhLIEkkIvr1ozF1Hx9xPk6PHpHb97hxZMNw7BitPWBMC4sahrEw9erRm5SPDzBtmuhoLIOnJ03W+PmJeXxLlZ/MIWp05pU9epj+2AA1ptrZkdeRuXj3jko/BQsCf/9tmUbYuDgSMmPG0PTh7NnifJw2bKCfjcePScyMHWu+sX9rh59WhhFA1670yXXECMreWGLJmUjq1QNy56YpqKpVLf/45t4obE57BHOaV546RasG/voLcHU1/fEBIDaWSizBwTS9ZYleluhoasBdt46sBn76yfyPmRrv35Ow8vYmP7glS4BcucTEYi1wpoZhBDFuHP2x/+47+mOvZmxtaVusqL4aJyfqZzDXBJa57BHMaV4ZG0tlmSpVzDsm/uuvtK1340bLGGN+/Ejlzo0bgfXrxQkaPz/giy9oYaK3N8XCgsb8sKhhGEFoNFSCqlSJ3vAfPxYdkXnRaqkZ9eZNyz+2rjHUXCUoc9kjmNO8culS2ui7YIH5ykErVlDZZ84coHFj8zxGYt69A776iko8u3ZRdsTSxMXRWHytWjQaf/GieW0tmKSwqGEYgTg4JCwfa9UKCA0VHZH5aNKEzBFFZGt0osZcJShz2SN4ewMlS5revPL1a2DUKHqzrVnTtMfWceoUZUn+9z/KCJmbZ8+ABg1INB86RD9vliYoiETVr7+Sy/mpU+bzAWNSh0UNwwgmf34a2X30iMpRIpfUmRMHB6BFCzHbhXWGgObM1Ji6n0ZnXtm9u+k/5Y8aReUnc00hBQZSc3iNGuYfEweABw/Ix+n1azKCtOT+Gx3bt9PPwI0bZHMwbZp5dgox6cOihmFkwKef0hvY/v3A4MGiozEfnp7Ua2DpUps5y0/mskcwl3mlnx81Bo8fb56NurqeFgcH2glj7jf2K1doaaCNDfk4mduzKjnh4UDfvuRjVacOxePhYdkYmARY1DCMTPjqK/pUO38+/atGWrSgNzlLl6DMKWru3jWPPYK3t+nNK+PiqBT06afAzz+b7rg6JIlKWrdvA9u20QZtc3LyJJXmChakjdXFipn38ZJz9SpZG3h704K/rVvNs3yR0R8WNQwjI3r3plr8gAG0Ql1tODvTp1hLixpd+ckcPTW6ySdTiprr14GzZ03fILxqFXDmDIlmc+xJmTSJdrKsXm2+RYQ6du+mvplKlcjHKV8+8z5eYiSJnsNq1ai0dv48iURuBhYPixqGkRkzZpA/VMeOCW+YakKrpb6H4GDLPaY5MzXmsEcwh3nlu3e0aK9zZ2qoNTW+vrQpd/x4eo3Nydq1VO756itaTGhOA87kBAfTtOIvvwC9etE6BnNsemaMg0UNw8gMGxvaulqqFE1EPX8uOiLT0qYN/bt9u+Ue05yixtT2CFFRlFExtXnl2LHAhw8kmk3NlSsUb4cOwG+/mf74iZk/n5ZXdu1KJrEODuZ9vMQcOEAZuTNngB07gHnzxPlIManDooZhZEj27PRHMyaGPpGa24zRkuTLR5MqlpyCMmf5ydT2COYwr7x2jcolo0ebtkcHSMhclClDe5fMVYKRJBJm/fuTKeby5ZazGoiKIhPOr74CKlQgEdeqlWUemzEMFjUMI1OKFCFhc+0aTcDExYmOyHR4etKWWUvt5TFXpsYc9gimNq+UJCqVlCwJDBxommPqiIoii4/wcGqSzZbNtMfXERdH5zBuHI2hz5hhOR+n27dpkd7cucDMmVTuKljQMo/NGA6LGoaRMVWqUP/A5s3mT+tbknbt6A3RUs3QNjbkzmxqUWNqewSdeaUpszQbNlAj7bx5pi1n6cTS6dPUT1O0qOmOnZioKCo1LVpEo+jDh1umIVeSSGB+8QV5OJ05QxkiUaaYjH7wy8MwMqddO2D6dPqEumKF6GhMQ7FiJNgsOQVlDlNLU9sjrFpFx+vUyTTHe/+e3ojbtQOaNjXNMXX8+SeJjCVLgNq1TXtsHR8+UPl182ba2/O//5nncZLz9i1ZLPTsCXz7LVkdfPGFZR6byRzs0s0wCmDIEHL17tULKF4caNhQdESZR6sFpk6lHS+WaPZ0cjJ9psaU9gg688qvvzadeeWkSbRld/Zs0xxPx6FDVMoaNIj20piDt2+pb8Xfn3ycLLXQ7vhxoEsXICyMFmJ+/bVlHpcxDZypYRgFoNHQJ+P69akf5c4d0RFlHk9PyiQcPGiZx3N0NE/5yVT9NMePA/fuAT16mOZ4d+4As2ZRucbd3TTHBCjGDh1IZEyfbrrjJiYoiH7Wb98GDh+2jKCJiaFG6oYN6YODvz8LGiXCooZhFELWrDTCmj8/fYJ9/Vp0RJmjfHmgbFnLTUGZuvxkanuE5ctNZ14pSTQlVLgwmSuaitBQmnTKmxdYv94800f37tF03Lt3JPSqVzf9YyQnIICe98mTqRn5yBHz9Qgx5oVFDcMoiFy5aOT37VvKdERFiY4oc3h60r4aS5h4mrr8ZEp7hNBQ05pXbt8O7NsH/PGH6faoxMZSf0lQEB0/Vy7THDcx/v4kaLJmJQuE8uVN/xjJ+ftv2kr87BmJqN9+o8ZyRpmwqGEYhVGyJI3PnjlDPTaSJDoi49FqE5yVzY2py0+mtEdYv57MK7//PvPHCg+nfpdmzRIWHZqCUaOAPXuoYbdsWdMdV8fx47TpuEgR8nEyd6YkNJSe7y5dKPN5+TKNbjPKhkUNwyiQOnWoqXTlSmq2VSpVq9KbmCWmoEwtakxpj+DtTdNJRYpk/ljTp9No+Ny5pht9XrMGmDaN9rSYeooKoEbgr76iCaPDh81vhHnuHFC5Mv3crV5NaxNM1ZzNiIVFDcMolC5dgDFjgJEjqXShRDQaytZs2WL+5YJOTqbtqTGVPYLOvNIUDcIBASRyhwwx3Zj52bM02vzjj6Zf3geQYGrbljJLu3eb18cpNpZWI9SpQ2L08mXagcOoBxY1DKNgxowhg8Lvv6c3HyXi6UmZhQsXzPs45sjUmELUmNK8cvBgIHduKhWZgqdPSXRWqULL70y99G7ePPKM6taNhLk5R/ufPCFX71GjqHn6xAkq5TLqgkUNwygYjYbeFL/4gvonHj0SHZHh1K1Lb8TmLkGZUtSYyh4hKorKH6Ywr9y3j3qtZs0i77DMEh5OS/tsbCiTZm+f+WPqkCQanx4wgDyVli0zr4+Try8J0Dt3qLw1aRI1IzPqg0UNwygcB4cE351WrSznp2QqbG2p/LBli3mbnk1ZfjKVPcLOnWQImVlbhKgoGuFu2JA24WYWSaKS0/XrNOmUP3/mj6kjNhbo2xeYMIH6dKZPN5/twcePQO/elA1s0ICya2pYXMmkDYsahlEBefPSG2RgINCxo2VGpE2JVkufom/eNN9jmDJTYyp7BG9v05hX/vEHcP8+lXNMIRCmTaNR55UrqaHWVERFUS/YkiXA0qWm3aGTnMuXqWy2ahU93ubNlBFk1A2LGoZRCZ98Qsv5DhwwT0OnOfHwoJKJORfxmVLUmMIe4elTGpHObJbm6VNg/HigXz+gQoXMHQsgZ/iRI4Hff6fNwabiwwcqkfr6Uv9Mz56mO3Zi4uJI5NWoQcLTz49WH1jCBJMRD4sahlERHh7AwoVkqTB/vuho9MfBAWjRwrx9NabcKGwKewRTmVd6eVHpcezYzB0HoHLTt99SL40pjqfjzRv62Tx5koScp6fpjp2YFy+Ali3Jk6pvX2qet8QCP0Y+sKElw6iMXr2olDNwIFCiBP2RVwKenvQG//Ahee+YGlNtFNbZI3TpYvwxTGVeeewYsG4d4OOT+Q2/r19TJqVECRJcWUz0kffpU9pt8+IF2Q9UrWqa4yZn716aogJIODVrZp7HYeQNZ2oYRoVMm0Yjwp06JTS1yp3mzWkCaOtW8xxfV37KbDOyKewRdOaVmSk9xcRQyalmzcxvIo6OplJTaCiwbZtppqcAeq7q1qXjHj9uHkETGUmZmebNqYfmyhUWNNYMixqGUSE2NrQltXRpmoh69kx0RBnj7Ex7RMzVV6PzQIqIyNxxTGGP4O1NO1IaNDD+GAsXUrlowYLMZ1UGDiTRsWWL6bJkly6RoHFwoLJTuXKmOW5ibt6k3pmFC6mPZtcu005qMcqDRQ3DqJRs2ajpMzaWygqm3KZrLrRaWor24oXpj+3kRP9mtgSVWXsEnXnljz8a37z64gU18vbqRdmJzLB4MYmChQuBevUydywd//5Lo9NFi5JYcnMzzXF1SBJNNFWpQhNV587RzhtuBmZY1DCMiilcmEa9b9ygBW/mtiLILG3a0BvT9u2mP7YuU5NZUZNZe4R//qFska7/wxhGjKDJq0mTjD8GABw9CvzyC13+97/MHUvHjh3UQ1O1Ki26M4U3VmJevwbat6f9M9260SZqU2x2ZtQBixqGUTmVK1Mzqa+v6dbnm4u8eYH69c0zBWUqUZNZe4TlyzNnXnnmDDUGT5qUub0rDx5Qo3KDBsDs2cYfJzGrVlG2rUUL8nHKkcM0x9Vx5Ag998eO0c/IokUJGTiGAVjUMIxV0KYNOSxPnUr9HHJGqwUOHgRCQkx7XN2bX2bKcJm1R8iseWVsLDUHV66cucxKWBhtcXZxATZsMI1FwZw5lDn58Uc6piltFaKjaXdO48a08PDKFRo7Z5jksKhhGCth0CDgp5/ocuSI6GjSRqulN7Hdu017XFNkajJrj5BZ80pvb1omt2ABNYMbQ1wclSIfPaIyn6urccfRIUnAb7+RmeawYcBffxkfW2rcv08NxzNmAJMn03LJwoVNd3xGXbCoYRgrQaOhhXyNGtFOmNu3RUeUOm5u1I9h6ikoU4kaY+0RdOaVXbsaZ1755g310nz/PVC7tuH31zF6NImZ9eszv5guNhbo04dKYTNmUCbQVM26kkTPV6VK1Edz8iQwfLhpBROjPljUMIwVkTUrlQYKFqSlfK9eiY4odTw9aYGaqWwNgARRk5nyU2bsEXTmlcaWnn7/nYTRtGnG3R8gITNpEh2jRQvjjwPQfpjOncnDydsbGDo0c8dLTEgIib/vv6em4EuXyCOLYTKCRQ3DWBm5ctE+j9BQEg+RkaIjSolWS15BBw6Y7pimGOnOjD2CtzdQrZpx5pWXLtHo9bhxQIECxj2+nx/1u3z3XeYFyPv3VELbvp2MIn/8MXPHS8zp05Sd2bmTTDVXrDB9wzGjXljUMIwV4u5Om3vPnaOG08xu2TU15cpRacSUU1CZLT/p7BGM6acJCqLMkzFZGkmi5uBy5ehfY3j2jBqDK1aknpfMlIhevyYfpzNn6JxM1bAbGwtMmEC7cgoWJJftzp1Nc2zGemDvJ4axUmrXptHgb78FypaV37i3VkvZiZgY00zn2NvTm7mx5afM2COsXGm8eeWaNcCpU8ChQ1Q+NJSICHouJYmErIOD4cfQ8fQp8NVXwMuX1Gye2cV/Oh4/pnLTyZPUdPz776Z5zRnrgzM1DGPFdO5MJY3ffqOlcHLC05OaY//91zTH02gS/J+MwdjJp8yYV4aGkgv3N98AX35p2H11j92rF/UCbdtGGRBjuXMHqFOHSk8nTphO0GzaRM/pw4e0DHDcOBY0jPEIEzXXrl1DtWrV4OLiAi8vL0h65L/HjRsHV1dX2NvbQ6vVIiwszAKRMoy6+f13+pTcrRuVFOTCF1/Qmn1TTkFlRtT4+9MosaEL7zJjXjluHO2UmTnT8PsCwKxZNEHk7Z05M8mLF2ms2smJBE3ZssYfS8eHD0DPnmSk2aQJPb+msmlgrBchoiYyMhKtW7dGlSpVcOHCBdy4cQMrVqxI9z5r167F2rVrsXfvXly/fh03b97E1KlTLRMww6gYjQZYtoze9Nq2pU/MckCjobLJ1q2ms3fIbKbGmNKTseaV168Dc+dSFs0Y76Tdu4Fff6Ux8Mz0phw9Sj5OxYtT1swUPk4XL5JoXb+enp9//qFFgAyTWYSImj179iAkJASzZ89GyZIlMXnyZCxfvjzd+wQGBmLlypWoXr06SpUqhY4dO+LSpUsWiphh1I29PTXlZs9Ort6m3uZrLFot9XGcP2+a4zk5Gd9TY4w9grHmlZIE9O9PDd2DBxv2mAC5V3fuTK/lxImG31/Htm1As2bkhH3oUOZ9nOLiKOtUsyZNNF28mDljT4ZJjhBR4+/vj5o1a8LpvxnLihUr4saNG+neZ/jw4ahVq1b817dv30bp0qXTvH1kZCRCQ0OTXBiGSZu8eWnU+8kT6uGIiREdEZU88uY13RSUsZkaY+0RjDWv3LyZzCDnzTPcbuDtW7LFcHMD1q4Fshj5V37FCtoR07o1jVdndqz62TMSSF5ewMCB1PxszBJDhkkPIaImNDQU7u7u8V9rNBrY2Njg7du3et3/zp078PX1Ra9evdK8zZQpU5AzZ874i5spcqYMo3LKlUt4Q+3fX/yot40NvUFv2WKaWIwVNcY2CXt7G25e+eEDZWdatwaaNzfs8WJiSJC+eUM7ZIwVIrNnUwalRw8qEWXWx2nnThKEV68C+/cD06cbt1WZYTJCiKixtbWFfbLfEgcHB3zUIy8cFxeH7t27o2fPnvj000/TvN2IESMQEhISfwkMDMx03AxjDTRuDCxcSA7I8+aJjoamoO7eBTJI5uqFseUnY+wRbtygxmtDG4SnTKGR6TlzDLsfAAwZQj0wmzYBJUoYfn9JIuPIIUOoF2fx4szZEoSHA7/8QgKtZk16Hps0Mf54DJMRQgbnXF1dce3atSTXhYWFwU4P6T5hwgS8efMGM2bMSPd29vb2KYQTwzD68b//kZAYNIjeHI01YDQFjRtTxmHLFrIoyAzGZmqMsUfQmVe2aaP/fe7dIw+lYcOoudgQli0jEbpwIfl7GYrOx2npUup7GTLE8GMk5to16uu5e5cMOH/+mXtnGPMjJFNTrVo1nD59Ov7rgIAAREZGwjUDu9gdO3Zg9uzZ2Lx5c3w/DsMw5mHqVJqG6tyZtruKwt6efKpM0VeTmfKTIf00UVHAqlWGm1cOHEg2CMOHGxbfiRMkGvr0oYuhREbSYkBvb+qlyYygkSQSVtWq0dcXLgB9+7KgYSyDEFFTv359hIaGwsfHBwAwefJkeHh4wMbGBu/evUNsbGyK+9y8eROdO3fG/Pnz4ebmhvfv3+tVrmIYxjiyZKFttmXLUqYmKEhcLFot+R8FBGTuOI6OhpefjLFH2LXLcPPKnTvpfnPmJPhU6cOjR1Siq1OHRsAN5f17mpLasYOyYYY2NSfm1SsSwn370g6ac+eM87piGGMR1lOzbNky9OvXD3ny5MG2bdsw7T/rWRcXF1y9ejXFff766y98+PAB3bp1Q44cOZAjRw588sknlg6dYayKbNnozU6SqIzy4YOYOJo3p4zN1q2ZO46Tk+GZGmPsEZYvN8y8MiICGDCA+k20Wv0f5/17EhHZs9PouKE2Cq9eUXnv7Flg3z7DSmXJOXiQnqPTp+lnZv78BL8thrEUwjYKt2nTBvfv38fKlStx8+bNeIEiSRIqVaqU4vZz5syBJElJLg/lsiWMYVRMoUKURbh1i8opplqEZwg5ctAbfma3CxtTfjJ08klnXmlIg/DMmeR/NG+e/mWauDjKqty/T5NOhu6QefIEqF+fsl/Hjhm+HFBHVBQt+WvShETclSuU+WEYEQj1fipQoABatmyJ3IbuHWcYxqJUqgSsW0fL2EaMEBODpycZHr54YfwxjCk/GWqPsHIl9dHou8X30SNg8mRqyi5XTv+4xo+nPqO1aw0v8dy+TeWqjx+pH6dyZcPur+POHTJG/eMPanDeuzdz/lIMk1nY0JJhGL1o3Zr2l0yfTpM2Ih5foyFhZSzGlJ8MaRI2xrxyyBAgVy7y4NKXjRvJF2riRMNLRn5+tNQwe3YSicYswNOdZ+XKtDX59Glg6FDjF/0xjKngH0GGYfRmwICECZtDhyz72HnyUIkkM1NQxpSfDLFHOHGCxrL1bRA+eJCWHc6cqf+ivEuXqOzUubPhWbMjR2jcu2RJ8nEqXNiw+wPAu3c0KdWjB8Vw8aLpHLsZJrOwqGEYRm80Gur7+PJLykbcumXZx9dqSUwZ601lqKgx1B5h+XLa61O/fsa3jYqixXT16ulfqnrxghqDP/mEHsuQMemtW8mmoGZNElPGVP1PnCCBt38/sGEDZeyyZzf8OAxjLljUmJJr12jkwcWFDE5E75hnGDNga0tvaIUK0f6YV68s99jt2gHR0TT6bAxOTnR/fX2tDGkS1plXdu+uXxlm/nzqSZk/Xz9xEhlJfUXR0VSCM2SyyMeHfJzataPJJEOFSEwMMGYMZcqKFaPsVYcOhh2DYSwBixpTERlJRf8qVWjb1I0btMWKYVRIzpwkLN6/p+xJZKRlHtfNjT43GDsFpRMC+mZrDLFHMMS88tkzYOxYWpinj2CSJLqtnx9lXAwpG82cSULrf/8D/v7bcB+nhw9JzEyaRDEfOQIULWrYMRjGUrCoMRV79lBOfPZsKlhPnkz5YYZRKcWLU8bg/HlatGapxKSnJ/26GbMZ2FBRY4g9giHmlb/+Cjg40ASTPsydS8dfuhSoUUO/+0gSbSb28gJ++428vAz1cVq/nkRXUBD14Pz+e+a8oBjG3LCoMRX+/lSs1q0CrVjRNA58DCNjatakEeY1a2gSxxJotTSKvH+/4ffV/XrqO9bt769fP40h5pXHj9PzNXUqVaozYv9+mpDy8gK++y7j2wPk49SrFzBtGm0onjDBsP6bsDDghx+o16dlS7LJqF1b//szjChY1JiK0FDA3T3ha42GPtK8fSsuJoaxAB070pvm6NG0y8bclC1LjbLGTEEZkqmJiQGuX9evPOTtTY23GRl/xsQA/fpRCe3HHzM+7p079Pw2a0bu3foQEQF88w310axcSX5ShnDuHI1qb95M91+7Vv/xdIYRDYsaU2Frm7JY7eBg+KYvhlEgo0ZRFuHHH4FTp8z/eFotbdGNjjbsfoaIGn3tEXTmld99l3G/ypIlwNWrwJ9/ZtxM/O4d7aApWJB6YfQp+4SFUWZl924Sfd9/n/F9dMTFUfaoTh3A1ZVGx7//no0oGWXBosZUuLqSg11iwsIMs+hlGIWi0VC/R/XqNGGTWePJjPD0pCTosWOG3U8navT5rKHv5JPOvDKj0lNwMPW29OiR4GCdFrGxVPp5+ZLEmz6ZkuBgGrW/cIF8nDLKGiXm6VOyORg5kspcJ08CpUrpf3+GkQssakzAu3eAVLUardXUERBAIyGursLiYhhLYm9PU0nOzpQtePfOfI9VuTKNFhtagtL11OiTqdHXHsHbm0RKhQrp327kSPp38uSMH3vYMODAARqd10dcPH5M+24ePyahp8+eHB1bt1I26vZt2gE0ebLhxpgMIxdY1JiARo2Agh3r411gKDa38sGWLUDYyMmQPDx4VICxKvLkoczFs2fU12FoeUhfNBoqQfn6GmawaUj5SR97hKAgKvVklKU5d46GISdOBPLmTf+2K1cCs2ZRg6+HR8Zx3rpFJaPISFqOl4ofcKp8/EibobVaEkH+/vS3jGGUDIsaEzBlCtDnF1ss+HwZmu/uh/rt8yB8/TbUPTENzZpRv8GWLWRcx/v4GLVTtiz9vB85QhtzzfUzr9WSeDp3Tv/7GFJ+0sceYdWqjM0r4+KoObhiReCnn9I/3qlTNLXUsyfdJyPOnycfp5w5qWRUunTG9wHo3KpWJQG1ZAm9XuwrzKgBPbYvMBnRrBldMKYN8Pw+Ig74wc+mJr66mxt+frSDT5dyzpMH+OIL+oNSpQpdihblZjxGXTRqBCxeTG/OZcuSA7WpqVOHsh5bttBouT7om6nRxx5BX/PKFStIfPz7b/r7bgIDqVeoenVqJM7ob8KhQ9S/9NlnlB3Tp9ItSWRz8euvQPnytMyvfPmM78cwSoFFjakpUACu37VEUwBNE1397Bn9AdFdEgud3LlJ3LDQYdREjx40QTRkCO2jNNRNOiNsbMgHydeX9rHo8/tia0v9IhmJGn2ahE+coPNbsiTt27x9SwvwunShnpe0+PiRBIq9PY1SZzRfsGULZYcaNaLbZ8uW/u0Bajr+4QdaXDhwIGWYHRwyvh/DKAkWNRaiYEGgVSu66NBH6CQWOyx0GKUxeTK98X/7LS2dq1zZtMf39CRTxWvXMm7U1aGPqaU+9gg688oGDdK+zZgx9FjTp6d9G0miUfjbt6mElC9f+rEtW0ZlrA4dEspfGbFvH9k3SBL1ADVvnvF9GEaJsKgRSGpC5/lzEjgXLtC/K1cmLN1iocMojSxZgNWr6Y2/dWvg7FnDfIsy4ssvgRw5KFujr6hxcsq4pyYjewSdeeWIEWnvm7lyhcpI06aR+WdaTJpEU06bN2fcwzN9Ok1G9elDRpgZzSFERtLU1ezZVCJfsQLInz/9+zCMktFIknW0roaGhiJnzpwICQmBs7Oz6HAMIrnQ8fOjqQsgqdDRiR0WOozcePaMekXy5qWMjT7lEn359luyKbh8Wb/blygBdOqU/mh11aokknx8Uv/+smXU0Pv4cepeT5JEQi44mARSWtkUX1/KNo0bRxuZ00KSSMzMmEG3Gzs249/xW7eoRHXjBgmr/v31cw9nGLlhyPs3Z2oUQIECtPejZcuE6/TN6LDQYeRAwYLAzp00qdOlC2UlTLXtwNOT7BkePCDBkhEZlZ909ghdu6Z9m+XL0zevXLeOxNv+/WkLmitXaAtxhw5kFJlePD/9RE3Jc+eSOEkPSSLRNWAA7fI5e1b/MW+GUTosahRKekJHJ3bSEzpVqtAfPBY6jKX4/HNyfW7ThppnZ8wwzXGbNaP+F19fakrOiIzKTxnZI+jMKzduTP37YWHA0KFA+/a0pTc1goPpeShdmrJBaf0eRkRQtmXHDjLB7NIl7bgBmtr63/+okfinn6jspFs4yDDWAIsaFcFCh5E7LVvSUrkBA+gNvVevzB8ze3bKmugrajLK1GQ0+ZSReeWECbRNedas1L8fFUVj4OHhNOadVikuNJQmok6fBrZtS/p7nRpHj1J2KTycRI1Wm/7tGUaNsKhRORkJnYxKVyx0GFPzyy/kPv3zz1Qu0mdrbkZotbTV9/lz+plPj4xETXr2CNHR6ZtX3rpFom3MGPq9SY4k0fmfPk3LCYsWTT2G4GCaULp3j+wS6tZNO97oaOqxmTKF+nhWr067LMYwaocbhRkAKYXOhQtpNyOz0GEyS0wMZTpOn6ZLZhfAvX5NUz1//pnx1t527UgI7NqV+vdbtaItwLt3p/yerrH3ypWU01aSBHz1FfX2XL+e+g6YP/+kTcHe3jTGnRqPH1PZKiSERrHTm4h68IAapS9coAzRr7+yMwujPgx5/2ZRw6RJcqHj50duvgAJneSbkVnoMIYQGkpbgT98oGbWjDyRMqJxYxrB3rcv/dt9+y39bB8+nPr33dyojKPLXiamdWu67/nzKb+3ZQv10ezYkXRNg45Dh6hM1r8/9bqkxs2bJIyyZqUMTcmSaZ/HmjWU7cqbF/j7b6BGjbRvyzBKhkVNKrCoMQ0sdBhT8ugRjXqXKkVv+pnZcPvnn7QpNzgYyJUr7dv16EHNvqdPp/zemzf0c/z33yn9nIKCSPD8+SfQu3fS7338CHzyCe22SS0DdO8enWf16jQFltr+m3PngBYtaKfNvn00MZYaoaEkZtauBb7/nvbV8J80Rs3wSDdjNvTp0Vm1KmmPDgsdJi2KFQO2bwcaNiSxsWaN8T8b7dpRaWfnzvTHsR0d055+Sq9JWLe9t1OnlN+bNo128Rw4kPJ7oaE06ZQ3L01/pSZoDh6k+D//nOJ3cUk9vjNnKNP0+jWJmm+/Tf12DGOtsKhhMo2xQifxZmQWOtZLjRrUrN6xI9kSjBlj3HEKF6Zj+fqmL2qcnNJuFE7LHiGxeWXyLNCDByRqhg5N6ZIdG0vCIyiISmypZZA2baJR7caNaUw8tWmo2Fj6/Rk7FqhWjbJa7u5pnyPDWCssahizoI/QWb0amDqVvufqmtICgoWO9fDNN1SiGTWKhIGxGQitlrbzfvyY9n6W9Kaf0rJHSM+8ctAgysKMHJnye6NGkYHk7t3kVp6cpUupsblzZ7IwyJo15W0CA0mknThBxxs9On23b4axZvhXg7EYqQmdFy+SbkZOS+joxA4LHfUyYgSNev/4I73OdeoYfgytlhb77d9P5ZzUyEjUpLZ0z9s7dfPK3bupfLZhQ8oMy5o1lMGZNYsahBMjSfS9ESOoZDZ3buoWBps3Az17kr/VkSNA/fqpx80wzH9IVkJISIgEQAoJCREdCpMBz59L0q5dkjRunCS1aSNJhQtLEr0NSJKrqyQ1aSJJw4dL0saNkhQQIElxcaIjZkxFZKQk1a8vSXnySNL9+8Yd49NPJem779L+/ty5kuTomPL66GhJcnCQpDlzkl4fEiJJTk6SNGFC0usjIiSpVClJ+vLLlD+DZ89Kkr29JP3wQ8rvxcVJ0pAh9PM8dmzqP7/v30vS//5Ht/n6a0l68ybt82EYtWPI+zdnahjZkT8/TYG0aJFwnS6jo8vqpJfRqVIFKF6cMzpKxM6ORqNr1qSM3unT6U8ypYanJ00ERUenXs7RZWokKenPSFr2CBs20O27dUt6/ezZwMOHtO038XGePqUs0RdfAIsXJ/1eTAzZGKxYQTH265cyvkuXqBwVGEgeTt27888yw+gLj3QziiW50Ek8Xs5CR9ncuUPCpkoVKvGkJk7S4tIlEhT796fuvbRmDW0EDg9POkL+zz802fTqVdJtwrVqkbDasyfhusBAoFw5Gu1ObIcQHk4lIt0um8TbjSMi6Pi7dlFjdPK+obg44I8/qHz22WdkiplaHw7DWBs80s1YBRlldDLq0WGhI1/KlKGMzVdfAX37UoOuvq9TpUr0uvr6pi5qdA3EHz8mFTWp2SPozCs3bEh6jKFDqc8l8aSWJFH/y/Xr1NSbWNCEhABt29Iumm3bkv7MAiSCunUjITZ0KDBxYuo2DAzDpA+LGkZVsNBRDw0bkpjp3p0yFvqYVQL02mm1tBNmwYKUDbiOjvRv8mbhK1dSlp58fEjktGmTcN3hwyRyVq1KuvRu2jRa2vfPP5Qp0vHyJTmJBwTQHpvkDdC7dlFztI1N2tklhmH0g0UNo3r0ETpr1iQVOskXBrLQEcOPP1Kvi5cXWQakNdGUHE9PMpY8e5bKR4lJS9T4+yfdb6Mzr+zaNSFrEh1NhpR16iS97Y4dNNL9++80nq7j0SMSKWFhwLFjSUVTRAR5Nc2fT7YK3t6Zt4pgGGuHRQ1jlbDQUQ4TJ5Kw6dIFOH48aRYkLWrVAvLloxJWWqIm8VbhN2+AJ0+Sio5duyjL0qNHwnULFpA/k59fwmt//Tr1x7RrR8vxdNy4QeUze3vg5EkaCddx/To1A9+5Q8f8+Wf+WWIYU8CNwgyTDsmFjp8fvfkBCUIn8cJAFjrm4eNHKkc9fUrZlyJFMr7PTz/R5t27d5O+Jlevkng5cybBBPLoUaBRIxIbn3xC1yU3r3z+nMpgXboACxfSda9fk59T9uwkXLJnp+vPniXBXKQIsHdvgo+TJNFE1ODBlHlaty6l2zfDMEnhRmGGMRH6ZHTWrqV+CoCFjrlwcqIldzVqkNg4fjxBQKSFVgv89VeCiNGRWvkpuT1CUBBNXf35Z8Jthg+nKayJE+nr6GigQwfydjp0KCGeAwfosStVIh8n3Uj6q1eU9dm+nZqfZ8xIiIVhGNPAooZhDISFjhgKFCCRUKcOZUu2bKHm2rT48ktq5PX1TV3UJC4/JbdHSG5eeeoUjWEvWUKvJ0CO4MePk6ApXpyu27iRYmvShP6vm7Q6dIjGyKOiaPopceMxwzCmg8tPDGMmXrwALl5M2KGTVulKJ3ZY6OjHnj3UWDtwYNIdManRpQtw7RqJFh1v39Lzv2kT0L49XVe1KpWBfHyoRFS2LJWV1qwhM8lq1WiK6uxZElKLFwN9+lAm6H//o2MsXky9Md9+S8fJmpVEzOjRwPTpJLJWrQIKFTLL08IwqsWg92+z7jaWEWyTwMiBFy8kafduSRo/XpLatpWkIkUSLCBcXCTJw0OShg2TpA0bJOnBA7aASIv58+k5W7w4/dtt2kS3u3cv4brwcLpu9Wr6Ork9wr//0vcPH6avFy2ir0+fpq+PHJEkW1tJ6tePvo6Lk6SJE+k2v/wiSbGxdP2dO5JUtSrddvr0hOsZhjEMtklgGJmSLx/QvDlddLx8mXQzcuLSlYtLyj067u6c0enXjyaH+valqaK0drs0a0YL9nx9aakdQL0zGk1CT01yewRvb3qOGzSgRuBRo2i0vGZN2jXz9df0vTlzaAvw0KH0//Hjgd9+o2OsWEExFipEVg9Vq5r16WAY5j+4/MQwMiS50ElcumKhQ8TEUG/KyZMkHHRTS8lp1w4IDqbb6ciWDZg8GRgwIKk9gp0d9e6MGEECpXdvWuJ3+zb1x9SuTWLo3DnaKNyzJy1z1I1lv3tH9/nnH1oaOHduxg3NDMOkD08/MYzC4YxOxtjakuCoW5fML8+epectOVot8MMPwLNnCaPVOlNLIKk9wrJlCeaVfn7UM/PHH7QUz9OTlumdOUP3b9+e+nv+/ptE0cmT1MPz7h2JmsRL+BiGsQwsahhGIWQkdJJPXVmD0HF2pomo6tUpI3P4cFI/J4BGwG1saOqod2+6LrGoSWyP4O0NNG1KIuebb2gi6uefqdl3+3baHFy4MN3Gz4++9vAAxo2j8lPt2rQ5uFgxiz0FDMMkgstPDKMykgudCxeSlq6Sb0ZWg9A5d476XNq1o8xJ8vPx8KDppf376euyZal0NWMG4OZGlgfff08lrA0bgA8fqI/m6FHK8HTuTGKxWzfq03n0iDYOFypE2ZnTp8nccuTIhLFwhmFMA5efGMaK0Sej8/ffSTM6Shc61atTb0uHDrRAb9y4pN/39KT+mbdv6Xx1mZrE9gje3lSCatCAxrs7daJ+mB9/JNHToQOVuj58AP79l7YPN29Oy/X+/TelUSXDMJaHMzUMY6UkFzp+fkBgIH1PJ3QSLwxUgtCZOpWafFevTmo4+fQpWRasWkVL8GrVoqzMd9+RPcLly+TT1LkznePSpVRGatuWyk0LF1Jmx9GRJqlmz6YJp06dgEWLErYGMwxjejhTwzBMhuiT0Vm3jhbHAcoQOsOG0ah3jx60zLBuXbq+cGEayfb1JSHj6EgbhXX2CPfu0bnXqwd07EjGlH370gah336jkfGiRUk0eXqSD9TKlXQsOZ0/w1g7nKlhGCZd9M3o6MSOaKETFUVZl2vXaCKqZEm6fvp0EiuvXlETsK0tlZsuXybRExREY9pPn1I5a/NmKtGNGEHn6OFBvk+VKpHYK1VK3DkyjDVhyPs3ixqGYQzm5cuUFhByEjpv3lBmJksWauJ1caEle2XKkGfU33+TEeXr1yR6Nm+mJmBvb9o9s2wZLc9bsoR6bGJjqWl42DDq17Gzs9y5MIy1w6ImFVjUMIx5kZvQuXuXhE2lSsDeveTFVKECfa3RAA8eUIweHuSsnTs3lZjOnqVMz/79JGiuXqUS1erV5N/EMIxlYVGTCixqGMbyGCJ0qlQhywNTCp1//yXR8v331Pw7dixt+e3QgZy3b9ygBmJnZ+qryZqVvr59myairlyhZuHly0n0MAxjeVjUpAKLGoaRBzqhk9gCwpxCZ+VK2ig8fTo1/FauTFuGz52j/hmAlvM5O9PjvHlDTdShoeTp9NNP3AzMMCLh6SeGYWRLvny0wK5Zs4TrgoOTLgtMPHWVK1fKzciGCJ1u3agUNWwY9c+4u5Mx5fv3NAWl80l//x6IjqYG4gIFgCNH0vaTYhhGnmQR9cDXrl1DtWrV4OLiAi8vL+iTMNq0aROKFSuGQoUKYd26dRaIkmEYS5A3L4mcUaNo7PrxY8ro7NlDLtjOziR0OnakqSNXVyorDRtGG4Dv3ydhkhbjx5O7dteuZGVw9y6NdEdGkkN3ZCQZZAI0yn32LAsahlEiQspPkZGRKFeuHJo2bQovLy/0798fX3/9NX788cc073Pt2jVUqVIFf/75J2rUqAFPT0/s3LkTZcuW1esxufzEMMoncUZHl9XRla5y5Uq5GTlxRic8nBbt3btHU0/JyZmTpqJatLDY6TAMowey76nZunUrunfvjidPnsDJyQn+/v7o27cvTpw4keZ9Bg4ciFu3bmHv3r0AgLlz5yI4OBgTJ07U6zFZ1DCMOkkudPz8KNMDpBQ6xYrRjprAwKSZnRo1gK1bqezEMIy8kH1Pjb+/P2rWrAknJycAQMWKFXHjxo0M79M80erT6tWrY/z48WnePjIyEpGRkfFfh4aGZjJqhmHkiK50lVaPjp8fsH59Qo9OjhxJBc3QobRkL4uwYjzDMKZCiKgJDQ2Fu7t7/NcajQY2NjZ4+/YtXFxc9LqPs7MzgoKC0nyMKVOmYFxyVzuGYayCjITO6NFAXBzg5ZUgdhiGUT5CPpvY2trC3t4+yXUODg74+PGj3vfJ6PYjRoxASEhI/CVQV3hnGMYqSdyMHBNDIocFDcOoCyGZGldXV1y7di3JdWFhYbBLZ/e4q6srgoOD9b69vb19CuHEMAwDUPNwnjyio2AYxtQIydRUq1YNp0+fjv86ICAAkZGRcHV11fs+ly5dQuHChc0aJ8MwDMMwykGIqKlfvz5CQ0Ph4+MDAJg8eTI8PDxgY2ODd+/eITY2NsV92rdvj/Xr1+Pq1at4//495s2bh6ZNm1o6dIZhGIZhZIqwnpply5ahX79+yJMnD7Zt24Zp06YBAFxcXHD16tUU9/n8888xYMAAVK1aFYULF4aNjQ1+/vlnS4fOMAzDMIxMEer99Pz5c/j5+aFmzZrIradb3I0bN/D06VM0aNAg3Z6a5PCeGoZhGIZRHrJfvicCFjUMwzAMozwMef/mdVMMwzAMw6gCFjUMwzAMw6gCFjUMwzAMw6gCFjUMwzAMw6gCFjUMwzAMw6gCFjUMwzAMw6gCFjUMwzAMw6gCFjUMwzAMw6gCIS7dItDtGAwNDRUcCcMwDMMw+qJ739ZnV7DViJqwsDAAgJubm+BIGIZhGIYxlLCwMOTMmTPd21iNTUJcXByCgoKQI0cOaDSaTB8vNDQUbm5uCAwMtArbBT5fdcPnq274fNWN2s9XkiSEhYWhUKFCyJIl/a4Zq8nUZMmSBUWKFDH5cZ2dnVX5Q5QWfL7qhs9X3fD5qhs1n29GGRod3CjMMAzDMIwqYFHDMAzDMIwqYFFjJPb29hgzZgzs7e1Fh2IR+HzVDZ+vuuHzVTfWdr7pYTWNwgzDMAzDqBvO1DAMwzAMowpY1DAMwzAMowpY1DAMwzAMowpY1DAMwzAMowpY1KTBq1ev4O7ujocPH+p9n2PHjqF8+fLIkycPZs+eneR7mzZtQrFixVCoUCGsW7fOxNFmjmvXrqFatWpwcXGBl5eXXv4aP/zwAzQaTYrLw4cPIUkScuXKleT6iRMnWuBM9MOY8wWAihUrJjmnnj17xn9Pba8vAIwbNw6urq6wt7eHVquNtxoB0n8uRGHMeab3uv3555/Inz8/SpQogcOHD5srbKMx5nyV9pomxpjzVervLGD4+Sr5b7JJkZgUBAcHSzVq1JAASAEBAXrd5+XLl5Kzs7M0btw46c6dO9IXX3whHT58WJIkSbp69apkZ2cnLV26VLpy5YpUqlQp6datW2Y8A/2JiIiQihcvLv3000/SvXv3pBYtWkje3t4Z3u/Dhw/S27dv4y+7d++WSpcuLcXExEi3b9+WihUrluT7ERERFjibjMnM+To5OUkvX76MP6ePHz9KkqTO13fNmjVS6dKlpbNnz0p3796VypYtK40cOVKSpPSfC1EYc57pvW579+6VHBwcpK1bt0onT56U3N3dpVevXlniVPTCmPNV2muaGGPOV6m/s5Jk/Pkq8W+yqWFRkwqNGzeW5s6da5ComTNnjlSuXDkpLi5OkiRJ2rp1q9SlSxdJkiRpwIABUtOmTeNv+8cff0ijRo0yedzG4OvrK7m4uEgfPnyQJEmSLl++LNWpU8fg4zRp0kRau3atJEn0x7NTp04mjdNUGHu+J06ckGrWrJnq99T4+k6ZMkU6depU/NejR4+WmjdvLklS+s+FKIw5z/Ret7Zt20o//fRT/PcGDhwoLV261AyRG4cx56u01zQxxpyvUn9nJck0f5eV8jfZ1HD5KRWWLl2K/v37G3Qff39/NGrUKN4ss3r16vDz84v/3pdffhl/28TfE42/vz9q1qwJJycnAJSuvXHjhkHHOH/+PAICAtCpUycAwLlz53Du3DnkypUL+fLlw2+//aZ3ycPcGHu+586dw5MnT5A3b17kypULffr0QWRkZPwx1fb6Dh8+HLVq1Yr/+vbt2yhdujSA9J8LURhznum9bnJ+TQHjzldpr2lijDlfpf7OApn/u6ykv8mmxmpFTbt27ZArV64UlwULFsDd3d3g44WGhia5n7OzM4KCgjL8nqVI63znzZuXJDaNRgMbGxu8fftW72PPnz8fffr0iXdPvXPnDlq3bo1Lly7h77//xuLFi/HPP/+Y/JzSw9Tne/v2bdStWxcnTpzAvn37cODAAcyZMweA+l/fO3fuwNfXF7169QKQ/nMhiuSvgT7nKfff2fQw5nwTo4TXNDHGnK/cf2fTI7Ovrxz/JlsKq3HpTs6SJUsQHh6e4npXV1ejjmdra5tkRbWDgwM+fvyY4fcsRVrnO3fu3Pjskg5dfC4uLhke982bN9i2bRvmzp0bf92ePXvi/+/u7o7+/ftj06ZN8Z8aLIGpz3fx4sVJvh49ejTmzZuH4cOHq/r1jYuLQ/fu3dGzZ098+umnANJ/LkSR/DUAMj5Puf/Opocx56tDKa9pYow5X7n/zqZHZl5fuf5NthRWK2ry589v0uO5uroiODg4/uuwsDDY2dll+D1Lkdb5FihQANeuXUtynSHxbdmyBfXq1Uv3Fy1fvnx4+vSp/sGaAHOdr47E56Tm13fChAl48+YNZsyYkeZtRLy+yXF1dTX4POX+O5sexpyvDqW8ponJzPnqkNvvbHpk5nzl+jfZUlht+cnUVKtWDadPn47/+tKlSyhcuHCG3xNN8tgCAgIQGRmpd8Zqw4YN8PT0jP86PDwcFSpUSJI1OH36NIoVK2a6oDOBsedbq1YtBAYGxn+d+JzU+vru2LEDs2fPxubNm+Nr+0D6z4UojDlPpf7OAsa/rkp6TRNjzPkq9XcWyNzvrdL+Jpsc0Z3KcgapTD+FhIRIUVFRKW4bHBwsOTg4SAcOHJCioqKkZs2aSf369ZMkiTrXs2XLJl25ckUKCwuTKlWqJM2cOdMSp5Ah0dHRUt68eePHBXv27Cm1atUq/vtv376VYmJiUr3vx48fJTs7O+n+/ftJrm/cuLH0ww8/SOfPn5dmz54t2draSkePHjXfSRiAsefbo0cPqXnz5tKZM2ekFStWSNmyZZNWrFghSZI6X98bN25I2bJlk1auXCmFhYVJYWFh8ZMY6T0XokjvPNM6x/Ret23btkkFCxaUnjx5Ij1//lwqXLiwtGnTJsudUAYYc75Ke00TY8z5KvV3VpKMO19JUubfZFPDoiYdUhM1xYoVk3x9fVO9/aJFi6SsWbNKLi4ukru7u/T8+fP4740cOVKys7OTnJ2dpSpVqshqB8S2bdskJycnKXfu3FLevHml69evx38PgHTp0qVU73fw4EEpf/78Ka5/9OiR1KhRI8ne3l4qW7asrN4MJMm483379q3Url07ydHRUSpWrJi0cOHCJN9X2+s7cOBACUCSS7FixSRJyvi5EEVa55nez3Bar1tcXJzUtWtXydHRUXJ0dJRatWoVv65BLhh6vkp8TRNj6Pkq+XdWkoz7eVbq32RTopEklc51CSIgIAC3bt1CvXr1kD179iTfu3HjBp4+fYoGDRrIqn4LAM+fP4efnx9q1qyJ3Llziw7H7JjjfPn1FY8x55ne63b+/Hl8+PABDRo0SNFwLQes5XXVYerzlfPvLGB9r68pYFHDMAzDMIwq4EZhhmEYhmFUAYsahmEYhmFUAYsahmEYhmFUAYsahmEYhmFUAYsahmEUwYcPH9CtWzc8evQow9vOmjULq1evtkBUDMPICZ5+YhhGMVSuXBmtWrXChAkTUv1+TEwMbG1tceLECbRv3x4BAQFwdHREXFwcZsyYgRMnTsTftmrVqhg7dqyFImcYxhJwpoZhGFkyfvx4FC9ePMnl3r17mDlzZorrly5dCgAoX748nJ2d0bZtW0RHR6NgwYJwcnLCzJkzcevWLRQvXhzDhw/Hy5cvZbmXhGGYzMGihmEYWfL+/Xt4eHjg4cOH8ZewsDDcu3cPly5dir+uSJEi8b42/v7+aNeuHR4/fow3b95gzJgxaNGiBYYNG4YcOXKgePHiqFOnDh48eIBmzZoJPkOGYUwNixqGYWRJxYoVUatWLdy8eRP16tXDzZs3AQD//PMPGjVqFH+7rl27olKlSgAAJycn+Pn5YcGCBQCAQ4cOoXbt2gAAGxsbAMD169dhZ2eHypUrW/BsGIaxBLaiA2AYhkmNrl27IjY2FpIkoXXr1qhRowbmzJkDAChevHj87Xr37g0A8bft378/Ll68iLCwMJw4cQIrV65ERERE/O0PHjyIFi1ayNL2gGGYzMGihmEY2eLh4YFWrVrBy8sLderUQXh4OM6ePYvChQunuO2pU6fQunVr2NrSn7XNmzcja9asKFu2LIoVK4b69esDIL8fe3t7i54HwzCWgctPDMPIllGjRuGPP/5Au3btUKdOHXh4eOD58+coWrRoitvWq1cP7969w6tXr5JcXr9+jYsXL8bfbtq0adi/fz98fHwseSoMw1gAFjUMw8gOSZIQHh6OL7/8EufPn0eLFi3iv/f06VO4ubnFfx0TE4OPHz8CAC5fvgw3N7ckk1F16tRJcmwXFxcsWbIEQ4cOTVKWYhhG+XD5iWEY2fH48WOULVsWDg4O8eWkUaNGIS4uDm/fvsW///6L/v37AwCioqLg4uKCR48eIS4uDvb29rh37x4A4MKFC+jatWuK41euXBlv377F48ePUaZMGcudGMMwZoVFDcMwsqNYsWKpZlGGDBmC+/fvY9y4cShdujScnJySfD9r1qwp7qObetLRrVs37NmzB+XLl0eJEiVMGzjDMEJhUcMwjOx58OABhg8fjjt37uDQoUPo2rUr/P39MXbsWPTo0SNeuMTExMTvrgGA6OhouLi4AKDpKADw9PREixYt0LZt2/gsEMMw6oB7ahiGkSUnT57ErFmz0KBBA1SsWBFFihTBqVOnkDt3buzZswfLly/HrFmzUKFCBRw8eBAAoNFoUKtWLTx58gRPnjzBgQMHkDt3bgCIz/y0bdsWHTt2hIODg7BzYxjGPLD3E8MwsmTPnj2YN28etFot2rdvHy9OEhMZGYlJkyahTp06aNq0qYAoGYaREyxqGIZhGIZRBVx+YhiGYRhGFbCoYRiGYRhGFbCoYRiGYRhGFbCoYRiGYRhGFbCoYRiGYRhGFbCoYRiGYRhGFbCoYRiGYRhGFbCoYRiGYRhGFbCoYRiGYRhGFfwfaWGSlc7jaf4AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams[\"font.sans-serif\"]=['simhei']\n",
    "freqs_for_each_token = torch.outer(torch.arange(10), freqs)\n",
    "freqs_cis = torch.polar(torch.ones_like(freqs_for_each_token), freqs_for_each_token)\n",
    "freqs_cis.shape\n",
    "\n",
    "# 查看freqs_cis的第三行\n",
    "value = freqs_cis[3]\n",
    "plt.figure()\n",
    "for i, element in enumerate(value[:10]):\n",
    "    plt.plot([0, element.real], [0, element.imag], color='blue', linewidth=1, label=f\"Index: {i}\")\n",
    "    plt.annotate(f\"{i}\", xy=(element.real, element.imag), color='red')\n",
    "plt.xlabel('实部')\n",
    "plt.ylabel('虚部')\n",
    "plt.title('freqs_cis的一行的图示')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:59<00:00,  1.87s/it]\n"
     ]
    }
   ],
   "source": [
    "final_embedding = token_embeddings_unnormalized\n",
    "for layer in tqdm(range(n_layers)):\n",
    "    qkv_attention_store = []\n",
    "    layer_embedding_norm = rms_norm(final_embedding, model[f\"layers.{layer}.attention_norm.weight\"])\n",
    "    q_layer = model[f\"layers.{layer}.attention.wq.weight\"]\n",
    "    q_layer = q_layer.view(n_heads, q_layer.shape[0] // n_heads, dim)\n",
    "    k_layer = model[f\"layers.{layer}.attention.wk.weight\"]\n",
    "    k_layer = k_layer.view(n_kv_heads, k_layer.shape[0] // n_kv_heads, dim)\n",
    "    v_layer = model[f\"layers.{layer}.attention.wv.weight\"]\n",
    "    v_layer = v_layer.view(n_kv_heads, v_layer.shape[0] // n_kv_heads, dim)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    for head in range(n_heads):\n",
    "        q_layer_head = q_layer[head]\n",
    "        k_layer_head = k_layer[head//4]\n",
    "        v_layer_head = v_layer[head//4]\n",
    "        q_per_token = torch.matmul(layer_embedding_norm, q_layer_head.T)\n",
    "        k_per_token = torch.matmul(layer_embedding_norm, k_layer_head.T)\n",
    "        v_per_token = torch.matmul(layer_embedding_norm, v_layer_head.T)\n",
    "        q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "        q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "        q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis)\n",
    "        q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "        k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "        k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "        k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)\n",
    "        k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "        qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5\n",
    "        mask = torch.full((len(token_embeddings_unnormalized), len(token_embeddings_unnormalized)), float(\"-inf\"))\n",
    "        mask = torch.triu(mask, diagonal=1)\n",
    "        qk_per_token_after_masking = qk_per_token + mask\n",
    "        qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "        qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "        qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "    stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    embedding_delta = torch.matmul(stacked_qkv_attention, w_layer.T)\n",
    "    embedding_after_edit = final_embedding + embedding_delta\n",
    "    embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[f\"layers.{layer}.ffn_norm.weight\"])\n",
    "    w1 = model[f\"layers.{layer}.feed_forward.w1.weight\"]\n",
    "    w2 = model[f\"layers.{layer}.feed_forward.w2.weight\"]\n",
    "    w3 = model[f\"layers.{layer}.feed_forward.w3.weight\"]\n",
    "    output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T)\n",
    "    final_embedding = embedding_after_edit+output_after_feedforward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' data'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_embedding = rms_norm(final_embedding, model[\"norm.weight\"])\n",
    "logits = torch.matmul(final_embedding[-1], model[\"output.weight\"].T)\n",
    "next_token = torch.argmax(logits, dim=-1)\n",
    "tokenizer.decode([next_token.item()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 备注：部分代码草稿"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)\n",
    "k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "k_per_token = torch.matmul(token_embeddings, k_layer0_head0.T)\n",
    "k_layer0_head0 = k_layer0[0]\n",
    "k_layer0 = model[\"layers.0.attention.wk.weight\"]\n",
    "k_layer0 = k_layer0.view(n_kv_heads, k_layer0.shape[0] // n_kv_heads, dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask = torch.full((len(tokens), len(tokens)), float(\"-inf\"), device=tokens.device)\n",
    "mask = torch.triu(mask, diagonal=1)\n",
    "qk_per_token_after_masking = qk_per_token + mask\n",
    "qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_layer0_head0 = v_layer0[0]\n",
    "v_layer0 = model[\"layers.0.attention.wv.weight\"]\n",
    "v_layer0 = v_layer0.view(n_kv_heads, v_layer0.shape[0] // n_kv_heads, dim)\n",
    "v_per_token = torch.matmul(token_embeddings, v_layer0_head0.T)\n",
    "qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qkv_attention_store = []\n",
    "\n",
    "for head in range(n_heads):\n",
    "    q_layer0_head = q_layer0[head]\n",
    "    k_layer0_head = k_layer0[head//4] # key weights are shared across 4 heads\n",
    "    v_layer0_head = v_layer0[head//4] # value weights are shared across 4 heads\n",
    "    q_per_token = torch.matmul(token_embeddings, q_layer0_head.T)\n",
    "    k_per_token = torch.matmul(token_embeddings, k_layer0_head.T)\n",
    "    v_per_token = torch.matmul(token_embeddings, v_layer0_head.T)\n",
    "\n",
    "    q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "    q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "    q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis[:len(tokens)])\n",
    "    q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "\n",
    "    k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "    k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "    k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis[:len(tokens)])\n",
    "    k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "\n",
    "    qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5\n",
    "    mask = torch.full((len(tokens), len(tokens)), float(\"-inf\"), device=tokens.device)\n",
    "    mask = torch.triu(mask, diagonal=1)\n",
    "    qk_per_token_after_masking = qk_per_token + mask\n",
    "    qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "    qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "    qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "    qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "# len(qkv_attention_store)\n",
    "stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)\n",
    "\n",
    "w_layer0 = model[\"layers.0.attention.wo.weight\"]\n",
    "embedding_delta = torch.matmul(stacked_qkv_attention, w_layer0.T)\n",
    "embedding_after_edit = token_embeddings_unnormalized + embedding_delta\n",
    "embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[\"layers.0.ffn_norm.weight\"])\n",
    "w1 = model[\"layers.0.feed_forward.w1.weight\"]\n",
    "w2 = model[\"layers.0.feed_forward.w2.weight\"]\n",
    "w3 = model[\"layers.0.feed_forward.w3.weight\"]\n",
    "output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T)\n",
    "layer_0_embedding = embedding_after_edit+output_after_feedforward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_embedding = token_embeddings_unnormalized\n",
    "for layer in range(n_layers):\n",
    "    qkv_attention_store = []\n",
    "    layer_embedding_norm = rms_norm(final_embedding, model[f\"layers.{layer}.attention_norm.weight\"])\n",
    "    q_layer = model[f\"layers.{layer}.attention.wq.weight\"]\n",
    "    q_layer = q_layer.view(n_heads, q_layer.shape[0] // n_heads, dim)\n",
    "    k_layer = model[f\"layers.{layer}.attention.wk.weight\"]\n",
    "    k_layer = k_layer.view(n_kv_heads, k_layer.shape[0] // n_kv_heads, dim)\n",
    "    v_layer = model[f\"layers.{layer}.attention.wv.weight\"]\n",
    "    v_layer = v_layer.view(n_kv_heads, v_layer.shape[0] // n_kv_heads, dim)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    for head in range(n_heads):\n",
    "        q_layer_head = q_layer[head]\n",
    "        k_layer_head = k_layer[head//4]\n",
    "        v_layer_head = v_layer[head//4]\n",
    "        q_per_token = torch.matmul(layer_embedding_norm, q_layer_head.T)\n",
    "        k_per_token = torch.matmul(layer_embedding_norm, k_layer_head.T)\n",
    "        v_per_token = torch.matmul(layer_embedding_norm, v_layer_head.T)\n",
    "        q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "        q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "        q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis)\n",
    "        q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "        k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "        k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "        k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)\n",
    "        k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "        qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5\n",
    "        mask = torch.full((len(token_embeddings_unnormalized), len(token_embeddings_unnormalized)), float(\"-inf\"))\n",
    "        mask = torch.triu(mask, diagonal=1)\n",
    "        qk_per_token_after_masking = qk_per_token + mask\n",
    "        qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "        qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "        qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "    stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    embedding_delta = torch.matmul(stacked_qkv_attention, w_layer.T)\n",
    "    embedding_after_edit = final_embedding + embedding_delta\n",
    "    embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[f\"layers.{layer}.ffn_norm.weight\"])\n",
    "    w1 = model[f\"layers.{layer}.feed_forward.w1.weight\"]\n",
    "    w2 = model[f\"layers.{layer}.feed_forward.w2.weight\"]\n",
    "    w3 = model[f\"layers.{layer}.feed_forward.w3.weight\"]\n",
    "    output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T)\n",
    "    final_embedding = embedding_after_edit+output_after_feedforward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_embedding = rms_norm(final_embedding, model[\"norm.weight\"])\n",
    "logits = torch.matmul(final_embedding[-1], model[\"output.weight\"].T)\n",
    "next_token = torch.argmax(logits, dim=-1)\n",
    "tokenizer.decode([next_token.item()])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}