From 641c368e97a0d190dbed84fd57139be5b97b7c2f Mon Sep 17 00:00:00 2001 From: Jonas Neergaard-Nielsen Date: Mon, 10 Aug 2026 05:15:50 +0200 Subject: [PATCH 1/4] Update schedule --- course_info/schedule.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/course_info/schedule.md b/course_info/schedule.md index a93ad6f..2cf8b36 100644 --- a/course_info/schedule.md +++ b/course_info/schedule.md @@ -8,11 +8,11 @@ The schedule is loosely defined and likely to change. | ----- | ------- | ------------------------------------------------------------ | ----------------------------------------------------- | | 1 | 3/8 | intro to course and to scientific computing;
environments, workflows | | | 2 | 4/8 | version control
NumPy | qubits, quantum circuit simulation | -| 3 | 5/8 | more NumPy | quantum circuit simulation
~~random circuit sampling~~ | -| 4 | 6/8 | visualisation | continuous-variable states | -| 5 | 7/8 | QuTiP;
profiling code | continuous-variable states
cavity QED | -| 6 | 10/8 | data analysis;
file I/O | realistic squeezed light | -| 7 | 11/8 | packaging
speeding up
other relevant packages and tools | teleportation simulation | +| 3 | 5/8 | more NumPy | quantum circuit simulation | +| 4 | 6/8 | visualisation | parametrized circuits | +| 5 | 7/8 | notebook presentation;
profiling code | continuous-variable states | +| 6 | 10/8 | QuTiP | continuous-variable states
cavity QED | +| 7 | 11/8 | data analysis;
file I/O;
(packaging?) | realistic squeezed light | | 8 | 12/8 | guided mini-project:
modeling, simulation, analysis, presentation | quantum state generation + tomography | | 9–13 | 13–19/8 | Project work | your choice! | | 14–15 | 20–21/8 | Project presentations + feedback | | From da45e0c7eabf1fe676c688ebe2b67ef5ddef10d4 Mon Sep 17 00:00:00 2001 From: Jonas Neergaard-Nielsen Date: Mon, 10 Aug 2026 05:16:08 +0200 Subject: [PATCH 2/4] Update tutorialize exercise with peer feedback instructions --- exercises/tutorialize_continuous_variables.md | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/exercises/tutorialize_continuous_variables.md b/exercises/tutorialize_continuous_variables.md index 49c8b83..a6a93ff 100644 --- a/exercises/tutorialize_continuous_variables.md +++ b/exercises/tutorialize_continuous_variables.md @@ -10,12 +10,14 @@ Some of you are almost experts on CV quantum optics, some of you may have only b 2. Start playing around with ways to visualise or otherwise present some basic and/or advanced concepts from continuous variables (see suggestions below if you don't know where to start). 3. Gradually combine your findings into a nicely formatted single notebook. Include Markdown cells with section headers, explanatory text and formulas. Try to make a coherent narrative throughout. Don't worry too much about getting everything perfectly right – think of this as a first draft you might improve upon later. 4. At the end of the day, submit your notebook as a pull request on the sciqis Github repository (instructions below). On Monday, you will give feedback to each other. +5. (Monday) Give feedback on two fellow students' notebook. -There are four objectives of this exercise: +There are five objectives of this exercise: * Practice writing a computational narrative in the form of a notebook with text, code, and static + interactive/animated plots. * Learn about continuous variables and Gaussian states. * Get more experience with visualising data or functions in an informative way, perhaps using interactive plots with ipywidgets or animated plots with Matplotlib's animation module. * Try out a Github pull request workflow. +* Practice 1) reading other people's code and 2) giving constructive feedback. ### References @@ -60,4 +62,13 @@ Instead of just sharing your notebook on Discord, you will practice a Github pul 4. Going to your forked repository on Github, switch to your new branch. You should now see a green button called "Compare & pull request" or similar. Choose `submissions` as the branch to merge into. Complete the form (quick title and description, nothing fancy - would be good to include your name or username in the description) and Create Pull Request. Detailed instructions are [here](https://docs.github.com/en/pull-requests/how-tos/create-pull-requests/creating-a-pull-request). 5. Confirm that the pull request is visible in the main course repository: https://github.com/qpit/sciqis/pulls -In case this doesn't work at all, the fallback solution is to send your notebook to me by direct message on Discord. \ No newline at end of file +In case this doesn't work at all, the fallback solution is to send your notebook to me by direct message on Discord. + +### Instructions for giving peer feedback + +1. Install Github CLI if you don't already have it (if you can run the `gh` command in your terminal, it's installed). Run `gh auth login` to authorize `gh` against the Github servers through browser login. +2. You will be assigned two fellow students' notebooks to review. They should belong to a specific [pull request](https://github.com/qpit/sciqis/pulls), each with a specific PR number. +3. In your terminal, go to the folder containing your fork of the qpit/sciqis repository. Now download and check out the branch containing the assigned pull request using `gh pr checkout `. You should now be able to see your fellow student's notebook and open it in Jupyter Lab, VS Code, etc. +4. Read the notebook. Run the code if needed. Study the plots. Spend 10-15 minutes max. +5. Now, go to the pull request on Github, https://github.com/qpit/sciqis/pull/PR-number (replace PR-number), and add your feedback as a comment at the bottom: What did you like about the notebook? Did you understand what was presented? Were the visuals interesting and informative? Did the code run without problems? Any other comments? +6. Now, repeat with the other assigned notebook. \ No newline at end of file From 301bd49880bf93b87d2b09ca9755b17d765d9519 Mon Sep 17 00:00:00 2001 From: Jonas Neergaard-Nielsen Date: Mon, 10 Aug 2026 08:12:34 +0200 Subject: [PATCH 3/4] Add activities Day 6 --- course_info/activities.md | 12 +++++++++++- exercises/profile-your-code.md | 12 ++++++++++++ exercises/try-out-qutip.md | 13 +++++++++++++ 3 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 exercises/profile-your-code.md create mode 100644 exercises/try-out-qutip.md diff --git a/course_info/activities.md b/course_info/activities.md index a11b8f7..69be3a4 100644 --- a/course_info/activities.md +++ b/course_info/activities.md @@ -58,4 +58,14 @@ 3. _Practice_: [Tutorialize continuous variable states](../exercises/tutorialize_continuous_variables.md) 4. _Demo_: Profiling and optimising code -11:45: Visit by Marjan and Ingrid from Skylab who will present their innovation and entrepreneurship opportunities \ No newline at end of file +11:45: Visit by Marjan and Ingrid from Skylab who will present their innovation and entrepreneurship opportunities + + +## Day 6 + +1. _Practice_: Finalise the [Tutorialize continuous variable states](../exercises/tutorialize_continuous_variables.md) exercise +2. _Peer review_: Give feedback on each other's notebooks +3. _Practice_: [Profile your code](../exercises/profile-your-code.md) +4. _Demo_: QuTiP +5. _Practice_: [Try out QuTiP](../exercises/try-out-qutip.md) +6. _Practice_: If you have time left, start or continue the [Random circuit sampling](../exercises/random-circuit-sampling.md) exercise \ No newline at end of file diff --git a/exercises/profile-your-code.md b/exercises/profile-your-code.md new file mode 100644 index 0000000..f20c9bf --- /dev/null +++ b/exercises/profile-your-code.md @@ -0,0 +1,12 @@ +# Profile your code + +_Practice_ + +Take another look at some of the code, you have built during this course. For example the quantum circuit simulator or some of the continuous-variable state calculations. + +Test the run time of your code using some of the tools from the [Profiling and optimising code](../demos/Profiling%20and%20optimising%20code.ipynb) notebook – especially `%timeit`, `%prun` and `%lprun` (and the equivalent for multiline cells, `%%timeit` and `%%prun`). The heatmap `%%heat` mentioned [here](https://www.python4data.science/en/latest/performance/ipython-profiler.html) also looks useful (I haven't tested it yet). + +If you have your code as normal `.py` Python files instead of notebooks, there are equivalent command-line commands to run your scripts through these profilers: +[timeit](https://docs.python.org/3/library/timeit.html), [profile/cProfile](https://docs.python.org/3/library/profile.html) and [line_profiler](https://kernprof.readthedocs.io/en/latest/). + +See if you can identify bottlenecks. Can you think of ways to speed up your code by rewriting it? You could also try to speed it up using Numba, JAX, numexpr, multiprocessing, or similar (see the [Profiling and optimising code](../demos/Profiling%20and%20optimising%20code.ipynb) notebook for very basic examples of usage). \ No newline at end of file diff --git a/exercises/try-out-qutip.md b/exercises/try-out-qutip.md new file mode 100644 index 0000000..a5d9a7d --- /dev/null +++ b/exercises/try-out-qutip.md @@ -0,0 +1,13 @@ +# Try out QuTiP + +**NOTE: NOT FINISHED YET** + + +1. Browse through the many tutorials on [QuTiP's website](https://qutip.org/qutip-tutorials/). If some of them are aligned with your quantum science interests, then feel free to dig into them and code along. + + Solving master equations with QuTiP + +2. Starting from [this QuTiP tutorial](https://nbviewer.org/urls/qutip.org/qutip-tutorials/tutorials-v5/time-evolution/006_photon_birth_death.ipynb) which replicates [one of the papers on cavity QED](http://dx.doi.org/10.1038/nature05589) that contributed to the 2012 Nobel prize of Serge Haroche, try to come up with new ways to visualise the results. This could be as a static plot, an animation, or an interactive plot. +3. Change the parameters of the simulation, like changing the initial state, the time steps, the number of trajectories, the coupling rate, environment temperate, etc. - you may discover something interesting by varying these. + +Note that you can store all trajectories with the `keep_runs_results` option to `mcsolve` described [here](https://qutip.readthedocs.io/en/stable/guide/dynamics/dynamics-monte.html) (under Monte Carlo Solver Result), and then access e.g. the expectation of the operators in `e_ops` at each time with the result's `runs_expect` property. \ No newline at end of file From e8f099efcec65d3183e86cc4030c7768e719b591 Mon Sep 17 00:00:00 2001 From: Oskar Brunn Fugmann Date: Mon, 10 Aug 2026 10:36:22 +0200 Subject: [PATCH 4/4] Added my notebook --- .../cv_submissions/cv_tutorial_oskar.ipynb | 333 ++++++++++++++++++ 1 file changed, 333 insertions(+) create mode 100644 exercises/cv_submissions/cv_tutorial_oskar.ipynb diff --git a/exercises/cv_submissions/cv_tutorial_oskar.ipynb b/exercises/cv_submissions/cv_tutorial_oskar.ipynb new file mode 100644 index 0000000..335b7fa --- /dev/null +++ b/exercises/cv_submissions/cv_tutorial_oskar.ipynb @@ -0,0 +1,333 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": "Start of tutorial", + "id": "1ccc09ab769061ef" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "We know that a quantum harmonic osc can be described by the hamiltonian $H=\\hbar \\omega (\\hat{n} +\\frac{1}{2})$. The eigenstates to such a system is what we call foch states or the number state. The foch state is a that has a well defined quanta of energy, like the amount of photons.\n", + "We start by creating the foch states. We start by creating a foch state with one quanta of energy" + ], + "id": "ab38a751bd42ebce" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-08-10T07:57:45.974008Z", + "start_time": "2026-08-10T07:57:45.948255Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import math\n", + "import matplotlib.pyplot as plt\n", + "class fochstate:\n", + " def __init__(self, state, normalize):\n", + " self.state = state\n", + " def __repr__(self):\n", + " return f\"|{self.state}⟩\"\n", + "def foch(n):\n", + " return fochstate(n,1)\n", + "state = foch(2)\n", + "print(state)\n" + ], + "id": "6ee9bae95ab25f9b", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "|2⟩\n" + ] + } + ], + "execution_count": 446 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-08-07T08:24:59.741151Z", + "start_time": "2026-08-07T08:24:59.697878Z" + } + }, + "cell_type": "markdown", + "source": "Now if we want to add or remove a quanta of energy from that state we use what is known as ladder operators. There are two ladder operators the creation operator and the annihilation operator. The creation operator adds a quanta of energy so $\\hat{a}^{\\dagger} \\vert n \\rangle = \\sqrt{n+1}\\ \\vert n+1 \\rangle$. The annihilation operator removes a quanta of energy $\\hat{a} \\vert n \\rangle = \\sqrt{n}\\ \\vert n-1 \\rangle$. Now we try to first lower by applying the annihilation operator to the foch state and then we apply the creation operator to get t then operator so $\\hat{a}^{\\dagger}\\hat{a}\\vert 2 \\rangle$", + "id": "b013cb2d7d776bb7" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-08-10T07:58:11.878574Z", + "start_time": "2026-08-10T07:58:11.849716Z" + } + }, + "cell_type": "code", + "source": [ + "class fochstate:\n", + " def __init__(self, state, normalize):\n", + " self.state = state\n", + " self.normalize = normalize\n", + " def create(self):\n", + " self.state += 1\n", + " self.normalize *= np.sqrt(self.state)\n", + " def annihilate(self):\n", + " self.state += -1\n", + " self.normalize *= np.sqrt(self.state + 1)\n", + " def __repr__(self):\n", + " if self.normalize == 1:\n", + " return f\"|{self.state}⟩\"\n", + " elif self.state < 0:\n", + " return \"0\"\n", + " else:\n", + " return f\"{round(self.normalize,2)} |{self.state}⟩\"\n", + "def foch(n):\n", + " return fochstate(n,1)\n", + "state = foch(2)\n", + "state.annihilate()\n", + "state.create()\n", + "print(state)\n", + "\n", + "\n", + "\n" + ], + "id": "52a299f2d7994c99", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0 |2⟩\n" + ] + } + ], + "execution_count": 451 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Now sometimes we need not just one foch state to describe the system but a linear combination of multiple fochstates. This means that $\\vert \\psi \\rangle = c_0 \\vert 0 \\rangle + c_1\\vert 1 \\rangle + \\ldots = \\sum_{n} c_n \\vert n \\rangle$", + "id": "184983b5861822e4" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-08-10T07:58:12.697220Z", + "start_time": "2026-08-10T07:58:12.671169Z" + } + }, + "cell_type": "code", + "source": [ + "class state:\n", + " def __init__(self, cn = list , n = list):\n", + " self.cn = cn\n", + " self.n = n\n", + " def normalize(self):\n", + " self.cn = self.cn / np.sqrt(np.sum(np.abs(self.cn)**2))\n", + "\n", + " def create(self):\n", + " for i in range(len(self.n)):\n", + " self.cn[i] *= foch(self.n[i]).create().normalize()\n", + " self.n[i] = foch(self.n[i]).create().state()\n", + " print(self.n[i]())\n", + " def __repr__(self):\n", + " if np.isclose(np.sum(abs(self.cn)**2),1):\n", + " exp = \"\"\n", + " for i in range(len(self.cn)):\n", + " exp += f\"{self.cn[i]} |{self.n[i]}⟩\"\n", + " if i != len(self.cn)-1:\n", + " exp += \" + \"\n", + " return exp\n", + " else:\n", + " print(\"The state has been normalized\")\n", + " self.normalize()\n", + " exp = \"\"\n", + " for i in range(len(self.cn)):\n", + " exp += f\"{self.cn[i]} |{self.n[i]}⟩\"\n", + " if i != len(self.cn)-1:\n", + " exp += \" + \"\n", + " return exp\n", + "\n", + "def mystate(cn,n):\n", + " return state(cn,n)\n", + "gen = mystate(np.array([1/np.sqrt(2),1/2,1/2]),np.array([1,2,4]))\n", + "print(gen)\n" + ], + "id": "acf42e8a022986b9", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7071067811865475 |1⟩ + 0.5 |2⟩ + 0.5 |4⟩\n" + ] + } + ], + "execution_count": 452 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "We could also work with states called cohernet states. Theses are eigenstates of the ladder operators. A coherent state $\\vert \\alpha \\rangle$ where $\\alpha \\in \\mathbb{C}$ is the quantum states that behave most like classical oscillations. We start by generating a coherent state $\\vert 1 + 1i \\rangle$. (in python 1i is written as ij)", + "id": "e35d4493fea911be" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-08-10T08:03:41.780650Z", + "start_time": "2026-08-10T08:03:41.758372Z" + } + }, + "cell_type": "code", + "source": [ + "class coherent:\n", + " def __init__(self, alpha):\n", + " self.alpha = alpha\n", + " def foch(self):\n", + " cn = np.array([])\n", + " n = np.array([])\n", + " i = 0\n", + " while True:\n", + " if np.isclose(self.alpha**i / np.sqrt(factorial(i)),0):\n", + " break\n", + " else:\n", + " cn = np.append(cn,np.exp(-np.abs(self.alpha)**2/2)*self.alpha**i / np.sqrt(factorial(i)))\n", + " n = np.append(n,i)\n", + " i += 1\n", + " return mystate(cn,n)\n", + " def prob(self):\n", + " values = self.foch()\n", + " photons = values.n\n", + " #photons = np.append(photons, photons[-1] + 1)\n", + " values = values.cn\n", + " prob = np.array([])\n", + " for i in range(len(values)):\n", + " prob = np.append(prob,np.abs(values[i])**2)\n", + " print(prob)\n", + " if len(prob) <= 19:\n", + " for i in range(len(prob), 14):\n", + " prob = np.append(prob,0)\n", + " photons = np.append(photons,i)\n", + " plt.bar(photons, prob, align='center')\n", + " plt.xticks(photons) # ticks at bin centers\n", + " tickdist = len(photons) //15 +1\n", + " plt.xticks(photons[::tickdist], range(len(photons))[::tickdist])\n", + " plt.xlabel(\"Photon number\")\n", + " plt.ylabel(\"Probability\")\n", + " plt.title(\"Photon number distribution\")\n", + " plt.show()\n", + "\n", + "\n", + " def __repr__(self):\n", + " return f\"|{self.alpha}⟩\"\n", + "def coherentstate(alpha):\n", + " return coherent(alpha)\n", + "coh = coherentstate(1 + 1j)\n", + "print(coh)" + ], + "id": "a83237429d5f82", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "|(1+1j)⟩\n" + ] + } + ], + "execution_count": 461 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Now we want to know how the coherent state looks as a foch state. A coherent state can be expressed as $\\vert \\alpha \\rangle = e^{-\\frac{\\vert{\\alpha}^{2}\\vert}{2}}\\sum_n\\frac{\\alpha^n}{n!}\\vert n \\rangle$. If we do that we get", + "id": "8d8114e03b751674" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-08-10T08:00:47.980840Z", + "start_time": "2026-08-10T08:00:47.963842Z" + } + }, + "cell_type": "code", + "source": [ + "mystate1 = coh.foch()\n", + "print(mystate1)" + ], + "id": "bc9bc911bd5f54e", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.3678794411714422+0j) |0.0⟩ + (0.3678794411714422+0.3678794411714422j) |1.0⟩ + 0.5202600950228887j |2.0⟩ + (-0.3003723059100851+0.3003723059100851j) |3.0⟩ + (-0.3003723059100851+0j) |4.0⟩ + (-0.1343305789146624-0.1343305789146624j) |5.0⟩ + -0.10968045839786396j |6.0⟩ + (0.04145531665775912-0.04145531665775912j) |7.0⟩ + (0.029313335524937117+0j) |8.0⟩ + (0.009771111841645707+0.009771111841645707j) |9.0⟩ + 0.006179793738368585j |10.0⟩ + (-0.0018632779192687566+0.0018632779192687566j) |11.0⟩ + (-0.0010757640082649023+0j) |12.0⟩ + (-0.00029836325323829015-0.00029836325323829015j) |13.0⟩ + -0.00015948186720299323j |14.0⟩ + (4.117804104661704e-05-4.117804104661704e-05j) |15.0⟩ + (2.058902052330852e-05+0j) |16.0⟩ + (4.99357096150652e-06+4.99357096150652e-06j) |17.0⟩ + 2.3539919261449917e-06j |18.0⟩ + (-5.400427852619305e-07+5.400427852619305e-07j) |19.0⟩ + (-2.4151447572079966e-07+0j) |20.0⟩ + (-5.2702779353244706e-08-5.2702779353244706e-08j) |21.0⟩ + -2.247254062408689e-08j |22.0⟩ + (4.685848640605287e-09-4.685848640605287e-09j) |23.0⟩\n" + ] + } + ], + "execution_count": 459 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Now we want to know how many photons there are in the coherent state. we can calculate the probability of having n photons as $P(n) = \\vert \\langle n \\vert \\alpha \\rangle \\vert^{2}$. This we can then make a histogram of", + "id": "c5236d7970dd6c76" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-08-10T08:03:47.127094Z", + "start_time": "2026-08-10T08:03:47.064801Z" + } + }, + "cell_type": "code", + "source": "coh.prob()", + "id": "2b7d3f4248ec7b5", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.35335283e-01 2.70670566e-01 2.70670566e-01 1.80447044e-01\n", + " 9.02235222e-02 3.60894089e-02 1.20298030e-02 3.43708656e-03\n", + " 8.59271640e-04 1.90949253e-04 3.81898506e-05 6.94360921e-06\n", + " 1.15726820e-06 1.78041262e-07 2.54344660e-08 3.39126213e-09\n", + " 4.23907766e-10 4.98715019e-11 5.54127799e-12 5.83292420e-13\n", + " 5.83292420e-14 5.55516590e-15 5.05015082e-16 4.39143550e-17]\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHGCAYAAACcmzRuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN3dJREFUeJzt3QeUE9X////3Lr1JVYEPZalSFlD6SlkQaSKiohSFjwKCoCIiIiziBxE/sgoiKh8ELIhgBQFRRKVJFalShC9F6b0uUlzKzv+87/+XnGRrtmQT9j4f5+TsZjIzuZlMMq/ce2duiOM4jgAAAFgkNNAFAAAAyGwEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAQAbatWuXjB8/Xk6ePMl2zSTBvM1Pnz5tyvZ///d/7mn79+83044cOZIpZUjs+QKxzTL7dQMpIQABPjh27Jj58nbd3n33XZk+fbrs3LnTa76NGzfKwIED5fDhwxm2Xf/880/znFoGJOSPbZ5Rjh49asq2fv1697QdO3aYaX/99Vem7AeJPZ+/tllyZUzr6wb8hQAE+GDfvn3my3v27Nnm/927d8vHH38sVapUkS5dusiVK1f8th23bt1qnlufFze+sLAwGTBggPzrX//KlP0grc+XFsmVMTPLAfgiu09zATDuu+8+eeGFF9xbY/To0TJs2DCpV6+eDBo0iK2EFGlo1lqSrPp8wV4OwIUABKTDk08+aQLQzz//nCAAXb58WebPn2/6gTRo0EBuv/32RNdx6NAhWbZsmZw/f978Sr7rrrskV65c5rFNmzbJd999Z/7/6quvZM2aNeb/Vq1aSbVq1Xxah6vPxw8//CCPPvqo5M+f36dyeUrN8tq8snz5cunbt6/kzp3bPV37m3z22Wdyzz33SOXKlROsN0+ePGa9ly5dktatW0vJkiXNPBcvXjTznD171ryuihUrJlnOCxcumHXExMRIRESE1KhRI9H59PGlS5ea/ig333yz3H333VK4cOEkX++CBQvMNn7iiSckb968ST7/tm3bZPXq1XLTTTdJu3btkuwLM2fOHOnUqZP7Nbpe55IlS0yZSpQoIQ0bNpRbbrnFp/0gufLqdk/s+XzdZr6+nymVManXnRn7L5AYmsCAdMiRI4f5e+3aNa/p+mXfokUL+fbbb02z2R133GFqi+IbOXKklCtXTj744AP57bffpF+/flKpUiXZsGGDeVwPCCdOnHD3J9GmBb3pQcvXdXj2+dCDsy/lii81y+tBXOf1LKPS/iY6XdcVf7168NMQogfuyZMnmwOqHkC183CzZs3k+++/l08++cQcSPXglxg9SEZGRprHtWx6YHz++ecTzPfpp59K6dKl5dVXXzXP//bbb5uDruvgHb9cTZs2NeubMmWKeT+SogG4Zs2a8s0335iDtZbFs/Nzcn1hVqxYIaVKlXKXadq0aSaMfPjhhz7tB8mVN7m+N75sM1/fz5TKmFQ5MmP/BRLlAEjRr7/+6ujHZcyYMV7Tp06daqa//PLL5v4XX3xh7kdGRjonTpxwz/f00087uXPndo4ePeqe9vXXX5t533jjDfe0mJgYp27duk6JEiWcCxcumGlz5swx82kZ4vN1HakpV2JSs7xuI5335MmTXuvYtGmTma7rSmy9p0+fNtOuX7/uNG7c2KlTp47TsWNH93ri4uLMfFWrVjX/x19HRESEc+zYMff0yZMnm+mff/65e9rSpUud0NBQJyoqymsdgwYNcvLly+ccPHgwwTpdr+38+fPu7ZnU9tHndNGy3HnnnWb69OnT3dMXLFhgpq1YscI9TZ+nRYsWXuu8dOmS88svv7jvJ7cfJFfexJ4vNdssNe9ncmVMrByZtf8CiaEGCEgF/aWu/Rjeeust6dmzp/Tu3dtUw8dv/tKO0dq04vLvf/9b/vnnH/ML1+X99983TR2ev7i16eSVV14xv6C1uSAlqV2HL+VKTnqXT0rXrl2lSJEi5v/Q0FB56KGHTA1A8+bNpVixYmZ6SEiIma41CcePH0+wjs6dO8utt97qvq/vjTaXTZo0yT1t7Nix5nm0pkXX56LbS5sstUnH08MPPyzFixc3/xcoUEDy5cuXaPm1tqV8+fLmOV20LPq6fKHNe1evXvWqSdQmQa2dSQ1fy5uabeZPmb3/Ap7oAwSkgh6otFpfD9Jly5aVefPmmT4O2bJl85ovPDzc676rz4Pnacd//PGHaXLInt37Y6jV+q7+JClJ7Tp8KVdy0rt8UqpXr+5133VQjj/ddXDX53P971KrVi2v+xpwtEnql19+cU/TUKV9fVwHeMdx3DftWxK/yUqX94Vu5zvvvNMrVCVWpqRo8442/VSoUEHuvfdeE3y0SdAVCn3la3lTs838KbP3X8ATAQhIx1lgSdGDqdcH7f99wXueLn/9+vUEX/ye8+rjKUntOnwpV3J8Wd4VBuPi4rzm1RqW1K43qelaWxJf/BDqmt+zHLqcbpM9e/YkmLdHjx5Su3Ztr2lFixYVX+hzJPX8vujTp480atRIZs2aJStXrpSpU6e6a6yeeuopn9aRmvKmZpul5f30VWbvv4AnAhAQINrRU5tz4tu+fbv7caW1TeldR2Zy/SrXDrGus5hUYh2CM5Kuv0mTJl7TdNt4bgPtRK3NZxl9OrY+R/yLYrqe31da2+Wq8dKOwx07dpRnn31WHnvsMdOUldx+4M9tlpr3M7VlDMb9F/agDxAQIHpg27t3r3zxxRfuadoHRM9q0f4begBUroOOnvab1nVkprp165oDoTYPuuip7Xpmkz/plbk9ayX0TCy9MJ/2E3Hp37+/OfPJdXaVJ7168cGDB9P03N27dzfNOZ5nqGlZfH3Na9euTVDToU1D2jQXGxub4n7gz22WmvcztWUMxv0X9qAGCAgQbfbQ03r14KnXEdJTsfU0cO338OWXX7qbM/RAqI/p9Yb04KTXYnFdW8XXdWQm7cei5RoxYoS5vouWQfuUaAdbPU3bX7p162auH9OyZUtzjRptRurQoYPpW+PZSTg6OtpM0+YmvdaONrNojYNex0an6SnyabkelG5/PWA//vjjpg+T3teO8noNnZS8+OKLJohoPyLt26QhbcaMGRIVFeXuB5TcfuDPbZaa9zO1ZQzG/Rf2oAYI8IGeqaKX8a9Tp06y8912221mPs8zVZQ2Yeh0V+dO8+ELDTXXpNEzy/QgoxfC01/eOp6SdoR10YOIHiT0YHrq1Cmva6v4uo7UlCu9r0tNnDhRvv76a3NGj970wnh6/RadV9eV0nq16UOne56hpPQ16nR9P+KvQy88+Pnnn5sLFRYqVMg8v55FFL+fy5AhQ8y1aPRAr6FD59dtpk06rj5ASZUrKfoc+lwzZ840naz1PdMzytq3b2/WU7Vq1WSHhNBAodtMHzt37pzpiKwB4rXXXvNpP0iuvIk9X2q3ma/vZ3JlTKwcmbX/AokJ0XPhE30EAAAgi6IGCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOlwIMQk67s2RI0fM1UjjD3AIAACCk17d5++//zbDuCQ3PAsBKAkaftJyRVgAABB4OrRNqVKlknycAJQErflxbUC98ikAAAh+58+fNxUYruN4UghASXA1e7ku/Q4AAG4cKXVfoRM0AACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHWyB7oASJ+wofPTvOy+6HZ+WxcAAMGMGiAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWyR7oAsTFxclvv/0mx48fl/DwcKlYsWKKy5w5c0Y2bNgg2bNnl9tvv10KFy7s9fj69etlz549XtMKFSokbdq0yfDyAwCAG09AA1BMTIwJJQcOHJBq1arJ6tWrpX///hIdHZ3o/I7jyFNPPSXz5s2T6tWry6VLl2TLli0yfvx46dmzp3u+Dz/8UObPny+NGjVyTytdujQBCAAABD4AvfTSS6Y2Z/v27VKwYEFZuXKlNGnSRFq2bCktWrRINADVqlVL3nnnHcmZM6eZ9v7778uTTz4pd999t5QpU8Y9b4MGDeTLL7/M1NcDAABuDAHrA6Rh5rPPPpNevXqZ8KMaN24s9evXlxkzZiS6TGhoqPTt29cdflTHjh3l2rVrsm3bNq95z549a2qKli1bJufOnfPzqwEAADeSgNUAHTp0yAQT7ffjqUaNGvL777/7vJ5FixZJSEiIaULztHnzZpk0aZIcPnxY9u3bZ2qNHn/88STXExsba24u58+fT9XrAQAAN47QQPb/UUWKFPGaXrRoUZ9rbDTYPPfcc9KvXz8JCwtzT+/SpYscPHhQfvjhBxOERo4cKb1795atW7cmua7Ro0ebmijXTfsMAQCArClgAShXrlzm74ULF7ym6/3cuXOnuPyRI0dMXyHt66OdoD01a9ZM8uTJ476vIUlDzYIFC5JcX1RUlAllrpsGKAAAkDUFrAlMOyzraex6Bpin/fv3S/ny5VMMP82bN5fKlSvLrFmzJEeOHCk+X4ECBeTkyZPJBjJXKAMAAFlbQGuA9EyvmTNnuqedOnVKlixZIu3atXNPW7dunfz444/u+0ePHjXhR68XNHv27AShRa8rdOLECa9pes0gDVb16tXz62sCAAA3hoCeBq/X+9Ezv7p37y4RERHm+j1Vq1b16qw8efJkWbNmjbmGj3ZS1tCkfYQ6deokc+bMcc+nZ49pzdH169clMjJS2rZta64VpDVM7733nglVesYYAABAQAOQXsV548aNJvjo1aAfeeQR06HZs1ZHg43rSs9XrlyRmjVrmv/j9+e59dZbTQDS5jC9EvS0adNMcNJl9f/27dtn8qsDAADBKsTRC/IgAT0NXjtOa4fom266KWi3UNjQ+Wledl90O7+tCwCAYD5+MxgqAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrZA90ARzHkfXr18vx48clPDxcwsLCUlzm3LlzsmnTJsmePbvUrFlTChYsmCHrBQAAdghoDdD58+elSZMmct9998lbb70l1atXl+HDhyc5v4aa/v37S7Vq1WTUqFEyePBgKVOmjEybNi1d6wUAAHYJaA2QhhKtodmxY4cUKlRIli1bJs2aNZO77rrL3BILQLfddpvs3btXcuXKZaZNmDBBevfubeYvXbp0mtYLAADsErAaIA0zM2bMkF69epmQoiIjI6VevXpmemJCQ0PlmWeecYcf1alTJ7l69aps3bo1zesFAAB2CVgN0KFDh+Ts2bOmD48nvf/777/7vJ4lS5ZISEiIVK1aNV3rjY2NNTfPZjQAAJA1BawGKCYmxvwtXLiw1/SiRYuaTs6+2L9/vwwYMED69Okj5cqVS9d6R48ebTpTu26u5jQAAJD1BCwAuZqxLl265DX9woULkjt37hSXP3r0qLRq1Urq1Kkj7777brrXGxUVZcKT63bw4MFUvyYAAHBjCFgTmNaw6GnsBw4c8Jqu98uXL5/ssseOHTOdmbXWZ/bs2ZIzZ850r1eDk2ffIgAAkHUFrAZIa2OaN28us2bNck87ffq0LF68WNq2beuetmHDBlm4cKH7vp7dpeGnbNmyMnfu3AS1Or6uFwAA2Cugp8FHR0eb6/X06NFDIiIi5IMPPpDKlStLz5493fO8//77smbNGtm2bZvppNyiRQsTaIYNGybff/+9e766deu6L3boy3oBAIC9AhqAateubWp4pkyZYq7V07FjR3n66ae9mqI02Nx0003m/ytXrkiVKlXMTWt/PGmnZ1cA8mW9AADAXiGOXjgHCehp8Ho2mHaIdgWwYBQ2dH6al90X3c5v6wIAIJiP3wyGCgAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOtkD3QBkDWFDZ2f5mX3RbfL0LIAABAfNUAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsE6aAtDGjRszviQAAADBHIDq1Kkjt99+u7z77rty5syZjC8VAABAsAWgXbt2Sdu2beWNN96QkiVLSufOneWnn36SuLi4jC8hAABAMASgSpUqyejRo+XAgQPyzTffyLVr16R9+/YSFhYmL7/8svz1118ZXU4AAIDg6ASdLVs2adeunUyfPl2io6Pl+PHj8tprr0nFihXlgQcekIMHD2ZcSQEAAIIhAK1Zs0b69OkjJUqUkHHjxsngwYNN7Y9Ov3r1qtx///0ZVU4AAIAMkz0tC40dO1Y+/vhj2b17t9xzzz0yY8YM81drhFS5cuVk5syZkj9//owrKQAAQCAD0KRJk6Rnz57So0cPU/uTmDx58shHH32U3vIBAAAERxNYrVq1ZNiwYYmGn4ceesj9/+OPP56+0gEAAARLAJo9e3ai0/U0+Dlz5qS3TAAAAMHTBHbq1KlE/3eFn1WrVknx4sUzrnQAAACBDkA333xzov+7aCfoMWPGZEzJAAAAgiEAbdq0yfy944473P+75MiRQ0qVKiUFCxbM2BICAAAEMgDp+F9KL3CoYQcAACBLB6Bjx46Zv9rHJ3v27O77iaEfEAAAyBIByHXKu+M4SV77x0XnAQAAuOED0NatWxP9HwAAIMsGoPDw8ET/BwAAyPJ9gHxBHyAAAJCl+gD5gj5AAAAgy/UBAgAAsK4PEAAAgHXXAUqpP1Bq+wBp7dLx48elWrVqUrJkSZ+W2bVrl7lFRERI0aJFE6xv//79XtNuuukmadq0aarKBQAAsqaAXgfowoUL0qFDB9m8ebNUqlRJfv/9d3nppZdk+PDhSS6zYsUKGTlypOzcuVMOHTokS5culWbNmnnN87///U++/fZbqVOnjnta2bJlCUAAACDw1wF6+eWXZe/evSbMaC3OwoULpVWrViaoJFVbc+TIERkyZIhUqVJFypQpk+S6GzVqJLNmzcqQcgIAgKwlYNcB0lqi6dOny/PPP+9uwmrZsqXUrl1bPv300yQDUOfOnc1frf1Jzt9//y1Lliwxg7Nq01qePHnSXWYAAGDhYKjxA8aMGTNkx44d5r6GjG7dukn+/Pl9Wv7w4cNy+vRpqVWrVoIBV7VJLL1Wr14tr7zyiqkxOnfunEycOFE6deqU5PyxsbHm5nL+/Pl0lwEAAASn0LQstHbtWilfvrwJGBqA9DZixAgzbf369T6tQ0OJKlKkiNd0rQ1yPZZWDzzwgAlYy5cvlz179sjAgQOle/fu7rCWmNGjR5vaItetdOnS6SoDAADIYgGob9++8tBDD8mBAwdMvx296f8dO3Y0j/kiZ86c5u+lS5e8put912Np1bp1a3PWl8uwYcMkX758Mn/+/CSXiYqKkpiYGPft4MGD6SoDAADIYk1gWpOioSdXrlzuafr/qFGjku2Y7Enny5YtW4K+PBo8ypUrJxkpJCREChUqlOzp+1p+z9cDAACyrjTVAFWsWNE0McWn/W0qVKjg0zpy584tkZGRMnv2bPc0bfpavHixtGnTxj1ty5YtpinLV3FxcQma0FzXBdIO1gAAAD7XAOk1e1wGDBhgOhS/+eabUq9ePXNGl/b9efHFF83NV9rvRs/26tevn7mg4aRJkyQsLEx69erlnufdd9+VNWvWyLZt28x9rTHS6wVpB2r166+/mrJVrlzZ3K5fvy4NGzY05atevbppmhs3bpwJWw8//DDvOAAA8D0AFShQIME0vYhhfBpeevbs6dM669evbzpUa/DRCxfqNYCee+45r1PW9Swxz6YpvWaQzq/atWsnq1atMrdHHnnEBKAcOXKYwDRlyhSZO3euFC5c2ASgLl26mKYwAAAAnwOQ1rT4Q82aNc0p6knp37+/1/0WLVqYW3K0v09qaqIAAIBdfA5A2qwEAABgbSdoAAAA606D107PehXomTNnmk7G165d83rc1WEZAAAgy9QAjR071vSx0dPKddgKHQJDOyBv3749wcjsAAAAWSIA6RlWWvujQ2GooUOHmuv5jB8/3ozuDgAAkOUCkIacBg0auC9oqAOjqsceeyxVFy0EAAC4YQKQXmxQr7fjGtJi3bp15n/tD+SaDgAAkKU6QXvSix527tzZXJtHa38efPDBjCkZAABAMAWgkydPuv8fMmSIFC9e3FwoUTtGP/XUUxlZPgAAgOAIQMWKFfO6r31/9AYAAJClm8C047NeC2jHjh3mfrVq1czp8Pnz58/I8gEAAARHJ2gdwLR8+fLmNHgNQHobMWKEmaajwgMAAGS5GqC+ffvKQw89ZK774xqpPTY21ozkro8RgpIXNnS+pNW+6HZpXhYAAKQjAGmNz8KFC93hR+n/o0aNMqfFAwAAZLkmsIoVK8rhw4cTTD9y5IhUqFAhI8oFAAAQ+AB04cIF923AgAHSqVMnmTdvnhw9etQEH/1fpw0cONB/pQUAAMjMJrACBQokmNahQ4cE03r16mUujggAAHDDByC90CEAAIBVAahhw4b+LQkAAMCNMBbYiRMnZOfOneI4jlSpUkVuueWWjCsZAABAMJ0FdunSJdPXp0SJEtK0aVOJjIw0/+s0fQwAACDLBaBBgwbJypUr5dtvvzUDo546dcr8v2LFCnnhhRcyvpQAAACBbgKbOXOmLF68WGrVquWedu+990qpUqWkZcuWMnHixIwsIwAAQOBrgPRaQKVLl04wXafpIKkAAABZLgDVqVNHXn/9dYmLi3NP0///+9//St26dTOyfAAAAMHRBDZu3Dhp1aqVzJ492x14dADUM2fOyE8//ZTRZQQAAAh8DVCDBg1kz5495orP2bJlk+zZs5v/d+/ebR4DAADIcjVAzzzzjEyYMEGGDx+e8SUCAAAIxhqgjz76SGJjYzO+NAAAAMEagCIiIsxp8AAAANY0gTVu3Fi6du0qvXv3lmrVqknOnDm9Hu/WrVtGlQ8AACA4AtCUKVMkT548MmPGjEQfJwABAIAsF4COHj1q/oaEhGR0eQAAAIKrD9C5c+dM01eBAgXMTf+PiYnxX+kAAAACHYBeeuklWb58uQwZMsTcli1bZqYBAABk2Saw7777zlz92XWxw7vvvlu6dOlirgkEAACQJWuAjhw54jXWV/369eXw4cP+KBcAAEBwBKDr16+boS9c9H+dBgAAkKXPAgsPD09x2rZt29JXKgAAgGAJQIMGDUowrU2bNhlZHgAAgOAKQGPHjvVfSQAAAIJ5LDAAAIAbGQEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYJigC0Y8cO+eWXX+T48eM+L/PXX3/Jjz/+KGfOnMnQ9QIAgKwvoAHo4sWL0rp1a7nzzjtl8ODBEhYWJtHR0ckus3r1amnTpo00adJE2rZtK1u2bMmQ9QIAAHtkD+ST/+c//5Fdu3bJ7t27pVixYvLTTz+ZcNO4cWNzS8z+/ftlwIABUr16dSlbtmyGrRcAANgjoDVAn376qfTq1cuEFKW1NnfccYdMmzYtyWW6du1qan5CQ0MzdL0AAMAeAasBOnTokJw6dcoEE096f/PmzZm+3tjYWHNzOX/+fJrLAAAAglvAaoDOnTtn/hYpUsRretGiReXs2bOZvt7Ro0dLwYIF3bfSpUunuQwAACC4BSwA5cyZ0/y9fPmy1/RLly65H8vM9UZFRUlMTIz7dvDgwTSXAQAABLeANYFpDUu2bNkSBA1twtKztjJ7vbly5TI3AACQ9QWsBihPnjzStGlTmTt3rnua1rwsWrTInLHl8scff8iqVasyfL0AAMBeAT0N/vXXX5dmzZpJ//79JSIiQt5//31Tg6NncLm8/fbbsmbNGtm2bZu5f/jwYdm6davp6KzWrl0r//zzj1SsWNHcfF0vAACwV0BPg2/YsKH8+uuv5uyrr776SiIjI01tT968ed3zhIeHe127Z/v27TJ+/HiZMWOGOb19yZIl5r6GpNSsFwAA2CugNUCu09OnTJmS5OPPPfec1/2WLVuaW3rXCwAA7BUUY4EBAABkJgIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrBPw0eCAlYUPnp3kj7YtuxwYGACRADRAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1sksQ2Lt3rxw/flxuu+02KVy4cLqX2bVrlxw5csRrWr58+aRevXoZWm4AAHBjCmgAunz5snTp0kUWL14s5cqVkz179sjrr78uAwcOTNcy48aNk2+++UaqV6/unqbzTp061e+vCQAABL+ABqBXXnlFNm3aJH/++afceuut8t1338l9990nERER0rBhw3QtExkZKbNmzcrEVwMAAG4UAe0D9Mknn8gTTzxhgoxq37691KxZM9maGl+X0ZqitWvXys6dO+XatWt+fiUAAOBGErAaoMOHD8uJEyekTp06XtP1vtbwpHeZRYsWydGjR+XYsWMSEhIikyZNMmEpKbGxsebmcv78+TS+MgAAEOwCVgN09uxZ87dIkSJe04sVK+Z+LK3L3HPPPaYT9MaNG+XQoUPy2GOPSefOnWX37t1Jlmf06NFSsGBB96106dLpen0AACB4BSwA5cyZ091U5enSpUvux9K6jPYJKlq0qPk/NDRURo0aJbly5TL9hZISFRUlMTEx7tvBgwfT8eoAAEAwC1gTWKlSpUw40WYtT3q/bNmyGbaMypYtm6k1in9qvCcNSHoDAABZX8BqgPLmzSuNGjWSefPmuadduHDB9N1p2bKle5p2Yl63bp3PyziOIxcvXvR6Ll3Hvn37pEaNGpnwygAAQLAL6Gnw//3vf6VFixYyePBgcxr7hAkTpHjx4tK7d2/3PGPGjJE1a9bItm3bfFrm6tWr5oKHjz/+uLkO0IEDByQ6Olrq168vXbt2DdhrBQAAwSOgp8E3adJEli9fbq7oPHnyZKldu7asWrVK8ufP755Hr/TseQXnlJbRvkBLly41NUN65tevv/4qw4cPlxUrViTZtwgAANgl4ENh6MULk7roodKantQuo9cIevXVVzOsjAAAIGthMFQAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArBPwwVCBzBQ2dH6al90X3S5DywIACBxqgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArEMAAgAA1iEAAQAA6xCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAALAOAQgAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWIcABAAArJM90AUAblRhQ+enedl90e0ytCwAgNShBggAAFiHAAQAAKxDAAIAANYhAAEAAOsQgAAAgHUIQAAAwDoEIAAAYB0CEAAAsA4BCAAAWCcoAtDBgwdl/fr1cv78+QxdJi3rBQAAWV9Ah8L4559/5NFHH5UFCxZI2bJlZf/+/fLGG29I//7907VMWtYLBBLDagCARQFo5MiRsnbtWvnzzz+lRIkSMnfuXHnggQekfv360qBBgzQvk5b1AgAAewS0CWzq1KnyxBNPmJCi7r//fgkPDzfT07NMWtYLAADsEbAaoCNHjsjx48elTp06XtO1lmbTpk1pXiYt61WxsbHm5hITE2P++qP/UFzspTQvG788rIvtFX+fCB/xU5r3r20jW6d5WQAIBq7vRMdxgjMAnTlzxvwtWrSo13S973osLcukZb1q9OjRpuksvtKlS0swKTiedbG9box9AgAC6e+//5aCBQsGXwDKkSOHu8Oyp8uXL0vOnDnTvExa1quioqLk+eefd9+Pi4szgUmDU0hIiGRmctXQpWew3XTTTRIsKBfbin0rOPBZZHvZuH+lhtb8aPgpWbJksvMFLADpBg4NDZXDhw97Tdf7ZcqUSfMyaVmvypUrl7l5KlSokASK7njBuPNRLrYV+1Zw4LPI9rJx//JVcjU/Ae8EnTdvXrnzzjtl3rx57mkXL16URYsWScuWLd3T9uzZ4+6748syvq4XAADYK6Cnwb/22msmlGjzU0REhLz33ntyyy23SJ8+fdzzREdHy5o1a2Tbtm0+L+PLPAAAwF4BPQ0+MjJSli5dai5U+M4770j16tVl5cqVkj9/fvc8lSpVktq1a6dqGV/mCVbaDDdixIgEzXGBRrnYVuxbwYHPItvLxv3LH0KclM4TAwAAyGKCYiwwAACAzEQAAgAA1iEAAQAA6xCAgoheuGn9+vWm83YwOXDggGzdulUuXUr7EB7+osOXaAf3HTt2SLC4fv26OWtRB+MNpjLt3r1bNm7cmOwV0f1NL1C6evVq2bt3b5Lz6DA0+jnQC7Fl5mdv1apVCa4f5mnfvn3mfdWLqmaWU6dOmf1b/yZHy6Tz7dy5M1PKpUMO6fMlN1SQ7nP6vZHce53R9Lm0XJ7DGnm6du2a7Nq1y1xa5ezZs5lSJn1vNm/enOL+rN9hWq6rV69mSrkuXLhgnu/o0aPpmueGpp2gEXiTJk1y8ubN61SpUsX8vffee52LFy8GtEwzZ8405SlTpowTHh7u5M+f34mOjnaCSb9+/ZzQ0FCnQ4cOTjCYO3euU6JECadcuXJOjRo1nLvuuss5ceJEQMu0fPlyJywszClVqpRzxx13OHny5HF69uzpXLt2LdPKcOrUKeeFF15wSpYsaZ5/wIABic737rvvmserVq1q/j744IPOP//847dyHThwwOnbt69TvHhxJ0eOHM6YMWMSzPP55587lSpVcsqWLetUr17dKVCggDNu3DjHn7Zv3+50797d7Ev6Nf3FF18kO3+PHj3M56Bz585+Lddvv/3mPPDAA87NN99syrVixYpE5/v666+dW2+91alQoYLZZq1atXJOnz7tt3ItWrTIPEeRIkVMufbu3ZvoPKVLlza322+/3cmdO7d5769fv+6XMunr7dOnj1OoUCGnVq1aTrFixZw6deo4O3bs8Jpv3759Ts2aNc3j+jnV7bZ06VLHn/t8165dnYIFC5rtoH+bN2/uHD58OFXzZAUEoCCwadMmJyQkxHxpqOPHj5vQMXDgwICWa+zYsc7OnTvd93/88UfzJTt//nwnGHzzzTfmi6NNmzZBEYBWrVrlZMuWzZk8ebJX+NiyZUtAy1W+fHlzMHV90W/dutXJnj27M3369Ezdx998803n5MmT5iCQWABas2aN+RzMmzfP3NcvWw1MUVFRfivX4sWLnf/973/O+fPnzYEnsQD0xhtvOHv27HHf//bbb0059YDqz3172rRpzt9//51iANKAVrduXRO2/R2APvroI2fWrFnO7t27kwxAS5YsMd8Tn3zyidd21lDnL2+//bazYMEC83lLKgDpvvTEE084cXFx5v7GjRvN+6g/9PxBP/f6XRAbG2vuX7582WnXrp35YeSpcePGTosWLZwrV66Y+4MGDXKKFi3qxMTE+KVcy5YtM/vT9f/3fXDu3DmnXr16Ttu2bVM1T1ZAAAoCzz77rKlp8fTaa685hQsX9tuvk7SqWLGiXw9Ivtq/f7/5dawHcw0/wRCAWrZsaQ5CwUZrLCZMmOA1TX9t+rsWIylJBSD9tay/Nj0NHz7cBJPMkFQASozWpo0cOdLvZbp69WqyAUiDmdZe6Q+V1q1b+z0AuWjASCoANWnSxLnnnnucQNDyJBaA9HtUa3w+/PBD9zQNQvrZmDhxYqaVT8Ojls8Vbnbt2mXue4ZprS3N7B8o48ePN9sivfPcaOgDFAS0jbVOnTpe0+rXr2/aqIOpP9Dx48dNO3bFihUDWg7tW9C1a1cZOnSohIeHSzDQvgXLly+X9u3bm3bzDRs2mH4SweD111+Xt956S2bMmCELFy40V0QvUaKE/Pvf/5Yb4XOg+10w9UE4dOiQHDt2LOCfA+0r0qVLFxk5cqRUrlxZgoH2d9E+Xvo50P5B2pcrGN47HR9y1KhRZmSBL774Qn7++Wfp0aOHeQ8feeSRTCvHunXr5Oabb3aPseUa5slzv9cBuMuXL+9+LLPKVTGF/dmXeW40AR0KA/8/7ZR6xx13eG0O/RC4HitXrlzAN1VcXJz07NnTDCirX7qB9J///EcKFCgg/fv3l2Bx+vRp0/Hyjz/+MAej4sWLm3Hs9ACuX7j6pRco9957r8ydO1eGDBliyqEhVkORax8LFrqvxy+T5+dAQ1swBN3HH3/cvMcdO3YMaFn0B8C//vWvoBri58SJE+YHyu+//26Cmb5n2vm+cePG8vnnn0vhwoUDVrb7779fvv/+exk8eLDZr7TD+5tvvunToJkZ4bfffpPx48fLmDFj3NN0v86WLVuCMmj5MutkhXnz5pn35ptvvknXPDciAlAQyJEjhzk7xpPrTJOcOXNKoGlTae/evU2txi+//GIGnA0U/WJ11WboWTvK9UWhZ3/UrVtXcufOHZD3UOkvS/3lduutt5pyNWrUSJ5//nmZPn26BIKGsubNm0urVq3kp59+Ml+227dvl4YNG5r/n3jiCQkWwf450B8BGn70bB2t7QvkUAF6MJ04caIJ17rfq3PnzpmApvc1eAdim7k+Bzr4tJ4BVqxYMXMGm+5vL774onzwwQcSCHoGa7NmzeTBBx+UJUuWmBohPTNLB87W7dStWze/Pr/+MNIfIrr/eP5w0+2lgVFr8zzfL93vM+P9W758ualNf/XVV+WBBx5I8zw3KgJQEChbtmyC029d90uXLi2BDj9PPvmk+eWk46tVqVIloOXRLzINOfpLysV1Crz+Iv7qq6/Mr+LMpr9stVpbf2Vq+FFFihSRTp06ybRp0yRQ9LRtPX27b9++JvCoatWqmVCkv+qCKQAl9TnQg1WpUqUk0OFHm0z04Kk/AipUqBDQ8ugBUptNxo4d656mp8Bnz57dfA7mzJkTkFpH3ff1B4jWjmn4UfpX73/77bcSKPqjRPelfv36mf1J1apVy9RM6efAnwFIf3DcddddJjy8//77CfZ5pc3lYWFh7ul6X2vb/WnlypXSrl07UyM2fPjwNM9zIyMABQEduV6bJ/RaJNq0o/TLol69elKoUKGAhh89cGpZ9ItfD5yBpr/YXL94XTR0KG3mCZSQkBBTyxL/AK79RQLZ/OV6bi2HZzOr3r/99tsl2D4H2k9DQ66rllH3Pa1Fy5MnT8Cbf7X/lP4ICIb+NlqbEf9z0KZNG/N98eWXXwasXBqy77777qD+HFStWtX9/ab3/dmvRX+cafi57777ZPLkyeZ7wlNERITky5fPhLBnn33WTPv1119NU6J+HvxFa8/btm1raqdfeeWVNM9zoyMABQH9Zfnee+9Jhw4dZMCAAabjoNZkLFiwIKDlGjRokHz88ccyYcIE0yHb9YWrv/IqVaoU0LIFI+3zoF9oL7/8sjRp0sR0Gvz0009NM0Wg6K9I3a+efvpp009J+ybNmjVLtmzZIpMmTcq0cmg1v36xK+0k7rqQXv78+d1BTPuyaLOO/lLW8mpnWj0wLF682G/l0rClF4dU2gyhtWVaLq29cwX+Z555xryH+uv95MmT5qa0f4u/aoK0OUtr73S7uWp3tFz+fE5faId07dOjncCVNnO5ajJctdUaYps2ber+POj7rt9nWivlz4u1ui7YqvQ7VMONhtVbbrnFfF9pQNR9TMul0/Q91YuVat8Wf9ATWDT86LbREw5cTfZKa+801Gv40T6Nw4YNM01eWpP80ksvmc+ANmP6qxuBBpumTZuakOUZpPUHptaQ+TJPVsBo8EFCv1T1DAXd8fTXilbVRkZGBrRMjz76aKJnod1zzz3mAxssXGXRjr2BptXd48aNMwdSPSD06tXLVLMH0pUrV2TKlCmybNkyc2aOHkB1/6pRo0amlUFDjx6A4tMD09SpU9339cCqnwM9kGnQ1iCkNUD+vHJw9+7dE0zX53zjjTfM/w8//HCiZzJpzeMLL7zgtz4++gMkNc+p0zVQ+vPXujaF6/sTnwYLz7MKNWBrM7WGEg3h+rj2A/IX/aGmt/g0TOiBXGn/Mq2FWbFihalt131P9y9XjVBG0+eJiopK9DENXZ5NXJ999pkJidpnT0PTc88957c+ZrNnzzbfUYnRWk4NZr7MkxUQgAAAgHWyRj0WAABAKhCAAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACkO6L9q1Zs4atyDYDbigMhQEgWXpVZh3N2jXWkw42q+OKua4Gq0NE6Cjk6b3Srw5foFfC9eeVn4NFRm0zAGlHAAKQLL1E/zvvvGNGhdaxqTZv3myGtvj6668zdJiPDz/8UE6dOmVFAAIQeAQgACnScblco4xrCNIw1Lt3bzPatefAops2bTLhqEGDBmZkck+6nDaX6YCaOg5TeHi4Vy2TDkypYzS5nqd58+bmeZNbTuljOrJ3zZo1k33+1C6jYznp2Fpa2+WiY/XFxMS4x+lzrUfL5HpMB5AsUKCAeS06AKYOcqkDSObOnTtBOfR59fl1Xl1Ony8+17bRseV04FithYv/OqpXr24GHdUBXfW9AZAyAhCAVNEDcPv27c0o6TrApNImMh3hWke+1gFNdfBQHXy1SpUq5nENLzoYqo5Irwdr7TOko0zriNy6Pg1SOjCpNoHNnTvXLOMKOskt52pO0lopLUtSzx+fL8voYKgVK1b0CkAzZswwo7S7ApCuR0eT10FmdfR4DSoagt58800ZMWKEGWhz165dkjdvXhNWPAeR1G2mAUwHp9WRy3W5RYsWuUeh11DUqVMn83xaBl2PBqvvvvtOihcv7vU6Ll68KOXLlzdlJwABviEAAUi13bt3S+HChd21Gjt37pQNGzaYA77WSNx9990yZswY+eijj8zjQ4cOdQedfPnymbCjtRn6uI4Urgf6JUuWmCYwVw2Q6tGjR7LLuaT0/IlJyzKJ2bNnj6n9qVy5sly5csXUUmk41GBSrlw5UzOmfzW09ezZ072cLqOvWWu6tJbrwQcflP79+8vixYvdo7uHhISYUKW1SHFxcWZkep2uQcxFA9K6devMdgHgOwIQgBRpU40GEz1Q64F74sSJMmrUKPfjzZo1M0FC6UFbm3MWLlxo7mu40P5CkyZNMiFGaSB45JFHzDo9g4yn1CyX3PMnJS3LJEYDjIYfpUGldu3aEhoaasqqtPZHa3q0BsdT3bp1zbJKQ54GGy2D1nYVLFjQhJynnnpK5s2bZ7aF3kqVKiWzZs3yWk+TJk0IP0AaEIAApEibWLRpSg/UJUqUkB9//FHuuusu9+NFihTxmj9Xrlzu5rGTJ0+aWhBtovGkTT8///xzks+ZmuWSe/6kpGWZxGhNWPz1xO/Lk9i6w8LCvO67AtP+/ftNE5e+dg2bBw8eTBDcPOn7ASD1CEAAUtUJOi0BQYPTmTNnvKbr/WLFimX4chlFa3G02clTWgJSUs6ePZvofX1t2tdHa6W0o7k2DyZH5wOQelwIEYBf5ciRQ+rXry+zZ892T9OmtDlz5nidRq+1Jp4Bw9fl/EWvd6T9e1w0DC1fvjzD1r969WpTy+Wir1M7ZGszlwYgPXNs8uTJpunL0+HDhzOsDIDNqAEC4HdvvfWWaTLTGh0NNdq3R89yioqK8uoTo9cC0v5F2jyl/WN8Wc5funXrZs720r45t912m+l7o2eLlSxZMkPWr32DWrRoIX379pV9+/bJ22+/LZ9++qmpeVK6HfRxff3a+VnDoXaQ1ibB9957L0PKANiMAAQgWdqBVztBJ0WvnxO/qUhP5W7durX7fkREhDnj6pNPPpGVK1eafix6VpRnU5Y29Vy+fNlcz0ZPK9fT4H1ZzpfnT0uZ9YKMS5cuNaFLz7QaMGCAaaby7JOT2HoSu+aPdm52nbruWq5evXomWP3www8m1OlfPcXfc7vrqfL62teuXWte87PPPutVxsSeH4BvQpz49asAAABZHH2AAACAdQhAAADAOgQgAABgHQIQAACwDgEIAABYhwAEAACsQwACAADWIQABAADrEIAAAIB1CEAAAMA6BCAAAGAdAhAAABDb/H9ANiDP1lNxFAAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 462 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "As we can see there is 27 procent chance of having one or two photons", + "id": "7878e933701a08c0" + } + ], + "metadata": { + "kernelspec": { + "name": "python3", + "language": "python", + "display_name": "Python 3 (ipykernel)" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}