diff --git a/irlc/__init__.py b/irlc/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1fb35b8fb96b2ee7223b545586eedc1c8f73208c
--- /dev/null
+++ b/irlc/__init__.py
@@ -0,0 +1,203 @@
+""" Source code for 02466, Introduction to reinforcement learning and control, offered at DTU """
+__version__ = "0.0.1"
+
+# Do not import Matplotlib (or imports which import matplotlib) in case you have to run in headless mode.
+import shutil
+import inspect
+import lzma, pickle
+import numpy as np
+import os
+
+# Global imports from across the API. Allows imports like
+# > from irlc import Agent, train
+
+
+
+
+# from irlc.utils.player_wrapper_pyglet import PlayWrapper as PlayWrapper # deprecated.
+# from irlc.utils.video_monitor import VideoMonitor as VideoMonitor # deprecated.
+
+
+def get_irlc_base():
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+    return dir_path
+
+def get_students_base():
+    return os.path.join(get_irlc_base(), "../../../02465students/")
+
+
+def pd2latex_(pd, index=False, escape=False, column_spec=None, **kwargs): # You can add column specs.
+    for c in pd.columns:
+        if pd[c].values.dtype == 'float64' and all(pd[c].values - np.round(pd[c].values)==0):
+            pd[c] = pd[c].astype(int)
+    ss = pd.to_latex(index=index, escape=escape, **kwargs)
+    return fix_bookstabs_latex_(ss,column_spec=column_spec)
+
+def fix_bookstabs_latex_(ss, linewidth=True, first_column_left=True, column_spec=None):
+    to_tabular_x = linewidth
+
+    if to_tabular_x:
+        ss = ss.replace("tabular", "tabularx")
+    lines = ss.split("\n")
+    hd = lines[0].split("{")
+    if column_spec is None:
+        adj = (('l' if to_tabular_x else 'l') if first_column_left else 'C') + ("".join(["C"] * (len(hd[-1][:-1]) - 1)))
+    else:
+        adj = column_spec
+
+    # adj = ( ('l' if to_tabular_x else 'l') if first_column_left else 'C') + ("".join(["C"] * (len(hd[-1][:-1])-1)))
+    if linewidth:
+        lines[0] = "\\begin{tabularx}{\\linewidth}{" + adj + "}"
+    else:
+        lines[0] = "\\begin{tabular}{" + adj.lower() + "}"
+
+    ss = '\n'.join(lines)
+    return ss
+
+
+def _savepdf_env(file, env):
+    from PIL import Image
+    import matplotlib.pyplot as plt
+
+    env.render_mode, rmt = 'rgb_array', env.render_mode
+    frame = env.render()
+    env.render_mode = rmt
+
+    im = Image.fromarray(frame)
+    snapshot_base = file
+    if snapshot_base.endswith(".png"):
+        sf = snapshot_base[:-4]
+        fext = 'png'
+    else:
+        fext = 'pdf'
+        if snapshot_base.endswith(".pdf"):
+            sf = snapshot_base[:-4]
+        else:
+            sf = snapshot_base
+
+    sf = f"{sf}.{fext}"
+    dn = os.path.dirname(sf)
+    if len(dn) > 0 and not os.path.isdir(dn):
+        os.makedirs(dn)
+    print("Saving snapshot of environment to", os.path.abspath(sf))
+    if fext == 'png':
+        im.save(sf)
+        from irlc import _move_to_output_directory
+        _move_to_output_directory(sf)
+    else:
+        plt.figure(figsize=(16, 16))
+        plt.imshow(im)
+        plt.axis('off')
+        plt.tight_layout()
+        from irlc import savepdf
+        savepdf(sf, verbose=True)
+        plt.show()
+
+
+
+def savepdf(pdf, verbose=False, watermark=False, env=None):
+    """
+    Convenience function for saving PDFs. Just call it after you have created your plot as ``savepdf('my_file.pdf')``
+    to save a PDF of the plot.
+    You can also pass an environment, in which case the environment will be stored to a pdf file.
+
+
+    :param pdf: The file to save to, for instance ``"my_pdf.pdf"``
+    :param verbose: Print output destination (optional)
+    :param watermark: Include a watermark (optional)
+    :return: Full path of the created PDF.
+    """
+    if env is not None:
+        _savepdf_env(pdf, env)
+        return
+
+    import matplotlib.pyplot as plt
+    pdf = os.path.normpath(pdf.strip())
+    pdf = pdf+".pdf" if not pdf.endswith(".pdf") else pdf
+
+    if os.sep in pdf:
+        pdf = os.path.abspath(pdf)
+    else:
+        pdf = os.path.join(os.getcwd(), "pdf", pdf)
+    if not os.path.isdir(os.path.dirname(pdf)):
+        os.makedirs(os.path.dirname(pdf))
+
+
+
+    # filename = None
+    stack = inspect.stack()
+    modules = [inspect.getmodule(s[0]) for s in inspect.stack()]
+    files = [m.__file__ for m in modules if m is not None]
+    if any( [f.endswith("RUN_OUTPUT_CAPTURE.py") for f in files] ):
+        return
+
+    wd = os.getcwd()
+    irlc_base = os.path.dirname(__file__)
+    if False:
+        pass
+    else:
+        plt.savefig(fname=pdf)
+    outf = os.path.normpath(os.path.abspath(pdf))
+    print("> [savepdf]", pdf + (f" [full path: {outf}]" if verbose else ""))
+
+    return outf
+
+
+def _move_to_output_directory(file):
+    """
+    Hidden function: Move file given file to static output dir.
+    """
+    if not is_this_my_computer():
+        return
+    CDIR = os.path.dirname(os.path.realpath(__file__)).replace('\\', '/')
+    shared_output_dir = CDIR + "/../../shared/output"
+    shutil.copy(file, shared_output_dir + "/"+ os.path.basename(file) )
+
+
+def bmatrix(a):
+    if False:
+        return a.__str__()
+    else:
+        np.set_printoptions(suppress=True)
+        """Returns a LaTeX bmatrix
+        :a: numpy array
+        :returns: LaTeX bmatrix as a string
+        """
+        if len(a.shape) > 2:
+            raise ValueError('bmatrix can at most display two dimensions')
+        lines = str(a).replace('[', '').replace(']', '').splitlines()
+        rv = [r'\begin{bmatrix}']
+        rv += ['  ' + ' & '.join(l.split()) + r'\\' for l in lines]
+        rv +=  [r'\end{bmatrix}']
+        return '\n'.join(rv)
+
+
+def is_this_my_computer():
+    CDIR = os.path.dirname(os.path.realpath(__file__)).replace('\\', '/')
+    return os.path.exists(CDIR + "/../../Exercises")
+
+def cache_write(object, file_name, only_on_professors_computer=False, verbose=True, protocol=-1): # -1 is default protocol. Fix crash issue with large files.
+    if only_on_professors_computer and not is_this_my_computer():
+        """ Probably for your own good :-). """
+        return
+
+    dn = os.path.dirname(file_name)
+    if not os.path.exists(dn):
+        os.mkdir(dn)
+    if verbose: print("Writing cache...", file_name)
+    with lzma.open(file_name, 'wb') as f:
+        pickle.dump(object, f)
+        # compress_pickle.dump(object, f, compression="lzma", protocol=protocol)
+    if verbose:
+        print("Done!")
+
+
+def cache_exists(file_name):
+    return os.path.exists(file_name)
+
+def cache_read(file_name):
+    if os.path.exists(file_name):
+        with lzma.open(file_name, 'rb') as f:
+            return pickle.load(f)
+    else:
+        return None
diff --git a/irlc/exam/__init__.py b/irlc/exam/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/irlc/exam/exam2024spring_0/__init__.py b/irlc/exam/exam2024spring_0/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0519ecba6ea913e21689ec692e81e9e4973fbf73
--- /dev/null
+++ b/irlc/exam/exam2024spring_0/__init__.py
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/irlc/exam/exam2024spring_0/exam2024spring.ipynb b/irlc/exam/exam2024spring_0/exam2024spring.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..059702fd199ac671daa55d49d8386cc0ae7fd58e
--- /dev/null
+++ b/irlc/exam/exam2024spring_0/exam2024spring.ipynb
@@ -0,0 +1,83 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1cd2586b",
+   "metadata": {},
+   "source": [
+    "# A problem about adding numbers\n",
+    "\n",
+    "## Subproblem 1: This problem will surely test your awesome number-adding skills.\n",
+    "\n",
+    "In this problem, you should compute $x_1 = a + b$ where $a = 45$ and $b = 48$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d13c5b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x1 = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "raise NotImplementedError(\"Insert your solution and remove this error.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d725d517",
+   "metadata": {},
+   "source": [
+    "## Subproblem 2: Multiplication\n",
+    "\n",
+    "In this problem, you should compute $x_2 = a b$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32966dc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x2 = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "raise NotImplementedError(\"Insert your solution and remove this error.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72838c51",
+   "metadata": {},
+   "source": [
+    "# A problem with more troublesome derivative\n",
+    "\n",
+    "## Subproblem 1: Testing some other stuff\n",
+    "\n",
+    "Consider the function $f(x) = \\frac{7 x^{a}}{a}$. Suppose that $7= f'(1)$, what is $a$?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4cf45579",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "raise NotImplementedError(\"Insert your solution and remove this error.\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/irlc/exam/exam2024spring_0/exam2024spring_tests.py b/irlc/exam/exam2024spring_0/exam2024spring_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e98f454f82169213f377e2d490554cfc3ff5cde
--- /dev/null
+++ b/irlc/exam/exam2024spring_0/exam2024spring_tests.py
@@ -0,0 +1,48 @@
+from unitgrade import hide, UTestCase
+from unitgrade import UTestCase, Report
+from exam_generator.exam import Question, jinjafy
+from types import SimpleNamespace
+import gym
+import numpy as np
+import sympy as sym
+import os
+import inspect
+from unitgrade import NotebookTestCase
+
+
+class Question1(NotebookTestCase):
+    notebook = "exam2024spring.ipynb"
+    
+    def test_addition(self):
+        self.assertIsNotNone(self.nb.x1)
+
+    def test_multiplication(self):
+        self.assertIsNotNone(self.nb.x1)
+
+
+
+    
+
+class Question2(NotebookTestCase):
+    notebook = "exam2024spring.ipynb"
+    
+    def test_derivative(self):
+        self.assertIsNotNone(self.nb.a)
+
+
+    
+
+class Exam2024spring_0(Report):
+    title = "Report id exam2024spring"
+    abbreviate_questions = True
+    questions = [
+                (Question1, 10),                (Question2, 10),                ]
+    
+
+    import irlc
+    pack_imports = [irlc]
+
+
+if __name__ == "__main__":
+    from unitgrade import evaluate_report_student
+    evaluate_report_student(Exam2024spring_0())
diff --git a/irlc/exam/exam2024spring_0/exam2024spring_tests_grade.py b/irlc/exam/exam2024spring_0/exam2024spring_tests_grade.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d06ec94b05f1fd3c50c76f83b72418c0aff3242
--- /dev/null
+++ b/irlc/exam/exam2024spring_0/exam2024spring_tests_grade.py
@@ -0,0 +1,4 @@
+# irlc/exam/exam2024spring_0/exam2024spring_tests.py
+''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
+import bz2, base64
+exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
diff --git a/irlc/exam/exam2024spring_0/unitgrade_data/Question1.pkl b/irlc/exam/exam2024spring_0/unitgrade_data/Question1.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9f1592b00fe946f9933ab9e8c03190d8527abc12
Binary files /dev/null and b/irlc/exam/exam2024spring_0/unitgrade_data/Question1.pkl differ
diff --git a/irlc/exam/exam2024spring_0/unitgrade_data/Question2.pkl b/irlc/exam/exam2024spring_0/unitgrade_data/Question2.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..05b5379b67e8f6101f301db6d7e92ff01f98da21
Binary files /dev/null and b/irlc/exam/exam2024spring_0/unitgrade_data/Question2.pkl differ
diff --git a/irlc/exam/exam2024spring_0/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl b/irlc/exam/exam2024spring_0/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..b5cccdf4ff5df0bcb0c71c61601b78ec83ee89db
Binary files /dev/null and b/irlc/exam/exam2024spring_0/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl differ
diff --git a/irlc/exam/exam2024spring_1/__init__.py b/irlc/exam/exam2024spring_1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0519ecba6ea913e21689ec692e81e9e4973fbf73
--- /dev/null
+++ b/irlc/exam/exam2024spring_1/__init__.py
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/irlc/exam/exam2024spring_1/exam2024spring.ipynb b/irlc/exam/exam2024spring_1/exam2024spring.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3ba32ec1860d71c8374a4760596f6cab7094a4e6
--- /dev/null
+++ b/irlc/exam/exam2024spring_1/exam2024spring.ipynb
@@ -0,0 +1,103 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bb0323ea",
+   "metadata": {},
+   "source": [
+    "# A problem about subtracting numbers.\n",
+    "\n",
+    "This problem set will test your skills in subtracting numbers\n",
+    "\n",
+    "## Subproblem 1: This problem will surely test your awesome number-adding skills.\n",
+    "\n",
+    "In this problem, you should compute $x_1 = a + b - c$ where $a = 6$ and $b = 9$ and $c = 10$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "530b5ca1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x1 = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "\n",
+    "print(x1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3fa4acbb",
+   "metadata": {},
+   "source": [
+    "## Subproblem 2: Multiplication and a parenthesis.\n",
+    "\n",
+    "In this problem, you should compute $x_2 = a (b-c)$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b262dc7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x2 = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "\n",
+    "print(x2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89e7ff17",
+   "metadata": {},
+   "source": [
+    "# A problem with more troublesome derivative\n",
+    "\n",
+    "## Subproblem 1: Testing some other stuff\n",
+    "\n",
+    "Consider the function $f(x) = \\frac{10 x^{a}}{a}$. Suppose that $1280= f'(2)$, what is $a$?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6c3ed12d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = None  # Write your result here.\n",
+    "a = 7"
+   ]
+  }
+ ],
+ "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.10.6"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/irlc/exam/exam2024spring_1/exam2024spring_tests.py b/irlc/exam/exam2024spring_1/exam2024spring_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..0032704b03c2064a3b261fb09940d9b48f5463e7
--- /dev/null
+++ b/irlc/exam/exam2024spring_1/exam2024spring_tests.py
@@ -0,0 +1,48 @@
+from unitgrade import hide, UTestCase
+from unitgrade import UTestCase, Report
+from exam_generator.exam import Question, jinjafy
+from types import SimpleNamespace
+import gym
+import numpy as np
+import sympy as sym
+import os
+import inspect
+from unitgrade import NotebookTestCase
+
+
+class Question1(NotebookTestCase):
+    notebook = "exam2024spring.ipynb"
+    
+    def test_addition(self):
+        self.assertIsNotNone(self.nb.x1)
+
+    def test_multiplication(self):
+        self.assertIsNotNone(self.nb.x1)
+
+
+
+    
+
+class Question2(NotebookTestCase):
+    notebook = "exam2024spring.ipynb"
+    
+    def test_derivative(self):
+        self.assertIsNotNone(self.nb.a)
+
+
+    
+
+class Exam2024spring_1(Report):
+    title = "Report id exam2024spring"
+    abbreviate_questions = True
+    questions = [
+                (Question1, 10),                (Question2, 10),                ]
+    
+
+    import irlc
+    pack_imports = [irlc]
+
+
+if __name__ == "__main__":
+    from unitgrade import evaluate_report_student
+    evaluate_report_student(Exam2024spring_1())
diff --git a/irlc/exam/exam2024spring_1/exam2024spring_tests_grade.py b/irlc/exam/exam2024spring_1/exam2024spring_tests_grade.py
new file mode 100644
index 0000000000000000000000000000000000000000..096e812f0735d610f99109948987c7dda6701cd8
--- /dev/null
+++ b/irlc/exam/exam2024spring_1/exam2024spring_tests_grade.py
@@ -0,0 +1,4 @@
+# irlc/exam/exam2024spring_1/exam2024spring_tests.py
+''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
+import bz2, base64
+exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
diff --git a/irlc/exam/exam2024spring_1/unitgrade_data/Question1.pkl b/irlc/exam/exam2024spring_1/unitgrade_data/Question1.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..108f139f055ef0c60b5f6e1588e4f8567281deb7
Binary files /dev/null and b/irlc/exam/exam2024spring_1/unitgrade_data/Question1.pkl differ
diff --git a/irlc/exam/exam2024spring_1/unitgrade_data/Question2.pkl b/irlc/exam/exam2024spring_1/unitgrade_data/Question2.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..a58833116fd71b28ec5b0e1f279dd1dd220816ba
Binary files /dev/null and b/irlc/exam/exam2024spring_1/unitgrade_data/Question2.pkl differ
diff --git a/irlc/exam/exam2024spring_1/unitgrade_data/cache.db b/irlc/exam/exam2024spring_1/unitgrade_data/cache.db
new file mode 100644
index 0000000000000000000000000000000000000000..6ad4cf7fad45f95bc7d4853c7d6876a075900a5d
Binary files /dev/null and b/irlc/exam/exam2024spring_1/unitgrade_data/cache.db differ
diff --git a/irlc/exam/exam2024spring_1/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl b/irlc/exam/exam2024spring_1/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9fe663b2950de4f18af57380b0a301726dea6c88
Binary files /dev/null and b/irlc/exam/exam2024spring_1/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl differ
diff --git a/irlc/exam/exam2024spring_2/__init__.py b/irlc/exam/exam2024spring_2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0519ecba6ea913e21689ec692e81e9e4973fbf73
--- /dev/null
+++ b/irlc/exam/exam2024spring_2/__init__.py
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/irlc/exam/exam2024spring_2/exam2024spring.ipynb b/irlc/exam/exam2024spring_2/exam2024spring.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..5294d55ba1dae56fba6719e828b18a63e6f72ab4
--- /dev/null
+++ b/irlc/exam/exam2024spring_2/exam2024spring.ipynb
@@ -0,0 +1,83 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ab27cf79",
+   "metadata": {},
+   "source": [
+    "# A problem about adding numbers\n",
+    "\n",
+    "## Subproblem 1: This problem will surely test your awesome number-adding skills.\n",
+    "\n",
+    "In this problem, you should compute $x_1 = a + b$ where $a = 41$ and $b = 16$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "979c206b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x1 = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "raise NotImplementedError(\"Insert your solution and remove this error.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f33e65f7",
+   "metadata": {},
+   "source": [
+    "## Subproblem 2: Multiplication\n",
+    "\n",
+    "In this problem, you should compute $x_2 = a b$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1611200",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x2 = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "raise NotImplementedError(\"Insert your solution and remove this error.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d56a39a0",
+   "metadata": {},
+   "source": [
+    "# A problem with more troublesome derivative\n",
+    "\n",
+    "## Subproblem 1: Testing some other stuff\n",
+    "\n",
+    "Consider the function $f(x) = \\frac{10 x^{a}}{a}$. Suppose that $160= f'(4)$, what is $a$?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dcc5f3bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = None  # Write your result here.\n",
+    "# TODO: 1 lines missing.\n",
+    "raise NotImplementedError(\"Insert your solution and remove this error.\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/irlc/exam/exam2024spring_2/exam2024spring_tests.py b/irlc/exam/exam2024spring_2/exam2024spring_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d3573342412f1769c497164f4ad66bafc6088fb
--- /dev/null
+++ b/irlc/exam/exam2024spring_2/exam2024spring_tests.py
@@ -0,0 +1,48 @@
+from unitgrade import hide, UTestCase
+from unitgrade import UTestCase, Report
+from exam_generator.exam import Question, jinjafy
+from types import SimpleNamespace
+import gym
+import numpy as np
+import sympy as sym
+import os
+import inspect
+from unitgrade import NotebookTestCase
+
+
+class Question1(NotebookTestCase):
+    notebook = "exam2024spring.ipynb"
+    
+    def test_addition(self):
+        self.assertIsNotNone(self.nb.x1)
+
+    def test_multiplication(self):
+        self.assertIsNotNone(self.nb.x1)
+
+
+
+    
+
+class Question2(NotebookTestCase):
+    notebook = "exam2024spring.ipynb"
+    
+    def test_derivative(self):
+        self.assertIsNotNone(self.nb.a)
+
+
+    
+
+class Exam2024spring_2(Report):
+    title = "Report id exam2024spring"
+    abbreviate_questions = True
+    questions = [
+                (Question1, 10),                (Question2, 10),                ]
+    
+
+    import irlc
+    pack_imports = [irlc]
+
+
+if __name__ == "__main__":
+    from unitgrade import evaluate_report_student
+    evaluate_report_student(Exam2024spring_2())
diff --git a/irlc/exam/exam2024spring_2/exam2024spring_tests_grade.py b/irlc/exam/exam2024spring_2/exam2024spring_tests_grade.py
new file mode 100644
index 0000000000000000000000000000000000000000..26b028ae2c45aa4d50c5f750b205aaf8fce48fa8
--- /dev/null
+++ b/irlc/exam/exam2024spring_2/exam2024spring_tests_grade.py
@@ -0,0 +1,4 @@
+# irlc/exam/exam2024spring_2/exam2024spring_tests.py
+''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
+import bz2, base64
+exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
diff --git a/irlc/exam/exam2024spring_2/unitgrade_data/Question1.pkl b/irlc/exam/exam2024spring_2/unitgrade_data/Question1.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..89645e27a36be86f17dc36de17b1c331d7a73329
Binary files /dev/null and b/irlc/exam/exam2024spring_2/unitgrade_data/Question1.pkl differ
diff --git a/irlc/exam/exam2024spring_2/unitgrade_data/Question2.pkl b/irlc/exam/exam2024spring_2/unitgrade_data/Question2.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..2f60e33476a0403ab8d8a60b236d68960c6eb333
Binary files /dev/null and b/irlc/exam/exam2024spring_2/unitgrade_data/Question2.pkl differ
diff --git a/irlc/exam/exam2024spring_2/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl b/irlc/exam/exam2024spring_2/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..43e241033e214495c8cefea8f90a4120431ff77c
Binary files /dev/null and b/irlc/exam/exam2024spring_2/unitgrade_data/main_config_exam2024spring_tests.artifacts.pkl differ