Upload 3 files

Face Detection Model.ipynb

@@ -0,0 +1,238 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f8d9c166-c713-4e3e-900b-df2d6c6df3b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:TensorFlow GPU support is not available on native Windows for TensorFlow >= 2.11. Even if CUDA/cuDNN are installed, GPU will not be used. Please use WSL2 or the TensorFlow-DirectML plugin.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Sequential name=sequential, built=True>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from tensorflow.keras.models import load_model\n",
+    "\n",
+    "model=load_model(\"Face_Detection_Model.h5\")\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "92f623a0-76d0-463e-a7d8-4783296ef2e4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tensorflow.keras.preprocessing import image\n",
+    "import numpy as np\n",
+    "\n",
+    "test_image = image.load_img(\n",
+    "    r\"C:\\Users\\abhis\\Desktop\\Deep Learning\\Deep Learning Project\\Face Detection Project\\images\\train\\Face\\00af34930b6f21da.jpg\",\n",
+    "    target_size=(128,128))\n",
+    "\n",
+    "test_image = image.img_to_array(test_image)\n",
+    "test_image = np.expand_dims(test_image, axis=0)\n",
+    "test_image = test_image / 255.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6df15bba-8afd-479f-9e56-8abffffe46b5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 4s/step\n",
+      "[[0.12947011]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "pred = model.predict(test_image)\n",
+    "print(pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "031710e6-077c-482d-aa39-9412ab838578",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Face Detected\n"
+     ]
+    }
+   ],
+   "source": [
+    "if pred [0][0]>0.5:\n",
+    "    print(\"Face Not Detected\")\n",
+    "else:\n",
+    "    print(\"Face Detected\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "de1d4df7-38de-4bfd-8d82-605a8a904cc9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tensorflow.keras.preprocessing import image\n",
+    "import numpy as np\n",
+    "\n",
+    "test_image = image.load_img(\n",
+    "    r\"C:\\Users\\abhis\\Desktop\\Deep Learning\\Deep Learning Project\\Face Detection Project\\images\\train\\No_Face\\001_0001.jpg\",\n",
+    "    target_size=(128,128))\n",
+    "\n",
+    "test_image = image.img_to_array(test_image)\n",
+    "test_image = np.expand_dims(test_image, axis=0)\n",
+    "test_image = test_image / 255.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79dba6a6-479c-403a-bfa7-768e2be56564",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pred = model.predict(test_image)\n",
+    "print(pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80198a51-50d1-4a47-9595-54f5330f728b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if pred [0][0]>0.5:\n",
+    "    print(\"Face Not Detected\")\n",
+    "else:\n",
+    "    print(\"Face Detected\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "70d6e1d0-4cca-470e-9bc0-9e5099139aaa",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8aa5e9f5-2fe5-4d84-9f12-dca2f7834335",
+   "metadata": {},
+   "source": [
+    "**WEB CAM OR LIVE FACE DETECTING**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "571476e8-d9ab-4f1a-bad6-43238be047f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "\n",
+    "#Load Face Detector\n",
+    "face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')\n",
+    "\n",
+    "#Open Webcam\n",
+    "cam = cv2.VideoCapture(1) #1 Means Portable Webcam. In Default Is 0 Means Inbuilt Camera.\n",
+    "\n",
+    "while True:\n",
+    "    ret, frame = cam.read()\n",
+    "\n",
+    "    if not ret:\n",
+    "        break\n",
+    "    \n",
+    "    #Convert To Grayscale\n",
+    "    gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)\n",
+    "\n",
+    "    #Detect Faces\n",
+    "    faces = face_cascade.detectMultiScale(gray, scaleFactor = 1.1, minNeighbors = 5)\n",
+    "\n",
+    "    #If Face Detected\n",
+    "    if len(faces)>0:\n",
+    "        text = \"Face Detected\"\n",
+    "    else:\n",
+    "        text = \"Face Not Detected\"\n",
+    "\n",
+    "    cv2.putText(frame, text, (20,40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)\n",
+    "\n",
+    "    #Draw Rectangle Around Faces\n",
+    "    for (x,y,w,h) in faces:\n",
+    "        cv2.rectangle(frame, (x,y), (x+w,y+h), (255,0,0), 2)\n",
+    "\n",
+    "    cv2.imshow(\"Live Face Detection\", frame)\n",
+    "\n",
+    "    if cv2.waitKey(1) == 27:\n",
+    "        break\n",
+    "\n",
+    "cam.release()\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2a0764de-c404-4af1-86e1-1fbe751698db",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:base] *",
+   "language": "python",
+   "name": "conda-base-py"
+  },
+  "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.13.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Face Detection.ipynb

@@ -0,0 +1,359 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7a34d31f-b8c7-48ae-ad5b-cc2d43c4c7f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 4000 images belonging to 2 classes.\n",
+      "Found 1000 images belonging to 2 classes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+    "\n",
+    "train_generator = ImageDataGenerator(rescale=1./255, rotation_range=20, zoom_range=0.2, horizontal_flip=True)\n",
+    "val_generator = ImageDataGenerator(rescale=1./255)\n",
+    "\n",
+    "train_data = train_generator.flow_from_directory(\n",
+    "    r\"C:\\Users\\abhis\\Desktop\\Deep Learning\\Deep Learning Project\\Face Detection Project\\images\\train\",\n",
+    "    target_size=(128,128),\n",
+    "    batch_size=32,\n",
+    "    class_mode=\"binary\")\n",
+    "val_data = val_generator.flow_from_directory(\n",
+    "    r\"C:\\Users\\abhis\\Desktop\\Deep Learning\\Deep Learning Project\\Face Detection Project\\images\\val\",\n",
+    "    target_size=(128,128),\n",
+    "    batch_size=32,\n",
+    "    class_mode=\"binary\")"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "9c9f138c-93b1-4e94-9be6-67675e7dfdb5",
+   "metadata": {},
+   "source": [
+    "print(train_data.class_indices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9d2004d7-7e3e-472d-9ed3-c203040ca096",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Data Shape : (128, 128, 3)\n",
+      "Val Data Shape : (128, 128, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Train Data Shape : {train_data.image_shape}\")\n",
+    "print(f\"Val Data Shape : {val_data.image_shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "40ccd023-547d-4ef8-aab3-61c7b33d0149",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\abhis\\anaconda3\\Lib\\site-packages\\keras\\src\\layers\\convolutional\\base_conv.py:113: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
+      "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout\n",
+    "\n",
+    "#Initializing Sequential Layers\n",
+    "cnn = Sequential()\n",
+    "\n",
+    "#First Convolutional Layer\n",
+    "cnn.add(Conv2D(32, (3,3), activation = \"relu\", input_shape = (128,128,3)))\n",
+    "\n",
+    "#First Max Pooling Layer\n",
+    "cnn.add(MaxPooling2D(2,2))\n",
+    "\n",
+    "#Second Convolutional Layer\n",
+    "cnn.add(Conv2D(64, (3,3), activation = \"relu\", input_shape = (128,128,3)))\n",
+    "\n",
+    "#Second Max Pooling Layer\n",
+    "cnn.add(MaxPooling2D(2,2))\n",
+    "\n",
+    "#Third Convolutional Layer\n",
+    "cnn.add(Conv2D(128, (3,3), activation = \"relu\", input_shape = (128,128,3)))\n",
+    "\n",
+    "#Third Max Pooling Layer\n",
+    "cnn.add(MaxPooling2D(2,2))\n",
+    "\n",
+    "#Flatten Layer (Converting 2D Layer Into 1D Layer)\n",
+    "cnn.add(Flatten())\n",
+    "\n",
+    "#First Dense Layer (Neural Or ANN Layer)\n",
+    "cnn.add(Dense(128, activation = \"relu\"))\n",
+    "\n",
+    "#Dropout Layer\n",
+    "cnn.add(Dropout(0.5)) #Prevents Overfitting By Randomly Turning Off 50% Neurons During Training\n",
+    "\n",
+    "#Output Layer\n",
+    "cnn.add(Dense(1, activation = \"sigmoid\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a0ea2154-ac26-4cb4-9c64-aec9fef0f812",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:TensorFlow GPU support is not available on native Windows for TensorFlow >= 2.11. Even if CUDA/cuDNN are installed, GPU will not be used. Please use WSL2 or the TensorFlow-DirectML plugin.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tensorflow.keras.optimizers import Adam\n",
+    "from tensorflow.keras.losses import BinaryCrossentropy\n",
+    "\n",
+    "cnn.compile(loss=BinaryCrossentropy(),optimizer=Adam(),metrics=['accuracy'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6772c5bb-d8af-4be1-bd19-615765e19e4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m782s\u001b[0m 6s/step - accuracy: 0.7185 - loss: 0.5584 - val_accuracy: 0.6540 - val_loss: 0.8269\n",
+      "Epoch 2/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m740s\u001b[0m 6s/step - accuracy: 0.8035 - loss: 0.4389 - val_accuracy: 0.6770 - val_loss: 0.5990\n",
+      "Epoch 3/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m712s\u001b[0m 6s/step - accuracy: 0.8163 - loss: 0.4251 - val_accuracy: 0.7100 - val_loss: 0.5743\n",
+      "Epoch 4/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m806s\u001b[0m 6s/step - accuracy: 0.8223 - loss: 0.3941 - val_accuracy: 0.7530 - val_loss: 0.5527\n",
+      "Epoch 5/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m739s\u001b[0m 6s/step - accuracy: 0.8335 - loss: 0.3814 - val_accuracy: 0.7400 - val_loss: 0.5307\n",
+      "Epoch 6/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m752s\u001b[0m 6s/step - accuracy: 0.8393 - loss: 0.3605 - val_accuracy: 0.7540 - val_loss: 0.4996\n",
+      "Epoch 7/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m737s\u001b[0m 6s/step - accuracy: 0.8438 - loss: 0.3490 - val_accuracy: 0.7530 - val_loss: 0.5425\n",
+      "Epoch 8/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m735s\u001b[0m 6s/step - accuracy: 0.8540 - loss: 0.3351 - val_accuracy: 0.7630 - val_loss: 0.5004\n",
+      "Epoch 9/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m744s\u001b[0m 6s/step - accuracy: 0.8495 - loss: 0.3285 - val_accuracy: 0.7370 - val_loss: 0.5375\n",
+      "Epoch 10/10\n",
+      "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m745s\u001b[0m 6s/step - accuracy: 0.8555 - loss: 0.3233 - val_accuracy: 0.7410 - val_loss: 0.5499\n"
+     ]
+    }
+   ],
+   "source": [
+    "performance = cnn.fit(train_data, validation_data=val_data, epochs=10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "1fd07bc9-6fa4-4128-bfdb-4e8f18e7b6c9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'accuracy': [0.718500018119812,\n",
+       "  0.8034999966621399,\n",
+       "  0.8162500262260437,\n",
+       "  0.8222500085830688,\n",
+       "  0.8335000276565552,\n",
+       "  0.8392500281333923,\n",
+       "  0.84375,\n",
+       "  0.8539999723434448,\n",
+       "  0.8495000004768372,\n",
+       "  0.8554999828338623],\n",
+       " 'loss': [0.5584008097648621,\n",
+       "  0.4389071464538574,\n",
+       "  0.4251162111759186,\n",
+       "  0.3940584659576416,\n",
+       "  0.381367564201355,\n",
+       "  0.36048099398612976,\n",
+       "  0.3490343689918518,\n",
+       "  0.33513495326042175,\n",
+       "  0.32850873470306396,\n",
+       "  0.32332107424736023],\n",
+       " 'val_accuracy': [0.6539999842643738,\n",
+       "  0.6769999861717224,\n",
+       "  0.7099999785423279,\n",
+       "  0.753000020980835,\n",
+       "  0.7400000095367432,\n",
+       "  0.7540000081062317,\n",
+       "  0.753000020980835,\n",
+       "  0.7630000114440918,\n",
+       "  0.7369999885559082,\n",
+       "  0.7409999966621399],\n",
+       " 'val_loss': [0.826907753944397,\n",
+       "  0.5989636778831482,\n",
+       "  0.5742875933647156,\n",
+       "  0.5526597499847412,\n",
+       "  0.5306937098503113,\n",
+       "  0.4995579421520233,\n",
+       "  0.5425190329551697,\n",
+       "  0.5004422664642334,\n",
+       "  0.5375431180000305,\n",
+       "  0.5498905181884766]}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "performance.history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "f3a2eae0-8fac-4cc8-a8fa-6bba3b22b6cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m52s\u001b[0m 2s/step - accuracy: 0.7410 - loss: 0.5499\n",
+      "Test Loss : 0.5498904585838318\n",
+      "Test Accuracy : 0.7409999966621399\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_loss, test_accuracy = cnn.evaluate(val_data)\n",
+    "\n",
+    "print(f\"Test Loss : {test_loss}\")\n",
+    "print(f\"Test Accuracy : {test_accuracy}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c63466c3-24ad-4640-8dac-cec7d1755807",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(performance.history[\"accuracy\"])\n",
+    "plt.plot(performance.history[\"val_accuracy\"])\n",
+    "\n",
+    "#plt.ylim(0,1)\n",
+    "plt.title(\"Model Accuracy\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Accuracy\")\n",
+    "plt.legend([\"Train\",\"Validation\"])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6e8f5b24-56eb-460a-8efe-41d67577beb2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(performance.history[\"loss\"])\n",
+    "plt.plot(performance.history[\"val_loss\"])\n",
+    "\n",
+    "plt.title(\"Model Loss\")\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.legend([\"Train\",\"Validation\"])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "291788b9-d7c7-42b9-a73a-124dffa9d0b3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
+     ]
+    }
+   ],
+   "source": [
+    "cnn.save(\"Face_Detection_Model.h5\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:base] *",
+   "language": "python",
+   "name": "conda-base-py"
+  },
+  "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.13.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Face_Detection_Model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9c39e8d9fabb91906d4b606c8ffd12aa58d0f9bc356886a830ca577b2a0aa93
+size 39704352