text: //     Copyright 2020, Kay Hayen, mailto:kay.hayen@gmail.com
  //
  //     Part of "Nuitka", an optimizing Python compiler that is compatible and
  //     integrates with CPython, but also works on its own.
  //
  //     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
  //     limitations under the License.
  //
  /* WARNING, this code is GENERATED. Modify the template HelperOperationBinary.c.j2 instead! */
  
  /* This file is included from another C file, help IDEs to still parse it on its own. */
  #ifdef __IDE_ONLY__
  #include "nuitka/prelude.h"
  #endif
  
  #include "HelpersOperationBinaryDivmodUtils.c"
  /* C helpers for type specialized "divmod" (DIVMOD) operations */
  
  /* Disable warnings about unused goto targets for compilers */
  
  #ifdef _MSC_VER
  #pragma warning(push)
  #pragma warning(disable : 4102)
  #endif
  #ifdef __GNUC__
  #pragma GCC diagnostic ignored "-Wunused-label"
  #endif
  
  #if PYTHON_VERSION < 0x300
  static inline PyObject *SLOT_nb_divmod_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyInt_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
      assert(PyInt_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      const long a = PyInt_AS_LONG(operand1);
      const long b = PyInt_AS_LONG(operand2);
  
      if (unlikely(b == 0)) {
          SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_ZeroDivisionError, "integer division or modulo by zero");
          return NULL;
      }
  
      if (likely(b != -1 || !UNARY_NEG_WOULD_OVERFLOW(a))) {
          long a_div_b = a / b;
          long a_mod_b = (long)(a - (unsigned long)a_div_b * b);
  
          if (a_mod_b && (b ^ a_mod_b) < 0) {
              a_mod_b += b;
              a_div_b -= 1;
          }
  
          return Py_BuildValue("(ll)", a_div_b, a_mod_b);
      }
      {
          PyObject *op1 = operand1;
          PyObject *op2 = operand2;
  
          // TODO: Could in-line and specialize these as well.
          PyObject *o = PyLong_Type.tp_as_number->nb_divmod(op1, op2);
          assert(o != Py_NotImplemented);
  
          return o;
      }
  }
  /* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyInt_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
      assert(PyInt_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      return SLOT_nb_divmod_OBJECT_INT_INT(operand1, operand2);
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_INT_INT(operand1, operand2);
  }
  #endif
  
  #if PYTHON_VERSION < 0x300
  /* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      CHECK_OBJECT(operand2);
      assert(PyInt_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      PyTypeObject *type1 = Py_TYPE(operand1);
      binaryfunc slot1 =
          (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_divmod : NULL;
  
      PyTypeObject *type2 = &PyInt_Type;
      binaryfunc slot2 = NULL;
  
      if (!(type1 == type2)) {
          assert(type1 != type2);
          /* Different types, need to consider second value slot. */
  
          slot2 = PyInt_Type.tp_as_number->nb_divmod;
  
          if (slot1 == slot2) {
              slot2 = NULL;
          }
      } else {
          assert(type1 == type2);
  
          return SLOT_nb_divmod_OBJECT_INT_INT(operand1, operand2);
      }
  
      if (slot1 != NULL) {
          if (slot2 != NULL) {
              if (0) {
                  PyObject *x = slot2(operand1, operand2);
  
                  if (x != Py_NotImplemented) {
                      return x;
                  }
  
                  Py_DECREF(x);
                  slot2 = NULL;
              }
          }
  
          PyObject *x = slot1(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
      if (slot2 != NULL) {
          PyObject *x = slot2(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
  #if PYTHON_VERSION < 0x300 && (1 || 1)
      if (!NEW_STYLE_NUMBER_TYPE(type1) || !1) {
          coercion c =
              (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced1, &coerced2);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
  
          c = PyInt_Type.tp_as_number->nb_coerce;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced2, &coerced1);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
      }
  #endif
  
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): '%s' and 'int'", type1->tp_name);
      return NULL;
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_INT(operand1, operand2);
  }
  #endif
  
  #if PYTHON_VERSION < 0x300
  /* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyInt_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
  
      PyTypeObject *type1 = &PyInt_Type;
      binaryfunc slot1 = PyInt_Type.tp_as_number->nb_divmod;
  
      PyTypeObject *type2 = Py_TYPE(operand2);
      binaryfunc slot2 = NULL;
  
      if (!(type1 == type2)) {
          assert(type1 != type2);
          /* Different types, need to consider second value slot. */
  
          slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_divmod : NULL;
  
          if (slot1 == slot2) {
              slot2 = NULL;
          }
      } else {
          assert(type1 == type2);
  
          return SLOT_nb_divmod_OBJECT_INT_INT(operand1, operand2);
      }
  
      if (slot1 != NULL) {
          if (slot2 != NULL) {
              if (PyType_IsSubtype(type2, type1)) {
                  PyObject *x = slot2(operand1, operand2);
  
                  if (x != Py_NotImplemented) {
                      return x;
                  }
  
                  Py_DECREF(x);
                  slot2 = NULL;
              }
          }
  
          PyObject *x = slot1(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
      if (slot2 != NULL) {
          PyObject *x = slot2(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
  #if PYTHON_VERSION < 0x300 && (1 || 1)
      if (!1 || !NEW_STYLE_NUMBER_TYPE(type2)) {
          coercion c = PyInt_Type.tp_as_number->nb_coerce;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced1, &coerced2);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
  
          c = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced2, &coerced1);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
      }
  #endif
  
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): 'int' and '%s'", type2->tp_name);
      return NULL;
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_INT_OBJECT(operand1, operand2);
  }
  #endif
  
  static PyObject *SLOT_nb_divmod_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
      PyObject *x = PyLong_Type.tp_as_number->nb_divmod(operand1, operand2);
      assert(x != Py_NotImplemented);
      return x;
  }
  /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyLong_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
      assert(PyLong_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      return SLOT_nb_divmod_OBJECT_LONG_LONG(operand1, operand2);
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_LONG_LONG(operand1, operand2);
  }
  
  /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      CHECK_OBJECT(operand2);
      assert(PyLong_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      PyTypeObject *type1 = Py_TYPE(operand1);
      binaryfunc slot1 =
          (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_divmod : NULL;
  
      PyTypeObject *type2 = &PyLong_Type;
      binaryfunc slot2 = NULL;
  
      if (!(type1 == type2)) {
          assert(type1 != type2);
          /* Different types, need to consider second value slot. */
  
          slot2 = PyLong_Type.tp_as_number->nb_divmod;
  
          if (slot1 == slot2) {
              slot2 = NULL;
          }
      } else {
          assert(type1 == type2);
  
          return SLOT_nb_divmod_OBJECT_LONG_LONG(operand1, operand2);
      }
  
      if (slot1 != NULL) {
          if (slot2 != NULL) {
              if (0) {
                  PyObject *x = slot2(operand1, operand2);
  
                  if (x != Py_NotImplemented) {
                      return x;
                  }
  
                  Py_DECREF(x);
                  slot2 = NULL;
              }
          }
  
          PyObject *x = slot1(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
      if (slot2 != NULL) {
          PyObject *x = slot2(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
  #if PYTHON_VERSION < 0x300 && (1 || 1)
      if (!NEW_STYLE_NUMBER_TYPE(type1) || !1) {
          coercion c =
              (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced1, &coerced2);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
  
          c = PyLong_Type.tp_as_number->nb_coerce;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced2, &coerced1);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
      }
  #endif
  
  #if PYTHON_VERSION < 0x300
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): '%s' and 'long'", type1->tp_name);
  #else
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): '%s' and 'int'", type1->tp_name);
  #endif
      return NULL;
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_LONG(operand1, operand2);
  }
  
  /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyLong_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
  
      PyTypeObject *type1 = &PyLong_Type;
      binaryfunc slot1 = PyLong_Type.tp_as_number->nb_divmod;
  
      PyTypeObject *type2 = Py_TYPE(operand2);
      binaryfunc slot2 = NULL;
  
      if (!(type1 == type2)) {
          assert(type1 != type2);
          /* Different types, need to consider second value slot. */
  
          slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_divmod : NULL;
  
          if (slot1 == slot2) {
              slot2 = NULL;
          }
      } else {
          assert(type1 == type2);
  
          return SLOT_nb_divmod_OBJECT_LONG_LONG(operand1, operand2);
      }
  
      if (slot1 != NULL) {
          if (slot2 != NULL) {
              if (PyType_IsSubtype(type2, type1)) {
                  PyObject *x = slot2(operand1, operand2);
  
                  if (x != Py_NotImplemented) {
                      return x;
                  }
  
                  Py_DECREF(x);
                  slot2 = NULL;
              }
          }
  
          PyObject *x = slot1(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
      if (slot2 != NULL) {
          PyObject *x = slot2(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
  #if PYTHON_VERSION < 0x300 && (1 || 1)
      if (!1 || !NEW_STYLE_NUMBER_TYPE(type2)) {
          coercion c = PyLong_Type.tp_as_number->nb_coerce;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced1, &coerced2);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
  
          c = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced2, &coerced1);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
      }
  #endif
  
  #if PYTHON_VERSION < 0x300
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): 'long' and '%s'", type2->tp_name);
  #else
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): 'int' and '%s'", type2->tp_name);
  #endif
      return NULL;
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_LONG_OBJECT(operand1, operand2);
  }
  
  static PyObject *SLOT_nb_divmod_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyFloat_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
      assert(PyFloat_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      double a = PyFloat_AS_DOUBLE(operand1);
      double b = PyFloat_AS_DOUBLE(operand2);
  
      if (b == 0.0) {
          SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_ZeroDivisionError, "float modulo");
          return NULL;
      }
  
      double mod = fmod(a, b);
      double div = (a - mod) / b;
  
      if (mod) {
          if ((a < 0) != (mod < 0)) {
              mod += b;
              div -= 1.0;
          }
      } else {
          mod = copysign(0.0, b);
      }
  
      double floordiv;
      if (div) {
          floordiv = floor(div);
          if (div - floordiv > 0.5) {
              floordiv += 1.0;
          }
      } else {
          floordiv = copysign(0.0, a / b);
      }
  
      return Py_BuildValue("(dd)", floordiv, mod);
  }
  /* Code referring to "FLOAT" corresponds to Python 'float' and "FLOAT" to Python 'float'. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyFloat_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
      assert(PyFloat_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      return SLOT_nb_divmod_OBJECT_FLOAT_FLOAT(operand1, operand2);
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_FLOAT(operand1, operand2);
  }
  
  /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      CHECK_OBJECT(operand2);
      assert(PyFloat_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
      PyTypeObject *type1 = Py_TYPE(operand1);
      binaryfunc slot1 =
          (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_divmod : NULL;
  
      PyTypeObject *type2 = &PyFloat_Type;
      binaryfunc slot2 = NULL;
  
      if (!(type1 == type2)) {
          assert(type1 != type2);
          /* Different types, need to consider second value slot. */
  
          slot2 = PyFloat_Type.tp_as_number->nb_divmod;
  
          if (slot1 == slot2) {
              slot2 = NULL;
          }
      } else {
          assert(type1 == type2);
  
          return SLOT_nb_divmod_OBJECT_FLOAT_FLOAT(operand1, operand2);
      }
  
      if (slot1 != NULL) {
          if (slot2 != NULL) {
              if (0) {
                  PyObject *x = slot2(operand1, operand2);
  
                  if (x != Py_NotImplemented) {
                      return x;
                  }
  
                  Py_DECREF(x);
                  slot2 = NULL;
              }
          }
  
          PyObject *x = slot1(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
      if (slot2 != NULL) {
          PyObject *x = slot2(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
  #if PYTHON_VERSION < 0x300 && (1 || 1)
      if (!NEW_STYLE_NUMBER_TYPE(type1) || !1) {
          coercion c =
              (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced1, &coerced2);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
  
          c = PyFloat_Type.tp_as_number->nb_coerce;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced2, &coerced1);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
      }
  #endif
  
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): '%s' and 'float'", type1->tp_name);
      return NULL;
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_FLOAT(operand1, operand2);
  }
  
  /* Code referring to "FLOAT" corresponds to Python 'float' and "OBJECT" to any Python object. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      assert(PyFloat_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
      assert(NEW_STYLE_NUMBER(operand1));
  #endif
      CHECK_OBJECT(operand2);
  
      PyTypeObject *type1 = &PyFloat_Type;
      binaryfunc slot1 = PyFloat_Type.tp_as_number->nb_divmod;
  
      PyTypeObject *type2 = Py_TYPE(operand2);
      binaryfunc slot2 = NULL;
  
      if (!(type1 == type2)) {
          assert(type1 != type2);
          /* Different types, need to consider second value slot. */
  
          slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_divmod : NULL;
  
          if (slot1 == slot2) {
              slot2 = NULL;
          }
      } else {
          assert(type1 == type2);
  
          return SLOT_nb_divmod_OBJECT_FLOAT_FLOAT(operand1, operand2);
      }
  
      if (slot1 != NULL) {
          if (slot2 != NULL) {
              if (PyType_IsSubtype(type2, type1)) {
                  PyObject *x = slot2(operand1, operand2);
  
                  if (x != Py_NotImplemented) {
                      return x;
                  }
  
                  Py_DECREF(x);
                  slot2 = NULL;
              }
          }
  
          PyObject *x = slot1(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
      if (slot2 != NULL) {
          PyObject *x = slot2(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
  #if PYTHON_VERSION < 0x300 && (1 || 1)
      if (!1 || !NEW_STYLE_NUMBER_TYPE(type2)) {
          coercion c = PyFloat_Type.tp_as_number->nb_coerce;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced1, &coerced2);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
  
          c = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced2, &coerced1);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
      }
  #endif
  
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): 'float' and '%s'", type2->tp_name);
      return NULL;
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_FLOAT_OBJECT(operand1, operand2);
  }
  
  /* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
  static PyObject *_BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
      CHECK_OBJECT(operand1);
      CHECK_OBJECT(operand2);
  
  #if PYTHON_VERSION < 0x300
      if (PyInt_CheckExact(operand1) && PyInt_CheckExact(operand2)) {
  
          PyObject *result;
  
          CHECK_OBJECT(operand1);
          assert(PyInt_CheckExact(operand1));
  #if PYTHON_VERSION < 0x300
          assert(NEW_STYLE_NUMBER(operand1));
  #endif
          CHECK_OBJECT(operand2);
          assert(PyInt_CheckExact(operand2));
  #if PYTHON_VERSION < 0x300
          assert(NEW_STYLE_NUMBER(operand2));
  #endif
  
          const long a = PyInt_AS_LONG(operand1);
          const long b = PyInt_AS_LONG(operand2);
  
          if (unlikely(b == 0)) {
              SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_ZeroDivisionError, "integer division or modulo by zero");
              goto exit_result_exception;
          }
  
          if (likely(b != -1 || !UNARY_NEG_WOULD_OVERFLOW(a))) {
              long a_div_b = a / b;
              long a_mod_b = (long)(a - (unsigned long)a_div_b * b);
  
              if (a_mod_b && (b ^ a_mod_b) < 0) {
                  a_mod_b += b;
                  a_div_b -= 1;
              }
  
              result = Py_BuildValue("(ll)", a_div_b, a_mod_b);
              goto exit_result_ok;
          }
  
          {
              PyObject *operand1_object = operand1;
              PyObject *operand2_object = operand2;
  
              PyObject *o = PyLong_Type.tp_as_number->nb_divmod(operand1_object, operand2_object);
              assert(o != Py_NotImplemented);
  
              result = o;
              goto exit_result;
          }
  
      exit_result:
  
          if (unlikely(result == NULL)) {
              return NULL;
          }
  
      exit_result_ok:
  
          return result;
  
      exit_result_exception:
          return NULL;
      }
  #endif
  
      PyTypeObject *type1 = Py_TYPE(operand1);
      binaryfunc slot1 =
          (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_divmod : NULL;
  
      PyTypeObject *type2 = Py_TYPE(operand2);
      binaryfunc slot2 = NULL;
  
      if (!(type1 == type2)) {
          assert(type1 != type2);
          /* Different types, need to consider second value slot. */
  
          slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_divmod : NULL;
  
          if (slot1 == slot2) {
              slot2 = NULL;
          }
      } else {
          assert(type1 == type2);
      }
  
      if (slot1 != NULL) {
          if (slot2 != NULL) {
              if (PyType_IsSubtype(type2, type1)) {
                  PyObject *x = slot2(operand1, operand2);
  
                  if (x != Py_NotImplemented) {
                      return x;
                  }
  
                  Py_DECREF(x);
                  slot2 = NULL;
              }
          }
  
          PyObject *x = slot1(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
      if (slot2 != NULL) {
          PyObject *x = slot2(operand1, operand2);
  
          if (x != Py_NotImplemented) {
              return x;
          }
  
          Py_DECREF(x);
      }
  
  #if PYTHON_VERSION < 0x300 && (1 || 1)
      if (!NEW_STYLE_NUMBER_TYPE(type1) || !NEW_STYLE_NUMBER_TYPE(type2)) {
          coercion c =
              (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced1, &coerced2);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
  
          c = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
  
          if (c != NULL) {
              PyObject *coerced1 = operand1;
              PyObject *coerced2 = operand2;
  
              int err = c(&coerced2, &coerced1);
  
              if (unlikely(err < 0)) {
                  return NULL;
              }
  
              if (err == 0) {
                  PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
  
                  if (likely(mv == NULL)) {
                      binaryfunc slot = mv->nb_divmod;
  
                      if (likely(slot != NULL)) {
                          PyObject *x = slot(coerced1, coerced2);
  
                          Py_DECREF(coerced1);
                          Py_DECREF(coerced2);
  
                          return x;
                      }
                  }
  
                  // nb_coerce took a reference.
                  Py_DECREF(coerced1);
                  Py_DECREF(coerced2);
              }
          }
      }
  #endif
  
      PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for divmod(): '%s' and '%s'", type1->tp_name,
                   type2->tp_name);
      return NULL;
  }
  
  PyObject *BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
      return _BINARY_OPERATION_DIVMOD_OBJECT_OBJECT_OBJECT(operand1, operand2);
  }
  
  /* Reneable warnings about unused goto targets for compilers */
  #ifdef _MSC_VER
  #pragma warning(pop)
  #endif
  #ifdef __GNUC__
  #pragma GCC diagnostic warning "-Wunused-label"
  #endif
  