train_v9.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "BHZnXywjxGeq"
   },
   "outputs": [],
   "source": [
    "#https://pytorch.org/tutorials/beginner/transformer_tutorial.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "kY_j8RUDP5y4"
   },
   "outputs": [],
   "source": [
    "from torch import nn, Tensor\n",
    "import torch.nn.functional as F\n",
    "import torch\n",
    "import math\n",
    "from torch.autograd.variable import Variable\n",
    "import typing\n",
    "import random\n",
    "import tqdm\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "y4lRdOSZNpe2"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ph2WO5JpKukk",
    "outputId": "ab00d895-307a-4ade-e705-1c6dd8ae6926"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "modelname=\"5_1_23_m2\"\n",
    "\n",
    "prefix_models=\"models/\"+modelname+\"/\"\n",
    "\n",
    "if not os.path.exists(prefix_models):\n",
    "    os.makedirs(prefix_models)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "Oe3wtt5oADl6"
   },
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "xGOoJdNdRSaO"
   },
   "outputs": [],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "    def __init__(self, d_model: int, dropout: float = 0.1, max_len: int = 5000):\n",
    "        super().__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "\n",
    "        position = torch.arange(max_len).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))\n",
    "        pe = torch.zeros(max_len, 1, d_model)\n",
    "        pe[:, 0, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 0, 1::2] = torch.cos(position * div_term)\n",
    "        self.register_buffer('pe', pe)\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        \"\"\"\n",
    "        Arguments:\n",
    "            x: Tensor, shape ``[seq_len, batch_size, embedding_dim]``\n",
    "        \"\"\"\n",
    "        #mine is [batch, seq, embed]\n",
    "        x = x.permute((1,0,2))\n",
    "        x = x + self.pe[:x.size(0)]\n",
    "        dropout = self.dropout(x)\n",
    "        return dropout.permute((1,0,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "XakHZ4HfFdYM"
   },
   "outputs": [],
   "source": [
    "class ScaledDotProductAttention(nn.Module):\n",
    "    def forward(self, query, key, value, mask = None):\n",
    "        key_tp = key.transpose(-2, -1)\n",
    "\n",
    "        scores = query.matmul(key_tp) / math.sqrt(query.size()[-1])\n",
    "\n",
    "        if mask is not None:\n",
    "            scores = scores.masked_fill(mask == 0, float(\"-inf\"))\n",
    "            \n",
    "        attention = F.softmax(scores, dim = -1)\n",
    "\n",
    "        return attention.matmul(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "G-sb6gd7L5bR"
   },
   "outputs": [],
   "source": [
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self,\n",
    "                 in_features,\n",
    "                 head_num,\n",
    "                 bias=True,\n",
    "                 activation=F.relu):\n",
    "        super(MultiHeadAttention, self).__init__()\n",
    "        if in_features % head_num != 0:\n",
    "            raise ValueError('`in_features`({}) should be divisible by \\\n",
    "                `head_num`({})'.format(in_features, head_num))\n",
    "        self.in_features = in_features\n",
    "        self.head_num = head_num\n",
    "        self.activation = activation\n",
    "        self.bias = bias\n",
    "        self.linear_q = nn.Linear(in_features, in_features, bias)\n",
    "        self.linear_k = nn.Linear(in_features, in_features, bias)\n",
    "        self.linear_v = nn.Linear(in_features, in_features, bias)\n",
    "        self.linear_o = nn.Linear(in_features, in_features, bias)\n",
    "\n",
    "    def forward(self, q, k, v, mask=None):\n",
    "        q, k, v = self.linear_q(q), self.linear_k(k), self.linear_v(v)\n",
    "        if self.activation is not None:\n",
    "            q = self.activation(q)\n",
    "            k = self.activation(k)\n",
    "            v = self.activation(v)\n",
    "\n",
    "        q = self._reshape_to_batches(q)\n",
    "        k = self._reshape_to_batches(k)\n",
    "        v = self._reshape_to_batches(v)\n",
    "        \n",
    "        if mask is not None:\n",
    "            mask = mask.repeat(self.head_num, 1, 1)   \n",
    "        \n",
    "        y = ScaledDotProductAttention()(q, k, v, mask)        \n",
    "        \n",
    "        y = self._reshape_from_batches(y)      \n",
    "\n",
    "        y = self.linear_o(y)\n",
    "        if self.activation is not None:\n",
    "            y = self.activation(y)\n",
    "        return y\n",
    "\n",
    "    @staticmethod\n",
    "    def gen_causal_mask(x):\n",
    "        batch_size, seq_len, _ = x.size()\n",
    "        return torch.tril(torch.ones(seq_len, seq_len)).view(1, seq_len, seq_len).repeat(batch_size, 1, 1)\n",
    "\n",
    "    def _reshape_to_batches(self, x):\n",
    "        batch_size, seq_len, in_feature = x.size()\n",
    "        sub_dim = in_feature // self.head_num\n",
    "        return x.reshape(batch_size, seq_len, self.head_num, sub_dim)\\\n",
    "                .permute(0, 2, 1, 3)\\\n",
    "                .reshape(batch_size * self.head_num, seq_len, sub_dim)\n",
    "\n",
    "    def _reshape_from_batches(self, x):\n",
    "        batch_size, seq_len, in_feature = x.size()\n",
    "        batch_size //= self.head_num\n",
    "        out_dim = in_feature * self.head_num\n",
    "        return x.reshape(batch_size, self.head_num, seq_len, in_feature)\\\n",
    "                .permute(0, 2, 1, 3)\\\n",
    "                .reshape(batch_size, seq_len, out_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "NDpTASiaTxTX"
   },
   "outputs": [],
   "source": [
    "class Transformer(nn.Module):\n",
    "    def __init__(self, \n",
    "                 embedding_dim: int,\n",
    "                 n_self_heads: int,\n",
    "                 n_features: int,\n",
    "                 n_layers: int,\n",
    "                 n_classes: int):\n",
    "        super().__init__()\n",
    "\n",
    "        #Embedding layer\n",
    "        self.embedding = nn.Embedding(n_features, embedding_dim)\n",
    "        #Positional encoding\n",
    "        self.pos_encode = PositionalEncoding(embedding_dim)\n",
    "\n",
    "        self.decoder_layers = []\n",
    "\n",
    "        for _ in range(n_layers):\n",
    "            layer = []\n",
    "            #Add multihead, which will be cross or self attention\n",
    "            layer.append(MultiHeadAttention(embedding_dim, n_self_heads)) #self attention first, masked\n",
    "            #Now add layer norm\n",
    "            layer.append(nn.LayerNorm(embedding_dim))\n",
    "            #Add a feed forward\n",
    "            layer.append(nn.Linear(embedding_dim, embedding_dim))\n",
    "            #Now add layer norm\n",
    "            layer.append(nn.LayerNorm(embedding_dim))\n",
    "\n",
    "            self.decoder_layers.append(nn.ModuleList(layer))\n",
    "        self.decoder_layers=nn.ModuleList(self.decoder_layers)\n",
    "\n",
    "        self.to_out = nn.Linear(embedding_dim, n_classes)\n",
    "            \n",
    "    def forward(self, x: torch.Tensor, calculate_loss: bool = False):\n",
    "        \"\"\"\n",
    "        Expect tensor of [batch_size, n_features]\n",
    "        \"\"\"\n",
    "        if calculate_loss:\n",
    "            #If give model that accepts ?x?x4 abcd, expect bcd0\n",
    "            \n",
    "            target_logits=torch.cat([x[:,1:], torch.zeros((x.shape[0],1)).to(device)], dim=-1) ## if x is abcd, then target_logits is bcd0\n",
    "\n",
    "        x=x.long().to(device)\n",
    "        embed = self.embedding(x)\n",
    "        pos_encode = self.pos_encode(embed)\n",
    "\n",
    "        res = embed+pos_encode\n",
    "        \n",
    "        for decoder_layer in self.decoder_layers:\n",
    "            d_self_attention = decoder_layer[0]\n",
    "            d_layer_norm_1 = decoder_layer[1]\n",
    "            d_ff = decoder_layer[2]\n",
    "            d_layer_norm_2 = decoder_layer[3]\n",
    "            \n",
    "            ## Run the decoder\n",
    "            #do masked self attention\n",
    "            mask = MultiHeadAttention.gen_causal_mask(res).to(device)\n",
    "            res = res + d_self_attention(res,res,res, mask = mask)\n",
    "            self_res = res\n",
    "            #layer norm\n",
    "            res = d_layer_norm_1(res)\n",
    "\n",
    "            #do ff\n",
    "            res = self_res + d_ff(res)\n",
    "            #layer norm\n",
    "            res = d_layer_norm_2(res)\n",
    "\n",
    "        out = self.to_out(res)\n",
    "        if calculate_loss:\n",
    "            loss = nn.functional.cross_entropy(out.permute(0, 2, 1), target_logits.long())\n",
    "            return out,loss\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "HqGGEpvCLbP8"
   },
   "outputs": [],
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, n_pad: int, device: torch.device, pad_byte: int = 0, split: str = \"\\n\"):\n",
    "        self.n_pad = n_pad\n",
    "        self.device = device\n",
    "        self.pad_byte = pad_byte\n",
    "        self.split = split\n",
    "\n",
    "    def tokenize_str(self, sentence: str, encoding = \"utf8\") -> torch.Tensor:\n",
    "        base = [int(i) for i in bytes(sentence, encoding)]\n",
    "        if len(base) < self.n_pad:\n",
    "            base.extend([self.pad_byte] * (self.n_pad - len(base)))\n",
    "        assert len(base) == self.n_pad, f\"n_pad is too small, use {len(base)} or greater.\"\n",
    "        tensor = torch.Tensor(base)\n",
    "        return tensor.to(self.device)\n",
    "\n",
    "    def texts_to_sequences(self, texts: typing.List[str], encoding = \"utf8\") -> torch.Tensor:\n",
    "        # tokenize the input text\n",
    "        sentences = []\n",
    "        for sentence in texts:\n",
    "            sentences.append(self.tokenize_str(sentence).unsqueeze(0))\n",
    "\n",
    "        return torch.cat(sentences, dim = 0).to(self.device)\n",
    "    \n",
    "    @staticmethod\n",
    "    def prepare_texts(document: str) -> typing.List[str]:\n",
    "        return filter(lambda x: len(x)!=0, document.split(self.split))\n",
    "    \n",
    "    def sequences_to_texts(self, texts: torch.Tensor, encoding = \"utf8\") -> typing.List[str]:\n",
    "        out = []\n",
    "        for seq in texts:\n",
    "            chars = []\n",
    "            i=0\n",
    "            while i<len(seq) and seq[i] != 0:\n",
    "                chars.append(int(seq[i]))\n",
    "                i+=1\n",
    "            out.append(bytes(chars).decode(encoding, \"replace\"))\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "pB-Xcf4TkKNQ"
   },
   "outputs": [],
   "source": [
    "def generate(seed: str, cutoff: int = 1024) -> str:\n",
    "    output = torch.tensor([list(bytes(seed,\"utf8\"))]).to(device)\n",
    "    \n",
    "    res=output\n",
    "    last = -1\n",
    "    i=0\n",
    "    while last != 0 and i<cutoff:\n",
    "        res = model(output)\n",
    "        argmax=res.argmax(-1)\n",
    "        \n",
    "        out = list(output[0])\n",
    "        out.append(list(argmax.to(device)[0])[-1])\n",
    "        last = list(argmax.to(device)[0])[-1]\n",
    "        output = torch.tensor([out])\n",
    "        i+=1\n",
    "    \n",
    "    if last == 0:\n",
    "        return convert_to_str(output)\n",
    "    return convert_to_str(output)+\"<CUTOFF>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "R81mAag8mHEG"
   },
   "outputs": [],
   "source": [
    "class TextDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data: typing.List[str], n_pad):\n",
    "        self.raw_data = data\n",
    "        self.tokenizer = Tokenizer(n_pad, device, split = \"\\0\")\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.raw_data)\n",
    "\n",
    "    def __getitem__(self,index):\n",
    "        return self.tokenizer.tokenize_str(self.raw_data[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "xQidsLjVaFUi"
   },
   "outputs": [],
   "source": [
    "def convert_to_str(x: torch.Tensor) -> str:\n",
    "    #Expects [1, 256] tensor\n",
    "    bts = []\n",
    "    i=0\n",
    "    while len(bts)<x.shape[1] and x[0][i] != 0:\n",
    "        bts.append(int(x[0][i]))\n",
    "        i+=1\n",
    "    return bytes(bts).decode(\"utf8\",\"replace\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "97rbDfS4gO8C"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Head size: 10\n"
     ]
    }
   ],
   "source": [
    "n_features = 256 # No. of tokens\n",
    "n_pad = 512 # Max line length\n",
    "embedding_dim = 640\n",
    "batch_size = 32\n",
    "head_factor = 64\n",
    "assert embedding_dim%head_factor == 0\n",
    "head_size = embedding_dim//head_factor\n",
    "print(f\"Head size: {head_size}\")\n",
    "n_layers = 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IvvenMeUKfaj",
    "outputId": "fb38b6f5-0eaf-4d89-83ad-bee41604b8ef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "92590\n"
     ]
    }
   ],
   "source": [
    "path_to_data = \"data/reddit_scrape_v6.txt\"\n",
    "data_raw = open(path_to_data, encoding=\"utf-8\").read()\n",
    "\n",
    "data_split = list(filter(lambda x: x!=\"\", data_raw.split(\"\\0\")))\n",
    "random.shuffle(data_split)\n",
    "\n",
    "train_data = data_split[100:]\n",
    "print(len(train_data))\n",
    "val_data = data_split[:100]\n",
    "\n",
    "train_dataloader = TextDataset(train_data, n_pad)\n",
    "test_dataloader = TextDataset(train_data, n_pad)\n",
    "\n",
    "dataloader = torch.utils.data.DataLoader(train_dataloader, batch_size=batch_size)\n",
    "testloader = torch.utils.data.DataLoader(test_dataloader , batch_size=1)\n",
    "testloader_iter = iter(testloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "GvibftHanb0A"
   },
   "outputs": [],
   "source": [
    "model = Transformer(embedding_dim, head_size, n_features, n_layers, 256)\n",
    "model=model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33188096 trainable params\n"
     ]
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "print(count_parameters(model), \"trainable params\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PXqmUSK0M3hD",
    "outputId": "69ad8160-d138-4e98-99b6-bd8cb83753c1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 512])\n",
      "torch.Size([1, 512, 256])\n"
     ]
    }
   ],
   "source": [
    "input=next(testloader_iter)\n",
    "input=input.to(device)\n",
    "print(input.shape)\n",
    "res = model(input)\n",
    "print(res.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "tZji9Va7-unn"
   },
   "outputs": [],
   "source": [
    "lr = 1e-4\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "hUN0DJQo-vmf"
   },
   "outputs": [],
   "source": [
    "n_epochs = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GczR7J4u6L5Q",
    "outputId": "15259e58-4468-44ff-dcf3-6c8dfb86d6bc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon May  1 21:36:41 2023       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 515.65.01    Driver Version: 515.65.01    CUDA Version: 11.7     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA A10          On   | 00000000:06:00.0 Off |                    0 |\n",
      "|  0%   42C    P0    58W / 150W |   1563MiB / 23028MiB |      3%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A      1692      C   /usr/bin/python3                 1561MiB |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "yYr65bmbITE1"
   },
   "outputs": [],
   "source": [
    "prompts = [\n",
    "    \"Why does Earth orbit the Sun?\",\n",
    "    \"Hello world, \",\n",
    "    \"How to use ChatGPT?\",\n",
    "    \"My code does not work. What should I do?\",\n",
    "    \"Why is this code not working: `1+\\\"A\\\"`?\",\n",
    "    \"Why is Java better than Python?\",\n",
    "    \"Why is Python better than Java?\",\n",
    "    \"What is the purpose of the main() function in C?\",\n",
    "    \"What is coding?\",\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "o85FrKyF-wg-"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:00<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I want to take there some there some that there some that there some that there some that there some that there some that there some that there some that there some that there some that there some that there some when you can some there some that there some there some that there some there some that there some there some there some that there solutions there some there some there some there some there simples the simple there simples the simples there sinsifical theres the sinses.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, what to start work work?\n",
      "I would taking there to start there some that there some that there some that there some that there some that there some that there some that there some that there some that there some there some that there some that stating there some that there some there some that stating there some there some that states that there some that same there some there some there some there some there some there some there some there sins there the sins theres the sins the sinses theres the sinses.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I would take to start there to start there than there some that there some that there some that there some that work when there some there some that there some that there some that work when there some there some there some that there some there some that there some there some there some that there some there some there some there the simple there some there some there some there some there some there some there simples the simple there sins the states there the sins the sins.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I would t hatt to start work work work work work work work work work there than there some that work when I want to supply to start there than there some that there some that there some that there some there some that there some that there some there some there than there some there some there the stary there than there some there some there some there some there some there some there some there some there some there some there some there sins.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I would take there to start the states that these states that there than the states that there than there than there situmes that there the same that there than there situm there than there than there situm there than there situm there than there situm there than there situm there than there the stating there the statics there some that states there simples there some there simples there simples the simples there simples the sinsifices theress the sinsifical the sinsisis.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would be think there some that there constant there some that when there some there some that when there some that when there some there some that there some that when there some there some there some that there some that work when there some there some there some that there some there some there some there some that statemes that there some there some there some there some there some there some there solutions theres the sinsifical the simples the sinsifices.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would take there to be there than there than the state the state there than the state there than there situmes that when there some there some that there some that when there some there some there some that when there some there some there some that there some there some that there some there some there some there some that statemes that when there some there some there some there some there simples there simples there simples the simple there sinssifices.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would take there the states that there consumptions in the consump there than the states that when there some that when there some there some that when there some there some that when there some there some there some that there some there some there some that there some there solutions there some there some there some that statemes there some there some there some there some there some there some there some there sins.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I was tring to static to stat the statistics to take the state them the statics to there that there statements that there statements that there some that there some that there some that there some that there some there some that there some that there some there some there some that there some there some there some there some that there some there some there solutions there some there some there simples there simples there simples there simples there sinsifical theres the sinsifices.\n",
      "\n",
      "Epoch 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:07<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I think the statement is the statement to the state the stack of the stack the stacs the stacs to the stack the stack the stack to the stack them the stacs to the stack them the stacs to the stack to the stack them. I would state the stacs then the stacs to the stacs then the stacs to the stacs then the stacs to the stacs then the stacs to the stacs then the stacs to the stacs there the stacs to the stacs to there.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, what would you work?\n",
      "I would take to start when I want to start when I want to start when I want to start when I want to start when I want to start when I want to start when I want to start when I want to start when I want to start when I want to start when I was working with to start when I was working when I was working when I was working when I was working when I was working with to stay. I was to some what I was working with there.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I would tring to start to start to start the statistics to the statics that statistics is there and there when I want to start the statement with the community to the state the constant to the state the constant to the constant the state the constant to the stack to there. I want to start there the stacs to start there the stacs to stac there the stacs to there the stacs to there the stacs to there the stacs to there.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I would take to start the stack for the stack to start the stack to the stack to the stack to the stack them to start the stack to the stack to there. I want to start the stack to there the stack to there the stack to there. I would start there the stack to start there the stacs to start there the stacs to start there. I want to start there the stacs to stack there the stacs to stac then the stacs to there the stacs to there.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "If you won't start the statement when you'd start the stack to the stack that the stack then you want to talk to the stack them the stacs to the stack them the stacs to the stack to the stack them the stacs to the stack to the stack to there. I would start there the stack to there the stacs then the stacs to the stac then the stacs to the stacs then the stacs to the stacs the stacs to the consticating the constist to the cons then to the cons to the torget the condes.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would tried to start the statistics to the state the state the stacs the stacs the stacs to the stack the stack to the stack them the state the stacs to the stack them the stacs to the stack to the stack them the stacs to the stacs then the stacs then the stacs to the stacs then the stacs to the stacs the stacs to the stace. I would some there the stacs to the stacs then the stacs to the stacs then the stacs to the torder to the torden to the torden.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say this is not some to start the state that statestics when I wanted to start when I want to start when I want to start when I want to start when I want to start when I want to start when I was to start when I was working when I was working when I was working when I was working when I was working when I was to started when I was working when I was to some what I was working with there.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would small the stuff the statement is the stacs to the stack the stack to the stack them the stack to the stack them the stack to the stack them the stacs to the stack them the stacs to the stack to the stack them the stacs to the stack to the stack to there. I would start there the stacs to the stacs then the stacs to there the stacs to the stacs to there the stacs to the stacs to there.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I wondering what you want to start when you want to start the statement with the stacs that the stacs when you chost the stacs when you chose the stacs to the stack them to the stack when you chose the constant to the stack them. I would state the command to there the stacs to there the stacs to there the stacs to there. It was there the statement to start there the stacs to there the stacs to there.\n",
      "\n",
      "Epoch 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [40:52<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAA++ElEQVR4nO2dd5wURdrHf88uSw4LkllwyUGyiAEwgiKcYs5nONOZ0+mhnor6Gs50nor5PLOImFDwSBJERVlyElhggSUucUm7sLvP+8f0zPb0dPd093RP9+w8389noae7uvqpDvVUPfXUU8TMEARBEAQjMvwWQBAEQQg2oigEQRAEU0RRCIIgCKaIohAEQRBMEUUhCIIgmCKKQhAEQTBFFIUgJAgRFRDRYItpryWi2V7LJAhuIopCqJIolfchItpPRLuJaAIRtbZ4bi4RMRFV81pOQUgFRFEIVZlzmLkugBYAtgF41Wd5BCElEUUhVHmYuQTAOADdwvuIaDgRLSCiYiLaSESjVKfMUv7fo/RITlTOuZGIVhDRPiJaTkR9Vef0JqLFRLSXiD4noppWZCOik4hornLeXCI6SXXsWiJaq1xvHRFdqezvQEQzlXN2ENHnzu6MIFhDFIVQ5SGi2gAuBTBHtfsAgKsBZAMYDuAWIjpPOXay8n82M9dl5l+J6GIAo5Rz6gM4F8BOVX6XABgKoC2AngCutSBXIwATALwC4CgALwGYQERHEVEdZf/ZzFwPwEkAFiqnPglgMoCGAHIgPSXBY0RRCFWZb4hoD4C9AIYAeD58gJlnMPMSZq5g5sUAPgNwikleNwB4jpnncoh8Zl6vOv4KM29m5l0AvgPQ24J8wwGsZuaPmLmMmT8D8AeAc5TjFQC6E1EtZt7CzMuU/UcAHA2gJTOXMLMMjgueIopCqMqcx8zZAGoCuB3ATCJqDgBEdDwRTSeiIiLaC+CvABqb5NUawBqT41tV2wcB1LUgX0sA6zX71gNoxcwHEOoF/RXAFmUwvouS5gEABOB3IlpGRH+xcC1BcIwoCqHKw8zlzPwVgHIAA5XdnwIYD6A1MzcA8CZClS8A6IVU3gigvcuibUaoZ6CmDYBNityTmHkIQoPxfwB4R9m/lZlvZOaWAG4G8DoRdXBZNkGIIIpCqPJQiBEI2fRXKLvrAdjFzCVE1B/AFapTihAy+7RT7XsXwN+I6Fglvw5EpK3k7TIRQCciuoKIqhHRpQgNuH9PRM2IaIQyVlEKYL8iE4joYiLKUfLYjZBiq0hQFkEwRPzEharMd0RUjlBFuh7ANSo7/60AXiSi1wDMBDAWoYFtMPNBInoKwM9ElAVgKDN/QURHIdQTaQWgAMCfEWs6sgwz7ySiPwH4N4A3AOQD+BMz7yCiFgDuBfChIv9CALcopx4H4GUiaoCQ2+9dzLzWqRyCEA+ShYsEQRAEM8T0JAiCIJgiikIQBEEwRRSFIAiCYIooCkEQBMGUlPN6aty4Mefm5vothiAIQkoxb968HczcxMm5KacocnNzkZeX57cYgiAIKQUROXblFtOTIAiCYIooCkEQBMEUURSCIAiCKaIoBEEQBFNEUQiCIAimiKIQBEEQTBFFIQiCIJgiiiJg7C8twzcLNvkthiAIQoSUm3BX1Xn46yX4duFmtGtSBz1zsv0WRxAEQXoUQWPL3hIAwIHScp8lEQRBCCGKImBULtosC0oJghAMPFUURDSUiFYSUT4RjdQ53oaIphPRAiJaTETDvJRHEIRoJi7ZgqnLt/kthhBwPFMURJQJYDSAsxFaMP5yIuqmSfYPAGOZuQ+AywC87pU8AFBWXoFJy7ZCln9NDGZGcckRv8UQXODWT+bjhg8lyKZgjpc9iv4A8pl5LTMfBjAGwAhNGgZQX9luAGCzh/LgjRlrcPNH8zAlwC0oqrQ9BZYxczei56jJWFO0329RBEFIAl4qilYANqp+Fyr71IwCcBURFQKYCOAOvYyI6CYiyiOivKKiIscCbdpzCACwY/9hx3l4DUVGKYLLtBXbAQBrtouiEIR0wO/B7MsBvM/MOQCGAfiIiGJkYua3mbkfM/dr0sTRuhsAVK11IUEC3N0RBMF1vFQUmwC0Vv3OUfapuR7AWABg5l8B1ATQ2EOZAKSGR5GZhK/9uBpdH/lf0mQRBCG98VJRzAXQkYjaElF1hAarx2vSbABwBgAQUVeEFIVz21JcQl2KII9lh3s9ZjK+MHkVDh2ReRaCICQHzxQFM5cBuB3AJAArEPJuWkZETxDRuUqy+wDcSESLAHwG4Fr20CVJTE/uEH5CJDdUENICT0N4MPNEhAap1fseVW0vBzDASxl05XIxr5Ij5fh1zU6c1qWpi7kKgiAEB78Hs5NKpP3rYqflye+X47r352Jx4R5X8ouYnlJgHEUQhPQgvRSFB5aS9TsPAgD2HtKfgLa9uATP/LACFRXWKn5KgXGUMGJ4EoT0IK0URZhk1sEPfLkYb81ciznrdibxqoIgCO6RVorCj9b64bKKpF9TSJy3Zq5B7sgJEqpEEJBuisIHW0lYQazatk/3eMmRcpSWVbq6Vo5RBJcgy+YWn/2+AQCwM8Cz+AUhWaSVovCTx79brru/yyP/w4BnpydZGndwS/Fu3nMoUjEHDQkgKQiywl0g2LG/1G8RfOXq935H/vb9OLt7c2TXru63OABkjoggqEnLHkUqtBK9kpGZsXKrvhnMTh5usvtAyLxzpDz4z0UQ0pG0UhR+RPC2Ox8i3JL1SsYv5hXirJdnYcbK7Qnn5VajOyMjlFFFABV48CQShOSTXorCA3OC2xPjvDZ4LN9cDABYW3TA4ytZJ1N5LuUW55oIgpBc0kpRhNE2XEuOlBtOmEuUoK4vESQTfGaAexRusnVvCS57+1fsOSieVEJqkZ6KQvP7vNE/o9fjkx3lFVYER8orcOdnC5CvWczHcY8jwHVmIqKVlVfgrjELosZJwkqroiIxudwkYqZ08Tm8OXMN5qzdha/ma6PtC0KwSStFoW1F546cgPvGLsIfqkrrlzU7cOiwtRDeew8eiSiC92YXYPyizRj80kxXZbTC9n0lKNpnzXPK74H8Vdv249uFm3HXmAWRfeEeRbkF2fK37094MN5vAtwGSFsKdhzA7NU7/BYjsKSVogijriy/nF8Y2V6/8wCueOc3PPjV4rh5TF+5Hb2emIyf80OhOfb5OIO3/1PTcNxTU22dkwzL08KNeyzFuLIzRjH4pZk46+VZpmkOHi7D/32/HCUBWLNj14HDOFBaBiBY5j4hmlNfmIGr/vOb32IElrRSFPHGC/aVhD7oVdvirwU9r2B31G+3W4leRY91M1ez+/lz/g6cN/pnvPfzuuhzdBZmivQoXBrMfmvmWrw7ex3++3OB80xcqtT7PjkFp784w53MBMEn0kpRuIm2dWg0B8CupSdZjU6vJ5QV7g5F1TUKXRItS+h/N5TjwcNlkfhMZeXBGPTYVpzeEyqF1CetZmZbWWYUsNbq1lazK7YUOxHJWIaAGbJHT89HnzbZOKl9Y1uy2UnrhodYz1GTUab0TNy5he4/CL/HiQTBLumlKFzNzJsW+dLN7ioct3h+0koAQMGzwyt3OrgFZr0HN3oUZS6Zr7x4ukF1lRaEeKSl6cmNCsmrTz7svWSl0bm2aD9u/ijPVv7Jbsxq9aleZZnuFejo6fn4OV88boRYKioYo8YvQ8EOfyfIppWisGp6spOXn9zx2QJMWrbN1jlhJZks+a3ca88G7lPEwvP8pJW48l3xuLFLt0f/h1emrfZbDE9ZvqUY7/9SgNs+ne+rHGmmKKzVjkapNuw8iNyREzB/w25kWMzLaV1l5bysTOuPb/nm4qi5FonoCWtjOOZXSJVKPFXkdBNmjrj0BpmDh8vx0pRVfothiW8WbEqoV+D3e5hWiiKM03s+a3URAGDcvELTavD69+cid+QEh1exTtit1ArDXvkJZwTATVNPvwbR9OSFV1gQeqFWeH3GGhzz2CRXw9+vLdqPjbsOupZfKvG/pVtx9+cLceoLMxzn4Xd7Ja0UhZ3vdNqKbcgdOSGqFR7uRTCz6Uc/7Y/EI7O6QeHug9i051Dkd3FJsFuJbreavDJpVXW+W7QZALDdRbfe01+ciUHPpeYCXYlixUXciKA0LtJKUViFAbz/SwGAkI0wjDomkdfzENxwoRz4z+kY8OyPmnwrt7cXl2BNUfzJhUa4Zb4K38oflm5NIEdvsPsUxi/ajF0HEgv6V7SvFH9s9d/7zYqiZWZZVzwNSEtFYW8eQGXiyvUs7GRgPakLp1mHCP2fnoYzXoyNTXX+6z/jxg/zkDtyAqa73DvSUy7hW/zKtNX4ZU3qev9s2XsId362AH/9eJ5punjv36nPT8fQl39yUTJ72GkEfTRnPXqOmoz1O4MTtl5wn/RSFA6awIfLKiKVZaXpKThdQrtYUUALNuzBlOUhb6rvFm+OzcOF3o5RHht2OrNjlxwpxyPfLNVcw34eL01ZhcNlzmZ0h8/bsveQ7nGrDY0DFoNSBoHwe1Lg8LkJ1vB7kmZ6KQoFOz2CpyauwHXvz8XCjXsqTU8cjAHYRCSwfK7JrbLS8tSerj3l24WbUFJWWTGO/GoJgFCl/bcvFmGnwYCqdqB13LxCfDRnvem11+88gP/MXgcj3pixBq9MW42P56x3FGY8CO+Em3hRNx0oLcPFb/4SE46/KpPIfQzKO5VWiiJ80+08uPVKS2nvoSOVy5TGGcx2A7/d4Yxw03Nl3vpduGvMwsg9DnPocDk++KUA4+YV4oXJK3XP1Y4DWGlxXfrWHDz5/XLsN3D9PKREmz0ckBhRasbmbcRz//vD0bmrt+2ztViSl6/2T6t3YG7BbvzTRlke+noJ/vuzsYJXMzZvI05/YQbGzSuMn9gBY+duxPFPT/W9hZ9s0ktRxPkCdiqVz879pfht3a6oY8yMsDcqA7DhmRrFmzPXIHfkBN2AdZOXeT+Ym+j7Pei56VixxboXh9FtYlRG69Vy8vPT8cwP5hWJOt+KCsa/psafeLW1uCR07Tg3YcLiLXHz0iNsptu4y8D0lEAN/MC4xXh9xhpH5w751ywMf2V2zP6JS5yVMxGcTHr99LcNePy75ZbSPjBuMdbuOIC/fbHIgXQW8v9yMbYVl9rraQajU5AQaRXrKR7XvPc7AGC7wSJA4VZsBbOlLuHHGlMIAPxbqdAOl1egmmbC3E0fmQ+CaknkBbR6rt73YMe/Pvb8ygsbma6sLML0w9Kt6NisHgBg5qoifU8jg6/Z6BsPK5Alm/aiU7O6cWUI89PqIvz5P79bTu9HY1TtJh3m1k+SP9s31etMotDzs/MIq0LnI716FMr/O/c7c1/8vwkrAIQe/J5D8fP4h2ZwdUnh3sj2fk1reummvYjGimti3CR6Zzk5SRfTj145OGnZVny7UH/pTyuVhlEZZ6tiIx1xyVT0zk/WzBta7v8i/kJXbvPgV0t0J3VuKy7B2gRcnpPF1BX2Qs94idE4mBnJMj0FpTeSVooijHYxHSu8OLkyVEAFM0ZPt2YGUA+cn/Pa7Mjv/k9Pi0q391C0L7r2PSwrr/BtZmu8jyJ35ARD+/m+kjLcNWahTqYJfgSsu2mUJIHLuFMhOAmJsevAYcNV+j77fYPu/uOfnobTdVye7eBl5ZTo/KOpy7fh1zU7bZ1zuKwCL05eabjE8Y0f2gusaZegVPaJ4KmiIKKhRLSSiPKJaKTO8X8R0ULlbxUR7fFWHufnLlG1+L1oTOjlOWX5tsggZIeHf8Cg56ZHuY8mUp6Hv14aPxFCSuLRb5fFTWfVfh6WecOug75FxLTy/Ox4m+gpE+2A+TGPTcLXC2Jdjc3o++QUXPb2HFvn+EWy6sIbPszD5e/Yuyef/rYer/6Yj9dn5Ose37K3JLLNzPh24SaUlpm7KIvpySWIKBPAaABnA+gG4HIi6qZOw8z3MHNvZu4N4FUAX3klD+Ceq1kirUyjl0Y7+Fa0vxQ3fpiHWz6OtiOHB2Tdvr4R2/eVxridukFZBeMRCwrICnafaq/HJ2PEa7MtreftlNd+jK2UwmM7dq66cOMedwTyGKtl8qNxXarMbyk1mB+jlmn6yu24a8xCvDRlFUqOlOPyt+fozpJPduXvt7LxskfRH0A+M69l5sMAxgAYYZL+cgCfeShPFL8kEP+/wgPvSa0CKD0SusgGjbkp2d1YI1dSIFaWrXsTU2J6WAtTHv/cmzTmhUWFe3HQwKxj5fo/5+/AGAPzDxCcZVgTwe/KyS3iFWOz6r3dczBkAt62twTz1u/Gr2t34gmVx5Wj6AwJEBSzlZeKohWAjarfhcq+GIjoaABtAfxocPwmIsojoryioiLHAqlv+hUJxP+vsPEFOf3YjCYkqfNz0kOyK4/VcOoA8Pcv4w/qJvO9V3/Mk5fbGzyNV+wr3/0tMjlQj0TjPXnJoo17bDUArBA+ZdOeQ3hg3CJDBwMvKj6ra1JYubRavp9WGzcmzb6jeet3Y8LiLZHginaZt34X3p4Vbcr1O8BlUAazLwMwjpl1m3jM/DYz92Pmfk2aNHF8Ebfe0UQemfrc3zVzNdR8nrdRd//0lZWxl34viD5/3Y4DCXtjaM0xdkKZW1GgXgdTtIMVSdYWORtH+WqBvqeXGUX7Sg0HXN3iQGkZRoz+Gbd55Br793GLMTavEHPW2htwTgSrisLul/HmTONxN713nZmxec8hXPjGL7jt0/m447MFNq8Y4sI3fsXTE51NrvQKLxXFJgCtVb9zlH16XIYkmp0Sxa3JNvePsz8p6KBJS/C0F2bgns8X2s5Tzcuaj87pxELtQPWijXuQO3ICCne747nldgvLyJPGyspidnWzUfrjnpqKi978xfTcRIMmhuNRWRn78GIszm47wenkR68IN3S6PToJBw9Hf4ttH5yIs//tXzBHL/FSUcwF0JGI2hJRdYSUwXhtIiLqAqAhgF89lCV8MZcycm56chpwLswHv5oPLH+zcDPyCox7KvGYuSratGfH9KRG6wU1Zm6ohzRrlT3ToReVVZhvVPM77HrSeMWyzebhxbXmkGkrtmGfjTDflTOjjW+OE5NmWUUFjn1yStT8FjfyXlS4x7Ysxte2jpW3rvhQpaIIB4LUurknSpWP9cTMZQBuBzAJwAoAY5l5GRE9QUTnqpJeBmAMp1DwlKkrrIfezlu/20NJ9NliMqisV/E+8s1SjHgtNsQDYK4onLzEiZie1APEcwt2Y8GGxO6t2Xrjf2y1Fqbkw18LDGfyJ4PrP8gz7EWWHCm3bMoqr2DsPei8ktt14EgkBI4pPtR7yahZ1ErDLQp3H4w8W79rR0/HKJh5IjN3Yub2zPyUsu9RZh6vSjOKmWPmWHhBMHSzPfRCL8TDbl380Zz1WKTMGk9oDhyHTExe6PxL3voVHR7+IWrf6On6fvFWceN9sDLHxE0Ol1XgJU2gRKMQ3/2fmoquj/7PUr5PfLcMvZ6Y7HiMxOiZf/b7Buw2USDfLtyEe5XKcOzcjdhu0f3bTpDDRIl2IFFtq354Mdj88NdLoxZO8xOJ9SS4xuz8HZidvwP/urSXa3mOzSvErFU7dOePxOudBLWLmkil8tGc9THmyx37S/He7HW4bkBu1H69pW+NeoHjFQ8dtd09UX3/x9ZiPPjVkqhgl9qrh2ftjzy7Cx74cjF6tGqA7+4YGDfv3k9MsSyHnYaTkwjTTtJbytP9LB0TFK+npOCniSAR3Fw9zOyF1puA5qRSM/MUctKKN5pkOGV5aF3zmw2CKcb7eL12wErElGOE3hjXnoNH8MT3yy2bywDjSoiIoqIQOIVRORfIiknqiPLurd95IKq3YKV3avQcw70jdRbLNxfjinfmGIZG0VsaWJ1/1LYqjZmYThsGQbLGp42iOHS43DA+jl9YfQ/OenmWrXzNxg7Mxkxu+mievdaXQdqDAVmhbXtxCeYnOI6RCK/+aM1t0y3Kyi3FJgFgHOL9C41b9sHDZfh6QeXaDh0emoh3Zq2N/LZbl8XrBRaXlKH3E1OwwobJxUiGGNMkAY98uxS/rNlpqAxf1ZlRH4T62m8R0kZRGLUg/MRqS6PkiD1PKbNvcZ1JfKWpK7bFzK42+0henrpKt9Vj6nWVxIGirxZswgWvm7ubOsHqu2QUIcSriieRHlK5Iqx2HZDHxy/HPZ8visz5KatgPDVxBWas3B45BwDyLUasNRJRu//sf/+EvIJdhmt7WEHvOc1TGkpuPAN1T8nsWw6K51IipI2iEKyh9Zgy+57mFuyO684ZRutznkzKDWps5lCIab1w3WZYWS8jdF3/wngYzQspNnDf1BvPYADb9oXeB23022v/Oxfv/FTZs3hr5lokgt4TmrN2J/5nYTEvIwWpzfNLG6veGZrmVJW+es6EG6an8gqOCgsThJ5MmLRRFPN8cFMNCvEiYZoS52U1qoS1fLtws6X8vGD6H8buzEYeQ24Qb86Ll+jNC9lXcgTnGLhBG6GObaTtPToJe6+u1LVmLi1WFbJVdjhchyZZfDxnvWlYGD9JG0Xhx3wGv9A2sOav3+PZtQLU6DGkzMWW/Y79pTFrfKcKPUZNjgS9swuzvRau0UDs9uLKyv/+cd4u+GQWwM+tgeJV2/bFdSm2anrarXH5VcttFPstWaSNe2yAQgx5jptljddt1vvgUkF5hPnglwLLaT/9bQMe+trdFt/lAV5vIrROfKW7qBvP9T4ba1n/qokX9d7sdbau5cl7qPm2zvzXLAzu2hS3nNreRA5rkmg/pSCZntJHUfgtgA5evQgHSstdWxQonox6lqfFhcbulQF69wFUzh8wo/9TU9GqYS0s2LDH9etrK0M9NvjYg4mE/ID9VvjOAzbWVtfJe9W26Fb0E98vj0ljxu/rdhmPTzmQx4jf1u5y5FK89+ARDPznj3jvuuNwXG6juOmZ2begmumjKAKoKbxSFNpWW0LxkuIcf36SvSiXb89KbNDTTayutb19X6mvc3AOB2Btixs/zMMnNxxv65y/vO/tEqPxWLJpL9o/NFH32N1jFmJo9+Zo3qCmrTz1qpF9pWXY52Cp2/kbd2NfaRle/TEfH/6lf0wdpa0f/jVlFe49s7Pt67hB2oxRBNFFzUl4jmTzRxx/9jlrnQcgTBZGCvkXm2svu0VpWQUe/GoJ5q0P/r1TV42PfBu9fK5Vj7cgsrW4BO//UoBnf0huOO/9pWUoVoI4RsZQmPHH1mJMXREde0zbwPv4N//mgUmPIh1IoOdyICCT5xLhFo/WXnDKD0u2YPX2/ZYngPr17rLm2toe2MKNezCwQ2PDc5NFEBuBRvQcNQkVDBQ8OzzKjDT05WCHJ08bRSEIQcHOComAv+Nr6msfKfOu+k/EDOtFQD5tjtNWbEP9WlkJK207y7TLYLaQVAL0vgkO+I9Fbx8vKhZ1xajnZhzkJV8TQnUvf127M+J0UKOae9b6StNTXBF8J43GKNKXILVMBPt8YtE2/YIm/Hii7Np/OGrNDr0Ja0EIg+2F6WnCEu9X1qv0KLP2gfpZh6WNohCEoOCV3tauTpgoN3zojteSlYZK0ExPRrg1XrRzf2lKja2IokgDkvkhCRZIs8dhZUxm5TbrIdKrArd/ugDrdoTmiRjengC9J6IoBEHwFCu9hUTiOgW9Za5X/l0HDuMRZXXEVDANi6JIA1LhRRSqGKp3zkqPIt16vVbKG6R7IooiDbj6vd/9FkFQEZzPPzhU5cZMvHENI4UQpHsiikIQkkzh7tSMPusUS4PZ3ovhC0X7SuOWP0gKwQhRFIKQZI5YWbK0CmHJhJJAbZnMWFh2V5s87qmpuvvVxTUqeXjRqCAgikIQBNdRj0sko0eR0OJcHqNnemLDH5Vol4H1MwyRKApBEFznten5kW0rSiBR84vdln4y0SubeiEiq4PWfq7QJ4pCEATXUa/dYWVth0RXnAtyj8JN8rf7M99EFIUgCJ5iRQfYCZanR2mAexTxWFNkfZExv8a3RFEIguAplkxPCV4jCIs7GfHl/ELT46kQWFEUhSAInpIM09PhsuAqisLd7i1Q5pcrrSgKQRA8JRl1W8mR9Bij8AtRFIIgeMoRC639vYeOJHSN8kQHOVIEv8J6pI+iSOu1UAXBPzbvjT9x7NUf8+OmMSM91IR/pI+iEAShylJRwSgL8IB2quOpoiCioUS0kojyiWikQZpLiGg5ES0jok+9lEcQhKpJBQO3fTrfbzE8x6/BbM/WzCaiTACjAQwBUAhgLhGNZ+blqjQdATwIYAAz7yaipl7JIwhC1YXBUcu2Cu7iZY+iP4B8Zl7LzIcBjAEwQpPmRgCjmXk3ADDzdg/lEQShipIKEVhTGS8VRSsAG1W/C5V9ajoB6EREPxPRHCIaqpcREd1ERHlElFdU5O66wIIgpD5WFkeqCvjl3eX3YHY1AB0BnArgcgDvEFG2NhEzv83M/Zi5X5MmTZIroSAIgSdN9IRvCtFLRbEJQGvV7xxln5pCAOOZ+QgzrwOwCiHFIQiCYJl06VEEWlEQUR0iylC2OxHRuUSUFee0uQA6ElFbIqoO4DIA4zVpvkGoNwEiaoyQKWqtdfEFQRDSqUfhz3Wt9ihmAahJRK0ATAbwZwDvm53AzGUAbgcwCcAKAGOZeRkRPUFE5yrJJgHYSUTLAUwHcD8z77RfjPjIdDtBqLpc9/5cv0VICn6NUVh1jyVmPkhE1wN4nZmfI6KF8U5i5okAJmr2ParaZgD3Kn+CIAiCCRUBH8wmIjoRwJUAJij7Mr0RSRAEQdAj6KanuxGaGPe1Yj5qh5CpSBAEQUgS5T4NxlgyPTHzTAAzAUAZ1N7BzHd6KZggCIIQTaBNT0T0KRHVJ6I6AJYCWE5E93srmtArp4HfIgiCECAC7R4LoBszFwM4D8APANoi5PkkJJlrT8r1WwRBEHwi6DOzs5R5E+dBmSCHFAsBX1WWo6gq5RAEwT5BH8x+C0ABgDoAZhHR0QCKvRLKS+48I7UnfpPMCBGEtCXQpidmfoWZWzHzMA6xHsBpHsuWEnzwl/5+iyAIQpoQaNMTETUgopfCEVyJ6EWEehdpT+dm9XT392glA9GCILhLoHsUAN4DsA/AJcpfMYD/eiVUKpHsMQMZoxCE9MUvRWE1hEd7Zr5Q9ftxKyE80gEv6229V0L0hCCkLxU+LQtutUdxiIgGhn8Q0QAAh7wRKcUwqLn7tslOOOsa1eI/nouOzUn4OoIgpAZ+zcy2qij+CmA0ERUQUQGA1wDc7JlUHvPmVcfi3F4t46bLsNB8zzCwBQ3p1tx2XlqseGi9cHEv+xk7YFDHxkm5jiAIxgR6ZjYzL2LmXgB6AujJzH0AnO6pZB4ytHtzvHJ5n7jpuraoHzeN1fr/3iGdDI+d2O4o3f21q8daBmWMQhDSl6DPowAAMHOxMkMbSIPQ4NpKeUTv2F4IJVhzN6ydhc9uOiGhPJJBouUUBCFx6teyOqzsLokshVrlaw7t5LZ/XdIbo6/oq0ljMS+DitZuBSwVtiCkL3/qGd9k7gWJKIqUCuExtHtozGDoMc3jpDQmI4NiBpiN6m2v6nO/1ISoJ0FIX0wVBRHtI6Jinb99APxRbQ7p0rw+Cp4djm4t44872MHPkBqvXRF/nMUtiIDhPVok7XpCLP2Obui3CEKaYqoomLkeM9fX+avHzP4Yy5KIlV5BVjX9RGZebAseGeJQougJN12au6v0zDilUxP0kLDnviJWR8EvEjE9pSXa+l/PMylMh6Z1dfcbudRaQe31kMyKY0TvVsm7mCAIgUIUhQmJDBybnZqZSbiwb2iinPkVYrslfk3hl8as/0jkYMEvRFEYcP9ZndHRoEegZf4jQ/DjfadE7WtWvwbYoFLPoFD+TlBnmUjPxC5E5uY0wXuaNajptwhCmiKKwoDbTuug237Tq/wb1amOujWiTVAdmtbDMIPB30Rahuoww8lsX0prFujUzFrDwSvq1azyw4JCQBFF4SH3DK6cjZ2VWVnRElkbX9Brwasn3CSzRwECOLU8ogVBcAlRFB6SoQrwdPWJubpp7Nb19WpmYdLdJ+PuwR3RulEt3TSX9LMeKNBK4EFATE9A6vaqGtbO8luEtOSsY5r5LYJrpLWi+O72gfETaciuXd3RtWpmZUa2MyixKqdz83q4e3AnV2Zpz3tkCN7+87Fx05ld6Y7TOxgeW/b4WQ6kSj16Bth1uGNT/cW1BMEqaa0ojOYFPDHiGMNz+rdthLd0KtbaNazbj63W704VgVU1dMXxbVC3RjXUqxnb4qyZpZ2BbpznJf1aGx6rY+O+uE1OQ/0el1OsPI4m9Wq4es1E+cfwrnjtyuRNzBQqeXJEd79FcI20VhRGVM80vy1n6YQBqVujGuY8eIal/Cnyjzl9Wmfj5pPbxZVn9t9Pi5rEZ1W/nNReP2otANStEa08CPoD+QDQulFtaxdMMrP/fnrSZ5O3a1wHx+UGZwb1dQPaomk98Zbyg6b1q859T3tF0ctFk0Fzi+6L0a1z41o9I4Pw4LCucfPNaVgbDes4M4kZ8fqVmuCHZDyBsKpSzckiIgGjChRBCABpryjONAkS6JVTUQbB05CKduXWS6+NK0QgDO2egrGeEniGVSFkhp7JUNsICDqndm7itwhpT9orCqu8dIm1leQGd20ad3lS9cdru1J3MVWY43IbxeZAQH/V/rCcx7Ssj8Z13e29+EELC72/ahnWx2nCMOx7h2nn4HhN64bBNBUakZmCGnuaZgJuquOpoiCioUS0kojyiWikzvFriaiIiBYqfzd4KU8inNHFmqvbu9cc5/rypD1a2TOPxfuuhvWI7kVlGtgnxv71xJh9E+4chLx/OA9q6JSPrz/e0XlGt+KqE46Oe+771x3n6JoxMgSsnsvIAC7o42/srusHtrWc9q7B8ZcEdoPj28Y2mJxydEDH7ZzimaIgokwAowGcDaAbgMuJqJtO0s+Zubfy965X8hihN0Ab/rB7tc5OrjAGvHBxL1cGSLu2qI8XVUpMzzvqGCUMu/a2+F3ZEYVmRr/okhK+9dT2cdO014zJuHULhnSz7l+/6LEzXb9+txb18dKlvdHb4fvdvkmdhGV45E96VYE+el55VrAbhj+pE1hTDC97FP0B5DPzWmY+DGAMgBEeXs81wl4iV/Rv49k1jKwTg7vGViK1qmeiTxvrisLodf/hrkG4MI5Z7OPrj8fYm0+MmiwYytPfj4gATL7nlLjyx5znYGXBcNEdlVjnwWrzufXU9qhTPTM2oQ4Nark7WW7qvadEyu5kmKxmVgam3psaZpX6NhWMXuSBP1voeepR1Vai9FJRtAKwUfW7UNmn5UIiWkxE44hI1yGfiG4iojwiyisqKvJC1ihO69I0fF0M7hraNlp3IlG0ub7952N1Z9Iauabq5pmAqA3rVEd/nS64X++9lbEELfVVMZH0xD5deb7x8KqFyYiuSOw8WyvoNTbCJOq5NqhjE88qQavu5V6h97ydFrVqqQnA7yhj3wH4jJlLiehmAB8AOF2biJnfBvA2APTr18/Vr0r7jR6lcTN99fK+WL/rgOm6E25cN0xGBmHiXYOwatt+3eNufKN61379yr7YX1pmeI5fL36bRrWxZW+JLQG+uW0AqiuhSRK5X9pzzfIa1qMFFhfuBRC/pc4cXRx1761Pm2ws2LDHlpxaWma7478/9d6TUadGNZz4zI+RfU+d790kMqvu5Vax++xrVMvAm1cdi2krtuGLeYWhPFyVKHXxskexCYC6h5Cj7IvAzDuZuVT5+S6A+LEkkkyt6plJXUkOAFo0qIVTOjl3CVSbido1NrYnqz+kYT1amM6wdrsV+ceTQ1HPgrdPuNK1Y/qqW7Mackw8e+LlFC6rlWue36cViFBp77cqpiqd2png61sHxMyKt4vlDkqchB2a1kOLBpWz2/vnNgrU5L1XLnd/xvnQ7s2jZtc7jo5QxTSMl4piLoCORNSWiKoDuAzAeHUCIlI75p8LYIWH8qQN6pf0x7+d6k6eDs4xs8PXzMpEtczYXI0muanLVPDscFx5vPH4kbqCT+h7tdCjePRP3bDumeGVOxgx4eW1lU2f1tnRPQrN8UTHg5IR5bdbi+jG042D2uK83i09uZZRUMMBJpEFnBBplKhuv2PTUxXTFJ4pCmYuA3A7gEkIKYCxzLyMiJ4gonOVZHcS0TIiWgTgTgDXeiWPoZwJnGvXbVUPL94nL15RJ3Jq3W7v1rg5HlU3Ni5S/tPDond4UOfFK0v4cIzpSXNnf3vojMiMePWRvwzIxRsmk9oyMiiqIolRFAk+wD6tvQkholZAXZpHBxp8eHg39D3am+saBeKMVxmHn1d9i+t46HWw/HbiCAqezqNg5onM3ImZ2zPzU8q+R5l5vLL9IDMfw8y9mPk0Zv7DS3msYLVeWjLqTIy7JXaegfXr+Bez28nYqRstpLtV63MAwId/6Y+nz+8R+a03VyJ8n7SVqVkRoluE9uUOnxLvzGYGsXyIyFaQyDihvGxzQV9rcyQSeQP9WpJXzeGyCkvp7Eoa1SMVPQFAZmY7pl7NLNSoZs3F0Yyq0mJ59oIe8RNpaJldC1eoTEgDOzaOSRNe0M/OB6uX1Ey+S/u11p2f4UTJhBVb/HGQym3tzONE3wivzB5q3VCh2/p2zrm9QmYrK/NbgJAybGo1Uq9FTaGXzEmZ7jojORMEk0naKwq/G0ZWexZ25NRWFBkUa/Zxm8v6t4nxGHMT7Qdr9X6Ez8syabb/86KeuvMztNc0q3/tVs7q1F5U7ENNYpg5hQ229Whnc1JeZ8WUZeSSrI10/Pi5x8TM9THCSNZLDZw3zMYovr9jIEad0830Xb/yhMTmX2XpjN35TdorCi3dXRh3UPP8RT1jQmYkglkPpLrBanVrnxkeY/YJ5eUuXjRk480xuP+szjpyqL90JR8b13Sjl6cW4fObTsDl/Vtrjlcm0I7luKE4Rl/ZFyv/b6hpGruNJHW4+3imJ7dfhfev6x+Z0xS9vzLMyqOa2d7h22j0DmkjLuuly9TE++rcvB6uHdAW717Tz5LcTqiemaHrrPHlLSd5ds14iKLQ4HZkzYv7tcbrVxp7/dqtlMx6IH8f2sVSHuHQJK1cXtjHbRY+OkTXEyVE6Eh27ayYgVU1Dw3rikv65eBPPdWeSPr3/D/X9MPUe0+OHNZes1Mz4+t0ahaayHbDoHYxx/rlNsIzF/SM2hfOenjPFnjvWmeVjpk+ycyguKZRvXdpQIdYT6KwMs5Vu1rHUTJmkxW/0IkhZiYTEGoE6QVPPLVzpfK4qF+OrbDqVnrzRgEw+7RpiIJnK73d/jG8KxrrOGc4gYhiJLu8fxsc65GzgBX8nnDnO9qXJVmRPL00ecVrkN58cjuc0bWpacVnFbsrur1zdb+Y2cHjbx+AhRv3xKSN9nYxcJuNo2gb162B5y6yFh/qDM2MZnXe398xEJ2b18M4ZSKWnqzqiiOeXOFnNOqcY2LuoZ7bsPqcMFmZGZYHdK2w6LEzUSsrE53+8UPU/ubKoL3a3VmvR6FWJBcem4Nnf9D3Tamt4zYd7lWZfRfqQ3q9rvo1s7D2meHIHTnB8DwrmLsu61MjK/HxSvU1/DaJa5EehcKI3i3x0wOneXqNC/q0irRswzZzu616swrIaiiIjAxyRUm0yq6lG3bBzOtmSLdmaKuZBNgzJxtXn5irm96Rh5bB/vBAqfWlaCu3u7dqYDrOYXauGeGGytndm0eW2A1HHn3zqjjzT1X3xg27doNaWbrmy/P6tML9Z3XGvWdWmi/1FMWgjk0w4c6BWPfMMJzd3bq59ZxeLXH1iaGYSm7Wj+E7YtVDK5zsPFVk3WQt/HTtSbmVPwgI34lwAEa/va/SvkcR5uij6ni+pOdLl/aObDepVwOvXdEHJ7azNmmoaf1Qq9PKSnbJ8KSa/rdT0ah2dd0Q5bee2h5fzd+kc5Z9jExP6m/faqTbnjnZlq7pxt0L53FCO6PQ1dGDJ2/oKIVm9Y17az1zGmD55uLI7xsHtcPrM9bYktGqEs7MINx2WoeofXpeTwBwTMvQGJ/ZO6g99tT53S2FyFHLa+cZGZbTYL96Nrq25+KVR9nF/XLw/i8FoWsgVB8BQNvGdbCm6IDvPYy071H4+QD+1LNlZNJZ5zgt/OsHtsO/L+uNC01a6+GyJKP10bZxHTQwmDHrKqzvbqouq1XPsXAk1lbZ1npxCb0bkYFUg8M2BtlHaGY8PzniGIy/faCvcxni9V6dvoNm2Z5gsVFVKUSca8X8Nl5yIC5RLReL5xhQMysTNw5qh09uOD4SoNRv0l5RhPHbIe2rW08yjZ6ZmUEY0buVaYtmQIfQPISzPHCNtIf7d1NbbvV8BW1r16g1e2L7o/D6lX3x4DDzQf/KStz5Fx93jEL530pd/+/L+kSNf4SJttlbl80NEtFRsTPeVfma3HO155id8hrlWF1jStRraCXrtqpDonx20wnIzCAM6NDY955EGFEUAaFOjWoJR8/s1rI+Cp4drhsmPLm493bHy4kIGNG7FQqeHY564VANJl/3sB4t4noDuWm6M5LfDWUUrkQuOjYHN59ibaKa3vlOUPdmwpPl3CAcDPPCvqF5LWrHByIyjAVmikE5bz3Nwj1zeTKk8WUqc27fJLFQ8F6Q9mMUAVHYggGRVp7B/uid7lzz9C5NMWHJFsMlYq1Qp0ZIGRnNHnZDGV17Ui7e/6XA9aV3rRC+1S9f2hvDe7YwTTu4azOUHCnH7PwdAHR6FKodJ7VvjDVPD0MGhcYuarrgTWSkjLXjIvqxnqzjSdw2v00dCmnfo2ijDGC3qWJr3H5z2wA8d2HP+AktYCUceDRutsgVE5NBluoKt0ZW4mtQAMBLl/bCTw+cllCIlp452Xjx4l54Jk5oE12FZ7EAj53TDWu0QRRt8Ng53SLzP+wSHszOrp2l6w0WLkLLBjXx7jX9bD2TTCVoopmSsKNo3TSTGV7D4nVqGEyKDTqpKbWLXNi3FT698XjLgdRShd6ts3HJccbrS1hl0aNnYs5D/q48BsRWDHrf5JibTsR9QzrZXgJTS41qma54wF14bI7hes9mg9l3ndEBRPFXoyOihHo9x7c7CpPvOQWA9QirYe4e3BHN69c0jBgbM6YU5bHk3JxjpeJ+eFhXfHf7wMh1zOrvYT2ao2dOyFNLbx0QtyP7fn/HQFvps5SZ4X4rmLQ3PRERTmofG4xOCJEUzyYNn9xwfMSfP64nl2p/h6Z1cUeKBGQLT6rT8x46vUuz6DUuPGbBI0OQZbMi6tumoWkDIjJYn4BcZqjfhzE3nYCte0siv288OTQ7fs7anQDM51G8fuWxqKhg/Hvaalylsz62Vg8zG7+L3VrWx6xVRbpzUa4f2Bb/mb0OHVXejce0rI9lKhfn7+8YGDPZ8vy+rVCw8wBusRgs0SvSXlEIwSPsvQUY++tnK66uerN8U4H/XtsfY/M2WnbV9RIrc3PsUhlnSfnfw9FA226zGjIyCPcMiY2FBlT2fvq0yca5vVoaBiLs07ohzu/TCss2F+uun/GP4V3xiCYWVUNNOr04c1mZGXjAYmgeL0l705OQGmhbcX87qzMeO6cbhnU3H0h1m5dVkyYToUPTunhoWNekrYR2x+kdHIw1JY6VuQl+DNiaLREchSJb28Z1cN2AtobJeuQ0QL2aWYZKS+85B2Wg2gqiKIRAYzSxq2ZWJq4b0NZyqGk92jepY7tLrw7v4BdO2ub3ndkZSx4/y3VZjIiMD4R7FC51KOwMYhvNVblxUFvLkVgjV0tz90gxPQmuU0sxBxnFb3KCF2FJpt13qut5CiFM1+6I+Z3cpnWv1tmm5ragTHILEtKjEFynemYG1j0zDPedqW/3tUMyw5II7hOuc7X2+WTSyOYYjNpcdpQSZryZw8mwdhdwCiqiKARPICJX7O99j84GUBmnyQ9quRhCOl0Iu3OGo592bVE/Mi6Q0BiFg1eqfZM6GH/7AAzp1ix+YoTco+tUz8SzF/TAaZ2b4tXL++AenYW/rDD25hN114JPNcT0JASaUecegz+fkIuWPnkHvXt1v8gynYJ1smtXx/vXHYc+rfXnWSSDsJtqvZpZ6JmTjWOPbogpy7chp6H5HJnMDMKyJypXBzwngRAljevWwMCOxlGAT+/SFHsOHnacf7IQRSEEmhrVMtGtZf34CT1isMVWaDJIti0/UdSrz0WTnHL0bp2NfwzviguUuFE3DWqH0zo3DYziJyK8d+1x8RMGADE9CUKKcHG/UIV3aidvQ0/3ymmAx87xb0zBLYgINwxqFxmjyMigwCiJVEN6FIJriLeIt/TMydYNN+42395uL8yEXRIZo0itPlXVQXoUgiCkDP+97jgM69Hc99hHbpBKSk96FIJrGLUMv7ltAOav351cYYSUwc7Yy0ntG1eZ2GxPx4ksHCREUQie07t1Nnq3zvZbDCEgiIkyRBDifFkl9ftvgiCkNDKZMviIohAEQRBMEUUhCIKvSIci+IiiEARBEEwRRSEINmlazzgkgyBURTxVFEQ0lIhWElE+EY00SXchETER9fNSHsFb/npKaG2HejbXX041Jt19Mqbdd4rfYlQZkrV4k+Acz75oIsoEMBrAEACFAOYS0XhmXq5JVw/AXQB+80oWITncMKgdbhjUzm8xPKdhneqOlg+97bT26NvGvyB5gjcM7uptSJUg4GXTrz+AfGZeCwBENAbACADLNemeBPBPAPd7KIsg+M79Z/m/9nEQSeX+xKr/OxvVElhlMVXw0vTUCsBG1e9CZV8EIuoLoDUzTzDLiIhuIqI8IsorKipyX1JBEAQHVK+WkdByvKmCb8ZkIsoA8BKAa+OlZea3AbwNAP369ZN5nYJQhUi3IYqxN5+IHftL/RbDFl4qik0AWqt+5yj7wtQD0B3ADGUwqzmA8UR0LjPneSiXIAiCb/Rv28hvEWzjpelpLoCORNSWiKoDuAzA+PBBZt7LzI2ZOZeZcwHMASBKQhDSDPF6Cj6e9SiYuYyIbgcwCUAmgPeYeRkRPQEgj5nHm+cgCIIdPr7+eNSvFWDXZNEHKYunbxUzTwQwUbPvUYO0p3opiyBUdQZ2rBrht4XgITOzBUEQBFNEUQiCIAimiKIQBEEQTBFFIQiCIJgiikIQhCQjc2ZTDVEUgiAIgimiKARBEARTRFEIgiAIpoiiEARBEEwRRSEIgiCYIopCEARBMEUUhSAISUFiAqYuoigEQRAEU0RRCILgC+f3aRU/kRAIRFEIguALL17cC388OdRvMQQLBHiVE0EQqjIZGYSaGZl+iyFYQHoUgiAIgimiKARBEARTRFEIgiAIpoiiEARBEEwRRSEIgiCYIopCEARBMEUUhSAISaFW9bArrATzSDVkHoUgCEnhzauOxZfzNqF9kzp+iyLYRBSFIAhJIadhbdw1uKPfYggOENOTIAiCYIooCkEQBMEUURSCIAiCKaIoBEEQBFNEUQiCIAimiKIQBEEQTBFFIQiCIJgiikIQBEEwhZjZbxlsQURFANY7PL0xgB0uihMEpEzBp6qVB6h6Zapq5QFiy3Q0MzdxklHKKYpEIKI8Zu7ntxxuImUKPlWtPEDVK1NVKw/gbpnE9CQIgiCYIopCEARBMCXdFMXbfgvgAVKm4FPVygNUvTJVtfIALpYprcYoBEEQBPukW49CEARBsIkoCkEQBMGUtFEURDSUiFYSUT4RjfRbHqsQUQERLSGihUSUp+xrRERTiGi18n9DZT8R0StKGRcTUV9/pQ9BRO8R0XYiWqraZ7sMRHSNkn41EV3jR1lUsuiVaRQRbVKe1UIiGqY69qBSppVEdJZqfyDeSyJqTUTTiWg5ES0joruU/Sn5nEzKk8rPqCYR/U5Ei5QyPa7sb0tEvynyfU5E1ZX9NZTf+crxXFVeumU1hJmr/B+ATABrALQDUB3AIgDd/JbLouwFABpr9j0HYKSyPRLAP5XtYQB+QGhR4hMA/Oa3/IpcJwPoC2Cp0zIAaARgrfJ/Q2W7YcDKNArA33TSdlPeuRoA2irvYmaQ3ksALQD0VbbrAVilyJ2Sz8mkPKn8jAhAXWU7C8Bvyr0fC+AyZf+bAG5Rtm8F8KayfRmAz83KanbtdOlR9AeQz8xrmfkwgDEARvgsUyKMAPCBsv0BgPNU+z/kEHMAZBNRCx/ki4KZZwHYpdlttwxnAZjCzLuYeTeAKQCGei68AQZlMmIEgDHMXMrM6wDkI/ROBua9ZOYtzDxf2d4HYAWAVkjR52RSHiNS4RkxM+9XfmYpfwzgdADjlP3aZxR+duMAnEFEBOOyGpIuiqIVgI2q34Uwf2mCBAOYTETziOgmZV8zZt6ibG8F0EzZTqVy2i1DqpTtdsUU817YTIMUK5NiouiDUIs15Z+TpjxACj8jIsokooUAtiOkhNcA2MPMZUoStXwR2ZXjewEcBQdlShdFkcoMZOa+AM4GcBsRnaw+yKG+ZEr7OFeFMii8AaA9gN4AtgB40VdpHEBEdQF8CeBuZi5WH0vF56RTnpR+Rsxczsy9AeQg1Avokozrpoui2ASgtep3jrIv8DDzJuX/7QC+Rujl2BY2KSn/b1eSp1I57ZYh8GVj5m3Kh1wB4B1UdudTokxElIVQpfoJM3+l7E7Z56RXnlR/RmGYeQ+A6QBORMjsV005pJYvIrtyvAGAnXBQpnRRFHMBdFS8A6ojNLAz3meZ4kJEdYioXngbwJkAliIke9ib5BoA3yrb4wFcrXiknABgr8psEDTslmESgDOJqKFiLjhT2RcYNONB5yP0rIBQmS5TvFDaAugI4HcE6L1UbNf/AbCCmV9SHUrJ52RUnhR/Rk2IKFvZrgVgCEJjL9MBXKQk0z6j8LO7CMCPSq/QqKzG+DF678cfQl4aqxCy6T3stzwWZW6HkHfCIgDLwnIjZGecBmA1gKkAGnGlV8RopYxLAPTzuwyKXJ8h1M0/gpA99HonZQDwF4QG3vIBXBfAMn2kyLxY+RhbqNI/rJRpJYCzg/ZeAhiIkFlpMYCFyt+wVH1OJuVJ5WfUE8ACRfalAB5V9rdDqKLPB/AFgBrK/prK73zleLt4ZTX6kxAegiAIginpYnoSBEEQHCKKQhAEQTBFFIUgCIJgiigKQRAEwRRRFIIgCIIpoigEQQciKleiiy4iovlEdFKc9NlEdKuFfGcQkSsL3gtCshBFIQj6HGLm3szcC8CDAJ6Jkz4boWidglDlEEUhCPGpD2A3EIodRETTlF7GEiIKRxJ9FkB7pRfyvJL270qaRUT0rCq/i5V1BVYR0aDkFkUQ7FMtfhJBSEtqKVE6ayK0tsHpyv4SAOczczERNQYwh4jGI7RWQ3cOBWwDEZ2NUDjn45n5IBE1UuVdjZn7U2jRnMcADE5KiQTBIaIoBEGfQ6pK/0QAHxJRd4RCVzytRPGtQCg8czOd8wcD+C8zHwQAZlavXREOuDcPQK4n0guCi4iiEIQ4MPOvSu+hCUJxf5oAOJaZjxBRAUK9DjuUKv+XQ75BIQWQMQpBiAMRdUFoScydCIVq3q4oidMAHK0k24fQkpthpgC4johqK3moTU+CkFJIa0YQ9AmPUQAhc9M1zFxORJ8A+I6IlgDIA/AHADDzTiL6mYiWAviBme8not4A8ojoMICJAB5KeikEwQUkeqwgCIJgipieBEEQBFNEUQiCIAimiKIQBEEQTBFFIQiCIJgiikIQBEEwRRSFIAiCYIooCkEQBMGU/wdLb5VIqXrCUQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I think the sub the sub the sub the sub the state the state the state state the state the state state the state the state is the state the state state. It would be there and then the state the state the state the state the state the state the state the state is the state. It would be there the state the state the state is the state. I would suggest the state there is the state there.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, whil is trem to be some to song when I work work with to solve when I have no some sort of work words. I wondering what I had to show there. I was wondering what I was working with them. I would some professor to some things who happen work with them.\n",
      "I would something the sound I want to spend to the sound to there. I would some to some things who work with the sounds whole I want to some which I work with there. I would some things I would have to some which is working.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "\n",
      "I would say to spec to some to some to some to some to some to some to some to some to some to some things who work work what you would be some work. I would be some to some things work work with the sound when I want to send the sound when I want to send the sound when I want to so more there. I would some work with the sound I would some while I want to some work. I would some work with the solve while.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I have take to some the statistics when I want to start working with the statistics when I was working with the statement when I was wondering when I was working with the statement when I was working with the statement when I was working with the statement when I was working with the statement when I was working with the statement when I was working when I was working with the statement when I want to start which there.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "`````\n",
      "```````\n",
      "````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I don't know what you want to do with these. I don't know what you want to do with them. I would be something when I was working with them. I would be to send them to start when I was wondering when I was working with them. I work with them. I work with them work with them. I work with them. I work with them. I work with them. I work with them.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "\n",
      "I would say this in the same is professor. I don't know what the process is the same thing. I don't know what the process when I want to send the process the same solution when I want to spend the process that I want to spend the process that would be some there. I would some there in the state whole I want to spend the process there.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "\n",
      "I don't know what you should be in the comments when you chosen the process in the comments when you chost the comments when you'd send the process the consumer that instances the consumption the consumer that is not the consump the consump the consump then you'd send the change. It would be there in the construction the change.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I would start with these the statem in the state in the state is the state in the state in the state is the state in the state there is the state there in the state there. I would send the state there is the state there in the state there is the state there that the state there is the state there in the state the state there is the state. I would suggest the state there is the state there in the state.\n",
      "\n",
      "Epoch 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:07<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/KUlEQVR4nO2dd3gVZfbHvychoXcQ6QEEpAgIiIBiQREUVyxrX+uqa3fX1d9i7yt2111711WxryggggiK0hWkQ8CAhN4CoSQkOb8/7kwydzIzd+qdufeez/PwcDPzzsx5p7znfc973nOImSEIgiAIZmSFLYAgCIIQbURRCIIgCJaIohAEQRAsEUUhCIIgWCKKQhAEQbBEFIUgCIJgiSgKQfAIERUQ0ck2y15ORDOClkkQ/EQUhZCWKI33fiIqJqKdRDSeiNraPDaPiJiIagQtpyCkAqIohHTmD8xcD0BLAJsB/DtkeQQhJRFFIaQ9zHwAwCcAuqvbiGgkEf1CRLuJ6Hciul9zyPfK/7uUEckg5ZiriWgZEe0hoqVE1FdzTB8i+pWIiojoQyKqZUc2IhpMRHOV4+YS0WDNvsuJaI1yvd+I6GJl+2FENF05ZhsRfejuzgiCPURRCGkPEdUBcD6AWZrNewFcCqARgJEAriOiM5V9xyn/N2Lmesw8k4jOBXC/ckwDAGcA2K4533kARgDoAKAXgMttyNUEwHgAzwFoCuBpAOOJqCkR1VW2n8rM9QEMBrBAOfQhAN8AaAygDWSkJASMKAohnfkfEe0CUARgGIAn1B3MPI2ZFzFzBTP/CuADAMdbnOsqAI8z81yOkc/MazX7n2PmDcy8A8CXAPrYkG8kgFXM/C4zlzHzBwCWA/iDsr8CQE8iqs3MG5l5ibL9IID2AFox8wFmlslxIVBEUQjpzJnM3AhALQA3AphORIcCABEdTUTfEdFWIioCcC2AZhbnagtgtcX+TZrf+wDUsyFfKwBrddvWAmjNzHsRGwVdC2CjMhl/uFLm/wAQgDlEtISIrrRxLUFwjSgKIe1h5nJm/gxAOYBjlc3vAxgHoC0zNwTwEmKNLwAYhVT+HUAnn0XbgNjIQEs7AIWK3JOYeRhik/HLAbyqbN/EzFczcysAfwHwAhEd5rNsglCJKAoh7aEYoxCz6S9TNtcHsIOZDxDRAAAXaQ7ZipjZp6Nm22sAbiOifsr5DiMifSPvlAkAuhDRRURUg4jOR2zC/SsiakFEo5S5ihIAxYpMIKJziaiNco6diCm2Co+yCIIp4icupDNfElE5Yg3pWgCXaez81wN4ioj+A2A6gI8Qm9gGM+8jokcA/EhEOQBGMPPHRNQUsZFIawAFAC5BddORbZh5OxGdDuBfAF4EkA/gdGbeRkQtAdwK4B1F/gUArlMOPQrAs0TUEDG331uYeY1bOQQhESSJiwRBEAQrxPQkCIIgWCKKQhAEQbBEFIUgCIJgiSgKQRAEwZKU83pq1qwZ5+XlhS2GIAhCSjF//vxtzNzczbEppyjy8vIwb968sMUQBEFIKYjItSu3mJ4EQRAES0RRCIIgCJaIohAEQRAsEUUhCIIgWCKKQhAEQbBEFIUgCIJgiSgKQRAEwRJRFBGjuKQM//ulMGwxBEEQKkm5BXfpzl2fL8IXCzagY/O66NWmUdjiCIIgyIgiamwsOgAA2FtSHrIkgiAIMURRRAxKXEQQBCGpiKIQHLO3pAzvz14HyY4oCJmBzFFEFEZ0G+GHvlqKsXN/R7smdXBs52ZhiyMIQsBk1IiiaP9BPPTVUpSWVYQtiimUAranbcWlAIB9pWUhSyIIQjLIKEXxxKTleH3Gb6nhfhrdAQUiLpwgCD6TUYqirDzWwJVVRLehoxSazqZUGP4Iljz37Sq8+v2asMUQIk5GKYpUatesVNnsNdvx6MRlSZNFSF+enrwSj0yQd0mwJqMUhUqUJ4rtKLPzX5mFl6eH1wsUZydByCwyTFHEWuFUaOhSQcYUGqAJguCBjFIUQZie9peW4+vFG307XyqZxwRByAwySlGo+NlZf+DLJbj2vz9jwe+7fDyrIAhCdMgoRVHZWffRrrN+534AwJ4DB307JxDteZToSiYIQhBklqIIwaxzsLwC89futF2eUmgeJZ2pqGAU7fdX+QtCqpJRikIlmW3wmInLcc6LP6HzXRMM9xds24vCXfuTKJFgh6cmr0DvB77Brn2lYYsiCKGTUYoijMVsyzbuBgAcLDdWTyc8OQ3HjJmaTJF8I50n3sf/GnNQ2LlPRhWCkFGKIgycmpDUxjfKlqdMihqbSXUVBDMyUlH4+e1HedI5Vfho3u/IGz0eB8ujE6xRwpMIQhUZpSgqe+vSS4wUjyohJPYckGi0ghBFMktRBHLOYHqeqaDM/Op0ZyknqohgnaMnkSAkn4xSFCpR/vgzweTx7qy12FZcUvk3OVAUc37bgR/ztwUmmyAI1ckoRaE2SMnsuEZtDmPXvlJ8ODe8NKb5W/bgnv8txk3v/1K5LavSJJj4+PNenomLX5sdkHTBs3VPSeJCQtKZsGgjHvpqadhiRJaMUhSpRFDN+LNTVuEfny7CDA+9ci+ylZbFjt6pWZ8QRdNTEOO6CYs24qhHpmD2mu0BnF3wwvXv/YzXZ/wWthiRJVBFQUQjiGgFEeUT0WiD/c8Q0QLl30oi2hWkPCrRaY6qUxVmJJjzb959AIC3iWO1PXczP2NkWVNHFBHOJ+ULc37bAQBYsmF3yJIIgjMCUxRElA3geQCnAugO4EIi6q4tw8x/Y+Y+zNwHwL8BfBaUPDGZjLcv2VCErxdvcnVO1bS0t6QMd32+yHMe6aCnKJLVaWdmfP7Lelv5ySvnKHzSFOUVjC8WFPpyviDuV5rrQ8FnNhbtR3nIvaggRxQDAOQz8xpmLgUwFsAoi/IXAvggQHkq0dvnRz43A9f+d76nc778/Rq8N3sd3vyxwNN5kkXQU+aTlmzG3z5ciOe+XWW4X/sIsrKqb/PCOzMLcMvYBRg793f3J/HpBm0rLkFxSazzkAF+CoLPbN59AIMenYonJq0IVY4gFUVrANovdb2yrRpE1B5ABwCGsSyI6BoimkdE87Zu3epaID9dWUvLKvDS9NWVebh/WbcLgH9urU4mwX/K34afVgfrCZQ3ejxu/WhB/EaL21m0PzYHsWXPgfhDDE1P/s5RqB5V24vDnzju//AUDH1yWthiCCHz/cqtWOgiFYHq/PD9Svftnh9EZTL7AgCfMHO50U5mfoWZ+zNz/+bNmydZNGNen/EbxkxcjtmK3dkv3Kiyi16bjYteDd4T6LOfCx0fY9b2axWhWme/FEUYMb2s2JLA0+n7lVuxdvveJEkTDtuLS1CUwXGzLn1jDkY9/6Pr48M2VwapKAoBtNX83UbZZsQFSJLZyS/2ltibi4iQI08kMGrE1RFFNG+V/1LpR52XvjEHxz8xzffrRIl+D09B7we/8fWc/5qyCvPX+ttRixpRMVcGqSjmAuhMRB2IKBcxZTBOX4iIDgfQGMDMAGVRrhX7X/1OJy3ZhN+2VfXkmBlPTFpuK+x3lskDnOcg94QVdhRMSVk5vvp1gy/Xc4KTptPOix5UaBUvZ1PF9lOkqI10Up1npqzEOS8G3mx4RvU0TGVqBHViZi4johsBTAKQDeANZl5CRA8CmMfMqtK4AMBYTsIKMP1n+pd34yewl23cg+e/W40Z+dvxxQ3HJDiZ8Uc/bYU3W6KTldlPTlqBV3+Itu+3qelJO5mt1NmPmIALft+Fn9f5o6wFwQ8+9OJUERECUxQAwMwTAEzQbbtX9/f9QcpghNlEsWojt+XSabGvvIJRXsHIreF8wDZ1+ZaYjDbU5oYi5z2VZK0Ud9J7rgqt7l22MzV2YDH7CYI/RGUyOynoTU9+nMuI816eiS53T/R+EY8U7T+I3T7n8taSzoaUIGJuRcXenGrs2Ftqe04wivjR3oQdJDTDFIW9L9VOKaseszZHdqCPN8HJez/wDXrdH5tA/HndTmws8iflqpeXNhUSMwVNott3x2e/4vB7wutoLC4swuVvzrE1si6vYCwNeKV534cm44QMdTGOyrxWRikKFT8aKbPJbL/wuyE9+4WfcPzj03w+qz+oH8NT36zETR/8kqC0ffwwZTk5w96SMoyZuBwlZYZe3rb5YM7vOHAwvCROt328ENNWbEX+luKEZZ+ZvBKnPfdDZcrfoLAbTHHMxOV49fs1gcrilHQYSWaUonDiybL7wEG8M7PAtPccfKgN//vcpRHKIKdFvZeTl27GlwuD8+LasbcU020uXHLzeP89NR8vTV+NsXOiNXk5ds46LC4scnycHUW7cP0uAInXiiSLl6avxiNKIqwg+GJBIU5+erqj7zMd5soCncxOZe7+fDHGLdyALi3qY2DHptX2RyFvhJcesx/iu7kHVcqasXNvKfo9PNlVMMBd+0rRqE6uo2OOemRKzFTy4HDUyfX/1VdHEis27zHc7+cbs3b7XqzcXIxh3VskLDv6s0UAgIIxI32UINpsLy5B03o1fT/vLWMX+H7OVCCjRhROUMNgl9iw06YqG3btx4pNxo1aUGh1y4L1u1xHjLXTg9X35NTAalYB1lZvTWxuMeP3HbE5oPdnr7OWyweT2ElPTcfV78zzfJ50ZeCj3wZ6fiejBC+dsgj0RwFkmqLwwQ1TjQ4buOnJThmP7c3gMVMx/NnvvZ0kAVEcdZvJ9MWCQpz01HR8u2xzVVlHFUhebcsCjCYa5Gj5YHkF7vx8EbYEvAjtYLk/92fGqm2Gc05Ozp4OpqeMUhR2PQjKK9gwX8Oi9UXofu8kfL14k61zGaXsXL21GC9OW21LjqjjpTnx+u14urbJxVXvnVVbih11BAp37ccDXy4JtEH454Rl+JPPmf0OHPQ26e6Gqcu34P3Z63D3/xYn/dpOWbKhCH96fTYe/qpqziOoKAJRJ6MUhUqiZ7xi8x4sUCI9PjtlJQYpw9hfC2Pbpq/cYsvr6eLXZldrEc99aSYe+3q557wVQbJofRGWbdyN+8ctMQzk5u0bsdcC52/Zg7zR4/HDqsSTz8yMD+euq7ZmxFRMkx3qgkunSujWDxfgzR8LMD/BinAvHfVXvl/jKSuhEWe98JPl/iDbwmSmV9hUdACDH/3WVuDFXftKccoz05G/ZQ92Ke++kTkys9REhikKNx/qL+t2YaOyAjq7MsGO+4/eTEHow3GH2WH5w39m4NR//YC3firAoxNdepAkuD/bi0stXR7VqLwTFm003L9U4445c/V2/OPTRZVrRioxuYmJTI/aZ2vHTKkqGLtZA+0+2+kBR5U1c2kN0qoahsn9iwWF2FB0AO8lmDsCYiOelZuL8fx31qP+IL/Ptdv3YuryzXHbwh7AZJSi8IrqPVLOjA98doHM31ysUyLBvBnqC2fXhmtn0ZXxhWL/fTJ/vaGyKdp/EP/3ya/uzg3EffTFDlftmn10KzfHeo4bdjmzn6sKL1EWMtX2b/fJXpZCUWWdKwB37/eW3QewY29p4oIOeHdmQbVtiUxLz0xZGZj56cQnp+HKt2KOCjKZHQJa10ynaNNqlldwXNRZP6jg2KI4J3h5T90ubHvgyyUoq4gpD/Ulvu+LxZaJk16eXrUAKiovvhHqGou3fipwdNx+n2z9L09fjVlrtns6x+NfL8dVb8/1RR4n2H0VVWU5ZdkWV9cZ8M9v0fehyY6OSSTbPV8sqfytfT/X7dgXO97gBC9OW43Nu81HxH9+ay7OesFd/oko5o7PqHUUiRqp0/89w3SftlfsR4Id/WQ4g7E8ya6qdpm8tGoYbJTq9e2Za/H2zLXxfvoeFYJ6f+zcarMiTre7vr5PH/ajE5d7PscLaeIo4YSCbXuR16xuwnJOX8k7FAuC/hx2Hve3y90pwqiSUSMKFTcftjact5NE53obt52w20Z/n/PiT7jhvZ/jtu1NwoR44a79SffX/++stXh8kvdGU8vTk1dW/n5jRvCh2fUeReUVHIqXkRvcjPrsHhLEgPLsF+2NxN3qc7P7ETeXxYwXpuX7Fk8tamSUoqjsJXo8j18pO7VMWbbZcv/8tTsxftHGOLPZD6uCzZMNhLPg8O7/La70OPHrVj/37arK3//5Lr/a/oteneXofA9/tTQupLkefc/+xvd/xjsz1wIIf2IyCCqYcetHC1zlhfbK7v3+R0jWPiI7z2v11r14/OsVuPa/Pycu7EoeiR6bclT40Hb+onOlVBuRRMwtSG5SHqvepZvIlr71KH02Cf20On5uQK33VW8bj6Zem/FbpQu10WX260Z7Exdvsi9MCrKtuBSf/VyIqxKMPsOco/IaFRowX4yoztvt9HmiXaLHpjDlHrqE6pEXvTbbMleE2RXOe9lb6kenkmdFZPa5ooIN13RY4UcvzE5aXKPXIajVzd/bDGqYLBJ9Cks37I7znAvjdfJzBKcd0RtVZd2OfcgbPT7+mDRYdZFRikJ9Sb0OVStcuiWMnRPvx32LhedRcUkZ8kaPx8fzwo1Emu3gy9belxk6s9jyTbvR875Jlp4iVvzr21Xo/WDVOom5a3egzEM03OWbdrt+jlryRo/HtuLqdQqqPZzp0SuqpKwceaPH4+lvVsRt/3rxRhz72NS4e+q1gf19xz6c9twPeHj80sptyewhb7Ch5M1wWvcgzIkHDpabriNKNpmlKJT/X5vxm6cJWrceDaN1XhQF2/eZllXXGDw7ZZVpGT0bi/b77tvtpAf44vQqu/w4Xbjwt39ai+KSsmoLiRKh9sYmLo7/YJiBJ79ZaXSILUY8+0OcvH6z0iSCLBBuD3NfSWxC/W2dqfPOzxdj/c79KNp/0NEz15fdta8UL0zLBzNXrndYoJ230JXfVlyCJRtiIdB/XrcT5788Eyc88V3l/iIPnTrVacFJfZ6bav29mY0UrT47t8rxwa+W4l/K3FrY81oZpSi0aF0+g8QqeJvffatBj07FA18uTVzQgk/mr4/7O9tBhiavawCsMLqNyzftRuGu/Zhi8iwTfVyL1pvnaNhW7M3W/N2KYExE63fux8saBdfj3q/xzRLj+Y+5BTuqhUAxazS1HYzFheZJiBYXFsWZTPX3+GA54/GvV2DWmh2m59Ay/JnvMfK5Gdi5txRnv/ATZv+2I64D9YKB4wEA3PtF4lhRblIfr9nqYH2UzRX8bjsG63dGx4Mqo9ZRhGEg/WXdLvOdAYjz1k8FuH14V9StWfVotxuYRsx4d5a9SfVkYzRSmrZiK44ZMzWQ6xmZk1QOhpgA6suFG+KSO+0tLcfjk1bglB6HxpWbuXo7LnTgyaXeXW2P2aiBO/3fM9C7bSN8ccMxlueL3aPsatv1r/x2ZdSxz8R12KyJtev8YXlxFySzBYlS4MGMGlFEY1rWGXYmU/VM1ZnG1NAUdnByj/R6d+32fQlNS24ned18MwcOVlg2+G7ZVGQvxIfZs/P7+zdqUBIpCf0xqjuyfk6MmbF+Z7yJNAwXWD9Yu83c1Ksnzj3WxoggCNNTlMgoRREJ2OR3RPAy6Fq3Yx+ufGueqSkIcK6s1Q/Qza1648ff0P/hKeayuKjrngMHK3vBiQhqtKNn9da9GPTot7YiEn/5a2yux+x+6leHv/z9Ghz72HdYZTHnAsDymWsbUbsdhbzR47HZY84K/bW+NjHRuWV/qb0FlOL1lGJExNPTMUaJU6zws57WPSVj/JwkVi/vd2wttwx9arrlQruw2Fh0AKu3JL5H9zjIA8EcM2EBMXu5lSnEbiNsNudgxMzV2x1FQdDj12dgNiLQBmz0Y5Q4f+3OONda7TnDVjUZNUcRhSFgqdb90OYxf3l3vqNrGMWRUjGaxH9y0grMKdiBvu0ao8yHzGBe3Fb1fL9yq2HMHT9wo1CtQqNHncWF5pP3ZsSHqfAugxo+3g7bikvwug/hVrz26IMaEezaV4oB//wW71w5AAM7NrWVeyUsMmpEkapM8+pBk+A9/893+Zjz2w68NH01FukaEzcfieURDhvnLXtK8MGcxHkE3FBcUo6KCnafcyNiOAl6aTd3RmXEZd2b0OWuiZUZAY1gAE8qazXM5LrsjTlV5Q20kF2vH9N6G2xnZlsut2ajJ1OvMRffyS+/70JpWUVKBHLMGEUxt2AHnpni3u8+CILyakiW6Sm23+nKJPeyBEHHOyfEhUEX4lHt/BUV8c+6tLwC78229jxKFItseoJV5nYXxpq9gkbPtd/DU9D7gW8cLcYLyhKRKO2BVvnkb7HvkBIEGWN6mr82uTGS7BCxNtM3jHqCn+rWZ0SB8A2R0Ud7j4J8X40muT/7pdDzefNGj49bC6QuAizctR+tGtW2dQ47o4V9Nie2tTj1AJy5ejsGdWrq+Dp+kDEjikxqFPR19fKBuzEjGWUgKw1x7YEZDtYSAkC1GD7JIix/er2DnpEYyfTocWoOUjGaEGeOebCZuU/rj5i9ZnvlCnIjrv2vs3lEPSVl5SjWmQP11b3h/WAi09ohY0YUUfR4itB6GnMsZLzmnfn494VHJk+WNEHb4NlJ62kV6iVonOYPd4sdZXj5m/5l7ntxWr6j1fPnvxJbl5KTbdyQ7HIYsBLQmp5i+Wb0K+Kj1D5kjqKI4JgiqA/v6yWb4mIteXnhrGQsLinDFW8lP+2mU16YZuySGVSEVyfYSevpxUXUL5jZ0XsUxCgo0ZyGExIpifG/VsUW04YjIds57oz5cuEG7D9YjvP6t60KMQK2DJsSBTJGUWQSXyyID8jnRSHtdNFTsiKMJu/xr1ckLmTBte/OR/P6NX2Sxjnh6rPYxT/7uRC92jSK27PbpudUOvPR3N9xTOdmtsuruerP6982LmumEVFaqJcxiiICncdqRGloaYbf3hYRfAwJ8XtFb9H+gzjlmem4/4wetsq/ZZCnPFmo383XSzZhx754M9mXCzfgmMMST66mwnvulv/79FfkNa3j+LhlG3dX5haxmx45TDJGUQjRIELvfmhKa+ryLVi9dS8uenW2rfJhBWo8cLA87h4Z5YP+MT9xxGA7qYOj1ChaYvDSuJlD+uvYBZW/U6HumeP1FMEhhRuXOjdE6UWMUkTMeSG5TAd1B6y8ctxwwSuz4kbiv+9wF/baziOP0GthjU9yRrA5siRQRUFEI4hoBRHlE9FokzLnEdFSIlpCRO8HJYufYSX8wo7HS7pRXBIdu7aXpDieCKhR1CfGChOnVSwtT06nKQzcKkH9YWHqlsBMT0SUDeB5AMMArAcwl4jGMfNSTZnOAO4AcAwz7ySiQ4KSZ2+Seu9RJEqdtQ/mhJvaNZ0Jolc+aYn3BF92xJpbEL0FsckiSpPWZgQ5ohgAIJ+Z1zBzKYCxAEbpylwN4Hlm3gkAzOwux6gNnC6uSieiZO4RMg95/1wSodsWpKJoDUDbfVyvbNPSBUAXIvqRiGYR0QijExHRNUQ0j4jmbd3qzpc6iusohMwkQt9/ZLAz4W3GQR8iHtvFaYQBfWphlbgQ4mZeT7o3xW4elCAIezK7BoDOAE4AcCGAV4mokb4QM7/CzP2ZuX/z5s1dXSjVJo+E9CUquTWCRBvOPhmT2QdMUqmGzW0fL0xYxknVt3hM5uSWIBVFIYC2mr/bKNu0rAcwjpkPMvNvAFYipjh8J5P1hPRghWTz/uyq0PC2Uol6vF4UY4lZYeeelBmsyA9rVBGkopgLoDMRdSCiXAAXABinK/M/xEYTIKJmiJmiAon5LCMKQQgHW6MFj0OK0rLUUhRx8ppU/Zd1u5Iiix0CUxTMXAbgRgCTACwD8BEzLyGiB4noDKXYJADbiWgpgO8A3M7MiVfwuCCK6yiShgwphBCxteDO4zVSTVFoF+mlgtdToCuzmXkCgAm6bfdqfjOAW5V/giCkIXaawQqPgQ8PppjpyS1hOZCFPZktCEK6Y2cy2+MlUm1EoSUVvIdFUWQAKzfvCVsEIYNJRjtYksqKImwBbCCKIgN4dOLysEUQMhg7C+689qqj7PWUqGpO0jSHNZ8hikIQhECxNUfhUVN4neMQrBFFIQhCoCTDBh9lPZEO/paiKARBCBRbC+48NvTMbJgvIwp8+rNxGI9UQhSFIAiBYiuEh0fbewUDI5+b4ekcQbF+p38KTNxjBUFIS5IR64nBGZnfJVmIohAEIVBseT15vobHEwiWiKIQBCFQNhQljnj6/NR8T9fIFEUhpidBEDKWPR5T5Hp1r00VwqpnxigKybIlCOnLosKisEVICqIoBEEQXPLEpBVhi5AUwlovIopCEAQhRQjLMmJLURBRXSLKUn53IaIziCgnWNEEQRAELVEfUXwPoBYRtQbwDYBLALwVlFCCIAhCdaI+R0HMvA/A2QBeYOZzAfQITixBEARBT+QVBRENAnAxgPHKtuxgRBIEQRCMiPo6ir8CuAPA50re646I5bgWBEEQkkRYIwpbObOZeTqA6QCgTGpvY+abgxTMb2QZhSAIqU6kJ7OJ6H0iakBEdQEsBrCUiG4PVjRBEARBS9TnKLoz824AZwKYCKADYp5PgiAIQpKI9DoKADnKuokzAYxj5oNIjZzggiAIaUNFSKnB7SqKlwEUAKgL4Hsiag9gd1BCCYIgCNWJtOmJmZ9j5tbMfBrHWAvgxIBly3h6t2kYtgiCIESIqE9mNySip4lonvLvKcRGF0KQUDqkZRcEwS+iPkfxBoA9AM5T/u0G8GZQQgkK4tMrCIKGSI8oAHRi5vuYeY3y7wEAHYMUTDDmlO4twhZBEISQiPQcBYD9RHSs+gcRHQNgfzAiBUMq9s2NZG7duHbS5RAEIRpEXVFcC+B5IiogogIA/wHwl8CkCpBjD2vm6/lGHtHS1/MlgiDzFoKQqUQ61hMzL2Tm3gB6AejFzEcCGBqoZAFxZLtGvp7vimPyfD2fIAiCGVEfUQAAmHm3skIbAG4NQJ6Uo0WDWmGLIAhChhD1yWwjxAYSAnqP2XP6tglHEEEQkk5FSJrCi6JIxflhAMDsO0/C4YfW9+VcQS51GNixafXr6f5+6rzewQmgoUWDmkm5jiAI5kTS9EREe4hot8G/PQBaJUlG32nRoBZaNvTHZJRlU1PcdkoX03392zc23B4lV9jDD20QtgiCkPFE0vTEzPWZuYHBv/rMnDCXBRGNIKIVRJRPRKMN9l9ORFuJaIHy7yovlQkDMz1Rv2YNXTnjgo3r5OCT6wZ7vp4gCOlPJEcUXiCibADPAzgVQHcAFxJRd4OiHzJzH+Xfa0HJE9T9NRtRtG1SJ5gLhsRJ3Q4JW4SMZ0Bek7BFEELGb69NuwSmKAAMAJCvrOQuBTAWwKgAr2cLtVn3S2947eGbjTTMzm1VPkiSvV5EMEBGkxlPj1bhBAoNUlG0BvC75u/1yjY95xDRr0T0CRG1NToREV2jBiTcunWrL8K5GWE0qFXd2ma2AM6qPR9me+4hOi1DWApKqKJJndywRRAc0LhOTtgi+EaQisIOXwLIY+ZeACYDeNuoEDO/wsz9mbl/8+bNkyZcX90w76ubhuAPvePn8M3aT6t29dGzj3AtU1jNNQG4cIChHheSRJN6oihSiRO6po+5NkhFUQhA27K0UbZVwszbmblE+fM1AP0ClMcz7ZrWwRk6RWHX68nrMSragdBZRxoN0IKBCGjXRCLLC4Jd/m7h6ZhqBKko5gLoTEQdiCgXwAUAxmkLEJHW8H0GgGUByhOHX71jsybfKiZTdhZpyjlDu+DmhhM7OTzaPQQCp+7SGUFIOm0ap49DS2CKgpnLANwIYBJiCuAjZl5CRA8S0RlKsZuJaAkRLQRwM4DLg5JHz4ie7iZn9YlDzEYHhx1Sz/QcWQTM+Ie7BIFh+VFHaLokNLq0MH+mKp0tnrsgpCqBzlEw8wRm7sLMnZj5EWXbvcw8Tvl9BzP3YObezHwiMy8PUp5AIGDCzUPwqW4txHn9zUcsRBQ3qnBCvB918lpvIsmjZDVK7KWkrW0q8whCGhL2ZHbS8MtscmS7+FXU9WvWQPdWDdBWlyfi6A5N0Km5sU2fYDdceHWZtSOaZDoiyYDCmqjenwk3D0HXFv6EqxEyl4xRFFce2wFnH9kaVx1nPzFfawMbY/P68TGPskxGBvrt5/avCt6nNVc5bezLtYrC2aGesHKPfeHivkmUJJpEdbDVuUU99G4bju+9kD5kjKJoUCsHT5/fBw1q2fNtLhgzEvVqZhvuG9yperA+I245ucrr4ZD6VbGliOwpCCNTj5++9I+dY99N10rc0zJkMZ5dpX5UnnHsrjAgAA+O6hm2GCmBn/NLFx3dzrdzRYGMURRuMLPJv3/1QFvH611p/aBOzRpo3zQ20jHr5Z/bz17o8bo1ayA32/gVqJNbXUnqJ/KjzpuXH4VWHoI/1nA5j+T0NtXKsfcZupGGiFArx7jDI8TTrJ5/EZLv+4NRtKLURRSFTzSrVxOj+thTDFnkT0JT9Rz92jfG1UM6uDrH4geG450rB1Tbrm/siIBzbCogLQvvO8WVXH5w4uGH4DAP9nknZkEr5ZDoPDlZwX2GUZ07iSJ+un+nW8piURQ+kZVF+NcFR9oqG99wOH+h9I3Sp9cNxl0j3fVgcmtkoUZ2YhkIhJYNaycsp6dh7dQNY+DmY4/aoEsir9gn3Rp3PxFFEQJ2X8eerRtikEHyogdH9UDHZnXRspGxWSVR46AmbVI/jPZNq3tntdZ5cWVig3NrQCtrHxrVI5DzGmFmnmzdyLnSDws761f8oFZOFh4c1QPHd/EeJijdvhdRFBYkOzS5nlo52fjgmoFxJi1CLIbM1NtOQM0axrZnq57R7cO7oqPObdeo0Xj2/D62ZEw2frl6nnR44jg8dud6nBJ2nvWvbjoWk289ztP8TTLp1NydonjuQnsjfC2XDspDV5+yX6YTGa0o8poaL7G/fXjXQK/rtLfx2Dm9cMxh9jytrMjOIlx/gnXYj+4tG8T9rxJ2D+m5C4/ER38ZhA+usedIoGImtp0UsvreuF8RdPUu1lb0bB1MZsE6uTVwiEuF5cRbzoz3rzradtmbhnZ2dQ0/orfa6VAYkWYDisxWFNNuNw6j0aRuzAU1qNhG5HAdRa2cbEdx6M3OWSOLQESWI6X3rjoaY68ZWG0dSNj222b1cjGgQ5PKZ+OVRjbcjPU1dnsHjI4zCllvxFPn9nF5VWPO6N3Kt3zxXhh8WLNq22bfeZJh2doGHnhBoH4W2ufV1yRNcSLSLSx/RisKM5LxiIOc8/Tyjjaum4uBBvMi6jkvDsk/3ImiunxwXqVd26WHa+yaTryelCfKSPxsrfa/eHHfOJndmEGO7mCeCe+5C49EDcUl2u07eGjD2hjZK37tzMfXDsJfT3bX81cJ2yRXSXq18b6Q8YpieA/zJEK3aUxQ51vEbkoGztYw+P+mq2e8fHCe7+f2m+tP6IRv/nY8AG8h3fXKyehUPVrFTENdW9g3ETGb9zhPPaIlckzWttilS0AhO47Ka4yx1wyMTfayfp9/oz27TLxliOV+p6Ngo0/M7fuTbrom4xVFrzaNTPcdUr8W5t99Ml65pB8e+2Mv2+esb9OsEDbab+D24V2rrcUoGDNSUzZW2G0wQwAY6sLeW+mh5fKyRsfZtjvbuOZ/LuqLibcMwR81E99tGofrUVRht1Nho5z2XSYiw9Fm0DQycbG2O9djZuaz6iSquH3d08zyJIoiEU3r1cQpPQ61XX7pg8Mx966TbZcP4n0ye0mvP+EwAMbtww0nHma5FkM9ZYdmdfGPEYe7kuvJcxNPIOtRGypH90lT2KjnbvcjttNIEIBuLRvEnfOfZx2BC44yH4F2aVEv0Ibk0kF5vpzn53uG4afRQ6s2sPanv8ZTq/vV2GSkYvcWmklqtmJdOxIJq8H/08BohQDJeEVhZNLx8nLUya3hKWRCIvdPO7KZFbnFgw1ZvS4R4boEnlMq9WvG9+QSif7M+eaKxMnkoPZD9zZHkdj0ZETdmjVwqkX8q/q1cuLuhf4N9No4+eXe2aRuLuprYqNplYPfruNtm/if5CfRfczWFaiczNZs1pueptx6nM1ru3+ItSMYciXjFYURp/fyP0aTXT67frDl/qit/FV57dL+1bbpvxUje++Vx1SZu846sg3e/XN8OBGv9TW2MfvXTax2eh+eT7I8zPx+lbxI7UfPfUBeE2NnC5OKtnKx6NBocapKzRr+NKdmuV/uPT28+FGiKHQ0rZuLujWDn2MwawD9uLb2o7vH4uVy8m0m6iGd3D2xvZc0b9uCe4dh8QPDcdng9nFlhnSOXxVr1MtLeB2LHqET7BypNupqWbXXrT3W2PylMW9U22dfxmSgjnIP1YRw8aLAjUakTuevXr+sP5rqgvh9dO0gPHJW9TUeZqLqzWeqdSHRs7t56GGG52vq02S+2eO/8lh38dz8IOMVhf6Ft/v+P3Vu74S9fzs4bRTsmZ6qCv3Z4OW6WLF/9mnXyNnFPaIVvVGdXNSrWcOyhwYYf7zTbz8BI22GNlfvV4dm5td584qjMOXW402PVdErnVuHdUHbJrWVss7MVFamp2Rht7H/06CYMtdOChvNUZjlZtFzus61duG9p+DwQ50tLBxg4QKsokpjNrlvVv/4jkb1c956SlfMvGNoXHidh8/sWXlHbvMY+oWIIpffJOMVhVvO6dcGfXXZ7vzixhONeyx2SdRIDencHAVjRroK8mdFswRpQL3YbbWHtm9aFw1trrpVG/dbTjKfnzmx6yGWOc7NuPmkzqZ1CsJ85OT23T2yW6D5u40a2XP6tsEhiieS1bWr3Rsb9bp7ZDfD7V/ddGzigz1gJlrLhrVNowSc3dd56Jcvb6yqR8QGlABEUUSS24Z3jXNNTRfcfACJelYDO1bvWWqvo/YIbbuMxp3Hu2JLpDwBbxPuZlw1pCMmG4ySvJDoDtbKycbDZ8aSJPltPrtqSEes+edplX+rCrpna/fZ+8zqE+/1ZK8iXkcAcZHmTeYowkQURUgEFR4EMG6Q9cP9MHDaeNxzenfNB6PzUFG2GzkeaD9u1de+Tm42Xr6knyM59OUau8gu2PkQYw+kOPNGtXAp9vCypgWw/w5Wzr/Eucca0z+vCXKyCX85ztwzTn9ftX9fcUye6XFZWeRKqTptdLXyVJfVXAAvjbv2WBlRRJCwFbfdXquTl1D/Mi97cITtXBlOcWKyUevaXxc/xyibHhA/v2L2fSZq9P9+Slc8clZPDLexFqZh7RxcMrC94b5Prh1kmd6yW8v6aFQnB38bFrNP6ye3rdDPfdjuxQbQ7TSy/avPuHebqt672aWb1M3FqkdOszWHYIRd13Jbd8jhaFItdo7GdOSm0XYzmtKupo89/3iZLxwQ7rqK1FhCnMJ0b9kASzfuTlju5G4tMGXZ5oTl3JhDggiqdvvwrjiyXSMM7lQ9uJuVHB9cPRA9dBFRp9x6PAq27TU8xk1TqL1DtXKycfHRscY/UXuhZuN7d9baavv651k3fPVr5WDBvZpsfgkfU/W1HkZmNLu0algLG4oOODpGfz9+uWcYaudm4/B7vo7bPrBjU0z9+/GWDgGJyM4ilFcojgnOpyiqypr5jlpg6vVkskO74jtZwf1yNa611x7fCWu3x76Hnq0bYHFh4vYjaERRKDSsnYOi/Qd9P+8n1w1C8YGyhOVeuaSfrZ5PkCYrJ9xgMeF+3x+644EvlxruG9SpegiIVo1qm/u0G3g9KTtMr2/2bR+q5F/o1tKeh40fbQRzLHf3u7PWYvLSqo5AvHmD8OPooWji0LSlvQOjjmyNF6et9iSr2QpoAOhYLSeEs/ewa4v6tjpMUbDNW5qezA5i9u3bvO6EmKJYvKEIp/ZsGQlFIaYn3XBTbxbxilncf/0HkZVFlVE9vRK2H75+LYQXqtZRmHsX2c2A1qdtI3x+/WBLDyi/UEd+DOC4Ls3xqm5BIul+t25Uu3Lkp6/p7cO74qi8+PcyJ5tCtWsnatD1j6ueNmaUA2lfv6z6Qk6j8xuWUa9jImu1dRQGBd2M4P3weGvftC6+umlIZFIJZ7yiUKlXMxtf/3VIYLZ8PWqEUKcB5MLOCxEW+lprGyon9vAj2zW2PQns5V73aN0AtXKycLONpDv6OYqaObF3Q13pe8OJh+Hja6vW7Nx8UmfMu2uYa9lUPE2+2ix3aINaWPbgCMtVy1bmHS9mU/W0bjzeVILwSHNC2J0+FTE9aXC66Mcp5/Rtg4PlFQBidtAXLu5rOxqnGnOnTs3oxYEJEjs919GndsN/Z62r2uaTMq3hoZVoUCsHyx861XS/tgHQK67WjetgW3EpXvxTX8Njm9XLtb2OxIrDDqlnyxzkBrXxJ6re2Fs1fted0Anbi0twVt/WuH/cEvQ2ie6c6BnXdaFg1HfNKiigleyVx1uUyckmHCyPgH3NIaIokog+/eZpNlcXA8C1J3RE3ZrZlnkx7h7ZDQ+PXwYCoV/7xpi/dqdrWaNCZUgM3cenVSD1atbAkgeG4+h/foviksTzQXaxu9I4KJy447oJBDjmnCPwx35tcOkbcxwfm8jjymoEaFW2Ye0cPKFEGVZzilidFwAeOKNHnDyvXNIP3Vo2QOGu/bFrm12YY6v85xXsxN8/Xmgim/11FEYZ8vR8edOxGPHsD4b7fho91LPLc1BkvKKIyuRwImrWyMZVQzpaltH2aD64eiBKysqTIFmwGPXytKhb69asUVUimt+aKVk6q4y6ujmRq+iFA9rhgznrMP7mY9G9ZQPcMnaBo+vWya2B47q4m0/SfjVPWYSPV59fkN/ZZbpkWmpagEpFYaGl2jeti/U795vur+VgZNKwdg627imxNKVZWS2MHDpO6BqLgXXhgHATp2W8oqgkKsZADwztdggembAMo/q0Qm6NrDiXu1Sn2ojCoOFp1ag2VmzeE9lemRat4mvTKD7E9pPn9sbkpZsTemc9cmZP3PeH7p7C2gPANcd1RGsXkVSBmEfXiQYB/aw+J/0uN5+ek3D75kEBdX8bFDy156H4+7AuuHRwHnKyyVIJvH3lAHyzZJNhQqUz+7TC/xZsSCy0jtaNakciSoMoijSiU/N6vr9Us+44CTnZ4TW8Trxr3v3zAMz6bQfqeYzA27x+TWzdU+LpHIlQ5b7ztMNxbr/43mLD2jlxGfMqj9E1sVlZhFpZ3ues7jzNOI6SFbaT6Pk8knCjVMxkVRdXWimubCLcZMNLbniPQ9GiQS1coQmbr+XxP/bGQ0p4k1Qk4xVFFPy2o4y69iAsnCyWOqRBLZzR23suka9vGYKtxcEqCpWRvVpZrl/QEiUzqUlkFVRtVtyDDUSOyuBdnyzJy/1tYeACr6VGFiG3VrwDwpDOzfDDqm2ur5lMMl5RqETk3U0rcmv456FlGsIjgCfXtF7NarkO/KYqflJ0Gn8nGIV/12LlfFCtbEBfn5WZSLsKvrMSPsMoTIZfSi0qytEt6WPEFiJDg9o18PdhXfDhX4zDMDshag2plzAbWto0jvVmc31aZJmIM/v4m7WxT9tGABKPONWn1yxO8bpvNZ0olSNaN0TXFvVxx6nxOd7vPO1wvHl5VSbF5vVromDMSIzq09q1XOlOxo8ootUMpQcEe3ZdM7644ZjKBYnac2oJ67m9dcWAarGQ3PDSJf3w0+pthqv2g+CZ8/vgmfP7+Ha+v57cBaf2bGnqxaOuQVHDkjxyVk+MW2g8mRtUb7t2bjYm/e04zFqzPW57y4a1A4l/ZkWyYkYFRaDdGSIaQUQriCifiEZblDuHiJiIjNfrCxlF77aN0L1VrAEyW8Skeuk08Zh+skerxIssh3SuCnzo1cNIpUndXMe52b3lx7D22HFKdhZVPiMjmtariUfPPgJvXxnrudevlVMZVDDZbaaaylVVXnavn5udFWgDn0rKI7ARBRFlA3gewDAA6wHMJaJxzLxUV64+gFsAzA5KFivUl8jNgiUheLq1rI8Vm/dU82S6cehh6NayAU7q5izXspaF955SGS7DjJ/vGYa6EVkNf9oRLfHurLW2V/OHjd7mH1az2LhuLgrGjMT1783HhEWbQpIitQnS9DQAQD4zrwEAIhoLYBQAfVjRhwA8BuD2AGUxZWSvluh0yJDAw3cI7nj07F646Oj21TxUcrKzMKJn4hwTVtgJg+F1xOIngzo1jYRPfah40DbNlXkS2+7TPmi2Z8/vg5emm0f1/ctxHbHbRnTpsAlSUbQG8Lvm7/UAjtYWIKK+ANoy83giCkVRAMHHeBLcUzs323USHCE1SJYF5o7TuqFn64Y43uZqdD/EOvPI1jjzSONJclJkSgVCm8wmoiwATwO43EbZawBcAwDt2oWb6UkQhNSkVk42zrWIlaaSLEe7sMNyOCHIyexCANo70UbZplIfQE8A04ioAMBAAOOMJrSZ+RVm7s/M/Zs39y/XgSAI1WndqDb+rqR0jRrqnGKQoxCzQJR+M6Jn+Hns7RLkiGIugM5E1AExBXEBgIvUncxcBKDSnYSIpgG4jZnnBSiTIAgJ+HH00KRez4k319tXDsDSDbtR08fFnGbyeA0Fk04EdieYuYyIbgQwCUA2gDeYeQkRPQhgHjOPC+ragiCkJ03q5uLYzvbztLuhdm427h7ZDSd1axHodVKJQFUmM08AMEG37V6TsicEKYsgCNEkissJEoX0zzRkbCUEzvibj8Wv64vCFkMQBJeIohACp0erhujRqmHYYggRJYIDCkGHBAUUBEEQLBFFIfhGF8V1MVkRUYXUJGIBgQUbiOlJ8I0X/9QPiwuLbIXGEASVVAqOp2fo4YdgWPf0944SRSH4RsPaOTjmsGBdFwUhSrxx+VFhi5AUxEYgCEKopO54InMQRSEIgpBE2ukiIacCYnoSBIdM/ttxWLNtr+Pj3ri8P9o3rRuARKlNCk9RuGLyrcehvCK1ZvRFUQiCQzq3qI/OLZwnuhp6ePpPegqJCTJOVVCI6UkQhFBJZa+nTEFGFIKQJmQRZAW8EAiiKAQhTVjzaIanSRUCQ0xPgiAIgiWiKARBSA4yFZGyiKIQBEEQLBFFIQiCIFgiikIQBEGwRBSFIAiCYIkoCkEQBMESURSCICSZ1IpzJIiiEARBEBIgikIQBEGwRBSFIAhJQdbbpS6iKARBEARLRFEIgiAIloiiEARBECwRRSEIgiBYIopCEIRQeOWSfjjtiEPDFkOwgSQuEgQhFE7pcShO6SGKIhWQEYUgCIJgiSgKQRAEwRJRFIIgJIXaudnKL1l6l2rIHIUgCEnhpT/1w6fzC9Gped2wRREcIopCEISk0KZxHdxycuewxRBcIKYnQRAEwZJAFQURjSCiFUSUT0SjDfZfS0SLiGgBEc0gou5ByiMIgiA4JzBFQUTZAJ4HcCqA7gAuNFAE7zPzEczcB8DjAJ4OSh5BEATBHUGOKAYAyGfmNcxcCmAsgFHaAsy8W/NnXUjqK0EQhMgR5GR2awC/a/5eD+BofSEiugHArQByAQw1OhERXQPgGgBo166d74IKgiAI5oQ+mc3MzzNzJwD/AHC3SZlXmLk/M/dv3rx5cgUUBEHIcIJUFIUA2mr+bqNsM2MsgDMDlEcQBEFwQZCKYi6AzkTUgYhyAVwAYJy2ABFpnapHAlgVoDyCIAiCCwKbo2DmMiK6EcAkANkA3mDmJUT0IIB5zDwOwI1EdDKAgwB2Args0Xnnz5+/jYjWuhSrGYBtLo+NKlKn6JNu9QHSr07pVh+gep3auz0RMWeOoxERzWPm/mHL4SdSp+iTbvUB0q9O6VYfwN86hT6ZLQiCIEQbURSCIAiCJZmmKF4JW4AAkDpFn3SrD5B+dUq3+gA+1imj5igEQRAE52TaiEIQBEFwiCgKQRAEwZKMURSJQp5HFSIq0IRin6dsa0JEk4lolfJ/Y2U7EdFzSh1/JaK+4Uofg4jeIKItRLRYs81xHYjoMqX8KiJKuOYmSEzqdD8RFSrPagERnabZd4dSpxVENFyzPRLvJRG1JaLviGgpES0holuU7Sn5nCzqk8rPqBYRzSGihUqdHlC2dyCi2Yp8HyoLnEFENZW/85X9eZpzGdbVFGZO+3+ILfhbDaAjYsEHFwLoHrZcNmUvANBMt+1xAKOV36MBPKb8Pg3ARMSSEg8EMDts+RW5jgPQF8Bit3UA0ATAGuX/xsrvxhGr0/0AbjMo211552oC6KC8i9lRei8BtATQV/ldH8BKRe6UfE4W9UnlZ0QA6im/cwDMVu79RwAuULa/BOA65ff1AF5Sfl8A4EOrulpdO1NGFAlDnqcYowC8rfx+G1UxskYBeIdjzALQiIhahiBfHMz8PYAdus1O6zAcwGRm3sHMOwFMBjAicOFNMKmTGaMAjGXmEmb+DUA+Yu9kZN5LZt7IzD8rv/cAWIZYBOiUfE4W9TEjFZ4RM3Ox8meO8o8Ri7r9ibJd/4zUZ/cJgJOIiGBeV1MyRVEYhTy3emmiBAP4hojmUyzcOgC0YOaNyu9NAFoov1Opnk7rkCp1u1ExxbyhmmmQYnVSTBRHItZjTfnnpKsPkMLPiIiyiWgBgC2IKeHVAHYxc5lSRCtfpezK/iIATeGiTpmiKFKZY5m5L2KZAm8gouO0Ozk2lkxpH+d0qIPCiwA6AegDYCOAp0KVxgVEVA/ApwD+yvGJxVLyORnUJ6WfETOXcywjaBvERgGHJ+O6maIonIY8jwzMXKj8vwXA54i9HJtVk5Ly/xaleCrV02kdIl83Zt6sfMgVAF5F1XA+JepERDmINarvMfNnyuaUfU5G9Un1Z6TCzLsAfAdgEGJmPzXAq1a+StmV/Q0BbIeLOmWKokgY8jyKEFFdIqqv/gZwCoDFiMmuepNcBuAL5fc4AJcqHikDARRpzAZRw2kdJgE4hYgaK+aCU5RtkUE3H3QWYs8KiNXpAsULpQOAzgDmIELvpWK7fh3AMmbW5q5PyedkVp8Uf0bNiaiR8rs2gGGIzb18B+CPSjH9M1Kf3R8BTFVGhWZ1NSeM2fsw/iHmpbESMZveXWHLY1Pmjoh5JywEsESVGzE747eI5e+YAqAJV3lFPK/UcRGA/mHXQZHrA8SG+QcRs4f+2U0dAFyJ2MRbPoArIlindxWZf1U+xpaa8ncpdVoB4NSovZcAjkXMrPQrgAXKv9NS9TlZ1CeVn1EvAL8osi8GcK+yvSNiDX0+gI8B1FS211L+zlf2d0xUV7N/EsJDEARBsCRTTE+CIAiCS0RRCIIgCJaIohAEQRAsEUUhCIIgWCKKQhAEQbBEFIUgGEBE5Up00YVE9DMRDU5QvhERXW/jvNOIyJeE94KQLERRCIIx+5m5DzP3BnAHgEcTlG+EWLROQUg7RFEIQmIaANgJxGIHEdG3yihjERGpkUTHAOikjEKeUMr+QymzkIjGaM53rpJXYCURDUluVQTBOTUSFxGEjKS2EqWzFmK5DYYq2w8AOIuZdxNRMwCziGgcYrkaenIsYBuI6FTEwjkfzcz7iKiJ5tw1mHkAxZLm3Afg5KTUSBBcIopCEIzZr2n0BwF4h4h6Iha64p9KFN8KxMIztzA4/mQAbzLzPgBgZm3uCjXg3nwAeYFILwg+IopCEBLAzDOV0UNzxOL+NAfQj5kPElEBYqMOJ5Qo/5dDvkEhBZA5CkFIABEdjlhKzO2IhWreoiiJEwG0V4rtQSzlpspkAFcQUR3lHFrTkyCkFNKbEQRj1DkKIGZuuoyZy4noPQBfEtEiAPMALAcAZt5ORD8S0WIAE5n5diLqA2AeEZUCmADgzqTXQhB8QKLHCoIgCJaI6UkQBEGwRBSFIAiCYIkoCkEQBMESURSCIAiCJaIoBEEQBEtEUQiCIAiWiKIQBEEQLPl/OcyU7JOA3+gAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I would suggest the subreddit stuf stuff stuff stuff stuff stuff stuff in the stuff stuff stuff in the stuff stuff stuff. I would suggest the stuff in the stuff stuff stuff the stuff in the stuff stuff in the stuff stuff in the stuff stuff in the stuff stuff in the stuff in the stuff in the stuff. I would suggest the stuff in the stuff stuff in the stuff in the stuff in the stuff there.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, while is the best best to send to be to send when in the construm to there.\n",
      "I work with the state statement statement to send the statement to send the statement to send the state statements to send the state statement to the state statement to the state state. I would send the state the state statement to the state statement to the state statement to the state statement to the state state.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "\n",
      "I don't know what you'd start with statistics when you chose to start when you chose. It will be stated for the statement when you want to start to state the state statement in the state. I would state the state statement in the state statement in the state statement in the state statement in the state statement in the state statement in the state states.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I was this in the same samples so I work with the same samples that I work with the same samples that I work with the same samples that I work with the same samples that I work with the same samples that I work with the same samples that I work with the same samples that I worked with the same samples the same samples the same samples the samples the samples the samples samples the samples samples the samples samples samp.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I work in the ``` instances ``` instances `` instances (``` instances `` instances ``` instances `````````````````````````````````````````````````````````````````````````````````````````````````````}``````````}```````}```````}```}`}`````}````}`}``````}`}`}``````}`}```````}`````}``}`````}}````````}`}````````}``````````````}````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would start with the state of the state in the state state in the state state state. I would start to state the state state state to state the state state state to state the state state. I would state the state state state the state state state state the state state state.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would se the state state states the states in the state states the state states the states states the states states the states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states the states states.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would start to start with the state in the state in the state in the state state. I would start to state the state state to state the state state state the state state state the state state state. I would state the state state state the state state state the state state state.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know what I want to do with these. I don't know what I want to do with these. I want to do with these text in the state. I don't know what I want to do with these. I would be supposed to support the state when I want to send the state state. I would send the state states that I want to send the states when I want to send the states states.\n",
      "\n",
      "Epoch 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:09<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I work on the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun sun the sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun the sun sun sun the sun sun sun the sun sun sun sun sun sun sun sun sun.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, while is the best best be to send in the body with the body standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard whites.\n",
      "This standard whitt standandard andanda s standandarin.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "\n",
      "I don't know what you want to do is this. I want to do it with the standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standarrd.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I want to spend with these times with the state of the state the state states that states with the states the states the states the states the states the states the states states the states the states states the states the states states the states the states states the states states the states states the states the states states the states states the states states the states states the states states the states states the states states the states states.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I work in the ````````\n",
      "`````\n",
      "````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I work for my programming is the best thing I work for the standard to make it with the standard for the standard to the standard to the standard standard in the standard standard to the standard standard standard to the standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standandarin.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I work with the standard python in the standard python in the standard python in the standard process. I work in the standard process the standard process the standard process the standard process the standard process the standard process the standard process the standard process the standard process the standard process the standard process the standard process the standard process.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would suggest the state in the state in the state in the state in the state in the state in the state state. I would started the state states that is stated to state the states that states the states states the states the states the states the states the states states the states the states the states the states states the states the states states the states the states states the states the states states.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know if the issue is to be a simple similar to send the similar to send the similar to send the similar to send the similar to send the similar to send the similar to send the similar to send the similar to send the similar to send to send the similar to send the similar to send to send the similar to send to send the similar to send to send to send the similar to send to send to send to send to send to send to send to send to send to send to send to send to send to sering to sering.\n",
      "\n",
      "Epoch 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:01<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I work with the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun in the sun the sun.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          t            tes   es        es   es   es    es     es  es tes        estestes    estes       estestestuestestestes. . . . . . . . . . . . . . . . . . . .\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't know what you want to do is to do when I write a bunch of statements when I write a bunch of statements when I write it with the bunch on the but I write it with the bunch one. I work with the bunch one who works when I was write the bunch on the bunch one. I work when I write in the bunch on the bunch one. I work when I write in the bunch in the bunch one.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I work with the shot of the shot the shot is the shot the shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot the shot shot thot shot though.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`? Is there any what to do to spend when to do in these `articles `articles`? I don't know what is there any way to do with `articles` which is there any way to do with `articles`.\n",
      "I don't know what you're working with these `articles` when you want to do with `articles` when you want to do with `articles` when you want to do with `articles` when you want to do with `articles` when you want to do with `articles` when `articles` when `articles`.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I work with the whole work with the whole work when I work with the work when I work with the work who I worked with the work when I was working with the work with the work when I was working with the work with the work with the work when I was working with the work with the work with the work with the work with the work with the work with the work with the work with the work with the work with the work with the work with the work.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I work with the whole work with the whole work. I work with the whole work when I worked with the work who I worked with the work who I was working with the work who I worked with the work who I was working with the work with the work who I was working with the work with the work with the work with the work who I was working with the work with the work with the work with the work with the work with the work.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would say that is the same that is the same that is the same that is the same that is the same that is the same that is the same that is the same that is the same that is the same that is the same. If you want to say the same is the same that is the same that is the same that is the same the same thing the same samples the same thing the same samples the same samples the same thing.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know what you want to do with them. I work when I was writing a bunch of when I write them with them when I write them when I write them when I write them when I write them. I was there was what I was write what I was write what I was write what I was write what I was wrong. I was wrong. I was wrong with them when I was working. I was working with them what I was working with them.\n",
      "\n",
      "Epoch 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:09<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I would suggest the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the the the then the then the then the.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t         tes        t t   tes  tes   t t  t   t t tes t t t tes t  tuest t t t tuest t t t tuest tut t t tutut t t t tututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututututut<CUTOFF>\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "\n",
      "ChatGPT is a sense of the sensors and then the sensors the sensors that chat when it works. I works when it works when it works with the sensors that works when it works with the sensors that works when it works when it works. I works when it works when I works when I work with the sensors when I want to sensor the sensors that works when I want to sensor the sensors that works when I want to sensor the sensors.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I don't know what it works for me. I work when I work in the future. I work when I work with the future. I work when I work with the future for me. I work with the future that I work with the future for the future. I work with the future for the future I work when I want to go to the future. I work with the future for the future I work when I want to go to the future. I work with the future for the future.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`? Is there an ``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would say that the problem is the problem when I was trying to do this to do with the problem. I work when I was working with the problem when I was working with the problem when I was working with the problem. I work with the problem when I was working with the problem when I was working with the problem when I was working with the problem when I was working with the problem when I was working with the problem when I was working with the problem with the problem.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say that working with Java is the word word when I work with Java in Java. I work with Java in Java in Java in Java. I work with Java in Java in Java in Java. I work with Java in Java Java in Java. I work with Java in Java in Java. I work with Java Java in Java. I work with Java Java in Java. I work with Java Java Java Java in Java. I work with Java Java Java Java Java Java Java Java Java Java Java Java Java Java Java Java Java Java.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would say that is the same thing that would be something that would be something when you check the same things that would be something that would be something that would be something that would be something that would be something that would be something that would be something that would be something that would be something that would be something that would be something that would be something that would be something the same.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I did this in the word when I was the word word word word when I was the word word word. I work with the word word when I was the word word when I was working with the word word. I work with the word word when I was working with the word word when I was working with the word word when I was working with the word word when I was working with the word word when I was working with the word word. I was the word word when I was working with the word word.\n",
      "\n",
      "Epoch 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:07<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I don't know if the sun is the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, \n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              es         es      es     es       es  es. ? . ? ? . . . . . . . ? ? ? ? ? ? ? ? ? es.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't know how to change the change to the change. I don't know how to do what you want. I work when I want to do with the change to be server. I work with the change that I worked with the change that I worked with the change that I worked with the change that I worked with the change that I worked with the change that I worked with the change that I worked with the change. I worked with the changes that I worked with the changes that I worked with the change.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I don't know if the whole work is the whole work. I work with the whole work and the whole work when I work with the whole work. I work with the whole work who works with the whole work. I worked with the whole work with the work with the work who works with the work with the work. I worked with the work with the work with the work with the work. I worked with the work with the work with the work. I worked with the work with the work.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I don't know why the `````` is ``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would say that the property would be such the property would be such the property word. I would recommend the property the property word word before the property word. I worked with the property of the property when I worked with the property of the property when I worked with the property of the property when I worked with the property word when I worked with the property word when I worked with the property working with the property working with the property work.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say that working with Java is the way to do with Java. I work with Java is a static where the working with Java is the working. I work with Java Java is a static where the working with Java Java is the working. I work with Java Java is javascript. I work with Java Java Java is just a business for Java JavaScript with JavaScript JavaScript.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know what you meant when you want to do with the comments and send the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sending the sendirang ign. the the stand things. things things things things things things.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know why went through the standard standard. I want to be a standard standard standard standard standard standard standard standard standard standard standard standard. I want to be standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standrard standrard.\n",
      "\n",
      "Epoch 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:05<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAlrUlEQVR4nO3deXhc9X3v8fdXm7VYsmVJtiRLtmws78gsCmCzhC3ggDDZA2kW2iSkaSBN05sm6e1t0/TetknT3CZA2hKSkIXgUkpywRAMZQmLWSwMXuQNG8urZEveJMuytX3vH3MsBlm2JazxGel8Xs8zDzPnnDnzkR6jz5zf2czdERGR6EoJO4CIiIRLRSAiEnEqAhGRiFMRiIhEnIpARCTiVAQiIhGnIhAZAmbmZjZtgMt+y8x+lehMIgOlIpARx8zqzazdzA7FPe4MO5dIskoLO4BIgtzg7v8ddgiR4UBbBBIpZnaLmb1oZnea2UEzW29mV8XNLzWzh81sn5ltMrPPx81LNbO/NLPNZtZqZq+ZWXnc6q82szfN7ICZ3WVmNsBMi8ysLnjfs2Y2K27e181sZ/B5G45lNbMLzKzWzFrMbLeZfX8Ifj0SUSoCiaILgc1AIfA3wENmNi6YtxjYAZQCHwH+3syuDOZ9FbgZuA7IA/4IOBy33hrgPUAV8DHg2lMFMbPpwP3AV4Ai4DHgETPLMLMZwG3Ae9w9N1hfffDWHwA/cPc84CzggUH9BkTiqAhkpPpt8A372OPzcfP2AP/i7p3u/h/ABuD64Nv9xcDX3f2Iu78B3AN8Onjf54C/cvcNHrPS3ffGrfcf3f2Au28DngHOGUDOjwOPuvuT7t4JfA/IAhYA3cAoYLaZpbt7vbtvDt7XCUwzs0J3P+TuLw/6NyQSUBHISPUBdx8b9/hx3Lyd/s6rLW4ltgVQCuxz99Y+8yYGz8uJbUmcSGPc88PA6AHkLA0+AwB37wG2AxPdfROxLYVvAXvMbLGZlQaLfhaYDqw3s+VmVjOAzxLpl4pAomhin/H7ScCu4DHOzHL7zNsZPN9ObBhmKO0CJh97EeQqP/aZ7v5rd78kWMaB7wTT33T3m4HxwbQHzSxniLNJRKgIJIrGA182s3Qz+ygwC3jM3bcDy4B/MLNMM6si9s372DH/9wB/Z2aVFlNlZgWnmeUBYsNSV5lZOvDnwFFgmZnNMLMrzWwUcARoB3oAzOyTZlYUbEEcCNbVc5pZJKJ0+KiMVI+YWXfc6yfd/YPB81eASqAZ2A18JG6s/2bg34h9U98P/E3cYajfJzZm/wSxHc3rgWPrfFfcfYOZfRK4g9gQ1BvEDn3tCArgH4kVVSexkro1eOtC4Ptmlk1saOkmd28/nSwSXaYb00iUmNktwOeC4RYRQUNDIiKRpyIQEYk4DQ2JiESctghERCJu2B01VFhY6BUVFWHHEBEZVl577bVmdy/qb96wK4KKigpqa2vDjiEiMqyY2dYTzdPQkIhIxKkIREQiTkUgIhJxKgIRkYhTEYiIRJyKQEQk4lQEIiIRF5kieH3bfr7z+PqwY4iIJJ3IFMGanQf512c3s6Gx9dQLi4hESGSKYOHcElIMlqzaFXYUEZGkEpkiKModxfyzCliyqgFdcVVE5G2RKQKAmqpStjS3sbahJewoIiJJI1JFsHBOMakpxpJVDWFHERFJGpEqgvycDC6eVsiSVbs0PCQiEohUEQDUVJWwfV87q3YcDDuKiEhSiFwRXDu7mPRU09FDIiKByBXBmOx0Lqss4tFVDfT0aHhIRCRyRQBQM6+EXQeP8Pr2/WFHEREJXSSL4OpZE8hIS+GRlTp6SEQkkkWQm5nOFTOKeGy1hodERCJZBBA7uWxP61GW1+8LO4qISKgiWwRXzhxPZnqKTi4TkciLbBHkjErjqpkT+N2aBrq6e8KOIyISmsgWAcROLms+1MErWzQ8JCLRFekiuGLmeHIyUnVymYhEWqSLIDM9latnT+B3axrp1PCQiERUpIsAYkcPHTjcybLNe8OOIiISioQWgZktNLMNZrbJzL7Rz/zJZvaUma0ys2fNrCyRefpz2fRCckelsWSlhodEJJoSVgRmlgrcBbwfmA3cbGaz+yz2PeAX7l4FfBv4h0TlOZFRaam8b84EltY10tGl4SERiZ5EbhFcAGxy97fcvQNYDNzYZ5nZwNPB82f6mX9G3FBVSsuRLp5/symMjxcRCVUii2AisD3u9Y5gWryVwIeC5x8Ecs2soO+KzOxWM6s1s9qmpqH/Y33xtELGZKXr5DIRiaSwdxb/D+C9ZvY68F5gJ9DddyF3v9vdq929uqioaMhDZKSlsHBOMU+u3c2RzuM+XkRkREtkEewEyuNelwXTern7Lnf/kLufC/zPYNqBBGY6oZp5JRw62sWzGzQ8JCLRksgiWA5UmtkUM8sAbgIejl/AzArN7FiGbwI/TWCek5o/tYCCnAydXCYikZOwInD3LuA2YCmwDnjA3evM7NtmtihY7HJgg5ltBCYA/ydReU4lLTWFhXOLeWrdHto7NDwkItGRlsiVu/tjwGN9pv113PMHgQcTmWEwrq8q4b5XtvH0+j1cX1USdhwRkTMi7J3FSeXCKQUU5Y7S8JCIRIqKIE5qinHd3GKeXr+HQ0e7wo4jInJGqAj6qJlXytGuHp5atzvsKCIiZ4SKoI/zJ+VTnJepG9uLSGSoCPpISTGuryrhuY1NHGzvDDuOiEjCqQj6UVNVQkd3D0+u1fCQiIx8KoJ+nFM+loljs3hURw+JSASoCPphZtRUlfD8m80cONwRdhwRkYRSEZxATVUpXT3O0rrGsKOIiCSUiuAE5k7MY3JBti5NLSIjnorgBI4NDy3bvJe9h46GHUdEJGFUBCdRU1VKd4/zuzUaHhKRkUtFcBIzi3M5qyhH1x4SkRFNRXASseGhUl7Zso89LUfCjiMikhAqglOoqSrBHQ0PiciIpSI4hcoJucyYkKvhIREZsVQEA1BTVcLy+v00HGwPO4qIyJBTEQxAzbxSAB7VOQUiMgKpCAZgSmEOc0rzdHKZiIxIKoIBqqkq5Y3tB9i+73DYUUREhpSKYIBqgpvZP7paWwUiMrKoCAaofFw288rG6OghERlxVASDUFNVypqdLdQ3t4UdRURkyKgIBuF6DQ+JyAikIhiE0rFZnD85n0dWanhIREYOFcEg1VSVsL6xlU17DoUdRURkSKgIBum6s0swQzuNRWTEUBEM0oS8TC6oGMeSVQ24e9hxREROm4rgXaiZV8qmPYfYsLs17CgiIqdNRfAuLJxTTIrBkpU6ekhEhr+EFoGZLTSzDWa2ycy+0c/8SWb2jJm9bmarzOy6ROYZKkW5o5h/VgGPrtbwkIgMfwkrAjNLBe4C3g/MBm42s9l9Fvsr4AF3Pxe4CfhRovIMtZqqUrY0t1G3qyXsKCIipyWRWwQXAJvc/S137wAWAzf2WcaBvOD5GGDYHIqzcE4xaSmmK5KKyLCXyCKYCGyPe70jmBbvW8AnzWwH8Bhwe38rMrNbzazWzGqbmpoSkXXQ8nMyuHhaIUtW7dLwkIgMa2HvLL4ZuNfdy4DrgF+a2XGZ3P1ud6929+qioqIzHvJEaqpK2LG/nZU7DoYdRUTkXUtkEewEyuNelwXT4n0WeADA3V8CMoHCBGYaUtfMKSY91ViiS06IyDCWyCJYDlSa2RQzyyC2M/jhPstsA64CMLNZxIogOcZ+BmBMVjqXVRbx6OoGeno0PCQiw1PCisDdu4DbgKXAOmJHB9WZ2bfNbFGw2J8DnzezlcD9wC0+zAbca+aV0HDwCCu27Q87iojIu5KWyJW7+2PEdgLHT/vruOdrgYsTmSHRrp41gYy0FJasaqC6YlzYcUREBi3sncXDXm5mOlfMKOKx1Q10a3hIRIYhFcEQqKkqZU/rUZbX7ws7iojIoKkIhsBVs8aTlZ6qS1OLyLCkIhgC2RlpXDlrPL9b3UhXd0/YcUREBkVFMERqzi5hb1sHL7+l4SERGV5UBEPkipnjycnQ8JCIDD8qgiGSmZ7K1bMn8HhdI50aHhKRYURFMIRqqko5cLiTFzc1hx1FRGTAVARD6LLpheRmpunS1CIyrKgIhtCotFSumV3M0rpGjnZ1hx1HRGRAVARDrGZeCa1Hunh+o4aHRGR4UBEMsUumFTImK11HD4nIsKEiGGLpqSksnFPMk2t3c6RTw0MikvxUBAlQM6+Eto5unt2wJ+woIiKnpCJIgPlTCyjIydDRQyIyLKgIEiAtNYWFc4t5at0eDnd0hR1HROSkVAQJUlNVSntnN0+v1/CQiCQ3FUGCXDBlHEW5o1iyUsNDIpLcVAQJkppiXH92Cc9s2MOhoxoeEpHkpSJIoOurSjja1cN/r90ddhQRkRNSESTQ+ZPyKc7L1MllIpLUVAQJlJJiXF9Vwu83NnGwvTPsOCIi/VIRJFhNVQmd3c6TGh4SkSSlIkiwc8rHUpafpeEhEUlaAyoCM8sxs5Tg+XQzW2Rm6YmNNjKYxYaHXnizmf1tHWHHERE5zkC3CJ4DMs1sIvAE8Cng3kSFGmluqCqlq8dZWtcYdhQRkeMMtAjM3Q8DHwJ+5O4fBeYkLtbIMqc0j8kF2br2kIgkpQEXgZnNB/4AeDSYlpqYSCOPmVFTVcKyzc00HzoadhwRkXcYaBF8Bfgm8Bt3rzOzqcAzCUs1AtVUldLj8Ls1Gh4SkeQyoCJw99+7+yJ3/06w07jZ3b98qveZ2UIz22Bmm8zsG/3M/79m9kbw2GhmBwb/IwwPM4tzOasohyUrdfSQiCSXgR419GszyzOzHGANsNbMvnaK96QCdwHvB2YDN5vZ7Phl3P3P3P0cdz8HuAN46F38DMNCbHiolFfr97Gn5UjYcUREeg10aGi2u7cAHwB+B0whduTQyVwAbHL3t9y9A1gM3HiS5W8G7h9gnmHphnkluMNjq7XTWESSx0CLID04b+ADwMPu3gn4Kd4zEdge93pHMO04ZjaZWLk8fYL5t5pZrZnVNjU1DTBy8pk2PpeZxbk6ekhEkspAi+DfgXogB3gu+MPdMoQ5bgIedPd+7/bu7ne7e7W7VxcVFQ3hx555NVUl1G7dz64D7WFHEREBBr6z+IfuPtHdr/OYrcAVp3jbTqA87nVZMK0/NzHCh4WOub6qFNDwkIgkj4HuLB5jZt8/NjxjZv9MbOvgZJYDlWY2xcwyiP2xf7ifdc8E8oGXBpl9WJpSmMOc0jwe0fCQiCSJgQ4N/RRoBT4WPFqAn53sDe7eBdwGLAXWAQ8E5yB828wWxS16E7DY3U+1z2HEqKkqZeX2A2zfdzjsKCIi2ED+/prZG8EhnieddiZUV1d7bW3tmf7YIbV932Eu/e4zfH3hTL54+VlhxxGRCDCz19y9ur95A90iaDezS+JWeDGgvZ3vUvm4bOaVj+XR1Tq5TETCN9Ai+GPgLjOrN7N64E7gCwlLFQE3VJWwZmcL9c1tYUcRkYgb6FFDK919HlAFVLn7ucCVCU02wl13dgmAblgjIqEb1B3K3L0lOMMY4KsJyBMZpWOzOH9yvk4uE5HQnc6tKm3IUkRUTVUJ6xtb2bSnNewoIhJhp1MEkTncM1GuO7sEM3hkpbYKRCQ8Jy0CM2s1s5Z+Hq1A6RnKOGJNyMvkgopxLFm1iwidRiEiSeakReDuue6e188j193TzlTIkezD55exuamNW3/5GgfbO8OOIyIRdDpDQzIEPnp+Gf+rZjbPrN/DojtfYO2uobyWn4jIqakIQmZmfPaSKSy+9SKOdHbzwR+9yH/Wbj/1G0VEhoiKIElUV4xjye2Xct6kfL724Cq++dAqjnT2e1VuEZEhpSJIIkW5o/jlZy/gTy4/i/tf3c5H/m2ZLkwnIgmnIkgyaakp/MXCmfz409Vs3XuYmjte4On1u8OOJSIjmIogSb1v9gSW3H4JE8dm8Uf31vLPT2ygu0eHmIrI0FMRJLHJBTk89CcL+Fh1GXc8vYnP/PRV9h46GnYsERlhVARJLjM9le9+ZB7f+fDZvFq/j5o7XmDFtv1hxxKREURFMEx8/D2TeOiLC0hLNT7+7y9x74tbdDayiAwJFcEwMnfiGJbcdinvnV7Etx5Zy5cXv0Hb0a6wY4nIMKciGGbGZKdz96eq+dq1M3h01S5uvOtFXb1URE6LimAYSkkxvnTFNH712QvZ39bBojtf1A1uRORdUxEMYwumFfLoly9lVkket/36df72kTo6unrCjiUiw4yKYJgrHpPJ4lsv4o8unsLPXqznprtfouFge9ixRGQYURGMAOmpKfz1DbO58xPnsqGxlZofvsCLm5rDjiUiw4SKYASpqSrl/912CeNyMvjUT17hrmc20aOzkUXkFFQEI8y08aP57ZcupqaqlH9auoHP/6KWg4d1wxsROTEVwQiUMyqNH9x0Dn+7aA7PvdlEzZ3Ps2bnwbBjiUiSUhGMUGbGZxZU8B9fmE9Xt/Ohf13GfyzfFnYsEUlCKoIR7rxJ+Sy5/RIunDKOr//Xav7iwZW64Y2IvIOKIAIKRo/i3j+8gC9fOY0HanfwoR8tY+vetrBjiUiSUBFERGqK8dVrZvCzW97DzgPt1NzxAk+u1Q1vRCTBRWBmC81sg5ltMrNvnGCZj5nZWjOrM7NfJzKPwBUzx7Pk9kuoKMjh87+o5buPr6erW2cji0RZworAzFKBu4D3A7OBm81sdp9lKoFvAhe7+xzgK4nKI28rH5fNf/7xfD5x4SR+9OxmPvWTV2lq1Q1vRKIqkVsEFwCb3P0td+8AFgM39lnm88Bd7r4fwN33JDCPxMlMT+XvP3g23/voPFZs20/NHc9TW78v7FgiEoJEFsFEYHvc6x3BtHjTgelm9qKZvWxmC/tbkZndama1Zlbb1NSUoLjR9JHzy/jtly4mKz2Vm+5+mZ+8oBveiERN2DuL04BK4HLgZuDHZja270Lufre7V7t7dVFR0ZlNGAGzSvJ4+PZLuHLmeP5uyVpu+/XrHNINb0QiI5FFsBMoj3tdFkyLtwN42N073X0LsJFYMcgZlpeZzr9/6ny++f6ZPF7XyKI7X2Djbt3wRiQKElkEy4FKM5tiZhnATcDDfZb5LbGtAcyskNhQ0VsJzCQnYWZ84b1ncd/nLqSlvYsb7niBbz60ivWNLWFHE5EESlgRuHsXcBuwFFgHPODudWb2bTNbFCy2FNhrZmuBZ4CvufveRGWSgbloagGPffkSPnjuRB5asZOF//I8n/jxyzxR10i3rmYqMuLYcNsxWF1d7bW1tWHHiIz9bR0sXr6dX75Uz66DRyjLz+Iz8yv4WHU5Y7LTw44nIgNkZq+5e3W/81QEMhBd3T08uXY3P1tWz6tb9pGVnsqHzpvILQsqqJyQG3Y8ETkFFYEMqbpdB/n5snp++8YuOrp6uGRaIbcsqOCKmeNJTbGw44lIP1QEkhD72jq4/9Vt/OrlrTQcPMKkcdl8ev5kPlpdzpgsDRuJJBMVgSRUZ3cPT9Tt5t5lW1hev5/sjFQ+fF4Zn1lQwbTxo8OOJyKoCOQMWrPzIPcuq+fhN3bR0d3DpZWF/OHFFVw+fTwpGjYSCY2KQM645kNHWfzqNn758lZ2txyloiCbzyyo4CPnl5GbqWEjkTNNRSCh6ezu4fE1jdy7rJ7Xtu4nJyOVj1aX8+n5k5lapGEjkTNFRSBJYdWOA9y7rJ4lKxvo6O7h8hlF3LKggssqizRsJJJgKgJJKk2tR7k/GDZqaj3K1MIcPrOggg+fX8boUWlhxxMZkVQEkpQ6unr43ZoGfvZiPW9sP8DoUWl8tLqMz8yvoKIwJ+x4IiOKikCS3uvb9vPzZfU8urqBrh7nihnjuWVBBZdWFmKmYSOR06UikGFjT8sR7ntlG/e9so3mQ0c5qyiHWxZU8KHzysjRsJHIu6YikGHnaFc3j62ODRut2nGQ3Mw0Pl5dzqfnVzCpIDvseCLDjopAhi135/XtB7j3xXoeW91AtztXzhjPDfNKuWLmeF3KQmSAVAQyIuxuOcJ9L29l8fLt7Gk9SlqKMf+sAq6dU8w1sycwPi8z7IgiSUtFICNKT4/zxo4DLK1rZOmaRur3HsYMzi0fy7Vzirl2TrGOOhLpQ0UgI5a7s3H3oVgp1DVStyt2W82ZxblcM6eYa+dMYHZJno48kshTEUhkbN93mCfW7mZpXSO19fvocSjLz+rdUjh/cr7umSCRpCKQSGo+dJSn1u3m8TWNvLhpLx3dPRSOzuDqWRO4dm4xC84qYFRaatgxRc4IFYFEXuuRTp7d0MTSukae3dDEoaNdjB6VxhUzx3PtnAlcPmO8Lm8hI5qKQCTO0a5ulm3ay9K6Rp5cu5u9bR1kpKVwybRCrp0zgatnTaBg9KiwY4oMKRWByAl09zivbd3P42tiO5t3HmgnxeA9FeNih6XOmUBZvk5gk+FPRSAyAO5O3a4WnqhrZGndbjbsbgVg7sQ8rp1dzLVzi6kcP1pHIMmwpCIQeRfqm9t6D0tdse0AAFMKc7hmzgQWzilmXtlY3UdBhg0Vgchp2t1yhCfW7uaJukZe2ryXrh5nQt4orpkdOyz1wqnjSE9NCTumyAmpCESG0MHDnTy9YTdL1+zm9xubaO/sZkxWOlfNHM97ZxRxybRC7WyWpKMiEEmQ9o5unn+ziaV1u3lq/W4OHO7EDOaWjuHSykIum17EeZPyyUjT1oKES0UgcgZ09zhrdh7kuY1NPPdmEyu2HaC7x8nJSGX+WQVcNr2ISyuLqCjI1g5nOeNUBCIhaD3SybLNe3n+zSae29jMtn2HASgfl8WllUVcVlnEgmkF5GXqUtqSeKEVgZktBH4ApAL3uPs/9pl/C/BPwM5g0p3ufs/J1qkikOGqvrmN599s4vcbm3lpczNtHd2kphjnlo8NthYKqSobq2shSUKEUgRmlgpsBN4H7ACWAze7+9q4ZW4Bqt39toGuV0UgI0Fndw8rtu7nuTebeP7NZlbvPIg7jM1O5+JphVxWWcillUWUjs0KO6qMECcrgkReXOUCYJO7vxWEWAzcCKw96btEIiA9NYULpxZw4dQCvnYt7Gvr4IVNzTy3sYnn32zi0VUNAEwbP5rLKou4dHohF00pICtDF8mToZfIIpgIbI97vQO4sJ/lPmxmlxHbevgzd9/edwEzuxW4FWDSpEkJiCoSrnE5GSyaV8qieaW991g4ttP5vle28tMXt5CRlsIFFeN6j0aaWZyrnc4yJBI5NPQRYKG7fy54/SngwvhhIDMrAA65+1Ez+wLwcXe/8mTr1dCQRM2Rzm5e3bKvtxg27j4EQFHuKC6tLOS904u4eFohhTp3QU4irKGhnUB53Osy3t4pDIC77417eQ/w3QTmERmWMtNTuWx6EZdNLwKg8eARnnuziec2NvH0+j08tCL2v9XciXm9RyOdP1nnLsjAJXKLII3YcM9VxApgOfAJd6+LW6bE3RuC5x8Evu7uF51svdoiEHnbsXMXjh2iumLbfrp6nOyMVOZPLeDSykIunV7E1MIcDSNFXChbBO7eZWa3AUuJHT76U3evM7NvA7Xu/jDwZTNbBHQB+4BbEpVHZCRKTTHmlY9lXvlYbruyktYjnby0eW/v0UhPrd8DQO6oNGaW5DKrJI/ZJXnMKsljRnEumena+Sw6oUxkRNu6t41lm/eydlcLaxtaWN/QQltHNwApBlOLRjOrJI9ZQUnMKcmjKHeUth5GoLD2EYhIyCYX5DC5IKf3dU+Ps33/YdY1tATl0MqKrft5ZOWu3mUKcjJiWw6lbxfEWUWjdXXVEUxFIBIhKSnWWw4L55b0Tj94uJN1jS29BbGusYV7l9XT0dUDQEZqCpUTRr9jaGl2SR5jsnV5jJFARSAijMlO56KpBVw0taB3Wmd3D1ua22LF0BAbWnp2wx4efG1H7zITx2b1bjUcK4hJ47J1w55hRkUgIv1KT01h+oRcpk/I5QPnTuydvqf1COsaWnsLYl1DC0+v30NPsLsxJyOVGcW5wdBS7DGzOJfsDP25SVbaWSwip+1IZzcbd7e+PbTUEHveerQLADOYUpBz3L6H4rxM7Zg+Q7SzWEQSKjM9laqysVSVje2d5u7s2N/O2oa3txxW7TzAo6sbepfJzkiloiCHKUU5TCnIYUphDhWFOUwtzCE/JyOEnySaVAQikhBmRvm4bMrHZXPtnOLe6a1HOlnf2Mr6hhbeam5jS3MbdTsP8viaRrp73h6hGJOV3lsK8WVRUZhNru7hMKRUBCJyRuVmpvOeinG8p2LcO6Z3dvewfd9htgTlUL839t9Xt+zjN6+/4+o0FI4eFSuIwuy3yyIoDJ0kN3gqAhFJCumpKUwtGs3UotHHzTvS2c3WvYfZ0nyILc2HqQ/K4pkNTTTV7njHsqVjMplSFGxFFL493FSen63rL52AikBEkl5meuxIpBnFucfNaz3Syda9h3mrua23ILY0t7FkVQMH2zt7l0tNMcrys2LFUJDD1LiyKB2bFek7w6kIRGRYy81MZ+7EMcydOOa4efvbOtiyt40tTbGhpmNlsXzLvt5LbUDshLlJBdm9WxDl+VmU5WczMT+LiWOzyBk1sv9UjuyfTkQiLT8ng/ycDM6blP+O6e5OU+vR3q2HLXvf3pr4/cam3jOqe9eTnR4rhrFZlOVn9RbEsbIYkzW8d16rCEQkcsyM8XmZjM/L5MK4s6khdj2m5kNH2b6/nZ0H2tmx/zA797ezY387m5oO8ezGPRzpfGdR5Gam9RZDWX5QFnFFkZ+dntTnS6gIRETipKS8XRLnT84/br67s6+tgx39FMWO/Yd5+a29HApOpDsmOyP1HVsTfbcuikaHe8VXFYGIyCCYGQWjR1EwehTzysceN9/daWnvYvv+w0FRtAdFEXu9YtuBd+zEBhiVlsLEscdK4viiGJ+bmdCd2SoCEZEhZGaMyU5nTHb/O7AhdqTTzgPt7NgXt1URlMbaXS3sbet4x/LpqUbJmCz+/Jrp3HjOxH7XeTpUBCIiZ1huZjozi9OZWZzX7/zDHV3sOtAe208RDDvtPNBO4ehRCcmjIhARSTLZGWlMG5/LtPHHnzeRCDrNTkQk4lQEIiIRpyIQEYk4FYGISMSpCEREIk5FICIScSoCEZGIUxGIiEScufupl0oiZtYEbH2Xby8EmocwzlBRrsFRrsFL1mzKNTink2uyuxf1N2PYFcHpMLNad68OO0dfyjU4yjV4yZpNuQYnUbk0NCQiEnEqAhGRiItaEdwddoATUK7BUa7BS9ZsyjU4CckVqX0EIiJyvKhtEYiISB8qAhGRiItMEZjZQjPbYGabzOwbYecBMLOfmtkeM1sTdpZ4ZlZuZs+Y2VozqzOzPw07E4CZZZrZq2a2Msj1t2FnimdmqWb2upktCTvLMWZWb2arzewNM6sNO88xZjbWzB40s/Vmts7M5idBphnB7+nYo8XMvhJ2LgAz+7Pg3/waM7vfzDKHdP1R2EdgZqnARuB9wA5gOXCzu68NOddlwCHgF+4+N8ws8cysBChx9xVmlgu8BnwgCX5fBuS4+yEzSwdeAP7U3V8OM9cxZvZVoBrIc/easPNArAiAandPqpOjzOznwPPufo+ZZQDZ7n4g5Fi9gr8ZO4EL3f3dnsA6VFkmEvu3Ptvd283sAeAxd793qD4jKlsEFwCb3P0td+8AFgM3hpwJd38O2Bd2jr7cvcHdVwTPW4F1wNDfMXuQPOZQ8DI9eCTFNxkzKwOuB+4JO0uyM7MxwGXATwDcvSOZSiBwFbA57BKIkwZkmVkakA3sGsqVR6UIJgLb417vIAn+sA0HZlYBnAu8EnIUoHf45Q1gD/CkuydFLuBfgL8AekLO0ZcDT5jZa2Z2a9hhAlOAJuBnwVDaPWaWE3aoPm4C7g87BIC77wS+B2wDGoCD7v7EUH5GVIpA3gUzGw38F/AVd28JOw+Au3e7+zlAGXCBmYU+pGZmNcAed38t7Cz9uMTdzwPeD3wpGI4MWxpwHvCv7n4u0AYkxX47gGCoahHwn2FnATCzfGIjGFOAUiDHzD45lJ8RlSLYCZTHvS4LpskJBGPw/wXc5+4PhZ2nr2Ao4RlgYchRAC4GFgXj8YuBK83sV+FGigm+TeLue4DfEBsmDdsOYEfc1tyDxIohWbwfWOHuu8MOErga2OLuTe7eCTwELBjKD4hKESwHKs1sStD2NwEPh5wpaQU7ZX8CrHP374ed5xgzKzKzscHzLGI7/9eHGgpw92+6e5m7VxD7t/W0uw/pN7Z3w8xygp39BEMv1wChH6Hm7o3AdjObEUy6Cgj1QIQ+biZJhoUC24CLzCw7+H/zKmL77YZM2lCuLFm5e5eZ3QYsBVKBn7p7XcixMLP7gcuBQjPbAfyNu/8k3FRA7Bvup4DVwXg8wF+6+2PhRQKgBPh5cERHCvCAuyfNoZpJaALwm9jfDtKAX7v74+FG6nU7cF/wxewt4A9DzgP0Fub7gC+EneUYd3/FzB4EVgBdwOsM8aUmInH4qIiInFhUhoZEROQEVAQiIhGnIhARiTgVgYhIxKkIREQiTkUg0oeZdfe5CuWQnfVqZhXJdrVZkUicRyAySO3BZSxEIkFbBCIDFFzb/7vB9f1fNbNpwfQKM3vazFaZ2VNmNimYPsHMfhPcP2GlmR27LECqmf04uL78E8FZ0iKhURGIHC+rz9DQx+PmHXT3s4E7iV1xFOAO4OfuXgXcB/wwmP5D4PfuPo/YtXSOnc1eCdzl7nOAA8CHE/rTiJyCziwW6cPMDrn76H6m1wNXuvtbwUX5Gt29wMyaid3IpzOY3uDuhWbWBJS5+9G4dVQQu3x2ZfD660C6u//vM/CjifRLWwQig+MneD4YR+Oed6N9dRIyFYHI4Hw87r8vBc+XEbvqKMAfAM8Hz58Cvgi9N9QZc6ZCigyGvomIHC8r7qqrAI+7+7FDSPPNbBWxb/U3B9NuJ3a3ra8Ru/PWsStp/ilwt5l9ltg3/y8Su8OUSFLRPgKRAUrWG8GLnC4NDYmIRJy2CEREIk5bBCIiEaciEBGJOBWBiEjEqQhERCJORSAiEnH/H8bu/sHzup+zAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "If you want to send the standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standrrard thandrand s.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, \n",
      "                                                                                                                                                                                                                                                                                                                                                                       es usuesuesursursursurarsuratratursuraturaturaturaturaturaturaturaturaturatururaturaturaturatururatururaturaturaturururatururaturururur.urgur.urgurgurgurgurgurgur.ur.ur.ur.ur.ur.ur`.ur`.ur`ur`ur`.ur.ur`ur.ur.ur.ur`ur.ur.ur.ur`ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.ur.undund.und.und.ur.und.und.und.und.und.und.und.ur.ur.und.und.und.und.und.und.und.und.und.und.und.und.und.und.usususund.und.und.und.und.und.und.und.und.und.und.und.und.usund<CUTOFF>\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't know home for the statement in the statement in the statement in the statement in the statement in the statement. I don't know home the statement in the statement in the statement in the statement in the statement in the statement in the statement in the statement. I don't know home the statement in the statement in the statement in the statement in the statement in the statement. The statement is the statement in the statement.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I don't know why the same thing is the same thing that works. I work with the same things and the same things when I work with the same things and then the same things when I work with the same things. I work with the same things that works when I work with the same things that works with the same. I work with the same things that works working with the same things that works working. I work with the same things the same things the same.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I think the ```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I work with my python project and I would say that works with my project servers the project servers that I would say that would be pretty supported to the project that would be pretty supported. I would say that would be pretty supported to the project to the project to the project to the project to the project to the project.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I work for my project, but I would say that works with my project solution. I would say that works with my project solution to make something that works with my project solutions. I work with Java Python solutions when I work with Java Python solutions. I work with Java Python solutions to Java Python solutions.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know why the command is the command function in the command there was a static function that command to the command there. I don't know the command there is a static function that command to the command to the command to the command to the command to the command to the command to the command to the command to the command to the command to the command to the command.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know about the same thing to do with the same problem. I don't know what the same problem is the same thing that would be to do with the same problem. I don't know what to do with the same problem when I want to do with the same problem. I don't know what to do with the same problem. I work with the same problem with the same problem. I work with the same problem with the same problem with the same problem. I worked with the same problem with the same problem.\n",
      "\n",
      "Epoch 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:11<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "I don't think the sun when it would be to send to the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, &String.\n",
      "I worked with the string to the string to the string to the string to the string to the string to the string to the string to the string to the string to the string.\n",
      "\n",
      "I would suggest the string to the string to the string to the string to the string to the string to the string to the string to the string to the string to the string.\n",
      "\n",
      "I don't think the string to the string to the string to the string. I don't think the string to the string.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "ChatGPT is a good chat to good answers to the chat to the chat to the chat to the chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat chat store chat. \n",
      "\n",
      "htstrere chat hatt chorgo .\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I was thinking about this to sent the state of the state of the state to the state. I don't think the state of the state the state of the state the state of the state. I don't think the state of the state the state of the state the state of the state. The state is the state of the state the state of the state. The state state the state of the state there to the state. The state state the state of the state state.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I don't know if the ```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would say that would be a pretty similar to make sure that would be a similar to make sure that would be more than the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity to make the similarity.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I work with the whole python who works for the whole then who works with the whole then who works when works when works when works when works when works when works when works when works when works when works when working when works when working when working when working when working when working when working when working when the working whole works when working when working when the working whole working when the whole working who working when working when the working work.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know the standard is the standard of the standard and the standard is the standard in the standard and the standard in the standard and the standard is the standard in the standard and the standard in the standard standard the standard in the standard standard in the standard standard the standard in the standard standard in the standard standard the standard is the standard standard in the standard standard the standard in the standard standard standard standard.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know if the issue where the issue is the issue is the instance. I don't know the instance of the instance of the instance of the instance of the instance of the instance of the instance of the instance of the instance. I don't know the instance of the instance of the instance of the instance of the instance. I don't know the instance of the instance. The instance is the instance. The instance is the instance. There is not the instance.\n",
      "\n",
      "Epoch 11\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:09<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "If you want to send the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to the standard to there.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, “After 0.5” Ben.\n",
      "Is there an entire form form that works for entire form form form form form form form form there?\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't knob if you have to do this for the field. I don't know why the field is to do when the field is to do when it works. I don't know when I want to do this to do when I want to do this to do when I want to do when I want to do when I want to do when I want to do when I want to do when I want to do when I want to do when I want to do when I want to do when I want to do when I want to do when I want to do to send when I want to do to send when IO. I want to do to start.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "If you want to show them to show them to show them in the field, then you can show them to show them.\n",
      "\n",
      "If you want to show them to show them to show them to show them to show them to show them to show them to show them to show them to show them to show them.\n",
      "\n",
      "If you can show them to show them to show them to show them to show them to show them to show them to show them to show to show them to show to show to show to show to show.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I don't know if the ```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would say that the python is that the python is the proper when it would be to sent the properties to the properties. I would say the properties to the properties that would be to sent the properties to the properties.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I work for my project semingly working for my project semingly working for my project semingly working for my project semingly working for my project. I work for my project semingly working for my project semingly working with JavaScript for my project semingly working for my project semingly working for my project semingly working for my project semingly working with JavaScript formats.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know why the problem is the standard standard standard standard standard standard standard. I would suggest the standard standard standard standard standard standard standard standard standard standard standard. I would suggest the standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard standard.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know if the issue when the issue is to confirm. I don't know why the issue works for the internet. I don't know why the internet is to my internet. I don't know why the internet is to my internet. I don't know why the internet is to my internet. I don't know why the internet is to my internet. I don't know why the internet is to my internet. I don't know what to make.\n",
      "\n",
      "I don't know this in the internet.\n",
      "\n",
      "Epoch 12\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:08<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?M (                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     esu t ? ? ? / tsues\n",
      "\n",
      "Shit it its its its its its its its its its its its its its its its its its endoit.\n",
      "\n",
      "It it is it ins it it ins it ts ins incait it ins it ins ins it ins ins it ins ins it ins ins it ins ins it it ins ins.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, ?\n",
      "I don't know that there is no problem.\n",
      "\n",
      "If you want to send them to send them to send them to send them to send them to send them to send them to send them to send them to send them to send them.\n",
      "\n",
      "If you want to send them to send them to send them to send them to send them to send them.\n",
      "\n",
      "If you want to send them to send them to send them to send them to send them to send them.\n",
      "\n",
      "If you want to send them to send them to send them.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't know why this is the set of the set of the set of the set of the set to the set of the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to the set to these told to the set to these told to the set to these told to these.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I want to show them to show them the show the shot when I want to show them. I want to show them to show them the shot when I want to show them. I want to show them to show them to show them to show them. I want to show them to show them to show them. I want to show to show them to show them to show to show them. I want to show to show to show to show to show to show to show to show to show to show to show to show.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I don't know if there is not the similar to the similar to the similarities. I don't know where to start with the similarities and the similarity to the similarities. I would suggest the similarity of the similarity to the similarity of the similarity.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would suggest to send the static static static static static static static static static static string static strings to the static strings that sending in the static strings to the strings that sending in the strings to the strings that the strings the strings to the strings then the strings the strings to the strings then the strings the strings to the strings. Then the strings the strings the strings the strings the strings the strings.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would suggest to send the static static static static static static static stretches. I would suggest to send me to send me to my preference. I would send the static static static stretches to the static stretches to the static stretches. I would send the static stretches to the stretches to the stretches to the stretches to the stretches.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know why the comment is the same function in the function. I don't know why the function is the function in the function in the function. I don't know why the function is the function in the function. I don't know why the function is the function that is the function that it would be there.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I don't know if the core is the core is the core in the core. If you want to send the core in the core. If you want to send the core in the core. If you want to send the core in the core. If you want to send the core in the core. If you want to send the core in the core. If you want to send the core in the core. If you want to send the core in the core.\n",
      "\n",
      "If you want to send the core in the core.\n",
      "\n",
      "Epoch 13\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:06<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?welch technical in the front of the front on the front.\n",
      "\n",
      "The front end when in the front end when in the front end.\n",
      "\n",
      "The front end when the front end when the front end when the front end when the front the front the front the front the front the front the front the front the front the front-therapist.\n",
      "\n",
      "The front the front the front the front the front the front the front the front the front the front the front.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, <> ...\n",
      "I want to send the same the same there was pretty similarity. I want to send the same there was no senting the same there. I want to send the same there was no senting the same there. I want to send the same there was no senting the same thing. I would suggest the same there was to send the same thing. I would send it to send the same thing.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't know why this is not enough. I don't know why it works for me. I would suggest to send the statements to the statements that works. I would recharge the statements to the statements that would be to send the statements to the statements. I would recharge the statements to the statements that would be to much to the statements.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I want to show the shot of the shot. I want to show the shot when I want to show the shot. I want to show the shot. I want to show the shot. I want to show the shot. I want to show the shot on the shot. I want to show the shot. I want to show the shot on the shot. I want to show the shot the shot is to show the shot the shot of the shot. I want to show the shot the shot. I want to shot the shot.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I work with `a` when `a` is not `a` in `a` when ```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "It's not just not surprised. It's not a simple pop on the side. It's not just a simple pop on the side. It's not just a simple pop on the side. It works fine.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I work with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java 1. I worked with Java Java 1. I worked with Java Java 1.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know why you want to do why you want to do what you want to do with the function to do what you want. I would do what you want to do what to do when web doing. I would suggest to do what to do when I want to do what to do when I want to do what to do when I want.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "If you consider the file that consider the file is the file through the file. If you want to do the file through the file through the file, then the file is the file through the file. If you want to do the file through the file, then the file is the file through the file. The file is the file through the file is the file. The file is the file is the file through the file. The file is the file is the file.\n",
      "\n",
      "Epoch 14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [40:52<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun? My computer increments are exited changes on the sun. Influentially one of the observes in the sun whitespace.\n",
      "I would suggest the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, <gh, -> ->>-gh -> -> -> -> ->>> ->> ->>> ->>� ->>�->��\n",
      "I was this just three to send three to send three to send three to send three to send three to send three to send three to send three to send three to send three to send three to send three to send three to send three to send three. I would send three to send three to send three to send three to send three to send three to send three.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't know why this is a good starting point for starting to start with a starting point for stuff. I don't know why the stuff is the stuff for the stuff. I don't know why the stuff is the stuff for the stuff. It will be super stuff.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I think the standard does not work with the standard does not sensitive to the standard detection. I have to sensitive the standard detection to the standard detection. I would suggest the standard detection to the standard detection. I would suggest the standard detection in the standard detection. I would suggest the standard detection in the standard detection.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I would say that the string is the string to the string to the string to the string to the string to the string to the string to the string to the string to the string to the string to the string to the string to the string. The string to the string to the string to the string to the string to the string to the string to the string to the string to the string. The string to the string to the string to the string to the string.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would suggest to set the python state to set the python state to set the python state to set the python state. Then you can set the python state to set the python state to set the python state. Then you can set the python state to set the python state.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say that the python is the same python when the python was still better. I would suggest that the python was the python way. I would suggest the python was the python way. I would suggest the python was the python way. I would suggest the python was the python way.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would suggest you to do with the standard field field when you check the field when you check the field when you check the field when you check the field when you check the field when you check the field when you check the field when the field when you check the field when the field when you check the field when the field when the field when the field when the field when the field when the field when the field.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "If I want to start with coding solutions that could be wrong. I want to start with solutions that could be wrong. I would suggest to start writing the solutions to start writing the solutions that could be wrong. I would suggest to start writing the solutions to start writing the solutions. I would suggest the solutions to start writing the solutions.\n",
      "\n",
      "Epoch 15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [40:53<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "If you want to send the serial serial serialization then the serialization the serialization then the serialization the serialization the serialization of the serialization the serialization of the serialization the serialization of the serialization of the serialization. The serialization is the serialization of the serialization the serialization of the serialization.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, �byz.\n",
      "I work on my comment for me and I have to start my own finger to get a sensitive finger from my life. I have no idea what I want. I have no idea what I want to do. I work with my sensitive fingers and I have to start my sensitive fingers to make my sensors and I have to start my sensors when I want to make my sensors and I have to start my sensors.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I would suggest to suggest the string out of the string to the string to the string then the string the string the string then the string the string the string then the string the string the string then the string the string the string the string then the string the string the string then the string. The string is the string then the string the string the string the string then the string. The string is the string then the string the string.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I want to show the string to the string to the string to the string to the string to the string to the string to the string. I want to show the string to the string to the string through the string to the string through the string to the string. I would suggest the string to the string to the string through the string to the string. Then the string to the string to the string. Then the string to the string.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I work with `a` std::index and `a` when `a` was ``````\n",
      "\n",
      "````\n",
      "is ````\n",
      "````\n",
      "````\n",
      "````\n",
      "````\n",
      "````\n",
      "````\n",
      "`````\n",
      "`````\n",
      "`````````\n",
      "````````````\n",
      "```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````ins``````````````````````````````````````````````````insens``````````````````````ins`````````````````````````````````````````````ins`ins`ins```````ins``ins``````ins`ins`````````````````````ins```````````````ins``````ins````ins``ins`ins```ins```ins`ins````````````ins````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would say that the python is that the python program would be to send the program to be the program. I would say the program would be to send the program to be the program. I would say the program would be to send the program to be there.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say that the python is that the python is the problem with the python statement. I would say that the problem is the problem when the problem is the problem. I would say the problem with the problem. I would say the problem when the problem was said the problem. I would say the problem when the problem was the problem. I would say the problem when the problem was the problem.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would suggest to support the string for the string for the string for the string for the string for the string for the string for the string. I would suggest the string for the string for the string for the string for the string. I would suggest the string for the string for the string.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I wanna head to start with some of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort of the sort.\n",
      "\n",
      "Epoch 16\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:02<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "If you want to send the sun the sun is the sun the sun the sun is the sun the sun is the sun the sun the sun the sun is the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun the sun sun tun the sun un the sun sun tun tun tun tun the stun . thes. tun tun tun thes . tun tun stun . tun tun `. then stun `. stun `. stuns. `. stren `. `. trens. `. trens. `. `. trnstrns. `. `. `. `.`.`.`.`.`.`.`.`.`.`.`.``.``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, <> ..\n",
      "The problem is the problem when you have to start with the problem. The problem is the problem when you have to start with the problem. The problem will be the problem. The problem will be to start with the problem. The problem will be to start with the problem. The problem will be to start with the problem. The problem will be touch the problem with the problem.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I would suggest to suggest the static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static static stick.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I want to show the file in the file. I want to show the file to show the file in the file. I would suggest the file to show the file in the file when it works with the file when it works. I would suggest the file in the file when the file is to show the file in the file. I would suggest the file in the file when the file is the file in the file. I would suggest the file in the file in the file.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I would say that ```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````insensensensensensensensensensensensensensensensensensensensensen``````````````````````````````````````````````insensensensensensensensensensensensensensensensensensensen``````````````````insensensensensensens```````````insensensensensen`in``insensen```````insensensen`ins`ins`ins`insens`````in``````ins``ins```<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would suggest to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before to suggest the static before.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say that the python is that the python is the python when the pin is the pin in the pin on the pin. I would say the pin is to be the project in the project. I would say the project is the project where the project is the project where the project is the project where the project is the project. I would say the project is the project where the project is the project which is the project which would be the project.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know why you would be the same for the same for the same for the same for the same for the same for the same for the same for the same for the same for the same for the same for the same for the same for the same for the same forer. I would suggest the same forer the same forer the same forer the same forer the same forer.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I wanna knob is to consider the coding in the comments. I want to consider the comments on the comments. I want to consider the comments on the comments. I would suggest the comments to consider the comments on the comments. I would suggest the comments to consider the comments on the comments. I would suggest the comments to consider the comments on the comments. I would suggest the comments on the comments on the comments.\n",
      "\n",
      "Epoch 17\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:02<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "If you want to send the sunday then the sunday when you want to send the sunday when the sundays works with the sundays when the sundays works with the sundays when the sundays works with the sundays when the sundays works with the sundays when the sundays when the sundays works with the sundays when the sundays when the sundays when the sundays when the sundays when the sundays when the sundays when the sundays when the sundays when the sundays when the sundays.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, why ?\n",
      "I don't know what the program is trying to do with the program that is trying to do with the program that when the program is trying to do when the program is trying to do when the program is trying to do when the program is trying to do when the program is trying to do when the program is trying to do when the program when the program when the program when the program when the program when the program when the program when the program when the program when the program.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I think the filesystem is the filesystem.probabilityprobability.probability for the filesystem.probability for the filesystem.probability for the filesystem.probability for the filesystem.probability for the filesystem for the filesystem.probability for the filesystem for the filesystem for the filesystem format, and the filesystem format format for the filesystem.probability for the filesystem format, the filesystem format format for the filesysystem format.probisity for the files.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I would suggest the first three three in the first process that works for the first process then when I was the first process which works when works when works when works when works when works when works when works when works when works when works when what the first process who works when who works who what who works who works who what who works who works who who works who who works who who works who whould who work who who whould who whould whangs then.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?````````java```````java```````````java``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "Just start with the python python project that works fine between the python project and the project with the python project. The project will be the project with the python project when you want to build a project with the project. The project would be to send the project with the project which would be the project.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say that the python is that the python is the python or setting the python that would be to set the python then the python the python when the pi is the primary then the pi the primary the primary then the primary the primary then the primary the primary then the primary the primary then the primary the primary then the primary the primary then the primary the primary then the primary the primary then the primary the primary the primary the primary.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know why you would need to do it from the function to do the function that you would need to do this to do this to do this. I would suggest the function that you would need to do this to do this to determine the function that you would need to determine the function that you would need to determine the function that you would need to determine the function to determine the function.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "If you could consider the file in the file, why would you consider the file that when we considered the file then when we considered the file then when we considered the file then when we considered the file then when we considered the file then when we considered the file then when we considered the file then when we considered the file the file then when we considered the file the file then when we considered the file then when we considered the file then when we considered the file.\n",
      "\n",
      "Epoch 18\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2894/2894 [41:14<00:00,  1.17it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output: Why does Earth orbit the Sun?\n",
      "If you want to send the sunlight to the sunlight then the sunling the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight the sunlight.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, why ?\n",
      "I don't know what is the best time to do with the simplest then the simplest the simplest the simplest then the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest the simplest then the simplest the simplest then the simplest then the simplest.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I don't know about this for some other positions that come to my professor when I write them to the same as then the same thing when I write the same thing. I write the same thing that works with the same things when I write the same things that works with the same things that works when the same things works with the same things that works when the same things works with the same things.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I want to show the file in the file. I want to show the file in the file. I want to show the file in the file. I want to show the file in the file. I want to show the file in the file. I would suggest the file in the file to show the file in the file. I would suggest the file in the file in the file. I would suggest the file in the file in the file. I would suggest the file in the file if then it works.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?````````job.`````job.````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````ngen``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````ting```````ting```ting```````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would say that the point is the better way to get the same thing that would be to start with the same point. I would say the same point is the same way to get the same point in the same when it comes to moving the same point and then the same thing. I would say the same point is to be a strong better than the same the same when the same was the same.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would say that the python is that the python is the python statement in the field. I would say that the python is the python statement in the field when i want to save the python statement. I would save the python statement the python statement the python statement. I would save the python statement the python statement.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I don't know why you would need to do it before the function in the function in the function in the function in the function. If you want to do the function then the function in the function in the function in the function in the function in the function in the function in the function in the function in the function in the function in the function in the function in the function in the function in the function in the function.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "If you could have a standard library that could be a bit more than one or through the standard library through the standard library through the standard library. If you want to start through the standard library through the standard library, you could start through the standard library through the standard library. The standard library is the standard library through the standard library.\n",
      "\n",
      "Epoch 19\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▌        | 435/2894 [06:12<35:05,  1.17it/s]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-64d5a6a06db1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     11\u001b[0m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m         \u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1128\u001b[0m         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m   1129\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1130\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1131\u001b[0m         \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1132\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-9-f94c1bba862f>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, calculate_loss)\u001b[0m\n\u001b[1;32m     54\u001b[0m             \u001b[0;31m## Run the decoder\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m             \u001b[0;31m#do masked self attention\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m             \u001b[0mmask\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMultiHeadAttention\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen_causal_mask\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     57\u001b[0m             \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0md_self_attention\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmask\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmask\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     58\u001b[0m             \u001b[0mself_res\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "model.train()\n",
    "\n",
    "epoch_losses = []\n",
    "for epoch in range(n_epochs):\n",
    "    print(f\"Epoch {epoch+1}\")\n",
    "    \n",
    "    batch_losses = []\n",
    "    for data in tqdm.tqdm(dataloader):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        data = data.to(device)\n",
    "\n",
    "        output, loss = model(data, True)\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        batch_losses.append(loss.item())\n",
    "\n",
    "        \n",
    "    epoch_losses.append(sum(batch_losses)/len(batch_losses))\n",
    "\n",
    "    plt.plot(range(len(batch_losses)),batch_losses)\n",
    "    plt.xlabel(\"Batch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.title(\"Batch loss\")\n",
    "    plt.show()\n",
    "\n",
    "    plt.plot(range(len(epoch_losses)), epoch_losses)\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.title(\"Epoch loss\")\n",
    "    plt.show()\n",
    "\n",
    "    torch.save(model, prefix_models+f\"model_E{epoch}\")\n",
    "\n",
    "    with open(prefix_models+\"losses.txt\", \"a\") as f:\n",
    "        f.write(f\"{epoch_losses[-1]}\\n\")\n",
    "        \n",
    "    scheduler.step()    \n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for i, prompt in enumerate(prompts):\n",
    "            print(f\"Prompt {i}: {prompt}\")\n",
    "            output=generate(prompt)\n",
    "            print(f\"Model output: {output}\")\n",
    "            print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DUracnfcZSLX",
    "tags": []
   },
   "outputs": [],
   "source": [
    "model = torch.load(prefix_models+\"model_E0\")\n",
    "\n",
    "with torch.no_grad():\n",
    "    for i, prompt in enumerate(prompts):\n",
    "        print(f\"Prompt {i}: {prompt}\")\n",
    "        output=generate(prompt)\n",
    "        print(f\"Model output: {output}\")\n",
    "        print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r31WSN9YiTuZ"
   },
   "outputs": [],
   "source": [
    "import builtins\n",
    "while True:\n",
    "    prompt = builtins.input(\">>> \")\n",
    "    output=generate(prompt)\n",
    "    print(f\"Model output: {output}\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "machine_shape": "hm",
   "provenance": []
  },
  "gpuClass": "premium",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}