From 859d5eb2b6855d9c78c9d40a68af7da845ffea41 Mon Sep 17 00:00:00 2001 From: Maksym Solomyanov Date: Wed, 15 Oct 2025 13:10:22 +0200 Subject: [PATCH] add my version of python to c++ converter --- .../max.solo23/convert_python_to_c++.ipynb | 870 ++++++++++++++++++ .../max.solo23/optimized.cpp | 73 ++ .../max.solo23/optimized.exe | Bin 0 -> 59675 bytes 3 files changed, 943 insertions(+) create mode 100644 week4/community-contributions/max.solo23/convert_python_to_c++.ipynb create mode 100644 week4/community-contributions/max.solo23/optimized.cpp create mode 100644 week4/community-contributions/max.solo23/optimized.exe diff --git a/week4/community-contributions/max.solo23/convert_python_to_c++.ipynb b/week4/community-contributions/max.solo23/convert_python_to_c++.ipynb new file mode 100644 index 0000000..390f446 --- /dev/null +++ b/week4/community-contributions/max.solo23/convert_python_to_c++.ipynb @@ -0,0 +1,870 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a389285f-5e8e-46ec-bcae-9b159ef7aa80", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import io\n", + "\n", + "import sys\n", + "from dotenv import load_dotenv\n", + "from openai import OpenAI\n", + "import google.generativeai\n", + "import anthropic\n", + "from IPython.display import Markdown, display, update_display\n", + "import gradio as gr\n", + "import subprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "850164b8-5bab-402f-9e80-d251930d9017", + "metadata": {}, + "outputs": [], + "source": [ + "load_dotenv()\n", + "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n", + "os.environ['ANTHROPIC_API_KEY'] = os.getenv('ANTHROPIC_API_KEY', 'your-key-if-not-using-env')" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "87650c13-e987-42a2-9089-23827bc81ffb", + "metadata": {}, + "outputs": [], + "source": [ + "openai = OpenAI()\n", + "claude = anthropic.Anthropic()\n", + "OPENAI_MODEL = \"gpt-5-nano\"\n", + "CLAUDE_MODEL = \"claude-3-5-sonnet-20240620\" # CLAUDE_MODEL = \"claude-3-haiku-20240307\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9d359c39-4eab-478c-a208-08a38b799093", + "metadata": {}, + "outputs": [], + "source": [ + "system_message = \"You are an assistant that reimplements Python code in high performance C++ for an windows 10. \"\n", + "system_message += \"Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. \"\n", + "system_message += \"The C++ response needs to produce an identical output in the fastest possible time.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "1d8da092-6c5c-4c42-aed9-dc219fdd97bb", + "metadata": {}, + "outputs": [], + "source": [ + "def user_prompt_for(python):\n", + " user_prompt = \"Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. Add a pause in the end of the code so it waits button press after execution. \"\n", + " user_prompt += \"Respond only with C++ code; do not explain your work other than a few comments. \"\n", + " user_prompt += \"Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\\n\\n\"\n", + " user_prompt += python\n", + " return user_prompt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "be49c7dc-5c82-468e-b41e-7fca27fbb2e0", + "metadata": {}, + "outputs": [], + "source": [ + "def messages_for(python):\n", + " return [\n", + " {\"role\": \"system\", \"content\": system_message},\n", + " {\"role\": \"user\", \"content\": user_prompt_for(python)}\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "afeded80-a4a0-4349-89c3-2e9370730e92", + "metadata": {}, + "outputs": [], + "source": [ + "def write_output(cpp):\n", + " code = cpp.replace(\"```cpp\",\"\").replace(\"```\",\"\")\n", + " with open(\"optimized.cpp\", \"w\") as f:\n", + " f.write(code)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6a53a889-9146-4049-850d-9b44d7245b8b", + "metadata": {}, + "outputs": [], + "source": [ + "def optimize_gpt(python): \n", + " stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n", + " reply = \"\"\n", + " for chunk in stream:\n", + " fragment = chunk.choices[0].delta.content or \"\"\n", + " reply += fragment\n", + " print(fragment, end='', flush=True)\n", + " write_output(reply)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3d31f2e4-2bcb-4d9a-bb73-6979784c9234", + "metadata": {}, + "outputs": [], + "source": [ + "def optimize_claude(python):\n", + " result = claude.messages.stream(\n", + " model=CLAUDE_MODEL,\n", + " max_tokens=2000,\n", + " system=system_message,\n", + " messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n", + " )\n", + " reply = \"\"\n", + " with result as stream:\n", + " for text in stream.text_stream:\n", + " reply += text\n", + " print(text, end=\"\", flush=True)\n", + " write_output(reply)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bff0c7f1-6402-46a7-940d-5233e93d1089", + "metadata": {}, + "outputs": [], + "source": [ + "pi = \"\"\"\n", + "import time\n", + "\n", + "def calculate(iterations, param1, param2):\n", + " result = 1.0\n", + " for i in range(1, iterations+1):\n", + " j = i * param1 - param2\n", + " result -= (1/j)\n", + " j = i * param1 + param2\n", + " result += (1/j)\n", + " return result\n", + "\n", + "start_time = time.time()\n", + "result = calculate(100_000_000, 4, 1) * 4\n", + "end_time = time.time()\n", + "\n", + "print(f\"Result: {result:.12f}\")\n", + "print(f\"Execution Time: {(end_time - start_time):.6f} seconds\")\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b878f33e-9008-496d-b8f6-f844c22e6a04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result: 3.141592658589\n", + "Execution Time: 9.382045 seconds\n" + ] + } + ], + "source": [ + "exec(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "af8bc910-9136-4305-a1a8-a47fa0566505", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#include \n", + "#include \n", + "#include \n", + "\n", + "int main() {\n", + " const long long iterations = 100000000LL;\n", + " const double param1 = 4.0;\n", + " const double param2 = 1.0;\n", + "\n", + " double result = 1.0;\n", + "\n", + " auto start = std::chrono::high_resolution_clock::now();\n", + " for (long long i = 1; i <= iterations; ++i) {\n", + " double j = i * param1 - param2;\n", + " result -= 1.0 / j;\n", + " j = i * param1 + param2;\n", + " result += 1.0 / j;\n", + " }\n", + " auto end = std::chrono::high_resolution_clock::now();\n", + "\n", + " double final_result = result * 4.0;\n", + "\n", + " std::cout.setf(std::ios::fixed);\n", + " std::cout << std::setprecision(12);\n", + " std::cout << \"Result: \" << final_result << \"\\n\";\n", + "\n", + " std::chrono::duration elapsed = end - start;\n", + " std::cout << std::setprecision(6);\n", + " std::cout << \"Execution Time: \" << elapsed.count() << \" seconds\" << std::endl;\n", + "\n", + " return 0;\n", + "}" + ] + } + ], + "source": [ + "optimize_gpt(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8d37469c-ab26-452f-8efb-e1b65f842f90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result: 3.141592658589\n", + "Execution Time: 9.346793 seconds\n" + ] + } + ], + "source": [ + "exec(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "1164d9cc-7ad8-4e5c-98bb-a186ad23f4d7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\".\" non e riconosciuto come comando interno o esterno,\n", + " un programma eseguibile o un file batch.\n" + ] + } + ], + "source": [ + "!g++ -O2 -std=c++17 optimized.cpp -o optimized\n", + "!./optimized" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "d4b501d0-3707-4c07-95c7-7f6fe389859c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "```cpp\n", + " \n", + "omanip>e lude \n", + "\n", + " calculate(long long int iterations, double param1, double param2) {\n", + " result = 1.0;\n", + " long int i = 1; i <= iterations; i++) {\n", + "double j = i * param1 - param2;\n", + " (1.0 / j);ult -=\n", + " * param1 + param2;\n", + " (1.0 / j);ult +=\n", + " }\n", + " return result;\n", + "}\n", + "\n", + " main() {\n", + " start_time = std::chrono::high_resolution_clock::now();\n", + " result = calculate(100000000, 4, 1) * 4;\n", + "d_time = std::chrono::high_resolution_clock::now();\n", + "\n", + " << std::fixed << std::setprecision(12) << \"Result: \" << result << std::endl;\n", + "cout << \"Execution Time: \" << std::chrono::duration_cast>(end_time - start_time).count() << \" seconds\" << std::endl;\n", + "\n", + "d::cout << \"Press any key to exit...\" << std::endl;\n", + "_getch();\n", + "; return 0\n", + "}\n", + "```" + ] + } + ], + "source": [ + "optimize_claude(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "c81bf6fc-27b7-4f42-a2c9-42eff17b6e41", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\".\" non e riconosciuto come comando interno o esterno,\n", + " un programma eseguibile o un file batch.\n" + ] + } + ], + "source": [ + "!g++ -O2 -std=c++17 optimized.cpp -o optimized\n", + "!./optimized\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "a5e8e6f5-50d4-4c37-8a10-dd07fbd24089", + "metadata": {}, + "outputs": [], + "source": [ + "python_hard = \"\"\"# Be careful to support large number sizes\n", + "\n", + "def lcg(seed, a=1664525, c=1013904223, m=2**32):\n", + " value = seed\n", + " while True:\n", + " value = (a * value + c) % m\n", + " yield value\n", + " \n", + "def max_subarray_sum(n, seed, min_val, max_val):\n", + " lcg_gen = lcg(seed)\n", + " random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val for _ in range(n)]\n", + " max_sum = float('-inf')\n", + " for i in range(n):\n", + " current_sum = 0\n", + " for j in range(i, n):\n", + " current_sum += random_numbers[j]\n", + " if current_sum > max_sum:\n", + " max_sum = current_sum\n", + " return max_sum\n", + "\n", + "def total_max_subarray_sum(n, initial_seed, min_val, max_val):\n", + " total_sum = 0\n", + " lcg_gen = lcg(initial_seed)\n", + " for _ in range(20):\n", + " seed = next(lcg_gen)\n", + " total_sum += max_subarray_sum(n, seed, min_val, max_val)\n", + " return total_sum\n", + "\n", + "# Parameters\n", + "n = 10000 # Number of random numbers\n", + "initial_seed = 42 # Initial seed for the LCG\n", + "min_val = -10 # Minimum value of random numbers\n", + "max_val = 10 # Maximum value of random numbers\n", + "\n", + "# Timing the function\n", + "import time\n", + "start_time = time.time()\n", + "result = total_max_subarray_sum(n, initial_seed, min_val, max_val)\n", + "end_time = time.time()\n", + "\n", + "print(\"Total Maximum Subarray Sum (20 runs):\", result)\n", + "print(\"Execution Time: {:.6f} seconds\".format(end_time - start_time))\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "cd8a29a9-94fa-43f5-ae4d-517182cfd218", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total Maximum Subarray Sum (20 runs): 10980\n", + "Execution Time: 34.608083 seconds\n" + ] + } + ], + "source": [ + "exec(python_hard)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "39c64322-ef0f-4d58-a54e-c31077ceadb9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#include \n", + "#include \n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "static inline uint32_t lcg_next(uint32_t value) {\n", + " const uint64_t a = 1664525ULL;\n", + " const uint64_t c = 1013904223ULL;\n", + " const uint64_t m = 0x100000000ULL; // 2^32\n", + " uint64_t t = a * value + c;\n", + " t %= m;\n", + " return static_cast(t);\n", + "}\n", + "\n", + "static inline int64_t max_subarray_sum_with_seed(uint32_t seed, int n, int min_val, int max_val) {\n", + " int range = max_val - min_val + 1;\n", + " int64_t max_ending_here = 0;\n", + " int64_t max_so_far = std::numeric_limits::min();\n", + " uint32_t v = seed;\n", + " bool started = false;\n", + " for (int i = 0; i < n; ++i) {\n", + " v = lcg_next(v);\n", + " int x = static_cast(v % range) + min_val;\n", + " if (!started) {\n", + " max_ending_here = x;\n", + " max_so_far = x;\n", + " started = true;\n", + " } else {\n", + " max_ending_here = (max_ending_here > 0) ? max_ending_here + x : x;\n", + " if (max_ending_here > max_so_far) max_so_far = max_ending_here;\n", + " }\n", + " }\n", + " return max_so_far;\n", + "}\n", + "\n", + "int main() {\n", + " const int n = 10000;\n", + " const uint32_t initial_seed = 42;\n", + " const int min_val = -10;\n", + " const int max_val = 10;\n", + "\n", + " auto start = std::chrono::high_resolution_clock::now();\n", + "\n", + " uint32_t seed = initial_seed;\n", + " long long total = 0;\n", + " for (int t = 0; t < 20; ++t) {\n", + " seed = lcg_next(seed);\n", + " total += max_subarray_sum_with_seed(seed, n, min_val, max_val);\n", + " }\n", + "\n", + " auto end = std::chrono::high_resolution_clock::now();\n", + " std::chrono::duration diff = end - start;\n", + "\n", + " std::cout << \"Total Maximum Subarray Sum (20 runs): \" << total << \"\\n\";\n", + " std::cout << std::fixed << std::setprecision(6);\n", + " std::cout << \"Execution Time: \" << diff.count() << \" seconds\" << std::endl;\n", + "\n", + " std::cout << \"Press Enter to exit...\";\n", + " std::cin.ignore(std::numeric_limits::max(), '\\n');\n", + " std::cin.get();\n", + "\n", + " return 0;\n", + "}" + ] + } + ], + "source": [ + "optimize_gpt(python_hard)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "922f484e-4e16-4ca6-b80d-0736972e18f5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\".\" non e riconosciuto come comando interno o esterno,\n", + " un programma eseguibile o un file batch.\n" + ] + } + ], + "source": [ + "!g++ -O2 -std=c++17 optimized.cpp -o optimized\n", + "!./optimized" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "38009c18-7496-4d55-bb0a-bfcc7c6a430e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#include \n", + "#include \n", + "ono>lude \n", + ">include e clude e random_numbers(n);\n", + " (int i = 0; i < n; ++i) {\n", + "[i] = lcg.next() % (max_val - min_val + 1) + min_val;\n", + " }\n", + "\n", + "t max_sum = std::numeric_limits::min();\n", + "int64_t current_sum = 0;\n", + " = 0; i < n; ++i) {\n", + "_sum = std::max(current_sum + random_numbers[i], random_numbers[i]);\n", + " = std::max(max_sum, current_sum);\n", + "} \n", + "; return max_sum\n", + "}\n", + "\n", + "64_t total_max_subarray_sum(int n, uint64_t initial_seed, int min_val, int max_val) {\n", + " total_sum = 0;\n", + "CG lcg(initial_seed);\n", + " = 0; i < 20; ++i) {\n", + "uint64_t seed = lcg.next();\n", + "sum += max_subarray_sum(n, seed, min_val, max_val);\n", + " }\n", + "; return total_sum\n", + "}\n", + "\n", + " main() {\n", + "const int n = 10000;\n", + " uint64_t initial_seed = 42;\n", + " min_val = -10;\n", + " int max_val = 10;\n", + "\n", + "auto start_time = std::chrono::high_resolution_clock::now();\n", + "int64_t result = total_max_subarray_sum(n, initial_seed, min_val, max_val);\n", + " = std::chrono::high_resolution_clock::now();\n", + "\n", + " duration = std::chrono::duration_cast(end_time - start_time);\n", + "\n", + "< \"Total Maximum Subarray Sum (20 runs): \" << result << std::endl;\n", + " << \"Execution Time: \" << std::fixed << std::setprecision(6) << duration.count() / 1e6 << \" seconds\" << std::endl;\n", + "\n", + "d::cout << \"Press any key to continue...\";\n", + "etch();\n", + "\n", + " 0; return\n", + "}" + ] + } + ], + "source": [ + "optimize_claude(python_hard)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "9012f543-ab06-4d7c-bf5f-250f4a6c43bd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\".\" non e riconosciuto come comando interno o esterno,\n", + " un programma eseguibile o un file batch.\n" + ] + } + ], + "source": [ + "!g++ -O2 -std=c++17 optimized.cpp -o optimized\n", + "!./optimized" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "3a1e4027-3309-48d5-9387-a8b309a325bf", + "metadata": {}, + "outputs": [], + "source": [ + "def stream_gpt(python): \n", + " stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)\n", + " reply = \"\"\n", + " for chunk in stream:\n", + " fragment = chunk.choices[0].delta.content or \"\"\n", + " reply += fragment\n", + " yield reply.replace('```cpp\\n','').replace('```','')" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "bcfa7016-ce17-4a8d-aa43-9acdd884159e", + "metadata": {}, + "outputs": [], + "source": [ + "def stream_claude(python):\n", + " result = claude.messages.stream(\n", + " model=CLAUDE_MODEL,\n", + " max_tokens=2000,\n", + " system=system_message,\n", + " messages=[{\"role\": \"user\", \"content\": user_prompt_for(python)}],\n", + " )\n", + " reply = \"\"\n", + " with result as stream:\n", + " for text in stream.text_stream:\n", + " reply += text\n", + " yield reply.replace('```cpp\\n','').replace('```','')" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "56790d11-d24d-40ab-8f1a-5283726b5764", + "metadata": {}, + "outputs": [], + "source": [ + "def optimize(python, model):\n", + " if model==\"GPT\":\n", + " result = stream_gpt(python)\n", + " elif model==\"Claude\":\n", + " result = stream_claude(python)\n", + " else:\n", + " raise ValueError(\"Unknown model\")\n", + " for stream_so_far in result:\n", + " yield stream_so_far " + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "6d7c83c0-e239-44df-b977-3fb6a2398b6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "* Running on local URL: http://127.0.0.1:7860\n", + "\n", + "To create a public link, set `share=True` in `launch()`.\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with gr.Blocks() as ui:\n", + " with gr.Row():\n", + " python = gr.Textbox(label=\"Python code: \", lines=10, value=python_hard)\n", + " cpp = gr.Textbox(label=\"C++ code: \", lines=10)\n", + " with gr.Row():\n", + " model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n", + " convert = gr.Button(\"Convert code\")\n", + "\n", + " convert.click(optimize, inputs=[python, model], outputs=[cpp])\n", + "ui.launch(inbrowser=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "d9156094-3e06-4c3a-9ede-3e6f9bf94de7", + "metadata": {}, + "outputs": [], + "source": [ + "def execute_python(code):\n", + " try:\n", + " output = io.StringIO()\n", + " sys.stdout = output\n", + " exec(code)\n", + " finally:\n", + " sys.stdout = sys.__stdout__\n", + " return output.getvalue()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "4da83af8-c8e1-474d-b954-d07957f55c37", + "metadata": {}, + "outputs": [], + "source": [ + "def execute_cpp(code):\n", + " write_output(code)\n", + " try:\n", + " compile_cmd = [\"g++\", \"-O2\", \"-std=c++17\", \"optimized.cpp\", \"-o\", \"optimized\"]\n", + " compile_result = subprocess.run(compile_cmd, check=True, text=True, capture_output=True)\n", + " run_cmd = [\"./optimized\"]\n", + " run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)\n", + " return run_result.stdout\n", + " except subprocess.CalledProcessError as e:\n", + " return f\"An error occurred:\\n{e.stderr}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "55f3f532-aa10-4c91-9d22-e7463f9a646b", + "metadata": {}, + "outputs": [], + "source": [ + "# !g++ -O2 -std=c++17 optimized.cpp -o optimized\n", + "# !./optimized" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "56f3ba77-a339-48f2-bd81-44cdd90c9458", + "metadata": {}, + "outputs": [], + "source": [ + "css = \"\"\"\n", + ".python {background-color: #306998;}\n", + ".cpp {background-color: #050;}\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "38c17a7a-45c5-4656-99ef-556f7d1a909b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "* Running on local URL: http://127.0.0.1:7861\n", + "\n", + "To create a public link, set `share=True` in `launch()`.\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with gr.Blocks(css=css) as ui:\n", + " gr.Markdown(\"## Convert code from Python to C++\")\n", + " with gr.Row():\n", + " python = gr.Textbox(label=\"Python code:\", value=python_hard, lines=10)\n", + " cpp = gr.Textbox(label=\"C++ code:\", lines=10)\n", + " with gr.Row():\n", + " model = gr.Dropdown([\"GPT\", \"Claude\"], label=\"Select model\", value=\"GPT\")\n", + " with gr.Row():\n", + " convert = gr.Button(\"Convert code\")\n", + " with gr.Row():\n", + " python_run = gr.Button(\"Run Python\")\n", + " cpp_run = gr.Button(\"Run C++\")\n", + " with gr.Row():\n", + " python_out = gr.TextArea(label=\"Python result:\", elem_classes=[\"python\"])\n", + " cpp_out = gr.TextArea(label=\"C++ result:\", elem_classes=[\"cpp\"])\n", + "\n", + " convert.click(optimize, inputs=[python, model], outputs=[cpp])\n", + " python_run.click(execute_python, inputs=[python], outputs=[python_out])\n", + " cpp_run.click(execute_cpp, inputs=[cpp], outputs=[cpp_out])\n", + "\n", + "ui.launch(inbrowser=True)" + ] + } + ], + "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.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/week4/community-contributions/max.solo23/optimized.cpp b/week4/community-contributions/max.solo23/optimized.cpp new file mode 100644 index 0000000..ed96ce5 --- /dev/null +++ b/week4/community-contributions/max.solo23/optimized.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include +#include +#include + +class LCG { +private: + uint64_t value; + const uint64_t a = 1664525; + const uint64_t c = 1013904223; + const uint64_t m = 1ULL << 32; + +public: + LCG(uint64_t seed) : value(seed) {} + + uint64_t next() { + value = (a * value + c) % m; + return value; + } +}; + +int64_t max_subarray_sum(int n, uint64_t seed, int min_val, int max_val) { + LCG lcg(seed); + std::vector random_numbers(n); + for (int i = 0; i < n; ++i) { + random_numbers[i] = lcg.next() % (max_val - min_val + 1) + min_val; + } + + int64_t max_sum = std::numeric_limits::min(); + int64_t current_sum = 0; + int64_t min_sum = 0; + + for (int i = 0; i < n; ++i) { + current_sum += random_numbers[i]; + max_sum = std::max(max_sum, current_sum - min_sum); + min_sum = std::min(min_sum, current_sum); + } + + return max_sum; +} + +int64_t total_max_subarray_sum(int n, uint64_t initial_seed, int min_val, int max_val) { + int64_t total_sum = 0; + LCG lcg(initial_seed); + for (int i = 0; i < 20; ++i) { + uint64_t seed = lcg.next(); + total_sum += max_subarray_sum(n, seed, min_val, max_val); + } + return total_sum; +} + +int main() { + const int n = 10000; + const uint64_t initial_seed = 42; + const int min_val = -10; + const int max_val = 10; + + auto start_time = std::chrono::high_resolution_clock::now(); + int64_t result = total_max_subarray_sum(n, initial_seed, min_val, max_val); + auto end_time = std::chrono::high_resolution_clock::now(); + + auto duration = std::chrono::duration_cast(end_time - start_time); + + std::cout << "Total Maximum Subarray Sum (20 runs): " << result << std::endl; + std::cout << "Execution Time: " << std::fixed << std::setprecision(6) << duration.count() / 1e6 << " seconds" << std::endl; + + std::cout << "Press Enter to exit..."; + std::cin.get(); + + return 0; +} \ No newline at end of file diff --git a/week4/community-contributions/max.solo23/optimized.exe b/week4/community-contributions/max.solo23/optimized.exe new file mode 100644 index 0000000000000000000000000000000000000000..c4bda34af2785af7f0648197a6ed0f5866f3fc72 GIT binary patch literal 59675 zcmeIb3w&JFbuYX}(%AA-1K405Eyu(raYX7CeBTIqb4L7NAyM^geVP( z?tksaIdkUdVRUJ~=DR*WjrKlkuf5jVYp=cb+WWlf_YJdr##jM<)6my#o}qLEvzMbVp=4oRW}B-?s$8+ zWW|c5>m+Hvm$CLgy@=g+=;vK5&Dd`t$RxX#Ez8T>$Ovg8etC?ozX+*|S8_Wjp*-Lu zHyutop`#V0ix_M9CkNU^CmILKy2uM6DxpFN5qKv+qEKY{|31bZm!$dm7-P|_Vq5lB z#)@q~@OYB3Q7-rlg#eYL!@X!eo4f}9NFZuE+L3)|5Ur#=m<|F6F-0elZ115H^KgSz zNm3xXh?XC}i}52}W*u%&*jz3ET#pIliQfAJO#OEgy@a60bF;@^Z{ z*5T%Q2}k20*@t5&B)sMBf;ceT-&yUf6P2%Mk9LKA;p5t*~w?fgk$@>RrBpmNj()Uafkd zzIgck&vS79Yg(omlf!`X%|FAS8+3jd19^}=IGSGm44H4{HjS}~rO%MbWNtw|^U13T zZ*?b}`ryR_E_HsrI{*3-PUq<=qSHU+=qUo#y(sk!oXRX)EvFw}{|lNSLMbqIQGJMU zP>3-_Vz_)m&Q3ZXs9vXe2EI`@NkaG)%K8M`9c3gp?)3XF1l4QdBOa|(QbR~~sb{<1!2z*fqS#JjE8L$|o z+P=a1Gk}fy23y7^eMNu26or$%{(C1`&ts_8foekG%b$TRSmrZ-4DvUjq>h(7INDQ; zlbdiNlz@{YPJ9E;A-9L;PGyczrKP8xnIXnCg`yR_I`!nWIJ?@Y;*?cdPz41)f!{dI zU0(maZ?T>~2IzT!d;{K-Xu%25f|e6#!AajkE|fZ{6uN?~U4_#(J^a+eqmyUJ_MV|S z(_@(z5El@>;D_9AKP6PPx`{K$gBh&(-SjjWnD$3#`5;Vi(76On@C~hAgaidCXgjlH zF{kvmf)%Xz7as;-0Me}ZDdh%NpG7k0{5t;E4xB-?VKi>Q`E3sU7XCwvD+Zk}B8S2c zg4v++lmI(3)%^5ta0-)37#65O;zQtQX#Jk-lRwEmdCpDZc&DJGsiLP@$IkkF>7`sD z=RN~n5O~miqc23ZG39fN0e2GF$w9W0f-Hr5zrclYjIIGn1}GVjD|&i#=Q0P-mh4;x z{iZie?52`I_Z|IHD-SN_d?tJx)Hena4~`c7KchuYjZTyk41~s!jt{z{S?HH@P~Uhq zx|36qBRt^if6eC`imr1H)NAlS#e-h0f7IbS>N_=_Pd&E#D&A&l2keuYuZGJxXc8mp zE#MBV`U>)-fDAR8&`xD;q?$wvlI5aJ`i8E`BiRV?msb*t{9GJC$|b?e6^BWm;|y^a ztRIIBQ2j5Uem}-5FyHIdiay*mJw2UE47J95r%6bX5-n+&gkg~{^4*?g3gm_dy>P{+ zGV4hy7{64!^CYNF3#|=Xj^{f%N{X&N%xM>0?Pgm>vmqVBEw}9^Ef;>w#k*T1T_Pu?^Dh}Ix|+CQ&KMpxwJ~>2$s@Hh z=zu%U_y#}cAdl@E_(!y?=JF{&p&H1Q`gWX2e^mgX@v)*WjZJ*Pv)j|+X_mdB)rEfH8~A2@C{sP~wYq`H z`hhomFx{dDuObRx;++Z!>PZ$lyLqVmR|F)URp9M;mR2gtvIb7q_W$0IzSuY9E36x; zncDJ7=Gx22SG``n;a|7BR6SJhs1LoAV=unQ_f~XV&bGXA|MU7UV>kK+&es0=7j=%G z`36?~ldu1j!?WY%KlxtW(DL{B27a^Ul`W&DROm9y!@hh+?Z9a5hOxRGFV+^-P5O2` z=PPO)L)F5%9WV8a*A2XanwkH?rH0daK_i>++~Ik@=g#NRZ&}(X{?aO7ZJG8AybPsy z2fhNO3`_Yu1LwR0(9*vsG5<&A$=}0%9H;yLm!s!@_y(p#mk83ZgY!M6*C+o1VZre9 z`Zk$1$+S$S*U0o@ndZs#^`oNR4`up_OrMkKlRQ=SJVA5br>=#<2E|PNamx3PA_Q1$p1X96H^zUd0Us()$egVZ+W30}Co2EEpp?ufh{y z%9vP%k|at7TQGeTj7^XAcTYL`@10^jKf!?9!$%^f!QW0#6JIkx(gvL${8K)$6`gi= zBL|~nnNHwK`G%=|Cjn$M_;ASfmQqY9LrU;|Y6o~D;LA&|z}aIsQ_;Yhy!5;J?_J~Q zxfDKC8*EwQg9ntZHCTjzkT_1%K*}aeVm_Mx`n^+y6W0K53a2zR;K!Zi5}AjiARN@W zmg?;APW60))5&TZ`P%+_U989Ou%Z#Fzp~_qc=_oS_|M>uxj0waW&J$DK*fVQB58mv z0pI_L(Og1-b0I#`fLv)k%_ zKpqpw^f=%{SRIlQChBqWDRtt;$!FEcR-C-3POintzo?VTaq^ZrS&ozSL>bhENsQO4 zi(GDv=Zajt)DQmGi(Cm8WqgBs3Ps3&6~-tzKxiKoE~;Kv`g+kt_pB?%|MWVocHq14 z2B7@UoXvBYdx6f)qo^1yFQ%3kqviL%Kq|r9$L-~NKf;Q`)K~v&+eukuLeNo5F_tBz zbp!PPV(NsnLXeMNLayzU=OkuI_AGS^*!~@7dn$7&Njdm_iP{BJAu|L#if8fFY;eUl`bC6+h-zRA5lJ4+;uM%r2;g1=yK*HFB(3=Cx$t~z>IR(; z&4N+q7zHH_3jrt%R6()mfl5p!d`LU@pxO@aTSXs^(*Tu`!L=9^-0pdBk5NMb11)x5 zDd(-sJWGCYaK$CF@Pv`UPhiXpRHCz2yoSb7xH3Z{MZl7AxRmxL2i?m(1Ea5Bpg$JPVdm;84q`=VU1BM4W+{i$T zm+zlNKSGV8P-7v`j?aw-qpQR~T5;cOXpS>9ZU$Sp&Xu?tt?eWF{QspIeRCvQ(M2SShS{vu~DGInL1fzUVN@ zsr6r<9j_WI@WB;eB{T~Jkx)##?tG>h&YwG25KQc4Xu*3s7YlR%vq?%m|kD#vyd6|uJK(* zql&L-D8-y}@A%@PkNESU6=av)M_i^zRXvysXyH|WEV)W#3z2ow47A)pT4o@n_fi%# zGZSv)GN?&wZ1_Yt7qyBaLYYD47#r|@4p}(W6YT6!y+{9zdl58dbU9c}p8J5PgmGk(0jtJrvB)g(0~x+| zK_d@qKR(Kyf>e}w=vki8(g*vew4#R|=VyiKrTtT`^!9T+{zFTOo?@s7GABXt?!xu7$u!{oR{y=b^s$2+AS>)UVn2AbDta2m8RL6gB}HVe5wGsXMd?67nQoprDW zeU$d#-@*O;Q-$fp)Ja!N=pawFcG4pv8MOOh45Eo$CL9*S^>GiuH=A%}o9zU@%!Kpx z3Fy=Tj-l(Fq%lFeTx*IRxF5cnkHpvdOh<*is(bkE!h;kcVDAZM+^sbtlQ{%>2!Lmt zu=+=fuy`uK3|)}#_)iBM)Lo>iL1&6sdrmUc&K? zQ;s4fZ-#OdIZ^Dox|iw=VN-A5)buODH~9^XXxumPS>D-5h&+2L^CL8ooMCpbnG=6Y zr;o{un#wBAe~pITb< z&^DY=%xJ{EwVTlKGWOkxJdb_(@O@?(IA-=z=ThX42*}ZMB_B(oY zzz7z239PD;^1@iAUy*}`&z&;T7KvJ~NqZi222c%#AeTiSe0B}Eiyi()AqZMQlOYz4 zi@Bvt>;sFb!4?`+5tZ;y?)e7*c8`o_z=ktiI|WGv!7pJ4>_Y^ zAc($Qz5!<^&?ZPE0F-Dvoh09X3LC={G|l6Tny9KFo$|(ppV@6V?vfiZD!CWAG~pfdviT{?)uNM7aWXt|ap zKe_{LKo`7k5s0Y{;O6&T-)ZOLs6)qT=O<(ieD`xgWOsl45UFZnW#;HF;KK_uDKJH| z)hZorH~pn%dRgAZ#tyq22Mr|2oZIUXkpe^5#VC3H4Dz(M-hnN3b0?QnApCarUIPWO zKzA8DTq1IB%f6#YlOwGxlN^<%1pq^`4B7|kk=fJa-p0XivgBR zrJi~mN;cic0b*h_iA#+b*K87kJJqD|>?Um>S>a4vo|A>d2ZU4L55hCFf{3VAoK~%H z8xttEY?#9X@8*)y0OmH8XOR?FnGo_{M@2Ngu|Y4!C&sGsDGj8`$*{YJ8WkzuV==wuo$9 zeq|(CTe7e}5TudsX z@k{GK5@X^b>J}QLt0qnlt6o4z2!C~}-?x+Q5AqGwty`14+;{&ue%8N)`8M$!FFp8E z-v(TySi<(~RU2z^*5^KF(D~zaATh|~AQ^Oi#d6;Nnu`y8>^FXZE0H=IpsbPc5KiHO zUT_&C+JI^dIt{Z)25To8x){cUi@h!=2GKcf{}^%W^!mFo9n${0N*|Et^Q9k?c>mGq zv-b;m|3;>tkm-kHdbdpPlIcE~-YnA_WcnVNULn(^GX1wcLH}nw9T>BAU}pbMX(ctZ z;^VmZoY_q$mP1_b(=zYPVDYjG#hzyn*D}w^HxU#+`yOPUadGGMeCGb2(8zi*vldvm z@K<>adh6ML`gPz($N%yL&9~t!y3Y6OpZQMx<|f~%e_M=8GT4je*Yh|0BVE#Yg;#%_ zhSpDc_EhGHSBc_pfY(gYodCF_=;tpHp+WY#ujoDh_QitppxiarauVdJuVBoPt^5 z@=~_O&i(d>78QZhg<}p4Jf`!z#0(5tOVObK*?EGY(~L4Y&!c}?M=t*4W-EPGYCU(! z^D3G8bIP+wU&y`#8i+>PIzu5nrMDj}+q9*mJsM@Yo(y+JQt5C~@4$V$VLcM-hy&Ul zo(Y~KgS_cClne*cVJ($zzu|@h;ZQoB)S|&;XE>>)yMi&TJJ_qIB6o+2H>m2(@pLe% z)dzbc-96n}pr1j)2$VkmC_x=sSP)1%-b6d^`s;5nARNW4g;X2!l8JqJ;nUV za4MyFV-Q8BwbQc!pZj?F7YTnwsch3U!hD#N5pw1XB_yiu-d7j<4Jb*bcbVU ztv%iy#68a8WD;#Hu5PUN)HZBjMsX?<>+FFFBI!d~aiDe=%J|WEAe`)o#t&-AV5~E& zsyFWTHr3QM-nN1HgUNIRnu*5Ix_F0{igd;z9TBKG6xNFUb&Y`lrzG?@Ggh;Kg=pQ5|F*QbitcW%_ycW%(M;$%2|AQ;_=6U;t;{t_HDel7U5;WvQaJ^01(tA}0= zZaP>|PF>bdK+MbhZUyTjS|BrU*pCXgO& zkN2dh_qma5)Y3GR($E}=Hfo0=;b=RZphGlhy$6I7N|0B+IX#`4;iuqtqm1%b<43wV zfy_5? z6FKyDRaM=f6=M|cx^2^K7=^vtEA)!;P2H&jp=5efBA$x$Vyty-)Y^I?@EL7~w8~^S z)Roo(!5Ail)J842b%VC0yrisz!hLpu-Ua<#u$K$t2i9~b7!|J&mO73xyV zi&&YtoAE=w6?wnR6AtZ@&@o z4g6oJ0bEOh&%h-Ik;1RALgXoZ6Tel+Q%cX@YsgdDj9)eKl=k8#>MrCdy=N6397CSc z{?)kc2YE`L#P7q%k0L#V-%;epkbV=tN01*!`p~6#3>^7kq+iGH1oG@M#uE6AB2Ou9 zH()O#--qCjqdO2gC!ms?JBE9Si_*dj9y$QcMDZ{N#$B?J=2UkN*@vIE0a0Gem;iD0FF9PzEV$Ys^4tYwkZ_mDnJf+yXXJ?S7^d9`i zkRRE?*r)OP;xKfF^eOz_K%Ua)@hkW!@R0uZGPDtS%!lm9_&Vqc0 z-%*(FEG(lO?27VDBEKXn--kY=IL3JqV^`uw_DbnYIOTxfEO991G+)W0uXrsh@Gi?= z^gv!|jtt;Kyc{bQtzVH}SXoe--!a81)RkNY;jqBXJD)rc`m^C=!#^hJD1E4u z+I(?NS+*WvKNpU@3(gU`GIR|GkOVd=mN3n&;WMF$sS|rUjo9 zrK@DRPNr^|-XYV&G98iWs7zm$=~Fe<;(R z$@C4Gz9rK|=pQ;(%5;rPuaW6SnO4ZuEz_H2+ALE+1wQ>k|8Z6Pq4wY7`TD+wTLS5A zq4c3dxHjb7vQ@9w4@TOTSVxJrqo(Nw&Y`Wo4zREETooi4p-p{KCZq;1M>Rw%?^Ic zK`xlR=%`7C!*!9iWH5P%_2=yhr|ZxpFWnx%*k90jeZ0LV8usBjS~ToI#7i(-jSk66 z-i&=TzZN})tN*xGoXgFP0i(Q1nL^ME3ZMGlN;0YBWAgPUhU*Il=%g5Q+0 z3N#k-yT#ko;H}$Q#)&|bV$k{b{)vmniX)g_I4)@5f(HI`YQPP@0?Aw>iIKjM;gO>w zBO}aD9v;V|g^#)(UGr%1quR03WA0=AW39&$$NG*99~(J#;@If1v18-MCXcb>uH)MA z(&O&q{^PC36UY0G4<8>ne&YD(@v-CM$0v^uKXLMju_rQ5Og=#*FC725G=MEZmd8b+ z2W>D_$@_E5_?i75ZGq8IFaMk&w2jQ~foTX`9rq zgYGJ$dlxr}`;fIw9kKYPR5}>izlrXyGjztvCv%JE^(Kv2;%KbgLcd2tjLmBot1uAESBKI*zP_zW1Q4xuwCY z2daGD>XtfhHq7s7YOeLv=}q2UdbQW@#eKRBRePBut5(3P&w`aVJ64TfuWD?-t;fxQ zY`Xcg*O&>tz(lY12AcI6PaULzoO(@TlfDZtoOGHP0Tc!Nb+ygZm;hU3mMHOS>O8x6 zO9RcGx;nPl#HerFy@wTMoqOvWoA&DUwSjt1bCpjQ6_%I?H7(#)Rqxk54b^&Olcxbl zTg%wexiKor*|NDY0*xeOfGy8K^VGFuv0^LCVoz07OMOe7r`fAFwlwc*tZmq(dzwIE zrHSKjYOHJA)#BA#0#uCFdRdWK?Df~$id|+gHMP#`L7j_CpdW9e((AdJ*u^H8=-0tu zP|7Yb!PSi|l?uGd1S{-DKU-}=6*8cgnoz%|S`YXdn_vYk4OPvxjScKFYiX0WxuvNg zz}A@Hn#PtU{pJ?*Q(bL+Z8N*vEP|$+Z}T)k)+TR_7oAL+sq{8@Yig@7BG?rsYF(9I zTELYiu*nO7>Km(TYxc6MOfV^{wxO!pTgCp!gw{4Rdv|%8^y(Va@bV4_us=4-8~x3? zXIBfm+5~xaH`Z2@-np%Ns;isu4rg;LAZb45z)=L)drb^6MOX$v)?~$QG%=}9Ap;tsXJhP~5kpO1?0sf&fCi~Q;A^R=WH*^$ zVOiysd*QNaJk{=jqTFUV@!jQV_CX#DcfFC@6oG#cv>mIcI6hAZL7#C_T?6D+ftTQTx%BZ zE~~DAr>Sn?K3{n2Cfx^z=&xosn|Pkxd%$8gyT4@)M62o7*)X$$ih4^ST5ODi21^M^ zqQ+9Ar3CHFj#B)VLaN5yC5@0;Zx!s~RvUs4*TiVDU=aNr5&;`RE{SFnLr%W8)i(Qd z=$N&bMV`9bJbMEO!Vn?qh>H;MY`>oEHW7q_C0}3XZD6;V1p!}eP4gDE$As+j(oC?Y z83Cs*cr{eBy=FNkiuy*359w2Brepie;u;V9xfna_b`zX6C+oL0)i!(C9cCfdO8pjn zcdbW<^Lf8n($GkggWprzFcnMJbIq+=E`!NL&h8f6F(#YlEFxq=c;D=~1-%`aACWi<tPAGY@+q1W!W_5D8fA) z9NW``u%5yr>$#s4E!RjAg@d+NVo6D!ngjRH@DU3heqI^4&EsccNy7nL418?Hu}H2s zo=9WO{2td%EJO>w09}0tzhw+!^SQFF7GqOqn_mVLuxgq= zC9ITSyh;)F0G59gi&O_&MAbjId>a3kc1+|ylu-5Tj z=Z>|D9GAc{9FE#cDB~YR(r{22z23ir!_$P z{7zQLaC;}5qvN+LS5QJbf%qYFHQyYr$9W#|MR^e_;s3Cor8bN6-(ZewuIb!c+H*^1 zXX(zmYp%(2pmH^EiS~_DXC~VD-$lu_U{rx0r(dv_*oNrzF3KICe?Yo${5xrY_H*eO z6ZBWFwtR8nh}1S+7obCRvAQ1MS?PKp&$Dt(Uw&+*Yt*x{@Hv5Z;r}0|21-gci$Ade zzZqNj9g)t>k*(V+Hir&%9*o3F0<7tVJCLDU5_Ig%cVfR@7uWbJ%J0D2LpF)Wzwh9i z`Fb~s58lx$o+HPL9X4^m*0MVU2SyhUJOQn&q`dqOQ)U0ZlKLI(+BuAg{rebGE=OTw zWhEil?B>~QcC%@-o3m_ov)yJlOPkGM!*b4P2!Uqy;9;gDG?q%bSZ7;w6TJv0g}hn# z|FtodbVP8?3b(xD_xovvr6u0`5bg~_gT{edx%e6GglD)jp5-$@=;l1k?FxcByb=V# z62Zj5TVNPN$R{CmTNr`p8nU2+4BL;NhMx%`(sW(Yg!JL8*aG3pjJnBjGvV_~*f)k1q|+gR>quee>YF7dVM| zaBc-o>pVD}z!{mR-#-GJv3clx4mhRr;CvrAqx10kEpU2a%%Zicvxw zgnn!&Yzqos1z5;q)uFj(Zs(QzV7;m(ZytM24q_=I>rJi zKZ$Y+q(Xx*5+W%V+9(g(C?{-`PuM80vQc)~D1X>SxywfRF&pKxFj1?_YiyM9kg38E z`q|cMqda1x{PKBFK5V1B$3~g#$f{?GTjrCw&qmpAqdaV*JYu7)*|c$wjk3>1`G}43 zVH@RQ8|7XbWw(uTpN;YzHp-%Ij>D z-8RZm8|7jf=HZ6FY~|c%jsX(lWsQ8b4gt7tWvmIc zKBa1LV)T%FD>Np2FG*!is#K4T`++lp6iox3ju*pH6mS{BSZkyw_8+ z0_wt#%agM<2bkICZU~lhs7Q}iqYw+c*5zP;j*RpsQ6lCY!a=ih4w`o+K}58DhIvQ! z1vX7&U&MlGz7{q+L&Ys_t__kWhY3zq+@c|Gw%v-S+I|9HuICx(Pz{pV4TSk*UV{3< zeh%XP>rgO>FjH}SJ2ID|l8||ZzGzFOi01joO!Mh{GGA`UjF(i?29zl>qelq|B=kJ9 z&D+~$zo4l4!fmvRT3|iSr!SNp?t#q04r%OI4`qj|fFta1_V{P~JoNJ}LqB>fe2|`q zG!>-U?mrJZbVE$hr&f9C%-(i;zY`wWVJVtCU!UG$$c#sIQ#}b&Vg^sr+pY&e%q8gv z$ldUc284JGLBXP3Gxs~;JOUgIq6&Ft_G6y~&MytGMYX;Rhzmv{R!MdpE{60#$vWPS z{fwfX7|Uo*&QSt&C=huju~(@eA|;%4`}Xal*361i)zrLhPn~DnvI~(zN8s$6nhPf> z9W+`jbXW=^WVPl|!s%3djQ$c2m6!;~Nt}H~56*Phs3F#oCAl@$)5Yp!=76}Uij7Cn0P?hv}k2Nt=yuhPqPG(*|%dqW2htS zXZA5Tb{;Z!8ZzS{dOZ7_z4!l4%RFw#EE}Aah`y-xoU!yp76P&oXW!X*ajHBg=EvDL zItLDMrheBjxP;Bm9s?XQbl8nI6PSHYG}N2&MZeGNqwIRV8Wd?hFpsxm8{?=ZY{RUt za%zq51_#kD$`Q7CsQIf8CFJ4q9dymcdZ;m24V?Mruf%!iupe~f*hzP_;=} zDfxEmp)A1<@O(4%IB;fbsp{oN&PEpJ&*_zX4(P^w*(0A+t84W#YRG2v9?* zN$})-LCo1dqt=uKa*jG-g^D)_XBvtR%~+VtDevmwtM(bsE`Oz3cpO+ckX(zDPZ;Sjd< zARXc!<9U6;Ss=5XjI)ln)2Euzt{Hr|jHnC1LG-CLvLKdfe2t_1)NT2W zjrgAmSnz0IPJbEg za%{KIpcCcCXm3#Tm({0o9N8CV&_dA{gk$elvggV3=!>P0OWfX$Vvo~*WsPGXLpKZ8)Ol}Hb_4-+gT6lFX|=HUvw{x z{U9Gz3Ss8+QLToa#Tre%j?c12dwY7GeJ(gL$9Sg}kj#DOA#>7@S=SS~cq3p*$kf4) zp&uc$HtSt6lfW5=s6s!5sBEf{EYfacWYs1PaZ@&yK%VO4-et;h)RmDr+OB-v;~*k@ z9m!)ol&@1TEw_JQ3yp+mZpay}g<&O?V92B5HwdPrtHl#e=U=#a|)fiz|u>NS~$&GVA$f#cGI zR%eQ=2r5}Mq z`q_wD7?4?q($5HBq?NhG@+hi`b!8R-nN?$X%+L>wQ|qDh^RS_x*~jweT>6py-lvJy z;NB-06`TM=-U{O?o*}bw$J8X6K>cgpF+~P%ft0(^QVXP_0-Y`)lKYVbaeu?cz0k(p zXXD;r<379~?o&4IE*p2hjr*PN5cjui+}GH+)750F=I^p`Kf0i{6Il!8ZJLdHtBpH8 zS)gjkejiy7_W~RDVjFi_^;;yY_>hhJV+-P5XyaaL38~4!#Y5po3 z_dPc5M{V5C+PI%t5O>YSz17Bj#K!%HHtu5!;=aztz01b^F&p=v*|?uw5cgsm_k@i* zMQA|7+(&KP7nyUD^z)Mo z;$Cj!e#FN8jE(zB8~3RNao=v^K5XMYX5+rb#+|KQNMuF3(pJqMwQ)ad<9>~ed*On( zyKUS@Y~06f+&9{|yB5T~+Q$7c8~2Qjdxeerngwz9*|?vuai6qtciXsY3*ug9<9^b{ zeagoDW*hh71#$P=xR2Vn)1m-qS-y@we*p&X$f+IzGfwsyU(Rpj?g`;qcY zDw$R9l$WCCICll9xYjnuZC|?(PkYwJJ!9iuY~xN(G)Z}+t-2S){aZHf<2LS^jr$@S zci)1zkJ-4NwQ*l#7wn>w>tyVB~Uw#nk9_P$gr z9AKJrywkA_?XUA*o+Gv~WtP#-wk(-t+kY`f+f@uO@*mf(^6k)_Xczsr9;y{ns+Z@8 zZN`;tIB?l3=TKK_F2YqR(eHRQk$MvX-glzV&*2IJ9YCX?5XY|p8NY^N5^d(l^FPoM zNFK{O1ZKIPjp7<1GeyfVewu`G4ti3X-XwwqIMiPIK~HLvXCn%^PrEDZWe6mPEqB!0 zdC|22jW%13h{ z+xl{AU4K+r6g`C$((x3MdUgP)ILfmm6p#QQt|h`+1Z0qK&>)gfK>lAql&$75_0_>b zORdiWhYqSCYCQ+Yh-^F6qVE&pu+;hnaC{bC{}T|m)T*HKb3jUwHRV}}i%z4!F(Fq0 zqM|`jYdavtU}xeq)1@jH2KAM|IRHqPg?m3B30W?19;RA2AhxXaX+ZoIc}^3=pbX7N z^&m86w4Lhz1URLZwoe11W^=)7IoyD<9|6$-Ibmo+eOFNI;cHT!om2}ZJdH;@MXeS< z==mlS5+eu>n1{qU49KvS-S2wYB$Lip0I{~~JAf#Ujb5gr=; z(a>L_FVy!N#cmrzN3o-S9st^vet(MAa%beJuzmJqYwn*iyu zXoGyAcm`Zi{(Gur(GR^``7nN_HhxYx78_fPvk?pBD*!oR(MAa%FQB3+j}MSO3$Fkm zZs1V6=?8fMQL8Nh=>cTY(mNjkZwb+b#Ne3J@25W-DIAnR*gXP(BODD6*yw ze+fvRmTh%~7r~+|mU%58rAAA|mpoyayq41HF5vW8Wc~mkCU;%O6T^7BH67-NyPt3@ zkUs}xyG6p!1EOMM(TcAE(u!JiCLlirq|cBLVD=^;nnj*P7sLBmD6ay<+RN_&L<3Mz zR^KWe1Bl`c!K;#LIkNR!C+V1)zY~xVOTX_2q}Za>VL-+#IFA6LcBBQbzXrtgnd*b4 z;}&^N17{R%he%Swp97+HmIR#@^x7MKpcM|f>w~b(Lwtc2V{mOYo%N_SX=qh_?R5;* zOgpRq&Iv$-#)x7SAV)0i@)N`|zU~C1(1Mc$L`Bp><_`m+W_$tpD?rrxR6srp2wg7_ z^1wewC@N4-CJLM{181E@!tVfL^{YPxL^E1Sttf;rZV)g>%2t9{aBc-;*n$%!9Mm@T z(+kL`0a0J9b#Xl_i|QvFqZL4Ap8({9p)vJMTg_7Ial)~1KLv{BOUnRx%z{%3h~Gl_c0dvqNE{Hg&yUJD?g3=j!hHacF$=H90AWBk zy~Gy)IceekJwT3VWUESt=KxXrHiB3FrI5$qrM?KrlJ#Ya;xccfedoTFN{<~2ah zT6k>)q}8AdIw6V}O?xKp9^e#PIa0*1djUVH0@`aBkrTX zc}&Ze@DV`9EfW46AbTv3e*k2}QtRsku~_C00O_^J{I7tVG&Bam*zW=9Lki+j=8NEN zt^K|okfRpvHv^KfKy*Mf1H$_~1RM*m4-jSW!L%ZI-3Q2|Q43)9Q9%3_ndzCEQdtA2 zI6ec&8KkBTUj$^0rPg-R`qKBL z0Rb|z_s&|XWszqyAfuMvc^@Dns7-AW?P>;u4%4EdHpsnzj9Et9!+@we`~{sy0Xbu_ zv7DC5ubhu+s$InOY1A^KO7T8Tj1&vbOTak_TvO)%1qhv)GB3sRPjr}&YXH$K+PEGN zAF7$NRSO`k7X7pXvfbz}^~LlxYqMp(7dU4ubcO*Lw$S+$Af*XJ0;nnQ9#@l z34Z{{QO-;C&aVJ5^+UBTGaeDq5T#%sanDF4=CKJl35z^8QZ2(vsIR^kTiR6zoL-|{ z;yd#gO1-9->!PGyYm5&H(RsqW8Pw zV>bta(MY==LUf1I;iNAZYmbJL49~plA(Tea@{z)ICCP9HK0Z^TYJ#$!K9qn&e5=PS z@1Q3?ZBTg^x(!~B&m7`wiuA3$x;lJbw6X=?$mAbjYqH_W2N;BKU_YaH@})Vp%I$IW zjwE(lBvy~NTVWX)pm!ekB#hS|AB5g41-hQjf#fz<$LpdZ2k>OLAf@At2m5WzbCH0Y zw(Cg5o;C)ENP~8YeD}(ZOY@`++I}d;Hx)=>IxR`s@MT^bT4$_B5BG+`cx7okrk;hh zVM)V@N85p$FrJyU<3+mh00-|Qyi}Zpy27FTc!vhJN}bHoCZ)2-NIIHMwd1qFdPh7N znn6ugM6~UE@KQbT+3;$+F;pspsW5BrNkk(d^o^cKU=(49U|iv$b^5-BTLS5AAsUjkA@BC~xPCCw9*%iK*jb#TD3C5k^cSrS1=3r# z&_}TJbTSx8r$EEo1lZQLU@8*QDlU9VUc- zl|Y%D>8`Us3`Pzh0*8+m5>wSIw_vL$H`(9-qp(QgmQ_QZCc_DQk6XvPa!`sM2;fOr z_>L6v$^G=M4DLw|CL`$}eNr3mQ308-jtL^t5ec^|3~B};p(NZLPaa}ulXyi31_QuQKMjqxt*;ywKU+vtN6}mz}r&Yh!6eMHCBnQq0yHQ z^|w<&$JE)93McD>=`L@QG$DKthDr)j0}34&P`oWB>n##YpV_fW8hBt{50M5qMR6u( zw*BElyqEPT`~(nme1*lt3bwcF3d2^IgdQ;`WtAJ$p+f_1u+^LE0>-?M{dN?5&^<*D zH|x78On_rFeWhN551#wIvd@|IwDM2`g*Zx2yTWOSR})Wq+S_3XCU3K_Dvl1$q2%oi zgFSHk-Ynj=sfKt=8CGqqswbHY$I=|ZU>c6~bnBRf$VBm^X)>5Rgn798?S@(ucJYvE z=6EeD_!2>x`QW16!uXsh0;KF`^JYO*F_W-0SQYGohiiI5#cReiO|MRzqgasWoD)Z% zyLeXKWFETZ@hzN-*-i{J>x`!JP_#sRL#1NdwyoP_^Nrzc9sBwm16k+uPc&6~ezRAo z8FSY*-G2*7Ono6XqIEJ4j4k}%A5O-?QGC=p2xSTjrsu9ibO)b-QJDQvML|VwA{Z`L z%_g#RUqc|iL$3!xc#w2$J58+dW}+4A)@lCaQ%@kAZi$IU3){Ua3ag1k5g{AVc(7-U%gGyB<0m18+=-Sl84uS|i|Be2pJI3exs5`qvQm_ECF2M6XgJoH z?hW5F$(rkNTSv4f z)#W|Fc1N&M2}W=231fmpr*Rn~h72YNi;oeV*${|q#oz`N+5N%pR3~D6tnN%oViPcj z4vZG_GU9jBNX%YR^PX8}_9@rw4%^Csw{vTvCyiLOIhul%V6y4KSp=Eo8YA)H|%?Q)-3 znM@+57wW>n12fqFOu9Qy_aerx&0x$H&2De12gEo@7@~tD#&tYp8PIB!WV>m@Yk6bv zHnw3s_r8VFxLmr+QzN7n{Mw`b12mLXoQw#oGuDkThC3O#tpJxr8xRP2gQ+-{h~%pg zTvGThnuaKvb{=>gqARab(4b0Jgy6qp@vZvqvMpuOk%ef3VrwjZkehd{r`b@AtQ|^_ zP_t_mf%Cy|a6dMJa^`i~SSsm)x22g1D_Kx6=GE*e%bZzr*T7=$OWCX1$${giDOmU? zG2rEcNqy6}=jB zS*rv-_aZec~C)oYFQv&|t`%x*3`q9dnX%BtOF>KPFZ ziUz?u^AIG*RS7*M_&a`Oo6s^fN$VXwTX;yRXwdjp{y`1f+`S}Jw+-Bm9z=goE)Pv* z&xNw2o-{7lQ1tQm`oJpHzyZA+N9!<}@+$7SogogaC7lYDV!HwMt4Qrll1vGmsp`x@IB8ja2 e;+Hzq42A7Rez$^jO8l-_YO}e*5iZhjD*qee%m>E+ literal 0 HcmV?d00001