merge_rgb_from_ms.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/nam/datasets/eurosat/data\n"
     ]
    }
   ],
   "source": [
    "%cd datasets/eurosat/data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'eurosat_ms': None, 'sentinel1/2_ms': None}\n"
     ]
    }
   ],
   "source": [
    "user_list = [\"eurosat_ms\", 'sentinel1/2_ms']\n",
    "datasets_dict = dict.fromkeys(user_list)\n",
    "list_datasets_size = []\n",
    "print(datasets_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/nam/.conda/envs/hf/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eurosat_dict: DatasetDict({\n",
      "    train: Dataset({\n",
      "        features: ['image', 'label', 'filename'],\n",
      "        num_rows: 16200\n",
      "    })\n",
      "    test: Dataset({\n",
      "        features: ['image', 'label', 'filename'],\n",
      "        num_rows: 5400\n",
      "    })\n",
      "    validation: Dataset({\n",
      "        features: ['image', 'label', 'filename'],\n",
      "        num_rows: 5400\n",
      "    })\n",
      "})\n",
      "\n",
      " eurosat_list: [Dataset({\n",
      "    features: ['image', 'label', 'filename'],\n",
      "    num_rows: 16200\n",
      "}), Dataset({\n",
      "    features: ['image', 'label', 'filename'],\n",
      "    num_rows: 5400\n",
      "}), Dataset({\n",
      "    features: ['image', 'label', 'filename'],\n",
      "    num_rows: 5400\n",
      "})]\n"
     ]
    }
   ],
   "source": [
    "from datasets import load_dataset\n",
    "\n",
    "eurosat_dict = load_dataset(\"parquet\", data_files={'train': 'train-*.parquet', 'test': 'test-*.parquet', 'validation': 'validation-*.parquet'})\n",
    "print(f\"eurosat_dict: {eurosat_dict}\")\n",
    "eurosat_list = list(eurosat_dict.values())\n",
    "print(f\"\\n eurosat_list: {eurosat_list}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset({\n",
      "    features: ['image', 'label', 'filename'],\n",
      "    num_rows: 16200\n",
      "})\n",
      "16200\n"
     ]
    }
   ],
   "source": [
    "eurosat_trainset_dict = eurosat_list[0]\n",
    "print(eurosat_trainset_dict)\n",
    "print(len(eurosat_trainset_dict))\n",
    "datasets_dict['eurosat_ms'] = eurosat_trainset_dict\n",
    "list_datasets_size.append(len(eurosat_trainset_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset({\n",
      "    features: ['image', 'label', 'filename'],\n",
      "    num_rows: 16\n",
      "})\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "batch_eurosat_trainset_dict = eurosat_trainset_dict.select(range(100, 100 + 16))\n",
    "print(batch_eurosat_trainset_dict)\n",
    "print(len(batch_eurosat_trainset_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of batch: (16, 64, 64, 13)\n",
      "Shape of 1 multispectral sample: (64, 64, 13)\n",
      "Shape of 1 rgb sample: (64, 64, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUgAAAFeCAYAAADnm4a1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRzElEQVR4nO29ebQdVZn+/+6azrnzvRkIgZCBEIGAioJow4JAM7UxiG0HRRxIbBukXQw2CA4Mhih0t9oLGkQGXUDb2LY0KspiaEZF2oHWgAyBMIREEsh8M90zVNXevz/45n7Z+30KThga+vt7Pmuxlmdbp06dqjo7dd9nv89jnHNOCCGEKKI3+wAIIeStCidIQgipgBMkIYRUwAmSEEIq4ARJCCEVcIIkhJAKOEESQkgFnCAJIaQCTpCEEFIBJ8j/xUydOlXmzZv3Zh/Gq+LZZ58VY4xce+21b/ahEFLJW2qCvPbaa8UYU/nfb37zm+3a38qVK+WrX/2qPPjgg2/MAXfALbfcIl/96lfftM8XEXUee3p6ZObMmfK1r31NRkZG3tRjez2466675NOf/rS87W1vk+7ubtl1113lM5/5jDz//POvep8rV66UT3ziE7L77rtLX1+fDA4Oyv777y/XXXedvF7duU8//bTU63Uxxsh///d/vy77fC1s+0dr239RFMmYMWPk/e9/v/z617+ufN8f//hHmT9/vkybNk3q9br09vbKPvvsI2eddZY888wz3rbz5s3zPiNJEtlll13kuOOOk8cee+yN/orbTfJmHwDiggsukGnTpqnx3Xbbbbv2s3LlSlmwYIFMnTpV9tlnn9fp6LaPW265Rb797W+/6ZPkEUccIZ/61KdERGTLli1y3333ybnnnisPPfSQ3HDDDW/qsb1Wzj77bFm/fr0ce+yxMmPGDHnmmWfksssuk5tvvlkefPBB2XHHHbd7n2vXrpXnnntO5s6dK5MnT5Y8z+WOO+6QefPmyRNPPCEXXnjhaz7uz3/+85IkibRarde8r9eTj33sYzJ79mwpy1KWLFkil19+uRx66KHywAMPyNvf/nZv26uvvlpOPvlkGTdunHz84x+XPfbYQ4qikEceeUT+5V/+RS6++GJpNBoSx/Hoe2q1mnz3u98VEZGiKOTpp5+WK664Qm677TZ57LHHZKeddvof/b4vi3sLcc011zgRcQ888MDrsr8HHnjAiYi75pprOtp+69atr8vnvpTPfe5z7o06zVOmTHEnnHDCK24nIu5zn/ucGp87d66Losg1Go034OhenqVLl27XtXk5fvGLX7iyLNWYiLivfOUrr3n/L2XOnDmup6fHFUXxmvZz2223uSzL3DnnnPO63vOvhW3X5Bvf+IY3fuuttzoRcSeffLI3fv/997s4jt3BBx/sNm3apPbXaDTcOeec452rE044wfX09Khtb775Zici7qqrrnqdvs3rw1vqT+xOOf/88yWKIrnrrru88RNPPFGyLJOHHnpI7r33XnnPe94jIiLz588ffaTfVvM65JBDZO+995bf//73cvDBB0t3d7d8+ctfFhGRm266ST7wgQ/ITjvtJLVaTaZPny4LFy6UsizVsfz2t7+V2bNny9DQkPT09Mg73vEOueSSS0TkxT8nvv3tb4uI/2fuNqy1cvHFF8tee+0l9XpdJkyYICeddJJs2LDB+wznnHzta1+TSZMmSXd3txx66KHy6KOPvubzuOOOO47+mbON++67T4499liZPHmy1Go12WWXXeTzn/+8NBoN773z5s2T3t5eWbFihXzoQx+S3t5eGT9+vJx55pnqPA0PD8u8efNkYGBABgcH5YQTTpDh4WF1PC+88ILMnz9fJk2aJLVaTSZOnCjHHHOMPPvssy/7PQ4++GCJokiNjRkzRhYvXrx9J+UVmDp1qoyMjEi73X7V+8jzXE477TQ57bTTZPr06R2/b/369XLmmWfK29/+dunt7ZX+/n55//vfLw899JDa9tJLL5W99tpLuru7ZWhoSPbbbz/5wQ9+8KqO96CDDhKRF0sCL2XBggVijJHrr79e+vr61Pvq9bosXLjQe3qsYttT/kvvxbcCb62j+T9s3LhR1q5d640ZY2Ts2LEiInLOOefIz3/+c/nrv/5refjhh6Wvr09uv/12ufrqq2XhwoXyzne+U1atWiUXXHCBnHfeeXLiiSeOXuQDDjhgdJ/r1q2T97///XLcccfJJz7xCZkwYYKIvFgL7e3tlb/7u7+T3t5eufvuu+W8886TTZs2yTe+8Y3R999xxx0yZ84cmThxopx22mmy4447yuLFi+Xmm2+W0047TU466SRZuXKl3HHHHfL9739ffc+TTjpJrr32Wpk/f76ceuqpsnTpUrnssstk0aJFcv/990uapiIict5558nXvvY1mT17tsyePVv+8Ic/yJFHHrldP9Jmszl6Trdu3Sr333+/XHfddXL88cd7N+UNN9wgIyMjcvLJJ8vYsWPld7/7nVx66aXy3HPPqT/Fy7KUo446St773vfKN7/5TbnzzjvlW9/6lkyfPl1OPvlkEXlxcj/mmGPkV7/6lXz2s5+VPffcU37yk5/ICSecoI7xr/7qr+TRRx+VU045RaZOnSqrV6+WO+64Q5YvXy5Tp07t+LuKvFhG2LJli4wbN2673hfSaDRk69atsmXLFvnFL34h11xzjfzZn/2ZdHV1vep9XnzxxbJhwwY555xz5Mc//nHH73vmmWfkpz/9qRx77LEybdo0WbVqlVx55ZUya9Ys70/Tq6++Wk499VSZO3eunHbaadJsNuWPf/yj/Pa3v5Xjjz9+u4932z9QQ0NDo2MjIyNy9913yyGHHCKTJk3a7n1uuxfLspRnnnlGzj77bBk7dqzMmTNnu/f1hvJmP8K+lG1/YqP/arWat+3DDz/ssixzn/nMZ9yGDRvczjvv7Pbbbz+X5/noNi/3J/asWbOciLgrrrhC/X8jIyNq7KSTTnLd3d2u2Ww655wrisJNmzbNTZkyxW3YsMHb1lo7+r+r/sS+7777nIi466+/3hu/7bbbvPHVq1e7LMvcBz7wAW+/X/7yl52IdPwnNvrvQx/60Oj3ebnvftFFFzljjFu2bNno2AknnOBExF1wwQXetu9617vcvvvuO/r6pz/9qRMR94//+I+jY0VRuIMOOsi7Nhs2bIB/3r1aFi5c6ETE3XXXXa9pPxdddJF3zg477DC3fPnyV72/559/3vX19bkrr7zSObd9ZaVms6lKCUuXLnW1Ws27Dsccc4zba6+9tvvYtv2JvWDBArdmzRr3wgsvuPvuu8+95z3vcSLibrjhhtFtH3roISci7vTTT1f7WbdunVuzZs3of61Wa/T/23bfhP/tvPPO7ve///12H/MbzVvyT+xvf/vbcscdd3j/3Xrrrd42e++9tyxYsEC++93vylFHHSVr166V6667brse0Wu1msyfP1+Nv/TpYPPmzbJ27Vo56KCDZGRkRB5//HEREVm0aJEsXbpUTj/9dBkcHPTe/9I/o6u44YYbZGBgQI444ghZu3bt6H/77ruv9Pb2yj333CMiInfeeae022055ZRTvP2efvrpHX9PEZFjjjlm9FzedNNN8qUvfUluu+02Of744z1V9qXffevWrbJ27Vo54IADxDknixYtUvv97Gc/670+6KCDPOXylltukSRJRp8oRUTiOJZTTjnFe19XV5dkWSb33nuvKjFsL7/85S9lwYIF8pGPfET+/M///DXt62Mf+5jccccd8oMf/GD06SssN2wPZ5999qjKvr3UarXRUkJZlrJu3Trp7e2V3XffXf7whz+Mbjc4OCjPPfecPPDAA6/qGM8//3wZP3687LjjjnLQQQfJ4sWL5Vvf+pbMnTt3dJtNmzaJiEhvb696/6677irjx48f/e9nP/uZ9//X6/XRe/H222+XK6+8Unp7e2X27NmyZMmSV3XMbxRvyT+x999/f9lvv/1ecbsvfOEL8sMf/lB+97vfyYUXXigzZ87crs/ZeeedJcsyNf7oo4/KOeecI3fffffojbCNjRs3isj/rcfsvffe2/WZ23jyySdl48aNssMOO8D/f/Xq1SIismzZMhERmTFjhvf/jx8/3vuT55WYNGmSHH744aOvP/jBD8rYsWPlzDPPlJtvvlmOPvpoERFZvny5nHfeefKzn/1MTVTbvvs26vW6jB8/3hsbGhry3rds2TKZOHGi+iHtvvvu3utarSb/8A//IGeccYZMmDBB3ve+98mcOXPkU5/61Hap0I8//rj85V/+pey9996jSulrYcqUKTJlyhQReXGyPPHEE+Xwww+XJ554Yrv/zP7Nb34j3//+9+Wuu+5SNdNOsNbKJZdcIpdffrksXbrUq/VuKz+JvDgJ33nnnbL//vvLbrvtJkceeaQcf/zxcuCBB3b0OSeeeKIce+yx0mw25e6775Z//ud/VnXlbTXHLVu2qPffdNNNkue5PPTQQ3LmmWeq/z+OY+9eFBGZPXu2zJgxQ770pS/JjTfe2NFx/k/wlpwgO+WZZ56RJ598UkREHn744e1+P7rBh4eHZdasWdLf3y8XXHCBTJ8+Xer1uvzhD3+Qs88+W6y1r/m4RV682XfYYQe5/vrr4f8fTjxvBIcddpiIvPjEdfTRR0tZlnLEEUfI+vXr5eyzz5Y99thDenp6ZMWKFTJv3jz13Tspvm8Pp59+uhx99NHy05/+VG6//XY599xz5aKLLpK7775b3vWud73i+//0pz/JkUceKQMDA3LLLbdA4eC1MnfuXLn66qvll7/8pRx11FHb9d6zzjpLDjroIJk2bdpoXW9bLe7555+X5cuXy+TJkyvff+GFF8q5554rn/70p2XhwoUyZswYiaJITj/9dO/a7LnnnvLEE0/IzTffLLfddpvceOONcvnll8t5550nCxYseMXjnDFjxugENmfOHInjWL74xS/KoYceOvrgsttuu0mSJPLII4+o98+aNUtEtk9wmTRpkuy+++7yy1/+suP3/E/wv3aCtNbKvHnzpL+/X04//XS58MILZe7cufLhD394dJtO/tQNuffee2XdunXy4x//WA4++ODR8aVLl3rbbVMfH3nkEfWv4UupOobp06fLnXfeKQceeODLPolse3p58sknZddddx0dX7NmzWv+U7QoChH5v08BDz/8sCxZskSuu+660TWTIi+KUa+WKVOmyF133SVbtmzxniKfeOIJuP306dPljDPOkDPOOEOefPJJ2WeffeRb3/qW/Ou//uvLfs66devkyCOPlFarJXfddZdMnDjxVR/zy7Htz+vwaboTli9fLsuWLYNrfD/4wQ/KwMAAVPe38R//8R9y6KGHyve+9z1vfHh4WIlRPT098tGPflQ++tGPSrvdlg9/+MPy9a9/Xb70pS9JvV7fruP+yle+IldffbWcc845ctttt43u/5BDDpFf/OIXsmLFCtl55523a5+IoijgE+mbyVuyBtkJ//RP/yT/9V//JVdddZUsXLhQDjjgADn55JM99bunp0dE5GVvupBtT0Uvrcu12225/PLLve3e/e53y7Rp0+Tiiy9W+3/pe6uO4SMf+YiUZSkLFy5Ux1AUxej2hx9+uKRpKpdeeqm334svvrjj71TFz3/+cxEReec73yki+Ls750aXLb0aZs+eLUVRyHe+853RsbIs5dJLL/W2GxkZkWaz6Y1Nnz5d+vr6XnEh9datW2X27NmyYsUKueWWW1Q54tWwZs0aOP69731PjDHy7ne/e7v3edVVV8lPfvIT779ttdhvfvOblX9NbCOOY9XFc8MNN8iKFSu8sXXr1nmvsyyTmTNninNO8jzf7uMeHByUk046SW6//XavK+28886TsizlE5/4BJzYwmN9OZYsWSJPPPHE6L34VuEt+QR56623joohL+WAAw6QXXfdVRYvXiznnnuuzJs3b7R2du2118o+++wjf/u3fys/+tGPROTFH9jg4KBcccUV0tfXJz09PfLe974X/gv+0s8YGhqSE044QU499VQxxsj3v/99dbGjKJLvfOc7cvTRR8s+++wj8+fPl4kTJ8rjjz8ujz76qNx+++0iIrLvvvuKiMipp54qRx11lMRxLMcdd5zMmjVLTjrpJLnooovkwQcflCOPPFLSNJUnn3xSbrjhBrnkkktk7ty5o2sLL7roIpkzZ47Mnj1bFi1aJLfeeut2LWFZsmTJ6FPYyMiI/OY3v5HrrrtOdtttN/nkJz8pIiJ77LGHTJ8+Xc4880xZsWKF9Pf3y4033vianlSPPvpoOfDAA+WLX/yiPPvsszJz5kz58Y9/rJ7AlixZIocddph85CMfkZkzZ0qSJPKTn/xEVq1aJccdd9zLfsbHP/5x+d3vfief/vSnZfHixd7ax97eXvnQhz40+vqrX/2qLFiwQO655x455JBDKvf59a9/Xe6//375i7/4C5k8ebKsX79ebrzxRnnggQfklFNO8bq67r33Xjn00EPl/PPPf9mOqSOPPFKNbfuHcNasWa9Yd58zZ45ccMEFMn/+fDnggAPk4Ycfluuvv977y2Lb5+y4445y4IEHyoQJE2Tx4sVy2WWXyQc+8IFXXXY47bTT5OKLL5a///u/lx/+8Ici8qIgd9lll8kpp5wiM2bMGO2kabfbsmTJErn++uslyzJVQy6KYvRetNbKs88+K1dccYVYa+X8889/Vcf3hvEmqeeQl1vmI/9nSUhRFO4973mPmzRpkhseHvbef8kllzgRcf/+7/8+OnbTTTe5mTNnuiRJvGUls2bNqlwKcf/997v3ve99rqury+20007urLPOcrfffrsTEXfPPfd42/7qV79yRxxxhOvr63M9PT3uHe94h7v00ktH//+iKNwpp5zixo8f74wxasnPVVdd5fbdd1/X1dXl+vr63Nvf/nZ31llnuZUrV45uU5alW7BggZs4caLr6upyhxxyiHvkkUe2q5Pmpf/FcewmTZrkTjzxRLdq1Spv28cee8wdfvjhrre3140bN879zd/8zeiSjpcul6rqiDj//PPVd1y3bp375Cc/6fr7+93AwID75Cc/6RYtWuTtc+3ate5zn/uc22OPPVxPT48bGBhw733ve92PfvSjV/x+U6ZMqbxnpkyZ4m17xhlnOGOMW7x48cvu8z//8z/dnDlz3E477eTSNHV9fX3uwAMPdNdcc4233Mo5537+859XLhl7JbZ3mc8ZZ5wxeh8ceOCB7te//rWbNWuWmzVr1uh2V155pTv44IPd2LFjXa1Wc9OnT3df+MIX3MaNG192/1WdNNuYN2+ei+PYPfXUU974okWL3Kc+9Sk3efJkl2XZ6O/gjDPOUNuiZT79/f3usMMOc3feeecrnoP/aYxzzMUm//9h//33lylTpryu/ednnXWW/Nu//Zs89dRTUqvVXrf9kjeft+Sf2IS8EWzatEkeeughue66617X/d5zzz1y7rnncnL8fxA+QRJCSAX/a1VsQgh5o+EESQghFXCCJISQCjhBEkJIBZwgCSGkgo6X+fz5vF90tF1e+q1M+Wbds9pqPKfGGquWqrFmQ7d7lYVvElsUunXKWS3MF42tel+lNp5wZaHG0rrfK13v1ss5XKQ/MwJucqWARQPBYTjgMIS+pzjd550kuq/bGv87GQP+XTTaeCKK9O1RAoOKWJ8yscFYEenjf3HdfPA+p6+JAecxDk6aLcA1Bw7wBoyV4Jpb8bdLwGIPk6VqLK1ph6X+nbXL1MTJe+n3Zn6XS3urbrEsBNwHuTZOrvX0q7Gs1x+LI2A2YnWIW9HQY3mux1pbfRu4OO1W26Q9+jNdNkaNdWe6Xzyp699d0fDbU9NUdwqZVP9OfvKPneVb8QmSEEIq4ARJCCEVcIIkhJAKOEESQkgFnCAJIaQCTpCEEFIBJ0hCCKmAEyQhhFTACZIQQirouJMGrcxHtDf53S8u0l0hcc9Oaqx7ol4lH20ZVGP5+hf8141htU1TdAeCA181inXXhgX/ZjTbfqdFXurOhSTV+6+nutMiivWq/sL4742s7pZIRL/PRnrMGX1sYccK6lZB3UcR6PqJQCeNFT1mgsseGX1+nNNdLZHVYwKOzQZjcazPdQkaRQy4dlLqY0tK/x4ypb4mUbupxopyvRobXv6o3j/4XUyYEgSBoU4dAd0k5WY1lrfB8QbdL8boc+2M7sQyoo81SkD8ceafs7LUv0Mjeh6pJ3r/aaa/Zwm+k4TRsnX9+zVhq9p2wCdIQgipgBMkIYRUwAmSEEIq6LgGGYEaGyJL/dqBi3TNJ7a9aiyva+ePnprOfXZ13/ljy0btDCSbX1BDoNwoTVBDMkbXfeLA9ccCJ5NGW9dbbKo/NK7pumGU+LUVA1x6nNHuJgY58KBLavz9RcDRJge1vwK4+cQFsO4R4IZjg88Ex+VAjRPVih2otYb/tJcWOf7o4wJ7EkFOPcGWzQLUgMG56DF6O9PSdclVzy3S+4v9WuL4Xd6rtunKJqixHJyfAt3buX8/ljVQOwb7ShL9mxDgBFRz/vloN3TNMK5pt50U3Qfgfixzvb+0yz82VMN24HfSKXyCJISQCjhBEkJIBZwgCSGkAk6QhBBSQccijVhY3lb01ge8110gAqBd6nm50dDRDCbSwk1taLz3emjcrmqbDaufVWNb1jytxmTT82qouWVYjSVBnILNQKxBS4s0zSYoGIOYh1pwFdIMiCPANj4C4gLQKsSUfiE7FFBERCIgLrgwN0FErAPRCWDxuCn9/VkQSWEiXfxPEmDJDwSSMgoWEsdgETF4n4AF2kYaaswGi6idRc0H+mRbcC6iCCzMH9GLu1c98ivvdZHq+2z65AP0/mP9nRxYyB1GS6RAb4sTcJ1qenF3Ahb5F84/j87oY0jbQHypo7gScO2AWBSKeuCWlRI1B3QInyAJIaQCTpCEEFIBJ0hCCKmAEyQhhFTQsUhj27p7BGGC3N7Q1UVEpA7El8ho9452DkQO1+O9jnt1h8lQXX9oV68ey9bosY0v6IJxc8T/7kmMTpt+XwkcYIDGISNNv4gcg6J1X48uWtdCdUcEpSZLu/C7KpC3SQbcdsQCtyNQ/AemMGKcL1aUYF8ROBLU5WNi4NASiEoOCE8WdHtE4FhRb5Bx/vnIEn2f2VJ3q5RAXEDuSTEIEy+t/xmblz+pttnQP0mN9fdPU2MpePTJQ3G0BdyUYn3vxZk+jwno7LJu0Htt4k1qGwPunxy4V0VO349poucNEzhJFehqGnSFO4NPkIQQUgEnSEIIqYATJCGEVMAJkhBCKuhYpEkiXZRFlEGNt0RF9wIUhxMt0nQnoJMjqBcbpwu3cQKsr8YCG7PakD62ZFCNDb/wlPe63dyg9wXs8Y0FNlEpKOw3/cK+cfr48yaSVvT56erR1ymu+WNbm7pzpCj1vmIQD2FAF5QzurAv4l9jA0SaEu0fWFPBHq6gIykCLUQF6PYQJAgY8JwQdKc4oESZtr5nBdhtWfAbQGJImvoCpIDrtHGdtvfr7tbCTYTOY/A1UXxGnKGOKmCnBu7ROOhSiga0tVnR0mKvaejvGXXr32bS1aPGbMv/PSG7PHQfdwqfIAkhpAJOkIQQUgEnSEIIqYATJCGEVNCxSJOCLAm4nfgWTXmhC7Bt5EkEOhAMsKbKgpXzJSg0Fy39tcpYizlJn87nHpMNqLFaf5CD8/xStc3mDSvVWN7SnQQCuoiS4NTGoCjeBnZbeaiIiUi90CJE/4Qgx2TDWrXNyIjefyFAXFAjIibMJhad2W0L0KEBuknEAUsrlCkSWtABS7EYde+A7hoDxJwy+O4O5FFLAjqlkLUW6AoRYAUmxr8GkWi7s3yjvnbNIS3c9A5NV2OhRVkG7OaQdV0OBLzMoHwY//faBoJMOaJFSpfojCqga0kJOpdsMJcYq8+/A1Z+ncInSEIIqYATJCGEVMAJkhBCKui4BtkGC2wRcRAD4KyuI0bA3aTMdQ1Mj4ikgZNODGomCbKbBzWwArqZ6FpTz7i3ea+z7rFqG7dysRrbsvopNWbAeQyPLAHuI12prtMgByQDFm3Xe3uDbUCNs6njJ9ptcKzgjokL8O9sGJ0QoQXmoAYGFr87tJA7qKc5ZNEvoJ4ZgeYDUMvV5kxgYTSqvYJzG4Gae4k+M2igMLJFbdLepOvam9etVmNdPePVWK3bj06AC8DbuoZXFvozyxg0jgTF9HZD/76aoEmkGzhtha5gIiIWNF6EqSPIuKfIXv1zIJ8gCSGkAk6QhBBSASdIQgipgBMkIYRU0LFI4wQs1gUUNrD3B6KBA4VaBxY4owWeZVCcL0v9FaIYLBoGNfEWEItQYT9O/bG0XxeyJ9T3UmODfWPU2PMrl6mxRpDFHRm9INYA8ahEDjNARWmO+OcWuaL0DI5TY8nIVjWW53rMFiCaIRBbDHBYCvO6RUQcuFDO6mYDEyzcRs401oIYDHA/GiAghbnMEfAUQiKHAdEVaCF9HOlrHK7LR8JlXq7T+1r3JzVW79fXc2zqCysluNfLtr6+BTj/GYg6SYNF+G2QY50AYa5egt95Te/foOkqXLAO7rNO5y4EnyAJIaQCTpCEEFIBJ0hCCKmAEyQhhFTQsUjTqWu5C4Kwi7ZehZ+3dVHftXVBGnVQFLFfyY4iUBQHXTMROP6w2UNExIXWOiLiAoeZoqEL5bbUziX18buosYlAuNn0gu8O1Fyn3YIEiFjAmEYEuJnkI8EYEHy6evU5q3Vr5yHb1ue7ATqSrGpFAXnIOSioAzHNANHN2DCmQh9DAm7a0umThoSbKBDAoJ4HDjaKwBgUqPQ1cIHggDp8DNh/e0Q7/Gx+Qd9DPYM7eq+BhiJRpI+rXtOuQiK6+yUPxJYM5NMbM6jGyroWDVHOfLs1rMai4EcM+6lQIkiH8AmSEEIq4ARJCCEVcIIkhJAKOEESQkgFHYs0m7Z0ptLYwu+gKHLQzVAie3xdZK/16OJtVvfndAds2MuGFnxMogvGSaYFmRx05hSBjX4U6+p2lO2gxuL6oBob06eFj/4+P9d4Q5e2U9u07mk11t66Rh8HKEiXLf/4C5BtnYDLG4Hqdhzpgn0vsKuSehC5ACy/Wk0QdQDs/Qsg8NggSxzV4RPQIYPu4hiMtgOBBNnImRjsH3XvAIUHCjfhzxF16hTAzwt0Xm3apGMYutau8F4PTdhNbZMmqENGCzftUnfcSCAW1YHIl6EOGXRRwPlu5iBOoQg/A3TpOXDOOoRPkIQQUgEnSEIIqYATJCGEVMAJkhBCKuhYpOnp6kykKVr+yvZGAlbJF7rYGr5PRMS29Gfmwf4SC1b5mw16/w7YheX9aixxKFfXL7JnXbobJgW5zKg4X4KknajmH9vALjPVNj3jJ6qx4WVL1NjG9VrMaWx5wXudgDxqm4J8FZBJY+1GNYbyy2vd/ndKYr1NdwYK9t36ehqQf+IK/3g3bwU2bMAuLMyyERGJYz2WWv9+tOBaOiAkCOj6iZDIBHKfTZDtY0E4dAms5SQGXVYN3dnVXOdb7blxO6ptLBAzkWUh0KdEQoEKiEwO2OW5Li2WdmVa4EECTCu4R5NE/85D4Xh74BMkIYRUwAmSEEIq4ARJCCEVcIIkhJAKOhZpshryewI7DIqkCci9QMH1RQ4EjZa2SisCwcSkWgRC9lX5iC5k13r1Z6bAAyqy/ntjpzsXYpDzkoLifNnWheYi6AoxoFMn6x1QY2Om6OJ20q+327D8Me/1pg06w8Q19XdyyM4r1rdMAoSJdtsXCcpUCyZxTQtiaQ/ovsiA3Vnqb9c/oMWFNhD+mg3wPYHwESfBdwfnwllwfZGGAjp1Qru2Fz8iyPEB9w+y7XNIjALiaNn2v/vIZi1mjukaVGPIYs0YLZwlwZgBfoJWUNYMOhf62a0ObNHyyM/LKcDvK0FiWofwCZIQQirgBEkIIRVwgiSEkAo6rkEasNAXEQW5xkmpa3+lBXm5qa5DZBFYIBzWaVKQrVzTC8DzRC+cRTEAMbCXj4NsA5uD0wZiHpKsV491gZyEZIv3MipBbILVtbO0Ry+KnTDwLjU2MHay93rV0kVqm7XPPaHGRjauVmMGRDpY4ObjgpqyBREDOViU327qRb3o2iVZUJ8GMRKmpuuZ3RloGADvbQeLi020RW1TgAgA5CtUgugEAa5RYc3XgdocbDRArkKis6ybW1Z5r9cv/6PaJu0eVGNDA+DagVprlPrbGbAavhC9rxqIVmnn+pqnRr+3O2jaGCl0HEobZH13Cp8gCSGkAk6QhBBSASdIQgipgBMkIYRU0LFIUzqUXYs29IuryPY+zUCmLijolmABcljcRnnUKMQ4yUAGswGLnlMtrESh2wuy3weRAhYtEI61SFNLBv1jcFrYilu66N5oAechq79TFuQhT9htP7VNT78Wttat0MLNhpXL1Jht6uNtB8JBBGzvI+AClCT6+NvAar8dLHrOc+0yJOCax8AlJq3pxfX1bn+sKLUYOJJv1p/ZBgvRwYJyB1yFXHDfqggGETEgEsGiRedAHG1s9SMR2oU+hu5V2g2quwZ++6k+Z67wjyMCueTh+nsREQcytl2pxai8qYWyWPzfU5KChoE23XwIIeR1hxMkIYRUwAmSEEIq4ARJCCEVdCzSJF2dddI0N/ur1lEXQQws4g0oWltQaDaBFX5pQReB0UJIChpYImDlDxb1q88UlcUr4mq6IB2BrgoLnGOsBFniwLElNfoz63W9r6KFOob8DoR0YILaYkyqRZquwbepsaT3YTW2foUea272BQFpgw4QcH0d6J7KgZtMGQhnEcijDkUDEZGyqcWcsg4iC4L7MakDl6FunYXuirVqrABCogOipA06uyIg8qUgUiAHAhhywzGBE1Zs9ffeskqLcD2DOpqhe0iLme3gEqTAtcuIFrGiXF9zicAPFoivJriH4kgLSrVU58x3Cp8gCSGkAk6QhBBSASdIQgipgBMkIYRU0LFIkzeGO9zSL8YbYOvUboCiuNWdIg50CJQSrKZ3QByJteBQgg4E1NWCxKJCFdRBpwsQiyKgDEXgOIrct+6yyCYKqkdaOIjAFTVBnnCzASz6gZd/9zhd3J7at68a6x/UFnHr/7TUe71lo7ahKto6UsOA7qkSiFa2FZwjIFQgsS4Hwke7DYSbhi82Zt2gA6dPn59ar85MT5ogazrW16DZ8H8DOcpzjoBwCcRAVyKRxv/uLgKdWKAjaWSDFm5q3TqnPe7yP7MEXV0gsUMs+u0jW7qWPmc2sAZMBXSqdetokk7hEyQhhFTACZIQQirgBEkIIRVwgiSEkAo6FmlaLW01hIiC7BQD5uAIiCPI7kxy0G3g/OJ5jFbro5wa0NFTgIyLJEKZNL5w4BJQPAd2WDnsZgC2aEEWSQwymEuDOo2AhZhBHU/+tYtBrgn6pzJv6usUR1oAGzNZCzc9QzO81+tWa+u0dc/pDpwSWFpZZJXWbAfb6PNvC93BYoBwYCJ9btuFL4Y021oc6Sr0vvoHh9RYfXC8GisKfQ1MMuy9zkeAnRr4TRTAtqwQLcCE+dwG5MPkbX3ONq9ZrsZSINKMTf3OKyiCgt8XsjWMwPdMgT1hHl4XZBXYR5GGEEJedzhBEkJIBZwgCSGkgo5rkGnWWeSCDUorFkQRSKHrIxFY4VwanWfbDmo3MbBwT1JgcQ8W5lpQI9SVLBEbrFR2YDEqwoIsawFZ0FFQR7VggTOKLADr6KUA8QQuqOegvGULYgHCRf8iIhbUrSKQK9095Neosl5de+rpGVRja/70lBrbsvY5NdYIXGFKcJ8lDlwn4LqkbGhERIJrjCIS8i16oXsDPHLUh7TrD4r2qPf4v4Fwgb+ISAEiHeK2rjsbtKg6cAtqAQekONfvKzbofPS4f6ka6wny11HWfZfR80gag/ox+J2UQKdwQa24De6Det7Z7xXBJ0hCCKmAEyQhhFTACZIQQirgBEkIIRV0LNJktc4iFyTIwi1HQNEXCAKx0YXapA7yirvGea/bLeDEAr4WWkBtgPCRFyA/O3RVQfENQGSCechgcbcEMQMWZPuaAji2AAt6F6HivF/cLkstfqGF9EiYSwzIfQbnzEa+CGEifS37JuyhxrJuvRB9fa9e6LtupX/Omhu1kGPAhUKFfgELlU2QfZ7CZwmQPb1JL+4ugVjUM0a7/kSp7xiUdutF59ZpYUisvp4x+A3kpf89kS6Hkg4icO8VW/WC/rw97B8DEEEL4DKUAqckGK8AFNko+O0UDXBcDS34dAqfIAkhpAJOkIQQUgEnSEIIqYATJCGEVNCxSFPmoDgMcEEnRxgpLSIisRYhkEjgBIg5gVNPlmjbeyiEIOEGiSioYyLs/HHAESbTBXtU8Y4iLUaFVviwGF0CC3pgtS/AoUgCtxqV8y0iLtddD7nVxW2b6O0S4NoSBWKOA0KFAXEZ3T2T1Fg6XYsVvWOneq/XLNPOQBvX6q6csrFBHwcQCJXmhu4VlHtegsiIQkcKlLkWVsLfRZIN6m2AGNgEzzmmro+tFvwuylwfaxoD9y2QxR0BYWjrume818l4LfLloLksApnjMfjtxCBiJHTzyks9T1lwf3YKnyAJIaQCTpCEEFIBJ0hCCKmAEyQhhFTQsUiDsqwRUWCRFYOiso11cR6kDIixuijrwjxkA4QcYOtuUtDtAXKHHYg2MMHq/wgcawS8xyywFTMWdCRl/v6NA500sa5um1IfaxRrGy2X+CJEJFo0iEBXRYksp0AjigP/zibBeUQdOC3QodEG+dz1bt11MjTgxxgMTdxZbbP6qd+rseeffkCNNTetV2Ph94yQnRrwxnNAxIqs/u00N+gOsLTun++kT4tTaU13GqVD+ppHwDIvDuIIrICuKCCmRcAE0OSgu2bYt0VrpCvUNtngVDVmUZxLon/DAs5jEohKJtVdV2ldZ9F3Cp8gCSGkAk6QhBBSASdIQgipgBMkIYRU0LFIIznqTgGbBav1bYYK+PpjE9A9kmZapClLP7e33dD2XihzJUl1obZW0x0CbVB8doFwAONbkOAAMj9qqEsm7MgA3TwRKJ6XTh+/AxZuxgSF7EwLGi4Fwg3onipA1rQtdbE/zAS3ddDtkaJMFP2ZZRvcBy3/fHT17qi2GTv1z9SYRFoAW7/ycTW2efXT3mtkXRcDIQHZ6hWFPj8lyn4JMqnjtj4XWaZFiKRL39tJTW9nEn+7WqLFHRPrc52m+nsWpb4P8qCLbmTTC2qbrgF97xWlFp5QdrsTMAfF/nfKaiB3G2UTdQifIAkhpAJOkIQQUgEnSEIIqaDjGmRU0zUBSFCrdCXIaTa6Rhhnup6Wi35vEiz4rgGXmyZwKWk2dI3N1fS/Dyj6wcRBXSMG3wmsoE7Bgnib6MWucTBkQQRAC65OB3U94MBjglXgBiwmN+BWsEbvHzjmSwIiHGxQiy4Kvf8UuDqZRNfOnNH1rqjpn7Rmps9Z1qNrWxN2fZ8aG9hhhhrb8OyD3uu1KxerbRojw2osTfT3jLv090zbIO4jiAbIt+p7pdiixwxwvnGJzrLOuvzfSh0cK3I2irt0XTID+kDU7ed/I1etZkvXVfvHjFNjrRZwSmqjOnBQX6+BeiPqbugQPkESQkgFnCAJIaQCTpCEEFIBJ0hCCKmg84XiQHBApOILGiVwQUE106gNis/AGSW0T0du6gkQF2yhi89FUxd9i1gLAkmwILgr08X/ApyeVhMIQyVYIBzkK7tcnwtrtPiCLOgjMOaCxelGgGMRiLeQmhZzaqm20beldmMx7WCspb9T6fS5iGJ9nTLgTBPcZmILEGFgQVZ5qr9TOqC/0w57+mJRfbxeiL52+SNqbGTjcjVWAH2zRLnPQeNCAjK8S9AIUIIfVL5Ff2gYd9CKtcCZoEiNll6IPgKmjqRn2Hvd1bOD2ibfqGMw1gLXqN5xu6qxCJ2Plv9eAyJNYnQBOoRPkIQQUgEnSEIIqYATJCGEVMAJkhBCKug8F3srsrABdPnV8wgIGnEBCvYGiDQOdLoEBekCFKgTkFdcZCAXOwbdI01UBPer2znoDqp1AfcUIAzl4N8kGzrAWC16IBGrBNsBd3ydawzcTSwogKNsiQg4JUWJjgaQwBXGJuBYSyBigcxxB9yfyuA4DHB6cQ6JZPp7OtEijUsHvNdjJu2ntunqn6LG1iz7jRpbv+xRNdZo6Xzu8Hasg3u2RPdPG1wTIFTmzeA+bmlhqwXExgx0/YDdSxR0FjU3Datt+oBb09YRfW/UunTefdal5xIXdI6VIBnGgfz1TuETJCGEVMAJkhBCKuAESQghFXCCJISQCjoWadJukFMLMKFKUALbIpCVnQLBBIk0kfgCQwliDXKQnxuD7hHgtiUpyNRuBZ0tBbBdKqwueMdADElS3b0QWoPZCOT4ZiByodAihDiQdRzEBcBsbnCuHQgrj4CwkoveXygSRBmwWHNa3EEdPSYGnT/BNclb6FzofVkQGRGLvl+c9Y+/lervmPVqIWHnGQeosYEBvd36555UY8Nrl3qvmygvGpAl+t6og+4jF4iXea6veYo6dQotSkYOqYH++Y4jfa7bm4fVWA0EjG8Z1nENgz36HoqDmId8RF/ztEu/r1P4BEkIIRVwgiSEkAo4QRJCSAWcIAkhpIKORZp62I1RQRHsEkQ8iw19l0TEid5/DPIlokAQsKgYDfJPBNiuFcCOLAaCQC2wgCqMFlEsEBfgsYFoGYkDQQOIKIXofRkD7J+AcJMY/0ML0MlkQfeRFOAzUVeC3ai3C/OnQQ6OGHDNQW440O/ERkEHBbCRK5sgj7oFurO6QCZ74u+/AB0geaFFpjgZo8Z6J75LjWV9ugsne+6P3ut1zz+ktmltXq/GStA+gmy/0iA/OwWdOgbkObVA7rkDop4NuqBCoUtEpN0CXWhNfR+PbF6lxvq2jFdjkvnfMwa/uQgIuZ3CJ0hCCKmAEyQhhFTACZIQQirgBEkIIRV0LNLkZWd2ZyYJQ+p10TRFIgcIdbFtXdC1QVC4gPDzOuhgaRe6K8ECC7EcdBKkgUiTGl30TWra7qxwuiun3QYF42B/Gcj/iQWci1AIEREDxLTCBAKG0d9RwPkpCr2dBdZmMciRcWEXC8ifgYIPuDccuJ4uEHjqdS0C5RH4nhG4j0HkjXWvLGgU6DsZvX9ntJ1ad/8uaqw+w7dYGxyjt1m97GE1tuGFJWosLzersSzyfzsmA3Z84Jylhb6PHco+CgRC0EQnMehuQrdBseU5NbZx/aAam7DLnv5ngkuet0FeUYfwCZIQQirgBEkIIRVwgiSEkAo6rkG2c/DHPSAt/YKOBTW9ONZ1iBxY5osFGb3BmANOMhmqc6DVxmC7BOV450GRCtRpIuAghOIPErD43Vq/nlOCQoqxerFuAuqvKXBKyotwcT2qnel/K01bL45GGdjoi9pg8bvJgSMMuA8Euck4XV8MXZwSq2uvaW2cGjORXkhfgmPLc3/xsoWr1YFbUwwWoqNfGcqyDhyPauOnq2126NbnomtQRxEMP69jHjatCxxyQBdH7IAzE6gxNy26h4LMetA84cBYBGq5SRB5ISKyadXjamxo3G7e66xb3wfthm5k6BQ+QRJCSAWcIAkhpAJOkIQQUgEnSEIIqaBjkSYGC2ARtvDFBBcBRxiQdRChXGaQhxzuLd+qbd0LIKI4sCgW2vuD442D3Ooy0kXlogWs/IEtvQWrkkPhyQILfXG6+Fxa/ZkJKKjXen0RKAfpBAVYdB6VIEu8BpyAmkDMafnXAGWQ5zW9ALmM9L/ZSa4X+tpAYGtb/b1jA7LKE70QPYm0ACbKLQgsmkduTeCedWBxOhLKkuAjTKSvefegdgHq7tZiVF//NDX2QrDIfN3qx9Q2JYikkESLpRkQqMpgjnAtvVIc5ZK3G/oze/r1+dnUBDnejRXe6+5eLWy1gPDUKXyCJISQCjhBEkJIBZwgCSGkAk6QhBBSQee52Elnudg28YuwwMFdivKVoxRERAzIJygLv3hbGOBygxzWR7S4EAFBpgDvTQPhIAZuPjZC8Qe6uO2APX47EJUi8L40Ad0kkbb3z4EDT1hjj4Adf5Lo4ypK4LBUgOgNsD9xvnBjC2DRD2IeYmDln9SAgBR0DJkCdHag6A3gyiOJ7kTJTHA+InCfgXNdtEBkwQjojAr3LyImyC/PYvC+VB9r0QViHibr6zRlyHdiGli5g9pmw8rFamzz8Go1BsWcgCQFvy/QqdZqaPFlZIvufqmD+2Dj2me814PjdlfbxKBLrFP4BEkIIRVwgiSEkAo4QRJCSAWcIAkhpIKORRpngC86IE79XSai7ebDLggRkRzFK4AieKjbhF0uIiJAe5ESZPu2QGHfChBWxBdgIpD3G6H0AFBkz0EnQRRYa8EkAmSxlmrhLALdO6EtF+qJSi3omkmBJb/TxXkLOlaiut+9Y0tddE9g1rc+NtRRIoFw5sCxOqfvKYMiL0D3joTdXqj7KwXxBBbYwTW1IOPARQ7vjBz8TlLQ0YNs45zVkQhZzyTv9ZhdtOCTDu6kx/60SI2tf+5JNVa0/GtcgugQA7pagC4nbdA1E4etRiLSDKJgSiDaSqk7vTqFT5CEEFIBJ0hCCKmAEyQhhFTACZIQQiroWKQBTQ+QVssvSEcgAwQV/+MasPMCFmthd4pBFV6wWt+ArJAEWFOVVn9m0fSFCRNpy6y0S4tRKegksKBgXBZBeR4ITwXo3jFAhIhAtk94GE5AbofR4osBNmOm0GJXXB9UYxLkhNtcF+wjkLWe1PW9URY649kFxf64roWiGFi4lU0tzIldp8dqE7yXBmT9OBg6BDJpuvSYK4EVXnAfoCh6UyCLPmDFBjJjXJBhZDIt5PRP0J0og31auBka0PkwLyx/0Hu9efhPahsBHVsJ+J23W8CTD1yDnuA30GhokSwfXqb31SF8giSEkAo4QRJCSAWcIAkhpIKOa5AJKLcgbBEsSra6TlY2dM0k69I1pCQFi3Odf8h5offfboM6E7LyL3VdLwELccPymTV6sXcBnIfQim8UN5Fl/v4KUOcr2qAGBuqlCYpOsEE9JwF1LHBcJtF1VQOtkjQmqJnW6jrnuGjrOhNqGHAGZKsH1ykCseQFuH/QSvRYdE1ZSv84LMjOtuCeKsF5TBxollDLwkXiYLG+AfEZZQFcl7bqY4trYP+hSxRoeBCwKN/UJ6qxsdPHqrHuHfyxlc/8Vm2zceVTasw2dd0wScHUBH7rjQ1rvdern/1v/baNS/W+OoRPkIQQUgEnSEIIqYATJCGEVMAJkhBCKuhYpGk3wcJNgAsWc8bIZQVm4w6rsShG+dD+WFwDi7EjvQA2tkD4MNoNJwEL25NgAa8DGc+uBP/WOODcg94b2A+ZRL8vybXwlINFz0WmxS6xvggRWb0APAEuKwYsdHeJPrcG5X8HQlMEsqHRmAMiQSxaELBBJniegwiDUl9LI/qaW2T/pK4dWLUNIinSRF9flMUtDmyX+p9hgKAUjQA3JdQYAQQYGzRLmBSJNKB5AuW0i3YCqg/t4b0eP02LU93ZLmps7Qt60XlzRMc8OBDzUAYLxcvnH1bb1JDVVofwCZIQQirgBEkIIRVwgiSEkAo4QRJCSAUdizR5Bzm4IiISON3UwBwcpbpoHQFHDwtEDhu41URWF5BroIMCCQkx6ApxwEIlLG5HoJNGG+aLCCiCu1yLRVpgAB04oHieJnpfyPmmDNtMDBANwHVyoGvDoGMDTkkSiD4W5IGjaIk01SKTg7dpILaArpYIOAhZ5HwDYiTitr9/l2lxJwafCUyXYMRFBLpkTOjiZPU5S7tBR1iXFs5aDS1QlUGEgwG/HaCbSYTiPoAw1A4E1Fq/dgGqARGxNqRzvTeseVqNbX1huRobafv3e5yB3yG60TqET5CEEFIBJ0hCCKmAEyQhhFTACZIQQirovJOm6CxbNha/sNywumiagfyGpKaFlbTUh9cMisg56DCJBHTD1HSRPcu0WJGD7ghnggxmYM+kArtFJA6jFETEIsv84K1tkNdtBJwf0KUkQECKIl/MsaDLotUGBXsgMsVAOECfGYfHC2zYxOh9WSBiGVB4z4LrmZegwwd0/aAIbOe0sBUFVnJhZ5CIiAWRBagTRcB9gLp8JPKvp4MHCzqNgAaRdenrWQT3FRIkIxTtAfLLo1h/p1oghuTg92trurumZ2CGGkuy8WosjXVHVSPonClBx5wAW8NO4RMkIYRUwAmSEEIq4ARJCCEVcIIkhJAKOs/Ftro4jHCl35XgQAW5BEJF5Hr1Rzpg4xQccowq1MB6zKIOGRC0g7KswxGbaaundqm7MVqlLhhHqF4c2FploBPIAfGoAMVnZJEVBx0OxoEOHNDpUlj9PR0ShoCoVATiXAbONcpccah7qg26fBL/MxNgI2fBtQQNWyKgy6oM809At01ouSYiYlBHEviZWWRlpuzOtIhoEi02Ogu6xBIgioWHBoSnsgT2geA75WA7E/4GwM0eASs/2wNsB8G1G1vX24U52xvWaSu/2KGL3hl8giSEkAo4QRJCSAWcIAkhpIKOa5BFu7OF4mni1xJrwELfAQv0dmtYbwdKB3GwQDgGLjpJphejlqLrNHlL12BSUP+zwcL2tA7qL7k+lXlDb5eDjGdr/fMRAUMSI7rOFzvw71sCFrqHi7tB3RaVco3oBfEW1CUj0Qumk6DGFrowiYgYlHcN3P2tQf+OB9cTLMYu0f7Bgn4UaW7DSASj7+O8sUqPFRvVWJoOqjGTagebKKi5p07nQEfomqcougL8tIOF2wbEPqAfHQpcsGBBeSusO4NjiAVoDcDvKDb6vUmv/g33jd/Ve71x/SJ9XA1dl+wUPkESQkgFnCAJIaQCTpCEEFIBJ0hCCKmgY5EmSjpbbBnV/cWtFq3jboEFtijzFmQY5w1/hwY4yXR1I/cRUAgGUQEFcuCxQbG8DRZo13QRP0pBPAE4ISZYlOyARbwDlfIUXT5gj1+UfnEbLSYHBksSo0EgFpXgO7nYt9ZHbkTwmofnWkRiJPAE+dM5KOrnuRYWS3C/GLDIXIKF1gZeEyBOIZEDOhmBRdSqMULfn2Wpz48BTRDIASkK9mcccCMC7wO3sVgQvWGtf83LUl83QeILUCVdCr4nyLvvHfRjHbLuceC49L46hU+QhBBSASdIQgipgBMkIYRUwAmSEEIq6FikcaAoizDB6n9XgEI/GLPAUSUCIb3O+iJBhDpfLHDuAcXtJAb53OCfDBsU3lsgFiAFDkVlCmIYUP530KVhYpBDDLoebALGHIhrCFxVjAHOOkgFAj0UcaTPI+qMiowfKVCAej1qYTGg4ymOQTRDFHxPq++DBMQTlOieCp17RCQOzqMBLT5JNqT3n+pOI5hzbkCXjAkiEcB3KsH9g2ISEpBpHprrGNhRpc8/ch5yoIMtC85ts62/I+rAkTAPXERAZL2UbSBGBY5HO73tMLXNxhV/1DvrED5BEkJIBZwgCSGkAk6QhBBSASdIQgipoGORBsXNIlrtDd5rg7KVwQr+CFjEJwnoiAmEA9TfY0CnS9sCm7FEW1MlIFIgDk+TAbb0yMas0CKBsVpEqQd2XiWKIgBCCOqIiQp9bkN9JwGWaKhpJgeREUUDXKcUdBElfoE+KnQOdBT1qTF0bgvQUWUCay0DumYMEhaBCBGB6IoiuJ4ROEExEqcSLfzZHESAgI4tZd2XgIzwSJ8fZWcnIg7ENRQSRm+A85MgOzg9TTgggNngfKSomwdEb6BolSIHESBtII5m/nfqH7eX2ibPQQZ5h/AJkhBCKuAESQghFXCCJISQCjhBEkJIBZ3nYmcDHW1mc1/4cCi7OdI2Vw5l6DpdaHahoAGsjCLQpYDyN/K2FkxaDf1vRpr5YkIM/J9ikOPrLLBxsnq7tvgFaQM6geJE5+zEoOukCXJkXNixAjK2kdwVAWuwJNb5HijTpQyymlGHjDOgeA46gcRpkaZohd8JCAKRPhdIBHJALDJBlpJzWpwqgM1YBjqN4gwIT6BzqQzuDQvElwT9TkR/ZgnfG5zHGGRso8wb0fuKgYAax/45KnPw+wXHn6DuL/Ds1ixB/nog3DQ26/usno5VY53CJ0hCCKmAEyQhhFTACZIQQirgBEkIIRV0LNIUeWe5DrUwEB0UrSUHuSbAQgwV8dOgsFwCEagEBfU0AcHyMJhdDUle+v+ORLHuIpA2KloDwad7UO8/3+y/bmxW25SFPj8R6jSKQSdE2+9UaOfAvgoJWyi/pQR5QsD6yoSiHsgTiUHxvwAtW67QwpANRI4S2M1ZkGWTgmtS70a2a/7+IiBioUaUAlh8oWyiBHThtINsHJeDDhbQleNSYHsHRJrwfs8KJNYBizXwGBVBYSXIi0pA5g24V6TUYk4MOutqA+A3vNkfa2zdoLaxDXbSEELI6w4nSEIIqYATJCGEVNBxDXJ45aMdbdc3fob3OgM1t6SmPxbVtlA9J878OT0Gi7EtqKehglGM6kogIzkNajWl0/WdNqjJJMBKvuwFi4uzYMEuONYSuL80ga0+yt1OwgW8DpxruEBb1zjDPGoRkQjEEYSlvhx8ps3B+QdFYAtqxaJqbLreGJtevX/gDNRug7pYUDtPQN54DJx1EEUOapzAiSmMljAo/wO4ClkHnIEsuE6Bi5MD9zEiBvcBcvMJ0yBSq2vHRQTclFAqC2qWMKBZoh58z0i7OjXAfdYpfIIkhJAKOEESQkgFnCAJIaQCTpCEEFJBxyJNY9OTHW0XRiz0mRlqG9ets4NjA9yCrI5EaAdiBVqEGyML+hLY9gNnlwhFGwRnCS0wL4FFvIC8ZQOiK4rI/4BaTZ8fWwMiARAXyhZYSBx8pcSARcSlXkyLXHokdIQREQdcl8IFx7Uwx1pE2pk+VhQDEFm94LgMRKUECRqg+l+C6IfSgOiH4D5zKcjmFn0xY7DQWt1AIliIC2JB0OlPQBxHBGIkCgeEiWCH6F5PwPtQ3IQAUbUMRMkCZHijPG0UIxGj2BGQ026D99bBd4Lr4TuET5CEEFIBJ0hCCKmAEyQhhFTACZIQQiroWKRBhWBEseV57/XGQhdz6/3T1Fhv30T9mcANpAwKxiBxQRxwobERyBgG3ymOdJE9LFFHIL4BZSQDgxkpW/o4krCjR+sgkmW6c6EOMryboAjeDmzpLdgmMsAFCHR7oFsGxWrkgRCUJfr4U4MEJX1sBRA0XDAWA8FNQAyGALHIxFoAc7l/bh3o7CjBmMSgA0RAVAA4t0kg5hgg7pSlPlYUT4CyyuPgGgMtUyQCrkhArUP3Sxy8NwfRHjirHLgRpfp7Sgk6x4LPKEGnTugAtj3wCZIQQirgBEkIIRVwgiSEkAo4QRJCSAWdRy6ArgFI0+9UyEeeU5u0tqxXY+XYmWqse2CCGssSv+AapXqOt7ku1FpQCEYdNymwcQpt4g3yZ0IaAbDCL8Bn2sIv4rfB+bGp7vaI6vq7F8jSPgrGQCFbLOiQQR0O0EYffM/AgivPgTAErNNMor9TDKzMJBQJCnABSmCPFekxJ9qWS2JfXIyACIQ0GmRLh6zNDBBDykDoQxnqKBIBR0sAu7PgnCU1fR+UwNpM2kiE08efGP84EiAoWRCvUCZAQAWZ4+iEm+C7u0jvX9kJbgd8giSEkAo4QRJCSAWcIAkhpAJOkIQQUkHHIk3e1NZjiJERv+Bdgk4aJ6vVWLOp82z7Cy3cDPXu5r2uD41R26SZLmTHoKuiLHUbTgH+zYhiv/Cegg4cZ3VBOgFZ0BLp8yFxUJwH1mmNhhZuooY+1hJ0AqVZ0HUCun4EdXYAazOLzg/oiKkFAo8FBfsSZIUYCzpAgFhkEl8MRNZdUqKuHNC1Ifo6hbnYDljcOYvy3UEnSqqvSWRAZ1GQEVOCjHD0SJMYLUy4Nrg3gs4rEGUjCejOki7QyVSA6xn8BtJI38cRsAAsgbDo2q8slopoKzYk6JWdT3Ng/4QQQiCcIAkhpAJOkIQQUkHHf5y3R4Y72q414tcqHXDgcGBetiAD2zVBDMAOfl2m101X2/QMjNUHZgb1UAwWDZe67lPkfl0jToFjC7D8dwZkTaN13GG9LtYLczOnayttlCttt6ixIvZrVA7UvwyIrjCgRhsBS34HHFqiwH4/SkC8BXCJseAzW+AeioNzFCEXJlC7jEDcROT0tcttcM7ATyVCv55Cn390zmLQWZC3g2sMjsuEi/5FJM87q1WGZWbkRoRq6QYstM6Qe1XgsORE32cWHL8BblAlsOkKF4WLiJTBOYKRKQ41uehYEwSfIAkhpAJOkIQQUgEnSEIIqYATJCGEVND5QvERsMAZYFt+ETxKgJW/BYXmYrMa27p+md6u5YtAI1tXqW36xu6hxnrH6JiH/j69yNzFIK+48P8daYGYB/Q9o0KLNCgaIMzZtsARJgaLscMF4C+CFkL72+UgCyIBueFO9BdNgdV+ieIarD9mUPEcqBwOuC4lyGEmEM4KENUgmV5AncZAoAJimg0UjbIAPxXgihQnoPkACH8WLeQOhDgDRJoYCGLOglxs0JAQJ/57TdKrthEkmIyATHOUqR00aKAca5SMgVx6kJjmwMp2F4h1IPECR2N0CJ8gCSGkAk6QhBBSASdIQgipgBMkIYRU0HnkQrNDkSZYKW9QhnSYAy0iuUqfFrGFtsJvbva7a0rQueCam8CB6e1imaHGkl4t3GRBl4aJdaUZdZMUbX38po6EFf+cJeBcgHo9zENG0QBR5AsToTuRiM7+FhEpC1D8D7s9RCROdMeTCT/DdpbxbIEYFYNYDRPENRirvwFKYUAONqjjJgmcaECjjgDTJbFWC0NIrHORPmeh7mGByFECt6ME3BwF6FiJSv9+jIFYKrEWbiIgbDnwmS68nkAxgVHroLMLCmAoriT47aDIEQNExE7hEyQhhFTACZIQQirgBEkIIRVwgiSEkAo676QpgXUX2mFQD7UOVGVjXZx3QCYogGW+CSrv1uqohqKNOnW0yNTeomMkenfUwk1Xv5/P3RXpQnacAmsnkGEssR4zZdDhgKzHnC5QFwXoNgAF6aju27pFoNBftrSgZMGlQ/niZQ6EoaAjI60ByzKQrSwWnR8g3ASKholR9jHoCin1fWBBZ1GY2R0BO7s0AhZ0sBML3Afgq0dBLAgSMyNghReBC+VA3EcZCFlFU++rHuuuH5cCizgg5oQdYA5cN9RxhjLlIyB6SqmFG2Nf+RnPxK/+OZBPkIQQUgEnSEIIqYATJCGEVMAJkhBCKug8MDbqzDIodBaKQJ4w0F6g5RHqtDAuLASDDpZyWO9+WBefy5YWadqNNWqsZ4c9/X0N7KK26R4Yr8ZSlCsNjjfsiEHiCNBtVOeFiEiU6k6O2PjH0Ta6i6MAHxqDHBmUm1yAzBUbiDShQCAikoAv4FC2D8jjCYUVi44VCBooYxuJTEUgMKB7UcBxxSAzPcq0KJY3gcVa0G0UJ6hTCuTIIGEOdcmEpxt8pSYQsZK2/sy0Do4/GfA/LtZCUdHW19xGel9A1oLXOHL++bbo+oL7s1P4BEkIIRVwgiSEkAo4QRJCSAUd1yDhwk1AGKfggH2HQ+HQYP2oAbnJ4f4teCPKIc6RcwzITshHtOtPM6hV2paOh7B2qhqrd+u6ZNY1pLer+3VDi5xpnK5tuRhkB6fAaSiMPwDxFgYsAEduQQ4sXjbg3ghrxbnRtVGb61qoJHpRMijbShoHxwvOGar3RgJcYlDjQnDvoX05EAWB3GoMcKuJM/A9g3xrC3Kly/B7i8DHnAReJ/+agHXc4oBAUBTATQloBibzXbRi0BxgHaou6nujQFnrJcgXV85UaKE++MgO4RMkIYRUwAmSEEIq4ARJCCEVcIIkhJAKOhZpkg5FmnCBsAV5xQ6MIVf0sFAuAjK14SJlUEAGjh62RIvY9YLyYrW/XdnQ27Q2rVZj/RP2VGO9YyerMZFx3qsk1QtskWm8Aw4/tgGK273+u6O2FhdQ6bxAC7TRmlugTERBpnaMYiTAv88xGLOlPrrwMGKrr6VFYh0SL8Dxp4E7Uy0Cgl5T76sAYhFqjDCRFiZMHFxP6OCk95/FPWoM/rKDReZo0TkSmdqg2UMK1PBggk204AnPtfSpMRsPqLGy0I0XxvqLzKMUCDlp5/0wIXyCJISQCjhBEkJIBZwgCSGkAk6QhBBSQeedNB3alhepX0SGOcSg0G+QBz3suPG3M6j4DxQNCyrlDnRV2FIXxo31OwSaoovWRWu9Gmu21qmxxtYpamxgrC/m9I3R29S6dCHbxWAs18JKa6tfLE9AyHOiT4Wk4EKhIjsSkIrQoSgH2dBA+IuBrb6A7pHQzt8gFyCjr2Vm9fnJQQRF6BxjItANAzpFHMjAtuAzi1zfQ2kSxono71SC91nwM7Yguz0O8q1Nps9/zYJYA/QbAwJPO8itjksUTA5EVac7qtIIOTHpzPoyiJYonRZQE3AfdAqfIAkhpAJOkIQQUgEnSEIIqYATJCGEVNB5J03U2aYm81e7F7kumuY5EEwssOlCHxAUby14Hy4Eg+4dUNg36L1Bd0Te1keWg+6dAmSJt0e01Vh707D3utXUGdVDO0xTY7WefjWWprrbIA/ys8GhigUiWdgVJSKSgRgAJKLYQGCLgXJmQCFewDlzOYgZCPLF27EWUZwD4g7odImAWKEEQhjnDAQrJCiBvAwLxCgVSwF+c1ECRBqkawH7usgEv5UcCDLgmtS6QGcX6DgrA4HQAkGvbOvjd+D0OwvErlxHpEiXv78wgkFEpCzACeoQPkESQkgFnCAJIaQCTpCEEFIBJ0hCCKmgY5GmLDoLdkjDlgzQgWBBIdjFoGsDrMQPC78GWHLhCG/UaaGFG1RYNmF3DaoqA5GjBJk3I+A8thob/G226q6ccusr53WLiPQM7KzGsjDLGthoIeEJeZvl4DwmKE8o6F4A8S1SokHQoSGR7rRwQa5OFPeqbbIu3XlhHLBTQ7nSgQiELPQK1DUD7p/EaOEs6UX3Y5gdpDaRHHmngRyiNNMWaHFwbgsglhbgmkRIhGvp/Gyp+e9NQfddnKLfqxZRslgLkDYB4m7pd7khG7kS3VOi7w0EnyAJIaQCTpCEEFIBJ0hCCKmAEyQhhFTQsUiDul8gwWr9yICifqrtthzyQBNkPRbYqSH7rRiIQCh9HogLERBbXBS+F2xTIGs2IEIkwPqq8EWIsgW6bYB12phNz6sxu/M71Vjf+F2912miC/gR6HRBmS6guUYEWHCFIUMRsN8y4DMLIIYgezZjfPEPhcpb0O2RAIs4E4FOi+DYIqD82QxYiqH7uND3cRRp4UaCHJwYiZltdJ/peyoFomdodxYBkbIIM59EpN0GHWEgj6fc7J/vGNi8dfVoMc106zmi0dQZTyX4rYfimW1pMTPLUCfNVDCm4RMkIYRUwAmSEEIq4ARJCCEVdB4YC2oTiKIZLhDWdYg4XLgsIhFwH4nBguYocGgpU12nKUFtKwJuPhaUJdGaUhfUEqGBEHLDQQ4wqJYb1IIsOGfNTWvV2LqWPj+NlnYCGtzqL6YdGLub2qbePagPKwM1sBwstHa6GSAKIwtgVANwWEKnpwbeGwzloKkgQo4woB5oI10Xi2u+g02EfipWu9yYqDN7/zZYBJ4E56MAK8UtqK8bcG+XbeCkE97cqrYuEoEM7K5Y7782Rp+zdlAfHdmg64ibN25QY24zyLsGZe0o0ovTw7QMC2q0WwrYOdIRfIIkhJAKOEESQkgFnCAJIaQCTpCEEFJBxyKNgY4YGlf6hdQCFE0NsMJHiQ5Joou3NgqK/7l2ejHARQQ59xRggS1ajKocYMD7HArjBsVzvehcvxftyoj+nm3kILRaLzLPt/qLzFtbn1PbDO0wU431Dup8bpMAMQ24yZjEd1UpkAsNcEWKQTyBATnkUvqLx2NwA5kSxB/EQKTJ9TmzQcZzkunF6jASAVzfOEO/ASAkBk0VbdDcEBktcKY17WBjjF4k75z/27TARacE56wAHRV1kCnvrL8Iv7dP3z/tQl/LKNK/pywb0McxogWe8BQlA1o4K4HrUqfwCZIQQirgBEkIIRVwgiSEkAo4QRJCSAXGQXWBEEIInyAJIaQCTpCEEFIBJ0hCCKmAEyQhhFTACZIQQirgBEkIIRVwgiSEkAo4QRJCSAWcIAkhpIL/DxNEFU/qM5MTAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# batch_rgb = list(batch_eurosat_trainset_dict[key] for key in ['image', 'images', 'rgb', 'rgbs'] if key in eurosat_trainset_dict)\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "for key in ['image', 'images', 'rgb', 'rgbs']:\n",
    "    if key in batch_eurosat_trainset_dict.column_names:\n",
    "        batch_rgb = batch_eurosat_trainset_dict[key]\n",
    "        \n",
    "np_batch_rgb = np.array(batch_rgb)\n",
    "print(\"Shape of batch:\", np_batch_rgb.shape)\n",
    "\n",
    "ms_sample = np_batch_rgb[0]\n",
    "print(\"Shape of 1 multispectral sample:\", ms_sample.shape)\n",
    "\n",
    "rgb_sample = ms_sample[:, :, 1:4]\n",
    "print(\"Shape of 1 rgb sample:\", rgb_sample.shape)\n",
    "\n",
    "\n",
    "if rgb_sample.dtype != np.uint8:\n",
    "    bands_min = rgb_sample.min()\n",
    "    bands_max = rgb_sample.max()\n",
    "    bands_norm = (rgb_sample - bands_min) / (bands_max - bands_min)\n",
    "    bands_uint8 = (bands_norm * 255).astype(np.uint8)\n",
    "else:\n",
    "    bands_uint8 = rgb_sample\n",
    "\n",
    "plt.figure(figsize=(4, 4))\n",
    "plt.imshow(bands_uint8)\n",
    "plt.axis('off')  # Turn off the axis\n",
    "plt.title(\"Extracted Bands 2, 3, 4 as RGB\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 32, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUgAAAFeCAYAAADnm4a1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAArMklEQVR4nO3deZRU5ZkG8OcuVdVNLzSbrLLYEglqQuKWgQMNUXFsIToZNMaoNE4GwngQMhCICYuAkZlJnIODGpXkKOOQyYRxixyEYXFlXEhEgoqAskVQoVmFXqruvd/8wXQNZfPxPQ0YnZnnd06fo8Vb3711l7duVX3vfT1jjIGIiDTjf9YrICLyeaUEKSJioQQpImKhBCkiYqEEKSJioQQpImKhBCkiYqEEKSJioQQpImKhBPm/WM+ePVFTU/NZr8ZJ2bZtGzzPwyOPPPJZr4qI1ecqQT7yyCPwPM/698orr7RovF27duGOO+7AG2+88emsMGHJkiW44447PrPlA2i2HUtKStC3b1/ceeedqKur+0zX7XRYuXIlbrnlFnzhC19Aq1atcNZZZ+G73/0uPvjgg5Mec9euXbjxxhtxzjnnoKysDBUVFbj44ouxYMECnK7q3Pfeew9FRUXwPA+/+93vTsuYp6LpTavpz/d9tG3bFldeeSVefvll6/P+8Ic/YNSoUejVqxeKiopQWlqKfv36YfLkydiyZUtBbE1NTcEywjDEmWeeieuvvx5vv/32p/0SWyz8rFfgeGbNmoVevXo1e/zss89u0Ti7du3CzJkz0bNnT/Tr1+80rV3LLFmyBPfdd99nniQvv/xy3HzzzQCAw4cP48UXX8S0adOwbt06LFq06DNdt1M1ZcoU7Nu3D9deey169+6NLVu24N5778XixYvxxhtvoFOnTi0es7a2Fu+//z5GjBiB7t27I5fLYfny5aipqcHGjRtx1113nfJ6f//730cYhmhsbDzlsU6nb3/726iurkYcx9i0aRPuv/9+DBkyBGvWrMH5559fEDt//nyMHTsW7du3x3e+8x306dMHURThzTffxD//8z9j7ty5qK+vRxAE+edkMhn84he/AABEUYT33nsPDzzwAJYuXYq3334bXbp0+ZO+3hMynyMPP/ywAWDWrFlzWsZbs2aNAWAefvhhKv7IkSOnZbnHuvXWW82ntZl79OhhRo4c6YwDYG699dZmj48YMcL4vm/q6+s/hbU7sa1bt7Zo35zI888/b+I4bvYYAPPjH//4lMc/1rBhw0xJSYmJouiUxlm6dKlJp9Nm6tSpp/WYPxVN++SnP/1pwePPPPOMAWDGjh1b8Pjq1atNEARm0KBB5tChQ83Gq6+vN1OnTi3YViNHjjQlJSXNYhcvXmwAmIceeug0vZrT43P1EZs1Y8YM+L6PlStXFjw+evRopNNprFu3Ds899xwuuugiAMCoUaPyl/RN33kNHjwY5513Hn7/+99j0KBBaNWqFX70ox8BAJ566ilcddVV6NKlCzKZDCorKzF79mzEcdxsXV599VVUV1ejTZs2KCkpwZe+9CXcc889AI5+nLjvvvsAFH7MbZIkCebOnYtzzz0XRUVF6NixI8aMGYP9+/cXLMMYgzvvvBPdunVDq1atMGTIELz11lunvB07deqU/5jT5MUXX8S1116L7t27I5PJ4Mwzz8T3v/991NfXFzy3pqYGpaWl2LlzJ6655hqUlpaiQ4cOmDRpUrPtdODAAdTU1KB169aoqKjAyJEjceDAgWbr8+GHH2LUqFHo1q0bMpkMOnfujKuvvhrbtm074esYNGgQfN9v9ljbtm2xYcOGlm0Uh549e6Kurg7ZbPakx8jlchg/fjzGjx+PyspK+nn79u3DpEmTcP7556O0tBTl5eW48sorsW7dumax8+bNw7nnnotWrVqhTZs2uPDCC/GrX/3qpNZ34MCBAI5+JXCsmTNnwvM8LFy4EGVlZc2eV1RUhNmzZxdcPdo0XeUfeyx+Hny+1ua/HTx4ELW1tQWPeZ6Hdu3aAQCmTp2Kp59+Gn/1V3+F9evXo6ysDMuWLcP8+fMxe/ZsfPnLX8ZHH32EWbNmYfr06Rg9enR+J/fv3z8/5t69e3HllVfi+uuvx4033oiOHTsCOPpdaGlpKf72b/8WpaWlWLVqFaZPn45Dhw7hpz/9af75y5cvx7Bhw9C5c2eMHz8enTp1woYNG7B48WKMHz8eY8aMwa5du7B8+XI8+uijzV7nmDFj8Mgjj2DUqFG47bbbsHXrVtx7771Yu3YtVq9ejVQqBQCYPn067rzzTlRXV6O6uhqvv/46hg4d2qKTtKGhIb9Njxw5gtWrV2PBggW44YYbCg7KRYsWoa6uDmPHjkW7du3w2muvYd68eXj//febfRSP4xhXXHEFLrnkEvzsZz/DihUrcPfdd6OyshJjx44FcDS5X3311XjppZfwve99D1/84hfxxBNPYOTIkc3W8S//8i/x1ltvYdy4cejZsyd2796N5cuXY8eOHejZsyf9WoGjXyMcPnwY7du3b9HzPqm+vh5HjhzB4cOH8fzzz+Phhx/Gn/3Zn6G4uPikx5w7dy7279+PqVOn4vHHH6eft2XLFjz55JO49tpr0atXL3z00Ud48MEHUVVVVfDRdP78+bjtttswYsQIjB8/Hg0NDfjDH/6AV199FTfccEOL17fpDapNmzb5x+rq6rBq1SoMHjwY3bp1a/GYTcdiHMfYsmULpkyZgnbt2mHYsGEtHutT9Vlfwh6r6SP28f4ymUxB7Pr16006nTbf/e53zf79+03Xrl3NhRdeaHK5XD7mRB+xq6qqDADzwAMPNPu3urq6Zo+NGTPGtGrVyjQ0NBhjjImiyPTq1cv06NHD7N+/vyA2SZL8f9s+Yr/44osGgFm4cGHB40uXLi14fPfu3SadTpurrrqqYNwf/ehHBgD9Eft4f9dcc03+9Zzotc+ZM8d4nme2b9+ef2zkyJEGgJk1a1ZB7Fe+8hVzwQUX5P//ySefNADMP/zDP+Qfi6LIDBw4sGDf7N+//7gf707W7NmzDQCzcuXKUxpnzpw5Bdvs0ksvNTt27Djp8T744ANTVlZmHnzwQWNMy75WamhoaPZVwtatW00mkynYD1dffbU599xzW7xuTR+xZ86cafbs2WM+/PBD8+KLL5qLLrrIADCLFi3Kx65bt84AMBMmTGg2zt69e82ePXvyf42Njfl/azpuPvnXtWtX8/vf/77F6/xp+1x+xL7vvvuwfPnygr9nnnmmIOa8887DzJkz8Ytf/AJXXHEFamtrsWDBghZdomcyGYwaNarZ48deHXz88ceora3FwIEDUVdXh3feeQcAsHbtWmzduhUTJkxARUVFwfOP/Rhts2jRIrRu3RqXX345amtr838XXHABSktL8eyzzwIAVqxYgWw2i3HjxhWMO2HCBPp1AsDVV1+d35ZPPfUUbr/9dixduhQ33HBDwa+yx772I0eOoLa2Fv3794cxBmvXrm027ve+972C/x84cGDBL5dLlixBGIb5K0oACIIA48aNK3hecXEx0uk0nnvuuWZfMbTUCy+8gJkzZ+K6667D17/+9VMa69vf/jaWL1+OX/3qV/mrr09+3dASU6ZMyf/K3lKZTCb/VUIcx9i7dy9KS0txzjnn4PXXX8/HVVRU4P3338eaNWtOah1nzJiBDh06oFOnThg4cCA2bNiAu+++GyNGjMjHHDp0CABQWlra7PlnnXUWOnTokP/77W9/W/DvRUVF+WNx2bJlePDBB1FaWorq6mps2rTppNb50/K5/Ih98cUX48ILL3TG/eAHP8Cvf/1rvPbaa7jrrrvQt2/fFi2na9euSKfTzR5/6623MHXqVKxatSp/IDQ5ePAggP/5Pua8885r0TKbbN68GQcPHsQZZ5xx3H/fvXs3AGD79u0AgN69exf8e4cOHQo+8rh069YNl112Wf7/v/GNb6Bdu3aYNGkSFi9ejOHDhwMAduzYgenTp+O3v/1ts0TV9NqbFBUVoUOHDgWPtWnTpuB527dvR+fOnZudSOecc07B/2cyGfz93/89Jk6ciI4dO+JrX/sahg0bhptvvrlFv0K/8847+Iu/+Aucd955+V9KT0WPHj3Qo0cPAEeT5ejRo3HZZZdh48aNLf6Y/corr+DRRx/FypUrm31nykiSBPfccw/uv/9+bN26teC73qavn4CjSXjFihW4+OKLcfbZZ2Po0KG44YYbMGDAAGo5o0ePxrXXXouGhgasWrUK//RP/9Tse+Wm7xwPHz7c7PlPPfUUcrkc1q1bh0mTJjX79yAICo5FAKiurkbv3r1x++2347HHHqPW80/hc5kgWVu2bMHmzZsBAOvXr2/x8493gB84cABVVVUoLy/HrFmzUFlZiaKiIrz++uuYMmUKkiQ55fUGjh7sZ5xxBhYuXHjcf/9k4vk0XHrppQCOXnENHz4ccRzj8ssvx759+zBlyhT06dMHJSUl2LlzJ2pqapq9dubL95aYMGEChg8fjieffBLLli3DtGnTMGfOHKxatQpf+cpXnM//4x//iKFDh6J169ZYsmTJcX84OFUjRozA/Pnz8cILL+CKK65o0XMnT56MgQMHolevXvnv9Zq+i/vggw+wY8cOdO/e3fr8u+66C9OmTcMtt9yC2bNno23btvB9HxMmTCjYN1/84hexceNGLF68GEuXLsVjjz2G+++/H9OnT8fMmTOd69m7d+98Ahs2bBiCIMAPf/hDDBkyJH/hcvbZZyMMQ7z55pvNnl9VVQWgZT+4dOvWDeeccw5eeOEF+jl/Cv9rE2SSJKipqUF5eTkmTJiAu+66CyNGjMA3v/nNfAzzUfeTnnvuOezduxePP/44Bg0alH9869atBXFNvz6++eabzd4Nj2Vbh8rKSqxYsQIDBgw44ZVI09XL5s2bcdZZZ+Uf37Nnzyl/FI2iCMD/XAWsX78emzZtwoIFC/JzJoGjP0adrB49emDlypU4fPhwwVXkxo0bjxtfWVmJiRMnYuLEidi8eTP69euHu+++G//yL/9ywuXs3bsXQ4cORWNjI1auXInOnTuf9DqfSNPH609eTTN27NiB7du3H3eO7ze+8Q20bt36uL/uN/n3f/93DBkyBL/85S8LHj9w4ECzH6NKSkrwrW99C9/61reQzWbxzW9+Ez/5yU9w++23o6ioqEXr/eMf/xjz58/H1KlTsXTp0vz4gwcPxvPPP4+dO3eia9euLRrzeKIoOu4V6Wfpc/kdJOMf//Ef8Z//+Z946KGHMHv2bPTv3x9jx44t+PW7pKQEAE540H1S01XRsd/LZbNZ3H///QVxX/3qV9GrVy/MnTu32fjHPte2Dtdddx3iOMbs2bObrUMURfn4yy67DKlUCvPmzSsYd+7cufRrsnn66acBAF/+8pcBHP+1G2Py05ZORnV1NaIows9//vP8Y3EcY968eQVxdXV1aGhoKHissrISZWVlzonUR44cQXV1NXbu3IklS5Y0+zriZOzZs+e4j//yl7+E53n46le/2uIxH3roITzxxBMFf03fxf7sZz+zfppoEgRBsyqeRYsWYefOnQWP7d27t+D/0+k0+vbtC2MMcrlci9e7oqICY8aMwbJlywqq0qZPn444jnHjjTceN7F9cl1PZNOmTdi4cWP+WPy8+FxeQT7zzDP5H0OO1b9/f5x11lnYsGEDpk2bhpqamvx3Z4888gj69euHv/mbv8FvfvMbAEdPsIqKCjzwwAMoKytDSUkJLrnkkuO+gx+7jDZt2mDkyJG47bbb4HkeHn300WY72/d9/PznP8fw4cPRr18/jBo1Cp07d8Y777yDt956C8uWLQMAXHDBBQCA2267DVdccQWCIMD111+PqqoqjBkzBnPmzMEbb7yBoUOHIpVKYfPmzVi0aBHuuecejBgxIj+3cM6cORg2bBiqq6uxdu1aPPPMMy2awrJp06b8VVhdXR1eeeUVLFiwAGeffTZuuukmAECfPn1QWVmJSZMmYefOnSgvL8djjz12Sleqw4cPx4ABA/DDH/4Q27ZtQ9++ffH44483uwLbtGkTLr30Ulx33XXo27cvwjDEE088gY8++gjXX3/9CZfxne98B6+99hpuueUWbNiwoWDuY2lpKa655pr8/99xxx2YOXMmnn32WQwePNg65k9+8hOsXr0af/7nf47u3btj3759eOyxx7BmzRqMGzeuoKrrueeew5AhQzBjxowTVkwNHTq02WNNb4RVVVXO792HDRuGWbNmYdSoUejfvz/Wr1+PhQsXFnyyaFpOp06dMGDAAHTs2BEbNmzAvffei6uuuuqkv3YYP3485s6di7/7u7/Dr3/9awBHf5C79957MW7cOPTu3TtfSZPNZrFp0yYsXLgQ6XS62XfIURTlj8UkSbBt2zY88MADSJIEM2bMOKn1+9R8Rr+eH9eJpvngv6eERFFkLrroItOtWzdz4MCBguffc889BoD5t3/7t/xjTz31lOnbt68Jw7BgWklVVZV1KsTq1avN1772NVNcXGy6dOliJk+ebJYtW2YAmGeffbYg9qWXXjKXX365KSsrMyUlJeZLX/qSmTdvXv7foygy48aNMx06dDCe5zWb8vPQQw+ZCy64wBQXF5uysjJz/vnnm8mTJ5tdu3blY+I4NjNnzjSdO3c2xcXFZvDgwebNN99sUSXNsX9BEJhu3bqZ0aNHm48++qgg9u233zaXXXaZKS0tNe3btzd//dd/nZ/Scex0KVtFxIwZM5q9xr1795qbbrrJlJeXm9atW5ubbrrJrF27tmDM2tpac+utt5o+ffqYkpIS07p1a3PJJZeY3/zmN87X16NHD+sx06NHj4LYiRMnGs/zzIYNG0445n/8x3+YYcOGmS5duphUKmXKysrMgAEDzMMPP1ww3coYY55++mnrlDGXlk7zmThxYv44GDBggHn55ZdNVVWVqaqqysc9+OCDZtCgQaZdu3Ymk8mYyspK84Mf/MAcPHjwhOPbKmma1NTUmCAIzLvvvlvw+Nq1a83NN99sunfvbtLpdP48mDhxYrPY403zKS8vN5deeqlZsWKFcxv8qXnGqC+2/P9x8cUXo0ePHqe1/nzy5Mn413/9V7z77rvIZDKnbVz57H0uP2KLfBoOHTqEdevWYcGCBad13GeffRbTpk1Tcvw/SFeQIiIW/2t/xRYR+bQpQYqIWChBiohYKEGKiFgoQYqIWNDTfKon1bqDACQ5980cEkOWO/nuH9jTMZfjIxxyBwGIGtxNrJKQnM7hk7Xgde7bZ9UfPkANtWtL87tLf1Lt+81vW3Y8DQd3U3GII2eIn+b2U8rn6oSPzrk/sShsfgf44wmIG5Cwdwb0A26fB8WtnDGtytpSY4VFJVRcNtvgjGH3eS464owxRC4AgCTh9pNvUs6YIMWdm0dqn+KWSUWJiPw/pAQpImKhBCkiYqEEKSJioQQpImKhBCkiYqEEKSJioQQpImKhBCkiYkFX0vhkVYhPdEyLcllqrJiYYR8RFRVHcdUGfsr9OgNwM/8b6k/cbKqJIbZtCdkG9qzyi50xrdty/Zz3bnuXijt04PgNro4VZ7lKJi/gqi9iYr/HDdx+gnFXAnke1+K2MSKrpxoPOEOiIx9TQ2VKSt1BAFLl7mOoqJTrcxQ2uM/zJHRX7gBAfZ27KgcAcjlif/otb0p2wuFO62giIv+HKEGKiFgoQYqIWChBiohYKEGKiFgoQYqIWChBiohYKEGKiFjQE8VzWW4CrOe5J90mhpsMHBJxMciJxYl7vQAg8NJE1GFqLN9wE2VBzEHONnATlQO/tTOmfc9LqLFK255Dxe358G1nTO2ON6ix4npucnRCTO4ODFeQkBC38o+JFgMA4CfusQDA893rnyUnnTdkuWO7Vew+3cvbtKPGKmpzhjMmF3GFEl64j4rL1hHFBo3ctmDpClJExEIJUkTEQglSRMRCCVJExEIJUkTEQglSRMRCCVJExEIJUkTEQglSRMSCrqRJ4noy0n3Lc7J7AxJi9XzD3WKdvPk+cpG7+sKQlQsG3AtNEqZtBFeVk8B9K3w/yFBjlbTtRsVlylo5Y0pL21Jj7d6+kYr7ePd2Z0wduGOWqbIKDVfJhAx5cGeZfc6dnoaoKgKA7McHnTH15MlZ3LajMyaVKqPG8kq51+kRZ3EUsHmKoytIERELJUgREQslSBERCyVIERELJUgREQslSBERCyVIERELJUgREQt+ojg5GRUJMXHbL+aGSrnbH3g5ZsItALI1Azz3hOwE3LaIY+42/SZ2r1sqXUqNlWLWn7yVfxJwE33ht3GGlHc+lxoqXeJuGQEA+8rKnTF73n+XGqt+/x+dMR7TFwN8aw8TuMfzPO6YTZHrBriLIOoOuCeTA0CcuJdZ2p5r3+Cn3IUGAJAqcY+XmAPUWCxdQYqIWChBiohYKEGKiFgoQYqIWChBiohYKEGKiFgoQYqIWChBiohYKEGKiFjQlTSez1WseEHKHUPeld4L3Mv0Y659QGy49Tc+MZ7PNXDwiGoDADA5927Ixe4qCAAwoXvjBiF5i3uiKufoQomqEMPt9JLS7lRc+gvuFg6l7SupsXZvXeuM2b+bawUR1++j4nzfXSXmswUyhqu4McQ5kCTcWHFU54yJsty5GQbubQEAYbrCGeOVsxuNoytIERELJUgREQslSBERCyVIERELJUgREQslSBERCyVIERELJUgREQslSBERC7qSBmQlhMdUtqS5vOwZoidNQFZ7xFz1SxC4e52YkKsQ8OGuNgC4wpzYcJU0UeyuljAeV20QeNw2C4mKm8YcV6GRDbjjrKhVe2dMu9YdqbHadj3TGfPRxlepsXZufpmKqz9Y64whD1n4ZL8oqoAqRZ7nift4rN+3nxorXcwd22G5u3oqXVRBjcXSFaSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIBT1RvDHLtSzIEG0SAnCThplbyXvE7f6PjsXd1j0xOWeM75HvK2mufYBJuyeUm+wBaqwccSt8xNwE9sRwr9MUueP8NNlnI3eQCouzJe6hGrljo7isizOmQ+VAaiyQ7QNq33/LGXPow83UWCbbSMUFqVbuGI9b/1zkLg6Ic9x61WW54zHIuo+NKF1GjcXSFaSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIgFXUmT8smqisB9+3TPXawCAEh8d1VOI1G5AwDwuaoKP3avvwm4SiAvKOXiiGqggHwvi313xUoYfUyNlSTcjspFKWdMiqwwCUJ3ywsASLwjzhivgVv/hrR7f6ZLK6ixOvfmKm4qOvZxxux773fUWLvff5OKq6tzt0DwU1xKCIvd28zPcT0jcke4ipvsx+5zk21NwtIVpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiAVdSeOliqg4E7tnxUfgKhxM5K6WSCKyH4fn7mECAD4RZ8jqHY/svePBPV5cxFXlZBJ3nIkPUWOhkay4aXTvz8S4e5gAgBe4q3IAIOMTh24x1wcniQ47Y0wdd6qYNFcJlGrj3k+dzm9NjVXcqSsVt3vbG86YI/u3UWNFDcR5nnCVNH4Rl1vC2D1eTOYWlq4gRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCzoieJFIXfL/Jxx59zE58ZC7J6o7Ge5iaFJwk16Rso9uTjwM9xYRCsFAEjiiBiKey8L4F5/E7ajxgp9bnJ9ELonWiOuo8aC4Q7JhDh0Y2JbAIAP9/aHqafGSiJucrTxiAn9qQpqrHbdL6Hiist7OWN2b32JGqt2yxvOmLoGd4sHAAhTXOFFcYbY50T+aQldQYqIWChBiohYKEGKiFgoQYqIWChBiohYKEGKiFgoQYqIWChBiohYKEGKiFjQlTRxzFWshGl3lUlC3DodABLffSv2IMNVq0Q5rpLDgzvOkLeS9xKuYsgws/8N174Bsbu1QQyuEsj3yOqdTJkzxjNtqbHoNhWBex/4uSw1VraBODbI7Z8QbUIAICRaAyQxt/0b09xxlilv74w5s88gaqyKNu6xare/Q421b8+7VFxDA1GxdZrpClJExEIJUkTEQglSRMRCCVJExEIJUkTEQglSRMRCCVJExEIJUkTEgp4onnB3r4cxxC3/A24wz3NPaI5j7iV4Hje5O47ck4ZTHneL+Bw5UTkBMZ7HvU7m7vUm4W6F77GtJQJ3+wAQ+xIAAm7eP3Wb/thPUWNFzOT6encMAMSN3AsIi93rn0pxx08ud5CKy0buyfpBimvHUdblImdMmmjxAACZ7a9TcXt2uuMaD9VSY7F0BSkiYqEEKSJioQQpImKhBCkiYqEEKSJioQQpImKhBCkiYqEEKSJioQQpImJBV9L4qWIqLtvorhDwyEqUNFNx4zVSYyU+d1v6JHS3eYg8rqoCHtemwos+dsbkIrJNRdjGGRMGZCsIsv2BMe59EDBtJQDA446zJHFXrBiyeqe4qNwZk/O57Q8yzhBnXpK4j0UASKe50zgCc64coMYynrt6qlXrntRYxX0qqLg27d3jfbhlLTUWS1eQIiIWSpAiIhZKkCIiFkqQIiIWSpAiIhZKkCIiFkqQIiIWSpAiIhZKkCIiFnQljRfVU3GpjHvIOGlFjRXHkTso4dYrTHH9SVK+e/1zObIqJ81V+RiP6GPSeIBbZnyYiOLWPw64908v6+6d4odcVQ4Msc8BxMZdyREZrmIrTNwVN6lMB2os+O6eRgAQE9ssl3DbIgm4Y9vE7v2ZIpsChUTmMAlXVdSYKaPiis74gjOmUyuiP1IL6ApSRMRCCVJExEIJUkTEQglSRMRCCVJExEIJUkTEQglSRMRCCVJExIKeKB43chNgE7gnmgbsnOGQmLRK3pY+jo9QcWHgnrSaKSuhxspxc9gREe0g/JjbVUHG3eYhbjhIjZU0cBOVfWLWcK6IKw5IPO49O8y5J8SbhDvQsol7+4eeuy0DAPhEyw4A8H2ibUfAFRrEETmhnChIMB456Zw4iROfLOLIEa1VAPiBe0J/SdtKaiyWriBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQs+EqayF2hAQAmdt9KPg64sfycO3+nU9wt1mO/HRWXi9y3iU9xE//hExUyABCG7m0WRdxCk9hdbeD5XLUEcIBbZs5doZGAq2oxhnudYYaoPgq4w9uL3VUtXkRWmKS5lgVe2NoZk/G48wRFXMVNknNX3OSy3H5qPEKsm0+e5zG3zCBwrz+zXVtCV5AiIhZKkCIiFkqQIiIWSpAiIhZKkCIiFkqQIiIWSpAiIhZKkCIiFkqQIiIWdCWNR8xiB4Bs4o7zs+5qlaMLdYfkyKqcIFVMxfnGXaFhEu59hWy9g5Rx7wY/zVVy5LLu3kEx2V8lLOJ67yTxAWdMin4v5ippPJ/o/eJzyzQpd/VRYrhqFT9LVtww60b0YGlJnJ9ynytp8zE1Vo6orDMxty8jcp8D7ryRTsjqI5KuIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQs6IniITGZFgCSBvft6yOirQEAJJ57mabRcGMl7rYGAOB5xGRU8m3FEOsPANnEvc2QPcItNFfvDAmL2nBjZbgJ5dmse6KvR95WP1XMTbSOo0POGENM+geAoMh9m/6QbFORa+AmlHtJrTso05kbi2wtYYz7NZiQm7QdFLtPAhOT+zIm8wERlvPY8gyOriBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQs6EqaHHsr/MBdvZDOcDPnY6IqJNdIVhEk3Kz+0HdXvwShu63B0cG4Wf0ecct8LyzllpkQyyTvcO95XJVSUXGFMyYiWkEAQDbLVTwZz93aIyTaAgCAl3NvkFyKq8qBx21c3xAtIxKuKifJkXFEm4c4INYLQGjcx1lCNh0JmWMWANLufRDnuOOHpStIERELJUgREQslSBERCyVIERELJUgREQslSBERCyVIERELJUgREQt6oriX5SZ3e8St6Y1PLjZ0LzM0RLsCALl6bjJtlCHeMxJuMm0QH6biQkNMFE9x72WJcU8o94lb7wNAkuO2rRe4J/r65K3wDTlR2fPcrzNJuDYVCTG52I+5sTyUUHGx596fHtNjAADICdmI3ZPYUyF3bHhhK3dQGHBjZciCCqLCgdxNNF1BiohYKEGKiFgoQYqIWChBiohYKEGKiFgoQYqIWChBiohYKEGKiFgoQYqIWPCVNBnu9vtJlmiTQN5Wn+kNwFTuAEAqdK8XAMTRIXeMT66/R1QbAAiN+3WayN1iAAB8ZpsFXIWDMVybAUO0NjBk+4ZUuoxbJtz73QO3TOO7q6x8oi3D0bG4Ng/GENU7We74MeliKi4gWi6w2ywhwoKQbVNBxsXubZsq4Y5tlq4gRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELOhKGp+s5DCRu78E2Z4E2chdbeCBm4WfSnNxXux+nV7A9WpJEm5Wf0PO/T4VpLixgoSp8uH2ZUBWOBimmsnnKlFisg+On3H3+0kzfVMA5GJ3HxmqBwsAotUMAMCYj50xfsydKEmOqxJLMkS/HLIyDUQ+MHEdNRRbDWeISiDA3d+pJXQFKSJioQQpImKhBCkiYqEEKSJioQQpImKhBCkiYqEEKSJioQQpImJBTxRvTLhJqz5zx3ZqwieQZiZ3x9wE5CjibiXvEROaQ8NN2vYM2eahwT25Oxe3psYyxDYzETcZO2diKi4TMu0PyNvqk8uMG937wITuVgoAEAbuZZo0d6oYphcBAMTubRZH3PoD3ITspMEd55HXTIZIHYnHnZt+isstXsrdWoKd0M/SFaSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIgFXUmT8rjqkRwxe94k3Ax7jyqq4KoNgoR8LwiY9c9RQ3nEWAAQEJvWg/sW/QCQEBU3Hohb7wMIyUqIhGjh4Hlkm4eAq0RJqN4GZPUO0T4g8riqKHL1qYqb2HCnp+dxbQZydR84Y7LRAWqsVKqtM8ZPtaPG8snzKUVUsPnseY4iKkpXkCIiFkqQIiIWSpAiIhZKkCIiFkqQIiIWSpAiIhZKkCIiFkqQIiIWSpAiIhZ0JY2f4qoqmB4xXuTuwQIAhmlVEXKlC6FPViX47ln9uYis0AjJiiHiJQQgK0yIyqIo4aqPTMj1wWH6zfg5rm9KnHDHRkBU5nght89znjsulz1CjRVx5V/wmXVLkccZWT2SBO4KqpA66YDAd6+b55F9rIhKLAAwRFwcs318VEkjInJKlCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCzoieJxwk2ADXz35NCIvEW8F7onhvomRY1lyEnDkWlwLzPgJjN7HrduHnEreUPuKt93T5T1fe590ffIyd3EHfNjw010Z7dZELgXmhDb4mige9JzCO6YjYnjHwCSnPsYCgy3/uyE+FTG3QIhTnHFAQBREOJxrRR8j91P7n0QMVUXLaArSBERCyVIERELJUgREQslSBERCyVIERELJUgREQslSBERCyVIERELJUgREQu6kiaJyFDiludFHpeXo9BdVWE8rq2BT8Z5kfu29GTxDoLg9LVcyMX11Fi5endVSIq8lb+f4iqGkshdcRP65dRYBu6qIgDImVbOGD/mqr+86KA7hizQMCG5bWP3gDm2EoVsxxESp52fLqbGSnLuweLcx9RYAdmmAp77HGBaphxVQUXpClJExEIJUkTEQglSRMRCCVJExEIJUkTEQglSRMRCCVJExEIJUkTEgp4o7ofkreQT90TfRnCTOT1iom+YLqPG8slb+efgntxqErJ9AHFb+qPc29YjJ9OGwWH30gy3XklMtoyAOy4h2zeAaHkBAB4xUTzbSM7ujonWHr57uwIActxEd/ju49bzi7ixDNcOIhe7j7MM2abCT7tTR0zkAgCIyDiTuPNG6KvlgojIn4QSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIgFXUkTJFwuLSpp64zJZQ9RY2Xr3bfCjyOuFYHP3G8eQBC4Z+InWXflBQA05riKFeO5Wxt4HrdMj2h/4JNVOV66DRVnfHebigBc+4Y44fZnHO1xxxiuQiOJ3BUmMVn9lQ644yx0FwLB97jqNZ+oxAJANWaIGrn95KeIqhay5Ug24NJQkiNasGTZ6jWOriBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQs6EqaxsPuqhYAiInZ/+l0MTVWmujpEuW4qpCGiKtEQeJeZhikqaFic4SKiwxRPZJwu8pLueO8gKswYft7ZA3RByfHjZWQy0yMu3eKl3BVITDuYyMgesgAgDHcsZ1lqrHI/jChzx3bIbHfyXZFyBH70/e4wYKQq1IKiSolA7InEElXkCIiFkqQIiIWSpAiIhZKkCIiFkqQIiIWSpAiIhZKkCIiFkqQIiIW9ETxOOeeDAwAfj0xudvnFpspKnfGhBlukmyU5SaUR43u9TfEBHYASBGtFACubYTh5k8Dgfte/uxkZngZKizjuSc059Lce7FHbls/cbd5YFsuhD6xbkQrDgCIyBYgJnYf217EHbMmxR1nCdzjBeQ+Z1KHIWedR1luojhz3qVCd1uGltAVpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiIUSpIiIhRKkiIiFEqSIiIVnDF2jISLy/4quIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCyUIEVELJQgRUQslCBFRCz+C8G6QyrcJMxsAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def crop_center(img,cropx,cropy):\n",
    "    y,x = img.shape[1:3]\n",
    "    startx = x//2-(cropx//2)\n",
    "    starty = y//2-(cropy//2)    \n",
    "    return img[:, starty:starty+cropy,startx:startx+cropx, ...]\n",
    "\n",
    "np_batch_rgb = crop_center(np_batch_rgb, 32, 32)\n",
    "ms_sample = np_batch_rgb[0]\n",
    "rgb_sample = ms_sample[:, :, 1:4]\n",
    "print(rgb_sample.shape)\n",
    "\n",
    "if rgb_sample.dtype != np.uint8:\n",
    "    bands_min = rgb_sample.min()\n",
    "    bands_max = rgb_sample.max()\n",
    "    bands_norm = (rgb_sample - bands_min) / (bands_max - bands_min)\n",
    "    bands_uint8 = (bands_norm * 255).astype(np.uint8)\n",
    "else:\n",
    "    bands_uint8 = rgb_sample\n",
    "\n",
    "plt.figure(figsize=(4, 4))\n",
    "plt.imshow(bands_uint8)\n",
    "plt.axis('off')  # Turn off the axis\n",
    "plt.title(\"Extracted Bands 2, 3, 4 as RGB\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31825\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import glob\n",
    "from PIL import Image\n",
    "from pathlib import Path\n",
    "\n",
    "root_dir = '/home/nam/ROIs2017_winter_lc'\n",
    "ROI2017_paths = glob.glob(os.path.join(root_dir, '**', '*.tif'), recursive=True)\n",
    "ROI2017_paths = [Path(p) for p in ROI2017_paths]\n",
    "print(len(ROI2017_paths))\n",
    "datasets_dict['sentinel1/2_ms'] = ROI2017_paths\n",
    "list_datasets_size.append(len(ROI2017_paths))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16200\n"
     ]
    }
   ],
   "source": [
    "merged_dataset_size = min(list_datasets_size)\n",
    "print(merged_dataset_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eurosat shape before processing is (16, 64, 64, 13)\n",
      "eurosat shape after processing is (16, 64, 64, 3)\n",
      "sentinel1/2 shape before processing is (16, 256, 256, 3)\n",
      "sentinel1/2 shape after processing is (16, 64, 64, 3)\n",
      "eurosat shape before processing is (16, 64, 64, 13)\n",
      "eurosat shape after processing is (16, 64, 64, 3)\n",
      "sentinel1/2 shape before processing is (16, 256, 256, 3)\n",
      "sentinel1/2 shape after processing is (16, 64, 64, 3)\n",
      "eurosat shape before processing is (16, 64, 64, 13)\n",
      "eurosat shape after processing is (16, 64, 64, 3)\n",
      "sentinel1/2 shape before processing is (16, 256, 256, 3)\n",
      "sentinel1/2 shape after processing is (16, 64, 64, 3)\n",
      "eurosat shape before processing is (16, 64, 64, 13)\n",
      "eurosat shape after processing is (16, 64, 64, 3)\n",
      "sentinel1/2 shape before processing is (16, 256, 256, 3)\n",
      "sentinel1/2 shape after processing is (16, 64, 64, 3)\n",
      "eurosat shape before processing is (16, 64, 64, 13)\n",
      "eurosat shape after processing is (16, 64, 64, 3)\n",
      "sentinel1/2 shape before processing is (16, 256, 256, 3)\n",
      "sentinel1/2 shape after processing is (16, 64, 64, 3)\n",
      "eurosat shape before processing is (16, 64, 64, 13)\n",
      "eurosat shape after processing is (16, 64, 64, 3)\n",
      "sentinel1/2 shape before processing is (16, 256, 256, 3)\n",
      "sentinel1/2 shape after processing is (16, 64, 64, 3)\n",
      "eurosat shape before processing is (16, 64, 64, 13)\n",
      "eurosat shape after processing is (16, 64, 64, 3)\n",
      "sentinel1/2 shape before processing is (16, 256, 256, 3)\n",
      "sentinel1/2 shape after processing is (16, 64, 64, 3)\n",
      "(224, 64, 64, 3)\n"
     ]
    }
   ],
   "source": [
    "# images = test_set['image']  # dont do this, you are practically loading 5400 samples into memory\n",
    "import datasets \n",
    "import numpy as np\n",
    "from osgeo import gdal\n",
    "\n",
    "combined_batch_size = 32\n",
    "num_datasets = 2\n",
    "per_dataset_batch_size = int(combined_batch_size/num_datasets)\n",
    "\n",
    "\n",
    "combined_batch_np = np.array([[0]])\n",
    "arbiter_dataset_size = 200\n",
    "merged_H = 64\n",
    "merged_W = 64\n",
    "for i in range(0, arbiter_dataset_size, combined_batch_size):\n",
    "    for _, dataset in datasets_dict.items():\n",
    "        if isinstance(dataset, list):\n",
    "            skipped_i_list = 0\n",
    "            metadata_batch = dataset[(skipped_i_list + i):(skipped_i_list + i + per_dataset_batch_size)]\n",
    "            if isinstance(metadata_batch[0], Path):\n",
    "                # not sure if it works with .geotiff, should do\n",
    "                batch_np = np.array([[0]])\n",
    "                if metadata_batch[0].suffix.lower() in ['.tif', '.tiff', '.geotiff']:\n",
    "                    for path in metadata_batch:\n",
    "                        sample = gdal.Open(str(path)) \n",
    "                        band_arrays = []\n",
    "                        # assume rgb bands = 2,3,4\n",
    "                        for band in [2,3,4]:\n",
    "                            raster_band = sample.GetRasterBand(band)\n",
    "                            band_arrays.append(raster_band.ReadAsArray())\n",
    "                \n",
    "                        sample_np = np.stack(band_arrays, axis=-1)\n",
    "                        if sample_np.dtype != np.uint8:\n",
    "                            sample_np_temp = sample_np\n",
    "                            # return shape shape (B, 1, 1, C) that contains min, max for each channel in each sample\n",
    "                            min_vals = sample_np_temp.min(axis=(1, 2), keepdims=True)\n",
    "                            max_vals = sample_np_temp.max(axis=(1, 2), keepdims=True)\n",
    "                            \n",
    "                            ranges = max_vals - min_vals\n",
    "                            ranges[ranges == 0] = 1\n",
    "                            sample_np_temp = (sample_np_temp - min_vals) / ranges * 255\n",
    "                            sample_np = sample_np_temp.astype(np.uint8) \n",
    "                        sample_np = np.expand_dims(sample_np, axis=0)\n",
    "                        \n",
    "                        if batch_np.ndim == sample_np.ndim:\n",
    "                            batch_np = np.concatenate((batch_np, sample_np), axis=0)\n",
    "                        else:\n",
    "                            batch_np = sample_np\n",
    "                    \n",
    "                    print(f\"sentinel1/2 shape before processing is {batch_np.shape}\")\n",
    "                    H,W = batch_np.shape[1:3]\n",
    "                    if H < merged_H or W < merged_W:\n",
    "                        skipped_i_list += per_dataset_batch_size\n",
    "                        metadata_batch = dataset.select(range(skipped_i_list, skipped_i_list + per_dataset_batch_size))\n",
    "                    elif H > merged_H or W > merged_W:\n",
    "                        batch_np = crop_center(batch_np, merged_H, merged_W)\n",
    "                \n",
    "                    print(f\"sentinel1/2 shape after processing is {batch_np.shape}\")\n",
    "                            \n",
    "                            \n",
    "        elif isinstance(dataset, datasets.arrow_dataset.Dataset):\n",
    "            skipped_i_dataset = 0\n",
    "            metadata_batch = dataset.select(range(skipped_i_dataset + i, skipped_i_dataset + i + per_dataset_batch_size))\n",
    "            batch_np = np.array([[0]])\n",
    "            if (key := next(iter(set(metadata_batch.column_names) & {'rgb', 'rgbs'}), None)) is not None:\n",
    "                batch_image = metadata_batch[key]\n",
    "                # same thing as \n",
    "                '''\n",
    "                for key in ['rgb', 'rgbs']:\n",
    "                    if key in metadata_batch.column_names:\n",
    "                        batch_image = metadata_batch[key]\n",
    "\n",
    "                '''\n",
    "                batch_np = np.array(batch_image)\n",
    "                # take into account for bi-temporal images for Change Detection\n",
    "                if batch_np.ndim == 5:\n",
    "                    continue\n",
    "                H,W = batch_np.shape[1:3]\n",
    "                if H < merged_H or W < merged_W:\n",
    "                    skipped_i_dataset += per_dataset_batch_size\n",
    "                    metadata_batch = dataset.select(range(skipped_i_dataset, skipped_i_dataset + per_dataset_batch_size))\n",
    "                    batch_np = np.array(metadata_batch[key])\n",
    "                elif H > merged_H or W > merged_W:\n",
    "                    batch_np = crop_center(batch_np, merged_H, merged_W)\n",
    "                print(f\"eurosat shape is {batch_np.shape}\")\n",
    "\n",
    "                if batch_np.dtype != np.uint8:\n",
    "                    batch_np_temp = batch_np\n",
    "                    # return shape shape (B, 1, 1, C) that contains min, max for each channel in each sample\n",
    "                    min_vals = batch_np_temp.min(axis=(1, 2), keepdims=True)\n",
    "                    max_vals = batch_np_temp.max(axis=(1, 2), keepdims=True)\n",
    "                    \n",
    "                    ranges = max_vals - min_vals\n",
    "                    ranges[ranges == 0] = 1\n",
    "                    batch_np_temp = (batch_np_temp - min_vals) / ranges * 255\n",
    "                    batch_np = batch_np_temp.astype(np.uint8) \n",
    "                    \n",
    "            elif (key := next(iter(set(metadata_batch.column_names) & {'ms'}), None)) is not None:\n",
    "                batch_image = metadata_batch[key]\n",
    "                batch_np = np.array(batch_image)\n",
    "                print(f\"eurosat shape before processing is {batch_np.shape}\")\n",
    "                # take into account for bi-temporal images for Change Detection\n",
    "                if batch_np.ndim == 5:\n",
    "                    continue\n",
    "                else:\n",
    "                    H,W = batch_np.shape[1:3]\n",
    "                    if H < merged_H or W < merged_W:\n",
    "                        skipped_i_dataset += per_dataset_batch_size\n",
    "                        metadata_batch = dataset.select(range(skipped_i_dataset, skipped_i_dataset + per_dataset_batch_size))\n",
    "                        batch_np = np.array(metadata_batch[key])\n",
    "                    elif H > merged_H or W > merged_W:\n",
    "                        batch_np = crop_center(batch_np, merged_H, merged_W)\n",
    "                \n",
    "                # by default extract band 2,3,4 but will need to add if-condition to check dataset name i.e. <if dataset is 'eurosat'>\n",
    "                batch_np = batch_np[:, :, :, 1:4]\n",
    "                if batch_np.dtype != np.uint8:\n",
    "                    batch_np_temp = batch_np\n",
    "                    # return shape shape (B, 1, 1, C) that contains min, max for each channel in each sample\n",
    "                    min_vals = batch_np_temp.min(axis=(1, 2), keepdims=True)\n",
    "                    max_vals = batch_np_temp.max(axis=(1, 2), keepdims=True)\n",
    "                    \n",
    "                    ranges = max_vals - min_vals\n",
    "                    ranges[ranges == 0] = 1\n",
    "                    batch_np_temp = (batch_np_temp - min_vals) / ranges * 255\n",
    "                    batch_np = batch_np_temp.astype(np.uint8) \n",
    "               \n",
    "            elif (key := next(iter(set(metadata_batch.column_names) & {'image', 'images'}), None)) is not None:\n",
    "                batch_image = metadata_batch[key]\n",
    "                batch_np = np.array(batch_image)\n",
    "                print(f\"eurosat shape before processing is {batch_np.shape}\")\n",
    "                # take into account for bi-temporal images for Change Detection\n",
    "                if batch_np.ndim == 5:\n",
    "                    continue  \n",
    "                else:     \n",
    "                    H,W = batch_np.shape[1:3]\n",
    "                    if H < merged_H or W < merged_W:\n",
    "                        skipped_i_dataset += per_dataset_batch_size\n",
    "                        metadata_batch = dataset.select(range(skipped_i_dataset, skipped_i_dataset + per_dataset_batch_size))\n",
    "                        batch_np = np.array(metadata_batch[key])\n",
    "                    elif H > merged_H or W > merged_W:\n",
    "                        batch_np = crop_center(batch_np, merged_H, merged_W)\n",
    "                \n",
    "                # multispectral images\n",
    "                if batch_np.shape[-1] > 3:\n",
    "                    # by default extract band 2,3,4 but will need to add if-condition to check dataset name\n",
    "                    # if dataset is 'eurosat'\n",
    "                    batch_np = batch_np[:, :, :, 1:4]\n",
    " \n",
    "                elif batch_np.shape[-1] < 3:\n",
    "                    print(\"Need to look into each sample of this remote sensing dataset\")\n",
    "                    continue\n",
    "\n",
    "                \n",
    "                if batch_np.dtype != np.uint8:\n",
    "                    batch_np_temp = batch_np\n",
    "                    # return shape shape (B, 1, 1, C) that contains min, max for each channel in each sample\n",
    "                    min_vals = batch_np_temp.min(axis=(1, 2), keepdims=True)\n",
    "                    max_vals = batch_np_temp.max(axis=(1, 2), keepdims=True)\n",
    "                    \n",
    "                    ranges = max_vals - min_vals\n",
    "                    ranges[ranges == 0] = 1\n",
    "                    batch_np_temp = (batch_np_temp - min_vals) / ranges * 255\n",
    "                    batch_np = batch_np_temp.astype(np.uint8)   \n",
    "                    \n",
    "                print(f\"eurosat shape after processing is {batch_np.shape}\")\n",
    "\n",
    "        if combined_batch_np.ndim == batch_np.ndim:\n",
    "            combined_batch_np = np.concatenate((combined_batch_np, batch_np), axis=0)\n",
    "        else:\n",
    "            combined_batch_np = batch_np\n",
    "                   \n",
    "print(combined_batch_np.shape)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "hf",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.21"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}