101. Lung_segmentation_with_Unet.ipynb

{"cells":[{"cell_type":"markdown","source":["**Acknowledgements:**\n","\n","The codes are taken from [Idiot Developer](https://www.youtube.com/watch?v=LkmgdNpcgTM&t=841s) watch the videos for detailed explanation."],"metadata":{"id":"VAxpRfFrihur"}},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3870,"status":"ok","timestamp":1661171516476,"user":{"displayName":"Shuvro das","userId":"00702906785603194809"},"user_tz":-360},"id":"f3NLyYRb8Xns","outputId":"0cbb1e65-6c29-4ff8-b5d4-e30e89ea6f55"},"outputs":[{"output_type":"stream","name":"stdout","text":["Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Requirement already satisfied: tensorflow in /usr/local/lib/python3.7/dist-packages (2.8.2+zzzcolab20220719082949)\n","Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.2.0)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from tensorflow) (57.4.0)\n","Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.26.0)\n","Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (4.1.1)\n","Requirement already satisfied: keras<2.9,>=2.8.0rc0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0)\n","Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.47.0)\n","Requirement already satisfied: numpy>=1.20 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.21.6)\n","Requirement already satisfied: libclang>=9.0.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (14.0.6)\n","Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.3.0)\n","Requirement already satisfied: flatbuffers>=1.12 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.0)\n","Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.1.0)\n","Requirement already satisfied: tensorboard<2.9,>=2.8 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0)\n","Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.15.0)\n","Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.1.0)\n","Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.6.3)\n","Requirement already satisfied: gast>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.5.3)\n","Requirement already satisfied: keras-preprocessing>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.1.2)\n","Requirement already satisfied: protobuf<3.20,>=3.9.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.17.3)\n","Requirement already satisfied: tensorflow-estimator<2.9,>=2.8 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0)\n","Requirement already satisfied: absl-py>=0.4.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.2.0)\n","Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.14.1)\n","Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.7/dist-packages (from astunparse>=1.6.0->tensorflow) (0.37.1)\n","Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py>=2.9.0->tensorflow) (1.5.2)\n","Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (2.23.0)\n","Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (3.4.1)\n","Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (1.0.1)\n","Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (1.35.0)\n","Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (0.6.1)\n","Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (0.4.6)\n","Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<2.9,>=2.8->tensorflow) (1.8.1)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (0.2.8)\n","Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (4.9)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (4.2.4)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.9,>=2.8->tensorflow) (1.3.1)\n","Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard<2.9,>=2.8->tensorflow) (4.12.0)\n","Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard<2.9,>=2.8->tensorflow) (3.8.1)\n","Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.9,>=2.8->tensorflow) (0.4.8)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (2.10)\n","Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (1.24.3)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (2022.6.15)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<2.9,>=2.8->tensorflow) (3.0.4)\n","Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.9,>=2.8->tensorflow) (3.2.0)\n"]}],"source":["!pip install tensorflow"]},{"cell_type":"code","source":["from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, MaxPool2D, Conv2DTranspose, Concatenate, Input\n","from tensorflow.keras.models import Model\n","\n","def convolution_block(input, num_filters):\n","    x = Conv2D(num_filters, 3, padding=\"same\")(input)\n","    x = BatchNormalization()(x)\n","    x = Activation(\"relu\")(x)\n","\n","    x = Conv2D(num_filters, 3, padding=\"same\")(x)\n","    x = BatchNormalization()(x)\n","    x = Activation(\"relu\")(x)\n","\n","    return x\n","\n","def encoder_block(input, num_filters):\n","    x = convolution_block(input, num_filters)\n","    p = MaxPool2D((2, 2))(x)\n","    return x, p\n","\n","def decoder_block(input, skip_features, num_filters):\n","    x = Conv2DTranspose(num_filters, (2, 2), strides=2, padding=\"same\")(input)\n","    x = Concatenate()([x, skip_features])\n","    x = convolution_block(x, num_filters)\n","    return x\n","\n","def build_unet(input_shape):\n","    inputs = Input(input_shape)\n","\n","    s1, p1 = encoder_block(inputs, 64)\n","    s2, p2 = encoder_block(p1, 128)\n","    s3, p3 = encoder_block(p2, 256)\n","    s4, p4 = encoder_block(p3, 512)\n","\n","    b1 = convolution_block(p4, 1024)\n","\n","    d1 = decoder_block(b1, s4, 512)\n","    d2 = decoder_block(d1, s3, 256)\n","    d3 = decoder_block(d2, s2, 128)\n","    d4 = decoder_block(d3, s1, 64)\n","\n","    outputs = Conv2D(1, 1, padding=\"same\", activation=\"sigmoid\")(d4)\n","\n","    model = Model(inputs, outputs, name=\"U-Net\")\n","    return model\n","\n","if __name__ == \"__main__\":\n","    input_shape = (512, 512, 3)\n","    \n","    model = build_unet(input_shape)\n","    #model.summary()"],"metadata":{"id":"AzOAf6RCiU22"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["import numpy as np\n","import tensorflow as tf\n","from tensorflow.keras import backend as K\n","\n","def iou(y_true, y_pred):\n","    def f(y_true, y_pred):\n","        intersection = (y_true * y_pred).sum()\n","        union = y_true.sum() + y_pred.sum() - intersection\n","        x = (intersection + 1e-15) / (union + 1e-15)\n","        x = x.astype(np.float32)\n","        return x\n","    return tf.numpy_function(f, [y_true, y_pred], tf.float32)\n","\n","smooth = 1e-15\n","def dice_coef(y_true, y_pred):\n","    y_true = tf.keras.layers.Flatten()(y_true)\n","    y_pred = tf.keras.layers.Flatten()(y_pred)\n","    intersection = tf.reduce_sum(y_true * y_pred)\n","    return (2. * intersection + smooth) / (tf.reduce_sum(y_true) + tf.reduce_sum(y_pred) + smooth)\n","\n","def dice_loss(y_true, y_pred):\n","    return 1.0 - dice_coef(y_true, y_pred)"],"metadata":{"id":"eUGdtStSiWJx"},"execution_count":null,"outputs":[]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vED7wNWt8h7d"},"outputs":[],"source":["import os\n","os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n","import numpy as np\n","import cv2\n","from glob import glob\n","from tqdm import tqdm\n","from sklearn.model_selection import train_test_split\n","import tensorflow as tf\n","import matplotlib.pyplot as plt\n","from tensorflow.keras.callbacks import ModelCheckpoint, CSVLogger, ReduceLROnPlateau\n","from tensorflow.keras.optimizers import Adam\n","from tensorflow.keras.metrics import Recall, Precision\n","from lung_seg_model import build_unet\n","from lung_seg_metrics import dice_loss, dice_coef, iou\n","from tensorflow.keras.utils import CustomObjectScope"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Fbasv6Wk8npO"},"outputs":[],"source":["\"\"\" Global parameters \"\"\"\n","H = 512\n","W = 512\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"sS1hkdqh8s21"},"outputs":[],"source":["def create_dir(path):\n","    \"\"\" Create a directory. \"\"\"\n","    if not os.path.exists(path):\n","        os.makedirs(path)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"CTZPK11283X1"},"outputs":[],"source":["def load_data(path):\n","    train_x = sorted(glob(os.path.join(path,\"Train\", \"CXR_png\", \"*.png\")))\n","    train_y1= sorted(glob(os.path.join(path,\"Train\", \"ManualMask\", \"leftMask\", \"*.png\")))\n","    train_y2= sorted(glob(os.path.join(path,\"Train\", \"ManualMask\", \"rightMask\", \"*.png\")))\n","\n","    valid_x = sorted(glob(os.path.join(path,\"Valid\", \"CXR_png\", \"*.png\")))\n","    valid_y1= sorted(glob(os.path.join(path,\"Valid\", \"ManualMask\", \"leftMask\", \"*.png\")))\n","    valid_y2= sorted(glob(os.path.join(path,\"Valid\", \"ManualMask\", \"rightMask\", \"*.png\")))\n","\n","    return (train_x, train_y1, train_y2), (valid_x, valid_y1, valid_y2)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"eZlq3J6W87B9"},"outputs":[],"source":["def read_image(path):\n","    x = cv2.imread(path, cv2.IMREAD_COLOR)\n","    x = cv2.resize(x, (W, H))\n","    x = x/255.0\n","    x = x.astype(np.float32)\n","    return x"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"CBi3jOkm9RRd"},"outputs":[],"source":["def read_mask(path1, path2):\n","    x1 = cv2.imread(path1, cv2.IMREAD_GRAYSCALE)\n","    x2 = cv2.imread(path2, cv2.IMREAD_GRAYSCALE)\n","    x = x1 + x2\n","    x = cv2.resize(x, (W, H))\n","    x = x/np.max(x)\n","    x = x > 0.5\n","    x = x.astype(np.float32)\n","    x = np.expand_dims(x, axis=-1)\n","    return x"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"-e_3iIxX9TE9"},"outputs":[],"source":["\n","def tf_parse(x, y1, y2):\n","    def _parse(x, y1, y2):\n","        x = x.decode()\n","        y1 = y1.decode()\n","        y2 = y2.decode()\n","\n","        x = read_image(x)\n","        y = read_mask(y1, y2)\n","        return x, y\n","\n","    x, y = tf.numpy_function(_parse, [x, y1, y2], [tf.float32, tf.float32])\n","    x.set_shape([H, W, 3])\n","    y.set_shape([H, W, 1])\n","    return x, y"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"KKIQbwGt9U98"},"outputs":[],"source":["def tf_dataset(X, Y1, Y2, batch=8):\n","    dataset = tf.data.Dataset.from_tensor_slices((X, Y1, Y2))\n","    dataset = dataset.shuffle(buffer_size=200)\n","    dataset = dataset.map(tf_parse)\n","    dataset = dataset.batch(batch)\n","    dataset = dataset.prefetch(4)\n","    return dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":783732,"status":"ok","timestamp":1661172316997,"user":{"displayName":"Shuvro das","userId":"00702906785603194809"},"user_tz":-360},"id":"zmx_wcdT9W_N","outputId":"9e396fa9-0a3e-4818-83eb-b18c273056d2"},"outputs":[{"output_type":"stream","name":"stdout","text":["Train: 118 - 118 - 118\n","Valid: 10 - 10 - 10\n","Epoch 1/10\n","59/59 [==============================] - ETA: 0s - loss: 0.5048 - dice_coef: 0.4952 - iou: 0.3331 - recall: 0.8744 - precision: 0.4750\n","Epoch 1: val_loss improved from inf to 0.65479, saving model to files/model.h5\n","59/59 [==============================] - 263s 4s/step - loss: 0.5048 - dice_coef: 0.4952 - iou: 0.3331 - recall: 0.8744 - precision: 0.4750 - val_loss: 0.6548 - val_dice_coef: 0.3452 - val_iou: 0.2090 - val_recall: 0.9655 - val_precision: 0.3160 - lr: 1.0000e-05\n","Epoch 2/10\n","59/59 [==============================] - ETA: 0s - loss: 0.3538 - dice_coef: 0.6462 - iou: 0.4792 - recall: 0.9258 - precision: 0.5911\n","Epoch 2: val_loss improved from 0.65479 to 0.64129, saving model to files/model.h5\n","59/59 [==============================] - 51s 857ms/step - loss: 0.3538 - dice_coef: 0.6462 - iou: 0.4792 - recall: 0.9258 - precision: 0.5911 - val_loss: 0.6413 - val_dice_coef: 0.3587 - val_iou: 0.2207 - val_recall: 0.9018 - val_precision: 0.3736 - lr: 1.0000e-05\n","Epoch 3/10\n","59/59 [==============================] - ETA: 0s - loss: 0.2439 - dice_coef: 0.7561 - iou: 0.6112 - recall: 0.9594 - precision: 0.8057\n","Epoch 3: val_loss did not improve from 0.64129\n","59/59 [==============================] - 49s 824ms/step - loss: 0.2439 - dice_coef: 0.7561 - iou: 0.6112 - recall: 0.9594 - precision: 0.8057 - val_loss: 0.6491 - val_dice_coef: 0.3509 - val_iou: 0.2138 - val_recall: 0.6896 - val_precision: 0.3567 - lr: 1.0000e-05\n","Epoch 4/10\n","59/59 [==============================] - ETA: 0s - loss: 0.1813 - dice_coef: 0.8187 - iou: 0.6967 - recall: 0.9678 - precision: 0.9055\n","Epoch 4: val_loss did not improve from 0.64129\n","59/59 [==============================] - 50s 843ms/step - loss: 0.1813 - dice_coef: 0.8187 - iou: 0.6967 - recall: 0.9678 - precision: 0.9055 - val_loss: 0.6621 - val_dice_coef: 0.3379 - val_iou: 0.2047 - val_recall: 0.0430 - val_precision: 0.1948 - lr: 1.0000e-05\n","Epoch 5/10\n","59/59 [==============================] - ETA: 0s - loss: 0.1553 - dice_coef: 0.8447 - iou: 0.7345 - recall: 0.9683 - precision: 0.9224\n","Epoch 5: val_loss did not improve from 0.64129\n","59/59 [==============================] - 49s 820ms/step - loss: 0.1553 - dice_coef: 0.8447 - iou: 0.7345 - recall: 0.9683 - precision: 0.9224 - val_loss: 0.7114 - val_dice_coef: 0.2886 - val_iou: 0.1689 - val_recall: 4.6366e-05 - val_precision: 0.0016 - lr: 1.0000e-05\n","Epoch 6/10\n","59/59 [==============================] - ETA: 0s - loss: 0.1356 - dice_coef: 0.8644 - iou: 0.7632 - recall: 0.9674 - precision: 0.9459\n","Epoch 6: val_loss did not improve from 0.64129\n","59/59 [==============================] - 50s 841ms/step - loss: 0.1356 - dice_coef: 0.8644 - iou: 0.7632 - recall: 0.9674 - precision: 0.9459 - val_loss: 0.7885 - val_dice_coef: 0.2115 - val_iou: 0.1184 - val_recall: 1.7948e-05 - val_precision: 0.0029 - lr: 1.0000e-05\n","Epoch 7/10\n","59/59 [==============================] - ETA: 0s - loss: 0.1265 - dice_coef: 0.8735 - iou: 0.7787 - recall: 0.9715 - precision: 0.9517\n","Epoch 7: val_loss did not improve from 0.64129\n","\n","Epoch 7: ReduceLROnPlateau reducing learning rate to 9.999999747378752e-07.\n","59/59 [==============================] - 49s 827ms/step - loss: 0.1265 - dice_coef: 0.8735 - iou: 0.7787 - recall: 0.9715 - precision: 0.9517 - val_loss: 0.8403 - val_dice_coef: 0.1597 - val_iou: 0.0868 - val_recall: 1.0470e-05 - val_precision: 0.0044 - lr: 1.0000e-05\n","Epoch 8/10\n","59/59 [==============================] - ETA: 0s - loss: 0.1190 - dice_coef: 0.8810 - iou: 0.7906 - recall: 0.9752 - precision: 0.9556\n","Epoch 8: val_loss did not improve from 0.64129\n","59/59 [==============================] - 49s 821ms/step - loss: 0.1190 - dice_coef: 0.8810 - iou: 0.7906 - recall: 0.9752 - precision: 0.9556 - val_loss: 0.8708 - val_dice_coef: 0.1292 - val_iou: 0.0691 - val_recall: 2.9914e-06 - val_precision: 0.0031 - lr: 1.0000e-06\n","Epoch 9/10\n","59/59 [==============================] - ETA: 0s - loss: 0.1152 - dice_coef: 0.8848 - iou: 0.7962 - recall: 0.9758 - precision: 0.9619\n","Epoch 9: val_loss did not improve from 0.64129\n","59/59 [==============================] - 50s 842ms/step - loss: 0.1152 - dice_coef: 0.8848 - iou: 0.7962 - recall: 0.9758 - precision: 0.9619 - val_loss: 0.8422 - val_dice_coef: 0.1578 - val_iou: 0.0858 - val_recall: 0.0285 - val_precision: 0.9764 - lr: 1.0000e-06\n","Epoch 10/10\n","59/59 [==============================] - ETA: 0s - loss: 0.1141 - dice_coef: 0.8859 - iou: 0.7977 - recall: 0.9767 - precision: 0.9625\n","Epoch 10: val_loss improved from 0.64129 to 0.45111, saving model to files/model.h5\n","59/59 [==============================] - 50s 846ms/step - loss: 0.1141 - dice_coef: 0.8859 - iou: 0.7977 - recall: 0.9767 - precision: 0.9625 - val_loss: 0.4511 - val_dice_coef: 0.5489 - val_iou: 0.3807 - val_recall: 0.4028 - val_precision: 0.9861 - lr: 1.0000e-06\n"]}],"source":["if __name__ == \"__main__\":\n","    \"\"\" Directory for storing files \"\"\"\n","    create_dir(\"files\")\n","\n","    \"\"\" Hyperparameters \"\"\"\n","    batch_size = 2\n","    lr = 1e-5             #this is the learning rate alpha\n","    num_epochs = 10\n","    model_path = os.path.join(\"files\", \"model.h5\")\n","    csv_path = os.path.join(\"files\", \"data.csv\")\n","\n","    \"\"\" Dataset \"\"\"\n","    dataset_path = \"/content/drive/MyDrive/Colab Notebooks/CustomMontgomerySet\"\n","    (train_x, train_y1, train_y2), (valid_x, valid_y1, valid_y2)= load_data(dataset_path)\n","     \n","   #  here we are printing to see that train x, train y1 and train y2  have same number of images. \n","    print(f\"Train: {len(train_x)} - {len(train_y1)} - {len(train_y2)}\")\n","    print(f\"Valid: {len(valid_x)} - {len(valid_y1)} - {len(valid_y2)}\")\n","    \n","    \n","    \"\"\"Lets find the train and valid dataset using the tf_dataset function and the batchsize is 2\"\"\"\n","    train_dataset = tf_dataset(train_x, train_y1, train_y2, batch=batch_size)\n","    valid_dataset = tf_dataset(valid_x, valid_y1, valid_y2, batch=batch_size)\n","  \n","\n","    \n","    \"\"\" Model \"\"\"\n","    model = build_unet((H, W, 3))\n","    metrics = [dice_coef, iou, Recall(), Precision()]\n","    model.compile(loss=dice_loss, optimizer=Adam(lr), metrics=metrics)\n","    \n","\n","    callbacks = [\n","        ModelCheckpoint(model_path, verbose=1, save_best_only=True),\n","        ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, min_lr=1e-7, verbose=1),\n","        CSVLogger(csv_path)\n","    ]\n","\n","    model.fit(\n","        train_dataset,\n","        epochs=num_epochs,\n","        validation_data=valid_dataset,\n","        callbacks=callbacks\n","    )\n"]},{"cell_type":"markdown","metadata":{"id":"mLDsVy_bX9DK"},"source":["Testing the images in the test folder"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":31056,"status":"ok","timestamp":1661172374408,"user":{"displayName":"Shuvro das","userId":"00702906785603194809"},"user_tz":-360},"id":"-KGxtsvJUjn_","outputId":"14288373-d2a1-4b0d-ce98-e83fb5f164be"},"outputs":[{"output_type":"stream","name":"stdout","text":["12\n"]},{"output_type":"stream","name":"stderr","text":["100%|██████████| 12/12 [00:28<00:00,  2.36s/it]\n"]}],"source":["if __name__ == \"__main__\":\n","   \n","    \"\"\" Directory for storing files \"\"\"\n","    create_dir(\"results\")\n","\n","    \"\"\" Loading model \"\"\"\n","    with CustomObjectScope({'iou': iou, 'dice_coef': dice_coef, 'dice_loss': dice_loss}):\n","        model = tf.keras.models.load_model(\"files/model.h5\")\n","\n","    \"\"\" Dataset \"\"\"\n","    path = \"/content/drive/MyDrive/Colab Notebooks/CustomMontgomerySet/Test/CXR_png\"\n","    test_x= sorted(glob(os.path.join(path, \"*.png\")))\n","\n","    print(len(test_x))\n","\n","    for x in tqdm(test_x, total=len(test_x)):\n","      \"\"\"Extracting the image name\"\"\"\n","      image_name = x.split(\"/\")[-1]\n","\n","\n","      \"\"\"Reading the image\"\"\"\n","      ori_x=cv2.imread(x,cv2.IMREAD_COLOR)\n","      ori_x = cv2.resize(ori_x, (W, H))\n","      x = ori_x/255.0\n","      x = x.astype(np.float32)\n","      x = np.expand_dims(x, axis=0)\n","\n","      \"\"\" Predicting the mask. \"\"\"\n","      y_pred = model.predict(x)[0] > 0.5\n","      y_pred = y_pred.astype(np.int32)\n","\n","      \"\"\" Saving the predicted mask along with the image and GT \"\"\"\n","      save_image_path = f\"/content/drive/MyDrive/Colab Notebooks/Results/{image_name}\"\n","      y_pred = np.concatenate([y_pred, y_pred, y_pred], axis=-1)\n","\n","      sep_line = np.ones((H, 10, 3)) * 255\n","      cat_image = np.concatenate([ori_x,sep_line,y_pred*255], axis=1)\n","      cv2.imwrite(save_image_path, cat_image)\n","       \n","     \n","\n","        "]},{"cell_type":"markdown","metadata":{"id":"yd-TCyY6YBo9"},"source":["Testing custom images "]},{"cell_type":"code","execution_count":null,"metadata":{"id":"SrEztIJJUzOp"},"outputs":[],"source":["if __name__ == \"__main__\":\n","\n","    \"\"\" Loading model \"\"\"\n","    with CustomObjectScope({'iou': iou, 'dice_coef': dice_coef, 'dice_loss': dice_loss}):\n","        model = tf.keras.models.load_model(\"files/model.h5\")\n","\n","    img=cv2.imread(\"12.jpeg\",cv2.IMREAD_COLOR)\n","    img = cv2.resize(img, (W, H))\n","    x = img/255.0\n","    x = x.astype(np.float32)\n","    x = np.expand_dims(x, axis=0)\n","\n","    y_pred = model.predict(x)[0] > 0.5\n","    y_pred = y_pred.astype(np.int32)\n","    y_pred = np.concatenate([y_pred, y_pred, y_pred], axis=-1)\n","\n","    sep_line = np.ones((H, 10, 3)) * 255\n","    output_image = np.concatenate([img,sep_line,y_pred*255], axis=1)\n","    cv2.imwrite(\"Output_img3.jpeg\", output_image)\n","\n","\n","\n","    "]},{"cell_type":"markdown","source":["**Output image**\n","\n","input-ground truth-output"],"metadata":{"id":"GCWesMzIktaI"}},{"cell_type":"code","execution_count":1,"metadata":{"id":"8WomzHkXaOVP","colab":{"base_uri":"https://localhost:8080/","height":180},"executionInfo":{"status":"ok","timestamp":1665148304096,"user_tz":-360,"elapsed":1656,"user":{"displayName":"Shuvro das","userId":"00702906785603194809"}},"outputId":"563b3ce3-6b21-49a1-8898-29e599f73592"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["<matplotlib.image.AxesImage at 0x7f363ea0bd90>"]},"metadata":{},"execution_count":1},{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAXcAAACRCAYAAAA4qvjVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZScZZ0/+nlq37qr906nu7OShSQsSQgZEEFBxcERFccRGEfHUWEY58zcq0dBfsflqJzRGWfGq3dE4cKIuyPOiIMLQmAGJIhhCWEJIQkJIWvvVV379tw/uj5Pf+vtqk53p96qItbnnD5d9dZb716f5/t8vpvSWqOJJppooonTC456H0ATTTTRRBPVR5Pcm2iiiSZOQzTJvYkmmmjiNEST3JtoookmTkM0yb2JJppo4jREk9ybaKKJJk5D2ELuSqm3KqX2KKX2KaVusmMfTTTRRBNNVIaqdpy7UsoJ4CUAbwZwGMAOANdorV+o6o6aaKKJJpqoCDss9/MB7NNav6y1zgD4EYB32LCfJppoookmKsAOcu8H8Kp4f7i4rIkmmmiiiRrBVa8dK6WuA3AdAHg8ns09PT1QSkEpBbfbDYfDAa01pGxUKBT4XfNfKTVjXfmdXC6HfD5v/gDA6XRCKQWtNZRSyOVyyOVy5nvcpty+PDan02mWORwOOBwOsy95rE6nE06n07znXzabRSaTMe/z+bw5fm5bHovL5TLb4rXhNnlO1msFAC6Xy1wrHie/K6+P1rpkuVIK2WzWHJc8brlsYGAAPp8Pr7zyCkZGRuZz+6sCt9uNzs5OtLe3w+fzzTi3SkilUjh48CDi8fi89+l0OtHf34+uri5zbeeKfD6PY8eOYXh42DzL9URXVxeWLl2KeDyOPXv2zHh+mnhNYERr3V3uAzvI/QiAQfF+oLisBFrr2wDcBgBLly7VN954oyFdn8+H3t5euFwupNNpQ6KZTAZKKQQCAXg8HuTzeWQyGUxOTiKTycDtdsPlcsHj8aBQKCCXy6FQKCAej2N8fByRSMSQpNYak5OTOHToEGKxmDkup9MJr9eLQqGATCYDr9cLr9cLn8+HUCiEQCCA7u5udHV1obW1FR6PB62trXA4HOZYs9ks0um0WT+fzyORSCCRSGB4eBivvvoqRkZGMD4+jkQiYcje5XKhvb3dkLvb7UY4HEYgEEAul4PP50NnZ6e5NrlcDtFo1AxS2WzWkIbT6TSkp7WGx+OB1+uFx+NBMBhEPp+Hw+GA2+1GMplEMplEPp+H0+lEZ2cnnn/+ecTjcaRSKXPsExMTGB0dRTKZRDabxec+9zmceeaZuP7663H77bfb8CiVh1IKK1euxL//+7/jggsumDEwVYIkr5dffhkf/vCH8cgjj5gB8mT7DIfDuP3223HllVfC7XbP+Fxu33oc/CydTuOOO+7AzTffjGg0etL92ol3vvOduO222/C73/0Ol1xyCbLZbF2Pp4kF4ZVKH9hB7jsArFJKLccUqV8N4NrZvkALLJPJGELOZDIIBoNwuVzI5/NQShmSdTqd5kGMx+OGmJLJJFpbW411y++2trbC6/Wis7MT6XQasVgMR48excGDB5FIJMwPlZaz1hqJRAJaa+TzecTjcbjdbrPP8fFxKKWMlZ1Op+H1eqGUMtY0LXsOMiT8SCSCyclJRCIRJBIJJJNJFAoFuN1utLa2IhQKmfPkrCKdTsPpdCKfz+PEiROYmJjA4sWLEQwG4fP5kEqlzHFLgqGVTYs9lUrB7XbD4/GYGY3f7zeWeSKRMNeBhMnZgtPphM/nM4MVZzL1wMqVK3HnnXfiwgsvLJnFnQxcR2uNFStW4Dvf+Q6uueYabN++fU5W6+tf/3pcccUVJcQu93uyY+Ag+5GPfAQdHR342Mc+huPHj590v01UD0qpkuf/dEbVyV1rnVNK/S2A+wA4AdyptX5+1oNwudDX14dsNotYLGasVo/HA4fDgUKhYCxyh8OBbDZrbpDP50M6nQYAQ/C04ClpaK0RDoehlEI8Hkc8HjeE6XK5kMlkjPXrdDoNoXJ//MtkMohEInC73YjH44hEIvB6vXC73fB6vQCmLThpyZEok8mk2T/Pye/3I5/Pw+PxoK2tDaFQCMCUhcfBxOPxQGuNTCZTQvRLly6Fx+Mx52iVJSij0KpPJpNwOp3IZDJYuXIljh07hr6+PjidTkQiEbzwwgvIZrM4fvy4uRaFQgFer9fIN6lUysyg5iqDVAsulwvLly/HHXfcgde97nULHlz4vYGBAXzyk5/EtddeW1Gi4boejwfve9/74PP5Znw23/263W782Z/9GYaHh3HjjTcinU43JZEaQCmFs88+G5///OexY8cOfP3rXy87e7LOwqzL5H2X6zXaPbRFc9da/xLAL+e6PkdTr9eLlpYWQ35KKQSDQUP2JCan04m+vj7k83mEw2E899xzJRecPxYSPAmQRBcMBhEOh5FMJs3+abVT7qFWLq1w6vapVAqpVArxeByJRAKBQMCQK3V3Diwk3mw2a/6AKcLnwKCUQmtrK8LhMHK5nJnBSC2e8ojL5UIoFEI8HseRI0cwMDBgBjoOhBLyeBwOB06cOIEnn3wS559/Ph5++GF8/OMfx7Jly8wshOtL/4bH4+F9NdIOz6GWGBgYWJDFXglKKVx22WV4wxvegF/+8pdlf5wcqM8//3xcfvnlC96vlRAcDgc++MEPYvv27fjJT37ScMRwukEphfb2dnzpS1/CW97yFlx++eVYtGgRPvGJTyCbzcLtdiOTyQAAAoEA+vv7sWbNGhQKBaTTaUxMTODEiRPI5/M499xz4XA4cOTIERw4cACRSKQhfChW1M2hagWtaK01WlpakM1mDZGQlBOJhNGmC4UCIpEIgsEg3G63IV7+iNLpNHK5HPx+v7F8KY3k83kEg0F0dHQYzZkDgnRcAjDSCH+Q3FYikYDP50Mmk0E2mzVkTN3b4XAgn88bRySlGaUUQqEQ8vm8kY+y2awhVlr3nE0UCgVorZFOp826nN7HYjGMjo5i0aJF8Hq9SKVSJXKJlIW43OPxIBKJwOFwoLu7G08//TSWLVtm7oF1xiGtzUAggHg8bmYptSJ3+gZuuukmXHDBBVWVgwKBAD75yU/it7/9rfFfSNCJ/pGPfAStra1mWTUQCoXw+c9/Hs888wxeeumlsk7x0w1SGitnIc/l+3J2TKPrZPD5fPj85z+PN73pTeZ3cPXVV2PRokVQSqGzsxMHDx6E3+/H6tWrMTg4iJaWFvMbKhQKmJycRD6fR3t7O5xOJ1KpFO677z5cf/31GB8fn9c58PdqJxqK3GVECq1ekiVJnss9Hg96enqMZklSlg8PLV8SYiKRQDqdNoMEMPXjlto5R2Bq0HwQaMkDU0QnJQpa5Pl83jhnPR6PmcLTag6FQujv78fw8LCRWPifTlz6EPgwcZDK5/Pwer1Gk08mk3A4HGYg8Hg88Hg8ZmbDh1JOJbXW6OjowJ//+Z9j0aJFWL9+vdHZCYfDgY6ODkxOTpZ8xoidjo4O5HI5Q/C1wmWXXYZrrrnGDCjVIlilFLZu3Yo3v/nN+OlPf1p2nfb29pLZQjX2SaxatQo33XQTrr/+evNMno4goW3cuBFnnXUWgKnf6IsvvogdO3bMSZpyOp1oaWnBypUr0dXVhTVr1uDxxx/H73//+1m/q5TCmjVr8N73vhcu1zTldXR04F3vepdZ5+KLL57xPQm/31/y3u1248orr8SePXvwhS98wcjDc4GMrLMLDUPuMuzQ4XAYByGdjYVCAalUCn6/31jTJFKuS2csQRLOZrOIRCJIp9NIp9OYnJw0pEhrPxAIIBAIlFiqY2NjxtLP5XIIhUJmEKGExOMKhULw+/1meufxeEoctXx4U6mUie7hjIESTiqVQi6XQyKRQCQSQTweN5YJZwKUdXw+H5LJJDweDxKJhHGucl3q5bRwFi1aZMIGOzo6zHLC5/NhyZIl0Fqb7ezcudPcFx5jd/dU1FUymbTdocrt9/T04LOf/SxaWlps2Y/H48Hq1asrWpKDg4Po6+uzZd9KKVx55ZUmauV0tdz7+/vx2c9+FldddRXa29vN8tHRUfzjP/4jfv3rX+Oll14yBGm9Fw6HA319ffi7v/s7fOADH0BbWxucTid2796NG264Adu3b59VGjn//PNL9kuc6jPsdrvx0Y9+FI888gjuv//+Oc2+yFV2oyHIXRKINR6bUS8MwePIOzk5ifHxcfM5gJIBgQ5BOgvHx8cxOTmJWCxmCJuyCR8kvvZ4PMYBS7J0uVzw+XwIBoNoaWmB0+k0I7mM8rGeh5x5JBIJM7DEYjFjfZPYM5kMYrGYsexJznS+8uFNJBIYGhpCd3c3MpkMRkdH0dXVZWQjGc/Ph+3gwYN4/PHH0dnZiVQqhbVr1+Lpp5/G5s2bcfjwYRPuuGXLFmzevBmFQgHPPPOMOSfej46ODrhcLhw4cKBkNmMXnE4n/vZv/xabN282z0q1wW1WIoezzjqrxJFabbS1teHaa6/Fjh07GlK7PRVwJv6FL3wB73//+2dEWXV2duJLX/oSPvrRj+JXv/oVfvrTn+K3v/1tiRXscDiwefNmfO1rX8OWLVtK5MD169fji1/8Iq688sqKoaUOhwNnn322CTGuhr9Gnl84HMaNN96I7du3Ix6Pn9IAzetTjeegIapCSq2bVqd0SGazWROymM/nkU6nMTQ0hGQyibGxsZLt8GGiEzWXyyESiWBiYgIjIyMYHR3FyMiIuQl0olJ68fl8JhTR5/MZRyz18EgkgrGxMSP50BEspRCGQ3JwYAx+LpfD5OQkJiYmjOVLa5zRLCR8GQUjdftMJmOknJGRERNzPjk5ac6d4LV0Op2IxWJ46aWXkMlkjMb72GOP4dChQxgcHERrayu6u7tL5BYODLQ0eC153ey23B0OB7Zu3YrrrruuRP+vNspFQUhs3rzZ1nOl9b5kyRLb9lEv8Nze/e53l72GJLMlS5bg+uuvx913343bbrsNGzduRCAQgM/nQ39/P774xS9i69atZZ+DTZs2YcOGDRXvkdvtxrnnnmvL+fEczj//fGzdurUqM69qSZ4NQ+50QpLg+cdEJjo0JeFYpQV+n3q30+k0MeVjY2NIpVLme7FYDGNjY4jFYiaJiCSbSqWQTqfhdrvR0tKCUChk4s55HAyHpNOWVqwMqeS5kOyz2Syi0ahxjkorRur98txI2D6fryRzlzOPiYkJE7nD68VjkRIXZyCTk5MYGBjA2NgYWltboZTC7t27sXjxYsRisZKpq3SskuB5zr29vTMSeaoNt9uNv/mbv1lQNuh8oLXGq6++WvYzr9eLs846y/aBrL+/H1dffbWtg1g9EA6HccMNNyAUCs2w2gk5cw+Hw3jf+96H+++/H7/5zW9w77334le/+hUuu+yyGcEC/AsEAhgcHKxIrN3d3ViyZEnF/VcDgUAA73rXu055Nqu1NlF8p4qGkGUAmOgYXnySFElFTlU4GNCalKUFXC6XCZtMpVIYHR3F+Pi4kU1oBTNJKRaLIR6Pm8GAEgRDKXmhHQ6H0fsZ/55MJs12GYpIGUZag3Sc0prnbIDZqRw0KO9wm5wxyIGAGbOUaWjBd3R0IJPJIBAIGElHykMXX3wx3vOe95gBR848GM65Zs0aE9ZZLlafg0oymTRZwnZi6dKluPTSS20nu2w2iwMHDpT9rL293fgi7Lber7nmGnzrW9/C6OiobfupJZRSuOqqq3DRRRfN69oppYwTey5wOBzo6emp+PnKlSvR29s75/0vFBdccAFCoRAmJiZs39dc0BDkTgK31nBhBAswHdZHwrGSjrRaSXzUpkm4tM5JvrTYKWlorREIBEyWazAYLLGkSKochKR1TmKno8RqgZFwnU4nEokEotGocdLKAYfSjAxh5Plwe4waokzFsgaDg4MIBoPweDwmzIqW+8jICCYmJoyDmrVYGIFz7Ngxk+kbCAQwOjpasj/eJ173RCJhuz78tre9Dd3d3bYTazQaxeHDh8tafqlUqmqW1GxQSuGMM87AunXr8Mgjj9i+P7vB8MIbbrhhQTO8+dzvQqGAgwcPVvyc/ii7n6N169bhvPPOwwMPPGDbPuaDhiB3YFoCYFIP9XISHOPAy03NSGDAdEhkoVBANBo1JClDChkxQ8ubVjrLGqTTafh8PiQSCbS0tJhYeYZoyuzZYDBo9k1phecgj5PbpWaey+VKSh1QruF63BYHK/oEWDeHA4Lf74fD4UA0GkUkEkE4HIbb7TZSFgdFEjczTiVhezwejI2NIRqNQillkjKY/WtNqGK0kp3k7vP5cMUVV9Qklv748eMV45Tp16mFVOLxeLB169bThtwvvPBC2yUtGmnDw8MV12lrazPPkZ0E7/F4cNVVV+Ghhx5qiNIGDUHuvNiMn2YJAMb90iqnxU1LmbIFiYeSCeUDJgLRWk8mkyZaRlrxstKhPBZq7yT2QCCAcDhsIlIo/5DsSdbSMuag5fF4TBgjo2zy+Tyi0ajR/WV0DAcySaryAZWyFck/Go2abDspo/CcpI7P45IROIlEwsw83G43/H6/iannzENea7vgcDiwbt06EyFjN+icL4d0Oo2XX365qnHus+H8888vyZZ8rcLhcOBd73qX7X4ZABgeHsbhw4dnLKfhVy701w5orfGGN7wBvb29OH78eN0jnxrCoQpMx4JTP5cSB61xWWrXqrnz5jEsks5RWubRaBTRaNQQNi1Pa2gUSY+DSyqVMjVvhoaGcOLECaPhk8BpSTNyhqTP4+D2AJQcfzqdNjIMk6CYoSrPTQ462WwW8XjcyDoc5LhdkgJzA+R14PlyAKFUxXPkvpj9euLECVPAjbMXDmJ2WtRKKbz97W9HOBy2Ne5bhonOVhHxhRdeKFnfzmNat24dgsGgbduvFTo6OrBlyxZbI5x4H/73f/+3ouVeKBTw3HPPlYQp2wWlFFatWjVnX4HdaBhylxedGry8gdI7Ln9kkqCtseDMTI1EIiXx7dT0A4FAiYPS4/GYMr2tra2mtIGMOpEDCy0DGQIpa7Lw2GUi1dDQEGKxWMnx8Fwpy8htcNu8Jpx1pFIpTExMIBqNmho6dMoy8oiWNknbGo3Dz2nxc51AIIBgMIhYLIZjx45hYmLCFEdzu90lNeXtQCgUwhVXXDHjubADWk9lSc6GBx54wJCHncSulEJ/fz+WLl1q2z5qhfPOOw/Lly+3fT+8f+UGZz7nx44dsz3Vn3A6nbjiiitqkgNyMjQEuTMKhA5UatLlIK1OK/lTa5chewyBpAZGiYVkKGcKJE0Z2cLYd1qtWmuMj4+bEESZTSuPhbKJ1LyHhobM8cTjcVOgLBAIlIRxcgbA/TLeXkbQ0BqnFc98ADpjKdfIuHtJ9NJSl+UTtNYm+5YhlMwP4PXjYGgX8S5fvhxr1qwx19Ku/dB3wLoulfDMM8/g1ltvnSFx2UH0wWAQa9eurfp2awmXy4X3vOc98Pv9tg2GMoR427Zts0ogx44dsz0CST6nmzdvti2bej5oCHKnPkzHoiQeSeJSj5YWu7SglVLGUUoCdTgchihJjNw+rWpWe2QW6eTkpFk3m80akqdeLssZkEi5f1m/gjdckiwwZZ22tLSYcrq04iVkFBCjdBiyKbfJ68ZryOtk7dpUiejplOWAJB2+XBaNRjE6Omo0fQ7GdmDr1q01+3GMjY1h165dFT/n8/Fv//ZvePTRR0tmY3bA6XTinHPOsWXbtYBSCr29vbj00ktt3Y+8DyeLZhofH8eLL75ou6RGrFixoiEG6IYgd2lhyxjtchY6UKp9ymgZasGZTMYMEsw4ld/jPpPJZAmhs4EGLXgWzqL2TQcniVxGoAAoIXcZM8+Qw56enpJollgshomJCRNWSDlFRsbI0sMy2qW1tXWGDEUd3pokxdeUdqSfQjqeAZj4fWuoJ0M4R0dHkUgkbEu2cTqdJmGlFjh48OCcWgSOjo7ihhtuwI9//GNTfdMubNy4sSGm9QvF1q1bsWjRoprsi9FlJ1vny1/+snG62k3wfr8fmzZtsnUfc0FDkLvUg+lo5GtgWr8up7UDpRUhGeooC3LRIuZ20um0qclOZ6YsARCLxUztmlgsViJdJJNJaD3V/CMYDBonJnVzkiJ//FJq6e7uxuDgoHHWso2dbMPHYmKyz6o1rJIWs9/vN6GYmUwG4+Pj5txllU05e5AOVs6AfD5fySDKQaMcgTM0kDOEakIphe7ubmzZsqWq250Ne/funZMeWygUsHv3bnz4wx/GP//zP9sWfaHUVCo+y82+1sBKiXZHyfDaHDhwAIcOHZp13UKhgN/+9re49tpr8cwzzwCwl+BZy6beaAhyB6ZL9DKCQ4YFWgm9XNQCdW9ZZ0WGITocU23mWLCLETMSJE3GotNpyVowrCTJgcPj8ZjSA9TtpdVOoqf1zpDJUChkqlqykJg1xp2hmul02jQFyeVyRmrhtfB6vUYqSiaTGB0dLRloABidnt+RswBKT9KXoZQy5RasUEohlUphZGSk6j03lVLYsGGDsfpq4UzduXPnvELWkskkvvvd7+LIkSO2TfNZvfO1iPb2dpx33nkA7PWXcPuvvPLKSQdnqgCPPfYYbr755llj4qtxTACwbNmymoSBzoaTkrtS6k6l1JBS6jmxrEMpdb9Sam/xf3txuVJKfU0ptU8ptUspNee5iSR3WpWS0KVeLH9UtC5JeLKLEXVjpZQhUGtcu/xxkozlMWWzWYyNjRkrnoMCJR2ttdHiGRcu49HNhS5KG26322SlsuOUrIIJwCRLSR+DzKalbMKHh45ZJjPRmcxtyiYi8lryPIaHhw3BM7poeHh4hiTG1wzZrHbZUqUUtmzZUlKGwk7k83kcOHBgXgTN0Mkf/ehHth1Xa2srBgYGbNu+nVi7di1WrlxZs/3Juk6VICPDtm3bhjvvvNMstwNKKZx55pno7e2t6+xrLpb7twG81bLsJgDbtNarAGwrvgeAPwawqvh3HYBb53IQ1jBH6fwr51SVeruUKYBpK5VOUOrpVsnEGmYoZRSrlEHphY5Wa7lgErTsZGT1EVAyIjjTkDdfWvn8npSUSMicVQBTkQl0SHObsVjMDGC8JryuEry2jHPnoMjty2tf6R5UEy6XC69//eurus1K4MC9f//+eX2P9/F73/ueyeitNjweD1asWFET51+1sXXrVng8npqRWiKRmFc2aDabxcMPP2x7klg4HMbixYsbm9y11g8DGLMsfgeAu4qv7wLwTrH8O3oKvwPQppSaU5cD6bwr7neGHCMtbemspJVLEmbbuvHxcUQiETMLAFBiKXs8HgSDQQQCgRLLm40v+JDy4SERRiIRZDIZsw0ZHsdjkyTPAYezCoZ+yvOjLk85pFy0kHydz+eNE5iSCytZMpSTTmDrH49VzgpkOCjfy0FM7tc646kW+vv7sXHjxpr9IIaGhnDs2LF5W+75fN40crEDSiksXbq0JqUXqgX6t2p5/zjLnO93du/ePe/vzRfBYBDr16+3dR8nw0LLD/RqrY8VXx8HwJJr/QBk7dTDxWXHMAvKaXMyK9OaIGT9Hi1Xki8AjIyMmOgRWq4MUWT2puxwJB2XdILKEgdSP2f4ldS2Kz3Qsholj5WNP1hlkhILBwR2cmJ0i3V2wf8ynr+rq6ukCbgsQyCvESHlLcpgwDTpcxvlBpj5aNTzwVlnnYWOjg5btl0Ox48fx+Tk5IK+a7dVvXr1apO38VpBd3c3tm7dWtN9shvbfDA2Nmaa3dgFpZTJ1agXTrm2jNZaK6Xm/aQrpa7DlHQzo1ynlQwrySjyc4fDYZyOlE8YGQJMxZVrrU2II6dl0pKntCFnED6fD4FAwOj5tFAAlJQZsOrm0nKXCUps/s0MWACmTg2tZ34fgNHp5QDCQUda4cPDw6YVnJRh5PXjNZVELQuASS2e5ytnPNZBtpoEp5TCpk2bauqEOnTo0IKm53Y7CgFgzZo1cLvdVXda24n169ejv7+/plLEiRMn5jUA8vdr96yIz7Os0FprLPQMT1BuKf4fKi4/AmBQrDdQXDYDWuvbtNbnaa3PC4fDXDaDYKxWK2HV2ynJ0NHJ77pcrhKnCy1nGeYnHYYATHw5j8Pv96O7uxuBQAAtLS3o6upCKBQyFRqlVU/yNBe4GCXDrjIul8uEQZaTN6xyFM+Rg0MwGDRlfSnfcBBjVyrq5tTgrdsHYM5NhoXK8FBGFbEWj2xmIi39asHlctU8Npi+mIVg5cqVttaAWbp0aU1qkFcTF154YU0H50KhULHJSiUopbB+/XoMDg6efOVTxPr16+t6Dxdquf8cwAcAfKn4/x6x/G+VUj8CsBVARMg3s0Lq1ZQKSMhSLgEwg1Blyd1YLGYkmFAoVBLDzu/JWuiy/ym3VSgUTN0Zrafi4iml+Hw+dHZ2mhR8KW9Yo0sk4fMYOQBxOinDFGU5YAAzNH2Zrcr3sjYNI3DkMUtnk7TerXo7CVtGGsk6N/I+SUu/WgiFQjWfxr788ssLIne3241rr70WgUDAhqOauk8tLS3o6+ur2ESk0eDxeHDOOefU1GrPZDLzvj4OhwPvfve7EQqFbDqqabS0tKC1tdX2/VTCScldKfVDAG8A0KWUOgzgs5gi9f9QSn0IwCsA/qy4+i8BXAFgH4AEgA/O9UBIFLTEGdMtLXRpiVIGkY0yaG16PB60traaGukyi5RhfDJZyKq5J5NJJBIJ+P3+kpvDmHI2yWYSE7fBaBkZmsWHXUavJJPJEtmIg1kqlSqpYS/rt8ha8sC0hU+yJ+myVr0sICa1eA6ecsCTYaYyYkZW1bSGQ3L9akAphZUrV6K/v78q25srFjL7UGqquNdb3/pWW4nM4/Fgw4YN2L59u237qCYGBwdrmnwGTGUN79u3b17f6enpsf3eET6fD6tWrcKzzz5r+77K4aTkrrW+psJHl5VZVwP46HwPghEI0mEodXdJ8LSEmUVJIqVzkTVgmCJODZ3WsmxhZ40g4QBAMiTZJhIJ9Pb2oquryzhjtdYmwoXWNZ2wUvoAMIM0T5w4gXg8bpKeeG5WsiwUCiUzDg4CvEaUq1jRkm3vOHBwwAGmQy85Q5BWOa+/tSiZLD//ZjMAACAASURBVCgmyxVYz+9UoZTCxo0b4fP5zPHY/ePTWi+oHZrWGpdddpntA5FSCuvWrbN1H9WCUlP5CbUqOUDE4/F5dclSSuGP//iPaxaH73Q6axogYEVDNOsAYCJXgOnEJBKw1fkhBwHKKMwa9fv9huSZ2MSQQTqnpPxSLuIGmJZUWM5gfHwcoVDIOGatzTCsiUtW7TyZTCIajWJoaAiRSMQcu9frLZGGZJSQnKXwPFhAzOPxlMgzTqfT1JuhPJXL5cw6tOJlLQ4OEDLUVEo0JHdrb1c6nqvlUKXzyRoNZCfy+fxJ09bLweFw4MILL6xJmOLq1atNR7JGx6ZNm0oK5tUCMgBhLlBK4XWve13N6vYopWpS9rgSGoLcSZLAzIYZJDa5XFqtfJ1IJOB2u02xL97AiYkJxONxsy9as9bEI9nwg/tmiCLJeWJiwswM5D5k7LckZpIlHZJyEPL5fCYaRWrh8vt0xsrzpS5P6Ymdqzhr8Pl8cLvdJWWO3W63qaEjnbjWAUiSeyKRMANEuZrw1QzT83q9WL9+fU31WgALkpX8fj/OPfdcG46mFEpN9VRtpIbLleD1ek3JgVpCyq1zBUt11Ao9PT0zgixqhYYhd2mxAqVatYxCsYYEApiRZMM6MtFotCQsUMa883sASjRrq0wjiZPkHIvFTAkB+YBZSVM6KKXUxIYXcl2em9ZTbfpI7vJaUP92OBymNo3T6YTf7y9prUeZKJVKIRAImNK9DOW0OlatFjujeYaHh0usfOnMrWa8ezgcxuDgYE3kGGC661elvqmzIRgM2hofLbF48WIsX74czzzzTEPHu/f29tYlplsmJ84VtTYgBgYGykqutUBDkDsw7XC0OiMZNSNDF0l6LNglSd/lciESiZjm2NZwSQCmaqLcjzVlmvKH2+1GOBw20Sc8JinhWC1uqzUsY+f9fj/a29tN2V/ODkg2LNcri6fRSpZx6/Q/cBBraWkxnxUKBVO7nrBeQzkbklo7QyNZ1Gx4eNj0U+VAwgSralkjPT09NdcmU6nUKRWQqgVJeL1erFq1Cjt37rR9XwuFUgptbW01bQ3I5+7ZZ5+dV55COYnXbgwODiIQCCw4We5U0BDkTitXOhe53PqZLKdrJVSXy2XkE2pxVl2aZCmdn7LZtNSygakfWFdXl0np93q9plwBCVZmrkpi57Fxf/wuo2wCgQACgYBJvJKDBn8s0qq2hobK/Y2Pj5t9ANMOVP7J6yaJWeYVyLLG4+PjpnOU1tr4G5LJpInZrxa5L1q0yFyTWqIeU+X5wOl04swzz6zbtH4ukDPFWu/30UcfnZdF7Ha7azbrIgYGBrB06VI8//zzNb+HDUHuhcJU2QAZeSL/JLlR7wamiVM20hgbGzPhhbISI3VuGXXC7zDEkHKH1PaBKSuPZOv3+9HS0mKaY3O2YHWoStLngCWdqNls1oRWJpNJM3WTcfs8D5mAJWUULmdo49jYmCkpzOtqlXx4DDxPOqUoyaTTaSQSCYyMjGBiYsLsa3R01Nyj8fFxBAKBqhVf2rBhQ80tqtHR0QVbU/Ja2o16F586GZRS6OrqKvld1gKHDx/Gb37zm3l9p7u7G2eeeSaA2kRkMcCjo6OjLgN0w5C7DPEDUGIJy5BCZl6SsEnujCaxlgumw5HERQ1cSioyI5YEKkmWyUQOhwPhcBitra3GcUkdmt+TkNmwAMwMIRgMmrh2ZoHymGl5s9qdbJUnW/lJuUdq8qOjo2DGLwcwDnRSPuJ1t4ZAsl59JBIpcaIWCgVEo1EzqJWrh78QOByOmrckU0ohGo0uqC6JDEe1G4y2sCajNRIcDgfWrVtna0/dcti5cyeOHj06L8JctWoV2trabDyqmXA4HOjr6/vDdagy9hpACVFanY3W2i3S0UqtmNtjlikdi4weYWy51tpEqzCWm9tlzZhAIIC2traSWQB151AohEAgYEoVcKCR8o/UyGnhc6CJxWKIx+OmJg6Pm/H5JBDZMs96DPxB8Xyp4dMiZXSMtRYNQfK2hj8yflg6jPmXTCZNeF41CMfpdNbcOj0Vf0E0GsWrr76KJUuWVPmoZoJyWCNXh3S5XLjoootqtj/et8OHD89r5uhwOLBmzRqTC1Kr583hcNSt8UpDkDutWBKfjDkneVv1ZhKdtNopVVhLA5BYaXUxO5UWM1CaIZvP502oYjabxfj4OJRSCIfDZjCgTMR9SSen1dlKHTsajSKRSJis2UwmY2YWSk2VAWY5YRk/L+UlbtOq99MB6/V6zWwgHA4b+UeSOwdOSe4c+OjYJZlLxzCvn5zhnCr8fj+WLl16ytuZL1555ZUFEXw+n593PZNTwcDAAFpbW+eVrFNLtLa21qUZ9Lp16+DxeOZM8A6Ho6RDVK2glMKKFSvqIss0hEmQyWQwMjKCeDxeIhPI+GqgtOuSJNJ0Om26E8myAOUsz2w2a0id26K0IiUhDiIkeLbY4yyjnHNSzjQkpK5tLcDFAUmeK1/LdUmo1j/6C5jYRNKmrMIoH+uxWi12vs5kMqY+jyR16/lUC11dXejt7a35gz86Orpgcj948GD1D6gM6CeqZSTKfEDZqK+vr2aEyf0MDAygpaVlzt+pp9+ir6+vLrOvhiD3XC6Hffv2YXh42Fit1mm/tNjlfwBmUGCYHi1qzgQ4M2CHIurYUrNmf1NKMpKAeYysCUOpBCitZEnC5PGSaKXvQNZsoRxEGYbaPr8v5R36DOh0lcTEGY7f7zdRLGy2zf1z8JL5ADwObj+XyyESicwoUVouvLNaZBwOh0vKDtQKrKA5X2it8eKLL9ZMAw+HwzVP658rtNZYtmxZzQcfPutzrUDJ53337t3mfS1x9tlnz3kgqiYagtwLhQImJiZw6NAh01lIWu7W6BW+JpmmUikTCSMThEjqkUjE1HqXcgkHEemwZGcmVo0kkYdCIfh8PlNsjIRY7kGx+gvkIML3nHHIsgN0knJg4nHKYmp0esrs13Q6bfwC7CjFtoC8ftaaN+XKDDAE0nr8RKXXp4L+/n7bqivOhn379i1YVtqzZ09J1rNd4LPSqP1UablXsxSFHSBvbNu2bUGJa6eKxYsXo7Ozs+b7bQhyp5abSCRw9OjRkjK9MmVeOldllAswLaUwppyFxGRTa5KaHCzoHKRFHYvFkM1mTTQMU/pDoRDC4bBJX5YzBwm5TIZFyu5LjIiRVjnJVkbqWGPuZYgkncSysiPLFXi9Xni9XsTjceNIljKSHEy472w2i2g0WvZ6l/urBpRSWLVq1Yy8BbvBgXWh5/HCCy9g586dNSE0h8OBVatW2b6fhYDkXkvw+ePveq7fKRQKeP755/HAAw/YfIQz0dbWVpcaMw1B7sB05AazSyXZWaUA6ZywZouSqGXYI4CS79OSlX1LW1paTDlfn8+H1tZWdHV1YdGiRRgcHERHR4ep507iZzhmucJm/GPqPxOM2tvbTZw8nb6UiigJ8Thl8hOJXlrxDKWUFS4ZnslY+lgsVlIqQM6IpM7OgbCc3GD1K1QLDofDPPS11ETT6TQOHDiwoHNRSiGRSODee++14chm7gsAlixZ0rCx7vXyBxw6dGjeoazZbBa33XbbgiW5hcLpdNakOYgVDUfu+XweIyMjSKfTJfHnkuApMVCrlgQbj8cxMTExQw4hmZEAKV+wjR5DG2VceTAYRGdnJ1paWhAIBMyAQXLntqUVbw3dpBXO7NSWlhb09PRgcHDQFBUCYAYWNggh8QIwA4psViIllUQigUQiUTKr4ayE5M9zl5Y7v09/BJOm7LDSy8HlcmH16tU1Jy461heyX96bX/ziFxgZGamJ9b5ixYqadjiaK5RSpkVmrR2qe/funXcLQq01Hn74YXzmM58xv5dayUm1bmQCNAi5k3D4PxaLGSvSGo4n35O0KV2wd6pcjz9GEh6tYJKvtIjZDi8UCpnsUa/Xa8L+SNBSEyeBA6WzA2sIIwcDEn1bWxtaWlrMZ7TQW1tb0d7ebmLouV0ZHST3RZJmhyfp+ORxU6O3OlQZkZNMJktq2VTS2qv9Q/B4PDWvKaP1VB33o0ePntJ29u/fj0cffbRKRzU7BgYGGjJixuFwoLW1teaklc/n8cQTTyzou7lcDt/+9rfnnd26UPDarFu3ruYDdEOQO1AakZHL5TAxMYFYLDaj1rkkL5KU0+lENBrF6OhoSUghrXfKLsFgEFpPx6nLrFCScCqVMq3qqF+T5N1uN1paWtDW1mYyNSWkDENiZ6giBxFJ5IFAwDiESa5utxu9vb3o6emZEUkiM3XlNZCRNXSiSuctZ0HyOpPYafVbywHLda2vqwGlFFpbW+vSY5Lx/KdyPplMBvfee29NslW7u7vR1dXVcNIMk/lqaQEDU+VAnnrqqQV9V2uNZDKJr3/964jH4zW7pv39/TUvN9xQ5A5MZ5eyXVwymSyJSpGyB0k8nU5jYmLC1DonUXk8HmOJM4lJfh+YelDGx8fNH6NqtNYm0ob1ahhZY01U4nHwM+kg5IyAzlSGcHHQYR0YDiasb0PSYJEujvpM2pBykMyOzWQyiEajJVFAbBguiZ2hlZSaZvuB2vHj1Vqjo6OjLiFiJ06cqEqVvvvvvx+HDx+uwhFVBnM36qHZngw0QmoNrfUp1TXSWuOJJ57A3r17q3hUs0MqBrXCScldKTWolHpIKfWCUup5pdTfF5d3KKXuV0rtLf5vLy5XSqmvKaX2KaV2KaXm3NJeWuWMniG5S6dgcT+GVGnh0yJj/RZavvyerP6YSqVMtij3KZtgUGdXSmF8fBwjIyMlUTrlkomsZXV5nJwtMMKFg1AqlTJ1XBiuyVBLGapJ8qYuz21SV+cMAYAh99HRUXOs0iqnVCNzCU5G7Hahv7+/LnKDbGSyUCilcPz4cTz44IO2+yfcbndd6qWfDD09PcY4qfWs4lS7KSUSCfz85z8/6fN/quB2W1paam7IzMVyzwH4uNZ6HYA/AvBRpdQ6ADcB2Ka1XgVgW/E9APwxgFXFv+sA3DqXA5G6upRnWCrA2miDFijrjnMAoK5OC5gESPKTso3UpaXjk80y6HBk423pyKX0YtXYpUNTOjAplfB7DofDhCxyqjgxMWEIngOG/NFQ1mGyFvfLmYDU3zlgUH7hucv1ZNw/r2k5Z6pdD/+qVavq4ijcv3//KZ8Pn4///M//rFp1zEpQqrQNYSPA4XBgxYoVJqy31vs+1f0WCgV8+9vfxssvv1ylo5odsuJtrXBSctdaH9NaP1V8PQlgN4B+AO8AcFdxtbsAvLP4+h0AvqOn8DsAbUqpvpPsw/yXf9KCp7VFMiJhjo2NIZFImKw11keXJEzL2RoLLiNQ8vk8PB4PWlpa4PF4TENtZr+mUimMjo6awlmyQqOVKKyx7lY5iBa01+s1ETKy0TdlFBIfz5UzC/oB2GZPlh1gzHo2m8XExIQheyltSed0pXtQC6xevbom+yF4XkeOHKlKXRytNbZv326629v5w92wYUPNy+rOBqfTicsvv7xivoed8Hq9p9ygXGuNQ4cO4fbbb69JtrHP56t5Mtq8NHel1DIAGwE8DqBXa32s+NFxAPSM9QOQlZUOF5dZt3WdUuoJpdQTvLjlojKkrCHj1pmdyegYNs+gRcX1ZPkAbkNKHzJMMRQKwe/3GymDlr81rt5aIkCW3ZXHzf8yLFI6XVkbvq2tzYzq0lHMsrSUUHhuwHSnqLa2NtPZidKS1NTHx8eNRsljkhKNRDlr3S6yd7vdWLduXdW3OxdUK86ZkTd33313VQaL2fazZMmSmjeamA0ulwt9fbPabLahGoMJjccf/vCH2L9/fxWOqjx4rB6PBxdeeKFt+ymHOZO7UioE4KcA/i+tdVR+pqd+/fNiAK31bVrr87TW51m7BhX3NyOGXEbB8IdFqYEaNafIbD8Xj8eNri5rqVCOoTzhcDhMchEHDtZxkVY6M02pdTNpqNzxSmcn1+dySizhcBjd3d1mYOHAQRnI5XKhUCgY3wOAkkJhHBRk7RjKV/n8VJMNJnVZWwvK/IDiPamZ5d7S0oJly5bV1Orj4Fntqfh//dd/YWhoyNbr19bWVpfqmZXQ2dlZ85kXkcvlEI1GT77iHHD8+HF89atfrVhKpBrgM7569epT9hXMB3Mid6WUG1PE/n2t9X8WF5+g3FL8P1RcfgSAdO0PFJfNClnzxVoczBqdQkkhHo8bB6ksqMVEJibmyMgZqXvLjk0kUZKgy+Uy4ZOSmEnKsnuTLEJWztFKK9ta+51O346ODrS1tZl1rBUfZagjJRoSvLTmSfbS+qaDNZvNlvgM+CchH+5ys6hqoru7u+Yx7gBMWYpq4sCBA7jnnntsHRT9fj82bNhg2/bnA6UU1q5dW7eZhMvlQmtra1W2lcvl8IMf/MDkLNh5D5csWdJY5K6mGOAOALu11v8iPvo5gA8UX38AwD1i+fuLUTN/BCAi5JuyqGS1W8P9ABiHIC1r6Uh1uVwlCVC05DkYMOFJhii63W7TH1T2WPX5fPB6vSXFvGSyEwlekrv1mEn4JOJgMGgyYWVYpN/vN01BMplMSYleJlpJeYit8ORMBEBJEhYrYmazWYyMjJjrMFvpUQ4edhO7Ugrr16+veaSMLkZJHTs26+M4b+Tzefz4xz82+RF24dxzz20Yp+qqVatK6h7VGtUsoRuNRvHpT3/aFBWzY/bFkNZaOqDncoVeB+AvAFyqlNpZ/LsCwJcAvFkptRfAm4rvAeCXAF4GsA/A7QD+Zq4HI52OUqOWTSlIcJQpqIuzCiItVKkvU36RIYWBQADt7e3o7Ow03dtJ2FprU5ogGAyaMgQdHR3GyWk9Pu7PGutOcudyOkRZw4Y9T8PhcEkSFY+b58Pj4vY4NaWzmQ5n6SyWBcEYUSQHJPk3W3RMtR90h8OBSy+9tG7kUO3zKRQK2LFjB5566ilbyJcD+/nnn49AIFCX2uASTqcTW7ZsqftxVBOPP/44br/9dlt9J729vTWdrZ7016W1/i2ASk/sZWXW1wA+Ot8DKfeDs4YVSuJkj1ES+/j4uCE3ts8jZPkBFgqThMtts5pkOByGx+MxTlqn02niVJlubSXDcscuz0FmrLISJZ2qnHUsXrwY6XQaIyMj5ocjm2ST4AnGzpPQ6TTlrIPSUyqVwtjYGPr7+43MI49tPvfkVKGUQigUwoUXXlhzK1QpVVKjv5pIJBL4wQ9+gIsuusg20luyZAmWLFmCF1980ZbtzxVKKVOmuR4zCTajqfY277zzTrz73e/GypUrq7ptoqOjAytXrsSBAwds2b4VDTX00monylnvXC+RSBh5ZmhoyEgQMtxPvgamCoHRaUmSpRbPcgJMLopGoygUCujs7ER7e7shSxYX40xCWsLU5q3HC8BIOxw0KM1QuvH5fOju7kZ/fz/a29vNdrg/qcWzyYfMSpUNNrh/TgGz2axpwkHfBNeTRM9ry//Sz1FNrFmzpm5lbIeHh22pCqi1xkMPPYSRkZGqb5toaWnBhg0b6i7N+Hy+urTWIzKZDIaHh6u6zUKhgL179+LWW2+1zXr3eDy44IILbNl2OTQMuUsisVrsErTUaYFNTEwgnU6XWOtW6YGyB6NcgOmEHmr4sVjMRN+wnjsAs22m6jPU0JotWy7eVx4/m2Ink0kjpVD+IXEzzn7RokXo7OyE1+stmbE4HI6SEE8SOv0IrO/Oz5VSxm+QSCQQiUSgtTbbne1e2Bk1c8EFF9SlQQcwLdPZgcOHD2PXrl22ka/T6cTGjRvrTu6dnZ117Q7FAAo7tvuzn/0Mhw4dqvq2iYsvvthExNmNhiJ3aTWWc6rKZhVMYCLRyvooXNfhcBhdm9YqHZBsqccsV8o6/D4zU1mmgMQswzGBytNSaREzokW2tGO4ZTabNcfn8/nMLIGzCXaYku0BpWOUAw71eQ5CHKR4LbLZrCmsJkM3CZnYJAuSVZvgXS4XLr744roRlF3EAEzdi0ceecRWp+qWLVvqkhUKTOd1rF27Fu3t7XU5BqC6PXytOHToELZt22bb83nuuedi5cqVNfFXNBy5z/bDYAQI67HQScg/WSsmGAyabFNCOlUp7ZC0aeUyeoWZnXRaMnJFhlJaZxflHME8N6vuznV4PpxRUKJhsTHq8sympSxDfV1m4FqTnzjL4DVgeQM5UMrrby35awdJdXV1YePGjVXf7lxx9OhR28oFKKVw33332dqCb+3atejq6rJt+7OBz8Mb3/jGutaXj0ajVYtzt6JQKODRRx+1bXbX3t6OSy65pCbGTUOQu9R3ZyMYWqCUUGQ4pGw2TTKkBi7TtoPBIPL5vCkvwBrotJ7prJXHBUw9UEws4mfAzL6u5c6Ln8kSwCR4WcxMdmXiZ/QP0F8AwFjvtOBlDRrOCCKRSEkbMpZUGBsbQy6XMz9OeX1ljXi7wsHOOecc9Pf3181yj0QitpF7oVDAvn37cOTIEdus987OTpxxxhm2bHsu8Hg82Lx5c932D0wl+CWTSVu2rbXG//zP/1Q9XBaYNv4uvfTSPyzLvVy9E0LKNLlcDmNjY0gmk6YGiyy5yzotUlNnMwpavdZBQcacAyhpnC3DMK1EaiV2a0x+JXKXFSRJ9HIb0kr3+/1wuVxmlsEwSlnygNExtOBls2tKSSyGxnIEckZTLrb9ZLLTQuBwOHD55ZebY6kH7PQlaD1VT/+5556zZfvAVF2VdevW1WVwVEqhu7sba9euPWmklZ0YGxubc//UheDo0aP4/e9/b1u02Jo1a2pSJ6hhyL1cnLV8gNhvNJFIlNRup05O65YOV2rOTqcTgUDAkLyslFgoFOByuUqaVrDnKEMGaU1zBiCjVgjre6DUKUzNXVafJMHToUvZh5azw+FAIpEw0pO8Hh6PB8FgsCR2Xko9vCYMEZX7ZoIXwyvl9ZYzJ+s9qQYCgQC2bt1ate01IrLZLH73u9/ZRgyMd68HsWqtcc4559RNFiJGR0fn3WJvruDvZt++feZ9tbF48eKaNKlpCHKX5FJJknE4pkr4jo+PIxqNljTBptRB/VoSP3uM0sLnfpgcBMBEsDBM0FrITHZQkkROQpbFwypp8dwvj4GkTGKWGjjJ3OFwGKer7KRUKBRKKkryvOV/nkMqlTLF1XiuTACTNX3KXftqP9jLly83Vme9Iz7sxM6dO0+509NsOPPMM+tSIdLhcGDr1q111du1nqopZWeyEQBs3769JLy4mmhpacGKFSts2bZEQ5A7UNr+zar9kkwTiYTRvlk3BgBCoZAhclkRkVmrlG8AlMwEZBMQ7sNaUoDlCVjLQu7DWhu+nKxkTcCyWsiMmZc9VmWdmnQ6jXg8Xtav0Nraira2NgAwDmA6WxkqKRtoc1CLRqMl8e7ltHY79PaLL764Lp2Xao3nnnsOJ06cqPp2eU+WLl2K3t7emg+Qra2teNOb3lT3gXloaMh2cn/44Yexa9cuW7btdDprMvtpCHKXpC4Jhu9ZzjYSiSAWiyGdTiOVSpVkbdIqJhkmk0kT6ULilw5Krg9MEY/b7TbE6PV60dLSgnA4bCJumJnKdWXTa2tSULnoGUa/sEYN6+FQUrL2VpV13pPJpLHeOSDJvqiUnWS/WV5Pfm98fNzkBjD6R6nSEsN2krvH48Fb3vKWuhNDLTA+Pm5rrHQ4HMby5ctt2345KKVw3nnn4eyzz67pfsthz549tvtsIpGIbbXeHQ4H2trabP8tNAS5A9MNKawkD0yXah0eHjbkzgJbtKAdDgeSyaTpu8qsTYZJyogURktQZiFBM4moq6vLECadnawBw0xWEja/K2vflPuTJM7aL5wlyAbdLI8QDAZNuz+WReAgxu5UsoBYKBSC1+s114/XkscUj8eNv4GEL60fa4x7tdHR0dEQxFALFAoFWzNVXS4XzjzzzJrWdlFqqhtUvWLsiVwuV5Pep1prPPjggxgdHbVl+7VIAmsIcpdWuiQmaV3G43ET/ZHNZuF2u412TKKbnJwsSeCRjkgAJcsAlJQUaGtrQ2dnp+kJCcBUYyT50qlLGWc+jkeZGCT1dmC69g2AkoHA6XQiFAqhq6vL1KChc5Z+BRJ8IpEwDl8eK2cZXH9oaMjMTqwzJNlL0g7LfcOGDejr6/uDsNzz+bwtDSCksVDrWuperxdXXHFF2UzsWkFrjWPHjtnaXEPu68iRI3j66adtkShrkQTWEOQOTPc2lZY7k45YZoBkTlJm9qhsoi23R4KkFCFJjLp2OBxGOBw2ljrJnNKJrBHD9nbMbrU+5DJxScoz8risNWi4ndk0RIZLSh2dAxrJnY5Xhk5aWxJms1lMTk6WRN8AKCF3u2QZpRQuueSSujri5LHYDa21bRYfMHUOvb29NbPclVJYsmQJ1q9fX5P9zYbf/OY3OHr0aE32lcvl8PTTT9uy7eXLl9t+/xqG3KXVLq14hvaxfykdrJRd4vG4ITxpCQMo6dBEjbpQmKrP3traauLJOQCQZCORCMbGxsxfLBYDMKVtd3R0GEu+nAwDzNTeuV8SMbNLKRXJOvHy/Amp3fPc6CjlTIaEzYxUNt/mIEnyZ0E0q9XOwdEOScbn89W0YFIlaK2Nr8bu/Zw4ccJWXXjZsmU1bbi8atWqqjXIOBXs2bPH1q5JBH8b99xzjy0Zx52dnbYbOw1B7lbrUcoyJDrGtjM7k4RE/VmGRNIypz5tbdzh9/tLinKR6CYnJ0va8vGPYZVMQCKkpS4hdXZKRLL4WCqVMoONtVYNCd4q1Ugrn9uiDEVLnr4ErbWx4LlvngMHF+nQtdtqpwOwESSZvXv31i2Bqppob29HIBCoybkwtr4eMy/5TGazWbzwwgs13f+ePXuwb9++qv8mzjjjDNt70DYEuQPTsowMMaS+TCKT0g1vNhtVsLYKnZzWQYJ6N4ndOgug7ENrnNKP1+tFa2urcXSSEGVMe7nYdoLkafUryAqOPH9Zu53HzNckd5/PB621GRwoSZHgtRZmXQAAGqhJREFUuU/2egWmm4Pz+sZiMZOBW06SqXaY2cDAQN0TXwhW43ytg+ReCyilsGzZsprsazbs27cPO3furOk+JycnsX379qptj7+xtrY2rFu3zlZppiHJXVZQJIHJCA8SfiqVKqllzgtFcqdmzqQf6uUkO6bpyyQfIpPJwOfzobW1FcFg0IQnysxSWYpXEr21cJjVKuY5UFKSDk5ZyVEOGpyVkOB5zSj3WAccykx+v79k36yCScu9nDO1mlBqqt/mfImoXEKV9Tzi8XhJ8bjZBiV+56WXXjotyD0YDNash6lSqiTQoFaQfqFXXnkFH//4xzE0NHSSb1UXhUIBDz/8cNUNHqfTaXv02Ek7MSmlfAAeBuAtrn+31vqzSqnlAH4EoBPAkwD+QmudUUp5AXwHwGYAowDeq7U+ONs+KkXLSK0amLZAZe12kh9JkZo65RPKNeyixP6isjgXNViZZer3+02se1tbmynFyzh5oLTswGzaO89RyjWFQsHEpXOgkWWLGVFDQgdgBrFgMIhkMlnSs5NWPvfLwVCWGOC+KdEQ5bJTq4lNmzYtyEKRyWWpVAojIyN46aWXsGvXLuzcuRMvvvgiMpkMli5dCrfbjRUrViAcDsPhcGD58uWGkGh5hkKhmjnj7AabzNQCWutTCu0s9zzJKDYOvMC0wZJKpTA+Po4TJ07gsccew7e//W08//zzdRmYDx06hEQigVAoVFVpcfXq1bZKlXNpYpkGcKnWOqaUcgP4rVLqVwA+BuBftdY/Ukp9E8CHANxa/D+utT5DKXU1gC8DeO/JdiKtWvmaJAjAVHNMJpMzEp7opCQx0oJtb29Hd3c32tvb0dLSYopukTCZsMTvMa1fWsokdMb4SusRKI3AmI0crQ8z/3P2QWnFGtXDomAej8d8zh6pvDaMnZdljXmN2IJPapesu8PjsQsej2fBURZKKYyOjuKBBx7AXXfdhaeffhqRSMRIdzzuZ555ZkZOAb9Pi4s9au0qFbtQyGNtZMyn85H1edJ6qmDdjh07sH//fhw7dgyjo6Po6emB1+vFsWPHcPToUWSzWcTjcSQSCYyOjpoCYZRQ60HsWms8++yz+P73v48Pf/jDJQaUdT2JSvdTLmc/XLvq08+lh6oGECu+dRf/NIBLAVxbXH4XgM9hitzfUXwNAHcD+H+VUkqf5M5YJQsreQMwtcrlchn7DUyRSaFQQCAQwMDAAHp7e40+KXuLytrslDlYO10W4pKVG/kZMC0BcVAgrDdVTud4fnSW0sKWTk/ZZYr7dLlcCAQCxlKnXu7z+RCPx6HUVDExDhDU5xnO6XQ6jRzFY5VSjPU+VBMOhwMDAwPz+o7WU6GEd999N+644w7s2rVr1jK9c/nhs7N9LWAd7OcCack2GvL5PI4cOTKv79BwefLJJ/GLX/wC99xzD/bu3Tuj5o4cjBsVsVgM/+f//B+88sorePvb3441a9YgHA6Xjbqaz320O2dgTu3nlVJOTEkvZwD4NwD7AUxordlp+DCA/uLrfgCvAoDWOqeUimBKuhmxbPM6ANfxvSQ+KdGQHOlEjEQiJU01WHeF3/V4POjo6MCSJUswMDCAzs5OtLS0mEgTmeBDBywdpdJKl1mnJEcSptVxytflmnQAMDMFOvOk05h6sVxfJjBRAuL3WCuH36H2fPz4cRPPLjs88VxklqvU5Lltu35gciCtBKul/cQTT+Dmm2/GI488UtIX97WERCKBnTt3YnJyEgcOHMDk5CSGh4dx8OBBY6mFw2FT/nXdunVYt24d2tvba5p5OlfMRXOW92loaAhf//rX8a1vfctkRpcj8tfKvZ2YmMA//dM/4Rvf+Ab6+/uxdu1arFmzBmvXrsXy5cuxdOlS9PX1le2TAJS35O0e2OZE7lrrPIBzlVJtAP4LwCl3x9Va3wbgNgBwOBy6uKzEYpfkThJjhAmJmCVsgSktesmSJRgcHMTg4CDC4bCp1c5m1DL8kZo7I2z4WhI7CZ0kKbVzK8GTxOToTamH5Cx9BiwjzAHDWjSMpCtj2Bn+ybBQOkjb29sxNjaGiYkJjI6OmobYzISVdeMBlAwodurtXV1ds0bKyP3FYjF897vfxS233IJjx45V3YlVK2it8d///d/49a9/bQbik51LIBDAkiVLcNFFF+Etb3kLLrroIixatKghrHmlFDo6Oua0rtYaL7zwAq677jrs2LHDPGf87LUK3j92gdq9ezcAGI7o7OzE2972NrznPe/B6173OtNYZzYMDg7C4/HYVr54TuROaK0nlFIPAbgAQJtSylW03gcAcN52BMAggMNKKReAMKYcq7Ntt+TPKrvQuqXlS4KU06L29nZjrQ8ODqKtrQ2BQMAk81B+sUahyJK9MnO0HNnLwUHuWxK7hIxy4XuGVjI0EYAZPHiu0qqXUhWXZTIZEwKZSqXMQOf3+xEKhRAKhTA+Po7jx48b/wTPX9Z6l6WN7SJ3a25AJRw6dAif/vSn8ZOf/MTWRgy1wny7BSUSCezZswcvvfQSvvOd72DTpk249dZbcfbZZ5cNsa0l5hIKSePj3nvvxY033mjqoZ/uYMDH0aNHcccdd+D73/8+/uRP/gSf+MQncNZZZ5XNZCcoEduFuUTLdAPIFondD+DNmHKSPgTgTzEVMfMBAPcUv/Lz4vvHip8/eDK9HSgNe5J/tE6tJQbS6bSRZtrb29HT04OBgQEMDAwgHA6btnQkPmmByzBGaSlL4rda0fK/NTJGRsdYz4ezAzlY+f3+ksFAOmgluVv/qM9zFsGSCrLDk3WwGh4eNiWPZWExDpQygcquDNWT4cknn8R1112HnTt3vqatu1OFDA54/PHHcdVVV+G2227DpZdeCqB+TleXy4UlS5aU/Yz3K5FI4I477sBnPvMZRKPRP8j7WCgUkEgk8JOf/AQPPvggPv7xj+Ov//qvEQ6HK65v5+x0LpZ7H4C7irq7A8B/aK3vVUq9AOBHSqkvAngawB3F9e8A8F2l1D4AYwCunuvBWC13LmPEDEkOmCb3ZcuWwefzob29HQMDA8Z5KmvAkOBlY4xKhC5fy7h1a1w7YbWqpN4uCZ6WvtTs5bmygqM1AYuzlnw+X0Li/IvH4yV1dORgwmNlM3GWPOZ25XHXQwLRWuOpp57CBz/4QezevfsPkhAqQWuNAwcO4LrrrsPtt9+ON77xjQDqQ/BdXV0466yzyn6mtcbjjz+Of/mXf8EvfvEL23qbvpag9VTo6Oc+9zk899xz+OIXv4ilS5fOkGwPHTpkWz9fYG7RMrsAzGhXr7V+GcD5ZZanALxnvgcif9iSFJmwZI2aUUoZa72trQ2hUAgdHR0IhUIlOjNL7HKZlF+ks0+Se7n4deu65ax1ayieXCZlHWB61Jb1ZUjyMllLfp8Eb23TR3mG26Xkw2tGUs9kMnC73YjH4zMGUP63m2Dl9p966in85V/+JZ5//nlb9/laxiuvvIK/+qu/wl133YVLLrnELOcMsBZYvHixaQojobXGr371K3zkIx/B8ePHm4OzBel0Gj/84Q8RiURw5513Gt8TCT4SidhqVDWMW96qudOSpQNRRo1ordHV1YX+/n50dXVhYGAAfX196OjoQEtLS0nYI+O/+ZqRNlKioS4ul5XLQi0nx1g/txImMK29c5CR+5Lx9FarnKQsByrZ1IOJVqFQyMxW/H4/gsEgQqGQkadaW1vR29trom9qESVzMuzduxcf+tCH8MILL9T1OBodhUIBhw4dwqc+9SkMDQ2VGD61qtJ4xhlnmFpMhNYa+/fvxyc+8Qnbi6S9llEoFHDffffhpptuwuTkJICFhcouBA1H7sC0VcvQOFqljNvu6urC8uXLTQ321tZWdHR0IBgMGiKUpC4Jlf+tLe3Ktbizkne5UgMAZpC9fC2JWn7fOoOwri+1cykhyfe8VvRF8Lxlow+WTuAgKLdRyZFtN8bHx/Gxj30Mzz77bJMU5oinnnoK3/jGN0oSXmpVEqCvr69EitRaI5FI4MYbbzxtyjnYiVwuh+9973v46le/OiMb3E6ZreHI3RotQ72dqehMTurs7CzJOiWJMyZd/kmL3GpxSx3bKtVYCV1KK1ZZxrpMavck63IROpUGlnLLpezDhCdrqV7OWkjw4XAYXV1dphaJlK2sZG6HBW19eLPZLL70pS/hvvvuq5sD97WIXC6Hb3zjG3jsscdsJwUrysk/P/vZz/DrX/+6JFO4ifLg7/X2228vkSCPHDnyh2W5l7MiU6kU8vk8vF4vFi9ejJ6eHrS3t6O9vd10H5It7KyELgnWSpzlCoFJAq4U4mh1pFYaia0ROXJ5pT/rgGM9VqmrEzJen/JNMBhEb28vwuGwObZFixYZcre7+xIwlfwRiUTMPf3BD36Ab37zm7alXJ+uKBQKGB0dxS233ILJycm6ECqfkUOHDuErX/lK03k6Txw9ehQ333wzhoeHkclksGPHDlv3N684dzth1arpaGAyTzabRWdnJ3p6etDR0WGKgLEPaqXQRilxWEnbupwo5zS1Si7yWK2oFBopE6is6zocjpJztg4S/I6MfWfyAzV9j8dT4rPgzIGRRblcDj09PThx4oSpGy/Xt8O5E4vFTLODoaEhfOUrXzHaYxPzg9YajzzyCO677z786Z/+ac2sdyaUORxT5bH/4R/+Ac8++2xN9n06QWuN++67D7fccgu2bNmC+++/v+6hkDVBOctR6+lKh263G11dXVi0aJGp0shwRz7kVktcWrwnI3YrkZd7X85itx4vvwNME3a56Jly1rI18oYDQqXvU5Kh1e73+2e0K8zlcuYzVrbr6+szvWat9XuqjUKhYOq6bNu2rSbNjU9npNNp3H777XjrW9+KgwcPzng+7MCuXbuQTCbh9/vxrW99C9/97nebktoCQXnN5XIZX6JdaBhyt9aTIfFIhyRJnT1PqbFLIqY0YY10sSYiWa3w2Qi8nCXO95XI2fq+3IBgnQHI/TBOXYZLWjV7RhMxzl3WugdgpBdmr+bzebjdbgwMDODw4cOIxWLGcrcroSKTyWDv3r3YtGkT7rrrLttSrf9QoLXG7373O2zbtg2PP/54TQh2//79eOCBB3Dw4EHccsstpkpjE/ODnH3Lsgx2oaHI3RoxwyqGgUAAgUDAJCgFg0FTFgCAkR9IftI5Wul/pdDGSpY7MRuBW5dLQpaQEg3P1fo5Q0H53joY0XHMh4Tnz0Exm82WRAix9nculzMlCljQyW4rLJvN4qmnnsLvf/972/bxhwKtNWKxGD71qU/h1Vdfrck+Jycn8f73v99ULG3itYGGIXcAJRqwJLjOzk7THk92VCrnfCRI+HONV69ksZ+Krmm1yOV76XyVJM7/1OatFjvf85xlpyV53kyAkvVk5DXlOuUqcFYTSik899xzeOqpp+rmCDydwOv34osv1myf+Xy+6Sd5DaKhyF02qSARAUB3d7dJAmK9GCZVUIqxhjtKWB2iVoK3xqvztXUbp4JyEk45sq8U5mYdfORABsCUFGC0DEnc4ZiqWsdKlC6Xq0STr4Xlvn///j/4ujFNNFFrNBS5S6KRpX+ZWenz+eDz+WYkIpVLBrJa6VZZA5hJ5qdqqVeCVUO3Lre+JiTRW613xrgD05IMv+90Os3gJ9uXyf3Sapdx8naQr9YaDz300GnTmLqJJl4raBhyt4bkyfeyRgwdpgzNKkfis72fq+VeLczmdJXkXY7Yre+Zwco6M7xOlFlYOVJrbWL9k8mkGQDlQGKVZOwk3kQiYcug2UQTTVRGwyQxAdMEL7Vn9vqklmzVoq3EOVvZgNks93Kx5aeKchJPudmCNXlLhjFSpuJ3KE/JrFfOCNgMBIApuSD9EkD5qCQ7QyGt+QtNNNFEbdAwljtQvuQvk3akY5R1Z6Rjkdb9XJ2m1nUAe8qpltPT5X95zlZL2upgpqTjcrkQDAZNVIzT6SxpR0c/hKxVwzZ/SilTG5+DRzNmuYkmTj80JLnLP5KPTEaSoYSV4tWtFjuAivKM3ZhtH5WSmawDgIxmYWijw+EwjThohZcrtRAMBpFMJk1cPEsXSMdqE000cXqhocgdKI13l1YrtWYuk6GP1lDAufxJzIfgT7ZuOX29klVsPWb5HVmmQP7nrIX12eUMhvq7x+MBMO1o5XpMcLJ2fGpa7U00cfqhoci9khULwBS7ItFL8qsUw15JnpF1ZGoFSfRWy5yfW8MgrQOR1d8gfRE+nw+BQADZbNZIWZSztNZIp9MlJG+NbZ8PwTedo0000fiYM7mrqTZ7TwA4orX+E6XUckz1T+0E8CSAv9BaZ5RSXgDfAbAZU42x36u1PjjX/ciQPSsB+Xw+IzVYjq2iHFPJarcjMobbJaxJTNbls31fKWWsdJm8JMMpA4GAiRySerzsN8vv0mcBoETDlzOkJppo4vTBfEzYvwewW7z/MoB/1VqfAWAcwIeKyz8EYLy4/F+L650UJDXpUOQfLU5WPpTkXikixqqzlyP7ekBa8FaSLzdAAaXnKOvVyw5OUqKiNU/kcrkZJYStjtr5WO5NGaeJJhofcyJ3pdQAgLcB+P+K7xWASwHcXVzlLgDvLL5+R/E9ip9fpubBpFZrkv/ZR1VamLNJMeVCH8X5mP+VPp+LVj9fWPdbbrtW2Wi22YiMhpHdpqzlDACYfAGJWsS4N9FEE/XBXC33rwL4JAAyayeACa01S5sdBtBffN0P4FUAKH4eKa5fAqXUdUqpJ5RST8jl5UIClVJIpVJIJBKmA5GVwCX5naziY70x27HNNlhZvy+Tmric10HOfOhsreRzaJJ7E02cfjgpuSul/gTAkNb6yWruWGt9m9b6PK31eWJfFRN6gKlMx3Q6bbRooLz1PhetfTaL3U7I45hLJu1sVru1wiUjX6w9UinTOBwOkwDV7ITURBOnN+biUH0dgCuVUlcA8AFoBfD/AGhTSrmK1vkAgCPF9Y8AGARwWCnlAhDGlGN1TiiX2EOCIslLguT/SkRe7n+9YA1t5LFa681I/wOJWzpHucwaXWMtoyCjieS1kSGUTTTRxOmJk1ruWutPaa0HtNbLAFwN4EGt9Z8DeAjAnxZX+wCAe4qvf158j+LnD+o5zPulg1H+LxcWWY7IK2nsc5FjakF0Vj+CPLfZnL7l9HWZfCWPvdxlltvM5XIlbe+aBN9EE6cvTiXg+0YAH1NK7cOUpn5HcfkdADqLyz8G4Kb5bthKgkD5phlzIcVylnytUS4py3puJ4vVpwxjrQBZaSCQ27L2iZUZrLXK0m2iiSZqi3klMWmt/wfA/xRfvwzg/DLrpAC851QPTGrKJDVWhJRhfdYQv0qNOeqRuFQO1gFKvrbKMWydJy1zqaPznKxVHwGY77IFH6+frMNjDaNcyDk00UQTjQnVCJESSqlJAHvqfRxVRheAkXofRBXRPJ/Gxul2PsDpd052nM9SrXV3uQ8apfzAHhk1czpAKfXE6XROzfNpbJxu5wOcfudU6/NpDK2iiSaaaKKJqqJJ7k000UQTpyEahdxvq/cB2IDT7Zya59PYON3OBzj9zqmm59MQDtUmmmiiiSaqi0ax3Jtoookmmqgi6k7uSqm3KqX2KKX2KaXmnfBUDyilBpVSDymlXlBKPa+U+vvi8g6l1P1Kqb3F/+3F5Uop9bXiOe5SSm2q7xmUh1LKqZR6Wil1b/H9cqXU48Xj/rFSylNc7i2+31f8fFk9j7sclFJtSqm7lVIvKqV2K6UuOA3uz/9dfN6eU0r9UCnley3dI6XUnUqpIaXUc2LZvO+JUuoDxfX3KqU+UG5ftUKFc/qn4nO3Syn1X0qpNvHZp4rntEcpdblYXn0elIkxtf4D4ASwH8AKAB4AzwBYV89jmuNx9wHYVHzdAuAlAOsA/COAm4rLbwLw5eLrKwD8CoAC8EcAHq/3OVQ4r48B+AGAe4vv/wPA1cXX3wRwQ/H13wD4ZvH11QB+XO9jL3MudwH4cPG1B0Dba/n+YKra6gEAfnFv/vK1dI8AXAxgE4DnxLJ53RMAHQBeLv5vL75ub7BzegsAV/H1l8U5rStynBfA8iL3Oe3iwXrf7AsA3CfefwrAp+r9EC7gPO4B8GZMJWL1FZf1YSp+HwC+BeAasb5Zr1H+MFX8bRum6vTfW/xRjYiH1NwrAPcBuKD42lVcT9X7HMS5hItEqCzLX8v3h6W0O4rX/F4Al7/W7hGAZRYinNc9AXANgG+J5SXrNcI5WT57F4DvF1+X8BvvkV08WG9ZxtR+L0LWhX9NoDjd3QjgcQC9Wutj/397Z88aVRCF4eeAXxgbbSR2CQRbBYsUFqISYhBtBUH8+AP2W9mLnWghWEiwUIOkE/QH+AWi4geuKDFiNJWCNhGOxZyLlyUYN+zu7FzeBy7snblw5+x7eS8zc/ZsdC0BO+NzCXH2vGZ/RsaAZeB6LDNdM7MRCtbH3T8DF4EF4AvpO39KuRpVdKvJ0GvVwVnSDAQGHFNucy8aM9sG3AHOu/uPep+nV3ARqUjWp5r9GdlAmipfcfe9wE86CtiVpA9ArEUfJ724dgEjwHTWQfWY0jRZCzNrAb+B2Rz3z23uVe33inpd+KHGzDaSjH3W3eei+auZjUb/KPAt2oc9zqpm/0fSn54fpFazP65ZrWY/to6a/QNgEVh094dxfptk9qXqA3AY+ODuy+6+AsyRdCtVo4puNSlBK8zsNHAUOBkvLRhwTLnN/TEwETv+m0gbP/OZx7QmZmak0sav3f1Sratey76zxv2pyACYBL7XpqLZ8QHV7B8U7r4EfDKz3dF0CHhFofoEC8CkmW2N56+KqUiNanSryT1gysy2x2xmKtqGBjObJi1xHnP3X7WueeBEZDKNARPAI/rlgzk3IuJZmyFlm7wHWrnH859j3k+aPj4HnsUxQ1rTfAC8A+4DO+J6Ay5HjC+Afblj+EdsB/ibLTMeD18buAVsjvYtcd6O/vHc414ljj3Ak9DoLimzomh9gAvAG+AlcIOUdVGMRsBN0n7BCml2dW49mpDWsdtxnBnCmNqkNfTKG67Wrm9FTG+BI7X2nvugfqEqhBANJPeyjBBCiD4gcxdCiAYicxdCiAYicxdCiAYicxdCiAYicxdCiAYicxdCiAYicxdCiAbyB7JPqd8GlFmjAAAAAElFTkSuQmCC\n"},"metadata":{"needs_background":"light"}}],"source":["import cv2\n","import matplotlib.pyplot as plt\n","\n","x=cv2.imread(\"img.jpeg\")\n","x=cv2.cvtColor(x, cv2.COLOR_RGB2BGR)\n","plt.imshow(x)"]},{"cell_type":"code","source":[],"metadata":{"id":"K3wXFr-2kq_E"},"execution_count":null,"outputs":[]}],"metadata":{"accelerator":"GPU","colab":{"collapsed_sections":[],"provenance":[],"mount_file_id":"1HjwZKqxyrbknGk8byG5rdRWfuQwaLJQa","authorship_tag":"ABX9TyNi5QZRq7FxNvVTpow/z8Py"},"gpuClass":"standard","kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}