diff -pruN 0.9.5+ds-1/Changelog.rst 1.0.1+ds-1/Changelog.rst
--- 0.9.5+ds-1/Changelog.rst	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/Changelog.rst	2022-07-30 17:47:39.000000000 +0000
@@ -7,6 +7,596 @@ becomes a document on the website, as we
 Nuitka blog.
 
 ********************
+ Nuitka Release 1.0
+********************
+
+This release contains a large amount of new features, while
+consolidating what we have with many bug fixes. Scalability should be
+dramatically better, as well as new optimization that will accelerate
+some code quite a bit. See the summary, how this release is paving the
+way forward.
+
+Bug Fixes
+=========
+
+-  Python3: Fix, ``bytes.decode`` with only ``errors`` argument given
+   was not working. Fixed in 0.9.1 already.
+
+-  MSYS2: Fix, the accelerate mode ``.cmd`` file was not working
+   correctly. Fixed in 0.9.1 already.
+
+-  Onefile: Fix, the bootstrap when waiting for the child, didn't
+   protect against signals that interrupt this call. This only affected
+   users of the non-public ``--onefile-tempdir`` option on Linux, but
+   with that becoming the default in 1.0, this was discovered. Fixed in
+   0.9.1 already.
+
+-  Fix, ``pkg_resources`` compile time generated ``Distribution`` values
+   could cause issues with code that put it into calls, or in tried
+   blocks. Fixed in 0.9.1 already.
+
+-  Standalone: Added implicit dependencies of ``Xlib`` package. Fixed in
+   0.9.1 already.
+
+-  macOS: Fix, the package configuration for ``wx`` had become invalid
+   when restructuring the Yaml with code and schema disagreeing on
+   allowed values. Fixed in 0.9.1 already.
+
+-  Fix: The ``str.format`` with a single positional argument didn't
+   generate proper code and failed to compile on the C level. Fixed in
+   0.9.1 already.
+
+-  Fix, the type shape of ``str.count`` result was wrong. Fixed in 0.9.1
+   already.
+
+-  UI: Fix, the warning about collision of just compiled package and
+   original package in the same folder hiding the compiled package
+   should not apply to packages without an ``__init__.py`` file, as
+   those do **not** take precedence. Fixed in 0.9.2 already.
+
+-  Debugging: Fix, the fallback to ``lldb`` from ``gdb`` when using the
+   option ``--debugger`` was broken on anything but Windows. Fixed in
+   0.9.2 already.
+
+-  Python3.8: The module ``importlib.metadata`` was not recognized
+   before 3.9, but actually 3.8 already has it, causing the compile time
+   resolution of package versions to not work there. Fixed in 0.9.3
+   already.
+
+-  Standalone: Fix, at least on macOS we should also scan from parent
+   folders of DLLs, since they may contain sub-directories in their
+   names. This is mostly the case, when using frameworks. Fixed in 0.9.2
+   already.
+
+-  Standalone: Added package configuration for ``PyQt5`` to require
+   onefile bundle mode on macOS, and recommend to disable console for
+   PyQt6. This is same as we already do for ``PySide2`` and ``PySide6``.
+   Fixed in 0.9.2 already.
+
+-  Standalone: Removed stray macOS onefile bundle package configuration
+   for ``pickle`` module which must have been added in error. Fixed in
+   0.9.2 already.
+
+-  UI: Catch user error of attempting to compile the ``__init__.py``
+   rather than the package directory. Fixed in 0.9.2 already.
+
+-  Fix, hard name import nodes failed to clone, causing issues in
+   optimization phase. Fixed in 0.9.2 already.
+
+-  Fix, avoid warnings given with gcc 11. Fixed in 0.9.2 already.
+
+-  Fix, dictionary nodes where the operation itself has no effect, e.g.
+   ``dict.copy`` were not properly annotating that their dictionary
+   argument could still cause a raise and have side effects, triggering
+   an assertion violation in Nuitka. Fixed in 0.9.2 already.
+
+-  Standalone: Added ``pynput`` implicit dependencies on Linux. Fixed in
+   0.9.2 already.
+
+-  Fix, boolean condition checks on variables converted immutable
+   constant value assignments to boolean values, leading to incorrect
+   code execution. Fixed in 0.9.2 already.
+
+-  Python3.9: Fix, could crash on generic aliases with non-hashable
+   values. Fixed in 0.9.3 already.
+
+   .. code:: python
+
+      dict[str:any]
+
+-  Python3: Fix, an iteration over ``sys.version_info`` was falsely
+   optimized into a tuple, which is not always compatible. Fixed in
+   0.9.3 already.
+
+-  Standalone: Added support for ``xgboost`` package. Fixed in 0.9.3
+   already.
+
+-  Standalone: Added data file for ``text_unidecode`` package. Fixed in
+   0.9.4 already.
+
+-  Standalone: Added data files for ``swagger_ui_bundle`` package. Fixed
+   in 0.9.4 already.
+
+-  Standalone: Added data files for ``connexion`` package. Fixed in
+   0.9.4 already.
+
+-  Standalone: Added implicit dependencies for ``sklearn.utils`` and
+   ``rapidfuzz``. Fixed in 0.9.4 already.
+
+-  Python3.10: Fix, the reformulation of ``match`` statements could
+   create nodes that are used twice, causing code generation to assert.
+   Fixed in 0.9.4 already.
+
+-  Fix, module objects removed from ``sys.modules`` but still used could
+   lack a reference to themselves, and therefore crash due to working on
+   a released module variables dictionary. Fixed in 0.9.5 already.
+
+-  Fix, the MSVC compiles code generated for SciPy 1.8 wrongly. Added a
+   workaround for that code to avoid triggering it. Fixed in 0.9.6
+   already.
+
+-  Fix, calls to ``str.format`` where the result is not used, could
+   crash the compiler during code generation. Fixed in 0.9.6 already.
+
+-  Standalone: For DLLs on macOS and Anaconda, also consider the ``lib``
+   directory of the root environment, as some DLLs are otherwise not
+   found.
+
+-  Fix, allow ``nonlocal`` and ``global`` for ``__class__`` to be used
+   on the class level.
+
+-  Fix, ``xrange`` with large values didn't work on all platforms. This
+   affected at least Python2 on macOS, but potentially others as well.
+
+-  Windows: When scanning for installed Pythons to e.g. run Scons or
+   onefile compression, it was attempting to use installations that got
+   deleted manually and could crash.
+
+-  macOS: Fix, DLL conflicts are now resolved by checking the version
+   information too, also all cases that previously errored out after a
+   conflict was reported, will now work.
+
+-  Fix, conditional expressions whose statically decided condition
+   picking a branch will raise an exception could crash the compilation.
+
+   .. code:: python
+
+      # Would previously crash Nuitka during optimization.
+      return 1/0 if os.name == "nt" else 1/0
+
+-  Windows: Make sure we set C level standard file handles too
+
+   At least newer subprocess was affected by this, being unable to
+   provide working handles to child processes that pass their current
+   handles through, and also this should help DLL code to use it as
+   level.
+
+-  Standalone: Added support for ``pyqtgraph`` data files.
+
+-  Standalone: Added support for ``dipy`` by anti-bloat removal of its
+   testing framework that wants to do unsupported stuff.
+
+-  UI: Could still give warnings about modules not being followed, where
+   that was not true.
+
+-  Fix, ``--include-module`` was not working for non-automatic standard
+   library paths.
+
+New Features
+============
+
+-  Onefile: Recognize a non-changing path from
+   ``--onefile-tempdir-spec`` and then use cached mode. By default a
+   temporary folder is used in the spec value, make it delete the files
+   afterwards.
+
+   The cached mode is not necessarily faster, but it is not going to
+   change files already there, leaving the binaries there intact. In the
+   future it may also become faster to execute, but right now checking
+   the validity of the file takes about as long as re-creating it,
+   therefore no gain yet. The main point, is to not change where it runs
+   from.
+
+-  Standalone: Added option to exclude DLLs. You can npw use
+   ``--noinclude-dlls`` to exclude DLLs by filename patterns.
+
+   The may e.g. come from Qt plugins, where you know, or experimented,
+   that it is not going to be used in your specific application. Use
+   with care, removing DLLs will lead to very hard to recognize errors.
+
+-  Anaconda: Use ``CondaCC`` from environment variables for Linux and
+   macOS, in case it is installed. This can be done with e.g. ``conda
+   install gcc-linux-64`` on Linux or ``conda install clang_osx-64`` on
+   macOS.
+
+-  Added new option ``--nowarn-mnemonic`` to disable warnings that use
+   mnemonics, there is currently not that many yet, but it's going to
+   expand. You can use this to acknowledge the ones you accept, and not
+   get that warning with the information pointer anymore.
+
+-  Added method for resolving DLL conflicts on macOS too. This is using
+   version information and picks the newer one where possible.
+
+-  Added option ``--user-package-configuration-file`` for user provided
+   Yaml files, which can be used to provide package configuration to
+   Nuitka, to e.g. add DLLs, data files, do some anti-bloat work, or add
+   missing dependencies locally. The documentation for this does not yet
+   exist though, but Nuitka contains a Yaml schema in the
+   ``misc/nuitka-package-config-schema.json`` file.
+
+-  Added ``nuitka-project-else`` to avoid repeating conditions in Nuitka
+   project configuration, this can e.g. be used like this:
+
+   .. code:: python
+
+      # nuitka-project-if: os.getenv("TEST_VARIANT", "pyside2") == "pyside2":
+      #   nuitka-project: --enable-plugin=no-qt
+      # nuitka-project-else:
+      #   nuitka-project: --enable-plugin=no-qt
+      #   nuitka-project: --noinclude-data-file=*.svg
+
+   Previously, the inverted condition had to be used in another
+   ``nuitka-project-if`` which is no big deal, but less readable.
+
+-  Added support for deep copying uncompiled functions. There is now a
+   section in the user manual that explains how to clone compiled
+   functions. This allows a workaround like this:
+
+   .. code:: python
+
+      def binder(func, name):
+         try:
+            result = func.clone()
+         except AttributeError:
+            result = types.FunctionType(func.__code__, func.__globals__, name=func.__name__, argdefs=func.__defaults__, closure=func.__closure__)
+            result = functools.update_wrapper(result, func)
+            result.__kwdefaults__ = func.__kwdefaults__
+
+         result.__name__ = name
+         return result
+
+-  Plugins: Added explicit deprecation status of a plugin. We now have a
+   few that do nothing, and are just there for compatibility with
+   existing users, and this now informs the user properly rather than
+   just saying it is not relevant.
+
+-  Fix, some Python installations crash when attempting to import
+   modules, such as ``os`` with a ``ModuleName`` object, because we
+   limit string operations done, and e.g. refuse to do ``.startswith``
+   which of course, other loaders that your installation has added,
+   might still use.
+
+-  Windows: In case of not found DLLs, we can still examine the run time
+   of the currently compiling Python process of Nuitka, and locate them
+   that way, which helps for some Python configurations to support
+   standalone, esp. to find CPython DLL in unusual spots.
+
+-  Debian: Workaround for ``lib2to3`` data files. These are from stdlib
+   and therefore the patched code from Debian needs to be undone, to
+   make these portable again.
+
+Optimization
+============
+
+-  Scalability: Avoid merge traces of initial variable versions, which
+   came into play when merging a variable used in only one branch. These
+   are useless and only made other optimization slower or impossible.
+
+-  Scalability: Also avoid merge traces of merge traces, instead flatten
+   merge traces and avoid the duplication doing so. There were
+   pathological cases, where this reduced optimization time for
+   functions from infinite to instant.
+
+-  For comparison helpers, switch comparison where possible, such that
+   there are only 3 variants, rather than 6. Instead the boolean result
+   is inverted, e.g. changing ``>=`` into ``not <`` effectively. Of
+   course this can only be done for types, where we know that nothing
+   special, i.e. no method overloads of ``__gte__`` is going on.
+
+-  For binary operations that are commutative with the selected types,
+   in mixed type cases, swap the arguments during code generation, such
+   that e.g. ``long_a + float_b`` is actually computed as ``float_b +
+   long_a``. This again avoids many helpers. It also can be done for
+   ``*`` with integers and container types.
+
+-  In cases, where a comparison (or one of the few binary operation
+   where we consider it useful), is used in a boolean context, but we
+   know it is impossible to raise an exception, a C boolean result type
+   is used rather than a ``nuitka_bool`` which is now only used when
+   necessary, because it can indicate the exception result.
+
+-  Anti-Bloat: More anti-bloat work was done for popular packages,
+   covering also uses of ``setuptools_scm``, ``nose`` and ``nose2``
+   package removals and warnings. There was also a focus on making
+   ``mmvc``, ``tensorflow`` and ``tifffile`` compile well, removing e.g.
+   the uses of the tensorflow testing framework.
+
+-  Faster comparison of ``int`` values with constant values, this uses
+   helpers that work with C ``long`` values that represent a single
+   "digit" of a value, or ones that use the full value space of C
+   ``long``.
+
+-  Faster comparison of ``float`` values with constant values, this uses
+   helpers that work with C ``float`` values, avoiding the useless
+   Python level constant objects.
+
+-  Python2: Comparison of ``int`` and ``long`` now has specialized
+   helpers that avoids converting the ``int`` to a ``long`` through
+   coercion. This takes advantage of code to compare C ``long`` values
+   (which are at the core of Python2 ``int`` objects, with ``long``
+   objects.
+
+-  For binary operation on mixed types, e.g. ``int * bytes`` the slot of
+   the first function was still considered, and called to give a
+   ``Py_NotImplemented`` return value for no good reason. This also
+   applies to mixed operations of ``int``, ``long``, and ``float``
+   types, and for ``str`` and ``unicode`` values on Python2.
+
+-  Added missing helper for ``**`` operation with floats, this had been
+   overlooked so far.
+
+-  Added dedicated nodes for ``ctypes.CDLL`` which aims to allow us to
+   detect used DLLs at compile time in the future, and to move closer to
+   support its bindings more efficiently.
+
+-  Added specialized nodes for ``dict.popitem`` as well. With this, now
+   all of the dictionary methods are specialized.
+
+-  Added specialized nodes for ``str.expandtabs``, ``str.translate``,
+   ``str.ljust``, ``str.rjust``, ``str.center``, ``str.zfill``, and
+   ``str.splitlines``. While these are barely performance relevant, this
+   completes all ``str`` methods, except ``removeprefix`` and
+   ``removesuffix`` that are Python3.9 or higher.
+
+-  Added type shape for result of ``str.index`` operation as well, this
+   was missing so far.
+
+-  Optimize ``str``, ``bytes`` and ``dict`` method calls through
+   variables.
+
+-  Optimize calls through variables containing e.g. mutable constant
+   values, these will be rare, because they all become exceptions.
+
+-  Optimize calls through variables containing built-in values,
+   unlocking optimization of such calls, where it is assigned to a local
+   variable.
+
+-  For generated attribute nodes, avoid local doing import statements on
+   the function level. While these were easier to generate, they can
+   only be slow at runtime.
+
+-  For the ``str`` built-in annotate its value as derived from ``str``,
+   which unfortunately does not allow much optimization, since that can
+   still change many things, but it was still a missing attribute.
+
+-  For variable value release nodes, specialize them by value type as
+   well, enhancing the scalability, because e.g. parameter variable
+   specific tests, need not be considered for all other variable types
+   as well.
+
+Organisational
+==============
+
+-  Plugins: Major changes to the Yaml file content, cleaning up some of
+   the DLL configuration to more easy to use.
+
+   The DLL configuration has two flavors, one from code and one from
+   filename matching, and these got separated into distinct items in the
+   Yaml configuration. Also how source and dest paths get provided got
+   simplified, with a relative path now being used consistently and with
+   sane defaults, deriving the destination path from where the module
+   lives. Also what we called patterns, are actually prefixes, as there
+   is still the platform specific DLL file naming appended.
+
+-  Plugins: Move mode checks to dedicated plugin called
+   ``options-nanny`` that is always enabled, giving also much cleaner
+   Yaml configuration with a new section added specifically for these.
+   It controls advice on the optional or required use of
+   ``--disable-console`` and the like. Some packages, e.g. ``wx`` are
+   known to crash on macOS when the console is enabled, so this advice
+   is now done with saner configuration.
+
+-  Plugins: Also for all Yaml configuration sub-items where is now a
+   consistent ``when`` field, that allows checking Python version, OS,
+   Nuitka modes such as standalone, and only apply configuration when
+   matching this criterion, with that the anti-bloat options to allow
+   certain bloat, should now have proper effect as well.
+
+-  The use of ``AppImage`` on Linux is no more. The performance for
+   startup was always slower, while having lost the main benefit of
+   avoiding IO at startup, due to new cached mode, so now we always use
+   the same bootstrap binary as on macOS and Windows.
+
+-  UI: Do not display implicit reports reported by plugins by default
+   anymore. These have become far too many, esp. with the recent stdlib
+   work, and often do not add any value. The compilation report will
+   become where to turn to find out why a module in included.
+
+-  UI: Ask the user to install the ordered set package that will
+   actually work for the specific Python version, rather than making him
+   try one of two, where sometimes only one can work, esp. with Python
+   3.10 allowing only one.
+
+-  GitHub: More clear wording in the issue template that ``python -m
+   nuitka --version`` output is really required for support to given.
+
+-  Attempt to use Anaconda ``ccache`` binary if installed on
+   non-Windows. This is esp. handy on macOS, where it is harder to get
+   it.
+
+-  Windows: Avoid byte-compiling the inline copy of Scons that uses
+   Python3 when installing for Python2.
+
+-  Added experimental switches to disable certain optimization in order
+   to try out their impact, e.g. on corruption bugs.
+
+-  Reports: Added included DLLs for standalone mode to compilation
+   report.
+
+-  Reports: Added control tags influencing plugin decisions to the
+   compilation report.
+
+-  Plugins: Make the ``implicit-imports`` dependency section in the Yaml
+   package configuration a list, for consistency with other blocks.
+
+-  Plugins: Added checking of tags such from the package configuration,
+   so that for things dependent on python version (e.g.
+   ``python39_or_higher``, ``before_python39``), the usage of Anaconda
+   (``anaconda``) or certain OS (e.g. ``macos``), or modes (e.g.
+   ``standalone``), expressions in ``when`` can limit a configuration
+   item.
+
+-  Quality: Re-enabled string normalization from black, the issues with
+   changes that are breaking to Python2 have been worked around.
+
+-  User Manual: Describe using a minimal virtualenv as a possible help
+   low memory situations as well.
+
+-  Quality: The yaml auto-format now properly preserves comments, being
+   based on ``ruamel.yaml``.
+
+-  Nuitka-Python: Added support for the Linux build with Nuitka-Python
+   for our own CPython fork as well, previously only Windows was
+   working, amd macOS will follow later.
+
+-  The commit hook when installed from git bash was working, but doing
+   so from ``cmd.exe`` didn't find a proper path for shell from the
+   ``git`` location.
+
+-  Debugging: A lot of experimental toggles were added, that allow
+   control over the use of certain optimization, e.g. use of dict, list,
+   iterators, subscripts, etc. internals, to aid in debugging in
+   situations where it's not clear, if these are causing the issue or
+   not.
+
+-  Added support for Fedora 36, which requires some specific linker
+   options, also recognize Fedora based distributions as such.
+
+-  Removed long deprecated option ``--noinclude-matplotlib`` from numpy
+   plugin, as it hasn't had an effect for a long time now.
+
+-  Visual Code: Added extension for editing Jinja2 templates. This one
+   even detects that we are editing C or Python and properly highlights
+   accordingly.
+
+Cleanups
+========
+
+-  Standalone: Major cleanup of the dependency analysis for standalone.
+   There is no longer a distinction between entry points (main binary,
+   extension modules) and DLLs that they depend on. The OS specific
+   parts got broken out into dedicated modules as well and decisions are
+   now taken immediately.
+
+-  Plugins: Split the Yaml package configuration files into 3 files. One
+   contains now Python2 only stdlib configuration, and another one
+   general stdlib.
+
+-  Plugins: Also cleanup the ``zmq`` plugin, which was one the last
+   holdouts of now removed plugin method, moving parts to the Yaml
+   configuration. We therefore no longer have ``considerExtraDlls``
+   which used to work on the standalone folder, but instead only plugin
+   code that provides included DLL or binary objects from
+   ``getExtraDlls`` which gives Nuitka much needed control over DLL
+   copying. This was a long lasting battle finally won, and will allow
+   many new features to come.
+
+-  UI: Avoid changing whitespace in warnings, where we have intended
+   line breaks, e.g. in case of duplicate DLLs. Went over all warnings
+   and made sure to either avoid new-lines or have them, depending on
+   wanted output.
+
+-  Iterator end check code now uses the same code as rich comparison
+   expressions and can benefit from optimization being done there as
+   well.
+
+-  Solved TODO item about code generation time C types to specify if
+   they have error checking or not, rather than hard coding it.
+
+-  Production of binary helper function set was cleaned up massively,
+   but still needs more work, comparison helper function set was also
+   redesigned.
+
+-  Changing the spelling of our container package to become more clear.
+
+-  Used ``namedtuple`` objects for storing used DLL information for more
+   clear code.
+
+-  Added spellchecker ignores for all attribute and argument names of
+   generated fixed attribute nodes.
+
+-  In auto-format make sure the imports float to the top. That very much
+   cleans up generated attribute nodes code, allowing also to combine
+   the many ones it makes, but also cleans up some of our existing code.
+
+-  The package configuration Yaml files are now sorted according to
+   module names. This will help to avoid merge conflicts during hotfixes
+   merge back to develop and automatically group related entries in a
+   sane way.
+
+-  Moved large amounts of code producing implicit imports to Yaml
+   configuration files.
+
+-  Changed the ``tensorflow`` plugin to Yaml based configuration, making
+   it a deprecated do nothing plugin, that only remains there for a few
+   releases, to not crash existing build scripts.
+
+-  Lots of spelling cleanups, e.g. renaming ``nuitka.codegen`` to
+   ``nuitka.code_generation`` for clarity.
+
+Tests
+=====
+
+-  Added generated test to cover ``bytes`` method. This would have found
+   the issue with ``decode`` potentially.
+
+-  Enhanced standalone test for ``ctypes`` on Linux to actually have
+   something to test.
+
+Summary
+=======
+
+This release improves on many things at once. A lot of work has been put
+into polishing the Yaml configuration that now only lacks documentation
+and examples, such that the community as a whole should become capable
+of adding missing dependencies, data files, DLLs, and even anti-bloat
+patches.
+
+Then a lot of new optimization has been done, to close the missing gaps
+with ``dict`` and ``str`` methods, but before completing ``list`` which
+is already a work in progress pull request, and ``bytes``, we want to
+start and generate the node classes that form the link or basis of
+dedicated nodes. This will be an area to work on more.
+
+The many improvements to existing code helpers, and them being able to
+pick target types for the arguments of comparisons and binary
+operations, is a pre-cursor to universal optimization of this kind. What
+is currently only done for constant values, will in the future be
+interesting for picking specific C types for use. That will then be a
+huge difference from what we are doing now, where most things still have
+to use ``PyObject *`` based types.
+
+Scalability has again seen very real improvements, memory usage of
+Nuitka itself, as well as compile time inside Nuitka are down by a lot
+for some cases, very noticeable. There is never enough of this, but it
+appears, in many cases now, large compilations run much faster.
+
+For macOS specifically, the new DLL dependency analysis, is much more
+capable or resolving conflicts all by itself. Many of the more complex
+packages with some variants of Python, specifically Anaconda will now be
+working a lot better.
+
+And then, of course there is the big improvement for Onefile, that
+allows to use cached paths. This will make it more usable in the general
+case, e.g. where the firewall of Windows hate binaries that change their
+path each time they run.
+
+Future directions will aim to make the compilation report more concise,
+and given reasons and dependencies as they are known on the inside more
+clearly, such that is can be a major tool for testing, bug reporting and
+analysis of the compilation result.
+
+********************
  Nuitka Release 0.9
 ********************
 
@@ -111,12 +701,6 @@ New Features
 
 -  Include module search path in compilation report.
 
-Tests
-=====
-
--  The reflected test was adapted to preserve ``PYTHONPATH`` now that
-   module presence influences optimization.
-
 Optimization
 ============
 
@@ -248,6 +832,12 @@ Organisational
    consistency. With few exceptions, it was already done like this. But
    it makes things easier for generated code.
 
+Tests
+=====
+
+-  The reflected test was adapted to preserve ``PYTHONPATH`` now that
+   module presence influences optimization.
+
 Summary
 =======
 
diff -pruN 0.9.5+ds-1/debian/changelog 1.0.1+ds-1/debian/changelog
--- 0.9.5+ds-1/debian/changelog	2022-07-15 11:59:28.000000000 +0000
+++ 1.0.1+ds-1/debian/changelog	2022-08-04 14:55:17.000000000 +0000
@@ -1,3 +1,21 @@
+nuitka (1.0.1+ds-1) unstable; urgency=medium
+
+  * New upstream hotfix release.
+
+ -- Kay Hayen <kay.hayen@gmail.com>  Thu, 04 Aug 2022 16:55:17 +0200
+
+nuitka (1.0+ds-1) unstable; urgency=medium
+
+  * New upstream release.
+
+ -- Kay Hayen <kay.hayen@gmail.com>  Sat, 30 Jul 2022 16:16:40 +0200
+
+nuitka (0.9.6+ds-1) unstable; urgency=medium
+
+  * New upstream hotfix release.
+
+ -- Kay Hayen <kay.hayen@gmail.com>  Sun, 17 Jul 2022 18:40:22 +0200
+
 nuitka (0.9.5+ds-1) unstable; urgency=medium
 
   * New upstream hotfix release.
diff -pruN 0.9.5+ds-1/debian/control 1.0.1+ds-1/debian/control
--- 0.9.5+ds-1/debian/control	2022-05-20 16:47:11.000000000 +0000
+++ 1.0.1+ds-1/debian/control	2022-07-30 17:47:39.000000000 +0000
@@ -27,6 +27,7 @@ Build-Depends: debhelper (>= 9),
                ccache,
                strace,
                patchelf,
+               libzstd-dev | base-files (<= 9),
                gdb | lldb
 Rules-Requires-Root: no
 Vcs-Git: https://github.com/Nuitka/Nuitka.git
@@ -44,6 +45,7 @@ Depends: gcc (>= 5.0) | g++ (>= 4.4) | c
          python3-appdirs | base-files (<< 7.2),
          python3-dev,
          zlib1g-dev,
+         libzstd-dev,
          ccache,
          patchelf,
          ${misc:Depends},
diff -pruN 0.9.5+ds-1/debian/copyright 1.0.1+ds-1/debian/copyright
--- 0.9.5+ds-1/debian/copyright	2022-05-20 16:47:11.000000000 +0000
+++ 1.0.1+ds-1/debian/copyright	2022-07-30 17:47:39.000000000 +0000
@@ -6,7 +6,7 @@ Source: https://nuitka.net/
 # No spell checking for this file, spell-checker: disable
 
 Files: *
-Copyright: 2021 Kay Hayen
+Copyright: 2022 Kay Hayen
            2020 Batakrishna Sahu
            2020 Jan Teske
            2020 Jorj McKie
@@ -52,7 +52,7 @@ License: Apache+Nuitka_test_origin
  On Debian GNU/Linux systems, the complete text of the Apache 2.0 license
  can be found in `/usr/share/common-licenses/Apache-2.0'.
 
-Files: nuitka/containers/odict.py
+Files: nuitka/containers/OrderedDicts.py
 Copyright: 2008 by Armin Ronacher and PEP 273 authors
 License: BSD-3-clause
  Redistribution and use in source and binary forms, with or without
@@ -77,7 +77,7 @@ License: BSD-3-clause
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-Files: nuitka/containers/OrderedSetFallback.py
+Files: nuitka/containers/OrderedSetsFallback.py
 Copyright: 2009 Raymond Hettinger
 License: MIT+Hettinger
  Permission is hereby granted, free of charge, to any person obtaining
diff -pruN 0.9.5+ds-1/Developer_Manual.rst 1.0.1+ds-1/Developer_Manual.rst
--- 0.9.5+ds-1/Developer_Manual.rst	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/Developer_Manual.rst	2022-07-30 17:47:39.000000000 +0000
@@ -85,10 +85,11 @@ Nuitka top level works like this:
 
 -  ``nuitka.finalization`` prepares the tree for code generation
 
--  ``nuitka.codegen.CodeGeneration`` orchestrates the creation of code
-   snippets
+-  ``nuitka.code_generation.CodeGeneration`` orchestrates the creation
+   of code snippets
 
--  ``nuitka.codegen.*Codes`` knows how specific code kinds are created
+-  ``nuitka.code_generation.*Codes`` knows how specific code kinds are
+   created
 
 -  ``nuitka.MainControl`` keeps it all together
 
@@ -257,10 +258,10 @@ For the packages, no real code is allowe
 they must be lower case, like e.g. ``nuitka`` or ``codegen``. This is to
 distinguish them from the modules.
 
-Packages shall only be used to group things. In ``nuitka.codegen`` the
-code generation packages are located, while the main interface is
-``nuitka.codegen.CodeGeneration`` and may then use most of the entries
-as local imports.
+Packages shall only be used to group things. In
+``nuitka.code_generation`` the code generation packages are located,
+while the main interface is ``nuitka.code_generation.CodeGeneration``
+and may then use most of the entries as local imports.
 
 There is no code in packages themselves. For programs, we use
 ``__main__`` package to carry the actual code.
diff -pruN 0.9.5+ds-1/doc/nuitka2.1 1.0.1+ds-1/doc/nuitka2.1
--- 0.9.5+ds-1/doc/nuitka2.1	2022-07-16 10:01:55.000000000 +0000
+++ 1.0.1+ds-1/doc/nuitka2.1	2022-08-04 18:22:49.000000000 +0000
@@ -1,5 +1,5 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.48.1.
-.TH NUITKA "1" "July 2022" "nuitka 0.9.5" "User Commands"
+.TH NUITKA "1" "August 2022" "nuitka 1.0.1" "User Commands"
 .SH NAME
 nuitka \- the Python compiler
 .SH SYNOPSIS
@@ -51,6 +51,8 @@ Python binary to use for Scons. Otherwis
 use what you run Nuitka with or a "scons" binary that
 is found in PATH, or a Python installation from
 Windows registry.
+.IP
+Control the warnings to be given by Nuitka:
 .TP
 \fB\-\-warn\-implicit\-exceptions\fR
 Enable warnings for implicit exceptions detected at
@@ -65,8 +67,16 @@ Allow Nuitka to download external code i
 e.g. dependency walker, ccache, and even gcc on
 Windows. To disable, redirect input from nul device,
 e.g. "</dev/null" or "<NUL:". Default is to prompt.
+.TP
+\fB\-\-nowarn\-mnemonic\fR=\fI\,MNEMONIC\/\fR
+Disable warning for a given mnemonic. These are given
+to make sure you are aware of certain topics, and
+typically point to the Nuitka website. The mnemonic is
+the part of the URL at the end, without the HTML
+suffix. Can be given multiple times and accepts shell
+pattern. Default empty.
 .IP
-Control the inclusion of modules and packages in result.:
+Control the inclusion of modules and packages in result:
 .TP
 \fB\-\-include\-package\fR=\fI\,PACKAGE\/\fR
 Include a whole package. Give as a Python namespace,
@@ -165,6 +175,15 @@ not source paths. So ignore file pattern
 data for "package_name" should be matched as
 "package_name/*.txt". Default empty.
 .IP
+DLL files:
+.TP
+\fB\-\-noinclude\-dlls\fR=\fI\,PATTERN\/\fR
+Do not include DLL files matching the filename pattern
+given. This is against the target filename, not source
+paths. So ignore a DLL "someDLL" contained in the
+package "package_name" it should be matched as
+"package_name/someDLL.*". Default empty.
+.IP
 Immediate execution after compilation:
 .TP
 \fB\-\-run\fR
@@ -498,7 +517,7 @@ required, when a version resource needs
 e.g. to specify product name, or company name.
 Defaults to nonsense.
 .TP
-\fB\-\-windows\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR, \fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
+\fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
 Use this as a temporary folder. Defaults to
 \&'%TEMP%\eonefile_%PID%_%TIME%', i.e. system temporary
 directory.
@@ -557,14 +576,10 @@ multiple times. Default empty.
 .IP
 Linux specific controls:
 .TP
-\fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
+\fB\-\-linux\-icon\fR=\fI\,ICON_PATH\/\fR, \fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
 Add executable icon for onefile binary to use. Can be
 given only one time. Defaults to Python icon if
 available.
-.TP
-\fB\-\-linux\-onefile\-compression\fR=\fI\,COMPRESSION\/\fR
-Compression method to use for Linux onefile builds.
-Defaults to gzip for faster decompression
 .IP
 Plugin control:
 .TP
diff -pruN 0.9.5+ds-1/doc/nuitka2-run.1 1.0.1+ds-1/doc/nuitka2-run.1
--- 0.9.5+ds-1/doc/nuitka2-run.1	2022-07-16 10:01:55.000000000 +0000
+++ 1.0.1+ds-1/doc/nuitka2-run.1	2022-08-04 18:22:49.000000000 +0000
@@ -1,5 +1,5 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.48.1.
-.TH NUITKA-RUN "1" "July 2022" "nuitka-run 0.9.5" "User Commands"
+.TH NUITKA-RUN "1" "August 2022" "nuitka-run 1.0.1" "User Commands"
 .SH NAME
 nuitka-run \- the Python compiler
 .SH SYNOPSIS
@@ -51,6 +51,8 @@ Python binary to use for Scons. Otherwis
 use what you run Nuitka with or a "scons" binary that
 is found in PATH, or a Python installation from
 Windows registry.
+.IP
+Control the warnings to be given by Nuitka:
 .TP
 \fB\-\-warn\-implicit\-exceptions\fR
 Enable warnings for implicit exceptions detected at
@@ -65,8 +67,16 @@ Allow Nuitka to download external code i
 e.g. dependency walker, ccache, and even gcc on
 Windows. To disable, redirect input from nul device,
 e.g. "</dev/null" or "<NUL:". Default is to prompt.
+.TP
+\fB\-\-nowarn\-mnemonic\fR=\fI\,MNEMONIC\/\fR
+Disable warning for a given mnemonic. These are given
+to make sure you are aware of certain topics, and
+typically point to the Nuitka website. The mnemonic is
+the part of the URL at the end, without the HTML
+suffix. Can be given multiple times and accepts shell
+pattern. Default empty.
 .IP
-Control the inclusion of modules and packages in result.:
+Control the inclusion of modules and packages in result:
 .TP
 \fB\-\-include\-package\fR=\fI\,PACKAGE\/\fR
 Include a whole package. Give as a Python namespace,
@@ -165,6 +175,15 @@ not source paths. So ignore file pattern
 data for "package_name" should be matched as
 "package_name/*.txt". Default empty.
 .IP
+DLL files:
+.TP
+\fB\-\-noinclude\-dlls\fR=\fI\,PATTERN\/\fR
+Do not include DLL files matching the filename pattern
+given. This is against the target filename, not source
+paths. So ignore a DLL "someDLL" contained in the
+package "package_name" it should be matched as
+"package_name/someDLL.*". Default empty.
+.IP
 Immediate execution after compilation:
 .TP
 \fB\-\-run\fR
@@ -498,7 +517,7 @@ required, when a version resource needs
 e.g. to specify product name, or company name.
 Defaults to nonsense.
 .TP
-\fB\-\-windows\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR, \fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
+\fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
 Use this as a temporary folder. Defaults to
 \&'%TEMP%\eonefile_%PID%_%TIME%', i.e. system temporary
 directory.
@@ -557,14 +576,10 @@ multiple times. Default empty.
 .IP
 Linux specific controls:
 .TP
-\fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
+\fB\-\-linux\-icon\fR=\fI\,ICON_PATH\/\fR, \fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
 Add executable icon for onefile binary to use. Can be
 given only one time. Defaults to Python icon if
 available.
-.TP
-\fB\-\-linux\-onefile\-compression\fR=\fI\,COMPRESSION\/\fR
-Compression method to use for Linux onefile builds.
-Defaults to gzip for faster decompression
 .IP
 Plugin control:
 .TP
diff -pruN 0.9.5+ds-1/doc/nuitka3.1 1.0.1+ds-1/doc/nuitka3.1
--- 0.9.5+ds-1/doc/nuitka3.1	2022-07-16 10:01:55.000000000 +0000
+++ 1.0.1+ds-1/doc/nuitka3.1	2022-08-04 18:22:50.000000000 +0000
@@ -1,5 +1,5 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.48.1.
-.TH NUITKA "1" "July 2022" "nuitka 0.9.5" "User Commands"
+.TH NUITKA "1" "August 2022" "nuitka 1.0.1" "User Commands"
 .SH NAME
 nuitka \- the Python compiler
 .SH SYNOPSIS
@@ -51,6 +51,8 @@ Python binary to use for Scons. Otherwis
 use what you run Nuitka with or a "scons" binary that
 is found in PATH, or a Python installation from
 Windows registry.
+.IP
+Control the warnings to be given by Nuitka:
 .TP
 \fB\-\-warn\-implicit\-exceptions\fR
 Enable warnings for implicit exceptions detected at
@@ -65,8 +67,16 @@ Allow Nuitka to download external code i
 e.g. dependency walker, ccache, and even gcc on
 Windows. To disable, redirect input from nul device,
 e.g. "</dev/null" or "<NUL:". Default is to prompt.
+.TP
+\fB\-\-nowarn\-mnemonic\fR=\fI\,MNEMONIC\/\fR
+Disable warning for a given mnemonic. These are given
+to make sure you are aware of certain topics, and
+typically point to the Nuitka website. The mnemonic is
+the part of the URL at the end, without the HTML
+suffix. Can be given multiple times and accepts shell
+pattern. Default empty.
 .IP
-Control the inclusion of modules and packages in result.:
+Control the inclusion of modules and packages in result:
 .TP
 \fB\-\-include\-package\fR=\fI\,PACKAGE\/\fR
 Include a whole package. Give as a Python namespace,
@@ -165,6 +175,15 @@ not source paths. So ignore file pattern
 data for "package_name" should be matched as
 "package_name/*.txt". Default empty.
 .IP
+DLL files:
+.TP
+\fB\-\-noinclude\-dlls\fR=\fI\,PATTERN\/\fR
+Do not include DLL files matching the filename pattern
+given. This is against the target filename, not source
+paths. So ignore a DLL "someDLL" contained in the
+package "package_name" it should be matched as
+"package_name/someDLL.*". Default empty.
+.IP
 Immediate execution after compilation:
 .TP
 \fB\-\-run\fR
@@ -498,7 +517,7 @@ required, when a version resource needs
 e.g. to specify product name, or company name.
 Defaults to nonsense.
 .TP
-\fB\-\-windows\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR, \fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
+\fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
 Use this as a temporary folder. Defaults to
 \&'%TEMP%\eonefile_%PID%_%TIME%', i.e. system temporary
 directory.
@@ -557,14 +576,10 @@ multiple times. Default empty.
 .IP
 Linux specific controls:
 .TP
-\fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
+\fB\-\-linux\-icon\fR=\fI\,ICON_PATH\/\fR, \fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
 Add executable icon for onefile binary to use. Can be
 given only one time. Defaults to Python icon if
 available.
-.TP
-\fB\-\-linux\-onefile\-compression\fR=\fI\,COMPRESSION\/\fR
-Compression method to use for Linux onefile builds.
-Defaults to gzip for faster decompression
 .IP
 Plugin control:
 .TP
diff -pruN 0.9.5+ds-1/doc/nuitka3-run.1 1.0.1+ds-1/doc/nuitka3-run.1
--- 0.9.5+ds-1/doc/nuitka3-run.1	2022-07-16 10:01:55.000000000 +0000
+++ 1.0.1+ds-1/doc/nuitka3-run.1	2022-08-04 18:22:50.000000000 +0000
@@ -1,5 +1,5 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.48.1.
-.TH NUITKA-RUN "1" "July 2022" "nuitka-run 0.9.5" "User Commands"
+.TH NUITKA-RUN "1" "August 2022" "nuitka-run 1.0.1" "User Commands"
 .SH NAME
 nuitka-run \- the Python compiler
 .SH SYNOPSIS
@@ -51,6 +51,8 @@ Python binary to use for Scons. Otherwis
 use what you run Nuitka with or a "scons" binary that
 is found in PATH, or a Python installation from
 Windows registry.
+.IP
+Control the warnings to be given by Nuitka:
 .TP
 \fB\-\-warn\-implicit\-exceptions\fR
 Enable warnings for implicit exceptions detected at
@@ -65,8 +67,16 @@ Allow Nuitka to download external code i
 e.g. dependency walker, ccache, and even gcc on
 Windows. To disable, redirect input from nul device,
 e.g. "</dev/null" or "<NUL:". Default is to prompt.
+.TP
+\fB\-\-nowarn\-mnemonic\fR=\fI\,MNEMONIC\/\fR
+Disable warning for a given mnemonic. These are given
+to make sure you are aware of certain topics, and
+typically point to the Nuitka website. The mnemonic is
+the part of the URL at the end, without the HTML
+suffix. Can be given multiple times and accepts shell
+pattern. Default empty.
 .IP
-Control the inclusion of modules and packages in result.:
+Control the inclusion of modules and packages in result:
 .TP
 \fB\-\-include\-package\fR=\fI\,PACKAGE\/\fR
 Include a whole package. Give as a Python namespace,
@@ -165,6 +175,15 @@ not source paths. So ignore file pattern
 data for "package_name" should be matched as
 "package_name/*.txt". Default empty.
 .IP
+DLL files:
+.TP
+\fB\-\-noinclude\-dlls\fR=\fI\,PATTERN\/\fR
+Do not include DLL files matching the filename pattern
+given. This is against the target filename, not source
+paths. So ignore a DLL "someDLL" contained in the
+package "package_name" it should be matched as
+"package_name/someDLL.*". Default empty.
+.IP
 Immediate execution after compilation:
 .TP
 \fB\-\-run\fR
@@ -498,7 +517,7 @@ required, when a version resource needs
 e.g. to specify product name, or company name.
 Defaults to nonsense.
 .TP
-\fB\-\-windows\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR, \fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
+\fB\-\-onefile\-tempdir\-spec\fR=\fI\,ONEFILE_TEMPDIR_SPEC\/\fR
 Use this as a temporary folder. Defaults to
 \&'%TEMP%\eonefile_%PID%_%TIME%', i.e. system temporary
 directory.
@@ -557,14 +576,10 @@ multiple times. Default empty.
 .IP
 Linux specific controls:
 .TP
-\fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
+\fB\-\-linux\-icon\fR=\fI\,ICON_PATH\/\fR, \fB\-\-linux\-onefile\-icon\fR=\fI\,ICON_PATH\/\fR
 Add executable icon for onefile binary to use. Can be
 given only one time. Defaults to Python icon if
 available.
-.TP
-\fB\-\-linux\-onefile\-compression\fR=\fI\,COMPRESSION\/\fR
-Compression method to use for Linux onefile builds.
-Defaults to gzip for faster decompression
 .IP
 Plugin control:
 .TP
diff -pruN 0.9.5+ds-1/MANIFEST.in 1.0.1+ds-1/MANIFEST.in
--- 0.9.5+ds-1/MANIFEST.in	2022-05-20 16:47:11.000000000 +0000
+++ 1.0.1+ds-1/MANIFEST.in	2022-07-30 17:47:39.000000000 +0000
@@ -47,4 +47,4 @@ recursive-include tests/reflected *.py
 recursive-include tests/plugins *.py
 
 # C templates for code generation.
-recursive-include nuitka/codegen/templates_c *.j2
+recursive-include nuitka/code_generation/templates_c *.j2
diff -pruN 0.9.5+ds-1/misc/nuitka.bat 1.0.1+ds-1/misc/nuitka.bat
--- 0.9.5+ds-1/misc/nuitka.bat	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/misc/nuitka.bat	2022-07-30 17:47:39.000000000 +0000
@@ -21,8 +21,10 @@ setlocal
 
 if exist "%~dp0..\python.exe" (
 "%~dp0..\python" -m nuitka %*
-) else (
+) else if exist "%~dp0python.exe" (
 "%~dp0python" -m nuitka %*
+) else (
+"python" -m nuitka %*
 )
 
 endlocal
diff -pruN 0.9.5+ds-1/nuitka/build/Backend.scons 1.0.1+ds-1/nuitka/build/Backend.scons
--- 0.9.5+ds-1/nuitka/build/Backend.scons	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/Backend.scons	2022-07-30 17:47:39.000000000 +0000
@@ -78,7 +78,6 @@ from .SconsProgress import enableSconsPr
 from .SconsSpawn import enableSpawnMonitoring
 from .SconsUtils import (
     addClangClPathFromMSVC,
-    addToPATH,
     changeKeyboardInterruptToErrorExit,
     createDefinitionsFile,
     createEnvironment,
@@ -92,6 +91,7 @@ from .SconsUtils import (
     initScons,
     isClangName,
     isGccName,
+    prepareEnvironment,
     provideStaticSourceFile,
     raiseNoCompilerFoundErrorExit,
     scanSourceDir,
@@ -156,6 +156,9 @@ nuitka_python = getArgumentBool("nuitka_
 # The Debian Python, for which we know that some optimization can be done.
 debian_python = getArgumentBool("debian_python", False)
 
+# The Fedora Python, for which we know that some optimization can be done.
+fedora_python = getArgumentBool("fedora_python", False)
+
 # For the msys2 python, we can know a few things, it's not Win32 entirely.
 msys2_mingw_python = getArgumentBool("msys2_mingw_python", False)
 
@@ -305,44 +308,23 @@ macos_min_version = getArgumentDefaulted
 # Target arch for macOS.
 macos_target_arch = getArgumentDefaulted("macos_target_arch", "")
 
+# Anaconda Python might use its own compiler.
+anaconda_python = getArgumentBool("anaconda_python", False)
+
 if getArgumentBool("progress_bar", True) and not show_scons_mode:
     enableSconsProgressBar()
 
-
-def printCompilerVersionOutput(*args):
-    if compiler_version_mode or show_scons_mode:
-        my_print("Scons:", *args)
-
-
 # Amount of jobs to use.
 job_count = GetOption("num_jobs")
 
-# Add environment specified compilers to the PATH variable.
-if "CC" in os.environ:
-    os.environ["CC"] = os.path.normpath(os.environ["CC"])
-
-    if os.path.isdir(os.environ["CC"]):
-        scons_logger.sysexit(
-            "Error, the CC variable must point to file, not directory."
-        )
-
-    if os.path.sep in os.environ["CC"]:
-        cc_dirname = os.path.dirname(os.environ["CC"])
-        if os.path.isdir(cc_dirname):
-            addToPATH(None, cc_dirname, prefix=True)
-
-    if win_target and isGccName(os.path.basename(os.environ["CC"])):
-        scons_details_logger.info(
-            "Environment CC seems to be a gcc, enabling mingw_mode."
-        )
-        mingw_mode = True
-
-    printCompilerVersionOutput("CC=%r" % os.environ["CC"])
+# Prepare environment for compiler detection.
+mingw_mode = prepareEnvironment(
+    mingw_mode=mingw_mode, anaconda_python=anaconda_python, python_prefix=python_prefix
+)
 
 # Patch the compiler detection.
 Environment.Detect = getEnhancedToolDetect()
 
-
 # Create Scons environment, the main control tool. Don't include "mingw" on
 # Windows immediately, we will default to MSVC if available.
 env = createEnvironment(
@@ -359,7 +341,7 @@ scons_details_logger.info(
 
 if "CC" in os.environ:
     # If the environment variable CC is set, use that.
-    env["CC"] = os.path.expanduser(os.environ["CC"])
+    env["CC"] = os.environ["CC"]
     env["CCVERSION"] = None
 
     scons_details_logger.info("Overridden with environment CC: %r" % env["CC"])
@@ -396,7 +378,7 @@ env.macos_min_version = macos_min_versio
 env.macos_target_arch = macos_target_arch
 
 # Various flavors could influence builds.
-env.anaconda_python = getArgumentBool("anaconda_python", False)
+env.anaconda_python = anaconda_python
 env.pyenv_python = getArgumentBool("pyenv_python", False)
 env.apple_python = getArgumentBool("pyenv_python", False)
 
@@ -418,8 +400,10 @@ env.clangcl_mode = clangcl_mode
 # Python specific modes have to influence some decisions
 env.nuitka_python = nuitka_python
 env.debian_python = debian_python
+env.fedora_python = fedora_python
 env.msys2_mingw_python = msys2_mingw_python
 env.static_libpython = static_libpython
+env.python_version = python_version
 
 # Consider switching from gcc to its g++ compiler as a workaround that makes us work without C11.
 switchFromGccToGpp(
@@ -573,13 +557,13 @@ if static_libpython:
     env.Append(CPPDEFINES=["Py_NO_ENABLE_SHARED"])
 
 
-def detectHostMultiarch():
+def detectHostMultiArch():
     stdout = check_output("dpkg-architecture")
 
     for line in stdout.splitlines():
         line = line.strip()
 
-        if line.startswith(b"DEB_HOST_MULTIARCH="):
+        if line.startswith(b"DEB_HOST_MULTI_ARCH="):
             return line.split("=", 1)[1].decode("utf8")
 
     return None
@@ -589,14 +573,14 @@ if env.gcc_mode and debian_python:
     # TODO: Seems rather meaningless nowadays and hard codes this to not be
     # self compiled or so.
     if python_version == (3, 3):
-        host_multiarch = detectHostMultiarch()
+        host_multi_arch = detectHostMultiArch()
 
-        if host_multiarch is not None:
+        if host_multi_arch is not None:
             env.Append(
                 CCFLAGS=[
                     "-I"
                     + os.path.join(
-                        "/usr/include/", host_multiarch, "python" + python_abi_version
+                        "/usr/include/", host_multi_arch, "python" + python_abi_version
                     )
                 ]
             )
@@ -641,7 +625,7 @@ def _detectPythonHeaderPath():
 
     if win_target:
         scons_logger.sysexit(
-            """Error, you seem to be using the unsupported embedable CPython distribution."""
+            """Error, you seem to be using the unsupported embeddable CPython distribution."""
         )
     else:
         scons_logger.sysexit(
@@ -730,33 +714,22 @@ elif not module_mode:
     python_lib_path = os.path.join(python_prefix, "lib")
     env.Append(LIBPATH=[python_lib_path])
 
-    if nuitka_python and "pgo-link" in experimental:
-        # With Nuitka-Python, we do not use the static link library actually, but
-        # instead we link against the object files, as otherwise gcc doesn't seem
-        # to want to pick the profiling information up. TODO: This is not showing
-        # any benefit over plain LTO yet.
-        pgo_dir = os.path.join(python_prefix, "lib/pgo")
-
-        env.Append(LINKFLAGS=["-fprofile-dir=%s" % pgo_dir])
-        env.Append(LINKFLAGS=["-fprofile-correction"])
-
-        for filename in check_output(["ar", "t", static_libpython]).splitlines():
-            filename = os.path.join(pgo_dir, filename)
-
-            if not filename.endswith(".o"):
-                continue
-
-            if os.path.basename(filename) in ("main.o", "python.o"):
-                continue
-
-            gcda_filename = filename[:-2] + ".gcda"
-
-            if os.path.exists(gcda_filename):
-                env.Append(
-                    LINKFLAGS=["-fprofile-use=%s" % os.path.basename(gcda_filename)]
-                )
-
-            env.Append(LIBS=[env.File(filename)])
+    if nuitka_python:
+        link_data = loadJsonFromFilename(os.path.join(python_prefix, "link.json"))
+        for lib in link_data["libraries"]:
+            # Need to prevent Scons from stripping .a from the passed in libs.
+            if os.path.isfile(lib):
+                env.Append(_LIBFLAGS=[lib])
+            elif lib.startswith(":") and lib.endswith(".a"):
+                env.Append(_LIBFLAGS=["-l" + lib])
+            else:
+                env.Append(LIBS=[lib])
+        env.Append(LIBPATH=link_data["library_dirs"])
+        for define, value in link_data["macros"]:
+            if value:
+                env.Append(CPPDEFINES=[define + "=" + value])
+            else:
+                env.Append(CPPDEFINES=[define])
     elif static_libpython:
         env.Append(LIBS=[env.File(static_libpython)])
 
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/allocator.h 1.0.1+ds-1/nuitka/build/include/nuitka/allocator.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/allocator.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/allocator.h	2022-07-30 17:47:39.000000000 +0000
@@ -27,7 +27,7 @@ NUITKA_MAY_BE_UNUSED static void *Nuitka
 
     Py_TYPE(op) = tp;
     Py_SIZE(op) = size;
-    Py_REFCNT(op) = 1;
+    Py_SET_REFCNT(op, 1);
 
     // TODO: Above assignments might replace this actually.
     op = PyObject_INIT_VAR(op, tp, nitems);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/calling.h 1.0.1+ds-1/nuitka/build/include/nuitka/calling.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/calling.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/calling.h	2022-07-30 17:47:39.000000000 +0000
@@ -94,6 +94,9 @@ NUITKA_MAY_BE_UNUSED static PyObject *CA
     return CALL_FUNCTION(function_object, const_tuple_empty, named_args);
 }
 
+// Call built-in functions with using defaulted values.
+extern PyObject *CALL_BUILTIN_KW_ARGS(PyObject *callable, PyObject **args, char const **arg_names, int max_args);
+
 #include "nuitka/helper/calling2.h"
 
 // For exception test formatting and call code mostly.
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_eq.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_eq.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_eq.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_eq.h	2022-07-30 17:47:39.000000000 +0000
@@ -28,9 +28,6 @@
 extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
@@ -39,31 +36,11 @@ extern PyObject *RICH_COMPARE_EQ_OBJECT_
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
 #endif
@@ -74,28 +51,21 @@ extern bool RICH_COMPARE_EQ_CBOOL_STR_ST
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
+#endif
 
 /* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
  * Python3 'str'. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
@@ -104,18 +74,15 @@ extern PyObject *RICH_COMPARE_EQ_OBJECT_
  * Python3 'str'. */
 extern bool RICH_COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -124,16 +91,6 @@ extern PyObject *RICH_COMPARE_EQ_OBJECT_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
@@ -144,33 +101,33 @@ extern bool RICH_COMPARE_EQ_CBOOL_BYTES_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_EQ_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_EQ_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -180,18 +137,14 @@ extern nuitka_bool RICH_COMPARE_EQ_NBOOL
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
@@ -199,26 +152,17 @@ extern PyObject *RICH_COMPARE_EQ_OBJECT_
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern bool RICH_COMPARE_EQ_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
 extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
@@ -226,77 +170,78 @@ extern PyObject *RICH_COMPARE_EQ_OBJECT_
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern bool RICH_COMPARE_EQ_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
 extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_EQ_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern PyObject *RICH_COMPARE_EQ_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_EQ_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_EQ_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_EQ_CBOOL_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_EQ_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool RICH_COMPARE_EQ_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_ge.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_ge.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_ge.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_ge.h	2022-07-30 17:47:39.000000000 +0000
@@ -28,9 +28,6 @@
 extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
@@ -39,23 +36,13 @@ extern PyObject *RICH_COMPARE_GE_OBJECT_
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -63,59 +50,21 @@ extern bool RICH_COMPARE_GE_CBOOL_STR_OB
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_GE_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern bool RICH_COMPARE_GE_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -124,8 +73,8 @@ extern PyObject *RICH_COMPARE_GE_OBJECT_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -133,59 +82,19 @@ extern bool RICH_COMPARE_GE_CBOOL_BYTES_
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_GE_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_GE_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -193,110 +102,96 @@ extern bool RICH_COMPARE_GE_CBOOL_INT_OB
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_GE_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_GE_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_GE_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern PyObject *RICH_COMPARE_GE_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_GE_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_GE_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern nuitka_bool RICH_COMPARE_GE_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_GE_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_GE_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_GE_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_GE_CBOOL_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GE_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_GE_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_GE_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool RICH_COMPARE_GE_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_gt.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_gt.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_gt.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_gt.h	2022-07-30 17:47:39.000000000 +0000
@@ -28,9 +28,6 @@
 extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
@@ -39,23 +36,13 @@ extern PyObject *RICH_COMPARE_GT_OBJECT_
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -63,59 +50,21 @@ extern bool RICH_COMPARE_GT_CBOOL_STR_OB
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_GT_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern bool RICH_COMPARE_GT_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -124,8 +73,8 @@ extern PyObject *RICH_COMPARE_GT_OBJECT_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -133,59 +82,19 @@ extern bool RICH_COMPARE_GT_CBOOL_BYTES_
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_GT_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_GT_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -193,110 +102,96 @@ extern bool RICH_COMPARE_GT_CBOOL_INT_OB
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_GT_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_GT_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_GT_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern PyObject *RICH_COMPARE_GT_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_GT_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_GT_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern nuitka_bool RICH_COMPARE_GT_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_GT_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_GT_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_GT_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_GT_CBOOL_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_GT_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_GT_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_GT_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool RICH_COMPARE_GT_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_le.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_le.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_le.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_le.h	2022-07-30 17:47:39.000000000 +0000
@@ -28,9 +28,6 @@
 extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
@@ -39,31 +36,11 @@ extern PyObject *RICH_COMPARE_LE_OBJECT_
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
 #endif
@@ -74,28 +51,21 @@ extern bool RICH_COMPARE_LE_CBOOL_STR_ST
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
+#endif
 
 /* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
  * Python3 'str'. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
@@ -104,18 +74,15 @@ extern PyObject *RICH_COMPARE_LE_OBJECT_
  * Python3 'str'. */
 extern bool RICH_COMPARE_LE_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -124,16 +91,6 @@ extern PyObject *RICH_COMPARE_LE_OBJECT_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
@@ -144,33 +101,33 @@ extern bool RICH_COMPARE_LE_CBOOL_BYTES_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_LE_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_LE_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -180,18 +137,14 @@ extern nuitka_bool RICH_COMPARE_LE_NBOOL
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
@@ -199,26 +152,17 @@ extern PyObject *RICH_COMPARE_LE_OBJECT_
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern bool RICH_COMPARE_LE_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
 extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
@@ -226,77 +170,78 @@ extern PyObject *RICH_COMPARE_LE_OBJECT_
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern bool RICH_COMPARE_LE_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
 extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_LE_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_LE_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern PyObject *RICH_COMPARE_LE_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_LE_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LE_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern nuitka_bool RICH_COMPARE_LE_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_LE_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_LE_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LE_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_LE_CBOOL_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LE_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LE_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_LE_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool RICH_COMPARE_LE_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_lt.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_lt.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_lt.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_lt.h	2022-07-30 17:47:39.000000000 +0000
@@ -28,9 +28,6 @@
 extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
@@ -39,31 +36,11 @@ extern PyObject *RICH_COMPARE_LT_OBJECT_
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
 #endif
@@ -74,28 +51,21 @@ extern bool RICH_COMPARE_LT_CBOOL_STR_ST
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
+#endif
 
 /* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
  * Python3 'str'. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
@@ -104,18 +74,15 @@ extern PyObject *RICH_COMPARE_LT_OBJECT_
  * Python3 'str'. */
 extern bool RICH_COMPARE_LT_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -124,16 +91,6 @@ extern PyObject *RICH_COMPARE_LT_OBJECT_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
@@ -144,33 +101,33 @@ extern bool RICH_COMPARE_LT_CBOOL_BYTES_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_LT_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_LT_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -180,18 +137,14 @@ extern nuitka_bool RICH_COMPARE_LT_NBOOL
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
@@ -199,26 +152,17 @@ extern PyObject *RICH_COMPARE_LT_OBJECT_
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern bool RICH_COMPARE_LT_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
 extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
@@ -226,77 +170,78 @@ extern PyObject *RICH_COMPARE_LT_OBJECT_
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern bool RICH_COMPARE_LT_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
 extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_LT_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_LT_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern PyObject *RICH_COMPARE_LT_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_LT_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_LT_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern nuitka_bool RICH_COMPARE_LT_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_LT_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_LT_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_LT_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_LT_CBOOL_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_LT_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_LT_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_LT_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool RICH_COMPARE_LT_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_ne.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_ne.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/comparisons_ne.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/comparisons_ne.h	2022-07-30 17:47:39.000000000 +0000
@@ -28,9 +28,6 @@
 extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
@@ -39,23 +36,13 @@ extern PyObject *RICH_COMPARE_NE_OBJECT_
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -63,59 +50,21 @@ extern bool RICH_COMPARE_NE_CBOOL_STR_OB
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern bool RICH_COMPARE_NE_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern bool RICH_COMPARE_NE_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2);
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
+extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -124,8 +73,8 @@ extern PyObject *RICH_COMPARE_NE_OBJECT_
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -133,59 +82,19 @@ extern bool RICH_COMPARE_NE_CBOOL_BYTES_
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern bool RICH_COMPARE_NE_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_NE_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -193,110 +102,96 @@ extern bool RICH_COMPARE_NE_CBOOL_INT_OB
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_NE_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_NE_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_NE_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern PyObject *RICH_COMPARE_NE_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_NE_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern nuitka_bool RICH_COMPARE_NE_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
 extern nuitka_bool RICH_COMPARE_NE_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool RICH_COMPARE_NE_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool RICH_COMPARE_NE_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern PyObject *RICH_COMPARE_NE_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_NE_CBOOL_INT_CLONG(PyObject *operand1, long operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool RICH_COMPARE_NE_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern nuitka_bool RICH_COMPARE_NE_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_NE_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool RICH_COMPARE_NE_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/dictionaries.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/dictionaries.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/dictionaries.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/dictionaries.h	2022-07-30 17:47:39.000000000 +0000
@@ -179,8 +179,10 @@ static Nuitka_DictEntryHandle GET_STRING
 
     if (value == NULL) {
         return NULL;
+#ifndef PY_NOGIL
     } else if (_PyDict_HasSplitTable(dict)) {
         return &dict->ma_values[ix];
+#endif
     } else {
         return &DK_ENTRIES(dict->ma_keys)[ix].me_value;
     }
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/import_hard.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/import_hard.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/import_hard.h	2022-07-03 16:06:12.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/import_hard.h	2022-07-30 17:47:39.000000000 +0000
@@ -35,6 +35,15 @@ extern PyObject *IMPORT_HARD__FROZEN_IMP
 extern PyObject *IMPORT_HARD__FROZEN_IMPORTLIB_EXTERNAL(void);
 #endif
 
+/* C helper for hard import of module "ctypes" import. */
+extern PyObject *IMPORT_HARD_CTYPES(void);
+
+/* C helper for hard import of module "ctypes.macholib" import. */
+extern PyObject *IMPORT_HARD_CTYPES__MACHOLIB(void);
+
+/* C helper for hard import of module "ctypes.wintypes" import. */
+extern PyObject *IMPORT_HARD_CTYPES__WINTYPES(void);
+
 /* C helper for hard import of module "functools" import. */
 extern PyObject *IMPORT_HARD_FUNCTOOLS(void);
 
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/iterators.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/iterators.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/iterators.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/iterators.h	2022-07-30 17:47:39.000000000 +0000
@@ -94,6 +94,10 @@ NUITKA_MAY_BE_UNUSED static PyObject *MA
 NUITKA_MAY_BE_UNUSED static PyObject *MAKE_ITERATOR(PyObject *iterated) {
     CHECK_OBJECT(iterated);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_ITERATOR_OPT
+    return PyObject_GetIter(iterated);
+#else
+
 #if PYTHON_VERSION < 0x300
     getiterfunc tp_iter = NULL;
     if (PyType_HasFeature(Py_TYPE(iterated), Py_TPFLAGS_HAVE_ITER)) {
@@ -133,6 +137,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *MA
 
         return NULL;
     }
+#endif
 }
 
 #if PYTHON_VERSION >= 0x370
@@ -179,6 +184,9 @@ NUITKA_MAY_BE_UNUSED static PyObject *MA
 NUITKA_MAY_BE_UNUSED static PyObject *ITERATOR_NEXT(PyObject *iterator) {
     CHECK_OBJECT(iterator);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_ITERATOR_OPT
+    return PyIter_Next(iterator);
+#else
     iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
 
     if (unlikely(iternext == NULL)) {
@@ -198,6 +206,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *IT
     CHECK_OBJECT_X(result);
 
     return result;
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED static PyObject *BUILTIN_NEXT1(PyObject *iterator) {
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_add.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_add.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_add.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_add.h	2022-07-30 17:47:39.000000000 +0000
@@ -90,6 +90,56 @@ extern nuitka_bool BINARY_OPERATION_ADD_
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_INT_CLONG(PyObject *operand1, long operand2);
+#endif
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
 extern PyObject *BINARY_OPERATION_ADD_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2);
@@ -158,57 +208,10 @@ extern nuitka_bool BINARY_OPERATION_ADD_
 extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_ADD_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_ADD_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_ADD_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_ADD_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "STR" to Python2 'str'. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_UNICODE_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_ADD_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_ADD_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
-
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "UNICODE" to Python2 'unicode', Python3 'str'. */
 extern PyObject *BINARY_OPERATION_ADD_OBJECT_STR_UNICODE(PyObject *operand1, PyObject *operand2);
@@ -216,7 +219,7 @@ extern PyObject *BINARY_OPERATION_ADD_OB
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "STR" to Python2 'str'. */
-extern PyObject *BINARY_OPERATION_ADD_OBJECT_UNICODE_STR(PyObject *operand1, PyObject *operand2);
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_UNICODE_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -224,11 +227,6 @@ extern PyObject *BINARY_OPERATION_ADD_OB
 extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_STR_UNICODE(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "STR" to Python2 'str'. */
-extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_UNICODE_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_ADD_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitand.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitand.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitand.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitand.h	2022-07-30 17:47:39.000000000 +0000
@@ -73,18 +73,18 @@ extern nuitka_bool BINARY_OPERATION_BITA
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_BITAND_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_BITAND_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_BITAND_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern nuitka_bool BINARY_OPERATION_BITAND_NBOOL_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_BITAND_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_BITAND_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitor.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitor.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitor.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitor.h	2022-07-30 17:47:39.000000000 +0000
@@ -73,18 +73,18 @@ extern nuitka_bool BINARY_OPERATION_BITO
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_BITOR_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_BITOR_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_BITOR_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern nuitka_bool BINARY_OPERATION_BITOR_NBOOL_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_BITOR_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_BITOR_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitxor.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitxor.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitxor.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_bitxor.h	2022-07-30 17:47:39.000000000 +0000
@@ -73,18 +73,18 @@ extern nuitka_bool BINARY_OPERATION_BITX
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_BITXOR_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_BITXOR_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_BITXOR_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern nuitka_bool BINARY_OPERATION_BITXOR_NBOOL_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_BITXOR_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_BITXOR_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_divmod.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_divmod.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_divmod.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_divmod.h	2022-07-30 17:47:39.000000000 +0000
@@ -57,5 +57,47 @@ extern PyObject *BINARY_OPERATION_DIVMOD
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_CLONG_INT(long operand1, PyObject *operand2);
+#endif
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "CFLOAT" corresponds to C platform float value and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_CFLOAT_FLOAT(double operand1, PyObject *operand2);
+
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_floordiv.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_floordiv.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_floordiv.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_floordiv.h	2022-07-30 17:47:39.000000000 +0000
@@ -39,21 +39,6 @@ extern PyObject *BINARY_OPERATION_FLOORD
 extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
 
@@ -63,15 +48,6 @@ extern PyObject *BINARY_OPERATION_FLOORD
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 
@@ -81,69 +57,47 @@ extern PyObject *BINARY_OPERATION_FLOORD
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_CLONG_INT(long operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CFLOAT" corresponds to C platform float value and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_CFLOAT_FLOAT(double operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_FLOORDIV_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_FLOORDIV_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_lshift.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_lshift.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_lshift.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_lshift.h	2022-07-30 17:47:39.000000000 +0000
@@ -73,18 +73,13 @@ extern nuitka_bool BINARY_OPERATION_LSHI
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_LSHIFT_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
 extern PyObject *BINARY_OPERATION_LSHIFT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_LSHIFT_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_LSHIFT_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -92,6 +87,11 @@ extern nuitka_bool BINARY_OPERATION_LSHI
 extern nuitka_bool BINARY_OPERATION_LSHIFT_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool BINARY_OPERATION_LSHIFT_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+#endif
+
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_LSHIFT_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mod.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mod.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mod.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mod.h	2022-07-30 17:47:39.000000000 +0000
@@ -90,9 +90,36 @@ extern nuitka_bool BINARY_OPERATION_MOD_
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -102,7 +129,7 @@ extern PyObject *BINARY_OPERATION_MOD_OB
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -111,36 +138,41 @@ extern nuitka_bool BINARY_OPERATION_MOD_
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_CLONG_INT(long operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_CLONG_INT(long operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CFLOAT" corresponds to C platform float value and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_CFLOAT_FLOAT(double operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
+
+/* Code referring to "CFLOAT" corresponds to C platform float value and "FLOAT" to Python 'float'. */
+extern nuitka_bool BINARY_OPERATION_MOD_NBOOL_CFLOAT_FLOAT(double operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "INT" to Python2 'int'. */
@@ -226,11 +258,6 @@ extern PyObject *BINARY_OPERATION_MOD_OB
 extern PyObject *BINARY_OPERATION_MOD_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *BINARY_OPERATION_MOD_OBJECT_BYTES_LONG(PyObject *operand1, PyObject *operand2);
 #endif
@@ -241,6 +268,11 @@ extern PyObject *BINARY_OPERATION_MOD_OB
 #endif
 
 #if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
+extern PyObject *BINARY_OPERATION_MOD_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "UNICODE" to Python2 'unicode', Python3 'str'. */
 extern PyObject *BINARY_OPERATION_MOD_OBJECT_BYTES_UNICODE(PyObject *operand1, PyObject *operand2);
 #endif
@@ -265,28 +297,6 @@ extern PyObject *BINARY_OPERATION_MOD_OB
 extern PyObject *BINARY_OPERATION_MOD_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
-
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "DICT" to Python 'dict'. */
-extern PyObject *BINARY_OPERATION_MOD_OBJECT_OBJECT_DICT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_MOD_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mult.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mult.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mult.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_mult.h	2022-07-30 17:47:39.000000000 +0000
@@ -90,58 +90,56 @@ extern nuitka_bool BINARY_OPERATION_MULT
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "CLONG" corresponds to C platform long value and "CLONG" to C platform long value. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_CLONG_CLONG(long operand1, long operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
-#endif
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_CLONG_INT(long operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "STR" to Python2 'str'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_STR(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_STR_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "STR" to Python2 'str'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_STR(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_STR_LONG(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "STR" corresponds to Python2 'str' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_STR_INT(PyObject *operand1, PyObject *operand2);
+#endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_UNICODE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "STR" to Python2 'str'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -149,23 +147,9 @@ extern PyObject *BINARY_OPERATION_MULT_O
 extern PyObject *BINARY_OPERATION_MULT_OBJECT_UNICODE_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "UNICODE" to Python2 'unicode', Python3
- * 'str'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_UNICODE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "LONG" to Python2 'long', Python3
- * 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_UNICODE_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
-
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "TUPLE" to Python 'tuple'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_TUPLE(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_UNICODE(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -173,21 +157,9 @@ extern PyObject *BINARY_OPERATION_MULT_O
 extern PyObject *BINARY_OPERATION_MULT_OBJECT_TUPLE_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "TUPLE" to Python 'tuple'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_TUPLE(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_TUPLE_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
-
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LIST" to Python 'list'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_LIST(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "TUPLE" to Python 'tuple'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_TUPLE(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -195,20 +167,22 @@ extern PyObject *BINARY_OPERATION_MULT_O
 extern PyObject *BINARY_OPERATION_MULT_OBJECT_LIST_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LIST" to Python 'list'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_LIST(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LIST" to Python 'list'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_LIST(PyObject *operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LIST_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "LONG" to Python2 'long', Python3
+ * 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_UNICODE_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "UNICODE" to Python2 'unicode', Python3
+ * 'str'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_UNICODE(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_BYTES_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
@@ -216,62 +190,55 @@ extern PyObject *BINARY_OPERATION_MULT_O
 extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_BYTES_LONG(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_TUPLE_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "TUPLE" to Python 'tuple'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_TUPLE(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LIST" corresponds to Python 'list' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_LIST_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LIST" to Python 'list'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_LIST(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2);
+
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_MULT_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_MULT_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern PyObject *BINARY_OPERATION_MULT_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_MULT_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_olddiv.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_olddiv.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_olddiv.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_olddiv.h	2022-07-30 17:47:39.000000000 +0000
@@ -40,21 +40,6 @@ extern PyObject *BINARY_OPERATION_OLDDIV
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
 #endif
@@ -70,21 +55,6 @@ extern PyObject *BINARY_OPERATION_OLDDIV
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
@@ -100,23 +70,23 @@ extern PyObject *BINARY_OPERATION_OLDDIV
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -126,60 +96,30 @@ extern PyObject *BINARY_OPERATION_OLDDIV
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_CLONG_INT(long operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CFLOAT" corresponds to C platform float value and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_CFLOAT_FLOAT(double operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_OLDDIV_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_OLDDIV_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_pow.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_pow.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_pow.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_pow.h	2022-07-30 17:47:39.000000000 +0000
@@ -27,77 +27,55 @@
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
-
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_POW_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_POW_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_POW_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_POW_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_POW_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_POW_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -105,11 +83,6 @@ extern nuitka_bool BINARY_OPERATION_POW_
 extern PyObject *BINARY_OPERATION_POW_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_POW_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_POW_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_rshift.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_rshift.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_rshift.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_rshift.h	2022-07-30 17:47:39.000000000 +0000
@@ -73,18 +73,13 @@ extern nuitka_bool BINARY_OPERATION_RSHI
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_RSHIFT_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
 extern PyObject *BINARY_OPERATION_RSHIFT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_RSHIFT_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
@@ -92,6 +87,11 @@ extern nuitka_bool BINARY_OPERATION_RSHI
 extern nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+#endif
+
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
 
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_sub.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_sub.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_sub.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_sub.h	2022-07-30 17:47:39.000000000 +0000
@@ -39,21 +39,6 @@ extern PyObject *BINARY_OPERATION_SUB_OB
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
 
@@ -63,15 +48,6 @@ extern PyObject *BINARY_OPERATION_SUB_OB
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 
@@ -81,69 +57,55 @@ extern PyObject *BINARY_OPERATION_SUB_OB
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_SUB_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_SUB_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_CLONG_INT(long operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "DIGIT" corresponds to C platform digit value for long Python objects and "LONG" to Python2 'long',
+ * Python3 'int'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_DIGIT_LONG(long operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CFLOAT" corresponds to C platform float value and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_CFLOAT_FLOAT(double operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_SUB_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_truediv.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_truediv.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_binary_truediv.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_binary_truediv.h	2022-07-30 17:47:39.000000000 +0000
@@ -39,21 +39,6 @@ extern PyObject *BINARY_OPERATION_TRUEDI
 extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2);
-#endif
-
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
 extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2);
 
@@ -63,15 +48,6 @@ extern PyObject *BINARY_OPERATION_TRUEDI
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2);
-
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
 extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
 
@@ -81,69 +57,47 @@ extern PyObject *BINARY_OPERATION_TRUEDI
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_INT_FLOAT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_INT_CLONG(PyObject *operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_FLOAT_INT(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CLONG" corresponds to C platform long value and "INT" to Python2 'int'. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_CLONG_INT(long operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_LONG_FLOAT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_FLOAT_LONG(PyObject *operand1, PyObject *operand2);
+/* Code referring to "CFLOAT" corresponds to C platform float value and "FLOAT" to Python 'float'. */
+extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_CFLOAT_FLOAT(double operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 extern PyObject *BINARY_OPERATION_TRUEDIV_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern nuitka_bool BINARY_OPERATION_TRUEDIV_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_builtin_types.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_builtin_types.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_builtin_types.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_builtin_types.h	2022-07-30 17:47:39.000000000 +0000
@@ -27,10 +27,13 @@ extern PyObject *str_builtin_format;
 extern PyObject *unicode_builtin_format;
 extern PyObject *DICT_POP2(PyObject *dict, PyObject *key);
 extern PyObject *DICT_POP3(PyObject *dict, PyObject *key, PyObject *default_value);
+extern PyObject *DICT_POPITEM(PyObject *dict);
 extern PyObject *DICT_SETDEFAULT2(PyObject *dict, PyObject *key);
 extern PyObject *DICT_SETDEFAULT3(PyObject *dict, PyObject *key, PyObject *default_value);
 #if PYTHON_VERSION < 0x300
 extern PyObject *STR_CAPITALIZE(PyObject *str);
+extern PyObject *STR_CENTER2(PyObject *str, PyObject *width);
+extern PyObject *STR_CENTER3(PyObject *str, PyObject *width, PyObject *fillchar);
 extern PyObject *STR_COUNT2(PyObject *str, PyObject *sub);
 extern PyObject *STR_COUNT3(PyObject *str, PyObject *sub, PyObject *start);
 extern PyObject *STR_COUNT4(PyObject *str, PyObject *sub, PyObject *start, PyObject *end);
@@ -43,6 +46,8 @@ extern PyObject *STR_ENCODE3(PyObject *s
 extern PyObject *STR_ENDSWITH2(PyObject *str, PyObject *suffix);
 extern PyObject *STR_ENDSWITH3(PyObject *str, PyObject *suffix, PyObject *start);
 extern PyObject *STR_ENDSWITH4(PyObject *str, PyObject *suffix, PyObject *start, PyObject *end);
+extern PyObject *STR_EXPANDTABS1(PyObject *str);
+extern PyObject *STR_EXPANDTABS2(PyObject *str, PyObject *tabsize);
 extern PyObject *STR_FIND2(PyObject *str, PyObject *sub);
 extern PyObject *STR_FIND3(PyObject *str, PyObject *sub, PyObject *start);
 extern PyObject *STR_FIND4(PyObject *str, PyObject *sub, PyObject *start, PyObject *end);
@@ -56,6 +61,8 @@ extern PyObject *STR_ISLOWER(PyObject *s
 extern PyObject *STR_ISSPACE(PyObject *str);
 extern PyObject *STR_ISTITLE(PyObject *str);
 extern PyObject *STR_ISUPPER(PyObject *str);
+extern PyObject *STR_LJUST2(PyObject *str, PyObject *width);
+extern PyObject *STR_LJUST3(PyObject *str, PyObject *width, PyObject *fillchar);
 extern PyObject *STR_LOWER(PyObject *str);
 extern PyObject *STR_LSTRIP1(PyObject *str);
 extern PyObject *STR_LSTRIP2(PyObject *str, PyObject *chars);
@@ -68,6 +75,8 @@ extern PyObject *STR_RFIND4(PyObject *st
 extern PyObject *STR_RINDEX2(PyObject *str, PyObject *sub);
 extern PyObject *STR_RINDEX3(PyObject *str, PyObject *sub, PyObject *start);
 extern PyObject *STR_RINDEX4(PyObject *str, PyObject *sub, PyObject *start, PyObject *end);
+extern PyObject *STR_RJUST2(PyObject *str, PyObject *width);
+extern PyObject *STR_RJUST3(PyObject *str, PyObject *width, PyObject *fillchar);
 extern PyObject *STR_RPARTITION(PyObject *str, PyObject *sep);
 extern PyObject *STR_RSPLIT1(PyObject *str);
 extern PyObject *STR_RSPLIT2(PyObject *str, PyObject *sep);
@@ -77,6 +86,8 @@ extern PyObject *STR_RSTRIP2(PyObject *s
 extern PyObject *STR_SPLIT1(PyObject *str);
 extern PyObject *STR_SPLIT2(PyObject *str, PyObject *sep);
 extern PyObject *STR_SPLIT3(PyObject *str, PyObject *sep, PyObject *maxsplit);
+extern PyObject *STR_SPLITLINES1(PyObject *str);
+extern PyObject *STR_SPLITLINES2(PyObject *str, PyObject *keepends);
 extern PyObject *STR_STARTSWITH2(PyObject *str, PyObject *prefix);
 extern PyObject *STR_STARTSWITH3(PyObject *str, PyObject *prefix, PyObject *start);
 extern PyObject *STR_STARTSWITH4(PyObject *str, PyObject *prefix, PyObject *start, PyObject *end);
@@ -84,9 +95,13 @@ extern PyObject *STR_STRIP1(PyObject *st
 extern PyObject *STR_STRIP2(PyObject *str, PyObject *chars);
 extern PyObject *STR_SWAPCASE(PyObject *str);
 extern PyObject *STR_TITLE(PyObject *str);
+extern PyObject *STR_TRANSLATE(PyObject *str, PyObject *table);
 extern PyObject *STR_UPPER(PyObject *str);
+extern PyObject *STR_ZFILL(PyObject *str, PyObject *width);
 #endif
 extern PyObject *UNICODE_CAPITALIZE(PyObject *unicode);
+extern PyObject *UNICODE_CENTER2(PyObject *unicode, PyObject *width);
+extern PyObject *UNICODE_CENTER3(PyObject *unicode, PyObject *width, PyObject *fillchar);
 extern PyObject *UNICODE_COUNT2(PyObject *unicode, PyObject *sub);
 extern PyObject *UNICODE_COUNT3(PyObject *unicode, PyObject *sub, PyObject *start);
 extern PyObject *UNICODE_COUNT4(PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end);
@@ -96,6 +111,8 @@ extern PyObject *UNICODE_ENCODE3(PyObjec
 extern PyObject *UNICODE_ENDSWITH2(PyObject *unicode, PyObject *suffix);
 extern PyObject *UNICODE_ENDSWITH3(PyObject *unicode, PyObject *suffix, PyObject *start);
 extern PyObject *UNICODE_ENDSWITH4(PyObject *unicode, PyObject *suffix, PyObject *start, PyObject *end);
+extern PyObject *UNICODE_EXPANDTABS1(PyObject *unicode);
+extern PyObject *UNICODE_EXPANDTABS2(PyObject *unicode, PyObject *tabsize);
 extern PyObject *UNICODE_FIND2(PyObject *unicode, PyObject *sub);
 extern PyObject *UNICODE_FIND3(PyObject *unicode, PyObject *sub, PyObject *start);
 extern PyObject *UNICODE_FIND4(PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end);
@@ -109,6 +126,8 @@ extern PyObject *UNICODE_ISLOWER(PyObjec
 extern PyObject *UNICODE_ISSPACE(PyObject *unicode);
 extern PyObject *UNICODE_ISTITLE(PyObject *unicode);
 extern PyObject *UNICODE_ISUPPER(PyObject *unicode);
+extern PyObject *UNICODE_LJUST2(PyObject *unicode, PyObject *width);
+extern PyObject *UNICODE_LJUST3(PyObject *unicode, PyObject *width, PyObject *fillchar);
 extern PyObject *UNICODE_LOWER(PyObject *unicode);
 extern PyObject *UNICODE_LSTRIP1(PyObject *unicode);
 extern PyObject *UNICODE_LSTRIP2(PyObject *unicode, PyObject *chars);
@@ -120,6 +139,8 @@ extern PyObject *UNICODE_RFIND4(PyObject
 extern PyObject *UNICODE_RINDEX2(PyObject *unicode, PyObject *sub);
 extern PyObject *UNICODE_RINDEX3(PyObject *unicode, PyObject *sub, PyObject *start);
 extern PyObject *UNICODE_RINDEX4(PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end);
+extern PyObject *UNICODE_RJUST2(PyObject *unicode, PyObject *width);
+extern PyObject *UNICODE_RJUST3(PyObject *unicode, PyObject *width, PyObject *fillchar);
 extern PyObject *UNICODE_RSPLIT1(PyObject *unicode);
 extern PyObject *UNICODE_RSPLIT2(PyObject *unicode, PyObject *sep);
 extern PyObject *UNICODE_RSPLIT3(PyObject *unicode, PyObject *sep, PyObject *maxsplit);
@@ -128,6 +149,8 @@ extern PyObject *UNICODE_RSTRIP2(PyObjec
 extern PyObject *UNICODE_SPLIT1(PyObject *unicode);
 extern PyObject *UNICODE_SPLIT2(PyObject *unicode, PyObject *sep);
 extern PyObject *UNICODE_SPLIT3(PyObject *unicode, PyObject *sep, PyObject *maxsplit);
+extern PyObject *UNICODE_SPLITLINES1(PyObject *unicode);
+extern PyObject *UNICODE_SPLITLINES2(PyObject *unicode, PyObject *keepends);
 extern PyObject *UNICODE_STARTSWITH2(PyObject *unicode, PyObject *prefix);
 extern PyObject *UNICODE_STARTSWITH3(PyObject *unicode, PyObject *prefix, PyObject *start);
 extern PyObject *UNICODE_STARTSWITH4(PyObject *unicode, PyObject *prefix, PyObject *start, PyObject *end);
@@ -135,7 +158,9 @@ extern PyObject *UNICODE_STRIP1(PyObject
 extern PyObject *UNICODE_STRIP2(PyObject *unicode, PyObject *chars);
 extern PyObject *UNICODE_SWAPCASE(PyObject *unicode);
 extern PyObject *UNICODE_TITLE(PyObject *unicode);
+extern PyObject *UNICODE_TRANSLATE(PyObject *unicode, PyObject *table);
 extern PyObject *UNICODE_UPPER(PyObject *unicode);
+extern PyObject *UNICODE_ZFILL(PyObject *unicode, PyObject *width);
 #if PYTHON_VERSION >= 0x300
 extern PyObject *BYTES_DECODE1(PyObject *bytes);
 extern PyObject *BYTES_DECODE2(PyObject *bytes, PyObject *encoding);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_add.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_add.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_add.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_add.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,133 +26,145 @@
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_ADD_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_ADD_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_ADD_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_ADD_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_ADD_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_ADD_FLOAT_INT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_ADD_INT_FLOAT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_ADD_LONG_INT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_ADD_INT_LONG(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_ADD_INT_CLONG(PyObject **operand1, long operand2);
+#endif
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool INPLACE_OPERATION_ADD_LONG_DIGIT(PyObject **operand1, long operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool INPLACE_OPERATION_ADD_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_ADD_STR_STR_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_STR_STR(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_STR_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_STR(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_STR_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_STR_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
  * Python3 'str'. */
-extern bool BINARY_OPERATION_ADD_UNICODE_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_UNICODE_UNICODE(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_UNICODE(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_UNICODE_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_UNICODE_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern bool BINARY_OPERATION_ADD_BYTES_BYTES_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_BYTES_BYTES(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_BYTES_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_BYTES(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_BYTES_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_BYTES_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_ADD_TUPLE_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_TUPLE_TUPLE(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_TUPLE(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_TUPLE_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_TUPLE_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_ADD_LIST_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_LIST_LIST(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_ADD_OBJECT_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_LIST(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_LIST_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_ADD_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_ADD_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
+extern bool INPLACE_OPERATION_ADD_LIST_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_ADD_INT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_ADD_FLOAT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "STR" to Python2 'str'. */
+extern bool INPLACE_OPERATION_ADD_UNICODE_STR(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_ADD_LONG_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_ADD_FLOAT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
-
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool BINARY_OPERATION_ADD_STR_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_ADD_UNICODE_STR_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_STR_UNICODE(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_ADD_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LIST" corresponds to Python 'list' and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_ADD_LIST_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_ADD_LIST_TUPLE(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitand.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitand.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitand.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitand.h	2022-07-30 17:47:39.000000000 +0000
@@ -25,47 +25,52 @@
 /* C helpers for type in-place "&" (BITAND) operations */
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITAND_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITAND_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITAND_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITAND_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITAND_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITAND_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITAND_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_BITAND_INT_CLONG(PyObject **operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITAND_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_LONG_INT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_BITAND_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "SET" corresponds to Python 'set' and "SET" to Python 'set'. */
-extern bool BINARY_OPERATION_BITAND_SET_SET_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_SET_SET(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "SET" to Python 'set'. */
-extern bool BINARY_OPERATION_BITAND_OBJECT_SET_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_OBJECT_SET(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "SET" corresponds to Python 'set' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITAND_SET_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_SET_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITAND_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITAND_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitor.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitor.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitor.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitor.h	2022-07-30 17:47:39.000000000 +0000
@@ -25,47 +25,52 @@
 /* C helpers for type in-place "|" (BITOR) operations */
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITOR_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITOR_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITOR_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITOR_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITOR_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITOR_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITOR_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_BITOR_INT_CLONG(PyObject **operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITOR_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_LONG_INT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_BITOR_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "SET" corresponds to Python 'set' and "SET" to Python 'set'. */
-extern bool BINARY_OPERATION_BITOR_SET_SET_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_SET_SET(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "SET" to Python 'set'. */
-extern bool BINARY_OPERATION_BITOR_OBJECT_SET_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_OBJECT_SET(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "SET" corresponds to Python 'set' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITOR_SET_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_SET_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITOR_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITOR_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitxor.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitxor.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitxor.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_bitxor.h	2022-07-30 17:47:39.000000000 +0000
@@ -25,47 +25,52 @@
 /* C helpers for type in-place "^" (BITXOR) operations */
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITXOR_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITXOR_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITXOR_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITXOR_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITXOR_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITXOR_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_BITXOR_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_BITXOR_INT_CLONG(PyObject **operand1, long operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_BITXOR_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_LONG_INT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_BITXOR_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "SET" corresponds to Python 'set' and "SET" to Python 'set'. */
-extern bool BINARY_OPERATION_BITXOR_SET_SET_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_SET_SET(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "SET" to Python 'set'. */
-extern bool BINARY_OPERATION_BITXOR_OBJECT_SET_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_OBJECT_SET(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "SET" corresponds to Python 'set' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITXOR_SET_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_SET_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_BITXOR_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_BITXOR_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_floordiv.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_floordiv.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_floordiv.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_floordiv.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,62 +26,70 @@
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_FLOORDIV_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_FLOORDIV_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_FLOORDIV_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_FLOORDIV_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_FLOORDIV_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_FLOORDIV_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_FLOORDIV_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_FLOORDIV_FLOAT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_FLOORDIV_INT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_FLOORDIV_INT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_FLOORDIV_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_FLOAT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_FLOORDIV_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_FLOORDIV_LONG_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_FLOORDIV_INT_CLONG(PyObject **operand1, long operand2);
+#endif
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_FLOORDIV_FLOAT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool INPLACE_OPERATION_FLOORDIV_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_FLOORDIV_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_FLOORDIV_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_lshift.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_lshift.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_lshift.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_lshift.h	2022-07-30 17:47:39.000000000 +0000
@@ -25,38 +25,38 @@
 /* C helpers for type in-place "<<" (LSHIFT) operations */
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_LSHIFT_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_LSHIFT_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_LSHIFT_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_LSHIFT_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_LSHIFT_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_LSHIFT_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_LSHIFT_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_LSHIFT_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_LSHIFT_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_LSHIFT_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_LSHIFT_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_LSHIFT_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_LSHIFT_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_LSHIFT_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_LSHIFT_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_LSHIFT_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_LSHIFT_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_LSHIFT_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_matmult.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_matmult.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_matmult.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_matmult.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,35 +26,35 @@
 
 #if PYTHON_VERSION >= 0x350
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MATMULT_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MATMULT_LONG_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x350
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MATMULT_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MATMULT_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x350
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MATMULT_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MATMULT_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x350
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MATMULT_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MATMULT_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x350
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MATMULT_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MATMULT_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x350
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MATMULT_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MATMULT_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x350
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MATMULT_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MATMULT_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mod.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mod.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mod.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mod.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,207 +26,193 @@
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MOD_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MOD_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MOD_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MOD_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MOD_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MOD_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MOD_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_MOD_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MOD_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_MOD_FLOAT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MOD_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_MOD_INT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MOD_INT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_MOD_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MOD_FLOAT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MOD_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MOD_LONG_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_MOD_INT_CLONG(PyObject **operand1, long operand2);
+#endif
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MOD_FLOAT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool INPLACE_OPERATION_MOD_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MOD_STR_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MOD_STR_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MOD_STR_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_MOD_STR_STR_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_STR(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool BINARY_OPERATION_MOD_STR_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_UNICODE(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_MOD_STR_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_TUPLE(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_MOD_STR_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_LIST(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "DICT" to Python 'dict'. */
-extern bool BINARY_OPERATION_MOD_STR_DICT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_DICT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MOD_STR_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_STR_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "LONG" to Python2 'long', Python3
  * 'int'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_FLOAT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_STR_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_STR(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "BYTES" to Python3 'bytes'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_BYTES_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_BYTES(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
  * Python3 'str'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_UNICODE(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_TUPLE(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_LIST(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "DICT" to Python 'dict'. */
-extern bool BINARY_OPERATION_MOD_UNICODE_DICT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_DICT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MOD_UNICODE_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_UNICODE_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-extern bool BINARY_OPERATION_MOD_BYTES_BYTES_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MOD_BYTES_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MOD_BYTES_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_MOD_BYTES_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MOD_BYTES_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
+extern bool INPLACE_OPERATION_MOD_BYTES_BYTES(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool BINARY_OPERATION_MOD_BYTES_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_BYTES_UNICODE(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_MOD_BYTES_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_BYTES_TUPLE(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_MOD_BYTES_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_BYTES_LIST(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "DICT" to Python 'dict'. */
-extern bool BINARY_OPERATION_MOD_BYTES_DICT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_BYTES_DICT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MOD_BYTES_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_STR_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
-
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_BYTES_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_BYTES_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "DICT" to Python 'dict'. */
-extern bool BINARY_OPERATION_MOD_OBJECT_DICT_INPLACE(PyObject **operand1, PyObject *operand2);
-
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MOD_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MOD_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mult.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mult.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mult.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_mult.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,180 +26,159 @@
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MULT_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_STR_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MULT_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_MULT_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_STR_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_MULT_FLOAT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_MULT_INT_STR_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_MULT_INT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_STR_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_MULT_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "STR" to Python2 'str'. */
-extern bool BINARY_OPERATION_MULT_LONG_STR_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MULT_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_STR_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_MULT_INT_CLONG(PyObject **operand1, long operand2);
 #endif
 
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool INPLACE_OPERATION_MULT_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_UNICODE_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "STR" corresponds to Python2 'str' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_MULT_STR_INT(PyObject **operand1, PyObject *operand2);
+#endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "UNICODE" to Python2 'unicode', Python3 'str'. */
-extern bool BINARY_OPERATION_MULT_INT_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "STR" to Python2 'str'. */
+extern bool INPLACE_OPERATION_MULT_INT_STR(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_UNICODE_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_UNICODE_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "UNICODE" to Python2 'unicode', Python3
- * 'str'. */
-extern bool BINARY_OPERATION_MULT_LONG_UNICODE_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "LONG" to Python2 'long', Python3
- * 'int'. */
-extern bool BINARY_OPERATION_MULT_UNICODE_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_TUPLE_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
-
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_MULT_INT_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "UNICODE" to Python2 'unicode', Python3 'str'. */
+extern bool INPLACE_OPERATION_MULT_INT_UNICODE(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "TUPLE" corresponds to Python 'tuple' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_TUPLE_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_TUPLE_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "TUPLE" to Python 'tuple'. */
-extern bool BINARY_OPERATION_MULT_LONG_TUPLE_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_TUPLE_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
-
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_LIST_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
-
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_MULT_INT_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "TUPLE" to Python 'tuple'. */
+extern bool INPLACE_OPERATION_MULT_INT_TUPLE(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LIST" corresponds to Python 'list' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_LIST_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_LIST_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LIST" to Python 'list'. */
-extern bool BINARY_OPERATION_MULT_LONG_LIST_INPLACE(PyObject **operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "LIST" to Python 'list'. */
+extern bool INPLACE_OPERATION_MULT_INT_LIST(PyObject **operand1, PyObject *operand2);
+#endif
 
-/* Code referring to "LIST" corresponds to Python 'list' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_LIST_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "LONG" to Python2 'long', Python3
+ * 'int'. */
+extern bool INPLACE_OPERATION_MULT_UNICODE_LONG(PyObject **operand1, PyObject *operand2);
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-extern bool BINARY_OPERATION_MULT_OBJECT_BYTES_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "UNICODE" to Python2 'unicode', Python3
+ * 'str'. */
+extern bool INPLACE_OPERATION_MULT_LONG_UNICODE(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_BYTES_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MULT_BYTES_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION >= 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "BYTES" to Python3 'bytes'. */
-extern bool BINARY_OPERATION_MULT_LONG_BYTES_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_LONG_BYTES(PyObject **operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_BYTES_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MULT_TUPLE_LONG(PyObject **operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "TUPLE" to Python 'tuple'. */
+extern bool INPLACE_OPERATION_MULT_LONG_TUPLE(PyObject **operand1, PyObject *operand2);
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
-#endif
+/* Code referring to "LIST" corresponds to Python 'list' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_MULT_LIST_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LIST" to Python 'list'. */
+extern bool INPLACE_OPERATION_MULT_LONG_LIST(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MULT_INT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+extern bool INPLACE_OPERATION_MULT_STR_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_MULT_FLOAT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
+extern bool INPLACE_OPERATION_MULT_UNICODE_OBJECT(PyObject **operand1, PyObject *operand2);
+
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
+extern bool INPLACE_OPERATION_MULT_BYTES_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_MULT_LONG_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+extern bool INPLACE_OPERATION_MULT_TUPLE_OBJECT(PyObject **operand1, PyObject *operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_MULT_FLOAT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
+extern bool INPLACE_OPERATION_MULT_LIST_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_MULT_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_MULT_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_olddiv.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_olddiv.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_olddiv.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_olddiv.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,80 +26,90 @@
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_OLDDIV_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_LONG_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_OLDDIV_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_OLDDIV_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_OLDDIV_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_OLDDIV_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_OLDDIV_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_OLDDIV_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_OLDDIV_FLOAT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_OLDDIV_INT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_INT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_FLOAT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_OLDDIV_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_OLDDIV_LONG_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_OLDDIV_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_OLDDIV_FLOAT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_OLDDIV_INT_CLONG(PyObject **operand1, long operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool INPLACE_OPERATION_OLDDIV_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_OLDDIV_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_OLDDIV_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_pow.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_pow.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_pow.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_pow.h	2022-07-30 17:47:39.000000000 +0000
@@ -25,47 +25,63 @@
 /* C helpers for type in-place "**" (POW) operations */
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_POW_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_POW_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_POW_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_POW_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_POW_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_POW_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_POW_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_POW_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_POW_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_INT_OBJECT(PyObject **operand1, PyObject *operand2);
+#endif
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_POW_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_POW_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_POW_FLOAT_INT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_POW_INT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_POW_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_POW_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_POW_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_POW_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_rshift.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_rshift.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_rshift.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_rshift.h	2022-07-30 17:47:39.000000000 +0000
@@ -25,38 +25,38 @@
 /* C helpers for type in-place ">>" (RSHIFT) operations */
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_RSHIFT_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_RSHIFT_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_RSHIFT_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_RSHIFT_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_RSHIFT_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_RSHIFT_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_RSHIFT_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_RSHIFT_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_RSHIFT_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_RSHIFT_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_RSHIFT_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_RSHIFT_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_RSHIFT_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_RSHIFT_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_RSHIFT_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_RSHIFT_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_RSHIFT_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_sub.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_sub.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_sub.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_sub.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,62 +26,74 @@
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_SUB_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_SUB_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_SUB_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_SUB_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_SUB_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_SUB_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_SUB_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_SUB_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_SUB_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_SUB_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_SUB_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_SUB_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_SUB_FLOAT_INT(PyObject **operand1, PyObject *operand2);
+#endif
+
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_SUB_INT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_SUB_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_SUB_INT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_SUB_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_SUB_FLOAT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_SUB_INT_CLONG(PyObject **operand1, long operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_SUB_LONG_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool INPLACE_OPERATION_SUB_LONG_DIGIT(PyObject **operand1, long operand2);
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_SUB_FLOAT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool INPLACE_OPERATION_SUB_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_SUB_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_SUB_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_truediv.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_truediv.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_truediv.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/operations_inplace_truediv.h	2022-07-30 17:47:39.000000000 +0000
@@ -26,62 +26,70 @@
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_INT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_INT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_OBJECT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_OBJECT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
 /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_TRUEDIV_INT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_INT_OBJECT(PyObject **operand1, PyObject *operand2);
 #endif
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_LONG_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_LONG_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_OBJECT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_OBJECT_LONG(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_TRUEDIV_LONG_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_LONG_OBJECT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_TRUEDIV_FLOAT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_FLOAT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_TRUEDIV_OBJECT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_OBJECT_FLOAT(PyObject **operand1, PyObject *operand2);
 
 /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_TRUEDIV_FLOAT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_FLOAT_OBJECT(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_TRUEDIV_FLOAT_LONG(PyObject **operand1, PyObject *operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_TRUEDIV_LONG_FLOAT(PyObject **operand1, PyObject *operand2);
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_INT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_TRUEDIV_FLOAT_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_LONG_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
+extern bool INPLACE_OPERATION_TRUEDIV_INT_FLOAT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_TRUEDIV_INT_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+extern bool INPLACE_OPERATION_TRUEDIV_LONG_INT(PyObject **operand1, PyObject *operand2);
 #endif
 
 #if PYTHON_VERSION < 0x300
-/* Code referring to "FLOAT" corresponds to Python 'float' and "INT" to Python2 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_FLOAT_INT_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
+extern bool INPLACE_OPERATION_TRUEDIV_INT_LONG(PyObject **operand1, PyObject *operand2);
 #endif
 
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "FLOAT" to Python 'float'. */
-extern bool BINARY_OPERATION_TRUEDIV_LONG_FLOAT_INPLACE(PyObject **operand1, PyObject *operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_TRUEDIV_INT_CLONG(PyObject **operand1, long operand2);
+#endif
 
-/* Code referring to "FLOAT" corresponds to Python 'float' and "LONG" to Python2 'long', Python3 'int'. */
-extern bool BINARY_OPERATION_TRUEDIV_FLOAT_LONG_INPLACE(PyObject **operand1, PyObject *operand2);
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+extern bool INPLACE_OPERATION_TRUEDIV_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-extern bool BINARY_OPERATION_TRUEDIV_OBJECT_OBJECT_INPLACE(PyObject **operand1, PyObject *operand2);
+extern bool INPLACE_OPERATION_TRUEDIV_OBJECT_OBJECT(PyObject **operand1, PyObject *operand2);
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/helper/subscripts.h 1.0.1+ds-1/nuitka/build/include/nuitka/helper/subscripts.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/helper/subscripts.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/helper/subscripts.h	2022-07-30 17:47:39.000000000 +0000
@@ -69,6 +69,9 @@ NUITKA_MAY_BE_UNUSED static PyObject *LO
     CHECK_OBJECT(source);
     CHECK_OBJECT(const_subscript);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_SUBSCRIPT_OPT
+    return PyObject_GetItem(source, const_subscript);
+#else
     PyTypeObject *type = Py_TYPE(source);
     PyMappingMethods *mapping_methods = type->tp_as_mapping;
 
@@ -167,12 +170,16 @@ NUITKA_MAY_BE_UNUSED static PyObject *LO
     }
 
     return result;
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_SUBSCRIPT(PyObject *source, PyObject *subscript) {
     CHECK_OBJECT(source);
     CHECK_OBJECT(subscript);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_SUBSCRIPT_OPT
+    return PyObject_GetItem(source, subscript);
+#else
     PyTypeObject *type = Py_TYPE(source);
     PyMappingMethods *mapping = type->tp_as_mapping;
 
@@ -218,6 +225,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *LO
 
     formatNotSubscriptableError(source);
     return NULL;
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED static bool HAS_SUBSCRIPT_CONST(PyObject *source, PyObject *const_subscript,
@@ -225,6 +233,16 @@ NUITKA_MAY_BE_UNUSED static bool HAS_SUB
     CHECK_OBJECT(source);
     CHECK_OBJECT(const_subscript);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_SUBSCRIPT_OPT
+    PyObject *item = PyObject_GetItem(source, const_subscript);
+
+    if (item) {
+        Py_DECREF(item);
+        return true;
+    } else {
+        return false;
+    }
+#else
     PyTypeObject *type = Py_TYPE(source);
     PyMappingMethods *mapping_methods = type->tp_as_mapping;
 
@@ -323,12 +341,24 @@ NUITKA_MAY_BE_UNUSED static bool HAS_SUB
     }
 
     return false;
+
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED static bool HAS_SUBSCRIPT(PyObject *source, PyObject *subscript) {
     CHECK_OBJECT(source);
     CHECK_OBJECT(subscript);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_SUBSCRIPT_OPT
+    PyObject *item = PyObject_GetItem(source, subscript);
+
+    if (item) {
+        Py_DECREF(item);
+        return true;
+    } else {
+        return false;
+    }
+#else
     PyTypeObject *type = Py_TYPE(source);
     PyMappingMethods *mapping = type->tp_as_mapping;
 
@@ -380,6 +410,7 @@ NUITKA_MAY_BE_UNUSED static bool HAS_SUB
 #endif
 
     return false;
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED static bool SET_SUBSCRIPT_CONST(PyObject *target, PyObject *subscript, Py_ssize_t int_subscript,
@@ -388,6 +419,10 @@ NUITKA_MAY_BE_UNUSED static bool SET_SUB
     CHECK_OBJECT(target);
     CHECK_OBJECT(subscript);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_SUBSCRIPT_OPT
+    int res = PyObject_SetItem(target, subscript, value);
+    return res == 0;
+#else
     PyMappingMethods *mapping_methods = Py_TYPE(target)->tp_as_mapping;
 
     if (mapping_methods != NULL && mapping_methods->mp_ass_subscript) {
@@ -446,6 +481,7 @@ NUITKA_MAY_BE_UNUSED static bool SET_SUB
 
         return false;
     }
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED static bool SET_SUBSCRIPT(PyObject *target, PyObject *subscript, PyObject *value) {
@@ -453,6 +489,10 @@ NUITKA_MAY_BE_UNUSED static bool SET_SUB
     CHECK_OBJECT(target);
     CHECK_OBJECT(subscript);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_SUBSCRIPT_OPT
+    int res = PyObject_SetItem(target, subscript, value);
+    return res == 0;
+#else
     PyMappingMethods *mapping_methods = Py_TYPE(target)->tp_as_mapping;
 
     if (mapping_methods != NULL && mapping_methods->mp_ass_subscript) {
@@ -488,6 +528,7 @@ NUITKA_MAY_BE_UNUSED static bool SET_SUB
     }
 
     return true;
+#endif
 }
 
 NUITKA_MAY_BE_UNUSED static bool DEL_SUBSCRIPT(PyObject *target, PyObject *subscript) {
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/prelude.h 1.0.1+ds-1/nuitka/build/include/nuitka/prelude.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/prelude.h	2022-06-30 15:07:53.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/prelude.h	2022-07-30 17:47:39.000000000 +0000
@@ -59,6 +59,11 @@
 #define Py_REFCNT(ob) (_PyObject_CAST(ob)->ob_refcnt)
 #endif
 
+// We are using this new macro on old code too.
+#ifndef Py_SET_REFCNT
+#define Py_SET_REFCNT(ob, refcnt) Py_REFCNT(ob) = refcnt
+#endif
+
 #if defined(_WIN32)
 // Windows is too difficult for API redefines.
 #define MIN_PYCORE_PYTHON_VERSION 0x380
@@ -101,9 +106,11 @@ extern _PyRuntimeState _PyRuntime;
 // TODO: Might be useful too, allows access to Python configuration.
 // #include <internal/pycore_initconfig.h>
 
+#ifndef PY_NOGIL
 #undef PyThreadState_GET
 #define _PyThreadState_Current _PyRuntime.gilstate.tstate_current
 #define PyThreadState_GET() ((PyThreadState *)_Py_atomic_load_relaxed(&_PyThreadState_Current))
+#endif
 
 #undef Py_BUILD_CORE
 
@@ -334,6 +341,19 @@ extern PyThreadState *_PyThreadState_Cur
 #define NuitkaType_HasFeatureClass(descr) (1)
 #endif
 
+// The digit types
+#if PYTHON_VERSION < 0x300
+#include <longintrepr.h>
+
+#if PYTHON_VERSION < 0x270
+// Not present in Python2.6 yet
+typedef signed int sdigit;
+#endif
+#endif
+
+// A long value that represents a signed digit on the helper interface.
+typedef long nuitka_digit;
+
 // Generated.
 // TODO: Move generated ones to separate file.
 #ifdef __IDE_ONLY__
@@ -414,7 +434,7 @@ extern PyObject **global_constants;
 #define const_str_plain_close global_constants[30]
 // 'throw'
 #define const_str_plain_throw global_constants[30]
-// 'throw'
+// 'send'
 #define const_str_plain_send global_constants[30]
 // 'sum'
 #define const_str_plain_sum global_constants[31]
@@ -494,6 +514,8 @@ extern PyObject **global_constants;
 #define const_str_plain___match_args__ global_constants[67]
 // '__args__'
 #define const_str_plain___args__ global_constants[67]
+// 'fileno'
+#define const_str_plain_fileno global_constants[67]
 
 #define _NUITKA_CONSTANTS_SIZE 27
 #define _NUITKA_CONSTANTS_HASH 0x27272727
@@ -559,4 +581,4 @@ extern PyObject *Nuitka_dunder_compiled_
 #define PyCFunction_CheckExact PyCFunction_Check
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff -pruN 0.9.5+ds-1/nuitka/build/include/nuitka/threading.h 1.0.1+ds-1/nuitka/build/include/nuitka/threading.h
--- 0.9.5+ds-1/nuitka/build/include/nuitka/threading.h	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/include/nuitka/threading.h	2022-07-30 17:47:39.000000000 +0000
@@ -61,8 +61,16 @@ NUITKA_MAY_BE_UNUSED static inline bool
         }
     }
 
+#ifdef PY_NOGIL
+    /* load eval breaker */
+    uintptr_t b = _Py_atomic_load_uintptr(&tstate->eval_breaker);
+
+    /* GIL drop request */
+    if ((b & EVAL_PENDING_SIGNALS) != 0) {
+#else
     /* GIL drop request */
     if (ceval2->gil_drop_request._value) {
+#endif
         /* Give another thread a chance */
         PyEval_SaveThread();
         PyEval_AcquireThread(tstate);
diff -pruN 0.9.5+ds-1/nuitka/build/Onefile.scons 1.0.1+ds-1/nuitka/build/Onefile.scons
--- 0.9.5+ds-1/nuitka/build/Onefile.scons	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/Onefile.scons	2022-07-30 17:47:39.000000000 +0000
@@ -63,7 +63,6 @@ from .SconsProgress import enableSconsPr
 from .SconsSpawn import enableSpawnMonitoring
 from .SconsUtils import (
     addClangClPathFromMSVC,
-    addToPATH,
     changeKeyboardInterruptToErrorExit,
     createDefinitionsFile,
     createEnvironment,
@@ -76,6 +75,7 @@ from .SconsUtils import (
     initScons,
     isClangName,
     isGccName,
+    prepareEnvironment,
     provideStaticSourceFile,
     raiseNoCompilerFoundErrorExit,
     setArguments,
@@ -84,7 +84,7 @@ from .SconsUtils import (
 )
 
 # spell-checker: ignore ccversion,ccflags,werror,cppdefines,cpppath,cppflags
-# spell-checker: ignore cxxflags,ldflags
+# spell-checker: ignore cxxflags,ldflags,libpath,linkflags
 
 # Set the arguments.
 setArguments(ARGUMENTS)
@@ -101,9 +101,6 @@ source_dir = getArgumentRequired("source
 nuitka_src = getArgumentRequired("nuitka_src")
 static_src = os.path.join(source_dir, "static")
 
-# The name of executable or extension module that we produce.
-result_basepath = getArgumentRequired("result_name")
-
 # The name of executable that we produce
 result_exe = getArgumentDefaulted("result_exe", None)
 
@@ -194,9 +191,6 @@ compiler_version_mode = getArgumentBool(
 
 assume_yes_for_downloads = getArgumentBool("assume_yes_for_downloads", False)
 
-# Onefile compression is optional.
-onefile_compression = getArgumentBool("onefile_compression", False)
-
 # Onefile bootstrap is optional.
 onefile_splash_screen = getArgumentBool("onefile_splash_screen", False)
 
@@ -206,6 +200,8 @@ macos_min_version = getArgumentDefaulted
 # Target arch for macOS.
 macos_target_arch = getArgumentDefaulted("macos_target_arch", "")
 
+# Anaconda Python might use its own compiler.
+anaconda_python = getArgumentBool("anaconda_python", False)
 
 if getArgumentBool("progress_bar", True) and not show_scons_mode:
     enableSconsProgressBar()
@@ -219,25 +215,12 @@ def printCompilerVersionOutput(*args):
 # Amount of jobs to use.
 job_count = GetOption("num_jobs")
 
-# Add environment specified compilers to the PATH variable.
-if "CC" in os.environ:
-    os.environ["CC"] = os.path.normpath(os.environ["CC"])
-
-    if os.path.isdir(os.environ["CC"]):
-        sys.exit("Error, the CC variable must point to file, not directory.")
-
-    cc_dirname = os.path.dirname(os.environ["CC"])
-
-    if win_target and isGccName(os.path.basename(os.environ["CC"])):
-        if show_scons_mode:
-            my_print("Scons: Environment CC seems to be a gcc, enable mingw_mode.")
-        mingw_mode = True
-
-    if os.path.isdir(cc_dirname):
-        addToPATH(None, cc_dirname, prefix=True)
-
-    printCompilerVersionOutput("CC=%r" % os.environ["CC"])
+# Prepare environment for compiler detection.
+mingw_mode = prepareEnvironment(
+    mingw_mode=mingw_mode, anaconda_python=anaconda_python, python_prefix=python_prefix
+)
 
+# TODO: Merge to prepareEnvironment as well.
 if "CXX" in os.environ:
     os.environ["CXX"] = os.path.normpath(os.environ["CXX"])
 
@@ -256,8 +239,6 @@ if "CXX" in os.environ:
             [cxx_dirname] + os.environ["PATH"].split(os.pathsep)
         )
 
-    printCompilerVersionOutput("CXX=%r" % os.environ["CXX"])
-
 # Patch the compiler detection.
 Environment.Detect = getEnhancedToolDetect()
 
@@ -277,7 +258,6 @@ scons_details_logger.info(
 
 if "CC" in os.environ:
     # If the environment variable CC is set, use that.
-    env["CC"] = os.path.expanduser(os.environ["CC"])
     env["CCVERSION"] = None
 
     scons_details_logger.info("Overridden with environment CC: %r" % env["CC"])
@@ -313,6 +293,8 @@ env.low_memory = False  # Never a concer
 env.macos_min_version = macos_min_version
 env.macos_target_arch = macos_target_arch
 
+env.anaconda_python = anaconda_python
+
 # Requested or user provided, detect if it's clang even from environment
 if isClangName(env.the_cc_name):
     clang_mode = True
@@ -332,6 +314,7 @@ env.clangcl_mode = clangcl_mode
 # for Onefile.
 env.nuitka_python = False
 env.debian_python = False
+env.fedora_python = False
 env.msys2_mingw_python = False
 env.static_libpython = None
 
@@ -595,19 +578,21 @@ if env.msvc_mode and not disable_ccache:
 def createBuildDefinitionsFile():
     onefile_definitions = {}
 
-    if "ONEFILE_TEMP_SPEC" in os.environ:
-        onefile_definitions["_NUITKA_ONEFILE_TEMP_SPEC"] = os.environ[
-            "ONEFILE_TEMP_SPEC"
-        ]
-        onefile_definitions["_NUITKA_ONEFILE_TEMP"] = 1
-    else:
-        onefile_definitions["_NUITKA_ONEFILE_TEMP"] = 0
+    onefile_definitions["_NUITKA_ONEFILE_TEMP_SPEC"] = os.environ[
+        "_NUITKA_ONEFILE_TEMP_SPEC"
+    ]
+    onefile_definitions["_NUITKA_ONEFILE_TEMP"] = int(
+        os.environ["_NUITKA_ONEFILE_TEMP"]
+    )
 
-    if onefile_compression:
-        onefile_definitions["_NUITKA_ONEFILE_COMPRESSION"] = 1
+    onefile_definitions["_NUITKA_ONEFILE_COMPRESSION"] = int(
+        os.environ["_NUITKA_ONEFILE_COMPRESSION"]
+    )
 
     if onefile_splash_screen:
         onefile_definitions["_NUITKA_ONEFILE_SPLASH_SCREEN"] = 1
+
+        # spell-checker: ignore Windowscodecs,Shlwapi
         env.Append(LIBS=["Ole32", "Windowscodecs", "User32", "Gdi32", "Shlwapi"])
 
     setProductVersionDefinitions(onefile_definitions)
diff -pruN 0.9.5+ds-1/nuitka/build/SconsCompilerSettings.py 1.0.1+ds-1/nuitka/build/SconsCompilerSettings.py
--- 0.9.5+ds-1/nuitka/build/SconsCompilerSettings.py	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/SconsCompilerSettings.py	2022-07-30 17:47:39.000000000 +0000
@@ -25,7 +25,7 @@ import re
 from nuitka.Tracing import scons_details_logger, scons_logger
 from nuitka.utils.Download import getCachedDownloadedMinGW64
 from nuitka.utils.FileOperations import openTextFile, putTextFileContents
-from nuitka.utils.Utils import isMacOS, isWin32Windows
+from nuitka.utils.Utils import isFedoraBasedLinux, isMacOS, isWin32Windows
 
 from .DataComposerInterface import getConstantBlobFilename
 from .SconsHacks import myDetectVersion
@@ -143,9 +143,12 @@ def _enableLtoSettings(
     ):
         lto_mode = True
         reason = "known to be supported (Debian)"
-    elif env.gcc_mode and env.the_cc_name == "gnu-cc":
+    elif env.gcc_mode and "gnu-cc" in env.the_cc_name and env.anaconda_python:
         lto_mode = True
         reason = "known to be supported (CondaCC)"
+    elif isMacOS() and env.gcc_mode and env.clang_mode:
+        lto_mode = True
+        reason = "known to be supported (macOS clang)"
     elif env.mingw_mode and env.clang_mode:
         lto_mode = False
         reason = "known to not be supported (new MinGW64 Clang)"
@@ -642,6 +645,10 @@ def setupCCompiler(env, lto_mode, pgo_mo
     if env.msvc_mode:
         env.Append(LIBS=["Shell32"])
 
+    # Since Fedora 36, the system Python will not link otherwise.
+    if isFedoraBasedLinux():
+        env.Append(CCFLAGS=["-fPIC"])
+
 
 def _enablePgoSettings(env, pgo_mode):
     if pgo_mode == "no":
diff -pruN 0.9.5+ds-1/nuitka/build/SconsHacks.py 1.0.1+ds-1/nuitka/build/SconsHacks.py
--- 0.9.5+ds-1/nuitka/build/SconsHacks.py	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/SconsHacks.py	2022-07-30 17:47:39.000000000 +0000
@@ -36,6 +36,7 @@ from SCons.Script import Environment  #
 
 from nuitka.Tracing import scons_details_logger
 from nuitka.utils.FileOperations import openTextFile
+from nuitka.utils.Utils import isLinux, isMacOS
 
 from .SconsUtils import decodeData, getExecutablePath, isGccName
 
@@ -160,6 +161,9 @@ def myDetect(self, progs):
         if blocked_tool in progs:
             return None
 
+    # Note: Actually, with our inline copy, this is maybe not supposed to
+    # happen at all
+
     return orig_detect(self, progs)
 
 
@@ -170,6 +174,15 @@ orig_detect = Environment.Detect
 def getEnhancedToolDetect():
     SCons.Tool.gcc.detect_version = myDetectVersion
 
+    # Allow CondaCC to be detected if it is in PATH.
+    if isLinux():
+        SCons.Tool.gcc.compilers.insert(0, "x86_64-conda-linux-gnu-gcc")
+
+    if isMacOS() and "CONDA_TOOLCHAIN_BUILD" in os.environ:
+        SCons.Tool.gcc.compilers.insert(
+            0, "%s-clang" % os.environ["CONDA_TOOLCHAIN_BUILD"]
+        )
+
     return myDetect
 
 
diff -pruN 0.9.5+ds-1/nuitka/build/SconsInterface.py 1.0.1+ds-1/nuitka/build/SconsInterface.py
--- 0.9.5+ds-1/nuitka/build/SconsInterface.py	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/SconsInterface.py	2022-07-30 17:47:39.000000000 +0000
@@ -31,6 +31,7 @@ import sys
 from nuitka import Options, Tracing
 from nuitka.__past__ import unicode
 from nuitka.plugins.Plugins import Plugins
+from nuitka.PythonFlavors import isAnacondaPython, isNuitkaPython
 from nuitka.PythonVersions import getTargetPythonDLLPath, python_version
 from nuitka.utils import Execution, Utils
 from nuitka.utils.FileOperations import (
@@ -136,8 +137,9 @@ def _setupSconsEnvironment():
     Python DLL lives, in case it needs to be copied, and then also the
     "NUITKA_PYTHON_EXE_PATH" to find the Python binary itself.
 
-    We also need to preserve PYTHONPATH and PYTHONHOME, but remove it potentially
-    as well, so not to confuse the other Python binary used to run scons.
+    We also need to preserve "PYTHONPATH" and "PYTHONHOME", but remove it
+    potentially as well, so not to confuse the other Python binary used to run
+    scons.
     """
 
     # For Python2, avoid unicode working directory.
@@ -378,6 +380,9 @@ def setCommonOptions(options):
     if Options.isUnstriped():
         options["unstriped_mode"] = asBoolStr(True)
 
+    if isAnacondaPython():
+        options["anaconda_python"] = asBoolStr(True)
+
     cpp_defines = Plugins.getPreprocessorSymbols()
     if cpp_defines:
         options["cpp_defines"] = ",".join(
@@ -449,4 +454,11 @@ def setCommonOptions(options):
     if effective_version:
         env_values["NUITKA_VERSION_COMBINED"] = effective_version
 
+    if getOS() != "Windows" and isNuitkaPython():
+        # Override environment CC and CXX to match build compiler.
+        import sysconfig
+
+        env_values["CC"] = sysconfig.get_config_var("CC").split()[0]
+        env_values["CXX"] = sysconfig.get_config_var("CXX").split()[0]
+
     return env_values
diff -pruN 0.9.5+ds-1/nuitka/build/SconsUtils.py 1.0.1+ds-1/nuitka/build/SconsUtils.py
--- 0.9.5+ds-1/nuitka/build/SconsUtils.py	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/SconsUtils.py	2022-07-30 17:47:39.000000000 +0000
@@ -30,35 +30,36 @@ from nuitka.__past__ import basestring,
 from nuitka.Tracing import scons_details_logger, scons_logger
 from nuitka.utils.Execution import executeProcess
 from nuitka.utils.FileOperations import getFileContentByLine, openTextFile
+from nuitka.utils.Utils import isLinux
 
 
 def initScons():
     # Avoid localized outputs.
     os.environ["LANG"] = "C"
 
-    def nosync(self):
+    def no_sync(self):
         # That's a noop, pylint: disable=unused-argument
         pass
 
-    # Avoid scons writing the scons file at all.
+    # Avoid scons writing the scons database at all, spell-checker: ignore dblite
     import SCons.dblite  # pylint: disable=I0021,import-error
 
-    SCons.dblite.dblite.sync = nosync
+    SCons.dblite.dblite.sync = no_sync
 
 
 def setupScons(env, source_dir):
     env["BUILD_DIR"] = source_dir
 
-    # Store the file signatures database with the rest of the source files
-    # and make it version dependent on the Python version of Scons, as its
-    # pickle is being used.
-    sconsign_dir = os.path.abspath(
+    # Store the file signatures database with the rest of the source files and
+    # make it version dependent on the Python version of running Scons, as its
+    # pickle is being used, spell-checker: ignore sconsign
+    sconsign_filename = os.path.abspath(
         os.path.join(
             source_dir, ".sconsign-%d%s" % (sys.version_info[0], sys.version_info[1])
         )
     )
 
-    env.SConsignFile(sconsign_dir)
+    env.SConsignFile(sconsign_filename)
 
 
 scons_arguments = {}
@@ -130,6 +131,8 @@ def _enableExperimentalSettings(env, exp
             # Allowing for nice names on command line, but using identifiers for C.
             experiment = experiment.upper().replace("-", "_")
 
+            # Experimental without a value is done as mere define, otherwise
+            # the value is passed. spell-checker: ignore cppdefines
             if value:
                 env.Append(CPPDEFINES=[("_NUITKA_EXPERIMENTAL_%s" % experiment, value)])
             else:
@@ -138,6 +141,35 @@ def _enableExperimentalSettings(env, exp
     env.experimental_flags = experimental_flags
 
 
+def prepareEnvironment(mingw_mode, anaconda_python, python_prefix):
+    # Add environment specified compilers to the PATH variable.
+    if "CC" in os.environ:
+        scons_details_logger.info("CC=%r" % os.environ["CC"])
+
+        os.environ["CC"] = os.path.normpath(os.path.expanduser(os.environ["CC"]))
+
+        if os.path.isdir(os.environ["CC"]):
+            scons_logger.sysexit(
+                "Error, the 'CC' variable must point to file, not directory."
+            )
+
+        if os.path.sep in os.environ["CC"]:
+            cc_dirname = os.path.dirname(os.environ["CC"])
+            if os.path.isdir(cc_dirname):
+                addToPATH(None, cc_dirname, prefix=True)
+
+        if win_target and isGccName(os.path.basename(os.environ["CC"])):
+            scons_details_logger.info(
+                "Environment CC seems to be a gcc, enabling mingw_mode."
+            )
+            mingw_mode = True
+    else:
+        if isLinux() and anaconda_python:
+            addToPATH(None, os.path.join(python_prefix, "bin"), prefix=True)
+
+    return mingw_mode
+
+
 def createEnvironment(mingw_mode, msvc_version, target_arch, experimental):
     from SCons.Script import Environment  # pylint: disable=I0021,import-error
 
@@ -150,6 +182,7 @@ def createEnvironment(mingw_mode, msvc_v
             "Installed MSVC versions are %s."
             % ",".join(repr(v) for v in SCons.Tool.MSCommon.vc.get_installed_vcs()),
         )
+
     # If we are on Windows, and MinGW is not enforced, lets see if we can
     # find "cl.exe", and if we do, disable automatic scan.
     if (
@@ -179,7 +212,8 @@ def createEnvironment(mingw_mode, msvc_v
         # Extra tools configuration for scons.
         tools=tools,
         # The shared libraries should not be named "lib...", because CPython
-        # requires the filename "module_name.so" to load it.
+        # requires the filename "module_name.so/pyd" to load it, with no
+        # prefix at all, spell-checker: ignore SHLIBPREFIX
         SHLIBPREFIX="",
         # Under windows, specify the target architecture is needed for Scons
         # to pick up MSVC.
@@ -294,6 +328,8 @@ def writeSconsReport(env, source_dir):
             if key.startswith(("_", "CONFIGURE")):
                 continue
 
+            # Ignore problematic and useless values
+            # spell-checker: ignore MSVSSCONS,IDLSUFFIXES,DSUFFIXES
             if key in ("MSVSSCONS", "BUILD_DIR", "IDLSUFFIXES", "DSUFFIXES"):
                 continue
 
@@ -381,6 +417,7 @@ def addClangClPathFromMSVC(env):
     env["CC"] = "clang-cl"
     env["LINK"] = "lld-link"
 
+    # Version information is outdated now, spell-checker: ignore ccversion
     env["CCVERSION"] = None
 
 
@@ -453,6 +490,7 @@ def scanSourceDir(env, dirname, plugins)
 
     for filename in sorted(os.listdir(dirname)):
         if filename.endswith(".h") and plugins and not added_path:
+            # Adding path for source paths on the fly, spell-checker: ignore cpppath
             env.Append(CPPPATH=[dirname])
             added_path = True
 
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/CompiledAsyncgenType.c 1.0.1+ds-1/nuitka/build/static_src/CompiledAsyncgenType.c
--- 0.9.5+ds-1/nuitka/build/static_src/CompiledAsyncgenType.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/CompiledAsyncgenType.c	2022-07-30 17:47:39.000000000 +0000
@@ -942,7 +942,7 @@ static void Nuitka_Asyncgen_tp_dealloc(s
 
     // Revive temporarily.
     assert(Py_REFCNT(asyncgen) == 0);
-    Py_REFCNT(asyncgen) = 1;
+    Py_SET_REFCNT(asyncgen, 1);
 
     // Save the current exception, if any, we must preserve it.
     PyObject *save_exception_type, *save_exception_value;
@@ -975,8 +975,9 @@ static void Nuitka_Asyncgen_tp_dealloc(s
 
     Nuitka_Asyncgen_release_closure(asyncgen);
 
-    // Allow for above code to resurrect the coroutine.
-    Py_REFCNT(asyncgen) -= 1;
+    // Allow for above code to resurrect the coroutine, do not release the object
+    // like Py_DECREF would.
+    Py_SET_REFCNT(asyncgen, Py_REFCNT(asyncgen) - 1);
     if (Py_REFCNT(asyncgen) >= 1) {
         return;
     }
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/CompiledCoroutineType.c 1.0.1+ds-1/nuitka/build/static_src/CompiledCoroutineType.c
--- 0.9.5+ds-1/nuitka/build/static_src/CompiledCoroutineType.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/CompiledCoroutineType.c	2022-07-30 17:47:39.000000000 +0000
@@ -1093,7 +1093,7 @@ static void Nuitka_Coroutine_tp_dealloc(
 
     // Revive temporarily.
     assert(Py_REFCNT(coroutine) == 0);
-    Py_REFCNT(coroutine) = 1;
+    Py_SET_REFCNT(coroutine, 1);
 
     // Save the current exception, if any, we must preserve it.
     PyObject *save_exception_type, *save_exception_value;
@@ -1114,7 +1114,7 @@ static void Nuitka_Coroutine_tp_dealloc(
     Nuitka_Coroutine_release_closure(coroutine);
 
     // Allow for above code to resurrect the coroutine.
-    Py_REFCNT(coroutine) -= 1;
+    Py_SET_REFCNT(coroutine, Py_REFCNT(coroutine) - 1);
     if (Py_REFCNT(coroutine) >= 1) {
         RESTORE_ERROR_OCCURRED(save_exception_type, save_exception_value, save_exception_tb);
         return;
@@ -1238,7 +1238,7 @@ static void Nuitka_CoroutineWrapper_tp_d
     Nuitka_GC_UnTrack((PyObject *)cw);
 
     assert(Py_REFCNT(cw) == 0);
-    Py_REFCNT(cw) = 1;
+    Py_SET_REFCNT(cw, 1);
 
 #if _DEBUG_REFCOUNTS
     count_active_Nuitka_CoroutineWrapper_Type -= 1;
@@ -1250,7 +1250,7 @@ static void Nuitka_CoroutineWrapper_tp_d
     cw->m_coroutine = NULL;
 
     assert(Py_REFCNT(cw) == 1);
-    Py_REFCNT(cw) = 0;
+    Py_SET_REFCNT(cw, 0);
 
     releaseToFreeList(free_list_coro_wrappers, cw, MAX_COROUTINE_FREE_LIST_COUNT);
 }
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/CompiledFrameType.c 1.0.1+ds-1/nuitka/build/static_src/CompiledFrameType.c
--- 0.9.5+ds-1/nuitka/build/static_src/CompiledFrameType.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/CompiledFrameType.c	2022-07-30 17:47:39.000000000 +0000
@@ -582,6 +582,7 @@ void _initCompiledFrameType(void) {
 static struct Nuitka_FrameObject *MAKE_FRAME(PyCodeObject *code, PyObject *module, bool is_module,
                                              Py_ssize_t locals_size) {
     assertCodeObject(code);
+    CHECK_OBJECT(module);
 
 #if _DEBUG_REFCOUNTS
     count_active_Nuitka_Frame_Type += 1;
@@ -589,6 +590,8 @@ static struct Nuitka_FrameObject *MAKE_F
 #endif
 
     PyObject *globals = ((PyModuleObject *)module)->md_dict;
+    CHECK_OBJECT(globals);
+
     assert(PyDict_Check(globals));
 
     struct Nuitka_FrameObject *result;
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/CompiledFunctionType.c 1.0.1+ds-1/nuitka/build/static_src/CompiledFunctionType.c
--- 0.9.5+ds-1/nuitka/build/static_src/CompiledFunctionType.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/CompiledFunctionType.c	2022-07-30 17:47:39.000000000 +0000
@@ -419,6 +419,21 @@ static PyObject *Nuitka_Function_reduce(
     return result;
 }
 
+static PyObject *Nuitka_Function_clone(struct Nuitka_FunctionObject *function) {
+    struct Nuitka_FunctionObject *result =
+        Nuitka_Function_New(function->m_c_code, function->m_name,
+#if PYTHON_VERSION >= 0x300
+                            function->m_qualname,
+#endif
+                            function->m_code_object, function->m_defaults,
+#if PYTHON_VERSION >= 0x300
+                            function->m_kwdefaults, function->m_annotations,
+#endif
+                            function->m_module, function->m_doc, function->m_closure, function->m_closure_given);
+
+    return (PyObject *)result;
+}
+
 #define MAX_FUNCTION_FREE_LIST_COUNT 100
 static struct Nuitka_FunctionObject *free_list_functions = NULL;
 static int free_list_functions_count = 0;
@@ -475,6 +490,7 @@ static void Nuitka_Function_tp_dealloc(s
 }
 
 static PyMethodDef Nuitka_Function_methods[] = {{"__reduce__", (PyCFunction)Nuitka_Function_reduce, METH_NOARGS, NULL},
+                                                {"clone", (PyCFunction)Nuitka_Function_clone, METH_NOARGS, NULL},
                                                 {NULL}};
 
 static PyObject *Nuitka_Function_tp_call(struct Nuitka_FunctionObject *function, PyObject *tuple_args, PyObject *kw);
@@ -484,7 +500,7 @@ PyTypeObject Nuitka_Function_Type = {
     sizeof(struct Nuitka_FunctionObject),               /* tp_basicsize */
     sizeof(struct Nuitka_CellObject *),                 /* tp_itemsize */
     (destructor)Nuitka_Function_tp_dealloc,             /* tp_dealloc */
-#if PYTHON_VERSION < 0x380
+#if PYTHON_VERSION < 0x380 || defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
     0, /* tp_print */
 #else
     offsetof(struct Nuitka_FunctionObject, m_vectorcall), /* tp_vectorcall_offset */
@@ -758,7 +774,7 @@ void Nuitka_Function_EnableConstReturnGe
     function->m_c_code = _Nuitka_FunctionEmptyCodeGenericImpl;
 }
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
 static PyObject *Nuitka_Function_tp_vectorcall(struct Nuitka_FunctionObject *function, PyObject *const *stack,
                                                size_t nargsf, PyObject *kw_names);
 #endif
@@ -874,7 +890,7 @@ struct Nuitka_FunctionObject *Nuitka_Fun
     static long Nuitka_Function_counter = 0;
     result->m_counter = Nuitka_Function_counter++;
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
     result->m_vectorcall = (vectorcallfunc)Nuitka_Function_tp_vectorcall;
 #endif
 
@@ -1193,6 +1209,27 @@ static inline bool checkKeywordType(PyOb
 #endif
 }
 
+static inline bool RICH_COMPARE_EQ_CBOOL_ARG_NAMES(PyObject *operand1, PyObject *operand2) {
+    // Compare with argument name. We know our type, but from the outside, it
+    // can be a derived type, or in case of Python2, a unicode value to compare
+    // with a string. These half sided comparisons will make the switch to the
+    // special one immediately if possible though.
+
+#if PYTHON_VERSION < 0x300
+    nuitka_bool result = RICH_COMPARE_EQ_NBOOL_STR_OBJECT(operand1, operand2);
+#else
+    nuitka_bool result = RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(operand1, operand2);
+#endif
+
+    // Should be close to impossible, we will have to ignore it though.
+    if (unlikely(result == NUITKA_BOOL_EXCEPTION)) {
+        DROP_ERROR_OCCURRED();
+        return false;
+    }
+
+    return result == NUITKA_BOOL_TRUE;
+}
+
 #if PYTHON_VERSION < 0x300
 static Py_ssize_t handleKeywordArgs(struct Nuitka_FunctionObject const *function, PyObject **python_pars, PyObject *kw)
 #else
@@ -1249,7 +1286,7 @@ static Py_ssize_t handleKeywordArgs(stru
             PyObject **varnames = function->m_varnames;
 
             for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
-                if (RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
                     assert(python_pars[i] == NULL);
                     python_pars[i] = value;
 
@@ -1271,7 +1308,7 @@ static Py_ssize_t handleKeywordArgs(stru
             for (Py_ssize_t i = 0; i < kw_arg_start; i++) {
                 PyObject **varnames = function->m_varnames;
 
-                if (RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
                     pos_only_error = true;
                     break;
                 }
@@ -1364,7 +1401,7 @@ static Py_ssize_t handleKeywordArgsSplit
 
             for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
                 // TODO: Could do better here, STR/UNICODE key knowledge being there.
-                if (RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
                     assert(python_pars[i] == NULL);
                     python_pars[i] = value;
 
@@ -1386,7 +1423,7 @@ static Py_ssize_t handleKeywordArgsSplit
             for (Py_ssize_t i = 0; i < kw_arg_start; i++) {
                 PyObject **varnames = function->m_varnames;
 
-                if (RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
                     pos_only_error = true;
                     break;
                 }
@@ -1424,9 +1461,12 @@ static bool MAKE_STAR_DICT_DICTIONARY_CO
     Py_ssize_t star_dict_index = function->m_args_star_dict_index;
     assert(star_dict_index != -1);
 
-    if (kw == NULL) {
+    if (kw == NULL || ((PyDictObject *)kw)->ma_used == 0) {
         python_pars[star_dict_index] = PyDict_New();
-    } else if (((PyDictObject *)kw)->ma_used > 0) {
+    } else {
+#if _NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT
+        python_pars[star_dict_index] = PyDict_Copy(kw);
+#else
 #if PYTHON_VERSION < 0x300
         python_pars[star_dict_index] = _PyDict_NewPresized(((PyDictObject *)kw)->ma_used);
 
@@ -1448,6 +1488,7 @@ static bool MAKE_STAR_DICT_DICTIONARY_CO
         }
 #else
         /* Python 3 */
+#ifndef PY_NOGIL
         if (_PyDict_HasSplitTable((PyDictObject *)kw)) {
             PyDictObject *mp = (PyDictObject *)kw;
 
@@ -1487,7 +1528,9 @@ static bool MAKE_STAR_DICT_DICTIONARY_CO
             Nuitka_GC_Track(split_copy);
 
             python_pars[star_dict_index] = (PyObject *)split_copy;
-        } else {
+        } else
+#endif
+        {
             python_pars[star_dict_index] = PyDict_New();
 
             PyDictObject *mp = (PyDictObject *)kw;
@@ -1521,8 +1564,7 @@ static bool MAKE_STAR_DICT_DICTIONARY_CO
             }
         }
 #endif
-    } else {
-        python_pars[star_dict_index] = PyDict_New();
+#endif
     }
 
     return true;
@@ -2432,7 +2474,7 @@ static Py_ssize_t handleVectorcallKeywor
             PyObject **varnames = function->m_varnames;
 
             for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
-                if (RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
                     assert(python_pars[i] == NULL);
                     python_pars[i] = kw_values[pos];
                     Py_INCREF(python_pars[i]);
@@ -2453,7 +2495,7 @@ static Py_ssize_t handleVectorcallKeywor
             for (Py_ssize_t i = 0; i < kw_arg_start; i++) {
                 PyObject **varnames = function->m_varnames;
 
-                if (RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
                     pos_only_error = true;
                     break;
                 }
@@ -2703,7 +2745,7 @@ static PyObject *Nuitka_Function_tp_call
     }
 }
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
 static PyObject *Nuitka_Function_tp_vectorcall(struct Nuitka_FunctionObject *function, PyObject *const *stack,
                                                size_t nargsf, PyObject *kw_names) {
     assert(kw_names == NULL || PyTuple_CheckExact(kw_names));
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/CompiledGeneratorType.c 1.0.1+ds-1/nuitka/build/static_src/CompiledGeneratorType.c
--- 0.9.5+ds-1/nuitka/build/static_src/CompiledGeneratorType.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/CompiledGeneratorType.c	2022-07-30 17:47:39.000000000 +0000
@@ -1228,7 +1228,7 @@ static int free_list_generators_count =
 static void Nuitka_Generator_tp_dealloc(struct Nuitka_GeneratorObject *generator) {
     // Revive temporarily.
     assert(Py_REFCNT(generator) == 0);
-    Py_REFCNT(generator) = 1;
+    Py_SET_REFCNT(generator, 1);
 
     // Save the current exception, if any, we must preserve it.
     PyObject *save_exception_type, *save_exception_value;
@@ -1247,7 +1247,7 @@ static void Nuitka_Generator_tp_dealloc(
     Nuitka_Generator_release_closure(generator);
 
     // Allow for above code to resurrect the generator.
-    Py_REFCNT(generator) -= 1;
+    Py_SET_REFCNT(generator, Py_REFCNT(generator) - 1);
     if (Py_REFCNT(generator) >= 1) {
         return;
     }
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c 1.0.1+ds-1/nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c
--- 0.9.5+ds-1/nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c	2022-07-30 17:47:39.000000000 +0000
@@ -28,6 +28,12 @@
 #include "nuitka/prelude.h"
 #endif
 
+#ifdef PY_NOGIL
+#define Py_BUILD_CORE
+#include "internal/pycore_generator.h"
+#undef Py_BUILD_CORE
+#endif
+
 // This function takes no reference to value, and publishes a StopIteration
 // exception with it.
 #if PYTHON_VERSION >= 0x300
@@ -91,7 +97,9 @@ static inline bool Nuitka_PyFrameHasComp
 }
 
 static inline bool Nuitka_PyGeneratorIsExecuting(PyGenObject const *gen) {
-#if PYTHON_VERSION < 0x3a0
+#ifdef PY_NOGIL
+    return gen->status == GEN_RUNNING;
+#elif PYTHON_VERSION < 0x3a0
     return gen->gi_running == 1;
 #else
     PyFrameObject *frame = gen->gi_frame;
@@ -104,7 +112,42 @@ static inline bool Nuitka_PyGeneratorIsE
 // what it does. It's unrelated to compiled generators, and used from coroutines
 // and asyncgen to interact with them.
 static PyObject *Nuitka_PyGen_Send(PyGenObject *gen, PyObject *arg) {
-#if PYTHON_VERSION >= 0x3a0
+#if defined(PY_NOGIL)
+    PyObject *res;
+
+    if (gen->status == GEN_CREATED) {
+        if (unlikely(arg != Py_None)) {
+            char const *msg = "generator raised StopIteration";
+            if (PyCoro_CheckExact(gen)) {
+                msg = "coroutine raised StopIteration";
+            } else if (PyAsyncGen_CheckExact(gen)) {
+                msg = "async generator raised StopIteration";
+            }
+
+            _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
+            return NULL;
+        }
+        arg = NULL;
+    }
+
+    res = PyEval2_EvalGen(gen, arg);
+
+    if (likely(res != NULL)) {
+        assert(gen->status == GEN_SUSPENDED);
+        return res;
+    }
+
+    if (likely(gen->return_value == Py_None)) {
+        gen->return_value = NULL;
+        PyErr_SetNone(PyAsyncGen_CheckExact(gen) ? PyExc_StopAsyncIteration : PyExc_StopIteration);
+        return NULL;
+    } else if (gen->return_value != NULL) {
+        Nuitka_SetStopIterationValue(gen->return_value);
+        return NULL;
+    } else {
+        return gen_wrap_exception(gen);
+    }
+#elif PYTHON_VERSION >= 0x3a0
     PyObject *result;
 
     PySendResult res = PyIter_Send((PyObject *)gen, arg, &result);
@@ -297,7 +340,8 @@ static PyObject *Nuitka_PyGen_Send(PyGen
 
 #endif
 
-#if PYTHON_VERSION >= 0x340
+// TODO: Disabled for NOGIL until it becomes more ready.
+#if PYTHON_VERSION >= 0x340 && !defined(PY_NOGIL)
 
 #include <opcode.h>
 
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/CompiledMethodType.c 1.0.1+ds-1/nuitka/build/static_src/CompiledMethodType.c
--- 0.9.5+ds-1/nuitka/build/static_src/CompiledMethodType.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/CompiledMethodType.c	2022-07-30 17:47:39.000000000 +0000
@@ -144,7 +144,7 @@ static PyMethodDef Nuitka_Method_methods
     {"__deepcopy__", (PyCFunction)Nuitka_Method_deepcopy, METH_O, NULL},
     {NULL}};
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
 static PyObject *Nuitka_Method_tp_vectorcall(struct Nuitka_MethodObject *method, PyObject *const *stack, size_t nargsf,
                                              PyObject *kwnames) {
     assert(Nuitka_Method_Check((PyObject *)method));
@@ -478,7 +478,7 @@ PyTypeObject Nuitka_Method_Type = {
     sizeof(struct Nuitka_MethodObject),
     0,
     (destructor)Nuitka_Method_tp_dealloc, /* tp_dealloc */
-#if PYTHON_VERSION < 0x380
+#if PYTHON_VERSION < 0x380 || defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
     0, /* tp_print */
 #else
     offsetof(struct Nuitka_MethodObject, m_vectorcall), /* tp_vectorcall_offset */
@@ -573,7 +573,7 @@ PyObject *Nuitka_Method_New(struct Nuitk
 
     result->m_weakrefs = NULL;
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
     result->m_vectorcall = (vectorcallfunc)Nuitka_Method_tp_vectorcall;
 #endif
 
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/HelpersAttributes.c 1.0.1+ds-1/nuitka/build/static_src/HelpersAttributes.c
--- 0.9.5+ds-1/nuitka/build/static_src/HelpersAttributes.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/HelpersAttributes.c	2022-07-30 17:47:39.000000000 +0000
@@ -113,6 +113,9 @@ PyObject *LOOKUP_ATTRIBUTE(PyObject *sou
      * updated in line with this: LOOKUP_ATTRIBUTE_[DICT|CLASS]_SLOT
      */
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_ATTR_OPT
+    return PyObject_GetAttr(source, attr_name);
+#else
     CHECK_OBJECT(source);
     CHECK_OBJECT(attr_name);
 
@@ -229,11 +232,15 @@ PyObject *LOOKUP_ATTRIBUTE(PyObject *sou
 
         return NULL;
     }
+#endif
 }
 
 PyObject *LOOKUP_ATTRIBUTE_DICT_SLOT(PyObject *source) {
     CHECK_OBJECT(source);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_ATTR_OPT
+    return PyObject_GetAttr(source, const_str_plain___dict__);
+#else
     PyTypeObject *type = Py_TYPE(source);
 
     if (type->tp_getattro == PyObject_GenericGetAttr) {
@@ -342,11 +349,15 @@ PyObject *LOOKUP_ATTRIBUTE_DICT_SLOT(PyO
 
         return NULL;
     }
+#endif
 }
 
 PyObject *LOOKUP_ATTRIBUTE_CLASS_SLOT(PyObject *source) {
     CHECK_OBJECT(source);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_ATTR_OPT
+    return PyObject_GetAttr(source, const_str_plain___class__);
+#else
     PyTypeObject *type = Py_TYPE(source);
 
     if (type->tp_getattro == PyObject_GenericGetAttr) {
@@ -456,6 +467,7 @@ PyObject *LOOKUP_ATTRIBUTE_CLASS_SLOT(Py
 
         return NULL;
     }
+#endif
 }
 
 int BUILTIN_HASATTR_BOOL(PyObject *source, PyObject *attr_name) {
@@ -508,6 +520,9 @@ bool HAS_ATTR_BOOL(PyObject *source, PyO
     CHECK_OBJECT(source);
     CHECK_OBJECT(attr_name);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_ATTR_OPT
+    return PyObject_HasAttr(source, attr_name);
+#else
     PyTypeObject *type = Py_TYPE(source);
 
     if (type->tp_getattro == PyObject_GenericGetAttr) {
@@ -653,6 +668,7 @@ bool HAS_ATTR_BOOL(PyObject *source, PyO
     } else {
         return false;
     }
+#endif
 }
 
 #if PYTHON_VERSION < 0x300
@@ -800,6 +816,10 @@ bool SET_ATTRIBUTE(PyObject *target, PyO
     CHECK_OBJECT(attr_name);
     CHECK_OBJECT(value);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_ATTR_OPT
+    int res = PyObject_SetAttr(target, attr_name, value);
+    return res == 0;
+#else
     PyTypeObject *type = Py_TYPE(target);
 
 #if PYTHON_VERSION < 0x300 || defined(_NUITKA_USE_UNEXPOSED_API)
@@ -843,6 +863,7 @@ bool SET_ATTRIBUTE(PyObject *target, PyO
 
         return false;
     }
+#endif
 }
 
 bool SET_ATTRIBUTE_DICT_SLOT(PyObject *target, PyObject *value) {
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/HelpersBuiltinTypeMethods.c 1.0.1+ds-1/nuitka/build/static_src/HelpersBuiltinTypeMethods.c
--- 0.9.5+ds-1/nuitka/build/static_src/HelpersBuiltinTypeMethods.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/HelpersBuiltinTypeMethods.c	2022-07-30 17:47:39.000000000 +0000
@@ -461,7 +461,6 @@ static void _initUnicodeBuiltinMethods(v
 }
 static PyObject *dict_builtin_clear = NULL;
 static PyObject *dict_builtin_copy = NULL;
-static PyObject *dict_builtin_fromkeys = NULL;
 static PyObject *dict_builtin_get = NULL;
 #if PYTHON_VERSION < 0x300
 static PyObject *dict_builtin_has_key = NULL;
@@ -494,7 +493,6 @@ static PyObject *dict_builtin_viewvalues
 static void _initDictBuiltinMethods(void) {
     dict_builtin_clear = PyObject_GetAttrString((PyObject *)&PyDict_Type, "clear");
     dict_builtin_copy = PyObject_GetAttrString((PyObject *)&PyDict_Type, "copy");
-    dict_builtin_fromkeys = PyObject_GetAttrString((PyObject *)&PyDict_Type, "fromkeys");
     dict_builtin_get = PyObject_GetAttrString((PyObject *)&PyDict_Type, "get");
 #if PYTHON_VERSION < 0x300
     dict_builtin_has_key = PyObject_GetAttrString((PyObject *)&PyDict_Type, "has_key");
@@ -531,8 +529,11 @@ PyObject *DICT_POP2(PyObject *dict, PyOb
 
     CHECK_OBJECT(key);
 
+    PyObject *called = dict_builtin_pop;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {dict, key};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(dict_builtin_pop, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -543,8 +544,22 @@ PyObject *DICT_POP3(PyObject *dict, PyOb
     CHECK_OBJECT(key);
     CHECK_OBJECT(default_value);
 
+    PyObject *called = dict_builtin_pop;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {dict, key, default_value};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(dict_builtin_pop, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
+
+    return result;
+}
+PyObject *DICT_POPITEM(PyObject *dict) {
+    CHECK_OBJECT(dict);
+    assert(PyDict_CheckExact(dict));
+
+    PyObject *called = dict_builtin_popitem;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, dict);
 
     return result;
 }
@@ -554,8 +569,11 @@ PyObject *DICT_SETDEFAULT2(PyObject *dic
 
     CHECK_OBJECT(key);
 
+    PyObject *called = dict_builtin_setdefault;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {dict, key};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(dict_builtin_setdefault, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -566,8 +584,11 @@ PyObject *DICT_SETDEFAULT3(PyObject *dic
     CHECK_OBJECT(key);
     CHECK_OBJECT(default_value);
 
+    PyObject *called = dict_builtin_setdefault;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {dict, key, default_value};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(dict_builtin_setdefault, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -576,7 +597,39 @@ PyObject *STR_CAPITALIZE(PyObject *str)
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_capitalize, str);
+    PyObject *called = str_builtin_capitalize;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
+
+    return result;
+}
+PyObject *STR_CENTER2(PyObject *str, PyObject *width) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = str_builtin_center;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {str, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
+
+    return result;
+}
+PyObject *STR_CENTER3(PyObject *str, PyObject *width, PyObject *fillchar) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(width);
+    CHECK_OBJECT(fillchar);
+
+    PyObject *called = str_builtin_center;
+    CHECK_OBJECT(called);
+
+    PyObject *args[3] = {str, width, fillchar};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -586,8 +639,11 @@ PyObject *STR_COUNT2(PyObject *str, PyOb
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = str_builtin_count;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_count, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -598,8 +654,11 @@ PyObject *STR_COUNT3(PyObject *str, PyOb
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = str_builtin_count;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_count, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -611,8 +670,11 @@ PyObject *STR_COUNT4(PyObject *str, PyOb
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = str_builtin_count;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_count, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -620,7 +682,10 @@ PyObject *STR_DECODE1(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_decode, str);
+    PyObject *called = str_builtin_decode;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -630,8 +695,11 @@ PyObject *STR_DECODE2(PyObject *str, PyO
 
     CHECK_OBJECT(encoding);
 
+    PyObject *called = str_builtin_decode;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, encoding};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_decode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -646,8 +714,11 @@ PyObject *STR_DECODE3(PyObject *str, PyO
     }
     CHECK_OBJECT(errors);
 
+    PyObject *called = str_builtin_decode;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, encoding, errors};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_decode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     Py_DECREF(encoding);
 
@@ -657,7 +728,10 @@ PyObject *STR_ENCODE1(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_encode, str);
+    PyObject *called = str_builtin_encode;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -667,8 +741,11 @@ PyObject *STR_ENCODE2(PyObject *str, PyO
 
     CHECK_OBJECT(encoding);
 
+    PyObject *called = str_builtin_encode;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, encoding};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_encode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -679,8 +756,11 @@ PyObject *STR_ENCODE3(PyObject *str, PyO
     CHECK_OBJECT(encoding);
     CHECK_OBJECT(errors);
 
+    PyObject *called = str_builtin_encode;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, encoding, errors};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_encode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -690,8 +770,11 @@ PyObject *STR_ENDSWITH2(PyObject *str, P
 
     CHECK_OBJECT(suffix);
 
+    PyObject *called = str_builtin_endswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, suffix};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_endswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -702,8 +785,11 @@ PyObject *STR_ENDSWITH3(PyObject *str, P
     CHECK_OBJECT(suffix);
     CHECK_OBJECT(start);
 
+    PyObject *called = str_builtin_endswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, suffix, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_endswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -715,8 +801,36 @@ PyObject *STR_ENDSWITH4(PyObject *str, P
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = str_builtin_endswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, suffix, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_endswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
+
+    return result;
+}
+PyObject *STR_EXPANDTABS1(PyObject *str) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    PyObject *called = str_builtin_expandtabs;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
+
+    return result;
+}
+PyObject *STR_EXPANDTABS2(PyObject *str, PyObject *tabsize) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(tabsize);
+
+    PyObject *called = str_builtin_expandtabs;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {str, tabsize};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -726,8 +840,11 @@ PyObject *STR_FIND2(PyObject *str, PyObj
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = str_builtin_find;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_find, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -738,8 +855,11 @@ PyObject *STR_FIND3(PyObject *str, PyObj
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = str_builtin_find;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_find, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -751,8 +871,11 @@ PyObject *STR_FIND4(PyObject *str, PyObj
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = str_builtin_find;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_find, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -762,8 +885,11 @@ PyObject *STR_INDEX2(PyObject *str, PyOb
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = str_builtin_index;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_index, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -774,8 +900,11 @@ PyObject *STR_INDEX3(PyObject *str, PyOb
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = str_builtin_index;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_index, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -787,8 +916,11 @@ PyObject *STR_INDEX4(PyObject *str, PyOb
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = str_builtin_index;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_index, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -796,7 +928,10 @@ PyObject *STR_ISALNUM(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_isalnum, str);
+    PyObject *called = str_builtin_isalnum;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -804,7 +939,10 @@ PyObject *STR_ISALPHA(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_isalpha, str);
+    PyObject *called = str_builtin_isalpha;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -812,7 +950,10 @@ PyObject *STR_ISDIGIT(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_isdigit, str);
+    PyObject *called = str_builtin_isdigit;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -820,7 +961,10 @@ PyObject *STR_ISLOWER(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_islower, str);
+    PyObject *called = str_builtin_islower;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -828,7 +972,10 @@ PyObject *STR_ISSPACE(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_isspace, str);
+    PyObject *called = str_builtin_isspace;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -836,7 +983,10 @@ PyObject *STR_ISTITLE(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_istitle, str);
+    PyObject *called = str_builtin_istitle;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -844,7 +994,39 @@ PyObject *STR_ISUPPER(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_isupper, str);
+    PyObject *called = str_builtin_isupper;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
+
+    return result;
+}
+PyObject *STR_LJUST2(PyObject *str, PyObject *width) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = str_builtin_ljust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {str, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
+
+    return result;
+}
+PyObject *STR_LJUST3(PyObject *str, PyObject *width, PyObject *fillchar) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(width);
+    CHECK_OBJECT(fillchar);
+
+    PyObject *called = str_builtin_ljust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[3] = {str, width, fillchar};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -852,7 +1034,10 @@ PyObject *STR_LOWER(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_lower, str);
+    PyObject *called = str_builtin_lower;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -860,7 +1045,10 @@ PyObject *STR_LSTRIP1(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_lstrip, str);
+    PyObject *called = str_builtin_lstrip;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -870,8 +1058,11 @@ PyObject *STR_LSTRIP2(PyObject *str, PyO
 
     CHECK_OBJECT(chars);
 
+    PyObject *called = str_builtin_lstrip;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, chars};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_lstrip, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -881,8 +1072,11 @@ PyObject *STR_PARTITION(PyObject *str, P
 
     CHECK_OBJECT(sep);
 
+    PyObject *called = str_builtin_partition;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sep};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_partition, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -893,8 +1087,11 @@ PyObject *STR_REPLACE3(PyObject *str, Py
     CHECK_OBJECT(old);
     CHECK_OBJECT(new_value);
 
+    PyObject *called = str_builtin_replace;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, old, new_value};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_replace, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -906,8 +1103,11 @@ PyObject *STR_REPLACE4(PyObject *str, Py
     CHECK_OBJECT(new_value);
     CHECK_OBJECT(count);
 
+    PyObject *called = str_builtin_replace;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, old, new_value, count};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_replace, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -917,8 +1117,11 @@ PyObject *STR_RFIND2(PyObject *str, PyOb
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = str_builtin_rfind;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_rfind, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -929,8 +1132,11 @@ PyObject *STR_RFIND3(PyObject *str, PyOb
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = str_builtin_rfind;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_rfind, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -942,8 +1148,11 @@ PyObject *STR_RFIND4(PyObject *str, PyOb
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = str_builtin_rfind;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_rfind, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -953,8 +1162,11 @@ PyObject *STR_RINDEX2(PyObject *str, PyO
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = str_builtin_rindex;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_rindex, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -965,8 +1177,11 @@ PyObject *STR_RINDEX3(PyObject *str, PyO
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = str_builtin_rindex;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_rindex, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -978,8 +1193,40 @@ PyObject *STR_RINDEX4(PyObject *str, PyO
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = str_builtin_rindex;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_rindex, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
+
+    return result;
+}
+PyObject *STR_RJUST2(PyObject *str, PyObject *width) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = str_builtin_rjust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {str, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
+
+    return result;
+}
+PyObject *STR_RJUST3(PyObject *str, PyObject *width, PyObject *fillchar) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(width);
+    CHECK_OBJECT(fillchar);
+
+    PyObject *called = str_builtin_rjust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[3] = {str, width, fillchar};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -989,8 +1236,11 @@ PyObject *STR_RPARTITION(PyObject *str,
 
     CHECK_OBJECT(sep);
 
+    PyObject *called = str_builtin_rpartition;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sep};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_rpartition, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -998,7 +1248,10 @@ PyObject *STR_RSPLIT1(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_rsplit, str);
+    PyObject *called = str_builtin_rsplit;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -1008,8 +1261,11 @@ PyObject *STR_RSPLIT2(PyObject *str, PyO
 
     CHECK_OBJECT(sep);
 
+    PyObject *called = str_builtin_rsplit;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sep};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_rsplit, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1020,8 +1276,11 @@ PyObject *STR_RSPLIT3(PyObject *str, PyO
     CHECK_OBJECT(sep);
     CHECK_OBJECT(maxsplit);
 
+    PyObject *called = str_builtin_rsplit;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, sep, maxsplit};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_rsplit, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1029,7 +1288,10 @@ PyObject *STR_RSTRIP1(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_rstrip, str);
+    PyObject *called = str_builtin_rstrip;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -1039,8 +1301,11 @@ PyObject *STR_RSTRIP2(PyObject *str, PyO
 
     CHECK_OBJECT(chars);
 
+    PyObject *called = str_builtin_rstrip;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, chars};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_rstrip, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1048,7 +1313,10 @@ PyObject *STR_SPLIT1(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_split, str);
+    PyObject *called = str_builtin_split;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -1058,8 +1326,11 @@ PyObject *STR_SPLIT2(PyObject *str, PyOb
 
     CHECK_OBJECT(sep);
 
+    PyObject *called = str_builtin_split;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, sep};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_split, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1070,8 +1341,36 @@ PyObject *STR_SPLIT3(PyObject *str, PyOb
     CHECK_OBJECT(sep);
     CHECK_OBJECT(maxsplit);
 
+    PyObject *called = str_builtin_split;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, sep, maxsplit};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_split, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
+
+    return result;
+}
+PyObject *STR_SPLITLINES1(PyObject *str) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    PyObject *called = str_builtin_splitlines;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
+
+    return result;
+}
+PyObject *STR_SPLITLINES2(PyObject *str, PyObject *keepends) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(keepends);
+
+    PyObject *called = str_builtin_splitlines;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {str, keepends};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1081,8 +1380,11 @@ PyObject *STR_STARTSWITH2(PyObject *str,
 
     CHECK_OBJECT(prefix);
 
+    PyObject *called = str_builtin_startswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, prefix};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_startswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1093,8 +1395,11 @@ PyObject *STR_STARTSWITH3(PyObject *str,
     CHECK_OBJECT(prefix);
     CHECK_OBJECT(start);
 
+    PyObject *called = str_builtin_startswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {str, prefix, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(str_builtin_startswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1106,8 +1411,11 @@ PyObject *STR_STARTSWITH4(PyObject *str,
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = str_builtin_startswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {str, prefix, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(str_builtin_startswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -1115,7 +1423,10 @@ PyObject *STR_STRIP1(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_strip, str);
+    PyObject *called = str_builtin_strip;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -1125,8 +1436,11 @@ PyObject *STR_STRIP2(PyObject *str, PyOb
 
     CHECK_OBJECT(chars);
 
+    PyObject *called = str_builtin_strip;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {str, chars};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(str_builtin_strip, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1134,7 +1448,10 @@ PyObject *STR_SWAPCASE(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_swapcase, str);
+    PyObject *called = str_builtin_swapcase;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
 
     return result;
 }
@@ -1142,7 +1459,24 @@ PyObject *STR_TITLE(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_title, str);
+    PyObject *called = str_builtin_title;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
+
+    return result;
+}
+PyObject *STR_TRANSLATE(PyObject *str, PyObject *table) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(table);
+
+    PyObject *called = str_builtin_translate;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {str, table};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1150,7 +1484,24 @@ PyObject *STR_UPPER(PyObject *str) {
     CHECK_OBJECT(str);
     assert(PyString_CheckExact(str));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(str_builtin_upper, str);
+    PyObject *called = str_builtin_upper;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, str);
+
+    return result;
+}
+PyObject *STR_ZFILL(PyObject *str, PyObject *width) {
+    CHECK_OBJECT(str);
+    assert(PyString_CheckExact(str));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = str_builtin_zfill;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {str, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1159,7 +1510,39 @@ PyObject *UNICODE_CAPITALIZE(PyObject *u
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_capitalize, unicode);
+    PyObject *called = unicode_builtin_capitalize;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
+
+    return result;
+}
+PyObject *UNICODE_CENTER2(PyObject *unicode, PyObject *width) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = unicode_builtin_center;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {unicode, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
+
+    return result;
+}
+PyObject *UNICODE_CENTER3(PyObject *unicode, PyObject *width, PyObject *fillchar) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(width);
+    CHECK_OBJECT(fillchar);
+
+    PyObject *called = unicode_builtin_center;
+    CHECK_OBJECT(called);
+
+    PyObject *args[3] = {unicode, width, fillchar};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1169,8 +1552,11 @@ PyObject *UNICODE_COUNT2(PyObject *unico
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = unicode_builtin_count;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_count, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1181,8 +1567,11 @@ PyObject *UNICODE_COUNT3(PyObject *unico
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = unicode_builtin_count;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_count, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1194,8 +1583,11 @@ PyObject *UNICODE_COUNT4(PyObject *unico
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = unicode_builtin_count;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_count, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -1203,7 +1595,10 @@ PyObject *UNICODE_ENCODE1(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_encode, unicode);
+    PyObject *called = unicode_builtin_encode;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1213,8 +1608,11 @@ PyObject *UNICODE_ENCODE2(PyObject *unic
 
     CHECK_OBJECT(encoding);
 
+    PyObject *called = unicode_builtin_encode;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, encoding};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_encode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1225,8 +1623,11 @@ PyObject *UNICODE_ENCODE3(PyObject *unic
     CHECK_OBJECT(encoding);
     CHECK_OBJECT(errors);
 
+    PyObject *called = unicode_builtin_encode;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, encoding, errors};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_encode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1236,8 +1637,11 @@ PyObject *UNICODE_ENDSWITH2(PyObject *un
 
     CHECK_OBJECT(suffix);
 
+    PyObject *called = unicode_builtin_endswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, suffix};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_endswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1248,8 +1652,11 @@ PyObject *UNICODE_ENDSWITH3(PyObject *un
     CHECK_OBJECT(suffix);
     CHECK_OBJECT(start);
 
+    PyObject *called = unicode_builtin_endswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, suffix, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_endswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1261,8 +1668,36 @@ PyObject *UNICODE_ENDSWITH4(PyObject *un
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = unicode_builtin_endswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, suffix, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_endswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
+
+    return result;
+}
+PyObject *UNICODE_EXPANDTABS1(PyObject *unicode) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    PyObject *called = unicode_builtin_expandtabs;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
+
+    return result;
+}
+PyObject *UNICODE_EXPANDTABS2(PyObject *unicode, PyObject *tabsize) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(tabsize);
+
+    PyObject *called = unicode_builtin_expandtabs;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {unicode, tabsize};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1272,8 +1707,11 @@ PyObject *UNICODE_FIND2(PyObject *unicod
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = unicode_builtin_find;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_find, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1284,8 +1722,11 @@ PyObject *UNICODE_FIND3(PyObject *unicod
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = unicode_builtin_find;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_find, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1297,8 +1738,11 @@ PyObject *UNICODE_FIND4(PyObject *unicod
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = unicode_builtin_find;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_find, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -1308,8 +1752,11 @@ PyObject *UNICODE_INDEX2(PyObject *unico
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = unicode_builtin_index;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_index, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1320,8 +1767,11 @@ PyObject *UNICODE_INDEX3(PyObject *unico
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = unicode_builtin_index;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_index, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1333,8 +1783,11 @@ PyObject *UNICODE_INDEX4(PyObject *unico
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = unicode_builtin_index;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_index, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -1342,7 +1795,10 @@ PyObject *UNICODE_ISALNUM(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_isalnum, unicode);
+    PyObject *called = unicode_builtin_isalnum;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1350,7 +1806,10 @@ PyObject *UNICODE_ISALPHA(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_isalpha, unicode);
+    PyObject *called = unicode_builtin_isalpha;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1358,7 +1817,10 @@ PyObject *UNICODE_ISDIGIT(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_isdigit, unicode);
+    PyObject *called = unicode_builtin_isdigit;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1366,7 +1828,10 @@ PyObject *UNICODE_ISLOWER(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_islower, unicode);
+    PyObject *called = unicode_builtin_islower;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1374,7 +1839,10 @@ PyObject *UNICODE_ISSPACE(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_isspace, unicode);
+    PyObject *called = unicode_builtin_isspace;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1382,7 +1850,10 @@ PyObject *UNICODE_ISTITLE(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_istitle, unicode);
+    PyObject *called = unicode_builtin_istitle;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1390,7 +1861,39 @@ PyObject *UNICODE_ISUPPER(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_isupper, unicode);
+    PyObject *called = unicode_builtin_isupper;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
+
+    return result;
+}
+PyObject *UNICODE_LJUST2(PyObject *unicode, PyObject *width) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = unicode_builtin_ljust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {unicode, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
+
+    return result;
+}
+PyObject *UNICODE_LJUST3(PyObject *unicode, PyObject *width, PyObject *fillchar) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(width);
+    CHECK_OBJECT(fillchar);
+
+    PyObject *called = unicode_builtin_ljust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[3] = {unicode, width, fillchar};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1398,7 +1901,10 @@ PyObject *UNICODE_LOWER(PyObject *unicod
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_lower, unicode);
+    PyObject *called = unicode_builtin_lower;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1406,7 +1912,10 @@ PyObject *UNICODE_LSTRIP1(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_lstrip, unicode);
+    PyObject *called = unicode_builtin_lstrip;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1416,8 +1925,11 @@ PyObject *UNICODE_LSTRIP2(PyObject *unic
 
     CHECK_OBJECT(chars);
 
+    PyObject *called = unicode_builtin_lstrip;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, chars};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_lstrip, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1428,8 +1940,11 @@ PyObject *UNICODE_REPLACE3(PyObject *uni
     CHECK_OBJECT(old);
     CHECK_OBJECT(new_value);
 
+    PyObject *called = unicode_builtin_replace;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, old, new_value};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_replace, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1441,8 +1956,11 @@ PyObject *UNICODE_REPLACE4(PyObject *uni
     CHECK_OBJECT(new_value);
     CHECK_OBJECT(count);
 
+    PyObject *called = unicode_builtin_replace;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, old, new_value, count};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_replace, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -1452,8 +1970,11 @@ PyObject *UNICODE_RFIND2(PyObject *unico
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = unicode_builtin_rfind;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_rfind, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1464,8 +1985,11 @@ PyObject *UNICODE_RFIND3(PyObject *unico
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = unicode_builtin_rfind;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_rfind, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1477,8 +2001,11 @@ PyObject *UNICODE_RFIND4(PyObject *unico
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = unicode_builtin_rfind;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_rfind, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -1488,8 +2015,11 @@ PyObject *UNICODE_RINDEX2(PyObject *unic
 
     CHECK_OBJECT(sub);
 
+    PyObject *called = unicode_builtin_rindex;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, sub};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_rindex, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1500,8 +2030,11 @@ PyObject *UNICODE_RINDEX3(PyObject *unic
     CHECK_OBJECT(sub);
     CHECK_OBJECT(start);
 
+    PyObject *called = unicode_builtin_rindex;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, sub, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_rindex, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1513,8 +2046,40 @@ PyObject *UNICODE_RINDEX4(PyObject *unic
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = unicode_builtin_rindex;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, sub, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_rindex, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
+
+    return result;
+}
+PyObject *UNICODE_RJUST2(PyObject *unicode, PyObject *width) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = unicode_builtin_rjust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {unicode, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
+
+    return result;
+}
+PyObject *UNICODE_RJUST3(PyObject *unicode, PyObject *width, PyObject *fillchar) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(width);
+    CHECK_OBJECT(fillchar);
+
+    PyObject *called = unicode_builtin_rjust;
+    CHECK_OBJECT(called);
+
+    PyObject *args[3] = {unicode, width, fillchar};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1522,7 +2087,10 @@ PyObject *UNICODE_RSPLIT1(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_rsplit, unicode);
+    PyObject *called = unicode_builtin_rsplit;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1532,8 +2100,11 @@ PyObject *UNICODE_RSPLIT2(PyObject *unic
 
     CHECK_OBJECT(sep);
 
+    PyObject *called = unicode_builtin_rsplit;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, sep};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_rsplit, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1544,8 +2115,11 @@ PyObject *UNICODE_RSPLIT3(PyObject *unic
     CHECK_OBJECT(sep);
     CHECK_OBJECT(maxsplit);
 
+    PyObject *called = unicode_builtin_rsplit;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, sep, maxsplit};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_rsplit, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1553,7 +2127,10 @@ PyObject *UNICODE_RSTRIP1(PyObject *unic
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_rstrip, unicode);
+    PyObject *called = unicode_builtin_rstrip;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1563,8 +2140,11 @@ PyObject *UNICODE_RSTRIP2(PyObject *unic
 
     CHECK_OBJECT(chars);
 
+    PyObject *called = unicode_builtin_rstrip;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, chars};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_rstrip, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1572,7 +2152,10 @@ PyObject *UNICODE_SPLIT1(PyObject *unico
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_split, unicode);
+    PyObject *called = unicode_builtin_split;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1582,8 +2165,11 @@ PyObject *UNICODE_SPLIT2(PyObject *unico
 
     CHECK_OBJECT(sep);
 
+    PyObject *called = unicode_builtin_split;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, sep};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_split, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1594,8 +2180,36 @@ PyObject *UNICODE_SPLIT3(PyObject *unico
     CHECK_OBJECT(sep);
     CHECK_OBJECT(maxsplit);
 
+    PyObject *called = unicode_builtin_split;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, sep, maxsplit};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_split, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
+
+    return result;
+}
+PyObject *UNICODE_SPLITLINES1(PyObject *unicode) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    PyObject *called = unicode_builtin_splitlines;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
+
+    return result;
+}
+PyObject *UNICODE_SPLITLINES2(PyObject *unicode, PyObject *keepends) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(keepends);
+
+    PyObject *called = unicode_builtin_splitlines;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {unicode, keepends};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1605,8 +2219,11 @@ PyObject *UNICODE_STARTSWITH2(PyObject *
 
     CHECK_OBJECT(prefix);
 
+    PyObject *called = unicode_builtin_startswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, prefix};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_startswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1617,8 +2234,11 @@ PyObject *UNICODE_STARTSWITH3(PyObject *
     CHECK_OBJECT(prefix);
     CHECK_OBJECT(start);
 
+    PyObject *called = unicode_builtin_startswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {unicode, prefix, start};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(unicode_builtin_startswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
@@ -1630,8 +2250,11 @@ PyObject *UNICODE_STARTSWITH4(PyObject *
     CHECK_OBJECT(start);
     CHECK_OBJECT(end);
 
+    PyObject *called = unicode_builtin_startswith;
+    CHECK_OBJECT(called);
+
     PyObject *args[4] = {unicode, prefix, start, end};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(unicode_builtin_startswith, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS4(called, args);
 
     return result;
 }
@@ -1639,7 +2262,10 @@ PyObject *UNICODE_STRIP1(PyObject *unico
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_strip, unicode);
+    PyObject *called = unicode_builtin_strip;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1649,8 +2275,11 @@ PyObject *UNICODE_STRIP2(PyObject *unico
 
     CHECK_OBJECT(chars);
 
+    PyObject *called = unicode_builtin_strip;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {unicode, chars};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(unicode_builtin_strip, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1658,7 +2287,10 @@ PyObject *UNICODE_SWAPCASE(PyObject *uni
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_swapcase, unicode);
+    PyObject *called = unicode_builtin_swapcase;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
 
     return result;
 }
@@ -1666,7 +2298,24 @@ PyObject *UNICODE_TITLE(PyObject *unicod
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_title, unicode);
+    PyObject *called = unicode_builtin_title;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
+
+    return result;
+}
+PyObject *UNICODE_TRANSLATE(PyObject *unicode, PyObject *table) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(table);
+
+    PyObject *called = unicode_builtin_translate;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {unicode, table};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1674,7 +2323,24 @@ PyObject *UNICODE_UPPER(PyObject *unicod
     CHECK_OBJECT(unicode);
     assert(PyUnicode_CheckExact(unicode));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(unicode_builtin_upper, unicode);
+    PyObject *called = unicode_builtin_upper;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, unicode);
+
+    return result;
+}
+PyObject *UNICODE_ZFILL(PyObject *unicode, PyObject *width) {
+    CHECK_OBJECT(unicode);
+    assert(PyUnicode_CheckExact(unicode));
+
+    CHECK_OBJECT(width);
+
+    PyObject *called = unicode_builtin_zfill;
+    CHECK_OBJECT(called);
+
+    PyObject *args[2] = {unicode, width};
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1683,7 +2349,10 @@ PyObject *BYTES_DECODE1(PyObject *bytes)
     CHECK_OBJECT(bytes);
     assert(PyBytes_CheckExact(bytes));
 
-    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(bytes_builtin_decode, bytes);
+    PyObject *called = bytes_builtin_decode;
+    CHECK_OBJECT(called);
+
+    PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(called, bytes);
 
     return result;
 }
@@ -1693,8 +2362,11 @@ PyObject *BYTES_DECODE2(PyObject *bytes,
 
     CHECK_OBJECT(encoding);
 
+    PyObject *called = bytes_builtin_decode;
+    CHECK_OBJECT(called);
+
     PyObject *args[2] = {bytes, encoding};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(bytes_builtin_decode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS2(called, args);
 
     return result;
 }
@@ -1705,8 +2377,11 @@ PyObject *BYTES_DECODE3(PyObject *bytes,
     CHECK_OBJECT(encoding);
     CHECK_OBJECT(errors);
 
+    PyObject *called = bytes_builtin_decode;
+    CHECK_OBJECT(called);
+
     PyObject *args[3] = {bytes, encoding, errors};
-    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(bytes_builtin_decode, args);
+    PyObject *result = CALL_METHODDESCR_WITH_ARGS3(called, args);
 
     return result;
 }
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/HelpersCalling2.c 1.0.1+ds-1/nuitka/build/static_src/HelpersCalling2.c
--- 0.9.5+ds-1/nuitka/build/static_src/HelpersCalling2.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/HelpersCalling2.c	2022-07-30 17:47:39.000000000 +0000
@@ -99,6 +99,7 @@ PyObject *CALL_FUNCTION_NO_ARGS(PyObject
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -169,8 +170,12 @@ PyObject *CALL_FUNCTION_NO_ARGS(PyObject
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return _fast_function_noargs(called);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -272,6 +277,7 @@ PyObject *CALL_FUNCTION_NO_ARGS(PyObject
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -325,7 +331,7 @@ PyObject *CALL_FUNCTION_NO_ARGS(PyObject
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -447,6 +453,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -521,8 +528,12 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 1);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -639,6 +650,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -695,7 +707,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -823,6 +835,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS1(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -889,8 +902,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS1(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 1);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -997,6 +1014,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS1(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -1053,7 +1071,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS1(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -1178,6 +1196,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -1238,8 +1257,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 2);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -1349,6 +1372,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -1405,7 +1429,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -1537,6 +1561,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS2(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -1589,8 +1614,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS2(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 2);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -1690,6 +1719,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS2(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -1746,7 +1776,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS2(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -1871,6 +1901,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -1931,8 +1962,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 3);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -2042,6 +2077,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -2098,7 +2134,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -2230,6 +2266,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS3(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -2282,8 +2319,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS3(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 3);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -2383,6 +2424,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS3(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -2439,7 +2481,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS3(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -2564,6 +2606,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -2624,8 +2667,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 4);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -2735,6 +2782,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -2791,7 +2839,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -2923,6 +2971,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -2975,8 +3024,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 4);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -3076,6 +3129,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -3132,7 +3186,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -3257,6 +3311,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -3317,8 +3372,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 5);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -3428,6 +3487,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -3484,7 +3544,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -3616,6 +3676,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS5(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -3668,8 +3729,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS5(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 5);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -3769,6 +3834,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS5(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -3825,7 +3891,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS5(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -3950,6 +4016,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -4010,8 +4077,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 6);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -4121,6 +4192,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -4177,7 +4249,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -4309,6 +4381,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS6(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -4361,8 +4434,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS6(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 6);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -4462,6 +4539,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS6(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -4518,7 +4596,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS6(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -4643,6 +4721,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -4703,8 +4782,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 7);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -4814,6 +4897,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -4870,7 +4954,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -5002,6 +5086,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS7(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -5054,8 +5139,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS7(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 7);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -5155,6 +5244,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS7(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -5211,7 +5301,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS7(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -5336,6 +5426,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -5396,8 +5487,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 8);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -5507,6 +5602,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -5563,7 +5659,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -5695,6 +5791,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS8(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -5747,8 +5844,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS8(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 8);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -5848,6 +5949,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS8(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -5904,7 +6006,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS8(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -6029,6 +6131,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyObj
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -6089,8 +6192,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyObj
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 9);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -6200,6 +6307,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyObj
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -6256,7 +6364,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9(PyObj
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -6388,6 +6496,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS9(Py
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -6440,8 +6549,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS9(Py
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 9);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -6541,6 +6654,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS9(Py
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -6597,7 +6711,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS9(Py
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -6722,6 +6836,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyOb
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -6782,8 +6897,12 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyOb
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 10);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -6893,6 +7012,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyOb
             Py_XDECREF(pos_args);
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -6949,7 +7069,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10(PyOb
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7081,6 +7201,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS10(P
 
             return result;
         }
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
@@ -7133,8 +7254,12 @@ PyObject *CALL_FUNCTION_WITH_POSARGS10(P
 
             return Nuitka_CheckFunctionResult(result);
         }
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
         return callPythonFunction(called, args, 10);
+#endif
+#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_TYPE_CREATION_OPT)
     } else if (PyType_Check(called)) {
         PyTypeObject *type = Py_TYPE(called);
 
@@ -7234,6 +7359,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS10(P
 
             return obj;
         }
+#endif
 #if PYTHON_VERSION < 0x300
     } else if (PyClass_Check(called)) {
         PyObject *obj = PyInstance_NewRaw(called, NULL);
@@ -7290,7 +7416,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS10(P
 
         return obj;
 #endif
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7334,7 +7460,7 @@ PyObject *CALL_FUNCTION_WITH_NO_ARGS_KWS
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7410,7 +7536,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS1_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7488,7 +7614,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS1_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7574,7 +7700,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS1_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7654,7 +7780,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7732,7 +7858,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS2_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7818,7 +7944,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS2_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7898,7 +8024,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -7976,7 +8102,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS3_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8062,7 +8188,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS3_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8142,7 +8268,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8220,7 +8346,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS4_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8306,7 +8432,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS4_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8386,7 +8512,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8464,7 +8590,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS5_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8550,7 +8676,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS5_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8630,7 +8756,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8708,7 +8834,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS6_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8794,7 +8920,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS6_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8874,7 +9000,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -8952,7 +9078,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS7_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9038,7 +9164,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS7_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9118,7 +9244,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9196,7 +9322,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS8_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9282,7 +9408,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS8_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9362,7 +9488,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9_VECTO
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9440,7 +9566,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS9_KWSPL
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9526,7 +9652,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS9_KW
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9606,7 +9732,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10_VECT
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9684,7 +9810,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS10_KWSP
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9770,7 +9896,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS10_K
         Py_LeaveRecursiveCall();
 
         return result;
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     } else if (PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL)) {
         vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
 
@@ -9834,7 +9960,7 @@ PyObject *CALL_METHODDESCR_WITH_SINGLE_A
     CHECK_OBJECT(called);
     CHECK_OBJECTS(args, 1);
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     assert(PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL));
     vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
     assert(func != NULL);
@@ -9917,7 +10043,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS2(Py
     CHECK_OBJECT(called);
     CHECK_OBJECTS(args, 2);
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     assert(PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL));
     vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
     assert(func != NULL);
@@ -10003,7 +10129,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS3(Py
     CHECK_OBJECT(called);
     CHECK_OBJECTS(args, 3);
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     assert(PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL));
     vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
     assert(func != NULL);
@@ -10086,7 +10212,7 @@ PyObject *CALL_METHODDESCR_WITH_ARGS4(Py
     CHECK_OBJECT(called);
     CHECK_OBJECTS(args, 4);
 
-#if PYTHON_VERSION >= 0x380
+#if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_USAGE)
     assert(PyType_HasFeature(Py_TYPE(called), _Py_TPFLAGS_HAVE_VECTORCALL));
     vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
     assert(func != NULL);
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/HelpersComparisonEq.c 1.0.1+ds-1/nuitka/build/static_src/HelpersComparisonEq.c
--- 0.9.5+ds-1/nuitka/build/static_src/HelpersComparisonEq.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/HelpersComparisonEq.c	2022-07-30 17:47:39.000000000 +0000
@@ -61,24 +61,6 @@ static bool COMPARE_EQ_CBOOL_INT_INT(PyO
     return result;
 }
 #endif
-#if PYTHON_VERSION < 0x300
-static nuitka_bool COMPARE_EQ_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyInt_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyInt_CheckExact(operand2));
-
-    const long a = PyInt_AS_LONG(operand1);
-    const long b = PyInt_AS_LONG(operand2);
-
-    bool r = a == b;
-
-    // Convert to target type.
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-}
-#endif
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
@@ -218,9 +200,11 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
@@ -252,7 +236,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
+            // Banking on C compile to optimize "strcmp".
             int s = strcmp(type1->tp_name, type2->tp_name);
 
             if (s < 0) {
@@ -382,29 +366,29 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
 }
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
 #if PYTHON_VERSION < 0x300
     if (PyInt_CheckExact(operand1) && PyInt_CheckExact(operand2)) {
-        return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2);
+        return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 #endif
 
     // Quick path for avoidable checks, compatible with CPython.
     if (operand1 == operand2 && IS_SANE_TYPE(Py_TYPE(operand1))) {
         bool r = true;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
@@ -424,11 +408,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -447,7 +431,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -474,7 +458,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -493,11 +477,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -515,11 +499,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -536,11 +520,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -552,9 +536,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
@@ -586,7 +572,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
+            // Banking on C compile to optimize "strcmp".
             int s = strcmp(type1->tp_name, type2->tp_name);
 
             if (s < 0) {
@@ -606,7 +592,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -631,7 +617,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
@@ -650,11 +636,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -673,11 +659,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -696,11 +682,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -717,13 +703,13 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
@@ -734,46 +720,83 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_OBJECT
         PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and '%s'", type1->tp_name,
                      type2->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
 
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
-
 #if PYTHON_VERSION < 0x300
-    if (PyInt_CheckExact(operand1) && PyInt_CheckExact(operand2)) {
-        return COMPARE_EQ_NBOOL_INT_INT(operand1, operand2);
-    }
-#endif
+static PyObject *COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyString_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyString_CheckExact(operand2));
 
-    // Quick path for avoidable checks, compatible with CPython.
-    if (operand1 == operand2 && IS_SANE_TYPE(Py_TYPE(operand1))) {
+    PyStringObject *a = (PyStringObject *)operand1;
+    PyStringObject *b = (PyStringObject *)operand2;
+
+    // Same object has fast path for all operations.
+    if (operand1 == operand2) {
         bool r = true;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
+        // Convert to target type.
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
+        return result;
+    }
+
+    Py_ssize_t len_a = Py_SIZE(operand1);
+    Py_ssize_t len_b = Py_SIZE(operand2);
+
+    if (len_a != len_b) {
+        bool r = false;
+
+        // Convert to target type.
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
+    } else {
+        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
+            bool r = true;
+
+            // Convert to target type.
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
+            return result;
+        } else {
+            bool r = false;
+
+            // Convert to target type.
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
+            return result;
+        }
+    }
+}
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyString_Type) {
+        return COMPARE_EQ_OBJECT_STR_STR(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !PyInstance_Check(operand1)) {
+    if (type1 == &PyString_Type && !0) {
 
-        richcmpfunc frich = RICHCOMPARE(type1);
+        richcmpfunc frich = PyString_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -781,22 +804,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = type1->tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -805,7 +820,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -832,8 +847,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -841,8 +856,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyString_Type && 0) {
+        f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -850,15 +865,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -872,36 +879,20 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = PyString_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -910,15 +901,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyString_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -935,7 +928,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyString_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -944,8 +937,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "str");
 
             if (s < 0) {
                 c = -1;
@@ -954,7 +947,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyString_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -964,7 +957,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -989,15 +982,15 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyString_Type && PyType_IsSubtype(&PyString_Type, type1)) {
+        f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -1007,15 +1000,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -1030,22 +1015,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -1053,15 +1030,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -1075,81 +1044,34 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == %s()", type1->tp_name, type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and '%s'", type1->tp_name,
-                     type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
 #endif
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 }
+#endif
 
 #if PYTHON_VERSION < 0x300
-static PyObject *COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyString_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyString_CheckExact(operand2));
-
-    PyStringObject *a = (PyStringObject *)operand1;
-    PyStringObject *b = (PyStringObject *)operand2;
-
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-
-    Py_ssize_t len_a = Py_SIZE(operand1);
-    Py_ssize_t len_b = Py_SIZE(operand2);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    } else {
-        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
-            bool r = true;
-
-            // Convert to target type.
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        } else {
-            bool r = false;
-
-            // Convert to target type.
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        }
-    }
-}
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyString_Type) {
-        return COMPARE_EQ_OBJECT_STR_STR(operand1, operand2);
+    if (&PyString_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_OBJECT_STR_STR(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
@@ -1162,12 +1084,11 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     }
 #endif
 
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyString_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyString_Type == type2 && !0) {
 
         richcmpfunc frich = PyString_Type.tp_richcompare;
 
@@ -1229,8 +1150,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyString_Type.tp_richcompare;
+    if (&PyString_Type != type2 && PyType_IsSubtype(type2, &PyString_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -1245,7 +1166,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyString_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -1258,7 +1179,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         Py_DECREF(result);
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -1273,16 +1194,18 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyString_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -1298,7 +1221,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyString_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -1308,8 +1231,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("str", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -1317,7 +1240,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyString_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -1360,8 +1283,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyString_Type.tp_richcompare;
+    if (&PyString_Type != type2 && PyType_IsSubtype(type2, &PyString_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -1378,7 +1301,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyString_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -1393,7 +1316,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     }
 
     if (checked_reverse_op == false) {
-        f = PyString_Type.tp_richcompare;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -1427,9 +1350,9 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
 #endif
         return NULL;
     }
@@ -1438,6 +1361,14 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
 #endif
 
 #if PYTHON_VERSION < 0x300
+/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_OBJECT_STR_STR(operand1, operand2);
+}
+#endif
+
+#if PYTHON_VERSION < 0x300
 static bool COMPARE_EQ_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2) {
     CHECK_OBJECT(operand1);
     assert(PyString_CheckExact(operand1));
@@ -1485,29 +1416,36 @@ static bool COMPARE_EQ_CBOOL_STR_STR(PyO
         }
     }
 }
+/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
+bool RICH_COMPARE_EQ_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_CBOOL_STR_STR(operand1, operand2);
+}
+#endif
+
+#if PYTHON_VERSION < 0x300
 /* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
 
     if (Py_TYPE(operand1) == &PyString_Type) {
-        return COMPARE_EQ_CBOOL_STR_STR(operand1, operand2);
+        return COMPARE_EQ_CBOOL_STR_STR(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyString_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyString_Type && !0) {
 
         richcmpfunc frich = PyString_Type.tp_richcompare;
 
@@ -1518,11 +1456,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -1541,7 +1479,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -1568,7 +1506,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -1577,7 +1515,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
+    if (type1 != &PyString_Type && 0) {
         f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
@@ -1587,11 +1525,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -1609,11 +1547,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -1630,11 +1568,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -1646,15 +1584,17 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyString_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -1671,7 +1611,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyString_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -1680,8 +1620,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "str");
 
             if (s < 0) {
                 c = -1;
@@ -1690,7 +1630,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyString_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -1700,7 +1640,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -1725,14 +1665,14 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (type1 != &PyString_Type && PyType_IsSubtype(&PyString_Type, type1)) {
         f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
@@ -1744,11 +1684,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -1767,11 +1707,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -1790,11 +1730,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -1811,13 +1751,13 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
@@ -1827,65 +1767,18 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_STR(Py
 #else
         PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
 #endif
 
 #if PYTHON_VERSION < 0x300
-static nuitka_bool COMPARE_EQ_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyString_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyString_CheckExact(operand2));
-
-    PyStringObject *a = (PyStringObject *)operand1;
-    PyStringObject *b = (PyStringObject *)operand2;
-
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
-
-        // Convert to target type.
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-
-    Py_ssize_t len_a = Py_SIZE(operand1);
-    Py_ssize_t len_b = Py_SIZE(operand2);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    } else {
-        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
-            bool r = true;
-
-            // Convert to target type.
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-            return result;
-        } else {
-            bool r = false;
-
-            // Convert to target type.
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-            return result;
-        }
-    }
-}
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyString_Type) {
-        return COMPARE_EQ_NBOOL_STR_STR(operand1, operand2);
+    if (&PyString_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_CBOOL_STR_STR(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
@@ -1898,12 +1791,11 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
 #endif
 
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyString_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyString_Type == type2 && !0) {
 
         richcmpfunc frich = PyString_Type.tp_richcompare;
 
@@ -1973,8 +1865,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyString_Type.tp_richcompare;
+    if (&PyString_Type != type2 && PyType_IsSubtype(type2, &PyString_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -1997,7 +1889,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyString_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -2018,7 +1910,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         Py_DECREF(result);
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -2041,16 +1933,18 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyString_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -2066,7 +1960,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyString_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -2076,8 +1970,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("str", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -2085,7 +1979,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyString_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -2128,8 +2022,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyString_Type.tp_richcompare;
+    if (&PyString_Type != type2 && PyType_IsSubtype(type2, &PyString_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -2154,7 +2048,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyString_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -2177,7 +2071,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
 
     if (checked_reverse_op == false) {
-        f = PyString_Type.tp_richcompare;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -2219,9 +2113,9 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
 #endif
         return NUITKA_BOOL_EXCEPTION;
     }
@@ -2229,47 +2123,120 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
 }
 #endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2) {
+static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyUnicode_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyUnicode_CheckExact(operand2));
 
-    if (&PyString_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_OBJECT_STR_STR(operand1, operand2);
-    }
+    PyUnicodeObject *a = (PyUnicodeObject *)operand1;
+    PyUnicodeObject *b = (PyUnicodeObject *)operand2;
 
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
+    // Same object has fast path for all operations.
+    if (operand1 == operand2) {
+        bool r = true;
+
+        // Convert to target type.
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
+        return result;
     }
-#endif
 
-    PyTypeObject *type1 = &PyString_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
+#if PYTHON_VERSION >= 0x300
+    bool r;
 
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
+    if (PyUnicode_GET_LENGTH(b) != len) {
+        r = false;
+    } else {
+        int kind1 = PyUnicode_KIND(a);
+        if (unlikely(kind1 == 0)) {
+            int res = _PyUnicode_Ready((PyObject *)a);
+            assert(res != -1);
+            kind1 = PyUnicode_KIND(a);
+            assert(kind1 != 0);
+        }
 
-        richcmpfunc frich = PyString_Type.tp_richcompare;
+        int kind2 = PyUnicode_KIND(b);
+        if (unlikely(kind2 == 0)) {
+            int res = _PyUnicode_Ready((PyObject *)b);
+            assert(res != -1);
+            kind2 = PyUnicode_KIND(b);
+            assert(kind2 != 0);
+        }
 
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
+        if (kind1 != kind2) {
+            r = false;
+        } else {
+            const void *data1 = PyUnicode_DATA(a);
+            const void *data2 = PyUnicode_DATA(b);
 
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
+            int cmp = memcmp(data1, data2, len * kind1);
+            r = (cmp == 0);
+        }
+    }
 
-                return result;
-            }
+    PyObject *result = BOOL_FROM(r == true);
+    Py_INCREF(result);
+    return result;
+#else
+    bool r;
+
+    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
+    if (PyUnicode_GET_LENGTH(b) != len) {
+        r = false;
+    } else {
+        const Py_UNICODE *data1 = a->str;
+        const Py_UNICODE *data2 = b->str;
+
+        int cmp = memcmp(data1, data2, len * sizeof(Py_UNICODE));
+        r = (cmp == 0);
+    }
+
+    PyObject *result = BOOL_FROM(r == true);
+    Py_INCREF(result);
+    return result;
+#endif
+}
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyUnicode_Type) {
+        return COMPARE_EQ_OBJECT_UNICODE_UNICODE(operand1, operand2);
+    }
+
+#if PYTHON_VERSION < 0x300
+    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
+        return NULL;
+    }
+#else
+    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
+        return NULL;
+    }
+#endif
+
+    PyTypeObject *type1 = Py_TYPE(operand1);
+
+#if PYTHON_VERSION < 0x300
+    // If the types are equal, we may get away immediately except for instances.
+    if (type1 == &PyUnicode_Type && !0) {
+
+        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
+
+        if (frich != NULL) {
+            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
+
+            if (result != Py_NotImplemented) {
+                Py_LeaveRecursiveCall();
+
+                return result;
+            }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyUnicode_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -2314,8 +2281,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyUnicode_Type && 0) {
+        f = PyUnicode_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -2330,7 +2297,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
         }
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -2343,7 +2310,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = PyUnicode_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -2358,16 +2325,18 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
 
     int c;
 
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (PyInstance_Check(operand1)) {
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyUnicode_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -2384,7 +2353,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyUnicode_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -2393,8 +2362,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, (PYTHON_VERSION < 0x300 ? "unicode" : "str"));
 
             if (s < 0) {
                 c = -1;
@@ -2403,7 +2372,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyUnicode_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -2445,8 +2414,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyUnicode_Type && PyType_IsSubtype(&PyUnicode_Type, type1)) {
+        f = PyUnicode_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -2463,7 +2432,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
         }
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -2478,7 +2447,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = PyUnicode_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -2511,43 +2480,42 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJ
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == unicode()", type1->tp_name);
+#elif PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
 #endif
         return NULL;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyString_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_STR_STR(operand1, operand2);
+    if (&PyUnicode_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_OBJECT_UNICODE_UNICODE(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NULL;
     }
 #endif
 
-    PyTypeObject *type1 = &PyString_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyUnicode_Type == type2 && !0) {
 
-        richcmpfunc frich = PyString_Type.tp_richcompare;
+        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -2555,22 +2523,14 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyUnicode_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -2579,7 +2539,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -2606,8 +2566,8 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
             }
 
             bool r = c != 0;
-            bool result = r;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -2615,7 +2575,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyUnicode_Type != type2 && PyType_IsSubtype(type2, &PyUnicode_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -2624,37 +2584,21 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = PyUnicode_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -2667,15 +2611,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -2684,15 +2620,17 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyUnicode_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -2708,7 +2646,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyUnicode_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -2718,8 +2656,8 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp((PYTHON_VERSION < 0x300 ? "unicode" : "str"), type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -2727,7 +2665,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyUnicode_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -2738,7 +2676,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -2763,14 +2701,14 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
     }
 
     bool r = c != 0;
-    bool result = r;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyUnicode_Type != type2 && PyType_IsSubtype(type2, &PyUnicode_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -2781,22 +2719,14 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = PyUnicode_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -2804,15 +2734,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -2827,15 +2749,7 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -2849,77 +2763,165 @@ bool RICH_COMPARE_EQ_CBOOL_STR_OBJECT(Py
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x360
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "unorderable types: unicode() == %s()", type2->tp_name);
+#elif PYTHON_VERSION < 0x360
         PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
 #else
         PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
 #endif
-        return false;
+        return NULL;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
+ * Python3 'str'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyString_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_NBOOL_STR_STR(operand1, operand2);
-    }
+    return COMPARE_EQ_OBJECT_UNICODE_UNICODE(operand1, operand2);
+}
 
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
+static bool COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyUnicode_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyUnicode_CheckExact(operand2));
 
-    PyTypeObject *type1 = &PyString_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
+    PyUnicodeObject *a = (PyUnicodeObject *)operand1;
+    PyUnicodeObject *b = (PyUnicodeObject *)operand2;
 
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    // Same object has fast path for all operations.
+    if (operand1 == operand2) {
+        bool r = true;
 
-        richcmpfunc frich = PyString_Type.tp_richcompare;
+        // Convert to target type.
+        bool result = r;
 
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
+        return result;
+    }
 
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
+#if PYTHON_VERSION >= 0x300
+    bool r;
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
+    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
+    if (PyUnicode_GET_LENGTH(b) != len) {
+        r = false;
+    } else {
+        int kind1 = PyUnicode_KIND(a);
+        if (unlikely(kind1 == 0)) {
+            int res = _PyUnicode_Ready((PyObject *)a);
+            assert(res != -1);
+            kind1 = PyUnicode_KIND(a);
+            assert(kind1 != 0);
+        }
 
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
+        int kind2 = PyUnicode_KIND(b);
+        if (unlikely(kind2 == 0)) {
+            int res = _PyUnicode_Ready((PyObject *)b);
+            assert(res != -1);
+            kind2 = PyUnicode_KIND(b);
+            assert(kind2 != 0);
+        }
+
+        if (kind1 != kind2) {
+            r = false;
+        } else {
+            const void *data1 = PyUnicode_DATA(a);
+            const void *data2 = PyUnicode_DATA(b);
+
+            int cmp = memcmp(data1, data2, len * kind1);
+            r = (cmp == 0);
+        }
+    }
+
+    bool result = r == true;
+
+    return result;
+#else
+    bool r;
+
+    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
+    if (PyUnicode_GET_LENGTH(b) != len) {
+        r = false;
+    } else {
+        const Py_UNICODE *data1 = a->str;
+        const Py_UNICODE *data2 = b->str;
+
+        int cmp = memcmp(data1, data2, len * sizeof(Py_UNICODE));
+        r = (cmp == 0);
+    }
+
+    bool result = r == true;
+
+    return result;
+#endif
+}
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
+ * Python3 'str'. */
+bool RICH_COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_CBOOL_UNICODE_UNICODE(operand1, operand2);
+}
+
+/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyUnicode_Type) {
+        return COMPARE_EQ_CBOOL_UNICODE_UNICODE(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+    }
+
+#if PYTHON_VERSION < 0x300
+    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
+        return NUITKA_BOOL_EXCEPTION;
+    }
+#else
+    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
+        return NUITKA_BOOL_EXCEPTION;
+    }
+#endif
+
+    PyTypeObject *type1 = Py_TYPE(operand1);
+
+#if PYTHON_VERSION < 0x300
+    // If the types are equal, we may get away immediately except for instances.
+    if (type1 == &PyUnicode_Type && !0) {
+
+        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
+
+        if (frich != NULL) {
+            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
+
+            if (result != Py_NotImplemented) {
+                Py_LeaveRecursiveCall();
+
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
+            }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyUnicode_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -2964,8 +2966,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyUnicode_Type && 0) {
+        f = PyUnicode_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -2988,7 +2990,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
         }
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -3009,7 +3011,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = PyUnicode_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -3032,16 +3034,18 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
 
     int c;
 
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (PyInstance_Check(operand1)) {
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyUnicode_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -3058,7 +3062,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyUnicode_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -3067,8 +3071,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, (PYTHON_VERSION < 0x300 ? "unicode" : "str"));
 
             if (s < 0) {
                 c = -1;
@@ -3077,7 +3081,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyUnicode_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -3119,8 +3123,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyUnicode_Type && PyType_IsSubtype(&PyUnicode_Type, type1)) {
+        f = PyUnicode_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -3145,7 +3149,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
         }
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -3168,7 +3172,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = PyUnicode_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -3209,139 +3213,40 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OB
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == unicode()", type1->tp_name);
+#elif PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
 #endif
         return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_OBJECT_STR_STR(operand1, operand2);
-}
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-bool RICH_COMPARE_EQ_CBOOL_STR_STR(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_CBOOL_STR_STR(operand1, operand2);
-}
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "STR" corresponds to Python2 'str' and "STR" to Python2 'str'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_STR(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_NBOOL_STR_STR(operand1, operand2);
-}
-#endif
-
-static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyUnicode_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyUnicode_CheckExact(operand2));
-
-    PyUnicodeObject *a = (PyUnicodeObject *)operand1;
-    PyUnicodeObject *b = (PyUnicodeObject *)operand2;
-
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
-
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-
-#if PYTHON_VERSION >= 0x300
-    bool r;
-
-    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
-    if (PyUnicode_GET_LENGTH(b) != len) {
-        r = false;
-    } else {
-        int kind1 = PyUnicode_KIND(a);
-        if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
-            assert(res != -1);
-            kind1 = PyUnicode_KIND(a);
-            assert(kind1 != 0);
-        }
-
-        int kind2 = PyUnicode_KIND(b);
-        if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
-            assert(res != -1);
-            kind2 = PyUnicode_KIND(b);
-            assert(kind2 != 0);
-        }
-
-        if (kind1 != kind2) {
-            r = false;
-        } else {
-            const void *data1 = PyUnicode_DATA(a);
-            const void *data2 = PyUnicode_DATA(b);
 
-            int cmp = memcmp(data1, data2, len * kind1);
-            r = (cmp == 0);
-        }
-    }
-
-    PyObject *result = BOOL_FROM(r == true);
-    Py_INCREF(result);
-    return result;
-#else
-    bool r;
-
-    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
-    if (PyUnicode_GET_LENGTH(b) != len) {
-        r = false;
-    } else {
-        const Py_UNICODE *data1 = a->str;
-        const Py_UNICODE *data2 = b->str;
-
-        int cmp = memcmp(data1, data2, len * sizeof(Py_UNICODE));
-        r = (cmp == 0);
-    }
-
-    PyObject *result = BOOL_FROM(r == true);
-    Py_INCREF(result);
-    return result;
-#endif
-}
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyUnicode_Type) {
-        return COMPARE_EQ_OBJECT_UNICODE_UNICODE(operand1, operand2);
+    if (&PyUnicode_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_CBOOL_UNICODE_UNICODE(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyUnicode_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyUnicode_Type == type2 && !0) {
 
         richcmpfunc frich = PyUnicode_Type.tp_richcompare;
 
@@ -3351,7 +3256,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -3367,7 +3280,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NULL;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -3394,8 +3307,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             }
 
             bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
             return result;
         }
     }
@@ -3403,8 +3316,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyUnicode_Type.tp_richcompare;
+    if (&PyUnicode_Type != type2 && PyType_IsSubtype(type2, &PyUnicode_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -3412,34 +3325,58 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
-            }
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
 
-            Py_DECREF(result);
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
+            }
+
+            Py_DECREF(result);
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyUnicode_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
@@ -3447,16 +3384,18 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyUnicode_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -3472,7 +3411,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyUnicode_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -3482,8 +3421,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp((PYTHON_VERSION < 0x300 ? "unicode" : "str"), type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -3491,7 +3430,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyUnicode_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -3502,7 +3441,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -3527,15 +3466,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     }
 
     bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyUnicode_Type.tp_richcompare;
+    if (&PyUnicode_Type != type2 && PyType_IsSubtype(type2, &PyUnicode_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -3545,14 +3484,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyUnicode_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -3560,14 +3507,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = PyUnicode_Type.tp_richcompare;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -3575,7 +3530,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -3589,129 +3552,101 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == unicode()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: unicode() == %s()", type2->tp_name);
 #elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
 #endif
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
 
-static bool COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
+#if PYTHON_VERSION >= 0x300
+static PyObject *COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
     CHECK_OBJECT(operand1);
-    assert(PyUnicode_CheckExact(operand1));
+    assert(PyBytes_CheckExact(operand1));
     CHECK_OBJECT(operand2);
-    assert(PyUnicode_CheckExact(operand2));
+    assert(PyBytes_CheckExact(operand2));
 
-    PyUnicodeObject *a = (PyUnicodeObject *)operand1;
-    PyUnicodeObject *b = (PyUnicodeObject *)operand2;
+    PyBytesObject *a = (PyBytesObject *)operand1;
+    PyBytesObject *b = (PyBytesObject *)operand2;
 
     // Same object has fast path for all operations.
     if (operand1 == operand2) {
         bool r = true;
 
         // Convert to target type.
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
 
-#if PYTHON_VERSION >= 0x300
-    bool r;
+    Py_ssize_t len_a = Py_SIZE(operand1);
+    Py_ssize_t len_b = Py_SIZE(operand2);
 
-    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
-    if (PyUnicode_GET_LENGTH(b) != len) {
-        r = false;
-    } else {
-        int kind1 = PyUnicode_KIND(a);
-        if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
-            assert(res != -1);
-            kind1 = PyUnicode_KIND(a);
-            assert(kind1 != 0);
-        }
+    if (len_a != len_b) {
+        bool r = false;
 
-        int kind2 = PyUnicode_KIND(b);
-        if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
-            assert(res != -1);
-            kind2 = PyUnicode_KIND(b);
-            assert(kind2 != 0);
-        }
+        // Convert to target type.
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
+        return result;
+    } else {
+        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
+            bool r = true;
 
-        if (kind1 != kind2) {
-            r = false;
+            // Convert to target type.
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
+            return result;
         } else {
-            const void *data1 = PyUnicode_DATA(a);
-            const void *data2 = PyUnicode_DATA(b);
+            bool r = false;
 
-            int cmp = memcmp(data1, data2, len * kind1);
-            r = (cmp == 0);
+            // Convert to target type.
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
+            return result;
         }
     }
-
-    bool result = r == true;
-
-    return result;
-#else
-    bool r;
-
-    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
-    if (PyUnicode_GET_LENGTH(b) != len) {
-        r = false;
-    } else {
-        const Py_UNICODE *data1 = a->str;
-        const Py_UNICODE *data2 = b->str;
-
-        int cmp = memcmp(data1, data2, len * sizeof(Py_UNICODE));
-        r = (cmp == 0);
-    }
-
-    bool result = r == true;
-
-    return result;
-#endif
 }
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyUnicode_Type) {
-        return COMPARE_EQ_CBOOL_UNICODE_UNICODE(operand1, operand2);
+    if (Py_TYPE(operand1) == &PyBytes_Type) {
+        return COMPARE_EQ_OBJECT_BYTES_BYTES(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NULL;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyUnicode_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyBytes_Type && !0) {
 
-        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
+        richcmpfunc frich = PyBytes_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -3719,22 +3654,14 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -3743,7 +3670,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -3770,8 +3697,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             }
 
             bool r = c != 0;
-            bool result = r;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -3779,8 +3706,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyUnicode_Type.tp_richcompare;
+    if (type1 != &PyBytes_Type && 0) {
+        f = PyBytes_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -3788,15 +3715,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -3810,36 +3729,20 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = PyBytes_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -3848,15 +3751,17 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyBytes_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -3873,7 +3778,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyBytes_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -3882,8 +3787,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "bytes");
 
             if (s < 0) {
                 c = -1;
@@ -3892,7 +3797,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyBytes_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -3902,7 +3807,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -3927,15 +3832,15 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
     }
 
     bool r = c != 0;
-    bool result = r;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyUnicode_Type.tp_richcompare;
+    if (type1 != &PyBytes_Type && PyType_IsSubtype(&PyBytes_Type, type1)) {
+        f = PyBytes_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -3945,16 +3850,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
+                return result;
+            }
 
             Py_DECREF(result);
         }
@@ -3968,22 +3865,14 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = PyUnicode_Type.tp_richcompare;
+        f = PyBytes_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -3991,15 +3880,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -4013,129 +3894,53 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_UNICOD
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == unicode()", type1->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
+#if PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == bytes()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'bytes'", type1->tp_name);
 #endif
-        return false;
+        return NULL;
     }
 #endif
 }
-
-static nuitka_bool COMPARE_EQ_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyUnicode_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyUnicode_CheckExact(operand2));
-
-    PyUnicodeObject *a = (PyUnicodeObject *)operand1;
-    PyUnicodeObject *b = (PyUnicodeObject *)operand2;
-
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
-
-        // Convert to target type.
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
+#endif
 
 #if PYTHON_VERSION >= 0x300
-    bool r;
-
-    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
-    if (PyUnicode_GET_LENGTH(b) != len) {
-        r = false;
-    } else {
-        int kind1 = PyUnicode_KIND(a);
-        if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
-            assert(res != -1);
-            kind1 = PyUnicode_KIND(a);
-            assert(kind1 != 0);
-        }
-
-        int kind2 = PyUnicode_KIND(b);
-        if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
-            assert(res != -1);
-            kind2 = PyUnicode_KIND(b);
-            assert(kind2 != 0);
-        }
-
-        if (kind1 != kind2) {
-            r = false;
-        } else {
-            const void *data1 = PyUnicode_DATA(a);
-            const void *data2 = PyUnicode_DATA(b);
-
-            int cmp = memcmp(data1, data2, len * kind1);
-            r = (cmp == 0);
-        }
-    }
-
-    nuitka_bool result = r == true ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-#else
-    bool r;
-
-    Py_ssize_t len = PyUnicode_GET_LENGTH(a);
-    if (PyUnicode_GET_LENGTH(b) != len) {
-        r = false;
-    } else {
-        const Py_UNICODE *data1 = a->str;
-        const Py_UNICODE *data2 = b->str;
-
-        int cmp = memcmp(data1, data2, len * sizeof(Py_UNICODE));
-        r = (cmp == 0);
-    }
-
-    nuitka_bool result = r == true ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-#endif
-}
-/* Code referring to "OBJECT" corresponds to any Python object and "UNICODE" to Python2 'unicode', Python3 'str'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyUnicode_Type) {
-        return COMPARE_EQ_NBOOL_UNICODE_UNICODE(operand1, operand2);
+    if (&PyBytes_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_OBJECT_BYTES_BYTES(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyUnicode_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyBytes_Type == type2 && !0) {
 
-        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
+        richcmpfunc frich = PyBytes_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -4143,22 +3948,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -4167,7 +3964,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -4194,8 +3991,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -4203,8 +4000,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyUnicode_Type.tp_richcompare;
+    if (&PyBytes_Type != type2 && PyType_IsSubtype(type2, &PyBytes_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -4212,58 +4009,34 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyBytes_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -4271,16 +4044,18 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyBytes_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -4296,7 +4071,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyBytes_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -4306,8 +4081,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("bytes", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -4315,7 +4090,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyBytes_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -4326,7 +4101,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -4351,15 +4126,15 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyUnicode_Type.tp_richcompare;
+    if (&PyBytes_Type != type2 && PyType_IsSubtype(type2, &PyBytes_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -4369,22 +4144,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyBytes_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -4392,22 +4159,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = PyUnicode_Type.tp_richcompare;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -4415,15 +4174,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -4437,54 +4188,116 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == unicode()", type1->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == str()", type1->tp_name);
+#if PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: bytes() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'bytes' and '%s'", type2->tp_name);
 #endif
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 }
+#endif
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2) {
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyUnicode_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_OBJECT_UNICODE_UNICODE(operand1, operand2);
+    return COMPARE_EQ_OBJECT_BYTES_BYTES(operand1, operand2);
+}
+#endif
+
+#if PYTHON_VERSION >= 0x300
+static bool COMPARE_EQ_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyBytes_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyBytes_CheckExact(operand2));
+
+    PyBytesObject *a = (PyBytesObject *)operand1;
+    PyBytesObject *b = (PyBytesObject *)operand2;
+
+    // Same object has fast path for all operations.
+    if (operand1 == operand2) {
+        bool r = true;
+
+        // Convert to target type.
+        bool result = r;
+
+        return result;
+    }
+
+    Py_ssize_t len_a = Py_SIZE(operand1);
+    Py_ssize_t len_b = Py_SIZE(operand2);
+
+    if (len_a != len_b) {
+        bool r = false;
+
+        // Convert to target type.
+        bool result = r;
+
+        return result;
+    } else {
+        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
+            bool r = true;
+
+            // Convert to target type.
+            bool result = r;
+
+            return result;
+        } else {
+            bool r = false;
+
+            // Convert to target type.
+            bool result = r;
+
+            return result;
+        }
+    }
+}
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
+bool RICH_COMPARE_EQ_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_CBOOL_BYTES_BYTES(operand1, operand2);
+}
+#endif
+
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyBytes_Type) {
+        return COMPARE_EQ_CBOOL_BYTES_BYTES(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = &PyUnicode_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
+    PyTypeObject *type1 = Py_TYPE(operand1);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyBytes_Type && !0) {
 
-        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
+        richcmpfunc frich = PyBytes_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -4492,14 +4305,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -4508,7 +4329,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NULL;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -4535,8 +4356,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             }
 
             bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
             return result;
         }
     }
@@ -4544,8 +4365,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyBytes_Type && 0) {
+        f = PyBytes_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -4553,34 +4374,58 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = PyBytes_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
@@ -4588,16 +4433,18 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
 
     int c;
 
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (PyInstance_Check(operand1)) {
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyBytes_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -4614,7 +4461,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyBytes_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -4623,8 +4470,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "bytes");
 
             if (s < 0) {
                 c = -1;
@@ -4633,7 +4480,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyBytes_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -4643,7 +4490,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -4668,15 +4515,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
     }
 
     bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyBytes_Type && PyType_IsSubtype(&PyBytes_Type, type1)) {
+        f = PyBytes_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -4686,14 +4533,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -4701,14 +4556,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = PyBytes_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -4716,7 +4579,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -4730,54 +4601,53 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: unicode() == %s()", type2->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
+#if PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == bytes()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'bytes'", type1->tp_name);
 #endif
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
+#endif
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2) {
+#if PYTHON_VERSION >= 0x300
+/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyUnicode_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_UNICODE_UNICODE(operand1, operand2);
+    if (&PyBytes_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_CBOOL_BYTES_BYTES(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = &PyUnicode_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyBytes_Type == type2 && !0) {
 
-        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
+        richcmpfunc frich = PyBytes_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -4786,11 +4656,11 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -4800,7 +4670,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -4809,7 +4679,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -4836,7 +4706,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -4845,7 +4715,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyBytes_Type != type2 && PyType_IsSubtype(type2, &PyBytes_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -4855,11 +4725,11 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -4869,7 +4739,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
         }
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = PyBytes_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -4877,11 +4747,11 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -4898,11 +4768,11 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -4914,15 +4784,17 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyBytes_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -4938,7 +4810,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyBytes_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -4948,8 +4820,8 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("bytes", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -4957,7 +4829,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyBytes_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -4968,7 +4840,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -4993,14 +4865,14 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyBytes_Type != type2 && PyType_IsSubtype(type2, &PyBytes_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -5012,11 +4884,11 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -5026,7 +4898,7 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
         }
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = PyBytes_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -5035,11 +4907,11 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -5058,11 +4930,11 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -5079,54 +4951,53 @@ bool RICH_COMPARE_EQ_CBOOL_UNICODE_OBJEC
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: unicode() == %s()", type2->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
+#if PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: bytes() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'bytes' and '%s'", type2->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
+#endif
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *operand2) {
+#if PYTHON_VERSION < 0x300
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyUnicode_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_NBOOL_UNICODE_UNICODE(operand1, operand2);
+    if (Py_TYPE(operand1) == &PyInt_Type) {
+        return COMPARE_EQ_OBJECT_INT_INT(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
-    PyTypeObject *type1 = &PyUnicode_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
+    PyTypeObject *type1 = Py_TYPE(operand1);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyInt_Type && !0) {
 
-        richcmpfunc frich = PyUnicode_Type.tp_richcompare;
+        richcmpfunc frich = NULL;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -5134,22 +5005,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyUnicode_Type.tp_compare;
+        cmpfunc fcmp = PyInt_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -5158,7 +5021,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -5185,8 +5048,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -5194,8 +5057,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyInt_Type && 0) {
+        f = NULL;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -5203,58 +5066,34 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = NULL;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -5262,16 +5101,18 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
 
     int c;
 
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (PyInstance_Check(operand1)) {
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = PyInt_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyInt_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -5288,7 +5129,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyInt_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -5297,8 +5138,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "int");
 
             if (s < 0) {
                 c = -1;
@@ -5307,7 +5148,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyInt_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -5317,7 +5158,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -5342,15 +5183,15 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyInt_Type && PyType_IsSubtype(&PyInt_Type, type1)) {
+        f = NULL;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -5360,22 +5201,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyUnicode_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -5383,22 +5216,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = NULL;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -5406,15 +5231,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -5428,123 +5245,53 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICOD
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: unicode() == %s()", type2->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: str() == %s()", type2->tp_name);
+#if PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'str' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
 #endif
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 }
+#endif
 
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_OBJECT_UNICODE_UNICODE(operand1, operand2);
-}
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-bool RICH_COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_CBOOL_UNICODE_UNICODE(operand1, operand2);
-}
-
-/* Code referring to "UNICODE" corresponds to Python2 'unicode', Python3 'str' and "UNICODE" to Python2 'unicode',
- * Python3 'str'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_NBOOL_UNICODE_UNICODE(operand1, operand2);
-}
-
-#if PYTHON_VERSION >= 0x300
-static bool COMPARE_EQ_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyBytes_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyBytes_CheckExact(operand2));
-
-    PyBytesObject *a = (PyBytesObject *)operand1;
-    PyBytesObject *b = (PyBytesObject *)operand2;
-
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
-
-        // Convert to target type.
-        bool result = r;
-
-        return result;
-    }
-
-    Py_ssize_t len_a = Py_SIZE(operand1);
-    Py_ssize_t len_b = Py_SIZE(operand2);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        bool result = r;
-
-        return result;
-    } else {
-        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
-            bool r = true;
-
-            // Convert to target type.
-            bool result = r;
-
-            return result;
-        } else {
-            bool r = false;
-
-            // Convert to target type.
-            bool result = r;
-
-            return result;
-        }
-    }
-}
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2) {
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyBytes_Type) {
-        return COMPARE_EQ_CBOOL_BYTES_BYTES(operand1, operand2);
+    if (&PyInt_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_OBJECT_INT_INT(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NULL;
     }
 #endif
 
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyBytes_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyInt_Type == type2 && !0) {
 
-        richcmpfunc frich = PyBytes_Type.tp_richcompare;
+        richcmpfunc frich = NULL;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -5552,22 +5299,14 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyInt_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -5576,7 +5315,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -5603,8 +5342,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
             }
 
             bool r = c != 0;
-            bool result = r;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -5612,8 +5351,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyBytes_Type.tp_richcompare;
+    if (&PyInt_Type != type2 && PyType_IsSubtype(type2, &PyInt_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -5621,58 +5360,34 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = NULL;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
+            return result;
+        }
 
         Py_DECREF(result);
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -5680,16 +5395,18 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = PyInt_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyInt_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -5705,7 +5422,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyInt_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -5715,8 +5432,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("int", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -5724,7 +5441,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyInt_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -5735,7 +5452,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -5760,15 +5477,15 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
     }
 
     bool r = c != 0;
-    bool result = r;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyBytes_Type.tp_richcompare;
+    if (&PyInt_Type != type2 && PyType_IsSubtype(type2, &PyInt_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -5778,22 +5495,14 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = NULL;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -5801,22 +5510,14 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = PyBytes_Type.tp_richcompare;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -5824,15 +5525,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -5846,81 +5539,50 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_BYTES(
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == bytes()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'bytes'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
 #endif
-        return false;
+        return NULL;
     }
 #endif
 }
 #endif
 
-#if PYTHON_VERSION >= 0x300
-static nuitka_bool COMPARE_EQ_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyBytes_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyBytes_CheckExact(operand2));
-
-    PyBytesObject *a = (PyBytesObject *)operand1;
-    PyBytesObject *b = (PyBytesObject *)operand2;
-
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
-
-        // Convert to target type.
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-
-    Py_ssize_t len_a = Py_SIZE(operand1);
-    Py_ssize_t len_b = Py_SIZE(operand2);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    } else {
-        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
-            bool r = true;
-
-            // Convert to target type.
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
 
-            return result;
-        } else {
-            bool r = false;
+    return COMPARE_EQ_OBJECT_INT_INT(operand1, operand2);
+}
+#endif
 
-            // Convert to target type.
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
+bool RICH_COMPARE_EQ_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2) {
 
-            return result;
-        }
-    }
+    return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2);
 }
-/* Code referring to "OBJECT" corresponds to any Python object and "BYTES" to Python3 'bytes'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *operand2) {
+#endif
 
-    if (Py_TYPE(operand1) == &PyBytes_Type) {
-        return COMPARE_EQ_NBOOL_BYTES_BYTES(operand1, operand2);
+#if PYTHON_VERSION < 0x300
+/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyInt_Type) {
+        return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
@@ -5934,13 +5596,12 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyBytes_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyInt_Type && !0) {
 
-        richcmpfunc frich = PyBytes_Type.tp_richcompare;
+        richcmpfunc frich = NULL;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -5963,7 +5624,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyInt_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -6008,8 +5669,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyBytes_Type.tp_richcompare;
+    if (type1 != &PyInt_Type && 0) {
+        f = NULL;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -6053,7 +5714,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         Py_DECREF(result);
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = NULL;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -6077,15 +5738,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = PyInt_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyInt_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -6102,7 +5765,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyInt_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -6111,8 +5774,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "int");
 
             if (s < 0) {
                 c = -1;
@@ -6121,7 +5784,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyInt_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -6163,8 +5826,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyBytes_Type.tp_richcompare;
+    if (type1 != &PyInt_Type && PyType_IsSubtype(&PyInt_Type, type1)) {
+        f = NULL;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -6212,7 +5875,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
 
     if (checked_reverse_op == false) {
-        f = PyBytes_Type.tp_richcompare;
+        f = NULL;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -6254,9 +5917,9 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == bytes()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'bytes'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
 #endif
         return NUITKA_BOOL_EXCEPTION;
     }
@@ -6264,79 +5927,31 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
 }
 #endif
 
-#if PYTHON_VERSION >= 0x300
-static PyObject *COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyBytes_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyBytes_CheckExact(operand2));
-
-    PyBytesObject *a = (PyBytesObject *)operand1;
-    PyBytesObject *b = (PyBytesObject *)operand2;
-
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
-
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-
-    Py_ssize_t len_a = Py_SIZE(operand1);
-    Py_ssize_t len_b = Py_SIZE(operand2);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    } else {
-        if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
-            bool r = true;
-
-            // Convert to target type.
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        } else {
-            bool r = false;
-
-            // Convert to target type.
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        }
-    }
-}
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *operand2) {
+#if PYTHON_VERSION < 0x300
+/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyBytes_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_OBJECT_BYTES_BYTES(operand1, operand2);
+    if (&PyInt_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = &PyBytes_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyInt_Type == type2 && !0) {
 
-        richcmpfunc frich = PyBytes_Type.tp_richcompare;
+        richcmpfunc frich = NULL;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -6344,14 +5959,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyInt_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -6360,7 +5983,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NULL;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -6387,8 +6010,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
             }
 
             bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
             return result;
         }
     }
@@ -6396,7 +6019,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyInt_Type != type2 && PyType_IsSubtype(type2, &PyInt_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -6405,22 +6028,38 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = NULL;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
-        }
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
+        }
 
         Py_DECREF(result);
     }
@@ -6432,7 +6071,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
@@ -6441,15 +6088,17 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = PyInt_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyInt_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -6465,7 +6114,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyInt_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -6475,8 +6124,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("int", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -6484,7 +6133,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyInt_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -6495,7 +6144,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -6520,14 +6169,14 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
     }
 
     bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyInt_Type != type2 && PyType_IsSubtype(type2, &PyInt_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -6538,14 +6187,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = NULL;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -6553,7 +6210,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
@@ -6568,7 +6233,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -6582,54 +6255,85 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_O
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: bytes() == %s()", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'bytes' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
 #endif
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
 #endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2) {
+static PyObject *COMPARE_EQ_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyLong_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyLong_CheckExact(operand2));
 
-    if (&PyBytes_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_BYTES_BYTES(operand1, operand2);
+    PyLongObject *operand1_long_object = (PyLongObject *)operand1;
+
+    PyLongObject *operand2_long_object = (PyLongObject *)operand2;
+
+    bool r;
+
+    if (operand1_long_object == operand2_long_object) {
+        r = true;
+    } else if (Py_SIZE(operand1_long_object) != Py_SIZE(operand2_long_object)) {
+        r = false;
+    } else {
+        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        r = true;
+
+        while (--i >= 0) {
+            if (operand1_long_object->ob_digit[i] != operand2_long_object->ob_digit[i]) {
+                r = false;
+                break;
+            }
+        }
+    }
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
+    return result;
+}
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyLong_Type) {
+        return COMPARE_EQ_OBJECT_LONG_LONG(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NULL;
     }
 #endif
 
-    PyTypeObject *type1 = &PyBytes_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
+    PyTypeObject *type1 = Py_TYPE(operand1);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyLong_Type && !0) {
 
-        richcmpfunc frich = PyBytes_Type.tp_richcompare;
+        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -6637,22 +6341,14 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyLong_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -6661,7 +6357,7 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -6688,8 +6384,8 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             }
 
             bool r = c != 0;
-            bool result = r;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -6697,8 +6393,8 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyLong_Type && 0) {
+        f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -6706,58 +6402,34 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -6765,16 +6437,18 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
 
     int c;
 
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (PyInstance_Check(operand1)) {
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = PyLong_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyLong_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -6791,7 +6465,7 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyLong_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -6800,8 +6474,8 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, (PYTHON_VERSION < 0x300 ? "long" : "int"));
 
             if (s < 0) {
                 c = -1;
@@ -6810,7 +6484,7 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyLong_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -6820,7 +6494,7 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -6845,15 +6519,15 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
     }
 
     bool r = c != 0;
-    bool result = r;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyLong_Type && PyType_IsSubtype(&PyLong_Type, type1)) {
+        f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -6863,22 +6537,14 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -6886,22 +6552,14 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -6909,15 +6567,7 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -6931,54 +6581,53 @@ bool RICH_COMPARE_EQ_CBOOL_BYTES_OBJECT(
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: bytes() == %s()", type2->tp_name);
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == long()", type1->tp_name);
+#elif PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'bytes' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
 #endif
-        return false;
+        return NULL;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyBytes_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_NBOOL_BYTES_BYTES(operand1, operand2);
+    if (&PyLong_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_OBJECT_LONG_LONG(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
-    PyTypeObject *type1 = &PyBytes_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyLong_Type == type2 && !0) {
 
-        richcmpfunc frich = PyBytes_Type.tp_richcompare;
+        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -6986,22 +6635,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
+        cmpfunc fcmp = PyLong_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -7010,7 +6651,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -7037,8 +6678,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -7046,7 +6687,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyLong_Type != type2 && PyType_IsSubtype(type2, &PyLong_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -7055,37 +6696,21 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -7098,15 +6723,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -7115,15 +6732,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = PyLong_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyLong_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -7139,7 +6758,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyLong_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -7149,8 +6768,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp((PYTHON_VERSION < 0x300 ? "long" : "int"), type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -7158,7 +6777,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyLong_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -7169,7 +6788,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -7194,14 +6813,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyLong_Type != type2 && PyType_IsSubtype(type2, &PyLong_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -7212,22 +6831,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    f = PyBytes_Type.tp_richcompare;
+    f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -7235,15 +6846,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -7258,15 +6861,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -7280,102 +6875,98 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: bytes() == %s()", type2->tp_name);
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "unorderable types: long() == %s()", type2->tp_name);
+#elif PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'bytes' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
 #endif
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
 
-    return COMPARE_EQ_OBJECT_BYTES_BYTES(operand1, operand2);
+    return COMPARE_EQ_OBJECT_LONG_LONG(operand1, operand2);
 }
-#endif
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-bool RICH_COMPARE_EQ_CBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
+static bool COMPARE_EQ_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyLong_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyLong_CheckExact(operand2));
 
-    return COMPARE_EQ_CBOOL_BYTES_BYTES(operand1, operand2);
-}
-#endif
+    PyLongObject *operand1_long_object = (PyLongObject *)operand1;
 
-#if PYTHON_VERSION >= 0x300
-/* Code referring to "BYTES" corresponds to Python3 'bytes' and "BYTES" to Python3 'bytes'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_BYTES(PyObject *operand1, PyObject *operand2) {
+    PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-    return COMPARE_EQ_NBOOL_BYTES_BYTES(operand1, operand2);
-}
-#endif
+    bool r;
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
+    if (operand1_long_object == operand2_long_object) {
+        r = true;
+    } else if (Py_SIZE(operand1_long_object) != Py_SIZE(operand2_long_object)) {
+        r = false;
+    } else {
+        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        r = true;
 
-    return COMPARE_EQ_OBJECT_INT_INT(operand1, operand2);
-}
-#endif
+        while (--i >= 0) {
+            if (operand1_long_object->ob_digit[i] != operand2_long_object->ob_digit[i]) {
+                r = false;
+                break;
+            }
+        }
+    }
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-bool RICH_COMPARE_EQ_CBOOL_INT_INT(PyObject *operand1, PyObject *operand2) {
+    // Convert to target type.
+    bool result = r;
 
-    return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2);
+    return result;
 }
-#endif
-
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
+bool RICH_COMPARE_EQ_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
 
-    return COMPARE_EQ_NBOOL_INT_INT(operand1, operand2);
+    return COMPARE_EQ_CBOOL_LONG_LONG(operand1, operand2);
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyInt_Type) {
-        return COMPARE_EQ_OBJECT_INT_INT(operand1, operand2);
+    if (Py_TYPE(operand1) == &PyLong_Type) {
+        return COMPARE_EQ_CBOOL_LONG_LONG(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyInt_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyLong_Type && !0) {
 
-        richcmpfunc frich = NULL;
+        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -7383,14 +6974,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyInt_Type.tp_compare;
+        cmpfunc fcmp = PyLong_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -7399,7 +6998,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NULL;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -7426,8 +7025,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             }
 
             bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
             return result;
         }
     }
@@ -7435,8 +7034,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = NULL;
+    if (type1 != &PyLong_Type && 0) {
+        f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -7444,7 +7043,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -7458,20 +7065,36 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
-    f = NULL;
+    f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
@@ -7480,15 +7103,17 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = PyLong_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyLong_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -7505,7 +7130,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyLong_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -7514,8 +7139,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, (PYTHON_VERSION < 0x300 ? "long" : "int"));
 
             if (s < 0) {
                 c = -1;
@@ -7524,7 +7149,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyLong_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -7534,7 +7159,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -7559,15 +7184,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     }
 
     bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = NULL;
+    if (type1 != &PyLong_Type && PyType_IsSubtype(&PyLong_Type, type1)) {
+        f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -7577,7 +7202,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -7592,14 +7225,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = NULL;
+        f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -7607,7 +7248,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -7621,54 +7270,53 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x360
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == long()", type1->tp_name);
+#elif PYTHON_VERSION < 0x360
         PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
 #else
         PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
 #endif
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyInt_Type) {
-        return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2);
+    if (&PyLong_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_CBOOL_LONG_LONG(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyInt_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyLong_Type == type2 && !0) {
 
-        richcmpfunc frich = NULL;
+        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -7677,11 +7325,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -7691,7 +7339,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyInt_Type.tp_compare;
+        cmpfunc fcmp = PyLong_Type.tp_compare;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -7700,7 +7348,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -7727,7 +7375,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -7736,8 +7384,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = NULL;
+    if (&PyLong_Type != type2 && PyType_IsSubtype(type2, &PyLong_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -7746,11 +7394,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -7760,7 +7408,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -7768,11 +7416,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -7781,7 +7429,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
         Py_DECREF(result);
     }
 
-    f = NULL;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -7789,11 +7437,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -7804,16 +7452,18 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = PyLong_Type.tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyLong_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -7829,7 +7479,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyLong_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -7839,8 +7489,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp((PYTHON_VERSION < 0x300 ? "long" : "int"), type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -7848,7 +7498,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyLong_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -7859,7 +7509,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -7884,15 +7534,15 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = NULL;
+    if (&PyLong_Type != type2 && PyType_IsSubtype(type2, &PyLong_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -7903,11 +7553,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -7917,7 +7567,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -7926,11 +7576,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -7940,7 +7590,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
     }
 
     if (checked_reverse_op == false) {
-        f = NULL;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -7949,11 +7599,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -7970,54 +7620,69 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_INT(Py
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "unorderable types: long() == %s()", type2->tp_name);
+#elif PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
+static PyObject *COMPARE_EQ_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyFloat_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyFloat_CheckExact(operand2));
 
-    if (Py_TYPE(operand1) == &PyInt_Type) {
-        return COMPARE_EQ_NBOOL_INT_INT(operand1, operand2);
+    const double a = PyFloat_AS_DOUBLE(operand1);
+    const double b = PyFloat_AS_DOUBLE(operand2);
+
+    bool r = a == b;
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
+    return result;
+}
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyFloat_Type) {
+        return COMPARE_EQ_OBJECT_FLOAT_FLOAT(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyInt_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyFloat_Type && !0) {
 
-        richcmpfunc frich = NULL;
+        richcmpfunc frich = PyFloat_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -8025,22 +7690,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyInt_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -8049,7 +7706,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -8076,8 +7733,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -8085,8 +7742,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = NULL;
+    if (type1 != &PyFloat_Type && 0) {
+        f = PyFloat_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -8094,15 +7751,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -8116,36 +7765,20 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
-    f = NULL;
+    f = PyFloat_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -8154,15 +7787,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyFloat_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -8179,7 +7814,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyFloat_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -8188,8 +7823,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "float");
 
             if (s < 0) {
                 c = -1;
@@ -8198,7 +7833,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyFloat_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -8208,7 +7843,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -8233,15 +7868,15 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = NULL;
+    if (type1 != &PyFloat_Type && PyType_IsSubtype(&PyFloat_Type, type1)) {
+        f = PyFloat_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -8251,15 +7886,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -8274,22 +7901,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = NULL;
+        f = PyFloat_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -8297,15 +7916,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -8319,34 +7930,32 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == float()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'float'", type1->tp_name);
 #endif
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyInt_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_OBJECT_INT_INT(operand1, operand2);
+    if (&PyFloat_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_OBJECT_FLOAT_FLOAT(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
@@ -8359,14 +7968,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
     }
 #endif
 
-    PyTypeObject *type1 = &PyInt_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyFloat_Type == type2 && !0) {
 
-        richcmpfunc frich = NULL;
+        richcmpfunc frich = PyFloat_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -8381,7 +7989,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyInt_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -8426,7 +8034,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyFloat_Type != type2 && PyType_IsSubtype(type2, &PyFloat_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -8442,7 +8050,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
         }
     }
 
-    f = NULL;
+    f = PyFloat_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -8471,15 +8079,17 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyFloat_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -8495,7 +8105,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyFloat_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -8505,8 +8115,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("float", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -8514,7 +8124,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyFloat_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -8557,7 +8167,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyFloat_Type != type2 && PyType_IsSubtype(type2, &PyFloat_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -8575,7 +8185,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
         }
     }
 
-    f = NULL;
+    f = PyFloat_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -8624,42 +8234,67 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJ
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: float() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'float' and '%s'", type2->tp_name);
 #endif
         return NULL;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyInt_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_INT_INT(operand1, operand2);
+    return COMPARE_EQ_OBJECT_FLOAT_FLOAT(operand1, operand2);
+}
+
+static bool COMPARE_EQ_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyFloat_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyFloat_CheckExact(operand2));
+
+    const double a = PyFloat_AS_DOUBLE(operand1);
+    const double b = PyFloat_AS_DOUBLE(operand2);
+
+    bool r = a == b;
+
+    // Convert to target type.
+    bool result = r;
+
+    return result;
+}
+/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
+bool RICH_COMPARE_EQ_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_CBOOL_FLOAT_FLOAT(operand1, operand2);
+}
+
+/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyFloat_Type) {
+        return COMPARE_EQ_CBOOL_FLOAT_FLOAT(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = &PyInt_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
+    PyTypeObject *type1 = Py_TYPE(operand1);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyFloat_Type && !0) {
 
-        richcmpfunc frich = NULL;
+        richcmpfunc frich = PyFloat_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -8668,11 +8303,11 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -8682,7 +8317,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyInt_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -8691,7 +8326,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -8718,7 +8353,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -8727,8 +8362,8 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyFloat_Type && 0) {
+        f = PyFloat_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -8737,11 +8372,11 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -8751,7 +8386,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
         }
     }
 
-    f = NULL;
+    f = RICHCOMPARE(type1);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -8759,11 +8394,11 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -8772,7 +8407,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = PyFloat_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -8780,11 +8415,11 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -8795,16 +8430,18 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
 
     int c;
 
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (PyInstance_Check(operand1)) {
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyFloat_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -8821,7 +8458,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyFloat_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -8830,8 +8467,8 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "float");
 
             if (s < 0) {
                 c = -1;
@@ -8840,7 +8477,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyFloat_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -8850,7 +8487,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -8875,15 +8512,15 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyFloat_Type && PyType_IsSubtype(&PyFloat_Type, type1)) {
+        f = PyFloat_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -8894,11 +8531,11 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -8908,7 +8545,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
         }
     }
 
-    f = NULL;
+    f = RICHCOMPARE(type1);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -8917,11 +8554,11 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -8931,7 +8568,7 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = PyFloat_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -8940,11 +8577,11 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -8961,34 +8598,32 @@ bool RICH_COMPARE_EQ_CBOOL_INT_OBJECT(Py
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == float()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'float'", type1->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
-#endif
 
-#if PYTHON_VERSION < 0x300
-/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyInt_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_NBOOL_INT_INT(operand1, operand2);
+    if (&PyFloat_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_CBOOL_FLOAT_FLOAT(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
@@ -9001,14 +8636,13 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
     }
 #endif
 
-    PyTypeObject *type1 = &PyInt_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyFloat_Type == type2 && !0) {
 
-        richcmpfunc frich = NULL;
+        richcmpfunc frich = PyFloat_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -9031,7 +8665,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyInt_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -9076,7 +8710,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyFloat_Type != type2 && PyType_IsSubtype(type2, &PyFloat_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -9100,7 +8734,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
         }
     }
 
-    f = NULL;
+    f = PyFloat_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -9145,15 +8779,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyFloat_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -9169,7 +8805,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyFloat_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -9179,8 +8815,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("float", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -9188,7 +8824,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyFloat_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -9231,7 +8867,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyFloat_Type != type2 && PyType_IsSubtype(type2, &PyFloat_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -9257,7 +8893,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
         }
     }
 
-    f = NULL;
+    f = PyFloat_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -9322,132 +8958,70 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OB
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: float() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'float' and '%s'", type2->tp_name);
 #endif
         return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
-#endif
 
-static PyObject *COMPARE_EQ_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
+static PyObject *COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
     CHECK_OBJECT(operand1);
-    assert(PyLong_CheckExact(operand1));
+    assert(PyTuple_CheckExact(operand1));
     CHECK_OBJECT(operand2);
-    assert(PyLong_CheckExact(operand2));
-
-    PyLongObject *a = (PyLongObject *)operand1;
-    PyLongObject *b = (PyLongObject *)operand2;
-
-    bool r;
-
-    if (a == b) {
-        r = true;
-    } else if (Py_SIZE(a) != Py_SIZE(b)) {
-        r = false;
-    } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(a));
-        r = true;
-        while (--i >= 0) {
-            if (a->ob_digit[i] != b->ob_digit[i]) {
-                r = false;
-                break;
-            }
-        }
-    }
-
-    // Convert to target type.
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-}
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_OBJECT_LONG_LONG(operand1, operand2);
-}
+    assert(PyTuple_CheckExact(operand2));
 
-static bool COMPARE_EQ_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyLong_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyLong_CheckExact(operand2));
+    PyTupleObject *a = (PyTupleObject *)operand1;
+    PyTupleObject *b = (PyTupleObject *)operand2;
 
-    PyLongObject *a = (PyLongObject *)operand1;
-    PyLongObject *b = (PyLongObject *)operand2;
+    Py_ssize_t len_a = Py_SIZE(a);
+    Py_ssize_t len_b = Py_SIZE(b);
 
-    bool r;
+    if (len_a != len_b) {
+        bool r = false;
 
-    if (a == b) {
-        r = true;
-    } else if (Py_SIZE(a) != Py_SIZE(b)) {
-        r = false;
-    } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(a));
-        r = true;
-        while (--i >= 0) {
-            if (a->ob_digit[i] != b->ob_digit[i]) {
-                r = false;
-                break;
-            }
-        }
+        // Convert to target type.
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
+        return result;
     }
 
-    // Convert to target type.
-    bool result = r;
-
-    return result;
-}
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-bool RICH_COMPARE_EQ_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
+    nuitka_bool res = NUITKA_BOOL_TRUE;
 
-    return COMPARE_EQ_CBOOL_LONG_LONG(operand1, operand2);
-}
+    Py_ssize_t i;
+    for (i = 0; i < len_a && i < len_b; i++) {
+        PyObject *aa = a->ob_item[i];
+        PyObject *bb = b->ob_item[i];
 
-static nuitka_bool COMPARE_EQ_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyLong_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyLong_CheckExact(operand2));
+        if (aa == bb) {
+            continue;
+        }
 
-    PyLongObject *a = (PyLongObject *)operand1;
-    PyLongObject *b = (PyLongObject *)operand2;
+        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
 
-    bool r;
+        if (res == NUITKA_BOOL_EXCEPTION) {
+            return NULL;
+        }
 
-    if (a == b) {
-        r = true;
-    } else if (Py_SIZE(a) != Py_SIZE(b)) {
-        r = false;
-    } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(a));
-        r = true;
-        while (--i >= 0) {
-            if (a->ob_digit[i] != b->ob_digit[i]) {
-                r = false;
-                break;
-            }
+        if (res == NUITKA_BOOL_FALSE) {
+            break;
         }
     }
 
-    // Convert to target type.
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+    bool r = res == NUITKA_BOOL_TRUE;
 
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 }
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_NBOOL_LONG_LONG(operand1, operand2);
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyLong_Type) {
-        return COMPARE_EQ_OBJECT_LONG_LONG(operand1, operand2);
+    if (Py_TYPE(operand1) == &PyTuple_Type) {
+        return COMPARE_EQ_OBJECT_TUPLE_TUPLE(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
@@ -9461,13 +9035,12 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyLong_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyTuple_Type && !0) {
 
-        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
+        richcmpfunc frich = PyTuple_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -9482,7 +9055,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyLong_Type.tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -9527,8 +9100,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
+    if (type1 != &PyTuple_Type && 0) {
+        f = PyTuple_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -9556,7 +9129,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         Py_DECREF(result);
     }
 
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
+    f = PyTuple_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -9572,15 +9145,17 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyTuple_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -9597,7 +9172,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyTuple_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -9606,8 +9181,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "tuple");
 
             if (s < 0) {
                 c = -1;
@@ -9616,7 +9191,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyTuple_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -9658,8 +9233,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
+    if (type1 != &PyTuple_Type && PyType_IsSubtype(&PyTuple_Type, type1)) {
+        f = PyTuple_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -9691,7 +9266,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     }
 
     if (checked_reverse_op == false) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
+        f = PyTuple_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -9724,5557 +9299,38 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         return result;
     }
     default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == long()", type1->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
+#if PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == tuple()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'tuple'", type1->tp_name);
 #endif
         return NULL;
     }
 #endif
 }
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyLong_Type) {
-        return COMPARE_EQ_CBOOL_LONG_LONG(operand1, operand2);
+    if (&PyTuple_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_OBJECT_TUPLE_TUPLE(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyLong_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyLong_Type.tp_compare;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return false;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            bool result = r;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return false;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    bool result = r;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        bool result = r;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        bool result = r;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == long()", type1->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
-#endif
-        return false;
-    }
-#endif
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyLong_Type) {
-        return COMPARE_EQ_NBOOL_LONG_LONG(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyLong_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyLong_Type.tp_compare;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type2));
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == long()", type1->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == int()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'int'", type1->tp_name);
-#endif
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-}
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyLong_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_OBJECT_LONG_LONG(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyLong_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyLong_Type.tp_compare;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NULL;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NULL;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: long() == %s()", type2->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
-#endif
-        return NULL;
-    }
-#endif
-}
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyLong_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_LONG_LONG(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyLong_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyLong_Type.tp_compare;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return false;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            bool result = r;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return false;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    bool result = r;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        bool result = r;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        bool result = r;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: long() == %s()", type2->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
-#endif
-        return false;
-    }
-#endif
-}
-
-/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyLong_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_NBOOL_LONG_LONG(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyLong_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = PyLong_Type.tp_compare;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = (PYTHON_VERSION < 0x300 ? NULL : RICHCOMPARE(type1));
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unorderable types: long() == %s()", type2->tp_name);
-#elif PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: int() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'int' and '%s'", type2->tp_name);
-#endif
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-}
-
-static PyObject *COMPARE_EQ_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyFloat_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyFloat_CheckExact(operand2));
-
-    const double a = PyFloat_AS_DOUBLE(operand1);
-    const double b = PyFloat_AS_DOUBLE(operand2);
-
-    bool r = a == b;
-
-    // Convert to target type.
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-}
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_OBJECT_FLOAT_FLOAT(operand1, operand2);
-}
-
-static bool COMPARE_EQ_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyFloat_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyFloat_CheckExact(operand2));
-
-    const double a = PyFloat_AS_DOUBLE(operand1);
-    const double b = PyFloat_AS_DOUBLE(operand2);
-
-    bool r = a == b;
-
-    // Convert to target type.
-    bool result = r;
-
-    return result;
-}
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-bool RICH_COMPARE_EQ_CBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_CBOOL_FLOAT_FLOAT(operand1, operand2);
-}
-
-static nuitka_bool COMPARE_EQ_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyFloat_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyFloat_CheckExact(operand2));
-
-    const double a = PyFloat_AS_DOUBLE(operand1);
-    const double b = PyFloat_AS_DOUBLE(operand2);
-
-    bool r = a == b;
-
-    // Convert to target type.
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-}
-/* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_NBOOL_FLOAT_FLOAT(operand1, operand2);
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyFloat_Type) {
-        return COMPARE_EQ_OBJECT_FLOAT_FLOAT(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyFloat_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyFloat_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NULL;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NULL;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == float()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'float'", type1->tp_name);
-#endif
-        return NULL;
-    }
-#endif
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyFloat_Type) {
-        return COMPARE_EQ_CBOOL_FLOAT_FLOAT(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyFloat_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyFloat_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return false;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            bool result = r;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return false;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    bool result = r;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        bool result = r;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        bool result = r;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == float()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'float'", type1->tp_name);
-#endif
-        return false;
-    }
-#endif
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyFloat_Type) {
-        return COMPARE_EQ_NBOOL_FLOAT_FLOAT(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyFloat_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyFloat_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = PyFloat_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == float()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'float'", type1->tp_name);
-#endif
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-}
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyFloat_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_OBJECT_FLOAT_FLOAT(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyFloat_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyFloat_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NULL;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NULL;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: float() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'float' and '%s'", type2->tp_name);
-#endif
-        return NULL;
-    }
-#endif
-}
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyFloat_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_FLOAT_FLOAT(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyFloat_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyFloat_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return false;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            bool result = r;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return false;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    bool result = r;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        bool result = r;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        bool result = r;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: float() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'float' and '%s'", type2->tp_name);
-#endif
-        return false;
-    }
-#endif
-}
-
-/* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyFloat_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_NBOOL_FLOAT_FLOAT(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyFloat_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyFloat_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyFloat_Type.tp_richcompare;
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: float() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'float' and '%s'", type2->tp_name);
-#endif
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-}
-
-static PyObject *COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyTuple_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyTuple_CheckExact(operand2));
-
-    PyTupleObject *a = (PyTupleObject *)operand1;
-    PyTupleObject *b = (PyTupleObject *)operand2;
-
-    Py_ssize_t len_a = Py_SIZE(a);
-    Py_ssize_t len_b = Py_SIZE(b);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-
-    nuitka_bool res = NUITKA_BOOL_TRUE;
-
-    Py_ssize_t i;
-    for (i = 0; i < len_a && i < len_b; i++) {
-        PyObject *aa = a->ob_item[i];
-        PyObject *bb = b->ob_item[i];
-
-        if (aa == bb) {
-            continue;
-        }
-
-        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
-
-        if (res == NUITKA_BOOL_EXCEPTION) {
-            return NULL;
-        }
-
-        if (res == NUITKA_BOOL_FALSE) {
-            break;
-        }
-    }
-
-    bool r = res == NUITKA_BOOL_TRUE;
-
-    // Convert to target type.
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-}
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_OBJECT_TUPLE_TUPLE(operand1, operand2);
-}
-
-static bool COMPARE_EQ_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyTuple_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyTuple_CheckExact(operand2));
-
-    PyTupleObject *a = (PyTupleObject *)operand1;
-    PyTupleObject *b = (PyTupleObject *)operand2;
-
-    Py_ssize_t len_a = Py_SIZE(a);
-    Py_ssize_t len_b = Py_SIZE(b);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        bool result = r;
-
-        return result;
-    }
-
-    nuitka_bool res = NUITKA_BOOL_TRUE;
-
-    Py_ssize_t i;
-    for (i = 0; i < len_a && i < len_b; i++) {
-        PyObject *aa = a->ob_item[i];
-        PyObject *bb = b->ob_item[i];
-
-        if (aa == bb) {
-            continue;
-        }
-
-        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
-
-        if (res == NUITKA_BOOL_EXCEPTION) {
-            return false;
-        }
-
-        if (res == NUITKA_BOOL_FALSE) {
-            break;
-        }
-    }
-
-    bool r = res == NUITKA_BOOL_TRUE;
-
-    // Convert to target type.
-    bool result = r;
-
-    return result;
-}
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-bool RICH_COMPARE_EQ_CBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_CBOOL_TUPLE_TUPLE(operand1, operand2);
-}
-
-static nuitka_bool COMPARE_EQ_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyTuple_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyTuple_CheckExact(operand2));
-
-    PyTupleObject *a = (PyTupleObject *)operand1;
-    PyTupleObject *b = (PyTupleObject *)operand2;
-
-    Py_ssize_t len_a = Py_SIZE(a);
-    Py_ssize_t len_b = Py_SIZE(b);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-
-    nuitka_bool res = NUITKA_BOOL_TRUE;
-
-    Py_ssize_t i;
-    for (i = 0; i < len_a && i < len_b; i++) {
-        PyObject *aa = a->ob_item[i];
-        PyObject *bb = b->ob_item[i];
-
-        if (aa == bb) {
-            continue;
-        }
-
-        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
-
-        if (res == NUITKA_BOOL_EXCEPTION) {
-            return NUITKA_BOOL_EXCEPTION;
-        }
-
-        if (res == NUITKA_BOOL_FALSE) {
-            break;
-        }
-    }
-
-    bool r = res == NUITKA_BOOL_TRUE;
-
-    // Convert to target type.
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-}
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_NBOOL_TUPLE_TUPLE(operand1, operand2);
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyTuple_Type) {
-        return COMPARE_EQ_OBJECT_TUPLE_TUPLE(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyTuple_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyTuple_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NULL;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NULL;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == tuple()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'tuple'", type1->tp_name);
-#endif
-        return NULL;
-    }
-#endif
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyTuple_Type) {
-        return COMPARE_EQ_CBOOL_TUPLE_TUPLE(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyTuple_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyTuple_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return false;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            bool result = r;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return false;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    bool result = r;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        bool result = r;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        bool result = r;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == tuple()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'tuple'", type1->tp_name);
-#endif
-        return false;
-    }
-#endif
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyTuple_Type) {
-        return COMPARE_EQ_NBOOL_TUPLE_TUPLE(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyTuple_Type;
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyTuple_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && 0) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = RICHCOMPARE(type1);
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = PyTuple_Type.tp_richcompare;
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == tuple()", type1->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'tuple'", type1->tp_name);
-#endif
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-}
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyTuple_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_OBJECT_TUPLE_TUPLE(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyTuple_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyTuple_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return NULL;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return NULL;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            return result;
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                return result;
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: tuple() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'tuple' and '%s'", type2->tp_name);
-#endif
-        return NULL;
-    }
-#endif
-}
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyTuple_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_TUPLE_TUPLE(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
-    }
-#endif
-
-    PyTypeObject *type1 = &PyTuple_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
-
-#if PYTHON_VERSION < 0x300
-    // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
-
-        richcmpfunc frich = PyTuple_Type.tp_richcompare;
-
-        if (frich != NULL) {
-            PyObject *result = (*frich)(operand1, operand2, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-
-        // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = NULL;
-
-        if (fcmp != NULL) {
-            int c = (*fcmp)(operand1, operand2);
-            c = adjust_tp_compare(c);
-
-            Py_LeaveRecursiveCall();
-
-            if (c == -2) {
-                return false;
-            }
-
-            switch (Py_EQ) {
-            case Py_LT:
-                c = c < 0;
-                break;
-            case Py_LE:
-                c = c <= 0;
-                break;
-            case Py_EQ:
-                c = c == 0;
-                break;
-            case Py_NE:
-                c = c != 0;
-                break;
-            case Py_GT:
-                c = c > 0;
-                break;
-            case Py_GE:
-                c = c >= 0;
-                break;
-            default:
-                NUITKA_CANNOT_GET_HERE("wrong op_code");
-            }
-
-            bool r = c != 0;
-            bool result = r;
-
-            return result;
-        }
-    }
-
-    // Fast path was not successful or not taken
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    f = RICHCOMPARE(type2);
-    if (f != NULL) {
-        PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    int c;
-
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
-    } else {
-        c = try_3way_compare(operand1, operand2);
-    }
-
-    if (c >= 2) {
-        if (type1 == type2) {
-            Py_uintptr_t aa = (Py_uintptr_t)operand1;
-            Py_uintptr_t bb = (Py_uintptr_t)operand2;
-
-            c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-        } else if (operand1 == Py_None) {
-            // None is smaller than everything else
-            c = -1;
-        } else if (operand2 == Py_None) {
-            // None is smaller than everything else
-            c = 1;
-        } else if (PyNumber_Check(operand1)) {
-            // different type: compare type names but numbers are smaller than
-            // others.
-            if (PyNumber_Check(operand2)) {
-                // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            } else {
-                c = -1;
-            }
-        } else if (PyNumber_Check(operand2)) {
-            c = 1;
-        } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
-
-            if (s < 0) {
-                c = -1;
-            } else if (s > 0) {
-                c = 1;
-            } else {
-                // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
-
-                c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
-            }
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    if (unlikely(c <= -2)) {
-        return false;
-    }
-
-    switch (Py_EQ) {
-    case Py_LT:
-        c = c < 0;
-        break;
-    case Py_LE:
-        c = c <= 0;
-        break;
-    case Py_EQ:
-        c = c == 0;
-        break;
-    case Py_NE:
-        c = c != 0;
-        break;
-    case Py_GT:
-        c = c > 0;
-        break;
-    case Py_GE:
-        c = c >= 0;
-        break;
-    }
-
-    bool r = c != 0;
-    bool result = r;
-
-    return result;
-#else
-    bool checked_reverse_op = false;
-    richcmpfunc f;
-
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            checked_reverse_op = true;
-
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return false;
-            }
-
-            {
-                bool r = CHECK_IF_TRUE(result) == 1;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return false;
-                }
-
-                {
-                    bool r = CHECK_IF_TRUE(result) == 1;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        bool result = r;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        bool result = r;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: tuple() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'tuple' and '%s'", type2->tp_name);
-#endif
-        return false;
-    }
-#endif
-}
-
-/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2) {
-
-    if (&PyTuple_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_NBOOL_TUPLE_TUPLE(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
-    PyTypeObject *type1 = &PyTuple_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyTuple_Type == type2 && !0) {
 
         richcmpfunc frich = PyTuple_Type.tp_richcompare;
 
@@ -15284,15 +9340,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -15308,7 +9356,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -15335,8 +9383,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -15344,7 +9392,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyTuple_Type != type2 && PyType_IsSubtype(type2, &PyTuple_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -15353,15 +9401,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -15375,15 +9415,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -15396,15 +9428,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -15413,15 +9437,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyTuple_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -15437,7 +9463,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyTuple_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -15447,8 +9473,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("tuple", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -15456,7 +9482,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyTuple_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -15467,7 +9493,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -15492,14 +9518,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyTuple_Type != type2 && PyType_IsSubtype(type2, &PyTuple_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -15510,215 +9536,85 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
-            }
-
-            Py_DECREF(result);
-        }
-    }
-
-    f = PyTuple_Type.tp_richcompare;
-
-    if (f != NULL) {
-        PyObject *result = (*f)(operand1, operand2, Py_EQ);
-
-        if (result != Py_NotImplemented) {
-            Py_LeaveRecursiveCall();
-
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
-        }
-
-        Py_DECREF(result);
-    }
-
-    if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
-
-        if (f != NULL) {
-            PyObject *result = (*f)(operand2, operand1, Py_EQ);
-
-            if (result != Py_NotImplemented) {
-                Py_LeaveRecursiveCall();
-
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
     }
 
-    Py_LeaveRecursiveCall();
-
-    // If it is not implemented, do pointer identity checks as "==" and "!=" and
-    // otherwise give an error
-    switch (Py_EQ) {
-    case Py_EQ: {
-        bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    case Py_NE: {
-        bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-        return result;
-    }
-    default:
-#if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: tuple() == %s()", type2->tp_name);
-#else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'tuple' and '%s'", type2->tp_name);
-#endif
-        return NUITKA_BOOL_EXCEPTION;
-    }
-#endif
-}
-
-static PyObject *COMPARE_EQ_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyList_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyList_CheckExact(operand2));
-
-    PyListObject *a = (PyListObject *)operand1;
-    PyListObject *b = (PyListObject *)operand2;
-
-    Py_ssize_t len_a = Py_SIZE(a);
-    Py_ssize_t len_b = Py_SIZE(b);
-
-    if (len_a != len_b) {
-        bool r = false;
-
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
-    }
-
-    nuitka_bool res = NUITKA_BOOL_TRUE;
-
-    Py_ssize_t i;
-    for (i = 0; i < len_a && i < len_b; i++) {
-        PyObject *aa = a->ob_item[i];
-        PyObject *bb = b->ob_item[i];
-
-        if (aa == bb) {
-            continue;
-        }
-
-        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
-
-        if (res == NUITKA_BOOL_EXCEPTION) {
-            return NULL;
-        }
-
-        if (res == NUITKA_BOOL_FALSE) {
-            break;
-        }
-    }
-
-    bool r = res == NUITKA_BOOL_TRUE;
-
-    // Convert to target type.
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
-    return result;
-}
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_OBJECT_LIST_LIST(operand1, operand2);
-}
-
-static bool COMPARE_EQ_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyList_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyList_CheckExact(operand2));
-
-    PyListObject *a = (PyListObject *)operand1;
-    PyListObject *b = (PyListObject *)operand2;
-
-    Py_ssize_t len_a = Py_SIZE(a);
-    Py_ssize_t len_b = Py_SIZE(b);
+    f = PyTuple_Type.tp_richcompare;
 
-    if (len_a != len_b) {
-        bool r = false;
+    if (f != NULL) {
+        PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
-        // Convert to target type.
-        bool result = r;
+        if (result != Py_NotImplemented) {
+            Py_LeaveRecursiveCall();
 
-        return result;
-    }
+            return result;
+        }
 
-    nuitka_bool res = NUITKA_BOOL_TRUE;
+        Py_DECREF(result);
+    }
 
-    Py_ssize_t i;
-    for (i = 0; i < len_a && i < len_b; i++) {
-        PyObject *aa = a->ob_item[i];
-        PyObject *bb = b->ob_item[i];
+    if (checked_reverse_op == false) {
+        f = RICHCOMPARE(type2);
 
-        if (aa == bb) {
-            continue;
-        }
+        if (f != NULL) {
+            PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
-        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
+            if (result != Py_NotImplemented) {
+                Py_LeaveRecursiveCall();
 
-        if (res == NUITKA_BOOL_EXCEPTION) {
-            return false;
-        }
+                return result;
+            }
 
-        if (res == NUITKA_BOOL_FALSE) {
-            break;
+            Py_DECREF(result);
         }
     }
 
-    bool r = res == NUITKA_BOOL_TRUE;
-
-    // Convert to target type.
-    bool result = r;
+    Py_LeaveRecursiveCall();
 
-    return result;
+    // If it is not implemented, do pointer identity checks as "==" and "!=" and
+    // otherwise give an error
+    switch (Py_EQ) {
+    case Py_EQ: {
+        bool r = operand1 == operand2;
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
+        return result;
+    }
+    case Py_NE: {
+        bool r = operand1 != operand2;
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
+        return result;
+    }
+    default:
+#if PYTHON_VERSION < 0x360
+        PyErr_Format(PyExc_TypeError, "unorderable types: tuple() == %s()", type2->tp_name);
+#else
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'tuple' and '%s'", type2->tp_name);
+#endif
+        return NULL;
+    }
+#endif
 }
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-bool RICH_COMPARE_EQ_CBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2) {
 
-    return COMPARE_EQ_CBOOL_LIST_LIST(operand1, operand2);
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_OBJECT_TUPLE_TUPLE(operand1, operand2);
 }
 
-static nuitka_bool COMPARE_EQ_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2) {
+static nuitka_bool COMPARE_EQ_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
     CHECK_OBJECT(operand1);
-    assert(PyList_CheckExact(operand1));
+    assert(PyTuple_CheckExact(operand1));
     CHECK_OBJECT(operand2);
-    assert(PyList_CheckExact(operand2));
+    assert(PyTuple_CheckExact(operand2));
 
-    PyListObject *a = (PyListObject *)operand1;
-    PyListObject *b = (PyListObject *)operand2;
+    PyTupleObject *a = (PyTupleObject *)operand1;
+    PyTupleObject *b = (PyTupleObject *)operand2;
 
     Py_ssize_t len_a = Py_SIZE(a);
     Py_ssize_t len_b = Py_SIZE(b);
@@ -15761,37 +9657,30 @@ static nuitka_bool COMPARE_EQ_NBOOL_LIST
 
     return result;
 }
-/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2) {
-
-    return COMPARE_EQ_NBOOL_LIST_LIST(operand1, operand2);
-}
-
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyList_Type) {
-        return COMPARE_EQ_OBJECT_LIST_LIST(operand1, operand2);
+    if (Py_TYPE(operand1) == &PyTuple_Type) {
+        return COMPARE_EQ_NBOOL_TUPLE_TUPLE(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyList_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyTuple_Type && !0) {
 
-        richcmpfunc frich = PyList_Type.tp_richcompare;
+        richcmpfunc frich = PyTuple_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -15799,7 +9688,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -15815,7 +9712,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NULL;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -15842,8 +9739,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             }
 
             bool r = c != 0;
-            PyObject *result = BOOL_FROM(r);
-            Py_INCREF(result);
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
             return result;
         }
     }
@@ -15851,8 +9748,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyList_Type.tp_richcompare;
+    if (type1 != &PyTuple_Type && 0) {
+        f = PyTuple_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -15860,7 +9757,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -15874,20 +9779,36 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
-    f = PyList_Type.tp_richcompare;
+    f = PyTuple_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
@@ -15896,15 +9817,17 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyTuple_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -15921,7 +9844,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyTuple_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -15930,8 +9853,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "tuple");
 
             if (s < 0) {
                 c = -1;
@@ -15940,7 +9863,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyTuple_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -15950,7 +9873,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -15975,15 +9898,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     }
 
     bool r = c != 0;
-    PyObject *result = BOOL_FROM(r);
-    Py_INCREF(result);
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyList_Type.tp_richcompare;
+    if (type1 != &PyTuple_Type && PyType_IsSubtype(&PyTuple_Type, type1)) {
+        f = PyTuple_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -15993,7 +9916,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -16008,14 +9939,22 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            return result;
+            if (unlikely(result == NULL)) {
+                return NUITKA_BOOL_EXCEPTION;
+            }
+
+            {
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                Py_DECREF(result);
+                return r;
+            }
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = PyList_Type.tp_richcompare;
+        f = PyTuple_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -16023,7 +9962,15 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                return result;
+                if (unlikely(result == NULL)) {
+                    return NUITKA_BOOL_EXCEPTION;
+                }
+
+                {
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+                    Py_DECREF(result);
+                    return r;
+                }
             }
 
             Py_DECREF(result);
@@ -16037,52 +9984,51 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == list()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == tuple()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'list'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'tuple'", type1->tp_name);
 #endif
-        return NULL;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
 
-/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "OBJECT" to any Python object. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    if (Py_TYPE(operand1) == &PyList_Type) {
-        return COMPARE_EQ_CBOOL_LIST_LIST(operand1, operand2);
+    if (&PyTuple_Type == Py_TYPE(operand2)) {
+        return COMPARE_EQ_NBOOL_TUPLE_TUPLE(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyList_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyTuple_Type == type2 && !0) {
 
-        richcmpfunc frich = PyList_Type.tp_richcompare;
+        richcmpfunc frich = PyTuple_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_EQ);
@@ -16091,11 +10037,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -16114,7 +10060,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -16141,7 +10087,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -16150,8 +10096,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyList_Type.tp_richcompare;
+    if (&PyTuple_Type != type2 && PyType_IsSubtype(type2, &PyTuple_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -16160,11 +10106,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -16174,7 +10120,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyTuple_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -16182,11 +10128,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -16195,7 +10141,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
         Py_DECREF(result);
     }
 
-    f = PyList_Type.tp_richcompare;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -16203,11 +10149,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -16218,16 +10164,18 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyTuple_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -16243,7 +10191,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyTuple_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -16253,8 +10201,8 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("tuple", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -16262,7 +10210,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyTuple_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -16273,7 +10221,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -16298,15 +10246,15 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyList_Type.tp_richcompare;
+    if (&PyTuple_Type != type2 && PyType_IsSubtype(type2, &PyTuple_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -16317,11 +10265,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -16331,7 +10279,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyTuple_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -16340,11 +10288,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -16354,7 +10302,7 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
     }
 
     if (checked_reverse_op == false) {
-        f = PyList_Type.tp_richcompare;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -16363,11 +10311,11 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -16384,50 +10332,105 @@ bool RICH_COMPARE_EQ_CBOOL_OBJECT_LIST(P
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == list()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: tuple() == %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'list'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'tuple' and '%s'", type2->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
 
+/* Code referring to "TUPLE" corresponds to Python 'tuple' and "TUPLE" to Python 'tuple'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_TUPLE(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_NBOOL_TUPLE_TUPLE(operand1, operand2);
+}
+
+static PyObject *COMPARE_EQ_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyList_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyList_CheckExact(operand2));
+
+    PyListObject *a = (PyListObject *)operand1;
+    PyListObject *b = (PyListObject *)operand2;
+
+    Py_ssize_t len_a = Py_SIZE(a);
+    Py_ssize_t len_b = Py_SIZE(b);
+
+    if (len_a != len_b) {
+        bool r = false;
+
+        // Convert to target type.
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
+        return result;
+    }
+
+    nuitka_bool res = NUITKA_BOOL_TRUE;
+
+    Py_ssize_t i;
+    for (i = 0; i < len_a && i < len_b; i++) {
+        PyObject *aa = a->ob_item[i];
+        PyObject *bb = b->ob_item[i];
+
+        if (aa == bb) {
+            continue;
+        }
+
+        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
+
+        if (res == NUITKA_BOOL_EXCEPTION) {
+            return NULL;
+        }
+
+        if (res == NUITKA_BOOL_FALSE) {
+            break;
+        }
+    }
+
+    bool r = res == NUITKA_BOOL_TRUE;
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
+    return result;
+}
 /* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
-nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2) {
+PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *operand2) {
 
     if (Py_TYPE(operand1) == &PyList_Type) {
-        return COMPARE_EQ_NBOOL_LIST_LIST(operand1, operand2);
+        return COMPARE_EQ_OBJECT_LIST_LIST(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyList_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyList_Type && !0) {
 
         richcmpfunc frich = PyList_Type.tp_richcompare;
 
@@ -16437,15 +10440,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -16461,7 +10456,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_EQ) {
@@ -16488,8 +10483,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -16497,7 +10492,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
+    if (type1 != &PyList_Type && 0) {
         f = PyList_Type.tp_richcompare;
 
         if (f != NULL) {
@@ -16506,15 +10501,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -16528,15 +10515,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -16549,15 +10528,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -16566,15 +10537,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyList_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -16591,7 +10564,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyList_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -16600,8 +10573,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "list");
 
             if (s < 0) {
                 c = -1;
@@ -16610,7 +10583,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyList_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -16620,7 +10593,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_EQ) {
@@ -16645,14 +10618,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (type1 != &PyList_Type && PyType_IsSubtype(&PyList_Type, type1)) {
         f = PyList_Type.tp_richcompare;
 
         if (f != NULL) {
@@ -16663,15 +10636,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -16686,15 +10651,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -16709,15 +10666,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -16731,14 +10680,14 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
@@ -16747,7 +10696,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT
 #else
         PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'list'", type1->tp_name);
 #endif
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 }
@@ -16769,12 +10718,11 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
     }
 #endif
 
-    PyTypeObject *type1 = &PyList_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyList_Type == type2 && !0) {
 
         richcmpfunc frich = PyList_Type.tp_richcompare;
 
@@ -16836,7 +10784,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyList_Type != type2 && PyType_IsSubtype(type2, &PyList_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -16881,15 +10829,17 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyList_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -16905,7 +10855,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyList_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -16915,8 +10865,8 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("list", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -16924,7 +10874,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyList_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -16967,7 +10917,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyList_Type != type2 && PyType_IsSubtype(type2, &PyList_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -17043,29 +10993,84 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OB
 #endif
 }
 
-/* Code referring to "LIST" corresponds to Python 'list' and "OBJECT" to any Python object. */
-bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(PyObject *operand1, PyObject *operand2) {
+/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_LIST_LIST(PyObject *operand1, PyObject *operand2) {
 
-    if (&PyList_Type == Py_TYPE(operand2)) {
-        return COMPARE_EQ_CBOOL_LIST_LIST(operand1, operand2);
+    return COMPARE_EQ_OBJECT_LIST_LIST(operand1, operand2);
+}
+
+static nuitka_bool COMPARE_EQ_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyList_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyList_CheckExact(operand2));
+
+    PyListObject *a = (PyListObject *)operand1;
+    PyListObject *b = (PyListObject *)operand2;
+
+    Py_ssize_t len_a = Py_SIZE(a);
+    Py_ssize_t len_b = Py_SIZE(b);
+
+    if (len_a != len_b) {
+        bool r = false;
+
+        // Convert to target type.
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
+        return result;
+    }
+
+    nuitka_bool res = NUITKA_BOOL_TRUE;
+
+    Py_ssize_t i;
+    for (i = 0; i < len_a && i < len_b; i++) {
+        PyObject *aa = a->ob_item[i];
+        PyObject *bb = b->ob_item[i];
+
+        if (aa == bb) {
+            continue;
+        }
+
+        res = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(aa, bb);
+
+        if (res == NUITKA_BOOL_EXCEPTION) {
+            return NUITKA_BOOL_EXCEPTION;
+        }
+
+        if (res == NUITKA_BOOL_FALSE) {
+            break;
+        }
+    }
+
+    bool r = res == NUITKA_BOOL_TRUE;
+
+    // Convert to target type.
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
+
+    return result;
+}
+/* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyList_Type) {
+        return COMPARE_EQ_NBOOL_LIST_LIST(operand1, operand2);
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
-    PyTypeObject *type1 = &PyList_Type;
-    PyTypeObject *type2 = Py_TYPE(operand2);
+    PyTypeObject *type1 = Py_TYPE(operand1);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyList_Type && !0) {
 
         richcmpfunc frich = PyList_Type.tp_richcompare;
 
@@ -17076,11 +11081,11 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -17099,7 +11104,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_EQ) {
@@ -17126,7 +11131,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -17135,8 +11140,8 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyList_Type && 0) {
+        f = PyList_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -17145,11 +11150,11 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -17159,7 +11164,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
         }
     }
 
-    f = PyList_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
 
@@ -17167,11 +11172,11 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -17180,7 +11185,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = PyList_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_EQ);
 
@@ -17188,11 +11193,11 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -17203,16 +11208,18 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
 
     int c;
 
-    if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (PyInstance_Check(operand1)) {
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyList_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -17229,7 +11236,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyList_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -17238,8 +11245,8 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "list");
 
             if (s < 0) {
                 c = -1;
@@ -17248,7 +11255,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyList_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -17258,7 +11265,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_EQ) {
@@ -17283,15 +11290,15 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyList_Type && PyType_IsSubtype(&PyList_Type, type1)) {
+        f = PyList_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -17302,11 +11309,11 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -17316,7 +11323,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
         }
     }
 
-    f = PyList_Type.tp_richcompare;
+    f = RICHCOMPARE(type1);
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_EQ);
@@ -17325,11 +11332,11 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -17339,7 +11346,7 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = PyList_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_EQ);
@@ -17348,11 +11355,11 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -17369,23 +11376,23 @@ bool RICH_COMPARE_EQ_CBOOL_LIST_OBJECT(P
     switch (Py_EQ) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: list() == %s()", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() == list()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of 'list' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'==' not supported between instances of '%s' and 'list'", type1->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
@@ -17407,12 +11414,11 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
     }
 #endif
 
-    PyTypeObject *type1 = &PyList_Type;
     PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyList_Type == type2 && !0) {
 
         richcmpfunc frich = PyList_Type.tp_richcompare;
 
@@ -17482,7 +11488,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyList_Type != type2 && PyType_IsSubtype(type2, &PyList_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -17551,15 +11557,17 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
     int c;
 
     if (0) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyList_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -17575,7 +11583,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyList_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -17585,8 +11593,8 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("list", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -17594,7 +11602,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyList_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -17637,7 +11645,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
+    if (&PyList_Type != type2 && PyType_IsSubtype(type2, &PyList_Type)) {
         f = RICHCOMPARE(type2);
 
         if (f != NULL) {
@@ -17736,3 +11744,287 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_O
     }
 #endif
 }
+
+/* Code referring to "LIST" corresponds to Python 'list' and "LIST" to Python 'list'. */
+nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_LIST(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_NBOOL_LIST_LIST(operand1, operand2);
+}
+
+#if PYTHON_VERSION < 0x300
+static PyObject *COMPARE_EQ_OBJECT_LONG_CLONG(PyObject *operand1, long operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyLong_CheckExact(operand1));
+
+    PyLongObject *operand1_long_object = (PyLongObject *)operand1;
+
+    bool operand2_is_negative;
+    unsigned long operand2_abs_ival;
+
+    if (operand2 < 0) {
+        operand2_abs_ival = (unsigned long)(-1 - operand2) + 1;
+        operand2_is_negative = true;
+    } else {
+        operand2_abs_ival = (unsigned long)operand2;
+        operand2_is_negative = false;
+    }
+
+    Py_ssize_t operand2_digit_count = 0;
+    digit operand2_digits[5]; // Could be more minimal and depend on sizeof(digit)
+    {
+        unsigned long t = operand2_abs_ival;
+
+        while (t != 0) {
+            operand2_digit_count += 1;
+            assert(operand2_digit_count <= (Py_ssize_t)(sizeof(operand2_digit_count) / sizeof(digit)));
+
+            operand2_digits[operand2_digit_count] = (digit)(t & PyLong_MASK);
+            t >>= PyLong_SHIFT;
+        }
+    }
+
+    Py_ssize_t operand2_size = operand2_is_negative == false ? operand2_digit_count : -operand2_digit_count;
+
+    bool r;
+
+    if (Py_SIZE(operand1_long_object) != operand2_size) {
+        r = false;
+    } else {
+        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        r = true;
+
+        while (--i >= 0) {
+            if (operand1_long_object->ob_digit[i] != operand2_digits[i]) {
+                r = false;
+                break;
+            }
+        }
+    }
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
+    return result;
+}
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+PyObject *RICH_COMPARE_EQ_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_OBJECT_LONG_CLONG(operand1, PyInt_AS_LONG(operand1));
+}
+#endif
+
+#if PYTHON_VERSION < 0x300
+static bool COMPARE_EQ_CBOOL_LONG_CLONG(PyObject *operand1, long operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyLong_CheckExact(operand1));
+
+    PyLongObject *operand1_long_object = (PyLongObject *)operand1;
+
+    bool operand2_is_negative;
+    unsigned long operand2_abs_ival;
+
+    if (operand2 < 0) {
+        operand2_abs_ival = (unsigned long)(-1 - operand2) + 1;
+        operand2_is_negative = true;
+    } else {
+        operand2_abs_ival = (unsigned long)operand2;
+        operand2_is_negative = false;
+    }
+
+    Py_ssize_t operand2_digit_count = 0;
+    digit operand2_digits[5]; // Could be more minimal and depend on sizeof(digit)
+    {
+        unsigned long t = operand2_abs_ival;
+
+        while (t != 0) {
+            operand2_digit_count += 1;
+            assert(operand2_digit_count <= (Py_ssize_t)(sizeof(operand2_digit_count) / sizeof(digit)));
+
+            operand2_digits[operand2_digit_count] = (digit)(t & PyLong_MASK);
+            t >>= PyLong_SHIFT;
+        }
+    }
+
+    Py_ssize_t operand2_size = operand2_is_negative == false ? operand2_digit_count : -operand2_digit_count;
+
+    bool r;
+
+    if (Py_SIZE(operand1_long_object) != operand2_size) {
+        r = false;
+    } else {
+        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        r = true;
+
+        while (--i >= 0) {
+            if (operand1_long_object->ob_digit[i] != operand2_digits[i]) {
+                r = false;
+                break;
+            }
+        }
+    }
+
+    // Convert to target type.
+    bool result = r;
+
+    return result;
+}
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
+bool RICH_COMPARE_EQ_CBOOL_LONG_INT(PyObject *operand1, PyObject *operand2) {
+
+    return COMPARE_EQ_CBOOL_LONG_CLONG(operand1, PyInt_AS_LONG(operand1));
+}
+#endif
+
+#if PYTHON_VERSION < 0x300
+static PyObject *COMPARE_EQ_OBJECT_INT_CLONG(PyObject *operand1, long operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyInt_CheckExact(operand1));
+
+    const long a = PyInt_AS_LONG(operand1);
+    const long b = operand2;
+
+    bool r = a == b;
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
+    return result;
+}
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+PyObject *RICH_COMPARE_EQ_OBJECT_INT_CLONG(PyObject *operand1, long operand2) {
+
+    return COMPARE_EQ_OBJECT_INT_CLONG(operand1, operand2);
+}
+#endif
+
+#if PYTHON_VERSION < 0x300
+static bool COMPARE_EQ_CBOOL_INT_CLONG(PyObject *operand1, long operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyInt_CheckExact(operand1));
+
+    const long a = PyInt_AS_LONG(operand1);
+    const long b = operand2;
+
+    bool r = a == b;
+
+    // Convert to target type.
+    bool result = r;
+
+    return result;
+}
+/* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
+bool RICH_COMPARE_EQ_CBOOL_INT_CLONG(PyObject *operand1, long operand2) {
+
+    return COMPARE_EQ_CBOOL_INT_CLONG(operand1, operand2);
+}
+#endif
+
+static PyObject *COMPARE_EQ_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyLong_CheckExact(operand1));
+    assert(Py_ABS(operand2) < (1 << PyLong_SHIFT));
+
+    PyLongObject *operand1_long_object = (PyLongObject *)operand1;
+
+    bool r;
+
+    if (Py_SIZE(operand1_long_object) != (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
+        r = false;
+    } else {
+        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        r = true;
+
+        while (--i >= 0) {
+            if (operand1_long_object->ob_digit[i] != (digit)Py_ABS(operand2)) {
+                r = false;
+                break;
+            }
+        }
+    }
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
+    return result;
+}
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+PyObject *RICH_COMPARE_EQ_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2) {
+
+    return COMPARE_EQ_OBJECT_LONG_DIGIT(operand1, operand2);
+}
+
+static bool COMPARE_EQ_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyLong_CheckExact(operand1));
+    assert(Py_ABS(operand2) < (1 << PyLong_SHIFT));
+
+    PyLongObject *operand1_long_object = (PyLongObject *)operand1;
+
+    bool r;
+
+    if (Py_SIZE(operand1_long_object) != (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
+        r = false;
+    } else {
+        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        r = true;
+
+        while (--i >= 0) {
+            if (operand1_long_object->ob_digit[i] != (digit)Py_ABS(operand2)) {
+                r = false;
+                break;
+            }
+        }
+    }
+
+    // Convert to target type.
+    bool result = r;
+
+    return result;
+}
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
+ * Python objects. */
+bool RICH_COMPARE_EQ_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2) {
+
+    return COMPARE_EQ_CBOOL_LONG_DIGIT(operand1, operand2);
+}
+
+static PyObject *COMPARE_EQ_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyFloat_CheckExact(operand1));
+
+    const double a = PyFloat_AS_DOUBLE(operand1);
+    const double b = operand2;
+
+    bool r = a == b;
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
+    return result;
+}
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2) {
+
+    return COMPARE_EQ_OBJECT_FLOAT_CFLOAT(operand1, operand2);
+}
+
+static bool COMPARE_EQ_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyFloat_CheckExact(operand1));
+
+    const double a = PyFloat_AS_DOUBLE(operand1);
+    const double b = operand2;
+
+    bool r = a == b;
+
+    // Convert to target type.
+    bool result = r;
+
+    return result;
+}
+/* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
+bool RICH_COMPARE_EQ_CBOOL_FLOAT_CFLOAT(PyObject *operand1, double operand2) {
+
+    return COMPARE_EQ_CBOOL_FLOAT_CFLOAT(operand1, operand2);
+}
diff -pruN 0.9.5+ds-1/nuitka/build/static_src/HelpersComparisonGe.c 1.0.1+ds-1/nuitka/build/static_src/HelpersComparisonGe.c
--- 0.9.5+ds-1/nuitka/build/static_src/HelpersComparisonGe.c	2022-06-23 09:52:44.000000000 +0000
+++ 1.0.1+ds-1/nuitka/build/static_src/HelpersComparisonGe.c	2022-07-30 17:47:39.000000000 +0000
@@ -60,24 +60,6 @@ static bool COMPARE_GE_CBOOL_INT_INT(PyO
     return result;
 }
 #endif
-#if PYTHON_VERSION < 0x300
-static nuitka_bool COMPARE_GE_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyInt_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyInt_CheckExact(operand2));
-
-    const long a = PyInt_AS_LONG(operand1);
-    const long b = PyInt_AS_LONG(operand2);
-
-    bool r = a >= b;
-
-    // Convert to target type.
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
-    return result;
-}
-#endif
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
 PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
@@ -217,9 +199,11 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
@@ -251,7 +235,7 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
+            // Banking on C compile to optimize "strcmp".
             int s = strcmp(type1->tp_name, type2->tp_name);
 
             if (s < 0) {
@@ -381,29 +365,29 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
 }
 
 /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
+nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
 
 #if PYTHON_VERSION < 0x300
     if (PyInt_CheckExact(operand1) && PyInt_CheckExact(operand2)) {
-        return COMPARE_GE_CBOOL_INT_INT(operand1, operand2);
+        return COMPARE_GE_CBOOL_INT_INT(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 #endif
 
     // Quick path for avoidable checks, compatible with CPython.
     if (operand1 == operand2 && IS_SANE_TYPE(Py_TYPE(operand1))) {
         bool r = true;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
@@ -423,11 +407,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -446,7 +430,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_GE) {
@@ -473,7 +457,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -492,11 +476,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -514,11 +498,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -535,11 +519,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -551,9 +535,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
@@ -585,7 +571,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
+            // Banking on C compile to optimize "strcmp".
             int s = strcmp(type1->tp_name, type2->tp_name);
 
             if (s < 0) {
@@ -605,7 +591,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 
     switch (Py_GE) {
@@ -630,7 +616,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
     }
 
     bool r = c != 0;
-    bool result = r;
+    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
     return result;
 #else
@@ -649,11 +635,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -672,11 +658,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -695,11 +681,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -716,13 +702,13 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
     switch (Py_GE) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        bool result = r;
+        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
         return result;
     }
@@ -733,46 +719,82 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_OBJECT
         PyErr_Format(PyExc_TypeError, "'>=' not supported between instances of '%s' and '%s'", type1->tp_name,
                      type2->tp_name);
 #endif
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 }
 
-/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
-nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
-
 #if PYTHON_VERSION < 0x300
-    if (PyInt_CheckExact(operand1) && PyInt_CheckExact(operand2)) {
-        return COMPARE_GE_NBOOL_INT_INT(operand1, operand2);
-    }
-#endif
+static PyObject *COMPARE_GE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2) {
+    CHECK_OBJECT(operand1);
+    assert(PyString_CheckExact(operand1));
+    CHECK_OBJECT(operand2);
+    assert(PyString_CheckExact(operand2));
 
-    // Quick path for avoidable checks, compatible with CPython.
-    if (operand1 == operand2 && IS_SANE_TYPE(Py_TYPE(operand1))) {
+    PyStringObject *a = (PyStringObject *)operand1;
+    PyStringObject *b = (PyStringObject *)operand2;
+
+    // Same object has fast path for all operations.
+    if (operand1 == operand2) {
         bool r = true;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
+        // Convert to target type.
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
 
+    Py_ssize_t len_a = Py_SIZE(operand1);
+    Py_ssize_t len_b = Py_SIZE(operand2);
+
+    Py_ssize_t min_len = (len_a < len_b) ? len_a : len_b;
+    int c;
+
+    if (min_len > 0) {
+        c = Py_CHARMASK(*a->ob_sval) - Py_CHARMASK(*b->ob_sval);
+
+        if (c == 0) {
+            c = memcmp(a->ob_sval, b->ob_sval, min_len);
+        }
+    } else {
+        c = 0;
+    }
+
+    if (c == 0) {
+        c = (len_a < len_b) ? -1 : (len_a > len_b) ? 1 : 0;
+    }
+
+    c = c >= 0;
+
+    // Convert to target type.
+    PyObject *result = BOOL_FROM(c != 0);
+    Py_INCREF(result);
+    return result;
+}
+/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
+PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
+
+    if (Py_TYPE(operand1) == &PyString_Type) {
+        return COMPARE_GE_OBJECT_STR_STR(operand1, operand2);
+    }
+
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !PyInstance_Check(operand1)) {
+    if (type1 == &PyString_Type && !0) {
 
-        richcmpfunc frich = RICHCOMPARE(type1);
+        richcmpfunc frich = PyString_Type.tp_richcompare;
 
         if (frich != NULL) {
             PyObject *result = (*frich)(operand1, operand2, Py_GE);
@@ -780,22 +802,14 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
         }
 
         // No rich comparison worked, but maybe compare works.
-        cmpfunc fcmp = type1->tp_compare;
+        cmpfunc fcmp = NULL;
 
         if (fcmp != NULL) {
             int c = (*fcmp)(operand1, operand2);
@@ -804,7 +818,7 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return NUITKA_BOOL_EXCEPTION;
+                return NULL;
             }
 
             switch (Py_GE) {
@@ -831,8 +845,8 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             }
 
             bool r = c != 0;
-            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+            PyObject *result = BOOL_FROM(r);
+            Py_INCREF(result);
             return result;
         }
     }
@@ -840,8 +854,8 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyString_Type && 0) {
+        f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_LE);
@@ -849,15 +863,7 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -871,36 +877,20 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
-    f = RICHCOMPARE(type2);
+    f = PyString_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_LE);
 
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
@@ -909,15 +899,17 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (PyInstance_Check(operand2)) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
+    } else if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyString_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -934,7 +926,7 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyString_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -943,8 +935,8 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp(type1->tp_name, "str");
 
             if (s < 0) {
                 c = -1;
@@ -953,7 +945,7 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             } else {
                 // Same type name need to make a decision based on type address.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyString_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             }
@@ -963,7 +955,7 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
     Py_LeaveRecursiveCall();
 
     if (unlikely(c <= -2)) {
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 
     switch (Py_GE) {
@@ -988,15 +980,15 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
     }
 
     bool r = c != 0;
-    nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+    PyObject *result = BOOL_FROM(r);
+    Py_INCREF(result);
     return result;
 #else
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = RICHCOMPARE(type2);
+    if (type1 != &PyString_Type && PyType_IsSubtype(&PyString_Type, type1)) {
+        f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -1006,15 +998,7 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -1029,22 +1013,14 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
         if (result != Py_NotImplemented) {
             Py_LeaveRecursiveCall();
 
-            if (unlikely(result == NULL)) {
-                return NUITKA_BOOL_EXCEPTION;
-            }
-
-            {
-                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                Py_DECREF(result);
-                return r;
-            }
+            return result;
         }
 
         Py_DECREF(result);
     }
 
     if (checked_reverse_op == false) {
-        f = RICHCOMPARE(type2);
+        f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_LE);
@@ -1052,15 +1028,7 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
             if (result != Py_NotImplemented) {
                 Py_LeaveRecursiveCall();
 
-                if (unlikely(result == NULL)) {
-                    return NUITKA_BOOL_EXCEPTION;
-                }
-
-                {
-                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-                    Py_DECREF(result);
-                    return r;
-                }
+                return result;
             }
 
             Py_DECREF(result);
@@ -1074,98 +1042,51 @@ nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT
     switch (Py_GE) {
     case Py_EQ: {
         bool r = operand1 == operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     case Py_NE: {
         bool r = operand1 != operand2;
-        nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
-
+        PyObject *result = BOOL_FROM(r);
+        Py_INCREF(result);
         return result;
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() >= %s()", type1->tp_name, type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: %s() >= str()", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'>=' not supported between instances of '%s' and '%s'", type1->tp_name,
-                     type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "'>=' not supported between instances of '%s' and 'str'", type1->tp_name);
 #endif
-        return NUITKA_BOOL_EXCEPTION;
+        return NULL;
     }
 #endif
 }
+#endif
 
 #if PYTHON_VERSION < 0x300
-static PyObject *COMPARE_GE_OBJECT_STR_STR(PyObject *operand1, PyObject *operand2) {
-    CHECK_OBJECT(operand1);
-    assert(PyString_CheckExact(operand1));
-    CHECK_OBJECT(operand2);
-    assert(PyString_CheckExact(operand2));
-
-    PyStringObject *a = (PyStringObject *)operand1;
-    PyStringObject *b = (PyStringObject *)operand2;
+/* Code referring to "STR" corresponds to Python2 'str' and "OBJECT" to any Python object. */
+PyObject *RICH_COMPARE_GE_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operand2) {
 
-    // Same object has fast path for all operations.
-    if (operand1 == operand2) {
-        bool r = true;
+    if (&PyString_Type == Py_TYPE(operand2)) {
+        return COMPARE_GE_OBJECT_STR_STR(operand1, operand2);
+    }
 
-        // Convert to target type.
-        PyObject *result = BOOL_FROM(r);
-        Py_INCREF(result);
-        return result;
+#if PYTHON_VERSION < 0x300
+    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
+        return NULL;
+    }
+#else
+    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
+        return NULL;
     }
+#endif
 
-    Py_ssize_t len_a = Py_SIZE(operand1);
-    Py_ssize_t len_b = Py_SIZE(operand2);
-
-    Py_ssize_t min_len = (len_a < len_b) ? len_a : len_b;
-    int c;
-
-    if (min_len > 0) {
-        c = Py_CHARMASK(*a->ob_sval) - Py_CHARMASK(*b->ob_sval);
-
-        if (c == 0) {
-            c = memcmp(a->ob_sval, b->ob_sval, min_len);
-        }
-    } else {
-        c = 0;
-    }
-
-    if (c == 0) {
-        c = (len_a < len_b) ? -1 : (len_a > len_b) ? 1 : 0;
-    }
-
-    c = c >= 0;
-
-    // Convert to target type.
-    PyObject *result = BOOL_FROM(c != 0);
-    Py_INCREF(result);
-    return result;
-}
-/* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
-
-    if (Py_TYPE(operand1) == &PyString_Type) {
-        return COMPARE_GE_OBJECT_STR_STR(operand1, operand2);
-    }
-
-#if PYTHON_VERSION < 0x300
-    if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return NULL;
-    }
-#else
-    if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return NULL;
-    }
-#endif
-
-    PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyString_Type;
+    PyTypeObject *type2 = Py_TYPE(operand2);
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (&PyString_Type == type2 && !0) {
 
         richcmpfunc frich = PyString_Type.tp_richcompare;
 
@@ -1227,8 +1148,8 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
-        f = PyString_Type.tp_richcompare;
+    if (&PyString_Type != type2 && PyType_IsSubtype(type2, &PyString_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_LE);
@@ -1243,7 +1164,7 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyString_Type.tp_richcompare;
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_GE);
 
@@ -1256,7 +1177,7 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
         Py_DECREF(result);
     }
 
-    f = PyString_Type.tp_richcompare;
+    f = RICHCOMPARE(type2);
     if (f != NULL) {
         PyObject *result = (*f)(operand2, operand1, Py_LE);
 
@@ -1271,16 +1192,18 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
 
     int c;
 
-    if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
-    } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+    if (0) {
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
+    } else if (PyInstance_Check(operand2)) {
+        cmpfunc fcmp = type2->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (&PyString_Type == type2) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -1296,7 +1219,7 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
             // others.
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyString_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -1306,8 +1229,8 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
         } else if (PyNumber_Check(operand2)) {
             c = 1;
         } else {
-            // TODO: Could be hard coded if one is known.
-            int s = strcmp(type1->tp_name, type2->tp_name);
+            // Banking on C compile to optimize "strcmp".
+            int s = strcmp("str", type2->tp_name);
 
             if (s < 0) {
                 c = -1;
@@ -1315,7 +1238,7 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
                 c = 1;
             } else {
                 // Same type name need to make a decision based on type address.
-                Py_uintptr_t aa = (Py_uintptr_t)type1;
+                Py_uintptr_t aa = (Py_uintptr_t)&PyString_Type;
                 Py_uintptr_t bb = (Py_uintptr_t)type2;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
@@ -1358,8 +1281,8 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
     bool checked_reverse_op = false;
     richcmpfunc f;
 
-    if (type1 != type2 && PyType_IsSubtype(type2, type1)) {
-        f = PyString_Type.tp_richcompare;
+    if (&PyString_Type != type2 && PyType_IsSubtype(type2, &PyString_Type)) {
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             checked_reverse_op = true;
@@ -1376,7 +1299,7 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
         }
     }
 
-    f = RICHCOMPARE(type1);
+    f = PyString_Type.tp_richcompare;
 
     if (f != NULL) {
         PyObject *result = (*f)(operand1, operand2, Py_GE);
@@ -1391,7 +1314,7 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
     }
 
     if (checked_reverse_op == false) {
-        f = PyString_Type.tp_richcompare;
+        f = RICHCOMPARE(type2);
 
         if (f != NULL) {
             PyObject *result = (*f)(operand2, operand1, Py_LE);
@@ -1425,9 +1348,9 @@ PyObject *RICH_COMPARE_GE_OBJECT_OBJECT_
     }
     default:
 #if PYTHON_VERSION < 0x360
-        PyErr_Format(PyExc_TypeError, "unorderable types: %s() >= str()", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unorderable types: str() >= %s()", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "'>=' not supported between instances of '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "'>=' not supported between instances of 'str' and '%s'", type2->tp_name);
 #endif
         return NULL;
     }
@@ -1483,28 +1406,27 @@ static bool COMPARE_GE_CBOOL_STR_STR(PyO
     return result;
 }
 /* Code referring to "OBJECT" corresponds to any Python object and "STR" to Python2 'str'. */
-bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
+nuitka_bool RICH_COMPARE_GE_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *operand2) {
 
     if (Py_TYPE(operand1) == &PyString_Type) {
-        return COMPARE_GE_CBOOL_STR_STR(operand1, operand2);
+        return COMPARE_GE_CBOOL_STR_STR(operand1, operand2) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
     }
 
 #if PYTHON_VERSION < 0x300
     if (unlikely(Py_EnterRecursiveCall((char *)" in cmp"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #else
     if (unlikely(Py_EnterRecursiveCall((char *)" in comparison"))) {
-        return false;
+        return NUITKA_BOOL_EXCEPTION;
     }
 #endif
 
     PyTypeObject *type1 = Py_TYPE(operand1);
-    PyTypeObject *type2 = &PyString_Type;
 
 #if PYTHON_VERSION < 0x300
     // If the types are equal, we may get away immediately except for instances.
-    if (type1 == type2 && !0) {
+    if (type1 == &PyString_Type && !0) {
 
         richcmpfunc frich = PyString_Type.tp_richcompare;
 
@@ -1515,11 +1437,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -1538,7 +1460,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
             Py_LeaveRecursiveCall();
 
             if (c == -2) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             switch (Py_GE) {
@@ -1565,7 +1487,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
             }
 
             bool r = c != 0;
-            bool result = r;
+            nuitka_bool result = r ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
 
             return result;
         }
@@ -1574,7 +1496,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
     // Fast path was not successful or not taken
     richcmpfunc f;
 
-    if (type1 != type2 && 0) {
+    if (type1 != &PyString_Type && 0) {
         f = PyString_Type.tp_richcompare;
 
         if (f != NULL) {
@@ -1584,11 +1506,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
                 Py_LeaveRecursiveCall();
 
                 if (unlikely(result == NULL)) {
-                    return false;
+                    return NUITKA_BOOL_EXCEPTION;
                 }
 
                 {
-                    bool r = CHECK_IF_TRUE(result) == 1;
+                    nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                     Py_DECREF(result);
                     return r;
                 }
@@ -1606,11 +1528,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -1627,11 +1549,11 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
             Py_LeaveRecursiveCall();
 
             if (unlikely(result == NULL)) {
-                return false;
+                return NUITKA_BOOL_EXCEPTION;
             }
 
             {
-                bool r = CHECK_IF_TRUE(result) == 1;
+                nuitka_bool r = CHECK_IF_TRUE(result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
                 Py_DECREF(result);
                 return r;
             }
@@ -1643,15 +1565,17 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
     int c;
 
     if (PyInstance_Check(operand1)) {
-        c = (*type1->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = type1->tp_compare;
+        c = (*fcmp)(operand1, operand2);
     } else if (0) {
-        c = (*type2->tp_compare)(operand1, operand2);
+        cmpfunc fcmp = NULL;
+        c = (*fcmp)(operand1, operand2);
     } else {
         c = try_3way_compare(operand1, operand2);
     }
 
     if (c >= 2) {
-        if (type1 == type2) {
+        if (type1 == &PyString_Type) {
             Py_uintptr_t aa = (Py_uintptr_t)operand1;
             Py_uintptr_t bb = (Py_uintptr_t)operand2;
 
@@ -1668,7 +1592,7 @@ bool RICH_COMPARE_GE_CBOOL_OBJECT_STR(Py
             if (PyNumber_Check(operand2)) {
                 // Both numbers, need to make a decision based on types.
                 Py_uintptr_t aa = (Py_uintptr_t)type1;
-                Py_uintptr_t bb = (Py_uintptr_t)type2;
+                Py_uintptr_t bb = (Py_uintptr_t)&PyString_Type;
 
                 c = (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
             } else {
@@ -1677,8