From 7e01d1f51254d0748d2c021d3d22ad8162fc1c50 Mon Sep 17 00:00:00 2001 From: lisMusi Date: Sun, 16 Feb 2025 19:27:29 +0100 Subject: [PATCH] lab terminado --- .ipynb_checkpoints/main_esp-checkpoint.ipynb | 411 +++++++++++++++++++ main_esp.ipynb | 406 +++++++++++++++--- mod/__pycache__/testing.cpython-38.pyc | Bin 0 -> 13355 bytes 3 files changed, 755 insertions(+), 62 deletions(-) create mode 100644 .ipynb_checkpoints/main_esp-checkpoint.ipynb create mode 100644 mod/__pycache__/testing.cpython-38.pyc diff --git a/.ipynb_checkpoints/main_esp-checkpoint.ipynb b/.ipynb_checkpoints/main_esp-checkpoint.ipynb new file mode 100644 index 0000000..8890780 --- /dev/null +++ b/.ipynb_checkpoints/main_esp-checkpoint.ipynb @@ -0,0 +1,411 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En este laboratorio pondremos en práctica algunos de los conceptos que hemos aprendido en los últimos días.\n", + "\n", + "`NOTA: En este laboratorio deberías intentar escribir todas las funciones por ti mismo utilizando solo la sintaxis más básica de Python y sin funciones como len, count, sum, max, min, in, etc. Dale una oportunidad. 🧑🏻‍💻👩🏻‍💻`\n", + "\n", + "La celda después de cada ejercicio contiene algunas pruebas para verificar si tu función funciona como se espera." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from mod.testing import *\n", + "import unittest" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Escribe una función que devuelva el mayor de dos números" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def greater(a,b):\n", + "#your code here#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_greater(greater)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Ahora escribe una función que devuelva el elemento más" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_greatest(greatest)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Escribe una función que sume todos los elementos de una lista" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def sum_all(lst):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_sum(sum_all)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Escribe otra función que multiplique todos los elementos de una lista" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def mult_all(lst):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_mult(mult_all)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Ahora combina esas dos ideas y escribe una función que reciba una lista y ya sea \"+\" o \"*\", y produzca el resultado acorde" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def oper_all(arr, oper = \"*\"):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_operations(oper_all)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Escribe una función que devuelva el factorial de un número." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def factorial(n):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Fórmula factorial\n", + "# n! = n * (n - 1) *...*1\n", + "\n", + "# Este código define una función llamada \"factorial\" que toma una entrada \"n\". La función utiliza un bucle for para iterar a través del rango de números\n", + "# desde 1 hasta n+1. Para cada número en ese rango, multiplica el valor actual de x por el número en el rango. Al final del bucle,\n", + "# la función devuelve el valor final de x, que será el factorial del número de entrada \"n\".\n", + "\n", + "# El factorial de un entero positivo n es el producto de todos los enteros positivos menores o iguales a n.\n", + "# Por ejemplo, el factorial de 6 (escrito \"6!\") es 6 * 5 * 4 * 3 * 2 * 1 = 720.\n", + "\n", + "# Así que esta función toma una entrada de cualquier entero positivo y devuelve el factorial de ese número." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# This will test your function \n", + "test_factorial(factorial)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Escribe una función que tome una lista y devuelva una lista de los valores únicos.\n", + "\n", + "`NOTE: No podemos usar set. 🤔`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def unique(lst_un):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función \n", + "test_unique(unique)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Escribe una función que devuelva la moda de una lista, es decir: el elemento que aparece más veces.\n", + "\n", + "`NOTE: No se debe usar count... 🧐`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def mode_counter(arr):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función \n", + "test_mode(mode_counter)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Escribe una función que calcule la desviación estándar de una lista.\n", + "`NOTE: no utilices librerías ni ninguna función ya construida. 😉`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def st_dev(list_sd):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_stdev(st_dev)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10. Escribe una función para verificar si una cadena es un pangrama, es decir: si contiene todas las letras del alfabeto al menos una vez. Ten en cuenta que las cadenas pueden contener caracteres que no son letras." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def pangram(string):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_pangram(pangram)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 11. Escribe una función que reciba una cadena de palabras separadas por comas y devuelva una cadena de palabras separadas por comas ordenadas alfabéticamente.\n", + "\n", + "`NOTA: Puedes usar sorted pero no split y definitivamente no join! 🤪`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def sort_alpha(string):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función \n", + "test_alpha(sort_alpha)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 12. Escribe una función para verificar si una contraseña dada es fuerte (al menos 8 caracteres, al menos una minúscula, al menos una mayúscula, al menos un número y al menos un carácter especial). Debería devolver True si es fuerte y False si no lo es." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def check_pass(password):\n", + "#tu codigo aquí" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Para testear tu función\n", + "test_pass(check_pass)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/main_esp.ipynb b/main_esp.ipynb index 8890780..baa1caa 100644 --- a/main_esp.ipynb +++ b/main_esp.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -37,19 +37,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def greater(a,b):\n", - "#your code here#tu codigo aquí" + "#tu codigo aquí\n", + " return a if a > b else b;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.319s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_greater(greater)" @@ -59,23 +72,41 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Ahora escribe una función que devuelva el elemento más" + "## 2. Ahora escribe una función que devuelva el elemento más grande de varios elementos" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "#tu codigo aquí" + "#tu codigo aquí\n", + "def greatest(numeros):\n", + " mayor = numeros[0] \n", + " for num in numeros:\n", + " if num > mayor:\n", + " mayor = num \n", + " return mayor;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.380s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_greatest(greatest)" @@ -90,21 +121,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "def sum_all(lst):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " total = 0\n", + " for l in lst:\n", + " total += l\n", + " return total;" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.331s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_sum(sum_all)" @@ -119,21 +166,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def mult_all(lst):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " total = 1 \n", + " for l in lst:\n", + " total *= l\n", + " return total;" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.448s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_mult(mult_all)" @@ -148,19 +211,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "def oper_all(arr, oper = \"*\"):\n", - "#tu codigo aquí" + "#tu codigo aquí \n", + " if not arr:\n", + " return 0 if oper == \"+\" else 1 \n", + " resultado = 0 if oper == \"+\" else 1 \n", + " \n", + " for num in arr:\n", + " if oper == \"+\":\n", + " resultado += num\n", + " elif oper == \"*\":\n", + " resultado *= num\n", + " else:\n", + " raise ValueError(\"Operador no válido. Usa '+' o '*'\")\n", + "\n", + " return resultado;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.495s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_operations(oper_all)" @@ -175,17 +263,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "def factorial(n):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " if n < 0:\n", + " raise ValueError(\"El factorial no está definido para números negativos\")\n", + " \n", + " resultado = 1\n", + " for i in range(2, n + 1):\n", + " resultado *= i\n", + " return resultado;" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -204,9 +299,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.547s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# This will test your function \n", "test_factorial(factorial)" @@ -223,19 +330,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "def unique(lst_un):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " unique_list = [] \n", + " for item in lst_un:\n", + " if item not in unique_list: \n", + " unique_list.append(item)\n", + " return unique_list;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.420s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función \n", "test_unique(unique)" @@ -252,19 +376,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "def mode_counter(arr):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " freq_dict = {} # diccionario para almacenar las frecuencias\n", + "\n", + " for num in arr:\n", + " if num in freq_dict:\n", + " freq_dict[num] += 1\n", + " else:\n", + " freq_dict[num] = 1\n", + "\n", + " max_freq = 0\n", + " moda = None\n", + "\n", + " for key, value in freq_dict.items():\n", + " if value > max_freq:\n", + " max_freq = value\n", + " moda = key\n", + "\n", + " return moda;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.585s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función \n", "test_mode(mode_counter)" @@ -280,19 +433,55 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ "def st_dev(list_sd):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " if len(list_sd) == 0:\n", + " raise ValueError(\"La lista no puede estar vacía\")\n", + " \n", + " suma = 0\n", + " n = len(list_sd)\n", + " \n", + " for num in list_sd:\n", + " suma += num\n", + " media = suma / n \n", + "\n", + " suma_cuadrados = 0\n", + " for num in list_sd:\n", + " suma_cuadrados += (num - media) ** 2\n", + "\n", + " varianza = suma_cuadrados / (n - 1) \n", + "\n", + " if varianza == 0:\n", + " return 0 \n", + "\n", + " aproximacion = varianza / 2 \n", + " for _ in range(20): \n", + " aproximacion = (aproximacion + varianza / aproximacion) / 2\n", + "\n", + " return aproximacion;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.271s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_stdev(st_dev)" @@ -307,19 +496,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ "def pangram(string):\n", - "#tu codigo aquí" + "#tu codigo aquí \n", + " string = string.lower() # convertir la cadena a minúsculas para evitar problemas con mayúsculas\n", + " alfabeto = \"abcdefghijklmnopqrstuvwxyz\"\n", + "\n", + " for letra in alfabeto:\n", + " if letra not in string:\n", + " return False \n", + "\n", + " return True;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "..............................\n", + "----------------------------------------------------------------------\n", + "Ran 30 tests in 0.169s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_pangram(pangram)" @@ -336,19 +545,52 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ "def sort_alpha(string):\n", - "#tu codigo aquí" + "#tu codigo aquí \n", + " palabras = [] \n", + " palabra_actual = \"\" \n", + "\n", + " for char in string:\n", + " if char == \",\": \n", + " palabras.append(palabra_actual)\n", + " palabra_actual = \"\"\n", + " else:\n", + " palabra_actual += char \n", + "\n", + " palabras.append(palabra_actual) \n", + " \n", + " palabras_ordenadas = sorted(palabras)\n", + "\n", + " resultado = \"\"\n", + " for i in range(len(palabras_ordenadas)):\n", + " resultado += palabras_ordenadas[i]\n", + " if i != len(palabras_ordenadas) - 1: \n", + " resultado += \",\"\n", + "\n", + " return resultado;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.550s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función \n", "test_alpha(sort_alpha)" @@ -363,23 +605,63 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ "def check_pass(password):\n", - "#tu codigo aquí" + "#tu codigo aquí\n", + " if len(password) < 8:\n", + " return False\n", + "\n", + " tiene_mayuscula = False\n", + " tiene_minuscula = False\n", + " tiene_numero = False\n", + " tiene_especial = False\n", + "\n", + " especiales = \"!@#$%^&*()-_=+[]{}|;:'\\\",.<>?/`~\"\n", + "\n", + " for char in password:\n", + " if 'A' <= char <= 'Z': # mayúsculas\n", + " tiene_mayuscula = True\n", + " elif 'a' <= char <= 'z': # minúsculas\n", + " tiene_minuscula = True\n", + " elif '0' <= char <= '9': # números\n", + " tiene_numero = True\n", + " elif char in especiales: # carácter especial\n", + " tiene_especial = True\n", + "\n", + " return tiene_mayuscula and tiene_minuscula and tiene_numero and tiene_especial;" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.392s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# Para testear tu función\n", "test_pass(check_pass)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -398,7 +680,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.8.18" }, "vscode": { "interpreter": { diff --git a/mod/__pycache__/testing.cpython-38.pyc b/mod/__pycache__/testing.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..13bd5c73482107e9684a938f3d99da7c93dc6086 GIT binary patch literal 13355 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 TeR9N^&bIjbXKW-jlp6jo@9Bt8 literal 0 HcmV?d00001