diff --git a/README.md b/README.md deleted file mode 100644 index 4d331d3..0000000 --- a/README.md +++ /dev/null @@ -1,16 +0,0 @@ -# Workbook_00_Submission -This is where your Workbook_00 submission will live. - -## Instructions: - -1. Create a **fork** of this repo using the "Fork" button at the top-right - - - -> Forking the repo will make a copy of this repo under your own account and you will become the owner of the fork. A fork allows you to independently make changes to the repository and have those changes be tracked in your own GitHub account. - -2. Clone **your fork** using GitHub Desktop (like you did with Lesson_00 and Workbook_00). -3. Inside your cloned "Workbook_00_Submission" directory, create a new directory. Use your GitHub username as the directory name. -4. Go ahead and complete Workbook_00 on your computer. Once you have completed the workbook, copy the .ipynb file from your Workbook_00 directory to your named directory within the Workbook_00_Submission directory on your computer. -5. In GitHub Desktop perform a **commit and push** of your forked Workbook_00_Submission directory. Now it will be syncronized with your forked repository on GitHub. -6. Now, the fancy part: diff --git a/krogers326/.gitignore b/krogers326/.gitignore new file mode 100644 index 0000000..b6e4761 --- /dev/null +++ b/krogers326/.gitignore @@ -0,0 +1,129 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ diff --git a/krogers326/README.md b/krogers326/README.md new file mode 100644 index 0000000..3eadc37 --- /dev/null +++ b/krogers326/README.md @@ -0,0 +1,2 @@ +# Workbook_01 +Python course: Workbook 01 diff --git a/krogers326/Workbook_01.ipynb b/krogers326/Workbook_01.ipynb new file mode 100644 index 0000000..0b31ee4 --- /dev/null +++ b/krogers326/Workbook_01.ipynb @@ -0,0 +1,748 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 28, + "id": "72bdb903-9877-46a7-a320-183c813dd6aa", + "metadata": {}, + "outputs": [], + "source": [ + "from PyNite import FEModel3D, Visualization" + ] + }, + { + "cell_type": "markdown", + "id": "f54dc2e3-fcb7-4506-ab0e-c8db04c2a962", + "metadata": { + "tags": [] + }, + "source": [ + "# πŸ‘©β€πŸ’» Workbook 01: String and list manipulation\n", + "\n", + "This workbook is about learning how to manually manipulate string data that is read from files.\n", + "\n", + "To do this, you will be reading data from three files: \"beam_1.txt\", \"beam_2.txt\", and \"beam_3.txt\".\n", + "\n", + "The file format of each text file is as follows. Values shown in square brackets `[]` are optional data and may or may not appear in the file.\n", + "\n", + "```python\n", + "Length, E, I # Line 0\n", + "Vertical (pin) support locations # Line 1\n", + "UDL Magnitude[, [Load Start], [Load End]] # Line 2\n", + "UDL Magnitude[, [Load Start], [Load End]] # Lines 3+ ...\n", + "... # etc.\n", + "```\n", + "\n", + "All the lines below the first two lines will be UDL loads. There can be zero, one, or many lines of loads.\n", + "\n", + "File format specifications (aka assumptions you can make):\n", + "\n", + "* The left-hand side of the beam always starts at `0.0` (i.e. it cannot start at a negative x-location)\n", + "* If a load line only has one number (i.e. no \"Load Start\" or \"Load End\" values), it is assumed to run the entire length of the beam\n", + "* If a load line only has two numbers (i.e. no \"Load End\" value), the load starts at the start point and runs the rest of the length of the beam\n", + "* Only the first support will be a \"true pin\", any remaining supports will be \"rollers\"\n", + "\n", + "This Workbook is designed to not require using `if/else` statements or `for` loops (those will be coming weeks). This workbook is focused on manually parsing text data from a file and putting each piece of information where it needs to go in the analysis engine.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f5c44721-63e5-4780-99a4-6fa40901d6ed", + "metadata": {}, + "source": [ + "## Task A\n", + "\n", + "Use the \"file opening\" template to open the file, \"beam_1.txt\". Assign the `file.read()` data to a variable named `beam_1_data`. Use `print()` to print `beam_1_data` to the notebook.\n", + "\n", + "Review the description of the file format above and mentally identify each piece of data in the file with what it represents in the description of the file format.\n", + "\n", + "Do the same with \"beam_2.txt\", except with a variable called `beam_2_data`, after you print it to the notebook, also." + ] + }, + { + "cell_type": "markdown", + "id": "19aa1c43-12d4-45c8-bd77-bce104bd644c", + "metadata": {}, + "source": [ + "## Task A response" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c59e694a-b8b9-4d94-9d56-71cf208f4f83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4800, 200000, 437000000\n", + "0, 3000\n", + "10, 2000\n", + "228, 28000, 756\n", + "63, 100, 200\n", + "15, 0, 0\n", + "35, 0, 0\n" + ] + } + ], + "source": [ + "#OPEN FILE FOR BEAM 1 \n", + "file_name=\"beam_1.txt\" # Same dir as notebook file\n", + "with open(file_name, 'r')as file:\n", + " beam_1_data=file.read()\n", + " \n", + "file_name=\"beam_2_us.txt\" # Same dir as notebook file\n", + "with open(file_name, 'r')as file:\n", + " beam_2_data=file.read()\n", + "\n", + "#print data from files\n", + "print(beam_1_data)\n", + "print(beam_2_data)\n" + ] + }, + { + "cell_type": "markdown", + "id": "71243b7c-2b2f-49f3-bed3-879cb7f46021", + "metadata": { + "tags": [] + }, + "source": [ + "# Task B" + ] + }, + { + "cell_type": "markdown", + "id": "04fdbbeb-6cae-4870-9839-62be15de69a0", + "metadata": {}, + "source": [ + "Use `.split()` to split the string in `beam_1_data` into separate lines. Access each line in the resulting list by using indexing and print each line to the notebook separately.\n", + "\n", + "Following that, if you see that any of the lines in the list is a string with comma-separated values, split those values up into another list by splitting that line with `.split()` using the appropriate character sequence." + ] + }, + { + "cell_type": "markdown", + "id": "53cbd8ee-59e9-4061-a171-08b31c2a7259", + "metadata": {}, + "source": [ + "## Task B response" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "61228527-a0cd-4a6d-8a51-cf63b4b7dcf7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4800, 200000, 437000000\n", + "0, 3000\n", + "10, 2000\n" + ] + } + ], + "source": [ + "print(beam_1_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "9d0a8eb8-8fcc-4ce1-b804-c1c056a8fc33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'4800, 200000, 437000000\\n0, 3000\\n10, 2000'" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Review format of Data\n", + "beam_1_data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "64ca04c5-d381-4eae-8033-619ce0dca522", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['4800, 200000, 437000000', '0, 3000', '10, 2000']" + ] + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list=beam_1_data.split(sep=\"\\n\")\n", + "list" + ] + }, + { + "cell_type": "markdown", + "id": "b2d4abb1-abe5-408c-98ae-230cb9257c85", + "metadata": {}, + "source": [ + "# Task C\n", + "\n", + "Using a combination of splitting and indexing, assign each piece of data in the \"beam_1.txt\" file to an appropriately named variable.\n", + "\n", + "For example, you might extract the length from the file and assign it to a variable called `length`. If there are two support locations, they could be `support_location_1` and `support_location_2`, etc.\n", + "\n", + "Try reducing the amount you have to type by assigning intermediary values (e.g. the list of split lines) to intermediary variable names.\n", + "\n", + "Check the type of your variables by printing the result of `type()`. Are your \"numbers\" numbers?\n", + "\n", + "You can convert strings of either integers or floating point values by using the `float()` function. This will \"cast\" the string data into float data.\n", + "\n", + "e.g. \n", + "```python\n", + "length = float(length)\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "id": "a5f79e8d-66ca-4ee2-95ab-fc66f969f4c2", + "metadata": {}, + "source": [ + "## Task C response" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b4994ee-a33f-43d1-9b22-608f1681f53f", + "metadata": {}, + "outputs": [], + "source": [ + "#Length, E, I # Line 0\n", + "#Vertical (pin) support locations # Line 1\n", + "#UDL Magnitude[, [Load Start], [Load End]] # Line 2\n", + "#UDL Magnitude[, [Load Start], [Load End]] # Lines 3+" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "6db68086-f2c6-4830-a84a-6a6825e7969c", + "metadata": {}, + "outputs": [], + "source": [ + "#break off first line of list\n", + "LEI=list[0]\n", + "split_LEI=LEI.split(sep=\",\")\n", + "\n", + "L=split_LEI[0]\n", + "E=split_LEI[1]\n", + "I=split_LEI[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "88a72484-5ed4-49d8-8fff-edd8fd1e48d9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' 3000'" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#break off second line of list\n", + "vert=list[1]\n", + "split_vert=vert.split(sep=\",\")\n", + "\n", + "vert_P1=split_vert[0]\n", + "vert_P2=split_vert[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "153f296f-e781-4e5e-b25a-548d68d84e49", + "metadata": {}, + "outputs": [], + "source": [ + "#break off third line of list\n", + "udl=list[2]\n", + "split_udl=udl.split(sep=\",\")\n", + "\n", + "udl_mag=split_udl[0]\n", + "udl_start=split_udl[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "ee84a517-7c06-4fd2-839c-eefc717ea578", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L:4800.0\n", + "E:4800.0\n", + "I:4800.0\n", + "vert_P1:0.0\n", + "vert_P2:3000.0\n", + "udl_mag:10\n", + "udl_start 2000\n" + ] + } + ], + "source": [ + "print(f'L:{L}\\nE:{E}\\nI:{I}\\nvert_P1:{vert_P1}\\nvert_P2:{vert_P2}\\nudl_mag:{udl_mag}\\nudl_start{udl_start}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27a0d8ea-7fbf-4ac6-9d86-689ecc478cb0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "9dc9a70d-56cc-4343-83c1-ff5bda9c04c6", + "metadata": { + "tags": [] + }, + "source": [ + "# Task D\n", + "\n", + "By combining the work you have done in the cells above, copy-and-paste them into the cell below to create the beginning of a script to read beam data from a text file. Then, using that data, create an `FEModel3D` using `PyNite`.\n", + "\n", + "Feel free to refer back to your Workbook 01 and the PyNite reference guide.\n", + "\n", + "Putting it all together, you will be performing the following:\n", + "\n", + "1. Read the contents of the file using `.read()` and store the resulting string in a variable called `beam_1_data`.\n", + "2. Using the information about the file format described above, use string methods, list methods, and indexing to extract data from the file. Create the following variables:\n", + "* `length`\n", + "* `E`\n", + "* `Iz`\n", + "* Supports\n", + " * Create separate variables for each support location, e.g. `support_location_1`, `support_location_2`, etc.\n", + " * `support_location_...`\n", + "* Loads\n", + " * Create separate variables for each load, e.g. `load_magnitude_1`, `load_magnitude_2`, etc.\n", + " * `load_magnitude_...`\n", + " * `load_start_...` (if applicable)\n", + " * `load_end_...` (if applicable)\n", + "\n", + "3. Create a new `FEModel3D` object using the variables containing the data you read from the file. \n", + "\n", + "4. Run an analysis of the beam model. Print reaction loads, plot the shear force, bending moment diagrams, and displacement." + ] + }, + { + "cell_type": "markdown", + "id": "cdcf9392-9cd8-44ba-8a16-7dbc7a06b45b", + "metadata": {}, + "source": [ + "## Task D Response" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "id": "635dd31a-144c-4fb5-92bc-a595b9955585", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L:4800.0\n", + "E:200000.0\n", + "I:437000000.0\n", + "vert_P1:0.0\n", + "vert_P2:3000.0\n", + "udl_mag:10.0\n", + "udl_start2000.0\n" + ] + } + ], + "source": [ + "#OPEN FILE FOR BEAM 1 \n", + "file_name=\"beam_1.txt\" # Same dir as notebook file\n", + "with open(file_name, 'r')as file:\n", + " beam_1_data=file.read()\n", + " \n", + "#split list by line\n", + "list=beam_1_data.split(sep=\"\\n\")\n", + "\n", + "#line1\n", + "LEI=list[0]\n", + "split_LEI=LEI.split(sep=\",\")\n", + "#variables\n", + "L=split_LEI[0]\n", + "L=float(L)\n", + "E=split_LEI[1]\n", + "E=float(E)\n", + "I=split_LEI[2]\n", + "I=float(I)\n", + "\n", + "#line2\n", + "vert=list[1]\n", + "split_vert=vert.split(sep=\",\")\n", + "#variables\n", + "vert_P1=split_vert[0]\n", + "vert_P1=float(vert_P1)\n", + "vert_P2=split_vert[1]\n", + "vert_P2=float(vert_P2)\n", + " \n", + "#line3\n", + "udl=list[2]\n", + "split_udl=udl.split(sep=\",\")\n", + "#variables\n", + "udl_mag=split_udl[0]\n", + "udl_mag=float(udl_mag)\n", + "udl_start=split_udl[1]\n", + "udl_start=float(udl_start)\n", + " \n", + "#print variables for reference\n", + "print(f'L:{L}\\nE:{E}\\nI:{I}\\nvert_P1:{vert_P1}\\nvert_P2:{vert_P2}\\nudl_mag:{udl_mag}\\nudl_start{udl_start}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "id": "bfcc0bb8-f3a6-4cc0-9a9c-ee51880da6a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+----------------+\n", + "| Statics Check: |\n", + "+----------------+\n", + "\n", + "+------------------+--------+--------+-----------+----------+--------+--------+--------+---------+--------+---------+----------+---------+\n", + "| Load Combination | Sum FX | Sum RX | Sum FY | Sum RY | Sum FZ | Sum RZ | Sum MX | Sum RMX | Sum MY | Sum RMY | Sum MZ | Sum RMZ |\n", + "+------------------+--------+--------+-----------+----------+--------+--------+--------+---------+--------+---------+----------+---------+\n", + "| LC1 | 0 | 0 | -3.42e+03 | 3.42e+03 | 0 | 0 | 0 | 0 | 0 | 0 | -3.9e+05 | 3.9e+05 |\n", + "+------------------+--------+--------+-----------+----------+--------+--------+--------+---------+--------+---------+----------+---------+\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from PyNite import FEModel3D\n", + "from PyNite.Visualization import render_model\n", + "\n", + "beam_model = FEModel3D() # Creates an empty model\n", + "\n", + "beam_model.add_node(name=\"node1\", X=0, Y=0, Z=0) # Change the model by adding nodes\n", + "beam_model.add_node(\"node2\", vert_P2, 0, 0)\n", + "beam_model.add_node(\"node3\", L, 0, 0)\n", + "\n", + "beam_model.add_member(name=\"M1\", i_node=\"node1\", j_node=\"node3\", E=E, G=77e3, Iy=I, Iz=I, J=30e3, A=1500)\n", + "\n", + "beam_model.def_support(\"node1\", support_DX=True, support_DY=True, support_DZ=True, support_RX=True, support_RY=False, support_RZ=False)\n", + "beam_model.def_support(\"node3\", False, True, True, False, False, False)\n", + "\n", + "beam_model.add_load_combo(name=\"LC1\", factors={\"Load\": 1})\n", + "\n", + "beam_model.add_member_dist_load(Member=\"M1\", Direction=\"Fy\", w1=-udl_mag, w2=-udl_mag, x1=udl_start, x2=L, case=\"Load\")\n", + "\n", + "beam_model.analyze(check_statics=True) # Changes the model by performing the analysis and adding analysis results\n", + "\n", + "beam_model.Members['M1'].plot_shear(Direction=\"Fy\", combo_name=\"LC1\", n_points=100)\n", + "beam_model.Members['M1'].plot_moment(Direction=\"Mz\", combo_name=\"LC1\", n_points=100)\n", + "\n", + "render_model(beam_model, combo_name='LC1', annotation_size=100)" + ] + }, + { + "cell_type": "markdown", + "id": "a0653be0-e976-4c21-8199-f94bb842795f", + "metadata": {}, + "source": [ + "# Task E\n", + "\n", + "Perform the same instructions from **Task D** with \"beam_2.txt\" except call your variable `beam_2_data`.\n", + "\n", + "Save yourself some time by copy-and-paste-ing your code from **Task D** and try modifying it to make it work. Note, the number of supports and number of loads are different in \"beam_2.txt\"." + ] + }, + { + "cell_type": "markdown", + "id": "0dd914dc-f6b8-4dce-a3e8-c88a821d943f", + "metadata": {}, + "source": [ + "## Task E Response" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "044cfe12-c578-4ecb-ad99-ae34b5839963", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L:228.0\n", + "E:28000.0\n", + "I:756.0\n", + "vert_P1:63.0\n", + "vert_P2:100.0\n", + "vert_P3:200.0\n", + "udl_mag_1:15.0\n", + "udl_start_1:0.0\n", + "udl_end_1:0.0\n", + "udl_mag_2:35.0\n", + "udl_start_2:0.0\n", + "udl_end_2:0.0\n" + ] + } + ], + "source": [ + "#OPEN FILE FOR BEAM 2 \n", + "file_name=\"beam_2_us.txt\" # Same dir as notebook file\n", + "with open(file_name, 'r')as file:\n", + " beam_2_data=file.read()\n", + " \n", + "#split list by line\n", + "list=beam_2_data.split(sep=\"\\n\")\n", + "\n", + "#line1\n", + "LEI=list[0]\n", + "split_LEI=LEI.split(sep=\",\")\n", + "#variables\n", + "L=split_LEI[0]\n", + "L=float(L)\n", + "E=split_LEI[1]\n", + "E=float(E)\n", + "I=split_LEI[2]\n", + "I=float(I)\n", + "\n", + "#line2\n", + "vert=list[1]\n", + "split_vert=vert.split(sep=\",\")\n", + "#variables\n", + "vert_P1=split_vert[0]\n", + "vert_P1=float(vert_P1)\n", + "vert_P2=split_vert[1]\n", + "vert_P2=float(vert_P2)\n", + "vert_P3=split_vert[2]\n", + "vert_P3=float(vert_P3)\n", + " \n", + " \n", + "#line3\n", + "udl=list[2]\n", + "split_udl=udl.split(sep=\",\")\n", + "#variables\n", + "udl_mag_1=split_udl[0]\n", + "udl_mag_1=float(udl_mag_1)\n", + "udl_start_1=split_udl[1]\n", + "udl_start_1=float(udl_start_1)\n", + "udl_end_1=split_udl[2]\n", + "udl_end_1=float(udl_end_1)\n", + "\n", + "#line4\n", + "udl=list[3]\n", + "split_udl=udl.split(sep=\",\")\n", + "#variables\n", + "udl_mag_2=split_udl[0]\n", + "udl_mag_2=float(udl_mag_2)\n", + "udl_start_2=split_udl[1]\n", + "udl_start_2=float(udl_start_2)\n", + "udl_end_2=split_udl[2]\n", + "udl_end_2=float(udl_end_2)\n", + " \n", + "#print variables for reference\n", + "print(f'L:{L}\\nE:{E}\\nI:{I}\\nvert_P1:{vert_P1}\\nvert_P2:{vert_P2}\\nvert_P3:{vert_P3}\\nudl_mag_1:{udl_mag_1}\\nudl_start_1:{udl_start_1}\\nudl_end_1:{udl_end_1}\\nudl_mag_2:{udl_mag_2}\\nudl_start_2:{udl_start_2}\\nudl_end_2:{udl_end_2}')" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "id": "ac1e19bd-f712-4bc3-85b9-a4a99dd3da92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+----------------+\n", + "| Statics Check: |\n", + "+----------------+\n", + "\n", + "+------------------+--------+--------+-----------+----------+--------+--------+--------+---------+--------+---------+----------+---------+\n", + "| Load Combination | Sum FX | Sum RX | Sum FY | Sum RY | Sum FZ | Sum RZ | Sum MX | Sum RMX | Sum MY | Sum RMY | Sum MZ | Sum RMZ |\n", + "+------------------+--------+--------+-----------+----------+--------+--------+--------+---------+--------+---------+----------+---------+\n", + "| LC1 | 0 | 0 | -1.14e+04 | 1.14e+04 | 0 | 0 | 0 | 0 | 0 | 0 | -1.3e+06 | 1.3e+06 |\n", + "+------------------+--------+--------+-----------+----------+--------+--------+--------+---------+--------+---------+----------+---------+\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAHcCAYAAAAZeJR7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5Q0lEQVR4nO3deVwU9f8H8NfustyXF4eKiPeFYGaKZmmieGSaeXSqfS3Lr1aKaZrm1WF5Z1l+O61fWh55lBpKeGSJmiaIF3mgeAFe3AJ7zO8P3BEEkYWdndnd1/Px4FG7Ozvz3hl3ePOZz7zfKkEQBBARERFRpanlDoCIiIjI1jCBIiIiIjITEygiIiIiMzGBIiIiIjITEygiIiIiMzGBIiIiIjITEygiIiIiMzGBIiIiIjITEygiIiIiMzGBIiIqx8iRI+Hp6Sl3GESkUEygiMjqVqxYAZVKBZVKhT///LPM64IgICgoCCqVCo8//rgMESrDyJEjoVKp4O3tjVu3bpV5/dSpU+J+XLBggfj8yZMnMXnyZISHh8PLywuBgYHo168fDh48aM3wiewaEygiko2rqytWrVpV5vndu3fj4sWLcHFxkSEqZXFyckJ+fj5+/fXXMq+tXLkSrq6uZZ7/6quv8OWXX+LBBx/EwoULER0djeTkZHTq1Am///67NcImsntMoIhINn379sXatWuh1+tLPb9q1Sq0b98eAQEBMkVmHYIglDuyVJKLiwt69OiBH3/8scxrq1atQr9+/co8/8wzz+DChQv46quvMHr0aEyaNAn79+9HzZo1MWvWLEuFT+TQmEARkWyeeeYZXL9+HbGxseJzRUVFWLduHZ599tly32M0GrFkyRK0bt0arq6u8Pf3xyuvvIKbN2+WWq5hw4Z4/PHHsWvXLjz44INwc3NDaGgodu3aBQBYv349QkND4erqivbt2+Pw4cPlbu/s2bOIioqCh4cH6tatizlz5kAQhGrFtG3bNjGm//3vf/fdT88++yx+++03ZGZmis/9/fffOHXqVLn7qX379mXmb9WqVQtdu3bFiRMn7rs9Iro/JlBEJJuGDRsiIiKi1OjKb7/9hqysLDz99NPlvueVV17BpEmT0KVLF3z88cd48cUXsXLlSkRFRUGn05Va9vTp03j22WfRv39/zJ07Fzdv3kT//v2xcuVKTJgwAc8//zxmz56NM2fOYOjQoTAajaXebzAY0Lt3b/j7+2PevHlo3749Zs6ciZkzZ1Y5puTkZDzzzDPo2bMnPv74Y4SHh993Pw0aNAgqlQrr168Xn1u1ahVatGiBBx544L7vN0lLS0Pt2rUrvTwRVUAgIrKyb7/9VgAg/P3338Knn34qeHl5Cfn5+YIgCMKQIUOE7t27C4IgCMHBwUK/fv3E9+3Zs0cAIKxcubLU+mJiYso8HxwcLAAQ9u7dKz63bds2AYDg5uYmnD9/Xnz+f//7nwBA2Llzp/jciBEjBADCa6+9Jj5nNBqFfv36Cc7OzsLVq1erHFNMTEyl9tOIESMEDw8PQRAEYfDgwUKPHj0EQRAEg8EgBAQECLNnzxZSUlIEAML8+fMrXNcff/whqFQq4Z133qnUtomoYhyBIiJZDR06FLdu3cLmzZuRk5ODzZs33/Py3dq1a+Hj44OePXvi2rVr4o/pktXOnTtLLd+qVStERESIjzt27AgAeOyxx9CgQYMyz589e7bMNseNGyf+v0qlwrhx41BUVCROxjY3ppCQEERFRZmziwAUX8bbtWsX0tLSsGPHDqSlpd1zP90tIyMDzz77LEJCQjB58mSzt01EZTnJHQARObY6deogMjISq1atQn5+PgwGAwYPHlzusqdOnUJWVhb8/PzKfT0jI6PU45JJEgD4+PgAAIKCgsp9/u45S2q1Go0aNSr1XLNmzQAA586dq1JMISEh5S53P3379oWXlxdWr16NhIQEdOjQAU2aNBHjuJe8vDw8/vjjyMnJwZ9//snaVkQWwgSKiGT37LPP4uWXX0ZaWhr69OkDX1/fcpczGo3w8/PDypUry329Tp06pR5rNJpyl7vX88Jdk8Mrw9yY3NzczN4GUHw33qBBg/Ddd9/h7NmzlbqbrqioCIMGDcKRI0ewbds2tGnTpkrbJqKymEARkeyefPJJvPLKK9i3bx9Wr159z+UaN26M33//HV26dKlyImIOo9GIs2fPiqNOAPDvv/8CKJ4Ab+2Ynn32WXzzzTdQq9X3nGRvYjQaMXz4cMTFxWHNmjV49NFHJY2NyNFwDhQRyc7T0xOff/45Zs2ahf79+99zuaFDh8JgMODdd98t85pery91m7+lfPrpp+L/C4KATz/9FFqtFj169LB6TN27d8e7776LTz/99L41sl577TWsXr0an332GQYNGmSxGIioGEegiEgRRowYcd9lHn30UbzyyiuYO3cuEhIS0KtXL2i1Wpw6dQpr167Fxx9/fM/5U1Xh6uqKmJgYjBgxAh07dsRvv/2GLVu24O233xYvzVkzJrVajenTp993uSVLluCzzz5DREQE3N3d8cMPP5R6/cknn4SHh4dFYiJyVEygiMimLF++HO3bt8f//vc/vP3223ByckLDhg3x/PPPo0uXLhbdlkajQUxMDMaMGYNJkybBy8sLM2fOxIwZM2SLqTISEhIAAPHx8YiPjy/zekpKChMoompSCVWZNUlERETkwDgHioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIyGGtWLECKpUKBw8erHC57OxszJ49G2FhYfD09ISbmxvatGmDt956C5cvXxaXS05OxoQJE9C5c2e4urpCpVLh3LlzEn8KIpIDK5ETEVXg7NmziIyMRGpqKoYMGYLRo0fD2dkZR44cwddff40NGzaIDYbj4+OxdOlStGrVCi1bthQrghOR/WECRUR0D3q9HoMGDUJ6ejp27dqFhx9+uNTr77//Pj766CPx8RNPPIHMzEx4eXlhwYIFTKCI7BgTKCKie/j555+RmJiI999/v0zyBADe3t54//33xcc1a9a0ZnhEJCPOgSIiuodffvkFAPDCCy/IHAkRKQ0TKCKiezhx4gR8fHwQFBQkdyhEpDBMoIiI7iE7OxteXl5yh0FECsQEiojoHry9vZGTkyN3GESkQEygiIjuoUWLFsjKysKFCxfkDoWIFIYJFBHRPfTv3x8A8MMPP8gcCREpDRMoIqJ7GDx4MEJDQ/H+++8jPj6+zOs5OTmYNm2aDJERkdxYB4qIHN4333yDmJiYMs+/8cYbWL9+PSIjI/HII49g6NCh6NKlC7RaLY4dO4ZVq1ahRo0aYi2orKwsfPLJJwCAv/76CwDw6aefwtfXF76+vhg3bpz1PhQRSUolCIIgdxBERHJYsWIFXnzxxXu+fuHCBdSvXx+ZmZlYvHgxNmzYgDNnzsBoNKJJkybo378/Xn/9dQQEBAAAzp07h5CQkHLXFRwczL54RHaECRQRERGRmTgHioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMRCmhIwGo24fPkyvLy8oFKp5A6HiIiIKkEQBOTk5KBu3bpQqyseY2ICJYHLly8jKChI7jCIiIioCkxFdCtiMwnU559/js8//1ys5Nu6dWvMmDEDffr0AQAUFBRg4sSJ+Omnn1BYWIioqCh89tln8Pf3F9eRmpqKMWPGYOfOnfD09MSIESMwd+5cODnd2Q27du1CdHQ0jh07hqCgIEyfPh0jR440K1YvLy8AxQfA29u7eh/8LjqdDtu3b0evXr2g1Wotum6qPB4H5eCxUA4eC+Xgsaia7OxsBAUFib/HK2IzCVT9+vXx4YcfomnTphAEAd999x0GDBiAw4cPo3Xr1pgwYQK2bNmCtWvXwsfHB+PGjcOgQYPEflQGgwH9+vVDQEAA9u7diytXrmD48OHQarX44IMPAAApKSno168fXn31VaxcuRJxcXF46aWXEBgYiKioqErHarps5+3tLUkC5e7uDm9vb34pZMTjoBw8FsrBY6EcPBbVU5npNzaTQPXv37/U4/fffx+ff/459u3bh/r16+Prr7/GqlWr8NhjjwEAvv32W7Rs2RL79u1Dp06dsH37dhw/fhy///47/P39ER4ejnfffRdvvfUWZs2aBWdnZyxfvhwhISFYuHAhAKBly5b4888/sXjxYrMSKCIiIrJvNpNAlWQwGLB27Vrk5eUhIiIChw4dgk6nQ2RkpLhMixYt0KBBA8THx6NTp06Ij49HaGhoqUt6UVFRGDNmDI4dO4Z27dohPj6+1DpMy4wfP77CeAoLC1FYWCg+zs7OBlD8F4BOp7PAJ77DtD5Lr5fMw+OgHDwWysFjoRw8FlVjzv6yqQQqKSkJERERKCgogKenJzZs2IBWrVohISEBzs7O8PX1LbW8v78/0tLSAABpaWmlkifT66bXKlomOzsbt27dgpubW7lxzZ07F7Nnzy7z/Pbt2+Hu7l6lz3o/sbGxkqyXzMPjoBw8FsrBY6EcPBbmyc/Pr/SyNpVANW/eHAkJCcjKysK6deswYsQI7N69W+6wMHXqVERHR4uPTZPQevXqJckcqNjYWPTs2ZPXtWXE46AcPBbKwWOhHDwWVWO6glQZNpVAOTs7o0mTJgCA9u3b4++//8bHH3+MYcOGoaioCJmZmaVGodLT0xEQEAAACAgIwIEDB0qtLz09XXzN9F/TcyWX8fb2vufoEwC4uLjAxcWlzPNarVayf7hSrpsqj8dBOXgslIPHQjl4LMxjzr6y6UrkRqMRhYWFaN++PbRaLeLi4sTXkpOTkZqaioiICABAREQEkpKSkJGRIS4TGxsLb29vtGrVSlym5DpMy5jWQURERATY0AjU1KlT0adPHzRo0AA5OTlYtWoVdu3ahW3btsHHxwejRo1CdHQ0atasCW9vb7z22muIiIhAp06dAAC9evVCq1at8MILL2DevHlIS0vD9OnTMXbsWHH06NVXX8Wnn36KyZMn4z//+Q927NiBNWvWYMuWLXJ+dCIiIlIYm0mgMjIyMHz4cFy5cgU+Pj5o27Yttm3bhp49ewIAFi9eDLVajaeeeqpUIU0TjUaDzZs3Y8yYMYiIiICHhwdGjBiBOXPmiMuEhIRgy5YtmDBhAj7++GPUr18fX331FUsYEBERUSk2k0B9/fXXFb7u6uqKZcuWYdmyZfdcJjg4GFu3bq1wPd26dcPhw4erFCMRERE5BpueA0VEREQkByZQRERERGZiAkVERERkJiZQRDZCEAQU6Axyh0FERGACRWQzhn9zAI/M24nU65VvNUBERNJgAkVkI/45fxMZOYWYuDYBBqMgdzhERA6NCRSRjTAIxUnT3+du4os/zsocDRGRY2MCRWQjSo46LYpNxrHLWTJGQ0Tk2JhAEdkIUwL1YHAN6AwCJqxO4KRyIiKZMIEisgGCIMA0ADV3UChqezrj3/RcLNiWLG9gREQOigkUkQ0oefmujpcLPnqqLQDg679SsPfMNbnCIiJyWEygiGyAvkQCpVGr0KOlP555KAiCALy5JhHZBToZoyMicjxMoIhsgFEonUABwPR+rRBcyx2Xswowa9MxuUIjInJITKCIbMDdI1AA4OHihEVDw6BWAesPX8KWI1fkCo+IyOEwgSKyAcaSCZRKJf5/++Ca+G+3JgCAaRuTkJFdYPXYiIgcERMoIhtQ3giUyes9mqJNPW9k5uswad0RCAKrlBMRSY0JFJENMI1AqVWASlU6gXJ2UmPx0HC4OKmx+9+r+GF/qhwhEhE5FCZQRDbA1MbFSV3+V7apvxem9GkBAHh/y3GcvZprtdiIiBwREygiG6A33B6BquAbOyKiIR5uUhsFOiMmrE6AzmC0UnRERI6HCRSRDTDeZwQKANRqFeYPaQtvVyckXszCsp2nrRWeYhiNAvRMHInICphAEdkAfYk5UBUJ9HHDuwPbAAA+2XEaCRcyJY5MOQxGAX0+3oPHP/mThUWJSHJMoIhsgGkS+d134JVnQHg99A+rC4NRQPTqBNwqcoyGw9fzipCcnoOTaTmY9QsLixKRtJhAEdkAvZhAVe4r++6A1gjwdsXZa3mY+9sJKUNTjNwCvfj/6/+5hK1JLCxKRNJhAkVkAwxiAlW55X3dnTF/SHHD4e/jz2NXcoZUoSlGTqG+1OO3N7CwKBFJhwkUkQ0wJVAVTSK/W9emdTCyc0MAwOR1R3Azr0iK0BQj93YC1ai2B1rXLS4sOvlnFhYlImkwgSKyAaY6UGbkTwCAKX1aoHEdD2TkFGLaxiS7TiZMl/BqeDhjybBwODupsSv5KlaysCgRSYAJFJENqMoIFAC4ajVYMqwdnNQqbE1Kw8aES1KEpwimEShPF6fiwqK9TYVFT7CwKBFZHBMoIhtgqGQZg/KE1vfBGz2aAgBmbDyGS5m3LBmaYpgSKC9XJwDAyM4N0aVJLdzSGTBhTSLrQxGRRTGBIrIBVR2BMhnTrTHaNfBFTqEeE9ckiGUR7EluYXG5BlMCpVarsGBIWHFh0QuZWLbzjJzhEZGdYQJFZAPEEaiqDEEBcNIUNxx202qw7+wNfPNXiiXDU4Sc28UzPV2cxOdKFhZduuMUEh2osCgRSYsJFJENuDMCVbUECgAa1vbAO4+3AgDMi0lGclqORWJTCtMIlKeLttTzT4TVxeNtA2EwCpjgQIVFiUhaTKCIbEB1R6BMnnkoCI+18EORwYjxqxNQqLefZEKcRO7qVOp5lUqF9wa2gb+3i0MVFiUiaTGBIrIBeguMQAHFycSHT4WihrsWJ65kY8nvpywRniLcPYm8JF93ZywYEgbAcQqLEpG0mEAR2QDj7fpNGlX1EigA8PNyxdxBoQCA5bvP4O9zN6q9TiXIMyVQLmUTKMDxCosSkbSYQBHZAIMZzYQro3ebQAxuXx+CAESvSRBHb2yZqZDm3ZfwSnqrdws0ul1YdPrGo3ZdWJSIpMUEisgGWDqBAoCZ/Vuhnq8bLty4hXd/PW6x9colp0QhzXtxc9ZgybBwOKlV2JJ0BZsSLlsrPCKyM0ygiGyAFAmUl6sWi4aGQaUCVh+8gO3H0iy2bjlUNAeqpLb1ffH67cKi72w6areFRYlIWkygiGyAFAkUAHRsVAujH2kEAJiyPglXcwotun5rEYR7lzEoz3+7NUZ4kC9yCvR4c02iXRYWJSJpMYEisgFiM2ELTCK/W3TPZmgR4IUbeUWYuv6ITc4L0hnvJJn3G4ECbhcWHVZcWDT+7HV8u/ecxBESkb1hAkVkAyxVxqA8Lk4aLHk6HM4aNX4/kYHVf1+w+DakVnC7nJVKBbg7ayr1npDaHpj+eEsAwEcxJ/Fvun0VFiUiaTGBIrIBRoku4Zm0CPDGm1HNAABzNh/H+et5kmxHKqYEytPFCSozRumefagBujevgyK9EeN/SkCRng2HiahymEAR2QC9xAkUAIx6uBE6htREfpEB0WsSxUtituDW7QTqXjWg7kWlUuGjwW1Rw12L41eyseT3fyWIjojsERMoIhsg9QiUad0Lh4bB08UJh87fxPLdZyTblqUVGIr3S0U1oO7FXguLEpG0mEAR2QBrjEABQP0a7pj9RGsAwOLYf3H0Upak27OU2zU0K6wBVZHebQLx1AP1YbSjwqJEJC0mUEQ2wJKtXO5n0AP10KdNAPRGARNWJ6BAp/yGw4WmS3iu9y9hcC8zn7CvwqJEJC0mUEQ2QG+4nUBppE+gVCoV3n8yFHW8XHAqIxfzYpIl32Z1iZPIq3AJz8TbVYuFJQqLxh5Pt1B0RGSPbCaBmjt3Ljp06AAvLy/4+flh4MCBSE4ufWIvKCjA2LFjUatWLXh6euKpp55Cenrpk2Bqair69esHd3d3+Pn5YdKkSdDrSw/X79q1Cw888ABcXFzQpEkTrFixQuqPR1QhgxVHoACgpocz5g1uCwD45q8U/HX6mlW2W1UFVZxEfrdOjWphdNfbhUV/PoJrubZZWJSIpGczCdTu3bsxduxY7Nu3D7GxsdDpdOjVqxfy8u7cbj1hwgT8+uuvWLt2LXbv3o3Lly9j0KBB4usGgwH9+vVDUVER9u7di++++w4rVqzAjBkzxGVSUlLQr18/dO/eHQkJCRg/fjxeeuklbNu2zaqfl6gkg7H49nqp50CV1L25H57r2AAA8ObaRGTl66y2bXOJk8irmUABQHSv4sKi1/OKMOXnJJssLEpE0rOZBComJgYjR45E69atERYWhhUrViA1NRWHDh0CAGRlZeHrr7/GokWL8Nhjj6F9+/b49ttvsXfvXuzbtw8AsH37dhw/fhw//PADwsPD0adPH7z77rtYtmwZioqKAADLly9HSEgIFi5ciJYtW2LcuHEYPHgwFi9eLNtnJzLcLk9kzQQKAKb1a4mGtdxxJasAM345atVtm+OWBS7hmbg4abB4mKmwaDrWHLS9wqJEJL3qn21kkpVVfHdQzZo1AQCHDh2CTqdDZGSkuEyLFi3QoEEDxMfHo1OnToiPj0doaCj8/f3FZaKiojBmzBgcO3YM7dq1Q3x8fKl1mJYZP378PWMpLCxEYeGdof7s7GwAgE6ng05n2b/aTeuz9HrJPNY+Drrbl5lVEKx67LUqYP5TbfD0V39jU8JldGtaC4+3DbTa9itDp9OJd+G5a9UW2T9NarthfGRjzNt2CrN/PY72DXwQXNO92uu1dzw/KQePRdWYs79sMoEyGo0YP348unTpgjZt2gAA0tLS4OzsDF9f31LL+vv7Iy0tTVymZPJket30WkXLZGdn49atW3BzcysTz9y5czF79uwyz2/fvh3u7tKcdGNjYyVZL5nHWsfh9Dk1ADXOnT2LrVtPW2WbJUXWVWPbRTXeXn8E2WcOw9fF6iFUqMBQPJie8u9xbM08ZpF1BgpAYy8NzuQY8PJXe/B6awOsPABos3h+Ug4eC/Pk5+dXelmbTKDGjh2Lo0eP4s8//5Q7FADA1KlTER0dLT7Ozs5GUFAQevXqBW9vb4tuS6fTITY2Fj179oRWW/Vbtql6rH0cDm45CVxJRbOmTdA3sonk27tbT4MRw748gKRL2die5Y9vhj8AtUKyCZ1Oh6VHdwAAIh5shz5tAiy27vDOt/D4sr1IyTHgomcLvPpoI4ut2x7x/KQcPBZVY7qCVBk2l0CNGzcOmzdvxh9//IH69euLzwcEBKCoqAiZmZmlRqHS09MREBAgLnPgwIFS6zPdpVdymbvv3EtPT4e3t3e5o08A4OLiAheXsn+Sa7Vayf7hSrluqjxrHQfTNGatk0aW467VAouHtUO/pXvw15nr+OnQZYzo3NDqcdyL6S48Xw9Xi+6fED8tZj/RBm+uTcTHO86ge8sAtKnnY7H12yuen5SDx8I85uwrm5lELggCxo0bhw0bNmDHjh0ICQkp9Xr79u2h1WoRFxcnPpecnIzU1FREREQAACIiIpCUlISMjAxxmdjYWHh7e6NVq1biMiXXYVrGtA4iOZgmkTvJOOrTxM8Tb/dtCQD4YOsJnM7IlS2Wu1miDtS9PPVAPfRubVuFRYlIejaTQI0dOxY//PADVq1aBS8vL6SlpSEtLQ23bt0CAPj4+GDUqFGIjo7Gzp07cejQIbz44ouIiIhAp06dAAC9evVCq1at8MILLyAxMRHbtm3D9OnTMXbsWHEE6dVXX8XZs2cxefJknDx5Ep999hnWrFmDCRMmyPbZiUxlDOS+bPZCp2B0bVobhXojJqxOgM6U2cmsqs2EK0OlUuGDQaGo7VlcWHT+NuUXFiUi6dlMAvX5558jKysL3bp1Q2BgoPizevVqcZnFixfj8ccfx1NPPYVHHnkEAQEBWL9+vfi6RqPB5s2bodFoEBERgeeffx7Dhw/HnDlzxGVCQkKwZcsWxMbGIiwsDAsXLsRXX32FqKgoq35eopLkKmNwN7VahfmDw+DjpkXSpSx8EndK1niA4tHpAgu0cqlIcWHR4obDX/+p/MKiRCQ9m5kDVZlidq6urli2bBmWLVt2z2WCg4OxdevWCtfTrVs3HD582OwYiaRiGoGS8xKeSYCPK95/sg3GrTqMZbvOoFsLPzzQoIZs8RTqjTAKtwtpSnAJz+SxFv54tmMDrNqfijfXJiJm/CPwcePcEiJHZTMjUESO7HYrPKit1Mrlfh5vWxcDw+vCYBQQvToB+UX6+79JIrmFt2tkqQB3rUbSbU3re6ew6MxNyi0sSkTSYwJFZAPEESgrNBOurNkD2iDQxxXnrufj/S0nZIvDlEB5ODtJPkfMw8UJi4aFQ60CNiZcxuYjlyXdHhEpFxMoIhtgMBYPQSllBAoAfNy0WDgkDACwcn8qdp7MuM87pJF7ewKUp4u0o08mDzSogXHdi2txTdtwFGlZBVbZLhEpCxMoIhtgSqCUMAeqpM5NauM/XYpLikxadwQ38oqsHkNOYXHrBUs0Eq6s13o0Rdv6Psi6pcOkdYlsOEzkgJhAEdkAcQRKYQkUAEzu3RxN/TxxLbcQU9cfsXoyYRqB8pJwAvndtBo1Fg0Nh4uTGntOXcP/7TtvtW0TkTIwgSKyAXqFjkABgKtWg8XDwqHVqLDtWDp+/ueSVbdvmgNlzREoQNmFRYlIekygiGyA8faojtx1oO6lTT0fjI9sBgCY9csxXLhR+Yac1SVXAgXcKSxaoDMieo1yCosSkfSYQBHZAL1B2QkUALz6aGM8GFwDuYV6TFybKF52lJqYQFnxEp5JycKiRy5m4ZMdp60eAxHJgwkUkQ0QR6AUdBfe3TRqFRYNDYeHswYHUm7g6z/PWmW7co5AAcWFRd8b2AYAsGznaRxOvSlLHERkXUygiGyAaQ6UkkegAKBBLXfM6F/cmHvBtn9x4kq25NvMKTAlUNYpY1Ce/mF1MeB2YdEJMhcWJSLrYAJFZAOMNpJAAcDQB4MQ2dIPRYbihsOFeoOk2zONQEnVB6+y5jxxp7DoB1vlKyxKRNbBBIrIBtjKCBQAqFQqzB3UFrU8nHEyLQeLtv8r6fbuXMKTbwQKAHzctVhwu7DoD/tSsTNZnsKiRGQdTKCIbIDBhhIoAKjj5YK5g0IBAF/sOYt9Z69Ltq3cQlMlcvl7o3cpUVh0skyFRYnIOphAEdkApZcxKE+v1gEY9mAQBAGYuCYR2QU6SbaTWyDvJPK7Te7dHE38PHE1pxBvr09ilXIiO8UEisgGiJfwFHwXXnne6d8KQTXdcCnzFmb/clySbch9F97dXLUaLBkWDie1CjHH0rDeyoVFicg6mEAR2QBbmkRekqeLExYNDYdKBfz8z0XEHL1i8W3IWQfqXtrU88GEnsWFRWdaubAoEVkHEygiG2BLk8jv1qFhTbz6aGMAwNT1ScjIKbDYugVBUNwIlMkrjzRC+9uFRd9cmygmwURkH5hAEdkAWx2BMpkQ2QwtA71xM1+Ht9ZZruFwod4I3e0q7UpLoJw0aiwaGgZ3Zw32p9zA13+myB0SEVkQEygiG2DLI1AA4OykxpJh4XB2UmNn8lWsOpBqkfWaRp8AwMNZ3jIG5Qmu5YF3Hi8uLDp/WzJOpklfWJSIrIMJFJENsMW78O7WPMALk6OaAwDe23wCKdfyqr1O0x14LhoBaoXum6c7BKFHi+LCouN/kr6wKBFZBxMoIhtgGoFyUmiSUFn/6RKCiEa1cEtnwITVCdAbjNVan2kEylV5g08ilUqFD59qi5pWKixKRNbBBIrIBpgKaaptrIzB3dRqFRYMDYOXqxMSLmTi811nqrU+U20pNwUnUEDZwqL7JSwsSkTWwQSKyAYYxBEo2//K1vN1w7sD2gAAPo47hSMXM6u8LtMlPCWPQJlEtQ7A0AfrQxCA6DWJyJGosCgRWYftn42JHIA4AmUn39gB4XXRr20g9EYBE1Yn4FZR1eYF3bmEZxslAmb0b32nsOiv0hQWJSLrsJPTMZF9s6cRKKB4XtD7A9vAz8sFZ67m4aOYk1Vajy3MgSqpZGHRdYcuIuZomtwhEVEV2cfZmMjOGQT7GoECAF93Z8wfEgYAWLH3HP7496rZ68gR78KzaGiSKllY9O0Nli0sSkTWY0enYyL7ZDQKMNWdtJcRKJNHm9XB8IhgAMCkdYnIzC8y6/3iCJSyamjel6mw6I28Ikz5mQ2HiWyRfZ2NieyQocQvV1trJlwZU/u0RKPaHkjPLsQ7m46Z9d4cG7kL725iYVGNGjtOZuDHAxfkDonsjN5gxPen1Pgu/rzcodgtJlBECmco0UNNo7G/BMrNWYPFw8KhUavwa+JlbEq4VOn33rkLz/ZGcJoHeGFy7+LCou9uPo5zFigsSmRy9HI2Dl1T472tydiVnCF3OHaJCRSRwpVKoOxwBAoAwoJ88fpjTQEA72w8isuZtyr1PlubRH63koVFo9dUv7AokUmh/s6/pcnrjuBmnnmXx+n+mEARKVypS3g2Xom8ImO7N0ZYkC+yC/SYtC5RbKBckRwbqgNVHrGwqIsT/knNxPLd1SssSmSiL/H9ycgpxLSNnGtnaUygiBTOYHCMBMpJo8bioWFw02rw1+nrWLH33H3fY+sjUEBxYdE5A1sDAJb8fgpJF7Nkjojsge72aGYNdy2c1CpsTUrDRjMuj9P9MYEiUriSI1B2nD8BABrV8cTb/VoCAD6MOYlT6TkVLn/nLjzb/st6YHg99A0NgN4oYPzqwyjQseEwVY/+9h9ewbXc8UaP4svjMzYew6VKXh6n+2MCRaRwpjlQGrUKKjudA1XS8x0boFvzOijSGzF+dQKK9PeeF2RLrVwqUlxYNFQsLPrhb1UrLEpkYhqB0mrUGNOtMdo18EVOoR5vrqnc5XG6PyZQRAonJlAOkDwBxcnEvKfawtddi2OXs7E07tQ9l7X1OVAl1fBwxrzBbQEUFxbdc8r8wqJEJrrbI1Bater25fFwuGk1iD97Hd/8lSJzdPaBCRSRwpUcgXIUft6umPtkKADgs12ncej8jTLLFOoNKLr9V7Y9JFAA0K25H17oVFxY9M215hcWJTIpOQIFAA1re+Cdx1sBAOZtS0ZyWsWXx+n+mEARKZwjJlAA0Cc0EIMeqAejAExYnYi82/OdTEyX7wDbauVyP1P7tqhyYVEiE9NdeE4lasc981AQHmvhJ14eL9Rzrl11MIEiUji9gyZQADDridao5+uG1Bv5eG/L8VKvmSaQezhr7GpyvbuzExZVsbAokcndI1BA8eXxD58KRU0PZ5y4ko0lv9/78jjdHxMoIoUzCo6bQHm7arFgSBhUKuDHAxfw+/F08TXT/CdPW2uEVwnhQb4Y170JgOLColeyeOcUmcc0B8rprvOGn5crPrh9efx/u8/g73NlL49T5TCBIlI40+3IjphAAUBE41p46eEQAMCU9UdwPbcQwJ0RKE8X+0ugAGDcY00QVt8H2QV6vLmWd06RecQRKKeyv+Z7twnA4Pb1YRSA6DUJ4neJzMMEikjhxBEoB7kLrzwTezVHc38vXMstwtT1xRWVxREoO02gtBo1Fg0Lh6tWjb9OX8d38efkDolsSMm78Mozs38r1PN1w4UbtzDnV861qwomUEQK58hzoExctcUNh7UaFbYfT8faQxeRW6gDYL8JFAA0ruOJaX1vFxb97SROZ/DOKaocfTlzoEryctVi0dDiy+NrDl7E9mNp1gzPLjCBIlI4R70L726t6npjYq/mAIDZvxzD8cvZAABPe7oFrxzPdwrGI83qoLAShUWJTMQ5UJp7nzc6NqqF0Y80AgBMXZ+EqzmFVonNXjCBIlI4UwJ192RQR/Ry10Z4qGFN5BUZ8PWfxcUA7XESeUkqlQrzBxcXFj16KRuf7OCdU3R/emPFI1Am0T2boUWAF67nFWHq+iNsOGwGJlBECmdKoNRMoKBRq7BwaBg8nDUwzan2suNLeCb+3nfunFq28zQOnb8pc0SkdEX3mQNl4uKkwZKnw+GsUeP3ExlY/fcFa4RnF2wqgfrjjz/Qv39/1K1bFyqVChs3biz1uiAImDFjBgIDA+Hm5obIyEicOlX6r7UbN27gueeeg7e3N3x9fTFq1Cjk5uaWWubIkSPo2rUrXF1dERQUhHnz5kn90YjuiSNQpQXVdMfMJ1qLj+15DlRJfUMDMahdPfHOqbsLixKVdL85UCW1CPDGpKjiy+NzNh/H+et5ksZmL2wqgcrLy0NYWBiWLVtW7uvz5s3D0qVLsXz5cuzfvx8eHh6IiopCQUGBuMxzzz2HY8eOITY2Fps3b8Yff/yB0aNHi69nZ2ejV69eCA4OxqFDhzB//nzMmjULX3zxheSfj6g8httD6moHvgvvbkPa10efNgEAgEZ1PGSOxnpmDSguLHr+ej7e23JC7nBIwSozB6qkUQ+HoGNITeQXGRC9JlH8w43uzaYSqD59+uC9997Dk08+WeY1QRCwZMkSTJ8+HQMGDEDbtm3x/fff4/Lly+JI1YkTJxATE4OvvvoKHTt2xMMPP4xPPvkEP/30Ey5fvgwAWLlyJYqKivDNN9+gdevWePrpp/H6669j0aJF1vyoRCJjOS0ZHJ1KpcInz7TDr+MeRr/biZQj8HbVYv6Q4obDPx5IRdyJ9Pu8gxyVOSNQQPEUgYVDw+Dp4oRD529i+e4zUoZnF2wqgapISkoK0tLSEBkZKT7n4+ODjh07Ij4+HgAQHx8PX19fPPjgg+IykZGRUKvV2L9/v7jMI488AmdnZ3GZqKgoJCcn4+ZNzjsg6zOVMeAIVGlOGjVC6/s43Nywzo1ri4VF3/r5TmFRopLMHYECgPo13DH79uXxxbH/4uilLElisxd2M3kgLa24hoW/v3+p5/39/cXX0tLS4OfnV+p1Jycn1KxZs9QyISEhZdZheq1GjRpltl1YWIjCwjsnsezs4turdToddDpddT5WGab1WXq9ZB5rHoei29tQq3jcy+OI34nxjzXC7n8zcCojD1N+PoJlz4RBpYAE2xGPhVIV3W4UrIFg1vHoH+qH7cf8sO14Bsb/dBgbxnSCq9a+S4WUZM6+spsESk5z587F7Nmzyzy/fft2uLu7S7LN2NhYSdZL5rHGcTh8XQVAg6ybN7F161bJt2erHO07MTAAWHRVg9gTGZj1XQw6+ilnzoqjHQslupyuBqDGvydPYOvN4/ddvqRH3IF4rQanr+Zh3JexGNTQcWqP5efnV3pZu0mgAgKK50Gkp6cjMDBQfD49PR3h4eHiMhkZGaXep9frcePGDfH9AQEBSE8vPa/A9Ni0zN2mTp2K6Oho8XF2djaCgoLQq1cveHt7V++D3UWn0yE2NhY9e/aEVqu16Lqp8qx5HIxHrgD/JqFO7Zro27eDpNuyRY78nRD8U7Ag9hQ2XXTGSwMiEFRDmj/YKsuRj4XSrM04CNy8gbDQNuj7YJDZ7/dveRUv/d9h7L6ixn+iOqBz41oSRKk8pitIlWE3CVRISAgCAgIQFxcnJkzZ2dnYv38/xowZAwCIiIhAZmYmDh06hPbt2wMAduzYAaPRiI4dO4rLTJs2DTqdTjwBxMbGonnz5uVevgMAFxcXuLi4lHleq9VKdhKRct1UeVY5DuriqYpaJw2PeQUc8TsxpntT7D51DX+fu4kp64/jx9GdFFGx3hGPhdKY5k66OjtV6VhEtq6L5zpex8r9qZiy4Rhixj8CHzf7P6bm7CubmkSem5uLhIQEJCQkACieOJ6QkIDU1FSoVCqMHz8e7733Hn755RckJSVh+PDhqFu3LgYOHAgAaNmyJXr37o2XX34ZBw4cwF9//YVx48bh6aefRt26dQEAzz77LJydnTFq1CgcO3YMq1evxscff1xqhInImm7fTMNJ5FSGRq3CoqHh8HDW4MC5G/hyz1m5QyKF0It371b91/y0fi3RsJY7rmQVYMamo5YKzW7YVAJ18OBBtGvXDu3atQMAREdHo127dpgxYwYAYPLkyXjttdcwevRodOjQAbm5uYiJiYGrq6u4jpUrV6JFixbo0aMH+vbti4cffrhUjScfHx9s374dKSkpaN++PSZOnIgZM2aUqhVFZE2G2y0ZWEiTylOysOjC7clij0BybEViGYOqnzfcnZ2weFg4NGoVNiVcxq+Jly0Vnl2wqUt43bp1q7BPj0qlwpw5czBnzpx7LlOzZk2sWrWqwu20bdsWe/bsqXKcRJYkjkAxgaJ7GNK+Pn4/no7tx9MxYXUCNo3r4lB3TlFZelMrl2qMQAFAuwY1MLZ7EyyNO4XpG4+iQ8OaCPBxvf8bHYBNjUAROSKOQNH9qFQqzB0UitqezkhOz8HC7clyh0Qy01lgBMrktceaoG19H2Td0mHSukSxuK+jYwJFpHBsJkyVUcvTBR8OKq5S/tWfKYg/c13miEhOphEoJ3X1f81rNWosGhoOFyc19py6hv/bd77a67QHTKCIFE7PZsJUSZGt/PHMQ0EQBODNtYnILmBBS0dlyREoAGji54m3+7YEAHyw9QROZ+RaZL22jAkUkcIZb8/70/AuPKqE6f1aoUFNd1zKvIVZvxyTOxySic5Cc6BKeqFTMLo2rY1CvRETVieISZqjYgJFpHCmESgl1Pch5fNwccLiYWFQq4D1/1zC1qQrcodEMtAZLTsCBRRPI5g/OAw+blokXcrCJ3GnLLZuW8QEikjhjEygyEztg2tiTLfGAIC3NyQhI7tA5ojI2nQWnANVUoCPK95/sg0AYNmuM/gn9aZF129LmEARKRxHoKgq3ujRDK3reiMzX4fJPx+psAQM2R+9aQ6Uk+XPG4+3rYsB4XVhMAqIXp2A/CK9xbdhC5hAESkcR6CoKpyd1FgyLBzOTmrsSr6KlftT5Q6JrEiqESiTOU+0QaCPK85dz8f7W05Isg2lYwJFpHAGgQkUVU1Tfy9M6d0CAPD+lhM4e5V3TjkCQRDEkWtnC86BKsnHXYsFQ8IAACv3p2LnyQxJtqNkTKCIFE68hMe78KgKRnZuiC5NauGWzoAJaxLFSztkv0yjT0D1euHdT5cmtTHq4RAAwKR1R3Ajr0iybSkREygihRMv4Un0lyTZN7VahQVDwuDt6oTEC5lYtvOM3CGRxPTGO0myJe/CK8+kqOZo6ueJa7mFmLresebaMYEiUjiOQFF1Bfq44d2BxXdOLd1xCokXMuUNiCSl05cYgZJoDpSJq1aDxcPCodWosO1YOn7+55Kk21MSJlBECsdJ5GQJT4TVxeNtA2EwCpiwOgG3igxyh0QS0VlxBAoA2tTzwfjIZgCAWb8cw4Ub+ZJvUwmYQBEpHMsYkCWoVCq8N7AN/L1dcPZaHub+5ph3TjkCU4VwjUqAykoj168+2hjtg2sgt1CPiWsSxR6e9owJFJHCsZULWYqvu7N459T38eex+9+rMkdEUjA1ErbmtEmNWoXFQ8Ph4azBgXM38NWes9bbuEyYQBEpnHgy5CRysoCuTetgZOeGAIBJaxNx08HunHIEReIIlHW326CWO2b0bwUAWLj9X5y4km3dAKyMCRSRwhk4AkUW9lbvFmhcxwMZOYWYvvGoQ9055QjkGIEyGfpgECJb+qPIUNxwuFBvv3PtmEARKZyBc6DIwtyci++cclKrsCXpCjYlXJY7JLIgcQ6UDL/hVSoVPnwqFLU8nHEyLQcLt/9r/SCshAkUkcIxgSIptK3vizd6NAUAvLPpKC5l3pI5IrIUnUyX8Exqe7rgw6faAgC+3HMW+85elycQiTGBIlI4UwLlxASKLGxMt8Zo18AXOQV6vLkmUSyZQbZN7IMn4ymjZyt/DHswCIIATFyTiJwCnXzBSIQJFJHCmRIoNRMosjAnjRqLh4bDTatB/Nnr+OavFLlDIgswteuR+5TxTv9WCKrphkuZtzD71+PyBiMBJlBECscRKJJSw9oemP54SwDAvG3J+Dc9R+aIqLpMd+E5yfwb3tPFCYuHhkOtAtYduoiYo1fkDcjCmEARKZzpLjw178IjiTz7UAN0b14HRXojxv+UgCI9Gw7bMjnvwrvbgw1r4tVHGwMApq5PQkZOgcwRWQ4TKCKFE0eglHA2JLukUqnw0eC2qOGuxfEr2Vjyu/3eOeUI5J5Efrfxkc3QKtAbN/N1mPJzkt2UzWACRaRw4hwojkCRhPy8XDF3UCgAYPnuM/j73A2ZI6Kq0okNyJWRqDg7qbHk6XA4O6mx42QGfjxwQe6QLIIJFJHC3ZkDxa8rSat3m0A89UB9GAUgek0Ccgv1codEVaDTK2sECgCa+XthclRzAMC7m4/j3LU8mSOqPp6RiRTuTh0omQMhhzDziVao5+uGCzdu4b3N9nfnlCOQs5BmRf7TJQQRjWrhls6ACWsSxLsFbZXCdi8R3U1s5cIRKLICb1ctFg4Ng0oF/PT3BcQeT5c7JDLTnUt4MgdyF7VahQVDw+Dl6oTDqZn4fNcZuUOqFp6RiRSOI1BkbZ0a1cLoro0AAFN+PoJruYUyR0TmUOIlPJN6vm54d0AbAMDHcaeQdDFL5oiqjqdkIoXjJHKSQ3SvZmgR4IXreUV2deeUI9Abb9eBUugpY0B4XfQLDYTeKGD86sMo0Nlmw2EmUEQKx0nkJAcXp+KGw84aNX4/kY41B+3jzilHYGrlotTauyqVCu8NbAM/LxecuZqHD387KXdIVcIzMpHC3WnlInMg5HBaBnpjYq9mAIA5vx5H6vV8mSOiytAppBJ5RWp4OGP+kDAAwIq957Dn1FWZIzKfgncvEQEcgSJ5vdS1ER4KqYm8IgOi1ySI/x5JuZRWSPNeHm1WB8MjggEAb65NRGZ+kcwRmYdnZCKFu3MXnsyBkEPSqFVYOCQMni5OOHj+Jpbvtu07pxyBklq53M/UPi3RqLYH0rML8c6mY3KHYxaekokUTjwZcgSKZBJU0x2znmgNAFgc+y+OXrLdO6ccQZFC60CVx81Zg0XDwqFRq/Br4mVsSrgkd0iVZgO7l8ixGU0jULwLj2T01AP1ENXaH3qjgAmrE2z2zilHYEsjUAAQHuSL1x5rAgB4Z+NRXM68JXNElcMEikjh9GIdKBs5G5JdUqlU+ODJUNT2dMGpjFzMi0mWOyS6B3ESuUJ64VXG2O5NEBbki+wCPSatS4TRBubaMYEiUjgjEyhSiFqeLpg3uLjh8Dd/peCv09dkjojKo7OxESgA0GrUWDw0DK5aNf46fR0r9p6TO6T7YgJFpHAcgSIleayFP57t2ABA8Z1TWbd0MkdEd1NqL7z7aVTHE9P6tQIAfBRzEqfSc2SOqGI2tnuJHA9HoEhppvVtiYa13HElqwAzNx2VOxy6i6kSuS2NQJk837EBHm1WB4V6IyasSUCRXrkNh5lAESmcXqwDZYNnQ7JLHi5OWDQsHGoVsDHhMn5NvCx3SFRCkd72LuGZqFQqzB/cFr7uWhy9lI2lcafkDumezE6g9Ho9vv/+e6Sns0M3kTWY6kCpmUCRgjzQoAbGdS++c2r6xqNIyyqQOSIyseURKADw83bF3CeL59p9tus0Dp2/IXNE5TM7gXJycsKrr76KggJ+WYiswcgRKFKo13o0Rdv6Psi6pbOZO6ccga1UIq9In9BADGpXD0YBiF6TiLxCvdwhlVGlS3gPPfQQEhISLBwKEZXHdAlPzTpQpDBajRqLhobDxUmNPaeuYeUBNhxWAvEuPBufpDNrQGvU83XD+ev5eG/LcbnDKaNKu/e///0voqOj8emnnyI+Ph5Hjhwp9UNEllHyL3qOQJESNfHzxNt9WwIA5m3/F+m2UQPRrt2pAyVzINXk7arFgiFhUKmAHw9cQNwJZU0dcqrKm55++mkAwOuvvy4+p1KpIAgCVCoVDAZWqCWyBH2JBIpzoEipXugUjN9PpGPPqWv4v1MaPG8wQquVOyrHZapEbg+njIjGtfDSwyH4ck8K3vr5CLaNfwS1PF3kDgtAFUegUlJSyvycPXtW/K89WLZsGRo2bAhXV1d07NgRBw4ckDskckCmNi4AyxiQcqnVKswfHAYfNydcyFPhs1328XvAVtnLCJTJxF7N0dzfC9dyizB1fRIEQRlz7aqUQAUHB1f4Y+tWr16N6OhozJw5E//88w/CwsIQFRWFjIwMuUMjB6PnJTyyEQE+rpjdv7gI4ud/pOCf1JsyR+S4xGbCNtTKpSKuWg0WDwuHVqPC9uPpWHvootwhAahmHajjx48jJiYGv/zyS6kfW7do0SK8/PLLePHFF9GqVSssX74c7u7u+Oabb+QOjRyMoeQlPE4iJ4XrFxqA9rWNMBgFRK9OQH6R8u6ccgR6O5lEXlKrut6Y2Ks5AGD2L8dw4Ua+zBFVcQ7U2bNn8eSTTyIpKUmc+wQUz4MCYNNzoIqKinDo0CFMnTpVfE6tViMyMhLx8fEyRlbsj1PXoFNuYVayMANHoMjGDA4x4lKRG85dz8cHW0/gvYGhcofkcOztEp7Jy10bYceJDBw4dwPRaxLw0+gIWac2VCmBeuONNxASEoK4uDiEhITgwIEDuH79OiZOnIgFCxZYOkarunbtGgwGA/z9/Us97+/vj5MnT5b7nsLCQhQWFoqPs7OzAQAHDx6Ep6enxWL74Wgufvn3FsLdshHodwBaztKUjU6nw5kzZ3DggLTHIbPgTrZ88ODfkm3HllnrWND96XQ6XDl/Bi+2egBz9xXih32pCFJnol2AMib9Oor8guLfR5cvXbS778Xw5kDSRRX+PncT76zcjYHN3S26/tzc3MovLFRBrVq1hMTEREEQBMHb21s4efKkIAiCEBcXJ4SHh1dllYpx6dIlAYCwd+/eUs9PmjRJeOihh8p9z8yZMwUAkv+4NnpQCH5rsxD81mbBNTjMKtvkj7w/Gs9aQvBbm4UGb26UPRb+8MecnxqPvSQEv7VZqDf2e0Ht5i17PI70U//1H4XgtzYLTjXryx6LFD8ebXoIDd7cIHg/9KRk28jKyrpvvqASBPOns9eoUQP//PMPQkJC0LhxY3z11Vfo3r07zpw5g9DQUOTny39tsqqKiorg7u6OdevWYeDAgeLzI0aMQGZmJjZt2lTmPeWNQAUFBSEuLs6iI1AA8L9DWYg7X4SariosjKwJD2c7ushtQ3Q6Hfbv34+OHTtK+tfdtXwD/htzA1o1sHJgHcm2Y8usdSzo/koeC0HthCk7buJijgEP1XXGxI7e4jQPktbwX66hQC9geM2ziOrygN19LwRBQHqeEQGeGouvOzc3Fz169EBWVha8vb0rXLZKl/DatGmDxMREhISEoGPHjpg3bx6cnZ3xxRdfoFGjRlUKWimcnZ3Rvn17xMXFiQmU0WhEXFwcxo0bV+57XFxc4OJSdoj6wQcfvO8BMFfz1rfQY34crhUAmy66YMnT7Sy6fqocnU6Ha9eu4aGHHpL05JR6PR+I2QmtkwYPPfSQZNuxZdY6FnR/dx+L5Q2yMHDZXzhwuQgXnerhqfb15Q7RIRg3/QZAQKOGDfi9MJNpCk5lVGn4Yvr06TDeblY4Z84cpKSkoGvXrti6dSuWLl1alVUqSnR0NL788kt89913OHHiBMaMGYO8vDy8+OKLcocGd2cnvNDEwC7oDsLUSFjDv9zJBrWp54MJPZsBAGYq5M4peycIAnQ23kzYVlRpBCoqKkr8/yZNmuDkyZO4ceMGatSoYRdDtMOGDcPVq1cxY8YMpKWlITw8HDExMWUmlsuloRcw5tFGWLbrLKZvPIoODWsiwMdV7rBIAgbTiZBnQrJRrzzSCDtOZuDQ+Zt4c20ifny5E6vqS8hgFGCamMPThrSqNYHm9OnT2LZtG27duoWaNWtaKiZFGDduHM6fP4/CwkLxmr6SjO3WCKH17nRBr8JUNrIBt+9G5ggU2SwnjRqLhobB3VmD/Sk38PWfKXKHZNdKFt+1pzpQSlSl3Xv9+nX06NEDzZo1Q9++fXHlyhUAwKhRozBx4kSLBkjl02rUWDzsThf0/9t3Xu6QSAJ60wgU/2InGxZcywMzHi+uUj5/WzJOplV+ngmZx1SFHLC/OlBKU6UEasKECdBqtUhNTYW7+50aDMOGDUNMTIzFgqOKNfHzxNQ+LQAAH2w9gdMZZtSvIJtgNI1AMYEiGzesQxAiW/qhyGDE+J8SUKi33YLLSmaqQg7YRzNhJatSArV9+3Z89NFHqF+/9B0VTZs2xfnzHAmxpuERDdG1aW0U6IyIXpMgVqAl+yBOIueZkGycSqXC3EFtUcvDGSfTcrAo9l+5Q7JLpt8BGrWKCZTEqpRA5eXllRp5Mrlx40a5t/OTdO50QdfiyMUsfLLjtNwhkQUZeAmP7EgdLxfMHVTc2uWLP85i/9nrMkdkf8Q2LjxnSK5KCVTXrl3x/fffi49VKhWMRiPmzZuH7t27Wyw4qpwAH1e8N7ANAGDZztM4zC7odsPAS3hkZ3q1DsDQB+tDEIDoNYnIKdDJHZJd0d2+hKflDHLJVWkPz5s3D1988QX69OmDoqIiTJ48GW3atMEff/yBjz76yNIxUiX0D6uLAeF1i7ugr0lkF3Q7IU4i5114ZEdm9G+NoJpuuJR5C7N/PS53OHZFf/uvLi1rGEiuSglUmzZt8O+//+Lhhx/GgAEDkJeXh0GDBuHw4cNo3LixpWOkSprzRBsE+rgi5Voe3t9yQu5wyAI4iZzskaeLExYNDYdKBaw7dBExR6/IHZLdKBITKI5ASa1KhTQBwMfHB9OmTbNkLFRNPu5aLBgShue+2o+V+1MR2cof3Zv7yR0WVQPLGJC96tCwJl59tDE+33UGU9cn4YHgGvDzYkHg6jLdhcc5UNKrcgKVmZmJAwcOICMjQ2zrYjJ8+PBqB0ZV06VJbbzYpSG+/escJq87gm3jH0FND2e5w6IqMvIuPLJjEyKbYVfyVZy4ko0pPyfh6xEP2kU3CznpOAJlNVVKoH799Vc899xzyM3Nhbd36Q7bKpWKCZTM3urdAntOXcPpjFy8vT4Jnz//AE9KNsr01yQTKLJHzk5qLBkWjv6f/IkdJzPw098X8MxDDeQOy6bdmUTOc4bUqpSiTpw4Ef/5z3+Qm5uLzMxM3Lx5U/y5ceOGpWMkM7lqNVgyLBxOahVijqVh/T+X5A6JqsjIZsJk55oHeGFy7+YAgHc3H8e5a3kyR2TbxDIGHIGSXJX28KVLl/D666+XWwuKlOHuLugXb7ILui0y9bXiCBTZs/90CUFEo1rILzIgek2CeCcZmc+UQDlzBEpyVUqgoqKicPDgQUvHQhb2yiON0D64BnIL9Zi4JhEGIxsO2xoDEyhyAGq1CguGhsHLxQn/pGZi+e4zcodks0yX8DgCJb1Kz4H65ZdfxP/v168fJk2ahOPHjyM0NBRarbbUsk888YTlIqQqM3VB7/PxHuxPuYFv/kzBy480kjssMgMTKHIU9XzdMGdga0xYnYglv5/Co838EFrfR+6wbI6OdaCsptIJ1MCBA8s8N2fOnDLPqVQqGAxsEqkUpi7oU9YnYf62ZHRtVhstArzlDosqiQkUOZKB4fXw+/EMbEm6gvGrD2PL613hqtXIHZZNMZU+cVJzBEpqld7DRqOxUj9MnpSHXdBtlymBYk0XcgQqlQrvDWwDPy8XnLmahw9/Oyl3SDZHp+ddeNZiVooaHx+PzZs3l3ru+++/R0hICPz8/DB69GgUFhZaNECqPnZBt12G23fhqXkXHjmIGh7OmDe4LQBgxd5z2HPqqswR2RadkXWgrMWsPTx79mwcO3ZMfJyUlIRRo0YhMjISU6ZMwa+//oq5c+daPEiqvjpeLviAXdBtjjgCxb8myYF0a+6HFzoFAwAmrT2CrHw2HK4snZ5zoKzFrAQqMTERPXr0EB//9NNP6NixI7788ktER0dj6dKlWLNmjcWDJMuIYhd0m2NKoDgCRY5mat8WaFTbA2nZBXhn01G5w7EZevGyP0egpGbWHr558yb8/f3Fx7t370afPn3Exx06dMCFCxcsFx1ZHLug2xbOgSJH5e7shEXDwqFRq/BL4mVsSmBB4MoQmwk78ZwhNbMSKH9/f6SkpAAAioqK8M8//6BTp07i6zk5OWVKGpCylO2CniZ3SFQBcQSKCRQ5oPAgX7z2WBMAwDsbj+JK1i2ZI1K+O82EOQIlNbP2cN++fTFlyhTs2bMHU6dOhbu7O7p27Sq+fuTIETRu3NjiQZJldWhYE688Unyc3t6QhIycApkjonsxTSLnCBQ5qrHdmyAsyBfZBXq8uTYRRhYErhArkVuPWQnUu+++CycnJzz66KP48ssv8eWXX8LZ2Vl8/ZtvvkGvXr0sHiRZ3oSeTdEy0Bs38oow5eckCAJPSkpkYDNhcnBajRqLh4bBVavGX6ev47v4c3KHpGisRG49Zu3h2rVr448//hAbBz/55JOlXl+7di1mzpxp0QBJGi5OxQ2HnTVq7DiZgR8PcO6aErGMARHQqI4npvVtCQD48LeTOJWeI3NEysVK5NZTpRTVx8cHGk3Z6rA1a9YsNSJFysYu6MrHSeRExZ7vFIxHmtVBod6ICWsSUKRnw+HymBoxcw6U9LiHHZypC/otHbugKxEnkRMVU6lUmD+4LXzdtTh6KRtL407JHZIiFRlYidxamEA5uLu7oH++i13QlYQjUER3+Hu74oMniwsCf7brNA6dvyFzRMqjN7ASubVwD5PYBR0APo47haSLWTJHRCYcgSIqrW9oIAa1qwejAExYnYi8Qr3cISkK50BZDxMoAlDcBb1faCD0RgHjVx9GgY4Nh5VAzxEoojJmDWiNuj6uSL2Rj/e2nJA7HEXRGU2X8PjrXWrcwwSAXdCVynj7LjwN78IjEnm7arFgaBgA4McDqYg7kS5zRMph6oXH/pnSYwJFInZBVx7TCJSGd9QQldK5cW289HAIAOCtn4/gem6hzBEpg54jUFbDPUylsAu6shjFBErmQIgU6M2o5mjm74lruUWYup4FgYESc6B42V9yPC1TGSW7oE9nF3RZcQSK6N5ctRosHhYOrUaF7cfTsfbQRblDkp2pPhZHoKTHPUxllOyC/iu7oMuKI1BEFWtd1wfRPYsLAs/59Tgu3MiXOSJ5iTeecA6U5HhapnKxC7oycASK6P5GP9IIHRrWQG6hHhPXJIrlPxyRjnWgrIZ7mO6JXdDlZxDvwpM5ECIF06hVWDQ0HB7OGhw4dwNf7jkrd0iyudNMmCcNqTGBontiF3T5GW6fDDX8a5KoQkE13THzieKCwAu3J+P45WyZI5KHaQTKmecMyXEPU4XYBV1eBtaBIqq0Ie3ro2crf+gMAiasTnDIgsB3mgnznCE1JlB0X+yCLh8jK5ETVZpKpcLcQaGo7emM5PQcLNyeLHdIVqczsA6UtXAP032xC7p89OyFR2SW2p4u+HBQcUHgr/5MQfyZ6zJHZF2mS3icAyU9JlBUKWW7oN+UOSLHILZy4TeVqNIiW/njmYeCIAjAm2sTkV3gOAWBeRee9XAPU6X1DQ3Ek7e7oEevSWAXdCvQG1jGgKgqpvdrheBa7riUeQuzfjkmdzhWoxcv4XEESmo8K5NZZj1R3AX9/HV2QbcGTiInqhoPFycsGhoGtQpY/88lbE26IndIVlHEESir4R4ms/i4sQu6NRnEQppMoIjM1T64JsZ0awwAeHtDEjKyC2SOSHp63nhiNUygyGzsgm49TKCIqueNHs3Quq43MvN1mLTuiF03HDYaBfGcwREo6XEPU5WwC7p1GPjXJFG1ODupsWRYOJyd1Nj971X8sD9V7pAkozPeKTHDBEp6NrOH33//fXTu3Bnu7u7w9fUtd5nU1FT069cP7u7u8PPzw6RJk6DXl57ovGvXLjzwwANwcXFBkyZNsGLFijLrWbZsGRo2bAhXV1d07NgRBw4ckOAT2ba7u6CvYxd0SRhYxoCo2pr6e2FK7xYAgPe3HMfZq7kyRyQNUw0ogJPIrcFmEqiioiIMGTIEY8aMKfd1g8GAfv36oaioCHv37sV3332HFStWYMaMGeIyKSkp6NevH7p3746EhASMHz8eL730ErZt2yYus3r1akRHR2PmzJn4559/EBYWhqioKGRkZEj+GW1NyS7os9kFXRIcgSKyjJGdG6JLk1oo0BkxYU2iWLHbnpT8TByBkp7N7OHZs2djwoQJCA0NLff17du34/jx4/jhhx8QHh6OPn364N1338WyZctQVFQEAFi+fDlCQkKwcOFCtGzZEuPGjcPgwYOxePFicT2LFi3Cyy+/jBdffBGtWrXC8uXL4e7ujm+++cYqn9PWsAu6tEx34al5Fx5RtajVKswfHAYvVyckXsjEsp1n5A7J4kx34KlUnDdpDTaTQN1PfHw8QkND4e/vLz4XFRWF7OxsHDt2TFwmMjKy1PuioqIQHx8PoHiU69ChQ6WWUavViIyMFJeh0tgFXVriCBSH44mqra6vG94b2AYAsHTHKSReyJQ3IAvTs42LVTnJHYClpKWllUqeAIiP09LSKlwmOzsbt27dws2bN2EwGMpd5uTJk/fcdmFhIQoL79yJlp1d3AVcp9NBp7NsBVzT+iy93uoI8NJiWt8WeHvjMSzcnozOITXQMtBL7rAkZa3jYBqSFwwGRR1zJVHid8JR2cKx6NOqDra3CcCWo2kY/9NhbPpvBNycNXKHZRH5hcVXW7RqlU0cCyUyZ3/JmkBNmTIFH330UYXLnDhxAi1atLBSRFUzd+5czJ49u8zz27dvh7u7uyTbjI2NlWS9VeUuAKE11Ei6qcYr3+7FxLYGaB3gjyCpj0NungaACvv27cWVo5JuyuYp7TvhyJR+LLq4An9qNUi5no+xX8RicCP7mA+VfgsAnCAY9eIxUPqxUJr8/MrP5ZU1gZo4cSJGjhxZ4TKNGjWq1LoCAgLK3C2Xnp4uvmb6r+m5kst4e3vDzc0NGo0GGo2m3GVM6yjP1KlTER0dLT7Ozs5GUFAQevXqBW9v70rFX1k6nQ6xsbHo2bMntFqtRdddXZ0eLUS/T+NxJa8IJ5waY0rv5nKHJBlrHYcPju0GigrxyMMPo3Vdy/5bshdK/k44Gls6FoGtr+PF7w5hT7oaL0Y9iK5Na8sdUrWdTMsBEuLh7uqCnj272MyxUBLTFaTKkDWBqlOnDurUqWORdUVEROD9999HRkYG/Pz8ABRn3t7e3mjVqpW4zNatW0u9LzY2FhEREQAAZ2dntG/fHnFxcRg4cCAAwGg0Ii4uDuPGjbvntl1cXODi4lLmea1WK9k/XCnXXVUBNbT46Km2eOn7g/hm73lEtgpERONacoclKamPg+mmGhdn5R1vpVHid8JR2cKx6N4yACM7N8SKvecwZcMxbBv/CGp4OMsdVvWoii9FOmvU4v63hWOhJObsK5u5yJKamoqEhASkpqbCYDAgISEBCQkJyM0trufRq1cvtGrVCi+88AISExOxbds2TJ8+HWPHjhWTm1dffRVnz57F5MmTcfLkSXz22WdYs2YNJkyYIG4nOjoaX375Jb777jucOHECY8aMQV5eHl588UVZPretceQu6FIwCqxETiSVt3q3QOM6HsjIKcT0jUdtviCw6S48J04itwqb2cszZsxAu3btMHPmTOTm5qJdu3Zo164dDh48CADQaDTYvHkzNBoNIiIi8Pzzz2P48OGYM2eOuI6QkBBs2bIFsbGxCAsLw8KFC/HVV18hKipKXGbYsGFYsGABZsyYgfDwcCQkJCAmJqbMxHK6t+n9WqFBTcfrgi4FtnIhko6bc3FBYCe1CluSrmBTwmW5Q6oWndhImOcLa7CZu/BWrFhRbtXwkoKDg8tcortbt27dcPjw4QqXGTduXIWX7KhiHi5OWDwsDEOWx2P9P5cQ2dIffUMD5Q7LJokJFOtAEUmibX1fvNGjKRbG/ot3Nh1Fh5CaqOfrJndYVcIyBtbFvUyScMQu6FLgCBSR9MZ0a4x2DXyRU6DHm2sSYbTRgsB3RqD4q90auJdJMo7UBV0qTKCIpOekUWPR0HC4aTWIP3sd3/yVIndIVaIT50DxfGENTKBIMo7UBV0qBk4iJ7KKkNoemP54SwDAvG3J+Dc9R+aIzKfjJTyr4l4mSTlKF3QpCILAESgiK3r2oQbo3rwOivRGjP8pAUV62yqwqTdyErk1MYEiyTlCF3QplJyGwUnkRNJTqVT4aHBb1HDX4viVbCz5/V+5QzKLKeHjCJR1cC+T5ByhC7oUTH9NAoCGf1ESWYWflyvmDgoFACzffQZ/n7shc0SVpzc1H1fzV7s1cC+TVdh7F3QplMifOAJFZEW92wRicPv6MApA9JoE5Bbq5Q6pUkyTyJ2deL6wBiZQZDVPhNXF420DYTAKmLA6AbeKDHKHpGilRqA4B4rIqmb2b4V6vm64cOMW3v31uNzhVAonkVsX9zJZjUqlwnsD28Df2wVnr+Vh7m8n5A5J0UqNQDGBIrIqL1ctFg4Ng0oFrD54AduPpckd0n2JZQx4Cc8quJfJqnzdnbFgSBgA4Pv489j971WZI1KuUiNQvIRHZHWdGtXC6K6NAABT1yfhak6hzBFVTM9LeFbFBIqsrmvTOhjZuSEAYNLaRNzMK5I3IIUy1YBSqYon4hOR9UX3aoYWAV64nleEqeuVXRC4yMBJ5NbEvUyysLcu6FIwiHfUMHkikouLU3HDYWeNGr+fyMCagxfkDume9GzlYlXcyyQLe+uCLgVTAqXm5TsiWbUM9MbEXs0AALN/PY7z1/Nkjqh8d3rh8ZxhDUygSDZt6/vi9R5NAQDvbDqKS5m3ZI5IWTgCRaQcL3VthIdCaiK/yIDoNYni91NJeBeedXEvk6z+260xwoNsvwu6FMQRKCZQRLLTqFVYOCQMni5OOHT+JpbvVl5BYDYTti4mUCQrJ40ai4fZfhd0KRgFjkARKUlQTXfMeqI1AGBx7L84eilL5ohK03MEyqq4l0l29tAFXQp6NhImUpynHqiH3q0DoL9dELhAp5yCwJwDZV1MoEgRbL0LuhQ4iZxIeVQqFT4YFIrani44lZGL+duS5Q5JpDNyBMqauJdJEWy9C7oUOImcSJlqejhj/uC2AICv/0zBX6evyRxRMZ3eNAeKv9qtgXuZFMOWu6BLgZPIiZSrews/PNexAQDgzbWJyLqlkzmiEs2EeQnPKphAkaL0bhOIpx6wvS7oUuAIFJGyTevXEg1rueNKVgFmbjoqdzjiJTxWIrcO7mVSnJlP3OmCPufXY3KHIxuOQBEpm7uzExYNC4daBWxMuIxfE+UtCGy6hKd14q92a+BeJsXxLtEFfc3BizbRBV0KHIEiUr4HGtTAuO5NAADTNx5FWlaBbLGYGpBrec6wCiZQpEh3d0G/lqvsLuhSMDUT5l14RMr2Wo+maFvfB1m3dJi0LlG23p5FrANlVdzLpFglu6BP+TnJ4RoOm+pAsaowkbJpNWosGhoOFyc19py6hv/bd16WOMRmwryEZxXcy6RYpbugpyu6C7oUTG1tNByBIlK8Jn6eeLtvcUHgD7aewOmMXKvHIBbS5CU8q2ACRYpmK13QpcBK5ES25YVOwejatDYKdEZEr0kQExprEVu5cATKKriXSfFKdkGfqNAu6FIwMoEisilqtQrzB4fBx02LIxez8MmO01bdfpGpmTDPGVbBBIoUr2QX9IMK7YIuBY5AEdmeAB9XvDewDQBg2c7T+Cf1ptW2zWbC1sW9TDahZBf0Jb8rrwu6FIwCEygiW9Q/rC4GhNeFwSggenUC8ousUxD4TjNh/mq3Bu5lshmmLug6g/K6oEvB9NekhlWFiWzOnCfaINDHFeeu5+P9LSesss07CRT/6LIGnpnJZii5C7oUTHWgeC4ksj0+7losGBIGAFi5PxU7kzMk36aOl/CsinuZbIpSu6BL4c4kcn5NiWxRlya18WKXhgCAyeuO4EZekaTbEyuRM4GyCu5lsjlK7IIuhTuTyGUOhIiq7K3eLdDEzxNXcwrx9nrpCgILgiCOQLH4rnXw1Ew2qWQX9BkK6IIuBdMkcnZWJ7JdrloNlgwLh5NahZhjaVj/zyVJtqMvUd6FI1DWwb1MNqlkF/RNCuiCLgXTJHI178Ijsmlt6vlgQs/igsAzfzmGizfzLb6NkkU7OYncOphAkc1SUhd0KRg5iZzIbrzySCO0D66B3EI9Jq5JFOc4Worp8h3AEShr4V4mm/Zaj6YIrSd/F3Qp6DmJnMhuOGnUWDQ0DO7OGuxPuYGv/0yx6PpLjkCxErl18MxMNk2rUWPxMPm7oEvBwEnkRHYluJYHZjzeCgAwf1syTqZlW2zdd6qQq6BiA3Kr4KmZbF4TP09M7dMCgHxd0KVg4AgUkd0Z1iEIkS39UGQwYvxPCSjUW6YgsE7sg8fzhbVwT5NdGB7RUNYu6FLgCBSR/VGpVJg7qC1qeTjjZFoOFsX+a5H1FrEKudXx1Ex2oUwX9LhTcodUbaYEin9REtmXOl4umDsoFADwxR9nsf/s9Wqvk42ErY97muxGqS7ou85YtQu6FEytXNScz0Bkd3q1DsDQB+tDEIDoNYnIKaheQWA2ErY+7mmyK3J1QZeCOALFIXkiuzSjf2sE1XTDpcxbmP3r8WqtS0ygnHi+sBYmUGR3SnZB/2CrdbqgS8GUQHEEisg+ebo4YdHQcKhUwLpDFxFzNK3K6xIbCfOSv9VwT5PdKdkF/Yd91umCLoU7c6CYQBHZqw4Na+LVRxsDAN7ekISMnKoVBNbzEp7V2cSePnfuHEaNGoWQkBC4ubmhcePGmDlzJoqKSne2PnLkCLp27QpXV1cEBQVh3rx5Zda1du1atGjRAq6urggNDcXWrVtLvS4IAmbMmIHAwEC4ubkhMjISp07Z/oRkR2PtLuhSEEegmEAR2bUJkc3QMtAbN/KKMOXnqjUcNt2Fx0v+1mMTCdTJkydhNBrxv//9D8eOHcPixYuxfPlyvP322+Iy2dnZ6NWrF4KDg3Ho0CHMnz8fs2bNwhdffCEus3fvXjzzzDMYNWoUDh8+jIEDB2LgwIE4evROM9p58+Zh6dKlWL58Ofbv3w8PDw9ERUWhoMC+2oQ4gpJd0KdtkK4LulT0HIEicgjOTmosGRYOZ40aO05m4McDF8xeB+/Csz6b2NO9e/fGt99+i169eqFRo0Z44okn8Oabb2L9+vXiMitXrkRRURG++eYbtG7dGk8//TRef/11LFq0SFzm448/Ru/evTFp0iS0bNkS7777Lh544AF8+umnAIpHn5YsWYLp06djwIABaNu2Lb7//ntcvnwZGzdutPbHpmoq2QX9t6Np2HBYmi7oUjGKdaCYQBHZu+YBXpjcuzkA4N3Nx3HuWp5Z79exDpTV2UQCVZ6srCzUrFlTfBwfH49HHnkEzs7O4nNRUVFITk7GzZs3xWUiIyNLrScqKgrx8fEAgJSUFKSlpZVaxsfHBx07dhSXIdtSqgv6Jmm6oEvFVMaACRSRY/hPlxBENKqFWzoDJqxJEOc1VYbOyBEoa3OSO4CqOH36ND755BMsWLBAfC4tLQ0hISGllvP39xdfq1GjBtLS0sTnSi6TlpYmLlfyfeUtU57CwkIUFhaKj7Ozi/sb6XQ66HTVq+1xN9P6LL1ee/afiCDEnUjHP6mZiF6dgP978cFqzyuyxnHQmVo8CEYe7wrwO6EcPBbV9+GTrdDv03gcTs3EpztOYWy3RpV6X0Fh8T7XqEr/7uGxMI85+0vWBGrKlCn46KOPKlzmxIkTaNGihfj40qVL6N27N4YMGYKXX35Z6hArZe7cuZg9e3aZ57dv3w53d3dJthkbGyvJeu1Vv1rA0YsaHDh3E5O/icFjdS0zH0rK43DhohqAGsknT2BrVvVqxDgCfieUg8eiegYGqfDDaQ2W7jgFp4yTCPK8/3v+SVcB0ODm9aulbo7isTBPfn7lr1LImkBNnDgRI0eOrHCZRo3uZN+XL19G9+7d0blz51KTwwEgICAA6enppZ4zPQ4ICKhwmZKvm54LDAwstUx4ePg9Y5w6dSqio6PFx9nZ2QgKCkKvXr3g7e1d4eczl06nQ2xsLHr27AmtVmvRdds71wYXMW3TcWy96ISXH++E5gFeVV6XNY5DTHYicD0doa1bo2+nBpJswx7wO6EcPBaW0UcQcH31Efx2LB3rr/hg0387wVWrqfA9Nw9cAM6eQN3AAPTtG85jUUWmK0iVIWsCVadOHdSpU6dSy166dAndu3dH+/bt8e2330J9V7GwiIgITJs2DTqdTvzHEhsbi+bNm6NGjRriMnFxcRg/frz4vtjYWERERAAAQkJCEBAQgLi4ODFhys7Oxv79+zFmzJh7xubi4gIXF5cyz2u1Wsn+4Uq5bnv1bKeG2PnvNfx+IgNv/nwUm8Z1gYtTxSel+5HyOAhQ3d6GE491JfA7oRw8FtX3waC2OJT6B85ey8PC389g1hOtK1zedL5wuet8wWNhHnP2lU3MNrt06RK6deuGBg0aYMGCBbh69SrS0tJKzUt69tln4ezsjFGjRuHYsWNYvXo1Pv7441IjQ2+88QZiYmKwcOFCnDx5ErNmzcLBgwcxbtw4AMVdssePH4/33nsPv/zyC5KSkjB8+HDUrVsXAwcOtPbHJgsr0wV9u2W6oEuFZQyIHFcND2fMG9wWALBi7znsOXW1wuXFu/B4vrAam0igYmNjcfr0acTFxaF+/foIDAwUf0x8fHywfft2pKSkoH379pg4cSJmzJiB0aNHi8t07twZq1atwhdffIGwsDCsW7cOGzduRJs2bcRlJk+ejNdeew2jR49Ghw4dkJubi5iYGLi6ulr1M5M0SnVB32OZLuhSMZruwmMrFyKH1K25H17oFAwAeHNtIrLy7z3BWcc6UFZnE3t65MiREASh3J+S2rZtiz179qCgoAAXL17EW2+9VWZdQ4YMQXJyMgoLC3H06FH07du31OsqlQpz5sxBWloaCgoK8Pvvv6NZs2aSfj6yLkt3QZeKnnWgiBze231bolFtD6RnF+KdTUfvuZyOlcitziYSKCJLK9kFfU41u6BLhYU0icjNWYNFw8KhUavwS+JlbEoovyAwK5FbH/c0OaSSXdDXVrMLulT0xuK/KJlAETm28CBfvPZYEwDAOxuP4krWrTLLsBK59TGBIofVoWFNvPJI9bugS+V2/sQEiogwtnsThAX5IrtAjzfXJooj1CacA2V93NPk0Cb0bFrtLuhS4QgUEZloNWosHhoGV60af52+ju/iz5V6/c4IFH+tWwv3NDk0FydNtbugS+X2H5S8C4+IAACN6nhiWr9WAIAPfzuJU+k54mumP7h4Cc96mECRw6tuF3SpGEwjUDwhEtFtz3dsgEeb1UGh3ogJaxJQpC8+TxTpeQnP2riniVDcBb1To5q4pTMg2swu6FIxhcARKCIyUalUmD+4LXzdtTh6KRtL404BKFnGgL/WrYV7mgiAWq3CgiFh8HJxwj+pmVi++4zcIYkjUKxETkQl+Xm74oMniwsCf7brNA6dvylewnPmiLXVMIEiuq1+DXfMHlDcb2rJ76eQdDFL1ngMt++yUTOBIqK79A0NxKB29WAUgOg1Cci8XaWcI1DWwz1NVMKT7eqhb2gA9EYBE9YkoEBnkC0W013KHIEiovLMGtAa9XzdcP56PvaeKW5LxTlQ1sM9TVSCSqXC+wNDUcfLBaczcvHhbydli8U0JM8RKCIqj7erFvOHtC31HO/Csx4mUER3ubsL+p+nrskSh6mQJkegiOheOjeujZceDhEfcwTKerinicrRvbkfnu/UAAAwaV3FXdClIo5A8S48IqrAm1HN0SLACwBQv4abzNE4DiZQRPfwdt+WCKntgStZBZjxy727oEvFwFYuRFQJrloN1o3pjI1ju6BtfV+5w3EYTKCI7sHd2QmLhoZBo1ZhU8Jl/JJ42arbZxkDIqosTxcnhAf5yh2GQ2ECRVSBdg1qYFz34i7o0zckIS3Leg2HWcaAiEi5mEAR3ce4x5ogrL7PPbugS8WUQHEEiohIeZhAEd2HVqPGomHhcNWq8efpa/j+ri7oUjEIt0egOImciEhxmEARVULjOp54u29LAMDc307idEau5NsUR6BY14WISHGYQBFV0gudgvHI7S7ob/6cBL3E/YZNCRSbCRMRKQ8TKKJKMnVB93HT4tjlHGy7KN3XRxAEsZULyxgQESkPEygiM/iX6IIee0mFwxcyJdmOocREdSZQRETKwwSKyEz92gbiibaBEKDCpHVHkVeot/g29EygiIgUjQkUURXMfLwFfJ0FnL+Rj/e2nLD4+o0CEygiIiVjAkVUBd5uWjzXpHgW+Y8HUrHjZLpF188RKCIiZWMCRVRFzXwEvNg5GAAweV0SrucWWmzdJYt18i48IiLlYQJFVA0TI5ugqZ8nruUW4u0NSRAEy1Qp5yRyIiJlYwJFVA0uWg0WDwuHVqPCtmPp+PmfSxZZr9gHT1VcPoGIiJSFCRRRNbWp54MJPZsBAGb9cgwXbuRXe52mNi5Oan5FiYiUiGdnIgt45ZHGeDC4BnIL9Zi4JrHUJbiq0Btuj0DxG0pEpEg8PRNZgEatwqKh4fBw1uDAuRv4cs/Zaq3PVMaAE8iJiJSJCRSRhTSo5Y4Z/VsBABZuT8bxy9lVXpepjAEnkBMRKRMTKCILGvpgECJb+kNnEBC9JgGFekOV1mNkAkVEpGhMoIgsSKVS4cOnQlHLwxkn03KwaPu/VVrPnREofkWJiJSIZ2ciC6vt6YIPn2oLAPhiz1nsO3vd7HUYxATKoqEREZGF8PRMJIGerfzxdIcgCAIwcU0isgt0Zr3flECxjAERkTLx7EwkkemPt0KDmu64lHkLs345ZtZ7TXWgmD8RESkTT89EEvF0ccLiYWFQq4D1/1zCb0lXKv1ejkARESkbz85EEmofXBOvPtoYAPD2hiRkZBdU6n0lW7kQEZHyMIEiktj4yGZoFeiNm/k6TP75SKUaDnMEiohI2Xh2JpKYs5MaS54Oh7OTGruSr2Ll/tT7vkccgeIQFBGRIjGBIrKCZv5eeKt3CwDA+1tOIOVaXoXL3xmBYgJFRKRETKCIrOTFzg3RuXEt3NIZMGF1AvQG4z2X5QgUEZGyMYEishK1WoX5Q8Lg5eqEhAuZWLbzzD2XNZUx4AgUEZEyMYEisqJ6vm54d0AbAMDSHaeQeCGz3OXESuQqJlBERErEBIrIygaE10W/toEwGAVMWJOAW0VlGw4b2EyYiEjRbCaBeuKJJ9CgQQO4uroiMDAQL7zwAi5fvlxqmSNHjqBr165wdXVFUFAQ5s2bV2Y9a9euRYsWLeDq6orQ0FBs3bq11OuCIGDGjBkIDAyEm5sbIiMjcerUKUk/GzkWlUqF9we2gZ+XC85ezcOHv50oswwTKCIiZbOZBKp79+5Ys2YNkpOT8fPPP+PMmTMYPHiw+Hp2djZ69eqF4OBgHDp0CPPnz8esWbPwxRdfiMvs3bsXzzzzDEaNGoXDhw9j4MCBGDhwII4ePSouM2/ePCxduhTLly/H/v374eHhgaioKBQUVK4AIlFl+Lo7Y/6QMADAd/Hn8ce/V0u9zknkRETKZjMJ1IQJE9CpUycEBwejc+fOmDJlCvbt2wedrrhJ68qVK1FUVIRvvvkGrVu3xtNPP43XX38dixYtEtfx8ccfo3fv3pg0aRJatmyJd999Fw888AA+/fRTAMWjT0uWLMH06dMxYMAAtG3bFt9//z0uX76MjRs3yvGxyY492qwORkQEAwAmrUtEZn6R+BrLGBARKZvNJFAl3bhxAytXrkTnzp2h1WoBAPHx8XjkkUfg7OwsLhcVFYXk5GTcvHlTXCYyMrLUuqKiohAfHw8ASElJQVpaWqllfHx80LFjR3EZIkua0qclGtXxQHp2IaZtPCpWKRebCXMSORGRIjnJHYA53nrrLXz66afIz89Hp06dsHnzZvG1tLQ0hISElFre399ffK1GjRpIS0sTnyu5TFpamrhcyfeVt0x5CgsLUVhYKD7Ozs4GAOh0OnGEzFJM67P0esk8ljoOTipgwVNtMOSLA9hy5Aoea1YbT4QFolCnBwCoVQKP9X3wO6EcPBbKwWNRNebsL1kTqClTpuCjjz6qcJkTJ06gRYviCs6TJk3CqFGjcP78ecyePRvDhw/H5s2boZL5r/S5c+di9uzZZZ7fvn073N3dJdlmbGysJOsl81jqOPSqq8JvFzWYvuEIcs4eRtINFQANMtLTytzoQOXjd0I5eCyUg8fCPPn5+ZVeVtYEauLEiRg5cmSFyzRq1Ej8/9q1a6N27dpo1qwZWrZsiaCgIOzbtw8REREICAhAenp6qfeaHgcEBIj/LW+Zkq+bngsMDCy1THh4+D1jnDp1KqKjo8XH2dnZCAoKQq9eveDt7V3h5zOXTqdDbGwsevbsKV6+JOuz9HHoZTDi0lcHcORiNrZl+qFbi9rAuX9Rv25d9O3b1gIR2y9+J5SDx0I5eCyqxnQFqTJkTaDq1KmDOnXqVOm9RmNxGwzTpbOIiAhMmzYNOp1O/McSGxuL5s2bo0aNGuIycXFxGD9+vLie2NhYREREAABCQkIQEBCAuLg4MWHKzs7G/v37MWbMmHvG4uLiAhcXlzLPa7Vayf7hSrluqjxLHQetFlgyrB36Lf0T8WdvID27+N+11knD41xJ/E4oB4+FcvBYmMecfWUTk8j379+PTz/9FAkJCTh//jx27NiBZ555Bo0bNxaTn2effRbOzs4YNWoUjh07htWrV+Pjjz8uNTL0xhtvICYmBgsXLsTJkycxa9YsHDx4EOPGjQNQXJ9n/PjxeO+99/DLL78gKSkJw4cPR926dTFw4EA5Pjo5kEZ1PDGtX0sAwNnbzYZZB4qISJlsIoFyd3fH+vXr0aNHDzRv3hyjRo1C27ZtsXv3bnHkx8fHB9u3b0dKSgrat2+PiRMnYsaMGRg9erS4ns6dO2PVqlX44osvEBYWhnXr1mHjxo1o06aNuMzkyZPx2muvYfTo0ejQoQNyc3MRExMDV1dXq39ucjzPdWyAbs3vjMqylQsRkTLZxF14oaGh2LFjx32Xa9u2Lfbs2VPhMkOGDMGQIUPu+bpKpcKcOXMwZ84cs+Mkqi6VSoV5T7VF1JI/cDNfx0KaREQKZRMjUESOxM/bFYuHhSOktgd6tfK//xuIiMjqbGIEisjRdGvuh27N/eQOg4iI7oEjUERERERmYgJFREREZCYmUERERERmYgJFREREZCYmUERERERmYgJFREREZCYmUERERERmYgJFREREZCYmUERERERmYgJFREREZCYmUERERERmYgJFREREZCYmUERERERmYgJFREREZCYnuQOwR4IgAACys7Mtvm6dTof8/HxkZ2dDq9VafP1UOTwOysFjoRw8FsrBY1E1pt/bpt/jFWECJYGcnBwAQFBQkMyREBERkblycnLg4+NT4TIqoTJpFpnFaDTi8uXL8PLygkqlsui6s7OzERQUhAsXLsDb29ui66bK43FQDh4L5eCxUA4ei6oRBAE5OTmoW7cu1OqKZzlxBEoCarUa9evXl3Qb3t7e/FIoAI+DcvBYKAePhXLwWJjvfiNPJpxETkRERGQmJlBEREREZmICZWNcXFwwc+ZMuLi4yB2KQ+NxUA4eC+XgsVAOHgvpcRI5ERERkZk4AkVERERkJiZQRERERGZiAkVERERkJiZQNmTZsmVo2LAhXF1d0bFjRxw4cEDukOzerFmzoFKpSv20aNFCfL2goABjx45FrVq14Onpiaeeegrp6ekyRmw//vjjD/Tv3x9169aFSqXCxo0bS70uCAJmzJiBwMBAuLm5ITIyEqdOnSq1zI0bN/Dcc8/B29sbvr6+GDVqFHJzc634KezD/Y7FyJEjy3xPevfuXWoZHovqmzt3Ljp06AAvLy/4+flh4MCBSE5OLrVMZc5Jqamp6NevH9zd3eHn54dJkyZBr9db86PYBSZQNmL16tWIjo7GzJkz8c8//yAsLAxRUVHIyMiQOzS717p1a1y5ckX8+fPPP8XXJkyYgF9//RVr167F7t27cfnyZQwaNEjGaO1HXl4ewsLCsGzZsnJfnzdvHpYuXYrly5dj//798PDwQFRUFAoKCsRlnnvuORw7dgyxsbHYvHkz/vjjD4wePdpaH8Fu3O9YAEDv3r1LfU9+/PHHUq/zWFTf7t27MXbsWOzbtw+xsbHQ6XTo1asX8vLyxGXud04yGAzo168fioqKsHfvXnz33XdYsWIFZsyYIcdHsm0C2YSHHnpIGDt2rPjYYDAIdevWFebOnStjVPZv5syZQlhYWLmvZWZmClqtVli7dq343IkTJwQAQnx8vJUidAwAhA0bNoiPjUajEBAQIMyfP198LjMzU3BxcRF+/PFHQRAE4fjx4wIA4e+//xaX+e233wSVSiVcunTJarHbm7uPhSAIwogRI4QBAwbc8z08FtLIyMgQAAi7d+8WBKFy56StW7cKarVaSEtLE5f5/PPPBW9vb6GwsNC6H8DGcQTKBhQVFeHQoUOIjIwUn1Or1YiMjER8fLyMkTmGU6dOoW7dumjUqBGee+45pKamAgAOHToEnU5X6ri0aNECDRo04HGRWEpKCtLS0krtex8fH3Ts2FHc9/Hx8fD19cWDDz4oLhMZGQm1Wo39+/dbPWZ7t2vXLvj5+aF58+YYM2YMrl+/Lr7GYyGNrKwsAEDNmjUBVO6cFB8fj9DQUPj7+4vLREVFITs7G8eOHbNi9LaPCZQNuHbtGgwGQ6l/8ADg7++PtLQ0maJyDB07dsSKFSsQExODzz//HCkpKejatStycnKQlpYGZ2dn+Pr6lnoPj4v0TPu3ou9EWloa/Pz8Sr3u5OSEmjVr8vhYWO/evfH9998jLi4OH330EXbv3o0+ffrAYDAA4LGQgtFoxPjx49GlSxe0adMGACp1TkpLSyv3e2N6jSqPzYSJKtCnTx/x/9u2bYuOHTsiODgYa9asgZubm4yRESnH008/Lf5/aGgo2rZti8aNG2PXrl3o0aOHjJHZr7Fjx+Lo0aOl5mSSdXEEygbUrl0bGo2mzJ0U6enpCAgIkCkqx+Tr64tmzZrh9OnTCAgIQFFRETIzM0stw+MiPdP+reg7ERAQUOYmC71ejxs3bvD4SKxRo0aoXbs2Tp8+DYDHwtLGjRuHzZs3Y+fOnahfv774fGXOSQEBAeV+b0yvUeUxgbIBzs7OaN++PeLi4sTnjEYj4uLiEBERIWNkjic3NxdnzpxBYGAg2rdvD61WW+q4JCcnIzU1lcdFYiEhIQgICCi177Ozs7F//35x30dERCAzMxOHDh0Sl9mxYweMRiM6duxo9ZgdycWLF3H9+nUEBgYC4LGwFEEQMG7cOGzYsAE7duxASEhIqdcrc06KiIhAUlJSqYQ2NjYW3t7eaNWqlXU+iL2QexY7Vc5PP/0kuLi4CCtWrBCOHz8ujB49WvD19S11JwVZ3sSJE4Vdu3YJKSkpwl9//SVERkYKtWvXFjIyMgRBEIRXX31VaNCggbBjxw7h4MGDQkREhBARESFz1PYhJydHOHz4sHD48GEBgLBo0SLh8OHDwvnz5wVBEIQPP/xQ8PX1FTZt2iQcOXJEGDBggBASEiLcunVLXEfv3r2Fdu3aCfv37xf+/PNPoWnTpsIzzzwj10eyWRUdi5ycHOHNN98U4uPjhZSUFOH3338XHnjgAaFp06ZCQUGBuA4ei+obM2aM4OPjI+zatUu4cuWK+JOfny8uc79zkl6vF9q0aSP06tVLSEhIEGJiYoQ6deoIU6dOleMj2TQmUDbkk08+ERo0aCA4OzsLDz30kLBv3z65Q7J7w4YNEwIDAwVnZ2ehXr16wrBhw4TTp0+Lr9+6dUv473//K9SoUUNwd3cXnnzySeHKlSsyRmw/du7cKQAo8zNixAhBEIpLGbzzzjuCv7+/4OLiIvTo0UNITk4utY7r168LzzzzjODp6Sl4e3sLL774opCTkyPDp7FtFR2L/Px8oVevXkKdOnUErVYrBAcHCy+//HKZP+54LKqvvGMAQPj222/FZSpzTjp37pzQp08fwc3NTahdu7YwceJEQafTWfnT2D6VIAiCtUe9iIiIiGwZ50ARERERmYkJFBEREZGZmEARERERmYkJFBEREZGZmEARERERmYkJFBEREZGZmEARERERmYkJFBEREZGZmEAREUlApVJh48aNcodBRBJhAkVENm/kyJEYOHCgLNueNWsWwsPDyzx/5coV9OnTx/oBEZFVOMkdABGRPQoICJA7BCKSEEegiMiu7d69Gw899BBcXFwQGBiIKVOmQK/Xi68bjUbMmzcPTZo0gYuLCxo0aID3339ffP2tt95Cs2bN4O7ujkaNGuGdd96BTqcDAKxYsQKzZ89GYmIiVCoVVCoVVqxYAaDsJbykpCQ89thjcHNzQ61atTB69Gjk5uaKr5tG0RYsWIDAwEDUqlULY8eOFbdFRMrCESgisluXLl1C3759MXLkSHz//fc4efIkXn75Zbi6umLWrFkAgKlTp+LLL7/E4sWL8fDDD+PKlSs4efKkuA4vLy+sWLECdevWRVJSEl5++WV4eXlh8uTJGDZsGI4ePYqYmBj8/vvvAAAfH58yceTl5SEqKgoRERH4+++/kZGRgZdeegnjxo0TEy4A2LlzJwIDA7Fz506cPn0aw4YNQ3h4OF5++WVJ9xMRVYFARGTjRowYIQwYMKDM82+//bbQvHlzwWg0is8tW7ZM8PT0FAwGg5CdnS24uLgIX375ZaW3NX/+fKF9+/bi45kzZwphYWFllgMgbNiwQRAEQfjiiy+EGjVqCLm5ueLrW7ZsEdRqtZCWliZ+huDgYEGv14vLDBkyRBg2bFilYyMi6+EIFBHZrRMnTiAiIgIqlUp8rkuXLsjNzcXFixeRlpaGwsJC9OjR457rWL16NZYuXYozZ84gNzcXer0e3t7eZscRFhYGDw+PUnEYjUYkJyfD398fANC6dWtoNBpxmcDAQCQlJZm1LSKyDs6BIiKH5ebmVuHr8fHxeO6559C3b19s3rwZhw8fxrRp01BUVCRJPFqtttRjlUoFo9EoybaIqHqYQBGR3WrZsiXi4+MhCIL43F9//QUvLy/Ur18fTZs2hZubG+Li4sp9/969exEcHIxp06bhwQcfRNOmTXH+/PlSyzg7O8NgMNw3jsTEROTl5ZWKQ61Wo3nz5tX4hEQkFyZQRGQXsrKykJCQUOpn9OjRuHDhAl577TWcPHkSmzZtwsyZMxEdHQ21Wg1XV1e89dZbmDx5Mr7//nucOXMG+/btw9dffw0AaNq0KVJTU/HTTz/hzJkzWLp0KTZs2FBquw0bNkRKSgoSEhJw7do1FBYWlontueeeg6urK0aMGIGjR49i586deO211/DCCy+Il++IyLZwDhQR2YVdu3ahXbt2pZ4bNWoUtm7dikmTJiEsLAw1a9bEqFGjMH36dHGZd955B05OTpgxYwYuX76MwMBAvPrqqwCAJ554AhMmTMC4ceNQWFiIfv364Z133hHv4AOAp556CuvXr0f37t2RmZmJb7/9FiNHjiwVh7u7O7Zt24Y33ngDHTp0gLu7O5566iksWrRIsv1BRNJSCSXHtomIiIjovngJj4iIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzMQEioiIiMhMTKCIiIiIzPT/lmd8LsKdaCcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from PyNite import FEModel3D\n", + "from PyNite.Visualization import render_model\n", + "\n", + "beam_model_2 = FEModel3D() # Creates an empty model\n", + "\n", + "beam_model_2.add_node(name=\"node1\", X=0, Y=0, Z=0) # Change the model by adding nodes\n", + "beam_model_2.add_node(\"node2\", vert_P1, 0, 0)\n", + "beam_model_2.add_node(\"node3\", vert_P2, 0, 0)\n", + "beam_model_2.add_node(\"node4\", vert_P3, 0, 0)\n", + "beam_model_2.add_node(\"node5\", L, 0, 0)\n", + "\n", + "beam_model_2.add_member(name=\"M2\", i_node=\"node1\", j_node=\"node5\", E=E, G=77e3, Iy=I, Iz=I, J=30e3, A=1500)\n", + "\n", + "beam_model_2.def_support(\"node2\", support_DX=True, support_DY=True, support_DZ=True, support_RX=True, support_RY=False, support_RZ=False)\n", + "beam_model_2.def_support(\"node3\", False, True, True, False, False, False)\n", + "beam_model_2.def_support(\"node4\", False, True, True, False, False, False)\n", + "\n", + "beam_model_2.add_load_combo(name=\"LC1\", factors={\"LoadA\": 1,\"LoadB\": 1})\n", + "\n", + "beam_model_2.add_member_dist_load(Member=\"M2\", Direction=\"Fy\", w1=-udl_mag_1, w2=-udl_mag_1,case=\"LoadA\")\n", + "beam_model_2.add_member_dist_load(Member=\"M2\", Direction=\"Fy\", w1=-udl_mag_2, w2=-udl_mag_2,case=\"LoadB\")\n", + "\n", + "beam_model_2.analyze(check_statics=True) # Changes the model by performing the analysis and adding analysis results\n", + "\n", + "beam_model_2.Members['M2'].plot_shear(Direction=\"Fy\", combo_name=\"LC1\", n_points=100)\n", + "beam_model_2.Members['M2'].plot_moment(Direction=\"Mz\", combo_name=\"LC1\", n_points=100)\n", + "\n", + "render_model(beam_model_2, combo_name='LC1', annotation_size=10, labels=True, deformed_shape=True)" + ] + }, + { + "cell_type": "markdown", + "id": "fd6a359d-ac05-40a2-bbf9-6c69d1e68162", + "metadata": {}, + "source": [ + "# Task F\n", + "\n", + "1. Make a duplicate of the file \"beam_1.txt\" and call it \"beam_3.txt\". \n", + "2. Make a duplicate of \"beam_2.txt\" and call it \"beam_4.txt\"\n", + "3. Change some of the values in \"beam_3.txt\" and change your **Task D** script to run the data in \"beam_3.txt\" to see some new results\n", + "4. Do the same with \"beam_4.txt\" and your **Task E** script to see some new results\n", + "5. What happens if you try to run the files \"beam_1.txt\" or \"beam_3.txt\" in your **Task E** script?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7669c3c6-3d6e-44a9-8a43-be866f8eef3e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "e058bea1-839a-4e6c-bc74-c898de6ab188", + "metadata": {}, + "source": [ + "# Workbook 01 Reflections\n", + "\n", + "By only using `str` and `list` we are able to perform a basic parse of the data in each file. However, because the data in each file are in _slightly_ different locations, our scripts only work for files that are formatted exactly so.\n", + "\n", + "This is where we start. Next week we will add looping into our process which will reduce the amount of code we write _and_ will make our a code a little bit more \"robust\" (less prone to \"breaking\")." + ] + }, + { + "cell_type": "markdown", + "id": "7ab3606f-0157-4657-996c-cfcb8e8520c6", + "metadata": {}, + "source": [ + "# πŸ¦Έβ€ Submit Workbook 01\n", + "Whew! Congratulations on getting through Workbook 01. Was some of that work repetitive? Maybe you started asking yourself, \"Is there a better way to do this?\"\n", + "\n", + "Of course there is :)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pfse", + "language": "python", + "name": "pfse" + }, + "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.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/krogers326/beam_1.txt b/krogers326/beam_1.txt new file mode 100644 index 0000000..8f719be --- /dev/null +++ b/krogers326/beam_1.txt @@ -0,0 +1,3 @@ +4800, 200000, 437000000 +0, 3000 +10, 2000 \ No newline at end of file diff --git a/krogers326/beam_2_si.txt b/krogers326/beam_2_si.txt new file mode 100644 index 0000000..d4b011a --- /dev/null +++ b/krogers326/beam_2_si.txt @@ -0,0 +1,4 @@ +5790, 28000, 756e6 +1600, 2540, 5080 +15, 0, 4800 +35, 1800 \ No newline at end of file diff --git a/krogers326/beam_2_us.txt b/krogers326/beam_2_us.txt new file mode 100644 index 0000000..f4e9628 --- /dev/null +++ b/krogers326/beam_2_us.txt @@ -0,0 +1,4 @@ +228, 28000, 756 +63, 100, 200 +15, 0, 0 +35, 0, 0 \ No newline at end of file