diff --git a/docs/Makefile b/docs/Makefile
index a293f14ee04261a3d46ac9e6b0924b5b62107a6b..0cfe1ab8baa27928d301317ee7e32a41250d8278 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -22,7 +22,7 @@ html:
 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
 
 clean:
-	rm -rf source/reference/generated
 	rm -rf source/api/generated
+	rm -rf source/api/symbolic/generated
 	rm -rf source/backend/generated
 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
\ No newline at end of file
diff --git a/docs/source/api/codegen.md b/docs/source/api/codegen.md
new file mode 100644
index 0000000000000000000000000000000000000000..b739a4f33c922c97c083f7f466525892544bc46d
--- /dev/null
+++ b/docs/source/api/codegen.md
@@ -0,0 +1,180 @@
+# Code Generation
+
+## Invocation
+
+```{eval-rst}
+.. module:: pystencils.codegen
+
+.. autosummary::
+  :toctree: generated
+  :nosignatures:
+
+  create_kernel
+```
+  
+## Configuration
+
+```{eval-rst}
+.. module:: pystencils.codegen.config
+```
+
+The code generation driver (`create_kernel`, but also `DefaultKernelCreationDriver`) can be configured by
+passing it a `CreateKernelConfig` object.
+This object can be constructed incrementally:
+
+```Python
+cfg = ps.CreateKernelConfig()
+cfg.default_dtype = "float32"
+cfg.target = ps.Target.X86_AVX
+cfg.cpu.openmp.enable = True
+cfg.cpu.vectorize.enable = True
+cfg.cpu.vectorize.assume_inner_stride_one = True
+```
+
+### Options and Option Categories
+
+The following options and option categories are exposed by the configuration object:
+
+#### Target Specification
+
+```{eval-rst}
+.. current
+
+.. autosummary::
+
+  ~CreateKernelConfig.target
+```
+
+#### Data Types
+
+```{eval-rst}
+.. autosummary::
+
+  ~CreateKernelConfig.default_dtype
+  ~CreateKernelConfig.index_dtype
+```
+
+#### Iteration Space
+
+```{eval-rst}
+.. autosummary::
+
+  ~CreateKernelConfig.ghost_layers
+  ~CreateKernelConfig.iteration_slice
+  ~CreateKernelConfig.index_field
+```
+
+#### Kernel Constraint Checks
+
+```{eval-rst}
+.. autosummary::
+
+  ~CreateKernelConfig.allow_double_writes
+  ~CreateKernelConfig.skip_independence_check
+```
+
+#### Target-Specific Options
+
+The following categories with target-specific options are exposed:
+
+| | |
+|---------------------------|--------------------------|
+| {any}`cpu <CpuOptions>`   | Options for CPU kernels  |
+| {any}`gpu <GpuOptions>`   | Options for GPU kernels  |
+| {any}`sycl <SyclOptions>` | Options for SYCL kernels |
+
+
+#### Kernel Object and Just-In-Time Compilation
+
+```{eval-rst}
+.. autosummary::
+
+  ~CreateKernelConfig.function_name
+  ~CreateKernelConfig.jit
+```
+
+### Configuration System Classes
+
+```{eval-rst}
+
+.. autosummary::
+  :toctree: generated
+  :nosignatures:
+  :template: autosummary/recursive_class.rst
+
+  CreateKernelConfig
+  CpuOptions
+  OpenMpOptions
+  VectorizationOptions
+  GpuOptions
+  SyclOptions
+
+.. autosummary::
+  :toctree: generated
+  :nosignatures:
+
+  AUTO
+
+.. dropdown:: Implementation Details
+
+  .. autosummary::
+    :toctree: generated
+    :nosignatures:
+    :template: autosummary/entire_class.rst
+
+    Option
+    BasicOption
+    Category
+    ConfigBase
+
+```
+
+## Target Specification
+
+```{eval-rst}
+
+.. module:: pystencils.codegen.target
+
+.. autosummary::
+  :toctree: generated
+  :nosignatures:
+  :template: autosummary/recursive_class.rst
+
+  Target
+
+```
+
+## Code Generation Drivers
+
+```{eval-rst}
+.. module:: pystencils.codegen.driver
+
+.. autosummary::
+  :toctree: generated
+  :nosignatures:
+  :template: autosummary/entire_class.rst
+
+  DefaultKernelCreationDriver
+
+.. autosummary::
+  :toctree: generated
+  :nosignatures:
+
+  get_driver
+```
+
+## Output Code Objects
+
+```{eval-rst}
+.. currentmodule:: pystencils.codegen
+
+.. autosummary::
+  :toctree: generated
+  :nosignatures:
+  :template: autosummary/entire_class.rst
+
+  Kernel
+  GpuKernel
+  Parameter
+  GpuThreadsRange
+```
diff --git a/docs/source/api/codegen.rst b/docs/source/api/codegen.rst
deleted file mode 100644
index d65e9a358296d017e11395050e5767d82d6569ac..0000000000000000000000000000000000000000
--- a/docs/source/api/codegen.rst
+++ /dev/null
@@ -1,72 +0,0 @@
-pystencils.codegen
-==================
-
-.. module:: pystencils.codegen
-
-Invocation
-----------
-
-.. autosummary::
-  :toctree: generated
-  :nosignatures:
-
-  create_kernel
-  
-Configuration
--------------
-
-.. autosummary::
-  :toctree: generated
-  :nosignatures:
-  :template: autosummary/entire_class.rst
-
-  CreateKernelConfig
-  CpuOptimConfig
-  OpenMpConfig
-  VectorizationConfig
-  GpuIndexingConfig
-
-.. autosummary::
-  :toctree: generated
-  :nosignatures:
-
-  AUTO
-
-Target Specification
---------------------
-
-.. autosummary::
-  :toctree: generated
-  :nosignatures:
-  :template: autosummary/recursive_class.rst
-
-  Target
-
-Code Generation Drivers
------------------------
-
-.. autosummary::
-  :toctree: generated
-  :nosignatures:
-  :template: autosummary/entire_class.rst
-
-  driver.DefaultKernelCreationDriver
-
-.. autosummary::
-  :toctree: generated
-  :nosignatures:
-
-  get_driver
-
-Output Code Objects
--------------------
-
-.. autosummary::
-  :toctree: generated
-  :nosignatures:
-  :template: autosummary/entire_class.rst
-
-  Kernel
-  GpuKernel
-  Parameter
-  GpuThreadsRange
diff --git a/docs/source/api/jit.rst b/docs/source/api/jit.rst
index 7bcd9989c9f7871eb085e55b7161d1deddda87fc..f2e271db3917825ed7fb6a97c38633a847b8bbfc 100644
--- a/docs/source/api/jit.rst
+++ b/docs/source/api/jit.rst
@@ -1,5 +1,5 @@
-pystencils.jit
-==============
+JIT Compilation
+===============
 
 .. module:: pystencils.jit
 
diff --git a/docs/source/api/symbolic/assignments.md b/docs/source/api/symbolic/assignments.md
new file mode 100644
index 0000000000000000000000000000000000000000..69446a8a551541d555fb7df0d149c2fa2dcf59a6
--- /dev/null
+++ b/docs/source/api/symbolic/assignments.md
@@ -0,0 +1,16 @@
+# Assignments and AssignmentCollection
+
+```{eval-rst}
+
+.. py:class:: pystencils.Assignment
+
+    Monkeypatched variant of `sympy.codegen.ast.Assignment`.
+    Represents an assignment of an expression to a symbol.
+
+.. autosummary::
+    :toctree: generated
+    :nosignatures:
+    :template: autosummary/recursive_class.rst
+
+    pystencils.AssignmentCollection
+```
diff --git a/docs/source/api/field.rst b/docs/source/api/symbolic/field.rst
similarity index 97%
rename from docs/source/api/field.rst
rename to docs/source/api/symbolic/field.rst
index 79cc12a3a883906a0dd6a2f27d50047344e4c770..33219c059bb3e27160111f5cead50a11ec5736b2 100644
--- a/docs/source/api/field.rst
+++ b/docs/source/api/symbolic/field.rst
@@ -1,5 +1,5 @@
-pystencils.field
-================
+Fields
+======
 
 .. module:: pystencils.field
 
diff --git a/docs/source/api/symbolic/index.md b/docs/source/api/symbolic/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..fad3df20b68fcac0aba0fcec3ef4564138df5f01
--- /dev/null
+++ b/docs/source/api/symbolic/index.md
@@ -0,0 +1,9 @@
+# Symbolic Toolbox
+
+:::{toctree}
+:maxdepth: 1
+
+field
+assignments
+sympyextensions
+:::
diff --git a/docs/source/api/sympyextensions.rst b/docs/source/api/symbolic/sympyextensions.rst
similarity index 97%
rename from docs/source/api/sympyextensions.rst
rename to docs/source/api/symbolic/sympyextensions.rst
index d377f998ea5d52189007b7c45f6de2f0d92e1258..e3d10fbdf67a1fc26fe1e339b0e642d86f1be51e 100644
--- a/docs/source/api/sympyextensions.rst
+++ b/docs/source/api/symbolic/sympyextensions.rst
@@ -1,5 +1,5 @@
-pystencils.sympyextensions
-==========================
+Extensions to SymPy
+===================
 
 .. module:: pystencils.sympyextensions
 
diff --git a/docs/source/reference/types.rst b/docs/source/api/types.rst
similarity index 100%
rename from docs/source/reference/types.rst
rename to docs/source/api/types.rst
diff --git a/docs/source/contributing/index.md b/docs/source/contributing/index.md
index 39e68b06f4304224fc37e60c8d7611f03ce12d17..04ad821ce5eacdc2f8712ca1f666652b078b7c0f 100644
--- a/docs/source/contributing/index.md
+++ b/docs/source/contributing/index.md
@@ -1,4 +1,4 @@
-# Contributor Guide
+# Contribution Guide
 
 Welcome to the Contributor's Guide to pystencils!
 If you are interested in contributing to the development of pystencils, this is the place to start.
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 5ddec09f2bb89619cfbc2b6c05c8dcc2bb3108a4..cb455c8b4d1589353a7538c0e98b5eab864b4392 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -77,19 +77,18 @@ Topics
 
 .. toctree::
   :maxdepth: 1
-  :caption: Reference Guides
+  :caption: User Manual
 
-  reference/symbolic_language
-  reference/kernelcreation
-  reference/gpu_kernels
-  reference/types
+  user_manual/symbolic_language
+  user_manual/kernelcreation
+  user_manual/gpu_kernels
 
 .. toctree::
   :maxdepth: 1
-  :caption: API
+  :caption: API Reference
 
-  api/field
-  api/sympyextensions
+  api/symbolic/index
+  api/types
   api/codegen
   api/jit
 
diff --git a/docs/source/migration.rst b/docs/source/migration.md
similarity index 51%
rename from docs/source/migration.rst
rename to docs/source/migration.md
index ea59d8881a66f992ee2ab99f166deea9e4f70c39..bb4a2cffb0e838f49822a85970eabec00e70af78 100644
--- a/docs/source/migration.rst
+++ b/docs/source/migration.md
@@ -1,36 +1,64 @@
-.. _page_v2_migration:
+---
+jupytext:
+  formats: md:myst
+  text_representation:
+    extension: .md
+    format_name: myst
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+mystnb:
+  execution_mode: cache
+---
 
-***************************
-Version 2.0 Migration Guide
-***************************
+(_page_v2_migration)=
+# Version 2.0 Migration Guide
 
 With version 2.0, many APIs of *pystencils* will be changed; old interfaces are being deprecated
 and new systems are put in place.
 This page is a still-incomplete list of these changes, with advice on how to migrate your code
 from pystencils 1.x to pystencils 2.0.
 
-Kernel Creation
-===============
+```{code-cell} ipython3
+:tags: [remove-cell]
 
-Configuration
--------------
+import pystencils as ps
+```
 
-The API of `create_kernel`, and the configuration options of the `CreateKernelConfig`, have changed significantly:
+
+## Kernel Creation
+
+### Configuration
+
+The API of {any}`create_kernel`, and the configuration options of the {any}`CreateKernelConfig`, have changed significantly.
+The `CreateKernelConfig` class has been refined to be safe to copy and edit incrementally.
+The recommended way of setting up the code generator is now *incremental configuration*:
+
+```{code-cell} ipython3
+cfg = ps.CreateKernelConfig()
+cfg.default_dtype = "float32"
+cfg.cpu.openmp.enable = True
+cfg.cpu.openmp.num_threads = 8
+cfg.ghost_layers = 2
+```
 
 - *Data Types:* `CreateKernelConfig` now takes to parameters to control data types in your kernels:
   the ``default_dtype`` is applied to all numerical computations, while the ``index_dtype`` is used
   for all index calculations and loop counters.
+- *CPU Optimization Options:* Should now be set via the {any}`cpu <CpuOptions>` option category and its subcategories.
    
-.. dropdown:: Deprecated options of `CreateKernelConfig`
+:::{dropdown} Deprecated options of `CreateKernelConfig`
+
+- ``data_type``: Use ``default_dtype`` instead
+- ``cpu_openmp``: Set OpenMP-Options in the `cpu.openmp <OpenMpOptions>` category instead.
+- ``cpu_vectorize_info``: Set vectorization options in the `cpu.vectorize <VectorizationOptions>` category instead
+- ``gpu_indexing_params``: Set GPU indexing options in the `gpu <GpuOptions>` category instead
 
-    - ``data_type``: Use ``default_dtype`` instead
-    - ``cpu_openmp``: Set OpenMP-Options via an `OpenMpConfig`  in the ``cpu_optim`` (`CpuOptimConfig`) instead.
-    - ``cpu_vectorize_info``: Set vectorization options via a `VectorizationConfig` in the ``cpu_optim`` option instead
-    - ``gpu_indexing_params``: Set GPU indexing options via a `GpuIndexingConfig` in the ``gpu_indexing`` option instead
+:::
 
 
-Type Checking
--------------
+### Type Checking
 
 The old type checking system of pystencils' code generator has been replaced by a new type inference and validation
 mechanism whose rules are much stricter than before.
@@ -38,24 +66,23 @@ While running `create_kernel`, you may now encounter a `TypificationError` where
 If this happens, it is probable that you have been doing some illegal, maybe dangerous, or at least unsafe things with data types
 (like inserting integers into a floating-point context without casting them, or mixing types of different precisions or signedness).
 If you are sure the error is not your fault, please file an issue at our
-`bug tracker <https://i10git.cs.fau.de/pycodegen/pystencils/-/issues>`_.
+[bug tracker](https://i10git.cs.fau.de/pycodegen/pystencils/-/issues).
 
-Type System
-===========
+### Type System
 
-The ``pystencils.typing`` module has been entirely replaced by the new `pystencils.types` module,
+The ``pystencils.typing`` module has been entirely replaced by the new {any}`pystencils.types` module,
 which is home to a completely new type system.
-The primary interaction points with this system are still the `TypedSymbol` class and the `create_type` routine.
+The primary interaction points with this system are still the {any}`TypedSymbol` class and the {any}`create_type` routine.
 Code using any of these two should not require any changes, except:
 
 - *Importing `TypedSymbol` and `create_type`:* Both `TypedSymbol` and `create_type` should now be imported directly
   from the ``pystencils`` namespace.
 - *Custom data types:* `TypedSymbol` used to accept arbitrary strings as data types.
-  This is no longer possible; instead, import `pystencils.types.PsCustomType` and use it to describe
+  This is no longer possible; instead, import {any}`pystencils.types.PsCustomType` and use it to describe
   custom data types unknown to pystencils, as in ``TypedSymbol("xs", PsCustomType("std::vector< int >"))``
 
 All old data type classes (such as ``BasicType``, ``PointerType``, ``StructType``, etc.) have been removed
-and replaced by the class hierarchy below `PsType`.
+and replaced by the class hierarchy below {any}`PsType`.
 Directly using any of these type classes in the frontend is discouraged unless absolutely necessary;
 in most cases, `create_type` suffices.
 
diff --git a/docs/source/tutorials/01_tutorial_getting_started.ipynb b/docs/source/tutorials/01_tutorial_getting_started.ipynb
index 5ce765fcea33088463c5e5274cab8fb5654f6229..f6c92a6bb5ecc36b11406c3ad1a7667218dee016 100644
--- a/docs/source/tutorials/01_tutorial_getting_started.ipynb
+++ b/docs/source/tutorials/01_tutorial_getting_started.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -52,7 +52,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -63,14 +63,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "4.74 ms ± 1.1 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "3.91 ms ± 88.9 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
@@ -88,22 +88,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
       "text/latex": [
        "$\\displaystyle {dst}_{(0,0)} \\leftarrow_{} \\frac{{src}_{(1,0)}}{4} + \\frac{{src}_{(0,1)}}{4} + \\frac{{src}_{(0,-1)}}{4} + \\frac{{src}_{(-1,0)}}{4}$"
       ],
       "text/plain": [
-       "         src_E   src_N   src_S   src_W\n",
-       "dst_C := ───── + ───── + ───── + ─────\n",
-       "           4       4       4       4  "
+       "Assignment(dst_C, src_E/4 + src_N/4 + src_S/4 + src_W/4)"
       ]
      },
-     "execution_count": 41,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -118,12 +115,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAEnCAYAAACHXNdEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAD4NJREFUeJzt3X+Q03V+x/FXfuwm+yPsQlYWsAIy4sFtT37pTL2WA3eEO6p4Mw4zWq9iubFqb9pK524qVO2MPTvlD7T27vAn4unO3Y2O1vPUG+s5bW3HOWUsFo6euK4IghywP2B3WTbZJN9v55vlh2CSTbJvSGKej5nMJkvyzQfN97mf7yffDT7XdV0BgBG/1YYAwENUAJgiKgBMBW03h0o3kHD0u7ijkTxW2gKSJof8aqnlZxNOIypI2zmY1D/vGdavjySVKvCxX2kM6M8vCuvrF9Seo9Ghkvh49we/HUxq9Y5jGkwV/1Lw5iob5zTomsmEpdoxb4We3B8bV1A8jqQf7B02GxMqF1GpcinX1b/3Jky2tWfYUddQoQdP+KIhKlVuIOnquDfNMOIt8qK6EZUqlzBuQIIluqpHVJDT0Z9v0d5bl6qzfbJ6ntpQ6uGgAhAV5BSMtiq65i5Flqws9VBQIThPBTk1Lr4m/XXo7V+VeiioEMxUAJgiKgBMERUApogKAFNEBTm5yaSceExuKiWlUqevA1kQFeTU27FRXcunaeDVDvV1PDB6/fVnSz0slDF+S7nKHY47WvxOv9n2HmlrUHuU31SuZsxUAJgiKgBMcUYtsupcMmnM+1z6Zt95GQsqB1FBVgQDxeDwB3kZ3rlVnUuj6n1mY6mHgjJHVDAm13HUveluhecsKPVQUAE4/MGY+l9+WuG5i+QMDZZ6KKgAzFSQU6q/T0eef1TRNetLPRRUCKKCnHo236+Jq+5QINJU6qGgQhAVZBXr3KHYrvfUdO3qUg8FFYQ1FWQ1vP0tjezr0u5VbenbzrEBKRBU4tOPNWX9plIPD2WKqCCrppW3KNJ+vQYGBtTT3a2af/2RGi/+kibdtLbUQ0MZIyrIyh+uT18GB4elpqgS8ssXrmd9BTkRFeQUj8UUj8dHb6y5VzWtraUeEsocC7XI6Wj/0TNvHz3zNnA2ooKsHMfRQP/AGd/zZi3e7AXIhqhUuZocr4DBgQFl+gyvs2cvZ2zP57MaGioUUalyE4I+NQQy/1m2Qx1v9uLNYjKZGuIlVe14BVS5gM+nqybV5F6gPYs3e/FmMWebWefXJdkKhapBVKBbLwqnZyz5HuJkmsV4L6S1M+vOyfhQWYgKNLcxqB9/pVFfmxiU15ZMC7RnO7lg66VofiSgH3y5QSsu4AOvwafp4yzHkq5+e6hXy77xx+kzabPx+f167mc/1VULL1O0lp9NOI2oIKP+/n7FTrx1vHPnTl199dW68cYb9dBDD6W/FwgE1NLSUuJRohxxRi0yampqSl88Bw8eTH9tbm5WK2fUYgzMWwGYIioATBEVAKaICgBTRAWAKaICwBRRAWCKqAAwRVQAmCIqAEwRFQCmiAoAU0QFgCmiAsAUUQFgiqgAMEVUAJgiKgBMERUApogKAFNEBYApogLAFFEBYIqoADBFVACYIioATBEVAKaICgBTRAWAKaICwBRRAWCKqAAwRVQAmCIqAEwRFQCmiAoAU0QFgCmiAsAUUQFgiqgAMEVUAJgiKgBMERUApogKAFNEBYApogLAFFEBYIqoADBFVACYIioATBEVAKaICgBTRAWAKaICwBRRAWCKqAAwRVQAmCIqAEwRFQCmiAoAU0QFgCmiAsAUUQFgiqgAMEVUAJgiKgBMERUApogKAFNEBYApogLAFFEBYIqoADBFVACYIioATBEVAKaICgBTRAWAKaICwBRRAWCKqAAwRVQAmCIqAEwRFQCmgmPd4UAspd3HHcUdd8yN+X1StMavtkhAAZ/PaowAzpEPh1L6XdxRIo/9u8bv09SQX7MbAsVFZcdAUv/QdVy/OZYqeKDRGp/+dFpI35lRV/BjAZx7vzw8oof2DGtvzCn4sTPCft05s07XTK7NPypevb79m2MaTI1dr0x6E67+ZW9MCVfpJwdQPl7vHtF3dw2p8JyM8kL0vV1DqvFJyy+ozW9N5acH4kUH5bN+vD+muMF2ANjZvD9WdFBOck5sJ5OMUfmPvhFZOO5I7/QnTbYFYPx6RxxtHyx8SSMTbzs9I05+UTkct5tddGd4UgClYb0/5h0Vm46NStAUoGxYr0YkXYPzVI7+fIv23rpUne2T1fPUBqOhASgHFvt3wVEJRlsVXXOXIktWFvWEAMqXxf495slvZ2tcfE3669Dbvyr6SQGUJ4v9m9P0AZgiKgBMERUApogKgNJGxU0m5cRjclMpKZU6fb1Ie/bs0WuvvSbX5XR+YDy2bt2qbdu2jWsbFvt3wVHp7dioruXTNPBqh/o6Hhi9/vqzBW0jkUjoxRdf1PLlyzVr1iytWLFCb7zxRqFDAXBCd3e3rrzySi1atEgLFizQE088ocHBQZVi/y74LeWWNevSl2JnJZs3b9bjjz+e/o8QCAROzVDi8XhR2wQgpbxZhTN6+vr27dt122236c4779TNN9+s22+/XQsXLjzn+/d5W1NJppJnzEo2bNiQDsrJ/xAAbJ38QT08PKwtW7akZy/z589Pz16GhoZ0rvncDIsZX/qvIyYb7+npVuKpf9TgK8+kZyW5InL55ZfnXVOcX729vXrhhRc0d+5cLV68uNTDQQZHjx7Vc889p2x8Jz6JsXb2ZQp//2dqnTJFFl5YENHvR4LFH/50Lpk05n0ufbPv1PW+3j5pYCCvWcm7776bvqB8vf/+++kLKo97cpkhFlO8vz9jVArdv7MpKCr5bPCzLrzwQrXMn68d//2S/H5/zrA8+OCDam9vL2j7OD8++OAD3XDDDVq1apXuueeeUg8HGXhLCsuWLVM2wWBQyWRSX25rU2+WWUqh+3fW5yr2gcM7t2rfX65Q9NvrFV39vYz3aWhs1Lq71umr312jJ598Uo899pgOHTqU8VBo9uzZmjdvXrHDwXnQ0tLC/6MydfDgwYyHPN4MpaGhQatXr04v2AZnten69wZN9m/ThVrXcdS96W6F5yzI6/7Tp0/Xfffdp/379+ull15KL9p6f2EvLgBsebMSj/fWsvfD3PtB/vDDD+f9A6HQ/ftzz1/Mg/pfflrhuYvkDA0W/Je97rrr0pdPPvnk1OzFWwhsbW0tZigAJIXDYTU3N6fPAfNmJd5byt47Pudz/y56ppLq79OR5x9VdM16jcdnZy/e+StXXHHFuLYHVLPm5mZ1dXWdmpUUGxSL/bvgmUrP5vs1cdUdCkSain7SMwYQDKYXdAGMTzQaHecWbPbvgmYqsc4diu16T03Xri76CQGUJ6v9u6CZyvD2tzSyr0u7V7WlbzvHBqRAUIlPP9aU9ZvGNRAApWW1fxcUlaaVtyjSfv2p24d/uF41U2do0k1rC9kMgDJktX8XFBV/uD59OXU7VCd/XYPZ+gqA0rHav4s++c3DIQ/wxTWlyP2bT34DYIqoADj3UakZ/S1pEyGyBZSNWr/hzp3evz+/vYy7/PQ6uxJcZLgtAOMzNeRX0Kgr3namhPKMytdbak2etKXGp4UTxrUWDMBQY9Cnrzbb7JNXNgcVCfrzi8q3poV08ThnGN6j182qk//EJ04BKA9rZ9ZpwjinK5GAT38zsy7jn2UsR0utXx2XRfStqaH0bKMQ3li/NjGoR9satbI1VNyIAZwzbZGgnrmsUSsn16qhwE8f8e7vPa5jXmN6O5lknQddEPLr72fX695L6jSYdBUb/aDunAI+pQtYY7wYBMDW3MagNs4JKuXWayDpKpHH/l3jH92/A2McfYx5cOV9mNKEGp8mFDRkAJXAC8REy7d7OU8FgDWiAsAUUQFgiqgAMEVUAJgiKgBMERUApogKAFNEBYApogLAFFEBYIqoADBFVACYIioATBEVAKaICgBTRAWAKaICwBRRAWCKqAAwRVQAmCIqAEwRFQCmiAoAU0QFgCmiAsAUUQFgiqgAMEVUAJgiKgBMERUApogKAFNEBYApogLAFFEBYIqoADBFVACYIioATBEVAKaICgBTRAWAKaICwBRRAWCKqAAwRVQAmCIqAEwRFQCmiAoAU0QFgCmiAsAUUQFgiqgAMEVUAJgiKgBMERUApogKAFNEBYApogLAFFEBYIqoADBFVACYIioATBEVAKaICgBTRAWAKaICwBRRAWCKqAAwRVQAmCIqAEwRFQCmiAoAU0QFgCmiAsAUUQFgiqgAMEVUAJgiKgBMERUApogKAFNEBYApogLAFFEBYCpouzl8UWzdulWHDx9OX//www/TX7dt26ZXXnklfT0UCmnZsmUlHSPKk891XbfUg0B5SLmu/qc/qf890KO/+Ku/lpNK5bz/361bp2VXzNcfNNcoHPCdt3GivBEVpL18KK5/2j2s3oQrua4++ugjpcaIyqxZsxSsqVGdX/qzC8Nae3HdeRsvyhdrKtB/9o7obz84PhoUj8+npubmnI+pb2hIB8Uz7EiP7Ivp4b3D52O4KHNEBeo4EJdz1veam5pyPqY5Q3R+4m2HiW/VIypVLuG4+vWR5Oe+781CvNlIJoFAQI0Z/qwn4er/juU+ZMIXH1Gpcv1JV6kCZiOe9KGRL/PCbN8IM5VqR1SqnJOjAd5sxJuVqIBDo5SISrUjKsjO51Po7V9K379FuuOPpF9sPmOBFsiEqCCnyO/NkFbeKi28KuchEXASUUFOTUu/qfo//IZU3yif35dxgRb4LKKCMZ2cnYTC4awLtMBJ/O4PxtTY2Jh+xydQX1/qoaACMFMBYIqoADBFVJCTm0zKicfker9cmEqdvg5kQVSQU2/HRnUtn6aBVzvU1/HA6PXXny31sFDG+OiDKnc47mjxO/1m23ukrUHt0Vqz7aHyMFMBYIqoADDFeSrIqnPJpDHvc+mbfedlLKgcRAVZEQwUg8Mf5GV451Z1Lo2q95mNpR4KyhxRwZhcx1H3prsVnrOg1ENBBeDwB2Pqf/lphecukjM0WOqhoAIwU0FOqf4+HXn+UUXXrC/1UFAhiApy6tl8vyauukOBSO5P1wdOIirIKta5Q7Fd76np2tWlHgoqCGsqyGp4+1sa2del3ava0redYwNSIKjEpx9ryvpNpR4eyhRRQVZNK29RpP36U7cP/3C9aqbO0KSb1pZ0XChvRAVZ+cP16cup26E6+esaWF9BTkQFeeOQB/lgoRaAKaICwBRRqXJh41dAyM8/4VHtiEqViwR9aqmxC8Gsus//28uoLkSlyvl8Pi1vsfn4x3mRgKZaT31QcXgFQN+ZHtbFdeN7KUQCPt17Cf/YGPjga5zQM+LoJwfi+reeEe0bdjSSx6vCO9CZHPKpfVKt/mRaSLMbOPQBUQFgjMMfAKaICgBTRAWAKaICQJb+HwS1Td+bGZaOAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 300x300 with 1 Axes>"
       ]
@@ -147,7 +144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -165,7 +162,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -175,14 +172,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "548 μs ± 34.7 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
+      "448 μs ± 72.8 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
      ]
     }
    ],
@@ -212,7 +209,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -229,7 +226,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -238,7 +235,7 @@
        "sympy.core.symbol.Symbol"
       ]
      },
-     "execution_count": 47,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -258,7 +255,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -272,7 +269,7 @@
        "x â‹…(x + y + 5) + x "
       ]
      },
-     "execution_count": 48,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -291,7 +288,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -305,7 +302,7 @@
        "x  + x â‹…y + 6â‹…x "
       ]
      },
-     "execution_count": 49,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -316,7 +313,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -330,7 +327,7 @@
        "x â‹…(x + y + 6)"
       ]
      },
-     "execution_count": 50,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -341,7 +338,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -355,7 +352,7 @@
        "x â‹…(x + cos(x) + 5) + x "
       ]
      },
-     "execution_count": 51,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -373,7 +370,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -387,7 +384,7 @@
        "x â‹…(x + y + 5) + x  = 1"
       ]
      },
-     "execution_count": 52,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -399,7 +396,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -415,7 +412,7 @@
        "⎣         x ⎦"
       ]
      },
-     "execution_count": 53,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -433,7 +430,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -447,7 +444,7 @@
        "x â‹…(x + y + 5) + x "
       ]
      },
-     "execution_count": 54,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -458,7 +455,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -467,7 +464,7 @@
        "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
        "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
        " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
-       "<!-- Generated by graphviz version 11.0.0 (0)\n",
+       "<!-- Generated by graphviz version 12.1.2 (0)\n",
        " -->\n",
        "<!-- Pages: 1 -->\n",
        "<svg width=\"422pt\" height=\"260pt\"\n",
@@ -616,10 +613,10 @@
        "</svg>\n"
       ],
       "text/plain": [
-       "<graphviz.sources.Source at 0x7e3154f58d30>"
+       "<graphviz.sources.Source at 0x7fd4d0f809d0>"
       ]
      },
-     "execution_count": 55,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -638,7 +635,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -647,7 +644,7 @@
        "sympy.core.add.Add"
       ]
      },
-     "execution_count": 56,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -658,7 +655,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -672,7 +669,7 @@
        "⎝x , x ⋅(x + y + 5)⎠"
       ]
      },
-     "execution_count": 57,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -699,7 +696,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -715,7 +712,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -728,7 +725,7 @@
        "f_E__1"
       ]
      },
-     "execution_count": 59,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -747,7 +744,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -756,7 +753,7 @@
        "True"
       ]
      },
-     "execution_count": 60,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -776,7 +773,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -785,7 +782,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
@@ -802,7 +799,7 @@
        "_W__2â‹…wâ‚‚) "
       ]
      },
-     "execution_count": 62,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -824,7 +821,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
@@ -841,7 +838,7 @@
        " img_W__2â‹…wâ‚‚) "
       ]
      },
-     "execution_count": 63,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -860,7 +857,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
@@ -877,7 +874,7 @@
        "g_SW__2 - img_W__2â‹…wâ‚‚) "
       ]
      },
-     "execution_count": 64,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -897,14 +894,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/media/data/fhennig/research-hpc/projects/2024_pystencils_nbackend/pystencils/src/pystencils/config.py:327: FutureWarning: The `cpu_openmp` option of CreateKernelConfig is deprecated and will be removed in pystencils 2.1. Use `cpu_optim.openmp` instead.\n",
+      "/media/data/fhennig/research-hpc/projects/2024_pystencils_nbackend/pystencils/src/pystencils/codegen/config.py:633: FutureWarning: The `cpu_openmp` option of CreateKernelConfig is deprecated and will be removed in pystencils 2.1. Use `cpu_optim.openmp` instead.\n",
+      "  warn(\n",
+      "/media/data/fhennig/research-hpc/projects/2024_pystencils_nbackend/pystencils/src/pystencils/codegen/config.py:543: UserWarning: Setting the deprecated `cpu_openmp` option will override any options passed in the `cpu.openmp` category.\n",
       "  warn(\n"
      ]
     }
@@ -925,15 +924,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "No requests or imageio installed\n"
-     ]
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -953,12 +955,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -985,7 +987,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1002,7 +1004,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
@@ -1016,9 +1018,9 @@
        ".highlight .hll { background-color: #ffffcc }\n",
        ".highlight { background: #f8f8f8; }\n",
        ".highlight .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".highlight .err { border: 1px solid #FF0000 } /* Error */\n",
+       ".highlight .err { border: 1px solid #F00 } /* Error */\n",
        ".highlight .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".highlight .o { color: #666666 } /* Operator */\n",
+       ".highlight .o { color: #666 } /* Operator */\n",
        ".highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
        ".highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
        ".highlight .cp { color: #9C6500 } /* Comment.Preproc */\n",
@@ -1035,34 +1037,34 @@
        ".highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
        ".highlight .gs { font-weight: bold } /* Generic.Strong */\n",
        ".highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".highlight .gt { color: #0044DD } /* Generic.Traceback */\n",
+       ".highlight .gt { color: #04D } /* Generic.Traceback */\n",
        ".highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
        ".highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
        ".highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
        ".highlight .kp { color: #008000 } /* Keyword.Pseudo */\n",
        ".highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
        ".highlight .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".highlight .m { color: #666666 } /* Literal.Number */\n",
+       ".highlight .m { color: #666 } /* Literal.Number */\n",
        ".highlight .s { color: #BA2121 } /* Literal.String */\n",
        ".highlight .na { color: #687822 } /* Name.Attribute */\n",
        ".highlight .nb { color: #008000 } /* Name.Builtin */\n",
-       ".highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".highlight .no { color: #880000 } /* Name.Constant */\n",
-       ".highlight .nd { color: #AA22FF } /* Name.Decorator */\n",
+       ".highlight .nc { color: #00F; font-weight: bold } /* Name.Class */\n",
+       ".highlight .no { color: #800 } /* Name.Constant */\n",
+       ".highlight .nd { color: #A2F } /* Name.Decorator */\n",
        ".highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
        ".highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".highlight .nf { color: #0000FF } /* Name.Function */\n",
+       ".highlight .nf { color: #00F } /* Name.Function */\n",
        ".highlight .nl { color: #767600 } /* Name.Label */\n",
-       ".highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
+       ".highlight .nn { color: #00F; font-weight: bold } /* Name.Namespace */\n",
        ".highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
        ".highlight .nv { color: #19177C } /* Name.Variable */\n",
-       ".highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".highlight .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".highlight .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".highlight .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".highlight .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".highlight .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".highlight .mo { color: #666666 } /* Literal.Number.Oct */\n",
+       ".highlight .ow { color: #A2F; font-weight: bold } /* Operator.Word */\n",
+       ".highlight .w { color: #BBB } /* Text.Whitespace */\n",
+       ".highlight .mb { color: #666 } /* Literal.Number.Bin */\n",
+       ".highlight .mf { color: #666 } /* Literal.Number.Float */\n",
+       ".highlight .mh { color: #666 } /* Literal.Number.Hex */\n",
+       ".highlight .mi { color: #666 } /* Literal.Number.Integer */\n",
+       ".highlight .mo { color: #666 } /* Literal.Number.Oct */\n",
        ".highlight .sa { color: #BA2121 } /* Literal.String.Affix */\n",
        ".highlight .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
        ".highlight .sc { color: #BA2121 } /* Literal.String.Char */\n",
@@ -1077,12 +1079,12 @@
        ".highlight .s1 { color: #BA2121 } /* Literal.String.Single */\n",
        ".highlight .ss { color: #19177C } /* Literal.String.Symbol */\n",
        ".highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".highlight .fm { color: #0000FF } /* Name.Function.Magic */\n",
+       ".highlight .fm { color: #00F } /* Name.Function.Magic */\n",
        ".highlight .vc { color: #19177C } /* Name.Variable.Class */\n",
        ".highlight .vg { color: #19177C } /* Name.Variable.Global */\n",
        ".highlight .vi { color: #19177C } /* Name.Variable.Instance */\n",
        ".highlight .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".highlight .il { color: #666666 } /* Literal.Number.Integer.Long */</style>"
+       ".highlight .il { color: #666 } /* Literal.Number.Integer.Long */</style>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -1094,32 +1096,28 @@
     {
      "data": {
       "text/html": [
-       "<div class=\"highlight\"><pre><span></span><span class=\"n\">FUNC_PREFIX</span><span class=\"w\"> </span><span class=\"kt\">void</span><span class=\"w\"> </span><span class=\"n\">kernel</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\">  </span><span class=\"n\">dst_data</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\">  </span><span class=\"n\">img_data</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"p\">)</span>\n",
+       "<div class=\"highlight\"><pre><span></span><span class=\"n\">FUNC_PREFIX</span><span class=\"w\"> </span><span class=\"kt\">void</span><span class=\"w\"> </span><span class=\"n\">kernel</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">RESTRICT</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"n\">_data_dst</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">RESTRICT</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"p\">)</span>\n",
        "<span class=\"p\">{</span>\n",
        "<span class=\"w\">   </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"n\">_size_dst_0</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
        "<span class=\"w\">   </span><span class=\"p\">{</span>\n",
        "<span class=\"w\">      </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"n\">_size_dst_1</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
        "<span class=\"w\">      </span><span class=\"p\">{</span>\n",
-       "<span class=\"w\">         </span><span class=\"n\">dst_data</span><span class=\"p\">[</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">])</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]);</span>\n",
+       "<span class=\"w\">         </span><span class=\"n\">_data_dst</span><span class=\"p\">[</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">])</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]);</span>\n",
        "<span class=\"w\">      </span><span class=\"p\">}</span>\n",
-       "\n",
        "<span class=\"w\">   </span><span class=\"p\">}</span>\n",
-       "\n",
        "<span class=\"p\">}</span>\n",
        "</pre></div>\n"
       ],
       "text/plain": [
-       "FUNC_PREFIX void kernel (const int64_t _size_dst_0, const int64_t _size_dst_1, const int64_t _stride_dst_0, const int64_t _stride_dst_1, const int64_t _stride_img_0, const int64_t _stride_img_1, const int64_t _stride_img_2, double * const  dst_data, double * const  img_data, const double w_2)\n",
+       "FUNC_PREFIX void kernel (double * RESTRICT const _data_dst, double * RESTRICT const _data_img, const int64_t _size_dst_0, const int64_t _size_dst_1, const int64_t _stride_dst_0, const int64_t _stride_dst_1, const int64_t _stride_img_0, const int64_t _stride_img_1, const int64_t _stride_img_2, const double w_2)\n",
        "{\n",
        "   for(int64_t ctr_0 = 1LL; ctr_0 < _size_dst_0 - 1LL; ctr_0 += 1LL)\n",
        "   {\n",
        "      for(int64_t ctr_1 = 1LL; ctr_1 < _size_dst_1 - 1LL; ctr_1 += 1LL)\n",
        "      {\n",
-       "         dst_data[ctr_0 * _stride_dst_0 + ctr_1 * _stride_dst_1] = (0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * img_data[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * img_data[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]) * (0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * img_data[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * img_data[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]);\n",
+       "         _data_dst[ctr_0 * _stride_dst_0 + ctr_1 * _stride_dst_1] = (0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]) * (0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]);\n",
        "      }\n",
-       "\n",
        "   }\n",
-       "\n",
        "}"
       ]
      },
@@ -1154,9 +1152,9 @@
        ".highlight .hll { background-color: #ffffcc }\n",
        ".highlight { background: #f8f8f8; }\n",
        ".highlight .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".highlight .err { border: 1px solid #FF0000 } /* Error */\n",
+       ".highlight .err { border: 1px solid #F00 } /* Error */\n",
        ".highlight .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".highlight .o { color: #666666 } /* Operator */\n",
+       ".highlight .o { color: #666 } /* Operator */\n",
        ".highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
        ".highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
        ".highlight .cp { color: #9C6500 } /* Comment.Preproc */\n",
@@ -1173,34 +1171,34 @@
        ".highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
        ".highlight .gs { font-weight: bold } /* Generic.Strong */\n",
        ".highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".highlight .gt { color: #0044DD } /* Generic.Traceback */\n",
+       ".highlight .gt { color: #04D } /* Generic.Traceback */\n",
        ".highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
        ".highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
        ".highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
        ".highlight .kp { color: #008000 } /* Keyword.Pseudo */\n",
        ".highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
        ".highlight .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".highlight .m { color: #666666 } /* Literal.Number */\n",
+       ".highlight .m { color: #666 } /* Literal.Number */\n",
        ".highlight .s { color: #BA2121 } /* Literal.String */\n",
        ".highlight .na { color: #687822 } /* Name.Attribute */\n",
        ".highlight .nb { color: #008000 } /* Name.Builtin */\n",
-       ".highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".highlight .no { color: #880000 } /* Name.Constant */\n",
-       ".highlight .nd { color: #AA22FF } /* Name.Decorator */\n",
+       ".highlight .nc { color: #00F; font-weight: bold } /* Name.Class */\n",
+       ".highlight .no { color: #800 } /* Name.Constant */\n",
+       ".highlight .nd { color: #A2F } /* Name.Decorator */\n",
        ".highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
        ".highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".highlight .nf { color: #0000FF } /* Name.Function */\n",
+       ".highlight .nf { color: #00F } /* Name.Function */\n",
        ".highlight .nl { color: #767600 } /* Name.Label */\n",
-       ".highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
+       ".highlight .nn { color: #00F; font-weight: bold } /* Name.Namespace */\n",
        ".highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
        ".highlight .nv { color: #19177C } /* Name.Variable */\n",
-       ".highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".highlight .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".highlight .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".highlight .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".highlight .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".highlight .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".highlight .mo { color: #666666 } /* Literal.Number.Oct */\n",
+       ".highlight .ow { color: #A2F; font-weight: bold } /* Operator.Word */\n",
+       ".highlight .w { color: #BBB } /* Text.Whitespace */\n",
+       ".highlight .mb { color: #666 } /* Literal.Number.Bin */\n",
+       ".highlight .mf { color: #666 } /* Literal.Number.Float */\n",
+       ".highlight .mh { color: #666 } /* Literal.Number.Hex */\n",
+       ".highlight .mi { color: #666 } /* Literal.Number.Integer */\n",
+       ".highlight .mo { color: #666 } /* Literal.Number.Oct */\n",
        ".highlight .sa { color: #BA2121 } /* Literal.String.Affix */\n",
        ".highlight .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
        ".highlight .sc { color: #BA2121 } /* Literal.String.Char */\n",
@@ -1215,12 +1213,12 @@
        ".highlight .s1 { color: #BA2121 } /* Literal.String.Single */\n",
        ".highlight .ss { color: #19177C } /* Literal.String.Symbol */\n",
        ".highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".highlight .fm { color: #0000FF } /* Name.Function.Magic */\n",
+       ".highlight .fm { color: #00F } /* Name.Function.Magic */\n",
        ".highlight .vc { color: #19177C } /* Name.Variable.Class */\n",
        ".highlight .vg { color: #19177C } /* Name.Variable.Global */\n",
        ".highlight .vi { color: #19177C } /* Name.Variable.Instance */\n",
        ".highlight .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".highlight .il { color: #666666 } /* Literal.Number.Integer.Long */</style>"
+       ".highlight .il { color: #666 } /* Literal.Number.Integer.Long */</style>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -1232,34 +1230,30 @@
     {
      "data": {
       "text/html": [
-       "<div class=\"highlight\"><pre><span></span><span class=\"n\">FUNC_PREFIX</span><span class=\"w\"> </span><span class=\"kt\">void</span><span class=\"w\"> </span><span class=\"n\">kernel</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\">  </span><span class=\"n\">dst_data</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\">  </span><span class=\"n\">img_data</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"p\">)</span>\n",
+       "<div class=\"highlight\"><pre><span></span><span class=\"n\">FUNC_PREFIX</span><span class=\"w\"> </span><span class=\"kt\">void</span><span class=\"w\"> </span><span class=\"n\">kernel</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">RESTRICT</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"n\">_data_dst</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">RESTRICT</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_size_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"p\">)</span>\n",
        "<span class=\"p\">{</span>\n",
        "<span class=\"w\">   </span><span class=\"cp\">#pragma omp parallel for schedule(static) num_threads(2)</span>\n",
        "<span class=\"w\">   </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"n\">_size_dst_0</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
        "<span class=\"w\">   </span><span class=\"p\">{</span>\n",
        "<span class=\"w\">      </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"n\">_size_dst_1</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
        "<span class=\"w\">      </span><span class=\"p\">{</span>\n",
-       "<span class=\"w\">         </span><span class=\"n\">dst_data</span><span class=\"p\">[</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">])</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">img_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]);</span>\n",
+       "<span class=\"w\">         </span><span class=\"n\">_data_dst</span><span class=\"p\">[</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_dst_1</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">])</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-0.5</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">w_2</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_img</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_stride_img_2</span><span class=\"p\">]);</span>\n",
        "<span class=\"w\">      </span><span class=\"p\">}</span>\n",
-       "\n",
        "<span class=\"w\">   </span><span class=\"p\">}</span>\n",
-       "\n",
        "<span class=\"p\">}</span>\n",
        "</pre></div>\n"
       ],
       "text/plain": [
-       "FUNC_PREFIX void kernel (const int64_t _size_dst_0, const int64_t _size_dst_1, const int64_t _stride_dst_0, const int64_t _stride_dst_1, const int64_t _stride_img_0, const int64_t _stride_img_1, const int64_t _stride_img_2, double * const  dst_data, double * const  img_data, const double w_2)\n",
+       "FUNC_PREFIX void kernel (double * RESTRICT const _data_dst, double * RESTRICT const _data_img, const int64_t _size_dst_0, const int64_t _size_dst_1, const int64_t _stride_dst_0, const int64_t _stride_dst_1, const int64_t _stride_img_0, const int64_t _stride_img_1, const int64_t _stride_img_2, const double w_2)\n",
        "{\n",
        "   #pragma omp parallel for schedule(static) num_threads(2)\n",
        "   for(int64_t ctr_0 = 1LL; ctr_0 < _size_dst_0 - 1LL; ctr_0 += 1LL)\n",
        "   {\n",
        "      for(int64_t ctr_1 = 1LL; ctr_1 < _size_dst_1 - 1LL; ctr_1 += 1LL)\n",
        "      {\n",
-       "         dst_data[ctr_0 * _stride_dst_0 + ctr_1 * _stride_dst_1] = (0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * img_data[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * img_data[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]) * (0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] - 0.5 * img_data[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * img_data[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * img_data[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]);\n",
+       "         _data_dst[ctr_0 * _stride_dst_0 + ctr_1 * _stride_dst_1] = (0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]) * (0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + 1LL) * _stride_img_1 + 2LL * _stride_img_2] + -0.5 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + (ctr_1 + -1LL) * _stride_img_1 + 2LL * _stride_img_2] + w_2 * _data_img[(ctr_0 + 1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2] - w_2 * _data_img[(ctr_0 + -1LL) * _stride_img_0 + ctr_1 * _stride_img_1 + 2LL * _stride_img_2]);\n",
        "      }\n",
-       "\n",
        "   }\n",
-       "\n",
        "}"
       ]
      },
@@ -1268,11 +1262,13 @@
     }
    ],
    "source": [
+    "cfg = ps.CreateKernelConfig()\n",
+    "cfg.cpu.openmp.enable = True\n",
+    "cfg.cpu.openmp.num_threads = 2\n",
     "ast = ps.create_kernel(\n",
     "    update_rule,\n",
-    "    cpu_optim = ps.CpuOptimConfig(\n",
-    "        openmp=ps.OpenMpConfig(num_threads=2))\n",
-    "    )\n",
+    "    cfg\n",
+    ")\n",
     "\n",
     "ps.show_code(ast)"
    ]
@@ -1289,7 +1285,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
@@ -1303,9 +1299,9 @@
        ".highlight .hll { background-color: #ffffcc }\n",
        ".highlight { background: #f8f8f8; }\n",
        ".highlight .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".highlight .err { border: 1px solid #FF0000 } /* Error */\n",
+       ".highlight .err { border: 1px solid #F00 } /* Error */\n",
        ".highlight .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".highlight .o { color: #666666 } /* Operator */\n",
+       ".highlight .o { color: #666 } /* Operator */\n",
        ".highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
        ".highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
        ".highlight .cp { color: #9C6500 } /* Comment.Preproc */\n",
@@ -1322,34 +1318,34 @@
        ".highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
        ".highlight .gs { font-weight: bold } /* Generic.Strong */\n",
        ".highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".highlight .gt { color: #0044DD } /* Generic.Traceback */\n",
+       ".highlight .gt { color: #04D } /* Generic.Traceback */\n",
        ".highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
        ".highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
        ".highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
        ".highlight .kp { color: #008000 } /* Keyword.Pseudo */\n",
        ".highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
        ".highlight .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".highlight .m { color: #666666 } /* Literal.Number */\n",
+       ".highlight .m { color: #666 } /* Literal.Number */\n",
        ".highlight .s { color: #BA2121 } /* Literal.String */\n",
        ".highlight .na { color: #687822 } /* Name.Attribute */\n",
        ".highlight .nb { color: #008000 } /* Name.Builtin */\n",
-       ".highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".highlight .no { color: #880000 } /* Name.Constant */\n",
-       ".highlight .nd { color: #AA22FF } /* Name.Decorator */\n",
+       ".highlight .nc { color: #00F; font-weight: bold } /* Name.Class */\n",
+       ".highlight .no { color: #800 } /* Name.Constant */\n",
+       ".highlight .nd { color: #A2F } /* Name.Decorator */\n",
        ".highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
        ".highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".highlight .nf { color: #0000FF } /* Name.Function */\n",
+       ".highlight .nf { color: #00F } /* Name.Function */\n",
        ".highlight .nl { color: #767600 } /* Name.Label */\n",
-       ".highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
+       ".highlight .nn { color: #00F; font-weight: bold } /* Name.Namespace */\n",
        ".highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
        ".highlight .nv { color: #19177C } /* Name.Variable */\n",
-       ".highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".highlight .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".highlight .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".highlight .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".highlight .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".highlight .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".highlight .mo { color: #666666 } /* Literal.Number.Oct */\n",
+       ".highlight .ow { color: #A2F; font-weight: bold } /* Operator.Word */\n",
+       ".highlight .w { color: #BBB } /* Text.Whitespace */\n",
+       ".highlight .mb { color: #666 } /* Literal.Number.Bin */\n",
+       ".highlight .mf { color: #666 } /* Literal.Number.Float */\n",
+       ".highlight .mh { color: #666 } /* Literal.Number.Hex */\n",
+       ".highlight .mi { color: #666 } /* Literal.Number.Integer */\n",
+       ".highlight .mo { color: #666 } /* Literal.Number.Oct */\n",
        ".highlight .sa { color: #BA2121 } /* Literal.String.Affix */\n",
        ".highlight .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
        ".highlight .sc { color: #BA2121 } /* Literal.String.Char */\n",
@@ -1364,12 +1360,12 @@
        ".highlight .s1 { color: #BA2121 } /* Literal.String.Single */\n",
        ".highlight .ss { color: #19177C } /* Literal.String.Symbol */\n",
        ".highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".highlight .fm { color: #0000FF } /* Name.Function.Magic */\n",
+       ".highlight .fm { color: #00F } /* Name.Function.Magic */\n",
        ".highlight .vc { color: #19177C } /* Name.Variable.Class */\n",
        ".highlight .vg { color: #19177C } /* Name.Variable.Global */\n",
        ".highlight .vi { color: #19177C } /* Name.Variable.Instance */\n",
        ".highlight .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".highlight .il { color: #666666 } /* Literal.Number.Integer.Long */</style>"
+       ".highlight .il { color: #666 } /* Literal.Number.Integer.Long */</style>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -1381,32 +1377,28 @@
     {
      "data": {
       "text/html": [
-       "<div class=\"highlight\"><pre><span></span><span class=\"n\">FUNC_PREFIX</span><span class=\"w\"> </span><span class=\"kt\">void</span><span class=\"w\"> </span><span class=\"n\">kernel</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\">  </span><span class=\"n\">I_data</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\">  </span><span class=\"n\">dst_data</span><span class=\"p\">)</span>\n",
+       "<div class=\"highlight\"><pre><span></span><span class=\"n\">FUNC_PREFIX</span><span class=\"w\"> </span><span class=\"kt\">void</span><span class=\"w\"> </span><span class=\"n\">kernel</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">RESTRICT</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"n\">_data_I</span><span class=\"p\">,</span><span class=\"w\"> </span><span class=\"kt\">double</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">RESTRICT</span><span class=\"w\"> </span><span class=\"k\">const</span><span class=\"w\"> </span><span class=\"n\">_data_dst</span><span class=\"p\">)</span>\n",
        "<span class=\"p\">{</span>\n",
-       "<span class=\"w\">   </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mf\">81L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
+       "<span class=\"w\">   </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mf\">202L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
        "<span class=\"w\">   </span><span class=\"p\">{</span>\n",
-       "<span class=\"w\">      </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mf\">289L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
+       "<span class=\"w\">      </span><span class=\"k\">for</span><span class=\"p\">(</span><span class=\"kt\">int64_t</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">&lt;</span><span class=\"w\"> </span><span class=\"mf\">600L</span><span class=\"n\">L</span><span class=\"p\">;</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+=</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span>\n",
        "<span class=\"w\">      </span><span class=\"p\">{</span>\n",
-       "<span class=\"w\">         </span><span class=\"n\">dst_data</span><span class=\"p\">[</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">290L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">-1.0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">I_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1160L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">I_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1160L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">I_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1160L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"mf\">2.0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">I_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1160L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2.0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">I_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1160L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">I_data</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">1160L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">];</span>\n",
+       "<span class=\"w\">         </span><span class=\"n\">_data_dst</span><span class=\"p\">[</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">601L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">=</span><span class=\"w\"> </span><span class=\"mf\">-1.0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_I</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">2404L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">_data_I</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">2404L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">-</span><span class=\"w\"> </span><span class=\"n\">_data_I</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">2404L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">-2.0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_I</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">2404L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">2.0</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"n\">_data_I</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">2404L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">]</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"n\">_data_I</span><span class=\"p\">[(</span><span class=\"n\">ctr_0</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">2404L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"p\">(</span><span class=\"n\">ctr_1</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mi\">-1LL</span><span class=\"p\">)</span><span class=\"w\"> </span><span class=\"o\">*</span><span class=\"w\"> </span><span class=\"mf\">4L</span><span class=\"n\">L</span><span class=\"w\"> </span><span class=\"o\">+</span><span class=\"w\"> </span><span class=\"mf\">1L</span><span class=\"n\">L</span><span class=\"p\">];</span>\n",
        "<span class=\"w\">      </span><span class=\"p\">}</span>\n",
-       "\n",
        "<span class=\"w\">   </span><span class=\"p\">}</span>\n",
-       "\n",
        "<span class=\"p\">}</span>\n",
        "</pre></div>\n"
       ],
       "text/plain": [
-       "FUNC_PREFIX void kernel (double * const  I_data, double * const  dst_data)\n",
+       "FUNC_PREFIX void kernel (double * RESTRICT const _data_I, double * RESTRICT const _data_dst)\n",
        "{\n",
-       "   for(int64_t ctr_0 = 1LL; ctr_0 < 81LL; ctr_0 += 1LL)\n",
+       "   for(int64_t ctr_0 = 1LL; ctr_0 < 202LL; ctr_0 += 1LL)\n",
        "   {\n",
-       "      for(int64_t ctr_1 = 1LL; ctr_1 < 289LL; ctr_1 += 1LL)\n",
+       "      for(int64_t ctr_1 = 1LL; ctr_1 < 600LL; ctr_1 += 1LL)\n",
        "      {\n",
-       "         dst_data[ctr_0 * 290LL + ctr_1] = -1.0 * I_data[(ctr_0 + 1LL) * 1160LL + (ctr_1 + 1LL) * 4LL + 1LL] - I_data[(ctr_0 + -1LL) * 1160LL + (ctr_1 + 1LL) * 4LL + 1LL] - I_data[(ctr_0 + -1LL) * 1160LL + (ctr_1 + -1LL) * 4LL + 1LL] - 2.0 * I_data[(ctr_0 + -1LL) * 1160LL + ctr_1 * 4LL + 1LL] + 2.0 * I_data[(ctr_0 + 1LL) * 1160LL + ctr_1 * 4LL + 1LL] + I_data[(ctr_0 + 1LL) * 1160LL + (ctr_1 + -1LL) * 4LL + 1LL];\n",
+       "         _data_dst[ctr_0 * 601LL + ctr_1] = -1.0 * _data_I[(ctr_0 + 1LL) * 2404LL + (ctr_1 + 1LL) * 4LL + 1LL] - _data_I[(ctr_0 + -1LL) * 2404LL + (ctr_1 + 1LL) * 4LL + 1LL] - _data_I[(ctr_0 + -1LL) * 2404LL + (ctr_1 + -1LL) * 4LL + 1LL] + -2.0 * _data_I[(ctr_0 + -1LL) * 2404LL + ctr_1 * 4LL + 1LL] + 2.0 * _data_I[(ctr_0 + 1LL) * 2404LL + ctr_1 * 4LL + 1LL] + _data_I[(ctr_0 + 1LL) * 2404LL + (ctr_1 + -1LL) * 4LL + 1LL];\n",
        "      }\n",
-       "\n",
        "   }\n",
-       "\n",
        "}"
       ]
      },
@@ -1443,7 +1435,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
     {
@@ -1486,7 +1478,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.14"
   }
  },
  "nbformat": 4,
diff --git a/docs/source/reference/gpu_kernels.md b/docs/source/user_manual/gpu_kernels.md
similarity index 97%
rename from docs/source/reference/gpu_kernels.md
rename to docs/source/user_manual/gpu_kernels.md
index 786840d182b0e06d4e26085cf6a95dbcb31d16b2..4db2d79443bc1d09031b3f1a8c8af014a0c824a8 100644
--- a/docs/source/reference/gpu_kernels.md
+++ b/docs/source/user_manual/gpu_kernels.md
@@ -159,15 +159,10 @@ kernel = ps.create_kernel(assignments, cfg).compile()
 ```
 
 This warns us that the threads range could not be determined automatically.
-We can disable this warning by setting `manual_launch_grid` in the GPU indexing options:
+We can disable this warning by setting `manual_launch_grid` in the GPU option category:
 
 ```{code-cell}
-cfg = ps.CreateKernelConfig(
-    # ... other options ...
-    gpu_indexing=ps.GpuIndexingConfig(
-        manual_launch_grid=True
-    )
-)
+cfg.gpu.manual_launch_grid = True
 ```
 
 Now, to execute our kernel, we have to manually specify its launch grid:
diff --git a/docs/source/reference/kernelcreation.md b/docs/source/user_manual/kernelcreation.md
similarity index 99%
rename from docs/source/reference/kernelcreation.md
rename to docs/source/user_manual/kernelcreation.md
index 248855fc1c755d9fee4c62c7db07d469d3ac84ed..c85c8f99d3490602321c57f881b32b0127051c70 100644
--- a/docs/source/reference/kernelcreation.md
+++ b/docs/source/user_manual/kernelcreation.md
@@ -485,13 +485,10 @@ h = sp.Symbol("h")
 cfg = ps.CreateKernelConfig(
   target=ps.Target.X86_AVX512,
   default_dtype="float32",
-  cpu_optim=ps.CpuOptimConfig(
-    openmp=True,
-    vectorize=ps.VectorizationConfig(
-        assume_inner_stride_one=True
-    )
-  )
 )
+cfg.cpu.openmp.enable = True
+cfg.cpu.vectorize.enable = True
+cfg.cpu.vectorize.assume_inner_stride_one = True
 
 assignments = [
   ps.Assignment(
diff --git a/docs/source/reference/symbolic_language.rst b/docs/source/user_manual/symbolic_language.rst
similarity index 96%
rename from docs/source/reference/symbolic_language.rst
rename to docs/source/user_manual/symbolic_language.rst
index 63b94e04d5026d8210c37db9f2d43f36159aa846..6d219306ec2f677f87f7dd7ca1edb1bd38f3d6d0 100644
--- a/docs/source/reference/symbolic_language.rst
+++ b/docs/source/user_manual/symbolic_language.rst
@@ -42,10 +42,6 @@ Assignments are the fundamental components of pystencils kernels;
 they are used both for assigning expressions to symbols
 and for writing values to fields.
 
-.. py:class:: pystencils.Assignment
-
-    Slightly monkey-patched version of `sympy.codegen.ast.Assignment`.
-
 Assignments are combined and structured inside `assignment collections <pystencils.AssignmentCollection>`.
 An assignment collection contains two separate lists of assignments:
 
@@ -56,10 +52,9 @@ An assignment collection contains two separate lists of assignments:
   into fields.
 
 .. autosummary::
-    :toctree: generated
     :nosignatures:
-    :template: autosummary/recursive_class.rst
 
+    pystencils.Assignment
     pystencils.AssignmentCollection
 
 
diff --git a/src/pystencils/__init__.py b/src/pystencils/__init__.py
index 6cb375b61e63904c0cd3c2e6e9d6a3be86be6b29..a23ce185d1a4f6c9cd9a17fccf315462eddf287f 100644
--- a/src/pystencils/__init__.py
+++ b/src/pystencils/__init__.py
@@ -3,10 +3,6 @@
 from .codegen import (
     Target,
     CreateKernelConfig,
-    CpuOptimConfig,
-    VectorizationConfig,
-    OpenMpConfig,
-    GpuIndexingConfig,
     AUTO
 )
 from .defaults import DEFAULTS
@@ -50,10 +46,6 @@ __all__ = [
     "create_numeric_type",
     "make_slice",
     "CreateKernelConfig",
-    "CpuOptimConfig",
-    "VectorizationConfig",
-    "GpuIndexingConfig",
-    "OpenMpConfig",
     "AUTO",
     "create_kernel",
     "create_staggered_kernel",
diff --git a/src/pystencils/backend/kernelcreation/iteration_space.py b/src/pystencils/backend/kernelcreation/iteration_space.py
index 031a0d843f3f5a648f2cd8c390134ba308c1c833..313377fd886709ada8961fe17210f15a58a4ce49 100644
--- a/src/pystencils/backend/kernelcreation/iteration_space.py
+++ b/src/pystencils/backend/kernelcreation/iteration_space.py
@@ -17,7 +17,6 @@ from ...types import PsStructType
 from ..exceptions import PsInputError, KernelConstraintsError
 
 if TYPE_CHECKING:
-    from ...codegen.config import _AUTO_TYPE
     from .context import KernelCreationContext
 
 
@@ -62,6 +61,7 @@ class FullIterationSpace(IterationSpace):
     @dataclass
     class Dimension:
         """One dimension of a dense iteration space"""
+
         start: PsExpression
         stop: PsExpression
         step: PsExpression
@@ -196,7 +196,7 @@ class FullIterationSpace(IterationSpace):
     def dimensions(self):
         """The dimensions of this iteration space"""
         return self._dimensions
-    
+
     @property
     def counters(self) -> tuple[PsSymbol, ...]:
         return tuple(dim.counter for dim in self._dimensions)
@@ -220,7 +220,7 @@ class FullIterationSpace(IterationSpace):
     def archetype_field(self) -> Field | None:
         """Field whose shape and memory layout act as archetypes for this iteration space's dimensions."""
         return self._archetype_field
-    
+
     @property
     def loop_order(self) -> tuple[int, ...]:
         """Return the loop order of this iteration space, ordered from slowest to fastest coordinate."""
@@ -242,7 +242,7 @@ class FullIterationSpace(IterationSpace):
         self, dimension: int | FullIterationSpace.Dimension | None = None
     ) -> PsExpression:
         """Construct an expression representing the actual number of unique points inside the iteration space.
-        
+
         Args:
             dimension: If an integer or a `Dimension` object is given, the number of iterations in that
                 dimension is computed. If `None`, the total number of iterations inside the entire space
@@ -417,14 +417,55 @@ def create_sparse_iteration_space(
 def create_full_iteration_space(
     ctx: KernelCreationContext,
     assignments: AssignmentCollection,
-    ghost_layers: None | _AUTO_TYPE | int | Sequence[int | tuple[int, int]] = None,
+    ghost_layers: None | int | Sequence[int | tuple[int, int]] = None,
     iteration_slice: None | int | slice | tuple[int | slice, ...] = None,
+    infer_ghost_layers: bool = False,
 ) -> IterationSpace:
+    """Create a dense iteration space from a sequence of assignments and iteration slice information.
+
+    This function finds all accesses to fields in the given assignment collection,
+    analyzes the set of fields involved,
+    and determines the iteration space bounds from these.
+    This requires that either all fields are of the same, fixed, shape, or all of them are
+    variable-shaped.
+    Also, all fields need to have the same memory layout of their spatial dimensions.
+
+    Args:
+        ctx: The kernel creation context
+        assignments: Collection of assignments the iteration space should be inferred from
+        ghost_layers: If set, strip off that many ghost layers from all sides of the iteration cuboid
+        iteration_slice: If set, constrain iteration to the given slice.
+            For details on the parsing of slices, see `AstFactory.parse_slice`.
+        infer_ghost_layers: If `True`, infer the number of ghost layers from the stencil ranges
+            used in the kernel.
+
+    Returns:
+        IterationSpace: The constructed iteration space.
+
+    Raises:
+        KernelConstraintsError: If field shape or memory layout conflicts are detected
+        ValueError: If the iteration slice could not be parsed
+
+    .. attention::
+        The ``ghost_layers`` and ``iteration_slice`` arguments are mutually exclusive.
+        Also, if ``infer_ghost_layers=True``, none of them may be set.
+    """
+
     assert not ctx.fields.index_fields
 
-    if (ghost_layers is not None) and (iteration_slice is not None):
+    if (ghost_layers is None) and (iteration_slice is None) and not infer_ghost_layers:
         raise ValueError(
-            "At most one of `ghost_layers` and `iteration_slice` may be specified."
+            "One argument of `ghost_layers`, `iteration_slice`, and `infer_ghost_layers` must be set."
+        )
+
+    if (
+        int(ghost_layers is not None)
+        + int(iteration_slice is not None)
+        + int(infer_ghost_layers)
+        > 1
+    ):
+        raise ValueError(
+            "At most one of `ghost_layers`, `iteration_slice`, and `infer_ghost_layers` may be set."
         )
 
     #   Collect all relative accesses into domain fields
@@ -457,9 +498,7 @@ def create_full_iteration_space(
     # Otherwise, if an iteration slice was specified, use that
     # Otherwise, use the inferred ghost layers
 
-    from ...codegen.config import AUTO, _AUTO_TYPE
-
-    if ghost_layers is AUTO:
+    if infer_ghost_layers:
         if len(domain_field_accesses) > 0:
             inferred_gls = max(
                 [fa.required_ghost_layers for fa in domain_field_accesses]
@@ -472,7 +511,6 @@ def create_full_iteration_space(
             ctx, inferred_gls, archetype_field
         )
     elif ghost_layers is not None:
-        assert not isinstance(ghost_layers, _AUTO_TYPE)
         ctx.metadata["ghost_layers"] = ghost_layers
         return FullIterationSpace.create_with_ghost_layers(
             ctx, ghost_layers, archetype_field
diff --git a/src/pystencils/backend/platforms/cuda.py b/src/pystencils/backend/platforms/cuda.py
index f146cfbfd3d3d4f106bc82571bd613798644f241..2559ac6d2456e094fe325956264b34ee859edf04 100644
--- a/src/pystencils/backend/platforms/cuda.py
+++ b/src/pystencils/backend/platforms/cuda.py
@@ -30,7 +30,7 @@ from ..literals import PsLiteral
 from ..functions import PsMathFunction, MathFunctions, CFunction
 
 if TYPE_CHECKING:
-    from ...codegen import GpuIndexingConfig, GpuThreadsRange
+    from ...codegen import GpuThreadsRange
 
 int32 = PsSignedIntegerType(width=32, const=False)
 
@@ -52,13 +52,15 @@ class CudaPlatform(GenericGpu):
     """Platform for CUDA-based GPUs."""
 
     def __init__(
-        self, ctx: KernelCreationContext, indexing_cfg: GpuIndexingConfig | None = None
+        self, ctx: KernelCreationContext,
+        omit_range_check: bool = False,
+        manual_launch_grid: bool = False,
     ) -> None:
         super().__init__(ctx)
 
-        from ...codegen.config import GpuIndexingConfig
+        self._omit_range_check = omit_range_check
+        self._manual_launch_grid = manual_launch_grid
 
-        self._cfg = indexing_cfg if indexing_cfg is not None else GpuIndexingConfig()
         self._typify = Typifier(ctx)
 
     @property
@@ -141,7 +143,7 @@ class CudaPlatform(GenericGpu):
     ) -> tuple[PsBlock, GpuThreadsRange | None]:
         dimensions = ispace.dimensions_in_loop_order()
 
-        if not self._cfg.manual_launch_grid:
+        if not self._manual_launch_grid:
             try:
                 threads_range = self.threads_from_ispace(ispace)
             except MaterializationError as e:
@@ -170,7 +172,7 @@ class CudaPlatform(GenericGpu):
                     )
                 )
             )
-            if not self._cfg.omit_range_check:
+            if not self._omit_range_check:
                 conds.append(PsLt(ctr, dim.stop))
 
         indexing_decls = indexing_decls[::-1]
@@ -213,7 +215,7 @@ class CudaPlatform(GenericGpu):
         ]
         body.statements = mappings + body.statements
 
-        if not self._cfg.omit_range_check:
+        if not self._omit_range_check:
             stop = PsExpression.make(ispace.index_list.shape[0])
             condition = PsLt(sparse_ctr, stop)
             ast = PsBlock([sparse_idx_decl, PsConditional(condition, body)])
diff --git a/src/pystencils/backend/platforms/sycl.py b/src/pystencils/backend/platforms/sycl.py
index 9c04d6074b4feb0e63deddeb5a94cf11d920a0c0..594c87b145fbe39640321634f5e5e33dd93d7378 100644
--- a/src/pystencils/backend/platforms/sycl.py
+++ b/src/pystencils/backend/platforms/sycl.py
@@ -19,7 +19,7 @@ from ..ast.expressions import (
     PsLe,
     PsTernary,
     PsLookup,
-    PsBufferAcc
+    PsBufferAcc,
 )
 from ..extensions.cpp import CppMethodCall
 
@@ -30,19 +30,21 @@ from ..exceptions import MaterializationError
 from ...types import PsCustomType, PsIeeeFloatType, constify, PsIntegerType
 
 if TYPE_CHECKING:
-    from ...codegen import GpuIndexingConfig, GpuThreadsRange
+    from ...codegen import GpuThreadsRange
 
 
 class SyclPlatform(GenericGpu):
 
     def __init__(
-        self, ctx: KernelCreationContext, indexing_cfg: GpuIndexingConfig | None = None
+        self,
+        ctx: KernelCreationContext,
+        omit_range_check: bool = False,
+        automatic_block_size: bool = False
     ):
         super().__init__(ctx)
 
-        from ...codegen.config import GpuIndexingConfig
-
-        self._cfg = indexing_cfg if indexing_cfg is not None else GpuIndexingConfig()
+        self._omit_range_check = omit_range_check
+        self._automatic_block_size = automatic_block_size
 
     @property
     def required_headers(self) -> set[str]:
@@ -138,7 +140,7 @@ class SyclPlatform(GenericGpu):
             indexing_decls.append(
                 PsDeclaration(ctr, dim.start + work_item_idx * dim.step)
             )
-            if not self._cfg.omit_range_check:
+            if not self._omit_range_check:
                 conds.append(PsLt(ctr, dim.stop))
 
         if conds:
@@ -156,7 +158,7 @@ class SyclPlatform(GenericGpu):
         self, body: PsBlock, ispace: SparseIterationSpace
     ) -> tuple[PsBlock, GpuThreadsRange]:
         factory = AstFactory(self._ctx)
-        
+
         id_type = PsCustomType("sycl::id< 1 >", const=True)
         id_symbol = PsExpression.make(self._ctx.get_symbol("id", id_type))
 
@@ -184,7 +186,7 @@ class SyclPlatform(GenericGpu):
         ]
         body.statements = mappings + body.statements
 
-        if not self._cfg.omit_range_check:
+        if not self._omit_range_check:
             stop = PsExpression.make(ispace.index_list.shape[0])
             condition = PsLt(sparse_ctr, stop)
             ast = PsBlock([sparse_idx_decl, PsConditional(condition, body)])
@@ -195,7 +197,7 @@ class SyclPlatform(GenericGpu):
         return ast, self.threads_from_ispace(ispace)
 
     def _item_type(self, rank: int):
-        if not self._cfg.sycl_automatic_block_size:
+        if not self._automatic_block_size:
             return PsCustomType(f"sycl::nd_item< {rank} >", const=True)
         else:
             return PsCustomType(f"sycl::item< {rank} >", const=True)
@@ -207,7 +209,7 @@ class SyclPlatform(GenericGpu):
         item_type = self._item_type(rank)
         item = PsExpression.make(self._ctx.get_symbol("sycl_item", item_type))
 
-        if not self._cfg.sycl_automatic_block_size:
+        if not self._automatic_block_size:
             rhs = CppMethodCall(item, "get_global_id", self._id_type(rank))
         else:
             rhs = CppMethodCall(item, "get_id", self._id_type(rank))
diff --git a/src/pystencils/backend/transformations/add_pragmas.py b/src/pystencils/backend/transformations/add_pragmas.py
index 78e721f3850e0075a8079131b84ae558abb50062..0e6d314acf16a5c16b6cb988f61dfaf4ba8e36f8 100644
--- a/src/pystencils/backend/transformations/add_pragmas.py
+++ b/src/pystencils/backend/transformations/add_pragmas.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
 
 from typing import Sequence
 from collections import defaultdict
@@ -10,8 +9,6 @@ from ..ast import PsAstNode
 from ..ast.structural import PsBlock, PsLoop, PsPragma
 from ..ast.expressions import PsExpression
 
-if TYPE_CHECKING:
-    from ...codegen.config import OpenMpConfig
 
 __all__ = ["InsertPragmasAtLoops", "LoopPragma", "AddOpenMP"]
 
@@ -101,23 +98,40 @@ class InsertPragmasAtLoops:
 class AddOpenMP:
     """Apply OpenMP directives to loop nests.
 
-    This transformation augments the AST with OpenMP pragmas according to the given
-    `OpenMpConfig` configuration.
+    This transformation augments the AST with OpenMP pragmas according to the given configuration.
     """
 
-    def __init__(self, ctx: KernelCreationContext, omp_params: OpenMpConfig) -> None:
+    def __init__(
+        self,
+        ctx: KernelCreationContext,
+        nesting_depth: int = 0,
+        num_threads: int | None = None,
+        schedule: str | None = None,
+        collapse: int | None = None,
+        omit_parallel: bool = False,
+    ) -> None:
         pragma_text = "omp"
-        pragma_text += " parallel" if not omp_params.omit_parallel_construct else ""
-        pragma_text += f" for schedule({omp_params.schedule})"
 
-        if omp_params.num_threads is not None:
-            pragma_text += f" num_threads({str(omp_params.num_threads)})"
+        if not omit_parallel:
+            pragma_text += " parallel"
+
+        pragma_text += " for"
+
+        if schedule is not None:
+            pragma_text += f" schedule({schedule})"
+
+        if num_threads is not None:
+            pragma_text += f" num_threads({str(num_threads)})"
 
-        if omp_params.collapse > 0:
-            pragma_text += f" collapse({str(omp_params.collapse)})"
+        if collapse is not None:
+            if collapse <= 0:
+                raise ValueError(
+                    f"Invalid value for OpenMP `collapse` clause: {collapse}"
+                )
+            pragma_text += f" collapse({str(collapse)})"
 
         self._insert_pragmas = InsertPragmasAtLoops(
-            ctx, [LoopPragma(pragma_text, omp_params.nesting_depth)]
+            ctx, [LoopPragma(pragma_text, nesting_depth)]
         )
 
     def __call__(self, node: PsAstNode) -> PsAstNode:
diff --git a/src/pystencils/codegen/__init__.py b/src/pystencils/codegen/__init__.py
index e27b94b9ebec9197eb044cd05b5d55fd5ae17f1f..e13f911dd9c2f8dd1a7b264a79dcdcd51cbef003 100644
--- a/src/pystencils/codegen/__init__.py
+++ b/src/pystencils/codegen/__init__.py
@@ -1,10 +1,6 @@
 from .target import Target
 from .config import (
     CreateKernelConfig,
-    CpuOptimConfig,
-    VectorizationConfig,
-    OpenMpConfig,
-    GpuIndexingConfig,
     AUTO,
 )
 from .parameters import Parameter
@@ -14,10 +10,6 @@ from .driver import create_kernel, get_driver
 __all__ = [
     "Target",
     "CreateKernelConfig",
-    "CpuOptimConfig",
-    "VectorizationConfig",
-    "OpenMpConfig",
-    "GpuIndexingConfig",
     "AUTO",
     "Parameter",
     "Kernel",
diff --git a/src/pystencils/codegen/config.py b/src/pystencils/codegen/config.py
index 3a7647907b82a4ee1ddbb72c2c700e42c7547f69..cbb3f4f32ef82662c51facb4c2ddae0d6dba349a 100644
--- a/src/pystencils/codegen/config.py
+++ b/src/pystencils/codegen/config.py
@@ -2,10 +2,11 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from warnings import warn
+from abc import ABC
 from collections.abc import Collection
 
-from typing import Sequence
-from dataclasses import dataclass, InitVar, replace
+from typing import Sequence, Generic, TypeVar, Callable, Any, cast
+from dataclasses import dataclass, InitVar, fields
 
 from .target import Target
 from ..field import Field, FieldType
@@ -13,7 +14,6 @@ from ..field import Field, FieldType
 from ..types import (
     PsIntegerType,
     UserTypeSpec,
-    PsIeeeFloatType,
     PsScalarType,
     create_type,
 )
@@ -24,108 +24,227 @@ if TYPE_CHECKING:
     from ..jit import JitBase
 
 
-class PsOptionsError(Exception):
-    """Indicates an option clash in the `CreateKernelConfig`."""
+Option_T = TypeVar("Option_T")
+"""Type variable for option values"""
 
 
-class _AUTO_TYPE: ...  # noqa: E701
+Arg_T = TypeVar("Arg_T")
+"""Type variable for option arguments"""
 
 
-AUTO = _AUTO_TYPE()
-"""Special value that can be passed to some options for invoking automatic behaviour.
+class Option(Generic[Option_T, Arg_T]):
+    """Option descriptor.
 
-Currently, these options permit `AUTO`:
+    This descriptor is used to model configuration options.
+    It maintains a default value for the option that is used when no value
+    was specified by the user.
 
-- `ghost_layers <CreateKernelConfig.ghost_layers>`
-"""
+    In configuration options, the value `None` stands for ``unset``.
+    It can therefore not be used to set an option to the meaning "not any", or "empty"
+    - for these, special values need to be used.
 
+    The Option allows a validator function to be specified,
+    which will be called to perform sanity checks on user-provided values.
 
-@dataclass
-class OpenMpConfig:
-    """Parameters controlling kernel parallelization using OpenMP."""
+    Through the validator, options may also be set from arguments of a different type (``Arg_T``)
+    than their value type (``Option_T``). If ``Arg_T`` is different from ``Option_T``,
+    the validator must perform the conversion from the former to the latter.
 
-    nesting_depth: int = 0
-    """Nesting depth of the loop that should be parallelized. Must be a nonnegative number."""
+    .. note::
+        ``Arg_T`` must always be a supertype of ``Option_T``.
+    """
 
-    collapse: int = 0
-    """Argument to the OpenMP ``collapse`` clause"""
+    def __init__(
+        self,
+        default: Option_T | None = None,
+        validator: Callable[[Any, Arg_T | None], Option_T | None] | None = None,
+    ) -> None:
+        self._default = default
+        self._validator = validator
+        self._name: str
+        self._lookup: str
+
+    def validate(self, validator: Callable[[Any, Any], Any] | None):
+        self._validator = validator
+        return validator
+
+    @property
+    def default(self) -> Option_T | None:
+        return self._default
+
+    def get(self, obj) -> Option_T | None:
+        val = getattr(obj, self._lookup, None)
+        if val is None:
+            return self._default
+        else:
+            return val
 
-    schedule: str = "static"
-    """Argument to the OpenMP ``schedule`` clause"""
+    def is_set(self, obj) -> bool:
+        return getattr(obj, self._lookup, None) is not None
 
-    num_threads: int | None = None
-    """Set the number of OpenMP threads to execute the parallel region."""
+    def __set_name__(self, owner: ConfigBase, name: str):
+        self._name = name
+        self._lookup = f"_{name}"
 
-    omit_parallel_construct: bool = False
-    """If set to ``True``, the OpenMP ``parallel`` construct is omitted, producing just a ``#pragma omp for``.
-    
-    Use this option only if you intend to wrap the kernel into an external ``#pragma omp parallel`` region.
-    """
+    def __get__(self, obj: ConfigBase, objtype: type[ConfigBase] | None = None) -> Option_T | None:
+        if obj is None:
+            return None
 
-    def __post_init__(self):
-        if self.omit_parallel_construct and self.num_threads is not None:
-            raise PsOptionsError(
-                "Cannot specify `num_threads` if `omit_parallel_construct` is set."
-            )
+        return getattr(obj, self._lookup, None)
 
+    def __set__(self, obj: ConfigBase, arg: Arg_T | None):
+        if arg is not None and self._validator is not None:
+            value = self._validator(obj, arg)
+        else:
+            value = cast(Option_T, arg)
+        setattr(obj, self._lookup, value)
 
-@dataclass
-class CpuOptimConfig:
-    """Configuration for the CPU optimizer.
+    def __delete__(self, obj):
+        delattr(obj, self._lookup)
 
-    If any flag in this configuration is set to a value not supported by the CPU specified
-    in `CreateKernelConfig.target`, an error will be raised.
-    """
 
-    openmp: bool | OpenMpConfig = False
-    """Enable OpenMP parallelization.
-    
-    If set to `True`, the kernel will be parallelized using OpenMP according to the default settings in `OpenMpConfig`.
-    To customize OpenMP parallelization, pass an instance of `OpenMpConfig` instead.
-    """
+class BasicOption(Option[Option_T, Option_T]):
+    "Subclass of Option where ``Arg_T == Option_T``."
 
-    vectorize: bool | VectorizationConfig = False
-    """Enable and configure auto-vectorization.
-    
-    If set to an instance of `VectorizationConfig` and a CPU target with vector capabilities is selected,
-    pystencils will attempt to vectorize the kernel according to the given vectorization options.
 
-    If set to `True`, pystencils will infer vectorization options from the given CPU target.
+class ConfigBase(ABC):
+    """Base class for configuration categories.
 
-    If set to `False`, no vectorization takes place.
-    """
+    This class implements query and retrieval mechanism for configuration options,
+    as well as deepcopy functionality for categories.
 
-    loop_blocking: None | tuple[int, ...] = None
-    """Block sizes for loop blocking.
-    
-    If set, the kernel's loops will be tiled according to the given block sizes.
+    Subclasses of `ConfigBase` must be `dataclasses`,
+    and all of their instance fields must have one of two descriptors types:
+    - Either `Option`, for scalar options;
+    - Or `Category` for option subcategories.
+
+    `Option` fields must be assigned immutable values, but are otherwise unconstrained.
+    `Category` subobjects must be subclasses of `ConfigBase`.
+
+    **Retrieval** Options set to `None` are considered *unset*, i.e. the user has not provided a value.
+    Through the `Option` descriptor, these options can still have a default value.
+    To retrieve either the user-set value if one exists, or the default value otherwise, use `get_option`.
+
+    **Deep-Copy** When a configuration object is copied, all of its subcategories must be copied along with it,
+    such that changes in the original do no affect the copy, and vice versa.
+    Such a deep copy is performed by the `copy <ConfigBase.copy>` method.
     """
 
-    use_cacheline_zeroing: bool = False
-    """Enable cache-line zeroing.
-    
-    If set to `True` and the selected CPU supports cacheline zeroing, the CPU optimizer will attempt
-    to produce cacheline zeroing instructions where possible.
+    def get_option(self, name: str) -> Any:
+        """Get the value set for the specified option, or the option's default value if none has been set."""
+        descr: Option = type(self).__dict__[name]
+        return descr.get(self)
+
+    def is_option_set(self, name: str) -> bool:
+        descr: Option = type(self).__dict__[name]
+        return descr.is_set(self)
+
+    def override(self, other: ConfigBase):
+        for f in fields(self):  # type: ignore
+            fvalue = getattr(self, f.name)
+            if isinstance(fvalue, ConfigBase):  # type: ignore
+                fvalue.override(getattr(other, f.name))
+            else:
+                new_val = getattr(other, f.name)
+                if new_val is not None:
+                    setattr(self, f.name, new_val)
+
+    def copy(self):
+        """Perform a semi-deep copy of this configuration object.
+
+        This will recursively copy any config subobjects
+        (categories, i.e. subclasses of `ConfigBase` wrapped in the `Category` descriptor)
+        nested in this configuration object. Any other fields will be copied by reference.
+        """
+
+        #   IMPLEMENTATION NOTES
+        #
+        #   We do not need to call `copy` on any subcategories here, since the `Category`
+        #   descriptor already calls `copy` in its `__set__` method,
+        #   which is invoked during the constructor call in the `return` statement.
+        #   Calling `copy` here would result in copying category objects twice.
+        #
+        #   We cannot use the standard library `copy.copy` here, since it merely duplicates
+        #   the instance dictionary and does not call the constructor.
+
+        config_fields = fields(self)  # type: ignore
+        kwargs = dict()
+        for field in config_fields:
+            val = getattr(self, field.name)
+            kwargs[field.name] = val
+        return type(self)(**kwargs)
+
+
+Category_T = TypeVar("Category_T", bound=ConfigBase)
+"""Type variable for option categories."""
+
+
+class Category(Generic[Category_T]):
+    """Descriptor for a category of options.
+
+    This descriptor makes sure that when an entire category is set to an object,
+    that object is copied immediately such that later changes to the original
+    do not affect this configuration.
     """
 
-    def get_vectorization_config(self) -> VectorizationConfig | None:
-        if self.vectorize is True:
-            return VectorizationConfig()
-        elif isinstance(self.vectorize, VectorizationConfig):
-            return self.vectorize
-        else:
-            return None
+    def __init__(self, default: Category_T):
+        self._default = default
+
+    def __set_name__(self, owner: ConfigBase, name: str):
+        self._name = name
+        self._lookup = f"_{name}"
+
+    def __get__(self, obj: ConfigBase, objtype: type[ConfigBase] | None = None) -> Category_T:
+        if obj is None:
+            return self._default
+
+        return cast(Category_T, getattr(obj, self._lookup, None))
+
+    def __set__(self, obj: ConfigBase, cat: Category_T):
+        setattr(obj, self._lookup, cat.copy())
+
+
+class _AUTO_TYPE: ...  # noqa: E701
+
+
+AUTO = _AUTO_TYPE()
+"""Special value that can be passed to some options for invoking automatic behaviour."""
 
 
 @dataclass
-class VectorizationConfig:
-    """Configuration for the auto-vectorizer.
+class OpenMpOptions(ConfigBase):
+    """Configuration options controlling automatic OpenMP instrumentation."""
+
+    enable: BasicOption[bool] = BasicOption(False)
+    """Enable OpenMP instrumentation"""
+
+    nesting_depth: BasicOption[int] = BasicOption(0)
+    """Nesting depth of the loop that should be parallelized. Must be a nonnegative number."""
+
+    collapse: BasicOption[int] = BasicOption()
+    """Argument to the OpenMP ``collapse`` clause"""
 
-    If any flag in this configuration is set to a value not supported by the CPU specified
-    in `CreateKernelConfig.target`, an error will be raised.
+    schedule: BasicOption[str] = BasicOption("static")
+    """Argument to the OpenMP ``schedule`` clause"""
+
+    num_threads: BasicOption[int] = BasicOption()
+    """Set the number of OpenMP threads to execute the parallel region."""
+
+    omit_parallel_construct: BasicOption[bool] = BasicOption(False)
+    """If set to ``True``, the OpenMP ``parallel`` construct is omitted, producing just a ``#pragma omp for``.
+    
+    Use this option only if you intend to wrap the kernel into an external ``#pragma omp parallel`` region.
     """
 
-    lanes: int | None = None
+
+@dataclass
+class VectorizationOptions(ConfigBase):
+    """Configuration for the auto-vectorizer."""
+
+    enable: BasicOption[bool] = BasicOption(False)
+    """Enable intrinsic vectorization."""
+
+    lanes: BasicOption[int] = BasicOption()
     """Number of SIMD lanes to be used in vectorization.
 
     If set to `None` (the default), the vector register width will be automatically set to the broadest possible.
@@ -134,7 +253,9 @@ class VectorizationConfig:
     operation contained in the kernel with the given number of lanes, an error will be raised.
     """
 
-    use_nontemporal_stores: bool | Collection[str | Field] = False
+    use_nontemporal_stores: BasicOption[bool | Collection[str | Field]] = BasicOption(
+        False
+    )
     """Enable nontemporal (streaming) stores.
     
     If set to `True` and the selected CPU supports streaming stores, the vectorizer will generate
@@ -144,14 +265,14 @@ class VectorizationConfig:
     the given fields.
     """
 
-    assume_aligned: bool = False
+    assume_aligned: BasicOption[bool] = BasicOption(False)
     """Assume field pointer alignment.
     
     If set to `True`, the vectorizer will assume that the address of the first inner entry
     (after ghost layers) of each field is aligned at the necessary byte boundary.
     """
 
-    assume_inner_stride_one: bool = False
+    assume_inner_stride_one: BasicOption[bool] = BasicOption(False)
     """Assume stride associated with the innermost spatial coordinate of all fields is one.
     
     If set to `True`, the vectorizer will replace the stride of the innermost spatial coordinate
@@ -180,10 +301,36 @@ class VectorizationConfig:
 
 
 @dataclass
-class GpuIndexingConfig:
-    """Configure index translation behaviour for kernels generated for GPU targets."""
+class CpuOptions(ConfigBase):
+    """Configuration options specific to CPU targets."""
+
+    openmp: Category[OpenMpOptions] = Category(OpenMpOptions())
+    """Options governing OpenMP-instrumentation.
+    """
+
+    vectorize: Category[VectorizationOptions] = Category(VectorizationOptions())
+    """Options governing intrinsic vectorization.
+    """
 
-    omit_range_check: bool = False
+    loop_blocking: BasicOption[tuple[int, ...]] = BasicOption()
+    """Block sizes for loop blocking.
+    
+    If set, the kernel's loops will be tiled according to the given block sizes.
+    """
+
+    use_cacheline_zeroing: BasicOption[bool] = BasicOption(False)
+    """Enable cache-line zeroing.
+    
+    If set to `True` and the selected CPU supports cacheline zeroing, the CPU optimizer will attempt
+    to produce cacheline zeroing instructions where possible.
+    """
+
+
+@dataclass
+class GpuOptions(ConfigBase):
+    """Configuration options specific to GPU targets."""
+
+    omit_range_check: BasicOption[bool] = BasicOption(False)
     """If set to `True`, omit the iteration counter range check.
     
     By default, the code generator introduces a check if the iteration counters computed from GPU block and thread
@@ -191,10 +338,10 @@ class GpuIndexingConfig:
     This check can be discarded through this option, at your own peril.
     """
 
-    block_size: tuple[int, int, int] | None = None
+    block_size: BasicOption[tuple[int, int, int]] = BasicOption()
     """Desired block size for the execution of GPU kernels. May be overridden later by the runtime system."""
 
-    manual_launch_grid: bool = False
+    manual_launch_grid: BasicOption[bool] = BasicOption(False)
     """Always require a manually specified launch grid when running this kernel.
     
     If set to `True`, the code generator will not attempt to infer the size of
@@ -202,8 +349,13 @@ class GpuIndexingConfig:
     The launch grid will then have to be specified manually at runtime.
     """
 
-    sycl_automatic_block_size: bool = True
-    """If set to `True` while generating for `Target.SYCL`, let the SYCL runtime decide on the block size.
+
+@dataclass
+class SyclOptions(ConfigBase):
+    """Options specific to the `SYCL <Target.SYCL>` target."""
+
+    automatic_block_size: BasicOption[bool] = BasicOption(True)
+    """If set to `True`, let the SYCL runtime decide on the block size.
 
     If set to `True`, the kernel is generated for execution via
     `parallel_for <https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html#_parallel_for_invoke>`_
@@ -216,24 +368,30 @@ class GpuIndexingConfig:
     """
 
 
+GhostLayerSpec = _AUTO_TYPE | int | Sequence[int | tuple[int, int]]
+
+
+IterationSliceSpec = int | slice | tuple[int | slice]
+
+
 @dataclass
-class CreateKernelConfig:
+class CreateKernelConfig(ConfigBase):
     """Options for create_kernel."""
 
-    target: Target = Target.GenericCPU
+    target: BasicOption[Target] = BasicOption(Target.GenericCPU)
     """The code generation target."""
 
-    jit: JitBase | None = None
+    jit: BasicOption[JitBase] = BasicOption()
     """Just-in-time compiler used to compile and load the kernel for invocation from the current Python environment.
     
     If left at `None`, a default just-in-time compiler will be inferred from the `target` parameter.
     To explicitly disable JIT compilation, pass `pystencils.no_jit <pystencils.jit.no_jit>`.
     """
 
-    function_name: str = "kernel"
+    function_name: BasicOption[str] = BasicOption("kernel")
     """Name of the generated function"""
 
-    ghost_layers: None | _AUTO_TYPE | int | Sequence[int | tuple[int, int]] = None
+    ghost_layers: BasicOption[GhostLayerSpec] = BasicOption()
     """Specifies the number of ghost layers of the iteration region.
     
     Options:
@@ -249,7 +407,7 @@ class CreateKernelConfig:
         At most one of `ghost_layers`, `iteration_slice`, and `index_field` may be set.
     """
 
-    iteration_slice: None | int | slice | tuple[int | slice] = None
+    iteration_slice: BasicOption[IterationSliceSpec] = BasicOption()
     """Specifies the kernel's iteration slice.
 
     Example:
@@ -263,7 +421,7 @@ class CreateKernelConfig:
         At most one of `ghost_layers`, `iteration_slice`, and `index_field` may be set.
     """
 
-    index_field: Field | None = None
+    index_field: BasicOption[Field] = BasicOption()
     """Index field for a sparse kernel.
     
     If this option is set, a sparse kernel with the given field as index field will be generated.
@@ -274,10 +432,10 @@ class CreateKernelConfig:
 
     """Data Types"""
 
-    index_dtype: UserTypeSpec = DEFAULTS.index_dtype
+    index_dtype: Option[PsIntegerType, UserTypeSpec] = Option(DEFAULTS.index_dtype)
     """Data type used for all index calculations."""
 
-    default_dtype: UserTypeSpec = PsIeeeFloatType(64)
+    default_dtype: Option[PsScalarType, UserTypeSpec] = Option(DEFAULTS.numeric_dtype)
     """Default numeric data type.
     
     This data type will be applied to all untyped symbols.
@@ -285,14 +443,14 @@ class CreateKernelConfig:
 
     """Analysis"""
 
-    allow_double_writes: bool = False
+    allow_double_writes: BasicOption[bool] = BasicOption(False)
     """
     If True, don't check if every field is only written at a single location. This is required
     for example for kernels that are compiled with loop step sizes > 1, that handle multiple
     cells at once. Use with care!
     """
 
-    skip_independence_check: bool = False
+    skip_independence_check: BasicOption[bool] = BasicOption(False)
     """
     By default the assignment list is checked for read/write independence. This means fields are only written at
     locations where they are read. Doing so guarantees thread safety. In some cases e.g. for
@@ -301,17 +459,36 @@ class CreateKernelConfig:
 
     """Target-Specific Options"""
 
-    cpu_optim: None | CpuOptimConfig = None
-    """Configuration of the CPU kernel optimizer.
-    
-    If this parameter is set while `target` is a non-CPU target, an error will be raised.
-    """
-
-    gpu_indexing: None | GpuIndexingConfig = None
-    """Configure index translation for GPU kernels.
-    
-    It this parameter is set while `target` is not a GPU target, an error will be raised.
-    """
+    cpu: Category[CpuOptions] = Category(CpuOptions())
+    """Options for CPU kernels. See `CpuOptions`."""
+
+    gpu: Category[GpuOptions] = Category(GpuOptions())
+    """Options for GPU Kernels. See `GpuOptions`."""
+
+    sycl: Category[SyclOptions] = Category(SyclOptions())
+    """Options for SYCL kernels. See `SyclOptions`."""
+
+    @index_dtype.validate
+    def validate_index_type(self, spec: UserTypeSpec):
+        dtype = create_type(spec)
+        if not isinstance(dtype, PsIntegerType):
+            raise ValueError("index_dtype must be an integer type")
+        return dtype
+
+    @default_dtype.validate
+    def validate_default_dtype(self, spec: UserTypeSpec):
+        dtype = create_type(spec)
+        if not isinstance(dtype, PsScalarType):
+            raise ValueError("default_dtype must be a scalar numeric type")
+        return dtype
+
+    @index_field.validate
+    def validate_index_field(self, idx_field: Field):
+        if idx_field.field_type != FieldType.INDEXED:
+            raise ValueError(
+                "Only fields of type FieldType.INDEXED can be used as index fields"
+            )
+        return idx_field
 
     #   Deprecated Options
 
@@ -319,39 +496,39 @@ class CreateKernelConfig:
     """Deprecated; use `default_dtype` instead"""
 
     cpu_openmp: InitVar[bool | int | None] = None
-    """Deprecated; use `cpu_optim.openmp <CpuOptimConfig.openmp>` instead."""
+    """Deprecated; use `cpu.openmp <CpuOptions.openmp>` instead."""
 
     cpu_vectorize_info: InitVar[dict | None] = None
-    """Deprecated; use `cpu_optim.vectorize <CpuOptimConfig.vectorize>` instead."""
+    """Deprecated; use `cpu.vectorize <CpuOptions.vectorize>` instead."""
 
     gpu_indexing_params: InitVar[dict | None] = None
-    """Deprecated; use `gpu_indexing` instead."""
+    """Deprecated; set options in the `gpu` category instead."""
 
     #   Getters
 
     def get_target(self) -> Target:
-        match self.target:
+        t: Target = self.get_option("target")
+        match t:
             case Target.CurrentCPU:
                 return Target.auto_cpu()
             case _:
-                return self.target
+                return t
 
     def get_jit(self) -> JitBase:
         """Returns either the user-specified JIT compiler, or infers one from the target if none is given."""
-        if self.jit is None:
-            if self.target.is_cpu():
+        jit: JitBase | None = self.get_option("jit")
+
+        if jit is None:
+            if self.get_target().is_cpu():
                 from ..jit import LegacyCpuJit
 
                 return LegacyCpuJit()
-            elif self.target == Target.CUDA:
+            elif self.get_target() == Target.CUDA:
                 try:
                     from ..jit.gpu_cupy import CupyJit
 
-                    if (
-                        self.gpu_indexing is not None
-                        and self.gpu_indexing.block_size is not None
-                    ):
-                        return CupyJit(self.gpu_indexing.block_size)
+                    if self.gpu is not None and self.gpu.block_size is not None:
+                        return CupyJit(self.gpu.block_size)
                     else:
                         return CupyJit()
 
@@ -360,7 +537,7 @@ class CreateKernelConfig:
 
                     return no_jit
 
-            elif self.target == Target.SYCL:
+            elif self.get_target() == Target.SYCL:
                 from ..jit import no_jit
 
                 return no_jit
@@ -369,64 +546,14 @@ class CreateKernelConfig:
                     f"No default JIT compiler implemented yet for target {self.target}"
                 )
         else:
-            return self.jit
+            return jit
 
     #   Postprocessing
 
     def __post_init__(self, *args):
-
         #   Check deprecated options
         self._check_deprecations(*args)
 
-        #   Check index data type
-        if not isinstance(create_type(self.index_dtype), PsIntegerType):
-            raise PsOptionsError("`index_dtype` was not an integer type.")
-
-        #   Check iteration space argument consistency
-        if (
-            int(self.iteration_slice is not None)
-            + int(self.ghost_layers is not None)
-            + int(self.index_field is not None)
-            > 1
-        ):
-            raise PsOptionsError(
-                "Parameters `iteration_slice`, `ghost_layers` and 'index_field` are mutually exclusive; "
-                "at most one of them may be set."
-            )
-
-        #   Check index field
-        if (
-            self.index_field is not None
-            and self.index_field.field_type != FieldType.INDEXED
-        ):
-            raise PsOptionsError(
-                "Only fields with `field_type == FieldType.INDEXED` can be specified as `index_field`"
-            )
-
-        #   Check optim
-        if self.cpu_optim is not None:
-            if (
-                self.cpu_optim.vectorize is not False
-                and not self.target.is_vector_cpu()
-            ):
-                raise PsOptionsError(
-                    f"Cannot enable auto-vectorization for non-vector CPU target {self.target}"
-                )
-
-        if self.gpu_indexing is not None:
-            if isinstance(self.gpu_indexing, str):
-                match self.gpu_indexing:
-                    case "block":
-                        self.gpu_indexing = GpuIndexingConfig()
-                    case "line":
-                        raise NotImplementedError(
-                            "GPU line indexing is currently unavailable."
-                        )
-                    case other:
-                        raise PsOptionsError(
-                            f"Invalid value for option gpu_indexing: {other}"
-                        )
-
     def _check_deprecations(
         self,
         data_type: UserTypeSpec | None,
@@ -434,8 +561,6 @@ class CreateKernelConfig:
         cpu_vectorize_info: dict | None,
         gpu_indexing_params: dict | None,
     ):  # pragma: no cover
-        optim: CpuOptimConfig | None = None
-
         if data_type is not None:
             _deprecated_option("data_type", "default_dtype")
             warn(
@@ -447,27 +572,33 @@ class CreateKernelConfig:
 
         if cpu_openmp is not None:
             _deprecated_option("cpu_openmp", "cpu_optim.openmp")
+            warn(
+                "Setting the deprecated `cpu_openmp` option will override any options "
+                "passed in the `cpu.openmp` category.",
+                UserWarning,
+            )
 
-            deprecated_omp: OpenMpConfig | bool
+            deprecated_omp = OpenMpOptions()
             match cpu_openmp:
                 case True:
-                    deprecated_omp = OpenMpConfig()
+                    deprecated_omp.enable = False
                 case False:
-                    deprecated_omp = False
+                    deprecated_omp.enable = False
                 case int():
-                    deprecated_omp = OpenMpConfig(num_threads=cpu_openmp)
+                    deprecated_omp.enable = True
+                    deprecated_omp.num_threads = cpu_openmp
                 case _:
-                    raise PsOptionsError(
+                    raise ValueError(
                         f"Invalid option for `cpu_openmp`: {cpu_openmp}"
                     )
 
-            optim = CpuOptimConfig(openmp=deprecated_omp)
+            self.cpu.openmp = deprecated_omp
 
         if cpu_vectorize_info is not None:
             _deprecated_option("cpu_vectorize_info", "cpu_optim.vectorize")
             if "instruction_set" in cpu_vectorize_info:
                 if self.target != Target.GenericCPU:
-                    raise PsOptionsError(
+                    raise ValueError(
                         "Setting 'instruction_set' in the deprecated 'cpu_vectorize_info' option is only "
                         "valid if `target == Target.CPU`."
                     )
@@ -486,7 +617,7 @@ class CreateKernelConfig:
                     case "avx512vl":
                         vec_target = Target.X86_AVX512 | Target._VL
                     case _:
-                        raise PsOptionsError(
+                        raise ValueError(
                             f'Value {isa} in `cpu_vectorize_info["instruction_set"]` is not supported.'
                         )
 
@@ -499,7 +630,14 @@ class CreateKernelConfig:
 
                 self.target = vec_target
 
-            deprecated_vec_opts = VectorizationConfig(
+            warn(
+                "Setting the deprecated `cpu_vectorize_info` will override any options "
+                "passed in the `cpu.vectorize` category.",
+                UserWarning,
+            )
+
+            deprecated_vec_opts = VectorizationOptions(
+                enable=True,
                 assume_inner_stride_one=cpu_vectorize_info.get(
                     "assume_inner_stride_one", False
                 ),
@@ -507,28 +645,16 @@ class CreateKernelConfig:
                 use_nontemporal_stores=cpu_vectorize_info.get("nontemporal", False),
             )
 
-            if optim is not None:
-                optim = replace(optim, vectorize=deprecated_vec_opts)
-            else:
-                optim = CpuOptimConfig(vectorize=deprecated_vec_opts)
-
-        if optim is not None:
-            if self.cpu_optim is not None:
-                raise PsOptionsError(
-                    "Cannot specify both `cpu_optim` and a deprecated legacy optimization option at the same time."
-                )
-            else:
-                self.cpu_optim = optim
+            self.cpu.vectorize = deprecated_vec_opts
 
         if gpu_indexing_params is not None:
             _deprecated_option("gpu_indexing_params", "gpu_indexing")
+            warn(
+                "Setting the deprecated `gpu_indexing_params` will override any options "
+                "passed in the `gpu` category."
+            )
 
-            if self.gpu_indexing is not None:
-                raise PsOptionsError(
-                    "Cannot specify both `gpu_indexing` and the deprecated `gpu_indexing_params` at the same time."
-                )
-
-            self.gpu_indexing = GpuIndexingConfig(
+            self.gpu = GpuOptions(
                 block_size=gpu_indexing_params.get("block_size", None)
             )
 
diff --git a/src/pystencils/codegen/driver.py b/src/pystencils/codegen/driver.py
index 28b685b55e4a41c0a80f512025ca23ecdf8c92b9..6f44e718d9aaebd393dacb9a99ae88702f07ccaa 100644
--- a/src/pystencils/codegen/driver.py
+++ b/src/pystencils/codegen/driver.py
@@ -3,12 +3,20 @@ from typing import cast, Sequence, Iterable, TYPE_CHECKING
 from dataclasses import dataclass, replace
 
 from .target import Target
-from .config import CreateKernelConfig, OpenMpConfig, VectorizationConfig, AUTO
+from .config import (
+    CreateKernelConfig,
+    VectorizationOptions,
+    AUTO,
+    _AUTO_TYPE,
+    GhostLayerSpec,
+    IterationSliceSpec,
+)
 from .kernel import Kernel, GpuKernel, GpuThreadsRange
 from .properties import PsSymbolProperty, FieldShape, FieldStride, FieldBasePtr
 from .parameters import Parameter
 
-from ..types import create_numeric_type, PsIntegerType, PsScalarType
+from ..field import Field
+from ..types import PsIntegerType, PsScalarType
 
 from ..backend.memory import PsSymbol
 from ..backend.ast import PsAstNode
@@ -105,15 +113,38 @@ class DefaultKernelCreationDriver:
     def __init__(self, cfg: CreateKernelConfig, retain_intermediates: bool = False):
         self._cfg = cfg
 
-        idx_dtype = create_numeric_type(self._cfg.index_dtype)
-        assert isinstance(idx_dtype, PsIntegerType)
+        #   Data Type Options
+        idx_dtype: PsIntegerType = cfg.get_option("index_dtype")
+        default_dtype: PsScalarType = cfg.get_option("default_dtype")
+
+        #   Iteration Space Options
+        num_ispace_options_set = (
+            int(cfg.is_option_set("ghost_layers"))
+            + int(cfg.is_option_set("iteration_slice"))
+            + int(cfg.is_option_set("index_field"))
+        )
+
+        if num_ispace_options_set > 1:
+            raise ValueError(
+                "At most one of the options 'ghost_layers' 'iteration_slice' and 'index_field' may be set."
+            )
+
+        self._ghost_layers: GhostLayerSpec | None = cfg.get_option("ghost_layers")
+        self._iteration_slice: IterationSliceSpec | None = cfg.get_option(
+            "iteration_slice"
+        )
+        self._index_field: Field | None = cfg.get_option("index_field")
+
+        if num_ispace_options_set == 0:
+            self._ghost_layers = AUTO
 
+        #   Create the context
         self._ctx = KernelCreationContext(
-            default_dtype=create_numeric_type(self._cfg.default_dtype),
+            default_dtype=default_dtype,
             index_dtype=idx_dtype,
         )
 
-        self._target = self._cfg.get_target()
+        self._target = cfg.get_target()
         self._platform = self._get_platform()
 
         self._intermediates: CodegenIntermediates | None
@@ -153,7 +184,7 @@ class DefaultKernelCreationDriver:
             self._intermediates.constants_eliminated = kernel_ast.clone()
 
         #   Target-Specific optimizations
-        if self._cfg.target.is_cpu():
+        if self._target.is_cpu():
             kernel_ast = self._transform_for_cpu(kernel_ast)
 
         #   Note: After this point, the AST may contain intrinsics, so type-dependent
@@ -174,13 +205,13 @@ class DefaultKernelCreationDriver:
         canonicalize = CanonicalizeSymbols(self._ctx, True)
         kernel_ast = cast(PsBlock, canonicalize(kernel_ast))
 
-        if self._cfg.target.is_cpu():
+        if self._target.is_cpu():
             return create_cpu_kernel_function(
                 self._ctx,
                 self._platform,
                 kernel_ast,
-                self._cfg.function_name,
-                self._cfg.target,
+                self._cfg.get_option("function_name"),
+                self._target,
                 self._cfg.get_jit(),
             )
         else:
@@ -189,8 +220,8 @@ class DefaultKernelCreationDriver:
                 self._platform,
                 kernel_ast,
                 gpu_threads,
-                self._cfg.function_name,
-                self._cfg.target,
+                self._cfg.get_option("function_name"),
+                self._target,
                 self._cfg.get_jit(),
             )
 
@@ -213,22 +244,26 @@ class DefaultKernelCreationDriver:
         )
         analysis(assignments)
 
-        if self._cfg.index_field is not None:
+        if self._index_field is not None:
             ispace = create_sparse_iteration_space(
                 self._ctx, assignments, index_field=self._cfg.index_field
             )
         else:
-            gls = self._cfg.ghost_layers
-            islice = self._cfg.iteration_slice
-
-            if gls is None and islice is None:
-                gls = AUTO
+            gls: GhostLayerSpec | None
+            if self._ghost_layers == AUTO:
+                infer_gls = True
+                gls = None
+            else:
+                assert not isinstance(self._ghost_layers, _AUTO_TYPE)
+                infer_gls = False
+                gls = self._ghost_layers
 
             ispace = create_full_iteration_space(
                 self._ctx,
                 assignments,
                 ghost_layers=gls,
-                iteration_slice=islice,
+                iteration_slice=self._iteration_slice,
+                infer_ghost_layers=infer_gls,
             )
 
         self._ctx.set_iteration_space(ispace)
@@ -257,7 +292,7 @@ class DefaultKernelCreationDriver:
         if self._intermediates is not None:
             self._intermediates.cpu_hoist_invariants = kernel_ast.clone()
 
-        cpu_cfg = self._cfg.cpu_optim
+        cpu_cfg = self._cfg.cpu
 
         if cpu_cfg is None:
             return kernel_ast
@@ -266,30 +301,41 @@ class DefaultKernelCreationDriver:
             raise NotImplementedError("Loop blocking not implemented yet.")
 
         kernel_ast = self._vectorize(kernel_ast)
+        kernel_ast = self._add_openmp(kernel_ast)
+
+        if cpu_cfg.use_cacheline_zeroing:
+            raise NotImplementedError("CL-zeroing not implemented yet")
+
+        return kernel_ast
+
+    def _add_openmp(self, kernel_ast: PsBlock) -> PsBlock:
+        omp_options = self._cfg.cpu.openmp
+        enable_omp: bool = omp_options.get_option("enable")
 
-        if cpu_cfg.openmp is not False:
+        if enable_omp:
             from ..backend.transformations import AddOpenMP
 
-            params = (
-                cpu_cfg.openmp
-                if isinstance(cpu_cfg.openmp, OpenMpConfig)
-                else OpenMpConfig()
+            add_omp = AddOpenMP(
+                self._ctx,
+                nesting_depth=omp_options.get_option("nesting_depth"),
+                num_threads=omp_options.get_option("num_threads"),
+                schedule=omp_options.get_option("schedule"),
+                collapse=omp_options.get_option("collapse"),
+                omit_parallel=omp_options.get_option("omit_parallel_construct"),
             )
-            add_omp = AddOpenMP(self._ctx, params)
             kernel_ast = cast(PsBlock, add_omp(kernel_ast))
 
             if self._intermediates is not None:
                 self._intermediates.cpu_openmp = kernel_ast.clone()
 
-        if cpu_cfg.use_cacheline_zeroing:
-            raise NotImplementedError("CL-zeroing not implemented yet")
-
         return kernel_ast
 
     def _vectorize(self, kernel_ast: PsBlock) -> PsBlock:
-        assert self._cfg.cpu_optim is not None
-        vec_config = self._cfg.cpu_optim.get_vectorization_config()
-        if vec_config is None:
+        vec_options = self._cfg.cpu.vectorize
+
+        enable_vec = vec_options.get_option("enable")
+
+        if not enable_vec:
             return kernel_ast
 
         from ..backend.transformations import LoopVectorizer, SelectIntrinsics
@@ -306,7 +352,9 @@ class DefaultKernelCreationDriver:
         inner_loop_dim = ispace.dimensions[inner_loop_coord]
 
         #   Apply stride (TODO: and alignment) assumptions
-        if vec_config.assume_inner_stride_one:
+        assume_unit_stride: bool = vec_options.get_option("assume_inner_stride_one")
+
+        if assume_unit_stride:
             for field in self._ctx.fields:
                 buf = self._ctx.get_buffer(field)
                 inner_stride = buf.strides[inner_loop_coord]
@@ -322,14 +370,14 @@ class DefaultKernelCreationDriver:
                     #   TODO: Communicate assumption to runtime system via a precondition
 
         #   Call loop vectorizer
-        if vec_config.lanes is None:
-            lanes = VectorizationConfig.default_lanes(
+        num_lanes: int | None = vec_options.get_option("lanes")
+
+        if num_lanes is None:
+            num_lanes = VectorizationOptions.default_lanes(
                 self._target, cast(PsScalarType, self._ctx.default_dtype)
             )
-        else:
-            lanes = vec_config.lanes
 
-        vectorizer = LoopVectorizer(self._ctx, lanes)
+        vectorizer = LoopVectorizer(self._ctx, num_lanes)
 
         def loop_predicate(loop: PsLoop):
             return loop.counter.symbol == inner_loop_dim.counter
@@ -375,15 +423,30 @@ class DefaultKernelCreationDriver:
                 )
 
         elif Target._GPU in self._target:
+            gpu_opts = self._cfg.gpu
+            omit_range_check: bool = gpu_opts.get_option("omit_range_check")
+
             match self._target:
                 case Target.SYCL:
                     from ..backend.platforms import SyclPlatform
 
-                    return SyclPlatform(self._ctx, self._cfg.gpu_indexing)
+                    auto_block_size: bool = self._cfg.sycl.get_option("automatic_block_size")
+
+                    return SyclPlatform(
+                        self._ctx,
+                        omit_range_check=omit_range_check,
+                        automatic_block_size=auto_block_size,
+                    )
                 case Target.CUDA:
                     from ..backend.platforms import CudaPlatform
 
-                    return CudaPlatform(self._ctx, self._cfg.gpu_indexing)
+                    manual_grid = gpu_opts.get_option("manual_launch_grid")
+
+                    return CudaPlatform(
+                        self._ctx,
+                        omit_range_check=omit_range_check,
+                        manual_launch_grid=manual_grid,
+                    )
 
         raise NotImplementedError(
             f"Code generation for target {self._target} not implemented"
diff --git a/src/pystencils/types/types.py b/src/pystencils/types/types.py
index 7645a452ffaad83de802da90e10b93fa43e1d3dc..825ac1d5d35fde0f26c5a9ebadb55ec43004c9ae 100644
--- a/src/pystencils/types/types.py
+++ b/src/pystencils/types/types.py
@@ -35,7 +35,7 @@ class PsCustomType(PsType):
         return self._name
 
     def c_string(self) -> str:
-        return f"{self._const_string()} {self._name}"
+        return f"{self._const_string()}{self._name}"
 
     def __repr__(self) -> str:
         return f"CustomType( {self.name}, const={self.const} )"
diff --git a/tests/codegen/test_config.py b/tests/codegen/test_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7f29b76047c96059b88b1e8ee6bf466a1ab979c
--- /dev/null
+++ b/tests/codegen/test_config.py
@@ -0,0 +1,161 @@
+import pytest
+
+from dataclasses import dataclass
+import numpy as np
+from pystencils.codegen.config import (
+    BasicOption,
+    Option,
+    Category,
+    ConfigBase,
+    CreateKernelConfig,
+    CpuOptions
+)
+from pystencils.field import Field, FieldType
+from pystencils.types.quick import Int, UInt, Fp, Ptr
+from pystencils.types import PsVectorType
+
+
+def test_descriptors():
+
+    @dataclass
+    class SampleCategory(ConfigBase):
+        val1: BasicOption[int] = BasicOption(2)
+        val2: Option[bool, str | bool] = Option(False)
+
+        @val2.validate
+        def validate_val2(self, v: str | bool):
+            if isinstance(v, str):
+                if v.lower() in ("off", "false", "no"):
+                    return False
+                elif v.lower() in ("on", "true", "yes"):
+                    return True
+
+                raise ValueError()
+            else:
+                return v
+
+    @dataclass
+    class SampleConfig(ConfigBase):
+        cat: Category[SampleCategory] = Category(SampleCategory())
+        val: BasicOption[str] = BasicOption("fallback")
+
+    cfg = SampleConfig()
+
+    #   Check unset and default values
+    assert cfg.val is None
+    assert cfg.get_option("val") == "fallback"
+
+    #   Check setting
+    cfg.val = "test"
+    assert cfg.val == "test"
+    assert cfg.get_option("val") == "test"
+    assert cfg.is_option_set("val")
+
+    #   Check unsetting
+    cfg.val = None
+    assert not cfg.is_option_set("val")
+    assert cfg.val is None
+
+    #   Check category
+    assert cfg.cat.val1 is None
+    assert cfg.cat.get_option("val1") == 2
+    assert cfg.cat.val2 is None
+    assert cfg.cat.get_option("val2") is False
+
+    #   Check copy on category setting
+    c = SampleCategory(32, "on")
+    cfg.cat = c
+    assert cfg.cat.val1 == 32
+    assert cfg.cat.val2 is True
+
+    assert cfg.cat is not c
+    c.val1 = 13
+    assert cfg.cat.val1 == 32
+
+    #   Check that category objects on two config objects are not the same
+    cfg1 = SampleConfig()
+    cfg2 = SampleConfig()
+
+    assert cfg1.cat is not cfg2.cat
+
+
+def test_category_init():
+    cfg1 = CreateKernelConfig()
+    cfg2 = CreateKernelConfig()
+
+    assert cfg1.cpu is not cfg2.cpu
+    assert cfg1.cpu.openmp is not cfg2.cpu.openmp
+    assert cfg1.cpu.vectorize is not cfg2.cpu.vectorize
+    assert cfg1.gpu is not cfg2.gpu
+
+
+def test_category_copy():
+    cfg = CreateKernelConfig()
+    cpu_repl = CpuOptions()
+    cpu_repl.openmp.num_threads = 42
+
+    cfg.cpu = cpu_repl
+    assert cfg.cpu.openmp.num_threads == 42
+    assert cfg.cpu is not cpu_repl
+    assert cfg.cpu.openmp is not cpu_repl.openmp
+
+
+def test_config_validation():
+    #   Check index dtype validation
+    cfg = CreateKernelConfig(index_dtype="int32")
+    assert cfg.index_dtype == Int(32)
+    cfg.index_dtype = np.uint64
+    assert cfg.index_dtype == UInt(64)
+
+    with pytest.raises(ValueError):
+        _ = CreateKernelConfig(index_dtype=np.float32)
+
+    with pytest.raises(ValueError):
+        cfg.index_dtype = "double"
+
+    #   Check default dtype validation
+    cfg = CreateKernelConfig(default_dtype="float32")
+    assert cfg.default_dtype == Fp(32)
+    cfg.default_dtype = np.int64
+    assert cfg.default_dtype == Int(64)
+
+    with pytest.raises(ValueError):
+        cfg.default_dtype = PsVectorType(Fp(64), 4)
+
+    with pytest.raises(ValueError):
+        _ = CreateKernelConfig(default_dtype=Ptr(Fp(32)))
+
+    #   Check index field validation
+    idx_field = Field.create_generic(
+        "idx", spatial_dimensions=1, field_type=FieldType.INDEXED
+    )
+    cfg.index_field = idx_field
+    assert cfg.index_field == idx_field
+
+    with pytest.raises(ValueError):
+        cfg.index_field = Field.create_generic(
+            "idx", spatial_dimensions=1, field_type=FieldType.GENERIC
+        )
+
+
+def test_override():
+    cfg1 = CreateKernelConfig()
+    cfg1.function_name = "test"
+    cfg1.cpu.openmp.schedule = "dynamic"
+    cfg1.gpu.manual_launch_grid = False
+    cfg1.allow_double_writes = True
+
+    cfg2 = CreateKernelConfig()
+    cfg2.function_name = "func"
+    cfg2.cpu.openmp.schedule = "static(5)"
+    cfg2.cpu.vectorize.lanes = 12
+    cfg2.allow_double_writes = False
+
+    cfg1.override(cfg2)
+
+    assert cfg1.function_name == "func"
+    assert cfg1.cpu.openmp.schedule == "static(5)"
+    assert cfg1.cpu.openmp.enable is None
+    assert cfg1.cpu.vectorize.lanes == 12
+    assert cfg1.cpu.vectorize.assume_aligned is None
+    assert cfg1.allow_double_writes is False
diff --git a/tests/fixtures.py b/tests/fixtures.py
index 7c95216147d02b7943b0c218af6fbb5b5175559b..71e54bad8346eaa5d54f5b438a32294b4773d868 100644
--- a/tests/fixtures.py
+++ b/tests/fixtures.py
@@ -31,15 +31,17 @@ except ImportError:
 AVAILABLE_TARGETS += ps.Target.available_vector_cpu_targets()
 TARGET_IDS = [t.name for t in AVAILABLE_TARGETS]
 
+
 @pytest.fixture(params=AVAILABLE_TARGETS, ids=TARGET_IDS)
 def target(request) -> ps.Target:
     """Provides all code generation targets available on the current hardware"""
     return request.param
 
+
 @pytest.fixture
 def gen_config(target: ps.Target):
     """Default codegen configuration for the current target.
-    
+
     For GPU targets, set default indexing options.
     For vector-CPU targets, set default vectorization config.
     """
@@ -47,25 +49,24 @@ def gen_config(target: ps.Target):
     gen_config = ps.CreateKernelConfig(target=target)
 
     if target.is_vector_cpu():
-        gen_config = replace(
-            gen_config,
-            cpu_optim=ps.CpuOptimConfig(
-                vectorize=ps.VectorizationConfig(assume_inner_stride_one=True)
-            ),
-        )
+        gen_config.cpu.vectorize.enable = True
+        gen_config.cpu.vectorize.assume_inner_stride_one = True
 
     return gen_config
 
+
 @pytest.fixture()
 def xp(target: ps.Target) -> ModuleType:
     """Primary array module for the current target.
-    
+
     Returns:
         `cupy` if `target == Target.CUDA`, and `numpy` otherwise
     """
     if target == ps.Target.CUDA:
         import cupy as xp
+
         return xp
     else:
         import numpy as np
+
         return np
diff --git a/tests/kernelcreation/test_buffer_gpu.py b/tests/kernelcreation/test_buffer_gpu.py
index 873cc1213fd2fd50eee38e1fab20626894d0ecb7..0b5019fba49ba439253ef1257b3c2f12a728d064 100644
--- a/tests/kernelcreation/test_buffer_gpu.py
+++ b/tests/kernelcreation/test_buffer_gpu.py
@@ -299,8 +299,7 @@ def test_iteration_slices(gpu_indexing):
         gpu_src_arr.set(src_arr)
         gpu_dst_arr.fill(0)
 
-        config = CreateKernelConfig(target=Target.GPU, iteration_slice=pack_slice,
-                                    gpu_indexing=gpu_indexing)
+        config = CreateKernelConfig(target=Target.GPU, iteration_slice=pack_slice)
 
         pack_code = create_kernel(pack_eqs, config=config)
         pack_kernel = pack_code.compile()
@@ -312,8 +311,7 @@ def test_iteration_slices(gpu_indexing):
             eq = Assignment(dst_field(idx), buffer(idx))
             unpack_eqs.append(eq)
 
-        config = CreateKernelConfig(target=Target.GPU, iteration_slice=pack_slice,
-                                    gpu_indexing=gpu_indexing)
+        config = CreateKernelConfig(target=Target.GPU, iteration_slice=pack_slice)
 
         unpack_code = create_kernel(unpack_eqs, config=config)
         unpack_kernel = unpack_code.compile()
diff --git a/tests/kernelcreation/test_gpu.py b/tests/kernelcreation/test_gpu.py
index 57de84b7af275ae3ce093fc65b5ef86c25bb5fb3..97f0c0fa9ee847389aee71bc511abef55c9f2b93 100644
--- a/tests/kernelcreation/test_gpu.py
+++ b/tests/kernelcreation/test_gpu.py
@@ -112,7 +112,7 @@ def test_ghost_layer():
     update_rule = Assignment(dst_field[0, 0], src_field[0, 0])
     ghost_layers = [(1, 2), (2, 1)]
 
-    config = CreateKernelConfig(target=Target.GPU, ghost_layers=ghost_layers, gpu_indexing="line")
+    config = CreateKernelConfig(target=Target.GPU, ghost_layers=ghost_layers, gpu="line")
     ast = create_kernel(sympy_cse_on_assignment_list([update_rule]), config=config)
     kernel = ast.compile()
 
@@ -135,7 +135,7 @@ def test_setting_value():
     f = Field.create_generic("f", 2)
     update_rule = [Assignment(f(0), sp.Symbol("value"))]
 
-    config = CreateKernelConfig(target=Target.GPU, gpu_indexing="line", iteration_slice=iteration_slice)
+    config = CreateKernelConfig(target=Target.GPU, gpu="line", iteration_slice=iteration_slice)
     ast = create_kernel(sympy_cse_on_assignment_list(update_rule), config=config)
     kernel = ast.compile()
 
@@ -207,7 +207,7 @@ def test_four_dimensional_kernel(gpu_indexing, layout, shape):
     f = Field.create_from_numpy_array("f", arr_cpu)
     update_rule = [Assignment(f.center, sp.Symbol("value"))]
 
-    config = CreateKernelConfig(target=Target.GPU, gpu_indexing=gpu_indexing, iteration_slice=iteration_slice)
+    config = CreateKernelConfig(target=Target.GPU, gpu=gpu_indexing, iteration_slice=iteration_slice)
     ast = create_kernel(update_rule, config=config)
     kernel = ast.compile()
 
diff --git a/tests/kernelcreation/test_iteration_slices.py b/tests/kernelcreation/test_iteration_slices.py
index fee3544f88087917290a42ed76d8941577726759..02b6b99220d11748647f82ccd88679cec6832ae7 100644
--- a/tests/kernelcreation/test_iteration_slices.py
+++ b/tests/kernelcreation/test_iteration_slices.py
@@ -13,7 +13,6 @@ from pystencils import (
     make_slice,
     Target,
     CreateKernelConfig,
-    GpuIndexingConfig,
     DynamicType,
 )
 from pystencils.sympyextensions.integer_functions import int_rem
@@ -81,7 +80,7 @@ def test_numerical_slices(gen_config: CreateKernelConfig, xp, islice):
     try:
         kernel = create_kernel(update, gen_config).compile()
     except NotImplementedError:
-        if gen_config.target.is_vector_cpu():
+        if gen_config.get_target().is_vector_cpu():
             #   TODO Gather/Scatter not implemented yet
             pytest.xfail("Gather/Scatter not available yet")
 
@@ -104,6 +103,9 @@ def test_symbolic_slice(gen_config: CreateKernelConfig, xp):
     update = Assignment(f.center(), 1)
     islice = make_slice[sy:ey, sx:ex]
     gen_config = replace(gen_config, iteration_slice=islice)
+
+    print(repr(gen_config))
+
     kernel = create_kernel(update, gen_config).compile()
 
     for slic in [make_slice[:, :], make_slice[1:-1, 2:-2], make_slice[8:14, 7:11]]:
@@ -140,9 +142,7 @@ def test_triangle_pattern(gen_config: CreateKernelConfig, xp):
     gen_config = replace(gen_config, iteration_slice=islice)
 
     if gen_config.target == Target.CUDA:
-        gen_config = replace(
-            gen_config, gpu_indexing=GpuIndexingConfig(manual_launch_grid=True)
-        )
+        gen_config.gpu.manual_launch_grid = True
 
     kernel = create_kernel(update, gen_config).compile()
 
@@ -170,17 +170,15 @@ def test_red_black_pattern(gen_config: CreateKernelConfig, xp):
     outer_counter = DEFAULTS.spatial_counters[0]
     start = sp.Piecewise((0, sp.Eq(int_rem(outer_counter, 2), 0)), (1, True))
     islice = make_slice[:, start::2]
-    gen_config = replace(gen_config, iteration_slice=islice)
+    gen_config.iteration_slice = islice
 
     if gen_config.target == Target.CUDA:
-        gen_config = replace(
-            gen_config, gpu_indexing=GpuIndexingConfig(manual_launch_grid=True)
-        )
+        gen_config.gpu.manual_launch_grid = True
 
     try:
         kernel = create_kernel(update, gen_config).compile()
     except NotImplementedError:
-        if gen_config.target.is_vector_cpu():
+        if gen_config.get_target().is_vector_cpu():
             pytest.xfail("Gather/Scatter not implemented yet")
 
     if isinstance(kernel, CupyKernelWrapper):
diff --git a/tests/nbackend/kernelcreation/test_openmp.py b/tests/nbackend/kernelcreation/test_openmp.py
index d7be8eb98cd29bea370bc6279013ef973e621370..4e24cd1b2e86d82f7ee0521054f087929ff3935f 100644
--- a/tests/nbackend/kernelcreation/test_openmp.py
+++ b/tests/nbackend/kernelcreation/test_openmp.py
@@ -4,8 +4,6 @@ from pystencils import (
     Assignment,
     create_kernel,
     CreateKernelConfig,
-    CpuOptimConfig,
-    OpenMpConfig,
     Target,
 )
 
@@ -15,21 +13,18 @@ from pystencils.backend.ast.structural import PsLoop, PsPragma
 
 @pytest.mark.parametrize("nesting_depth", range(3))
 @pytest.mark.parametrize("schedule", ["static", "static,16", "dynamic", "auto"])
-@pytest.mark.parametrize("collapse", range(3))
+@pytest.mark.parametrize("collapse", [None, 1, 2])
 @pytest.mark.parametrize("omit_parallel_construct", range(3))
 def test_openmp(nesting_depth, schedule, collapse, omit_parallel_construct):
     f, g = fields("f, g: [3D]")
     asm = Assignment(f.center(0), g.center(0))
 
-    omp = OpenMpConfig(
-        nesting_depth=nesting_depth,
-        schedule=schedule,
-        collapse=collapse,
-        omit_parallel_construct=omit_parallel_construct,
-    )
-    gen_config = CreateKernelConfig(
-        target=Target.CPU, cpu_optim=CpuOptimConfig(openmp=omp)
-    )
+    gen_config = CreateKernelConfig(target=Target.CPU)
+    gen_config.cpu.openmp.enable = True
+    gen_config.cpu.openmp.nesting_depth = nesting_depth
+    gen_config.cpu.openmp.schedule = schedule
+    gen_config.cpu.openmp.collapse = collapse
+    gen_config.cpu.openmp.omit_parallel_construct = omit_parallel_construct
 
     kernel = create_kernel(asm, gen_config)
     ast = kernel.body
@@ -52,10 +47,10 @@ def test_openmp(nesting_depth, schedule, collapse, omit_parallel_construct):
     pragma = find_omp_pragma(ast)
     tokens = set(pragma.text.split())
 
-    expected_tokens = {"omp", "for", f"schedule({omp.schedule})"}
-    if not omp.omit_parallel_construct:
+    expected_tokens = {"omp", "for", f"schedule({schedule})"}
+    if not omit_parallel_construct:
         expected_tokens.add("parallel")
-    if omp.collapse > 0:
-        expected_tokens.add(f"collapse({omp.collapse})")
+    if collapse is not None:
+        expected_tokens.add(f"collapse({collapse})")
 
     assert tokens == expected_tokens
diff --git a/tests/nbackend/kernelcreation/test_options.py b/tests/nbackend/kernelcreation/test_options.py
deleted file mode 100644
index fefcc98fe62e956aeeba47543667e82bff758ec1..0000000000000000000000000000000000000000
--- a/tests/nbackend/kernelcreation/test_options.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import pytest
-
-from pystencils.field import Field, FieldType
-from pystencils.types.quick import *
-from pystencils.codegen.config import (
-    CreateKernelConfig,
-    PsOptionsError,
-)
-
-
-def test_invalid_iteration_region_options():
-    idx_field = Field.create_generic(
-        "idx", spatial_dimensions=1, field_type=FieldType.INDEXED
-    )
-    with pytest.raises(PsOptionsError):
-        CreateKernelConfig(
-            ghost_layers=2, iteration_slice=(slice(1, -1), slice(1, -1))
-        )
-    with pytest.raises(PsOptionsError):
-        CreateKernelConfig(ghost_layers=2, index_field=idx_field)
-
-
-def test_index_field_options():
-    with pytest.raises(PsOptionsError):
-        idx_field = Field.create_generic(
-            "idx", spatial_dimensions=1, field_type=FieldType.GENERIC
-        )
-        CreateKernelConfig(index_field=idx_field)
diff --git a/tests/nbackend/transformations/test_add_pragmas.py b/tests/nbackend/transformations/test_add_pragmas.py
index 1d8dd1ded148697dbe7acde3648a292dc5a7fcac..c1749fe287875b8ac8b41abff7848448b16d43c6 100644
--- a/tests/nbackend/transformations/test_add_pragmas.py
+++ b/tests/nbackend/transformations/test_add_pragmas.py
@@ -12,6 +12,7 @@ from pystencils.backend.ast import dfs_preorder
 from pystencils.backend.ast.structural import PsBlock, PsPragma, PsLoop
 from pystencils.backend.transformations import InsertPragmasAtLoops, LoopPragma
 
+
 def test_insert_pragmas():
     ctx = KernelCreationContext()
     factory = AstFactory(ctx)
diff --git a/tests/runtime/test_data/datahandling_save_test.npz b/tests/runtime/test_data/datahandling_save_test.npz
index 22202358a4fa1d1cea4db89c0889f5bca636598b..486c7ee74d4421d563c3b1c2e3739d8db6308b07 100644
Binary files a/tests/runtime/test_data/datahandling_save_test.npz and b/tests/runtime/test_data/datahandling_save_test.npz differ
diff --git a/tests/test_quicktests.py b/tests/test_quicktests.py
index 5d5dba0eada50ed7c7f2a6f4f3ddb342781e23b6..9cefc84c540f10cfc1223ae0a00498ee763b2e5e 100644
--- a/tests/test_quicktests.py
+++ b/tests/test_quicktests.py
@@ -71,13 +71,10 @@ def test_basic_vectorization():
     update_rule = [
         ps.Assignment(g[0, 0], f[0, 0] + f[-1, 0] + f[1, 0] + f[0, 1] + f[0, -1] + 42.0)
     ]
-    ast = ps.create_kernel(
-        update_rule,
-        target=target,
-        cpu_optim=ps.CpuOptimConfig(
-            vectorize=ps.VectorizationConfig(assume_inner_stride_one=True)
-        ),
-    )
+    cfg = ps.CreateKernelConfig(target=target)
+    cfg.cpu.vectorize.enable = True
+    cfg.cpu.vectorize.assume_inner_stride_one = True
+    ast = ps.create_kernel(update_rule, cfg)
 
     func = ast.compile()