From e75500728ace0da15890b5ea0423ac963d4d4f7b Mon Sep 17 00:00:00 2001 From: Nahia Date: Sun, 2 Nov 2025 08:18:35 -0600 Subject: [PATCH] dosnov16 --- main.ipynb | 800 ++++++++++++++++++++++-- mod/__pycache__/testing.cpython-313.pyc | Bin 0 -> 20248 bytes 2 files changed, 734 insertions(+), 66 deletions(-) create mode 100644 mod/__pycache__/testing.cpython-313.pyc diff --git a/main.ipynb b/main.ipynb index b05630a..453e7e2 100644 --- a/main.ipynb +++ b/main.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -37,31 +37,101 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def greater(a,b):\n", - "#your code here" + "#your code here\n", + " if a > b:\n", + " return a \n", + "\n", + " else:\n", + " return b\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# This will test your function \n", - "test_greater(greater)" + "greater(5,8)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "24049723" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "greater(727597, 24049723)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2346234" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "#your code here" + "greater (2346234, 234723)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function greater works\n" + ] + } + ], + "source": [ + "# This will test your function \n", + "def test_greater(greater):\n", + " assert greater(2346234, 234723) == 2346234\n", + " assert greater( 727597, 24049723) == 24049723\n", + " assert greater (5, 8) == 8\n", + " print (\"Function greater works\")\n", + "\n", + "test_greater(greater)" ] }, { @@ -73,21 +143,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 71, "metadata": {}, "outputs": [], "source": [ - "#your code here" + "#your code here\n", + "def largest_e(lst):\n", + "#your code here\n", + " if not list:\n", + " return None\n", + " \n", + " x = lst[0]\n", + " for num in lst:\n", + " if num > x :\n", + " x = num\n", + " return x\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 73, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# This will test your function \n", - "test_greatest(greatest)" + "largest_e([3, 5, 6])" ] }, { @@ -101,21 +191,64 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15\n" + ] + } + ], "source": [ "def sum_all(lst):\n", - "#your code here" + "#your code here\n", + " sum_result = 0\n", + "\n", + " for num in lst:\n", + " sum_result += num\n", + " return sum_result\n", + "print(sum_all([1, 2, 3, 4, 5]))\n" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "755474" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# This will test your function \n", + "sum_all([1, 2, 686698, 68768, 5])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function sum_all works\n" + ] + } + ], + "source": [ + "def test_sum(sum_all):\n", + " assert sum_all([1, 2, 3, 4, 5]) == 15\n", + " assert sum_all([1, 2, 686698, 68768, 5]) == 755474\n", + " print(\"Function sum_all works\")\n", "test_sum(sum_all)" ] }, @@ -130,10 +263,45 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120\n" + ] + } + ], "source": [ "def mult_all(lst):\n", - "#your code here" + "#your code here\n", + " mult_result = 1\n", + " for num in lst:\n", + " mult_result *= num\n", + " return mult_result\n", + "\n", + "print(mult_all([1, 2, 3, 4, 5]))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1600" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mult_all([1, 2, 40, 4, 5])" ] }, { @@ -142,9 +310,23 @@ "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function mult_all works\n" + ] + } + ], "source": [ "# This will test your function \n", + "\n", + "def test_mult(mult_all):\n", + " assert mult_all([1, 2, 3, 4, 5]) == 120\n", + " assert mult_all([1, 2, 40, 4, 5]) == 1600\n", + " print(\"Function mult_all works\")\n", + "\n", "test_mult(mult_all)" ] }, @@ -157,21 +339,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ - "def oper_all(arr, oper = \"*\"):\n", - "#your code here" + "def oper_all(arr, oper):\n", + " if oper == \"+\":\n", + " result = sum (arr)\n", + " print(\" The result of the sum is\", {result})\n", + " return result\n", + " elif oper == \"*\":\n", + " result = 1\n", + " for n in arr:\n", + " result *= n\n", + " print(\" The result of the multiplication is\", {result} )\n", + " return result\n", + "\n", + " else:\n", + " print (\"error\")\n", + " result = None\n", + "\n", + "\n", + " \n", + " " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " The result of the sum is {10}\n", + " The result of the multiplication is {24}\n", + "Function oper_all works\n" + ] + } + ], "source": [ "# This will test your function \n", + "def test_operations(oper):\n", + " assert oper_all([1, 2, 3, 4], \"+\") == 10\n", + " assert oper_all([1, 2, 3, 4], \"*\") == 24\n", + " print(\"Function oper_all works\")\n", + "\n", "test_operations(oper_all)" ] }, @@ -189,7 +403,52 @@ "outputs": [], "source": [ "def factorial(n):\n", - "#your code here" + " if n < 0:\n", + " raise ValueError(\"Error\")\n", + " product = 1\n", + " for i in range(1, n + 1):\n", + " product *= i\n", + " return product \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3628800" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(10)" ] }, { @@ -215,10 +474,24 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function factorial works\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_factorial(factorial)" + "\n", + "def test_mult(mult_all):\n", + " assert factorial(4) == 24\n", + " assert factorial(10) == 3628800\n", + " print(\"Function factorial works\")\n", + "\n", + "test_mult(factorial)" ] }, { @@ -234,19 +507,89 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5]\n" + ] + } + ], "source": [ - "def unique(lst_un):\n", - "#your code here" + "def unique(lst):\n", + "\n", + " unique_list =[]\n", + " for num in lst:\n", + " if num not in unique_list:\n", + " unique_list.append(num)\n", + " return unique_list\n", + "\n", + "print(unique([1, 2, 3, 4, 5, 5]))\n", + "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 45, 5]" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unique([1, 2, 3, 45, 1, 1, 5, 5])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 88, 45, 5]" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unique([1, 88, 88, 45, 1, 1, 5, 5])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function unique works\n" + ] + } + ], "source": [ "# This will test your function \n", + "\n", + "def test_unique(unique):\n", + " assert unique([1, 2, 3, 45, 1, 1, 5, 5]) == [1, 2, 3, 45, 5]\n", + " assert unique([1, 88, 88, 45, 1, 1, 5, 5]) == [1, 88, 45, 5]\n", + " print(\"Function unique works\")\n", + "\n", "test_unique(unique)" ] }, @@ -264,18 +607,68 @@ "metadata": {}, "outputs": [], "source": [ - "def mode_counter(arr):\n", - "#your code here" + "def mode_counter(lst):\n", + " most = max(set(lst), key=lambda x: sum(1 for i in lst if i == x))\n", + " return [most]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2]\n" + ] + } + ], + "source": [ + "numbers = [1, 2, 3, 2, 4, 2, 5]\n", + "print(mode_counter(numbers)) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6]\n" + ] + } + ], + "source": [ + "numbers = [1, 2, 3, 2,6,6,6,6,6,6, 4, 2, 5]\n", + "print(mode_counter(numbers)) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function mode_counter works\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_mode(mode_counter)" + "def test_mode_counter(mode_counter):\n", + " assert mode_counter([1, 2, 3, 2, 4, 2, 5]) == [2]\n", + " assert mode_counter([1, 2, 3, 2,6,6,6,6,6,6, 4, 2, 5]) == [6]\n", + " print(\"Function mode_counter works\")\n", + "\n", + "test_mode_counter(mode_counter)" ] }, { @@ -293,17 +686,73 @@ "outputs": [], "source": [ "def st_dev(list_sd):\n", - "#your code here" + "#your code here\n", + "\n", + " mean = sum(list_sd) / len(list_sd)\n", + "\n", + " variance = sum(( x-mean)**2 for x in list_sd)/ len(list_sd)\n", + " st_dev = variance ** 0.5\n", + " \n", + " return [st_dev]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[105.7745243430572]\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_stdev(st_dev)" + "list_sd = [4, 46, 345, 4, 63, 4, 62, 56 ]\n", + "print(st_dev(list_sd))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1161801.997261523]\n" + ] + } + ], + "source": [ + "list_sd = [4, 46, 345, 4, 63, 4, 3463, 4363463, 4535, 34543, 223, 62, 56]\n", + "print(st_dev(list_sd))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function st_dev works\n" + ] + } + ], + "source": [ + "def test_st_dev(st_dev):\n", + " assert st_dev([4, 46, 345, 4, 63, 4, 62, 56]) == [105.7745243430572]\n", + " assert st_dev([4, 46, 345, 4, 63, 4, 3463, 4363463, 4535, 34543, 223, 62, 56]) == [1161801.997261523]\n", + " print(\"Function st_dev works\")\n", + "\n", + "test_st_dev(st_dev)" ] }, { @@ -317,10 +766,22 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n" + ] + } + ], "source": [ - "def pangram(string):\n", - "#your code here" + "\n", + "#your code here\n", + "import string\n", + "\n", + "english_alphabet = list(string.ascii_uppercase)\n", + "print(english_alphabet)" ] }, { @@ -329,8 +790,86 @@ "metadata": {}, "outputs": [], "source": [ - "# This will test your function \n", - "test_pangram(pangram)" + "import string\n", + "\n", + "def pangram(lista):\n", + " english_alphabet = string.ascii_lowercase\n", + " counter = 0 \n", + " lista = lista.lower()\n", + "\n", + " for letter in english_alphabet:\n", + " if letter in lista:\n", + " counter += 1\n", + "\n", + " else:\n", + " return(\"No pangram\") \n", + " \n", + " if counter == 26:\n", + " return(\"It is pangram\")\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'It is pangram'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pangram (\"The quick brown fox jumps over the lazy dog\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'No pangram'" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pangram (\"Thedgsadgas quicown fox ffsdfafasjumps over fwefwefwethe lazy dog\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function pangram works\n" + ] + } + ], + "source": [ + "def test_pangram():\n", + " assert pangram(\"The quick brown fox jumps over the lazy dog\") == \"It is pangram\"\n", + " assert pangram(\"Thedgsadgas quicown fox ffsdfafasjumps over fwefwefwethe lazy dog\") == \"No pangram\"\n", + " print(\"Function pangram works\")\n", + "\n", + "test_pangram()" ] }, { @@ -348,18 +887,75 @@ "metadata": {}, "outputs": [], "source": [ - "def sort_alpha(string):\n", - "#your code here" + "\n", + "#your code here\n", + "import string\n", + "\n", + "def sort_alpha(list):\n", + " return sorted(list)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['banana', 'kiwi', 'manzana', 'naranja']" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sort_alpha([\"naranja\", \"manzana\", \"banana\", \"kiwi\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['banana', 'kiwi', 'naranja', 'peach', 'watermelon']" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sort_alpha([\"naranja\", \"peach\", \"banana\", \"kiwi\", \"watermelon\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function sort_alpha works\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_alpha(sort_alpha)" + "def test_sort_alpha():\n", + " assert sort_alpha([\"naranja\", \"manzana\", \"banana\", \"kiwi\"]) == ['banana', 'kiwi', 'manzana', 'naranja']\n", + " assert sort_alpha([\"naranja\", \"peach\", \"banana\", \"kiwi\", \"watermelon\"]) == ['banana', 'kiwi', 'naranja', 'peach', 'watermelon']\n", + " print(\"Function sort_alpha works\")\n", + "\n", + "test_sort_alpha()" ] }, { @@ -371,28 +967,105 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "metadata": {}, "outputs": [], "source": [ + "import string\n", + "\n", "def check_pass(password):\n", - "#your code here" + " if len(password) < 8:\n", + " return False\n", + "\n", + " counter_digit = 0\n", + " counter_lower = 0\n", + " counter_upper = 0\n", + " counter_punctuation = 0\n", + "\n", + " for character in password:\n", + " if character.isdigit():\n", + " counter_digit += 1\n", + " elif character.islower():\n", + " counter_lower += 1\n", + " elif character.isupper():\n", + " counter_upper += 1\n", + " elif character in string.punctuation:\n", + " counter_punctuation += 1\n", + "\n", + " if counter_digit == 0:\n", + " return False\n", + " if counter_lower == 0:\n", + " return False\n", + " if counter_upper == 0:\n", + " return False\n", + " if counter_punctuation == 0:\n", + " return False\n", + "\n", + " return True" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 89, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], "source": [ + "print(check_pass(\"789oizuiuizoi\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(check_pass(\"789o*zuI\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Function check_pass works\n" + ] + } + ], + "source": [ + "\n", "# This will test your function \n", - "test_pass(check_pass)" + "def test_pass(check_pass):\n", + " assert check_pass (\"789oizuiuizoi\") == False\n", + " assert check_pass(\"789o*zuI\") == True\n", + " print(\"Function check_pass works\")\n", + "\n", + "test_pass(check_pass) " ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -406,12 +1079,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" - }, - "vscode": { - "interpreter": { - "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" - } + "version": "3.13.8" } }, "nbformat": 4, diff --git a/mod/__pycache__/testing.cpython-313.pyc b/mod/__pycache__/testing.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d3d0988b6eb15c36131a0fca80b6994972fcdb7 GIT binary patch literal 20248 zcmeHPe^49Oo!?zaAV3KG3;&3N7Yw$Q7_g1)CU)Z325bim#t4C90qP>HKv=BETge#N zak-hBp4+CEG?Pr-YdeQy-x+ebtDE}HzFudFlXTAQWF`_KIHRW5nY)|0@?T z-1qxdyDMSIU^kTHCYsTA_q~1l_Wjz==lj0z`*tQjKbL{uf4%j;y+7j_=07l?{z3&druVMx9`8>H2423cUw0a<9z1-ZnY2Xd+10&ALMeo737L4#$IrgB}Mi^ z2(7d)0lCV)6y)k2*0yXKi`!&l<5@)Xgxn&W<#+{mFhG2Q-^RsFa?m55j2rs{9?@oq z7YMT3=X3c3gCcPYvZzLc1_lxlSsq`HFDScN%sBDG)-u3<<`l$sF_(F1V4h@2b{S(c#n%NzIq2#kq7W2G+I0z?u*jE?_(~|r~ z;tlX?W#KJM`@ZeO_%!dA9fn1^cq>!QsqZMyK<98xf5^4>210%h-!1ZEhIk&dvq*w< z&xQoQ-Wy{aDT0E;Ij05()9`nAr>hn(2K@;VsMBsAcVU zT1J*%UUOm1dDp1t2Pei(Tt9x(_-@|M^TwZx>~_3oX(Mal1}K6yIL6F4k|d#Dgpri% zazW39{CIA0xv=1gD+Ml>*GJ@_-zSMuz~!P{O3JX{D_|@Ig`m&v5`sbE>kdKr;r{%@ zNOOyRzsogdAgdrTS&3pj2pPxq-eINkO0)%H@YR{YL3`(`%x^hEPRZ|b*_?KEhCxXS zPt#6&Aj$Nq|M}#T>EA#`W4Up22wnzkxwyF%WDPOhX?RGWjcRS&Ant z#W4#%T=zl#(if}$^7uLS1MBh^q_0co9V6Rg)=jS${h;`@;_IgCo|vuXT*>?9{1@`S zmj5l^$dVD$CHLso(ejIZv7)V0=4~ID80)H!vlvtUE#pHI#)o3Yhi@56qQ;Vu^7o9J zXhWvFK3Gibk(qx`2+NotEaL+ZmN5y!)4WhRgl8lyA0;e}%;rHyhS`L&jA`R!u8NU4 zAV2_X zq8i0^5Mw3^rsOG%*b5?V5C~DQ6!j6r(gc*|r*trBhO5XRGp~Y3U}+o0(zX;VZDTWI zY4u}2Df(&gkBe_|H>+chADOIfj#-aRR5y?CYq-JSW%82^{XBqn!IGZw^c!&;kInYb93mFbX6QGACHVWR{^|+Nj+_Ro^tgXv-xy z`6D|~d42-Wh(|GP3y2gD!U+~t z_O5;wls*3WX^c)41OlUOy+fP3E#I2c~AUU2>dkW6T zUtx~16`-G$fdv+VV`xFx2Pb4d2t{4xl?kx<3BS;{9GY0qZ$yXLlWA7y)!e zCn7WbIT%&HDPx?7!t`f{B@+j%?5VmCERqW_JmFr9LV6%I=>?I@CIsw&OuRB< zYYE9?Sml;h%tYaq(XFplEA0m6H^#;hCmbky!1)o(n+psiKM<@Dk{nmGpmgsETt#JC z=0SkbyI=)V6 z37fNSCZVMzr{S^b?al?W+K2!&GY8-=-vIG|rspj?u6nOYZ%E@UHx03!hbOl*#tNDy zwlt1zeL3sf)|ag3<&kYug&U$<8lweGlg(|nnmZ?&J0q^{h}#?K>WMY?My$SbhT9yM zv-86&CdZmERzrJ@E*p6|R#Z7Oc^Z#wdt(Xp8Sjc`hB&LH$REHJ|9u=>IjAhfXu@B0a z0UNX75>+vuhm*{!ZMtHaaMnn(hOCY`^$6>4sPfJF(e<}9@v~hwsKRbDk`lNd46R~N zcaI>Y5T~e!30H+OOtj(NJ*C=dP#c%g6)A~{hAyu$N9bo7N5D)Q$;O( z5t8droYwT5m((8QB}h+I`B&j2fw@k)ROd`ts&n3Bsc!4et0%9WedFwS_s!+8FEveW zJrc7vPi#Fhx-VgH@r+bY6>N-dJ%R?8W*w97cc~5>1@E$tYta0g&w^U{)%&!v80?y5 zTYWtq0GiV-(xH{bo}FZ8Nw4B2-CITNh7~XnJ{4sb=={@Fc9YyF7S^T?-lXXu{S>s! zVnKSsrk=iJ8lVqB2{QmXLMsLI&$zOiu&HOLXhP4$8T0+_2ceXb^T;TL(F=3 zqM~7xO(3l>!c7&dk5)89t%q-tNr&^6!#&|}M?7N0+Z%KEBCUPVBYjb8-#J4v4A+h> zyQt3b@9B(2Jti9UIet}!IsO-(Y0$~c7kaWO{xH=xsGoj1O#KUJrp3ZkMKR1&G!0a7 zTABe=H7yyzC9{^C*^yZ#{Y*Y-b}s!D)Qatf$BpRB3v0V}v{7rb8jLs0MzFZo$lwR02;dYgMKMs+*bY>sbnSJSXW`uC+$2LD4 zr;Ya{-b2@F)46Np>Z6#v1}Q<$W8@^2*+*4oUy91?yNAmBM|ii@jjq2~KOZwj!n=*C z%(jAXdAr~bhBx!lQ2#*hX5Jeh{IemS`vl+T>yi1B;wgTA$Ws|Ew-5CCq*Hvr%Xj-> z4*?_+2;SEh^7M#&{}6vNFjyJh)Qs04)Ezj*5Bh?=ycaeh@SZ?elz2Z(iXr>HP>)<0 zUVqT<>*o6c?h`UTFsu}S4+iKnJ%a-AR)#m!Lv|ivQ0Dys$OiNE_3*M*6r~VQy4GG% zc@jJqHY~uS!vgWh@T~p;r9S?l%5d4Cz#wK1Df~l;YI+23kPnO9L{L(fgv*Z7`iI4V z-XS7GbpwN&6L;}6b-k}2iq<+9;61p-LQ2%4SM(3?Ug4BlOsrL9xB`pTCk$=o2Yfx) zzNa=TkK@689g_|Q{3k_h1E^|A*k*@*5Q4qFFs%mNis1E~;*W-e6C&XQ-F+f#(SRE& z!&Und)!Yar4|MZBS#3RcFI1a0tNR30)F;7Xdn&`*+J&IIm)}?~1_q#YhDtVW=J)xb zhg*r*EuMgEU;_x>+NShJ59}wX3~%2*#MeXHZ^oi3149mmJVQ7T;8veI&_e`hD5!?S z3;Y1_g~gKaqwT_}AzDGW<)lcUE-+GPUwcFS-F}e|LaPk;!eOB@#iE9bzPKng(+xJI zKjEe;)Y<6Ii4#ZqOWuB!SQ(L@lvFg{=Gg!t>nqH|`pEALF zm`)h=Tng2D^3oHnkAB3ZbBEE1 z3y<`7_p@47tJn0Sp59?>c}R~}&yW}JrgXfA^lQ(`o~J}9 z$WP!=e*=H{S0L`-o~JAm`st(8_dH?fW9zIvPnPAAWH53nJV{Q+R-Tz4rz8E+dG4>X zzmxsWig!-Fd-fM+BVAvP2%gvxaq?+zjPIFv+B?4QQqkpyUw!!XuS}IZ6@A(p<$I=9 z^+w6*=*lxu%bDT2Uly)7XVmAV#!L3s*Tu>ozg50JTE747YS;-8z7c-wOsu9gR_=%u zwN07ZKQb^&ivH7RNw;(A&h2cbq?f%jvGR<(3Tk*GySjFB){R|dwHpiHEY5@Tw>O$V zrVtYXFeRq(KP@p~x6@w+I{Hq6jx^d*(}T~4cCS;j@wI4_qNke&9Vw)j-SWpi#jGwB zslcCx^z^c(rB0_tg=!x2A-$xu-&Kf(ZVE#Z+@BypgtJ*cg#>}@)74ueO`tlBCiM)! zf(w>s{M~iDo9t@uB0C(IvwlfrmxfyBCc7lsTOjW=Wl}Hr2YQ8cllrSrp~WISWm2E1 zXd31HBNXv-PI<~SJ!4H1g!f~t=zS0#S|_pp(wR!*?B;2@)_)Ka&{X+wX0y)XIb~DC zKVhQBQS3sIN^bEiIY5G<2e#@C_|>5;=Q_9#8K#r_GWRh9A%UA=nEY<;wi19#Eu5V@XMf??*N#mF zf|H@szhjt_Y%M0h10<;94&dP+_cY#nlC8&_2G|A+tvrkgF%aoH@gn*5;I{_fF}>q` zSNeq%>FkQQgjiGe6ZTnf;bw ztc@I;V@ZeW;IUBF*)%y~zkKY%vDdv)&vSkb{L^P#yIk{8)K zP-b`-9w2-95op{STy@<;#v41T>x!&zZYrx=vg$2M9-P0mG7sW^w!{SIKPxi9c?x?X z>rnPAQ`j>ru{9Y!$#CD_(#QfbO8nC8>DN(Gq91<%cP@PBin80Z*4QI7x!S_B|VB%*|bDdoyn3$C=5LX$zFlps+;tFTB+=X#q zQ~W{)!1$Stpx%P^Trh$H=Y%DYzq0i?i+=CJMZfJ~GtsX}kazJa_Au4a>9-crZktvB zK0_TeCVLw)lGlI$J8bF~IM(pbH_$I|-0je0hV;weKl3t(g)m%$**c;9zyq|O6}~T& z(V%TqeUhnB+t3tVb^wfsU?G!vY=gl7@qk5b)v8Z|+hNHNrV7}_-Xa~;OZc^C4&oA_KusfKS*YG*mzqtyi4L_oOLVSLdt$9 z#e-eh3Y9uORCjf3Oc^F(%rNsk``dxZcJE}b1fBaVbT#z&0qAPb0ZMC72f)BMducs< z>SM#j6Ia(?5q`8Gy5X@{>EqW+CQElGlEVR#gZ^-ktH)u|z#YXb4stCRYUA25--B>~ z&;jlkhDwiNisEN5s*~%&XBBr*?uMKwj{H@{z7n&tt^X<%cABo2& zwf4#0{z)l#OFAc4d4%D!mX zj;n!aS>4;-XxZUNV`sFibE>Edx&~9i0d7OR?Es$RqZPf)dAHuyKH7S*GgeeRW!^rQ zmIirJ^~}jBrVLYcZNBlwV~^FEt#5A0gY&n|CXlu@iYkt3H+(7$Kl2m__+`3}0zQ)l z>kZUdH=aws0tDZDa?6A+e<1{rTPU!jh~D2d7;Hw-fx?f1x?h~bvzJhOAH{1Z=&TB@ zN>oXw{i^I1S&MP2LB!2ZC|@nwL;f9th)Z%Ohz|`c%l?un_$8D7D`xGlm^HsK-Ao+hRd8Oz8 literal 0 HcmV?d00001