Added files

33 files changed, 6488 insertions, 0 deletions

diff --git a/src/Lecture7/notebook/X1-ComputationalComplexity-notebook.ipynb b/src/Lecture7/notebook/X1-ComputationalComplexity-notebook.ipynb
new file mode 100644
index 0000000..18be171
--- /dev/null
+++ b/src/Lecture7/notebook/X1-ComputationalComplexity-notebook.ipynb
@@ -0,0 +1,412 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Nested loops\n",
+    "\n",
+    "The following two functions compute sum and product of matrices, respectively.\n",
+    "\n",
+    "By counting the nested loops it is easy to see that `add()` is $O(n^2)$ while `prod()` is $O(n^3)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time for add:  0.01961983600000039\n",
+      "Time for prod: 11.278560734\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def add(A, B):\n",
+    "    S = [[0] * len(A) for i in range(len(A))]\n",
+    "    for i in range(len(A)):\n",
+    "        for j in range(len(A)):\n",
+    "            S[i][j] = A[i][j] + B[i][j]\n",
+    "    return S\n",
+    "\n",
+    "def prod(A, B):\n",
+    "    S = [[0] * len(A) for i in range(len(A))]\n",
+    "    for i in range(len(A)):\n",
+    "        for j in range(len(A)):\n",
+    "            for k in range(len(A)):\n",
+    "                S[i][j] = S[i][j] + A[i][k] * B[k][j]\n",
+    "    return S\n",
+    "\n",
+    "N = 400\n",
+    "A = [ [randint(0,100) for i in range(N)] for j in range(N) ]\n",
+    "B = [ [randint(0,100) for i in range(N)] for j in range(N) ]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "add(A,B)\n",
+    "t1 = time.process_time()\n",
+    "prod(A,B)\n",
+    "t2 = time.process_time()\n",
+    "\n",
+    "print(\"Time for add: \", t1-t0)\n",
+    "print(\"Time for prod:\", t2-t1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sorting a list, slow version\n",
+    "\n",
+    "The following code implements a slow version of the so-called *insertion sort* alogithm\n",
+    "\n",
+    "Complexity: $O(n^2)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running time: 1.2679741750000009\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def correct_position(e, S):\n",
+    "    for i in range(len(S)):\n",
+    "        if S[i] > e:\n",
+    "            return i\n",
+    "    return len(S)\n",
+    "\n",
+    "def sort_list(L):\n",
+    "    S = []\n",
+    "    for e in L:\n",
+    "        cp = correct_position(e, S)\n",
+    "        S.insert(cp, e)\n",
+    "    return S\n",
+    "\n",
+    "N = 10000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "sort_list(L)\n",
+    "#L.sort()\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Binary search\n",
+    "\n",
+    "The following code implements a binary search.\n",
+    "\n",
+    "Complexity: $O(\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The correct position of e = 36132116 in L is:\n",
+      "... 36130178 36131096 e 36132160 36132386 ...\n",
+      "\n",
+      "Time for sorting:   0.4964379069999971\n",
+      "Time for searching: 0.00012017000000241751\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def binary_search(e, S, start, end):\n",
+    "    if start == end:\n",
+    "        return start\n",
+    "    midpoint = (start+end) // 2\n",
+    "    if e < S[midpoint]:\n",
+    "        return binary_search(e, S, start, midpoint)\n",
+    "    else:\n",
+    "        return binary_search(e, S, midpoint+1, end)\n",
+    "    \n",
+    "N = 1000000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "e = randint(0,10**9)\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "L.sort() # Using Python's sort()\n",
+    "t1 = time.process_time()\n",
+    "i = binary_search(e, L, 0, len(L))\n",
+    "t2 = time.process_time()\n",
+    "print(\"The correct position of e =\", e, \"in L is:\")\n",
+    "print(\"...\", L[i-2], L[i-1], \"e\", L[i], L[i+1], \"...\")\n",
+    "print(\"\")\n",
+    "print(\"Time for sorting:  \", t1-t0)\n",
+    "print(\"Time for searching:\", t2-t1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sorting a list, fast version (with binary_search)\n",
+    "\n",
+    "The following code uses the function `binary_search()` above instead of `correct_position()` in our insertion sort algorithm.\n",
+    "\n",
+    "Complexity: $O(n\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running time: 1.5683504970000008\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def binary_search(e, S, start, end):\n",
+    "    if start == end:\n",
+    "        return start\n",
+    "    midpoint = (start+end) // 2\n",
+    "    if e < S[midpoint]:\n",
+    "        return binary_search(e, S, start, midpoint)\n",
+    "    else:\n",
+    "        return binary_search(e, S, midpoint+1, end)\n",
+    "    \n",
+    "def sort_list(L):\n",
+    "    S = []\n",
+    "    for e in L:\n",
+    "        cp = binary_search(e, S, 0, len(S)) # Changed here\n",
+    "        S.insert(cp, e)\n",
+    "    return S\n",
+    "    \n",
+    "N = 100000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "sort_list(L)\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast exponentiation\n",
+    "\n",
+    "The following cell contains two functions for computing $a^n$ ($n$ non-negative integer): a slow one that runs in $O(n)$ and a fast one that runs in $O(\\log_2(n))$. We compare these two also with Python's built-in operator `**`.\n",
+    "\n",
+    "Complexity: $O(n)$ for the slow algorithm, $O(\\log_2(n))$ for the other two."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.71828179834636\n",
+      "2.7182817863957984\n",
+      "2.7182817983473577\n",
+      "Time for slow_power(): 3.5567659670000005\n",
+      "Time for fast_power(): 0.00014241699999928414\n",
+      "Time for Python's **:  9.477100000054861e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def slow_power(a, n):\n",
+    "    r = 1\n",
+    "    for i in range(n):\n",
+    "        r = r * a\n",
+    "    return r\n",
+    "\n",
+    "def fast_power(a, n):\n",
+    "    if n == 0:\n",
+    "        return 1\n",
+    "    if n%2 == 0:\n",
+    "        return fast_power(a*a, n//2)\n",
+    "    else:\n",
+    "        return a * fast_power(a, n-1)\n",
+    "\n",
+    "a = 1.00000001\n",
+    "n = 100000000\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(slow_power(a, n))\n",
+    "t1 = time.process_time()\n",
+    "print(fast_power(a, n))\n",
+    "t2 = time.process_time()\n",
+    "print(a**n)\n",
+    "t3 = time.process_time()\n",
+    "\n",
+    "print(\"Time for slow_power():\", t1-t0)\n",
+    "print(\"Time for fast_power():\", t2-t1)\n",
+    "print(\"Time for Python's **: \", t3-t2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast gcd\n",
+    "\n",
+    "Complexity: $O(\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126\n",
+      "Running time: 0.0002987290000007192\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def gcd(a, b):\n",
+    "    if b == 0:\n",
+    "        return a\n",
+    "    else:\n",
+    "        return gcd(b, a%b)\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(gcd(155275387236018, 572335397352432))\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fibonacci numbers\n",
+    "\n",
+    "In the following cell there are two functions that compute the $n$-th Fibonacci number. They are almost the same, but the second one memorizes the results in a list to avoid computing them multiple times, and it is much much faster.\n",
+    "\n",
+    "Complexity: $O\\left(\\left(\\frac{1+\\sqrt 5}{2}\\right)^n\\right)\\sim O(1.6^n)$ for the slow version, $O(n)$ for the fast version."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "222232244629420445529739893461909967206666939096499764990979600\n",
+      "Time for F_slow: 3.0404000000316955e-05\n",
+      "Time for F_fast: 0.0003859389999973928\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "F_memorized = [-1] * (10**6)\n",
+    "\n",
+    "def F_slow(n):\n",
+    "    if n <= 1:\n",
+    "        return n\n",
+    "    else:\n",
+    "        return F_slow(n-1) + F_slow(n-2)\n",
+    "    \n",
+    "def F_fast(n):\n",
+    "    if F_memorized[n] == -1:\n",
+    "        if n <= 1:\n",
+    "            F_memorized[n] = n\n",
+    "        else:\n",
+    "            F_memorized[n] = F_fast(n-1) + F_fast(n-2)\n",
+    "    \n",
+    "    return F_memorized[n]\n",
+    "\n",
+    "n = 300\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "#print(F_slow(n))\n",
+    "t1 = time.process_time()\n",
+    "print(F_fast(n))\n",
+    "t2 = time.process_time()\n",
+    "\n",
+    "print(\"Time for F_slow:\", t1-t0)\n",
+    "print(\"Time for F_fast:\", t2-t1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture7/notebook/X2-StudentsRequests-notebook.ipynb b/src/Lecture7/notebook/X2-StudentsRequests-notebook.ipynb
new file mode 100644
index 0000000..89cdd0b
--- /dev/null
+++ b/src/Lecture7/notebook/X2-StudentsRequests-notebook.ipynb
@@ -0,0 +1,516 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Diffie-Hellman key exchange\n",
+    "\n",
+    "The following is a simple implementation of the classic [Diffie-Hellman key exchange](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange) cryptographic protocol."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Public key: p = 97021 and g = 66271 \n",
+      "\n",
+      "[[ Alice's secret key: a = 19234 ]]\n",
+      "[[ Bob's secret key: b = 76267 ]] \n",
+      "\n",
+      "Alice sends h1 = 17104 to Bob\n",
+      "Bob sends h2 = 28787 to Alice \n",
+      "\n",
+      "Alice computed 62444 using h2 and her secret a\n",
+      "Bob computed 62444 using h1 and his secret b\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Public information:\n",
+    "p = Primes()[10^3 + randint(1,10000)] # random prime\n",
+    "g = randint(2, p-1) # random integer\n",
+    "\n",
+    "print(\"Public key: p =\", p, \"and g =\", g, \"\\n\")\n",
+    "\n",
+    "a = randint(2, p-1) # Only Alice knows this\n",
+    "b = randint(2, p-1) # Only Bob knows this\n",
+    "\n",
+    "print(\"[[ Alice's secret key: a =\", a, \"]]\")\n",
+    "print(\"[[ Bob's secret key: b =\", b, \"]]\", \"\\n\")\n",
+    "\n",
+    "h1 = (g^a) % p # Alice sends this to Bob\n",
+    "h2 = (g^b) % p # Bob sends this to Alice\n",
+    "\n",
+    "print(\"Alice sends h1 =\", h1, \"to Bob\")\n",
+    "print(\"Bob sends h2 =\", h2, \"to Alice\", \"\\n\")\n",
+    "\n",
+    "secret_a = (h2^a) % p # Alice can compute this because she knows a\n",
+    "secret_b = (h1^b) % p # Bob can compute this because he knows b\n",
+    "\n",
+    "print(\"Alice computed\", secret_a, \"using h2 and her secret a\")\n",
+    "print(\"Bob computed\", secret_b, \"using h1 and his secret b\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## General Diffie-Hellman\n",
+    "\n",
+    "The following code is an implementation of a generic Diffie-Hellman key exchange protocol that uses a group $G$ instead of $(\\mathbb Z/p \\mathbb Z)^\\times$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Public key:\n",
+      "G = Additive abelian group isomorphic to Z/171 embedded in Abelian group of points on Elliptic Curve defined by y^2 = x^3 + x + 156 over Finite Field of size 157 \n",
+      "g = (35 : 131 : 1) \n",
+      "\n",
+      "[[ Alice's secret key: a = 140 ]]\n",
+      "[[ Bob's secret key: b = 73 ]] \n",
+      "\n",
+      "Alice sends h1 = (150 : 80 : 1) to Bob\n",
+      "Bob sends h2 = (18 : 121 : 1) to Alice \n",
+      "\n",
+      "Alice computed (154 : 35 : 1) using h2 and her secret a\n",
+      "Bob computed (154 : 35 : 1) using h1 and his secret b\n"
+     ]
+    }
+   ],
+   "source": [
+    "def genericDH(G):\n",
+    "    if G.cardinality() == 1:\n",
+    "        print(\"Group is trivial, can't do anything\")\n",
+    "        return\n",
+    "    g = G.random_element()\n",
+    "    while g == G.identity(): # Make sure g is not trivial\n",
+    "        g = G.random_element()\n",
+    "        \n",
+    "    print(\"Public key:\\nG =\", G, \"\\ng =\", g, \"\\n\")\n",
+    "    \n",
+    "    a = randint(2, G.exponent()-1) # Only Alice knows this\n",
+    "    b = randint(2, G.exponent()-1) # Only Bob knows this\n",
+    "\n",
+    "    print(\"[[ Alice's secret key: a =\", a, \"]]\")\n",
+    "    print(\"[[ Bob's secret key: b =\", b, \"]]\", \"\\n\")\n",
+    "    \n",
+    "    # \"Ternary operator\", I did not explain this\n",
+    "    # https://docs.python.org/3/reference/expressions.html#conditional-expressions\n",
+    "    h1 = g^a if G.is_multiplicative() else a*g # Alice sends this to Bob\n",
+    "    h2 = g^b if G.is_multiplicative() else b*g # Bob sends this to Alice\n",
+    "\n",
+    "    print(\"Alice sends h1 =\", h1, \"to Bob\")\n",
+    "    print(\"Bob sends h2 =\", h2, \"to Alice\", \"\\n\")\n",
+    "    \n",
+    "    secret_a = h2^a if G.is_multiplicative() else a*h2 # Alice can compute this because she knows a\n",
+    "    secret_b = h1^b if G.is_multiplicative() else b*h1 # Bob can compute this because he knows b\n",
+    "\n",
+    "    print(\"Alice computed\", secret_a, \"using h2 and her secret a\")\n",
+    "    print(\"Bob computed\", secret_b, \"using h1 and his secret b\")\n",
+    "    \n",
+    "E = EllipticCurve(GF(157), [1,-1])\n",
+    "G = E.abelian_group()\n",
+    "genericDH(G)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Numerical methods for differential equations\n",
+    "\n",
+    "## Euler's method (ODE)\n",
+    "\n",
+    "In sage you can use [`ode_solver()`](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/ode.html) to solve any ordinary differential equation by hand, but Euler's method is very simple to implement by hand:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 2 graphics primitives"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "var('y')\n",
+    "\n",
+    "def euler_desolve(f, x0, y0, x1):\n",
+    "    n = 10000\n",
+    "    h = (x1-x0)/n\n",
+    "    S = []\n",
+    "    Y = [y0]\n",
+    "    for i in range(n+1):\n",
+    "        S.append(x0 + i*h)\n",
+    "        Y.append(N(  Y[i] + h*f(S[i], Y[i])  ))\n",
+    "    return S, Y\n",
+    "\n",
+    "f(x,y) = y\n",
+    "x0 = -1\n",
+    "x1 = 2\n",
+    "y0 = e^(-1)\n",
+    "\n",
+    "S, Y = euler_desolve(f, x0, y0, x1)\n",
+    "plot(e^x, -1, 2) + line([(S[i], Y[i]) for i in range(len(S))], color='red', marker='o', markersize=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sage also has an `eulers_method()` function \"for pedagogical purposes only\":"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         x                    y                  h*f(x,y)\n",
+      "        -1    0.367879441171442   0.0367879441171442\n",
+      "-0.900000000000000    0.404667385288587   0.0404667385288587\n",
+      "-0.800000000000000    0.445134123817445   0.0445134123817445\n",
+      "-0.700000000000000    0.489647536199190   0.0489647536199190\n",
+      "-0.600000000000000    0.538612289819109   0.0538612289819109\n",
+      "-0.500000000000000    0.592473518801020   0.0592473518801020\n",
+      "-0.400000000000000    0.651720870681122   0.0651720870681122\n",
+      "-0.300000000000000    0.716892957749234   0.0716892957749234\n",
+      "-0.200000000000000    0.788582253524157   0.0788582253524157\n",
+      "-0.100000000000000    0.867440478876573   0.0867440478876573\n",
+      "-1.38777878078145e-16    0.954184526764230   0.0954184526764230\n",
+      "0.0999999999999999     1.04960297944065    0.104960297944065\n",
+      "0.200000000000000     1.15456327738472    0.115456327738472\n",
+      "0.300000000000000     1.27001960512319    0.127001960512319\n",
+      "0.400000000000000     1.39702156563551    0.139702156563551\n",
+      "0.500000000000000     1.53672372219906    0.153672372219906\n",
+      "0.600000000000000     1.69039609441897    0.169039609441897\n",
+      "0.700000000000000     1.85943570386086    0.185943570386086\n",
+      "0.800000000000000     2.04537927424695    0.204537927424695\n",
+      "0.900000000000000     2.24991720167165    0.224991720167165\n",
+      "1.00000000000000     2.47490892183881    0.247490892183881\n",
+      "1.10000000000000     2.72239981402269    0.272239981402269\n",
+      "1.20000000000000     2.99463979542496    0.299463979542496\n",
+      "1.30000000000000     3.29410377496746    0.329410377496746\n",
+      "1.40000000000000     3.62351415246420    0.362351415246420\n",
+      "1.50000000000000     3.98586556771062    0.398586556771062\n",
+      "1.60000000000000     4.38445212448168    0.438445212448168\n",
+      "1.70000000000000     4.82289733692985    0.482289733692985\n",
+      "1.80000000000000     5.30518707062284    0.530518707062284\n",
+      "1.90000000000000     5.83570577768512    0.583570577768512\n",
+      "2.00000000000000     6.41927635545363    0.641927635545363\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Usage: eulers_method(f, x0, y0, h, x1)\n",
+    "eulers_method(f, -1, N(e^(-1)), 0.1, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solving the heat equation with a finite difference method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkwAAAGGCAYAAACJ/96MAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3de3BU9f3/8ddCZAMxiRK5BVCiQmFBQSFYgVpQoIMYpX4VLCqo6ODXFQSqQr54iYqkOpVvOmbFa8R+gchYEamlAoMI3ug3XGIt24IoFVQiXpjNBVlDcn5/7I98WQl+WHL2nAN5PmZ2mN0c8nlvTjY8ObvZ47MsyxIAAACOqoXbAwAAAHgdwQQAAGBAMAEAABgQTAAAAAYEEwAAgAHBBAAAYEAwAQAAGBBMAAAABp4LJsuyVFlZKd5PEwAAeIXngmnNmiplZmbqf/+3yu1R4uTlSWPGOL/u1VdLl1/u7Jq/+pU0dqxz6+3aJfl80qpVzq05bpw0YoRz661aFbuPu3c7t2ZWlvTYY86tdzKaPl3q3du59TZsiH2fbN3q3Jo5OdLs2c6tN2eO1KmTc+tFo7Gv6cKFzq1ZXCylpjq3nhR7rJ9xhrNrStK8eVJGhvPrusFzwQQAAOA1BBMAAIBBwsG0fv165eXlKTs7Wz6fT8uWLWv4WG1trWbOnKnzzjtPaWlpys7O1oQJE/Tll1/aOjQAAICTEg6mmpoa9e3bV8XFxUd8bP/+/dq8ebPuv/9+bd68WUuXLtX27dt15ZVX2jIsAACAG1IS/QujRo3SqFGjGv1YZmamVq9eHXfbk08+qYEDB2rXrl0688wzj29KAAAAFyUcTImKRCLy+Xw67bTTGv14NBpVNBptuF5TU5PskQAAABKS1Bd9HzhwQLNmzdL48eOVcZTfOywsLFRmZmbDZcwYnr4DAADekrRgqq2t1XXXXaf6+no99dRTR90uPz9fkUik4bJs2fJkjQQAAHBckvKUXG1trcaOHaudO3fqrbfeOurRJUny+/3y+/0N19PSkjERAADA8bM9mA7F0scff6y1a9cqKyvL7iUAAAAclXAwVVdXa8eOHQ3Xd+7cqfLycrVt21bZ2dm65pprtHnzZr3xxhuqq6tTRUWFJKlt27Zq1aqVfZMDAAA4JOFg2rhxo4YNG9ZwfcaMGZKkiRMnqqCgQMuXx16D1K9fv7i/t3btWg0dOrQJowIAALgj4WAaOnSoLMs66sd/6mMAAAAnIs4lBwAAYEAwAQAAGBBMAAAABgQTAACAAcEEAABgQDABAAAYEEwAAAAGSTmX3PEIhUIKhUKqrg64PQoAAEAczxxhCgaDCofDKikpcXsUAACAOJ4JJgAAAK8imAAAAAwIJgAAAAOCCQAAwIBgAgAAMCCYAAAADAgmAAAAA4IJAADAgGACAAAwIJgAAAAMCCYAAAADTr4LAABg4JkjTJx8FwAAeJVnggkAAMCrCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwIBgAgAAMCCYAAAADAgmAAAAA4IJAADAgGACAAAwSHF7gENCoZBCoZCqqwNujwIAABDHM0eYgsGgwuGwSkpK3B4FAAAgjmeCCQAAwKsIJgAAAAOCCQAAwIBgAgAAMCCYAAAADAgmAAAAA4IJAADAIOFgWr9+vfLy8pSdnS2fz6dly5bFfdyyLBUUFCg7O1utW7fW0KFDtXXrVtsGBgAAcFrCwVRTU6O+ffuquLi40Y8//vjjmjdvnoqLi1VWVqaOHTtqxIgRqqqqavKwAAAAbkj41CijRo3SqFGjGv2YZVkqKirS7NmzdfXVV0uSXnrpJXXo0EGLFy/W5MmTmzYtAACAC2x9DdPOnTtVUVGhkSNHNtzm9/v1y1/+Uu+//76dSwEAADjG1pPvVlRUSJI6dOgQd3uHDh302WefNfp3otGootFow/Wamho7RwIAAGiypPyWnM/ni7tuWdYRtx1SWFiozMzMhsuYMVcmYyQAAIDjZmswdezYUdL/HWk6ZO/evUccdTokPz9fkUik4bJs2XI7RwIAAGgyW4MpJydHHTt21OrVqxtu++GHH7Ru3ToNGjSo0b/j9/uVkZHRcElLS7NzJAAAgCZL+DVM1dXV2rFjR8P1nTt3qry8XG3bttWZZ56padOmae7cuerevbu6d++uuXPnqk2bNho/frytgwMAADgl4WDauHGjhg0b1nB9xowZkqSJEydqwYIFuvfee/X999/rjjvu0L59+3TRRRdp1apVSk9Pt29qAAAAByUcTEOHDpVlWUf9uM/nU0FBgQoKCpoyFwAAgGdwLjkAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwIBgAgAAMCCYAAAADBJ+48pkCYVCCoVCqq4OuD0KAABAHM8cYQoGgwqHwyopKXF7FAAAgDieCSYAAACvIpgAAAAMCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwIBgAgAAMCCYAAAADAgmAAAAA06+CwAAYOCZI0ycfBcAAHiVZ4IJAADAqwgmAAAAA4IJAADAgGACAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwIBgAgAAMEhxe4BDQqGQQqGQqqsDbo8CAAAQxzNHmILBoMLhsEpKStweBQAAII5nggkAAMCrCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwMD2YDp48KDuu+8+5eTkqHXr1jr77LP18MMPq76+3u6lAAAAHGH7O30/9thjevrpp/XSSy+pd+/e2rhxo26++WZlZmbqrrvusns5AACApLM9mD744ANdddVVGj16tCSpW7duKi0t1caNG+1eCgAAwBG2PyU3ZMgQrVmzRtu3b5ckffjhh3r33Xd1+eWX270UAACAI2w/wjRz5kxFIhH17NlTLVu2VF1dnR599FH95je/aXT7aDSqaDTacL2mpsbukQAAAJrE9mBasmSJFi5cqMWLF6t3794qLy/XtGnTlJ2drYkTJx6xfWFhoR566KHDbhlg90gAAABNYvtTcvfcc49mzZql6667Tuedd55uvPFGTZ8+XYWFhY1un5+fr0gk0nBZtmy53SMBAAA0ie1HmPbv368WLeI7rGXLlkd9WwG/3y+/399wPS3N7okAAACaxvZgysvL06OPPqozzzxTvXv31pYtWzRv3jzdcsstdi8FAADgCNuD6cknn9T999+vO+64Q3v37lV2drYmT56sBx54wO6lAAAAHGF7MKWnp6uoqEhFRUV2f2oAAABXcC45AAAAA4IJAADAgGACAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADCw/X2YjlcoFFIoFFJ1dcDtUQAAAOJ45ghTMBhUOBxWSUmJ26MAAADE8UwwAQAAeBXBBAAAYEAwAQAAGBBMAAAABgQTAACAAcEEAABgQDABAAAYEEwAAAAGBBMAAIABwQQAAGBAMAEAABgQTAAAAAYpbg9wSCgUUigUUnV1wO1RAAAA4njmCFMwGFQ4HFZJSYnbowAAAMTxTDABAAB4FcEEAABgQDABAAAYEEwAAAAGBBMAAIABwQQAAGBAMAEAABgQTAAAAAYEEwAAgAHBBAAAYEAwAQAAGBBMAAAABiluD3BIKBRSKBRSdXXA7VEAAADieOYIUzAYVDgcVklJidujAAAAxPFMMAEAAHgVwQQAAGBAMAEAABgQTAAAAAYEEwAAgAHBBAAAYEAwAQAAGCQlmL744gvdcMMNysrKUps2bdSvXz9t2rQpGUsBAAAkne3v9L1v3z4NHjxYw4YN01//+le1b99en3zyiU477TS7lwIAAHCE7cH02GOPqWvXrnrxxRcbbuvWrZvdywAAADjG9qfkli9frgEDBujaa69V+/btdcEFF+i555476vbRaFSVlZUNl5qaGrtHAgAAaBLbg+nTTz/V/Pnz1b17d61cuVK33367pk6dqj/+8Y+Nbl9YWKjMzMyGy5gxV9o9EgAAQJPYHkz19fW68MILNXfuXF1wwQWaPHmybrvtNs2fP7/R7fPz8xWJRBouy5Ytt3skAACAJrE9mDp16qRAIBB3W69evbRr165Gt/f7/crIyGi4pKWl2T0SAABAk9geTIMHD9a2bdvibtu+fbvOOussu5cCAABwhO3BNH36dG3YsEFz587Vjh07tHjxYj377LMKBoN2LwUAAOAI24MpNzdXr732mkpLS9WnTx898sgjKioq0vXXX2/3UgAAAI6w/X2YJOmKK67QFVdckYxPDQAA4DjOJQcAAGBAMAEAABgQTAAAAAYEEwAAgAHBBAAAYEAwAQAAGBBMAGyxdq00a5b05ZduTwIA9vNMMIVCIQUCAd122zWSpFNPdXkgAAl55RXpscekc86R7r5b+vprtycCAPt4JpiCwaDC4bA+/PBPkqSuXV0eCEDCevaUZs6Unn1WysmR7rtP2rfP7akAoOk8E0wATnxt2kgFBdLOndKdd0rz5sXCac4cqarK7ekA4PgRTABsl5Ul/e530qefShMnSo88Egun3/9e2r/f7ekAIHEEE4Ck6dhR+sMfpB07pP/4Dyk/Xzr3XCkUkqJRt6cDgGNHMAFIuq5dpWeekf71L2nECGnqVKlHD+mFF6TaWrenAwAzggmAY845R3rpJekf/5B+/nPp1lulQEBatEiqq3N7OgA4OoIJgON69ZKWLJG2bIkF0w03SOefL736qmRZbk8HAEcimAC4pl8/6fXXpb/9TerSRbrmGql/f2nFCsIJgLcQTABcN3CgtHKltG5d7E1rR4+WBg+W3nrL7ckAIIZgAuAZl1wSi6aVK6WDB6XLLpMuvVR6/323JwPQ3BFMADzF55NGjow9Tff669K338aONl1+ubRpk9vTAWiuCCYAnuTzSVdeGXth+JIlsTfBHDBAuvrq2G/ZAYCTCCYAntaihTR2bCySFiyQystjv1E3fry0fbvb0wFoLjwTTKFQSIFAQLm5uW6PAsCDUlJip1n517+k+fOl9etjb0kwaZL073+7PR2Ak51ngikYDCocDqusrMztUQB4WKtW0uTJsdOtPPGE9MYbsXcNDwalL790ezoAJyvPBBMAJCI1Vbrrrthrmx55RCotjb2T+G9/K+3d6/Z0AE42BBOAE1pamjRzprRzpzRrlvTcc9LZZ0uzZ0v79rk9HYCTBcEE4KSQmSk9+GAsnKZMkYqKpJwcac4cqarK7ekAnOgIJgAnlawsqbAw9lTdTTfFnq7LyZF+/3tp/363pwNwoiKYAJyUOnSIHWXasSN2jrr8/NhrnIqLpWjU7ekAnGgIJgAnta5dpaeflrZtk371q9gLxbt3l55/XqqtdXs6ACcKgglAs3D22bE3vty6VRo0SLrtttj7OC1aJNXVuT0dAK8jmAA0Kz17Si+/HHvH8EBAuuGG2DuHv/qqVF/v9nQAvIpgAtAs9e0bO7nv3/4mdekSe53TgAHSX/4iWZbb0wHwGoIJQLM2cKC0cqW0bp106qnSFVfEnrJbs8btyQB4CcEEAJIuuSQWTatWxZ6aGz489iaYAE48y5fHzjtpJ88EEyffBeA2n08aMULasCH2A/fcc6Vu3dyeCkCibrkl9pS7nTwTTJx8F4BX+HxSXl7sheF/+Yvb0wDwAs8EEwAAgFcRTAAAAAYEEwAAgAHBBAAAYEAwAQAAGBBMAAAABgQTAACAAcEEAABgkPRgKiwslM/n07Rp05K9FAAAQFIkNZjKysr07LPP6vzzz0/mMgAAAEmVtGCqrq7W9ddfr+eee06nn356spYBAABIuqQFUzAY1OjRozV8+PCf3C4ajaqysjLuAgAA4CUpyfikL7/8sjZv3nxMJ9ItLCzUQw89lIwxAAAAbGH7Eabdu3frrrvu0sKFC5WammrcPj8/X5FIpOGye/duu0cCAABoEtuPMG3atEl79+5V//79G26rq6vT+vXrVVxcrGg0qpYtWzZ8zO/3y+/32z0GAACAbWwPpssuu0wfffRR3G0333yzevbsqZkzZ8bFEgAAwInA9mBKT09Xnz594m5LS0tTVlbWEbcDAACcCHinbwAAAIOk/Jbcj7399ttOLAMAAJAUHGECAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAPPBFMoFFIgEFBubq7bowAAAMTxTDAFg0GFw2GVlZW5PQoAAEAczwQTAACAVxFMAAAABgQTAACAAcEEAABgQDABAAAYEEwAAAAGBBMAAIABwQQAAGBAMAEAABgQTAAAAAYEEwAAgIFngomT7wIAAK/yTDBx8l0AAOBVngkmAAAAryKYAAAADAgmAAAAA4IJAADAgGACAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwMAzwRQKhRQIBJSbm+v2KAAAAHE8E0zBYFDhcFhlZWVujwIAABDHM8EEAADgVQQTAACAAcEEAABgQDABAAAYEEwAAAAGBBMAAIABwQQAAGBgezAVFhYqNzdX6enpat++vcaMGaNt27bZvQwAAIBjbA+mdevWKRgMasOGDVq9erUOHjyokSNHqqamxu6lAAAAHJFi9yd88803466/+OKLat++vTZt2qRLLrnE7uUAAACSLumvYYpEIpKktm3bJnspAACApLD9CNPhLMvSjBkzNGTIEPXp06fRbaLRqKLRaMP1ysrKZI4EAACQsKQeYbrzzjv197//XaWlpUfdprCwUJmZmQ2Xrl27JnMkAACAhCUtmKZMmaLly5dr7dq16tKly1G3y8/PVyQSabjs3r07WSMBAAAcF9ufkrMsS1OmTNFrr72mt99+Wzk5OT+5vd/vl9/vt3sMAAAA29geTMFgUIsXL9brr7+u9PR0VVRUSJIyMzPVunVru5cDAABIOtufkps/f74ikYiGDh2qTp06NVyWLFli91IAAACOSMpTcgAAACcTziUHAABgQDABAAAYEEwAAAAGBBMAAIABwQQAAGBAMAEAABgQTAAAAAaeCaZQKKRAIKDc3Fy3RwEAAIjjmWAKBoMKh8MqKytzexQAAIA4ngkmAAAAryKYAAAADAgmAAAAA4IJAADAgGACAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwMAzwRQKhRQIBJSbm+v2KAAAAHE8E0zBYFDhcFhlZWVujwIAABDHM8EEAADgVQQTAACAAcEEAABgQDABAAAYEEwAAAAGBBMAAIABwQQAAGBAMAEAABgQTAAAAAYEEwAAgAHBBAAAYEAwAQAAGHgmmEKhkAKBgHJzc90eBQAAII5ngikYDCocDqusrMztUQAAAOJ4JpgAAAC8imACAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADAgmAAAAAwIJgAAAAOCCQAAwIBgAgAAMCCYAAAADFKcWsiyLFVVVR1xezQaVTQabbh+aJvKykqnRjsmtbVSfb3k9Fi1tbGLk+sePOjsmoe+LWpqnFuztjZ2P51ar6Ym9mdVlXNrWpZ04IBz6/3wg1RX5/xj5GRy6Pukutq5r2N9vRSNOrfegQPO/iw99M/L9987t+b338cef04+Fpz+uh6+rtP39VjU1yf28y89PV0+n+8nt/FZlmXZMJtRZWWlMjMznVgKAADgmEUiEWVkZPzkNo4F07EeYdqzZ48GDhyocDiszp07J32u3NxclZWVGbcbO1Zq2VIqLU3+Woe7/vpYJb/6anLXOdyvfy1lZEgvvfTT21VWVqpr167avXu38Rvtp+zeLfXpIy1dKl12WePbNPU+/dhNN0n79kmvv578tSRpzRrp6qulrVulLl2St87hunWT7rpLmjTJnv1kMmOGtHDhP7V3b6+krXG4ZH/9nF4n9ngaI+ktbdgg9Uril/Hw+3TeedK110oPPJD8tSTp8cel556TPv44uescEo1K7dtLzz4rjRvX9HWO5efeM89I990nff1109ZK5Hvvv/9b+sMfpH//O/lrHa64WCoslL74IrnrJKpbt3rt21eg3bvvPqafe8dyhMmxp+R8Pl9CP6zT09OT+sP9kJYtWx7TOqecEgumpox0rGv9eN26usTWPZ51DpeSElv3WD9FRkZGk9ZLT4/9mZZ29DWbep9+7JRTYvezsU9p91pS7L5Jsft66FMnY53D+XxSaur/rdfU/WTSqpXk853qyONWSv7Xz+l1YlIkZejUU5v2s8bk8PvUooXk9ydvvR9//VJTY2vavd7R9tOh/4+3bm3vmj/1eGrdOvb4a+p6iXzvNfXrerzf56mpid1Xpx5PPl+9JL+tP/ea/Yu+g8HgSbeWk/fJKeynE0O7du0cW4v9dPx4PJ0Y2E/eQjDxDXlCYD+dGNq1a+/YWuyn48fj6cTAfvIWzwWT3++P+xPe5ff79eCDD7KvPI79dGLw+/2aNOlWt8eAAY+nE4PP59Nllw23dT8RTDhufr9fBQUF7CuPYz+dGPx+v269lWDyOh5PJwqfRowYcXIHEwAAgNcQTAAAAAYEEwAAgAHBhKN66qmnlJOTo9TUVPXv31/vvPPOUbddunSpRowYoXbt2ikjI0MXX3yxVq5c6eC0zVci++lw7733nlJSUtSvX78kTwgp8f0UjUY1e/ZsnXXWWfL7/TrnnHNUUlLi0LTNW6L7atGiRerbt6/atGmjTp06aeHChZIceU9o/Mj69euVl5en7777TrNmzdSyZcts+9wEExq1e/cuTZs2TbNnz9aWLVv0i1/8QqNGjdKuXbsa3X79+vUaMWKEVqxYoU2bNmnYsGHKy8vTli1bHJ68eVmyZElC++mQSCSiCRMm6LKjvbU6bHU8+2ns2LFas2aNXnjhBW3btk2lpaXq2bOng1M3T4nuq3fffVcTJkzQpEmTtHXrVr3yyiv67LPPVFtb6/DkkKSamhr17dtXp56aZvvnJpjQqO3bt2vSpEm69dZb1atXLxUVFalr166aP39+o9sXFRXp3nvvVW5urrp37665c+eqe/fu+vOf/+zw5M3LvHnzEtpPh0yePFnjx4/XxRdf7NCkzVui++ndd9/VunXrtGLFCg0fPlzdunXTwIEDNWjQIIcnb34S3VcbNmxQt27dNHXqVOXk5GjIkCEaMmSI6uvrHZ4ckjRq1CjNmTNHrVrZ/1uMngmmUCikQCCg3Nxct0dp9urr67Vv3z6NHDky7vaRI0fq/fffP+bPUVVVpbZt2yZjREj64YcftGnTpoT304svvqhPPvlEDz74YLJHhI5vP61du1YDBgzQ448/rs6dO6tHjx66++679f333zsxcrN1PPtq0KBB+vzzz7VixQpZlqWvvvpKW7ZsUcuWLZ0YGQ5y7FxyJsFgUMFgUJWVlcrMzHR7nGattvYHWZalDh06xN3eoUMHVVRUHNPneOKJJ1RTU6OxY8cmY0RI+uabb1RXV5fQfvr44481a9YsvfPOO0pJ8czD/6R2PPvp888/18aN7yo1NVWvvfaavvnmG91xxx367rvveB1TEh3Pvho0aJAWLVqkcePG6cCBAzp48KDOO+9pHl8nIc8cYYL3/PjMzZZlGc/mLEmlpaUqKCjQkiVL1L69c6fKaK6OdT/V1dVp/Pjxeuihh9SjRw+nxsP/l8jjqb6+Xj6fT4sWLdLAgQN1+eWXa968eVqwYAFHmRyQyL4Kh8OaOnWqHnjgAW3atElvvvmmvvnmWx08eNCJUeEgEhhHOOWUVvL5fEf8j2rv3r1H/M/rx5YsWaJJkybplVde0fDhw5M5ZrN3xhlnqGXLlkfdT19/Hb99VVWVNm7cqC1btujOO++UFPuH2bIspaSkaNWqVbr00kudGr/ZMO2nxrRr106dO3eOO9req1cvWZalzz//XN27d0/qzM3V8eyrwsJCDR48WPfcc48k6fzzz9e4ceeqqKhOe/Z8o06dOiV9bjiDI0w4QosWLXT66adr9erVcbevXr36J190WlpaqptuukmLFy/W6NGjkz1ms9eqVSv179//mPdTRkaGPvroI5WXlzdcbr/9dv3sZz9TeXm5LrroIqdGb1YS3U+SdMEFF+jLL79UdXV1w23bt29XixYt1KVLl6TO25wdz77av3+/WrSI/6f00HXL4q0FTiYEExrVo0cPPf/88yopKdE///lPTZ8+Xbt27dLtt98uScrPz9eECRMati8tLdWECRP0xBNP6Oc//7kqKipUUVGhSCTi1l1oFmbMmPGT++nNN//asJ9atGihPn36xF3at2+v1NRU9enTR2lp9v8aLmJM++nHj6fRo0crKytLN998s8LhsNavX6977rlHt9xyi1q3bu3W3WgWEt1XeXl5Wrp0qebPn69PP/1U7733nv70p1fk8/mUnZ3t1t1otqqrq1VeXq66uthTojt37lR5ebnxrVaOBU/JoVFdu56pG28s0sMPP6w9e/aoT58+WrFihc466yxJ0p49e+K+AZ955hkdPHiw4cX7h0ycOFELFixwevxmY9y4cfr222+Pup8qK6ts+UGBpjHtpx8/ntq0aaPVq1drypQpGjBggLKysjR27FjNmTPHrbvQbCS6r2666SZVVVWpuLhYv/3tb3Xaaaepc+dCffVVK7fuQrO2ceNGDRs2TFLsNQkzZsyQZNO/RZbHRCIRS5IViUTcHiXOFVdY1lVXOb/ur39tWaNGObvmyJGWde21zq332WeWJVnWypXOrTl2rGUNH+7ceitXxu7jrl3Ordm2rWX97nfOrfef/2lZF17o3Honow8+iH2f/OMfzq3ZrZtl/dd/ObfeI49YVseOzq134EDsa/o//+Pcmk8+aVl+v3PrWVbssZ6V5eyalmVZTzxhWenpzq9rkpVl/88/npIDAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADAgmAAAAAw8E0yhUEiBQEC5ublujwIAABDHM8EUDAYVDodVVlbm9igAAABxPBNMAAAAXkUwAQAAGBBMAAAABgQTAACAAcEEAABg4LMsy3J7iMNVVlYqMzNTkUhEGRkZbo8DAADgvWCyLEtVVVVKT0+Xz+dzexwAAADvBRMAAKEVsRgAAAAxSURBVIDX8BomAAAAA4IJAADAgGACAAAwIJgAAAAMCCYAAAADggkAAMCAYAIAADD4fyzd3AknpAcyAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 1 graphics primitive"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def heat_fdm(u0j, u1j, ui0):\n",
+    "    m, n = len(u0j)-1, len(ui0)-1\n",
+    "    k, h = 1/m, 1/n\n",
+    "    \n",
+    "    u = [[0] * (m+1) for i in range(n+1)]\n",
+    "    for j in range(m+1):\n",
+    "        u[0][j] = u0j[j]\n",
+    "    for j in range(m+1):\n",
+    "        u[n][j] = u1j[j]\n",
+    "    for i in range(n+1):\n",
+    "        u[i][0] = ui0[i]\n",
+    "        \n",
+    "    for j in range(0,m):\n",
+    "        for i in range(1,n):\n",
+    "            u[i][j+1] = (k/(h*h)) * (u[i+1][j] - 2*u[i][j] + u[i-1][j]) + u[i][j]\n",
+    "    \n",
+    "    return u\n",
+    "\n",
+    "n, m = 20, 20\n",
+    "u0j = [10 - (j/m)*10 for j in range(m+1)] # One extreme goes from hot to cold\n",
+    "u1j = [(j/m)*10 for j in range(m+1)] # The other does the opposite\n",
+    "ui0 = [10 - (i/m)*10 for i in range(0,n+1)]\n",
+    "\n",
+    "u = heat_fdm(u0j, u1j, ui0)\n",
+    "for t in range(m+1):\n",
+    "    show(line([(i/n, u[i][t]) for i in range(n+1)], ymin=-1, ymax =12))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 9.0",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "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.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture7/slides/.ipynb_checkpoints/X1-ComputationalComplexity-checkpoint.ipynb b/src/Lecture7/slides/.ipynb_checkpoints/X1-ComputationalComplexity-checkpoint.ipynb
new file mode 100644
index 0000000..ab7dd49
--- /dev/null
+++ b/src/Lecture7/slides/.ipynb_checkpoints/X1-ComputationalComplexity-checkpoint.ipynb
@@ -0,0 +1,394 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Nested loops\n",
+    "\n",
+    "The following two functions compute sum and product of matrices, respectively.\n",
+    "\n",
+    "By counting the nested loops it is easy to see that `add()` is $O(n^2)$ while `prod()` is $O(n^3)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time for add:  0.00012074300000008975\n",
+      "Time for prod: 0.00036587199999971176\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def add(A, B):\n",
+    "    S = [[0] * len(A) for i in range(len(A))]\n",
+    "    for i in range(len(A)):\n",
+    "        for j in range(len(A)):\n",
+    "            S[i][j] = A[i][j] + B[i][j]\n",
+    "    return S\n",
+    "\n",
+    "def prod(A, B):\n",
+    "    S = [[0] * len(A) for i in range(len(A))]\n",
+    "    for i in range(len(A)):\n",
+    "        for j in range(len(A)):\n",
+    "            for k in range(len(A)):\n",
+    "                S[i][j] = S[i][j] + A[i][k] * B[k][j]\n",
+    "    return S\n",
+    "\n",
+    "N = 10\n",
+    "A = [ [randint(0,100) for i in range(N)] for j in range(N) ]\n",
+    "B = [ [randint(0,100) for i in range(N)] for j in range(N) ]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "add(A,B)\n",
+    "t1 = time.process_time()\n",
+    "prod(A,B)\n",
+    "t2 = time.process_time()\n",
+    "\n",
+    "print(\"Time for add: \", t1-t0)\n",
+    "print(\"Time for prod:\", t2-t1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sorting a list, slow version\n",
+    "\n",
+    "The following code implements a slow version of the so-called *insertion sort* alogithm\n",
+    "\n",
+    "Complexity: $O(n^2)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running time: 1.1012288430000012\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def correct_position(e, S):\n",
+    "    for i in range(len(S)):\n",
+    "        if S[i] > e:\n",
+    "            return i\n",
+    "    return len(S)\n",
+    "\n",
+    "def sort_list(L):\n",
+    "    S = []\n",
+    "    for e in L:\n",
+    "        cp = correct_position(e, S)\n",
+    "        S.insert(cp, e)\n",
+    "    return S\n",
+    "\n",
+    "N = 10000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "sort_list(L)\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Binary search\n",
+    "\n",
+    "The following code implements a binary search.\n",
+    "\n",
+    "Complexity: $O(\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The correct position of e = 658230309 in L is:\n",
+      "... 658211821 658224379 e 658234625 658246765 ...\n",
+      "\n",
+      "Time for sorting:   0.021211020999999164\n",
+      "Time for searching: 7.820199999741817e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def binary_search(e, S, start, end):\n",
+    "    if start == end:\n",
+    "        return start\n",
+    "    midpoint = (start+end) // 2\n",
+    "    if e < S[midpoint]:\n",
+    "        return binary_search(e, S, start, midpoint)\n",
+    "    else:\n",
+    "        return binary_search(e, S, midpoint+1, end)\n",
+    "    \n",
+    "N = 100000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "e = randint(0,10**9)\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "L.sort() # Using Python's sort()\n",
+    "t1 = time.process_time()\n",
+    "i = binary_search(e, L, 0, len(L))\n",
+    "t2 = time.process_time()\n",
+    "print(\"The correct position of e =\", e, \"in L is:\")\n",
+    "print(\"...\", L[i-2], L[i-1], \"e\", L[i], L[i+1], \"...\")\n",
+    "print(\"\")\n",
+    "print(\"Time for sorting:  \", t1-t0)\n",
+    "print(\"Time for searching:\", t2-t1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sorting a list, fast version (with binary_search)\n",
+    "\n",
+    "The following code uses the function `binary_search()` above instead of `correct_position()` in our insertion sort algorithm.\n",
+    "\n",
+    "Complexity: $O(n\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running time: 0.03710268399998995\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def binary_search(e, S, start, end):\n",
+    "    if start == end:\n",
+    "        return start\n",
+    "    midpoint = (start+end) // 2\n",
+    "    if e < S[midpoint]:\n",
+    "        return binary_search(e, S, start, midpoint)\n",
+    "    else:\n",
+    "        return binary_search(e, S, midpoint+1, end)\n",
+    "    \n",
+    "def sort_list(L):\n",
+    "    S = []\n",
+    "    for e in L:\n",
+    "        cp = binary_search(e, S, 0, len(S)) # Changed here\n",
+    "        S.insert(cp, e)\n",
+    "    return S\n",
+    "    \n",
+    "N = 10000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "sort_list(L)\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast exponentiation\n",
+    "\n",
+    "The following cell contains two functions for computing $a^n$ ($n$ non-negative integer): a slow one that runs in $O(n)$ and a fast one that runs in $O(\\log_2(n))$. We compare these two also with Python's built-in operator `**`.\n",
+    "\n",
+    "Complexity: $O(n)$ for the slow algorithm, $O(\\log_2(n))$ for the other two."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.71828179834636\n",
+      "2.7182817863957984\n",
+      "2.7182817983473577\n",
+      "Time for slow_power(): 3.234879998000004\n",
+      "Time for fast_power(): 9.059099999575437e-05\n",
+      "Time for Python's **:  0.00010159500000384014\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def slow_power(a, n):\n",
+    "    r = 1\n",
+    "    for i in range(n):\n",
+    "        r = r * a\n",
+    "    return r\n",
+    "\n",
+    "def fast_power(a, n):\n",
+    "    if n == 0:\n",
+    "        return 1\n",
+    "    if n%2 == 0:\n",
+    "        return fast_power(a*a, n//2)\n",
+    "    else:\n",
+    "        return a * fast_power(a, n-1)\n",
+    "\n",
+    "a = 1.00000001\n",
+    "n = 100000000\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(slow_power(a, n))\n",
+    "t1 = time.process_time()\n",
+    "print(fast_power(a, n))\n",
+    "t2 = time.process_time()\n",
+    "print(a**n)\n",
+    "t3 = time.process_time()\n",
+    "\n",
+    "print(\"Time for slow_power():\", t1-t0)\n",
+    "print(\"Time for fast_power():\", t2-t1)\n",
+    "print(\"Time for Python's **: \", t3-t2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast gcd\n",
+    "\n",
+    "Complexity: $O(\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126\n",
+      "Running time: 0.00017707599999994272\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def gcd(a, b):\n",
+    "    if b == 0:\n",
+    "        return a\n",
+    "    else:\n",
+    "        return gcd(b, a%b)\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(gcd(155275387236018, 572335397352432))\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fibonacci numbers\n",
+    "\n",
+    "In the following cell there are two functions that compute the $n$-th Fibonacci number. They are almost the same, but the second one memorizes the results in a list to avoid computing them multiple times, and it is much much faster.\n",
+    "\n",
+    "Complexity: $O\\left(\\left(\\frac{1+\\sqrt 5}{2}\\right)^n\\right)\\sim O(1.6^n)$ for the slow version, $O(n)$ for the fast version."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "F_memorized = [-1] * (10**6)\n",
+    "\n",
+    "def F_slow(n):\n",
+    "    if n <= 1:\n",
+    "        return n\n",
+    "    else:\n",
+    "        return F_slow(n-1) + F_slow(n-2)\n",
+    "    \n",
+    "def F_fast(n):\n",
+    "    if F_memorized[n] == -1:\n",
+    "        if n <= 1:\n",
+    "            F_memorized[n] = n\n",
+    "        else:\n",
+    "            F_memorized[n] = F_fast(n-1) + F_fast(n-2)\n",
+    "    \n",
+    "    return F_memorized[n]\n",
+    "\n",
+    "n = 40\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(F_slow(n))\n",
+    "t1 = time.process_time()\n",
+    "print(F_fast(n))\n",
+    "t2 = time.process_time()\n",
+    "\n",
+    "print(\"Time for F_slow:\", t1-t0)\n",
+    "print(\"Time for F_fast:\", t2-t1)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture7/slides/.ipynb_checkpoints/X1-ComputationalComplexity-notebook-checkpoint.ipynb b/src/Lecture7/slides/.ipynb_checkpoints/X1-ComputationalComplexity-notebook-checkpoint.ipynb
new file mode 100644
index 0000000..16a6d40
--- /dev/null
+++ b/src/Lecture7/slides/.ipynb_checkpoints/X1-ComputationalComplexity-notebook-checkpoint.ipynb
@@ -0,0 +1,412 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Nested loops\n",
+    "\n",
+    "The following two functions compute sum and product of matrices, respectively.\n",
+    "\n",
+    "By counting the nested loops it is easy to see that `add()` is $O(n^2)$ while `prod()` is $O(n^3)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time for add:  0.005766554000000035\n",
+      "Time for prod: 1.3871021639999999\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def add(A, B):\n",
+    "    S = [[0] * len(A) for i in range(len(A))]\n",
+    "    for i in range(len(A)):\n",
+    "        for j in range(len(A)):\n",
+    "            S[i][j] = A[i][j] + B[i][j]\n",
+    "    return S\n",
+    "\n",
+    "def prod(A, B):\n",
+    "    S = [[0] * len(A) for i in range(len(A))]\n",
+    "    for i in range(len(A)):\n",
+    "        for j in range(len(A)):\n",
+    "            for k in range(len(A)):\n",
+    "                S[i][j] = S[i][j] + A[i][k] * B[k][j]\n",
+    "    return S\n",
+    "\n",
+    "N = 200\n",
+    "A = [ [randint(0,100) for i in range(N)] for j in range(N) ]\n",
+    "B = [ [randint(0,100) for i in range(N)] for j in range(N) ]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "add(A,B)\n",
+    "t1 = time.process_time()\n",
+    "prod(A,B)\n",
+    "t2 = time.process_time()\n",
+    "\n",
+    "print(\"Time for add: \", t1-t0)\n",
+    "print(\"Time for prod:\", t2-t1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sorting a list, slow version\n",
+    "\n",
+    "The following code implements a slow version of the so-called *insertion sort* alogithm\n",
+    "\n",
+    "Complexity: $O(n^2)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running time: 1.1191449070000001\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def correct_position(e, S):\n",
+    "    for i in range(len(S)):\n",
+    "        if S[i] > e:\n",
+    "            return i\n",
+    "    return len(S)\n",
+    "\n",
+    "def sort_list(L):\n",
+    "    S = []\n",
+    "    for e in L:\n",
+    "        cp = correct_position(e, S)\n",
+    "        S.insert(cp, e)\n",
+    "    return S\n",
+    "\n",
+    "N = 10000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "sort_list(L)\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Binary search\n",
+    "\n",
+    "The following code implements a binary search.\n",
+    "\n",
+    "Complexity: $O(\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The correct position of e = 216197744 in L is:\n",
+      "... 216196218 216197540 e 216198673 216198962 ...\n",
+      "\n",
+      "Time for sorting:   0.26413054400000036\n",
+      "Time for searching: 9.616099999965044e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def binary_search(e, S, start, end):\n",
+    "    if start == end:\n",
+    "        return start\n",
+    "    midpoint = (start+end) // 2\n",
+    "    if e < S[midpoint]:\n",
+    "        return binary_search(e, S, start, midpoint)\n",
+    "    else:\n",
+    "        return binary_search(e, S, midpoint+1, end)\n",
+    "    \n",
+    "N = 1000000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "e = randint(0,10**9)\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "L.sort() # Using Python's sort()\n",
+    "t1 = time.process_time()\n",
+    "i = binary_search(e, L, 0, len(L))\n",
+    "t2 = time.process_time()\n",
+    "print(\"The correct position of e =\", e, \"in L is:\")\n",
+    "print(\"...\", L[i-2], L[i-1], \"e\", L[i], L[i+1], \"...\")\n",
+    "print(\"\")\n",
+    "print(\"Time for sorting:  \", t1-t0)\n",
+    "print(\"Time for searching:\", t2-t1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sorting a list, fast version (with binary_search)\n",
+    "\n",
+    "The following code uses the function `binary_search()` above instead of `correct_position()` in our insertion sort algorithm.\n",
+    "\n",
+    "Complexity: $O(n\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running time: 0.03710268399998995\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "import time\n",
+    "\n",
+    "def binary_search(e, S, start, end):\n",
+    "    if start == end:\n",
+    "        return start\n",
+    "    midpoint = (start+end) // 2\n",
+    "    if e < S[midpoint]:\n",
+    "        return binary_search(e, S, start, midpoint)\n",
+    "    else:\n",
+    "        return binary_search(e, S, midpoint+1, end)\n",
+    "    \n",
+    "def sort_list(L):\n",
+    "    S = []\n",
+    "    for e in L:\n",
+    "        cp = binary_search(e, S, 0, len(S)) # Changed here\n",
+    "        S.insert(cp, e)\n",
+    "    return S\n",
+    "    \n",
+    "N = 10000\n",
+    "L = [randint(0,10**9) for i in range(N)]\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "sort_list(L)\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast exponentiation\n",
+    "\n",
+    "The following cell contains two functions for computing $a^n$ ($n$ non-negative integer): a slow one that runs in $O(n)$ and a fast one that runs in $O(\\log_2(n))$. We compare these two also with Python's built-in operator `**`.\n",
+    "\n",
+    "Complexity: $O(n)$ for the slow algorithm, $O(\\log_2(n))$ for the other two."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.71828179834636\n",
+      "2.7182817863957984\n",
+      "2.7182817983473577\n",
+      "Time for slow_power(): 3.234879998000004\n",
+      "Time for fast_power(): 9.059099999575437e-05\n",
+      "Time for Python's **:  0.00010159500000384014\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def slow_power(a, n):\n",
+    "    r = 1\n",
+    "    for i in range(n):\n",
+    "        r = r * a\n",
+    "    return r\n",
+    "\n",
+    "def fast_power(a, n):\n",
+    "    if n == 0:\n",
+    "        return 1\n",
+    "    if n%2 == 0:\n",
+    "        return fast_power(a*a, n//2)\n",
+    "    else:\n",
+    "        return a * fast_power(a, n-1)\n",
+    "\n",
+    "a = 1.00000001\n",
+    "n = 100000000\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(slow_power(a, n))\n",
+    "t1 = time.process_time()\n",
+    "print(fast_power(a, n))\n",
+    "t2 = time.process_time()\n",
+    "print(a**n)\n",
+    "t3 = time.process_time()\n",
+    "\n",
+    "print(\"Time for slow_power():\", t1-t0)\n",
+    "print(\"Time for fast_power():\", t2-t1)\n",
+    "print(\"Time for Python's **: \", t3-t2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast gcd\n",
+    "\n",
+    "Complexity: $O(\\log_2(n))$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "126\n",
+      "Running time: 0.00017707599999994272\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def gcd(a, b):\n",
+    "    if b == 0:\n",
+    "        return a\n",
+    "    else:\n",
+    "        return gcd(b, a%b)\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(gcd(155275387236018, 572335397352432))\n",
+    "t1 = time.process_time()\n",
+    "\n",
+    "print(\"Running time:\", t1-t0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fibonacci numbers\n",
+    "\n",
+    "In the following cell there are two functions that compute the $n$-th Fibonacci number. They are almost the same, but the second one memorizes the results in a list to avoid computing them multiple times, and it is much much faster.\n",
+    "\n",
+    "Complexity: $O\\left(\\left(\\frac{1+\\sqrt 5}{2}\\right)^n\\right)\\sim O(1.6^n)$ for the slow version, $O(n)$ for the fast version."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9227465\n",
+      "9227465\n",
+      "Time for F_slow: 2.3301570169999906\n",
+      "Time for F_fast: 8.848800000293977e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "F_memorized = [-1] * (10**6)\n",
+    "\n",
+    "def F_slow(n):\n",
+    "    if n <= 1:\n",
+    "        return n\n",
+    "    else:\n",
+    "        return F_slow(n-1) + F_slow(n-2)\n",
+    "    \n",
+    "def F_fast(n):\n",
+    "    if F_memorized[n] == -1:\n",
+    "        if n <= 1:\n",
+    "            F_memorized[n] = n\n",
+    "        else:\n",
+    "            F_memorized[n] = F_fast(n-1) + F_fast(n-2)\n",
+    "    \n",
+    "    return F_memorized[n]\n",
+    "\n",
+    "n = 35\n",
+    "\n",
+    "t0 = time.process_time()\n",
+    "print(F_slow(n))\n",
+    "t1 = time.process_time()\n",
+    "print(F_fast(n))\n",
+    "t2 = time.process_time()\n",
+    "\n",
+    "print(\"Time for F_slow:\", t1-t0)\n",
+    "print(\"Time for F_fast:\", t2-t1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture7/slides/.ipynb_checkpoints/X2-StudentsRequests-checkpoint.ipynb b/src/Lecture7/slides/.ipynb_checkpoints/X2-StudentsRequests-checkpoint.ipynb
new file mode 100644
index 0000000..a35bb8d
--- /dev/null
+++ b/src/Lecture7/slides/.ipynb_checkpoints/X2-StudentsRequests-checkpoint.ipynb
@@ -0,0 +1,165 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Diffie-Hellman key exchange\n",
+    "\n",
+    "The following is a simple implementation of the classic [Diffie-Hellman key exchange](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange) cryptographic protocol."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Public key: p = 20747 and g = 13428 \n",
+      "\n",
+      "[[ Alice's secret key: a = 12403 ]]\n",
+      "[[ Bob's secret key: b = 17642 ]] \n",
+      "\n",
+      "Alice sends h1 = 14710 to Bob\n",
+      "Bob sends h2 = 10680 to Alice \n",
+      "\n",
+      "Alice computed 10455 using h2 and her secret a\n",
+      "Bob computed 10455 using h1 and his secret b\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Public information:\n",
+    "p = Primes()[10^3 + randint(1,10000)] # random prime\n",
+    "g = randint(2, p-1) # random integer\n",
+    "\n",
+    "print(\"Public key: p =\", p, \"and g =\", g, \"\\n\")\n",
+    "\n",
+    "a = randint(2, p-1) # Only Alice knows this\n",
+    "b = randint(2, p-1) # Only Bob knows this\n",
+    "\n",
+    "print(\"[[ Alice's secret key: a =\", a, \"]]\")\n",
+    "print(\"[[ Bob's secret key: b =\", b, \"]]\", \"\\n\")\n",
+    "\n",
+    "h1 = (g^a) % p # Alice sends this to Bob\n",
+    "h2 = (g^b) % p # Bob sends this to Alice\n",
+    "\n",
+    "print(\"Alice sends h1 =\", h1, \"to Bob\")\n",
+    "print(\"Bob sends h2 =\", h2, \"to Alice\", \"\\n\")\n",
+    "\n",
+    "secret_a = (h2^a) % p # Alice can compute this because she knows a\n",
+    "secret_b = (h1^b) % p # Bob can compute this because he knows b\n",
+    "\n",
+    "print(\"Alice computed\", secret_a, \"using h2 and her secret a\")\n",
+    "print(\"Bob computed\", secret_b, \"using h1 and his secret b\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## General Diffie-Hellman\n",
+    "\n",
+    "The following code is an implementation of a generic Diffie-Hellman key exchange protocol that uses a group $G$ instead of $(\\mathbb Z/p \\mathbb Z)^\\times$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Public key:\n",
+      "G = Additive abelian group isomorphic to Z/171 embedded in Abelian group of points on Elliptic Curve defined by y^2 = x^3 + x + 156 over Finite Field of size 157 \n",
+      "g = (155 : 60 : 1) \n",
+      "\n",
+      "[[ Alice's secret key: a = 141 ]]\n",
+      "[[ Bob's secret key: b = 158 ]] \n",
+      "\n",
+      "Alice sends h1 = (29 : 125 : 1) to Bob\n",
+      "Bob sends h2 = (60 : 59 : 1) to Alice \n",
+      "\n",
+      "Alice computed (109 : 94 : 1) using h2 and her secret a\n",
+      "Bob computed (109 : 94 : 1) using h1 and his secret b\n"
+     ]
+    }
+   ],
+   "source": [
+    "def genericDH(G):\n",
+    "    if G.cardinality() == 1:\n",
+    "        print(\"Group is trivial, can't do anything\")\n",
+    "        return\n",
+    "    g = G.random_element()\n",
+    "    while g == G.identity(): # Make sure g is not trivial\n",
+    "        g = G.random_element()\n",
+    "        \n",
+    "    print(\"Public key:\\nG =\", G, \"\\ng =\", g, \"\\n\")\n",
+    "    \n",
+    "    a = randint(2, G.exponent()-1) # Only Alice knows this\n",
+    "    b = randint(2, G.exponent()-1) # Only Bob knows this\n",
+    "\n",
+    "    print(\"[[ Alice's secret key: a =\", a, \"]]\")\n",
+    "    print(\"[[ Bob's secret key: b =\", b, \"]]\", \"\\n\")\n",
+    "    \n",
+    "    # \"Ternary operator\", I did not explain this\n",
+    "    # https://docs.python.org/3/reference/expressions.html#conditional-expressions\n",
+    "    h1 = g^a if G.is_multiplicative() else a*g # Alice sends this to Bob\n",
+    "    h2 = g^b if G.is_multiplicative() else b*g # Bob sends this to Alice\n",
+    "\n",
+    "    print(\"Alice sends h1 =\", h1, \"to Bob\")\n",
+    "    print(\"Bob sends h2 =\", h2, \"to Alice\", \"\\n\")\n",
+    "    \n",
+    "    secret_a = h2^a if G.is_multiplicative() else a*h2 # Alice can compute this because she knows a\n",
+    "    secret_b = h1^b if G.is_multiplicative() else b*h1 # Bob can compute this because he knows b\n",
+    "\n",
+    "    print(\"Alice computed\", secret_a, \"using h2 and her secret a\")\n",
+    "    print(\"Bob computed\", secret_b, \"using h1 and his secret b\")\n",
+    "    \n",
+    "E = EllipticCurve(GF(157), [1,-1])\n",
+    "G = E.abelian_group()\n",
+    "genericDH(G)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Numerical methods for PDEs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 9.0",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "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.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture7/slides/.ipynb_checkpoints/X2-StudentsRequests-notebook-checkpoint.ipynb b/src/Lecture7/slides/.ipynb_checkpoints/X2-StudentsRequests-notebook-checkpoint.ipynb
new file mode 100644
index 0000000..ccd6a21
--- /dev/null
+++ b/src/Lecture7/slides/.ipynb_checkpoints/X2-StudentsRequests-notebook-checkpoint.ipynb
@@ -0,0 +1,298 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Diffie-Hellman key exchange\n",
+    "\n",
+    "The following is a simple implementation of the classic [Diffie-Hellman key exchange](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange) cryptographic protocol."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Public key: p = 75521 and g = 58258 \n",
+      "\n",
+      "[[ Alice's secret key: a = 22794 ]]\n",
+      "[[ Bob's secret key: b = 69773 ]] \n",
+      "\n",
+      "Alice sends h1 = 31067 to Bob\n",
+      "Bob sends h2 = 54398 to Alice \n",
+      "\n",
+      "Alice computed 30031 using h2 and her secret a\n",
+      "Bob computed 30031 using h1 and his secret b\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Public information:\n",
+    "p = Primes()[10^3 + randint(1,10000)] # random prime\n",
+    "g = randint(2, p-1) # random integer\n",
+    "\n",
+    "print(\"Public key: p =\", p, \"and g =\", g, \"\\n\")\n",
+    "\n",
+    "a = randint(2, p-1) # Only Alice knows this\n",
+    "b = randint(2, p-1) # Only Bob knows this\n",
+    "\n",
+    "print(\"[[ Alice's secret key: a =\", a, \"]]\")\n",
+    "print(\"[[ Bob's secret key: b =\", b, \"]]\", \"\\n\")\n",
+    "\n",
+    "h1 = (g^a) % p # Alice sends this to Bob\n",
+    "h2 = (g^b) % p # Bob sends this to Alice\n",
+    "\n",
+    "print(\"Alice sends h1 =\", h1, \"to Bob\")\n",
+    "print(\"Bob sends h2 =\", h2, \"to Alice\", \"\\n\")\n",
+    "\n",
+    "secret_a = (h2^a) % p # Alice can compute this because she knows a\n",
+    "secret_b = (h1^b) % p # Bob can compute this because he knows b\n",
+    "\n",
+    "print(\"Alice computed\", secret_a, \"using h2 and her secret a\")\n",
+    "print(\"Bob computed\", secret_b, \"using h1 and his secret b\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## General Diffie-Hellman\n",
+    "\n",
+    "The following code is an implementation of a generic Diffie-Hellman key exchange protocol that uses a group $G$ instead of $(\\mathbb Z/p \\mathbb Z)^\\times$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Public key:\n",
+      "G = Additive abelian group isomorphic to Z/171 embedded in Abelian group of points on Elliptic Curve defined by y^2 = x^3 + x + 156 over Finite Field of size 157 \n",
+      "g = (53 : 90 : 1) \n",
+      "\n",
+      "[[ Alice's secret key: a = 145 ]]\n",
+      "[[ Bob's secret key: b = 65 ]] \n",
+      "\n",
+      "Alice sends h1 = (150 : 80 : 1) to Bob\n",
+      "Bob sends h2 = (4 : 58 : 1) to Alice \n",
+      "\n",
+      "Alice computed (28 : 28 : 1) using h2 and her secret a\n",
+      "Bob computed (28 : 28 : 1) using h1 and his secret b\n"
+     ]
+    }
+   ],
+   "source": [
+    "def genericDH(G):\n",
+    "    if G.cardinality() == 1:\n",
+    "        print(\"Group is trivial, can't do anything\")\n",
+    "        return\n",
+    "    g = G.random_element()\n",
+    "    while g == G.identity(): # Make sure g is not trivial\n",
+    "        g = G.random_element()\n",
+    "        \n",
+    "    print(\"Public key:\\nG =\", G, \"\\ng =\", g, \"\\n\")\n",
+    "    \n",
+    "    a = randint(2, G.exponent()-1) # Only Alice knows this\n",
+    "    b = randint(2, G.exponent()-1) # Only Bob knows this\n",
+    "\n",
+    "    print(\"[[ Alice's secret key: a =\", a, \"]]\")\n",
+    "    print(\"[[ Bob's secret key: b =\", b, \"]]\", \"\\n\")\n",
+    "    \n",
+    "    # \"Ternary operator\", I did not explain this\n",
+    "    # https://docs.python.org/3/reference/expressions.html#conditional-expressions\n",
+    "    h1 = g^a if G.is_multiplicative() else a*g # Alice sends this to Bob\n",
+    "    h2 = g^b if G.is_multiplicative() else b*g # Bob sends this to Alice\n",
+    "\n",
+    "    print(\"Alice sends h1 =\", h1, \"to Bob\")\n",
+    "    print(\"Bob sends h2 =\", h2, \"to Alice\", \"\\n\")\n",
+    "    \n",
+    "    secret_a = h2^a if G.is_multiplicative() else a*h2 # Alice can compute this because she knows a\n",
+    "    secret_b = h1^b if G.is_multiplicative() else b*h1 # Bob can compute this because he knows b\n",
+    "\n",
+    "    print(\"Alice computed\", secret_a, \"using h2 and her secret a\")\n",
+    "    print(\"Bob computed\", secret_b, \"using h1 and his secret b\")\n",
+    "    \n",
+    "E = EllipticCurve(GF(157), [1,-1])\n",
+    "G = E.abelian_group()\n",
+    "genericDH(G)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Numerical methods for differential equations\n",
+    "\n",
+    "## Euler's method (ODE)\n",
+    "\n",
+    "In sage you can use [`ode_solver()`](https://doc.sagemath.org/html/en/reference/calculus/sage/calculus/ode.html) to solve any ordinary differential equation by hand, but Euler's method is very simple to implement by hand:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "Graphics object consisting of 2 graphics primitives"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "var('y')\n",
+    "\n",
+    "def euler_desolve(f, x0, y0, x1):\n",
+    "    n = 5\n",
+    "    h = (x1-x0)/n\n",
+    "    S = []\n",
+    "    Y = [y0]\n",
+    "    for i in range(n+1):\n",
+    "        S.append(x0 + i*h)\n",
+    "        Y.append(N(  Y[i] + h*f(S[i], Y[i])  ))\n",
+    "    return S, Y\n",
+    "\n",
+    "f(x,y) = y\n",
+    "x0 = -1\n",
+    "x1 = 2\n",
+    "y0 = e^(-1)\n",
+    "\n",
+    "S, Y = euler_desolve(f, x0, y0, x1)\n",
+    "plot(e^x, -1, 2) + line([(S[i], Y[i]) for i in range(len(S))], color='red', marker='o', markersize=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sage also has an `eulers_method()` function \"for pedagogical purposes only\":"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         x                    y                  h*f(x,y)\n",
+      "        -1    0.367879441171442   0.0367879441171442\n",
+      "-0.900000000000000    0.404667385288587   0.0404667385288587\n",
+      "-0.800000000000000    0.445134123817445   0.0445134123817445\n",
+      "-0.700000000000000    0.489647536199190   0.0489647536199190\n",
+      "-0.600000000000000    0.538612289819109   0.0538612289819109\n",
+      "-0.500000000000000    0.592473518801020   0.0592473518801020\n",
+      "-0.400000000000000    0.651720870681122   0.0651720870681122\n",
+      "-0.300000000000000    0.716892957749234   0.0716892957749234\n",
+      "-0.200000000000000    0.788582253524157   0.0788582253524157\n",
+      "-0.100000000000000    0.867440478876573   0.0867440478876573\n",
+      "-1.38777878078145e-16    0.954184526764230   0.0954184526764230\n",
+      "0.0999999999999999     1.04960297944065    0.104960297944065\n",
+      "0.200000000000000     1.15456327738472    0.115456327738472\n",
+      "0.300000000000000     1.27001960512319    0.127001960512319\n",
+      "0.400000000000000     1.39702156563551    0.139702156563551\n",
+      "0.500000000000000     1.53672372219906    0.153672372219906\n",
+      "0.600000000000000     1.69039609441897    0.169039609441897\n",
+      "0.700000000000000     1.85943570386086    0.185943570386086\n",
+      "0.800000000000000     2.04537927424695    0.204537927424695\n",
+      "0.900000000000000     2.24991720167165    0.224991720167165\n",
+      "1.00000000000000     2.47490892183881    0.247490892183881\n",
+      "1.10000000000000     2.72239981402269    0.272239981402269\n",
+      "1.20000000000000     2.99463979542496    0.299463979542496\n",
+      "1.30000000000000     3.29410377496746    0.329410377496746\n",
+      "1.40000000000000     3.62351415246420    0.362351415246420\n",
+      "1.50000000000000     3.98586556771062    0.398586556771062\n",
+      "1.60000000000000     4.38445212448168    0.438445212448168\n",
+      "1.70000000000000     4.82289733692985    0.482289733692985\n",
+      "1.80000000000000     5.30518707062284    0.530518707062284\n",
+      "1.90000000000000     5.83570577768512    0.583570577768512\n",
+      "2.00000000000000     6.41927635545363    0.641927635545363\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Usage: eulers_method(f, x0, y0, h, x1)\n",
+    "eulers_method(f, -1, N(e^(-1)), 0.1, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solving the heat equation with a finite difference method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def heat_fdm(u0j, u1j, ui0):\n",
+    "    m, n = len(u0j)-1, len(ui0)-1\n",
+    "    k, h = 1/m, 1/n\n",
+    "    \n",
+    "    u = [[0] * (m+1) for i in range(n+1)]\n",
+    "    for j in range(m+1):\n",
+    "        u[0][j] = u0j[j]\n",
+    "    for j in range(m+1):\n",
+    "        u[n][j] = u1j[j]\n",
+    "    for i in range(n+1):\n",
+    "        u[i][0] = ui0[i]\n",
+    "        \n",
+    "    for j in range(0,m):\n",
+    "        for i in range(1,n):\n",
+    "            u[i][j+1] = (k/(h*h)) * (u[i+1][j] - 2*u[i][j] + u[i-1][j]) + u[i][j]\n",
+    "    \n",
+    "    return u\n",
+    "\n",
+    "n, m = 20, 20\n",
+    "u0j = [10 - (j/m)*10 for j in range(m+1)] # One extreme goes from hot to cold\n",
+    "u1j = [(j/m)*10 for j in range(m+1)] # The other does the opposite\n",
+    "ui0 = [10 - (i/m)*10 for i in range(0,n+1)]\n",
+    "\n",
+    "u = heat_fdm(u0j, u1j, ui0)\n",
+    "for t in range(m+1):\n",
+    "    show(line([(i/n, u[i][t]) for i in range(n+1)], ymin=-1, ymax =12))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 9.0",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "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.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.aux b/src/Lecture7/slides/X1-ComputationalComplexity.aux
new file mode 100644
index 0000000..b0463b4
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.aux
@@ -0,0 +1,100 @@
+\relax 
+\providecommand\hyper@newdestlabel[2]{}
+\providecommand\HyperFirstAtBeginDocument{\AtBeginDocument}
+\HyperFirstAtBeginDocument{\ifx\hyper@anchor\@undefined
+\global\let\oldcontentsline\contentsline
+\gdef\contentsline#1#2#3#4{\oldcontentsline{#1}{#2}{#3}}
+\global\let\oldnewlabel\newlabel
+\gdef\newlabel#1#2{\newlabelxx{#1}#2}
+\gdef\newlabelxx#1#2#3#4#5#6{\oldnewlabel{#1}{{#2}{#3}}}
+\AtEndDocument{\ifx\hyper@anchor\@undefined
+\let\contentsline\oldcontentsline
+\let\newlabel\oldnewlabel
+\fi}
+\fi}
+\global\let\hyper@last\relax 
+\gdef\HyperFirstAtBeginDocument#1{#1}
+\providecommand\HyField@AuxAddToFields[1]{}
+\providecommand\HyField@AuxAddToCoFields[2]{}
+\providecommand \oddpage@label [2]{}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{1}{1/1}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {1}{1}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{2}{2/2}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {2}{2}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{3}{3/3}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {3}{3}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{4}{4/4}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {4}{4}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{5}{5/5}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {5}{5}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{6}{6/6}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {6}{6}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{7}{7/7}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {7}{7}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{8}{8/8}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {8}{8}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{9}{9/9}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {9}{9}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{10}{10/10}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {10}{10}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{11}{11/11}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {11}{11}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{12}{12/12}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {12}{12}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{13}{13/13}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {13}{13}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{14}{14/14}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {14}{14}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{15}{15/15}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {15}{15}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{16}{16/16}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {16}{16}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{17}{17/17}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {17}{17}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{18}{18/18}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {18}{18}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{19}{19/19}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {19}{19}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{20}{20/20}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {20}{20}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{21}{21/21}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {21}{21}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{22}{22/22}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {22}{22}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{23}{23/26}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {23}{26}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{24}{27/30}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {27}{30}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{25}{31/31}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {31}{31}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{26}{32/32}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {32}{32}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{27}{33/33}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {33}{33}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{28}{34/34}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {34}{34}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{29}{35/35}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {35}{35}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{30}{36/36}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {36}{36}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{31}{37/37}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {37}{37}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{32}{38/38}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {38}{38}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{33}{39/39}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {39}{39}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{34}{40/40}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {40}{40}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{35}{41/41}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {41}{41}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{36}{42/42}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {42}{42}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{37}{43/43}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {43}{43}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{38}{44/44}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {44}{44}}}
+\@writefile{nav}{\headcommand {\beamer@partpages {1}{44}}}
+\@writefile{nav}{\headcommand {\beamer@subsectionpages {1}{44}}}
+\@writefile{nav}{\headcommand {\beamer@sectionpages {1}{44}}}
+\@writefile{nav}{\headcommand {\beamer@documentpages {44}}}
+\@writefile{nav}{\headcommand {\gdef \inserttotalframenumber {38}}}
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.log b/src/Lecture7/slides/X1-ComputationalComplexity.log
new file mode 100644
index 0000000..03238ae
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.log
@@ -0,0 +1,1513 @@
+This is pdfTeX, Version 3.14159265-2.6-1.40.20 (TeX Live 2019/Debian) (preloaded format=pdflatex 2021.5.20)  25 MAY 2021 16:23
+entering extended mode
+ \write18 enabled.
+ %&-line parsing enabled.
+**X1-ComputationalComplexity.tex
+(./X1-ComputationalComplexity.tex
+LaTeX2e <2020-02-02> patch level 2
+L3 programming layer <2020-02-14>
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamer.cls
+Document Class: beamer 2019/09/29 v3.57 A class for typesetting presentations
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasemodes.sty
+(/usr/share/texlive/texmf-dist/tex/latex/etoolbox/etoolbox.sty
+Package: etoolbox 2019/09/21 v2.5h e-TeX tools for LaTeX (JAW)
+\etb@tempcnta=\count167
+)
+\beamer@tempbox=\box45
+\beamer@tempcount=\count168
+\c@beamerpauses=\count169
+
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasedecode.sty
+\beamer@slideinframe=\count170
+\beamer@minimum=\count171
+\beamer@decode@box=\box46
+)
+\beamer@commentbox=\box47
+\beamer@modecount=\count172
+)
+(/usr/share/texlive/texmf-dist/tex/generic/iftex/ifpdf.sty
+Package: ifpdf 2019/10/25 v3.4 ifpdf legacy package. Use iftex instead.
+
+(/usr/share/texlive/texmf-dist/tex/generic/iftex/iftex.sty
+Package: iftex 2019/11/07 v1.0c TeX engine tests
+))
+\headdp=\dimen134
+\footheight=\dimen135
+\sidebarheight=\dimen136
+\beamer@tempdim=\dimen137
+\beamer@finalheight=\dimen138
+\beamer@animht=\dimen139
+\beamer@animdp=\dimen140
+\beamer@animwd=\dimen141
+\beamer@leftmargin=\dimen142
+\beamer@rightmargin=\dimen143
+\beamer@leftsidebar=\dimen144
+\beamer@rightsidebar=\dimen145
+\beamer@boxsize=\dimen146
+\beamer@vboxoffset=\dimen147
+\beamer@descdefault=\dimen148
+\beamer@descriptionwidth=\dimen149
+\beamer@lastskip=\skip47
+\beamer@areabox=\box48
+\beamer@animcurrent=\box49
+\beamer@animshowbox=\box50
+\beamer@sectionbox=\box51
+\beamer@logobox=\box52
+\beamer@linebox=\box53
+\beamer@sectioncount=\count173
+\beamer@subsubsectionmax=\count174
+\beamer@subsectionmax=\count175
+\beamer@sectionmax=\count176
+\beamer@totalheads=\count177
+\beamer@headcounter=\count178
+\beamer@partstartpage=\count179
+\beamer@sectionstartpage=\count180
+\beamer@subsectionstartpage=\count181
+\beamer@animationtempa=\count182
+\beamer@animationtempb=\count183
+\beamer@xpos=\count184
+\beamer@ypos=\count185
+\beamer@ypos@offset=\count186
+\beamer@showpartnumber=\count187
+\beamer@currentsubsection=\count188
+\beamer@coveringdepth=\count189
+\beamer@sectionadjust=\count190
+\beamer@tocsectionnumber=\count191
+
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseoptions.sty
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/keyval.sty
+Package: keyval 2014/10/28 v1.15 key=value parser (DPC)
+\KV@toks@=\toks14
+))
+\beamer@paperwidth=\skip48
+\beamer@paperheight=\skip49
+
+(/usr/share/texlive/texmf-dist/tex/latex/geometry/geometry.sty
+Package: geometry 2020/01/02 v5.9 Page Geometry
+
+(/usr/share/texlive/texmf-dist/tex/generic/iftex/ifvtex.sty
+Package: ifvtex 2019/10/25 v1.7 ifvtex legacy package. Use iftex instead.
+)
+\Gm@cnth=\count192
+\Gm@cntv=\count193
+\c@Gm@tempcnt=\count194
+\Gm@bindingoffset=\dimen150
+\Gm@wd@mp=\dimen151
+\Gm@odd@mp=\dimen152
+\Gm@even@mp=\dimen153
+\Gm@layoutwidth=\dimen154
+\Gm@layoutheight=\dimen155
+\Gm@layouthoffset=\dimen156
+\Gm@layoutvoffset=\dimen157
+\Gm@dimlist=\toks15
+)
+(/usr/share/texlive/texmf-dist/tex/latex/base/size11.clo
+File: size11.clo 2019/12/20 v1.4l Standard LaTeX file (size option)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/basiclayer/pgfcore.sty
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphicx.sty
+Package: graphicx 2019/11/30 v1.2a Enhanced LaTeX Graphics (DPC,SPQR)
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphics.sty
+Package: graphics 2019/11/30 v1.4a Standard LaTeX Graphics (DPC,SPQR)
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/trig.sty
+Package: trig 2016/01/03 v1.10 sin cos tan (DPC)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/graphics.cfg
+File: graphics.cfg 2016/06/04 v1.11 sample graphics configuration
+)
+Package graphics Info: Driver file: pdftex.def on input line 105.
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics-def/pdftex.def
+File: pdftex.def 2018/01/08 v1.0l Graphics/color driver for pdftex
+))
+\Gin@req@height=\dimen158
+\Gin@req@width=\dimen159
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/systemlayer/pgfsys.sty
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/pgfrcs.sty
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfutil-common.tex
+\pgfutil@everybye=\toks16
+\pgfutil@tempdima=\dimen160
+\pgfutil@tempdimb=\dimen161
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfutil-common-lists.t
+ex)) (/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfutil-latex.def
+\pgfutil@abb=\box54
+(/usr/share/texlive/texmf-dist/tex/latex/ms/everyshi.sty
+Package: everyshi 2001/05/15 v3.00 EveryShipout Package (MS)
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfrcs.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/pgf.revision.tex)
+Package: pgfrcs 2020/01/08 v3.1.5b (3.1.5b)
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsys.code.tex
+Package: pgfsys 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex
+\pgfkeys@pathtoks=\toks17
+\pgfkeys@temptoks=\toks18
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfkeysfiltered.code.t
+ex
+\pgfkeys@tmptoks=\toks19
+))
+\pgf@x=\dimen162
+\pgf@y=\dimen163
+\pgf@xa=\dimen164
+\pgf@ya=\dimen165
+\pgf@xb=\dimen166
+\pgf@yb=\dimen167
+\pgf@xc=\dimen168
+\pgf@yc=\dimen169
+\pgf@xd=\dimen170
+\pgf@yd=\dimen171
+\w@pgf@writea=\write3
+\r@pgf@reada=\read2
+\c@pgf@counta=\count195
+\c@pgf@countb=\count196
+\c@pgf@countc=\count197
+\c@pgf@countd=\count198
+\t@pgf@toka=\toks20
+\t@pgf@tokb=\toks21
+\t@pgf@tokc=\toks22
+\pgf@sys@id@count=\count199
+ (/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgf.cfg
+File: pgf.cfg 2020/01/08 v3.1.5b (3.1.5b)
+)
+Driver file for pgf: pgfsys-pdftex.def
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsys-pdftex.def
+File: pgfsys-pdftex.def 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsys-common-pdf.de
+f
+File: pgfsys-common-pdf.def 2020/01/08 v3.1.5b (3.1.5b)
+)))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsyssoftpath.code.
+tex
+File: pgfsyssoftpath.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfsyssoftpath@smallbuffer@items=\count266
+\pgfsyssoftpath@bigbuffer@items=\count267
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsysprotocol.code.
+tex
+File: pgfsysprotocol.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)) (/usr/share/texlive/texmf-dist/tex/latex/xcolor/xcolor.sty
+Package: xcolor 2016/05/11 v2.12 LaTeX color extensions (UK)
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/color.cfg
+File: color.cfg 2016/01/02 v1.6 sample color configuration
+)
+Package xcolor Info: Driver file: pdftex.def on input line 225.
+Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1348.
+Package xcolor Info: Model `hsb' substituted by `rgb' on input line 1352.
+Package xcolor Info: Model `RGB' extended on input line 1364.
+Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1366.
+Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1367.
+Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1368.
+Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1369.
+Package xcolor Info: Model `Gray' substituted by `gray' on input line 1370.
+Package xcolor Info: Model `wave' substituted by `hsb' on input line 1371.
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcore.code.tex
+Package: pgfcore 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmath.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathcalc.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathutil.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathparser.code.tex
+\pgfmath@dimen=\dimen172
+\pgfmath@count=\count268
+\pgfmath@box=\box55
+\pgfmath@toks=\toks23
+\pgfmath@stack@operand=\toks24
+\pgfmath@stack@operation=\toks25
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.basic.code
+.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.trigonomet
+ric.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.random.cod
+e.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.comparison
+.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.base.code.
+tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.round.code
+.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.misc.code.
+tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.integerari
+thmetics.code.tex)))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfloat.code.tex
+\c@pgfmathroundto@lastzeros=\count269
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfint.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepoints.code.te
+x
+File: pgfcorepoints.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@picminx=\dimen173
+\pgf@picmaxx=\dimen174
+\pgf@picminy=\dimen175
+\pgf@picmaxy=\dimen176
+\pgf@pathminx=\dimen177
+\pgf@pathmaxx=\dimen178
+\pgf@pathminy=\dimen179
+\pgf@pathmaxy=\dimen180
+\pgf@xx=\dimen181
+\pgf@xy=\dimen182
+\pgf@yx=\dimen183
+\pgf@yy=\dimen184
+\pgf@zx=\dimen185
+\pgf@zy=\dimen186
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathconstruct.
+code.tex
+File: pgfcorepathconstruct.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@path@lastx=\dimen187
+\pgf@path@lasty=\dimen188
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathusage.code
+.tex
+File: pgfcorepathusage.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@shorten@end@additional=\dimen189
+\pgf@shorten@start@additional=\dimen190
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorescopes.code.te
+x
+File: pgfcorescopes.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfpic=\box56
+\pgf@hbox=\box57
+\pgf@layerbox@main=\box58
+\pgf@picture@serial@count=\count270
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoregraphicstate.c
+ode.tex
+File: pgfcoregraphicstate.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgflinewidth=\dimen191
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoretransformation
+s.code.tex
+File: pgfcoretransformations.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@pt@x=\dimen192
+\pgf@pt@y=\dimen193
+\pgf@pt@temp=\dimen194
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorequick.code.tex
+File: pgfcorequick.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreobjects.code.t
+ex
+File: pgfcoreobjects.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathprocessing
+.code.tex
+File: pgfcorepathprocessing.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorearrows.code.te
+x
+File: pgfcorearrows.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfarrowsep=\dimen195
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreshade.code.tex
+File: pgfcoreshade.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@max=\dimen196
+\pgf@sys@shading@range@num=\count271
+\pgf@shadingcount=\count272
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreimage.code.tex
+File: pgfcoreimage.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreexternal.code.
+tex
+File: pgfcoreexternal.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfexternal@startupbox=\box59
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorelayers.code.te
+x
+File: pgfcorelayers.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoretransparency.c
+ode.tex
+File: pgfcoretransparency.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepatterns.code.
+tex
+File: pgfcorepatterns.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorerdf.code.tex
+File: pgfcorerdf.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+))) (/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/xxcolor.sty
+Package: xxcolor 2003/10/24 ver 0.1
+\XC@nummixins=\count273
+\XC@countmixins=\count274
+)
+(/usr/share/texlive/texmf-dist/tex/generic/atbegshi/atbegshi.sty
+Package: atbegshi 2019/12/05 v1.19 At begin shipout hook (HO)
+
+(/usr/share/texlive/texmf-dist/tex/generic/infwarerr/infwarerr.sty
+Package: infwarerr 2019/12/03 v1.5 Providing info/warning/error messages (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/ltxcmds/ltxcmds.sty
+Package: ltxcmds 2019/12/15 v1.24 LaTeX kernel commands for general use (HO)
+))
+(/usr/share/texlive/texmf-dist/tex/latex/hyperref/hyperref.sty
+Package: hyperref 2020/01/14 v7.00d Hypertext links for LaTeX
+
+(/usr/share/texlive/texmf-dist/tex/latex/pdftexcmds/pdftexcmds.sty
+Package: pdftexcmds 2019/11/24 v0.31 Utility functions of pdfTeX for LuaTeX (HO
+)
+Package pdftexcmds Info: \pdf@primitive is available.
+Package pdftexcmds Info: \pdf@ifprimitive is available.
+Package pdftexcmds Info: \pdfdraftmode found.
+)
+(/usr/share/texlive/texmf-dist/tex/generic/kvsetkeys/kvsetkeys.sty
+Package: kvsetkeys 2019/12/15 v1.18 Key value parser (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/kvdefinekeys/kvdefinekeys.sty
+Package: kvdefinekeys 2019-12-19 v1.6 Define keys (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pdfescape/pdfescape.sty
+Package: pdfescape 2019/12/09 v1.15 Implements pdfTeX's escape features (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/hycolor/hycolor.sty
+Package: hycolor 2020-01-27 v1.10 Color options for hyperref/bookmark (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/letltxmacro/letltxmacro.sty
+Package: letltxmacro 2019/12/03 v1.6 Let assignment for LaTeX macros (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/auxhook/auxhook.sty
+Package: auxhook 2019-12-17 v1.6 Hooks for auxiliary files (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/kvoptions/kvoptions.sty
+Package: kvoptions 2019/11/29 v3.13 Key value format for package options (HO)
+)
+\@linkdim=\dimen197
+\Hy@linkcounter=\count275
+\Hy@pagecounter=\count276
+
+(/usr/share/texlive/texmf-dist/tex/latex/hyperref/pd1enc.def
+File: pd1enc.def 2020/01/14 v7.00d Hyperref: PDFDocEncoding definition (HO)
+Now handling font encoding PD1 ...
+... no UTF-8 mapping file for font encoding PD1
+)
+(/usr/share/texlive/texmf-dist/tex/generic/intcalc/intcalc.sty
+Package: intcalc 2019/12/15 v1.3 Expandable calculations with integers (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/etexcmds/etexcmds.sty
+Package: etexcmds 2019/12/15 v1.7 Avoid name clashes with e-TeX commands (HO)
+)
+\Hy@SavedSpaceFactor=\count277
+\pdfmajorversion=\count278
+Package hyperref Info: Option `bookmarks' set `true' on input line 4421.
+Package hyperref Info: Option `bookmarksopen' set `true' on input line 4421.
+Package hyperref Info: Option `implicit' set `false' on input line 4421.
+Package hyperref Info: Hyper figures OFF on input line 4547.
+Package hyperref Info: Link nesting OFF on input line 4552.
+Package hyperref Info: Hyper index ON on input line 4555.
+Package hyperref Info: Plain pages OFF on input line 4562.
+Package hyperref Info: Backreferencing OFF on input line 4567.
+Package hyperref Info: Implicit mode OFF; no redefinition of LaTeX internals.
+Package hyperref Info: Bookmarks ON on input line 4800.
+\c@Hy@tempcnt=\count279
+
+(/usr/share/texlive/texmf-dist/tex/latex/url/url.sty
+\Urlmuskip=\muskip16
+Package: url 2013/09/16  ver 3.4  Verb mode for urls, etc.
+)
+LaTeX Info: Redefining \url on input line 5159.
+\XeTeXLinkMargin=\dimen198
+
+(/usr/share/texlive/texmf-dist/tex/generic/bitset/bitset.sty
+Package: bitset 2019/12/09 v1.3 Handle bit-vector datatype (HO)
+
+(/usr/share/texlive/texmf-dist/tex/generic/bigintcalc/bigintcalc.sty
+Package: bigintcalc 2019/12/15 v1.5 Expandable calculations on big integers (HO
+)
+))
+\Fld@menulength=\count280
+\Field@Width=\dimen199
+\Fld@charsize=\dimen256
+Package hyperref Info: Hyper figures OFF on input line 6430.
+Package hyperref Info: Link nesting OFF on input line 6435.
+Package hyperref Info: Hyper index ON on input line 6438.
+Package hyperref Info: backreferencing OFF on input line 6445.
+Package hyperref Info: Link coloring OFF on input line 6450.
+Package hyperref Info: Link coloring with OCG OFF on input line 6455.
+Package hyperref Info: PDF/A mode OFF on input line 6460.
+LaTeX Info: Redefining \ref on input line 6500.
+LaTeX Info: Redefining \pageref on input line 6504.
+\Hy@abspage=\count281
+
+
+Package hyperref Message: Stopped early.
+
+)
+Package hyperref Info: Driver (autodetected): hpdftex.
+ (/usr/share/texlive/texmf-dist/tex/latex/hyperref/hpdftex.def
+File: hpdftex.def 2020/01/14 v7.00d Hyperref driver for pdfTeX
+
+(/usr/share/texlive/texmf-dist/tex/latex/atveryend/atveryend.sty
+Package: atveryend 2019-12-11 v1.11 Hooks at the very end of document (HO)
+)
+\Fld@listcount=\count282
+\c@bookmark@seq@number=\count283
+
+(/usr/share/texlive/texmf-dist/tex/latex/rerunfilecheck/rerunfilecheck.sty
+Package: rerunfilecheck 2019/12/05 v1.9 Rerun checks for auxiliary files (HO)
+
+(/usr/share/texlive/texmf-dist/tex/generic/uniquecounter/uniquecounter.sty
+Package: uniquecounter 2019/12/15 v1.4 Provide unlimited unique counter (HO)
+)
+Package uniquecounter Info: New unique counter `rerunfilecheck' on input line 2
+86.
+))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaserequires.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasecompatibility.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasefont.sty
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amssymb.sty
+Package: amssymb 2013/01/14 v3.01 AMS font symbols
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amsfonts.sty
+Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support
+\@emptytoks=\toks26
+\symAMSa=\mathgroup4
+\symAMSb=\mathgroup5
+LaTeX Font Info:    Redeclaring math symbol \hbar on input line 98.
+LaTeX Font Info:    Overwriting math alphabet `\mathfrak' in version `bold'
+(Font)                  U/euf/m/n --> U/euf/b/n on input line 106.
+))
+(/usr/share/texlive/texmf-dist/tex/latex/sansmathaccent/sansmathaccent.sty
+Package: sansmathaccent 2020/01/31
+
+(/usr/share/texlive/texmf-dist/tex/latex/koma-script/scrlfile.sty
+Package: scrlfile 2020/01/24 v3.29 KOMA-Script package (loading files)
+)))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetranslator.sty
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator.sty
+Package: translator 2019-05-31 v1.12a Easy translation of strings in LaTeX
+))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasemisc.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetwoscreens.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseoverlay.sty
+\beamer@argscount=\count284
+\beamer@lastskipcover=\skip50
+\beamer@trivlistdepth=\count285
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetitle.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasesection.sty
+\c@lecture=\count286
+\c@part=\count287
+\c@section=\count288
+\c@subsection=\count289
+\c@subsubsection=\count290
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseframe.sty
+\beamer@framebox=\box60
+\beamer@frametitlebox=\box61
+\beamer@zoombox=\box62
+\beamer@zoomcount=\count291
+\beamer@zoomframecount=\count292
+\beamer@frametextheight=\dimen257
+\c@subsectionslide=\count293
+\beamer@frametopskip=\skip51
+\beamer@framebottomskip=\skip52
+\beamer@frametopskipautobreak=\skip53
+\beamer@framebottomskipautobreak=\skip54
+\beamer@envbody=\toks27
+\framewidth=\dimen258
+\c@framenumber=\count294
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseverbatim.sty
+\beamer@verbatimfileout=\write4
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseframesize.sty
+\beamer@splitbox=\box63
+\beamer@autobreakcount=\count295
+\beamer@autobreaklastheight=\dimen259
+\beamer@frametitletoks=\toks28
+\beamer@framesubtitletoks=\toks29
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseframecomponents.sty
+\beamer@footins=\box64
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasecolor.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasenotes.sty
+\beamer@frameboxcopy=\box65
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetoc.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetemplates.sty
+\beamer@sbttoks=\toks30
+
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseauxtemplates.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseboxes.sty
+\bmb@box=\box66
+\bmb@colorbox=\box67
+\bmb@boxshadow=\box68
+\bmb@boxshadowball=\box69
+\bmb@boxshadowballlarge=\box70
+\bmb@temp=\dimen260
+\bmb@dima=\dimen261
+\bmb@dimb=\dimen262
+\bmb@prevheight=\dimen263
+)
+\beamer@blockheadheight=\dimen264
+))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaselocalstructure.sty
+(/usr/share/texlive/texmf-dist/tex/latex/tools/enumerate.sty
+Package: enumerate 2015/07/23 v3.00 enumerate extensions (DPC)
+\@enLab=\toks31
+)
+\c@figure=\count296
+\c@table=\count297
+\abovecaptionskip=\skip55
+\belowcaptionskip=\skip56
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasenavigation.sty
+\beamer@section@min@dim=\dimen265
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetheorems.sty
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsmath.sty
+Package: amsmath 2020/01/20 v2.17e AMS math features
+\@mathmargin=\skip57
+
+For additional information on amsmath, use the `?' option.
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amstext.sty
+Package: amstext 2000/06/29 v2.01 AMS text
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsgen.sty
+File: amsgen.sty 1999/11/30 v2.0 generic functions
+\@emptytoks=\toks32
+\ex@=\dimen266
+))
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsbsy.sty
+Package: amsbsy 1999/11/29 v1.2d Bold Symbols
+\pmbraise@=\dimen267
+)
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsopn.sty
+Package: amsopn 2016/03/08 v2.02 operator names
+)
+\inf@bad=\count298
+LaTeX Info: Redefining \frac on input line 227.
+\uproot@=\count299
+\leftroot@=\count300
+LaTeX Info: Redefining \overline on input line 389.
+\classnum@=\count301
+\DOTSCASE@=\count302
+LaTeX Info: Redefining \ldots on input line 486.
+LaTeX Info: Redefining \dots on input line 489.
+LaTeX Info: Redefining \cdots on input line 610.
+\Mathstrutbox@=\box71
+\strutbox@=\box72
+\big@size=\dimen268
+LaTeX Font Info:    Redeclaring font encoding OML on input line 733.
+LaTeX Font Info:    Redeclaring font encoding OMS on input line 734.
+\macc@depth=\count303
+\c@MaxMatrixCols=\count304
+\dotsspace@=\muskip17
+\c@parentequation=\count305
+\dspbrk@lvl=\count306
+\tag@help=\toks33
+\row@=\count307
+\column@=\count308
+\maxfields@=\count309
+\andhelp@=\toks34
+\eqnshift@=\dimen269
+\alignsep@=\dimen270
+\tagshift@=\dimen271
+\tagwidth@=\dimen272
+\totwidth@=\dimen273
+\lineht@=\dimen274
+\@envbody=\toks35
+\multlinegap=\skip58
+\multlinetaggap=\skip59
+\mathdisplay@stack=\toks36
+LaTeX Info: Redefining \[ on input line 2859.
+LaTeX Info: Redefining \] on input line 2860.
+)
+(/usr/share/texlive/texmf-dist/tex/latex/amscls/amsthm.sty
+Package: amsthm 2017/10/31 v2.20.4
+\thm@style=\toks37
+\thm@bodyfont=\toks38
+\thm@headfont=\toks39
+\thm@notefont=\toks40
+\thm@headpunct=\toks41
+\thm@preskip=\skip60
+\thm@postskip=\skip61
+\thm@headsep=\skip62
+\dth@everypar=\toks42
+)
+\c@theorem=\count310
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasethemes.sty))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerthemedefault.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerfontthemedefault.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamercolorthemedefault.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerinnerthemedefault.sty
+\beamer@dima=\dimen275
+\beamer@dimb=\dimen276
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerouterthemedefault.sty)))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerthemeMadrid.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamercolorthemewhale.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamercolorthemeorchid.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerinnerthemerounded.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerouterthemeinfolines.sty))
+(/usr/share/texlive/texmf-dist/tex/latex/base/inputenc.sty
+Package: inputenc 2018/08/11 v1.3c Input encoding file
+\inpenc@prehook=\toks43
+\inpenc@posthook=\toks44
+)
+(/usr/share/texlive/texmf-dist/tex/latex/listings/listings.sty
+\lst@mode=\count311
+\lst@gtempboxa=\box73
+\lst@token=\toks45
+\lst@length=\count312
+\lst@currlwidth=\dimen277
+\lst@column=\count313
+\lst@pos=\count314
+\lst@lostspace=\dimen278
+\lst@width=\dimen279
+\lst@newlines=\count315
+\lst@lineno=\count316
+\lst@maxwidth=\dimen280
+
+(/usr/share/texlive/texmf-dist/tex/latex/listings/lstmisc.sty
+File: lstmisc.sty 2019/09/10 1.8c (Carsten Heinz)
+\c@lstnumber=\count317
+\lst@skipnumbers=\count318
+\lst@framebox=\box74
+)
+(/usr/share/texlive/texmf-dist/tex/latex/listings/listings.cfg
+File: listings.cfg 2019/09/10 1.8c listings configuration
+))
+Package: listings 2019/09/10 1.8c (Carsten Heinz)
+
+(/usr/share/texlive/texmf-dist/tex/latex/mathtools/mathtools.sty
+Package: mathtools 2020/01/17 v1.23 mathematical typesetting tools
+
+(/usr/share/texlive/texmf-dist/tex/latex/tools/calc.sty
+Package: calc 2017/05/25 v4.3 Infix arithmetic (KKT,FJ)
+\calc@Acount=\count319
+\calc@Bcount=\count320
+\calc@Adimen=\dimen281
+\calc@Bdimen=\dimen282
+\calc@Askip=\skip63
+\calc@Bskip=\skip64
+LaTeX Info: Redefining \setlength on input line 80.
+LaTeX Info: Redefining \addtolength on input line 81.
+\calc@Ccount=\count321
+\calc@Cskip=\skip65
+)
+(/usr/share/texlive/texmf-dist/tex/latex/mathtools/mhsetup.sty
+Package: mhsetup 2017/03/31 v1.3 programming setup (MH)
+)
+LaTeX Info: Thecontrolsequence`\('isalreadyrobust on input line 129.
+LaTeX Info: Thecontrolsequence`\)'isalreadyrobust on input line 129.
+LaTeX Info: Thecontrolsequence`\['isalreadyrobust on input line 129.
+LaTeX Info: Thecontrolsequence`\]'isalreadyrobust on input line 129.
+\g_MT_multlinerow_int=\count322
+\l_MT_multwidth_dim=\dimen283
+\origjot=\skip66
+\l_MT_shortvdotswithinadjustabove_dim=\dimen284
+\l_MT_shortvdotswithinadjustbelow_dim=\dimen285
+\l_MT_above_intertext_sep=\dimen286
+\l_MT_below_intertext_sep=\dimen287
+\l_MT_above_shortintertext_sep=\dimen288
+\l_MT_below_shortintertext_sep=\dimen289
+)
+(/usr/share/texlive/texmf-dist/tex/latex/tikz-cd/tikz-cd.sty
+Package: tikz-cd 2018/11/19 v0.9f Commutative diagrams with TikZ
+
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/frontendlayer/tikz.sty
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/basiclayer/pgf.sty
+Package: pgf 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/modules/pgfmoduleshapes.code.tex
+File: pgfmoduleshapes.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfnodeparttextbox=\box75
+) (/usr/share/texlive/texmf-dist/tex/generic/pgf/modules/pgfmoduleplot.code.tex
+File: pgfmoduleplot.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/compatibility/pgfcomp-version-0-65
+.sty
+Package: pgfcomp-version-0-65 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@nodesepstart=\dimen290
+\pgf@nodesepend=\dimen291
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/compatibility/pgfcomp-version-1-18
+.sty
+Package: pgfcomp-version-1-18 2020/01/08 v3.1.5b (3.1.5b)
+)) (/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/pgffor.sty
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/pgfkeys.sty
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex))
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/math/pgfmath.sty
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmath.code.tex))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgffor.code.tex
+Package: pgffor 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmath.code.tex)
+\pgffor@iter=\dimen292
+\pgffor@skip=\dimen293
+\pgffor@stack=\toks46
+\pgffor@toks=\toks47
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/tikz.code.tex
+Package: tikz 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/libraries/pgflibraryplothandlers
+.code.tex
+File: pgflibraryplothandlers.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@plot@mark@count=\count323
+\pgfplotmarksize=\dimen294
+)
+\tikz@lastx=\dimen295
+\tikz@lasty=\dimen296
+\tikz@lastxsaved=\dimen297
+\tikz@lastysaved=\dimen298
+\tikz@lastmovetox=\dimen299
+\tikz@lastmovetoy=\dimen300
+\tikzleveldistance=\dimen301
+\tikzsiblingdistance=\dimen302
+\tikz@figbox=\box76
+\tikz@figbox@bg=\box77
+\tikz@tempbox=\box78
+\tikz@tempbox@bg=\box79
+\tikztreelevel=\count324
+\tikznumberofchildren=\count325
+\tikznumberofcurrentchild=\count326
+\tikz@fig@count=\count327
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/modules/pgfmodulematrix.code.tex
+File: pgfmodulematrix.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfmatrixcurrentrow=\count328
+\pgfmatrixcurrentcolumn=\count329
+\pgf@matrix@numberofcolumns=\count330
+)
+\tikz@expandcount=\count331
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/libraries/tik
+zlibrarytopaths.code.tex
+File: tikzlibrarytopaths.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)))
+(/usr/share/texlive/texmf-dist/tex/generic/tikz-cd/tikzlibrarycd.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/libraries/tik
+zlibrarymatrix.code.tex
+File: tikzlibrarymatrix.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/libraries/tik
+zlibraryquotes.code.tex
+File: tikzlibraryquotes.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/libraries/pgflibraryarrows.meta.
+code.tex
+File: pgflibraryarrows.meta.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfarrowinset=\dimen303
+\pgfarrowlength=\dimen304
+\pgfarrowwidth=\dimen305
+\pgfarrowlinewidth=\dimen306
+))) (/usr/share/texlive/texmf-dist/tex/latex/adjustbox/adjustbox.sty
+Package: adjustbox 2019/01/04 v1.2 Adjusting TeX boxes (trim, clip, ...)
+
+(/usr/share/texlive/texmf-dist/tex/latex/xkeyval/xkeyval.sty
+Package: xkeyval 2014/12/03 v2.7a package option processing (HA)
+
+(/usr/share/texlive/texmf-dist/tex/generic/xkeyval/xkeyval.tex
+(/usr/share/texlive/texmf-dist/tex/generic/xkeyval/xkvutils.tex
+\XKV@toks=\toks48
+\XKV@tempa@toks=\toks49
+)
+\XKV@depth=\count332
+File: xkeyval.tex 2014/12/03 v2.7a key=value parser (HA)
+))
+(/usr/share/texlive/texmf-dist/tex/latex/adjustbox/adjcalc.sty
+Package: adjcalc 2012/05/16 v1.1 Provides advanced setlength with multiple back
+-ends (calc, etex, pgfmath)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/adjustbox/trimclip.sty
+Package: trimclip 2018/04/08 v1.1 Trim and clip general TeX material
+
+(/usr/share/texlive/texmf-dist/tex/latex/collectbox/collectbox.sty
+Package: collectbox 2012/05/17 v0.4b Collect macro arguments as boxes
+\collectedbox=\box80
+)
+\tc@llx=\dimen307
+\tc@lly=\dimen308
+\tc@urx=\dimen309
+\tc@ury=\dimen310
+Package trimclip Info: Using driver 'tc-pdftex.def'.
+
+(/usr/share/texlive/texmf-dist/tex/latex/adjustbox/tc-pdftex.def
+File: tc-pdftex.def 2019/01/04 v2.2 Clipping driver for pdftex
+))
+\adjbox@Width=\dimen311
+\adjbox@Height=\dimen312
+\adjbox@Depth=\dimen313
+\adjbox@Totalheight=\dimen314
+\adjbox@pwidth=\dimen315
+\adjbox@pheight=\dimen316
+\adjbox@pdepth=\dimen317
+\adjbox@ptotalheight=\dimen318
+
+(/usr/share/texlive/texmf-dist/tex/latex/ifoddpage/ifoddpage.sty
+Package: ifoddpage 2016/04/23 v1.1 Conditionals for odd/even page detection
+\c@checkoddpage=\count333
+)
+(/usr/share/texlive/texmf-dist/tex/latex/varwidth/varwidth.sty
+Package: varwidth 2009/03/30 ver 0.92;  Variable-width minipages
+\@vwid@box=\box81
+\sift@deathcycles=\count334
+\@vwid@loff=\dimen319
+\@vwid@roff=\dimen320
+))
+(/usr/share/texlive/texmf-dist/tex/latex/listings/lstlang1.sty
+File: lstlang1.sty 2019/09/10 1.8c listings language file
+)
+(/usr/share/texlive/texmf-dist/tex/latex/l3backend/l3backend-pdfmode.def
+File: l3backend-pdfmode.def 2020-02-03 L3 backend support: PDF mode
+\l__kernel_color_stack_int=\count335
+\l__pdf_internal_box=\box82
+)
+(./X1-ComputationalComplexity.aux)
+\openout1 = `X1-ComputationalComplexity.aux'.
+
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+LaTeX Font Info:    Checking defaults for TS1/cmr/m/n on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+LaTeX Font Info:    Checking defaults for PD1/pdf/m/n on input line 32.
+LaTeX Font Info:    ... okay on input line 32.
+
+*geometry* driver: auto-detecting
+*geometry* detected driver: pdftex
+*geometry* verbose mode - [ preamble ] result:
+* driver: pdftex
+* paper: custom
+* layout: <same size as paper>
+* layoutoffset:(h,v)=(0.0pt,0.0pt)
+* modes: includehead includefoot 
+* h-part:(L,W,R)=(10.95003pt, 342.2953pt, 10.95003pt)
+* v-part:(T,H,B)=(0.0pt, 273.14662pt, 0.0pt)
+* \paperwidth=364.19536pt
+* \paperheight=273.14662pt
+* \textwidth=342.2953pt
+* \textheight=244.6939pt
+* \oddsidemargin=-61.31996pt
+* \evensidemargin=-61.31996pt
+* \topmargin=-72.26999pt
+* \headheight=14.22636pt
+* \headsep=0.0pt
+* \topskip=11.0pt
+* \footskip=14.22636pt
+* \marginparwidth=4.0pt
+* \marginparsep=10.0pt
+* \columnsep=10.0pt
+* \skip\footins=10.0pt plus 4.0pt minus 2.0pt
+* \hoffset=0.0pt
+* \voffset=0.0pt
+* \mag=1000
+* \@twocolumnfalse
+* \@twosidefalse
+* \@mparswitchfalse
+* \@reversemarginfalse
+* (1in=72.27pt=25.4mm, 1cm=28.453pt)
+
+(/usr/share/texlive/texmf-dist/tex/context/base/mkii/supp-pdf.mkii
+[Loading MPS to PDF converter (version 2006.09.02).]
+\scratchcounter=\count336
+\scratchdimen=\dimen321
+\scratchbox=\box83
+\nofMPsegments=\count337
+\nofMParguments=\count338
+\everyMPshowfont=\toks50
+\MPscratchCnt=\count339
+\MPscratchDim=\dimen322
+\MPnumerator=\count340
+\makeMPintoPDFobject=\count341
+\everyMPtoPDFconversion=\toks51
+) (/usr/share/texlive/texmf-dist/tex/latex/epstopdf-pkg/epstopdf-base.sty
+Package: epstopdf-base 2020-01-24 v2.11 Base part for package epstopdf
+Package epstopdf-base Info: Redefining graphics rule for `.eps' on input line 4
+85.
+
+(/usr/share/texlive/texmf-dist/tex/latex/latexconfig/epstopdf-sys.cfg
+File: epstopdf-sys.cfg 2010/07/13 v1.3 Configuration of (r)epstopdf for TeX Liv
+e
+))
+ABD: EveryShipout initializing macros
+\AtBeginShipoutBox=\box84
+Package hyperref Info: Link coloring OFF on input line 32.
+
+(/usr/share/texlive/texmf-dist/tex/latex/hyperref/nameref.sty
+Package: nameref 2019/09/16 v2.46 Cross-referencing by name of section
+
+(/usr/share/texlive/texmf-dist/tex/latex/refcount/refcount.sty
+Package: refcount 2019/12/15 v3.6 Data extraction from label references (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/gettitlestring/gettitlestring.sty
+Package: gettitlestring 2019/12/15 v1.6 Cleanup title references (HO)
+)
+\c@section@level=\count342
+)
+LaTeX Info: Redefining \ref on input line 32.
+LaTeX Info: Redefining \pageref on input line 32.
+LaTeX Info: Redefining \nameref on input line 32.
+
+(./X1-ComputationalComplexity.out) (./X1-ComputationalComplexity.out)
+\@outlinefile=\write5
+\openout5 = `X1-ComputationalComplexity.out'.
+
+LaTeX Font Info:    Overwriting symbol font `operators' in version `normal'
+(Font)                  OT1/cmr/m/n --> OT1/cmss/m/n on input line 32.
+LaTeX Font Info:    Overwriting symbol font `operators' in version `bold'
+(Font)                  OT1/cmr/bx/n --> OT1/cmss/b/n on input line 32.
+\symnumbers=\mathgroup6
+\sympureletters=\mathgroup7
+LaTeX Font Info:    Overwriting math alphabet `\mathrm' in version `normal'
+(Font)                  OT1/cmss/m/n --> OT1/cmr/m/n on input line 32.
+LaTeX Font Info:    Redeclaring math alphabet \mathbf on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathbf' in version `normal'
+(Font)                  OT1/cmr/bx/n --> OT1/cmss/b/n on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathbf' in version `bold'
+(Font)                  OT1/cmr/bx/n --> OT1/cmss/b/n on input line 32.
+LaTeX Font Info:    Redeclaring math alphabet \mathsf on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathsf' in version `normal'
+(Font)                  OT1/cmss/m/n --> OT1/cmss/m/n on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathsf' in version `bold'
+(Font)                  OT1/cmss/bx/n --> OT1/cmss/m/n on input line 32.
+LaTeX Font Info:    Redeclaring math alphabet \mathit on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathit' in version `normal'
+(Font)                  OT1/cmr/m/it --> OT1/cmss/m/it on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathit' in version `bold'
+(Font)                  OT1/cmr/bx/it --> OT1/cmss/m/it on input line 32.
+LaTeX Font Info:    Redeclaring math alphabet \mathtt on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathtt' in version `normal'
+(Font)                  OT1/cmtt/m/n --> OT1/cmtt/m/n on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathtt' in version `bold'
+(Font)                  OT1/cmtt/m/n --> OT1/cmtt/m/n on input line 32.
+LaTeX Font Info:    Overwriting symbol font `numbers' in version `bold'
+(Font)                  OT1/cmss/m/n --> OT1/cmss/b/n on input line 32.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `bold'
+(Font)                  OT1/cmss/m/it --> OT1/cmss/b/it on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathrm' in version `bold'
+(Font)                  OT1/cmss/b/n --> OT1/cmr/b/n on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathbf' in version `bold'
+(Font)                  OT1/cmss/b/n --> OT1/cmss/b/n on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathsf' in version `bold'
+(Font)                  OT1/cmss/m/n --> OT1/cmss/b/n on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathit' in version `bold'
+(Font)                  OT1/cmss/m/it --> OT1/cmss/b/it on input line 32.
+LaTeX Font Info:    Overwriting math alphabet `\mathtt' in version `bold'
+(Font)                  OT1/cmtt/m/n --> OT1/cmtt/b/n on input line 32.
+LaTeX Font Info:    Redeclaring symbol font `pureletters' on input line 32.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `normal'
+(Font)                  OT1/cmss/m/it --> OT1/mathkerncmss/m/sl on input line 3
+2.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `bold'
+(Font)                  OT1/cmss/b/it --> OT1/mathkerncmss/m/sl on input line 3
+2.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `bold'
+(Font)                  OT1/mathkerncmss/m/sl --> OT1/mathkerncmss/bx/sl on inp
+ut line 32.
+
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-basic-dictionary
+-English.dict
+Dictionary: translator-basic-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-bibliography-dic
+tionary-English.dict
+Dictionary: translator-bibliography-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-environment-dict
+ionary-English.dict
+Dictionary: translator-environment-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-months-dictionar
+y-English.dict
+Dictionary: translator-months-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-numbers-dictiona
+ry-English.dict
+Dictionary: translator-numbers-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-theorem-dictiona
+ry-English.dict
+Dictionary: translator-theorem-dictionary, Language: English 
+)
+\c@lstlisting=\count343
+ (./X1-ComputationalComplexity.nav)
+<img/unilu.jpg, id=20, 645.16031pt x 578.16pt>
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 36.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [1
+
+{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map} <./img/unilu.jpg>]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 51.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [2
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 64.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [3
+
+]
+LaTeX Font Info:    Trying to load font information for U+msa on input line 80.
+
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/umsa.fd
+File: umsa.fd 2013/01/14 v3.01 AMS symbols A
+)
+LaTeX Font Info:    Trying to load font information for U+msb on input line 80.
+
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/umsb.fd
+File: umsb.fd 2013/01/14 v3.01 AMS symbols B
+)
+LaTeX Font Info:    Trying to load font information for OT1+mathkerncmss on inp
+ut line 80.
+
+(/usr/share/texlive/texmf-dist/tex/latex/sansmathaccent/ot1mathkerncmss.fd
+File: ot1mathkerncmss.fd 2020/01/31 Fontinst v1.933 font definitions for OT1/ma
+thkerncmss.
+)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 80.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+
+[4
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 89.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [5
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 111.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [6
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 131.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [7
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 143.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [8
+
+]
+<img/plot1.png, id=252, 426.32072pt x 280.84122pt>
+File: img/plot1.png Graphic file (type png)
+<use img/plot1.png>
+Package pdftex.def Info: img/plot1.png  used on input line 147.
+(pdftex.def)             Requested size: 298.42245pt x 196.5875pt.
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 147.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [9
+
+ <./img/plot1.png>]
+<img/plot2.png, id=281, 424.73079pt x 280.84122pt>
+File: img/plot2.png Graphic file (type png)
+<use img/plot2.png>
+Package pdftex.def Info: img/plot2.png  used on input line 151.
+(pdftex.def)             Requested size: 297.30951pt x 196.5875pt.
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 151.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [10
+
+ <./img/plot2.png>]
+<img/plot3.png, id=309, 425.23668pt x 280.84122pt>
+File: img/plot3.png Graphic file (type png)
+<use img/plot3.png>
+Package pdftex.def Info: img/plot3.png  used on input line 155.
+(pdftex.def)             Requested size: 297.66365pt x 196.5875pt.
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 155.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [11
+
+ <./img/plot3.png>]
+<img/plot4.png, id=337, 424.87534pt x 280.84122pt>
+File: img/plot4.png Graphic file (type png)
+<use img/plot4.png>
+Package pdftex.def Info: img/plot4.png  used on input line 159.
+(pdftex.def)             Requested size: 297.4107pt x 196.5875pt.
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 159.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [12
+
+ <./img/plot4.png>]
+<img/plot5.png, id=366, 424.65852pt x 280.84122pt>
+File: img/plot5.png Graphic file (type png)
+<use img/plot5.png>
+Package pdftex.def Info: img/plot5.png  used on input line 163.
+(pdftex.def)             Requested size: 297.25893pt x 196.5875pt.
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 163.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [13
+
+ <./img/plot5.png>]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 186.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [14
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+
+(./X1-ComputationalComplexity.vrb
+LaTeX Font Info:    Trying to load font information for TS1+cmss on input line 
+5.
+
+(/usr/share/texlive/texmf-dist/tex/latex/base/ts1cmss.fd
+File: ts1cmss.fd 2019/12/16 v2.5j Standard LaTeX font definitions
+)) [15
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 224.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [16
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+
+(./X1-ComputationalComplexity.vrb
+LaTeX Font Info:    Trying to load font information for OML+cmss on input line 
+5.
+LaTeX Font Info:    No file OMLcmss.fd. on input line 5.
+
+
+LaTeX Font Warning: Font shape `OML/cmss/m/n' undefined
+(Font)              using `OML/cmm/m/it' instead
+(Font)              for symbol `textgreater' on input line 5.
+
+)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 241.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [17
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 260.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [18
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 269.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [19
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 277.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [20
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 291.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [21
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+ (./X1-ComputationalComplexity.vrb)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 305.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [22
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 363.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [23
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 363.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+
+[24
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 363.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [25
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 363.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [26
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 419.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [27
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 419.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [28
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 419.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [29
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 419.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [30
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 427.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [31
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+ (./X1-ComputationalComplexity.vrb)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 443.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+
+[32
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 456.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [33
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+ (./X1-ComputationalComplexity.vrb
+
+LaTeX Font Warning: Font shape `OML/cmss/m/it' undefined
+(Font)              using `OML/cmm/m/it' instead
+(Font)              for symbol `textgreater' on input line 3.
+
+)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 469.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [34
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 478.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [35
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+ (./X1-ComputationalComplexity.vrb)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 507.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [36
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 516.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [37
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+
+(./X1-ComputationalComplexity.vrb)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 538.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [38
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+ (./X1-ComputationalComplexity.vrb)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 551.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+
+[39
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 560.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [40
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+ (./X1-ComputationalComplexity.vrb)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 577.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [41
+
+]
+\openout4 = `X1-ComputationalComplexity.vrb'.
+
+
+(./X1-ComputationalComplexity.vrb)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 589.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [42
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 597.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [43
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 606.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [44
+
+]
+\tf@nav=\write6
+\openout6 = `X1-ComputationalComplexity.nav'.
+
+\tf@toc=\write7
+\openout7 = `X1-ComputationalComplexity.toc'.
+
+\tf@snm=\write8
+\openout8 = `X1-ComputationalComplexity.snm'.
+
+Package atveryend Info: Empty hook `BeforeClearDocument' on input line 608.
+Package atveryend Info: Empty hook `AfterLastShipout' on input line 608.
+
+(./X1-ComputationalComplexity.aux)
+Package atveryend Info: Executing hook `AtVeryEndDocument' on input line 608.
+Package atveryend Info: Executing hook `AtEndAfterFileList' on input line 608.
+Package rerunfilecheck Info: File `X1-ComputationalComplexity.out' has not chan
+ged.
+(rerunfilecheck)             Checksum: D41D8CD98F00B204E9800998ECF8427E;0.
+
+
+LaTeX Font Warning: Some font shapes were not available, defaults substituted.
+
+ ) 
+Here is how much of TeX's memory you used:
+ 25931 strings out of 481239
+ 509927 string characters out of 5920377
+ 935890 words of memory out of 5000000
+ 40483 multiletter control sequences out of 15000+600000
+ 549107 words of font info for 85 fonts, out of 8000000 for 9000
+ 1141 hyphenation exceptions out of 8191
+ 58i,31n,89p,810b,1569s stack positions out of 5000i,500n,10000p,200000b,80000s
+ </home/sebastiano/.texlive2019/texmf-var/fonts/pk/ljfour/jknappen/ec/tcss090
+0.600pk></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmex10.pf
+b></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi10.pfb></us
+r/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi9.pfb></usr/share
+/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmss10.pfb></usr/share/texli
+ve/texmf-dist/fonts/type1/public/amsfonts/cm/cmss12.pfb></usr/share/texlive/tex
+mf-dist/fonts/type1/public/amsfonts/cm/cmss8.pfb></usr/share/texlive/texmf-dist
+/fonts/type1/public/amsfonts/cm/cmss9.pfb></usr/share/texlive/texmf-dist/fonts/
+type1/public/amsfonts/cm/cmssbx10.pfb></usr/share/texlive/texmf-dist/fonts/type
+1/public/amsfonts/cm/cmssi10.pfb></usr/share/texlive/texmf-dist/fonts/type1/pub
+lic/amsfonts/cm/cmssi8.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/am
+sfonts/cm/cmssi9.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts
+/cm/cmsy10.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cm
+sy8.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy9.pfb
+></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt10.pfb></usr
+/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt8.pfb>
+Output written on X1-ComputationalComplexity.pdf (44 pages, 1769406 bytes).
+PDF statistics:
+ 1306 PDF objects out of 1440 (max. 8388607)
+ 1204 compressed objects within 13 object streams
+ 89 named destinations out of 1000 (max. 500000)
+ 121 words of extra memory for PDF output out of 10000 (max. 10000000)
+
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.nav b/src/Lecture7/slides/X1-ComputationalComplexity.nav
new file mode 100644
index 0000000..d21fe16
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.nav
@@ -0,0 +1,81 @@
+\headcommand {\slideentry {0}{0}{1}{1/1}{}{0}}
+\headcommand {\beamer@framepages {1}{1}}
+\headcommand {\slideentry {0}{0}{2}{2/2}{}{0}}
+\headcommand {\beamer@framepages {2}{2}}
+\headcommand {\slideentry {0}{0}{3}{3/3}{}{0}}
+\headcommand {\beamer@framepages {3}{3}}
+\headcommand {\slideentry {0}{0}{4}{4/4}{}{0}}
+\headcommand {\beamer@framepages {4}{4}}
+\headcommand {\slideentry {0}{0}{5}{5/5}{}{0}}
+\headcommand {\beamer@framepages {5}{5}}
+\headcommand {\slideentry {0}{0}{6}{6/6}{}{0}}
+\headcommand {\beamer@framepages {6}{6}}
+\headcommand {\slideentry {0}{0}{7}{7/7}{}{0}}
+\headcommand {\beamer@framepages {7}{7}}
+\headcommand {\slideentry {0}{0}{8}{8/8}{}{0}}
+\headcommand {\beamer@framepages {8}{8}}
+\headcommand {\slideentry {0}{0}{9}{9/9}{}{0}}
+\headcommand {\beamer@framepages {9}{9}}
+\headcommand {\slideentry {0}{0}{10}{10/10}{}{0}}
+\headcommand {\beamer@framepages {10}{10}}
+\headcommand {\slideentry {0}{0}{11}{11/11}{}{0}}
+\headcommand {\beamer@framepages {11}{11}}
+\headcommand {\slideentry {0}{0}{12}{12/12}{}{0}}
+\headcommand {\beamer@framepages {12}{12}}
+\headcommand {\slideentry {0}{0}{13}{13/13}{}{0}}
+\headcommand {\beamer@framepages {13}{13}}
+\headcommand {\slideentry {0}{0}{14}{14/14}{}{0}}
+\headcommand {\beamer@framepages {14}{14}}
+\headcommand {\slideentry {0}{0}{15}{15/15}{}{0}}
+\headcommand {\beamer@framepages {15}{15}}
+\headcommand {\slideentry {0}{0}{16}{16/16}{}{0}}
+\headcommand {\beamer@framepages {16}{16}}
+\headcommand {\slideentry {0}{0}{17}{17/17}{}{0}}
+\headcommand {\beamer@framepages {17}{17}}
+\headcommand {\slideentry {0}{0}{18}{18/18}{}{0}}
+\headcommand {\beamer@framepages {18}{18}}
+\headcommand {\slideentry {0}{0}{19}{19/19}{}{0}}
+\headcommand {\beamer@framepages {19}{19}}
+\headcommand {\slideentry {0}{0}{20}{20/20}{}{0}}
+\headcommand {\beamer@framepages {20}{20}}
+\headcommand {\slideentry {0}{0}{21}{21/21}{}{0}}
+\headcommand {\beamer@framepages {21}{21}}
+\headcommand {\slideentry {0}{0}{22}{22/22}{}{0}}
+\headcommand {\beamer@framepages {22}{22}}
+\headcommand {\slideentry {0}{0}{23}{23/26}{}{0}}
+\headcommand {\beamer@framepages {23}{26}}
+\headcommand {\slideentry {0}{0}{24}{27/30}{}{0}}
+\headcommand {\beamer@framepages {27}{30}}
+\headcommand {\slideentry {0}{0}{25}{31/31}{}{0}}
+\headcommand {\beamer@framepages {31}{31}}
+\headcommand {\slideentry {0}{0}{26}{32/32}{}{0}}
+\headcommand {\beamer@framepages {32}{32}}
+\headcommand {\slideentry {0}{0}{27}{33/33}{}{0}}
+\headcommand {\beamer@framepages {33}{33}}
+\headcommand {\slideentry {0}{0}{28}{34/34}{}{0}}
+\headcommand {\beamer@framepages {34}{34}}
+\headcommand {\slideentry {0}{0}{29}{35/35}{}{0}}
+\headcommand {\beamer@framepages {35}{35}}
+\headcommand {\slideentry {0}{0}{30}{36/36}{}{0}}
+\headcommand {\beamer@framepages {36}{36}}
+\headcommand {\slideentry {0}{0}{31}{37/37}{}{0}}
+\headcommand {\beamer@framepages {37}{37}}
+\headcommand {\slideentry {0}{0}{32}{38/38}{}{0}}
+\headcommand {\beamer@framepages {38}{38}}
+\headcommand {\slideentry {0}{0}{33}{39/39}{}{0}}
+\headcommand {\beamer@framepages {39}{39}}
+\headcommand {\slideentry {0}{0}{34}{40/40}{}{0}}
+\headcommand {\beamer@framepages {40}{40}}
+\headcommand {\slideentry {0}{0}{35}{41/41}{}{0}}
+\headcommand {\beamer@framepages {41}{41}}
+\headcommand {\slideentry {0}{0}{36}{42/42}{}{0}}
+\headcommand {\beamer@framepages {42}{42}}
+\headcommand {\slideentry {0}{0}{37}{43/43}{}{0}}
+\headcommand {\beamer@framepages {43}{43}}
+\headcommand {\slideentry {0}{0}{38}{44/44}{}{0}}
+\headcommand {\beamer@framepages {44}{44}}
+\headcommand {\beamer@partpages {1}{44}}
+\headcommand {\beamer@subsectionpages {1}{44}}
+\headcommand {\beamer@sectionpages {1}{44}}
+\headcommand {\beamer@documentpages {44}}
+\headcommand {\gdef \inserttotalframenumber {38}}
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.out b/src/Lecture7/slides/X1-ComputationalComplexity.out
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.out
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.pdf b/src/Lecture7/slides/X1-ComputationalComplexity.pdf
new file mode 100644
index 0000000..fe67ff6
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.pdf
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.snm b/src/Lecture7/slides/X1-ComputationalComplexity.snm
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.snm
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.tex b/src/Lecture7/slides/X1-ComputationalComplexity.tex
new file mode 100644
index 0000000..c7e1602
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.tex
@@ -0,0 +1,608 @@
+\documentclass[11pt]{beamer}
+\usetheme{Madrid}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath}
+
+\usepackage{color}
+\usepackage{listings}
+\usepackage{mathtools}
+\usepackage{tikz-cd}
+\usepackage{adjustbox}
+
+\definecolor{myblue}{rgb}{0,0,0.5}
+\lstset{
+        language=Python,
+        tabsize=4,
+        basicstyle=\footnotesize,
+        keywordstyle=\bf\color{myblue},
+        commentstyle=\it\color{gray},
+        numbers=left,
+        numbersep=3pt,
+        numberstyle=\tiny\color{gray},
+}
+
+\author[\texttt{sebastiano.tronto@uni.lu}]{Sebastiano Tronto}
+\title[Computational Complexity]%
+{Why is my code slow?}
+\logo{\includegraphics[scale=0.1]{img/unilu.jpg}} 
+%\institute{University of Luxembourg} 
+
+\date{2021-05-21} 
+
+\begin{document}
+
+\begin{frame}
+  \titlepage
+\end{frame}
+
+\begin{frame}{Computational Complexity}
+        \begin{itemize}
+                \item \textbf{Goal:}
+                      estimate the running {\color{blue}time} of a program
+                \item \textbf{How:}
+                      count the {\color{blue}basic steps} that an
+                      {\color{blue}algorithm} takes to complete
+                \item \textbf{Why}:
+                      find the \emph{bottleneck} of your program, make it faster
+        \end{itemize}
+
+        \vspace{0.5cm}
+        Our analysis should not depend on the hardware
+\end{frame}
+
+\begin{frame}{Algorithm}
+        \begin{definition}
+                \emph{An algorithm is a sequence of {\color{blue}steps} needed to
+                solve a {\color{blue}class of problems}. }
+        \end{definition}
+
+        \begin{definition}[alternative]
+                \emph{An algorithm is a sequence of steps that takes
+                an input satisfying certain conditions and produces an output
+                satisfying other conditions.}
+        \end{definition}
+\end{frame}
+
+\begin{frame}{Sorting a list}
+        \begin{block}{Class of problems}
+                Sort a list $L$ of numbers in increasing order.
+        \end{block}
+
+        \begin{block}{Algorithm}
+                \begin{enumerate}
+                        \item Let $S$ be an empty list.
+                        \item Take an element from $L$ an insert it in $S$ in its correct
+                              position.
+                        \item Repeat step $2$ until $L$ is empty.
+                        \item Return $S$.
+                \end{enumerate}
+        \end{block}
+\end{frame}
+
+\begin{frame}{Sorting a list}
+\begin{itemize}
+        \item It solves a \emph{class} of problems: works for any list
+        \item The specific steps to sort the list $[3,7,1]$ are not an algorithm
+        \item Input conditions: must be a list of numbers
+        \item Output conditions: same numbers in increasing order
+\end{itemize}
+\end{frame}
+
+\begin{frame}{How to write an algorithm}
+        \begin{itemize}
+                \item \textbf{Human language}:
+                        \begin{itemize}
+                                \item Easy to understand
+                                \item Not precise
+                        \end{itemize}
+
+                \vspace{0.3cm}
+                \item \textbf{Computer code}:
+                        \begin{itemize}
+                                \item Can be executed by computers
+                                \item Precise
+                                \item From very low level (machine code) to high level
+                      (Python, \dots)
+                    \end{itemize}
+        \end{itemize}
+
+        %\vspace{0.5cm}
+        %To what \emph{level of detail}?
+\end{frame}
+
+\begin{frame}{Basic steps}
+        \begin{itemize}
+                %\item Strictly speaking, only CPU instructions are \emph{basic}
+                %\item In practice:%, we consider basic:
+                %       \begin{itemize}
+                                \item Arithmetic operations $+,-,*,//,\%$
+                                \item Relational operations $==, !=, >, <,\dots$
+                                \item Memory access (read/write variable)
+                %       \end{itemize}
+        \end{itemize}
+
+        \vspace{0.5cm}
+        \textbf{Warning:}
+                Depends on data type (integer, floating point, string,\dots)
+        %\begin{itemize}
+        %       \item Depends on data type (integer, floating point, string,\dots)
+        %       \item There are non-basic instructions such as \texttt{sort()}
+        %\end{itemize}
+\end{frame}
+
+\begin{frame}{Running time}
+        \begin{itemize}
+                \item Depends on computer power, programming language, compiler\dots
+                %\item Not all basic steps are equal
+                \item ``Big O'' notation: an algorithm runs in time $O(f(n))$ if, when
+                      run with input of size $n$, it takes about $c\cdot f(n)$ steps
+                \item Algorithm A is \emph{asymptotically faster} than algorithm B if
+                      it is faster \textbf{for $n$ large enough}
+                \item Rule of thumb: $10^7\sim10^9$ basic steps per second
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Asymptotical analysis vs constant factors}
+        \includegraphics[scale=0.7]{img/plot1.png}
+\end{frame}
+
+\begin{frame}{Asymptotical analysis vs constant factors}
+        \includegraphics[scale=0.7]{img/plot2.png}
+\end{frame}
+
+\begin{frame}{Asymptotical analysis vs constant factors}
+        \includegraphics[scale=0.7]{img/plot3.png}
+\end{frame}
+
+\begin{frame}{Asymptotical analysis vs constant factors}
+        \includegraphics[scale=0.7]{img/plot4.png}
+\end{frame}
+
+\begin{frame}{Asymptotical analysis vs constant factors}
+        \includegraphics[scale=0.7]{img/plot5.png}
+\end{frame}
+
+%\begin{frame}{title}
+%graphs here, uncomment
+%\end{frame}
+
+\begin{frame}{Basic complexity analysis}
+
+        Easy things to do:
+
+        \vspace{0.3cm}
+        \begin{itemize}
+                \item Check documentation for ``non-basic steps''
+                        \begin{itemize}
+                                \item Example: check Sage's \href{https://doc.sagemath.org/html/en/reference/rings\_standard/sage/rings/integer.html\#sage.rings.integer.Integer.is\_prime}{\texttt{is\_prime()}} (redirects to PARI \href{https://pari.math.u-bordeaux.fr/dochtml/html/Arithmetic\_functions.html\#se:isprime}{\texttt{isprime()}})
+                        \end{itemize}
+
+        \vspace{0.3cm}
+                \item Count nested loops
+                        \begin{itemize}
+                                \item How many times is a step repeated?
+                        \end{itemize}
+        \end{itemize}
+\end{frame}
+
+{\setbeamertemplate{logo}{}
+\begin{frame}[fragile]{Nested loops - matrix sum and product}
+\begin{lstlisting}
+def add(A, B):
+        n = len(A)
+        S = [[0] * n for i in range(n)]
+        for i in range(0, n):
+                for j in range(0, n):
+                        S[i][j] = A[i][j] + B[i][j]
+        return S
+\end{lstlisting}
+
+\vspace{0.5cm}
+\begin{lstlisting}
+def prod(A, B):
+        n = len(A)
+        S = [[0] * n for i in range(n)]
+        for i in range(0, n):
+                for j in range(0, n):
+                        for k in range(0, n):
+                                S[i][j] = S[i][j] + A[i][k]*B[k][j]
+        return S
+\end{lstlisting}
+\end{frame}
+}
+
+\begin{frame}{Nested loops - matrix sum and product}
+        \begin{itemize}
+                \item \texttt{add} is $O(n^2)$ (two loops)
+                \item \texttt{prod} is $O(n^3)$ (three loops)
+        \end{itemize}
+
+        \vspace{0.3cm}
+        \textbf{Fun fact:} there are faster algorithms for matrix multiplication,
+        for example \href{https://en.wikipedia.org/wiki/Strassen_algorithm}%
+        {Strassen's algorithm}.
+\end{frame}
+
+\begin{frame}[fragile]{Sorting a list}
+\begin{lstlisting}
+def correct_position(e, S):
+        for i in range(0, len(S)):
+                if S[i] > e:
+                        return i
+        return len(S)
+
+def sort_list(L):
+        S = []
+        for e in L:
+                cp = correct_position(e, S)
+                S.insert(cp, e)
+        return S
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}{Sorting a list}
+        \begin{itemize}
+                \item Complexity of \texttt{correct\_position()}:
+                        \begin{itemize}
+                                %\item best case $O(1)$
+                                \item worst case $O($\texttt{len(S)}$)$
+                                \item average $O($\texttt{len(S)}$)$
+                        \end{itemize}
+
+                \vspace{0.3cm}
+                \item Complexity of \texttt{sort\_list} (here $n=$\texttt{len(L)}):
+                        \begin{align*}
+                                %\sum_{i=0}^{n-1} O(1) = O(n) && \text{best case}\\
+                                \sum_{i=0}^{n-1} O(i) = O(n^2)% && \text{average/worst}
+                        \end{align*}
+                        (it calls \texttt{correct\_position()} $n$ times).
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Sorting a list}
+        \begin{itemize}
+                \item For which lists does the ``best case'' happen?
+                \item For which lists does the ``worst case'' happen?
+                \item How large can $n$ be for \texttt{sort\_list()} to run
+                      in under a second?
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Sorting a list}
+        How to improve our code?
+        \begin{itemize}
+                \item Improve \texttt{correct\_position()}
+                \item Take advantage of the fact that $S$ is always sorted
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Binary search}
+        \begin{block}{Algorithm}
+                \textbf{Input:} a \emph{sorted} list $S$ and a value $e$.
+                \begin{enumerate}
+                        \item If the list is empty, you have found the position of $e$
+                        \item Otherwise, compare $e$ to the middle element $m$ of $S$
+                        \begin{itemize}
+                                \item If $e<m$, repeat from (1) on the first half of $S$
+                                \item Otherwise, repeat from (1) on the second half of $S$
+                        \end{itemize}
+                \end{enumerate}
+        \end{block}
+\end{frame}
+
+\begin{frame}[fragile]{Binary search}
+\begin{lstlisting}
+# Return position of e in L
+def binary_search(e, S, start, end):
+        if start == end:
+                return start
+        midpoint = (end+start)//2
+        if e < S[midpoint]:
+                return binary_search(e, S, start, midpoint)
+        else:
+                return binary_search(e, S, midpoint+1, end)
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}{Binary search - example 1}
+        Searching for \texttt{e}$=2$:
+        \begin{align*}
+        \only<1>{
+                \underbrace{
+                        \overset{{\color{blue}
+                                \substack{\mathclap{\texttt{start}=0}\\\downarrow}}}{-2}
+                        \quad 0\quad 1\quad 3\quad 
+                        \overset{\substack{\mathclap{\texttt{midpoint}=4}\\\downarrow}}{5}
+                        \quad 6\quad 7\quad 9\quad 12
+                }\quad
+                        \overset{{\color{red}
+                                \substack{\mathclap{\texttt{end}=9}\\\downarrow}}}{\phantom{0}}
+        }
+        \only<2>{
+                \underbrace{
+                        \overset{{\color{blue}
+                                \substack{\mathclap{\texttt{start}=0}\\\downarrow}}}{-2}
+                        \quad 0\quad
+                        \overset{\substack{\mathclap{\texttt{midpoint}=2}\\\\\downarrow}}%
+                                {1}
+                        \quad 3
+                }\quad
+                        \overset{{\color{red}
+                                \substack{\mathclap{\texttt{end}=4}\\\downarrow}}}{5}
+                \quad 6\quad 7\quad 9\quad 12\quad \phantom{0}
+        }
+        \only<3>{
+                -2\quad 0\quad 1\quad
+                \underbrace{
+                        \overset{
+                                \substack{
+                                        \mathclap{
+                                                {\color{blue}\texttt{start}}=\texttt{midpoint}=3}\\\\
+                                                        {\color{blue}\downarrow}
+                                }
+                        }{3}
+                } \quad
+                \overset{{\color{red}
+                        \substack{\mathclap{\texttt{end}=4}\\\downarrow}}}{5}
+                \quad 6\quad 7\quad 9\quad 12\quad \phantom{0}
+        }
+        \only<4>{
+                -2\quad 0\quad 1\quad
+                \overset{
+                        \substack{
+                                \mathclap{
+                                        {\color{blue}\texttt{start}}=
+                                                {\color{red}\texttt{end}}=3}\\\downarrow}}{3} 
+                \quad 5 \quad 6\quad 7\quad 9\quad 12\quad \phantom{0}
+        }
+        \end{align*}
+        \only<1>{{\color{blue}$e<5$}$\implies$ check left half}
+        \only<2>{{\color{red}$e>1$}$\implies$ check right half}
+        \only<3>{{\color{blue}$e<3$}$\implies$ check left half}
+        \only<4>{\texttt{start}=\texttt{end}, done}
+\end{frame}
+
+\begin{frame}{Binary search - example 2}
+        Searching for \texttt{e}$=11$:
+        \begin{align*}
+        \only<1>{
+                \underbrace{
+                        \overset{{\color{blue}
+                                \substack{\mathclap{\texttt{start}=0}\\\downarrow}}}{-2}
+                        \quad 0\quad 1\quad 3\quad 
+                        \overset{\substack{\mathclap{\texttt{midpoint}=4}\\\downarrow}}{5}
+                        \quad 6\quad 7\quad 9\quad 12
+                }\quad
+                        \overset{{\color{red}
+                                \substack{\mathclap{\texttt{end}=9}\\\downarrow}}}{\phantom{0}}
+        }
+        \only<2>{
+                -2 \quad 0\quad 1 \quad 3 \quad 5 \quad
+                \underbrace{
+                        \overset{{\color{blue}
+                                \substack{\mathclap{\texttt{start}=5}\\\downarrow}}}{6}
+                        \quad 7 \quad
+                        \overset{\substack{\mathclap{\texttt{midpoint}=7}\\\\\downarrow}}%
+                                {9}
+                        \quad 12
+                }\quad
+                        \overset{{\color{red}
+                                \substack{\mathclap{\texttt{end}=9}\\\downarrow}}}{\phantom{0}}
+        }
+        \only<3>{
+                -2\quad 0\quad 1\quad 3\quad 5\quad 6\quad 7\quad 9\quad
+                \underbrace{
+                        \overset{
+                                \substack{
+                                        \mathclap{
+                                                {\color{blue}\texttt{start}}=\texttt{midpoint}=8}\\\\
+                                                        {\color{blue}\downarrow}
+                                }
+                        }{12}
+                } \quad
+                \overset{{\color{red}
+                        \substack{\mathclap{\texttt{end}=9}\\\downarrow}}}{\phantom{0}}
+        }
+        \only<4>{
+                -2\quad 0\quad 1\quad 3\quad 5\quad 6\quad 7\quad 9\quad
+                \overset{
+                        \substack{
+                                \mathclap{
+                                        {\color{blue}\texttt{start}}=
+                                                {\color{red}\texttt{end}}=8}\\\downarrow}}{12} 
+        }
+        \end{align*}
+        \only<1>{{\color{red}$e>5$}$\implies$ check right half}
+        \only<2>{{\color{red}$e>9$}$\implies$ check right half}
+        \only<3>{{\color{blue}$e<11$}$\implies$ check left half}
+        \only<4>{\texttt{start}=\texttt{end}, done}
+\end{frame}
+
+\begin{frame}{Binary search}
+        \begin{itemize}
+                \item Works only if the list is sorted
+                \item Complexity $O(\log_2(n))$: at every step we cut the list in half
+                \item Recursive, \emph{divide et impera}
+        \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{Sorting a list - binary search version}
+\begin{lstlisting}
+def sort_list(L):
+        S = []
+        for e in L:
+                cp = binary_search(e, S, 0, len(S)) # This changed
+                S.insert(cp, e)
+        return S
+\end{lstlisting}
+        \vspace{0.3cm}
+        \begin{itemize}
+                \item Complexity: \[\sum_{i=0}^{n-1} O(\log_2(i)) = O(n\log_2(n))\]\\
+                        (it calls \texttt{binary\_search} $n$ times).
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Fast exponentiation}
+        \begin{block}{Algorithm / formula}
+                \begin{align*}
+                        a^n=
+                        \begin{cases}
+                                1                     & \text{if }n=0,\\
+                                (a\cdot a)^{\frac n2} & \text{if $n$ is even},\\
+                                a\cdot a^{n-1}        & \text{if $n$ is odd.}
+                        \end{cases}
+                \end{align*}
+        \end{block}
+\end{frame}
+
+\begin{frame}[fragile]{Fast exponentiation}
+\begin{lstlisting}
+# Compute a^n (n>=0 integer)
+def power(a, n):
+        if n == 0:
+                return 1
+        if n % 2 == 0:     # n is even
+                return power(a*a, n//2)
+        else:              # n is odd
+                return a*power(a, n-1)
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}{Fast exponentiation}
+  
+  \begin{itemize}
+    \item Complexity: $O(\log_2(n))$ (after $2$ steps, $n$ is halved)
+    \item Python's operator $**$ does something similar
+    \item Naive algorithm (one loop): $O(n)$
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]{Fast $\gcd$}
+        \begin{block}{Algorithm / formula}
+                \begin{align*}
+                        \gcd(a,b) =
+                        \begin{cases}
+                                a                     & \text{if }b=0,\\
+                                \gcd(b,a\bmod b)      & \text{otherwise.}
+                        \end{cases}
+                \end{align*}
+        \end{block}
+
+\begin{columns}
+\column{0.5\textwidth}
+\begin{lstlisting}
+def gcd(a, b):
+        if b == 0:
+                return a
+        else:
+                return gcd(b, a%b)
+\end{lstlisting}
+
+\column{0.5\textwidth}
+\begin{itemize}
+        \item After $2$ steps, $a$ is halved $\implies$ complexity $O(\log_2(a))$
+\end{itemize}
+\end{columns}
+\end{frame}
+
+\begin{frame}{Recursion}
+        \begin{itemize}
+                \item These examples use \emph{recursion}
+                      (a function that calls itself)
+                \item If it calls itself more than once, it is slow
+                      (\emph{exponential} complexity!)
+        \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{Fibonacci numbers}
+
+        \begin{block}{Algorithm / formula}
+                \begin{align*}
+                        F(n) =
+                        \begin{cases}
+                                n                     & \text{if }n\leq1,\\
+                                F(n-1)+F(n-2)         & \text{otherwise.}
+                        \end{cases}
+                \end{align*}
+        \end{block}
+
+\vspace{0.5cm}
+\begin{lstlisting}
+def F(n):
+        if n <= 1:
+                return n
+        else:
+                return F(n-1) + F(n-2)
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]{Fibonacci}
+        \begin{adjustbox}{scale={0.85}{0.9},center}
+        \begin{tikzcd}[column sep=1mm]
+                & & & & & & & & F(5) \ar[drrr] \ar[dlll]\\
+                & & & & & F(4)\ar[dll]\ar[dr] & & & & & & F(3) \ar[dl] \ar[dr]\\
+                & & & F(3) \ar[dl]\ar[dr] & & & F(2) \ar[dr]\ar[dl]
+                        & & & & F(2) \ar[dl]\ar[dr] & & F(1) \\
+                & & F(2) \ar[dl]\ar[dr] & & F(1) & F(1) & & F(0) & & F(1) & & F(0)\\
+                & F(1) & & F(0)
+        \end{tikzcd}
+        \end{adjustbox}
+\end{frame}
+
+\begin{frame}{Fibonacci}
+        \begin{itemize}
+                \item Complexity: almost $O(2^n)$ (actually $O(\varphi^n)$
+                      with $\varphi=\frac{1+\sqrt 5}{2}\sim 1.6$)
+                \item But some values are computed many times!
+                \item Optimization: memorize previously computed values
+        \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{Fibonacci with memorization}
+\begin{lstlisting}
+# List with memorized values, N is the largest possible
+N = 10**6
+F_memorized = [-1] * N
+
+def F(n):
+        if F_memorized[n] == -1:
+                if n <= 1:
+                        F_memorized[n] = n
+                else:
+                        F_memorized[n] = F(n-1) + F(n-2)
+
+        return F_memorized[n]
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]{Fibonacci with memorization}
+        \begin{adjustbox}{scale={0.85}{0.9},center}
+        \begin{tikzcd}[column sep=1mm]
+                & & & & & & & & F(5) \ar[drrr] \ar[dlll]\\
+                & & & & & F(4)\ar[dll]\ar[dr] & & & & & & {\color{blue}F(3)}\\
+                & & & F(3) \ar[dl]\ar[dr] & & & {\color{blue}F(2)}\\
+                & & F(2) \ar[dl]\ar[dr] & & {\color{blue}F(1)} \\
+                & F(1) & & F(0)
+        \end{tikzcd}
+        \end{adjustbox}
+\end{frame}
+
+\begin{frame}{Fibonacci with memorization}
+        \begin{itemize}
+                \item Complexity: $O(n)$, huge improvement!
+                \item Further improvement (but still $O(n)$): dynamic programming
+                \item Pay attention to memory usage
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{References}
+        \begin{itemize}
+        \item Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and
+                Clifford Stein - 
+                \href{https://en.wikipedia.org/wiki/Introduction\_to\_Algorithms}%
+                {\emph{Introductions to Algorithms}}
+        \end{itemize}
+\end{frame}
+
+\end{document}
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.toc b/src/Lecture7/slides/X1-ComputationalComplexity.toc
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.toc
diff --git a/src/Lecture7/slides/X1-ComputationalComplexity.vrb b/src/Lecture7/slides/X1-ComputationalComplexity.vrb
new file mode 100644
index 0000000..57dfae6
--- /dev/null
+++ b/src/Lecture7/slides/X1-ComputationalComplexity.vrb
@@ -0,0 +1,10 @@
+\frametitle{Fibonacci with memorization}
+\begin{adjustbox}{scale={0.85}{0.9},center}
+        \begin{tikzcd}[column sep=1mm]
+                & & & & & & & & F(5) \ar[drrr] \ar[dlll]\\
+                & & & & & F(4)\ar[dll]\ar[dr] & & & & & & {\color{blue}F(3)}\\
+                & & & F(3) \ar[dl]\ar[dr] & & & {\color{blue}F(2)}\\
+                & & F(2) \ar[dl]\ar[dr] & & {\color{blue}F(1)} \\
+                & F(1) & & F(0)
+        \end{tikzcd}
+        \end{adjustbox}
diff --git a/src/Lecture7/slides/X2-StudentsRequests.aux b/src/Lecture7/slides/X2-StudentsRequests.aux
new file mode 100644
index 0000000..65a5da5
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.aux
@@ -0,0 +1,67 @@
+\relax 
+\providecommand\hyper@newdestlabel[2]{}
+\providecommand{\transparent@use}[1]{}
+\providecommand\HyperFirstAtBeginDocument{\AtBeginDocument}
+\HyperFirstAtBeginDocument{\ifx\hyper@anchor\@undefined
+\global\let\oldcontentsline\contentsline
+\gdef\contentsline#1#2#3#4{\oldcontentsline{#1}{#2}{#3}}
+\global\let\oldnewlabel\newlabel
+\gdef\newlabel#1#2{\newlabelxx{#1}#2}
+\gdef\newlabelxx#1#2#3#4#5#6{\oldnewlabel{#1}{{#2}{#3}}}
+\AtEndDocument{\ifx\hyper@anchor\@undefined
+\let\contentsline\oldcontentsline
+\let\newlabel\oldnewlabel
+\fi}
+\fi}
+\global\let\hyper@last\relax 
+\gdef\HyperFirstAtBeginDocument#1{#1}
+\providecommand\HyField@AuxAddToFields[1]{}
+\providecommand\HyField@AuxAddToCoFields[2]{}
+\providecommand \oddpage@label [2]{}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{1}{1/1}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {1}{1}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{2}{2/2}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {2}{2}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{3}{3/3}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {3}{3}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{4}{4/4}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {4}{4}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{5}{5/5}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {5}{5}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{6}{6/6}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {6}{6}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{7}{7/7}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {7}{7}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{8}{8/8}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {8}{8}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{9}{9/9}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {9}{9}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{10}{10/10}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {10}{10}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{11}{11/11}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {11}{11}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{12}{12/12}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {12}{12}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{13}{13/13}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {13}{13}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{14}{14/14}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {14}{14}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{15}{15/15}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {15}{15}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{16}{16/16}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {16}{16}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{17}{17/17}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {17}{17}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{18}{18/18}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {18}{18}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{19}{19/19}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {19}{19}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{20}{20/20}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {20}{20}}}
+\@writefile{nav}{\headcommand {\slideentry {0}{0}{21}{21/21}{}{0}}}
+\@writefile{nav}{\headcommand {\beamer@framepages {21}{21}}}
+\@writefile{nav}{\headcommand {\beamer@partpages {1}{21}}}
+\@writefile{nav}{\headcommand {\beamer@subsectionpages {1}{21}}}
+\@writefile{nav}{\headcommand {\beamer@sectionpages {1}{21}}}
+\@writefile{nav}{\headcommand {\beamer@documentpages {21}}}
+\@writefile{nav}{\headcommand {\gdef \inserttotalframenumber {21}}}
diff --git a/src/Lecture7/slides/X2-StudentsRequests.log b/src/Lecture7/slides/X2-StudentsRequests.log
new file mode 100644
index 0000000..3af479e
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.log
@@ -0,0 +1,1307 @@
+This is pdfTeX, Version 3.14159265-2.6-1.40.20 (TeX Live 2019/Debian) (preloaded format=pdflatex 2021.5.20)  25 MAY 2021 16:22
+entering extended mode
+ \write18 enabled.
+ %&-line parsing enabled.
+**X2-StudentsRequests.tex
+(./X2-StudentsRequests.tex
+LaTeX2e <2020-02-02> patch level 2
+L3 programming layer <2020-02-14>
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamer.cls
+Document Class: beamer 2019/09/29 v3.57 A class for typesetting presentations
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasemodes.sty
+(/usr/share/texlive/texmf-dist/tex/latex/etoolbox/etoolbox.sty
+Package: etoolbox 2019/09/21 v2.5h e-TeX tools for LaTeX (JAW)
+\etb@tempcnta=\count167
+)
+\beamer@tempbox=\box45
+\beamer@tempcount=\count168
+\c@beamerpauses=\count169
+
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasedecode.sty
+\beamer@slideinframe=\count170
+\beamer@minimum=\count171
+\beamer@decode@box=\box46
+)
+\beamer@commentbox=\box47
+\beamer@modecount=\count172
+)
+(/usr/share/texlive/texmf-dist/tex/generic/iftex/ifpdf.sty
+Package: ifpdf 2019/10/25 v3.4 ifpdf legacy package. Use iftex instead.
+
+(/usr/share/texlive/texmf-dist/tex/generic/iftex/iftex.sty
+Package: iftex 2019/11/07 v1.0c TeX engine tests
+))
+\headdp=\dimen134
+\footheight=\dimen135
+\sidebarheight=\dimen136
+\beamer@tempdim=\dimen137
+\beamer@finalheight=\dimen138
+\beamer@animht=\dimen139
+\beamer@animdp=\dimen140
+\beamer@animwd=\dimen141
+\beamer@leftmargin=\dimen142
+\beamer@rightmargin=\dimen143
+\beamer@leftsidebar=\dimen144
+\beamer@rightsidebar=\dimen145
+\beamer@boxsize=\dimen146
+\beamer@vboxoffset=\dimen147
+\beamer@descdefault=\dimen148
+\beamer@descriptionwidth=\dimen149
+\beamer@lastskip=\skip47
+\beamer@areabox=\box48
+\beamer@animcurrent=\box49
+\beamer@animshowbox=\box50
+\beamer@sectionbox=\box51
+\beamer@logobox=\box52
+\beamer@linebox=\box53
+\beamer@sectioncount=\count173
+\beamer@subsubsectionmax=\count174
+\beamer@subsectionmax=\count175
+\beamer@sectionmax=\count176
+\beamer@totalheads=\count177
+\beamer@headcounter=\count178
+\beamer@partstartpage=\count179
+\beamer@sectionstartpage=\count180
+\beamer@subsectionstartpage=\count181
+\beamer@animationtempa=\count182
+\beamer@animationtempb=\count183
+\beamer@xpos=\count184
+\beamer@ypos=\count185
+\beamer@ypos@offset=\count186
+\beamer@showpartnumber=\count187
+\beamer@currentsubsection=\count188
+\beamer@coveringdepth=\count189
+\beamer@sectionadjust=\count190
+\beamer@tocsectionnumber=\count191
+
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseoptions.sty
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/keyval.sty
+Package: keyval 2014/10/28 v1.15 key=value parser (DPC)
+\KV@toks@=\toks14
+))
+\beamer@paperwidth=\skip48
+\beamer@paperheight=\skip49
+
+(/usr/share/texlive/texmf-dist/tex/latex/geometry/geometry.sty
+Package: geometry 2020/01/02 v5.9 Page Geometry
+
+(/usr/share/texlive/texmf-dist/tex/generic/iftex/ifvtex.sty
+Package: ifvtex 2019/10/25 v1.7 ifvtex legacy package. Use iftex instead.
+)
+\Gm@cnth=\count192
+\Gm@cntv=\count193
+\c@Gm@tempcnt=\count194
+\Gm@bindingoffset=\dimen150
+\Gm@wd@mp=\dimen151
+\Gm@odd@mp=\dimen152
+\Gm@even@mp=\dimen153
+\Gm@layoutwidth=\dimen154
+\Gm@layoutheight=\dimen155
+\Gm@layouthoffset=\dimen156
+\Gm@layoutvoffset=\dimen157
+\Gm@dimlist=\toks15
+)
+(/usr/share/texlive/texmf-dist/tex/latex/base/size11.clo
+File: size11.clo 2019/12/20 v1.4l Standard LaTeX file (size option)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/basiclayer/pgfcore.sty
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphicx.sty
+Package: graphicx 2019/11/30 v1.2a Enhanced LaTeX Graphics (DPC,SPQR)
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/graphics.sty
+Package: graphics 2019/11/30 v1.4a Standard LaTeX Graphics (DPC,SPQR)
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics/trig.sty
+Package: trig 2016/01/03 v1.10 sin cos tan (DPC)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/graphics.cfg
+File: graphics.cfg 2016/06/04 v1.11 sample graphics configuration
+)
+Package graphics Info: Driver file: pdftex.def on input line 105.
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics-def/pdftex.def
+File: pdftex.def 2018/01/08 v1.0l Graphics/color driver for pdftex
+))
+\Gin@req@height=\dimen158
+\Gin@req@width=\dimen159
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/systemlayer/pgfsys.sty
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/pgfrcs.sty
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfutil-common.tex
+\pgfutil@everybye=\toks16
+\pgfutil@tempdima=\dimen160
+\pgfutil@tempdimb=\dimen161
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfutil-common-lists.t
+ex)) (/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfutil-latex.def
+\pgfutil@abb=\box54
+(/usr/share/texlive/texmf-dist/tex/latex/ms/everyshi.sty
+Package: everyshi 2001/05/15 v3.00 EveryShipout Package (MS)
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfrcs.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/pgf.revision.tex)
+Package: pgfrcs 2020/01/08 v3.1.5b (3.1.5b)
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsys.code.tex
+Package: pgfsys 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex
+\pgfkeys@pathtoks=\toks17
+\pgfkeys@temptoks=\toks18
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfkeysfiltered.code.t
+ex
+\pgfkeys@tmptoks=\toks19
+))
+\pgf@x=\dimen162
+\pgf@y=\dimen163
+\pgf@xa=\dimen164
+\pgf@ya=\dimen165
+\pgf@xb=\dimen166
+\pgf@yb=\dimen167
+\pgf@xc=\dimen168
+\pgf@yc=\dimen169
+\pgf@xd=\dimen170
+\pgf@yd=\dimen171
+\w@pgf@writea=\write3
+\r@pgf@reada=\read2
+\c@pgf@counta=\count195
+\c@pgf@countb=\count196
+\c@pgf@countc=\count197
+\c@pgf@countd=\count198
+\t@pgf@toka=\toks20
+\t@pgf@tokb=\toks21
+\t@pgf@tokc=\toks22
+\pgf@sys@id@count=\count199
+ (/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgf.cfg
+File: pgf.cfg 2020/01/08 v3.1.5b (3.1.5b)
+)
+Driver file for pgf: pgfsys-pdftex.def
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsys-pdftex.def
+File: pgfsys-pdftex.def 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsys-common-pdf.de
+f
+File: pgfsys-common-pdf.def 2020/01/08 v3.1.5b (3.1.5b)
+)))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsyssoftpath.code.
+tex
+File: pgfsyssoftpath.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfsyssoftpath@smallbuffer@items=\count266
+\pgfsyssoftpath@bigbuffer@items=\count267
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/systemlayer/pgfsysprotocol.code.
+tex
+File: pgfsysprotocol.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)) (/usr/share/texlive/texmf-dist/tex/latex/xcolor/xcolor.sty
+Package: xcolor 2016/05/11 v2.12 LaTeX color extensions (UK)
+
+(/usr/share/texlive/texmf-dist/tex/latex/graphics-cfg/color.cfg
+File: color.cfg 2016/01/02 v1.6 sample color configuration
+)
+Package xcolor Info: Driver file: pdftex.def on input line 225.
+Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1348.
+Package xcolor Info: Model `hsb' substituted by `rgb' on input line 1352.
+Package xcolor Info: Model `RGB' extended on input line 1364.
+Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1366.
+Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1367.
+Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1368.
+Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1369.
+Package xcolor Info: Model `Gray' substituted by `gray' on input line 1370.
+Package xcolor Info: Model `wave' substituted by `hsb' on input line 1371.
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcore.code.tex
+Package: pgfcore 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmath.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathcalc.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathutil.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathparser.code.tex
+\pgfmath@dimen=\dimen172
+\pgfmath@count=\count268
+\pgfmath@box=\box55
+\pgfmath@toks=\toks23
+\pgfmath@stack@operand=\toks24
+\pgfmath@stack@operation=\toks25
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.basic.code
+.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.trigonomet
+ric.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.random.cod
+e.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.comparison
+.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.base.code.
+tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.round.code
+.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.misc.code.
+tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.integerari
+thmetics.code.tex)))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmathfloat.code.tex
+\c@pgfmathroundto@lastzeros=\count269
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfint.code.tex)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepoints.code.te
+x
+File: pgfcorepoints.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@picminx=\dimen173
+\pgf@picmaxx=\dimen174
+\pgf@picminy=\dimen175
+\pgf@picmaxy=\dimen176
+\pgf@pathminx=\dimen177
+\pgf@pathmaxx=\dimen178
+\pgf@pathminy=\dimen179
+\pgf@pathmaxy=\dimen180
+\pgf@xx=\dimen181
+\pgf@xy=\dimen182
+\pgf@yx=\dimen183
+\pgf@yy=\dimen184
+\pgf@zx=\dimen185
+\pgf@zy=\dimen186
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathconstruct.
+code.tex
+File: pgfcorepathconstruct.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@path@lastx=\dimen187
+\pgf@path@lasty=\dimen188
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathusage.code
+.tex
+File: pgfcorepathusage.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@shorten@end@additional=\dimen189
+\pgf@shorten@start@additional=\dimen190
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorescopes.code.te
+x
+File: pgfcorescopes.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfpic=\box56
+\pgf@hbox=\box57
+\pgf@layerbox@main=\box58
+\pgf@picture@serial@count=\count270
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoregraphicstate.c
+ode.tex
+File: pgfcoregraphicstate.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgflinewidth=\dimen191
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoretransformation
+s.code.tex
+File: pgfcoretransformations.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@pt@x=\dimen192
+\pgf@pt@y=\dimen193
+\pgf@pt@temp=\dimen194
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorequick.code.tex
+File: pgfcorequick.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreobjects.code.t
+ex
+File: pgfcoreobjects.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathprocessing
+.code.tex
+File: pgfcorepathprocessing.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorearrows.code.te
+x
+File: pgfcorearrows.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfarrowsep=\dimen195
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreshade.code.tex
+File: pgfcoreshade.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@max=\dimen196
+\pgf@sys@shading@range@num=\count271
+\pgf@shadingcount=\count272
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreimage.code.tex
+File: pgfcoreimage.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreexternal.code.
+tex
+File: pgfcoreexternal.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfexternal@startupbox=\box59
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorelayers.code.te
+x
+File: pgfcorelayers.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcoretransparency.c
+ode.tex
+File: pgfcoretransparency.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepatterns.code.
+tex
+File: pgfcorepatterns.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/basiclayer/pgfcorerdf.code.tex
+File: pgfcorerdf.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+))) (/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/xxcolor.sty
+Package: xxcolor 2003/10/24 ver 0.1
+\XC@nummixins=\count273
+\XC@countmixins=\count274
+)
+(/usr/share/texlive/texmf-dist/tex/generic/atbegshi/atbegshi.sty
+Package: atbegshi 2019/12/05 v1.19 At begin shipout hook (HO)
+
+(/usr/share/texlive/texmf-dist/tex/generic/infwarerr/infwarerr.sty
+Package: infwarerr 2019/12/03 v1.5 Providing info/warning/error messages (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/ltxcmds/ltxcmds.sty
+Package: ltxcmds 2019/12/15 v1.24 LaTeX kernel commands for general use (HO)
+))
+(/usr/share/texlive/texmf-dist/tex/latex/hyperref/hyperref.sty
+Package: hyperref 2020/01/14 v7.00d Hypertext links for LaTeX
+
+(/usr/share/texlive/texmf-dist/tex/latex/pdftexcmds/pdftexcmds.sty
+Package: pdftexcmds 2019/11/24 v0.31 Utility functions of pdfTeX for LuaTeX (HO
+)
+Package pdftexcmds Info: \pdf@primitive is available.
+Package pdftexcmds Info: \pdf@ifprimitive is available.
+Package pdftexcmds Info: \pdfdraftmode found.
+)
+(/usr/share/texlive/texmf-dist/tex/generic/kvsetkeys/kvsetkeys.sty
+Package: kvsetkeys 2019/12/15 v1.18 Key value parser (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/kvdefinekeys/kvdefinekeys.sty
+Package: kvdefinekeys 2019-12-19 v1.6 Define keys (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pdfescape/pdfescape.sty
+Package: pdfescape 2019/12/09 v1.15 Implements pdfTeX's escape features (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/hycolor/hycolor.sty
+Package: hycolor 2020-01-27 v1.10 Color options for hyperref/bookmark (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/letltxmacro/letltxmacro.sty
+Package: letltxmacro 2019/12/03 v1.6 Let assignment for LaTeX macros (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/auxhook/auxhook.sty
+Package: auxhook 2019-12-17 v1.6 Hooks for auxiliary files (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/kvoptions/kvoptions.sty
+Package: kvoptions 2019/11/29 v3.13 Key value format for package options (HO)
+)
+\@linkdim=\dimen197
+\Hy@linkcounter=\count275
+\Hy@pagecounter=\count276
+
+(/usr/share/texlive/texmf-dist/tex/latex/hyperref/pd1enc.def
+File: pd1enc.def 2020/01/14 v7.00d Hyperref: PDFDocEncoding definition (HO)
+Now handling font encoding PD1 ...
+... no UTF-8 mapping file for font encoding PD1
+)
+(/usr/share/texlive/texmf-dist/tex/generic/intcalc/intcalc.sty
+Package: intcalc 2019/12/15 v1.3 Expandable calculations with integers (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/etexcmds/etexcmds.sty
+Package: etexcmds 2019/12/15 v1.7 Avoid name clashes with e-TeX commands (HO)
+)
+\Hy@SavedSpaceFactor=\count277
+\pdfmajorversion=\count278
+Package hyperref Info: Option `bookmarks' set `true' on input line 4421.
+Package hyperref Info: Option `bookmarksopen' set `true' on input line 4421.
+Package hyperref Info: Option `implicit' set `false' on input line 4421.
+Package hyperref Info: Hyper figures OFF on input line 4547.
+Package hyperref Info: Link nesting OFF on input line 4552.
+Package hyperref Info: Hyper index ON on input line 4555.
+Package hyperref Info: Plain pages OFF on input line 4562.
+Package hyperref Info: Backreferencing OFF on input line 4567.
+Package hyperref Info: Implicit mode OFF; no redefinition of LaTeX internals.
+Package hyperref Info: Bookmarks ON on input line 4800.
+\c@Hy@tempcnt=\count279
+
+(/usr/share/texlive/texmf-dist/tex/latex/url/url.sty
+\Urlmuskip=\muskip16
+Package: url 2013/09/16  ver 3.4  Verb mode for urls, etc.
+)
+LaTeX Info: Redefining \url on input line 5159.
+\XeTeXLinkMargin=\dimen198
+
+(/usr/share/texlive/texmf-dist/tex/generic/bitset/bitset.sty
+Package: bitset 2019/12/09 v1.3 Handle bit-vector datatype (HO)
+
+(/usr/share/texlive/texmf-dist/tex/generic/bigintcalc/bigintcalc.sty
+Package: bigintcalc 2019/12/15 v1.5 Expandable calculations on big integers (HO
+)
+))
+\Fld@menulength=\count280
+\Field@Width=\dimen199
+\Fld@charsize=\dimen256
+Package hyperref Info: Hyper figures OFF on input line 6430.
+Package hyperref Info: Link nesting OFF on input line 6435.
+Package hyperref Info: Hyper index ON on input line 6438.
+Package hyperref Info: backreferencing OFF on input line 6445.
+Package hyperref Info: Link coloring OFF on input line 6450.
+Package hyperref Info: Link coloring with OCG OFF on input line 6455.
+Package hyperref Info: PDF/A mode OFF on input line 6460.
+LaTeX Info: Redefining \ref on input line 6500.
+LaTeX Info: Redefining \pageref on input line 6504.
+\Hy@abspage=\count281
+
+
+Package hyperref Message: Stopped early.
+
+)
+Package hyperref Info: Driver (autodetected): hpdftex.
+ (/usr/share/texlive/texmf-dist/tex/latex/hyperref/hpdftex.def
+File: hpdftex.def 2020/01/14 v7.00d Hyperref driver for pdfTeX
+
+(/usr/share/texlive/texmf-dist/tex/latex/atveryend/atveryend.sty
+Package: atveryend 2019-12-11 v1.11 Hooks at the very end of document (HO)
+)
+\Fld@listcount=\count282
+\c@bookmark@seq@number=\count283
+
+(/usr/share/texlive/texmf-dist/tex/latex/rerunfilecheck/rerunfilecheck.sty
+Package: rerunfilecheck 2019/12/05 v1.9 Rerun checks for auxiliary files (HO)
+
+(/usr/share/texlive/texmf-dist/tex/generic/uniquecounter/uniquecounter.sty
+Package: uniquecounter 2019/12/15 v1.4 Provide unlimited unique counter (HO)
+)
+Package uniquecounter Info: New unique counter `rerunfilecheck' on input line 2
+86.
+))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaserequires.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasecompatibility.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasefont.sty
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amssymb.sty
+Package: amssymb 2013/01/14 v3.01 AMS font symbols
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/amsfonts.sty
+Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support
+\@emptytoks=\toks26
+\symAMSa=\mathgroup4
+\symAMSb=\mathgroup5
+LaTeX Font Info:    Redeclaring math symbol \hbar on input line 98.
+LaTeX Font Info:    Overwriting math alphabet `\mathfrak' in version `bold'
+(Font)                  U/euf/m/n --> U/euf/b/n on input line 106.
+))
+(/usr/share/texlive/texmf-dist/tex/latex/sansmathaccent/sansmathaccent.sty
+Package: sansmathaccent 2020/01/31
+
+(/usr/share/texlive/texmf-dist/tex/latex/koma-script/scrlfile.sty
+Package: scrlfile 2020/01/24 v3.29 KOMA-Script package (loading files)
+)))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetranslator.sty
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator.sty
+Package: translator 2019-05-31 v1.12a Easy translation of strings in LaTeX
+))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasemisc.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetwoscreens.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseoverlay.sty
+\beamer@argscount=\count284
+\beamer@lastskipcover=\skip50
+\beamer@trivlistdepth=\count285
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetitle.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasesection.sty
+\c@lecture=\count286
+\c@part=\count287
+\c@section=\count288
+\c@subsection=\count289
+\c@subsubsection=\count290
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseframe.sty
+\beamer@framebox=\box60
+\beamer@frametitlebox=\box61
+\beamer@zoombox=\box62
+\beamer@zoomcount=\count291
+\beamer@zoomframecount=\count292
+\beamer@frametextheight=\dimen257
+\c@subsectionslide=\count293
+\beamer@frametopskip=\skip51
+\beamer@framebottomskip=\skip52
+\beamer@frametopskipautobreak=\skip53
+\beamer@framebottomskipautobreak=\skip54
+\beamer@envbody=\toks27
+\framewidth=\dimen258
+\c@framenumber=\count294
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseverbatim.sty
+\beamer@verbatimfileout=\write4
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseframesize.sty
+\beamer@splitbox=\box63
+\beamer@autobreakcount=\count295
+\beamer@autobreaklastheight=\dimen259
+\beamer@frametitletoks=\toks28
+\beamer@framesubtitletoks=\toks29
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseframecomponents.sty
+\beamer@footins=\box64
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasecolor.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasenotes.sty
+\beamer@frameboxcopy=\box65
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetoc.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetemplates.sty
+\beamer@sbttoks=\toks30
+
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseauxtemplates.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaseboxes.sty
+\bmb@box=\box66
+\bmb@colorbox=\box67
+\bmb@boxshadow=\box68
+\bmb@boxshadowball=\box69
+\bmb@boxshadowballlarge=\box70
+\bmb@temp=\dimen260
+\bmb@dima=\dimen261
+\bmb@dimb=\dimen262
+\bmb@prevheight=\dimen263
+)
+\beamer@blockheadheight=\dimen264
+))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbaselocalstructure.sty
+(/usr/share/texlive/texmf-dist/tex/latex/tools/enumerate.sty
+Package: enumerate 2015/07/23 v3.00 enumerate extensions (DPC)
+\@enLab=\toks31
+)
+\c@figure=\count296
+\c@table=\count297
+\abovecaptionskip=\skip55
+\belowcaptionskip=\skip56
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasenavigation.sty
+\beamer@section@min@dim=\dimen265
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasetheorems.sty
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsmath.sty
+Package: amsmath 2020/01/20 v2.17e AMS math features
+\@mathmargin=\skip57
+
+For additional information on amsmath, use the `?' option.
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amstext.sty
+Package: amstext 2000/06/29 v2.01 AMS text
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsgen.sty
+File: amsgen.sty 1999/11/30 v2.0 generic functions
+\@emptytoks=\toks32
+\ex@=\dimen266
+))
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsbsy.sty
+Package: amsbsy 1999/11/29 v1.2d Bold Symbols
+\pmbraise@=\dimen267
+)
+(/usr/share/texlive/texmf-dist/tex/latex/amsmath/amsopn.sty
+Package: amsopn 2016/03/08 v2.02 operator names
+)
+\inf@bad=\count298
+LaTeX Info: Redefining \frac on input line 227.
+\uproot@=\count299
+\leftroot@=\count300
+LaTeX Info: Redefining \overline on input line 389.
+\classnum@=\count301
+\DOTSCASE@=\count302
+LaTeX Info: Redefining \ldots on input line 486.
+LaTeX Info: Redefining \dots on input line 489.
+LaTeX Info: Redefining \cdots on input line 610.
+\Mathstrutbox@=\box71
+\strutbox@=\box72
+\big@size=\dimen268
+LaTeX Font Info:    Redeclaring font encoding OML on input line 733.
+LaTeX Font Info:    Redeclaring font encoding OMS on input line 734.
+\macc@depth=\count303
+\c@MaxMatrixCols=\count304
+\dotsspace@=\muskip17
+\c@parentequation=\count305
+\dspbrk@lvl=\count306
+\tag@help=\toks33
+\row@=\count307
+\column@=\count308
+\maxfields@=\count309
+\andhelp@=\toks34
+\eqnshift@=\dimen269
+\alignsep@=\dimen270
+\tagshift@=\dimen271
+\tagwidth@=\dimen272
+\totwidth@=\dimen273
+\lineht@=\dimen274
+\@envbody=\toks35
+\multlinegap=\skip58
+\multlinetaggap=\skip59
+\mathdisplay@stack=\toks36
+LaTeX Info: Redefining \[ on input line 2859.
+LaTeX Info: Redefining \] on input line 2860.
+)
+(/usr/share/texlive/texmf-dist/tex/latex/amscls/amsthm.sty
+Package: amsthm 2017/10/31 v2.20.4
+\thm@style=\toks37
+\thm@bodyfont=\toks38
+\thm@headfont=\toks39
+\thm@notefont=\toks40
+\thm@headpunct=\toks41
+\thm@preskip=\skip60
+\thm@postskip=\skip61
+\thm@headsep=\skip62
+\dth@everypar=\toks42
+)
+\c@theorem=\count310
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerbasethemes.sty))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerthemedefault.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerfontthemedefault.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamercolorthemedefault.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerinnerthemedefault.sty
+\beamer@dima=\dimen275
+\beamer@dimb=\dimen276
+)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerouterthemedefault.sty)))
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerthemeMadrid.sty
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamercolorthemewhale.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamercolorthemeorchid.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerinnerthemerounded.sty)
+(/usr/share/texlive/texmf-dist/tex/latex/beamer/beamerouterthemeinfolines.sty))
+(/usr/share/texlive/texmf-dist/tex/latex/base/inputenc.sty
+Package: inputenc 2018/08/11 v1.3c Input encoding file
+\inpenc@prehook=\toks43
+\inpenc@posthook=\toks44
+)
+(/usr/share/texlive/texmf-dist/tex/latex/svg/svg.sty
+Package: svg 2020/01/13 v2.02e (include SVG pictures)
+
+(/usr/share/texlive/texmf-dist/tex/latex/koma-script/scrbase.sty
+Package: scrbase 2020/01/24 v3.29 KOMA-Script package (KOMA-Script-independent 
+basics and keyval usage)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/tools/shellesc.sty
+Package: shellesc 2019/11/08 v1.0c unified shell escape interface for LaTeX
+Package shellesc Info: Unrestricted shell escape enabled on input line 75.
+)
+(/usr/share/texlive/texmf-dist/tex/latex/trimspaces/trimspaces.sty
+Package: trimspaces 2009/09/17 v1.1 Trim spaces around a token list
+)
+\svg@box=\box73
+\c@svg@param@lastpage=\count311
+\c@svg@param@currpage=\count312
+
+(/usr/share/texlive/texmf-dist/tex/latex/ifplatform/ifplatform.sty
+Package: ifplatform 2017/10/13 v0.4a Testing for the operating system
+
+(/usr/share/texlive/texmf-dist/tex/generic/catchfile/catchfile.sty
+Package: catchfile 2019/12/09 v1.8 Catch the contents of a file (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/iftex/ifluatex.sty
+Package: ifluatex 2019/10/25 v1.5 ifluatex legacy package. Use iftex instead.
+)
+runsystem(uname -s > "X2-StudentsRequests.w18")...executed.
+
+
+(./X2-StudentsRequests.w18)
+runsystem(rm -- "X2-StudentsRequests.w18")...executed.
+
+))
+(/usr/share/texlive/texmf-dist/tex/latex/transparent/transparent.sty
+Package: transparent 2019/11/29 v1.4 Transparency via pdfTeX's color stack (HO)
+
+)
+(/usr/share/texlive/texmf-dist/tex/latex/listings/listings.sty
+\lst@mode=\count313
+\lst@gtempboxa=\box74
+\lst@token=\toks45
+\lst@length=\count314
+\lst@currlwidth=\dimen277
+\lst@column=\count315
+\lst@pos=\count316
+\lst@lostspace=\dimen278
+\lst@width=\dimen279
+\lst@newlines=\count317
+\lst@lineno=\count318
+\lst@maxwidth=\dimen280
+
+(/usr/share/texlive/texmf-dist/tex/latex/listings/lstmisc.sty
+File: lstmisc.sty 2019/09/10 1.8c (Carsten Heinz)
+\c@lstnumber=\count319
+\lst@skipnumbers=\count320
+\lst@framebox=\box75
+)
+(/usr/share/texlive/texmf-dist/tex/latex/listings/listings.cfg
+File: listings.cfg 2019/09/10 1.8c listings configuration
+))
+Package: listings 2019/09/10 1.8c (Carsten Heinz)
+
+(/usr/share/texlive/texmf-dist/tex/latex/mathtools/mathtools.sty
+Package: mathtools 2020/01/17 v1.23 mathematical typesetting tools
+
+(/usr/share/texlive/texmf-dist/tex/latex/tools/calc.sty
+Package: calc 2017/05/25 v4.3 Infix arithmetic (KKT,FJ)
+\calc@Acount=\count321
+\calc@Bcount=\count322
+\calc@Adimen=\dimen281
+\calc@Bdimen=\dimen282
+\calc@Askip=\skip63
+\calc@Bskip=\skip64
+LaTeX Info: Redefining \setlength on input line 80.
+LaTeX Info: Redefining \addtolength on input line 81.
+\calc@Ccount=\count323
+\calc@Cskip=\skip65
+)
+(/usr/share/texlive/texmf-dist/tex/latex/mathtools/mhsetup.sty
+Package: mhsetup 2017/03/31 v1.3 programming setup (MH)
+)
+LaTeX Info: Thecontrolsequence`\('isalreadyrobust on input line 129.
+LaTeX Info: Thecontrolsequence`\)'isalreadyrobust on input line 129.
+LaTeX Info: Thecontrolsequence`\['isalreadyrobust on input line 129.
+LaTeX Info: Thecontrolsequence`\]'isalreadyrobust on input line 129.
+\g_MT_multlinerow_int=\count324
+\l_MT_multwidth_dim=\dimen283
+\origjot=\skip66
+\l_MT_shortvdotswithinadjustabove_dim=\dimen284
+\l_MT_shortvdotswithinadjustbelow_dim=\dimen285
+\l_MT_above_intertext_sep=\dimen286
+\l_MT_below_intertext_sep=\dimen287
+\l_MT_above_shortintertext_sep=\dimen288
+\l_MT_below_shortintertext_sep=\dimen289
+)
+(/usr/share/texlive/texmf-dist/tex/latex/tikz-cd/tikz-cd.sty
+Package: tikz-cd 2018/11/19 v0.9f Commutative diagrams with TikZ
+
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/frontendlayer/tikz.sty
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/basiclayer/pgf.sty
+Package: pgf 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/modules/pgfmoduleshapes.code.tex
+File: pgfmoduleshapes.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfnodeparttextbox=\box76
+) (/usr/share/texlive/texmf-dist/tex/generic/pgf/modules/pgfmoduleplot.code.tex
+File: pgfmoduleplot.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/compatibility/pgfcomp-version-0-65
+.sty
+Package: pgfcomp-version-0-65 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@nodesepstart=\dimen290
+\pgf@nodesepend=\dimen291
+)
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/compatibility/pgfcomp-version-1-18
+.sty
+Package: pgfcomp-version-1-18 2020/01/08 v3.1.5b (3.1.5b)
+)) (/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/pgffor.sty
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/utilities/pgfkeys.sty
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex))
+(/usr/share/texlive/texmf-dist/tex/latex/pgf/math/pgfmath.sty
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmath.code.tex))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/utilities/pgffor.code.tex
+Package: pgffor 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/math/pgfmath.code.tex)
+\pgffor@iter=\dimen292
+\pgffor@skip=\dimen293
+\pgffor@stack=\toks46
+\pgffor@toks=\toks47
+))
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/tikz.code.tex
+Package: tikz 2020/01/08 v3.1.5b (3.1.5b)
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/libraries/pgflibraryplothandlers
+.code.tex
+File: pgflibraryplothandlers.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgf@plot@mark@count=\count325
+\pgfplotmarksize=\dimen294
+)
+\tikz@lastx=\dimen295
+\tikz@lasty=\dimen296
+\tikz@lastxsaved=\dimen297
+\tikz@lastysaved=\dimen298
+\tikz@lastmovetox=\dimen299
+\tikz@lastmovetoy=\dimen300
+\tikzleveldistance=\dimen301
+\tikzsiblingdistance=\dimen302
+\tikz@figbox=\box77
+\tikz@figbox@bg=\box78
+\tikz@tempbox=\box79
+\tikz@tempbox@bg=\box80
+\tikztreelevel=\count326
+\tikznumberofchildren=\count327
+\tikznumberofcurrentchild=\count328
+\tikz@fig@count=\count329
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/modules/pgfmodulematrix.code.tex
+File: pgfmodulematrix.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfmatrixcurrentrow=\count330
+\pgfmatrixcurrentcolumn=\count331
+\pgf@matrix@numberofcolumns=\count332
+)
+\tikz@expandcount=\count333
+
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/libraries/tik
+zlibrarytopaths.code.tex
+File: tikzlibrarytopaths.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)))
+(/usr/share/texlive/texmf-dist/tex/generic/tikz-cd/tikzlibrarycd.code.tex
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/libraries/tik
+zlibrarymatrix.code.tex
+File: tikzlibrarymatrix.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/frontendlayer/tikz/libraries/tik
+zlibraryquotes.code.tex
+File: tikzlibraryquotes.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/pgf/libraries/pgflibraryarrows.meta.
+code.tex
+File: pgflibraryarrows.meta.code.tex 2020/01/08 v3.1.5b (3.1.5b)
+\pgfarrowinset=\dimen303
+\pgfarrowlength=\dimen304
+\pgfarrowwidth=\dimen305
+\pgfarrowlinewidth=\dimen306
+))) (/usr/share/texlive/texmf-dist/tex/latex/adjustbox/adjustbox.sty
+Package: adjustbox 2019/01/04 v1.2 Adjusting TeX boxes (trim, clip, ...)
+
+(/usr/share/texlive/texmf-dist/tex/latex/xkeyval/xkeyval.sty
+Package: xkeyval 2014/12/03 v2.7a package option processing (HA)
+
+(/usr/share/texlive/texmf-dist/tex/generic/xkeyval/xkeyval.tex
+(/usr/share/texlive/texmf-dist/tex/generic/xkeyval/xkvutils.tex
+\XKV@toks=\toks48
+\XKV@tempa@toks=\toks49
+)
+\XKV@depth=\count334
+File: xkeyval.tex 2014/12/03 v2.7a key=value parser (HA)
+))
+(/usr/share/texlive/texmf-dist/tex/latex/adjustbox/adjcalc.sty
+Package: adjcalc 2012/05/16 v1.1 Provides advanced setlength with multiple back
+-ends (calc, etex, pgfmath)
+)
+(/usr/share/texlive/texmf-dist/tex/latex/adjustbox/trimclip.sty
+Package: trimclip 2018/04/08 v1.1 Trim and clip general TeX material
+
+(/usr/share/texlive/texmf-dist/tex/latex/collectbox/collectbox.sty
+Package: collectbox 2012/05/17 v0.4b Collect macro arguments as boxes
+\collectedbox=\box81
+)
+\tc@llx=\dimen307
+\tc@lly=\dimen308
+\tc@urx=\dimen309
+\tc@ury=\dimen310
+Package trimclip Info: Using driver 'tc-pdftex.def'.
+
+(/usr/share/texlive/texmf-dist/tex/latex/adjustbox/tc-pdftex.def
+File: tc-pdftex.def 2019/01/04 v2.2 Clipping driver for pdftex
+))
+\adjbox@Width=\dimen311
+\adjbox@Height=\dimen312
+\adjbox@Depth=\dimen313
+\adjbox@Totalheight=\dimen314
+\adjbox@pwidth=\dimen315
+\adjbox@pheight=\dimen316
+\adjbox@pdepth=\dimen317
+\adjbox@ptotalheight=\dimen318
+
+(/usr/share/texlive/texmf-dist/tex/latex/ifoddpage/ifoddpage.sty
+Package: ifoddpage 2016/04/23 v1.1 Conditionals for odd/even page detection
+\c@checkoddpage=\count335
+)
+(/usr/share/texlive/texmf-dist/tex/latex/varwidth/varwidth.sty
+Package: varwidth 2009/03/30 ver 0.92;  Variable-width minipages
+\@vwid@box=\box82
+\sift@deathcycles=\count336
+\@vwid@loff=\dimen319
+\@vwid@roff=\dimen320
+))
+(/usr/share/texlive/texmf-dist/tex/latex/listings/lstlang1.sty
+File: lstlang1.sty 2019/09/10 1.8c listings language file
+)
+(/usr/share/texlive/texmf-dist/tex/latex/l3backend/l3backend-pdfmode.def
+File: l3backend-pdfmode.def 2020-02-03 L3 backend support: PDF mode
+\l__kernel_color_stack_int=\count337
+\l__pdf_internal_box=\box83
+)
+(./X2-StudentsRequests.aux)
+\openout1 = `X2-StudentsRequests.aux'.
+
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+LaTeX Font Info:    Checking defaults for TS1/cmr/m/n on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+LaTeX Font Info:    Checking defaults for PD1/pdf/m/n on input line 33.
+LaTeX Font Info:    ... okay on input line 33.
+
+*geometry* driver: auto-detecting
+*geometry* detected driver: pdftex
+*geometry* verbose mode - [ preamble ] result:
+* driver: pdftex
+* paper: custom
+* layout: <same size as paper>
+* layoutoffset:(h,v)=(0.0pt,0.0pt)
+* modes: includehead includefoot 
+* h-part:(L,W,R)=(10.95003pt, 342.2953pt, 10.95003pt)
+* v-part:(T,H,B)=(0.0pt, 273.14662pt, 0.0pt)
+* \paperwidth=364.19536pt
+* \paperheight=273.14662pt
+* \textwidth=342.2953pt
+* \textheight=244.6939pt
+* \oddsidemargin=-61.31996pt
+* \evensidemargin=-61.31996pt
+* \topmargin=-72.26999pt
+* \headheight=14.22636pt
+* \headsep=0.0pt
+* \topskip=11.0pt
+* \footskip=14.22636pt
+* \marginparwidth=4.0pt
+* \marginparsep=10.0pt
+* \columnsep=10.0pt
+* \skip\footins=10.0pt plus 4.0pt minus 2.0pt
+* \hoffset=0.0pt
+* \voffset=0.0pt
+* \mag=1000
+* \@twocolumnfalse
+* \@twosidefalse
+* \@mparswitchfalse
+* \@reversemarginfalse
+* (1in=72.27pt=25.4mm, 1cm=28.453pt)
+
+(/usr/share/texlive/texmf-dist/tex/context/base/mkii/supp-pdf.mkii
+[Loading MPS to PDF converter (version 2006.09.02).]
+\scratchcounter=\count338
+\scratchdimen=\dimen321
+\scratchbox=\box84
+\nofMPsegments=\count339
+\nofMParguments=\count340
+\everyMPshowfont=\toks50
+\MPscratchCnt=\count341
+\MPscratchDim=\dimen322
+\MPnumerator=\count342
+\makeMPintoPDFobject=\count343
+\everyMPtoPDFconversion=\toks51
+) (/usr/share/texlive/texmf-dist/tex/latex/epstopdf-pkg/epstopdf-base.sty
+Package: epstopdf-base 2020-01-24 v2.11 Base part for package epstopdf
+Package epstopdf-base Info: Redefining graphics rule for `.eps' on input line 4
+85.
+
+(/usr/share/texlive/texmf-dist/tex/latex/latexconfig/epstopdf-sys.cfg
+File: epstopdf-sys.cfg 2010/07/13 v1.3 Configuration of (r)epstopdf for TeX Liv
+e
+))
+ABD: EveryShipout initializing macros
+\AtBeginShipoutBox=\box85
+Package hyperref Info: Link coloring OFF on input line 33.
+
+(/usr/share/texlive/texmf-dist/tex/latex/hyperref/nameref.sty
+Package: nameref 2019/09/16 v2.46 Cross-referencing by name of section
+
+(/usr/share/texlive/texmf-dist/tex/latex/refcount/refcount.sty
+Package: refcount 2019/12/15 v3.6 Data extraction from label references (HO)
+)
+(/usr/share/texlive/texmf-dist/tex/generic/gettitlestring/gettitlestring.sty
+Package: gettitlestring 2019/12/15 v1.6 Cleanup title references (HO)
+)
+\c@section@level=\count344
+)
+LaTeX Info: Redefining \ref on input line 33.
+LaTeX Info: Redefining \pageref on input line 33.
+LaTeX Info: Redefining \nameref on input line 33.
+
+(./X2-StudentsRequests.out) (./X2-StudentsRequests.out)
+\@outlinefile=\write5
+\openout5 = `X2-StudentsRequests.out'.
+
+LaTeX Font Info:    Overwriting symbol font `operators' in version `normal'
+(Font)                  OT1/cmr/m/n --> OT1/cmss/m/n on input line 33.
+LaTeX Font Info:    Overwriting symbol font `operators' in version `bold'
+(Font)                  OT1/cmr/bx/n --> OT1/cmss/b/n on input line 33.
+\symnumbers=\mathgroup6
+\sympureletters=\mathgroup7
+LaTeX Font Info:    Overwriting math alphabet `\mathrm' in version `normal'
+(Font)                  OT1/cmss/m/n --> OT1/cmr/m/n on input line 33.
+LaTeX Font Info:    Redeclaring math alphabet \mathbf on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathbf' in version `normal'
+(Font)                  OT1/cmr/bx/n --> OT1/cmss/b/n on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathbf' in version `bold'
+(Font)                  OT1/cmr/bx/n --> OT1/cmss/b/n on input line 33.
+LaTeX Font Info:    Redeclaring math alphabet \mathsf on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathsf' in version `normal'
+(Font)                  OT1/cmss/m/n --> OT1/cmss/m/n on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathsf' in version `bold'
+(Font)                  OT1/cmss/bx/n --> OT1/cmss/m/n on input line 33.
+LaTeX Font Info:    Redeclaring math alphabet \mathit on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathit' in version `normal'
+(Font)                  OT1/cmr/m/it --> OT1/cmss/m/it on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathit' in version `bold'
+(Font)                  OT1/cmr/bx/it --> OT1/cmss/m/it on input line 33.
+LaTeX Font Info:    Redeclaring math alphabet \mathtt on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathtt' in version `normal'
+(Font)                  OT1/cmtt/m/n --> OT1/cmtt/m/n on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathtt' in version `bold'
+(Font)                  OT1/cmtt/m/n --> OT1/cmtt/m/n on input line 33.
+LaTeX Font Info:    Overwriting symbol font `numbers' in version `bold'
+(Font)                  OT1/cmss/m/n --> OT1/cmss/b/n on input line 33.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `bold'
+(Font)                  OT1/cmss/m/it --> OT1/cmss/b/it on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathrm' in version `bold'
+(Font)                  OT1/cmss/b/n --> OT1/cmr/b/n on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathbf' in version `bold'
+(Font)                  OT1/cmss/b/n --> OT1/cmss/b/n on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathsf' in version `bold'
+(Font)                  OT1/cmss/m/n --> OT1/cmss/b/n on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathit' in version `bold'
+(Font)                  OT1/cmss/m/it --> OT1/cmss/b/it on input line 33.
+LaTeX Font Info:    Overwriting math alphabet `\mathtt' in version `bold'
+(Font)                  OT1/cmtt/m/n --> OT1/cmtt/b/n on input line 33.
+LaTeX Font Info:    Redeclaring symbol font `pureletters' on input line 33.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `normal'
+(Font)                  OT1/cmss/m/it --> OT1/mathkerncmss/m/sl on input line 3
+3.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `bold'
+(Font)                  OT1/cmss/b/it --> OT1/mathkerncmss/m/sl on input line 3
+3.
+LaTeX Font Info:    Overwriting symbol font `pureletters' in version `bold'
+(Font)                  OT1/mathkerncmss/m/sl --> OT1/mathkerncmss/bx/sl on inp
+ut line 33.
+
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-basic-dictionary
+-English.dict
+Dictionary: translator-basic-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-bibliography-dic
+tionary-English.dict
+Dictionary: translator-bibliography-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-environment-dict
+ionary-English.dict
+Dictionary: translator-environment-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-months-dictionar
+y-English.dict
+Dictionary: translator-months-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-numbers-dictiona
+ry-English.dict
+Dictionary: translator-numbers-dictionary, Language: English 
+)
+(/usr/share/texlive/texmf-dist/tex/latex/translator/translator-theorem-dictiona
+ry-English.dict
+Dictionary: translator-theorem-dictionary, Language: English 
+)
+\c@lstlisting=\count345
+ (./X2-StudentsRequests.nav)
+<img/unilu.jpg, id=20, 645.16031pt x 578.16pt>
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 37.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [1
+
+{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map} <./img/unilu.jpg>] [2
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 53.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [3
+
+]
+LaTeX Font Info:    Trying to load font information for U+msa on input line 76.
+
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/umsa.fd
+File: umsa.fd 2013/01/14 v3.01 AMS symbols A
+)
+LaTeX Font Info:    Trying to load font information for U+msb on input line 76.
+
+
+(/usr/share/texlive/texmf-dist/tex/latex/amsfonts/umsb.fd
+File: umsb.fd 2013/01/14 v3.01 AMS symbols B
+)
+LaTeX Font Info:    Trying to load font information for OT1+mathkerncmss on inp
+ut line 76.
+
+(/usr/share/texlive/texmf-dist/tex/latex/sansmathaccent/ot1mathkerncmss.fd
+File: ot1mathkerncmss.fd 2020/01/31 Fontinst v1.933 font definitions for OT1/ma
+thkerncmss.
+)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 76.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+
+[4
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 85.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [5
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 95.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [6
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 105.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [7
+
+]
+Package svg Info: Last page of `./svg-inkscape/DH_svg-tex.pdf' is 1 on input li
+ne 109.
+ (./svg-inkscape/DH_svg-tex.pdf_tex
+<./svg-inkscape/DH_svg-tex.pdf, id=228, page=1, 321.11218pt x 481.97127pt>
+File: ./svg-inkscape/DH_svg-tex.pdf Graphic file (type pdf)
+<use ./svg-inkscape/DH_svg-tex.pdf, page 1>
+Package pdftex.def Info: ./svg-inkscape/DH_svg-tex.pdf , page1 used on input li
+ne 56.
+(pdftex.def)             Requested size: 144.49948pt x 216.88507pt.
+)
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 109.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [8
+
+ <./svg-inkscape/DH_svg-tex.pdf>]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 120.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [9
+
+] [10
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 133.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [11
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 152.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [12
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 165.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [13
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 185.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [14
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 193.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [15
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 211.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [16
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 232.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [17
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 254.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [18
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 266.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [19
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 297.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [20
+
+]
+File: img/unilu.jpg Graphic file (type jpg)
+<use img/unilu.jpg>
+Package pdftex.def Info: img/unilu.jpg  used on input line 307.
+(pdftex.def)             Requested size: 64.5198pt x 57.81938pt.
+ [21
+
+]
+\tf@nav=\write6
+\openout6 = `X2-StudentsRequests.nav'.
+
+\tf@toc=\write7
+\openout7 = `X2-StudentsRequests.toc'.
+
+\tf@snm=\write8
+\openout8 = `X2-StudentsRequests.snm'.
+
+Package atveryend Info: Empty hook `BeforeClearDocument' on input line 309.
+Package atveryend Info: Empty hook `AfterLastShipout' on input line 309.
+
+(./X2-StudentsRequests.aux)
+Package atveryend Info: Executing hook `AtVeryEndDocument' on input line 309.
+Package atveryend Info: Executing hook `AtEndAfterFileList' on input line 309.
+Package rerunfilecheck Info: File `X2-StudentsRequests.out' has not changed.
+(rerunfilecheck)             Checksum: D41D8CD98F00B204E9800998ECF8427E;0.
+ ) 
+Here is how much of TeX's memory you used:
+ 25732 strings out of 481239
+ 509817 string characters out of 5920377
+ 960739 words of memory out of 5000000
+ 40331 multiletter control sequences out of 15000+600000
+ 545963 words of font info for 73 fonts, out of 8000000 for 9000
+ 1141 hyphenation exceptions out of 8191
+ 58i,21n,89p,803b,926s stack positions out of 5000i,500n,10000p,200000b,80000s
+</usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmex10.pfb></us
+r/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cmextra/cmex8.pfb></usr/
+share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi10.pfb></usr/share/
+texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi12.pfb></usr/share/texliv
+e/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi8.pfb></usr/share/texlive/texmf
+-dist/fonts/type1/public/amsfonts/cm/cmss10.pfb></usr/share/texlive/texmf-dist/
+fonts/type1/public/amsfonts/cm/cmss12.pfb></usr/share/texlive/texmf-dist/fonts/
+type1/public/amsfonts/cm/cmss17.pfb></usr/share/texlive/texmf-dist/fonts/type1/
+public/amsfonts/cm/cmss8.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/
+amsfonts/cm/cmssbx10.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/amsf
+onts/cm/cmssi10.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/
+cm/cmssi12.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cm
+ssi8.pfb></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy10.p
+fb></usr/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy7.pfb></us
+r/share/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy8.pfb></usr/share
+/texlive/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt8.pfb></usr/share/texliv
+e/texmf-dist/fonts/type1/public/amsfonts/symbols/msbm10.pfb>
+Output written on X2-StudentsRequests.pdf (21 pages, 271722 bytes).
+PDF statistics:
+ 687 PDF objects out of 1000 (max. 8388607)
+ 621 compressed objects within 7 object streams
+ 43 named destinations out of 1000 (max. 500000)
+ 106 words of extra memory for PDF output out of 10000 (max. 10000000)
+
diff --git a/src/Lecture7/slides/X2-StudentsRequests.nav b/src/Lecture7/slides/X2-StudentsRequests.nav
new file mode 100644
index 0000000..b90e3f7
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.nav
@@ -0,0 +1,47 @@
+\headcommand {\slideentry {0}{0}{1}{1/1}{}{0}}
+\headcommand {\beamer@framepages {1}{1}}
+\headcommand {\slideentry {0}{0}{2}{2/2}{}{0}}
+\headcommand {\beamer@framepages {2}{2}}
+\headcommand {\slideentry {0}{0}{3}{3/3}{}{0}}
+\headcommand {\beamer@framepages {3}{3}}
+\headcommand {\slideentry {0}{0}{4}{4/4}{}{0}}
+\headcommand {\beamer@framepages {4}{4}}
+\headcommand {\slideentry {0}{0}{5}{5/5}{}{0}}
+\headcommand {\beamer@framepages {5}{5}}
+\headcommand {\slideentry {0}{0}{6}{6/6}{}{0}}
+\headcommand {\beamer@framepages {6}{6}}
+\headcommand {\slideentry {0}{0}{7}{7/7}{}{0}}
+\headcommand {\beamer@framepages {7}{7}}
+\headcommand {\slideentry {0}{0}{8}{8/8}{}{0}}
+\headcommand {\beamer@framepages {8}{8}}
+\headcommand {\slideentry {0}{0}{9}{9/9}{}{0}}
+\headcommand {\beamer@framepages {9}{9}}
+\headcommand {\slideentry {0}{0}{10}{10/10}{}{0}}
+\headcommand {\beamer@framepages {10}{10}}
+\headcommand {\slideentry {0}{0}{11}{11/11}{}{0}}
+\headcommand {\beamer@framepages {11}{11}}
+\headcommand {\slideentry {0}{0}{12}{12/12}{}{0}}
+\headcommand {\beamer@framepages {12}{12}}
+\headcommand {\slideentry {0}{0}{13}{13/13}{}{0}}
+\headcommand {\beamer@framepages {13}{13}}
+\headcommand {\slideentry {0}{0}{14}{14/14}{}{0}}
+\headcommand {\beamer@framepages {14}{14}}
+\headcommand {\slideentry {0}{0}{15}{15/15}{}{0}}
+\headcommand {\beamer@framepages {15}{15}}
+\headcommand {\slideentry {0}{0}{16}{16/16}{}{0}}
+\headcommand {\beamer@framepages {16}{16}}
+\headcommand {\slideentry {0}{0}{17}{17/17}{}{0}}
+\headcommand {\beamer@framepages {17}{17}}
+\headcommand {\slideentry {0}{0}{18}{18/18}{}{0}}
+\headcommand {\beamer@framepages {18}{18}}
+\headcommand {\slideentry {0}{0}{19}{19/19}{}{0}}
+\headcommand {\beamer@framepages {19}{19}}
+\headcommand {\slideentry {0}{0}{20}{20/20}{}{0}}
+\headcommand {\beamer@framepages {20}{20}}
+\headcommand {\slideentry {0}{0}{21}{21/21}{}{0}}
+\headcommand {\beamer@framepages {21}{21}}
+\headcommand {\beamer@partpages {1}{21}}
+\headcommand {\beamer@subsectionpages {1}{21}}
+\headcommand {\beamer@sectionpages {1}{21}}
+\headcommand {\beamer@documentpages {21}}
+\headcommand {\gdef \inserttotalframenumber {21}}
diff --git a/src/Lecture7/slides/X2-StudentsRequests.out b/src/Lecture7/slides/X2-StudentsRequests.out
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.out
diff --git a/src/Lecture7/slides/X2-StudentsRequests.pdf b/src/Lecture7/slides/X2-StudentsRequests.pdf
new file mode 100644
index 0000000..8b5793e
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.pdf
diff --git a/src/Lecture7/slides/X2-StudentsRequests.snm b/src/Lecture7/slides/X2-StudentsRequests.snm
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.snm
diff --git a/src/Lecture7/slides/X2-StudentsRequests.tex b/src/Lecture7/slides/X2-StudentsRequests.tex
new file mode 100644
index 0000000..787e7fb
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.tex
@@ -0,0 +1,309 @@
+\documentclass[11pt]{beamer}
+\usetheme{Madrid}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath}
+
+\usepackage{svg}
+\usepackage{color}
+\usepackage{listings}
+\usepackage{mathtools}
+\usepackage{tikz-cd}
+\usepackage{adjustbox}
+
+\definecolor{myblue}{rgb}{0,0,0.5}
+\lstset{
+        language=Python,
+        tabsize=4,
+        basicstyle=\footnotesize,
+        keywordstyle=\bf\color{myblue},
+        commentstyle=\it\color{gray},
+        numbers=left,
+        numbersep=3pt,
+        numberstyle=\tiny\color{gray},
+}
+
+\author[\texttt{sebastiano.tronto@uni.lu}]{Sebastiano Tronto}
+\title[Students requests]%
+{Students requests}
+\logo{\includegraphics[scale=0.1]{img/unilu.jpg}} 
+%\institute{University of Luxembourg} 
+
+\date{2021-05-21} 
+
+\begin{document}
+
+\begin{frame}
+  \titlepage
+\end{frame}
+
+\begin{frame}[plain]
+        \begin{center} {\Huge More cryptography} \end{center}
+\end{frame}
+
+\begin{frame}{Cryptography}
+        What we have seen:
+
+        \vspace{0.3cm}
+        \begin{itemize}
+                \item \textbf{RSA:}
+                        sending messages using a private key / public key pair
+                \item \textbf{Flip-a-coin:}
+                        cryptographic ``proof'' that the opponent is not cheating
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Cryptography}
+        \begin{itemize}
+                \item Rely on integer factorization being hard
+
+                        \vspace{0.3cm}
+                        \textbf{Example:} the best-known factorization algorithm
+                        (\href{https://en.wikipedia.org/wiki/General\_number\_field\_sieve}%
+                        {\emph{General number field sieve}}) has complexity
+                        \begin{align*}
+                                \sim O\left(
+                                        e^{\sqrt[3]{\frac{64}{9}\log_2n\cdot(\log_2\log_2n)^2}}
+                                \right)
+                        \end{align*}
+
+                        Factoring a number with $300$ digits:
+                        \begin{itemize}
+                                \item Your laptop: $10^{13}$ billion years
+                                \item Best supercomputer: $13$ billion years
+                                        (age of the universe)
+                        \end{itemize}
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Symmetric and asymmetric cryptography}
+        \begin{itemize}
+                \item Our examples are \emph{asymmetric}: different public/private keys
+                \item Safe against eavesdroppers
+                \item Symmetric protocols can be faster and simpler, but you need
+                        a secure way to exchange a key
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Diffie-Hellman key exchange}
+        \begin{itemize}
+                \item Generate a ``password'' without communicating it directly
+                \item It can then be used for symmetric cryptography
+                \item Based on a different hard problem:
+                        \href{https://en.wikipedia.org/wiki/Discrete\_logarithm}%
+                        {\emph{discrete logarithm}}
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Diffie-Hellman key exchange}
+        \begin{itemize}
+                \item Alice and Bob agree on a prime number $p$ and an integer $g$
+                \item Alice picks an integer $a$ and sends $(g^a\bmod p)$ to Bob
+                \item Bob picks an integer $b$ and sends $(g^b\bmod p)$ to Alice
+                \item Alice can compute $(g^b)^a\bmod p$ and Bob can compute
+                        $(g^a)^b\bmod p$. This is their shared secret (key).
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Diffie-Hellman with colors (from Wikipedia)}
+        \begin{center}\includesvg[scale=0.45]{img/DH}\end{center}
+\end{frame}
+
+\begin{frame}{Diffie-Hellman key exchange}
+        \begin{itemize}
+                \item Knowing $h$ and $a$, it is hard to find $g$ such that
+                        $g^a \bmod p =h$ (discrete logarithm problem)
+                \item Very simple, many variants
+                \item Any group can be used, e.g. Elliptic Curves (see
+\href{https://en.wikipedia.org/wiki/Elliptic-curve_Diffie\%E2\%80\%93Hellman}%
+                        {Wikipedia: elliptic-curve Diffie-Hellman})
+        \end{itemize}
+\end{frame}
+
+
+\begin{frame}[plain]
+        \begin{center} {\Huge Numerical methods for PDEs} \end{center}
+\end{frame}
+
+\begin{frame}{Solving partial differential equations}
+        \begin{itemize}
+                \item Very, very hard
+                \item Very important in practical applications (physics and such)
+                \item Approximations are necessary, might as well use numerical methods
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{Numerical methods for ODEs}
+        \begin{block}{Problem}
+                Given $f(x,y)$, $x_0$ and $y_0$, find an approximation
+                for $y(x)$ such that
+                \begin{align*}
+                        \begin{cases}
+                                y'(x) = f(x, y(x))\\
+                                y(x_0) =y_0
+                        \end{cases}
+                \end{align*}
+        \end{block}
+
+        \begin{block}{Approximation}
+                We can describe $y(x)$ in an interval $[x_0,x_1]$ by giving the
+                (approximate) values $y(s_0)$, \dots, $y(s_n)$ for many
+                values of $s_i\in [x_0, x_1]$.
+        \end{block}
+\end{frame}
+
+\begin{frame}{Euler's method}
+        \begin{block}{Idea}
+                For $h$ small
+                \begin{align*}
+                        y'(x)\approx\frac{y(x+h)-y(x)}{h}
+                \end{align*}
+                which implies
+                \begin{align*}
+                        y(x+h) \approx y(x) + h\cdot f(x, y(x))
+                \end{align*}
+        \end{block}
+\end{frame}
+
+\begin{frame}{Euler's method}
+        \begin{block}{Algorithm}
+                \textbf{Input:} the data $f(x,y)$, $x_0$, $y_0$ and $x_1$ describing
+                        the problem and the desired range for the solution.
+
+                \vspace{0.3cm}
+                \textbf{Output:} $x_0=s_0 < s_1 < \dots < s_n=x_1$ and
+                        $y_0, \dots, y_n$ such that $y_i\approx y(s_i)$.
+
+                \vspace{0.3cm}
+                \begin{enumerate}
+                        \item Choose a value $n$ and let
+                                $h=\frac{x_1-x_0}{n}$ and $s_i=x_0+ih$
+                        \item For $i=0,\dots, n-1$ compute
+                                $y_{i+1}=y_i+h\cdot f(s_i, y_i)$
+                        \item Return $s_0, \dots, s_n$ and $y_0, \dots, y_n$
+                \end{enumerate}
+        \end{block}
+\end{frame}
+
+\begin{frame}{Euler's method}
+        \begin{itemize}
+                \item Very simple and fast
+                \item Generalization for higher-order equations: Runge-Kutta methods
+                \item A similar idea works for some PDEs
+        \end{itemize}
+\end{frame}
+
+\begin{frame}{The heat equation (PDE)}
+        \begin{align*}
+                \frac{\partial u}{\partial t} = \frac{\partial^2 u}{\partial x_1^2} +
+                \frac{\partial^2 u}{\partial x_2^2} + \cdots +
+                \frac{\partial^2 u}{\partial x_n^2}
+        \end{align*}
+        
+        Where
+        \[u(x_1,x_2,\dots,x_n,t): \mathbb R^n\times \mathbb R_+\to \mathbb R\]
+        describes the quantity of heat at the point $(x_1,\dots x_n)$ at time $t$.
+
+        \vspace{0.3cm} It appears also outside thermodynamics: mathematical finance
+        (\href{https://en.wikipedia.org/wiki/Black\%E2\%80\%93Scholes\_equation}%
+        {Black-Scholes equation}), quantum mechanics
+        (\href{https://en.wikipedia.org/wiki/Schr\%C3\%B6dinger\_equation}%
+        {Schrödinger equation}), image analysis\dots
+\end{frame}
+
+\begin{frame}{A simple case ($n=1$, in $[0,1]^2$)}
+        \begin{block}{Problem}
+                Given $u_0(t)$, $u_1(t)$ and $u^0(x)$, find an approximation
+                for $u(x,t)$ such that
+                \begin{align*}
+                        \begin{cases}
+                                \frac{\partial u}{\partial t} =
+                                        \frac{\partial^2 u}{\partial x^2} \\
+                                u(0,t) = u_{(0)}(t) \quad \text{(boundary condition)}\\
+                                u(1,t) = u_{(1)}(t) \quad \text{(boundary condition)}\\
+                                u(x,0) = u^0(x) \quad \text{(initial condition)}
+                        \end{cases}
+                \end{align*}
+        \end{block}
+
+        \begin{block}{Approximation}
+                Values $u_i^j\approx u(s_i, r^j)$ for
+                $(s_i,r^j)\in [0,1]\times [0,1]$
+        \end{block}
+\end{frame}
+
+\begin{frame}{Idea}
+        For $k$ small:
+        \begin{align*}
+                \frac{\partial u(x,t)}{\partial t} \approx \frac{u(x,t+k)-u(x,t)}{k}\\
+        \end{align*}
+        For $h$ small (left limit + right limit):
+        \begin{align*}
+                \frac{\partial^2 u(x,t)}{\partial x^2} &\approx
+                        \frac{\partial}{\partial x}\left(
+                                \frac{u(x,t) - u(x-h,t)}{h}
+                        \right)\\
+                &\approx \frac1h\left(
+                        \frac{\partial u(x,t)}{\partial x} -
+                        \frac{\partial u(x-h,t)}{\partial x}
+                \right)\\
+                &\approx \frac1h\left(
+                        \frac{u(x+h,t) - u(x,t)}{h} - \frac{u(x,t)-u(x-h,t)}{h}
+                \right)\\
+                &\approx \frac{u(x+h,t)-2u(x,t)+u(x-h,t)}{h^2}
+        \end{align*}
+\end{frame}
+
+\begin{frame}{Idea}
+        From the equation
+        \begin{align*}
+                \frac{u_i^{j+1}-u_i^j}{k}= \frac{u_{i+1}^j-2u_{i}^j+u_{i-1}^j}{h^2}
+        \end{align*}
+        we find the formula
+        \begin{align*}
+                u_i^{j+1} = \frac{k}{h^2}\left(u_{i+1}^j - 2u_i^j + u_{i-1}^j\right)
+                         + u_i^j
+        \end{align*}
+\end{frame}
+
+\begin{frame}{Finite difference method for the heat equation}
+        \begin{block}{Algorithm}
+                \textbf{Input:} $u_{(0)}^j$, $u_{(1)}^j$ (boundary)
+                        and $u_i^0$ (initial).
+
+                \vspace{0.3cm}
+                \textbf{Output:} values $u_i^j$ approximating a solution.
+
+                \vspace{0.3cm}
+                \begin{enumerate}
+                        \item Let  $m=\operatorname{len}(u_0)-1$,
+                                $n=\operatorname{len}(u^0)-1$ and $k=1/m$, $h=1/n$
+                                %\begin{align*}
+                                %       \begin{array}{cccc}
+                                %               k=\frac{t_1-t_0}{m}, & h=\frac{x_1-x_0}{n}, &
+                                %               r^j = t_0 +jk, & s_i = x_0+ih
+                                %       \end{array}
+                                %\end{align*}
+                        \item For $j=0,\dots, m-1$ do the following:
+                                \begin{itemize}
+                                        \item For $i=1,\dots, n-1$ compute
+                                                \begin{align*}
+                                                        u_i^{j+1} = \frac{k}{h^2}\left(u_{i+1}^j - 
+                                                                     2u_i^j + u_{i-1}^j\right) + u_i^j
+                                                \end{align*}
+                                \end{itemize}
+                        \item Return the $u_i^j$
+                \end{enumerate}
+        \end{block}
+\end{frame}
+
+\begin{frame}{Other PDEs}
+        \begin{itemize}
+                \item In general, there is no generic method
+                \item You might need to write specific code for your equation
+                \item Some packages exists
+                        (e.g. \href{https://wiki.octave.org/Fem-fenics}{fem-fenics} for
+                        \href{https://www.gnu.org/software/octave/index}{Gnu Octave})
+        \end{itemize}
+\end{frame}
+
+\end{document}
diff --git a/src/Lecture7/slides/X2-StudentsRequests.toc b/src/Lecture7/slides/X2-StudentsRequests.toc
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.toc
diff --git a/src/Lecture7/slides/X2-StudentsRequests.vrb b/src/Lecture7/slides/X2-StudentsRequests.vrb
new file mode 100644
index 0000000..57dfae6
--- /dev/null
+++ b/src/Lecture7/slides/X2-StudentsRequests.vrb
@@ -0,0 +1,10 @@
+\frametitle{Fibonacci with memorization}
+\begin{adjustbox}{scale={0.85}{0.9},center}
+        \begin{tikzcd}[column sep=1mm]
+                & & & & & & & & F(5) \ar[drrr] \ar[dlll]\\
+                & & & & & F(4)\ar[dll]\ar[dr] & & & & & & {\color{blue}F(3)}\\
+                & & & F(3) \ar[dl]\ar[dr] & & & {\color{blue}F(2)}\\
+                & & F(2) \ar[dl]\ar[dr] & & {\color{blue}F(1)} \\
+                & F(1) & & F(0)
+        \end{tikzcd}
+        \end{adjustbox}
diff --git a/src/Lecture7/slides/img/DH.svg b/src/Lecture7/slides/img/DH.svg
new file mode 100644
index 0000000..1ea0408
--- /dev/null
+++ b/src/Lecture7/slides/img/DH.svg
@@ -0,0 +1,181 @@
+<svg width="426.5" height="641" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+  <g id="k" style="">
+    <ellipse id="o" cx="45.75" cy="630.2" rx="45" ry="10" fill="#796300" stroke="#000" stroke-width="1.5"/>
+    <path fill="#796300" stroke="#000" stroke-width="1.5" d="m0.75 630.2v-60h90v60"/>
+    <use transform="translate(0,-60)" style="" xlink:href="#o"/>
+  </g>
+  <use transform="translate(335)" style="" xlink:href="#k"/>
+  <g id="j" style="">
+    <ellipse id="n" cx="45.75" cy="520.2" rx="45" ry="10" fill="#ff5a00" stroke="#000" stroke-width="1.5"/>
+    <path fill="#ff5a00" stroke="#000" stroke-width="1.5" d="m0.75 520.2v-20h90v20"/>
+    <use transform="translate(0,-20)" style="" xlink:href="#n"/>
+  </g>
+  <g id="i" style="">
+    <ellipse id="m" cx="380.8" cy="520.2" rx="45" ry="10" fill="#5dcac5" stroke="#000" stroke-width="1.5"/>
+    <path fill="#5dcac5" stroke="#000" stroke-width="1.5" d="m335.8 520.2v-20h90v20"/>
+    <use transform="translate(0,-20)" style="" xlink:href="#m"/>
+  </g>
+  <g id="h" style="">
+    <g id="c" style="">
+      <path fill="#fff" stroke="#000" stroke-width="1.5" d="m0.75 450.2v-60h90v60"/>
+      <ellipse cx="45.75" cy="390.2" rx="45" ry="10" fill="#fff" stroke="#000" stroke-width="1.5"/>
+    </g>
+    <g style="">
+      <ellipse id="l" cx="45.75" cy="450.2" rx="45" ry="10" fill="#93bbff" stroke="#000" stroke-width="1.5"/>
+      <path fill="#93bbff" stroke="#000" stroke-width="1.5" d="m0.75 450.2v-40h90v40"/>
+      <use transform="translate(0,-40)" style="" xlink:href="#l"/>
+    </g>
+  </g>
+  <g id="g" style="">
+    <use transform="translate(335)" style="" xlink:href="#c"/>
+    <g style="">
+      <ellipse id="p" cx="380.8" cy="450.2" rx="45" ry="10" fill="#ffbf61" stroke="#000" stroke-width="1.5"/>
+      <path fill="#ffbe60" stroke="#000" stroke-width="1.5" d="m335.8 450.2v-40h90v40"/>
+      <use transform="translate(0,-40)" style="" xlink:href="#p"/>
+    </g>
+  </g>
+  <use transform="translate(-335,-160)" style="" xlink:href="#g"/>
+  <use transform="translate(335,-160)" style="" xlink:href="#h"/>
+  <use transform="translate(0,-340)" style="" xlink:href="#j"/>
+  <use transform="translate(0,-340)" style="" xlink:href="#i"/>
+  <g id="f" style="">
+    <use transform="translate(0,-340)" style="" xlink:href="#c"/>
+    <g style="">
+      <use transform="translate(0,20)" style="" xlink:href="#q"/>
+      <path fill="#ff0" stroke="#000" stroke-width="1.5" d="m0.75 110.2v-20h90v20"/>
+      <ellipse id="q" cx="45.75" cy="90.25" rx="45" ry="10" fill="#ff0" stroke="#000" stroke-width="1.5"/>
+    </g>
+  </g>
+  <use transform="translate(335)" style="" xlink:href="#f"/>
+  <g id="e" style="">
+    <path stroke="#000" stroke-width="1.5" d="m91.5 301 243.5 78.5"/>
+    <path d="m326.4 372.8 2.406 4.719-4.719 2.406 13.66 0.4687" style=""/>
+  </g>
+  <use transform="matrix(-1,0,0,1,427.5,0)" style="" xlink:href="#e"/>
+  <g aria-label="Common secret">
+    <path d="m146.9 606.7q-2.484 0-3.726-1.674-1.224-1.674-1.224-4.824t1.224-4.824q1.242-1.674 3.726-1.674 3.618 0 4.446 3.618l-2.52 0.612q-0.234-1.008-0.666-1.53t-1.314-0.522q-1.062 0-1.548 0.828-0.468 0.828-0.468 2.394v2.196q0 1.566 0.468 2.394 0.486 0.828 1.548 0.828 0.882 0 1.314-0.522t0.666-1.53l2.52 0.612q-0.828 3.618-4.446 3.618z"/>
+    <path d="m157.4 606.7q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m164.1 597.1h2.664v1.602h0.108q0.27-0.828 0.9-1.314 0.648-0.504 1.638-0.504 0.972 0 1.656 0.486t0.99 1.422h0.054q0.27-0.828 1.044-1.368 0.792-0.54 1.836-0.54 1.368 0 2.088 0.99 0.738 0.972 0.738 2.754v5.922h-2.664v-5.706q0-0.918-0.324-1.35-0.306-0.45-0.972-0.45-0.648 0-1.116 0.36-0.45 0.36-0.45 1.026v6.12h-2.664v-5.706q0-1.8-1.296-1.8-0.63 0-1.098 0.36t-0.468 1.026v6.12h-2.664z"/>
+    <path d="m180.3 597.1h2.664v1.602h0.108q0.27-0.828 0.9-1.314 0.648-0.504 1.638-0.504 0.972 0 1.656 0.486t0.99 1.422h0.054q0.27-0.828 1.044-1.368 0.792-0.54 1.836-0.54 1.368 0 2.088 0.99 0.738 0.972 0.738 2.754v5.922h-2.664v-5.706q0-0.918-0.324-1.35-0.306-0.45-0.972-0.45-0.648 0-1.116 0.36-0.45 0.36-0.45 1.026v6.12h-2.664v-5.706q0-1.8-1.296-1.8-0.63 0-1.098 0.36t-0.468 1.026v6.12h-2.664z"/>
+    <path d="m200.6 606.7q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m207.2 606.5v-9.288h2.664v1.692h0.108q0.342-0.864 1.008-1.386 0.684-0.522 1.728-0.522 1.368 0 2.196 0.918t0.828 2.574v6.012h-2.664v-5.652q0-0.882-0.396-1.332-0.396-0.468-1.17-0.468-0.666 0-1.152 0.36t-0.486 0.99v6.102z"/>
+    <path d="m230.2 606.7q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+    <path d="m241.4 606.7q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m252.3 606.7q-2.196 0-3.456-1.296-1.242-1.296-1.242-3.564 0-2.25 1.242-3.546 1.26-1.314 3.438-1.314 2.79 0 3.87 2.268l-2.052 1.116q-0.27-0.594-0.702-0.918-0.414-0.342-1.116-0.342-0.9 0-1.404 0.54-0.504 0.522-0.504 1.44v1.512q0 0.936 0.504 1.458t1.44 0.522q0.72 0 1.17-0.324 0.468-0.342 0.792-0.972l2.016 1.152q-0.522 1.062-1.512 1.674-0.99 0.594-2.484 0.594z"/>
+    <path d="m258.6 597.2h2.664v2.628h0.126q0.666-2.628 2.97-2.628h0.342v2.448h-1.44q-0.954 0-1.476 0.576-0.522 0.558-0.522 1.44v4.824h-2.664z"/>
+    <path d="m271 606.7q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m281.4 603.8q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+  </g>
+  <use transform="translate(0 340)" style="" xlink:href="#a"/>
+  <use transform="translate(335 340)" style="" xlink:href="#a"/>
+  <use width="100%" height="100%" transform="translate(0,340)" xlink:href="#d"/>
+  <use transform="translate(0,340)" style="" xlink:href="#b"/>
+  <use transform="translate(335,340)" style="" xlink:href="#b"/>
+  <g aria-label="Public transport">
+    <path d="m139.9 311.4v-12.56h4.86q1.836 0 2.844 1.08 1.008 1.062 1.008 2.916t-1.008 2.934q-1.008 1.062-2.844 1.062h-2.142v4.572zm2.718-6.75h1.458q0.936 0 1.314-0.36t0.378-1.188v-0.54q0-0.828-0.378-1.188t-1.314-0.36h-1.458z"/>
+    <path d="m156.3 309.7h-0.108q-0.342 0.864-1.026 1.386-0.666 0.522-1.71 0.522-1.368 0-2.196-0.918t-0.828-2.574v-6.012h2.664v5.652q0 0.882 0.396 1.35 0.396 0.45 1.17 0.45 0.666 0 1.152-0.36t0.486-0.99v-6.102h2.664v9.288h-2.664z"/>
+    <path d="m161.2 298.1h2.664v5.724h0.126q0.378-0.9 1.026-1.404 0.666-0.504 1.728-0.504 1.602 0 2.538 1.224 0.954 1.206 0.954 3.636t-0.954 3.654q-0.936 1.206-2.538 1.206-1.062 0-1.728-0.504-0.648-0.504-1.026-1.404h-0.126v1.692h-2.664zm4.392 11.47q0.882 0 1.368-0.54 0.504-0.558 0.504-1.53v-1.44q0-0.972-0.504-1.512-0.486-0.558-1.368-0.558-0.756 0-1.242 0.36t-0.486 1.062v2.736q0 0.702 0.486 1.062t1.242 0.36z"/>
+    <path d="m174.7 311.4q-2.646 0-2.646-2.592v-10.73h2.664v10.66q0 0.288 0.144 0.45 0.162 0.144 0.45 0.144h0.594v2.07z"/>
+    <path d="m180.5 298v2.844h-2.862v-2.844zm-2.772 4.122h2.664v9.288h-2.664z"/>
+    <path d="m187.5 311.6q-2.196 0-3.456-1.296-1.242-1.296-1.242-3.564 0-2.25 1.242-3.546 1.26-1.314 3.438-1.314 2.79 0 3.87 2.268l-2.052 1.116q-0.27-0.594-0.702-0.918-0.414-0.342-1.116-0.342-0.9 0-1.404 0.54-0.504 0.522-0.504 1.44v1.512q0 0.936 0.504 1.458t1.44 0.522q0.72 0 1.17-0.324 0.468-0.342 0.792-0.972l2.016 1.152q-0.522 1.062-1.512 1.674-0.99 0.594-2.484 0.594z"/>
+    <path d="m205.9 308.7q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+    <path d="m210 302.1h2.664v2.628h0.126q0.666-2.628 2.97-2.628h0.342v2.448h-1.44q-0.954 0-1.476 0.576-0.522 0.558-0.522 1.44v4.824h-2.664z"/>
+    <path d="m225.6 311.4q-0.828 0-1.35-0.432-0.504-0.432-0.576-1.206h-0.09q-0.234 0.9-0.99 1.386-0.756 0.468-1.836 0.468-1.368 0-2.178-0.738t-0.81-2.034q0-2.862 4.176-2.862h1.494v-0.468q0-0.846-0.396-1.26t-1.296-0.414q-0.792 0-1.332 0.306-0.522 0.306-0.936 0.864l-1.458-1.296q0.486-0.828 1.512-1.314 1.026-0.504 2.52-0.504 1.926 0 2.988 0.9 1.062 0.882 1.062 2.61v3.456q0 0.252 0.18 0.432t0.432 0.18h0.414v1.926zm-3.834-1.53q0.738 0 1.206-0.342 0.468-0.36 0.468-0.99v-1.116h-1.422q-0.792 0-1.224 0.288-0.414 0.27-0.414 0.81v0.36q0 0.486 0.36 0.738 0.378 0.252 1.026 0.252z"/>
+    <path d="m228.8 311.4v-9.288h2.664v1.692h0.108q0.342-0.864 1.008-1.386 0.684-0.522 1.728-0.522 1.368 0 2.196 0.918t0.828 2.574v6.012h-2.664v-5.652q0-0.882-0.396-1.332-0.396-0.468-1.17-0.468-0.666 0-1.152 0.36t-0.486 0.99v6.102z"/>
+    <path d="m243.7 311.6q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+    <path d="m250.2 302.1h2.664v1.692h0.126q0.378-0.9 1.026-1.404 0.666-0.504 1.728-0.504 1.602 0 2.538 1.224 0.954 1.206 0.954 3.636t-0.954 3.654q-0.936 1.206-2.538 1.206-1.062 0-1.728-0.504-0.648-0.504-1.026-1.404h-0.126v5.292h-2.664zm4.392 7.434q0.882 0 1.368-0.54 0.504-0.558 0.504-1.53v-1.44q0-0.972-0.504-1.512-0.486-0.558-1.368-0.558-0.756 0-1.242 0.36t-0.486 1.062v2.736q0 0.702 0.486 1.062t1.242 0.36z"/>
+    <path d="m265.4 311.6q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m272 302.1h2.664v2.628h0.126q0.666-2.628 2.97-2.628h0.342v2.448h-1.44q-0.954 0-1.476 0.576-0.522 0.558-0.522 1.44v4.824h-2.664z"/>
+    <path d="m284.1 308.7q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+  </g>
+  <g id="a" aria-label="=">
+    <path d="m41.47 204.4v-2.124h8.568v2.124zm0 4.14v-2.124h8.568v2.124z"/>
+  </g>
+  <use transform="translate(335)" style="" xlink:href="#a"/>
+  <g id="d" aria-label="Secret colours">
+    <path d="m150.5 177q-1.53 0-2.718-0.504-1.188-0.522-1.926-1.44l1.566-1.728q0.666 0.738 1.476 1.116 0.828 0.36 1.692 0.36 0.954 0 1.458-0.432 0.522-0.432 0.522-1.242 0-0.666-0.396-1.008-0.378-0.342-1.296-0.486l-1.314-0.216q-1.62-0.27-2.412-1.206-0.792-0.954-0.792-2.394 0-1.8 1.188-2.808t3.33-1.008q1.404 0 2.502 0.45 1.098 0.432 1.782 1.224l-1.53 1.71q-0.504-0.576-1.206-0.882t-1.53-0.306q-1.818 0-1.818 1.494 0 0.63 0.396 0.972 0.396 0.324 1.332 0.486l1.314 0.234q1.53 0.27 2.358 1.17t0.828 2.358q0 1.188-0.558 2.124-0.54 0.918-1.638 1.44-1.08 0.522-2.61 0.522z"/>
+    <path d="m161.7 177q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m172.7 177q-2.196 0-3.456-1.296-1.242-1.296-1.242-3.564 0-2.25 1.242-3.546 1.26-1.314 3.438-1.314 2.79 0 3.87 2.268l-2.052 1.116q-0.27-0.594-0.702-0.918-0.414-0.342-1.116-0.342-0.9 0-1.404 0.54-0.504 0.522-0.504 1.44v1.512q0 0.936 0.504 1.458t1.44 0.522q0.72 0 1.17-0.324 0.468-0.342 0.792-0.972l2.016 1.152q-0.522 1.062-1.512 1.674-0.99 0.594-2.484 0.594z"/>
+    <path d="m179 167.5h2.664v2.628h0.126q0.666-2.628 2.97-2.628h0.342v2.448h-1.44q-0.954 0-1.476 0.576-0.522 0.558-0.522 1.44v4.824h-2.664z"/>
+    <path d="m191.4 177q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m201.8 174.1q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+    <path d="m218.5 177q-2.196 0-3.456-1.296-1.242-1.296-1.242-3.564 0-2.25 1.242-3.546 1.26-1.314 3.438-1.314 2.79 0 3.87 2.268l-2.052 1.116q-0.27-0.594-0.702-0.918-0.414-0.342-1.116-0.342-0.9 0-1.404 0.54-0.504 0.522-0.504 1.44v1.512q0 0.936 0.504 1.458t1.44 0.522q0.72 0 1.17-0.324 0.468-0.342 0.792-0.972l2.016 1.152q-0.522 1.062-1.512 1.674-0.99 0.594-2.484 0.594z"/>
+    <path d="m228.9 177q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m238.1 176.8q-2.646 0-2.646-2.592v-10.73h2.664v10.66q0 0.288 0.144 0.45 0.162 0.144 0.45 0.144h0.594v2.07z"/>
+    <path d="m245.1 177q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m257.5 175.1h-0.108q-0.342 0.864-1.026 1.386-0.666 0.522-1.71 0.522-1.368 0-2.196-0.918t-0.828-2.574v-6.012h2.664v5.652q0 0.882 0.396 1.35 0.396 0.45 1.17 0.45 0.666 0 1.152-0.36t0.486-0.99v-6.102h2.664v9.288h-2.664z"/>
+    <path d="m262.6 167.5h2.664v2.628h0.126q0.666-2.628 2.97-2.628h0.342v2.448h-1.44q-0.954 0-1.476 0.576-0.522 0.558-0.522 1.44v4.824h-2.664z"/>
+    <path d="m274.7 177q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+  </g>
+  <g id="b" aria-label="+">
+    <path d="m44.6 139.8v-3.312h-3.132v-2.124h3.132v-3.312h2.304v3.312h3.132v2.124h-3.132v3.312z"/>
+  </g>
+  <use transform="translate(335)" style="" xlink:href="#b"/>
+  <g aria-label="Common paint">
+    <path d="m153.7 85.37q-2.484 0-3.726-1.674-1.224-1.674-1.224-4.824t1.224-4.824q1.242-1.674 3.726-1.674 3.618 0 4.446 3.618l-2.52 0.612q-0.234-1.008-0.666-1.53t-1.314-0.522q-1.062 0-1.548 0.828-0.468 0.828-0.468 2.394v2.196q0 1.566 0.468 2.394 0.486 0.828 1.548 0.828 0.882 0 1.314-0.522t0.666-1.53l2.52 0.612q-0.828 3.618-4.446 3.618z"/>
+    <path d="m164.2 85.37q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m170.8 75.7h2.664v1.602h0.108q0.27-0.828 0.9-1.314 0.648-0.504 1.638-0.504 0.972 0 1.656 0.486t0.99 1.422h0.054q0.27-0.828 1.044-1.368 0.792-0.54 1.836-0.54 1.368 0 2.088 0.99 0.738 0.972 0.738 2.754v5.922h-2.664v-5.706q0-0.918-0.324-1.35-0.306-0.45-0.972-0.45-0.648 0-1.116 0.36-0.45 0.36-0.45 1.026v6.12h-2.664v-5.706q0-1.8-1.296-1.8-0.63 0-1.098 0.36t-0.468 1.026v6.12h-2.664z"/>
+    <path d="m187 75.7h2.664v1.602h0.108q0.27-0.828 0.9-1.314 0.648-0.504 1.638-0.504 0.972 0 1.656 0.486t0.99 1.422h0.054q0.27-0.828 1.044-1.368 0.792-0.54 1.836-0.54 1.368 0 2.088 0.99 0.738 0.972 0.738 2.754v5.922h-2.664v-5.706q0-0.918-0.324-1.35-0.306-0.45-0.972-0.45-0.648 0-1.116 0.36-0.45 0.36-0.45 1.026v6.12h-2.664v-5.706q0-1.8-1.296-1.8-0.63 0-1.098 0.36t-0.468 1.026v6.12h-2.664z"/>
+    <path d="m207.4 85.37q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m213.9 85.15v-9.288h2.664v1.692h0.108q0.342-0.864 1.008-1.386 0.684-0.522 1.728-0.522 1.368 0 2.196 0.918t0.828 2.574v6.012h-2.664v-5.652q0-0.882-0.396-1.332-0.396-0.468-1.17-0.468-0.666 0-1.152 0.36t-0.486 0.99v6.102z"/>
+    <path d="m232.7 75.87h2.664v1.692h0.126q0.378-0.9 1.026-1.404 0.666-0.504 1.728-0.504 1.602 0 2.538 1.224 0.954 1.206 0.954 3.636t-0.954 3.654q-0.936 1.206-2.538 1.206-1.062 0-1.728-0.504-0.648-0.504-1.026-1.404h-0.126v5.292h-2.664zm4.392 7.434q0.882 0 1.368-0.54 0.504-0.558 0.504-1.53v-1.44q0-0.972-0.504-1.512-0.486-0.558-1.368-0.558-0.756 0-1.242 0.36t-0.486 1.062v2.736q0 0.702 0.486 1.062t1.242 0.36z"/>
+    <path d="m251.2 85.15q-0.828 0-1.35-0.432-0.504-0.432-0.576-1.206h-0.09q-0.234 0.9-0.99 1.386-0.756 0.468-1.836 0.468-1.368 0-2.178-0.738t-0.81-2.034q0-2.862 4.176-2.862h1.494v-0.468q0-0.846-0.396-1.26t-1.296-0.414q-0.792 0-1.332 0.306-0.522 0.306-0.936 0.864l-1.458-1.296q0.486-0.828 1.512-1.314 1.026-0.504 2.52-0.504 1.926 0 2.988 0.9 1.062 0.882 1.062 2.61v3.456q0 0.252 0.18 0.432t0.432 0.18h0.414v1.926zm-3.834-1.53q0.738 0 1.206-0.342 0.468-0.36 0.468-0.99v-1.116h-1.422q-0.792 0-1.224 0.288-0.414 0.27-0.414 0.81v0.36q0 0.486 0.36 0.738 0.378 0.252 1.026 0.252z"/>
+    <path d="m257.4 71.74v2.844h-2.862v-2.844zm-2.772 4.122h2.664v9.288h-2.664z"/>
+    <path d="m259.8 85.15v-9.288h2.664v1.692h0.108q0.342-0.864 1.008-1.386 0.684-0.522 1.728-0.522 1.368 0 2.196 0.918t0.828 2.574v6.012h-2.664v-5.652q0-0.882-0.396-1.332-0.396-0.468-1.17-0.468-0.666 0-1.152 0.36t-0.486 0.99v6.102z"/>
+    <path d="m274.7 82.47q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+  </g>
+  <g aria-label="Alice">
+    <path d="m21.98 24.56-1.408-5.376h-6.112l-1.376 5.376h-4.864l6.048-22.34h6.784l6.048 22.34zm-4.32-17.7h-0.256l-2.176 8.448h4.608z"/>
+    <path d="m34.03 24.56q-4.704 0-4.704-4.608v-19.07h4.736v18.94q0 0.512 0.256 0.8 0.288 0.256 0.8 0.256h1.056v3.68z"/>
+    <path d="m44.23 0.7225v5.056h-5.088v-5.056zm-4.928 7.328h4.736v16.51h-4.736z"/>
+    <path d="m56.77 24.95q-3.904 0-6.144-2.304-2.208-2.304-2.208-6.336 0-4 2.208-6.304 2.24-2.336 6.112-2.336 4.96 0 6.88 4.032l-3.648 1.984q-0.48-1.056-1.248-1.632-0.736-0.608-1.984-0.608-1.6 0-2.496 0.96-0.896 0.928-0.896 2.56v2.688q0 1.664 0.896 2.592t2.56 0.928q1.28 0 2.08-0.576 0.832-0.608 1.408-1.728l3.584 2.048q-0.928 1.888-2.688 2.976-1.76 1.056-4.416 1.056z"/>
+    <path d="m75.73 24.95q-4.096 0-6.272-2.272t-2.176-6.304q0-4.064 2.144-6.368 2.176-2.336 5.888-2.336 3.68 0 5.824 2.272 2.144 2.24 2.144 6.112v1.408h-11.3v0.288q0 1.632 1.024 2.592t2.88 0.96q2.624 0 4.352-2.048l2.56 2.784q-1.056 1.312-2.816 2.112t-4.256 0.8zm-0.384-13.89q-1.536 0-2.464 0.96-0.896 0.928-0.896 2.528v0.256h6.656v-0.256q0-1.6-0.896-2.528-0.864-0.96-2.4-0.96z"/>
+  </g>
+  <g aria-label="Bob">
+    <path d="m353.8 2.226h7.84q3.232 0 4.992 1.6 1.792 1.6 1.792 4.352 0 3.648-3.648 4.704v0.192q4.352 1.056 4.352 5.344 0 2.816-1.824 4.48-1.792 1.664-4.928 1.664h-8.576zm6.496 9.472q1.728 0 2.464-0.576 0.768-0.576 0.768-2.016v-0.96q0-1.44-0.768-1.984-0.736-0.576-2.464-0.576h-1.824v6.112zm0.608 9.504q1.76 0 2.528-0.576 0.8-0.608 0.8-2.112v-0.928q0-1.472-0.8-2.08-0.768-0.608-2.528-0.608h-2.432v6.304z"/>
+    <path d="m380.1 24.95q-3.872 0-6.08-2.304-2.208-2.336-2.208-6.336t2.208-6.304q2.208-2.336 6.08-2.336t6.08 2.336q2.208 2.304 2.208 6.304t-2.208 6.336q-2.208 2.304-6.08 2.304zm0-3.52q1.6 0 2.496-0.992t0.896-2.816v-2.624q0-1.824-0.896-2.816t-2.496-0.992-2.496 0.992-0.896 2.816v2.624q0 1.824 0.896 2.816t2.496 0.992z"/>
+    <path d="m391.6 0.8825h4.736v10.18h0.224q0.672-1.6 1.824-2.496 1.184-0.896 3.072-0.896 2.848 0 4.512 2.176 1.696 2.144 1.696 6.464t-1.696 6.496q-1.664 2.144-4.512 2.144-1.888 0-3.072-0.896-1.152-0.896-1.824-2.496h-0.224v3.008h-4.736zm7.808 20.38q1.568 0 2.432-0.96 0.896-0.992 0.896-2.72v-2.56q0-1.728-0.896-2.688-0.864-0.992-2.432-0.992-1.344 0-2.208 0.64t-0.864 1.888v4.864q0 1.248 0.864 1.888t2.208 0.64z"/>
+  </g>
+  <g aria-label="(assume that mixture separation is expensive)">
+    <path d="m152.4 375.8q0-1.692 0.504-3.258t1.35-2.808 1.89-2.016h2.664q-1.8 1.242-2.988 3.132t-1.188 4.032v1.836q0 2.142 1.188 4.032t2.988 3.132h-2.664q-1.044-0.774-1.89-2.016t-1.35-2.808-0.504-3.258z"/>
+    <path d="m168.8 381.4q-0.828 0-1.35-0.432-0.504-0.432-0.576-1.206h-0.09q-0.234 0.9-0.99 1.386-0.756 0.468-1.836 0.468-1.368 0-2.178-0.738t-0.81-2.034q0-2.862 4.176-2.862h1.494v-0.468q0-0.846-0.396-1.26t-1.296-0.414q-0.792 0-1.332 0.306-0.522 0.306-0.936 0.864l-1.458-1.296q0.486-0.828 1.512-1.314 1.026-0.504 2.52-0.504 1.926 0 2.988 0.9 1.062 0.882 1.062 2.61v3.456q0 0.252 0.18 0.432t0.432 0.18h0.414v1.926zm-3.834-1.53q0.738 0 1.206-0.342 0.468-0.36 0.468-0.99v-1.116h-1.422q-0.792 0-1.224 0.288-0.414 0.27-0.414 0.81v0.36q0 0.486 0.36 0.738 0.378 0.252 1.026 0.252z"/>
+    <path d="m176.1 381.6q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+    <path d="m186.9 381.6q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+    <path d="m199.4 379.7h-0.108q-0.342 0.864-1.026 1.386-0.666 0.522-1.71 0.522-1.368 0-2.196-0.918t-0.828-2.574v-6.012h2.664v5.652q0 0.882 0.396 1.35 0.396 0.45 1.17 0.45 0.666 0 1.152-0.36t0.486-0.99v-6.102h2.664v9.288h-2.664z"/>
+    <path d="m204.4 371.9h2.664v1.602h0.108q0.27-0.828 0.9-1.314 0.648-0.504 1.638-0.504 0.972 0 1.656 0.486t0.99 1.422h0.054q0.27-0.828 1.044-1.368 0.792-0.54 1.836-0.54 1.368 0 2.088 0.99 0.738 0.972 0.738 2.754v5.922h-2.664v-5.706q0-0.918-0.324-1.35-0.306-0.45-0.972-0.45-0.648 0-1.116 0.36-0.45 0.36-0.45 1.026v6.12h-2.664v-5.706q0-1.8-1.296-1.8-0.63 0-1.098 0.36t-0.468 1.026v6.12h-2.664z"/>
+    <path d="m225 381.6q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m243.5 378.7q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+    <path d="m247.5 368.1h2.664v5.724h0.108q0.342-0.864 1.008-1.386 0.684-0.522 1.728-0.522 1.368 0 2.196 0.918t0.828 2.574v6.012h-2.664v-5.652q0-0.882-0.396-1.332-0.396-0.468-1.17-0.468-0.666 0-1.152 0.36t-0.486 0.99v6.102h-2.664z"/>
+    <path d="m265.9 381.4q-0.828 0-1.35-0.432-0.504-0.432-0.576-1.206h-0.09q-0.234 0.9-0.99 1.386-0.756 0.468-1.836 0.468-1.368 0-2.178-0.738t-0.81-2.034q0-2.862 4.176-2.862h1.494v-0.468q0-0.846-0.396-1.26t-1.296-0.414q-0.792 0-1.332 0.306-0.522 0.306-0.936 0.864l-1.458-1.296q0.486-0.828 1.512-1.314 1.026-0.504 2.52-0.504 1.926 0 2.988 0.9 1.062 0.882 1.062 2.61v3.456q0 0.252 0.18 0.432t0.432 0.18h0.414v1.926zm-3.834-1.53q0.738 0 1.206-0.342 0.468-0.36 0.468-0.99v-1.116h-1.422q-0.792 0-1.224 0.288-0.414 0.27-0.414 0.81v0.36q0 0.486 0.36 0.738 0.378 0.252 1.026 0.252z"/>
+    <path d="m273.2 378.7q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+    <path d="m126.2 394.4h2.664v1.602h0.108q0.27-0.828 0.9-1.314 0.648-0.504 1.638-0.504 0.972 0 1.656 0.486t0.99 1.422h0.054q0.27-0.828 1.044-1.368 0.792-0.54 1.836-0.54 1.368 0 2.088 0.99 0.738 0.972 0.738 2.754v5.922h-2.664v-5.706q0-0.918-0.324-1.35-0.306-0.45-0.972-0.45-0.648 0-1.116 0.36-0.45 0.36-0.45 1.026v6.12h-2.664v-5.706q0-1.8-1.296-1.8-0.63 0-1.098 0.36t-0.468 1.026v6.12h-2.664z"/>
+    <path d="m145.3 390.5v2.844h-2.862v-2.844zm-2.772 4.122h2.664v9.288h-2.664z"/>
+    <path d="m147 403.9 3.474-4.716-3.24-4.572h3.042l0.99 1.494 0.756 1.206h0.144l0.774-1.206 1.008-1.494h2.79l-3.24 4.428 3.474 4.86h-3.06l-1.17-1.746-0.81-1.242h-0.144l-0.792 1.242-1.188 1.746z"/>
+    <path d="m162.6 401.2q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+    <path d="m172.4 402.2h-0.108q-0.342 0.864-1.026 1.386-0.666 0.522-1.71 0.522-1.368 0-2.196-0.918t-0.828-2.574v-6.012h2.664v5.652q0 0.882 0.396 1.35 0.396 0.45 1.17 0.45 0.666 0 1.152-0.36t0.486-0.99v-6.102h2.664v9.288h-2.664z"/>
+    <path d="m177.5 394.6h2.664v2.628h0.126q0.666-2.628 2.97-2.628h0.342v2.448h-1.44q-0.954 0-1.476 0.576-0.522 0.558-0.522 1.44v4.824h-2.664z"/>
+    <path d="m190 404.1q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m208.5 404.1q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+    <path d="m219.6 404.1q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m225.8 394.6h2.664v1.692h0.126q0.378-0.9 1.026-1.404 0.666-0.504 1.728-0.504 1.602 0 2.538 1.224 0.954 1.206 0.954 3.636t-0.954 3.654q-0.936 1.206-2.538 1.206-1.062 0-1.728-0.504-0.648-0.504-1.026-1.404h-0.126v5.292h-2.664zm4.392 7.434q0.882 0 1.368-0.54 0.504-0.558 0.504-1.53v-1.44q0-0.972-0.504-1.512-0.486-0.558-1.368-0.558-0.756 0-1.242 0.36t-0.486 1.062v2.736q0 0.702 0.486 1.062t1.242 0.36z"/>
+    <path d="m244.3 403.9q-0.828 0-1.35-0.432-0.504-0.432-0.576-1.206h-0.09q-0.234 0.9-0.99 1.386-0.756 0.468-1.836 0.468-1.368 0-2.178-0.738t-0.81-2.034q0-2.862 4.176-2.862h1.494v-0.468q0-0.846-0.396-1.26t-1.296-0.414q-0.792 0-1.332 0.306-0.522 0.306-0.936 0.864l-1.458-1.296q0.486-0.828 1.512-1.314 1.026-0.504 2.52-0.504 1.926 0 2.988 0.9 1.062 0.882 1.062 2.61v3.456q0 0.252 0.18 0.432t0.432 0.18h0.414v1.926zm-3.834-1.53q0.738 0 1.206-0.342 0.468-0.36 0.468-0.99v-1.116h-1.422q-0.792 0-1.224 0.288-0.414 0.27-0.414 0.81v0.36q0 0.486 0.36 0.738 0.378 0.252 1.026 0.252z"/>
+    <path d="m247.6 394.6h2.664v2.628h0.126q0.666-2.628 2.97-2.628h0.342v2.448h-1.44q-0.954 0-1.476 0.576-0.522 0.558-0.522 1.44v4.824h-2.664z"/>
+    <path d="m263.2 403.9q-0.828 0-1.35-0.432-0.504-0.432-0.576-1.206h-0.09q-0.234 0.9-0.99 1.386-0.756 0.468-1.836 0.468-1.368 0-2.178-0.738t-0.81-2.034q0-2.862 4.176-2.862h1.494v-0.468q0-0.846-0.396-1.26t-1.296-0.414q-0.792 0-1.332 0.306-0.522 0.306-0.936 0.864l-1.458-1.296q0.486-0.828 1.512-1.314 1.026-0.504 2.52-0.504 1.926 0 2.988 0.9 1.062 0.882 1.062 2.61v3.456q0 0.252 0.18 0.432t0.432 0.18h0.414v1.926zm-3.834-1.53q0.738 0 1.206-0.342 0.468-0.36 0.468-0.99v-1.116h-1.422q-0.792 0-1.224 0.288-0.414 0.27-0.414 0.81v0.36q0 0.486 0.36 0.738 0.378 0.252 1.026 0.252z"/>
+    <path d="m270.5 401.2q0 0.252 0.18 0.432t0.432 0.18h1.566v2.07h-1.998q-1.404 0-2.124-0.72-0.72-0.738-0.72-1.962v-4.536h-1.8v-2.07h1.8v-3.276h2.664v3.276h2.178v2.07h-2.178z"/>
+    <path d="m277.5 390.5v2.844h-2.862v-2.844zm-2.772 4.122h2.664v9.288h-2.664z"/>
+    <path d="m284.1 404.1q-2.178 0-3.42-1.296-1.242-1.314-1.242-3.564t1.242-3.546q1.242-1.314 3.42-1.314t3.42 1.314q1.242 1.296 1.242 3.546t-1.242 3.564q-1.242 1.296-3.42 1.296zm0-1.98q0.9 0 1.404-0.558t0.504-1.584v-1.476q0-1.026-0.504-1.584t-1.404-0.558-1.404 0.558-0.504 1.584v1.476q0 1.026 0.504 1.584t1.404 0.558z"/>
+    <path d="m290.7 403.9v-9.288h2.664v1.692h0.108q0.342-0.864 1.008-1.386 0.684-0.522 1.728-0.522 1.368 0 2.196 0.918t0.828 2.574v6.012h-2.664v-5.652q0-0.882-0.396-1.332-0.396-0.468-1.17-0.468-0.666 0-1.152 0.36t-0.486 0.99v6.102z"/>
+    <path d="m153.3 413v2.844h-2.862v-2.844zm-2.772 4.122h2.664v9.288h-2.664z"/>
+    <path d="m159.9 426.6q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+    <path d="m179.2 426.6q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m184.7 426.4 3.474-4.716-3.24-4.572h3.042l0.99 1.494 0.756 1.206h0.144l0.774-1.206 1.008-1.494h2.79l-3.24 4.428 3.474 4.86h-3.06l-1.17-1.746-0.81-1.242h-0.144l-0.792 1.242-1.188 1.746z"/>
+    <path d="m196.1 417.1h2.664v1.692h0.126q0.378-0.9 1.026-1.404 0.666-0.504 1.728-0.504 1.602 0 2.538 1.224 0.954 1.206 0.954 3.636t-0.954 3.654q-0.936 1.206-2.538 1.206-1.062 0-1.728-0.504-0.648-0.504-1.026-1.404h-0.126v5.292h-2.664zm4.392 7.434q0.882 0 1.368-0.54 0.504-0.558 0.504-1.53v-1.44q0-0.972-0.504-1.512-0.486-0.558-1.368-0.558-0.756 0-1.242 0.36t-0.486 1.062v2.736q0 0.702 0.486 1.062t1.242 0.36z"/>
+    <path d="m211.5 426.6q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m217.8 426.4v-9.288h2.664v1.692h0.108q0.342-0.864 1.008-1.386 0.684-0.522 1.728-0.522 1.368 0 2.196 0.918t0.828 2.574v6.012h-2.664v-5.652q0-0.882-0.396-1.332-0.396-0.468-1.17-0.468-0.666 0-1.152 0.36t-0.486 0.99v6.102z"/>
+    <path d="m232.8 426.6q-1.53 0-2.682-0.468t-1.728-1.278l1.494-1.386q1.152 1.26 2.934 1.26 0.792 0 1.242-0.252t0.45-0.738q0-0.36-0.288-0.522-0.27-0.18-0.864-0.27l-1.494-0.234q-1.368-0.216-2.178-0.846-0.792-0.63-0.792-1.872 0-1.458 1.116-2.286 1.134-0.828 3.132-0.828 2.646 0 3.87 1.422l-1.332 1.512q-0.432-0.486-1.098-0.774t-1.53-0.288q-0.756 0-1.152 0.252-0.396 0.234-0.396 0.684 0 0.378 0.27 0.558 0.288 0.162 0.882 0.252l1.476 0.234q1.386 0.216 2.178 0.846 0.81 0.63 0.81 1.872 0 1.458-1.134 2.304t-3.186 0.846z"/>
+    <path d="m242.4 413v2.844h-2.862v-2.844zm-2.772 4.122h2.664v9.288h-2.664z"/>
+    <path d="m247.5 426.4-3.33-9.288h2.808l1.206 3.978 0.882 3.096h0.144l0.882-3.096 1.206-3.978h2.7l-3.33 9.288z"/>
+    <path d="m260.1 426.6q-2.304 0-3.528-1.278t-1.224-3.546q0-2.286 1.206-3.582 1.224-1.314 3.312-1.314 2.07 0 3.276 1.278 1.206 1.26 1.206 3.438v0.792h-6.354v0.162q0 0.918 0.576 1.458t1.62 0.54q1.476 0 2.448-1.152l1.44 1.566q-0.594 0.738-1.584 1.188t-2.394 0.45zm-0.216-7.812q-0.864 0-1.386 0.54-0.504 0.522-0.504 1.422v0.144h3.744v-0.144q0-0.9-0.504-1.422-0.486-0.54-1.35-0.54z"/>
+    <path d="m272.9 420.8q0 1.692-0.504 3.258t-1.35 2.808-1.89 2.016h-2.664q1.8-1.242 2.988-3.132t1.188-4.032v-1.836q0-2.142-1.188-4.032t-2.988-3.132h2.664q1.044 0.774 1.89 2.016t1.35 2.808 0.504 3.258z"/>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/src/Lecture7/slides/img/plot1.png b/src/Lecture7/slides/img/plot1.png
new file mode 100644
index 0000000..15798bb
--- /dev/null
+++ b/src/Lecture7/slides/img/plot1.png
diff --git a/src/Lecture7/slides/img/plot2.png b/src/Lecture7/slides/img/plot2.png
new file mode 100644
index 0000000..9ca9bae
--- /dev/null
+++ b/src/Lecture7/slides/img/plot2.png
diff --git a/src/Lecture7/slides/img/plot3.png b/src/Lecture7/slides/img/plot3.png
new file mode 100644
index 0000000..0c27f8a
--- /dev/null
+++ b/src/Lecture7/slides/img/plot3.png
diff --git a/src/Lecture7/slides/img/plot4.png b/src/Lecture7/slides/img/plot4.png
new file mode 100644
index 0000000..48bad2e
--- /dev/null
+++ b/src/Lecture7/slides/img/plot4.png
diff --git a/src/Lecture7/slides/img/plot5.png b/src/Lecture7/slides/img/plot5.png
new file mode 100644
index 0000000..e8cfacd
--- /dev/null
+++ b/src/Lecture7/slides/img/plot5.png
diff --git a/src/Lecture7/slides/img/unilu.jpg b/src/Lecture7/slides/img/unilu.jpg
new file mode 100644
index 0000000..5265563
--- /dev/null
+++ b/src/Lecture7/slides/img/unilu.jpg
diff --git a/src/Lecture7/slides/svg-inkscape/DH_svg-tex.pdf b/src/Lecture7/slides/svg-inkscape/DH_svg-tex.pdf
new file mode 100644
index 0000000..c5c0f10
--- /dev/null
+++ b/src/Lecture7/slides/svg-inkscape/DH_svg-tex.pdf
diff --git a/src/Lecture7/slides/svg-inkscape/DH_svg-tex.pdf_tex b/src/Lecture7/slides/svg-inkscape/DH_svg-tex.pdf_tex
new file mode 100644
index 0000000..3964967
--- /dev/null
+++ b/src/Lecture7/slides/svg-inkscape/DH_svg-tex.pdf_tex
@@ -0,0 +1,58 @@
+%% Creator: Inkscape inkscape 0.92.5, www.inkscape.org
+%% PDF/EPS/PS + LaTeX output extension by Johan Engelen, 2010
+%% Accompanies image file 'DH_svg-tex.pdf' (pdf, eps, ps)
+%%
+%% To include the image in your LaTeX document, write
+%%   \input{<filename>.pdf_tex}
+%%  instead of
+%%   \includegraphics{<filename>.pdf}
+%% To scale the image, write
+%%   \def\svgwidth{<desired width>}
+%%   \input{<filename>.pdf_tex}
+%%  instead of
+%%   \includegraphics[width=<desired width>]{<filename>.pdf}
+%%
+%% Images with a different path to the parent latex file can
+%% be accessed with the `import' package (which may need to be
+%% installed) using
+%%   \usepackage{import}
+%% in the preamble, and then including the image with
+%%   \import{<path to file>}{<filename>.pdf_tex}
+%% Alternatively, one can specify
+%%   \graphicspath{{<path to file>/}}
+%% 
+%% For more information, please see info/svg-inkscape on CTAN:
+%%   http://tug.ctan.org/tex-archive/info/svg-inkscape
+%%
+\begingroup%
+  \makeatletter%
+  \providecommand\color[2][]{%
+    \errmessage{(Inkscape) Color is used for the text in Inkscape, but the package 'color.sty' is not loaded}%
+    \renewcommand\color[2][]{}%
+  }%
+  \providecommand\transparent[1]{%
+    \errmessage{(Inkscape) Transparency is used (non-zero) for the text in Inkscape, but the package 'transparent.sty' is not loaded}%
+    \renewcommand\transparent[1]{}%
+  }%
+  \providecommand\rotatebox[2]{#2}%
+  \newcommand*\fsize{\dimexpr\f@size pt\relax}%
+  \newcommand*\lineheight[1]{\fontsize{\fsize}{#1\fsize}\selectfont}%
+  \ifx\svgwidth\undefined%
+    \setlength{\unitlength}{319.9125bp}%
+    \ifx\svgscale\undefined%
+      \relax%
+    \else%
+      \setlength{\unitlength}{\unitlength * \real{\svgscale}}%
+    \fi%
+  \else%
+    \setlength{\unitlength}{\svgwidth}%
+  \fi%
+  \global\let\svgwidth\undefined%
+  \global\let\svgscale\undefined%
+  \makeatother%
+  \begin{picture}(1,1.50094365)%
+    \lineheight{1}%
+    \setlength\tabcolsep{0pt}%
+    \put(0,0){\includegraphics[width=\unitlength,page=1]{DH_svg-tex.pdf}}%
+  \end{picture}%
+\endgroup%