Repository: SethMMorton/fastnumbers (language: python)

Issue:
Improve performance with METH_FASTCALL
Starting in Python 3.7, there is a new way for C functions to define how arguments are passed from python called "fast call" or "vector call" that is supposed to be much faster than the standard method. Taking advantage of this should provide a performance boost for `fastnumbers`.

Unfortunately, there is as-of-yet no public API for parsing arguments when using this method, so I will have to write one. I will likely heavily borrow from https://github.com/numpy/numpy/pull/15269.



Discussion / hints:

Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0533f87a..cc541b39 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,10 @@ Unreleased
 - `query_type` now sets `allow_underscores` to `False` by default
 - Complete rewrite into C++ (Issues [#45](https://github.com/SethMMorton/fastnumbers/issues/45)
   and [#56](https://github.com/SethMMorton/fastnumbers/issues/56))
+- All functions now use use `METH_FASTCALL` for pass arguments from
+  Python to C (Issue [#59](https://github.com/SethMMorton/fastnumbers/issues/59))
+- Always parse integers using `int64_t` instead of using `long` to ensure
+  we can always quickly parse at least 18 digits
 
 ### Deprecated
 - `isreal`, `isfloat`, `isint`, and `isintlike` are deprecated in
@@ -28,6 +32,8 @@ Unreleased
 
 ### Removed
 - Support for Python 3.6
+- Removed the undocumentente `dig`, `max_exp`, `min_exp`, and `max_int_len`
+  module-level constants, as they are now meaningless
 
 [3.2.1] - 2021-11-02
 ---
diff --git a/MANIFEST.in b/MANIFEST.in
index 40888a52..bff10652 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -14,5 +14,6 @@ graft include
 graft tests
 graft dev
 graft docs
+graft profiling
 graft .github
 global-exclude *.py[cod] __pycache__ *.so
diff --git a/README.rst b/README.rst
index e055c84c..da23b3d8 100644
--- a/README.rst
+++ b/README.rst
@@ -30,13 +30,14 @@ Super-fast and clean conversions to numbers.
 ``fastnumbers`` is a module with the following three objectives (in order
 of decreasing importance as to why the module was created):
 
-    #. Provide a set of convenience functions that wrap the above
-       ``int`` and ``float`` replacements and provides easy, concise,
-       powerful, fast and flexible error handling.
+    #. Provide a set of convenience functions that wrap calls to
+       ``int`` and ``float`` and provides easy, concise, powerful, fast
+       and flexible error handling.
     #. Provide a set of functions that can be used to rapidly identify if
        an input *could* be converted to *int* or *float*.
     #. Provide drop-in replacements for the Python built-in ``int`` and
-       ``float`` that on average are *up to* 2x faster. These functions
+       ``float`` that are on par or faster with the Python equivalents
+       (see the `Timing_` section for details). These functions
        should behave *identically* to the Python built-ins except for a few
        specific corner-cases as mentioned in the
        `API documentation for those functions <https://fastnumbers.readthedocs.io/en/main/api.html#the-built-in-replacement-functions>`_.
@@ -156,8 +157,6 @@ on if there is any fractional component of thi return value.
     56
     >>> try_real(56.0, coerce=False)
     56.0
-    >>>
-    >>>
 
 ``try_forceint`` always returns an integer.
 
@@ -372,7 +371,10 @@ with a speedup - they may not. Every platform, compiler, and data-set is
 different, and you should perform a timing test on your system with your data
 to evaluate if you will see a benefit. As you can see from the data linked in
 the `Timing`_ section, the amount of speedup you will get is particularly
-data-dependent.
+data-dependent. *In general* you will see a performance boost for floats (and
+this boost increases as the size of the float increases), but for integers it
+is largely dependent on the length of the integer. You will likely *not* see
+a performance boost if the input are already numbers instead of strings.
 
 **NOTE**: in the below examples, we use ``from fastnumbers import int`` instead
 of ``import fastnumbers``. This is because calling ``fastnumbers.int()`` is a
@@ -413,39 +415,33 @@ Timing
 ------
 
 Just how much faster is ``fastnumbers`` than a pure python implementation?
-Please see the following Jupyter notebooks for timing information on various
-Python versions.
-
-    - https://nbviewer.jupyter.org/github/SethMMorton/fastnumbers/blob/master/TIMING_35.ipynb
-    - https://nbviewer.jupyter.org/github/SethMMorton/fastnumbers/blob/master/TIMING_36.ipynb
-    - https://nbviewer.jupyter.org/github/SethMMorton/fastnumbers/blob/master/TIMING_37.ipynb
+Please look https://github.com/SethMMorton/fastnumbers/tree/main/profiling.
 
 High-Level Algorithm
 --------------------
 
-CPython goes to great lengths to ensure that your string input is converted to a
-number *correctly* (you can prove this to yourself by examining the source code
-for
-`integer conversions <https://github.com/python/cpython/blob/e349bf23584eef20e0d1e1b2989d9b1430f15507/Objects/longobject.c#L2213>`_
-and for
-`float conversions <https://github.com/python/cpython/blob/e349bf23584eef20e0d1e1b2989d9b1430f15507/Python/dtoa.c#L1434>`_),
-but this extra effort is only needed for very large
-integers or for floats with many digits or large exponents. For integers, if
-the result could fit into a C ``long`` then a naive algorithm of < 10 lines
-of C code is sufficient. For floats, if the number does not require high
-precision or does not have a large exponent (such as "-123.45e6") then a
-short naive algorithm is also possible.
-
-These naive algorithms are quite fast, but the performance improvement comes
-at the expense of being unsafe (no protection against overflow or round-off
-errors). ``fastnumbers`` uses a heuristic to determine if the input can be
-safely converted with the much faster naive algorithm. These heuristics are
-extremely conservative - if there is *any* chance that the naive result would
-not give *exactly* the same result as the built-in functions then it will fall
-back on CPython's conversion function. For this reason, ``fastnumbers`` is aways
-*at least as fast* as CPython's built-in ``float`` and ``int`` functions, and
-oftentimes is significantly faster because most real-world numbers pass the
-heuristic.
+For integers, CPython goes to great lengths to ensure that your string input
+is converted to a number *correctly* and *losslessly* (you can prove this to
+yourself by examining the source code for
+`integer conversions <https://github.com/python/cpython/blob/e349bf23584eef20e0d1e1b2989d9b1430f15507/Objects/longobject.c#L2213>`_).
+This extra effort is only needed for integers that cannot fit into a 64-bit
+integer data type - for those that can, a naive algorithm of < 10 lines
+of C code is sufficient and significantly faster. ``fastnumbers`` uses a
+heuristic to determine if the input can be safely converted with the much
+faster naive algorithm, and if so it does so, falling back on
+the CPython implementation for longer input strings.
+Most real-world numbers pass the heuristic and so you should generally see
+improved performance with ``fastnumbers`` for integers.
+
+For floats, ``fastnumbers`` utilizes the ultra-fast
+`fast_float::from_chars <https://github.com/fastfloat/fast_float>`_ function
+to convert strings representing floats into a C ``double`` both quickly *and
+safely* - the conversion provides the same accuracy as the CPython
+`float conversion function <https://github.com/python/cpython/blob/e349bf23584eef20e0d1e1b2989d9b1430f15507/Python/dtoa.c#L1434>`_
+but instead of scaling linearly with length of the input string it seems
+to have roughly constant performance. By completely bypassing the CPython
+converter we get significant performance gains with no penalty, so you
+should always see improved performance with ``fastnumbers`` for floats.
 
 Installation
 ------------
diff --git a/TIMING_35.ipynb b/TIMING_35.ipynb
deleted file mode 100644
index 59c96a29..00000000
--- a/TIMING_35.ipynb
+++ /dev/null
@@ -1,836 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Timing Tests of `fastnumbers` Functions Compared to Equivalent Solutions\n",
-    "\n",
-    "In order for you to see the benefit of `fastnumbers`, some timings are collected below for comparison to equivalent python implementations. The numbers may change depending on the machine you are on or the Python version you are using.\n",
-    "\n",
-    "Feel free to download this Jupyter Notebook and run the tests yourself to see how `fastnumbers` performs on your machine (it takes about 1-2 minutes total).\n",
-    "\n",
-    "**This notebook contains timing results for Python 3.5.**\n",
-    "\n",
-    "#### Some notes about the data\n",
-    "\n",
-    " - Each test is the time it takes for the function to run 100,000 times on a given input.\n",
-    " - Each test is repeated either 5 or 100 times, and the mean ± standard deviation is reported.\n",
-    " - The fastest time is shown in **bold**\n",
-    " - The timing results for the pure-Python functions include about 10-15 ms of \"function call overhead\"; the `fastnumbers` functions do not suffer from as much overhead because they are C-extensions.\n",
-    " - Python version-dependent behaviors:\n",
-    "   - **Python 2.7** has a particularly slow `int` function, so the `fastnumbers` speedup is much larger on Python 2.7 than Python 3.x\n",
-    "   - **Python >=3.6** is slightly slower in general than previous versions because underscores are now allowed in floats and integers which makes parsing take a bit longer due to the extra logic.\n",
-    "   \n",
-    "#### Notes about the `Timing` class below\n",
-    "\n",
-    "The timing runner class is implemented below, and this is used in all the tests to perform the actual timing tests in the sections below. In general you can skip this implementation, but of note is the `THINGS_TO_TIME` tuple, which contains the values that are passed to the functions to type the various input types."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "sys.version_info(major=3, minor=5, micro=6, releaselevel='final', serial=0)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from __future__ import print_function, division\n",
-    "import re\n",
-    "import math\n",
-    "import timeit\n",
-    "from IPython.display import Markdown, display, clear_output\n",
-    "\n",
-    "class Timer(object):\n",
-    "    \"\"\"Class to time functions and make pretty tables of the output.\"\"\"\n",
-    "    \n",
-    "    # This is a list of all the things we will time with an associated label.\n",
-    "    THINGS_TO_TIME = (\n",
-    "        ('not_a_number', 'Non-number String'),\n",
-    "        ('-4', 'Small Int String'),\n",
-    "        ('-41053', 'Int String'),\n",
-    "        ('35892482945872302493947939485729', 'Large Int String'),\n",
-    "        ('-4.1', 'Small Float String'),\n",
-    "        ('-41053.543034e34', 'Float String'),\n",
-    "        ('-41053.543028758302e256', 'Large Float String'),\n",
-    "        (-41053, 'Int'),\n",
-    "        (-41053.543028758302e100, 'Float'),\n",
-    "    )\n",
-    "\n",
-    "    # Formatting strings.\n",
-    "    FUNCTION_CALL_FMT = '{}({!r})'\n",
-    "    \n",
-    "    def __init__(self, title):\n",
-    "        display(Markdown('### ' + title))\n",
-    "        self.functions = []\n",
-    "    \n",
-    "    def add_function(self, func, label, setup='pass'):\n",
-    "        \"\"\"Add a function to be timed and compared.\"\"\"\n",
-    "        self.functions.append((func, setup, label))\n",
-    "\n",
-    "    def time_functions(self, repeat=5):\n",
-    "        \"\"\"Time all the given functions against all input then display results.\"\"\"\n",
-    "\n",
-    "        # Collect the function labels to make the header of this table.\n",
-    "        # Show that the units are seconds for each.\n",
-    "        function_labels = [label + ' (ms)' for _, _, label in self.functions]\n",
-    "        \n",
-    "        # Construct the table strings, formatted in Markdown.\n",
-    "        # Store each line as a string element in a list.\n",
-    "        # This portion here is the table header only for now.\n",
-    "        table = Table()\n",
-    "        table.add_header('Input type', *function_labels)\n",
-    "        \n",
-    "        # For each value, time each function and collect the results.\n",
-    "        for value, value_label in self.THINGS_TO_TIME:\n",
-    "            row = []\n",
-    "            for func, setup, _ in self.functions:\n",
-    "                call = self.FUNCTION_CALL_FMT.format(func, value)\n",
-    "                try:\n",
-    "                    row.append(self._timeit(call, setup, repeat))\n",
-    "                except (ValueError, TypeError):\n",
-    "                    # We might send in some invalid input accidentally.\n",
-    "                    # Ignore those inputs.\n",
-    "                    break\n",
-    "\n",
-    "            # Only add this row if the for loop quit without break.\n",
-    "            else:\n",
-    "                # Convert to milliseconds\n",
-    "                row = [(mean * 1000, stddev * 1000) for mean, stddev in row]\n",
-    "                # Make the lowest value bold.\n",
-    "                min_indx = min(enumerate(row), key=lambda x: x[1])[0]\n",
-    "                row = ['{:.3f} ± {:.3f}'.format(*x) for x in row]\n",
-    "                row[min_indx] = self.bold(row[min_indx])\n",
-    "                table.add_row(value_label, *row)\n",
-    "\n",
-    "        # Show the results in a table.\n",
-    "        display(Markdown(str(table)))\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def mean(x):\n",
-    "        return math.fsum(x) / len(x)\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def stddev(x):\n",
-    "        mean = Timer.mean(x)\n",
-    "        sum_of_squares = math.fsum((v - mean)**2 for v in x)\n",
-    "        return math.sqrt(sum_of_squares / (len(x) - 1))\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def bold(x):\n",
-    "        return \"**{}**\".format(x)\n",
-    "    \n",
-    "    def _timeit(self, call, setup, repeat=5):\n",
-    "        \"\"\"Perform the actual timing and return a formatted string of the runtime\"\"\"\n",
-    "        result = timeit.repeat(call, setup, number=100000, repeat=repeat)\n",
-    "        return self.mean(result), self.stddev(result)\n",
-    "\n",
-    "class Table(list):\n",
-    "    \"\"\"List of strings that can be made into a Markdown table.\"\"\"\n",
-    "    def add_row(self, *elements):\n",
-    "        self.append('|'.join(elements))\n",
-    "    def add_header(self, *elements):\n",
-    "        self.add_row(*elements)\n",
-    "        seperators = ['---'] * len(elements)\n",
-    "        seperators = [sep + (':' if i != 0 else '') for i, sep in enumerate(seperators)]\n",
-    "        self.add_row(*seperators)\n",
-    "    def __str__(self):\n",
-    "        return '\\n'.join(self)\n",
-    "\n",
-    "    \n",
-    "import sys\n",
-    "print(sys.version_info)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Built-in Functions Drop-in Replacement Timing Results\n",
-    "The following timing tests compare the performance of Python's builtin `int` and `float` functions against the implementations from `fastnumbers` for various input types."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `int` functions"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|builtin (ms)|fastnumbers (ms)\n",
-       "---|---:|---:\n",
-       "Small Int String|18.300 ± 1.921|**12.096 ± 0.195**\n",
-       "Int String|18.069 ± 0.116|**13.868 ± 0.048**\n",
-       "Large Int String|**23.110 ± 0.219**|24.665 ± 0.132\n",
-       "Int|**9.842 ± 0.019**|10.065 ± 0.170\n",
-       "Float|25.132 ± 0.173|**24.559 ± 0.231**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "timer = Timer('Timing comparison of `int` functions')\n",
-    "timer.add_function('int', 'builtin')\n",
-    "timer.add_function('int', 'fastnumbers', 'from fastnumbers import int')\n",
-    "timer.time_functions(repeat=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` functions"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|builtin (ms)|fastnumbers (ms)\n",
-       "---|---:|---:\n",
-       "Small Int String|16.618 ± 1.050|**13.026 ± 0.087**\n",
-       "Int String|17.051 ± 0.258|**13.592 ± 0.045**\n",
-       "Large Int String|**39.689 ± 0.352**|41.238 ± 0.159\n",
-       "Small Float String|16.779 ± 0.059|**13.607 ± 0.188**\n",
-       "Float String|41.306 ± 0.212|**15.002 ± 0.290**\n",
-       "Large Float String|73.779 ± 3.112|**72.747 ± 0.992**\n",
-       "Int|15.106 ± 0.343|**13.376 ± 0.221**\n",
-       "Float|10.758 ± 0.261|**9.653 ± 0.201**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "timer = Timer('Timing comparison of `float` functions')\n",
-    "timer.add_function('float', 'builtin')\n",
-    "timer.add_function('float', 'fastnumbers', 'from fastnumbers import float')\n",
-    "timer.time_functions(repeat=100)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Error-Handling Conversion Functions Timing Results\n",
-    "The following timing tests compare the performance of the `fastnumbers` functions that convert input to numeric types while doing error handling with common equivalent pure-Python implementations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `int` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|139.867 ± 8.382|40.248 ± 0.022|**12.515 ± 0.333**\n",
-       "Small Int String|27.062 ± 0.039|62.238 ± 2.573|**12.661 ± 0.018**\n",
-       "Int String|27.884 ± 0.025|67.332 ± 1.208|**14.750 ± 0.042**\n",
-       "Large Int String|35.074 ± 0.331|98.660 ± 2.440|**25.400 ± 0.020**\n",
-       "Small Float String|128.910 ± 0.815|45.091 ± 0.611|**12.596 ± 0.018**\n",
-       "Float String|138.439 ± 0.338|52.313 ± 0.165|**12.812 ± 0.016**\n",
-       "Large Float String|145.466 ± 6.762|52.518 ± 0.341|**13.871 ± 0.197**\n",
-       "Int|21.058 ± 0.082|91.689 ± 2.353|**10.801 ± 0.024**\n",
-       "Float|34.740 ± 0.060|105.248 ± 7.611|**25.144 ± 0.020**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def int_re(x, int_match=re.compile(r'[-+]?\\d+$').match):\n",
-    "    \"\"\"Function to simulate fast_int but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return int(x)\n",
-    "\n",
-    "def int_try(x):\n",
-    "    \"\"\"Function to simulate fast_int but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return int(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of `int` functions with error handling')\n",
-    "timer.add_function('int_try', 'try/except', 'from __main__ import int_try')\n",
-    "timer.add_function('int_re', 'regex', 'from __main__ import int_re')\n",
-    "timer.add_function('fast_int', 'fastnumbers', 'from fastnumbers import fast_int')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|100.024 ± 5.108|46.575 ± 0.980|**12.832 ± 0.074**\n",
-       "Small Int String|28.879 ± 0.087|74.808 ± 2.293|**14.084 ± 0.488**\n",
-       "Int String|27.937 ± 0.023|78.356 ± 0.965|**14.370 ± 0.006**\n",
-       "Large Int String|51.189 ± 0.017|129.265 ± 0.550|**42.177 ± 0.321**\n",
-       "Small Float String|27.775 ± 0.010|72.907 ± 0.440|**14.271 ± 0.005**\n",
-       "Float String|52.732 ± 0.033|117.696 ± 0.837|**15.779 ± 0.031**\n",
-       "Large Float String|90.478 ± 6.332|156.654 ± 0.535|**73.442 ± 0.052**\n",
-       "Int|26.118 ± 0.407|94.987 ± 0.150|**14.159 ± 0.023**\n",
-       "Float|21.566 ± 0.025|90.204 ± 0.639|**10.219 ± 0.012**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def float_re(x, float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_float but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if float_match(x):\n",
-    "            return float(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return float(x)\n",
-    "\n",
-    "def float_try(x):\n",
-    "    \"\"\"Function to simulate fast_float but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return float(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of `float` functions with error handling')\n",
-    "timer.add_function('float_try', 'try/except', 'from __main__ import float_try')\n",
-    "timer.add_function('float_re', 'regex', 'from __main__ import float_re')\n",
-    "timer.add_function('fast_float', 'fastnumbers', 'from fastnumbers import fast_float')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|100.073 ± 7.343|79.565 ± 0.479|**13.236 ± 0.082**\n",
-       "Small Int String|50.484 ± 1.098|64.384 ± 1.161|**13.336 ± 0.013**\n",
-       "Int String|52.166 ± 0.439|66.460 ± 0.126|**15.304 ± 0.010**\n",
-       "Large Int String|86.692 ± 0.028|98.642 ± 0.551|**29.187 ± 0.059**\n",
-       "Small Float String|50.014 ± 0.995|107.214 ± 0.436|**16.712 ± 0.014**\n",
-       "Float String|91.603 ± 0.045|159.401 ± 0.235|**29.163 ± 0.073**\n",
-       "Large Float String|167.878 ± 0.459|198.068 ± 1.309|**109.333 ± 0.440**\n",
-       "Int|49.084 ± 0.045|94.791 ± 0.069|**10.190 ± 0.005**\n",
-       "Float|73.756 ± 0.236|95.102 ± 0.482|**47.500 ± 0.360**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def real_re(x,\n",
-    "            int_match=re.compile(r'[-+]?\\d+$').match,\n",
-    "            real_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_real but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        elif real_match(x):\n",
-    "            return float(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        if type(x) in (float, int):\n",
-    "            return x\n",
-    "        else:\n",
-    "            raise TypeError\n",
-    "\n",
-    "def real_try(x):\n",
-    "    \"\"\"Function to simulate fast_real but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        a = float(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "    else:\n",
-    "        b = int(a)\n",
-    "        return b if a == b else b\n",
-    "\n",
-    "timer = Timer('Timing comparison of `float` (but coerce to `int` if possible) functions with error handling')\n",
-    "timer.add_function('real_try', 'try/except', 'from __main__ import real_try')\n",
-    "timer.add_function('real_re', 'regex', 'from __main__ import real_re')\n",
-    "timer.add_function('fast_real', 'fastnumbers', 'from fastnumbers import fast_real')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of forced `int` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|244.823 ± 15.385|79.286 ± 0.153|**12.971 ± 0.324**\n",
-       "Small Int String|26.944 ± 0.019|59.953 ± 0.452|**13.281 ± 0.006**\n",
-       "Int String|27.817 ± 0.021|68.868 ± 7.404|**18.182 ± 1.116**\n",
-       "Large Int String|33.263 ± 0.368|178.418 ± 4.251|**29.240 ± 0.519**\n",
-       "Small Float String|162.987 ± 8.011|120.105 ± 1.716|**18.973 ± 0.046**\n",
-       "Float String|202.641 ± 2.391|179.179 ± 2.396|**29.746 ± 0.087**\n",
-       "Large Float String|256.698 ± 1.134|240.627 ± 3.280|**108.667 ± 0.025**\n",
-       "Int|19.622 ± 0.030|87.825 ± 0.694|**10.099 ± 0.056**\n",
-       "Float|34.976 ± 0.034|104.639 ± 2.756|**24.786 ± 0.359**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def forceint_re(x,\n",
-    "                int_match=re.compile(r'[-+]\\d+$').match,\n",
-    "                float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_forceint but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        elif float_match(x):\n",
-    "            return int(float(x))\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return int(x)\n",
-    "\n",
-    "def forceint_try(x):\n",
-    "    \"\"\"Function to simulate fast_forceint but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return int(x)\n",
-    "    except ValueError:\n",
-    "        try:\n",
-    "            return int(float(x))\n",
-    "        except ValueError:\n",
-    "            return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of forced `int` functions with error handling')\n",
-    "timer.add_function('forceint_try', 'try/except', 'from __main__ import forceint_try')\n",
-    "timer.add_function('forceint_re', 'regex', 'from __main__ import forceint_re')\n",
-    "timer.add_function('fast_forceint', 'fastnumbers', 'from fastnumbers import fast_forceint')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
-   "source": [
-    "## Checking Functions Timing Results\n",
-    "The following timing tests compare the performance of the `fastnumbers` functions that check if an input *could* be converted to numeric type with common equivalent pure-Python implementations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|136.770 ± 7.570|68.438 ± 0.765|**12.166 ± 0.092**\n",
-       "Small Int String|41.092 ± 1.086|75.545 ± 1.053|**11.699 ± 0.029**\n",
-       "Int String|39.501 ± 0.042|75.559 ± 0.291|**12.129 ± 0.027**\n",
-       "Large Int String|45.077 ± 0.029|100.621 ± 0.502|**14.624 ± 0.024**\n",
-       "Small Float String|129.223 ± 0.837|72.828 ± 0.229|**11.847 ± 0.011**\n",
-       "Float String|135.933 ± 0.153|81.394 ± 0.260|**12.383 ± 0.049**\n",
-       "Large Float String|141.929 ± 1.038|80.747 ± 0.203|**12.288 ± 0.007**\n",
-       "Int|31.064 ± 0.007|29.168 ± 0.013|**9.079 ± 0.011**\n",
-       "Float|46.022 ± 0.152|28.008 ± 0.036|**9.255 ± 0.029**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isint_re(x, int_match=re.compile(r'[-+]?\\d+$').match):\n",
-    "    \"\"\"Function to simulate isint but with regular expressions.\"\"\"\n",
-    "    t = type(x)\n",
-    "    return t == int if t in (float, int) else bool(int_match(x))\n",
-    "\n",
-    "def isint_try(x):\n",
-    "    \"\"\"Function to simulate isint but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        int(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return type(x) != float\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `int`')\n",
-    "timer.add_function('isint_try', 'try/except', 'from __main__ import isint_try')\n",
-    "timer.add_function('isint_re', 'regex', 'from __main__ import isint_re')\n",
-    "timer.add_function('isint', 'fastnumbers', 'from fastnumbers import isint')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `float`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|99.873 ± 5.316|70.125 ± 0.223|**12.096 ± 0.039**\n",
-       "Small Int String|37.519 ± 0.058|79.637 ± 0.484|**11.807 ± 0.021**\n",
-       "Int String|38.727 ± 0.270|84.876 ± 0.250|**12.310 ± 0.125**\n",
-       "Large Int String|63.529 ± 0.434|108.808 ± 1.519|**13.577 ± 0.015**\n",
-       "Small Float String|38.133 ± 0.024|78.530 ± 0.654|**11.962 ± 0.069**\n",
-       "Float String|67.089 ± 1.180|100.133 ± 2.517|**12.614 ± 0.024**\n",
-       "Large Float String|95.234 ± 0.213|105.110 ± 0.363|**12.966 ± 0.020**\n",
-       "Int|35.489 ± 0.026|29.958 ± 0.081|**9.339 ± 0.023**\n",
-       "Float|32.315 ± 0.649|27.403 ± 0.015|**8.571 ± 0.033**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isfloat_re(x, float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isfloat but with regular expressions.\"\"\"\n",
-    "    t = type(x)\n",
-    "    return t == float if t in (float, int) else bool(float_match(x))\n",
-    "\n",
-    "def isfloat_try(x):\n",
-    "    \"\"\"Function to simulate isfloat but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        float(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return type(x) != int\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `float`')\n",
-    "timer.add_function('isfloat_try', 'try/except', 'from __main__ import isfloat_try')\n",
-    "timer.add_function('isfloat_re', 'regex', 'from __main__ import isfloat_re')\n",
-    "timer.add_function('isfloat', 'fastnumbers', 'from fastnumbers import isfloat')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `float` or `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|99.393 ± 6.224|69.763 ± 1.438|**12.103 ± 0.009**\n",
-       "Small Int String|27.034 ± 0.203|82.158 ± 1.140|**12.602 ± 0.072**\n",
-       "Int String|29.275 ± 0.133|85.371 ± 2.650|**12.305 ± 0.211**\n",
-       "Large Int String|50.929 ± 0.057|109.240 ± 2.687|**13.460 ± 0.004**\n",
-       "Small Float String|27.619 ± 0.120|80.067 ± 1.444|**12.529 ± 0.062**\n",
-       "Float String|54.957 ± 0.973|97.142 ± 0.777|**12.757 ± 0.023**\n",
-       "Large Float String|83.728 ± 0.057|105.238 ± 1.151|**13.356 ± 0.124**\n",
-       "Int|26.100 ± 0.174|27.249 ± 0.102|**9.409 ± 0.186**\n",
-       "Float|21.477 ± 0.573|23.395 ± 0.040|**8.731 ± 0.055**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isreal_re(x, real_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isreal but with regular expressions.\"\"\"\n",
-    "    return type(x) in (float, int) or bool(real_match(x))\n",
-    "\n",
-    "def isreal_try(x):\n",
-    "    \"\"\"Function to simulate isreal but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        float(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return True\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `float` or `int`')\n",
-    "timer.add_function('isreal_try', 'try/except', 'from __main__ import isreal_try')\n",
-    "timer.add_function('isreal_re', 'regex', 'from __main__ import isreal_re')\n",
-    "timer.add_function('isreal', 'fastnumbers', 'from fastnumbers import isreal')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be coerced losslessly to `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|237.356 ± 8.392|77.243 ± 0.120|**12.067 ± 0.106**\n",
-       "Small Int String|55.912 ± 1.349|44.405 ± 0.884|**11.210 ± 0.050**\n",
-       "Int String|56.230 ± 0.123|45.226 ± 0.036|**11.406 ± 0.024**\n",
-       "Large Int String|92.532 ± 0.899|70.153 ± 0.084|**12.840 ± 0.067**\n",
-       "Small Float String|156.041 ± 1.430|109.634 ± 0.327|**11.637 ± 0.025**\n",
-       "Float String|191.856 ± 1.885|160.514 ± 0.268|**12.368 ± 0.024**\n",
-       "Large Float String|227.364 ± 2.524|198.978 ± 0.735|**13.073 ± 0.508**\n",
-       "Int|45.582 ± 0.356|92.058 ± 1.575|**8.785 ± 0.195**\n",
-       "Float|72.378 ± 0.400|127.355 ± 0.175|**31.312 ± 0.014**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isintlike_re(x,\n",
-    "                 int_match=re.compile(r'[-+]?\\d+$').match,\n",
-    "                 float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isintlike but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return True\n",
-    "        elif float_match(x):\n",
-    "            return float(x).is_integer()\n",
-    "        else:\n",
-    "            return False\n",
-    "    except TypeError:\n",
-    "        return int(x) == x\n",
-    "\n",
-    "def isintlike_try(x):\n",
-    "    \"\"\"Function to simulate isintlike but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        a = int(x)\n",
-    "    except ValueError:\n",
-    "        try:\n",
-    "            a = float(x)\n",
-    "        except ValueError:\n",
-    "            return False\n",
-    "        else:\n",
-    "            return a.is_integer()\n",
-    "    else:\n",
-    "        return a == float(x)\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be coerced losslessly to `int`')\n",
-    "timer.add_function('isintlike_try', 'try/except', 'from __main__ import isintlike_try')\n",
-    "timer.add_function('isintlike_re', 'regex', 'from __main__ import isintlike_re')\n",
-    "timer.add_function('isintlike', 'fastnumbers', 'from fastnumbers import isintlike')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.5.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/TIMING_36.ipynb b/TIMING_36.ipynb
deleted file mode 100644
index 354dd560..00000000
--- a/TIMING_36.ipynb
+++ /dev/null
@@ -1,836 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Timing Tests of `fastnumbers` Functions Compared to Equivalent Solutions\n",
-    "\n",
-    "In order for you to see the benefit of `fastnumbers`, some timings are collected below for comparison to equivalent python implementations. The numbers may change depending on the machine you are on or the Python version you are using.\n",
-    "\n",
-    "Feel free to download this Jupyter Notebook and run the tests yourself to see how `fastnumbers` performs on your machine (it takes about 1-2 minutes total).\n",
-    "\n",
-    "**This notebook contains timing results for Python 3.6.**\n",
-    "\n",
-    "#### Some notes about the data\n",
-    "\n",
-    " - Each test is the time it takes for the function to run 100,000 times on a given input.\n",
-    " - Each test is repeated either 5 or 100 times, and the mean ± standard deviation is reported.\n",
-    " - The fastest time is shown in **bold**\n",
-    " - The timing results for the pure-Python functions include about 10-15 ms of \"function call overhead\"; the `fastnumbers` functions do not suffer from as much overhead because they are C-extensions.\n",
-    " - Python version-dependent behaviors:\n",
-    "   - **Python 2.7** has a particularly slow `int` function, so the `fastnumbers` speedup is much larger on Python 2.7 than Python 3.x\n",
-    "   - **Python >=3.6** is slightly slower in general than previous versions because underscores are now allowed in floats and integers which makes parsing take a bit longer due to the extra logic.\n",
-    "   \n",
-    "#### Notes about the `Timing` class below\n",
-    "\n",
-    "The timing runner class is implemented below, and this is used in all the tests to perform the actual timing tests in the sections below. In general you can skip this implementation, but of note is the `THINGS_TO_TIME` tuple, which contains the values that are passed to the functions to type the various input types."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "sys.version_info(major=3, minor=6, micro=9, releaselevel='final', serial=0)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from __future__ import print_function, division\n",
-    "import re\n",
-    "import math\n",
-    "import timeit\n",
-    "from IPython.display import Markdown, display, clear_output\n",
-    "\n",
-    "class Timer(object):\n",
-    "    \"\"\"Class to time functions and make pretty tables of the output.\"\"\"\n",
-    "    \n",
-    "    # This is a list of all the things we will time with an associated label.\n",
-    "    THINGS_TO_TIME = (\n",
-    "        ('not_a_number', 'Non-number String'),\n",
-    "        ('-4', 'Small Int String'),\n",
-    "        ('-41053', 'Int String'),\n",
-    "        ('35892482945872302493947939485729', 'Large Int String'),\n",
-    "        ('-4.1', 'Small Float String'),\n",
-    "        ('-41053.543034e34', 'Float String'),\n",
-    "        ('-41053.543028758302e256', 'Large Float String'),\n",
-    "        (-41053, 'Int'),\n",
-    "        (-41053.543028758302e100, 'Float'),\n",
-    "    )\n",
-    "\n",
-    "    # Formatting strings.\n",
-    "    FUNCTION_CALL_FMT = '{}({!r})'\n",
-    "    \n",
-    "    def __init__(self, title):\n",
-    "        display(Markdown('### ' + title))\n",
-    "        self.functions = []\n",
-    "    \n",
-    "    def add_function(self, func, label, setup='pass'):\n",
-    "        \"\"\"Add a function to be timed and compared.\"\"\"\n",
-    "        self.functions.append((func, setup, label))\n",
-    "\n",
-    "    def time_functions(self, repeat=5):\n",
-    "        \"\"\"Time all the given functions against all input then display results.\"\"\"\n",
-    "\n",
-    "        # Collect the function labels to make the header of this table.\n",
-    "        # Show that the units are seconds for each.\n",
-    "        function_labels = [label + ' (ms)' for _, _, label in self.functions]\n",
-    "        \n",
-    "        # Construct the table strings, formatted in Markdown.\n",
-    "        # Store each line as a string element in a list.\n",
-    "        # This portion here is the table header only for now.\n",
-    "        table = Table()\n",
-    "        table.add_header('Input type', *function_labels)\n",
-    "        \n",
-    "        # For each value, time each function and collect the results.\n",
-    "        for value, value_label in self.THINGS_TO_TIME:\n",
-    "            row = []\n",
-    "            for func, setup, _ in self.functions:\n",
-    "                call = self.FUNCTION_CALL_FMT.format(func, value)\n",
-    "                try:\n",
-    "                    row.append(self._timeit(call, setup, repeat))\n",
-    "                except (ValueError, TypeError):\n",
-    "                    # We might send in some invalid input accidentally.\n",
-    "                    # Ignore those inputs.\n",
-    "                    break\n",
-    "\n",
-    "            # Only add this row if the for loop quit without break.\n",
-    "            else:\n",
-    "                # Convert to milliseconds\n",
-    "                row = [(mean * 1000, stddev * 1000) for mean, stddev in row]\n",
-    "                # Make the lowest value bold.\n",
-    "                min_indx = min(enumerate(row), key=lambda x: x[1])[0]\n",
-    "                row = ['{:.3f} ± {:.3f}'.format(*x) for x in row]\n",
-    "                row[min_indx] = self.bold(row[min_indx])\n",
-    "                table.add_row(value_label, *row)\n",
-    "\n",
-    "        # Show the results in a table.\n",
-    "        display(Markdown(str(table)))\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def mean(x):\n",
-    "        return math.fsum(x) / len(x)\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def stddev(x):\n",
-    "        mean = Timer.mean(x)\n",
-    "        sum_of_squares = math.fsum((v - mean)**2 for v in x)\n",
-    "        return math.sqrt(sum_of_squares / (len(x) - 1))\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def bold(x):\n",
-    "        return \"**{}**\".format(x)\n",
-    "    \n",
-    "    def _timeit(self, call, setup, repeat=5):\n",
-    "        \"\"\"Perform the actual timing and return a formatted string of the runtime\"\"\"\n",
-    "        result = timeit.repeat(call, setup, number=100000, repeat=repeat)\n",
-    "        return self.mean(result), self.stddev(result)\n",
-    "\n",
-    "class Table(list):\n",
-    "    \"\"\"List of strings that can be made into a Markdown table.\"\"\"\n",
-    "    def add_row(self, *elements):\n",
-    "        self.append('|'.join(elements))\n",
-    "    def add_header(self, *elements):\n",
-    "        self.add_row(*elements)\n",
-    "        seperators = ['---'] * len(elements)\n",
-    "        seperators = [sep + (':' if i != 0 else '') for i, sep in enumerate(seperators)]\n",
-    "        self.add_row(*seperators)\n",
-    "    def __str__(self):\n",
-    "        return '\\n'.join(self)\n",
-    "\n",
-    "\n",
-    "import sys\n",
-    "print(sys.version_info)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Built-in Functions Drop-in Replacement Timing Results\n",
-    "The following timing tests compare the performance of Python's builtin `int` and `float` functions against the implementations from `fastnumbers` for various input types."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `int` functions"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|builtin (ms)|fastnumbers (ms)\n",
-       "---|---:|---:\n",
-       "Small Int String|20.979 ± 1.132|**14.467 ± 1.031**\n",
-       "Int String|21.856 ± 0.724|**15.621 ± 0.471**\n",
-       "Large Int String|**29.114 ± 0.464**|30.062 ± 1.599\n",
-       "Int|12.319 ± 0.149|**10.412 ± 0.252**\n",
-       "Float|27.806 ± 0.204|**25.298 ± 0.371**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "timer = Timer('Timing comparison of `int` functions')\n",
-    "timer.add_function('int', 'builtin')\n",
-    "timer.add_function('int', 'fastnumbers', 'from fastnumbers import int')\n",
-    "timer.time_functions(repeat=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` functions"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|builtin (ms)|fastnumbers (ms)\n",
-       "---|---:|---:\n",
-       "Small Int String|18.151 ± 0.731|**13.858 ± 0.245**\n",
-       "Int String|18.776 ± 0.389|**14.338 ± 0.105**\n",
-       "Large Int String|**41.426 ± 0.517**|42.038 ± 0.293\n",
-       "Small Float String|18.502 ± 0.126|**14.161 ± 0.116**\n",
-       "Float String|43.327 ± 0.219|**15.619 ± 0.044**\n",
-       "Large Float String|74.260 ± 1.893|**73.192 ± 0.971**\n",
-       "Int|12.323 ± 0.016|**10.358 ± 0.035**\n",
-       "Float|10.979 ± 0.026|**9.304 ± 0.176**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "timer = Timer('Timing comparison of `float` functions')\n",
-    "timer.add_function('float', 'builtin')\n",
-    "timer.add_function('float', 'fastnumbers', 'from fastnumbers import float')\n",
-    "timer.time_functions(repeat=100)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Error-Handling Conversion Functions Timing Results\n",
-    "The following timing tests compare the performance of the `fastnumbers` functions that convert input to numeric types while doing error handling with common equivalent pure-Python implementations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `int` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|144.683 ± 3.347|41.749 ± 0.246|**21.335 ± 0.162**\n",
-       "Small Int String|32.662 ± 0.886|71.386 ± 1.048|**13.753 ± 0.038**\n",
-       "Int String|33.090 ± 0.127|73.380 ± 1.152|**15.589 ± 0.024**\n",
-       "Large Int String|41.284 ± 0.056|106.675 ± 1.183|**30.585 ± 0.018**\n",
-       "Small Float String|137.226 ± 3.178|46.039 ± 0.076|**13.533 ± 0.010**\n",
-       "Float String|142.712 ± 1.011|53.792 ± 0.047|**13.981 ± 0.049**\n",
-       "Large Float String|150.679 ± 0.756|53.280 ± 0.008|**14.280 ± 0.034**\n",
-       "Int|24.021 ± 0.021|92.668 ± 0.470|**11.265 ± 0.029**\n",
-       "Float|39.637 ± 0.028|113.185 ± 2.360|**28.474 ± 0.022**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def int_re(x, int_match=re.compile(r'[-+]?\\d+$').match):\n",
-    "    \"\"\"Function to simulate fast_int but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return int(x)\n",
-    "\n",
-    "def int_try(x):\n",
-    "    \"\"\"Function to simulate fast_int but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return int(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of `int` functions with error handling')\n",
-    "timer.add_function('int_try', 'try/except', 'from __main__ import int_try')\n",
-    "timer.add_function('int_re', 'regex', 'from __main__ import int_re')\n",
-    "timer.add_function('fast_int', 'fastnumbers', 'from fastnumbers import fast_int')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|83.510 ± 3.017|46.939 ± 0.359|**20.820 ± 0.047**\n",
-       "Small Int String|28.160 ± 0.188|79.882 ± 2.368|**15.813 ± 0.051**\n",
-       "Int String|31.155 ± 0.567|84.160 ± 2.408|**16.009 ± 0.455**\n",
-       "Large Int String|52.098 ± 0.037|129.641 ± 0.340|**43.951 ± 0.474**\n",
-       "Small Float String|29.229 ± 0.202|79.912 ± 2.453|**15.724 ± 0.303**\n",
-       "Float String|54.785 ± 1.037|121.975 ± 0.538|**17.163 ± 0.004**\n",
-       "Large Float String|84.763 ± 0.353|161.045 ± 2.012|**74.414 ± 0.104**\n",
-       "Int|22.444 ± 0.013|90.434 ± 0.368|**11.567 ± 0.005**\n",
-       "Float|21.335 ± 0.070|89.935 ± 0.230|**10.479 ± 0.031**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def float_re(x, float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_float but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if float_match(x):\n",
-    "            return float(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return float(x)\n",
-    "\n",
-    "def float_try(x):\n",
-    "    \"\"\"Function to simulate fast_float but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return float(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of `float` functions with error handling')\n",
-    "timer.add_function('float_try', 'try/except', 'from __main__ import float_try')\n",
-    "timer.add_function('float_re', 'regex', 'from __main__ import float_re')\n",
-    "timer.add_function('fast_float', 'fastnumbers', 'from fastnumbers import fast_float')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|86.011 ± 10.141|78.260 ± 0.350|**22.121 ± 0.315**\n",
-       "Small Int String|49.187 ± 2.165|65.275 ± 0.477|**14.633 ± 0.022**\n",
-       "Int String|52.408 ± 0.105|72.847 ± 1.617|**16.873 ± 0.008**\n",
-       "Large Int String|90.163 ± 0.172|102.653 ± 0.029|**33.967 ± 0.067**\n",
-       "Small Float String|49.394 ± 0.112|113.780 ± 2.718|**18.058 ± 0.006**\n",
-       "Float String|94.656 ± 0.157|165.167 ± 5.397|**32.193 ± 0.042**\n",
-       "Large Float String|174.448 ± 5.179|202.332 ± 2.477|**111.109 ± 0.992**\n",
-       "Int|44.910 ± 0.195|93.687 ± 0.066|**11.376 ± 0.012**\n",
-       "Float|75.685 ± 0.049|94.530 ± 0.395|**47.864 ± 0.117**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def real_re(x,\n",
-    "            int_match=re.compile(r'[-+]?\\d+$').match,\n",
-    "            real_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_real but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        elif real_match(x):\n",
-    "            return float(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        if type(x) in (float, int):\n",
-    "            return x\n",
-    "        else:\n",
-    "            raise TypeError\n",
-    "\n",
-    "def real_try(x):\n",
-    "    \"\"\"Function to simulate fast_real but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        a = float(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "    else:\n",
-    "        b = int(a)\n",
-    "        return b if a == b else b\n",
-    "\n",
-    "timer = Timer('Timing comparison of `float` (but coerce to `int` if possible) functions with error handling')\n",
-    "timer.add_function('real_try', 'try/except', 'from __main__ import real_try')\n",
-    "timer.add_function('real_re', 'regex', 'from __main__ import real_re')\n",
-    "timer.add_function('fast_real', 'fastnumbers', 'from fastnumbers import fast_real')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of forced `int` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|220.782 ± 5.873|78.113 ± 2.879|**23.518 ± 0.345**\n",
-       "Small Int String|32.161 ± 0.363|63.187 ± 1.494|**14.501 ± 0.036**\n",
-       "Int String|31.157 ± 0.242|66.524 ± 0.087|**17.052 ± 0.018**\n",
-       "Large Int String|39.329 ± 0.151|179.512 ± 1.573|**33.950 ± 0.209**\n",
-       "Small Float String|167.763 ± 1.714|117.728 ± 0.715|**20.554 ± 0.053**\n",
-       "Float String|216.373 ± 10.684|207.621 ± 10.602|**32.358 ± 0.077**\n",
-       "Large Float String|267.190 ± 6.281|244.906 ± 4.435|**110.536 ± 1.295**\n",
-       "Int|23.086 ± 0.858|99.587 ± 0.961|**11.349 ± 0.143**\n",
-       "Float|38.894 ± 0.875|110.764 ± 5.551|**25.543 ± 0.194**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def forceint_re(x,\n",
-    "                int_match=re.compile(r'[-+]\\d+$').match,\n",
-    "                float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_forceint but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        elif float_match(x):\n",
-    "            return int(float(x))\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return int(x)\n",
-    "\n",
-    "def forceint_try(x):\n",
-    "    \"\"\"Function to simulate fast_forceint but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return int(x)\n",
-    "    except ValueError:\n",
-    "        try:\n",
-    "            return int(float(x))\n",
-    "        except ValueError:\n",
-    "            return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of forced `int` functions with error handling')\n",
-    "timer.add_function('forceint_try', 'try/except', 'from __main__ import forceint_try')\n",
-    "timer.add_function('forceint_re', 'regex', 'from __main__ import forceint_re')\n",
-    "timer.add_function('fast_forceint', 'fastnumbers', 'from fastnumbers import fast_forceint')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
-   "source": [
-    "## Checking Functions Timing Results\n",
-    "The following timing tests compare the performance of the `fastnumbers` functions that check if an input *could* be converted to numeric type with common equivalent pure-Python implementations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|141.093 ± 5.387|70.776 ± 0.301|**21.645 ± 0.532**\n",
-       "Small Int String|44.548 ± 0.098|74.475 ± 1.835|**12.804 ± 0.319**\n",
-       "Int String|43.706 ± 0.625|77.166 ± 0.051|**13.167 ± 0.004**\n",
-       "Large Int String|53.041 ± 1.504|101.407 ± 0.402|**16.835 ± 0.414**\n",
-       "Small Float String|136.773 ± 2.733|75.112 ± 0.119|**12.675 ± 0.016**\n",
-       "Float String|142.669 ± 1.529|83.172 ± 0.504|**13.444 ± 0.015**\n",
-       "Large Float String|147.643 ± 2.316|82.862 ± 1.113|**13.367 ± 0.021**\n",
-       "Int|34.570 ± 0.054|32.585 ± 0.061|**10.106 ± 0.037**\n",
-       "Float|49.457 ± 0.148|30.953 ± 0.116|**10.060 ± 0.011**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isint_re(x, int_match=re.compile(r'[-+]?\\d+$').match):\n",
-    "    \"\"\"Function to simulate isint but with regular expressions.\"\"\"\n",
-    "    t = type(x)\n",
-    "    return t == int if t in (float, int) else bool(int_match(x))\n",
-    "\n",
-    "def isint_try(x):\n",
-    "    \"\"\"Function to simulate isint but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        int(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return type(x) != float\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `int`')\n",
-    "timer.add_function('isint_try', 'try/except', 'from __main__ import isint_try')\n",
-    "timer.add_function('isint_re', 'regex', 'from __main__ import isint_re')\n",
-    "timer.add_function('isint', 'fastnumbers', 'from fastnumbers import isint')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `float`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|83.848 ± 7.001|74.631 ± 0.095|**21.260 ± 0.371**\n",
-       "Small Int String|41.149 ± 0.429|90.871 ± 2.201|**14.011 ± 0.084**\n",
-       "Int String|44.037 ± 0.390|89.396 ± 0.961|**13.440 ± 0.007**\n",
-       "Large Int String|65.682 ± 0.083|112.739 ± 0.381|**14.927 ± 0.021**\n",
-       "Small Float String|41.853 ± 0.026|88.599 ± 2.144|**13.295 ± 0.148**\n",
-       "Float String|67.390 ± 0.473|101.040 ± 0.035|**13.950 ± 0.010**\n",
-       "Large Float String|98.492 ± 0.300|111.738 ± 3.609|**14.489 ± 0.513**\n",
-       "Int|34.600 ± 0.027|37.252 ± 6.607|**10.963 ± 0.373**\n",
-       "Float|34.284 ± 0.699|29.926 ± 0.016|**9.633 ± 0.018**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isfloat_re(x, float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isfloat but with regular expressions.\"\"\"\n",
-    "    t = type(x)\n",
-    "    return t == float if t in (float, int) else bool(float_match(x))\n",
-    "\n",
-    "def isfloat_try(x):\n",
-    "    \"\"\"Function to simulate isfloat but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        float(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return type(x) != int\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `float`')\n",
-    "timer.add_function('isfloat_try', 'try/except', 'from __main__ import isfloat_try')\n",
-    "timer.add_function('isfloat_re', 'regex', 'from __main__ import isfloat_re')\n",
-    "timer.add_function('isfloat', 'fastnumbers', 'from fastnumbers import isfloat')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `float` or `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|85.985 ± 8.067|82.365 ± 0.703|**21.755 ± 0.398**\n",
-       "Small Int String|27.934 ± 0.019|89.240 ± 2.058|**13.647 ± 0.446**\n",
-       "Int String|29.389 ± 0.630|91.554 ± 0.838|**13.491 ± 0.124**\n",
-       "Large Int String|53.059 ± 0.657|115.372 ± 0.990|**15.133 ± 0.564**\n",
-       "Small Float String|28.742 ± 0.081|89.933 ± 5.897|**13.198 ± 0.012**\n",
-       "Float String|53.800 ± 0.026|105.325 ± 0.781|**14.158 ± 0.126**\n",
-       "Large Float String|84.577 ± 0.568|114.008 ± 0.612|**14.250 ± 0.005**\n",
-       "Int|22.443 ± 0.019|27.993 ± 0.026|**9.574 ± 0.006**\n",
-       "Float|21.392 ± 0.463|26.376 ± 0.129|**9.759 ± 0.137**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isreal_re(x, real_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isreal but with regular expressions.\"\"\"\n",
-    "    return type(x) in (float, int) or bool(real_match(x))\n",
-    "\n",
-    "def isreal_try(x):\n",
-    "    \"\"\"Function to simulate isreal but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        float(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return True\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `float` or `int`')\n",
-    "timer.add_function('isreal_try', 'try/except', 'from __main__ import isreal_try')\n",
-    "timer.add_function('isreal_re', 'regex', 'from __main__ import isreal_re')\n",
-    "timer.add_function('isreal', 'fastnumbers', 'from fastnumbers import isreal')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be coerced losslessly to `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|222.218 ± 9.050|80.082 ± 1.280|**20.220 ± 0.022**\n",
-       "Small Int String|53.629 ± 0.268|44.853 ± 0.114|**12.722 ± 0.045**\n",
-       "Int String|57.669 ± 0.310|48.050 ± 0.130|**12.674 ± 0.058**\n",
-       "Large Int String|98.850 ± 0.392|70.958 ± 0.095|**14.075 ± 0.101**\n",
-       "Small Float String|165.709 ± 1.333|118.616 ± 1.261|**12.805 ± 0.007**\n",
-       "Float String|196.835 ± 1.935|171.553 ± 1.162|**13.725 ± 0.017**\n",
-       "Large Float String|236.102 ± 5.235|209.288 ± 1.628|**14.554 ± 0.036**\n",
-       "Int|40.924 ± 0.028|91.617 ± 0.498|**9.495 ± 0.072**\n",
-       "Float|75.837 ± 0.351|132.797 ± 0.305|**30.942 ± 0.588**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isintlike_re(x,\n",
-    "                 int_match=re.compile(r'[-+]?\\d+$').match,\n",
-    "                 float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isintlike but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return True\n",
-    "        elif float_match(x):\n",
-    "            return float(x).is_integer()\n",
-    "        else:\n",
-    "            return False\n",
-    "    except TypeError:\n",
-    "        return int(x) == x\n",
-    "\n",
-    "def isintlike_try(x):\n",
-    "    \"\"\"Function to simulate isintlike but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        a = int(x)\n",
-    "    except ValueError:\n",
-    "        try:\n",
-    "            a = float(x)\n",
-    "        except ValueError:\n",
-    "            return False\n",
-    "        else:\n",
-    "            return a.is_integer()\n",
-    "    else:\n",
-    "        return a == float(x)\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be coerced losslessly to `int`')\n",
-    "timer.add_function('isintlike_try', 'try/except', 'from __main__ import isintlike_try')\n",
-    "timer.add_function('isintlike_re', 'regex', 'from __main__ import isintlike_re')\n",
-    "timer.add_function('isintlike', 'fastnumbers', 'from fastnumbers import isintlike')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/TIMING_37.ipynb b/TIMING_37.ipynb
deleted file mode 100644
index 3c225daa..00000000
--- a/TIMING_37.ipynb
+++ /dev/null
@@ -1,836 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Timing Tests of `fastnumbers` Functions Compared to Equivalent Solutions\n",
-    "\n",
-    "In order for you to see the benefit of `fastnumbers`, some timings are collected below for comparison to equivalent python implementations. The numbers may change depending on the machine you are on or the Python version you are using.\n",
-    "\n",
-    "Feel free to download this Jupyter Notebook and run the tests yourself to see how `fastnumbers` performs on your machine (it takes about 1-2 minutes total).\n",
-    "\n",
-    "**This notebook contains timing results for Python 3.7.**\n",
-    "\n",
-    "#### Some notes about the data\n",
-    "\n",
-    " - Each test is the time it takes for the function to run 100,000 times on a given input.\n",
-    " - Each test is repeated either 5 or 100 times, and the mean ± standard deviation is reported.\n",
-    " - The fastest time is shown in **bold**\n",
-    " - The timing results for the pure-Python functions include about 10-15 ms of \"function call overhead\"; the `fastnumbers` functions do not suffer from as much overhead because they are C-extensions.\n",
-    " - Python version-dependent behaviors:\n",
-    "   - **Python 2.7** has a particularly slow `int` function, so the `fastnumbers` speedup is much larger on Python 2.7 than Python 3.x\n",
-    "   - **Python >=3.6** is slightly slower in general than previous versions because underscores are now allowed in floats and integers which makes parsing take a bit longer due to the extra logic.\n",
-    "   \n",
-    "#### Notes about the `Timer` class below\n",
-    "\n",
-    "The timing runner class is implemented below, and this is used in all the tests to perform the actual timing tests in the sections below. In general you can skip this implementation, but of note is the `THINGS_TO_TIME` tuple, which contains the values that are passed to the functions to type the various input types."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "sys.version_info(major=3, minor=7, micro=5, releaselevel='final', serial=0)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from __future__ import print_function, division\n",
-    "import re\n",
-    "import math\n",
-    "import timeit\n",
-    "from IPython.display import Markdown, display, clear_output\n",
-    "\n",
-    "class Timer(object):\n",
-    "    \"\"\"Class to time functions and make pretty tables of the output.\"\"\"\n",
-    "    \n",
-    "    # This is a list of all the things we will time with an associated label.\n",
-    "    THINGS_TO_TIME = (\n",
-    "        ('not_a_number', 'Non-number String'),\n",
-    "        ('-4', 'Small Int String'),\n",
-    "        ('-41053', 'Int String'),\n",
-    "        ('35892482945872302493947939485729', 'Large Int String'),\n",
-    "        ('-4.1', 'Small Float String'),\n",
-    "        ('-41053.543034e34', 'Float String'),\n",
-    "        ('-41053.543028758302e256', 'Large Float String'),\n",
-    "        (-41053, 'Int'),\n",
-    "        (-41053.543028758302e100, 'Float'),\n",
-    "    )\n",
-    "\n",
-    "    # Formatting strings.\n",
-    "    FUNCTION_CALL_FMT = '{}({!r})'\n",
-    "    \n",
-    "    def __init__(self, title):\n",
-    "        display(Markdown('### ' + title))\n",
-    "        self.functions = []\n",
-    "    \n",
-    "    def add_function(self, func, label, setup='pass'):\n",
-    "        \"\"\"Add a function to be timed and compared.\"\"\"\n",
-    "        self.functions.append((func, setup, label))\n",
-    "\n",
-    "    def time_functions(self, repeat=5):\n",
-    "        \"\"\"Time all the given functions against all input then display results.\"\"\"\n",
-    "\n",
-    "        # Collect the function labels to make the header of this table.\n",
-    "        # Show that the units are seconds for each.\n",
-    "        function_labels = [label + ' (ms)' for _, _, label in self.functions]\n",
-    "        \n",
-    "        # Construct the table strings, formatted in Markdown.\n",
-    "        # Store each line as a string element in a list.\n",
-    "        # This portion here is the table header only for now.\n",
-    "        table = Table()\n",
-    "        table.add_header('Input type', *function_labels)\n",
-    "        \n",
-    "        # For each value, time each function and collect the results.\n",
-    "        for value, value_label in self.THINGS_TO_TIME:\n",
-    "            row = []\n",
-    "            for func, setup, _ in self.functions:\n",
-    "                call = self.FUNCTION_CALL_FMT.format(func, value)\n",
-    "                try:\n",
-    "                    row.append(self._timeit(call, setup, repeat))\n",
-    "                except (ValueError, TypeError):\n",
-    "                    # We might send in some invalid input accidentally.\n",
-    "                    # Ignore those inputs.\n",
-    "                    break\n",
-    "\n",
-    "            # Only add this row if the for loop quit without break.\n",
-    "            else:\n",
-    "                # Convert to milliseconds\n",
-    "                row = [(mean * 1000, stddev * 1000) for mean, stddev in row]\n",
-    "                # Make the lowest value bold.\n",
-    "                min_indx = min(enumerate(row), key=lambda x: x[1])[0]\n",
-    "                row = ['{:.3f} ± {:.3f}'.format(*x) for x in row]\n",
-    "                row[min_indx] = self.bold(row[min_indx])\n",
-    "                table.add_row(value_label, *row)\n",
-    "\n",
-    "        # Show the results in a table.\n",
-    "        display(Markdown(str(table)))\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def mean(x):\n",
-    "        return math.fsum(x) / len(x)\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def stddev(x):\n",
-    "        mean = Timer.mean(x)\n",
-    "        sum_of_squares = math.fsum((v - mean)**2 for v in x)\n",
-    "        return math.sqrt(sum_of_squares / (len(x) - 1))\n",
-    "\n",
-    "    @staticmethod\n",
-    "    def bold(x):\n",
-    "        return \"**{}**\".format(x)\n",
-    "    \n",
-    "    def _timeit(self, call, setup, repeat=5):\n",
-    "        \"\"\"Perform the actual timing and return a formatted string of the runtime\"\"\"\n",
-    "        result = timeit.repeat(call, setup, number=100000, repeat=repeat)\n",
-    "        return self.mean(result), self.stddev(result)\n",
-    "\n",
-    "class Table(list):\n",
-    "    \"\"\"List of strings that can be made into a Markdown table.\"\"\"\n",
-    "    def add_row(self, *elements):\n",
-    "        self.append('|'.join(elements))\n",
-    "    def add_header(self, *elements):\n",
-    "        self.add_row(*elements)\n",
-    "        seperators = ['---'] * len(elements)\n",
-    "        seperators = [sep + (':' if i != 0 else '') for i, sep in enumerate(seperators)]\n",
-    "        self.add_row(*seperators)\n",
-    "    def __str__(self):\n",
-    "        return '\\n'.join(self)\n",
-    "\n",
-    "    \n",
-    "import sys\n",
-    "print(sys.version_info)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Built-in Functions Drop-in Replacement Timing Results\n",
-    "The following timing tests compare the performance of Python's builtin `int` and `float` functions against the implementations from `fastnumbers` for various input types."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `int` functions"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|builtin (ms)|fastnumbers (ms)\n",
-       "---|---:|---:\n",
-       "Small Int String|17.932 ± 2.940|**13.548 ± 0.517**\n",
-       "Int String|18.530 ± 1.043|**15.756 ± 0.605**\n",
-       "Large Int String|**24.696 ± 1.132**|27.728 ± 0.454\n",
-       "Int|**9.219 ± 0.139**|10.433 ± 0.152\n",
-       "Float|**24.451 ± 0.245**|25.454 ± 0.261"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "timer = Timer('Timing comparison of `int` functions')\n",
-    "timer.add_function('int', 'builtin')\n",
-    "timer.add_function('int', 'fastnumbers', 'from fastnumbers import int')\n",
-    "timer.time_functions(repeat=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` functions"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|builtin (ms)|fastnumbers (ms)\n",
-       "---|---:|---:\n",
-       "Small Int String|15.486 ± 0.473|**14.193 ± 0.155**\n",
-       "Int String|15.924 ± 0.186|**14.782 ± 0.106**\n",
-       "Large Int String|**39.803 ± 1.467**|43.776 ± 1.139\n",
-       "Small Float String|16.145 ± 0.516|**14.774 ± 0.249**\n",
-       "Float String|41.140 ± 0.714|**16.260 ± 0.199**\n",
-       "Large Float String|**72.156 ± 1.293**|75.244 ± 1.796\n",
-       "Int|**8.389 ± 0.173**|10.670 ± 0.074\n",
-       "Float|**7.702 ± 0.166**|9.634 ± 0.064"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "timer = Timer('Timing comparison of `float` functions')\n",
-    "timer.add_function('float', 'builtin')\n",
-    "timer.add_function('float', 'fastnumbers', 'from fastnumbers import float')\n",
-    "timer.time_functions(repeat=100)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Error-Handling Conversion Functions Timing Results\n",
-    "The following timing tests compare the performance of the `fastnumbers` functions that convert input to numeric types while doing error handling with common equivalent pure-Python implementations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `int` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|146.400 ± 7.402|39.931 ± 0.154|**21.698 ± 0.316**\n",
-       "Small Int String|26.531 ± 0.682|61.320 ± 0.546|**13.975 ± 0.012**\n",
-       "Int String|27.011 ± 0.105|66.103 ± 0.073|**16.099 ± 0.083**\n",
-       "Large Int String|34.512 ± 0.292|103.080 ± 0.694|**29.078 ± 0.285**\n",
-       "Small Float String|130.215 ± 1.605|43.022 ± 0.040|**13.717 ± 0.007**\n",
-       "Float String|141.935 ± 3.640|51.606 ± 0.093|**14.497 ± 0.049**\n",
-       "Large Float String|143.260 ± 0.532|50.034 ± 0.045|**14.284 ± 0.019**\n",
-       "Int|18.591 ± 0.018|86.049 ± 1.895|**11.285 ± 0.129**\n",
-       "Float|34.326 ± 0.040|101.555 ± 1.727|**25.890 ± 0.135**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def int_re(x, int_match=re.compile(r'[-+]?\\d+$').match):\n",
-    "    \"\"\"Function to simulate fast_int but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return int(x)\n",
-    "\n",
-    "def int_try(x):\n",
-    "    \"\"\"Function to simulate fast_int but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return int(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of `int` functions with error handling')\n",
-    "timer.add_function('int_try', 'try/except', 'from __main__ import int_try')\n",
-    "timer.add_function('int_re', 'regex', 'from __main__ import int_re')\n",
-    "timer.add_function('fast_int', 'fastnumbers', 'from fastnumbers import fast_int')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|80.172 ± 5.990|40.084 ± 0.025|**21.130 ± 0.003**\n",
-       "Small Int String|24.566 ± 0.006|72.200 ± 3.940|**16.177 ± 0.085**\n",
-       "Int String|26.997 ± 0.235|74.031 ± 3.074|**15.708 ± 0.005**\n",
-       "Large Int String|48.710 ± 0.463|118.449 ± 0.096|**43.990 ± 0.214**\n",
-       "Small Float String|25.602 ± 0.304|69.010 ± 0.282|**15.844 ± 0.029**\n",
-       "Float String|50.641 ± 0.807|114.521 ± 0.306|**17.226 ± 0.024**\n",
-       "Large Float String|80.664 ± 0.026|156.879 ± 3.616|**75.021 ± 0.164**\n",
-       "Int|16.832 ± 0.005|82.519 ± 0.033|**11.189 ± 0.015**\n",
-       "Float|15.815 ± 0.010|82.213 ± 1.139|**10.316 ± 0.115**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def float_re(x, float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_float but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if float_match(x):\n",
-    "            return float(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return float(x)\n",
-    "\n",
-    "def float_try(x):\n",
-    "    \"\"\"Function to simulate fast_float but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return float(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of `float` functions with error handling')\n",
-    "timer.add_function('float_try', 'try/except', 'from __main__ import float_try')\n",
-    "timer.add_function('float_re', 'regex', 'from __main__ import float_re')\n",
-    "timer.add_function('fast_float', 'fastnumbers', 'from fastnumbers import fast_float')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|82.803 ± 2.037|75.379 ± 2.195|**22.294 ± 0.140**\n",
-       "Small Int String|42.518 ± 0.189|60.290 ± 0.381|**14.623 ± 0.008**\n",
-       "Int String|45.155 ± 0.123|67.623 ± 1.621|**17.427 ± 0.030**\n",
-       "Large Int String|85.460 ± 1.146|97.309 ± 0.408|**30.452 ± 0.023**\n",
-       "Small Float String|42.940 ± 0.013|106.552 ± 1.611|**18.466 ± 0.109**\n",
-       "Float String|91.277 ± 0.144|161.596 ± 1.752|**30.662 ± 0.039**\n",
-       "Large Float String|165.773 ± 3.157|199.720 ± 4.092|**110.978 ± 0.276**\n",
-       "Int|37.884 ± 0.482|94.962 ± 1.168|**10.560 ± 0.024**\n",
-       "Float|66.981 ± 0.280|87.820 ± 0.338|**45.576 ± 0.023**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def real_re(x,\n",
-    "            int_match=re.compile(r'[-+]?\\d+$').match,\n",
-    "            real_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_real but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        elif real_match(x):\n",
-    "            return float(x)\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        if type(x) in (float, int):\n",
-    "            return x\n",
-    "        else:\n",
-    "            raise TypeError\n",
-    "\n",
-    "def real_try(x):\n",
-    "    \"\"\"Function to simulate fast_real but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        a = float(x)\n",
-    "    except ValueError:\n",
-    "        return x\n",
-    "    else:\n",
-    "        b = int(a)\n",
-    "        return b if a == b else b\n",
-    "\n",
-    "timer = Timer('Timing comparison of `float` (but coerce to `int` if possible) functions with error handling')\n",
-    "timer.add_function('real_try', 'try/except', 'from __main__ import real_try')\n",
-    "timer.add_function('real_re', 'regex', 'from __main__ import real_re')\n",
-    "timer.add_function('fast_real', 'fastnumbers', 'from fastnumbers import fast_real')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison of forced `int` functions with error handling"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|225.559 ± 8.299|71.459 ± 0.240|**22.172 ± 0.009**\n",
-       "Small Int String|25.769 ± 0.111|58.116 ± 0.593|**14.587 ± 0.004**\n",
-       "Int String|26.941 ± 0.204|65.053 ± 0.844|**17.394 ± 0.097**\n",
-       "Large Int String|34.931 ± 0.012|170.357 ± 2.402|**30.658 ± 0.036**\n",
-       "Small Float String|164.257 ± 4.999|114.764 ± 2.557|**20.625 ± 0.148**\n",
-       "Float String|207.379 ± 2.101|182.404 ± 5.072|**30.808 ± 0.022**\n",
-       "Large Float String|266.086 ± 7.579|237.553 ± 3.553|**112.624 ± 1.795**\n",
-       "Int|18.725 ± 0.074|87.270 ± 1.511|**10.042 ± 0.013**\n",
-       "Float|33.056 ± 0.202|98.963 ± 0.103|**25.322 ± 0.008**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def forceint_re(x,\n",
-    "                int_match=re.compile(r'[-+]\\d+$').match,\n",
-    "                float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate fast_forceint but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return int(x)\n",
-    "        elif float_match(x):\n",
-    "            return int(float(x))\n",
-    "        else:\n",
-    "            return x\n",
-    "    except TypeError:\n",
-    "        return int(x)\n",
-    "\n",
-    "def forceint_try(x):\n",
-    "    \"\"\"Function to simulate fast_forceint but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        return int(x)\n",
-    "    except ValueError:\n",
-    "        try:\n",
-    "            return int(float(x))\n",
-    "        except ValueError:\n",
-    "            return x\n",
-    "\n",
-    "timer = Timer('Timing comparison of forced `int` functions with error handling')\n",
-    "timer.add_function('forceint_try', 'try/except', 'from __main__ import forceint_try')\n",
-    "timer.add_function('forceint_re', 'regex', 'from __main__ import forceint_re')\n",
-    "timer.add_function('fast_forceint', 'fastnumbers', 'from fastnumbers import fast_forceint')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
-   "source": [
-    "## Checking Functions Timing Results\n",
-    "The following timing tests compare the performance of the `fastnumbers` functions that check if an input *could* be converted to numeric type with common equivalent pure-Python implementations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|139.979 ± 1.782|63.361 ± 0.278|**21.334 ± 0.181**\n",
-       "Small Int String|37.410 ± 1.392|64.609 ± 0.761|**13.047 ± 0.005**\n",
-       "Int String|37.839 ± 0.348|68.377 ± 0.413|**13.287 ± 0.004**\n",
-       "Large Int String|46.521 ± 0.527|95.243 ± 0.757|**14.921 ± 0.297**\n",
-       "Small Float String|129.535 ± 1.040|66.287 ± 0.335|**13.159 ± 0.031**\n",
-       "Float String|141.850 ± 3.183|75.430 ± 1.136|**13.407 ± 0.002**\n",
-       "Large Float String|142.889 ± 0.751|74.267 ± 0.679|**13.497 ± 0.096**\n",
-       "Int|29.627 ± 0.118|28.415 ± 0.120|**9.861 ± 0.144**\n",
-       "Float|44.634 ± 0.444|26.469 ± 0.410|**9.737 ± 0.025**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isint_re(x, int_match=re.compile(r'[-+]?\\d+$').match):\n",
-    "    \"\"\"Function to simulate isint but with regular expressions.\"\"\"\n",
-    "    t = type(x)\n",
-    "    return t == int if t in (float, int) else bool(int_match(x))\n",
-    "\n",
-    "def isint_try(x):\n",
-    "    \"\"\"Function to simulate isint but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        int(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return type(x) != float\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `int`')\n",
-    "timer.add_function('isint_try', 'try/except', 'from __main__ import isint_try')\n",
-    "timer.add_function('isint_re', 'regex', 'from __main__ import isint_re')\n",
-    "timer.add_function('isint', 'fastnumbers', 'from fastnumbers import isint')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `float`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|79.375 ± 3.525|68.012 ± 0.583|**21.351 ± 0.014**\n",
-       "Small Int String|35.220 ± 0.029|79.661 ± 1.600|**13.486 ± 0.103**\n",
-       "Int String|37.227 ± 0.316|82.679 ± 2.462|**13.614 ± 0.505**\n",
-       "Large Int String|60.360 ± 0.199|104.238 ± 0.372|**14.856 ± 0.043**\n",
-       "Small Float String|36.180 ± 0.723|79.475 ± 0.744|**13.782 ± 0.553**\n",
-       "Float String|63.161 ± 1.109|97.006 ± 0.725|**14.035 ± 0.004**\n",
-       "Large Float String|92.725 ± 0.280|105.473 ± 2.179|**14.734 ± 0.261**\n",
-       "Int|27.912 ± 0.160|28.377 ± 0.365|**9.793 ± 0.073**\n",
-       "Float|26.382 ± 0.018|25.945 ± 0.534|**9.370 ± 0.051**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isfloat_re(x, float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isfloat but with regular expressions.\"\"\"\n",
-    "    t = type(x)\n",
-    "    return t == float if t in (float, int) else bool(float_match(x))\n",
-    "\n",
-    "def isfloat_try(x):\n",
-    "    \"\"\"Function to simulate isfloat but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        float(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return type(x) != int\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `float`')\n",
-    "timer.add_function('isfloat_try', 'try/except', 'from __main__ import isfloat_try')\n",
-    "timer.add_function('isfloat_re', 'regex', 'from __main__ import isfloat_re')\n",
-    "timer.add_function('isfloat', 'fastnumbers', 'from fastnumbers import isfloat')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be converted to `float` or `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|79.205 ± 4.791|65.407 ± 0.066|**21.527 ± 0.007**\n",
-       "Small Int String|25.638 ± 0.507|87.775 ± 10.495|**14.242 ± 0.066**\n",
-       "Int String|26.071 ± 0.413|78.936 ± 0.614|**13.376 ± 0.018**\n",
-       "Large Int String|48.917 ± 0.022|101.990 ± 0.193|**14.852 ± 0.174**\n",
-       "Small Float String|26.126 ± 0.436|78.288 ± 1.177|**14.137 ± 0.123**\n",
-       "Float String|51.264 ± 1.266|94.813 ± 0.376|**14.017 ± 0.006**\n",
-       "Large Float String|80.919 ± 0.046|102.607 ± 2.370|**15.127 ± 0.160**\n",
-       "Int|18.494 ± 0.302|25.281 ± 0.374|**9.721 ± 0.168**\n",
-       "Float|15.959 ± 0.033|21.943 ± 0.018|**9.362 ± 0.007**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isreal_re(x, real_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isreal but with regular expressions.\"\"\"\n",
-    "    return type(x) in (float, int) or bool(real_match(x))\n",
-    "\n",
-    "def isreal_try(x):\n",
-    "    \"\"\"Function to simulate isreal but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        float(x)\n",
-    "    except ValueError:\n",
-    "        return False\n",
-    "    else:\n",
-    "        return True\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be converted to `float` or `int`')\n",
-    "timer.add_function('isreal_try', 'try/except', 'from __main__ import isreal_try')\n",
-    "timer.add_function('isreal_re', 'regex', 'from __main__ import isreal_re')\n",
-    "timer.add_function('isreal', 'fastnumbers', 'from fastnumbers import isreal')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "### Timing comparison to check if value can be coerced losslessly to `int`"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "Input type|try/except (ms)|regex (ms)|fastnumbers (ms)\n",
-       "---|---:|---:|---:\n",
-       "Non-number String|210.808 ± 6.231|76.480 ± 1.204|**21.170 ± 0.109**\n",
-       "Small Int String|48.875 ± 0.572|41.911 ± 0.066|**12.427 ± 0.014**\n",
-       "Int String|50.218 ± 0.468|45.611 ± 0.064|**12.702 ± 0.014**\n",
-       "Large Int String|90.622 ± 0.070|70.319 ± 0.697|**14.228 ± 0.094**\n",
-       "Small Float String|173.815 ± 9.556|121.739 ± 7.846|**13.385 ± 0.489**\n",
-       "Float String|217.171 ± 4.553|180.605 ± 10.143|**14.302 ± 1.108**\n",
-       "Large Float String|253.053 ± 18.106|211.222 ± 9.037|**15.430 ± 0.105**\n",
-       "Int|35.585 ± 0.536|87.717 ± 1.716|**9.211 ± 0.033**\n",
-       "Float|66.754 ± 0.259|124.244 ± 0.894|**30.690 ± 0.133**"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def isintlike_re(x,\n",
-    "                 int_match=re.compile(r'[-+]?\\d+$').match,\n",
-    "                 float_match=re.compile(r'[-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?$').match):\n",
-    "    \"\"\"Function to simulate isintlike but with regular expressions.\"\"\"\n",
-    "    try:\n",
-    "        if int_match(x):\n",
-    "            return True\n",
-    "        elif float_match(x):\n",
-    "            return float(x).is_integer()\n",
-    "        else:\n",
-    "            return False\n",
-    "    except TypeError:\n",
-    "        return int(x) == x\n",
-    "\n",
-    "def isintlike_try(x):\n",
-    "    \"\"\"Function to simulate isintlike but with try/except.\"\"\"\n",
-    "    try:\n",
-    "        a = int(x)\n",
-    "    except ValueError:\n",
-    "        try:\n",
-    "            a = float(x)\n",
-    "        except ValueError:\n",
-    "            return False\n",
-    "        else:\n",
-    "            return a.is_integer()\n",
-    "    else:\n",
-    "        return a == float(x)\n",
-    "\n",
-    "timer = Timer('Timing comparison to check if value can be coerced losslessly to `int`')\n",
-    "timer.add_function('isintlike_try', 'try/except', 'from __main__ import isintlike_try')\n",
-    "timer.add_function('isintlike_re', 'regex', 'from __main__ import isintlike_re')\n",
-    "timer.add_function('isintlike', 'fastnumbers', 'from fastnumbers import isintlike')\n",
-    "timer.time_functions()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/docs/source/timing.rst b/docs/source/timing.rst
index 9373d4a0..911c911b 100644
--- a/docs/source/timing.rst
+++ b/docs/source/timing.rst
@@ -10,9 +10,4 @@ Timing
     :local:
 
 Just how much faster is ``fastnumbers`` than a pure python implementation?
-Please see the following Jupyter notebooks for timing information on various
-Python versions.
-
-    - https://nbviewer.jupyter.org/github/SethMMorton/fastnumbers/blob/master/TIMING_35.ipynb
-    - https://nbviewer.jupyter.org/github/SethMMorton/fastnumbers/blob/master/TIMING_36.ipynb
-    - https://nbviewer.jupyter.org/github/SethMMorton/fastnumbers/blob/master/TIMING_37.ipynb
+Please look https://github.com/SethMMorton/fastnumbers/tree/main/profiling.
diff --git a/include/fastnumbers/argparse.hpp b/include/fastnumbers/argparse.hpp
new file mode 100644
index 00000000..db7cbb4a
--- /dev/null
+++ b/include/fastnumbers/argparse.hpp
@@ -0,0 +1,95 @@
+#pragma once
+
+// Based on:
+// https://github.com/numpy/numpy/blob/2ce11750cbdba4d81fa8b3b8856c5b40aee75d45/numpy/core/src/common/npy_argparse.h
+// but edited to fastnumbers needs.
+
+#include <Python.h>
+
+/*
+ * This file defines macros to help with keyword argument parsing.
+ * This solves two issues as of now:
+ *   1. Pythons C-API PyArg_* keyword argument parsers are slow, due to
+ *      not caching the strings they use.
+ *   2. It allows the use of METH_ARGPARSE (and `tp_vectorcall`)
+ *      when available in Python, which removes a large chunk of overhead.
+ *
+ * Internally CPython achieves similar things by using a code generator
+ * argument clinic.
+ */
+
+#define FN_MAX_KWARGS 15
+
+typedef struct {
+    int npositional;
+    int nargs;
+    int npositional_only;
+    int nrequired;
+    /* Null terminated list of keyword argument name strings */
+    PyObject* kw_strings[FN_MAX_KWARGS + 1];
+} _FNArgParserCache;
+
+/*
+ * The sole purpose of this macro is to hide the argument parsing cache.
+ * Since this cache must be static, this also removes a source of error.
+ */
+#define FN_PREPARE_ARGPARSER static _FNArgParserCache __argparse_cache = { -1 }
+
+/**
+ * Macro to help with argument parsing.
+ *
+ * The pattern for using this macro is by defining the method as:
+ *
+ * @code
+ * static PyObject *
+ * my_method(PyObject *self,
+ *           PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
+ * {
+ *     FN_PREPARE_ARGPARSER;
+ *
+ *     PyObject *argument1, *argument3;
+ *     bool argument2 = false;
+ *     if (fn_parse_arguments("method", args, len_args, kwnames,
+ *                "argument1", false, &argument1,
+ *                "|argument2", true, &argument2,
+ *                "$argument3", false, &argument3,
+ *                nullptr, false, nullptr) < 0) {
+ *          return nullptr;
+ *      }
+ * }
+ * @endcode
+ *
+ * The `FN_PREPARE_ARGPARSER` macro sets up a static cache variable necessary
+ * to hold data for speeding up the parsing. `fn_parse_arguments` must be
+ * used in cunjunction with the macro defined in the same scope.
+ * (No two `fn_parse_arguments` may share a single `FN_PREPARE_ARGPARSER`.)
+ *
+ * '|' means an optional parameter, and '$' is keyword-only.
+ *
+ * @param funcname
+ * @param args Python passed args (METH_FASTCALL)
+ * @param len_args Number of arguments (not flagged)
+ * @param kwnames Tuple as passed by METH_FASTCALL or nullptr.
+ * @param ... List of arguments must be param1_name, param2_converter,
+ *            *param1_outvalue, param2_name, ..., nullptr, nullptr, nullptr.
+ *            Where name is ``char *``, is a ``bool`` indicating if the return
+ *            is a boolean or not, and ``outvalue`` is the
+ *            ``PyObject *`` or ``bool` borrowed reference.
+ *
+ * @return Returns 0 on success and -1 on failure.
+ */
+int _fn_parse_arguments(
+    const char* funcname,
+    /* cache_ptr is a nullptr initialized persistent storage for data */
+    _FNArgParserCache* cache_ptr,
+    PyObject* const* args,
+    Py_ssize_t len_args,
+    PyObject* kwnames,
+    /* va_list is nullptr, false, nullptr terminated: name, as_bool, value */
+    ...
+);
+
+#define fn_parse_arguments(funcname, args, len_args, kwnames, ...)                      \
+    _fn_parse_arguments(                                                                \
+        funcname, &__argparse_cache, args, len_args, kwnames, __VA_ARGS__               \
+    )
diff --git a/include/fastnumbers/buffer.hpp b/include/fastnumbers/buffer.hpp
index 1832f6b9..ca127a48 100644
--- a/include/fastnumbers/buffer.hpp
+++ b/include/fastnumbers/buffer.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "fastnumbers/c_str_parsing.hpp"
 #include <cstring>
 #include <limits>
 
@@ -64,7 +65,12 @@ class Buffer {
 
     /// Remove underscores that are syntactically valid in a number,
     /// possibly accounting for non-base-10 integers
-    void remove_valid_underscores(const bool based);
+    void remove_valid_underscores(const bool based)
+    {
+        const char* new_end = end();
+        ::remove_valid_underscores(start(), new_end, based);
+        m_len = static_cast<std::size_t>(new_end - start());
+    }
 
     /// The largest amount of data the buffer can contain
     std::size_t max_size() const { return std::numeric_limits<std::size_t>::max(); }
diff --git a/include/fastnumbers/c_str_parsing.hpp b/include/fastnumbers/c_str_parsing.hpp
index c16ed899..72dac95e 100644
--- a/include/fastnumbers/c_str_parsing.hpp
+++ b/include/fastnumbers/c_str_parsing.hpp
@@ -1,22 +1,52 @@
 #pragma once
 
+#include "fastnumbers/third_party/fast_float.h"
 #include <cctype>
+#include <cstdint>
 #include <cstring>
-#include <limits>
 
-/// Largest allowed value for an ASCII character
-constexpr std::size_t ASCII_MAX = 127;
+/// Table of what characters are classified as whitespace
+constexpr bool WHITESPACE_TABLE[]
+    = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+/// Table of what characters are classified as digits
+constexpr int DIGIT_TABLE[]
+    = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 
 /**
- * \brief Convert a string to a long type
+ * \brief Convert a string to a 64-bit int type
  *
  * Assumes no sign or whitespace. No overflow checking is performed.
  *
  * \param str The string to parse, assumed to be non-NULL
  * \param end The end of the string being checked
+ * \param base The base to assume when checking an integer, 0 is "guess".
  * \param error Flag to indicate if there was a parsing error
+ * \param overflow Flag to indicate if the string was long enough to overflow
  */
-long parse_int(const char* str, const char* end, bool& error);
+int64_t
+parse_int(const char* str, const char* end, int base, bool& error, bool& overflow);
 
 /**
  * \brief Convert a string to a double type
@@ -62,42 +92,94 @@ int string_contains_what(const char* str, const char* end, int base);
 void remove_valid_underscores(char* str, const char*& end, const bool based);
 
 /**
- * \brief Maximum number of digits we allow in an integer for conversion
- *
- * The number of digits in an int that fastnumbers is willing
- * to attempt to convert itself. This is entirely based on the size
- * of a this compiler's long, since the long is what Python uses to
- * represent an int under the hood - use one less than the maximum
- * length of a long.
- *
- * 64-bit int max == 9223372036854775807; len('9223372036854775807') - 1 == 18
- * 32-bit int max == 2147483647; len('2147483647') - 1 == 9
+ * \brief Lowercase a character - does no error checking
  */
-constexpr long FN_MAX_INT_LEN
-    = std::numeric_limits<unsigned long>::max() == 9223372036854775807 ? 18 : 9;
+constexpr inline char lowercase(const char c)
+{
+    // The ASCII standard was quite clever... upper- and lower-case
+    // letters only differ from each other by the 32 bit, otherwise
+    // they are identical. ORing the 32-bit forces lowercase.
+    return static_cast<char>(c | 32);
+}
 
 /**
  * \brief Determine if a character is whitespace
  */
-inline bool is_whitespace(const char c)
+constexpr inline bool is_whitespace(const char c)
 {
-    const unsigned char cu = static_cast<unsigned char>(c);
-    return ::isspace(cu) && cu < ASCII_MAX;
+    // Using a table was determined through performance testing to be
+    // many times faster than std::isspace, and twice as fast as using
+    // a switch statement.
+    return WHITESPACE_TABLE[static_cast<uint8_t>(c)];
+}
+
+/**
+ * \brief Advance a string's pointer while whitespace is found
+ */
+constexpr inline void consume_whitespace(const char*& str, const char* end)
+{
+    while (str != end && is_whitespace(*str)) {
+        str += 1;
+    }
+}
+
+/**
+ * \brief Convert a character to a digit, returns -1 on failure.
+ */
+template <typename T>
+constexpr inline T to_digit(const char c)
+{
+    // Using a table was determined through performance testing to be
+    // three times faster than c - '0' or a switch statement.
+    return static_cast<T>(DIGIT_TABLE[static_cast<uint8_t>(c)]);
 }
 
 /**
  * \brief Determine if a character represents a digit
  */
-inline bool is_valid_digit(const char c)
+constexpr inline bool is_valid_digit(const char c)
 {
-    const unsigned char cu = static_cast<unsigned char>(c);
-    return ::isdigit(cu) && cu < ASCII_MAX;
+    // Using a table was determined through performance testing to be
+    // faster than std::isdigit or a switch statement.
+    return to_digit<int>(c) >= 0;
+}
+
+/**
+ * \brief Advance a string's pointer while digits are found
+ */
+constexpr inline void consume_digits(const char*& str, const char* end)
+{
+    while (str != end && is_valid_digit(*str)) {
+        str += 1;
+    }
+}
+
+/**
+ * \brief Advance a string's pointer while digits are found
+ *        and attempt to read multiple digits at a time if possible
+ */
+inline void consume_digits(const char*& str, const std::size_t len)
+{
+    // Attempt to read eight characters at a time to determine
+    // if they are digits. Loop over the character array in steps
+    // of eight. Stop processing if not all eight characters are digits.
+    const std::size_t number_of_eights = len / 8;
+    for (std::size_t i = 0; i < number_of_eights; ++i) {
+        if (fast_float::is_made_of_eight_digits_fast(str)) {
+            str += 8;
+        } else {
+            break;
+        }
+    }
+
+    // Read the remainder of digits one-at-a-time.
+    consume_digits(str, str + len);
 }
 
 /**
  * \brief Determine if a character is '-' or '+'
  */
-inline bool is_sign(const char c)
+constexpr inline bool is_sign(const char c)
 {
     return c == '-' || c == '+';
 }
@@ -105,19 +187,25 @@ inline bool is_sign(const char c)
 /**
  * \brief Determine if a character a prefix for base 2, 8, or 16
  */
-inline bool is_base_prefix(const char c)
+constexpr inline bool is_base_prefix(const char c)
 {
-    return c == 'x' || c == 'X' || c == 'o' || c == 'O' || c == 'b' || c == 'B';
+    // The ASCII standard was quite clever... upper- and lower-case
+    // letters only differ from each other by the 32 bit, otherwise
+    // they are identical.
+    // So, we can OR the 32 bit to force the character to be
+    // lowercase and then just check against the lowercase characters.
+    const char lowered = lowercase(c);
+    return (lowered == 'x') || (lowered == 'o') || (lowered == 'b');
 }
 
 /**
  * \brief Determine if a character a prefix for a specific base 2, 8, or 16
  */
-inline bool is_base_prefix(const char c, const int base)
+constexpr inline bool is_base_prefix(const char c, const int base)
 {
-    return (base == 16 && (c == 'x' || c == 'X'))
-        || (base == 8 && (c == 'o' || c == 'O'))
-        || (base == 2 && (c == 'b' || c == 'B'));
+    const char lowered = lowercase(c);
+    return (base == 16 && (lowered == 'x')) || (base == 8 && (lowered == 'o'))
+        || (base == 2 && (lowered == 'b'));
 }
 
 /**
@@ -129,17 +217,31 @@ inline bool is_base_prefix(const char c, const int base)
  * \param str The string to check, assumed to be non-NULL
  * \param len The length of the string
  */
-inline bool quick_detect_infinity(const char* str, const std::size_t len)
+constexpr inline bool quick_detect_infinity(const char* str, const std::size_t len)
 {
+    // The ASCII standard was quite clever... upper- and lower-case
+    // letters only differ from each other by the 32 bit, otherwise
+    // they are identical. So, we can use the XOR operator against
+    // lowercase "inf" and accumulate the results - if all bits are
+    // zero or if only the 32 bit is one that means that the string
+    // contained a case-insensitive INF.
     switch (len) {
-    case 3:
-        return (str[0] == 'i' || str[0] == 'I') && (str[1] == 'n' || str[1] == 'N')
-            && (str[2] == 'f' || str[2] == 'F');
-    case 8:
-        return (str[0] == 'i' || str[0] == 'I') && (str[1] == 'n' || str[1] == 'N')
-            && (str[2] == 'f' || str[2] == 'F') && (str[3] == 'i' || str[3] == 'I')
-            && (str[4] == 'n' || str[4] == 'N') && (str[5] == 'i' || str[5] == 'I')
-            && (str[6] == 't' || str[6] == 'T') && (str[7] == 'y' || str[7] == 'Y');
+    case 3: {
+        const uint8_t accumulator = (str[0] ^ 'i') | (str[1] ^ 'n') | (str[2] ^ 'f');
+        return accumulator == 0 || accumulator == 32;
+    }
+    case 8: {
+        uint8_t accumulator = 0;
+        accumulator |= (str[0] ^ 'i');
+        accumulator |= (str[1] ^ 'n');
+        accumulator |= (str[2] ^ 'f');
+        accumulator |= (str[3] ^ 'i');
+        accumulator |= (str[4] ^ 'n');
+        accumulator |= (str[5] ^ 'i');
+        accumulator |= (str[6] ^ 't');
+        accumulator |= (str[7] ^ 'y');
+        return accumulator == 0 || accumulator == 32;
+    }
     default:
         return false;
     }
@@ -154,10 +256,19 @@ inline bool quick_detect_infinity(const char* str, const std::size_t len)
  * \param str The string to check, assumed to be non-NULL
  * \param len The length of the string
  */
-inline bool quick_detect_nan(const char* str, const std::size_t len)
+constexpr inline bool quick_detect_nan(const char* str, const std::size_t len)
 {
-    return len == 3 && (str[0] == 'n' || str[0] == 'N')
-        && (str[1] == 'a' || str[1] == 'A') && (str[2] == 'n' || str[2] == 'N');
+    if (len != 3) {
+        return false;
+    }
+    // The ASCII standard was quite clever... upper- and lower-case
+    // letters only differ from each other by the 32 bit, otherwise
+    // they are identical. So, we can use the XOR operator against
+    // lowercase "nan" and accumulate the results - if all bits are
+    // zero or if only the 32 bit is one that means that the string
+    // contained a case-insensitive NaN.
+    const uint8_t accumulator = (str[0] ^ 'n') | (str[1] ^ 'a') | (str[2] ^ 'n');
+    return accumulator == 0 || accumulator == 32;
 }
 
 /**
@@ -169,83 +280,7 @@ inline bool quick_detect_nan(const char* str, const std::size_t len)
  * \param str The string to check, assumed to be non-NULL
  * \param len The length of the string
  */
-inline bool is_likely_int(const char* str, std::size_t len)
+constexpr inline bool is_likely_int(const char* str, std::size_t len)
 {
     return len > 0 && is_valid_digit(*str);
 }
-
-/**
- * \brief Detect if a string probably contains a float
- *
- * This is not a 100% assurance, but it is a gross check that
- * makes sure the string starts with a digit or '.' followed
- * by a digit..
- *
- * \param str The string to check, assumed to be non-NULL
- * \param len The length of the string
- */
-inline bool is_likely_float(const char* str, std::size_t len)
-{
-    return len > 0
-        && (is_valid_digit(*str)
-            || (*str == '.' && len > 1 && is_valid_digit(*(str + 1))));
-}
-
-// Define the number of digits in a float that fastnumbers is willing
-// to attempt to convert itself. For Clang and GNUC, it is known
-// that DBL_DIG - 4 works. It is known that DBL_DIG - 6 works for MSVC.
-// To be safe, any compiler not known during fastnumbers testing will
-// use DBL_DIG - 6.
-// Also define the largest and smallest exponent that
-// fastnumbers is willing attempt to convert itself. For Clang and GNUC,
-// it is known that larger numbers work than MSVC.
-// To be safe, any compiler not known during fastnumbers testing will
-// use the smaller numbers.
-#if defined(__clang__) || defined(__GNUC__)
-
-/// Number of float digits fastnumbers will convert itself
-constexpr long FN_DBL_DIG = std::numeric_limits<double>::digits10 - 4;
-
-/// Most positive exponent fastumbers will convert itself
-constexpr long FN_MAX_EXP = 99;
-
-/// Most negative exponent fastumbers will convert itself
-constexpr long FN_MIN_EXP = -98;
-
-/// Allow the preprocessor to be able to dispatch on this decision
-#define FASTNUMBERS_WIDE_EXP_RANGE
-
-#else
-
-/// Number of float digits fastnumbers will convert itself
-constexpr long FN_DBL_DIG = std::numeric_limits<double>::digits10 - 6;
-
-/// Most positive exponent fastumbers will convert itself
-constexpr long FN_MAX_EXP = 19;
-
-/// Most negative exponent fastumbers will convert itself
-constexpr long FN_MIN_EXP = -19;
-
-/// Allow the preprocessor to be able to dispatch on this decision
-#undef FASTNUMBERS_WIDE_EXP_RANGE
-
-#endif
-
-/**
- * \brief Guess if an int will overflow.
- *
- * \param start The string to check, assumed to be non-NULL
- * \param len The length of the string
- */
-inline bool int_might_overflow(const char*, const std::size_t len)
-{
-    return len > FN_MAX_INT_LEN;
-}
-
-/**
- * \brief Guess if a float will overflow.
- *
- * \param start The string to check, assumed to be non-NULL
- * \param len The length of the string
- */
-bool float_might_overflow(const char* start, const std::size_t len);
diff --git a/include/fastnumbers/evaluator.hpp b/include/fastnumbers/evaluator.hpp
index 3e4ce135..a7084248 100644
--- a/include/fastnumbers/evaluator.hpp
+++ b/include/fastnumbers/evaluator.hpp
@@ -94,8 +94,7 @@ class Evaluator {
     Payload from_numeric_as_type(const UserType ntype)
     {
         const NumberFlags typeflags = m_parser.get_number_type();
-        const NumberFlags nan_or_inf = NumberType::Infinity | NumberType::NaN;
-        const NumberFlags is_intlike = NumberType::Integer | NumberType::IntLike;
+        constexpr NumberFlags nan_or_inf = NumberType::Infinity | NumberType::NaN;
 
         // If not a numeric type it is a type error
         if (typeflags & NumberType::INVALID) {
@@ -106,10 +105,10 @@ class Evaluator {
         // on the user requested type
         switch (ntype) {
         case UserType::REAL:
-            if (options().allow_coerce() && (typeflags & is_intlike)) {
-                return Payload(m_parser.as_pyint());
-            } else if (typeflags & nan_or_inf) {
+            if (typeflags & nan_or_inf) {
                 return Payload(handle_nan_and_inf());
+            } else if (options().allow_coerce()) {
+                return Payload(m_parser.as_pyfloat(false, true));
             } else if (typeflags & NumberType::User) {
                 if (typeflags & NumberType::Float) {
                     return Payload(m_parser.as_pyfloat());
@@ -165,62 +164,49 @@ class Evaluator {
     /// Logic for evaluating a text python object as a float or integer
     Payload from_text_as_int_or_float(const bool force_int)
     {
-        const NumberFlags typeflags = m_parser.get_number_type();
-        const NumberFlags nan_or_inf = NumberType::Infinity | NumberType::NaN;
-
         // Integers are returned as-is
         // NaN and infinity are illegal with force_int
         // Otherwise, grab as a float and convert to int if required
-        if (typeflags & NumberType::Integer) {
+        if (m_parser.peek_try_as_int()) {
             return from_text_as_int();
 
-        } else if (force_int && (typeflags & nan_or_inf)) {
+        } else if (force_int && (m_parser.peek_inf() || m_parser.peek_nan())) {
             return Payload(ActionType::ERROR_INVALID_INT);
 
         } else {
-            Payload payload = from_text_as_float();
-
-            // If the returned value is a double or a python float, annotate
-            // whether it should be an integer and then return.
-            const bool is_python = payload.get_action() == ActionType::PY_OBJECT
-                && payload.to_pyobject() != nullptr;
-            if (is_python) {
-                const double value = PyFloat_AS_DOUBLE(payload.to_pyobject());
-                Py_DECREF(payload.to_pyobject());
-                return Payload(
-                    value,
-                    force_int
-                        || (options().allow_coerce() && Parser::float_is_intlike(value))
-                );
+            // Special-case handling of infinity and NaN
+            if (m_parser.peek_inf()) {
+                return Payload(inf_action(m_parser.is_negative()));
+            } else if (m_parser.peek_nan()) {
+                return Payload(nan_action(m_parser.is_negative()));
             }
 
-            // Otherwise return the payload as-is.
-            return payload;
+            // Otherwise, attempt to convert to a python float
+            // and optionally make as integer and if not signal an error.
+            PyObject* result = m_parser.as_pyfloat(force_int, options().allow_coerce());
+            if (m_parser.errored()) {
+                return Payload(ActionType::ERROR_INVALID_FLOAT);
+            }
+            return Payload(result);
         }
     }
 
     /// Logic for evaluating a text python object as a float
     Payload from_text_as_float()
     {
-        const NumberFlags typeflags = m_parser.get_number_type();
-
         // Special-case handling of infinity and NaN
-        if (typeflags & NumberType::Infinity) {
+        if (m_parser.peek_inf()) {
             return Payload(inf_action(m_parser.is_negative()));
-        } else if (typeflags & NumberType::NaN) {
+        } else if (m_parser.peek_nan()) {
             return Payload(nan_action(m_parser.is_negative()));
         }
 
-        // Otherwise, attempt to naively parse if possible, otherwise
-        // use the python conversion function
-        const double result = m_parser.as_float();
+        // Otherwise, attempt to convert to a python float
+        // and if not signal an error.
+        PyObject* result = m_parser.as_pyfloat();
         if (m_parser.errored()) {
-            return m_parser.potential_overflow()
-                ? to_pyfloat()
-                : Payload(ActionType::ERROR_INVALID_FLOAT);
+            return Payload(ActionType::ERROR_INVALID_FLOAT);
         }
-
-        // Successful naive conversion
         return Payload(result);
     }
 
@@ -234,19 +220,14 @@ class Evaluator {
             if (m_parser.illegal_explicit_base()) {
                 return Payload(ActionType::ERROR_ILLEGAL_EXPLICIT_BASE);
             }
-            return to_pyint();
         }
 
-        // Otherwise, attempt to naively parse if possible, otherwise
-        // use the python conversion function
-        const long result = m_parser.as_int();
+        // Otherwise, attempt to convert to a python int
+        // and if not signal an error.
+        PyObject* result = m_parser.as_pyint();
         if (m_parser.errored()) {
-            return m_parser.potential_overflow()
-                ? to_pyint()
-                : Payload(ActionType::ERROR_INVALID_INT);
+            return Payload(ActionType::ERROR_INVALID_INT);
         }
-
-        // Successful naive conversion
         return Payload(result);
     }
 
@@ -283,35 +264,9 @@ class Evaluator {
     /// Helper to properly respond to NaN and infinity
     ActionType handle_nan_and_inf()
     {
-        // Exctract the double from the parser, accounting for errors
-        const double value = m_parser.as_float();
-        if (m_parser.errored()) {
-            return ActionType::ERROR_BAD_TYPE_FLOAT;
-        }
-
         // Assume infinity or NaN.
         const NumberFlags typeflags = m_parser.get_number_type();
-        return typeflags & NumberType::NaN ? nan_action(value < 0.0)
-                                           : inf_action(value < 0.0);
-    }
-
-    /// Helper function to convert to Python float objects
-    Payload to_pyfloat()
-    {
-        PyObject* result = m_parser.as_pyfloat();
-        if (m_parser.errored()) {
-            return Payload(ActionType::ERROR_INVALID_FLOAT);
-        }
-        return Payload(result);
-    }
-
-    /// Helper function to convert to Python int objects
-    Payload to_pyint()
-    {
-        PyObject* result = m_parser.as_pyint();
-        if (m_parser.errored()) {
-            return Payload(ActionType::ERROR_INVALID_INT);
-        }
-        return Payload(result);
+        return typeflags & NumberType::NaN ? nan_action(m_parser.is_negative())
+                                           : inf_action(m_parser.is_negative());
     }
 };
diff --git a/include/fastnumbers/parser/base.hpp b/include/fastnumbers/parser/base.hpp
index b1eeadd1..5bdeda12 100644
--- a/include/fastnumbers/parser/base.hpp
+++ b/include/fastnumbers/parser/base.hpp
@@ -71,30 +71,40 @@ class Parser {
     }
 
     /// Is the stored number negative?
-    bool is_negative() const { return m_negative; }
+    virtual bool is_negative() const { return m_negative; }
 
     /// Access the user-given options for parsing
     const UserOptions& options() const { return m_options; }
 
-    /// Convert the stored object to a long (check error state)
-    /// Base implementation does nothing but throw a runtime error
-    virtual long as_int() = 0;
-
-    /// Convert the stored object to a double (check error state)
-    /// Base implementation does nothing but throw a runtime error
-    virtual double as_float() = 0;
-
     /// Convert the stored object to a python int (check error state)
-    /// Base implementation does nothing but throw a runtime error
     virtual PyObject* as_pyint() = 0;
 
     /// Convert the stored object to a python float (check error state)
-    /// Base implementation does nothing but throw a runtime error
     virtual PyObject* as_pyfloat() = 0;
 
+    /**
+     * \brief Convert the stored object to a python float but possible
+     *        coerce to an integer (check error state)
+     * \param force_int Force the output to integer (takes precidence)
+     * \param coerce Return as integer if the float is int-like
+     */
+    virtual PyObject* as_pyfloat(const bool force_int, const bool coerce) = 0;
+
     /// Check the type of the number.
     virtual NumberFlags get_number_type() const { return m_number_type; }
 
+    /// Check if the number is INF
+    virtual bool peek_inf() const { return false; }
+
+    /// Check if the number is NaN
+    virtual bool peek_nan() const { return false; }
+
+    /// Check if the should be parsed as an integer
+    virtual bool peek_try_as_int() const
+    {
+        return bool(get_number_type() & NumberType::Integer);
+    }
+
     /**
      * \brief Determine if a float is "intlike"
      *
diff --git a/include/fastnumbers/parser/character.hpp b/include/fastnumbers/parser/character.hpp
index bec6e6a2..69e3060f 100644
--- a/include/fastnumbers/parser/character.hpp
+++ b/include/fastnumbers/parser/character.hpp
@@ -7,6 +7,7 @@
 #include <Python.h>
 
 #include "fastnumbers/buffer.hpp"
+#include "fastnumbers/c_str_parsing.hpp"
 #include "fastnumbers/parser/base.hpp"
 #include "fastnumbers/user_options.hpp"
 
@@ -34,25 +35,46 @@ class CharacterParser final : public Parser {
     CharacterParser& operator=(const CharacterParser&) = default;
     ~CharacterParser() = default;
 
-    /// Convert the stored object to a long (check error state)
-    long as_int() override;
-
-    /// Convert the stored object to a double (check error state)
-    double as_float() override;
-
     /// Convert the stored object to a python int (check error state)
     PyObject* as_pyint() override;
 
     /// Convert the stored object to a python float (check error state)
     PyObject* as_pyfloat() override;
 
+    /**
+     * \brief Convert the stored object to a python float but possible
+     *        coerce to an integer (check error state)
+     * \param force_int Force the output to integer (takes precidence)
+     * \param coerce Return as integer if the float is int-like
+     */
+    PyObject* as_pyfloat(const bool force_int, const bool coerce) override;
+
     /// Check the type of the number.
     NumberFlags get_number_type() const override;
 
+    /// Check if the number is INF
+    bool peek_inf() const override { return quick_detect_infinity(m_start, m_str_len); }
+
+    /// Check if the number is NaN
+    bool peek_nan() const override { return quick_detect_nan(m_start, m_str_len); }
+
+    /// Check if the should be parsed as an integer
+    bool peek_try_as_int() const override
+    {
+        // Attempt to simply see if all the characters are digits.
+        // If so it is an integer.
+        const char* str = m_start;
+        consume_digits(str, m_str_len);
+        return str != m_start && str == (m_start + m_str_len);
+    }
+
 private:
     /// The potential start of the character array
     const char* m_start;
 
+    /// The original start of the character array
+    const char* m_start_orig;
+
     /// The original end of the character array
     const char* m_end_orig;
 
@@ -80,27 +102,8 @@ class CharacterParser final : public Parser {
         return m_start == nullptr ? nullptr : (m_start + m_str_len);
     }
 
-    /// Template for conversion to base types
-    template <
-        typename T,
-        typename CheckFunction,
-        typename OverflowCheckFunction,
-        typename ConvertFunction>
-    T as_type(
-        CheckFunction check_function,
-        OverflowCheckFunction overflow_check_function,
-        ConvertFunction convert_function
-    );
-
-    /// Template for checking that in input contains a type, accounting for underscores
-    template <typename Function>
-    bool check_string_for_number(
-        Buffer& buffer,
-        const char*& start,
-        const char*& new_end,
-        const std::size_t offset,
-        Function string_contains_number
-    );
+    /// The string as a double (check error state)
+    double as_double();
 
     /// Add FromStr to the return NumberFlags
     static constexpr NumberFlags flag_wrap(const NumberFlags val)
diff --git a/include/fastnumbers/parser/numeric.hpp b/include/fastnumbers/parser/numeric.hpp
index 040d98ea..6cd74739 100644
--- a/include/fastnumbers/parser/numeric.hpp
+++ b/include/fastnumbers/parser/numeric.hpp
@@ -12,6 +12,10 @@
  * \brief Parses numeric python objects
  */
 class NumericParser final : public Parser {
+public:
+    /// Cached instance of zero for use in identifying negative numbers
+    static PyObject* PYTHON_ZERO;
+
 public:
     /// Construct with a Python object
     explicit NumericParser(PyObject* obj, const UserOptions& options)
@@ -41,43 +45,19 @@ class NumericParser final : public Parser {
     /// Descructor decreases reference count of the stored object
     ~NumericParser() { Py_XDECREF(m_obj); };
 
-    /// Convert the stored object to a long (check error state)
-    long as_int() override
+    /// Is the stored number negative?
+    bool is_negative() const override
     {
-        reset_error();
-
-        if (get_number_type() & NumberType::Integer) {
-            int overflow = 0;
-            const long value = PyLong_AsLongAndOverflow(m_obj, &overflow);
-            if (overflow) {
-                encountered_potential_overflow_error();
-                return -1L;
-            } else if (value == -1 && PyErr_Occurred()) {
-                PyErr_Clear();
-            }
-            return value;
-        }
-        encountered_conversion_error();
-        return -1L;
-    }
-
-    /// Convert the stored object to a double (check error state)
-    double as_float() override
-    {
-        reset_error();
-
-        if (get_number_type() & (NumberType::Float | NumberType::User)) {
-            const double value = PyFloat_AsDouble(m_obj);
-            if (value == -1.0 && PyErr_Occurred()) {
-                PyErr_Clear();
-            } else {
-                return value;
-            }
-        } else if (get_number_type() & NumberType::Float) {
-            return get_double();
+        // For floats, compare in C++-land.
+        // For everything else use Python's logic.
+        const NumberFlags flags = get_number_type();
+        if (flags & NumberType::Float && !(flags & NumberType::User)) {
+            return get_double() < 0;
+        } else if (!(flags & NumberType::INVALID)) {
+            return PyObject_RichCompareBool(m_obj, PYTHON_ZERO, Py_LT);
+        } else {
+            return Parser::is_negative();
         }
-        encountered_conversion_error();
-        return -1.0;
     }
 
     /// Convert the stored object to a python int (check error state)
@@ -94,6 +74,28 @@ class NumericParser final : public Parser {
         return PyNumber_Float(m_obj);
     }
 
+    /**
+     * \brief Convert the stored object to a python float but possible
+     *        coerce to an integer (check error state)
+     * \param force_int Force the output to integer (takes precidence)
+     * \param coerce Return as integer if the float is int-like
+     */
+    PyObject* as_pyfloat(const bool force_int, const bool coerce) override
+    {
+        reset_error();
+        if (force_int) {
+            return PyNumber_Long(m_obj);
+        } else if (coerce) {
+            if (get_number_type() & (NumberType::IntLike | NumberType::Integer)) {
+                return PyNumber_Long(m_obj);
+            } else {
+                return PyNumber_Float(m_obj);
+            }
+        } else {
+            return PyNumber_Float(m_obj);
+        }
+    }
+
     /// Check the type of the number.
     NumberFlags get_number_type() const override
     {
@@ -136,6 +138,12 @@ class NumericParser final : public Parser {
         return NumberType::INVALID;
     }
 
+    /// Check if the should be parsed as an integer
+    bool peek_try_as_int() const override
+    {
+        return bool(get_number_type() & NumberType::Integer);
+    }
+
 private:
     /// The Python object potentially under analysis
     PyObject* m_obj;
diff --git a/include/fastnumbers/parser/unicode.hpp b/include/fastnumbers/parser/unicode.hpp
index 8ebd8e4f..42802c84 100644
--- a/include/fastnumbers/parser/unicode.hpp
+++ b/include/fastnumbers/parser/unicode.hpp
@@ -33,58 +33,66 @@ class UnicodeParser final : public Parser {
     UnicodeParser& operator=(const UnicodeParser&) = default;
     ~UnicodeParser() = default;
 
-    /// Convert the stored object to a long (check error state)
-    long as_int() override
+    /// Convert the stored object to a python int (check error state)
+    PyObject* as_pyint() override
     {
         reset_error();
-
         if (get_number_type() & NumberType::Integer) {
-            return sign() * m_digit;
+            return PyLong_FromLong(sign() * m_digit);
         }
         encountered_conversion_error();
-        return -1L;
+        return nullptr;
     }
 
-    /// Convert the stored object to a double (check error state)
-    double as_float() override
+    /// Convert the stored object to a python float (check error state)
+    PyObject* as_pyfloat() override
     {
         reset_error();
 
         const NumberFlags ntype = get_number_type();
 
         if (ntype & NumberType::Integer) {
-            return static_cast<double>(sign() * m_digit);
+            return PyFloat_FromDouble(static_cast<double>(sign() * m_digit));
         } else if (ntype & NumberType::Float) {
-            return sign() * m_numeric;
+            return PyFloat_FromDouble(sign() * m_numeric);
         }
-        encountered_conversion_error();
-        return -1.0;
-    }
-
-    /// Convert the stored object to a python int (check error state)
-    PyObject* as_pyint() override
-    {
-        reset_error();
 
-        const long value = as_int();
-        if (!errored()) {
-            return PyLong_FromLong(value);
-        }
         encountered_conversion_error();
         return nullptr;
     }
 
-    /// Convert the stored object to a python float (check error state)
-    PyObject* as_pyfloat() override
+    /**
+     * \brief Convert the stored object to a python float but possible
+     *        coerce to an integer (check error state)
+     * \param force_int Force the output to integer (takes precidence)
+     * \param coerce Return as integer if the float is int-like
+     */
+    PyObject* as_pyfloat(const bool force_int, const bool coerce) override
     {
         reset_error();
 
-        const double value = as_float();
-        if (!errored()) {
-            return PyFloat_FromDouble(value);
+        const NumberFlags ntype = get_number_type();
+
+        // Quit here if not a valid number
+        if (!(ntype & (NumberType::Integer | NumberType::Float))) {
+            encountered_conversion_error();
+            return nullptr;
+        }
+
+        if (force_int) {
+            return (ntype & NumberType::Integer) ? PyLong_FromLong(sign() * m_digit)
+                                                 : PyLong_FromDouble(sign() * m_numeric);
+        } else if (coerce) {
+            return (ntype & NumberType::Integer)
+                ? PyLong_FromLong(sign() * m_digit)
+                : ((ntype & NumberType::IntLike)
+                       ? PyLong_FromDouble(sign() * m_numeric)
+                       : PyFloat_FromDouble(sign() * m_numeric));
+        } else {
+            return (ntype & NumberType::Integer)
+                ? PyFloat_FromDouble(static_cast<double>(sign() * m_digit))
+                : PyFloat_FromDouble(sign() * m_numeric);
         }
-        encountered_conversion_error();
-        return nullptr;
     }
 
     /// Check the type of the number.
@@ -113,6 +121,12 @@ class UnicodeParser final : public Parser {
         return NumberType::INVALID;
     }
 
+    /// Check if the should be parsed as an integer
+    bool peek_try_as_int() const override
+    {
+        return bool(get_number_type() & NumberType::Integer);
+    }
+
 private:
     /// The potential numeric value of a unicode character
     double m_numeric;
diff --git a/include/fastnumbers/third_party/fast_float.h b/include/fastnumbers/third_party/fast_float.h
new file mode 100644
index 00000000..824cf969
--- /dev/null
+++ b/include/fastnumbers/third_party/fast_float.h
@@ -0,0 +1,3155 @@
+// fast_float by Daniel Lemire
+// fast_float by João Paulo Magalhaes
+//
+// with contributions from Eugene Golushkov
+// with contributions from Maksim Kita
+// with contributions from Marcin Wojdyr
+// with contributions from Neal Richardson
+// with contributions from Tim Paine
+// with contributions from Fabio Pellacini
+//
+// Licensed under the Apache License, Version 2.0, or the
+// MIT License at your option. This file may not be copied,
+// modified, or distributed except according to those terms.
+//
+// MIT License Notice
+//
+//    MIT License
+//    
+//    Copyright (c) 2021 The fast_float authors
+//    
+//    Permission is hereby granted, free of charge, to any
+//    person obtaining a copy of this software and associated
+//    documentation files (the "Software"), to deal in the
+//    Software without restriction, including without
+//    limitation the rights to use, copy, modify, merge,
+//    publish, distribute, sublicense, and/or sell copies of
+//    the Software, and to permit persons to whom the Software
+//    is furnished to do so, subject to the following
+//    conditions:
+//    
+//    The above copyright notice and this permission notice
+//    shall be included in all copies or substantial portions
+//    of the Software.
+//    
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+//    ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+//    TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+//    SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+//    IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+//    DEALINGS IN THE SOFTWARE.
+//
+// Apache License (Version 2.0) Notice
+//
+//    Copyright 2021 The fast_float authors
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//    
+//    http://www.apache.org/licenses/LICENSE-2.0
+//    
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//
+
+#ifndef FASTFLOAT_FAST_FLOAT_H
+#define FASTFLOAT_FAST_FLOAT_H
+
+#include <system_error>
+
+namespace fast_float {
+enum chars_format {
+    scientific = 1<<0,
+    fixed = 1<<2,
+    hex = 1<<3,
+    general = fixed | scientific
+};
+
+
+struct from_chars_result {
+  const char *ptr;
+  std::errc ec;
+};
+
+struct parse_options {
+  constexpr explicit parse_options(chars_format fmt = chars_format::general,
+                         char dot = '.')
+    : format(fmt), decimal_point(dot) {}
+
+  /** Which number formats are accepted */
+  chars_format format;
+  /** The character used as decimal point */
+  char decimal_point;
+};
+
+/**
+ * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
+ * a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale.
+ * The resulting floating-point value is the closest floating-point values (using either float or double),
+ * using the "round to even" convention for values that would otherwise fall right in-between two values.
+ * That is, we provide exact parsing according to the IEEE standard.
+ *
+ * Given a successful parse, the pointer (`ptr`) in the returned value is set to point right after the
+ * parsed number, and the `value` referenced is set to the parsed value. In case of error, the returned
+ * `ec` contains a representative error, otherwise the default (`std::errc()`) value is stored.
+ *
+ * The implementation does not throw and does not allocate memory (e.g., with `new` or `malloc`).
+ *
+ * Like the C++17 standard, the `fast_float::from_chars` functions take an optional last argument of
+ * the type `fast_float::chars_format`. It is a bitset value: we check whether
+ * `fmt & fast_float::chars_format::fixed` and `fmt & fast_float::chars_format::scientific` are set
+ * to determine whether we allow the fixed point and scientific notation respectively.
+ * The default is  `fast_float::chars_format::general` which allows both `fixed` and `scientific`.
+ */
+template<typename T>
+from_chars_result from_chars(const char *first, const char *last,
+                             T &value, chars_format fmt = chars_format::general)  noexcept;
+
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ */
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept;
+
+} // namespace fast_float
+#endif // FASTFLOAT_FAST_FLOAT_H
+
+#ifndef FASTFLOAT_FLOAT_COMMON_H
+#define FASTFLOAT_FLOAT_COMMON_H
+
+#include <cfloat>
+#include <cstdint>
+#include <cassert>
+#include <cstring>
+#include <type_traits>
+
+#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)   \
+       || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
+       || defined(__MINGW64__)                                          \
+       || defined(__s390x__)                                            \
+       || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) )
+#define FASTFLOAT_64BIT 1
+#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86)   \
+     || defined(__arm__) || defined(_M_ARM) || defined(__ppc__)   \
+     || defined(__MINGW32__) || defined(__EMSCRIPTEN__))
+#define FASTFLOAT_32BIT 1
+#else
+  // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
+  // We can never tell the register width, but the SIZE_MAX is a good approximation.
+  // UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max portability.
+  #if SIZE_MAX == 0xffff
+    #error Unknown platform (16-bit, unsupported)
+  #elif SIZE_MAX == 0xffffffff
+    #define FASTFLOAT_32BIT 1
+  #elif SIZE_MAX == 0xffffffffffffffff
+    #define FASTFLOAT_64BIT 1
+  #else
+    #error Unknown platform (not 32-bit, not 64-bit?)
+  #endif
+#endif
+
+#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__))
+#include <intrin.h>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define FASTFLOAT_VISUAL_STUDIO 1
+#endif
+
+#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
+#define FASTFLOAT_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#elif defined _WIN32
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <machine/endian.h>
+#elif defined(sun) || defined(__sun)
+#include <sys/byteorder.h>
+#else
+#ifdef __has_include
+#if __has_include(<endian.h>)
+#include <endian.h>
+#endif //__has_include(<endian.h>)
+#endif //__has_include
+#endif
+#
+#ifndef __BYTE_ORDER__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#ifndef __ORDER_LITTLE_ENDIAN__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#define FASTFLOAT_IS_BIG_ENDIAN 1
+#endif
+#endif
+
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#define fastfloat_really_inline __forceinline
+#else
+#define fastfloat_really_inline inline __attribute__((always_inline))
+#endif
+
+#ifndef FASTFLOAT_ASSERT
+#define FASTFLOAT_ASSERT(x)  { ((void)(x)); }
+#endif
+
+#ifndef FASTFLOAT_DEBUG_ASSERT
+#define FASTFLOAT_DEBUG_ASSERT(x) { ((void)(x)); }
+#endif
+
+// rust style `try!()` macro, or `?` operator
+#define FASTFLOAT_TRY(x) { if (!(x)) return false; }
+
+namespace fast_float {
+
+// Compares two ASCII strings in a case insensitive manner.
+inline bool fastfloat_strncasecmp(const char *input1, const char *input2,
+                                  size_t length) {
+  char running_diff{0};
+  for (size_t i = 0; i < length; i++) {
+    running_diff |= (input1[i] ^ input2[i]);
+  }
+  return (running_diff == 0) || (running_diff == 32);
+}
+
+#ifndef FLT_EVAL_METHOD
+#error "FLT_EVAL_METHOD should be defined, please include cfloat."
+#endif
+
+// a pointer and a length to a contiguous block of memory
+template <typename T>
+struct span {
+  const T* ptr;
+  size_t length;
+  span(const T* _ptr, size_t _length) : ptr(_ptr), length(_length) {}
+  span() : ptr(nullptr), length(0) {}
+
+  constexpr size_t len() const noexcept {
+    return length;
+  }
+
+  const T& operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return ptr[index];
+  }
+};
+
+struct value128 {
+  uint64_t low;
+  uint64_t high;
+  value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
+  value128() : low(0), high(0) {}
+};
+
+/* result might be undefined when input_num is zero */
+fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
+  assert(input_num > 0);
+#ifdef FASTFLOAT_VISUAL_STUDIO
+  #if defined(_M_X64) || defined(_M_ARM64)
+  unsigned long leading_zero = 0;
+  // Search the mask data from most significant bit (MSB)
+  // to least significant bit (LSB) for a set bit (1).
+  _BitScanReverse64(&leading_zero, input_num);
+  return (int)(63 - leading_zero);
+  #else
+  int last_bit = 0;
+  if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, last_bit |= 32;
+  if(input_num & uint64_t(        0xffff0000)) input_num >>= 16, last_bit |= 16;
+  if(input_num & uint64_t(            0xff00)) input_num >>=  8, last_bit |=  8;
+  if(input_num & uint64_t(              0xf0)) input_num >>=  4, last_bit |=  4;
+  if(input_num & uint64_t(               0xc)) input_num >>=  2, last_bit |=  2;
+  if(input_num & uint64_t(               0x2)) input_num >>=  1, last_bit |=  1;
+  return 63 - last_bit;
+  #endif
+#else
+  return __builtin_clzll(input_num);
+#endif
+}
+
+#ifdef FASTFLOAT_32BIT
+
+// slow emulation routine for 32-bit
+fastfloat_really_inline uint64_t emulu(uint32_t x, uint32_t y) {
+    return x * (uint64_t)y;
+}
+
+// slow emulation routine for 32-bit
+#if !defined(__MINGW64__)
+fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
+                                          uint64_t *hi) {
+  uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
+  uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
+  uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
+  uint64_t adbc_carry = !!(adbc < ad);
+  uint64_t lo = bd + (adbc << 32);
+  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
+        (adbc_carry << 32) + !!(lo < bd);
+  return lo;
+}
+#endif // !__MINGW64__
+
+#endif // FASTFLOAT_32BIT
+
+
+// compute 64-bit a*b
+fastfloat_really_inline value128 full_multiplication(uint64_t a,
+                                                     uint64_t b) {
+  value128 answer;
+#if defined(_M_ARM64) && !defined(__MINGW32__)
+  // ARM64 has native support for 64-bit multiplications, no need to emulate
+  // But MinGW on ARM64 doesn't have native support for 64-bit multiplications
+  answer.high = __umulh(a, b);
+  answer.low = a * b;
+#elif defined(FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__))
+  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
+#elif defined(FASTFLOAT_64BIT)
+  __uint128_t r = ((__uint128_t)a) * b;
+  answer.low = uint64_t(r);
+  answer.high = uint64_t(r >> 64);
+#else
+  #error Not implemented
+#endif
+  return answer;
+}
+
+struct adjusted_mantissa {
+  uint64_t mantissa{0};
+  int32_t power2{0}; // a negative value indicates an invalid result
+  adjusted_mantissa() = default;
+  bool operator==(const adjusted_mantissa &o) const {
+    return mantissa == o.mantissa && power2 == o.power2;
+  }
+  bool operator!=(const adjusted_mantissa &o) const {
+    return mantissa != o.mantissa || power2 != o.power2;
+  }
+};
+
+// Bias so we can get the real exponent with an invalid adjusted_mantissa.
+constexpr static int32_t invalid_am_bias = -0x8000;
+
+constexpr static double powers_of_ten_double[] = {
+    1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+constexpr static float powers_of_ten_float[] = {1e0f, 1e1f, 1e2f, 1e3f, 1e4f, 1e5f,
+                                                1e6f, 1e7f, 1e8f, 1e9f, 1e10f};
+// used for max_mantissa_double and max_mantissa_float
+constexpr uint64_t constant_55555 = 5 * 5 * 5 * 5 * 5;
+// Largest integer value v so that (5**index * v) <= 1<<53.
+// 0x10000000000000 == 1 << 53
+constexpr static uint64_t max_mantissa_double[] = {
+      0x10000000000000,
+      0x10000000000000 / 5,
+      0x10000000000000 / (5 * 5),
+      0x10000000000000 / (5 * 5 * 5),
+      0x10000000000000 / (5 * 5 * 5 * 5),
+      0x10000000000000 / (constant_55555),
+      0x10000000000000 / (constant_55555 * 5),
+      0x10000000000000 / (constant_55555 * 5 * 5),
+      0x10000000000000 / (constant_55555 * 5 * 5 * 5),
+      0x10000000000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555),
+      0x10000000000000 / (constant_55555 * constant_55555 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * constant_55555),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * constant_55555 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * constant_55555 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x10000000000000 / (constant_55555 * constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5 * 5)};
+  // Largest integer value v so that (5**index * v) <= 1<<24.
+  // 0x1000000 == 1<<24
+  constexpr static uint64_t max_mantissa_float[] = {
+      0x1000000,
+      0x1000000 / 5,
+      0x1000000 / (5 * 5),
+      0x1000000 / (5 * 5 * 5),
+      0x1000000 / (5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555),
+      0x1000000 / (constant_55555 * 5),
+      0x1000000 / (constant_55555 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * constant_55555),
+      0x1000000 / (constant_55555 * constant_55555 * 5)};
+
+template <typename T> struct binary_format {
+  using equiv_uint = typename std::conditional<sizeof(T) == 4, uint32_t, uint64_t>::type;
+
+  static inline constexpr int mantissa_explicit_bits();
+  static inline constexpr int minimum_exponent();
+  static inline constexpr int infinite_power();
+  static inline constexpr int sign_index();
+  static inline constexpr int min_exponent_fast_path(); // used when fegetround() == FE_TONEAREST
+  static inline constexpr int max_exponent_fast_path();
+  static inline constexpr int max_exponent_round_to_even();
+  static inline constexpr int min_exponent_round_to_even();
+  static inline constexpr uint64_t max_mantissa_fast_path(int64_t power);
+  static inline constexpr uint64_t max_mantissa_fast_path(); // used when fegetround() == FE_TONEAREST
+  static inline constexpr int largest_power_of_ten();
+  static inline constexpr int smallest_power_of_ten();
+  static inline constexpr T exact_power_of_ten(int64_t power);
+  static inline constexpr size_t max_digits();
+  static inline constexpr equiv_uint exponent_mask();
+  static inline constexpr equiv_uint mantissa_mask();
+  static inline constexpr equiv_uint hidden_bit_mask();
+};
+
+template <> inline constexpr int binary_format<double>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -22;
+#endif
+}
+
+template <> inline constexpr int binary_format<float>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -10;
+#endif
+}
+
+template <> inline constexpr int binary_format<double>::mantissa_explicit_bits() {
+  return 52;
+}
+template <> inline constexpr int binary_format<float>::mantissa_explicit_bits() {
+  return 23;
+}
+
+template <> inline constexpr int binary_format<double>::max_exponent_round_to_even() {
+  return 23;
+}
+
+template <> inline constexpr int binary_format<float>::max_exponent_round_to_even() {
+  return 10;
+}
+
+template <> inline constexpr int binary_format<double>::min_exponent_round_to_even() {
+  return -4;
+}
+
+template <> inline constexpr int binary_format<float>::min_exponent_round_to_even() {
+  return -17;
+}
+
+template <> inline constexpr int binary_format<double>::minimum_exponent() {
+  return -1023;
+}
+template <> inline constexpr int binary_format<float>::minimum_exponent() {
+  return -127;
+}
+
+template <> inline constexpr int binary_format<double>::infinite_power() {
+  return 0x7FF;
+}
+template <> inline constexpr int binary_format<float>::infinite_power() {
+  return 0xFF;
+}
+
+template <> inline constexpr int binary_format<double>::sign_index() { return 63; }
+template <> inline constexpr int binary_format<float>::sign_index() { return 31; }
+
+template <> inline constexpr int binary_format<double>::max_exponent_fast_path() {
+  return 22;
+}
+template <> inline constexpr int binary_format<float>::max_exponent_fast_path() {
+  return 10;
+}
+template <> inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+template <> inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 22
+  //
+  return max_mantissa_double[power];
+}
+template <> inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+template <> inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 10
+  //
+  return max_mantissa_float[power];
+}
+
+template <>
+inline constexpr double binary_format<double>::exact_power_of_ten(int64_t power) {
+  return powers_of_ten_double[power];
+}
+template <>
+inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
+
+  return powers_of_ten_float[power];
+}
+
+
+template <>
+inline constexpr int binary_format<double>::largest_power_of_ten() {
+  return 308;
+}
+template <>
+inline constexpr int binary_format<float>::largest_power_of_ten() {
+  return 38;
+}
+
+template <>
+inline constexpr int binary_format<double>::smallest_power_of_ten() {
+  return -342;
+}
+template <>
+inline constexpr int binary_format<float>::smallest_power_of_ten() {
+  return -65;
+}
+
+template <> inline constexpr size_t binary_format<double>::max_digits() {
+  return 769;
+}
+template <> inline constexpr size_t binary_format<float>::max_digits() {
+  return 114;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::exponent_mask() {
+  return 0x7F800000;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::exponent_mask() {
+  return 0x7FF0000000000000;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::mantissa_mask() {
+  return 0x007FFFFF;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::mantissa_mask() {
+  return 0x000FFFFFFFFFFFFF;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::hidden_bit_mask() {
+  return 0x00800000;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::hidden_bit_mask() {
+  return 0x0010000000000000;
+}
+
+template<typename T>
+fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
+  uint64_t word = am.mantissa;
+  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
+  word = negative
+  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+   if (std::is_same<T, float>::value) {
+     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
+   } else {
+     ::memcpy(&value, &word, sizeof(T));
+   }
+#else
+   // For little-endian systems:
+   ::memcpy(&value, &word, sizeof(T));
+#endif
+}
+
+#if FASTFLOAT_SKIP_WHITE_SPACE // disabled by default
+inline bool is_space(uint8_t c) {
+   static const bool table[] = {
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+   return table[c];
+ }
+#endif
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+#include <cctype>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
+
+fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+  return (val & 0xFF00000000000000) >> 56
+    | (val & 0x00FF000000000000) >> 40
+    | (val & 0x0000FF0000000000) >> 24
+    | (val & 0x000000FF00000000) >> 8
+    | (val & 0x00000000FF000000) << 8
+    | (val & 0x0000000000FF0000) << 24
+    | (val & 0x000000000000FF00) << 40
+    | (val & 0x00000000000000FF) << 56;
+}
+
+fastfloat_really_inline uint64_t read_u64(const char *chars) {
+  uint64_t val;
+  ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  return val;
+}
+
+fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  ::memcpy(chars, &val, sizeof(uint64_t));
+}
+
+// credit  @aqrit
+fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
+  const uint64_t mask = 0x000000FF000000FF;
+  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+  val -= 0x3030303030303030;
+  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+  return uint32_t(val);
+}
+
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
+  return parse_eight_digits_unrolled(read_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
+  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+     0x8080808080808080));
+}
+
+fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
+  return is_made_of_eight_digits_fast(read_u64(chars));
+}
+
+typedef span<const char> byte_span;
+
+struct parsed_number_string {
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  const char *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  byte_span integer{};  // non-nullable
+  byte_span fraction{}; // nullable
+};
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+fastfloat_really_inline
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+  const chars_format fmt = options.format;
+  const char decimal_point = options.decimal_point;
+
+  parsed_number_string answer;
+  answer.valid = false;
+  answer.too_many_digits = false;
+  answer.negative = (*p == '-');
+#if FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default
+  if ((*p == '-') || (*p == '+')) {
+#else
+  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+#endif
+    ++p;
+    if (p == pend) {
+      return answer;
+    }
+    if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
+      return answer;
+    }
+  }
+  const char *const start_digits = p;
+
+  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+  while ((p != pend) && is_integer(*p)) {
+    // a multiplication by 10 is cheaper than an arbitrary integer
+    // multiplication
+    i = 10 * i +
+        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
+    ++p;
+  }
+  const char *const end_of_integer_part = p;
+  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = byte_span(start_digits, size_t(digit_count));
+  int64_t exponent = 0;
+  if ((p != pend) && (*p == decimal_point)) {
+    ++p;
+    const char* before = p;
+    // can occur at most twice without overflowing, but let it occur more, since
+    // for integers with many digits, digit parsing is the primary bottleneck.
+    while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+      p += 8;
+    }
+    while ((p != pend) && is_integer(*p)) {
+      uint8_t digit = uint8_t(*p - '0');
+      ++p;
+      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+    }
+    exponent = before - p;
+    answer.fraction = byte_span(before, size_t(p - before));
+    digit_count -= exponent;
+  }
+  // we must have encountered at least one integer!
+  if (digit_count == 0) {
+    return answer;
+  }
+  int64_t exp_number = 0;            // explicit exponential part
+  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
+    const char * location_of_e = p;
+    ++p;
+    bool neg_exp = false;
+    if ((p != pend) && ('-' == *p)) {
+      neg_exp = true;
+      ++p;
+    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+      ++p;
+    }
+    if ((p == pend) || !is_integer(*p)) {
+      if(!(fmt & chars_format::fixed)) {
+        // We are in error.
+        return answer;
+      }
+      // Otherwise, we will be ignoring the 'e'.
+      p = location_of_e;
+    } else {
+      while ((p != pend) && is_integer(*p)) {
+        uint8_t digit = uint8_t(*p - '0');
+        if (exp_number < 0x10000000) {
+          exp_number = 10 * exp_number + digit;
+        }
+        ++p;
+      }
+      if(neg_exp) { exp_number = - exp_number; }
+      exponent += exp_number;
+    }
+  } else {
+    // If it scientific and not fixed, we have to bail out.
+    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
+  }
+  answer.lastmatch = p;
+  answer.valid = true;
+
+  // If we frequently had to deal with long strings of digits,
+  // we could extend our code by using a 128-bit integer instead
+  // of a 64-bit integer. However, this is uncommon.
+  //
+  // We can deal with up to 19 digits.
+  if (digit_count > 19) { // this is uncommon
+    // It is possible that the integer had an overflow.
+    // We have to handle the case where we have 0.0000somenumber.
+    // We need to be mindful of the case where we only have zeroes...
+    // E.g., 0.000000000...000.
+    const char *start = start_digits;
+    while ((start != pend) && (*start == '0' || *start == decimal_point)) {
+      if(*start == '0') { digit_count --; }
+      start++;
+    }
+    if (digit_count > 19) {
+      answer.too_many_digits = true;
+      // Let us start again, this time, avoiding overflows.
+      // We don't need to check if is_integer, since we use the
+      // pre-tokenized spans from above.
+      i = 0;
+      p = answer.integer.ptr;
+      const char* int_end = p + answer.integer.len();
+      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+      while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+        i = i * 10 + uint64_t(*p - '0');
+        ++p;
+      }
+      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+        exponent = end_of_integer_part - p + exp_number;
+      } else { // We have a value with a fractional component.
+          p = answer.fraction.ptr;
+          const char* frac_end = p + answer.fraction.len();
+          while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+            i = i * 10 + uint64_t(*p - '0');
+            ++p;
+          }
+          exponent = answer.fraction.ptr - p + exp_number;
+      }
+      // We have now corrected both exponent and i, to a truncated value
+    }
+  }
+  answer.exponent = exponent;
+  answer.mantissa = i;
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_FAST_TABLE_H
+#define FASTFLOAT_FAST_TABLE_H
+
+#include <cstdint>
+
+namespace fast_float {
+
+/**
+ * When mapping numbers from decimal to binary,
+ * we go from w * 10^q to m * 2^p but we have
+ * 10^q = 5^q * 2^q, so effectively
+ * we are trying to match
+ * w * 2^q * 5^q to m * 2^p. Thus the powers of two
+ * are not a concern since they can be represented
+ * exactly using the binary notation, only the powers of five
+ * affect the binary significand.
+ */
+
+/**
+ * The smallest non-zero float (binary64) is 2^-1074.
+ * We take as input numbers of the form w x 10^q where w < 2^64.
+ * We have that w * 10^-343  <  2^(64-344) 5^-343 < 2^-1076.
+ * However, we have that
+ * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^-1074.
+ * Thus it is possible for a number of the form w * 10^-342 where
+ * w is a 64-bit value to be a non-zero floating-point number.
+ *********
+ * Any number of form w * 10^309 where w>= 1 is going to be
+ * infinite in binary64 so we never need to worry about powers
+ * of 5 greater than 308.
+ */
+template <class unused = void>
+struct powers_template {
+
+constexpr static int smallest_power_of_five = binary_format<double>::smallest_power_of_ten();
+constexpr static int largest_power_of_five = binary_format<double>::largest_power_of_ten();
+constexpr static int number_of_entries = 2 * (largest_power_of_five - smallest_power_of_five + 1);
+// Powers of five from 5^-342 all the way to 5^308 rounded toward one.
+static const uint64_t power_of_five_128[number_of_entries];
+};
+
+template <class unused>
+const uint64_t powers_template<unused>::power_of_five_128[number_of_entries] = {
+        0xeef453d6923bd65a,0x113faa2906a13b3f,
+        0x9558b4661b6565f8,0x4ac7ca59a424c507,
+        0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
+        0xe95a99df8ace6f53,0xf4d82c2c107973dc,
+        0x91d8a02bb6c10594,0x79071b9b8a4be869,
+        0xb64ec836a47146f9,0x9748e2826cdee284,
+        0xe3e27a444d8d98b7,0xfd1b1b2308169b25,
+        0x8e6d8c6ab0787f72,0xfe30f0f5e50e20f7,
+        0xb208ef855c969f4f,0xbdbd2d335e51a935,
+        0xde8b2b66b3bc4723,0xad2c788035e61382,
+        0x8b16fb203055ac76,0x4c3bcb5021afcc31,
+        0xaddcb9e83c6b1793,0xdf4abe242a1bbf3d,
+        0xd953e8624b85dd78,0xd71d6dad34a2af0d,
+        0x87d4713d6f33aa6b,0x8672648c40e5ad68,
+        0xa9c98d8ccb009506,0x680efdaf511f18c2,
+        0xd43bf0effdc0ba48,0x212bd1b2566def2,
+        0x84a57695fe98746d,0x14bb630f7604b57,
+        0xa5ced43b7e3e9188,0x419ea3bd35385e2d,
+        0xcf42894a5dce35ea,0x52064cac828675b9,
+        0x818995ce7aa0e1b2,0x7343efebd1940993,
+        0xa1ebfb4219491a1f,0x1014ebe6c5f90bf8,
+        0xca66fa129f9b60a6,0xd41a26e077774ef6,
+        0xfd00b897478238d0,0x8920b098955522b4,
+        0x9e20735e8cb16382,0x55b46e5f5d5535b0,
+        0xc5a890362fddbc62,0xeb2189f734aa831d,
+        0xf712b443bbd52b7b,0xa5e9ec7501d523e4,
+        0x9a6bb0aa55653b2d,0x47b233c92125366e,
+        0xc1069cd4eabe89f8,0x999ec0bb696e840a,
+        0xf148440a256e2c76,0xc00670ea43ca250d,
+        0x96cd2a865764dbca,0x380406926a5e5728,
+        0xbc807527ed3e12bc,0xc605083704f5ecf2,
+        0xeba09271e88d976b,0xf7864a44c633682e,
+        0x93445b8731587ea3,0x7ab3ee6afbe0211d,
+        0xb8157268fdae9e4c,0x5960ea05bad82964,
+        0xe61acf033d1a45df,0x6fb92487298e33bd,
+        0x8fd0c16206306bab,0xa5d3b6d479f8e056,
+        0xb3c4f1ba87bc8696,0x8f48a4899877186c,
+        0xe0b62e2929aba83c,0x331acdabfe94de87,
+        0x8c71dcd9ba0b4925,0x9ff0c08b7f1d0b14,
+        0xaf8e5410288e1b6f,0x7ecf0ae5ee44dd9,
+        0xdb71e91432b1a24a,0xc9e82cd9f69d6150,
+        0x892731ac9faf056e,0xbe311c083a225cd2,
+        0xab70fe17c79ac6ca,0x6dbd630a48aaf406,
+        0xd64d3d9db981787d,0x92cbbccdad5b108,
+        0x85f0468293f0eb4e,0x25bbf56008c58ea5,
+        0xa76c582338ed2621,0xaf2af2b80af6f24e,
+        0xd1476e2c07286faa,0x1af5af660db4aee1,
+        0x82cca4db847945ca,0x50d98d9fc890ed4d,
+        0xa37fce126597973c,0xe50ff107bab528a0,
+        0xcc5fc196fefd7d0c,0x1e53ed49a96272c8,
+        0xff77b1fcbebcdc4f,0x25e8e89c13bb0f7a,
+        0x9faacf3df73609b1,0x77b191618c54e9ac,
+        0xc795830d75038c1d,0xd59df5b9ef6a2417,
+        0xf97ae3d0d2446f25,0x4b0573286b44ad1d,
+        0x9becce62836ac577,0x4ee367f9430aec32,
+        0xc2e801fb244576d5,0x229c41f793cda73f,
+        0xf3a20279ed56d48a,0x6b43527578c1110f,
+        0x9845418c345644d6,0x830a13896b78aaa9,
+        0xbe5691ef416bd60c,0x23cc986bc656d553,
+        0xedec366b11c6cb8f,0x2cbfbe86b7ec8aa8,
+        0x94b3a202eb1c3f39,0x7bf7d71432f3d6a9,
+        0xb9e08a83a5e34f07,0xdaf5ccd93fb0cc53,
+        0xe858ad248f5c22c9,0xd1b3400f8f9cff68,
+        0x91376c36d99995be,0x23100809b9c21fa1,
+        0xb58547448ffffb2d,0xabd40a0c2832a78a,
+        0xe2e69915b3fff9f9,0x16c90c8f323f516c,
+        0x8dd01fad907ffc3b,0xae3da7d97f6792e3,
+        0xb1442798f49ffb4a,0x99cd11cfdf41779c,
+        0xdd95317f31c7fa1d,0x40405643d711d583,
+        0x8a7d3eef7f1cfc52,0x482835ea666b2572,
+        0xad1c8eab5ee43b66,0xda3243650005eecf,
+        0xd863b256369d4a40,0x90bed43e40076a82,
+        0x873e4f75e2224e68,0x5a7744a6e804a291,
+        0xa90de3535aaae202,0x711515d0a205cb36,
+        0xd3515c2831559a83,0xd5a5b44ca873e03,
+        0x8412d9991ed58091,0xe858790afe9486c2,
+        0xa5178fff668ae0b6,0x626e974dbe39a872,
+        0xce5d73ff402d98e3,0xfb0a3d212dc8128f,
+        0x80fa687f881c7f8e,0x7ce66634bc9d0b99,
+        0xa139029f6a239f72,0x1c1fffc1ebc44e80,
+        0xc987434744ac874e,0xa327ffb266b56220,
+        0xfbe9141915d7a922,0x4bf1ff9f0062baa8,
+        0x9d71ac8fada6c9b5,0x6f773fc3603db4a9,
+        0xc4ce17b399107c22,0xcb550fb4384d21d3,
+        0xf6019da07f549b2b,0x7e2a53a146606a48,
+        0x99c102844f94e0fb,0x2eda7444cbfc426d,
+        0xc0314325637a1939,0xfa911155fefb5308,
+        0xf03d93eebc589f88,0x793555ab7eba27ca,
+        0x96267c7535b763b5,0x4bc1558b2f3458de,
+        0xbbb01b9283253ca2,0x9eb1aaedfb016f16,
+        0xea9c227723ee8bcb,0x465e15a979c1cadc,
+        0x92a1958a7675175f,0xbfacd89ec191ec9,
+        0xb749faed14125d36,0xcef980ec671f667b,
+        0xe51c79a85916f484,0x82b7e12780e7401a,
+        0x8f31cc0937ae58d2,0xd1b2ecb8b0908810,
+        0xb2fe3f0b8599ef07,0x861fa7e6dcb4aa15,
+        0xdfbdcece67006ac9,0x67a791e093e1d49a,
+        0x8bd6a141006042bd,0xe0c8bb2c5c6d24e0,
+        0xaecc49914078536d,0x58fae9f773886e18,
+        0xda7f5bf590966848,0xaf39a475506a899e,
+        0x888f99797a5e012d,0x6d8406c952429603,
+        0xaab37fd7d8f58178,0xc8e5087ba6d33b83,
+        0xd5605fcdcf32e1d6,0xfb1e4a9a90880a64,
+        0x855c3be0a17fcd26,0x5cf2eea09a55067f,
+        0xa6b34ad8c9dfc06f,0xf42faa48c0ea481e,
+        0xd0601d8efc57b08b,0xf13b94daf124da26,
+        0x823c12795db6ce57,0x76c53d08d6b70858,
+        0xa2cb1717b52481ed,0x54768c4b0c64ca6e,
+        0xcb7ddcdda26da268,0xa9942f5dcf7dfd09,
+        0xfe5d54150b090b02,0xd3f93b35435d7c4c,
+        0x9efa548d26e5a6e1,0xc47bc5014a1a6daf,
+        0xc6b8e9b0709f109a,0x359ab6419ca1091b,
+        0xf867241c8cc6d4c0,0xc30163d203c94b62,
+        0x9b407691d7fc44f8,0x79e0de63425dcf1d,
+        0xc21094364dfb5636,0x985915fc12f542e4,
+        0xf294b943e17a2bc4,0x3e6f5b7b17b2939d,
+        0x979cf3ca6cec5b5a,0xa705992ceecf9c42,
+        0xbd8430bd08277231,0x50c6ff782a838353,
+        0xece53cec4a314ebd,0xa4f8bf5635246428,
+        0x940f4613ae5ed136,0x871b7795e136be99,
+        0xb913179899f68584,0x28e2557b59846e3f,
+        0xe757dd7ec07426e5,0x331aeada2fe589cf,
+        0x9096ea6f3848984f,0x3ff0d2c85def7621,
+        0xb4bca50b065abe63,0xfed077a756b53a9,
+        0xe1ebce4dc7f16dfb,0xd3e8495912c62894,
+        0x8d3360f09cf6e4bd,0x64712dd7abbbd95c,
+        0xb080392cc4349dec,0xbd8d794d96aacfb3,
+        0xdca04777f541c567,0xecf0d7a0fc5583a0,
+        0x89e42caaf9491b60,0xf41686c49db57244,
+        0xac5d37d5b79b6239,0x311c2875c522ced5,
+        0xd77485cb25823ac7,0x7d633293366b828b,
+        0x86a8d39ef77164bc,0xae5dff9c02033197,
+        0xa8530886b54dbdeb,0xd9f57f830283fdfc,
+        0xd267caa862a12d66,0xd072df63c324fd7b,
+        0x8380dea93da4bc60,0x4247cb9e59f71e6d,
+        0xa46116538d0deb78,0x52d9be85f074e608,
+        0xcd795be870516656,0x67902e276c921f8b,
+        0x806bd9714632dff6,0xba1cd8a3db53b6,
+        0xa086cfcd97bf97f3,0x80e8a40eccd228a4,
+        0xc8a883c0fdaf7df0,0x6122cd128006b2cd,
+        0xfad2a4b13d1b5d6c,0x796b805720085f81,
+        0x9cc3a6eec6311a63,0xcbe3303674053bb0,
+        0xc3f490aa77bd60fc,0xbedbfc4411068a9c,
+        0xf4f1b4d515acb93b,0xee92fb5515482d44,
+        0x991711052d8bf3c5,0x751bdd152d4d1c4a,
+        0xbf5cd54678eef0b6,0xd262d45a78a0635d,
+        0xef340a98172aace4,0x86fb897116c87c34,
+        0x9580869f0e7aac0e,0xd45d35e6ae3d4da0,
+        0xbae0a846d2195712,0x8974836059cca109,
+        0xe998d258869facd7,0x2bd1a438703fc94b,
+        0x91ff83775423cc06,0x7b6306a34627ddcf,
+        0xb67f6455292cbf08,0x1a3bc84c17b1d542,
+        0xe41f3d6a7377eeca,0x20caba5f1d9e4a93,
+        0x8e938662882af53e,0x547eb47b7282ee9c,
+        0xb23867fb2a35b28d,0xe99e619a4f23aa43,
+        0xdec681f9f4c31f31,0x6405fa00e2ec94d4,
+        0x8b3c113c38f9f37e,0xde83bc408dd3dd04,
+        0xae0b158b4738705e,0x9624ab50b148d445,
+        0xd98ddaee19068c76,0x3badd624dd9b0957,
+        0x87f8a8d4cfa417c9,0xe54ca5d70a80e5d6,
+        0xa9f6d30a038d1dbc,0x5e9fcf4ccd211f4c,
+        0xd47487cc8470652b,0x7647c3200069671f,
+        0x84c8d4dfd2c63f3b,0x29ecd9f40041e073,
+        0xa5fb0a17c777cf09,0xf468107100525890,
+        0xcf79cc9db955c2cc,0x7182148d4066eeb4,
+        0x81ac1fe293d599bf,0xc6f14cd848405530,
+        0xa21727db38cb002f,0xb8ada00e5a506a7c,
+        0xca9cf1d206fdc03b,0xa6d90811f0e4851c,
+        0xfd442e4688bd304a,0x908f4a166d1da663,
+        0x9e4a9cec15763e2e,0x9a598e4e043287fe,
+        0xc5dd44271ad3cdba,0x40eff1e1853f29fd,
+        0xf7549530e188c128,0xd12bee59e68ef47c,
+        0x9a94dd3e8cf578b9,0x82bb74f8301958ce,
+        0xc13a148e3032d6e7,0xe36a52363c1faf01,
+        0xf18899b1bc3f8ca1,0xdc44e6c3cb279ac1,
+        0x96f5600f15a7b7e5,0x29ab103a5ef8c0b9,
+        0xbcb2b812db11a5de,0x7415d448f6b6f0e7,
+        0xebdf661791d60f56,0x111b495b3464ad21,
+        0x936b9fcebb25c995,0xcab10dd900beec34,
+        0xb84687c269ef3bfb,0x3d5d514f40eea742,
+        0xe65829b3046b0afa,0xcb4a5a3112a5112,
+        0x8ff71a0fe2c2e6dc,0x47f0e785eaba72ab,
+        0xb3f4e093db73a093,0x59ed216765690f56,
+        0xe0f218b8d25088b8,0x306869c13ec3532c,
+        0x8c974f7383725573,0x1e414218c73a13fb,
+        0xafbd2350644eeacf,0xe5d1929ef90898fa,
+        0xdbac6c247d62a583,0xdf45f746b74abf39,
+        0x894bc396ce5da772,0x6b8bba8c328eb783,
+        0xab9eb47c81f5114f,0x66ea92f3f326564,
+        0xd686619ba27255a2,0xc80a537b0efefebd,
+        0x8613fd0145877585,0xbd06742ce95f5f36,
+        0xa798fc4196e952e7,0x2c48113823b73704,
+        0xd17f3b51fca3a7a0,0xf75a15862ca504c5,
+        0x82ef85133de648c4,0x9a984d73dbe722fb,
+        0xa3ab66580d5fdaf5,0xc13e60d0d2e0ebba,
+        0xcc963fee10b7d1b3,0x318df905079926a8,
+        0xffbbcfe994e5c61f,0xfdf17746497f7052,
+        0x9fd561f1fd0f9bd3,0xfeb6ea8bedefa633,
+        0xc7caba6e7c5382c8,0xfe64a52ee96b8fc0,
+        0xf9bd690a1b68637b,0x3dfdce7aa3c673b0,
+        0x9c1661a651213e2d,0x6bea10ca65c084e,
+        0xc31bfa0fe5698db8,0x486e494fcff30a62,
+        0xf3e2f893dec3f126,0x5a89dba3c3efccfa,
+        0x986ddb5c6b3a76b7,0xf89629465a75e01c,
+        0xbe89523386091465,0xf6bbb397f1135823,
+        0xee2ba6c0678b597f,0x746aa07ded582e2c,
+        0x94db483840b717ef,0xa8c2a44eb4571cdc,
+        0xba121a4650e4ddeb,0x92f34d62616ce413,
+        0xe896a0d7e51e1566,0x77b020baf9c81d17,
+        0x915e2486ef32cd60,0xace1474dc1d122e,
+        0xb5b5ada8aaff80b8,0xd819992132456ba,
+        0xe3231912d5bf60e6,0x10e1fff697ed6c69,
+        0x8df5efabc5979c8f,0xca8d3ffa1ef463c1,
+        0xb1736b96b6fd83b3,0xbd308ff8a6b17cb2,
+        0xddd0467c64bce4a0,0xac7cb3f6d05ddbde,
+        0x8aa22c0dbef60ee4,0x6bcdf07a423aa96b,
+        0xad4ab7112eb3929d,0x86c16c98d2c953c6,
+        0xd89d64d57a607744,0xe871c7bf077ba8b7,
+        0x87625f056c7c4a8b,0x11471cd764ad4972,
+        0xa93af6c6c79b5d2d,0xd598e40d3dd89bcf,
+        0xd389b47879823479,0x4aff1d108d4ec2c3,
+        0x843610cb4bf160cb,0xcedf722a585139ba,
+        0xa54394fe1eedb8fe,0xc2974eb4ee658828,
+        0xce947a3da6a9273e,0x733d226229feea32,
+        0x811ccc668829b887,0x806357d5a3f525f,
+        0xa163ff802a3426a8,0xca07c2dcb0cf26f7,
+        0xc9bcff6034c13052,0xfc89b393dd02f0b5,
+        0xfc2c3f3841f17c67,0xbbac2078d443ace2,
+        0x9d9ba7832936edc0,0xd54b944b84aa4c0d,
+        0xc5029163f384a931,0xa9e795e65d4df11,
+        0xf64335bcf065d37d,0x4d4617b5ff4a16d5,
+        0x99ea0196163fa42e,0x504bced1bf8e4e45,
+        0xc06481fb9bcf8d39,0xe45ec2862f71e1d6,
+        0xf07da27a82c37088,0x5d767327bb4e5a4c,
+        0x964e858c91ba2655,0x3a6a07f8d510f86f,
+        0xbbe226efb628afea,0x890489f70a55368b,
+        0xeadab0aba3b2dbe5,0x2b45ac74ccea842e,
+        0x92c8ae6b464fc96f,0x3b0b8bc90012929d,
+        0xb77ada0617e3bbcb,0x9ce6ebb40173744,
+        0xe55990879ddcaabd,0xcc420a6a101d0515,
+        0x8f57fa54c2a9eab6,0x9fa946824a12232d,
+        0xb32df8e9f3546564,0x47939822dc96abf9,
+        0xdff9772470297ebd,0x59787e2b93bc56f7,
+        0x8bfbea76c619ef36,0x57eb4edb3c55b65a,
+        0xaefae51477a06b03,0xede622920b6b23f1,
+        0xdab99e59958885c4,0xe95fab368e45eced,
+        0x88b402f7fd75539b,0x11dbcb0218ebb414,
+        0xaae103b5fcd2a881,0xd652bdc29f26a119,
+        0xd59944a37c0752a2,0x4be76d3346f0495f,
+        0x857fcae62d8493a5,0x6f70a4400c562ddb,
+        0xa6dfbd9fb8e5b88e,0xcb4ccd500f6bb952,
+        0xd097ad07a71f26b2,0x7e2000a41346a7a7,
+        0x825ecc24c873782f,0x8ed400668c0c28c8,
+        0xa2f67f2dfa90563b,0x728900802f0f32fa,
+        0xcbb41ef979346bca,0x4f2b40a03ad2ffb9,
+        0xfea126b7d78186bc,0xe2f610c84987bfa8,
+        0x9f24b832e6b0f436,0xdd9ca7d2df4d7c9,
+        0xc6ede63fa05d3143,0x91503d1c79720dbb,
+        0xf8a95fcf88747d94,0x75a44c6397ce912a,
+        0x9b69dbe1b548ce7c,0xc986afbe3ee11aba,
+        0xc24452da229b021b,0xfbe85badce996168,
+        0xf2d56790ab41c2a2,0xfae27299423fb9c3,
+        0x97c560ba6b0919a5,0xdccd879fc967d41a,
+        0xbdb6b8e905cb600f,0x5400e987bbc1c920,
+        0xed246723473e3813,0x290123e9aab23b68,
+        0x9436c0760c86e30b,0xf9a0b6720aaf6521,
+        0xb94470938fa89bce,0xf808e40e8d5b3e69,
+        0xe7958cb87392c2c2,0xb60b1d1230b20e04,
+        0x90bd77f3483bb9b9,0xb1c6f22b5e6f48c2,
+        0xb4ecd5f01a4aa828,0x1e38aeb6360b1af3,
+        0xe2280b6c20dd5232,0x25c6da63c38de1b0,
+        0x8d590723948a535f,0x579c487e5a38ad0e,
+        0xb0af48ec79ace837,0x2d835a9df0c6d851,
+        0xdcdb1b2798182244,0xf8e431456cf88e65,
+        0x8a08f0f8bf0f156b,0x1b8e9ecb641b58ff,
+        0xac8b2d36eed2dac5,0xe272467e3d222f3f,
+        0xd7adf884aa879177,0x5b0ed81dcc6abb0f,
+        0x86ccbb52ea94baea,0x98e947129fc2b4e9,
+        0xa87fea27a539e9a5,0x3f2398d747b36224,
+        0xd29fe4b18e88640e,0x8eec7f0d19a03aad,
+        0x83a3eeeef9153e89,0x1953cf68300424ac,
+        0xa48ceaaab75a8e2b,0x5fa8c3423c052dd7,
+        0xcdb02555653131b6,0x3792f412cb06794d,
+        0x808e17555f3ebf11,0xe2bbd88bbee40bd0,
+        0xa0b19d2ab70e6ed6,0x5b6aceaeae9d0ec4,
+        0xc8de047564d20a8b,0xf245825a5a445275,
+        0xfb158592be068d2e,0xeed6e2f0f0d56712,
+        0x9ced737bb6c4183d,0x55464dd69685606b,
+        0xc428d05aa4751e4c,0xaa97e14c3c26b886,
+        0xf53304714d9265df,0xd53dd99f4b3066a8,
+        0x993fe2c6d07b7fab,0xe546a8038efe4029,
+        0xbf8fdb78849a5f96,0xde98520472bdd033,
+        0xef73d256a5c0f77c,0x963e66858f6d4440,
+        0x95a8637627989aad,0xdde7001379a44aa8,
+        0xbb127c53b17ec159,0x5560c018580d5d52,
+        0xe9d71b689dde71af,0xaab8f01e6e10b4a6,
+        0x9226712162ab070d,0xcab3961304ca70e8,
+        0xb6b00d69bb55c8d1,0x3d607b97c5fd0d22,
+        0xe45c10c42a2b3b05,0x8cb89a7db77c506a,
+        0x8eb98a7a9a5b04e3,0x77f3608e92adb242,
+        0xb267ed1940f1c61c,0x55f038b237591ed3,
+        0xdf01e85f912e37a3,0x6b6c46dec52f6688,
+        0x8b61313bbabce2c6,0x2323ac4b3b3da015,
+        0xae397d8aa96c1b77,0xabec975e0a0d081a,
+        0xd9c7dced53c72255,0x96e7bd358c904a21,
+        0x881cea14545c7575,0x7e50d64177da2e54,
+        0xaa242499697392d2,0xdde50bd1d5d0b9e9,
+        0xd4ad2dbfc3d07787,0x955e4ec64b44e864,
+        0x84ec3c97da624ab4,0xbd5af13bef0b113e,
+        0xa6274bbdd0fadd61,0xecb1ad8aeacdd58e,
+        0xcfb11ead453994ba,0x67de18eda5814af2,
+        0x81ceb32c4b43fcf4,0x80eacf948770ced7,
+        0xa2425ff75e14fc31,0xa1258379a94d028d,
+        0xcad2f7f5359a3b3e,0x96ee45813a04330,
+        0xfd87b5f28300ca0d,0x8bca9d6e188853fc,
+        0x9e74d1b791e07e48,0x775ea264cf55347e,
+        0xc612062576589dda,0x95364afe032a819e,
+        0xf79687aed3eec551,0x3a83ddbd83f52205,
+        0x9abe14cd44753b52,0xc4926a9672793543,
+        0xc16d9a0095928a27,0x75b7053c0f178294,
+        0xf1c90080baf72cb1,0x5324c68b12dd6339,
+        0x971da05074da7bee,0xd3f6fc16ebca5e04,
+        0xbce5086492111aea,0x88f4bb1ca6bcf585,
+        0xec1e4a7db69561a5,0x2b31e9e3d06c32e6,
+        0x9392ee8e921d5d07,0x3aff322e62439fd0,
+        0xb877aa3236a4b449,0x9befeb9fad487c3,
+        0xe69594bec44de15b,0x4c2ebe687989a9b4,
+        0x901d7cf73ab0acd9,0xf9d37014bf60a11,
+        0xb424dc35095cd80f,0x538484c19ef38c95,
+        0xe12e13424bb40e13,0x2865a5f206b06fba,
+        0x8cbccc096f5088cb,0xf93f87b7442e45d4,
+        0xafebff0bcb24aafe,0xf78f69a51539d749,
+        0xdbe6fecebdedd5be,0xb573440e5a884d1c,
+        0x89705f4136b4a597,0x31680a88f8953031,
+        0xabcc77118461cefc,0xfdc20d2b36ba7c3e,
+        0xd6bf94d5e57a42bc,0x3d32907604691b4d,
+        0x8637bd05af6c69b5,0xa63f9a49c2c1b110,
+        0xa7c5ac471b478423,0xfcf80dc33721d54,
+        0xd1b71758e219652b,0xd3c36113404ea4a9,
+        0x83126e978d4fdf3b,0x645a1cac083126ea,
+        0xa3d70a3d70a3d70a,0x3d70a3d70a3d70a4,
+        0xcccccccccccccccc,0xcccccccccccccccd,
+        0x8000000000000000,0x0,
+        0xa000000000000000,0x0,
+        0xc800000000000000,0x0,
+        0xfa00000000000000,0x0,
+        0x9c40000000000000,0x0,
+        0xc350000000000000,0x0,
+        0xf424000000000000,0x0,
+        0x9896800000000000,0x0,
+        0xbebc200000000000,0x0,
+        0xee6b280000000000,0x0,
+        0x9502f90000000000,0x0,
+        0xba43b74000000000,0x0,
+        0xe8d4a51000000000,0x0,
+        0x9184e72a00000000,0x0,
+        0xb5e620f480000000,0x0,
+        0xe35fa931a0000000,0x0,
+        0x8e1bc9bf04000000,0x0,
+        0xb1a2bc2ec5000000,0x0,
+        0xde0b6b3a76400000,0x0,
+        0x8ac7230489e80000,0x0,
+        0xad78ebc5ac620000,0x0,
+        0xd8d726b7177a8000,0x0,
+        0x878678326eac9000,0x0,
+        0xa968163f0a57b400,0x0,
+        0xd3c21bcecceda100,0x0,
+        0x84595161401484a0,0x0,
+        0xa56fa5b99019a5c8,0x0,
+        0xcecb8f27f4200f3a,0x0,
+        0x813f3978f8940984,0x4000000000000000,
+        0xa18f07d736b90be5,0x5000000000000000,
+        0xc9f2c9cd04674ede,0xa400000000000000,
+        0xfc6f7c4045812296,0x4d00000000000000,
+        0x9dc5ada82b70b59d,0xf020000000000000,
+        0xc5371912364ce305,0x6c28000000000000,
+        0xf684df56c3e01bc6,0xc732000000000000,
+        0x9a130b963a6c115c,0x3c7f400000000000,
+        0xc097ce7bc90715b3,0x4b9f100000000000,
+        0xf0bdc21abb48db20,0x1e86d40000000000,
+        0x96769950b50d88f4,0x1314448000000000,
+        0xbc143fa4e250eb31,0x17d955a000000000,
+        0xeb194f8e1ae525fd,0x5dcfab0800000000,
+        0x92efd1b8d0cf37be,0x5aa1cae500000000,
+        0xb7abc627050305ad,0xf14a3d9e40000000,
+        0xe596b7b0c643c719,0x6d9ccd05d0000000,
+        0x8f7e32ce7bea5c6f,0xe4820023a2000000,
+        0xb35dbf821ae4f38b,0xdda2802c8a800000,
+        0xe0352f62a19e306e,0xd50b2037ad200000,
+        0x8c213d9da502de45,0x4526f422cc340000,
+        0xaf298d050e4395d6,0x9670b12b7f410000,
+        0xdaf3f04651d47b4c,0x3c0cdd765f114000,
+        0x88d8762bf324cd0f,0xa5880a69fb6ac800,
+        0xab0e93b6efee0053,0x8eea0d047a457a00,
+        0xd5d238a4abe98068,0x72a4904598d6d880,
+        0x85a36366eb71f041,0x47a6da2b7f864750,
+        0xa70c3c40a64e6c51,0x999090b65f67d924,
+        0xd0cf4b50cfe20765,0xfff4b4e3f741cf6d,
+        0x82818f1281ed449f,0xbff8f10e7a8921a4,
+        0xa321f2d7226895c7,0xaff72d52192b6a0d,
+        0xcbea6f8ceb02bb39,0x9bf4f8a69f764490,
+        0xfee50b7025c36a08,0x2f236d04753d5b4,
+        0x9f4f2726179a2245,0x1d762422c946590,
+        0xc722f0ef9d80aad6,0x424d3ad2b7b97ef5,
+        0xf8ebad2b84e0d58b,0xd2e0898765a7deb2,
+        0x9b934c3b330c8577,0x63cc55f49f88eb2f,
+        0xc2781f49ffcfa6d5,0x3cbf6b71c76b25fb,
+        0xf316271c7fc3908a,0x8bef464e3945ef7a,
+        0x97edd871cfda3a56,0x97758bf0e3cbb5ac,
+        0xbde94e8e43d0c8ec,0x3d52eeed1cbea317,
+        0xed63a231d4c4fb27,0x4ca7aaa863ee4bdd,
+        0x945e455f24fb1cf8,0x8fe8caa93e74ef6a,
+        0xb975d6b6ee39e436,0xb3e2fd538e122b44,
+        0xe7d34c64a9c85d44,0x60dbbca87196b616,
+        0x90e40fbeea1d3a4a,0xbc8955e946fe31cd,
+        0xb51d13aea4a488dd,0x6babab6398bdbe41,
+        0xe264589a4dcdab14,0xc696963c7eed2dd1,
+        0x8d7eb76070a08aec,0xfc1e1de5cf543ca2,
+        0xb0de65388cc8ada8,0x3b25a55f43294bcb,
+        0xdd15fe86affad912,0x49ef0eb713f39ebe,
+        0x8a2dbf142dfcc7ab,0x6e3569326c784337,
+        0xacb92ed9397bf996,0x49c2c37f07965404,
+        0xd7e77a8f87daf7fb,0xdc33745ec97be906,
+        0x86f0ac99b4e8dafd,0x69a028bb3ded71a3,
+        0xa8acd7c0222311bc,0xc40832ea0d68ce0c,
+        0xd2d80db02aabd62b,0xf50a3fa490c30190,
+        0x83c7088e1aab65db,0x792667c6da79e0fa,
+        0xa4b8cab1a1563f52,0x577001b891185938,
+        0xcde6fd5e09abcf26,0xed4c0226b55e6f86,
+        0x80b05e5ac60b6178,0x544f8158315b05b4,
+        0xa0dc75f1778e39d6,0x696361ae3db1c721,
+        0xc913936dd571c84c,0x3bc3a19cd1e38e9,
+        0xfb5878494ace3a5f,0x4ab48a04065c723,
+        0x9d174b2dcec0e47b,0x62eb0d64283f9c76,
+        0xc45d1df942711d9a,0x3ba5d0bd324f8394,
+        0xf5746577930d6500,0xca8f44ec7ee36479,
+        0x9968bf6abbe85f20,0x7e998b13cf4e1ecb,
+        0xbfc2ef456ae276e8,0x9e3fedd8c321a67e,
+        0xefb3ab16c59b14a2,0xc5cfe94ef3ea101e,
+        0x95d04aee3b80ece5,0xbba1f1d158724a12,
+        0xbb445da9ca61281f,0x2a8a6e45ae8edc97,
+        0xea1575143cf97226,0xf52d09d71a3293bd,
+        0x924d692ca61be758,0x593c2626705f9c56,
+        0xb6e0c377cfa2e12e,0x6f8b2fb00c77836c,
+        0xe498f455c38b997a,0xb6dfb9c0f956447,
+        0x8edf98b59a373fec,0x4724bd4189bd5eac,
+        0xb2977ee300c50fe7,0x58edec91ec2cb657,
+        0xdf3d5e9bc0f653e1,0x2f2967b66737e3ed,
+        0x8b865b215899f46c,0xbd79e0d20082ee74,
+        0xae67f1e9aec07187,0xecd8590680a3aa11,
+        0xda01ee641a708de9,0xe80e6f4820cc9495,
+        0x884134fe908658b2,0x3109058d147fdcdd,
+        0xaa51823e34a7eede,0xbd4b46f0599fd415,
+        0xd4e5e2cdc1d1ea96,0x6c9e18ac7007c91a,
+        0x850fadc09923329e,0x3e2cf6bc604ddb0,
+        0xa6539930bf6bff45,0x84db8346b786151c,
+        0xcfe87f7cef46ff16,0xe612641865679a63,
+        0x81f14fae158c5f6e,0x4fcb7e8f3f60c07e,
+        0xa26da3999aef7749,0xe3be5e330f38f09d,
+        0xcb090c8001ab551c,0x5cadf5bfd3072cc5,
+        0xfdcb4fa002162a63,0x73d9732fc7c8f7f6,
+        0x9e9f11c4014dda7e,0x2867e7fddcdd9afa,
+        0xc646d63501a1511d,0xb281e1fd541501b8,
+        0xf7d88bc24209a565,0x1f225a7ca91a4226,
+        0x9ae757596946075f,0x3375788de9b06958,
+        0xc1a12d2fc3978937,0x52d6b1641c83ae,
+        0xf209787bb47d6b84,0xc0678c5dbd23a49a,
+        0x9745eb4d50ce6332,0xf840b7ba963646e0,
+        0xbd176620a501fbff,0xb650e5a93bc3d898,
+        0xec5d3fa8ce427aff,0xa3e51f138ab4cebe,
+        0x93ba47c980e98cdf,0xc66f336c36b10137,
+        0xb8a8d9bbe123f017,0xb80b0047445d4184,
+        0xe6d3102ad96cec1d,0xa60dc059157491e5,
+        0x9043ea1ac7e41392,0x87c89837ad68db2f,
+        0xb454e4a179dd1877,0x29babe4598c311fb,
+        0xe16a1dc9d8545e94,0xf4296dd6fef3d67a,
+        0x8ce2529e2734bb1d,0x1899e4a65f58660c,
+        0xb01ae745b101e9e4,0x5ec05dcff72e7f8f,
+        0xdc21a1171d42645d,0x76707543f4fa1f73,
+        0x899504ae72497eba,0x6a06494a791c53a8,
+        0xabfa45da0edbde69,0x487db9d17636892,
+        0xd6f8d7509292d603,0x45a9d2845d3c42b6,
+        0x865b86925b9bc5c2,0xb8a2392ba45a9b2,
+        0xa7f26836f282b732,0x8e6cac7768d7141e,
+        0xd1ef0244af2364ff,0x3207d795430cd926,
+        0x8335616aed761f1f,0x7f44e6bd49e807b8,
+        0xa402b9c5a8d3a6e7,0x5f16206c9c6209a6,
+        0xcd036837130890a1,0x36dba887c37a8c0f,
+        0x802221226be55a64,0xc2494954da2c9789,
+        0xa02aa96b06deb0fd,0xf2db9baa10b7bd6c,
+        0xc83553c5c8965d3d,0x6f92829494e5acc7,
+        0xfa42a8b73abbf48c,0xcb772339ba1f17f9,
+        0x9c69a97284b578d7,0xff2a760414536efb,
+        0xc38413cf25e2d70d,0xfef5138519684aba,
+        0xf46518c2ef5b8cd1,0x7eb258665fc25d69,
+        0x98bf2f79d5993802,0xef2f773ffbd97a61,
+        0xbeeefb584aff8603,0xaafb550ffacfd8fa,
+        0xeeaaba2e5dbf6784,0x95ba2a53f983cf38,
+        0x952ab45cfa97a0b2,0xdd945a747bf26183,
+        0xba756174393d88df,0x94f971119aeef9e4,
+        0xe912b9d1478ceb17,0x7a37cd5601aab85d,
+        0x91abb422ccb812ee,0xac62e055c10ab33a,
+        0xb616a12b7fe617aa,0x577b986b314d6009,
+        0xe39c49765fdf9d94,0xed5a7e85fda0b80b,
+        0x8e41ade9fbebc27d,0x14588f13be847307,
+        0xb1d219647ae6b31c,0x596eb2d8ae258fc8,
+        0xde469fbd99a05fe3,0x6fca5f8ed9aef3bb,
+        0x8aec23d680043bee,0x25de7bb9480d5854,
+        0xada72ccc20054ae9,0xaf561aa79a10ae6a,
+        0xd910f7ff28069da4,0x1b2ba1518094da04,
+        0x87aa9aff79042286,0x90fb44d2f05d0842,
+        0xa99541bf57452b28,0x353a1607ac744a53,
+        0xd3fa922f2d1675f2,0x42889b8997915ce8,
+        0x847c9b5d7c2e09b7,0x69956135febada11,
+        0xa59bc234db398c25,0x43fab9837e699095,
+        0xcf02b2c21207ef2e,0x94f967e45e03f4bb,
+        0x8161afb94b44f57d,0x1d1be0eebac278f5,
+        0xa1ba1ba79e1632dc,0x6462d92a69731732,
+        0xca28a291859bbf93,0x7d7b8f7503cfdcfe,
+        0xfcb2cb35e702af78,0x5cda735244c3d43e,
+        0x9defbf01b061adab,0x3a0888136afa64a7,
+        0xc56baec21c7a1916,0x88aaa1845b8fdd0,
+        0xf6c69a72a3989f5b,0x8aad549e57273d45,
+        0x9a3c2087a63f6399,0x36ac54e2f678864b,
+        0xc0cb28a98fcf3c7f,0x84576a1bb416a7dd,
+        0xf0fdf2d3f3c30b9f,0x656d44a2a11c51d5,
+        0x969eb7c47859e743,0x9f644ae5a4b1b325,
+        0xbc4665b596706114,0x873d5d9f0dde1fee,
+        0xeb57ff22fc0c7959,0xa90cb506d155a7ea,
+        0x9316ff75dd87cbd8,0x9a7f12442d588f2,
+        0xb7dcbf5354e9bece,0xc11ed6d538aeb2f,
+        0xe5d3ef282a242e81,0x8f1668c8a86da5fa,
+        0x8fa475791a569d10,0xf96e017d694487bc,
+        0xb38d92d760ec4455,0x37c981dcc395a9ac,
+        0xe070f78d3927556a,0x85bbe253f47b1417,
+        0x8c469ab843b89562,0x93956d7478ccec8e,
+        0xaf58416654a6babb,0x387ac8d1970027b2,
+        0xdb2e51bfe9d0696a,0x6997b05fcc0319e,
+        0x88fcf317f22241e2,0x441fece3bdf81f03,
+        0xab3c2fddeeaad25a,0xd527e81cad7626c3,
+        0xd60b3bd56a5586f1,0x8a71e223d8d3b074,
+        0x85c7056562757456,0xf6872d5667844e49,
+        0xa738c6bebb12d16c,0xb428f8ac016561db,
+        0xd106f86e69d785c7,0xe13336d701beba52,
+        0x82a45b450226b39c,0xecc0024661173473,
+        0xa34d721642b06084,0x27f002d7f95d0190,
+        0xcc20ce9bd35c78a5,0x31ec038df7b441f4,
+        0xff290242c83396ce,0x7e67047175a15271,
+        0x9f79a169bd203e41,0xf0062c6e984d386,
+        0xc75809c42c684dd1,0x52c07b78a3e60868,
+        0xf92e0c3537826145,0xa7709a56ccdf8a82,
+        0x9bbcc7a142b17ccb,0x88a66076400bb691,
+        0xc2abf989935ddbfe,0x6acff893d00ea435,
+        0xf356f7ebf83552fe,0x583f6b8c4124d43,
+        0x98165af37b2153de,0xc3727a337a8b704a,
+        0xbe1bf1b059e9a8d6,0x744f18c0592e4c5c,
+        0xeda2ee1c7064130c,0x1162def06f79df73,
+        0x9485d4d1c63e8be7,0x8addcb5645ac2ba8,
+        0xb9a74a0637ce2ee1,0x6d953e2bd7173692,
+        0xe8111c87c5c1ba99,0xc8fa8db6ccdd0437,
+        0x910ab1d4db9914a0,0x1d9c9892400a22a2,
+        0xb54d5e4a127f59c8,0x2503beb6d00cab4b,
+        0xe2a0b5dc971f303a,0x2e44ae64840fd61d,
+        0x8da471a9de737e24,0x5ceaecfed289e5d2,
+        0xb10d8e1456105dad,0x7425a83e872c5f47,
+        0xdd50f1996b947518,0xd12f124e28f77719,
+        0x8a5296ffe33cc92f,0x82bd6b70d99aaa6f,
+        0xace73cbfdc0bfb7b,0x636cc64d1001550b,
+        0xd8210befd30efa5a,0x3c47f7e05401aa4e,
+        0x8714a775e3e95c78,0x65acfaec34810a71,
+        0xa8d9d1535ce3b396,0x7f1839a741a14d0d,
+        0xd31045a8341ca07c,0x1ede48111209a050,
+        0x83ea2b892091e44d,0x934aed0aab460432,
+        0xa4e4b66b68b65d60,0xf81da84d5617853f,
+        0xce1de40642e3f4b9,0x36251260ab9d668e,
+        0x80d2ae83e9ce78f3,0xc1d72b7c6b426019,
+        0xa1075a24e4421730,0xb24cf65b8612f81f,
+        0xc94930ae1d529cfc,0xdee033f26797b627,
+        0xfb9b7cd9a4a7443c,0x169840ef017da3b1,
+        0x9d412e0806e88aa5,0x8e1f289560ee864e,
+        0xc491798a08a2ad4e,0xf1a6f2bab92a27e2,
+        0xf5b5d7ec8acb58a2,0xae10af696774b1db,
+        0x9991a6f3d6bf1765,0xacca6da1e0a8ef29,
+        0xbff610b0cc6edd3f,0x17fd090a58d32af3,
+        0xeff394dcff8a948e,0xddfc4b4cef07f5b0,
+        0x95f83d0a1fb69cd9,0x4abdaf101564f98e,
+        0xbb764c4ca7a4440f,0x9d6d1ad41abe37f1,
+        0xea53df5fd18d5513,0x84c86189216dc5ed,
+        0x92746b9be2f8552c,0x32fd3cf5b4e49bb4,
+        0xb7118682dbb66a77,0x3fbc8c33221dc2a1,
+        0xe4d5e82392a40515,0xfabaf3feaa5334a,
+        0x8f05b1163ba6832d,0x29cb4d87f2a7400e,
+        0xb2c71d5bca9023f8,0x743e20e9ef511012,
+        0xdf78e4b2bd342cf6,0x914da9246b255416,
+        0x8bab8eefb6409c1a,0x1ad089b6c2f7548e,
+        0xae9672aba3d0c320,0xa184ac2473b529b1,
+        0xda3c0f568cc4f3e8,0xc9e5d72d90a2741e,
+        0x8865899617fb1871,0x7e2fa67c7a658892,
+        0xaa7eebfb9df9de8d,0xddbb901b98feeab7,
+        0xd51ea6fa85785631,0x552a74227f3ea565,
+        0x8533285c936b35de,0xd53a88958f87275f,
+        0xa67ff273b8460356,0x8a892abaf368f137,
+        0xd01fef10a657842c,0x2d2b7569b0432d85,
+        0x8213f56a67f6b29b,0x9c3b29620e29fc73,
+        0xa298f2c501f45f42,0x8349f3ba91b47b8f,
+        0xcb3f2f7642717713,0x241c70a936219a73,
+        0xfe0efb53d30dd4d7,0xed238cd383aa0110,
+        0x9ec95d1463e8a506,0xf4363804324a40aa,
+        0xc67bb4597ce2ce48,0xb143c6053edcd0d5,
+        0xf81aa16fdc1b81da,0xdd94b7868e94050a,
+        0x9b10a4e5e9913128,0xca7cf2b4191c8326,
+        0xc1d4ce1f63f57d72,0xfd1c2f611f63a3f0,
+        0xf24a01a73cf2dccf,0xbc633b39673c8cec,
+        0x976e41088617ca01,0xd5be0503e085d813,
+        0xbd49d14aa79dbc82,0x4b2d8644d8a74e18,
+        0xec9c459d51852ba2,0xddf8e7d60ed1219e,
+        0x93e1ab8252f33b45,0xcabb90e5c942b503,
+        0xb8da1662e7b00a17,0x3d6a751f3b936243,
+        0xe7109bfba19c0c9d,0xcc512670a783ad4,
+        0x906a617d450187e2,0x27fb2b80668b24c5,
+        0xb484f9dc9641e9da,0xb1f9f660802dedf6,
+        0xe1a63853bbd26451,0x5e7873f8a0396973,
+        0x8d07e33455637eb2,0xdb0b487b6423e1e8,
+        0xb049dc016abc5e5f,0x91ce1a9a3d2cda62,
+        0xdc5c5301c56b75f7,0x7641a140cc7810fb,
+        0x89b9b3e11b6329ba,0xa9e904c87fcb0a9d,
+        0xac2820d9623bf429,0x546345fa9fbdcd44,
+        0xd732290fbacaf133,0xa97c177947ad4095,
+        0x867f59a9d4bed6c0,0x49ed8eabcccc485d,
+        0xa81f301449ee8c70,0x5c68f256bfff5a74,
+        0xd226fc195c6a2f8c,0x73832eec6fff3111,
+        0x83585d8fd9c25db7,0xc831fd53c5ff7eab,
+        0xa42e74f3d032f525,0xba3e7ca8b77f5e55,
+        0xcd3a1230c43fb26f,0x28ce1bd2e55f35eb,
+        0x80444b5e7aa7cf85,0x7980d163cf5b81b3,
+        0xa0555e361951c366,0xd7e105bcc332621f,
+        0xc86ab5c39fa63440,0x8dd9472bf3fefaa7,
+        0xfa856334878fc150,0xb14f98f6f0feb951,
+        0x9c935e00d4b9d8d2,0x6ed1bf9a569f33d3,
+        0xc3b8358109e84f07,0xa862f80ec4700c8,
+        0xf4a642e14c6262c8,0xcd27bb612758c0fa,
+        0x98e7e9cccfbd7dbd,0x8038d51cb897789c,
+        0xbf21e44003acdd2c,0xe0470a63e6bd56c3,
+        0xeeea5d5004981478,0x1858ccfce06cac74,
+        0x95527a5202df0ccb,0xf37801e0c43ebc8,
+        0xbaa718e68396cffd,0xd30560258f54e6ba,
+        0xe950df20247c83fd,0x47c6b82ef32a2069,
+        0x91d28b7416cdd27e,0x4cdc331d57fa5441,
+        0xb6472e511c81471d,0xe0133fe4adf8e952,
+        0xe3d8f9e563a198e5,0x58180fddd97723a6,
+        0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
+using powers = powers_template<>;
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H
+#define FASTFLOAT_DECIMAL_TO_BINARY_H
+
+#include <cfloat>
+#include <cinttypes>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+
+namespace fast_float {
+
+// This will compute or rather approximate w * 5**q and return a pair of 64-bit words approximating
+// the result, with the "high" part corresponding to the most significant bits and the
+// low part corresponding to the least significant bits.
+//
+template <int bit_precision>
+fastfloat_really_inline
+value128 compute_product_approximation(int64_t q, uint64_t w) {
+  const int index = 2 * int(q - powers::smallest_power_of_five);
+  // For small values of q, e.g., q in [0,27], the answer is always exact because
+  // The line value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
+  // gives the exact answer.
+  value128 firstproduct = full_multiplication(w, powers::power_of_five_128[index]);
+  static_assert((bit_precision >= 0) && (bit_precision <= 64), " precision should  be in (0,64]");
+  constexpr uint64_t precision_mask = (bit_precision < 64) ?
+               (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
+               : uint64_t(0xFFFFFFFFFFFFFFFF);
+  if((firstproduct.high & precision_mask) == precision_mask) { // could further guard with  (lower + w < lower)
+    // regarding the second product, we only need secondproduct.high, but our expectation is that the compiler will optimize this extra work away if needed.
+    value128 secondproduct = full_multiplication(w, powers::power_of_five_128[index + 1]);
+    firstproduct.low += secondproduct.high;
+    if(secondproduct.high > firstproduct.low) {
+      firstproduct.high++;
+    }
+  }
+  return firstproduct;
+}
+
+namespace detail {
+/**
+ * For q in (0,350), we have that
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ *   floor(p) + q
+ * where
+ *   p = log(5**q)/log(2) = q * log(5)/log(2)
+ *
+ * For negative values of q in (-400,0), we have that 
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to 
+ *   -ceil(p) + q
+ * where
+ *   p = log(5**-q)/log(2) = -q * log(5)/log(2)
+ */
+  constexpr fastfloat_really_inline int32_t power(int32_t q)  noexcept  {
+    return (((152170 + 65536) * q) >> 16) + 63;
+  }
+} // namespace detail
+
+// create an adjusted mantissa, biased by the invalid power2
+// for significant digits already multiplied by 10 ** q.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept  {
+  int hilz = int(w >> 63) ^ 1;
+  adjusted_mantissa answer;
+  answer.mantissa = w << hilz;
+  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
+  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + invalid_am_bias);
+  return answer;
+}
+
+// w * 10 ** q, without rounding the representation up.
+// the power2 in the exponent will be adjusted by invalid_am_bias.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error(int64_t q, uint64_t w)  noexcept  {
+  int lz = leading_zeroes(w);
+  w <<= lz;
+  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  return compute_error_scaled<binary>(q, product.high, lz);
+}
+
+// w * 10 ** q
+// The returned value should be a valid ieee64 number that simply need to be packed.
+// However, in some very rare cases, the computation will fail. In such cases, we
+// return an adjusted_mantissa with a negative power of 2: the caller should recompute
+// in such cases.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
+  adjusted_mantissa answer;
+  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
+    answer.power2 = 0;
+    answer.mantissa = 0;
+    // result should be zero
+    return answer;
+  }
+  if (q > binary::largest_power_of_ten()) {
+    // we want to get infinity:
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+    return answer;
+  }
+  // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].
+
+  // We want the most significant bit of i to be 1. Shift if needed.
+  int lz = leading_zeroes(w);
+  w <<= lz;
+
+  // The required precision is binary::mantissa_explicit_bits() + 3 because
+  // 1. We need the implicit bit
+  // 2. We need an extra bit for rounding purposes
+  // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)
+
+  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  if(product.low == 0xFFFFFFFFFFFFFFFF) { //  could guard it further
+    // In some very rare cases, this could happen, in which case we might need a more accurate
+    // computation that what we can provide cheaply. This is very, very unlikely.
+    //
+    const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0, 
+    // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
+    if(!inside_safe_exponent) {
+      return compute_error_scaled<binary>(q, product.high, lz);
+    }
+  }
+  // The "compute_product_approximation" function can be slightly slower than a branchless approach:
+  // value128 product = compute_product(q, w);
+  // but in practice, we can win big with the compute_product_approximation if its additional branch
+  // is easily predicted. Which is best is data specific.
+  int upperbit = int(product.high >> 63);
+
+  answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
+
+  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - binary::minimum_exponent());
+  if (answer.power2 <= 0) { // we have a subnormal?
+    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
+    if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
+      answer.power2 = 0;
+      answer.mantissa = 0;
+      // result should be zero
+      return answer;
+    }
+    // next line is safe because -answer.power2 + 1 < 64
+    answer.mantissa >>= -answer.power2 + 1;
+    // Thankfully, we can't have both "round-to-even" and subnormals because
+    // "round-to-even" only occurs for powers close to 0.
+    answer.mantissa += (answer.mantissa & 1); // round up
+    answer.mantissa >>= 1;
+    // There is a weird scenario where we don't have a subnormal but just.
+    // Suppose we start with 2.2250738585072013e-308, we end up
+    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
+    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
+    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
+    // subnormal, but we can only know this after rounding.
+    // So we only declare a subnormal if we are smaller than the threshold.
+    answer.power2 = (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ? 0 : 1;
+    return answer;
+  }
+
+  // usually, we round *up*, but if we fall right in between and and we have an
+  // even basis, we need to round down
+  // We are only concerned with the cases where 5**q fits in single 64-bit word.
+  if ((product.low <= 1) &&  (q >= binary::min_exponent_round_to_even()) && (q <= binary::max_exponent_round_to_even()) &&
+      ((answer.mantissa & 3) == 1) ) { // we may fall between two floats!
+    // To be in-between two floats we need that in doing
+    //   answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
+    // ... we dropped out only zeroes. But if this happened, then we can go back!!!
+    if((answer.mantissa  << (upperbit + 64 - binary::mantissa_explicit_bits() - 3)) ==  product.high) {
+      answer.mantissa &= ~uint64_t(1);          // flip it so that we do not round up
+    }
+  }
+
+  answer.mantissa += (answer.mantissa & 1); // round up
+  answer.mantissa >>= 1;
+  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
+    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
+    answer.power2++; // undo previous addition
+  }
+
+  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
+  if (answer.power2 >= binary::infinite_power()) { // infinity
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+  }
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_BIGINT_H
+#define FASTFLOAT_BIGINT_H
+
+#include <algorithm>
+#include <cstdint>
+#include <climits>
+#include <cstring>
+
+
+namespace fast_float {
+
+// the limb width: we want efficient multiplication of double the bits in
+// limb, or for 64-bit limbs, at least 64-bit multiplication where we can
+// extract the high and low parts efficiently. this is every 64-bit
+// architecture except for sparc, which emulates 128-bit multiplication.
+// we might have platforms where `CHAR_BIT` is not 8, so let's avoid
+// doing `8 * sizeof(limb)`.
+#if defined(FASTFLOAT_64BIT) && !defined(__sparc)
+#define FASTFLOAT_64BIT_LIMB 1
+typedef uint64_t limb;
+constexpr size_t limb_bits = 64;
+#else
+#define FASTFLOAT_32BIT_LIMB
+typedef uint32_t limb;
+constexpr size_t limb_bits = 32;
+#endif
+
+typedef span<limb> limb_span;
+
+// number of bits in a bigint. this needs to be at least the number
+// of bits required to store the largest bigint, which is
+// `log2(10**(digits + max_exp))`, or `log2(10**(767 + 342))`, or
+// ~3600 bits, so we round to 4000.
+constexpr size_t bigint_bits = 4000;
+constexpr size_t bigint_limbs = bigint_bits / limb_bits;
+
+// vector-like type that is allocated on the stack. the entire
+// buffer is pre-allocated, and only the length changes.
+template <uint16_t size>
+struct stackvec {
+  limb data[size];
+  // we never need more than 150 limbs
+  uint16_t length{0};
+
+  stackvec() = default;
+  stackvec(const stackvec &) = delete;
+  stackvec &operator=(const stackvec &) = delete;
+  stackvec(stackvec &&) = delete;
+  stackvec &operator=(stackvec &&other) = delete;
+
+  // create stack vector from existing limb span.
+  stackvec(limb_span s) {
+    FASTFLOAT_ASSERT(try_extend(s));
+  }
+
+  limb& operator[](size_t index) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  const limb& operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  // index from the end of the container
+  const limb& rindex(size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    size_t rindex = length - index - 1;
+    return data[rindex];
+  }
+
+  // set the length, without bounds checking.
+  void set_len(size_t len) noexcept {
+    length = uint16_t(len);
+  }
+  constexpr size_t len() const noexcept {
+    return length;
+  }
+  constexpr bool is_empty() const noexcept {
+    return length == 0;
+  }
+  constexpr size_t capacity() const noexcept {
+    return size;
+  }
+  // append item to vector, without bounds checking
+  void push_unchecked(limb value) noexcept {
+    data[length] = value;
+    length++;
+  }
+  // append item to vector, returning if item was added
+  bool try_push(limb value) noexcept {
+    if (len() < capacity()) {
+      push_unchecked(value);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // add items to the vector, from a span, without bounds checking
+  void extend_unchecked(limb_span s) noexcept {
+    limb* ptr = data + length;
+    ::memcpy((void*)ptr, (const void*)s.ptr, sizeof(limb) * s.len());
+    set_len(len() + s.len());
+  }
+  // try to add items to the vector, returning if items were added
+  bool try_extend(limb_span s) noexcept {
+    if (len() + s.len() <= capacity()) {
+      extend_unchecked(s);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // resize the vector, without bounds checking
+  // if the new size is longer than the vector, assign value to each
+  // appended item.
+  void resize_unchecked(size_t new_len, limb value) noexcept {
+    if (new_len > len()) {
+      size_t count = new_len - len();
+      limb* first = data + len();
+      limb* last = first + count;
+      ::std::fill(first, last, value);
+      set_len(new_len);
+    } else {
+      set_len(new_len);
+    }
+  }
+  // try to resize the vector, returning if the vector was resized.
+  bool try_resize(size_t new_len, limb value) noexcept {
+    if (new_len > capacity()) {
+      return false;
+    } else {
+      resize_unchecked(new_len, value);
+      return true;
+    }
+  }
+  // check if any limbs are non-zero after the given index.
+  // this needs to be done in reverse order, since the index
+  // is relative to the most significant limbs.
+  bool nonzero(size_t index) const noexcept {
+    while (index < len()) {
+      if (rindex(index) != 0) {
+        return true;
+      }
+      index++;
+    }
+    return false;
+  }
+  // normalize the big integer, so most-significant zero limbs are removed.
+  void normalize() noexcept {
+    while (len() > 0 && rindex(0) == 0) {
+      length--;
+    }
+  }
+};
+
+fastfloat_really_inline
+uint64_t empty_hi64(bool& truncated) noexcept {
+  truncated = false;
+  return 0;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, bool& truncated) noexcept {
+  truncated = false;
+  int shl = leading_zeroes(r0);
+  return r0 << shl;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept {
+  int shl = leading_zeroes(r0);
+  if (shl == 0) {
+    truncated = r1 != 0;
+    return r0;
+  } else {
+    int shr = 64 - shl;
+    truncated = (r1 << shl) != 0;
+    return (r0 << shl) | (r1 >> shr);
+  }
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, bool& truncated) noexcept {
+  return uint64_hi64(r0, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, bool& truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  return uint64_hi64((x0 << 32) | x1, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  uint64_t x2 = r2;
+  return uint64_hi64(x0, (x1 << 32) | x2, truncated);
+}
+
+// add two small integers, checking for overflow.
+// we want an efficient operation. for msvc, where
+// we don't have built-in intrinsics, this is still
+// pretty fast.
+fastfloat_really_inline
+limb scalar_add(limb x, limb y, bool& overflow) noexcept {
+  limb z;
+
+// gcc and clang
+#if defined(__has_builtin)
+  #if __has_builtin(__builtin_add_overflow)
+    overflow = __builtin_add_overflow(x, y, &z);
+    return z;
+  #endif
+#endif
+
+  // generic, this still optimizes correctly on MSVC.
+  z = x + y;
+  overflow = z < x;
+  return z;
+}
+
+// multiply two small integers, getting both the high and low bits.
+fastfloat_really_inline
+limb scalar_mul(limb x, limb y, limb& carry) noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+  #if defined(__SIZEOF_INT128__)
+  // GCC and clang both define it as an extension.
+  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+  #else
+  // fallback, no native 128-bit integer multiplication with carry.
+  // on msvc, this optimizes identically, somehow.
+  value128 z = full_multiplication(x, y);
+  bool overflow;
+  z.low = scalar_add(z.low, carry, overflow);
+  z.high += uint64_t(overflow);  // cannot overflow
+  carry = z.high;
+  return z.low;
+  #endif
+#else
+  uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+#endif
+}
+
+// add scalar value to bigint starting from offset.
+// used in grade school multiplication
+template <uint16_t size>
+inline bool small_add_from(stackvec<size>& vec, limb y, size_t start) noexcept {
+  size_t index = start;
+  limb carry = y;
+  bool overflow;
+  while (carry != 0 && index < vec.len()) {
+    vec[index] = scalar_add(vec[index], carry, overflow);
+    carry = limb(overflow);
+    index += 1;
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add scalar value to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool small_add(stackvec<size>& vec, limb y) noexcept {
+  return small_add_from(vec, y, 0);
+}
+
+// multiply bigint by scalar value.
+template <uint16_t size>
+inline bool small_mul(stackvec<size>& vec, limb y) noexcept {
+  limb carry = 0;
+  for (size_t index = 0; index < vec.len(); index++) {
+    vec[index] = scalar_mul(vec[index], y, carry);
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add bigint to bigint starting from index.
+// used in grade school multiplication
+template <uint16_t size>
+bool large_add_from(stackvec<size>& x, limb_span y, size_t start) noexcept {
+  // the effective x buffer is from `xstart..x.len()`, so exit early
+  // if we can't get that current range.
+  if (x.len() < start || y.len() > x.len() - start) {
+      FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
+  }
+
+  bool carry = false;
+  for (size_t index = 0; index < y.len(); index++) {
+    limb xi = x[index + start];
+    limb yi = y[index];
+    bool c1 = false;
+    bool c2 = false;
+    xi = scalar_add(xi, yi, c1);
+    if (carry) {
+      xi = scalar_add(xi, 1, c2);
+    }
+    x[index + start] = xi;
+    carry = c1 | c2;
+  }
+
+  // handle overflow
+  if (carry) {
+    FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
+  }
+  return true;
+}
+
+// add bigint to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool large_add_from(stackvec<size>& x, limb_span y) noexcept {
+  return large_add_from(x, y, 0);
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool long_mul(stackvec<size>& x, limb_span y) noexcept {
+  limb_span xs = limb_span(x.data, x.len());
+  stackvec<size> z(xs);
+  limb_span zs = limb_span(z.data, z.len());
+
+  if (y.len() != 0) {
+    limb y0 = y[0];
+    FASTFLOAT_TRY(small_mul(x, y0));
+    for (size_t index = 1; index < y.len(); index++) {
+      limb yi = y[index];
+      stackvec<size> zi;
+      if (yi != 0) {
+        // re-use the same buffer throughout
+        zi.set_len(0);
+        FASTFLOAT_TRY(zi.try_extend(zs));
+        FASTFLOAT_TRY(small_mul(zi, yi));
+        limb_span zis = limb_span(zi.data, zi.len());
+        FASTFLOAT_TRY(large_add_from(x, zis, index));
+      }
+    }
+  }
+
+  x.normalize();
+  return true;
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool large_mul(stackvec<size>& x, limb_span y) noexcept {
+  if (y.len() == 1) {
+    FASTFLOAT_TRY(small_mul(x, y[0]));
+  } else {
+    FASTFLOAT_TRY(long_mul(x, y));
+  }
+  return true;
+}
+
+// big integer type. implements a small subset of big integer
+// arithmetic, using simple algorithms since asymptotically
+// faster algorithms are slower for a small number of limbs.
+// all operations assume the big-integer is normalized.
+struct bigint {
+  // storage of the limbs, in little-endian order.
+  stackvec<bigint_limbs> vec;
+
+  bigint(): vec() {}
+  bigint(const bigint &) = delete;
+  bigint &operator=(const bigint &) = delete;
+  bigint(bigint &&) = delete;
+  bigint &operator=(bigint &&other) = delete;
+
+  bigint(uint64_t value): vec() {
+#ifdef FASTFLOAT_64BIT_LIMB
+    vec.push_unchecked(value);
+#else
+    vec.push_unchecked(uint32_t(value));
+    vec.push_unchecked(uint32_t(value >> 32));
+#endif
+    vec.normalize();
+  }
+
+  // get the high 64 bits from the vector, and if bits were truncated.
+  // this is to get the significant digits for the float.
+  uint64_t hi64(bool& truncated) const noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint64_hi64(vec.rindex(0), truncated);
+    } else {
+      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
+      truncated |= vec.nonzero(2);
+      return result;
+    }
+#else
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint32_hi64(vec.rindex(0), truncated);
+    } else if (vec.len() == 2) {
+      return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
+    } else {
+      uint64_t result = uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
+      truncated |= vec.nonzero(3);
+      return result;
+    }
+#endif
+  }
+
+  // compare two big integers, returning the large value.
+  // assumes both are normalized. if the return value is
+  // negative, other is larger, if the return value is
+  // positive, this is larger, otherwise they are equal.
+  // the limbs are stored in little-endian order, so we
+  // must compare the limbs in ever order.
+  int compare(const bigint& other) const noexcept {
+    if (vec.len() > other.vec.len()) {
+      return 1;
+    } else if (vec.len() < other.vec.len()) {
+      return -1;
+    } else {
+      for (size_t index = vec.len(); index > 0; index--) {
+        limb xi = vec[index - 1];
+        limb yi = other.vec[index - 1];
+        if (xi > yi) {
+          return 1;
+        } else if (xi < yi) {
+          return -1;
+        }
+      }
+      return 0;
+    }
+  }
+
+  // shift left each limb n bits, carrying over to the new limb
+  // returns true if we were able to shift all the digits.
+  bool shl_bits(size_t n) noexcept {
+    // Internally, for each item, we shift left by n, and add the previous
+    // right shifted limb-bits.
+    // For example, we transform (for u8) shifted left 2, to:
+    //      b10100100 b01000010
+    //      b10 b10010001 b00001000
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
+
+    size_t shl = n;
+    size_t shr = limb_bits - shl;
+    limb prev = 0;
+    for (size_t index = 0; index < vec.len(); index++) {
+      limb xi = vec[index];
+      vec[index] = (xi << shl) | (prev >> shr);
+      prev = xi;
+    }
+
+    limb carry = prev >> shr;
+    if (carry != 0) {
+      return vec.try_push(carry);
+    }
+    return true;
+  }
+
+  // move the limbs left by `n` limbs.
+  bool shl_limbs(size_t n) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    if (n + vec.len() > vec.capacity()) {
+      return false;
+    } else if (!vec.is_empty()) {
+      // move limbs
+      limb* dst = vec.data + n;
+      const limb* src = vec.data;
+      ::memmove(dst, src, sizeof(limb) * vec.len());
+      // fill in empty limbs
+      limb* first = vec.data;
+      limb* last = first + n;
+      ::std::fill(first, last, 0);
+      vec.set_len(n + vec.len());
+      return true;
+    } else {
+      return true;
+    }
+  }
+
+  // move the limbs left by `n` bits.
+  bool shl(size_t n) noexcept {
+    size_t rem = n % limb_bits;
+    size_t div = n / limb_bits;
+    if (rem != 0) {
+      FASTFLOAT_TRY(shl_bits(rem));
+    }
+    if (div != 0) {
+      FASTFLOAT_TRY(shl_limbs(div));
+    }
+    return true;
+  }
+
+  // get the number of leading zeros in the bigint.
+  int ctlz() const noexcept {
+    if (vec.is_empty()) {
+      return 0;
+    } else {
+#ifdef FASTFLOAT_64BIT_LIMB
+      return leading_zeroes(vec.rindex(0));
+#else
+      // no use defining a specialized leading_zeroes for a 32-bit type.
+      uint64_t r0 = vec.rindex(0);
+      return leading_zeroes(r0 << 32);
+#endif
+    }
+  }
+
+  // get the number of bits in the bigint.
+  int bit_length() const noexcept {
+    int lz = ctlz();
+    return int(limb_bits * vec.len()) - lz;
+  }
+
+  bool mul(limb y) noexcept {
+    return small_mul(vec, y);
+  }
+
+  bool add(limb y) noexcept {
+    return small_add(vec, y);
+  }
+
+  // multiply as if by 2 raised to a power.
+  bool pow2(uint32_t exp) noexcept {
+    return shl(exp);
+  }
+
+  // multiply as if by 5 raised to a power.
+  bool pow5(uint32_t exp) noexcept {
+    // multiply by a power of 5
+    static constexpr uint32_t large_step = 135;
+    static constexpr uint64_t small_power_of_5[] = {
+      1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL, 78125UL, 390625UL,
+      1953125UL, 9765625UL, 48828125UL, 244140625UL, 1220703125UL,
+      6103515625UL, 30517578125UL, 152587890625UL, 762939453125UL,
+      3814697265625UL, 19073486328125UL, 95367431640625UL, 476837158203125UL,
+      2384185791015625UL, 11920928955078125UL, 59604644775390625UL,
+      298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL,
+    };
+#ifdef FASTFLOAT_64BIT_LIMB
+    constexpr static limb large_power_of_5[] = {
+      1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
+      10482974169319127550UL, 198276706040285095UL};
+#else
+    constexpr static limb large_power_of_5[] = {
+      4279965485U, 329373468U, 4020270615U, 2137533757U, 4287402176U,
+      1057042919U, 1071430142U, 2440757623U, 381945767U, 46164893U};
+#endif
+    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
+    limb_span large = limb_span(large_power_of_5, large_length);
+    while (exp >= large_step) {
+      FASTFLOAT_TRY(large_mul(vec, large));
+      exp -= large_step;
+    }
+#ifdef FASTFLOAT_64BIT_LIMB
+    uint32_t small_step = 27;
+    limb max_native = 7450580596923828125UL;
+#else
+    uint32_t small_step = 13;
+    limb max_native = 1220703125U;
+#endif
+    while (exp >= small_step) {
+      FASTFLOAT_TRY(small_mul(vec, max_native));
+      exp -= small_step;
+    }
+    if (exp != 0) {
+      FASTFLOAT_TRY(small_mul(vec, limb(small_power_of_5[exp])));
+    }
+
+    return true;
+  }
+
+  // multiply as if by 10 raised to a power.
+  bool pow10(uint32_t exp) noexcept {
+    FASTFLOAT_TRY(pow5(exp));
+    return pow2(exp);
+  }
+};
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+#include <cctype>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
+
+fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+  return (val & 0xFF00000000000000) >> 56
+    | (val & 0x00FF000000000000) >> 40
+    | (val & 0x0000FF0000000000) >> 24
+    | (val & 0x000000FF00000000) >> 8
+    | (val & 0x00000000FF000000) << 8
+    | (val & 0x0000000000FF0000) << 24
+    | (val & 0x000000000000FF00) << 40
+    | (val & 0x00000000000000FF) << 56;
+}
+
+fastfloat_really_inline uint64_t read_u64(const char *chars) {
+  uint64_t val;
+  ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  return val;
+}
+
+fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  ::memcpy(chars, &val, sizeof(uint64_t));
+}
+
+// credit  @aqrit
+fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
+  const uint64_t mask = 0x000000FF000000FF;
+  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+  val -= 0x3030303030303030;
+  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+  return uint32_t(val);
+}
+
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
+  return parse_eight_digits_unrolled(read_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
+  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+     0x8080808080808080));
+}
+
+fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
+  return is_made_of_eight_digits_fast(read_u64(chars));
+}
+
+typedef span<const char> byte_span;
+
+struct parsed_number_string {
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  const char *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  byte_span integer{};  // non-nullable
+  byte_span fraction{}; // nullable
+};
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+fastfloat_really_inline
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+  const chars_format fmt = options.format;
+  const char decimal_point = options.decimal_point;
+
+  parsed_number_string answer;
+  answer.valid = false;
+  answer.too_many_digits = false;
+  answer.negative = (*p == '-');
+#if FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default
+  if ((*p == '-') || (*p == '+')) {
+#else
+  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+#endif
+    ++p;
+    if (p == pend) {
+      return answer;
+    }
+    if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
+      return answer;
+    }
+  }
+  const char *const start_digits = p;
+
+  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+  while ((p != pend) && is_integer(*p)) {
+    // a multiplication by 10 is cheaper than an arbitrary integer
+    // multiplication
+    i = 10 * i +
+        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
+    ++p;
+  }
+  const char *const end_of_integer_part = p;
+  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = byte_span(start_digits, size_t(digit_count));
+  int64_t exponent = 0;
+  if ((p != pend) && (*p == decimal_point)) {
+    ++p;
+    const char* before = p;
+    // can occur at most twice without overflowing, but let it occur more, since
+    // for integers with many digits, digit parsing is the primary bottleneck.
+    while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+      p += 8;
+    }
+    while ((p != pend) && is_integer(*p)) {
+      uint8_t digit = uint8_t(*p - '0');
+      ++p;
+      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+    }
+    exponent = before - p;
+    answer.fraction = byte_span(before, size_t(p - before));
+    digit_count -= exponent;
+  }
+  // we must have encountered at least one integer!
+  if (digit_count == 0) {
+    return answer;
+  }
+  int64_t exp_number = 0;            // explicit exponential part
+  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
+    const char * location_of_e = p;
+    ++p;
+    bool neg_exp = false;
+    if ((p != pend) && ('-' == *p)) {
+      neg_exp = true;
+      ++p;
+    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+      ++p;
+    }
+    if ((p == pend) || !is_integer(*p)) {
+      if(!(fmt & chars_format::fixed)) {
+        // We are in error.
+        return answer;
+      }
+      // Otherwise, we will be ignoring the 'e'.
+      p = location_of_e;
+    } else {
+      while ((p != pend) && is_integer(*p)) {
+        uint8_t digit = uint8_t(*p - '0');
+        if (exp_number < 0x10000000) {
+          exp_number = 10 * exp_number + digit;
+        }
+        ++p;
+      }
+      if(neg_exp) { exp_number = - exp_number; }
+      exponent += exp_number;
+    }
+  } else {
+    // If it scientific and not fixed, we have to bail out.
+    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
+  }
+  answer.lastmatch = p;
+  answer.valid = true;
+
+  // If we frequently had to deal with long strings of digits,
+  // we could extend our code by using a 128-bit integer instead
+  // of a 64-bit integer. However, this is uncommon.
+  //
+  // We can deal with up to 19 digits.
+  if (digit_count > 19) { // this is uncommon
+    // It is possible that the integer had an overflow.
+    // We have to handle the case where we have 0.0000somenumber.
+    // We need to be mindful of the case where we only have zeroes...
+    // E.g., 0.000000000...000.
+    const char *start = start_digits;
+    while ((start != pend) && (*start == '0' || *start == decimal_point)) {
+      if(*start == '0') { digit_count --; }
+      start++;
+    }
+    if (digit_count > 19) {
+      answer.too_many_digits = true;
+      // Let us start again, this time, avoiding overflows.
+      // We don't need to check if is_integer, since we use the
+      // pre-tokenized spans from above.
+      i = 0;
+      p = answer.integer.ptr;
+      const char* int_end = p + answer.integer.len();
+      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+      while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+        i = i * 10 + uint64_t(*p - '0');
+        ++p;
+      }
+      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+        exponent = end_of_integer_part - p + exp_number;
+      } else { // We have a value with a fractional component.
+          p = answer.fraction.ptr;
+          const char* frac_end = p + answer.fraction.len();
+          while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+            i = i * 10 + uint64_t(*p - '0');
+            ++p;
+          }
+          exponent = answer.fraction.ptr - p + exp_number;
+      }
+      // We have now corrected both exponent and i, to a truncated value
+    }
+  }
+  answer.exponent = exponent;
+  answer.mantissa = i;
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_DIGIT_COMPARISON_H
+#define FASTFLOAT_DIGIT_COMPARISON_H
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// 1e0 to 1e19
+constexpr static uint64_t powers_of_ten_uint64[] = {
+    1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL, 1000000UL, 10000000UL, 100000000UL,
+    1000000000UL, 10000000000UL, 100000000000UL, 1000000000000UL, 10000000000000UL,
+    100000000000000UL, 1000000000000000UL, 10000000000000000UL, 100000000000000000UL,
+    1000000000000000000UL, 10000000000000000000UL};
+
+// calculate the exponent, in scientific notation, of the number.
+// this algorithm is not even close to optimized, but it has no practical
+// effect on performance: in order to have a faster algorithm, we'd need
+// to slow down performance for faster algorithms, and this is still fast.
+fastfloat_really_inline int32_t scientific_exponent(parsed_number_string& num) noexcept {
+  uint64_t mantissa = num.mantissa;
+  int32_t exponent = int32_t(num.exponent);
+  while (mantissa >= 10000) {
+    mantissa /= 10000;
+    exponent += 4;
+  }
+  while (mantissa >= 100) {
+    mantissa /= 100;
+    exponent += 2;
+  }
+  while (mantissa >= 10) {
+    mantissa /= 10;
+    exponent += 1;
+  }
+  return exponent;
+}
+
+// this converts a native floating-point number to an extended-precision float.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended(T value) noexcept {
+  using equiv_uint = typename binary_format<T>::equiv_uint;
+  constexpr equiv_uint exponent_mask = binary_format<T>::exponent_mask();
+  constexpr equiv_uint mantissa_mask = binary_format<T>::mantissa_mask();
+  constexpr equiv_uint hidden_bit_mask = binary_format<T>::hidden_bit_mask();
+
+  adjusted_mantissa am;
+  int32_t bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+  equiv_uint bits;
+  ::memcpy(&bits, &value, sizeof(T));
+  if ((bits & exponent_mask) == 0) {
+    // denormal
+    am.power2 = 1 - bias;
+    am.mantissa = bits & mantissa_mask;
+  } else {
+    // normal
+    am.power2 = int32_t((bits & exponent_mask) >> binary_format<T>::mantissa_explicit_bits());
+    am.power2 -= bias;
+    am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
+  }
+
+  return am;
+}
+
+// get the extended precision value of the halfway point between b and b+u.
+// we are given a native float that represents b, so we need to adjust it
+// halfway between b and b+u.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended_halfway(T value) noexcept {
+  adjusted_mantissa am = to_extended(value);
+  am.mantissa <<= 1;
+  am.mantissa += 1;
+  am.power2 -= 1;
+  return am;
+}
+
+// round an extended-precision float to the nearest machine float.
+template <typename T, typename callback>
+fastfloat_really_inline void round(adjusted_mantissa& am, callback cb) noexcept {
+  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
+  if (-am.power2 >= mantissa_shift) {
+    // have a denormal float
+    int32_t shift = -am.power2 + 1;
+    cb(am, std::min<int32_t>(shift, 64));
+    // check for round-up: if rounding-nearest carried us to the hidden bit.
+    am.power2 = (am.mantissa < (uint64_t(1) << binary_format<T>::mantissa_explicit_bits())) ? 0 : 1;
+    return;
+  }
+
+  // have a normal float, use the default shift.
+  cb(am, mantissa_shift);
+
+  // check for carry
+  if (am.mantissa >= (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
+    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+    am.power2++;
+  }
+
+  // check for infinite: we could have carried to an infinite power
+  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+  if (am.power2 >= binary_format<T>::infinite_power()) {
+    am.power2 = binary_format<T>::infinite_power();
+    am.mantissa = 0;
+  }
+}
+
+template <typename callback>
+fastfloat_really_inline
+void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) noexcept {
+  uint64_t mask;
+  uint64_t halfway;
+  if (shift == 64) {
+    mask = UINT64_MAX;
+  } else {
+    mask = (uint64_t(1) << shift) - 1;
+  }
+  if (shift == 0) {
+    halfway = 0;
+  } else {
+    halfway = uint64_t(1) << (shift - 1);
+  }
+  uint64_t truncated_bits = am.mantissa & mask;
+  bool is_above = truncated_bits > halfway;
+  bool is_halfway = truncated_bits == halfway;
+
+  // shift digits into position
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+
+  bool is_odd = (am.mantissa & 1) == 1;
+  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
+}
+
+fastfloat_really_inline void round_down(adjusted_mantissa& am, int32_t shift) noexcept {
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+}
+
+fastfloat_really_inline void skip_zeros(const char*& first, const char* last) noexcept {
+  uint64_t val;
+  while (std::distance(first, last) >= 8) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != 0x3030303030303030) {
+      break;
+    }
+    first += 8;
+  }
+  while (first != last) {
+    if (*first != '0') {
+      break;
+    }
+    first++;
+  }
+}
+
+// determine if any non-zero digits were truncated.
+// all characters must be valid digits.
+fastfloat_really_inline bool is_truncated(const char* first, const char* last) noexcept {
+  // do 8-bit optimizations, can just compare to 8 literal 0s.
+  uint64_t val;
+  while (std::distance(first, last) >= 8) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != 0x3030303030303030) {
+      return true;
+    }
+    first += 8;
+  }
+  while (first != last) {
+    if (*first != '0') {
+      return true;
+    }
+    first++;
+  }
+  return false;
+}
+
+fastfloat_really_inline bool is_truncated(byte_span s) noexcept {
+  return is_truncated(s.ptr, s.ptr + s.len());
+}
+
+fastfloat_really_inline
+void parse_eight_digits(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+  value = value * 100000000 + parse_eight_digits_unrolled(p);
+  p += 8;
+  counter += 8;
+  count += 8;
+}
+
+fastfloat_really_inline
+void parse_one_digit(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+  value = value * 10 + limb(*p - '0');
+  p++;
+  counter++;
+  count++;
+}
+
+fastfloat_really_inline
+void add_native(bigint& big, limb power, limb value) noexcept {
+  big.mul(power);
+  big.add(value);
+}
+
+fastfloat_really_inline void round_up_bigint(bigint& big, size_t& count) noexcept {
+  // need to round-up the digits, but need to avoid rounding
+  // ....9999 to ...10000, which could cause a false halfway point.
+  add_native(big, 10, 1);
+  count++;
+}
+
+// parse the significant digits into a big integer
+inline void parse_mantissa(bigint& result, parsed_number_string& num, size_t max_digits, size_t& digits) noexcept {
+  // try to minimize the number of big integer and scalar multiplication.
+  // therefore, try to parse 8 digits at a time, and multiply by the largest
+  // scalar value (9 or 19 digits) for each step.
+  size_t counter = 0;
+  digits = 0;
+  limb value = 0;
+#ifdef FASTFLOAT_64BIT_LIMB
+  size_t step = 19;
+#else
+  size_t step = 9;
+#endif
+
+  // process all integer digits.
+  const char* p = num.integer.ptr;
+  const char* pend = p + num.integer.len();
+  skip_zeros(p, pend);
+  // process all digits, in increments of step per loop
+  while (p != pend) {
+    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+      parse_eight_digits(p, value, counter, digits);
+    }
+    while (counter < step && p != pend && digits < max_digits) {
+      parse_one_digit(p, value, counter, digits);
+    }
+    if (digits == max_digits) {
+      // add the temporary value, then check if we've truncated any digits
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      bool truncated = is_truncated(p, pend);
+      if (num.fraction.ptr != nullptr) {
+        truncated |= is_truncated(num.fraction);
+      }
+      if (truncated) {
+        round_up_bigint(result, digits);
+      }
+      return;
+    } else {
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      counter = 0;
+      value = 0;
+    }
+  }
+
+  // add our fraction digits, if they're available.
+  if (num.fraction.ptr != nullptr) {
+    p = num.fraction.ptr;
+    pend = p + num.fraction.len();
+    if (digits == 0) {
+      skip_zeros(p, pend);
+    }
+    // process all digits, in increments of step per loop
+    while (p != pend) {
+      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+        parse_eight_digits(p, value, counter, digits);
+      }
+      while (counter < step && p != pend && digits < max_digits) {
+        parse_one_digit(p, value, counter, digits);
+      }
+      if (digits == max_digits) {
+        // add the temporary value, then check if we've truncated any digits
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        bool truncated = is_truncated(p, pend);
+        if (truncated) {
+          round_up_bigint(result, digits);
+        }
+        return;
+      } else {
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        counter = 0;
+        value = 0;
+      }
+    }
+  }
+
+  if (counter != 0) {
+    add_native(result, limb(powers_of_ten_uint64[counter]), value);
+  }
+}
+
+template <typename T>
+inline adjusted_mantissa positive_digit_comp(bigint& bigmant, int32_t exponent) noexcept {
+  FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
+  adjusted_mantissa answer;
+  bool truncated;
+  answer.mantissa = bigmant.hi64(truncated);
+  int bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+  answer.power2 = bigmant.bit_length() - 64 + bias;
+
+  round<T>(answer, [truncated](adjusted_mantissa& a, int32_t shift) {
+    round_nearest_tie_even(a, shift, [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
+      return is_above || (is_halfway && truncated) || (is_odd && is_halfway);
+    });
+  });
+
+  return answer;
+}
+
+// the scaling here is quite simple: we have, for the real digits `m * 10^e`,
+// and for the theoretical digits `n * 2^f`. Since `e` is always negative,
+// to scale them identically, we do `n * 2^f * 5^-f`, so we now have `m * 2^e`.
+// we then need to scale by `2^(f- e)`, and then the two significant digits
+// are of the same magnitude.
+template <typename T>
+inline adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
+  bigint& real_digits = bigmant;
+  int32_t real_exp = exponent;
+
+  // get the value of `b`, rounded down, and get a bigint representation of b+h
+  adjusted_mantissa am_b = am;
+  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with -Wnoexcept-type.
+  round<T>(am_b, [](adjusted_mantissa&a, int32_t shift) { round_down(a, shift); });
+  T b;
+  to_float(false, am_b, b);
+  adjusted_mantissa theor = to_extended_halfway(b);
+  bigint theor_digits(theor.mantissa);
+  int32_t theor_exp = theor.power2;
+
+  // scale real digits and theor digits to be same power.
+  int32_t pow2_exp = theor_exp - real_exp;
+  uint32_t pow5_exp = uint32_t(-real_exp);
+  if (pow5_exp != 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
+  }
+  if (pow2_exp > 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
+  } else if (pow2_exp < 0) {
+    FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
+  }
+
+  // compare digits, and use it to director rounding
+  int ord = real_digits.compare(theor_digits);
+  adjusted_mantissa answer = am;
+  round<T>(answer, [ord](adjusted_mantissa& a, int32_t shift) {
+    round_nearest_tie_even(a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
+      (void)_;  // not needed, since we've done our comparison
+      (void)__; // not needed, since we've done our comparison
+      if (ord > 0) {
+        return true;
+      } else if (ord < 0) {
+        return false;
+      } else {
+        return is_odd;
+      }
+    });
+  });
+
+  return answer;
+}
+
+// parse the significant digits as a big integer to unambiguously round the
+// the significant digits. here, we are trying to determine how to round
+// an extended float representation close to `b+h`, halfway between `b`
+// (the float rounded-down) and `b+u`, the next positive float. this
+// algorithm is always correct, and uses one of two approaches. when
+// the exponent is positive relative to the significant digits (such as
+// 1234), we create a big-integer representation, get the high 64-bits,
+// determine if any lower bits are truncated, and use that to direct
+// rounding. in case of a negative exponent relative to the significant
+// digits (such as 1.2345), we create a theoretical representation of
+// `b` as a big-integer type, scaled to the same binary exponent as
+// the actual digits. we then compare the big integer representations
+// of both, and use that to direct rounding.
+template <typename T>
+inline adjusted_mantissa digit_comp(parsed_number_string& num, adjusted_mantissa am) noexcept {
+  // remove the invalid exponent bias
+  am.power2 -= invalid_am_bias;
+
+  int32_t sci_exp = scientific_exponent(num);
+  size_t max_digits = binary_format<T>::max_digits();
+  size_t digits = 0;
+  bigint bigmant;
+  parse_mantissa(bigmant, num, max_digits, digits);
+  // can't underflow, since digits is at most max_digits.
+  int32_t exponent = sci_exp + 1 - int32_t(digits);
+  if (exponent >= 0) {
+    return positive_digit_comp<T>(bigmant, exponent);
+  } else {
+    return negative_digit_comp<T>(bigmant, am, exponent);
+  }
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_PARSE_NUMBER_H
+#define FASTFLOAT_PARSE_NUMBER_H
+
+
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <system_error>
+
+namespace fast_float {
+
+
+namespace detail {
+/**
+ * Special case +inf, -inf, nan, infinity, -infinity.
+ * The case comparisons could be made much faster given that we know that the
+ * strings a null-free and fixed.
+ **/
+template <typename T>
+from_chars_result parse_infnan(const char *first, const char *last, T &value)  noexcept  {
+  from_chars_result answer;
+  answer.ptr = first;
+  answer.ec = std::errc(); // be optimistic
+  bool minusSign = false;
+  if (*first == '-') { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here
+      minusSign = true;
+      ++first;
+  }
+  if (last - first >= 3) {
+    if (fastfloat_strncasecmp(first, "nan", 3)) {
+      answer.ptr = (first += 3);
+      value = minusSign ? -std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::quiet_NaN();
+      // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7, C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
+      if(first != last && *first == '(') {
+        for(const char* ptr = first + 1; ptr != last; ++ptr) {
+          if (*ptr == ')') {
+            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
+            break;
+          }
+          else if(!(('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z') || ('0' <= *ptr && *ptr <= '9') || *ptr == '_'))
+            break; // forbidden char, not nan(n-char-seq-opt)
+        }
+      }
+      return answer;
+    }
+    if (fastfloat_strncasecmp(first, "inf", 3)) {
+      if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, "inity", 5)) {
+        answer.ptr = first + 8;
+      } else {
+        answer.ptr = first + 3;
+      }
+      value = minusSign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
+      return answer;
+    }
+  }
+  answer.ec = std::errc::invalid_argument;
+  return answer;
+}
+
+/**
+ * Returns true if the floating-pointing rounding mode is to 'nearest'.
+ * It is the default on most system. This function is meant to be inexpensive.
+ * Credit : @mwalcott3
+ */
+fastfloat_really_inline bool rounds_to_nearest() noexcept {
+  // See
+  // A fast function to check your floating-point rounding mode
+  // https://lemire.me/blog/2022/11/16/a-fast-function-to-check-your-floating-point-rounding-mode/
+  //
+  // This function is meant to be equivalent to :
+  // prior: #include <cfenv>
+  //  return fegetround() == FE_TONEAREST;
+  // However, it is expected to be much faster than the fegetround()
+  // function call.
+  //
+  // The volatile keywoard prevents the compiler from computing the function
+  // at compile-time.
+  // There might be other ways to prevent compile-time optimizations (e.g., asm).
+  // The value does not need to be std::numeric_limits<float>::min(), any small
+  // value so that 1 + x should round to 1 would do (after accounting for excess
+  // precision, as in 387 instructions).
+  static volatile float fmin = std::numeric_limits<float>::min();
+  float fmini = fmin; // we copy it so that it gets loaded at most once.
+  //
+  // Explanation:
+  // Only when fegetround() == FE_TONEAREST do we have that
+  // fmin + 1.0f == 1.0f - fmin.
+  //
+  // FE_UPWARD:
+  //  fmin + 1.0f > 1
+  //  1.0f - fmin == 1
+  //
+  // FE_DOWNWARD or  FE_TOWARDZERO:
+  //  fmin + 1.0f == 1
+  //  1.0f - fmin < 1
+  //
+  // Note: This may fail to be accurate if fast-math has been
+  // enabled, as rounding conventions may not apply.
+  #if FASTFLOAT_VISUAL_STUDIO
+  #   pragma warning(push)
+  //  todo: is there a VS warning?
+  //  see https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013
+  #elif defined(__clang__)
+  #   pragma clang diagnostic push
+  #   pragma clang diagnostic ignored "-Wfloat-equal"
+  #elif defined(__GNUC__)
+  #   pragma GCC diagnostic push
+  #   pragma GCC diagnostic ignored "-Wfloat-equal"
+  #endif
+  return (fmini + 1.0f == 1.0f - fmini);
+  #if FASTFLOAT_VISUAL_STUDIO
+  #   pragma warning(pop)
+  #elif defined(__clang__)
+  #   pragma clang diagnostic pop
+  #elif defined(__GNUC__)
+  #   pragma GCC diagnostic pop
+  #endif
+}
+
+} // namespace detail
+
+template<typename T>
+from_chars_result from_chars(const char *first, const char *last,
+                             T &value, chars_format fmt /*= chars_format::general*/)  noexcept  {
+  return from_chars_advanced(first, last, value, parse_options{fmt});
+}
+
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept  {
+
+  static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
+
+
+  from_chars_result answer;
+#if FASTFLOAT_SKIP_WHITE_SPACE  // disabled by default
+  while ((first != last) && fast_float::is_space(uint8_t(*first))) {
+    first++;
+  }
+#endif
+  if (first == last) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  parsed_number_string pns = parse_number_string(first, last, options);
+  if (!pns.valid) {
+    return detail::parse_infnan(first, last, value);
+  }
+  answer.ec = std::errc(); // be optimistic
+  answer.ptr = pns.lastmatch;
+  // The implementation of the Clinger's fast path is convoluted because
+  // we want round-to-nearest in all cases, irrespective of the rounding mode
+  // selected on the thread.
+  // We proceed optimistically, assuming that detail::rounds_to_nearest() returns
+  // true.
+  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent && pns.exponent <= binary_format<T>::max_exponent_fast_path() && !pns.too_many_digits) {
+    // Unfortunately, the conventional Clinger's fast path is only possible
+    // when the system rounds to the nearest float.
+    //
+    // We expect the next branch to almost always be selected.
+    // We could check it first (before the previous branch), but
+    // there might be performance advantages at having the check
+    // be last.
+    if(detail::rounds_to_nearest())  {
+      // We have that fegetround() == FE_TONEAREST.
+      // Next is Clinger's fast path.
+      if (pns.mantissa <=binary_format<T>::max_mantissa_fast_path()) {
+        value = T(pns.mantissa);
+        if (pns.exponent < 0) { value = value / binary_format<T>::exact_power_of_ten(-pns.exponent); }
+        else { value = value * binary_format<T>::exact_power_of_ten(pns.exponent); }
+        if (pns.negative) { value = -value; }
+        return answer;
+      }
+    } else {
+      // We do not have that fegetround() == FE_TONEAREST.
+      // Next is a modified Clinger's fast path, inspired by Jakub Jelínek's proposal
+      if (pns.exponent >= 0 && pns.mantissa <=binary_format<T>::max_mantissa_fast_path(pns.exponent)) {
+#if defined(__clang__)
+        // Clang may map 0 to -0.0 when fegetround() == FE_DOWNWARD
+        if(pns.mantissa == 0) {
+          value = 0;
+          return answer;
+        }
+#endif
+        value = T(pns.mantissa) * binary_format<T>::exact_power_of_ten(pns.exponent);
+        if (pns.negative) { value = -value; }
+        return answer;
+      }
+    }
+  }
+  adjusted_mantissa am = compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
+  if(pns.too_many_digits && am.power2 >= 0) {
+    if(am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
+      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
+    }
+  }
+  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
+  // then we need to go the long way around again. This is very uncommon.
+  if(am.power2 < 0) { am = digit_comp<T>(pns, am); }
+  to_float(pns.negative, am, value);
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
diff --git a/profiling/README.md b/profiling/README.md
new file mode 100644
index 00000000..ab707aff
--- /dev/null
+++ b/profiling/README.md
@@ -0,0 +1,19 @@
+## `fastnumbers` profiling
+
+The files in this folder represent the profiling results for
+`fastnumbers` functionality. The results are separated by Python version.
+You can see what is being profiled in `profile.py`.
+
+Some general observations about the results:
+- The older the Python version, the greater the benefit `fastnumbers` brings
+  over the built-in functionality. This is because the CPython maintainers are
+  continiously making Python faster.
+- The conversion to floats is always faster than built-in functionality
+  for Python <= 3.9. Starting with Python 3.10 some optimization was added
+  that makes the conversion for small floats very fast.
+- The conversion to integers is always faster than built-in functionality
+  until the length of the input digit string is greater than 18 characters
+  (the cut-off for 64-bit integers), at which point it is roughty tied to
+  slightly slower than CPython.
+- When numbers are provided (as opposed to strings), the Python built-ins
+  are usually faster.
diff --git a/profiling/profile.py b/profiling/profile.py
new file mode 100644
index 00000000..be8cdc0d
--- /dev/null
+++ b/profiling/profile.py
@@ -0,0 +1,425 @@
+#! /usr/bin/env python
+
+import copy
+import math
+import re
+import sys
+import timeit
+
+# If given an file path as an argument, cause print to write
+# to stdout and it.
+try:
+    outloc = sys.argv[1]
+except IndexError:
+    pass
+else:
+
+    class Tee:
+        def __init__(self, stream, filepath):
+            self.stream = stream
+            self.fo = open(filepath, "w")
+
+        def write(self, data):
+            self.stream.write(data)
+            self.stream.flush()
+            self.fo.write(data)
+
+        def flush(self):
+            self.stream.flush()
+            self.fo.flush()
+
+        def close(self):
+            self.fo.close()
+
+        def __del__(self):
+            self.close()
+
+    sys.stdout = Tee(sys.stdout, outloc)
+
+
+class Timer(object):
+    """Class to time functions and make pretty tables of the output."""
+
+    # This is a list of all the things we will time with an associated label.
+    THINGS_TO_TIME = (
+        ("not_a_number", "Non-number String"),
+        ("-4", "Small Int String"),
+        ("-41053", "Int String"),
+        ("358924829458", "Medium Int String"),
+        ("35892482945872302493947939485729", "Large Int String"),
+        ("-4.1", "Small Float String"),
+        ("-41053.543034e34", "Float String"),
+        ("-41053.543028758302e256", "Large Float String"),
+        (-41053, "Int"),
+        (-41053.543028758302e100, "Float"),
+    )
+
+    # Formatting strings.
+    FUNCTION_CALL_FMT = "{}({!r})"
+
+    def __init__(self, title):
+        print("### " + title)
+        print()
+        self.functions = []
+
+    def add_function(self, func, label, setup="pass"):
+        """Add a function to be timed and compared."""
+        self.functions.append((func, setup, label))
+
+    def time_functions(self, repeat=5):
+        """Time all the given functions against all input then display results."""
+
+        # Collect the function labels to make the header of this table.
+        # Show that the units are seconds for each.
+        function_labels = [label + " (ms)" for _, _, label in self.functions]
+
+        # Construct the table strings, formatted in Markdown.
+        # Store each line as a string element in a list.
+        # This portion here is the table header only for now.
+        table = Table()
+        table.add_header("Input type", *function_labels)
+
+        # For each value, time each function and collect the results.
+        for value, value_label in self.THINGS_TO_TIME:
+            row = []
+            for func, setup, _ in self.functions:
+                call = self.FUNCTION_CALL_FMT.format(func, value)
+                try:
+                    row.append(self._timeit(call, setup, repeat))
+                except (ValueError, TypeError):
+                    # We might send in some invalid input accidentally.
+                    # Ignore those inputs.
+                    break
+
+            # Only add this row if the for loop quit without break.
+            else:
+                # Convert to milliseconds
+                row = [(mean * 1000, stddev * 1000) for mean, stddev in row]
+                # Make the lowest value bold.
+                min_indx = min(enumerate(row), key=lambda x: x[1])[0]
+                row = ["{:.3f} ± {:.3f}".format(*x) for x in row]
+                row[min_indx] = self.bold(row[min_indx])
+                table.add_row(value_label, *row)
+
+        # Show the results in a table.
+        print(str(table))
+        print()
+
+    @staticmethod
+    def mean(x):
+        return math.fsum(x) / len(x)
+
+    @staticmethod
+    def stddev(x):
+        mean = Timer.mean(x)
+        sum_of_squares = math.fsum((v - mean) ** 2 for v in x)
+        return math.sqrt(sum_of_squares / (len(x) - 1))
+
+    @staticmethod
+    def bold(x):
+        return "**{}**".format(x)
+
+    def _timeit(self, call, setup, repeat=5):
+        """Perform the actual timing and return a formatted string of the runtime"""
+        result = timeit.repeat(call, setup, number=100000, repeat=repeat)
+        return self.mean(result), self.stddev(result)
+
+
+class Table(list):
+    """List of strings that can be made into a Markdown table."""
+
+    def add_row(self, *elements):
+        self.append(list(elements))
+
+    def add_header(self, *elements):
+        self.add_row(*elements)
+
+    def __str__(self):
+        header = copy.deepcopy(self[0])
+        rows = copy.deepcopy(self[1:])
+
+        # We want to center each number on the ± character.
+        # To do this, we have to partition each element on that character,
+        # find the longest vales in each column, then pad so that all in the
+        # column match that, then replace in the column.
+        for i in range(1, len(rows[0])):
+            column = [row[i] for row in rows]
+            partitioned_column = [x.partition("±") for x in column]
+            left_max = len(max(partitioned_column, key=lambda x: len(x[0]))[0])
+            right_max = len(max(partitioned_column, key=lambda x: len(x[2]))[2])
+            column = [
+                (x[0].rjust(left_max), x[1], x[2].ljust(right_max))
+                for x in partitioned_column
+            ]
+            for j, elem in enumerate(column):
+                rows[j][i] = "".join(elem)
+
+        # Now, we need to include the headers and pad each column.
+        # We will pad left headers right for rows.
+        for i in range(len(header)):
+            longest = len(max([header[i], *[x[i] for x in rows]], key=len))
+            header[i] = header[i].ljust(longest)
+            for j, row in enumerate(rows):
+                rows[j][i] = row[i].rjust(longest)
+
+        # Finally, add the header/row spacer
+        spacer = ["-" * (len(x) - 1) + ":" for x in header]
+
+        # Format!
+        out = [("| " + " | ".join(x) + " |") for x in [header, spacer, *rows]]
+        return "\n".join(out)
+
+
+def int_re(x, int_match=re.compile(r"[-+]?\d+$").match):
+    """Function to simulate fast_int but with regular expressions."""
+    try:
+        if int_match(x):
+            return int(x)
+        else:
+            return x
+    except TypeError:
+        return int(x)
+
+
+def int_try(x):
+    """Function to simulate fast_int but with try/except."""
+    try:
+        return int(x)
+    except ValueError:
+        return x
+
+
+def float_re(x, float_match=re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$").match):
+    """Function to simulate fast_float but with regular expressions."""
+    try:
+        if float_match(x):
+            return float(x)
+        else:
+            return x
+    except TypeError:
+        return float(x)
+
+
+def float_try(x):
+    """Function to simulate fast_float but with try/except."""
+    try:
+        return float(x)
+    except ValueError:
+        return x
+
+
+def real_re(
+    x,
+    int_match=re.compile(r"[-+]?\d+$").match,
+    real_match=re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$").match,
+):
+    """Function to simulate fast_real but with regular expressions."""
+    try:
+        if int_match(x):
+            return int(x)
+        elif real_match(x):
+            return float(x)
+        else:
+            return x
+    except TypeError:
+        if type(x) in (float, int):
+            return x
+        else:
+            raise TypeError
+
+
+def real_try(x):
+    """Function to simulate fast_real but with try/except."""
+    try:
+        a = float(x)
+    except ValueError:
+        return x
+    else:
+        b = int(a)
+        return b if a == b else b
+
+
+def forceint_re(
+    x,
+    int_match=re.compile(r"[-+]\d+$").match,
+    float_match=re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$").match,
+):
+    """Function to simulate fast_forceint but with regular expressions."""
+    try:
+        if int_match(x):
+            return int(x)
+        elif float_match(x):
+            return int(float(x))
+        else:
+            return x
+    except TypeError:
+        return int(x)
+
+
+def forceint_try(x):
+    """Function to simulate fast_forceint but with try/except."""
+    try:
+        return int(x)
+    except ValueError:
+        try:
+            return int(float(x))
+        except ValueError:
+            return x
+
+
+def check_int_re(x, int_match=re.compile(r"[-+]?\d+$").match):
+    """Function to simulate check_int but with regular expressions."""
+    t = type(x)
+    return t == int if t in (float, int) else bool(int_match(x))
+
+
+def check_int_try(x):
+    """Function to simulate check_int but with try/except."""
+    try:
+        int(x)
+    except ValueError:
+        return False
+    else:
+        return type(x) != float
+
+
+def check_float_re(
+    x, float_match=re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$").match
+):
+    """Function to simulate check_float but with regular expressions."""
+    t = type(x)
+    return t == float if t in (float, int) else bool(float_match(x))
+
+
+def check_float_try(x):
+    """Function to simulate check_float but with try/except."""
+    try:
+        float(x)
+    except ValueError:
+        return False
+    else:
+        return type(x) != int
+
+
+def check_real_re(x, real_match=re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$").match):
+    """Function to simulate check_real but with regular expressions."""
+    return type(x) in (float, int) or bool(real_match(x))
+
+
+def check_real_try(x):
+    """Function to simulate check_real but with try/except."""
+    try:
+        float(x)
+    except ValueError:
+        return False
+    else:
+        return True
+
+
+def check_intlike_re(
+    x,
+    int_match=re.compile(r"[-+]?\d+$").match,
+    float_match=re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$").match,
+):
+    """Function to simulate check_intlike but with regular expressions."""
+    try:
+        if int_match(x):
+            return True
+        elif float_match(x):
+            return float(x).is_integer()
+        else:
+            return False
+    except TypeError:
+        return int(x) == x
+
+
+def check_intlike_try(x):
+    """Function to simulate check_intlike but with try/except."""
+    try:
+        a = int(x)
+    except ValueError:
+        try:
+            a = float(x)
+        except ValueError:
+            return False
+        else:
+            return a.is_integer()
+    else:
+        return a == float(x)
+
+
+print(sys.version_info)
+print()
+
+timer = Timer("Timing comparison of `int` functions")
+timer.add_function("int", "builtin")
+timer.add_function("int", "fastnumbers", "from fastnumbers import int")
+timer.time_functions(repeat=100)
+
+timer = Timer("Timing comparison of `float` functions")
+timer.add_function("float", "builtin")
+timer.add_function("float", "fastnumbers", "from fastnumbers import float")
+timer.time_functions(repeat=100)
+
+timer = Timer("Timing comparison of `int` functions with error handling")
+timer.add_function("int_try", "try/except", "from __main__ import int_try")
+timer.add_function("int_re", "regex", "from __main__ import int_re")
+timer.add_function("try_int", "fastnumbers", "from fastnumbers import try_int")
+timer.time_functions()
+
+timer = Timer("Timing comparison of `float` functions with error handling")
+timer.add_function("float_try", "try/except", "from __main__ import float_try")
+timer.add_function("float_re", "regex", "from __main__ import float_re")
+timer.add_function("try_float", "fastnumbers", "from fastnumbers import try_float")
+timer.time_functions()
+
+timer = Timer(
+    "Timing comparison of `float` (but coerce to `int` if possible) "
+    "functions with error handling"
+)
+timer.add_function("real_try", "try/except", "from __main__ import real_try")
+timer.add_function("real_re", "regex", "from __main__ import real_re")
+timer.add_function("try_real", "fastnumbers", "from fastnumbers import try_real")
+timer.time_functions()
+
+timer = Timer("Timing comparison of forced `int` functions with error handling")
+timer.add_function("forceint_try", "try/except", "from __main__ import forceint_try")
+timer.add_function("forceint_re", "regex", "from __main__ import forceint_re")
+timer.add_function(
+    "try_forceint", "fastnumbers", "from fastnumbers import try_forceint"
+)
+timer.time_functions()
+
+timer = Timer("Timing comparison to check if value can be converted to `int`")
+timer.add_function("check_int_try", "try/except", "from __main__ import check_int_try")
+timer.add_function("check_int_re", "regex", "from __main__ import check_int_re")
+timer.add_function("check_int", "fastnumbers", "from fastnumbers import check_int")
+timer.time_functions()
+
+timer = Timer("Timing comparison to check if value can be converted to `float`")
+timer.add_function(
+    "check_float_try", "try/except", "from __main__ import check_float_try"
+)
+timer.add_function("check_float_re", "regex", "from __main__ import check_float_re")
+timer.add_function("check_float", "fastnumbers", "from fastnumbers import check_float")
+timer.time_functions()
+
+timer = Timer(
+    "Timing comparison to check if value can be converted to `float` or `int`"
+)
+timer.add_function(
+    "check_real_try", "try/except", "from __main__ import check_real_try"
+)
+timer.add_function("check_real_re", "regex", "from __main__ import check_real_re")
+timer.add_function("check_real", "fastnumbers", "from fastnumbers import check_real")
+timer.time_functions()
+
+timer = Timer("Timing comparison to check if value can be coerced losslessly to `int`")
+timer.add_function(
+    "check_intlike_try", "try/except", "from __main__ import check_intlike_try"
+)
+timer.add_function("check_intlike_re", "regex", "from __main__ import check_intlike_re")
+timer.add_function(
+    "check_intlike", "fastnumbers", "from fastnumbers import check_intlike"
+)
+timer.time_functions()
diff --git a/profiling/results-3.10.md b/profiling/results-3.10.md
new file mode 100644
index 00000000..3bec6a10
--- /dev/null
+++ b/profiling/results-3.10.md
@@ -0,0 +1,147 @@
+sys.version_info(major=3, minor=10, micro=6, releaselevel='final', serial=0)
+
+### Timing comparison of `int` functions
+
+| Input type        | builtin (ms)       | fastnumbers (ms)  |
+| ----------------: | -----------------: | ----------------: |
+|  Small Int String |    9.631 ± 0.476   | **7.466 ± 0.151** |
+|        Int String |   10.730 ± 0.715   | **9.469 ± 0.185** |
+| Medium Int String |   11.573 ± 0.726   | **9.414 ± 0.098** |
+|  Large Int String | **16.108 ± 0.168** |  18.211 ± 0.764   |
+|               Int |  **5.848 ± 0.814** |   6.317 ± 0.146   |
+|             Float | **15.029 ± 0.244** |  19.011 ± 0.175   |
+
+### Timing comparison of `float` functions
+
+| Input type         | builtin (ms)      | fastnumbers (ms)   |
+| -----------------: | ----------------: | -----------------: |
+|   Small Int String | **8.512 ± 0.565** |    9.487 ± 0.746   |
+|         Int String | **9.216 ± 0.227** |    9.715 ± 0.150   |
+|  Medium Int String |  10.486 ± 0.162   | **10.028 ± 0.087** |
+|   Large Int String |  28.977 ± 1.327   | **14.435 ± 0.182** |
+| Small Float String | **8.719 ± 0.304** |    9.946 ± 0.652   |
+|       Float String |  26.140 ± 0.447   | **11.401 ± 0.158** |
+| Large Float String |  52.146 ± 1.277   | **12.464 ± 0.450** |
+|                Int | **4.869 ± 0.045** |    9.016 ± 0.121   |
+|              Float | **4.060 ± 0.064** |    6.736 ± 0.116   |
+
+### Timing comparison of `int` functions with error handling
+
+| Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | -----------------: | -------------: | -----------------: |
+|  Non-number String |   85.344 ± 0.324   | 21.042 ± 0.058 |  **8.462 ± 0.064** |
+|   Small Int String |   13.659 ± 0.133   | 32.744 ± 0.028 |  **8.008 ± 0.069** |
+|         Int String |   14.435 ± 0.082   | 35.465 ± 0.517 | **10.396 ± 0.011** |
+|  Medium Int String |   16.305 ± 0.124   | 39.316 ± 0.349 | **10.792 ± 0.009** |
+|   Large Int String | **21.066 ± 0.370** | 53.589 ± 0.056 |   21.727 ± 3.613   |
+| Small Float String |   81.628 ± 1.191   | 23.037 ± 0.342 |  **8.465 ± 0.028** |
+|       Float String |   85.498 ± 1.389   | 29.598 ± 1.407 |  **8.565 ± 0.055** |
+| Large Float String |   92.305 ± 1.269   | 30.355 ± 0.530 |  **8.893 ± 0.391** |
+|                Int |   10.079 ± 0.025   | 50.395 ± 0.765 |  **7.146 ± 0.047** |
+|              Float | **19.626 ± 0.023** | 62.877 ± 0.125 |   20.773 ± 0.013   |
+
+### Timing comparison of `float` functions with error handling
+
+| Input type         | try/except (ms)   | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | ----------------: | -------------: | -----------------: |
+|  Non-number String |  46.551 ± 0.177   | 23.013 ± 0.023 |  **9.349 ± 0.068** |
+|   Small Int String |  12.582 ± 0.061   | 38.585 ± 0.595 | **11.144 ± 0.011** |
+|         Int String |  13.822 ± 0.035   | 41.978 ± 0.010 | **11.210 ± 0.163** |
+|  Medium Int String |  14.820 ± 0.055   | 46.409 ± 1.863 | **12.355 ± 0.029** |
+|   Large Int String |  35.615 ± 0.499   | 80.730 ± 0.087 | **16.538 ± 0.267** |
+| Small Float String |  12.924 ± 0.055   | 37.369 ± 0.009 | **12.769 ± 1.701** |
+|       Float String |  32.907 ± 0.044   | 67.682 ± 0.014 | **13.143 ± 0.180** |
+| Large Float String |  57.393 ± 0.025   | 96.052 ± 1.335 | **13.343 ± 0.210** |
+|                Int | **8.501 ± 0.028** | 47.501 ± 0.041 |    9.819 ± 0.012   |
+|              Float |   7.616 ± 0.048   | 48.687 ± 0.032 |  **7.495 ± 0.045** |
+
+### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | --------------: | ---------------: | -----------------: |
+|  Non-number String |  49.292 ± 0.277 |  40.196 ± 0.057  | **10.436 ± 0.016** |
+|   Small Int String |  22.239 ± 0.079 |  32.782 ± 0.008  |  **9.033 ± 0.141** |
+|         Int String |  24.193 ± 0.035 |  35.432 ± 0.415  | **11.396 ± 0.014** |
+|  Medium Int String |  29.025 ± 0.485 |  40.538 ± 0.004  | **12.157 ± 0.175** |
+|   Large Int String |  55.918 ± 0.015 |  54.337 ± 0.829  | **21.736 ± 0.303** |
+| Small Float String |  22.084 ± 0.012 |  70.081 ± 27.353 | **13.924 ± 0.219** |
+|       Float String |  64.979 ± 2.653 |  94.541 ± 1.321  | **20.525 ± 0.792** |
+| Large Float String | 119.572 ± 1.793 | 119.674 ± 1.644  | **38.955 ± 0.608** |
+|                Int |  17.547 ± 0.044 |  53.594 ± 0.180  |  **7.856 ± 0.040** |
+|              Float |  39.578 ± 0.455 |  52.933 ± 0.403  | **21.245 ± 0.006** |
+
+### Timing comparison of forced `int` functions with error handling
+
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |  131.969 ± 4.728   |  40.198 ± 0.045 |  **9.259 ± 0.022** |
+|   Small Int String |   13.700 ± 0.056   |  32.389 ± 0.023 |  **8.463 ± 0.036** |
+|         Int String |   14.463 ± 0.017   |  34.942 ± 0.016 | **10.750 ± 0.009** |
+|  Medium Int String |   16.435 ± 1.151   |  68.008 ± 0.225 | **11.229 ± 0.028** |
+|   Large Int String | **20.243 ± 0.333** | 104.271 ± 1.515 |   20.524 ± 0.025   |
+| Small Float String |   93.431 ± 1.688   |  60.968 ± 0.875 | **10.232 ± 0.045** |
+|       Float String |  133.335 ± 0.825   | 105.494 ± 0.415 | **18.650 ± 0.035** |
+| Large Float String |  178.613 ± 1.096   | 150.346 ± 0.090 | **37.636 ± 0.393** |
+|                Int |    9.432 ± 0.057   |  48.779 ± 0.914 |  **6.880 ± 0.031** |
+|              Float | **19.774 ± 0.014** |  61.374 ± 2.030 |   20.468 ± 0.007   |
+
+### Timing comparison to check if value can be converted to `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  87.819 ± 1.736 | 29.586 ± 0.033 | **6.703 ± 0.042** |
+|   Small Int String |  17.920 ± 0.055 | 33.269 ± 0.734 | **6.654 ± 0.046** |
+|         Int String |  18.503 ± 0.069 | 35.133 ± 0.745 | **6.787 ± 0.046** |
+|  Medium Int String |  20.077 ± 0.273 | 38.332 ± 0.844 | **6.925 ± 0.061** |
+|   Large Int String |  25.034 ± 0.058 | 46.740 ± 0.057 | **7.142 ± 0.422** |
+| Small Float String |  79.564 ± 0.348 | 32.218 ± 0.197 | **7.447 ± 0.051** |
+|       Float String |  87.389 ± 0.101 | 37.024 ± 0.760 | **8.206 ± 0.138** |
+| Large Float String |  87.220 ± 0.083 | 36.735 ± 0.600 | **8.338 ± 0.084** |
+|                Int |  13.964 ± 0.067 | 14.274 ± 0.071 | **5.943 ± 0.028** |
+|              Float |  25.229 ± 0.285 | 13.705 ± 0.090 | **5.978 ± 0.051** |
+
+### Timing comparison to check if value can be converted to `float`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  47.741 ± 0.184 | 32.281 ± 0.031 | **7.339 ± 0.041** |
+|   Small Int String |  16.903 ± 0.040 | 43.378 ± 3.023 | **7.731 ± 0.066** |
+|         Int String |  18.479 ± 0.126 | 42.753 ± 0.968 | **7.633 ± 0.045** |
+|  Medium Int String |  19.209 ± 0.075 | 45.565 ± 0.737 | **7.673 ± 0.065** |
+|   Large Int String |  38.828 ± 0.008 | 54.346 ± 0.360 | **7.800 ± 0.081** |
+| Small Float String |  17.452 ± 0.005 | 39.007 ± 0.104 | **8.183 ± 0.034** |
+|       Float String |  36.508 ± 0.092 | 47.560 ± 0.502 | **8.872 ± 0.068** |
+| Large Float String |  62.730 ± 1.024 | 51.882 ± 0.086 | **9.196 ± 0.044** |
+|                Int |  12.689 ± 0.060 | 15.186 ± 0.088 | **6.705 ± 0.064** |
+|              Float |  12.019 ± 0.038 | 13.328 ± 0.113 | **6.424 ± 0.049** |
+
+### Timing comparison to check if value can be converted to `float` or `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  48.080 ± 0.422 | 32.689 ± 1.053 | **7.041 ± 0.053** |
+|   Small Int String |  12.951 ± 0.034 | 40.364 ± 0.285 | **7.305 ± 0.086** |
+|         Int String |  13.770 ± 0.049 | 41.131 ± 0.339 | **7.493 ± 0.052** |
+|  Medium Int String |  15.908 ± 0.397 | 45.402 ± 0.072 | **7.514 ± 0.165** |
+|   Large Int String |  34.728 ± 0.014 | 54.111 ± 1.112 | **7.417 ± 0.043** |
+| Small Float String |  13.397 ± 0.075 | 40.625 ± 2.437 | **8.128 ± 0.029** |
+|       Float String |  33.328 ± 0.035 | 48.178 ± 0.106 | **8.650 ± 0.069** |
+| Large Float String |  57.835 ± 0.006 | 50.262 ± 0.825 | **8.971 ± 0.081** |
+|                Int |   8.984 ± 0.138 | 12.015 ± 0.071 | **6.262 ± 0.018** |
+|              Float |   8.120 ± 0.025 | 10.986 ± 0.090 | **6.274 ± 0.011** |
+
+### Timing comparison to check if value can be coerced losslessly to `int`
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
+| -----------------: | --------------: | --------------: | ----------------: |
+|  Non-number String | 128.786 ± 1.799 |  40.152 ± 0.192 | **6.491 ± 0.060** |
+|   Small Int String |  24.634 ± 0.015 |  23.478 ± 0.017 | **6.424 ± 0.071** |
+|         Int String |  26.103 ± 0.372 |  25.953 ± 0.007 | **6.804 ± 0.094** |
+|  Medium Int String |  32.231 ± 0.017 |  28.397 ± 0.294 | **6.765 ± 0.052** |
+|   Large Int String |  63.351 ± 0.089 |  37.483 ± 0.480 | **6.728 ± 0.077** |
+| Small Float String |  99.912 ± 1.287 |  61.313 ± 0.828 | **7.505 ± 0.066** |
+|       Float String | 129.121 ± 3.041 |  97.321 ± 1.135 | **7.921 ± 0.048** |
+| Large Float String | 157.302 ± 0.920 | 126.913 ± 2.508 | **7.991 ± 0.068** |
+|                Int |  16.014 ± 0.067 |  51.582 ± 0.022 | **5.632 ± 0.030** |
+|              Float |  39.637 ± 0.012 |  81.462 ± 1.585 | **5.930 ± 0.087** |
+
diff --git a/profiling/results-3.7.md b/profiling/results-3.7.md
new file mode 100644
index 00000000..d4687040
--- /dev/null
+++ b/profiling/results-3.7.md
@@ -0,0 +1,147 @@
+sys.version_info(major=3, minor=7, micro=9, releaselevel='final', serial=0)
+
+### Timing comparison of `int` functions
+
+| Input type        | builtin (ms)       | fastnumbers (ms)   |
+| ----------------: | -----------------: | -----------------: |
+|  Small Int String |   14.186 ± 0.248   |  **7.790 ± 0.138** |
+|        Int String |   15.145 ± 0.093   | **10.171 ± 0.949** |
+| Medium Int String |   17.014 ± 0.271   | **10.367 ± 0.075** |
+|  Large Int String |   22.850 ± 0.070   | **21.071 ± 0.489** |
+|               Int |    9.258 ± 0.097   |  **6.889 ± 0.079** |
+|             Float | **19.593 ± 0.538** |   20.350 ± 0.188   |
+
+### Timing comparison of `float` functions
+
+| Input type         | builtin (ms)      | fastnumbers (ms)   |
+| -----------------: | ----------------: | -----------------: |
+|   Small Int String |  11.829 ± 0.092   |  **9.585 ± 0.090** |
+|         Int String |  12.384 ± 0.560   |  **9.919 ± 0.055** |
+|  Medium Int String |  13.359 ± 0.051   | **10.308 ± 0.167** |
+|   Large Int String |  35.909 ± 7.434   | **14.476 ± 0.049** |
+| Small Float String |  12.384 ± 1.176   | **10.130 ± 0.288** |
+|       Float String |  29.721 ± 0.108   | **11.757 ± 1.495** |
+| Large Float String |  52.927 ± 1.115   | **11.749 ± 0.270** |
+|                Int | **8.040 ± 0.050** |    8.839 ± 0.059   |
+|              Float |   7.213 ± 0.050   |  **6.478 ± 0.057** |
+
+### Timing comparison of `int` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 110.521 ± 4.610 | 26.948 ± 0.390  |  **8.470 ± 0.075** |
+|   Small Int String |  21.906 ± 0.020 | 58.548 ± 18.708 |  **8.206 ± 0.112** |
+|         Int String |  23.084 ± 0.262 | 49.424 ± 0.111  | **10.597 ± 0.018** |
+|  Medium Int String |  24.732 ± 0.006 | 55.776 ± 0.613  | **10.813 ± 0.020** |
+|   Large Int String |  31.168 ± 0.815 | 72.905 ± 0.123  | **21.539 ± 0.025** |
+| Small Float String | 105.259 ± 0.415 | 30.295 ± 0.486  |  **8.417 ± 0.052** |
+|       Float String | 111.828 ± 0.983 | 35.278 ± 0.008  |  **8.912 ± 0.101** |
+| Large Float String | 116.722 ± 0.523 | 35.528 ± 0.360  |  **8.799 ± 0.067** |
+|                Int |  16.463 ± 0.013 | 76.058 ± 0.876  |  **7.137 ± 0.052** |
+|              Float |  30.025 ± 4.226 | 87.508 ± 0.943  | **20.979 ± 0.163** |
+
+### Timing comparison of `float` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  66.865 ± 0.461 |  30.442 ± 0.187 |  **9.101 ± 0.080** |
+|   Small Int String |  19.368 ± 0.006 |  52.993 ± 0.540 | **10.617 ± 0.009** |
+|         Int String |  19.996 ± 0.050 |  55.830 ± 0.218 | **10.883 ± 0.016** |
+|  Medium Int String |  21.070 ± 0.004 |  61.365 ± 0.508 | **11.307 ± 0.006** |
+|   Large Int String |  44.510 ± 6.144 |  94.440 ± 0.840 | **15.548 ± 0.010** |
+| Small Float String |  19.962 ± 0.537 |  52.069 ± 0.312 | **11.073 ± 0.007** |
+|       Float String |  37.684 ± 0.143 |  83.942 ± 0.360 | **12.632 ± 0.009** |
+| Large Float String |  60.153 ± 0.499 | 112.514 ± 3.484 | **12.790 ± 0.009** |
+|                Int |  14.964 ± 0.146 |  74.737 ± 0.715 |  **9.822 ± 0.119** |
+|              Float |  14.010 ± 0.011 |  74.387 ± 0.300 |  **7.404 ± 0.053** |
+
+### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  67.302 ± 1.119 |  50.590 ± 0.267 |  **9.738 ± 0.094** |
+|   Small Int String |  39.310 ± 0.044 |  46.318 ± 0.174 |  **9.477 ± 0.915** |
+|         Int String |  41.514 ± 0.088 |  49.650 ± 0.281 | **11.634 ± 0.015** |
+|  Medium Int String |  44.871 ± 0.092 |  56.371 ± 1.757 | **12.027 ± 0.009** |
+|   Large Int String |  74.584 ± 1.467 |  73.177 ± 0.378 | **22.698 ± 0.013** |
+| Small Float String |  40.815 ± 1.699 |  75.774 ± 0.180 | **12.140 ± 0.014** |
+|       Float String |  73.566 ± 2.522 | 112.994 ± 1.238 | **18.685 ± 0.013** |
+| Large Float String | 128.552 ± 0.897 | 139.712 ± 0.302 | **38.582 ± 0.709** |
+|                Int |  36.251 ± 0.242 |  81.588 ± 0.369 |  **7.689 ± 0.215** |
+|              Float |  56.887 ± 0.391 |  76.445 ± 0.460 | **23.644 ± 4.198** |
+
+### Timing comparison of forced `int` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 186.441 ± 2.084 |  49.671 ± 0.291 |  **9.270 ± 0.033** |
+|   Small Int String |  21.701 ± 0.066 |  46.545 ± 2.056 |  **8.551 ± 0.195** |
+|         Int String |  22.808 ± 0.022 |  48.340 ± 0.021 | **11.144 ± 0.019** |
+|  Medium Int String |  24.827 ± 0.008 |  91.899 ± 0.621 | **11.533 ± 0.118** |
+|   Large Int String |  30.876 ± 0.246 | 130.498 ± 2.043 | **22.536 ± 0.193** |
+| Small Float String | 134.801 ± 1.360 |  84.207 ± 0.394 | **14.178 ± 0.289** |
+|       Float String | 166.256 ± 1.710 | 129.991 ± 2.359 | **18.363 ± 0.759** |
+| Large Float String | 216.890 ± 6.090 | 171.889 ± 0.626 | **40.946 ± 1.459** |
+|                Int |  17.872 ± 1.052 |  77.692 ± 1.847 |  **7.078 ± 0.066** |
+|              Float |  27.031 ± 0.014 |  90.800 ± 4.886 | **21.339 ± 0.934** |
+
+### Timing comparison to check if value can be converted to `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String | 110.722 ± 4.893 | 52.946 ± 4.146 | **7.081 ± 0.057** |
+|   Small Int String |  35.604 ± 0.457 | 55.293 ± 0.835 | **6.858 ± 0.013** |
+|         Int String |  33.660 ± 0.106 | 57.756 ± 0.458 | **7.178 ± 0.059** |
+|  Medium Int String |  36.716 ± 1.376 | 61.818 ± 0.250 | **7.143 ± 0.039** |
+|   Large Int String |  41.543 ± 0.027 | 73.656 ± 0.619 | **7.100 ± 0.039** |
+| Small Float String | 108.112 ± 7.347 | 57.282 ± 5.071 | **7.853 ± 0.033** |
+|       Float String | 112.621 ± 1.406 | 60.651 ± 0.174 | **8.693 ± 0.402** |
+| Large Float String | 114.817 ± 0.649 | 60.503 ± 0.025 | **8.490 ± 0.029** |
+|                Int |  29.711 ± 0.878 | 26.859 ± 0.007 | **5.636 ± 0.035** |
+|              Float |  37.428 ± 0.002 | 25.901 ± 0.005 | **5.869 ± 0.106** |
+
+### Timing comparison to check if value can be converted to `float`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  67.044 ± 0.672 | 57.037 ± 1.025 | **7.706 ± 0.088** |
+|   Small Int String |  31.891 ± 2.469 | 63.985 ± 0.052 | **7.656 ± 0.069** |
+|         Int String |  31.273 ± 0.168 | 67.491 ± 2.249 | **8.021 ± 0.076** |
+|  Medium Int String |  32.441 ± 0.201 | 70.825 ± 0.157 | **7.970 ± 0.085** |
+|   Large Int String |  54.262 ± 1.786 | 83.828 ± 3.105 | **7.957 ± 0.107** |
+| Small Float String |  32.761 ± 2.163 | 63.740 ± 1.771 | **8.531 ± 0.117** |
+|       Float String |  49.362 ± 0.205 | 78.911 ± 3.808 | **9.646 ± 0.094** |
+| Large Float String |  74.955 ± 1.046 | 83.865 ± 0.606 | **9.300 ± 0.067** |
+|                Int |  25.516 ± 0.026 | 27.316 ± 0.006 | **6.570 ± 0.034** |
+|              Float |  25.998 ± 1.748 | 24.980 ± 0.011 | **6.590 ± 0.035** |
+
+### Timing comparison to check if value can be converted to `float` or `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  68.250 ± 3.584 | 56.598 ± 0.598 | **7.879 ± 0.277** |
+|   Small Int String |  20.913 ± 0.144 | 66.921 ± 0.993 | **7.716 ± 0.154** |
+|         Int String |  21.603 ± 0.111 | 66.744 ± 1.185 | **7.686 ± 0.067** |
+|  Medium Int String |  21.906 ± 0.143 | 71.929 ± 4.001 | **7.738 ± 0.087** |
+|   Large Int String |  42.685 ± 0.250 | 81.850 ± 0.396 | **7.988 ± 0.690** |
+| Small Float String |  20.428 ± 0.009 | 62.688 ± 0.986 | **8.355 ± 0.066** |
+|       Float String |  38.531 ± 0.317 | 75.633 ± 0.834 | **9.036 ± 0.041** |
+| Large Float String |  60.694 ± 0.158 | 78.825 ± 0.086 | **9.165 ± 0.216** |
+|                Int |  15.534 ± 0.002 | 23.422 ± 0.387 | **6.315 ± 0.049** |
+|              Float |  14.630 ± 0.008 | 21.430 ± 0.006 | **6.582 ± 0.179** |
+
+### Timing comparison to check if value can be coerced losslessly to `int`
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
+| -----------------: | --------------: | --------------: | ----------------: |
+|  Non-number String | 179.668 ± 2.145 |  50.616 ± 0.128 | **6.854 ± 0.070** |
+|   Small Int String |  40.662 ± 0.187 |  30.886 ± 0.039 | **6.755 ± 0.135** |
+|         Int String |  42.547 ± 0.445 |  33.349 ± 0.192 | **7.145 ± 0.180** |
+|  Medium Int String |  47.565 ± 0.070 |  37.261 ± 0.006 | **6.961 ± 0.039** |
+|   Large Int String |  80.071 ± 0.384 |  48.726 ± 0.007 | **7.057 ± 0.211** |
+| Small Float String | 129.395 ± 1.054 |  80.865 ± 1.709 | **7.623 ± 0.058** |
+|       Float String | 155.662 ± 0.427 | 118.904 ± 4.248 | **8.321 ± 0.059** |
+| Large Float String | 182.865 ± 2.367 | 145.046 ± 0.389 | **8.311 ± 0.055** |
+|                Int |  31.019 ± 0.013 |  77.993 ± 0.663 | **5.584 ± 0.058** |
+|              Float |  53.975 ± 0.266 | 105.516 ± 0.273 | **5.722 ± 0.064** |
+
diff --git a/profiling/results-3.8.md b/profiling/results-3.8.md
new file mode 100644
index 00000000..6360b540
--- /dev/null
+++ b/profiling/results-3.8.md
@@ -0,0 +1,147 @@
+sys.version_info(major=3, minor=8, micro=7, releaselevel='final', serial=0)
+
+### Timing comparison of `int` functions
+
+| Input type        | builtin (ms)       | fastnumbers (ms)   |
+| ----------------: | -----------------: | -----------------: |
+|  Small Int String |   12.730 ± 0.184   |  **7.454 ± 0.066** |
+|        Int String |   13.343 ± 0.093   |  **9.933 ± 0.047** |
+| Medium Int String |   14.755 ± 1.501   | **10.131 ± 0.065** |
+|  Large Int String | **18.180 ± 0.070** |   18.253 ± 0.962   |
+|               Int |    7.435 ± 0.244   |  **6.172 ± 0.041** |
+|             Float | **17.668 ± 0.053** |   21.402 ± 2.892   |
+
+### Timing comparison of `float` functions
+
+| Input type         | builtin (ms)      | fastnumbers (ms)   |
+| -----------------: | ----------------: | -----------------: |
+|   Small Int String |  12.128 ± 0.628   |  **9.800 ± 0.203** |
+|         Int String |  12.717 ± 0.103   | **10.155 ± 0.549** |
+|  Medium Int String |  14.058 ± 0.113   | **10.416 ± 0.053** |
+|   Large Int String |  33.896 ± 0.956   | **14.643 ± 0.543** |
+| Small Float String |  12.857 ± 0.043   | **10.499 ± 0.181** |
+|       Float String |  32.188 ± 0.592   | **12.598 ± 0.094** |
+| Large Float String |  55.475 ± 0.987   | **12.794 ± 0.592** |
+|                Int | **8.732 ± 0.155** |    9.620 ± 0.144   |
+|              Float |   7.481 ± 0.145   |  **6.676 ± 0.088** |
+
+### Timing comparison of `int` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 110.888 ± 2.108 | 26.199 ± 0.055  |  **8.889 ± 0.019** |
+|   Small Int String |  19.847 ± 0.024 | 45.566 ± 2.212  |  **8.633 ± 0.089** |
+|         Int String |  20.747 ± 0.009 | 47.540 ± 0.045  | **11.254 ± 0.149** |
+|  Medium Int String |  21.260 ± 0.096 | 51.947 ± 0.623  | **11.643 ± 0.007** |
+|   Large Int String |  26.181 ± 0.365 | 71.502 ± 1.341  | **20.053 ± 0.514** |
+| Small Float String | 111.405 ± 2.267 | 29.582 ± 0.007  |  **8.822 ± 0.011** |
+|       Float String | 112.832 ± 2.168 | 34.062 ± 0.007  |  **9.003 ± 0.014** |
+| Large Float String | 120.336 ± 2.375 | 34.637 ± 0.538  |  **8.982 ± 0.031** |
+|                Int |  13.266 ± 0.004 | 74.868 ± 12.544 | **12.489 ± 2.175** |
+|              Float |  29.298 ± 2.650 | 86.266 ± 2.120  | **23.768 ± 1.904** |
+
+### Timing comparison of `float` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  70.751 ± 8.698 |  30.179 ± 1.103 |  **9.367 ± 0.062** |
+|   Small Int String |  19.460 ± 0.042 |  53.537 ± 0.778 | **11.219 ± 0.033** |
+|         Int String |  19.576 ± 0.009 |  56.897 ± 0.923 | **11.829 ± 0.011** |
+|  Medium Int String |  21.582 ± 0.167 |  61.248 ± 0.890 | **12.174 ± 0.024** |
+|   Large Int String |  42.487 ± 0.683 |  97.267 ± 1.224 | **17.050 ± 0.015** |
+| Small Float String |  19.632 ± 0.322 |  51.714 ± 0.708 | **12.111 ± 0.008** |
+|       Float String |  39.262 ± 0.752 |  85.373 ± 1.487 | **13.693 ± 0.008** |
+| Large Float String |  62.573 ± 0.079 | 114.056 ± 1.649 | **13.478 ± 0.104** |
+|                Int |  14.332 ± 0.031 |  69.986 ± 3.002 | **10.713 ± 0.367** |
+|              Float |  13.464 ± 0.014 |  69.146 ± 0.062 |  **7.738 ± 0.004** |
+
+### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  66.106 ± 0.906 |  47.295 ± 0.829 | **10.245 ± 0.006** |
+|   Small Int String |  34.680 ± 0.054 |  44.154 ± 1.597 |  **9.482 ± 0.004** |
+|         Int String |  36.684 ± 0.595 |  47.816 ± 1.794 | **12.480 ± 0.500** |
+|  Medium Int String |  40.420 ± 0.601 |  54.676 ± 2.252 | **12.219 ± 0.011** |
+|   Large Int String |  71.460 ± 0.935 |  70.553 ± 2.034 | **21.439 ± 0.014** |
+| Small Float String |  34.389 ± 0.520 |  73.655 ± 1.037 | **13.372 ± 0.243** |
+|       Float String |  70.123 ± 1.163 | 112.252 ± 1.398 | **20.727 ± 0.393** |
+| Large Float String | 129.285 ± 1.095 | 140.052 ± 0.325 | **40.601 ± 0.085** |
+|                Int |  29.827 ± 0.519 |  74.714 ± 2.484 |  **7.556 ± 0.012** |
+|              Float |  51.868 ± 0.042 |  73.311 ± 0.451 | **22.674 ± 0.108** |
+
+### Timing comparison of forced `int` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | --------------: | ---------------: | -----------------: |
+|  Non-number String | 177.131 ± 2.119 |  48.813 ± 0.300  |  **9.375 ± 0.019** |
+|   Small Int String |  19.265 ± 0.006 |  44.503 ± 3.029  |  **8.922 ± 0.004** |
+|         Int String |  20.755 ± 0.005 |  49.112 ± 0.412  | **11.512 ± 0.106** |
+|  Medium Int String |  21.270 ± 0.096 |  89.518 ± 1.242  | **12.191 ± 0.050** |
+|   Large Int String |  26.013 ± 0.007 | 131.097 ± 9.542  | **20.358 ± 0.031** |
+| Small Float String | 129.235 ± 1.141 |  80.439 ± 2.077  | **14.826 ± 0.009** |
+|       Float String | 171.361 ± 3.261 | 151.193 ± 25.174 | **20.896 ± 0.185** |
+| Large Float String | 214.887 ± 4.584 | 177.821 ± 4.828  | **42.449 ± 4.578** |
+|                Int |  13.700 ± 0.005 |  69.204 ± 0.058  |  **7.183 ± 0.033** |
+|              Float |  25.247 ± 0.022 |  80.713 ± 1.155  | **22.774 ± 0.304** |
+
+### Timing comparison to check if value can be converted to `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String | 114.661 ± 1.215 | 49.919 ± 1.429 | **7.014 ± 0.053** |
+|   Small Int String |  29.961 ± 0.186 | 52.985 ± 2.409 | **7.122 ± 0.100** |
+|         Int String |  30.869 ± 0.052 | 55.649 ± 0.943 | **7.545 ± 0.047** |
+|  Medium Int String |  32.032 ± 0.238 | 60.471 ± 1.687 | **7.404 ± 0.157** |
+|   Large Int String |  36.726 ± 0.045 | 71.843 ± 1.947 | **7.385 ± 0.048** |
+| Small Float String | 109.212 ± 2.871 | 55.673 ± 1.208 | **8.436 ± 0.122** |
+|       Float String | 123.935 ± 1.338 | 61.109 ± 1.439 | **8.811 ± 0.017** |
+| Large Float String | 117.221 ± 1.827 | 60.288 ± 1.207 | **9.261 ± 0.047** |
+|                Int |  25.544 ± 0.054 | 24.007 ± 0.061 | **6.143 ± 0.020** |
+|              Float |  36.979 ± 0.134 | 22.762 ± 0.018 | **6.617 ± 0.090** |
+
+### Timing comparison to check if value can be converted to `float`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  70.067 ± 1.201 | 55.434 ± 1.117 | **8.225 ± 0.034** |
+|   Small Int String |  30.417 ± 0.013 | 61.630 ± 1.561 | **7.950 ± 0.051** |
+|         Int String |  30.453 ± 0.348 | 64.639 ± 2.905 | **8.275 ± 0.017** |
+|  Medium Int String |  32.233 ± 0.566 | 69.451 ± 1.637 | **8.626 ± 0.005** |
+|   Large Int String |  53.524 ± 0.890 | 80.674 ± 1.647 | **8.405 ± 0.133** |
+| Small Float String |  30.925 ± 0.056 | 60.978 ± 0.859 | **8.546 ± 0.020** |
+|       Float String |  52.656 ± 3.021 | 78.660 ± 1.274 | **9.716 ± 0.021** |
+| Large Float String |  76.718 ± 2.023 | 79.064 ± 2.076 | **9.798 ± 0.010** |
+|                Int |  24.224 ± 0.016 | 22.936 ± 0.008 | **6.507 ± 0.039** |
+|              Float |  24.162 ± 0.564 | 21.357 ± 0.043 | **6.761 ± 0.034** |
+
+### Timing comparison to check if value can be converted to `float` or `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  66.447 ± 0.292 | 52.414 ± 1.822 | **7.448 ± 0.030** |
+|   Small Int String |  19.648 ± 0.288 | 61.143 ± 0.632 | **7.618 ± 0.062** |
+|         Int String |  20.017 ± 0.007 | 66.307 ± 5.601 | **8.571 ± 0.809** |
+|  Medium Int String |  22.139 ± 0.053 | 69.420 ± 1.079 | **8.168 ± 0.067** |
+|   Large Int String |  43.621 ± 0.040 | 80.505 ± 1.017 | **7.761 ± 0.035** |
+| Small Float String |  19.807 ± 0.251 | 60.539 ± 1.596 | **8.196 ± 0.031** |
+|       Float String |  38.855 ± 0.097 | 74.068 ± 1.164 | **8.954 ± 0.094** |
+| Large Float String |  63.789 ± 1.272 | 78.092 ± 0.584 | **9.132 ± 0.077** |
+|                Int |  14.503 ± 0.031 | 19.901 ± 0.027 | **6.271 ± 0.016** |
+|              Float |  13.670 ± 0.237 | 18.868 ± 0.510 | **6.564 ± 0.012** |
+
+### Timing comparison to check if value can be coerced losslessly to `int`
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
+| -----------------: | --------------: | --------------: | ----------------: |
+|  Non-number String | 174.255 ± 3.376 |  47.925 ± 0.285 | **6.958 ± 0.030** |
+|   Small Int String |  38.187 ± 0.543 |  30.375 ± 0.008 | **6.796 ± 0.030** |
+|         Int String |  42.139 ± 3.555 |  33.888 ± 0.172 | **7.547 ± 0.036** |
+|  Medium Int String |  45.751 ± 0.138 |  37.241 ± 0.526 | **7.039 ± 0.065** |
+|   Large Int String |  76.780 ± 0.337 |  50.521 ± 0.785 | **6.943 ± 0.016** |
+| Small Float String | 131.403 ± 2.628 |  78.397 ± 1.509 | **7.772 ± 0.035** |
+|       Float String | 156.915 ± 2.271 | 118.703 ± 2.614 | **8.666 ± 0.023** |
+| Large Float String | 188.136 ± 3.973 | 148.394 ± 2.881 | **8.659 ± 0.050** |
+|                Int |  26.778 ± 0.045 |  69.914 ± 0.988 | **5.703 ± 0.026** |
+|              Float |  51.406 ± 0.266 |  97.251 ± 1.374 | **5.838 ± 0.020** |
+
diff --git a/profiling/results-3.9.md b/profiling/results-3.9.md
new file mode 100644
index 00000000..7ac5d57e
--- /dev/null
+++ b/profiling/results-3.9.md
@@ -0,0 +1,147 @@
+sys.version_info(major=3, minor=9, micro=1, releaselevel='final', serial=0)
+
+### Timing comparison of `int` functions
+
+| Input type        | builtin (ms)       | fastnumbers (ms)   |
+| ----------------: | -----------------: | -----------------: |
+|  Small Int String |   12.593 ± 0.248   |  **7.914 ± 0.441** |
+|        Int String |   13.992 ± 0.188   | **10.547 ± 0.130** |
+| Medium Int String |   16.081 ± 0.933   | **10.798 ± 0.156** |
+|  Large Int String |   20.625 ± 0.423   | **20.528 ± 0.482** |
+|               Int |    7.456 ± 0.086   |  **6.754 ± 0.101** |
+|             Float | **17.618 ± 0.245** |   20.509 ± 0.342   |
+
+### Timing comparison of `float` functions
+
+| Input type         | builtin (ms)      | fastnumbers (ms)   |
+| -----------------: | ----------------: | -----------------: |
+|   Small Int String |  12.346 ± 0.181   |  **9.970 ± 0.154** |
+|         Int String |  13.045 ± 0.369   | **10.372 ± 0.202** |
+|  Medium Int String |  14.447 ± 0.172   | **10.655 ± 0.165** |
+|   Large Int String |  34.842 ± 0.483   | **15.100 ± 0.127** |
+| Small Float String |  12.745 ± 0.199   | **10.717 ± 0.589** |
+|       Float String |  32.362 ± 0.544   | **12.314 ± 0.430** |
+| Large Float String |  55.314 ± 0.748   | **12.370 ± 0.131** |
+|                Int | **8.269 ± 0.468** |    9.181 ± 0.139   |
+|              Float |   7.166 ± 0.084   |  **6.925 ± 1.448** |
+
+### Timing comparison of `int` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String | 113.282 ± 2.178 | 28.338 ± 0.103 |  **8.585 ± 0.133** |
+|   Small Int String |  18.880 ± 0.010 | 49.447 ± 0.530 |  **8.270 ± 0.052** |
+|         Int String |  20.351 ± 0.763 | 53.191 ± 0.911 | **10.739 ± 0.015** |
+|  Medium Int String |  22.308 ± 1.526 | 59.030 ± 0.929 | **11.239 ± 0.164** |
+|   Large Int String |  26.523 ± 0.236 | 75.934 ± 0.082 | **20.858 ± 0.070** |
+| Small Float String | 101.350 ± 1.587 | 32.187 ± 0.499 |  **9.069 ± 0.014** |
+|       Float String | 123.328 ± 0.383 | 38.582 ± 0.300 |  **9.553 ± 0.022** |
+| Large Float String | 119.014 ± 1.791 | 36.978 ± 0.542 |  **9.031 ± 0.008** |
+|                Int |  13.046 ± 0.124 | 71.464 ± 3.671 |  **7.964 ± 0.517** |
+|              Float |  26.833 ± 0.331 | 82.255 ± 2.104 | **23.186 ± 0.193** |
+
+### Timing comparison of `float` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  63.457 ± 0.217 |  32.312 ± 0.097 |  **9.439 ± 0.039** |
+|   Small Int String |  18.933 ± 0.203 |  54.598 ± 3.398 | **11.018 ± 0.010** |
+|         Int String |  18.883 ± 0.006 |  56.796 ± 2.269 | **11.612 ± 0.010** |
+|  Medium Int String |  20.686 ± 0.031 |  61.178 ± 1.864 | **11.651 ± 0.006** |
+|   Large Int String |  41.133 ± 0.011 |  96.650 ± 3.003 | **16.260 ± 0.025** |
+| Small Float String |  18.666 ± 0.013 |  49.794 ± 0.746 | **12.010 ± 0.009** |
+|       Float String |  38.494 ± 0.561 |  86.937 ± 0.727 | **13.328 ± 0.217** |
+| Large Float String |  61.532 ± 0.015 | 115.315 ± 3.365 | **13.405 ± 0.060** |
+|                Int |  13.837 ± 0.026 |  65.023 ± 0.919 | **10.488 ± 0.015** |
+|              Float |  12.811 ± 0.255 |  67.340 ± 4.061 |  **9.297 ± 2.210** |
+
+### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  69.576 ± 8.552 |  48.195 ± 0.448 | **10.047 ± 0.012** |
+|   Small Int String |  33.381 ± 0.179 |  46.644 ± 0.130 |  **8.828 ± 0.051** |
+|         Int String |  34.312 ± 0.029 |  52.759 ± 0.572 | **12.017 ± 0.023** |
+|  Medium Int String |  47.312 ± 8.377 |  61.891 ± 1.043 | **12.847 ± 0.022** |
+|   Large Int String |  70.102 ± 0.612 |  76.042 ± 0.778 | **21.787 ± 0.072** |
+| Small Float String |  33.033 ± 0.027 |  74.887 ± 3.416 | **12.688 ± 0.010** |
+|       Float String |  70.756 ± 4.574 | 114.817 ± 1.407 | **19.573 ± 0.010** |
+| Large Float String | 126.242 ± 0.647 | 145.267 ± 3.663 | **40.787 ± 0.566** |
+|                Int |  28.990 ± 0.074 |  69.509 ± 0.643 |  **7.437 ± 0.017** |
+|              Float |  51.889 ± 0.062 |  67.726 ± 0.117 | **22.826 ± 0.082** |
+
+### Timing comparison of forced `int` functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 172.662 ± 2.171 |  46.588 ± 0.041 |  **9.413 ± 0.040** |
+|   Small Int String |  19.126 ± 0.338 |  46.695 ± 1.698 |  **8.909 ± 0.530** |
+|         Int String |  20.797 ± 0.238 |  50.297 ± 0.791 | **11.261 ± 0.009** |
+|  Medium Int String |  21.675 ± 0.157 |  89.442 ± 0.190 | **11.666 ± 0.012** |
+|   Large Int String |  26.574 ± 0.015 | 127.667 ± 0.937 | **21.386 ± 0.006** |
+| Small Float String | 125.611 ± 0.717 |  83.287 ± 4.168 | **14.638 ± 5.906** |
+|       Float String | 176.213 ± 6.931 | 131.219 ± 2.238 | **18.761 ± 0.009** |
+| Large Float String | 215.600 ± 4.576 | 175.560 ± 2.711 | **39.680 ± 0.434** |
+|                Int |  13.061 ± 0.027 |  66.012 ± 0.072 |  **7.223 ± 0.051** |
+|              Float |  23.827 ± 0.254 |  76.009 ± 0.825 | **23.477 ± 4.494** |
+
+### Timing comparison to check if value can be converted to `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String | 108.364 ± 1.407 | 43.367 ± 0.035 | **7.053 ± 0.040** |
+|   Small Int String |  26.890 ± 0.441 | 51.432 ± 2.656 | **7.471 ± 0.029** |
+|         Int String |  28.267 ± 0.522 | 52.019 ± 0.167 | **7.556 ± 0.060** |
+|  Medium Int String |  28.778 ± 0.069 | 54.932 ± 0.404 | **7.225 ± 0.046** |
+|   Large Int String |  33.605 ± 0.056 | 70.005 ± 2.097 | **7.319 ± 0.124** |
+| Small Float String | 101.619 ± 1.371 | 47.796 ± 0.775 | **8.112 ± 0.023** |
+|       Float String | 112.443 ± 1.773 | 52.576 ± 0.025 | **8.581 ± 0.020** |
+| Large Float String | 116.919 ± 0.845 | 54.079 ± 1.947 | **8.990 ± 0.048** |
+|                Int |  20.050 ± 0.365 | 21.579 ± 0.005 | **5.650 ± 0.027** |
+|              Float |  30.338 ± 0.020 | 20.427 ± 0.014 | **5.875 ± 0.037** |
+
+### Timing comparison to check if value can be converted to `float`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  62.413 ± 0.843 | 47.293 ± 0.042 | **7.975 ± 0.038** |
+|   Small Int String |  26.279 ± 0.005 | 57.323 ± 0.810 | **7.861 ± 0.026** |
+|         Int String |  26.804 ± 0.389 | 63.788 ± 3.379 | **8.652 ± 0.180** |
+|  Medium Int String |  28.135 ± 0.006 | 67.880 ± 2.493 | **8.369 ± 0.031** |
+|   Large Int String |  50.123 ± 0.725 | 77.206 ± 0.682 | **8.239 ± 0.033** |
+| Small Float String |  26.503 ± 0.380 | 56.502 ± 0.931 | **8.642 ± 0.068** |
+|       Float String |  47.032 ± 2.534 | 70.667 ± 0.914 | **9.228 ± 0.016** |
+| Large Float String |  69.682 ± 0.434 | 73.521 ± 0.039 | **9.291 ± 0.042** |
+|                Int |  20.431 ± 0.030 | 22.568 ± 0.372 | **6.595 ± 0.120** |
+|              Float |  19.404 ± 0.026 | 19.850 ± 0.003 | **6.463 ± 0.062** |
+
+### Timing comparison to check if value can be converted to `float` or `int`
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  62.700 ± 2.415 | 47.693 ± 0.448  |  **7.654 ± 0.067** |
+|   Small Int String |  18.768 ± 0.024 | 57.541 ± 2.481  |  **8.121 ± 0.285** |
+|         Int String |  20.091 ± 0.017 | 60.349 ± 0.058  |  **8.399 ± 0.104** |
+|  Medium Int String |  21.361 ± 0.120 | 63.463 ± 0.883  |  **7.972 ± 0.025** |
+|   Large Int String |  42.285 ± 0.751 | 82.013 ± 3.395  |  **8.439 ± 0.019** |
+| Small Float String |  20.607 ± 0.066 | 58.581 ± 0.248  |  **9.694 ± 0.449** |
+|       Float String |  42.608 ± 0.548 | 72.007 ± 1.249  |  **9.772 ± 0.040** |
+| Large Float String |  64.745 ± 2.167 | 93.079 ± 11.397 | **10.517 ± 0.027** |
+|                Int |  15.962 ± 0.042 | 21.281 ± 0.018  |  **6.939 ± 0.054** |
+|              Float |  14.370 ± 0.139 | 18.610 ± 0.010  |  **6.893 ± 0.039** |
+
+### Timing comparison to check if value can be coerced losslessly to `int`
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
+| -----------------: | --------------: | --------------: | ----------------: |
+|  Non-number String | 176.388 ± 5.146 |  47.721 ± 0.665 | **6.952 ± 0.107** |
+|   Small Int String |  36.671 ± 0.131 |  31.345 ± 0.148 | **7.069 ± 0.009** |
+|         Int String |  38.811 ± 0.543 |  33.323 ± 0.562 | **9.177 ± 3.960** |
+|  Medium Int String |  45.133 ± 0.185 |  38.554 ± 0.021 | **7.352 ± 0.025** |
+|   Large Int String |  78.121 ± 0.124 |  50.196 ± 0.022 | **7.092 ± 0.026** |
+| Small Float String | 128.708 ± 3.183 |  78.251 ± 3.168 | **7.931 ± 0.044** |
+|       Float String | 157.215 ± 3.267 | 120.111 ± 2.452 | **8.544 ± 0.186** |
+| Large Float String | 182.948 ± 2.852 | 149.855 ± 4.554 | **8.850 ± 0.069** |
+|                Int |  26.646 ± 0.444 |  65.726 ± 0.545 | **5.852 ± 0.037** |
+|              Float |  51.737 ± 0.760 |  95.225 ± 0.323 | **5.854 ± 0.106** |
+
diff --git a/setup.py b/setup.py
index 38d62ddc..168eed2d 100644
--- a/setup.py
+++ b/setup.py
@@ -11,7 +11,7 @@
 # Compilation arguments are platform-dependent
 if sys.platform == "win32":
     compile_args = [
-        "/std:c++14",
+        "/std:c++17",
         "/W4",  # Equivalent to -Wall -Wpedantic on GCC/Clang
         "/wd4100",  # don't warn about unreferenced formal parameters
         "/wd4127",  # don't warn about constant conditional expressions
@@ -21,7 +21,7 @@
         compile_args.append("/Z7")
 else:
     compile_args = [
-        "-std=c++14",
+        "-std=c++17",
         "-Wall",
         "-Weffc++",
         "-Wpedantic",
@@ -29,8 +29,6 @@
     if "FN_DEBUG" in os.environ or "FN_COV" in os.environ:
         compile_args.append("-O0")
         compile_args.append("-g")
-    if sys.platform == "darwin":
-        compile_args.append("-Wno-c++17-extensions")
 
 
 ext = [
diff --git a/src/cpp/argparse.cpp b/src/cpp/argparse.cpp
new file mode 100644
index 00000000..393e9d32
--- /dev/null
+++ b/src/cpp/argparse.cpp
@@ -0,0 +1,394 @@
+// Based on:
+// https://github.com/numpy/numpy/blob/2ce11750cbdba4d81fa8b3b8856c5b40aee75d45/numpy/core/src/common/npy_argparse.c
+// but edited to fastnumbers needs.
+
+#include "fastnumbers/argparse.hpp"
+#include <Python.h>
+
+typedef int convert(PyObject*, void*);
+
+/**
+ * Internal function to initialize keyword argument parsing.
+ *
+ * This does a few simple jobs:
+ *
+ * * Check the input for consistency to find coding errors, for example
+ *   a parameter not marked with | after one marked with | (optional).
+ * 2. Find the number of positional-only arguments, the number of
+ *    total, required, and keyword arguments.
+ * 3. Intern all keyword arguments strings to allow fast, identity based
+ *    parsing and avoid string creation overhead on each call.
+ *
+ * @param funcname Name of the function, mainly used for errors.
+ * @param cache A cache object stored statically in the parsing function
+ * @param va_orig Argument list to npy_parse_arguments
+ * @return 0 on success, -1 on failure
+ */
+static int
+initialize_keywords(const char* funcname, _FNArgParserCache* cache, va_list va_orig)
+{
+    va_list va;
+    int nargs = 0;
+    int nkwargs = 0;
+    int npositional_only = 0;
+    int nrequired = 0;
+    int npositional = 0;
+    char state = '\0';
+
+    va_copy(va, va_orig);
+    while (1) {
+        /* Count length first: */
+        char* name = va_arg(va, char*);
+        bool as_bool = va_arg(va, int);
+        void* data = va_arg(va, void*);
+
+        /* Check if this is the sentinel */
+        if ((name == NULL) && (!as_bool) && (data == NULL)) {
+            break;
+        }
+
+        if (name == NULL) {
+            PyErr_Format(
+                PyExc_SystemError,
+                "fastnumbers internal error: name is NULL in %s() at "
+                "argument %d.",
+                funcname,
+                nargs
+            );
+            va_end(va);
+            return -1;
+        }
+        if (data == NULL) {
+            PyErr_Format(
+                PyExc_SystemError,
+                "fastnumbers internal error: data is NULL in %s() at "
+                "argument %d.",
+                funcname,
+                nargs
+            );
+            va_end(va);
+            return -1;
+        }
+
+        nargs += 1;
+        if (*name == '|') {
+            if (state == '$') {
+                PyErr_Format(
+                    PyExc_SystemError,
+                    "fastnumbers internal error: positional argument `|` "
+                    "after keyword only `$` one to %s() at argument %d.",
+                    funcname,
+                    nargs
+                );
+                va_end(va);
+                return -1;
+            }
+            state = '|';
+            name++; /* advance to actual name. */
+            npositional += 1;
+        } else if (*name == '$') {
+            state = '$';
+            name++; /* advance to actual name. */
+        } else {
+            if (state != '\0') {
+                PyErr_Format(
+                    PyExc_SystemError,
+                    "fastnumbers internal error: non-required argument after "
+                    "required | or $ one to %s() at argument %d.",
+                    funcname,
+                    nargs
+                );
+                va_end(va);
+                return -1;
+            }
+
+            nrequired += 1;
+            npositional += 1;
+        }
+
+        if (*name == '\0') {
+            /* Empty string signals positional only */
+            if (state == '$') {
+                PyErr_Format(
+                    PyExc_SystemError,
+                    "fastnumbers internal error: non-kwarg marked with or $ "
+                    "to %s() at argument %d.",
+                    funcname,
+                    nargs
+                );
+                va_end(va);
+                return -1;
+            }
+            npositional_only += 1;
+        } else {
+            nkwargs += 1;
+        }
+    }
+    va_end(va);
+
+    if (npositional == -1) {
+        npositional = nargs;
+    }
+
+    if (nargs > FN_MAX_KWARGS) {
+        PyErr_Format(
+            PyExc_SystemError,
+            "fastnumbers internal error: function %s() has %d arguments, but "
+            "the maximum is currently limited to %d for easier parsing; "
+            "it can be increased by modifying `FN_MAX_KWARGS`.",
+            funcname,
+            nargs,
+            FN_MAX_KWARGS
+        );
+        return -1;
+    }
+
+    /*
+     * Do any necessary string allocation and interning,
+     * creating a caching object.
+     */
+    cache->nargs = nargs;
+    cache->npositional_only = npositional_only;
+    cache->npositional = npositional;
+    cache->nrequired = nrequired;
+
+    /* NULL kw_strings for easier cleanup (and NULL termination) */
+    memset(cache->kw_strings, 0, sizeof(PyObject*) * (nkwargs + 1));
+
+    va_copy(va, va_orig);
+    for (int i = 0; i < nargs; i++) {
+        /* Advance through non-kwargs, which do not require setup. */
+        char* name = va_arg(va, char*);
+        va_arg(va, int);
+        va_arg(va, void*);
+
+        if (*name == '|' || *name == '$') {
+            name++; /* ignore | and $ */
+        }
+        if (i >= npositional_only) {
+            int i_kwarg = i - npositional_only;
+            cache->kw_strings[i_kwarg] = PyUnicode_InternFromString(name);
+            if (cache->kw_strings[i_kwarg] == NULL) {
+                va_end(va);
+                goto error;
+            }
+        }
+    }
+
+    va_end(va);
+    return 0;
+
+error:
+    for (int i = 0; i < nkwargs; i++) {
+        Py_XDECREF(cache->kw_strings[i]);
+    }
+    cache->npositional = -1; /* not initialized */
+    return -1;
+}
+
+static int raise_incorrect_number_of_positional_args(
+    const char* funcname, const _FNArgParserCache* cache, Py_ssize_t len_args
+)
+{
+    if (cache->npositional == cache->nrequired) {
+        PyErr_Format(
+            PyExc_TypeError,
+            "%s() takes %d positional arguments but %zd were given",
+            funcname,
+            cache->npositional,
+            len_args
+        );
+    } else {
+        PyErr_Format(
+            PyExc_TypeError,
+            "%s() takes from %d to %d positional arguments but "
+            "%zd were given",
+            funcname,
+            cache->nrequired,
+            cache->npositional,
+            len_args
+        );
+    }
+    return -1;
+}
+
+static void
+raise_missing_argument(const char* funcname, const _FNArgParserCache* cache, int i)
+{
+    if (i < cache->npositional_only) {
+        PyErr_Format(
+            PyExc_TypeError, "%s() missing required positional argument %d", funcname, i
+        );
+    } else {
+        PyObject* kw = cache->kw_strings[i - cache->npositional_only];
+        PyErr_Format(
+            PyExc_TypeError,
+            "%s() missing required argument '%S' (pos %d)",
+            funcname,
+            kw,
+            i
+        );
+    }
+}
+
+/**
+ * Generic helper for argument parsing
+ *
+ * See macro version for an example pattern of how to use this function.
+ *
+ * @param funcname
+ * @param cache
+ * @param args Python passed args (METH_FASTCALL)
+ * @param len_args
+ * @param kwnames
+ * @param ... List of arguments (see macro version).
+ *
+ * @return Returns 0 on success and -1 on failure.
+ */
+int _fn_parse_arguments(
+    const char* funcname,
+    /* cache_ptr is a NULL initialized persistent storage for data */
+    _FNArgParserCache* cache,
+    PyObject* const* args,
+    Py_ssize_t len_args,
+    PyObject* kwnames,
+    /* ... is NULL, false, NULL terminated: name, as_bool, value */
+    ...
+)
+{
+    if (cache->npositional == -1) {
+        va_list va;
+        va_start(va, kwnames);
+
+        int res = initialize_keywords(funcname, cache, va);
+        va_end(va);
+        if (res < 0) {
+            return -1;
+        }
+    }
+
+    if (len_args > cache->npositional) {
+        return raise_incorrect_number_of_positional_args(funcname, cache, len_args);
+    }
+
+    /* NOTE: Could remove the limit but too many kwargs are slow anyway. */
+    PyObject* all_arguments[FN_MAX_KWARGS];
+
+    for (Py_ssize_t i = 0; i < len_args; i++) {
+        all_arguments[i] = args[i];
+    }
+
+    /* Without kwargs, do not iterate all converters. */
+    int max_nargs = (int)len_args;
+    Py_ssize_t len_kwargs = 0;
+
+    /* If there are any kwargs, first handle them */
+    if (kwnames != NULL) {
+        len_kwargs = PyTuple_GET_SIZE(kwnames);
+        max_nargs = cache->nargs;
+
+        for (int i = len_args; i < cache->nargs; i++) {
+            all_arguments[i] = NULL;
+        }
+
+        for (Py_ssize_t i = 0; i < len_kwargs; i++) {
+            PyObject* key = PyTuple_GET_ITEM(kwnames, i);
+            PyObject* value = args[i + len_args];
+            PyObject* const* name;
+
+            /* Super-fast path, check identity: */
+            for (name = cache->kw_strings; *name != NULL; name++) {
+                if (*name == key) {
+                    break;
+                }
+            }
+            if (*name == NULL) {
+                /* Slow fallback, if identity checks failed for some reason */
+                for (name = cache->kw_strings; *name != NULL; name++) {
+                    int eq = PyObject_RichCompareBool(*name, key, Py_EQ);
+                    if (eq == -1) {
+                        return -1;
+                    } else if (eq) {
+                        break;
+                    }
+                }
+                if (*name == NULL) {
+                    /* Invalid keyword argument. */
+                    PyErr_Format(
+                        PyExc_TypeError,
+                        "%s() got an unexpected keyword argument '%S'",
+                        funcname,
+                        key
+                    );
+                    return -1;
+                }
+            }
+
+            Py_ssize_t param_pos
+                = ((name - cache->kw_strings) + cache->npositional_only);
+
+            /* There could be an identical positional argument */
+            if (all_arguments[param_pos] != NULL) {
+                PyErr_Format(
+                    PyExc_TypeError,
+                    "argument for %s() given by name ('%S') and position "
+                    "(position %zd)",
+                    funcname,
+                    key,
+                    param_pos
+                );
+                return -1;
+            }
+
+            all_arguments[param_pos] = value;
+        }
+    }
+
+    /*
+     * There cannot be too many args, too many kwargs would find an
+     * incorrect one above.
+     */
+    assert(len_args + len_kwargs <= cache->nargs);
+
+    /* At this time `all_arguments` holds either NULLs or the objects */
+    va_list va;
+    va_start(va, kwnames);
+
+    for (int i = 0; i < max_nargs; i++) {
+        va_arg(va, char*);
+        bool as_bool = va_arg(va, int);
+        void* data = va_arg(va, void*);
+
+        if (all_arguments[i] == NULL) {
+            continue;
+        }
+
+        if (as_bool) {
+            *((bool*)data) = PyObject_IsTrue(all_arguments[i]);
+        } else {
+            *((PyObject**)data) = all_arguments[i];
+        }
+    }
+
+    /* Required arguments are typically not passed as keyword arguments */
+    if (len_args < cache->nrequired) {
+        /* (PyArg_* also does this after the actual parsing is finished) */
+        if (max_nargs < cache->nrequired) {
+            raise_missing_argument(funcname, cache, max_nargs);
+            goto converting_failed;
+        }
+        for (int i = 0; i < cache->nrequired; i++) {
+            if (all_arguments[i] == NULL) {
+                raise_missing_argument(funcname, cache, i);
+                goto converting_failed;
+            }
+        }
+    }
+
+    va_end(va);
+    return 0;
+
+converting_failed:
+    va_end(va);
+    return -1;
+}
diff --git a/src/cpp/c_str_parsing.cpp b/src/cpp/c_str_parsing.cpp
index 9994fc5d..cda323b2 100644
--- a/src/cpp/c_str_parsing.cpp
+++ b/src/cpp/c_str_parsing.cpp
@@ -5,56 +5,14 @@
 // from both sides of the string, and that the sign has been removed.
 
 #include "fastnumbers/c_str_parsing.hpp"
+#include "fastnumbers/third_party/fast_float.h"
 #include <algorithm>
+#include <charconv>
 #include <cmath>
 #include <cstdint>
 #include <cstring>
 
-/// Convert a character to an integer in the desired type
-template <typename T>
-static inline T ascii2int(const char c)
-{
-    return static_cast<T>(c - '0');
-}
-
-/// A function that accepts an argument and does nothing
-static inline void do_nothing(const char) { }
-
-/// Map to the approprate scaling factor for an exponent value
-constexpr long double POWER_OF_TEN_SCALING_FACTOR[] = {
-    1E0L,   1E1L,   1E2L,   1E3L,   1E4L,   1E5L,   1E6L,   1E7L,   1E8L,   1E9L,
-    1E10L,  1E11L,  1E12L,  1E13L,  1E14L,  1E15L,  1E16L,  1E17L,  1E18L,  1E19L,
-    1E20L,  1E21L,  1E22L,  1E23L,  1E24L,  1E25L,  1E26L,  1E27L,  1E28L,  1E29L,
-    1E30L,  1E31L,  1E32L,  1E33L,  1E34L,  1E35L,  1E36L,  1E37L,  1E38L,  1E39L,
-    1E40L,  1E41L,  1E42L,  1E43L,  1E44L,  1E45L,  1E46L,  1E47L,  1E48L,  1E49L,
-    1E50L,  1E51L,  1E52L,  1E53L,  1E54L,  1E55L,  1E56L,  1E57L,  1E58L,  1E59L,
-    1E60L,  1E61L,  1E62L,  1E63L,  1E64L,  1E65L,  1E66L,  1E67L,  1E68L,  1E69L,
-    1E70L,  1E71L,  1E72L,  1E73L,  1E74L,  1E75L,  1E76L,  1E77L,  1E78L,  1E79L,
-    1E80L,  1E81L,  1E82L,  1E83L,  1E84L,  1E85L,  1E86L,  1E87L,  1E88L,  1E89L,
-    1E90L,  1E91L,  1E92L,  1E93L,  1E94L,  1E95L,  1E96L,  1E97L,  1E98L,  1E99L,
-    1E100L, 1E101L, 1E102L, 1E103L, 1E104L, 1E105L, 1E106L, 1E107L, 1E108L, 1E109L,
-    1E110L, 1E111L, 1E112L, 1E113L, 1E114L, 1E115L, 1E116L, 1E117L, 1E118L, 1E119L,
-    1E120L, 1E121L, 1E122L, 1E123L, 1E124L, 1E125L, 1E126L, 1E127L, 1E128L, 1E129L,
-    1E130L, 1E131L, 1E132L, 1E133L, 1E134L, 1E135L, 1E136L, 1E137L, 1E138L, 1E139L,
-    1E140L, 1E141L, 1E142L, 1E143L, 1E144L, 1E145L, 1E146L, 1E147L, 1E148L, 1E149L,
-};
-constexpr int32_t LEN_EXP_ARRAY
-    = sizeof(POWER_OF_TEN_SCALING_FACTOR) / sizeof(POWER_OF_TEN_SCALING_FACTOR[0]);
-constexpr int32_t MAX_EXP_VALUE = LEN_EXP_ARRAY - 1;
-
 // FORWARD DECLARATIONS
-template <typename Function>
-static inline bool parse_integer_components(const char*& str, Function callback);
-static inline bool parse_integer_components(const char*& str);
-template <typename Function>
-static inline bool parse_decimal_components(const char*& str, Function callback);
-static inline bool parse_decimal_components(const char*& str);
-template <typename NFunction, typename Function>
-static inline bool
-parse_exponent_components(const char*& str, NFunction sign_callback, Function callback);
-static inline bool parse_exponent_components(const char*& str);
-static inline bool neg_exp_ok(const char* str, std::size_t len);
-static inline bool pos_exp_ok(const char* str, std::size_t len);
 static inline uint32_t number_trailing_zeros(const char* start, const char* end);
 static inline int detect_base(const char* str, const char* end);
 static inline bool is_valid_digit_arbitrary_base(const char c, const int base);
@@ -67,92 +25,109 @@ static inline bool is_valid_digit_arbitrary_base(const char c, const int base);
 
 int string_contains_what(const char* str, const char* end, int base)
 {
-    /* Define possible return values */
+    const std::size_t len = static_cast<std::size_t>(end - str);
+
+    // Define possible return values
     static constexpr int INVALID = 0;
     static constexpr int INTEGER = 1;
     static constexpr int FLOAT = 2;
     static constexpr int INTLIKE_FLOAT = 3;
 
+    // If the base needs to be guessed, do so now and get it over with.
     if (base == 0) {
         base = detect_base(str, end);
     }
 
-    /* Special-case non-base-10 integer detection */
-    if (base < 0) {
+    // Negative bases are illegal. So is zero length.
+    if (base < 0 || len == 0) {
         return INVALID;
-    } else if (base != 10) {
-        const std::size_t len = static_cast<std::size_t>(end - str);
+    }
 
-        /* Skip leading characters for non-base 10 ints. */
+    // Special-case non-base 10.
+    if (base != 10) {
+        // Skip leading characters for non-base 10 ints.
         if (len > 1 && str[0] == '0' && is_base_prefix(str[1], base)) {
             str += 2;
         }
 
-        /* The rest behaves as normal. */
-        bool valid = false;
-        while (is_valid_digit_arbitrary_base(*str, base)) {
+        // The rest behaves as normal.
+        const char* digit_start = str;
+        while (str != end && is_valid_digit_arbitrary_base(*str, base)) {
             str += 1;
-            valid = true;
         }
-        return (valid && str == end) ? INTEGER : INVALID;
+        return (str == end && str != digit_start) ? INTEGER : INVALID;
     }
 
-    /* Before decimal. Keep track of number of digits read. */
+    // Before decimal. Keep track of the start location.
+    bool valid = false;
     int value = INVALID;
     const char* int_start = str;
-    bool valid = parse_integer_components(str);
-    if (valid) {
+    consume_digits(str, len);
+    if (str != int_start) {
+        valid = true;
         value = INTEGER;
     }
 
-    /* Decimal part of float. Keep track of number of digits read */
-    /* as well as beginning and end locations. */
+    // Decimal part of float. Keep track of number of digits read
+    // as well as beginning and end locations.
     const char* decimal_start = str;
     uint32_t dec_length = 0;
-    valid = parse_decimal_components(
-                str,
-                [&dec_length](const char) {
-                    dec_length += 1;
-                }
-            )
-        || valid;
+    if (str != end && *str == '.') {
+        str += 1;
+        const char* dec_digits_start = str;
+        consume_digits(str, static_cast<std::size_t>(end - str));
+        dec_length = static_cast<uint32_t>(str - dec_digits_start);
+        valid = valid || dec_length > 0;
+    }
     const char* decimal_end = str;
+
+    // If there are any decimal components then we are looking at a float.
     if (valid && decimal_end != decimal_start) {
         value = FLOAT;
     }
 
-    /* Exponential part of float. Parse the magnitude. */
+    // Exponential part of float. Parse the magnitude.
     uint32_t expon = 0;
     bool exp_negative = false;
     if (valid) {
         const char* exp_start = str;
-        valid = parse_exponent_components(
-            str,
-            [&exp_negative](const char) {
-                exp_negative = true;
-            },
-            [&expon](const char c) {
-                expon *= 10;
-                expon += ascii2int<uint32_t>(c);
+        if (str != end && (*str == 'e' || *str == 'E')) {
+
+            // Skip the 'e' and any sign that might be present.
+            str += 1;
+            if (str != end && is_sign(*str)) {
+                exp_negative = *str == '-';
+                str += 1;
             }
-        );
+
+            // Parse the exponent as a digit.
+            const char* exp_digit_start = str;
+            int32_t this_char_as_digit = 0L;
+            while (str != end && (this_char_as_digit = to_digit<int32_t>(*str)) >= 0) {
+                expon = expon * 10L + this_char_as_digit;
+                str += 1;
+            }
+
+            // If all we found was e.g. "e" or "e-" then it's not valid.
+            valid = str != exp_digit_start;
+        }
         const char* exp_end = str;
-        if (valid && exp_end != exp_start) {
+
+        // If we found an exponent AND it was parsed validly then this is a float.
+        if (exp_end != exp_start && valid) {
             value = FLOAT;
         }
     }
 
-    /* If the parsing was not valid or we are not at the end of the string
-     * then the string is invalid.
-     * Othewise, do a check to see if it is an *intlike* float.
-     */
+    // If the parsing was not valid or we are not at the end of the string
+    // then the string is invalid.
+    // Othewise, do a check to see if it is an *intlike* float.
     if (!valid || str != end) {
         return INVALID;
     } else if (value == FLOAT) {
-        /* If we "move the decimal place" left or right depending on
-         * exponent sign and magnitude, all digits after the decimal
-         * must be zero.
-         */
+        // If we "move the decimal place" left or right depending on
+        // exponent sign and magnitude, all digits after the decimal
+        // must be zero.
         const unsigned int_trailing_zeros
             = number_trailing_zeros(int_start, decimal_start);
         const unsigned dec_trailing_zeros = decimal_start == decimal_end
@@ -172,121 +147,95 @@ int string_contains_what(const char* str, const char* end, int base)
     return value;
 }
 
-long parse_int(const char* str, const char* end, bool& error)
+int64_t
+parse_int(const char* str, const char* end, int base, bool& error, bool& overflow)
 {
-    long value = 0L;
-
-    /* Convert digits, if any. */
-    bool valid = parse_integer_components(str, [&value](const char c) {
-        value *= 10L;
-        value += ascii2int<long>(c);
-    });
-
-    error = !valid || str != end;
-    return value;
-}
+    const std::size_t len = static_cast<std::size_t>(end - str);
 
-double parse_float(const char* str, const char* end, bool& error)
-{
-    /* Parse integer part. */
-    uint64_t intvalue = 0UL;
-    bool valid = parse_integer_components(str, [&intvalue](const char c) {
-        intvalue *= 10UL;
-        intvalue += ascii2int<uint64_t>(c);
-    });
-
-    /* Parse decimal part. */
-    uint32_t decimal_len = 0;
-    valid = parse_decimal_components(
-                str,
-                [&intvalue, &decimal_len](const char c) {
-                    intvalue *= 10UL;
-                    intvalue += ascii2int<uint64_t>(c);
-                    decimal_len += 1U;
-                }
-            )
-        || valid;
-
-    /* Parse exponential part. */
-    int32_t expon = 0;
-    if (valid) {
-        int32_t exp_sign = 1;
-        valid = parse_exponent_components(
-            str,
-            [&exp_sign](const char c) {
-                if (c == '-') {
-                    exp_sign = -1;
-                }
-            },
-            [&expon](const char c) {
-                expon *= 10;
-                expon += ascii2int<int32_t>(c);
-            }
-        );
-        expon *= exp_sign;
+    // If the base needs to be guessed, do so now and get it over with.
+    if (base == 0) {
+        base = detect_base(str, end);
     }
-    expon -= decimal_len; /* Adjust the exponent by the # of decimal places */
-
-    error = !valid || str != end;
-    if (expon < 0) {
-        expon = std::abs(expon);
-        return static_cast<double>(
-            static_cast<long double>(intvalue)
-            / POWER_OF_TEN_SCALING_FACTOR[std::min(expon, MAX_EXP_VALUE)]
-        );
-    } else {
-        return static_cast<double>(
-            static_cast<long double>(intvalue)
-            * POWER_OF_TEN_SCALING_FACTOR[std::min(expon, MAX_EXP_VALUE)]
-        );
+
+    // Negative bases are illegal. So is zero-length
+    if (base < 0 || len == 0) {
+        overflow = false;
+        error = true;
+        return -1;
     }
-}
 
-bool float_might_overflow(const char* start, const std::size_t len)
-{
-    // Locate the decimal place (if any).
-    const char* decimal_loc = static_cast<const char*>(std::memchr(start, '.', len));
-    const bool has_decimal = static_cast<bool>(decimal_loc);
-
-    // Find the exponent (if any) in the input.
-    // It is always after the exponent, usually close to the end, so
-    // we will start from the back. No need to include the stop
-    // location since that is either a decimal or the first digit
-    // which cannot be 'e' or 'E'.
-    const char* ptr = nullptr;
-    const char* exp = nullptr;
-    const char* stop = decimal_loc ? decimal_loc : start;
-    for (ptr = start + len - 1; ptr > stop; ptr--) {
-        if (*ptr == 'e' || *ptr == 'E') {
-            exp = ptr;
-            break;
+    // Use std::from_chars for all but base-10.
+    if (base != 10) {
+        // Skip leading characters for non-base 10 ints.
+        if (len > 1 && str[0] == '0' && is_base_prefix(str[1], base)) {
+            str += 2;
         }
-    }
 
-    // If the number of pre-exponent digits is greater than the known
-    // value it might overflow.
-    const std::size_t decimal_offset = static_cast<std::size_t>(has_decimal);
-    const std::size_t len_pre_exp = exp ? (exp - start) : len;
-    if (len_pre_exp - decimal_offset > FN_DBL_DIG) {
-        return true;
+        // Use a very fast and accurate string to integer parser
+        // that will report back if there was an overflow (which
+        // we propagete back to the user).
+        int64_t value;
+        const std::from_chars_result res = std::from_chars(str, end, value, base);
+        error = res.ptr != end || res.ec == std::errc::invalid_argument;
+        overflow = res.ec == std::errc::result_out_of_range;
+        return value;
     }
 
-    // If an exponent was found, ensure it is within chosen range.
-    if (exp) {
-        const bool neg = *(++exp) == '-'; // First remove 'e' or 'E'.
-        std::size_t exp_len = len - (exp - start);
-        if (is_sign(*exp)) {
-            exp += 1;
-            exp_len -= 1;
+    // We use our own method for base-10 because we can omit some overflow
+    // checking and get faster results.
+    //
+    // We just assume overflow if the length of the string is over a certain value.
+    // The number of digits chosen for overflow is 18 - this is one less than the
+    // maximumlength of a 64-bit integer.
+    //
+    // 64-bit int max == 9223372036854775807; len('9223372036854775807') - 1 == 18
+    overflow = len > 18;
+
+    // If an overflow is going to happen, just evaluate that this looks like
+    // an integer. Otherwise, actually calculate the value contained in the string.
+    int64_t value = 0L;
+    if (overflow) {
+        consume_digits(str, len);
+    } else {
+        // Attempt to read eight characters at a time and parse as digits.
+        // Loop over the character array in steps of eight. Stop processing
+        // if not all eight characters are digits.
+        const std::size_t number_of_eights = len / 8;
+        for (std::size_t i = 0; i < number_of_eights; ++i) {
+            if (fast_float::is_made_of_eight_digits_fast(str)) {
+                value = value * 100000000 + fast_float::parse_eight_digits_unrolled(str);
+                str += 8;
+            } else {
+                break;
+            }
         }
-        const bool exp_ok = neg ? neg_exp_ok(exp, exp_len) : pos_exp_ok(exp, exp_len);
-        if (!exp_ok) {
-            return true;
+
+        // Convert digits the remaining digits one-at-a-time.
+        int64_t this_char_as_digit = 0L;
+        while (str != end && (this_char_as_digit = to_digit<int64_t>(*str)) >= 0) {
+            value = value * 10L + this_char_as_digit;
+            str += 1;
         }
     }
+    error = str != end;
+    return value;
+}
+
+double parse_float(const char* str, const char* end, bool& error)
+{
+    // parse_float is not supposed to accept signed values, but from_chars
+    // will accept negative signs. To prevent accidental success on e.g. "+-3.14"
+    // we short-cicuit on a leading negative sign.
+    if (str != end && *str == '-') {
+        error = true;
+        return -1.0;
+    }
 
-    // Won't overflow
-    return false;
+    // Use a very fast and accurate string to double parser
+    double value;
+    const fast_float::from_chars_result res = fast_float::from_chars(str, end, value);
+    error = !(res.ptr == end && res.ec == std::errc());
+    return value;
 }
 
 void remove_valid_underscores(char* str, const char*& end, const bool based)
@@ -339,11 +288,11 @@ void remove_valid_underscores(char* str, const char*& end, const bool based)
         }
 
         // Now search for simpler valid underscores.
-        // use hex as the base because it is the most inclusive.
+        // use base 36 as the base because it is the most inclusive.
         for (; i < len; i++) {
             if (str[i] == '_' && i > 0 && i < len - 1
-                && is_valid_digit_arbitrary_base(str[i - 1], 16)
-                && is_valid_digit_arbitrary_base(str[i + 1], 16)) {
+                && is_valid_digit_arbitrary_base(str[i - 1], 36)
+                && is_valid_digit_arbitrary_base(str[i + 1], 36)) {
                 offset += 1;
                 continue;
             }
@@ -366,140 +315,6 @@ void remove_valid_underscores(char* str, const char*& end, const bool based)
 /* IMPLEMENTATION DETAILS */
 /**************************/
 
-/**
- * \brief Scan a string while integer components are found
- *
- * A user-defined callback function can be provided to perform
- * an operation when a digit is found.
- *
- * \param str The string to inspect. Assumed to be non-NULL
- * \param callback A function to call for each digit character.
- *                 Must accept a single char and return void.
- *
- * \returns true if at least one character was read as a digit
- */
-template <typename Function>
-bool parse_integer_components(const char*& str, Function callback)
-{
-    const char* start = str;
-    while (is_valid_digit(*str)) {
-        callback(*str);
-        str += 1;
-    }
-    return str != start; // return whether or not a valid digit was found
-}
-
-bool parse_integer_components(const char*& str)
-{
-    return parse_integer_components(str, do_nothing);
-}
-
-/**
- * \brief Scan a string for decimal parts of a float
- *
- * It is basically the same as parse_integer_components except
- * that it allows a single '.' at the front of the string.
- *
- * A user-defined callback function can be provided to perform
- * an operation when a digit is found.
- *
- * \param str The string to inspect. Assumed to be non-NULL
- * \param callback A function to call for each digit character.
- *                 Must accept a single char and return void.
- *
- * \returns true if at least one character was read as a digit
- */
-template <typename Function>
-bool parse_decimal_components(const char*& str, Function callback)
-{
-    if (*str == '.') {
-        str += 1;
-        return parse_integer_components(str, callback);
-    }
-    return false;
-}
-
-bool parse_decimal_components(const char*& str)
-{
-    return parse_decimal_components(str, do_nothing);
-}
-
-/**
- * \brief Scan a string for exponents parts of a float
- *
- * Require that the string starts with 'e' or 'E', then
- * require that an (optionally signed) string of digits follows.
- *
- * A user-defined callback function can be provided to perform
- * an operation when a sign is found.
- *
- * A user-defined callback function can be provided to perform
- * an operation when a digit is found.
- *
- * \param str The string to inspect. Assumed to be non-NULL
- * \param callback A function to call for each digit character.
- *                 Must accept a single char and return void.
- *
- * \returns true if at least one character was read as a digit OR
- *          if nothing was read
- */
-template <typename NFunction, typename Function>
-bool parse_exponent_components(
-    const char*& str, NFunction sign_callback, Function callback
-)
-{
-    if (*str == 'e' || *str == 'E') {
-        str += 1;
-        if (is_sign(*str)) {
-            sign_callback(*str);
-            str += 1;
-        }
-        return parse_integer_components(str, callback);
-    }
-    return true;
-}
-
-bool parse_exponent_components(const char*& str)
-{
-    return parse_exponent_components(str, do_nothing, do_nothing);
-}
-
-#ifndef FASTNUMBERS_WIDE_EXP_RANGE
-/// Helper to check if an exponent number is in the allowed range
-static inline bool _exp_ok(const char* str, std::size_t len)
-{
-    return len == 1 || (len == 2 && (*str <= '1' || (*str == '1' && *(str + 1) <= '9')));
-}
-#endif
-
-/**
- * \brief Check if a negative exponent number is in the allowed range
- * \param str The string to check, assumed to be non-NULL
- * \param len The length of the string
- */
-bool neg_exp_ok(const char* str, std::size_t len)
-{
-#ifdef FASTNUMBERS_WIDE_EXP_RANGE
-    return len == 1 || (len == 2 && (*str <= '8' || (*str == '9' && *(str + 1) <= '8')));
-#else
-    return _exp_ok(str, len);
-#endif
-}
-
-/**
- * \brief Check if a positive exponent number is in the allowed range
- * \param str The string to check, assumed to be non-NULL
- * \param len The length of the string
- */
-bool pos_exp_ok(const char* str, std::size_t len)
-{
-#ifdef FASTNUMBERS_WIDE_EXP_RANGE
-    return len > 0 && len <= 2;
-#else
-    return _exp_ok(str, len);
-#endif
-}
-
 /**
  * \brief Check the number of zeros at the end of a number
  *
@@ -532,11 +347,14 @@ int detect_base(const char* str, const char* end)
     const std::size_t len = static_cast<std::size_t>(end - str);
     if (str[0] != '0' || len == 1) {
         return 10;
-    } else if (str[1] == 'x' || str[1] == 'X') {
+    }
+
+    const char lowered = lowercase(str[1]);
+    if (lowered == 'x') {
         return 16;
-    } else if (str[1] == 'o' || str[1] == 'O') {
+    } else if (lowered == 'o') {
         return 8;
-    } else if (str[1] == 'b' || str[1] == 'B') {
+    } else if (lowered == 'b') {
         return 2;
     } else
         /* "old" (C-style) octal literal illegal in 3.x. */
@@ -558,8 +376,8 @@ bool is_valid_digit_arbitrary_base(const char c, const int base)
     if (base < 10) {
         return c >= '0' && c <= (static_cast<int>('0') + base);
     } else {
+        const char lowered = lowercase(c);
         const char offset = static_cast<char>(base) - 10;
-        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'a' + offset)
-            || (c >= 'A' && c <= 'A' + offset);
+        return is_valid_digit(c) || (lowered >= 'a' && lowered <= 'a' + offset);
     }
 }
diff --git a/src/cpp/extractor.cpp b/src/cpp/extractor.cpp
index 4a86e376..d8c6933f 100644
--- a/src/cpp/extractor.cpp
+++ b/src/cpp/extractor.cpp
@@ -3,7 +3,6 @@
 
 #include <Python.h>
 
-#include "fastnumbers/c_str_parsing.hpp"
 #include "fastnumbers/extractor.hpp"
 #include "fastnumbers/parser.hpp"
 
@@ -125,6 +124,7 @@ bool TextExtractor::parse_unicode_to_char()
     // character.
     long u_as_decimal = 0;
     const Py_ssize_t data_len = len + index;
+    static constexpr uint8_t ASCII_MAX = 127;
     for (; index < data_len; index++) {
         const Py_UCS4 u = (Py_UCS4)PyUnicode_READ(kind, data, index);
         if (u < ASCII_MAX) {
diff --git a/src/cpp/fastnumbers.cpp b/src/cpp/fastnumbers.cpp
index 739597c8..c4a0f2d1 100644
--- a/src/cpp/fastnumbers.cpp
+++ b/src/cpp/fastnumbers.cpp
@@ -8,9 +8,10 @@
 
 #include <Python.h>
 
-#include "fastnumbers/c_str_parsing.hpp"
+#include "fastnumbers/argparse.hpp"
 #include "fastnumbers/docstrings.hpp"
 #include "fastnumbers/implementation.hpp"
+#include "fastnumbers/parser/numeric.hpp"
 #include "fastnumbers/selectors.hpp"
 #include "fastnumbers/user_options.hpp"
 #include "fastnumbers/version.hpp"
@@ -238,7 +239,9 @@ static inline void validate_consider(const PyObject* selector)
 /**
  * \brief Quickly convert to an int or float, depending on value, with error handling
  */
-static PyObject* fastnumbers_try_real(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_try_real(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* inf = Selectors::ALLOWED;
@@ -247,28 +250,21 @@ static PyObject* fastnumbers_try_real(PyObject* self, PyObject* args, PyObject*
     PyObject* on_type_error = Selectors::RAISE;
     int coerce = true;
     int allow_underscores = false;
-    static const char* keywords[] = {
-        "x",    "inf", "nan", "on_fail", "on_type_error", "coerce", "allow_underscores",
-        nullptr
-    };
-    static const char* format = "O|$OOOOpp:try_real";
 
     // Read the function argument
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &inf,
-            &nan,
-            &on_fail,
-            &on_type_error,
-            &coerce,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("try_float", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$coerce", true, &coerce,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -294,7 +290,9 @@ static PyObject* fastnumbers_try_real(PyObject* self, PyObject* args, PyObject*
 /**
  * \brief Quickly convert to an int or float, depending on value, with error handling
  */
-static PyObject* fastnumbers_fast_real(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_fast_real(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* default_value = nullptr;
@@ -305,29 +303,23 @@ static PyObject* fastnumbers_fast_real(PyObject* self, PyObject* args, PyObject*
     int raise_on_invalid = false;
     int coerce = true;
     int allow_underscores = true;
-    static const char* keywords[]
-        = { "x",   "default", "raise_on_invalid",  "on_fail", "inf",
-            "nan", "coerce",  "allow_underscores", "key",     nullptr };
-    static const char* format = "O|O$pOOOppO:fast_real";
 
     // Read the function argument
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &default_value,
-            &raise_on_invalid,
-            &on_fail,
-            &inf,
-            &nan,
-            &coerce,
-            &allow_underscores,
-            &key
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("fast_real", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "|default", false, &default_value,
+                           "$raise_on_invalid", true, &raise_on_invalid,
+                           "$on_fail", false, &on_fail,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$coerce", true, &coerce,
+                           "$allow_underscores", true, &allow_underscores,
+                           "$key", false, &key,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -345,7 +337,9 @@ static PyObject* fastnumbers_fast_real(PyObject* self, PyObject* args, PyObject*
 /**
  * \brief Quickly convert to a float, with error handling
  */
-static PyObject* fastnumbers_try_float(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_try_float(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* inf = Selectors::ALLOWED;
@@ -353,26 +347,20 @@ static PyObject* fastnumbers_try_float(PyObject* self, PyObject* args, PyObject*
     PyObject* on_fail = Selectors::INPUT;
     PyObject* on_type_error = Selectors::RAISE;
     int allow_underscores = false;
-    static const char* keywords[] = { "x",       "inf",           "nan",
-                                      "on_fail", "on_type_error", "allow_underscores",
-                                      nullptr };
-    static const char* format = "O|$OOOOp:try_float";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &inf,
-            &nan,
-            &on_fail,
-            &on_type_error,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("try_float", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -391,7 +379,9 @@ static PyObject* fastnumbers_try_float(PyObject* self, PyObject* args, PyObject*
 /**
  * \brief Quickly convert to a float, with error handling
  */
-static PyObject* fastnumbers_fast_float(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_fast_float(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* default_value = nullptr;
@@ -401,28 +391,22 @@ static PyObject* fastnumbers_fast_float(PyObject* self, PyObject* args, PyObject
     PyObject* nan = Selectors::ALLOWED;
     int raise_on_invalid = false;
     int allow_underscores = true;
-    static const char* keywords[] = { "x",    "default", "raise_on_invalid",  "on_fail",
-                                      "inf",  "nan",     "allow_underscores", "key",
-                                      nullptr };
-    static const char* format = "O|O$pOOOpO:fast_float";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &default_value,
-            &raise_on_invalid,
-            &on_fail,
-            &inf,
-            &nan,
-            &allow_underscores,
-            &key
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("fast_float", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "|default", false, &default_value,
+                           "$raise_on_invalid", true, &raise_on_invalid,
+                           "$on_fail", false, &on_fail,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$allow_underscores", true, &allow_underscores,
+                           "$key", false, &key,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -440,31 +424,28 @@ static PyObject* fastnumbers_fast_float(PyObject* self, PyObject* args, PyObject
 /**
  * \brief Quickly convert to an int, with error handling
  */
-static PyObject* fastnumbers_try_int(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_try_int(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* on_fail = Selectors::INPUT;
     PyObject* on_type_error = Selectors::RAISE;
     PyObject* pybase = nullptr;
     int allow_underscores = false;
-    static const char* keywords[]
-        = { "x", "on_fail", "on_type_error", "base", "allow_underscores", nullptr };
-    static const char* format = "O|$OOOp:try_int";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &on_fail,
-            &on_type_error,
-            &pybase,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("try_int", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$base", false, &pybase,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -482,7 +463,9 @@ static PyObject* fastnumbers_try_int(PyObject* self, PyObject* args, PyObject* k
 /**
  * \brief Quickly convert to an int, with error handling
  */
-static PyObject* fastnumbers_fast_int(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_fast_int(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* default_value = nullptr;
@@ -491,27 +474,21 @@ static PyObject* fastnumbers_fast_int(PyObject* self, PyObject* args, PyObject*
     PyObject* pybase = nullptr;
     int raise_on_invalid = false;
     int allow_underscores = true;
-    static const char* keywords[]
-        = { "x",   "default", "raise_on_invalid", "on_fail", "base", "allow_underscores",
-            "key", nullptr };
-    static const char* format = "O|O$pOOpO:fast_int";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &default_value,
-            &raise_on_invalid,
-            &on_fail,
-            &pybase,
-            &allow_underscores,
-            &key
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("fast_int", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "|default", false, &default_value,
+                           "$raise_on_invalid", true, &raise_on_invalid,
+                           "$on_fail", false, &on_fail,
+                           "$base", false, &pybase,
+                           "$allow_underscores", true, &allow_underscores,
+                           "$key", false, &key,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -528,30 +505,26 @@ static PyObject* fastnumbers_fast_int(PyObject* self, PyObject* args, PyObject*
 /**
  * \brief Quickly convert to an int (even if input is float), with error handling
  */
-static PyObject*
-fastnumbers_try_forceint(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_try_forceint(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* on_fail = Selectors::INPUT;
     PyObject* on_type_error = Selectors::RAISE;
     int allow_underscores = false;
-    static const char* keywords[]
-        = { "x", "on_fail", "on_type_error", "allow_underscores", nullptr };
-    static const char* format = "O|$OOp:try_forceint";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &on_fail,
-            &on_type_error,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("try_forceint", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -568,8 +541,9 @@ fastnumbers_try_forceint(PyObject* self, PyObject* args, PyObject* kwargs)
 /**
  * \brief Quickly convert to an int (even if input is float), with error handling
  */
-static PyObject*
-fastnumbers_fast_forceint(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_fast_forceint(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* default_value = nullptr;
@@ -577,26 +551,20 @@ fastnumbers_fast_forceint(PyObject* self, PyObject* args, PyObject* kwargs)
     PyObject* key = nullptr;
     int raise_on_invalid = false;
     int allow_underscores = true;
-    static const char* keywords[]
-        = { "x",   "default", "raise_on_invalid", "on_fail", "allow_underscores",
-            "key", nullptr };
-    static const char* format = "O|O$pOpO:fast_forceint";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &default_value,
-            &raise_on_invalid,
-            &on_fail,
-            &allow_underscores,
-            &key
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("fast_forceint", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "|default", false, &default_value,
+                           "$raise_on_invalid", true, &raise_on_invalid,
+                           "$on_fail", false, &on_fail,
+                           "$allow_underscores", true, &allow_underscores,
+                           "$key", false, &key,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -612,31 +580,28 @@ fastnumbers_fast_forceint(PyObject* self, PyObject* args, PyObject* kwargs)
 /**
  * \brief Quickly determine if the input is a real.
  */
-static PyObject* fastnumbers_check_real(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_check_real(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* consider = Py_None;
     PyObject* inf = Selectors::NUMBER_ONLY;
     PyObject* nan = Selectors::NUMBER_ONLY;
     int allow_underscores = false;
-    static const char* keywords[]
-        = { "x", "consider", "inf", "nan", "allow_underscores", nullptr };
-    static const char* format = "O|$OOOp:check_real";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &consider,
-            &inf,
-            &nan,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("check_real", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$consider", false, &consider,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -654,7 +619,9 @@ static PyObject* fastnumbers_check_real(PyObject* self, PyObject* args, PyObject
 /**
  * \brief Quickly determine if the input is a real.
  */
-static PyObject* fastnumbers_isreal(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_isreal(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     int str_only = false;
@@ -662,26 +629,20 @@ static PyObject* fastnumbers_isreal(PyObject* self, PyObject* args, PyObject* kw
     int allow_inf = false;
     int allow_nan = false;
     int allow_underscores = true;
-    static const char* keywords[]
-        = { "x",         "str_only",          "num_only", "allow_inf",
-            "allow_nan", "allow_underscores", nullptr };
-    static const char* format = "O|$ppppp:isreal";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &str_only,
-            &num_only,
-            &allow_inf,
-            &allow_nan,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("isreal", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$str_only", true, &str_only,
+                           "$num_only", true, &num_only,
+                           "$allow_inf", true, &allow_inf,
+                           "$allow_nan", true, &allow_nan,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Convert old-style arguments to new-style
     const PyObject* consider = create_consider(str_only, num_only);
@@ -701,8 +662,9 @@ static PyObject* fastnumbers_isreal(PyObject* self, PyObject* args, PyObject* kw
 /**
  * \brief Quickly determine if the input is a float.
  */
-static PyObject*
-fastnumbers_check_float(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_check_float(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* consider = Py_None;
@@ -710,25 +672,20 @@ fastnumbers_check_float(PyObject* self, PyObject* args, PyObject* kwargs)
     PyObject* nan = Selectors::NUMBER_ONLY;
     int strict = false;
     int allow_underscores = false;
-    static const char* keywords[]
-        = { "x", "consider", "inf", "nan", "strict", "allow_underscores", nullptr };
-    static const char* format = "O|$OOOpp:check_float";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &consider,
-            &inf,
-            &nan,
-            &strict,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("check_float", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$consider", false, &consider,
+                           "$strict", true, &strict,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -746,7 +703,9 @@ fastnumbers_check_float(PyObject* self, PyObject* args, PyObject* kwargs)
 /**
  * \brief Quickly determine if the input is a float.
  */
-static PyObject* fastnumbers_isfloat(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_isfloat(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     int str_only = false;
@@ -754,26 +713,20 @@ static PyObject* fastnumbers_isfloat(PyObject* self, PyObject* args, PyObject* k
     int allow_inf = false;
     int allow_nan = false;
     int allow_underscores = true;
-    static const char* keywords[]
-        = { "x",         "str_only",          "num_only", "allow_inf",
-            "allow_nan", "allow_underscores", nullptr };
-    static const char* format = "O|$ppppp:isfloat";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &str_only,
-            &num_only,
-            &allow_inf,
-            &allow_nan,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("isfloat", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$str_only", true, &str_only,
+                           "$num_only", true, &num_only,
+                           "$allow_inf", true, &allow_inf,
+                           "$allow_nan", true, &allow_nan,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Convert old-style arguments to new-style
     const PyObject* consider = create_consider(str_only, num_only);
@@ -793,29 +746,26 @@ static PyObject* fastnumbers_isfloat(PyObject* self, PyObject* args, PyObject* k
 /**
  * \brief Quickly determine if the input is an int.
  */
-static PyObject* fastnumbers_check_int(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_check_int(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* consider = Py_None;
     PyObject* pybase = nullptr;
     int allow_underscores = false;
-    static const char* keywords[]
-        = { "x", "consider", "base", "allow_underscores", nullptr };
-    static const char* format = "O|$OOp:check_int";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &consider,
-            &pybase,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("check_int", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$consider", false, &consider,
+                           "$base", false, &pybase,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -830,31 +780,28 @@ static PyObject* fastnumbers_check_int(PyObject* self, PyObject* args, PyObject*
 /**
  * \brief Quickly determine if the input is an int.
  */
-static PyObject* fastnumbers_isint(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_isint(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* pybase = nullptr;
     int str_only = false;
     int num_only = false;
     int allow_underscores = true;
-    static const char* keywords[]
-        = { "x", "str_only", "num_only", "base", "allow_underscores", nullptr };
-    static const char* format = "O|$ppOp:isint";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &str_only,
-            &num_only,
-            &pybase,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("isint", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$str_only", true, &str_only,
+                           "$num_only", true, &num_only,
+                           "$base", false, &pybase,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Convert old-style arguments to new-style
     const PyObject* consider = create_consider(str_only, num_only);
@@ -871,27 +818,24 @@ static PyObject* fastnumbers_isint(PyObject* self, PyObject* args, PyObject* kwa
 /**
  * \brief Quickly determine if the input is an int or int-like float.
  */
-static PyObject*
-fastnumbers_check_intlike(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_check_intlike(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* consider = Py_None;
-    int allow_underscores = false;
-    static const char* keywords[] = { "x", "consider", "allow_underscores", nullptr };
-    static const char* format = "O|$Op:check_intlike";
+    bool allow_underscores = false;
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &consider,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("check_intlike", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$consider", false, &consider,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Execute main logic in a try-block to convert C++ exceptions
     try {
@@ -905,29 +849,26 @@ fastnumbers_check_intlike(PyObject* self, PyObject* args, PyObject* kwargs)
 /**
  * \brief Quickly determine if the input is an int or int-like float.
  */
-static PyObject* fastnumbers_isintlike(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_isintlike(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
-    int str_only = false;
-    int num_only = false;
-    int allow_underscores = true;
-    static const char* keywords[]
-        = { "x", "str_only", "num_only", "allow_underscores", nullptr };
-    static const char* format = "O|$ppp:isintlike";
+    bool str_only = false;
+    bool num_only = false;
+    bool allow_underscores = true;
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &str_only,
-            &num_only,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("isintlike", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$str_only", true, &str_only,
+                           "$num_only", true, &num_only,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Convert old-style arguments to new-style
     const PyObject* consider = create_consider(str_only, num_only);
@@ -943,7 +884,9 @@ static PyObject* fastnumbers_isintlike(PyObject* self, PyObject* args, PyObject*
 /**
  * \brief Quickly determine the type
  */
-static PyObject* fastnumbers_query_type(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_query_type(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* allowed_types = nullptr;
@@ -951,26 +894,20 @@ static PyObject* fastnumbers_query_type(PyObject* self, PyObject* args, PyObject
     int allow_inf = false;
     int allow_nan = false;
     int allow_underscores = false;
-    static const char* keywords[] = { "x",      "allow_inf",     "allow_nan",
-                                      "coerce", "allowed_types", "allow_underscores",
-                                      nullptr };
-    static const char* format = "O|$pppOp:type";
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args,
-            kwargs,
-            format,
-            const_cast<char**>(keywords),
-            &input,
-            &allow_inf,
-            &allow_nan,
-            &coerce,
-            &allowed_types,
-            &allow_underscores
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("query_type", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$allow_inf", true, &allow_inf,
+                           "$allow_nan", true, &allow_nan,
+                           "$coerce", true, &coerce,
+                           "$allowed_types", false, &allowed_types,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // Allowed types must be a non-empty sequence.
     if (allowed_types != nullptr) {
@@ -1005,15 +942,19 @@ static PyObject* fastnumbers_query_type(PyObject* self, PyObject* args, PyObject
 /**
  * \brief Drop-in replacement for float
  */
-static PyObject* fastnumbers_float(PyObject* self, PyObject* args)
+static PyObject*
+fastnumbers_float(PyObject* self, PyObject* const* args, Py_ssize_t len_args)
 {
     PyObject* input = nullptr;
-    static const char* format = "|O:float";
 
     // Read the function argument - do not accept it as a keyword argument
-    if (!PyArg_ParseTuple(args, format, &input)) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("float", args, len_args, nullptr,
+                           "|", false,  &input,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // No arguments returns 0.0
     if (input == nullptr) {
@@ -1031,21 +972,22 @@ static PyObject* fastnumbers_float(PyObject* self, PyObject* args)
 /**
  * \brief Drop-in replacement for int
  */
-static PyObject* fastnumbers_int(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_int(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     PyObject* pybase = nullptr;
-    static const char* format = "|OO:int";
-
-    // Do not accept number as a keyword argument
-    static const char* keywords[] = { "", "base", nullptr };
 
     // Read the function argument
-    if (!PyArg_ParseTupleAndKeywords(
-            args, kwargs, format, const_cast<char**>(keywords), &input, &pybase
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("int", args, len_args, kwnames,
+                           "|", false,  &input,
+                           "|base", false, &pybase,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // No arguments returns 0
     if (input == nullptr) {
@@ -1068,21 +1010,22 @@ static PyObject* fastnumbers_int(PyObject* self, PyObject* args, PyObject* kwarg
 /**
  * \brief Behaves like float or int, but returns correct type
  */
-static PyObject* fastnumbers_real(PyObject* self, PyObject* args, PyObject* kwargs)
+static PyObject* fastnumbers_real(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
 {
     PyObject* input = nullptr;
     int coerce = true;
-    static const char* format = "|O$p:real";
-
-    // Do not accept number as a keyword argument
-    static const char* keywords[] = { "", "coerce", nullptr };
 
     // Read the function arguments
-    if (!PyArg_ParseTupleAndKeywords(
-            args, kwargs, format, const_cast<char**>(keywords), &input, &coerce
-        )) {
-        return nullptr;
-    }
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("real", args, len_args, kwnames,
+                           "|", false,  &input,
+                           "$coerce", true, &coerce,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
 
     // No arguments returns 0.0 or 0 depending on the state of coerce
     if (input == nullptr) {
@@ -1101,80 +1044,80 @@ static PyObject* fastnumbers_real(PyObject* self, PyObject* args, PyObject* kwar
 static PyMethodDef FastnumbersMethods[] = {
     { "try_real",
       (PyCFunction)fastnumbers_try_real,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       try_real__doc__ },
     { "fast_real",
       (PyCFunction)fastnumbers_fast_real,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       fast_real__doc__ },
     { "try_float",
       (PyCFunction)fastnumbers_try_float,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       try_float__doc__ },
     { "fast_float",
       (PyCFunction)fastnumbers_fast_float,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       fast_float__doc__ },
     { "try_int",
       (PyCFunction)fastnumbers_try_int,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       try_int__doc__ },
     { "fast_int",
       (PyCFunction)fastnumbers_fast_int,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       fast_int__doc__ },
     { "try_forceint",
       (PyCFunction)fastnumbers_try_forceint,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       try_forceint__doc__ },
     { "fast_forceint",
       (PyCFunction)fastnumbers_fast_forceint,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       fast_forceint__doc__ },
     { "check_real",
       (PyCFunction)fastnumbers_check_real,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       check_real__doc__ },
     { "isreal",
       (PyCFunction)fastnumbers_isreal,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       isreal__doc__ },
     { "check_float",
       (PyCFunction)fastnumbers_check_float,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       check_float__doc__ },
     { "isfloat",
       (PyCFunction)fastnumbers_isfloat,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       isfloat__doc__ },
     { "isint",
       (PyCFunction)fastnumbers_isint,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       isint__doc__ },
     { "check_int",
       (PyCFunction)fastnumbers_check_int,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       check_int__doc__ },
     { "isintlike",
       (PyCFunction)fastnumbers_isintlike,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       isintlike__doc__ },
     { "check_intlike",
       (PyCFunction)fastnumbers_check_intlike,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       check_intlike__doc__ },
     { "query_type",
       (PyCFunction)fastnumbers_query_type,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       query_type__doc__ },
     { "int",
       (PyCFunction)fastnumbers_int,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       fastnumbers_int__doc__ },
-    { "float", (PyCFunction)fastnumbers_float, METH_VARARGS, fastnumbers_float__doc__ },
+    { "float", (PyCFunction)fastnumbers_float, METH_FASTCALL, fastnumbers_float__doc__ },
     { "real",
       (PyCFunction)fastnumbers_real,
-      METH_VARARGS | METH_KEYWORDS,
+      METH_FASTCALL | METH_KEYWORDS,
       fastnumbers_real__doc__ },
     { nullptr, nullptr, 0, nullptr } /* Sentinel */
 };
@@ -1201,6 +1144,7 @@ PyObject* Selectors::INPUT = nullptr;
 PyObject* Selectors::RAISE = nullptr;
 PyObject* Selectors::STRING_ONLY = nullptr;
 PyObject* Selectors::NUMBER_ONLY = nullptr;
+PyObject* NumericParser::PYTHON_ZERO = nullptr;
 
 // Actually create the module object itself
 PyMODINIT_FUNC PyInit_fastnumbers()
@@ -1212,10 +1156,6 @@ PyMODINIT_FUNC PyInit_fastnumbers()
 
     // Add module level constants.
     PyModule_AddStringConstant(m, "__version__", FASTNUMBERS_VERSION);
-    PyModule_AddIntConstant(m, "max_int_len", FN_MAX_INT_LEN);
-    PyModule_AddIntConstant(m, "dig", FN_DBL_DIG);
-    PyModule_AddIntConstant(m, "max_exp", FN_MAX_EXP);
-    PyModule_AddIntConstant(m, "min_exp", FN_MIN_EXP);
 
     // Selectors
     Selectors::ALLOWED = PyObject_New(PyObject, &PyBaseObject_Type);
@@ -1244,6 +1184,7 @@ PyMODINIT_FUNC PyInit_fastnumbers()
     Py_DecRef(neg_inf_str);
     Py_DecRef(pos_nan_str);
     Py_DecRef(neg_nan_str);
+    NumericParser::PYTHON_ZERO = PyLong_FromLong(0L);
 
     return m;
 }
diff --git a/src/cpp/parser.cpp b/src/cpp/parser.cpp
index 7bf5902c..d478e12c 100644
--- a/src/cpp/parser.cpp
+++ b/src/cpp/parser.cpp
@@ -3,6 +3,8 @@
 #include "fastnumbers/parser/base.hpp"
 #include "fastnumbers/parser/character.hpp"
 #include "fastnumbers/user_options.hpp"
+#include <Python.h>
+#include <limits>
 
 /**
  * \brief Remove whitespace at the end of a string
@@ -17,11 +19,19 @@
  */
 inline void strip_trailing_whitespace(const char* start, const char*& end)
 {
-    end -= 1;
-    while (start < end && is_whitespace(*end)) {
+    while (start < end && is_whitespace(*(end - 1))) {
         end -= 1;
     }
-    end += 1;
+}
+
+/// Convert a 64-int with the appropriate function depending on the compiler's long size
+inline PyObject* pyobject_from_int64(const int64_t value)
+{
+    if constexpr (std::numeric_limits<long>::max() == std::numeric_limits<int64_t>::max()) {
+        return PyLong_FromLong(static_cast<long>(value));
+    } else {
+        return PyLong_FromLongLong(static_cast<long long>(value));
+    };
 }
 
 CharacterParser::CharacterParser(
@@ -32,6 +42,7 @@ CharacterParser::CharacterParser(
 )
     : Parser(ParserType::CHARACTER, options, explict_base_allowed)
     , m_start(nullptr)
+    , m_start_orig(nullptr)
     , m_end_orig(nullptr)
     , m_str_len(0)
 {
@@ -42,7 +53,7 @@ CharacterParser::CharacterParser(
     }
 
     // Store the start and end point of the character array
-    m_start = str;
+    m_start = m_start_orig = str;
     const char* end = m_end_orig = str + len;
 
     // Strip leading whitespace
@@ -66,50 +77,40 @@ CharacterParser::CharacterParser(
     m_str_len = static_cast<std::size_t>(end - m_start);
 }
 
-long CharacterParser::as_int()
-{
-    return as_type<long>(is_likely_int, int_might_overflow, parse_int);
-}
-
-double CharacterParser::as_float()
-{
-    return as_type<double>(is_likely_float, float_might_overflow, parse_float);
-}
-
 PyObject* CharacterParser::as_pyint()
 {
     reset_error();
 
-    // If the number is negative, include the sign as part of the string
-    const std::size_t offset = std::size_t(is_negative());
-    const char* start = m_start - offset;
-
-    // Attempt to pre-detect if the string is a valid integer.
-    // it is cheaper to do this than to let Python do that and construct an exception.
-    // Need to account for underscores if they exist and we are allowing them.
-    Buffer buffer;
-    const char* my_end = m_end_orig;
-    const bool is_integer = check_string_for_number(
-        buffer,
-        start,
-        my_end,
-        offset,
-        [&](const char* start, const char* end) -> bool {
-            return string_contains_what(start, end, options().get_base()) == 1;
-        }
-    );
-    if (!is_integer) {
+    // We use the fast path method even if the result overflows,
+    // so that we can determine if the integer was at least valid.
+    // If it was valid but overflowed, we use Python's parser, otherwise
+    // return an error.
+    // The only thing special handling we need is underscores.
+    bool error;
+    bool overflow;
+    int64_t result = parse_int(m_start, end(), options().get_base(), error, overflow);
+    if (error && has_valid_underscores()) {
+        Buffer buffer(m_start, m_str_len);
+        buffer.remove_valid_underscores(options().get_base() != 10);
+        result = parse_int(
+            buffer.start(), buffer.end(), options().get_base(), error, overflow
+        );
+    }
+    if (error) {
         encountered_conversion_error();
         return nullptr;
     }
+    if (!overflow) {
+        return pyobject_from_int64(sign() * result);
+    }
 
     // Parse and record the location where parsing ended (including trailing whitespace)
     char* their_end = nullptr;
-    PyObject* retval = PyLong_FromString(start, &their_end, options().get_base());
+    PyObject* retval = PyLong_FromString(m_start_orig, &their_end, options().get_base());
 
     // Check the parsed end against the original end - if they don't match
     // there was a parsing error.
-    if (their_end != my_end && retval != nullptr) {
+    if (their_end != m_end_orig && retval != nullptr) {
         encountered_conversion_error();
         return nullptr;
     }
@@ -118,50 +119,51 @@ PyObject* CharacterParser::as_pyint()
     return retval;
 }
 
-PyObject* CharacterParser::as_pyfloat()
+double CharacterParser::as_double()
 {
     reset_error();
 
-    // If the number is negative, include the sign as part of the string
-    const std::size_t offset = std::size_t(is_negative());
-    const char* start = m_start - offset;
-
-    // Attempt to pre-detect if the string is a valid integer.
-    // it is cheaper to do this than to let Python do that and construct an exception.
-    // Need to account for underscores if they exist and we are allowing them.
-    double retval = -1.0;
-    char* their_end = nullptr;
-    Buffer buffer;
-    const char* my_end = end();
-    const bool is_float = check_string_for_number(
-        buffer,
-        start,
-        my_end,
-        offset,
-        [](const char* start, const char* end) -> bool {
-            return string_contains_what(start, end, 10) > 0;
-        }
-    );
-    if (!is_float) {
+    // The C++ parser is robust enough to handle any double properly,
+    // so there is no need to fall back on Python's parser.
+    // The only thing special handling we need is underscores.
+    bool error;
+    double result = parse_float(m_start, end(), error);
+    if (error && has_valid_underscores()) {
+        Buffer buffer(m_start, m_str_len);
+        buffer.remove_valid_underscores();
+        result = parse_float(buffer.start(), buffer.end(), error);
+    }
+    if (error) {
         encountered_conversion_error();
-        return nullptr;
+        return -1.0;
     }
-    strip_trailing_whitespace(start, my_end);
+    return sign() * result;
+}
+
+PyObject* CharacterParser::as_pyfloat()
+{
+    const double result = as_double();
+    return errored() ? nullptr : PyFloat_FromDouble(result);
+}
 
-    // Parse and record the location where parsing ended (excluding trailing whitespace)
-    retval = PyOS_string_to_double(start, &their_end, nullptr);
+PyObject* CharacterParser::as_pyfloat(const bool force_int, const bool coerce)
+{
+    const double result = as_double();
 
-    // If an exception was raised propagate it. If the full string was not parsed, raise
-    // an error also.
-    if (retval == -1.0 && PyErr_Occurred()) {
-        return nullptr;
-    } else if (their_end != my_end) {
-        encountered_conversion_error();
+    // Fail fast on error
+    if (errored()) {
         return nullptr;
     }
 
-    // Return the value as a python object
-    return PyFloat_FromDouble(retval);
+    // force_int takes precidence, and coerce conditionally returns as an integer
+    if (force_int) {
+        return PyLong_FromDouble(result);
+    } else if (coerce) {
+        return Parser::float_is_intlike(result) ? PyLong_FromDouble(result)
+                                                : PyFloat_FromDouble(result);
+    } else {
+        return PyFloat_FromDouble(result);
+    }
 }
 
 NumberFlags CharacterParser::get_number_type() const
@@ -205,91 +207,3 @@ NumberFlags CharacterParser::get_number_type() const
     // Return the found type
     return type_mapping[value];
 }
-
-template <
-    typename T,
-    typename CheckFunction,
-    typename OverflowCheckFunction,
-    typename ConvertFunction>
-T CharacterParser::as_type(
-    CheckFunction check_function,
-    OverflowCheckFunction overflow_check_function,
-    ConvertFunction convert_function
-)
-{
-    reset_error();
-
-    // Do a quick check if the input likely contains the desired type
-    if (check_function(m_start, m_str_len)) {
-
-        // If the number will be too long report an overflow error
-        if (overflow_check_function(m_start, m_str_len)) {
-            if (has_invalid_underscores()) {
-                encountered_conversion_error();
-            } else {
-                encountered_potential_overflow_error();
-            }
-            return static_cast<T>(-1);
-        }
-
-        // Convert to the desired type - handle the special case
-        // of underscores in the string by removing them and trying again
-        bool error = false;
-        T result = convert_function(m_start, end(), error);
-        if (!error) {
-            return sign() * result;
-        } else if (has_valid_underscores()) {
-            Buffer buffer(m_start, m_str_len);
-            buffer.remove_valid_underscores();
-            result = convert_function(buffer.start(), buffer.end(), error);
-            if (!error) {
-                return sign() * result;
-            }
-        }
-    }
-
-    // Any non-success above ends up here, record as failure
-    encountered_conversion_error();
-    return static_cast<T>(-1);
-}
-
-template <typename Function>
-bool CharacterParser::check_string_for_number(
-    Buffer& buffer,
-    const char*& start,
-    const char*& original_end,
-    const std::size_t offset,
-    Function string_contains_number
-)
-{
-    if (!string_contains_number(m_start, end())) {
-        // If it does not contain a number, see if it is because of underscores.
-        // If so, remove them and try again.
-        // Otherwise, it does not contain a number.
-        if (has_valid_underscores()) {
-            const std::size_t len = static_cast<std::size_t>(original_end - start);
-            buffer.copy(start, len);
-            buffer.remove_valid_underscores(options().get_base() != 10);
-            const char* b_start = buffer.start() + offset;
-            const char* b_end = buffer.end();
-            strip_trailing_whitespace(b_start, b_end);
-            if (!string_contains_number(b_start, b_end)) {
-                return false;
-            }
-            start = buffer.start();
-            original_end = buffer.end();
-        } else {
-            return false;
-        }
-    }
-
-    // If here, the string for sure contains the number
-    return true;
-}
-
-void Buffer::remove_valid_underscores(const bool based)
-{
-    const char* new_end = end();
-    ::remove_valid_underscores(start(), new_end, based);
-    m_len = static_cast<std::size_t>(new_end - start());
-}
diff --git a/src/fastnumbers/__init__.py b/src/fastnumbers/__init__.py
index 3d7dddc9..a7abda4c 100644
--- a/src/fastnumbers/__init__.py
+++ b/src/fastnumbers/__init__.py
@@ -10,7 +10,6 @@
     check_int,
     check_intlike,
     check_real,
-    dig,
     fast_float,
     fast_forceint,
     fast_int,
@@ -21,9 +20,6 @@
     isint,
     isintlike,
     isreal,
-    max_exp,
-    max_int_len,
-    min_exp,
     query_type,
     real,
     try_float,
@@ -44,7 +40,6 @@
     "check_int",
     "check_intlike",
     "check_real",
-    "dig",
     "fast_float",
     "fast_forceint",
     "fast_int",
@@ -55,9 +50,6 @@
     "isint",
     "isintlike",
     "isreal",
-    "max_exp",
-    "max_int_len",
-    "min_exp",
     "query_type",
     "real",
     "try_float",
diff --git a/src/fastnumbers/fastnumbers.pyi b/src/fastnumbers/fastnumbers.pyi
index a6408321..722103ba 100644
--- a/src/fastnumbers/fastnumbers.pyi
+++ b/src/fastnumbers/fastnumbers.pyi
@@ -14,10 +14,6 @@ from typing import (
 from typing_extensions import Protocol
 
 __version__: str
-max_int_len: pyint
-dig: pyint
-max_exp: pyint
-min_exp: pyint
 
 class HasIndex(Protocol):
     def __index__(self) -> pyint: ...
diff --git a/tox.ini b/tox.ini
index 1a8b374f..982ad03f 100644
--- a/tox.ini
+++ b/tox.ini
@@ -11,7 +11,7 @@ envlist = py37, py38, py39, py310
 #   docs
 #   bump
 #   clean
-#   py{37,38}-nb  (to update the Jupyter Notebooks}
+#   py{37,38,39,310}-prof  (to update the profiling script}
 
 # Don't error out if a user hasn't installed all python versions.
 skip_missing_interpreters =
@@ -85,13 +85,19 @@ skip_install = true
 deps =
 commands = {envpython} dev/clean.py
 
-# For running jupyter notebooks.
-[testenv:py37-nb]
+# For running profiling.
+[testenv:py37-prof]
 skip_install = false
-deps = jupyter
-commands = jupyter notebook TIMING_37.ipynb
+commands = {envpython} profiling/profile.py profiling/results-3.7.md
 
-[testenv:py38-nb]
+[testenv:py38-prof]
 skip_install = false
-deps = jupyter
-commands = jupyter notebook TIMING_38.ipynb
+commands = {envpython} profiling/profile.py profiling/results-3.8.md
+
+[testenv:py39-prof]
+skip_install = false
+commands = {envpython} profiling/profile.py profiling/results-3.9.md
+
+[testenv:py310-prof]
+skip_install = false
+commands = {envpython} profiling/profile.py profiling/results-3.10.md


Test patch:
diff --git a/tests/test_fastnumbers.py b/tests/test_fastnumbers.py
index ec16c051..805c23cb 100644
--- a/tests/test_fastnumbers.py
+++ b/tests/test_fastnumbers.py
@@ -384,10 +384,16 @@ def test_key(self, func: Any) -> None:
 
     old_to_new_conversion_pairing = []
     func_pairs: List[Tuple[Callable[[Any], Any], Callable[[Any], Any]]] = [
-        (fastnumbers.fast_real, fastnumbers.try_real),
-        (fastnumbers.fast_float, fastnumbers.try_float),
-        (fastnumbers.fast_int, fastnumbers.try_int),
-        (fastnumbers.fast_forceint, fastnumbers.try_forceint),
+        (partial(fastnumbers.fast_real, allow_underscores=False), fastnumbers.try_real),
+        (
+            partial(fastnumbers.fast_float, allow_underscores=False),
+            fastnumbers.try_float,
+        ),
+        (partial(fastnumbers.fast_int, allow_underscores=False), fastnumbers.try_int),
+        (
+            partial(fastnumbers.fast_forceint, allow_underscores=False),
+            fastnumbers.try_forceint,
+        ),
     ]
     for old, new in func_pairs:
         old_to_new_conversion_pairing += [
@@ -426,10 +432,16 @@ def test_old_to_new_conversion_equivalence(
 
     old_to_new_checking_pairing = []
     func_pairs = [
-        (fastnumbers.isreal, fastnumbers.check_real),
-        (fastnumbers.isfloat, fastnumbers.check_float),
-        (fastnumbers.isint, fastnumbers.check_int),
-        (fastnumbers.isintlike, fastnumbers.check_intlike),
+        (partial(fastnumbers.isreal, allow_underscores=False), fastnumbers.check_real),
+        (
+            partial(fastnumbers.isfloat, allow_underscores=False),
+            fastnumbers.check_float,
+        ),
+        (partial(fastnumbers.isint, allow_underscores=False), fastnumbers.check_int),
+        (
+            partial(fastnumbers.isintlike, allow_underscores=False),
+            fastnumbers.check_intlike,
+        ),
     ]
     for old, new in func_pairs:
         old_to_new_checking_pairing += [
@@ -1188,6 +1200,7 @@ def test_given_unicode_numeral_returns_true(
     @example("e")
     @example("e8")
     @example(".")
+    @example(b"0e\x00")
     @parametrize("func", get_funcs(funcs), ids=funcs)
     def test_returns_false_if_given_non_number_string(
         self, func: IdentificationFuncs, x: str
diff --git a/tests/test_fastnumbers_examples.py b/tests/test_fastnumbers_examples.py
index 68444138..2b3d4bc5 100644
--- a/tests/test_fastnumbers_examples.py
+++ b/tests/test_fastnumbers_examples.py
@@ -1,10 +1,8 @@
 # -*- coding: utf-8 -*-
 # Find the build location and add that to the path
 import math
-import sys
-from typing import Callable, Iterator, List, cast
+from typing import cast
 
-import pytest
 from pytest import raises
 
 import fastnumbers
@@ -560,25 +558,3 @@ def test_type() -> None:
     assert fastnumbers.query_type("⁸") is int
     assert fastnumbers.query_type("⅔") is float
     assert fastnumbers.query_type("Ⅴ") is float
-
-
-@pytest.fixture()
-def tprint(capsys: pytest.CaptureFixture[str]) -> Iterator[Callable[[str], None]]:
-    """
-    Fixture for printing info after test, not supressed by pytest stdout/stderr capture
-    """
-    lines: List[str] = []
-    yield lines.append
-
-    with capsys.disabled():
-        for line in lines:
-            sys.stdout.write("\n{}".format(line))
-
-
-def test_print_limits(tprint: Callable[[str], None]) -> None:
-    tprint("\nFASNUMBERS NUMERICAL LIMITS FOR THIS COMPILER BEFORE PYTHON FALLBACK:")
-    tprint("MAXIMUM INTEGER LENTH: {}".format(fastnumbers.max_int_len))
-    tprint("MAX NUMBER FLOAT DIGITS: {}".format(fastnumbers.dig))
-    tprint("MAXIMUM FLOAT EXPONENT: {}".format(fastnumbers.max_exp))
-    tprint("MINIMUM FLOAT EXPONENT: {}".format(fastnumbers.min_exp))
-    tprint("")