From d3d0b450bbc7e89203b55a7d8339a32378d34f22 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Tue, 18 Jan 2022 07:09:33 +0800
Subject: [PATCH 01/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 109 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 1b2d1266c6bc5f..a448b31fc6fe63 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1635,6 +1635,38 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
     return (digit)rem;
 }
 
+/* Remiander of long pin, w/ size digits, by non-zero digit n,
+   returning the remainder. pin points at the LSD. */
+
+static digit
+inplace_rem1(digit *pin, Py_ssize_t size, digit n)
+{
+    twodigits rem = 0;
+
+    assert(n > 0 && n <= PyLong_MASK);
+    pin += size;
+    while (--size >= 0) {
+        rem = (rem << PyLong_SHIFT) | *--pin;
+        rem %= n;
+    }
+    return (digit)rem;
+}
+
+/* Get the remainder of an integer divided by a digit, returning
+   the remainder as the result of the function. The sign of a is
+   ignored; n should not be zero. */
+
+static PyLongObject *
+rem1(PyLongObject *a, digit n)
+{
+    const Py_ssize_t size = Py_ABS(Py_SIZE(a));
+
+    assert(n > 0 && n <= PyLong_MASK);
+    return (PyLongObject *)PyLong_FromLong(
+        (long)inplace_rem1(a->ob_digit, size, n)
+    );
+}
+
 /* Divide an integer by a digit, returning both the quotient
    (as function result) and the remainder (through *prem).
    The sign of a is ignored; n should not be zero. */
@@ -2672,6 +2704,47 @@ long_divrem(PyLongObject *a, PyLongObject *b,
     return 0;
 }
 
+/* Int remainder, top-level routine */
+
+static int
+long_rem(PyLongObject *a, PyLongObject *b, PyLongObject **prem)
+{
+    Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b));
+
+    if (size_b == 0) {
+        PyErr_SetString(PyExc_ZeroDivisionError,
+                        "integer modulo by zero");
+        return -1;
+    }
+    if (size_a < size_b ||
+        (size_a == size_b &&
+         a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) {
+        /* |a| < |b|. */
+        *prem = (PyLongObject *)long_long((PyObject *)a);
+        return -(*prem == NULL);
+    }
+    if (size_b == 1) {
+        *prem = rem1(a, b->ob_digit[0]);
+        if (*prem == NULL)
+            return -1;
+    }
+    else {
+        /* Slow path using divrem. */
+        x_divrem(a, b, prem);
+        if (*prem == NULL)
+            return -1;
+    }
+    /* Set the sign. */
+    if (Py_SIZE(a) < 0 && Py_SIZE(*prem) != 0) {
+        _PyLong_Negate(prem);
+        if (*prem == NULL) {
+            Py_CLEAR(*prem);
+            return -1;
+        }
+    }
+    return 0;
+}
+
 /* Unsigned int division with remainder -- the algorithm.  The arguments v1
    and w1 should satisfy 2 <= Py_ABS(Py_SIZE(w1)) <= Py_ABS(Py_SIZE(v1)). */
 
@@ -3790,6 +3863,42 @@ l_divmod(PyLongObject *v, PyLongObject *w,
     return 0;
 }
 
+/* Compute
+ *     *pmod = mod(v)
+ * NULL can be passed for pmod, in which case the function
+ * never runs code.  The caller owns a reference to
+ * each of these it requests (does not pass NULL for).
+ */
+static int
+l_mod(PyLongObject *v, PyLongObject *w, PyLongObject **pmod)
+{
+    PyLongObject *mod;
+
+    if (pmod == NULL)
+        return 0;
+    if (Py_ABS(Py_SIZE(v)) == 1 && Py_ABS(Py_SIZE(w)) == 1) {
+        /* Fast path for single-digit longs */
+        *pmod = (PyLongObject *)fast_mod(v, w);
+        return -(*pmod == NULL);
+    }
+    if (long_rem(v, w, &mod) < 0)
+        return -1;
+    if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) ||
+        (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) {
+        PyLongObject *temp;
+        temp = (PyLongObject *) long_add(mod, w);
+        Py_DECREF(mod);
+        mod = temp;
+        if (mod == NULL) {
+            Py_DECREF(div);
+            return -1;
+        }
+    }
+    *pmod = mod;
+
+    return 0;
+}
+
 static PyObject *
 long_div(PyObject *a, PyObject *b)
 {

From 39b9c09c2f9defd7930f1135601e9fd3829c24eb Mon Sep 17 00:00:00 2001
From: "blurb-it[bot]" <43283697+blurb-it[bot]@users.noreply.github.com>
Date: Mon, 17 Jan 2022 23:12:02 +0000
Subject: [PATCH 02/17] =?UTF-8?q?=F0=9F=93=9C=F0=9F=A4=96=20Added=20by=20b?=
 =?UTF-8?q?lurb=5Fit.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst   | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst

diff --git a/Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst b/Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst
new file mode 100644
index 00000000000000..68353fb111765b
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst	
@@ -0,0 +1 @@
+Optimize some modulo operations in ``Objects/longobject.c`` as part of bpo-46407. Patch by Jeremiah Vivian.
\ No newline at end of file

From cf1ac24f2aa097b97eb44b42e4895d8913b97bff Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Tue, 18 Jan 2022 07:22:44 +0800
Subject: [PATCH 03/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index a448b31fc6fe63..fa3b2681d85513 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -4421,7 +4421,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
            We could _always_ do this reduction, but l_divmod() isn't cheap,
            so we only do it when it buys something. */
         if (Py_SIZE(a) < 0 || Py_SIZE(a) > Py_SIZE(c)) {
-            if (l_divmod(a, c, NULL, &temp) < 0)
+            if (l_mod(a, c, &temp) < 0)
                 goto Error;
             Py_DECREF(a);
             a = temp;
@@ -4442,7 +4442,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
 #define REDUCE(X)                                       \
     do {                                                \
         if (c != NULL) {                                \
-            if (l_divmod(X, c, NULL, &temp) < 0)        \
+            if (l_mod(X, c, &temp) < 0)                 \
                 goto Error;                             \
             Py_XDECREF(X);                              \
             X = temp;                                   \
@@ -5107,7 +5107,7 @@ _PyLong_GCD(PyObject *aarg, PyObject *barg)
 
         if (k == 0) {
             /* no progress; do a Euclidean step */
-            if (l_divmod(a, b, NULL, &r) < 0)
+            if (l_mod(a, b, &r) < 0)
                 goto error;
             Py_DECREF(a);
             a = b;

From ad71a1c18a689d3fbea4e6ad73e41f6785194f76 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Tue, 18 Jan 2022 08:07:40 +0800
Subject: [PATCH 04/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index fa3b2681d85513..550df020681b7c 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -4185,11 +4185,7 @@ long_mod(PyObject *a, PyObject *b)
 
     CHECK_BINOP(a, b);
 
-    if (Py_ABS(Py_SIZE(a)) == 1 && Py_ABS(Py_SIZE(b)) == 1) {
-        return fast_mod((PyLongObject*)a, (PyLongObject*)b);
-    }
-
-    if (l_divmod((PyLongObject*)a, (PyLongObject*)b, NULL, &mod) < 0)
+    if (l_mod((PyLongObject*)a, (PyLongObject*)b, &mod) < 0)
         mod = NULL;
     return (PyObject *)mod;
 }

From 9e9fd0080e43703776263e5bdb2bb862ea59b12d Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Wed, 19 Jan 2022 06:29:27 +0800
Subject: [PATCH 05/17] bpo-46407: Optimizing some modulo operations

Retain fast path
---
 Objects/longobject.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 550df020681b7c..cf826b2f03fc0f 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -3867,7 +3867,7 @@ l_divmod(PyLongObject *v, PyLongObject *w,
  *     *pmod = mod(v)
  * NULL can be passed for pmod, in which case the function
  * never runs code.  The caller owns a reference to
- * each of these it requests (does not pass NULL for).
+ * pmod that it requests (does not pass NULL for).
  */
 static int
 l_mod(PyLongObject *v, PyLongObject *w, PyLongObject **pmod)
@@ -4185,6 +4185,11 @@ long_mod(PyObject *a, PyObject *b)
 
     CHECK_BINOP(a, b);
 
+    /* Fast path to avoid more checking and overhead in l_mod */
+    if (Py_ABS(Py_SIZE(a)) == 1 && Py_ABS(Py_SIZE(b)) == 1) {
+        return fast_mod((PyLongObject*)a, (PyLongObject*)b);
+    }
+
     if (l_mod((PyLongObject*)a, (PyLongObject*)b, &mod) < 0)
         mod = NULL;
     return (PyObject *)mod;

From fd485107e3e52ccb5b9564ef66f067a6551aa36b Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Wed, 19 Jan 2022 13:02:49 +0800
Subject: [PATCH 06/17] Update 2022-01-17-23-12-01.bpo-46407.2_5a7R.rst

---
 .../Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst b/Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst
index 68353fb111765b..e7f555f1ffc2f4 100644
--- a/Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst	
+++ b/Misc/NEWS.d/next/Core and Builtins/2022-01-17-23-12-01.bpo-46407.2_5a7R.rst	
@@ -1 +1 @@
-Optimize some modulo operations in ``Objects/longobject.c`` as part of bpo-46407. Patch by Jeremiah Vivian.
\ No newline at end of file
+Optimize some modulo operations in ``Objects/longobject.c``. Patch by Jeremiah Vivian.

From 99ac778729a72e790b7fe43206734d8949bc58f0 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Wed, 19 Jan 2022 13:04:12 +0800
Subject: [PATCH 07/17] bpo-46407: Optimizing some modulo operations

Fix documentation for l_mod and remove recently added branch.
---
 Objects/longobject.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index cf826b2f03fc0f..1579ec2ab81568 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -3866,8 +3866,7 @@ l_divmod(PyLongObject *v, PyLongObject *w,
 /* Compute
  *     *pmod = mod(v)
  * NULL can be passed for pmod, in which case the function
- * never runs code.  The caller owns a reference to
- * pmod that it requests (does not pass NULL for).
+ * never runs code.  The caller owns a reference to pmod.
  */
 static int
 l_mod(PyLongObject *v, PyLongObject *w, PyLongObject **pmod)
@@ -4185,11 +4184,6 @@ long_mod(PyObject *a, PyObject *b)
 
     CHECK_BINOP(a, b);
 
-    /* Fast path to avoid more checking and overhead in l_mod */
-    if (Py_ABS(Py_SIZE(a)) == 1 && Py_ABS(Py_SIZE(b)) == 1) {
-        return fast_mod((PyLongObject*)a, (PyLongObject*)b);
-    }
-
     if (l_mod((PyLongObject*)a, (PyLongObject*)b, &mod) < 0)
         mod = NULL;
     return (PyObject *)mod;

From 80a2d27999eaa42bd6039d3f424709f7a5cc9cfc Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Thu, 20 Jan 2022 05:16:42 +0800
Subject: [PATCH 08/17] bpo-46407: Optimizing some modulo operations

Fix documentation
---
 Objects/longobject.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 1579ec2ab81568..d84815858e4b08 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1635,7 +1635,7 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
     return (digit)rem;
 }
 
-/* Remiander of long pin, w/ size digits, by non-zero digit n,
+/* Remainder of long pin, w/ size digits, by non-zero digit n,
    returning the remainder. pin points at the LSD. */
 
 static digit

From ca6bb8e8d482ef3589c14eadbda4da63e5014ef8 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Mon, 24 Jan 2022 04:49:10 +0800
Subject: [PATCH 09/17] bpo-46407: Optimizing some modulo operations

Fix conflicts
---
 Objects/longobject.c | 42 ++++++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index d84815858e4b08..c42a47399e2d20 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1635,6 +1635,24 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
     return (digit)rem;
 }
 
+/* Divide an integer by a digit, returning both the quotient
+   (as function result) and the remainder (through *prem).
+   The sign of a is ignored; n should not be zero. */
+
+static PyLongObject *
+divrem1(PyLongObject *a, digit n, digit *prem)
+{
+    const Py_ssize_t size = Py_ABS(Py_SIZE(a));
+    PyLongObject *z;
+
+    assert(n > 0 && n <= PyLong_MASK);
+    z = _PyLong_New(size);
+    if (z == NULL)
+        return NULL;
+    *prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n);
+    return long_normalize(z);
+}
+
 /* Remainder of long pin, w/ size digits, by non-zero digit n,
    returning the remainder. pin points at the LSD. */
 
@@ -1645,10 +1663,8 @@ inplace_rem1(digit *pin, Py_ssize_t size, digit n)
 
     assert(n > 0 && n <= PyLong_MASK);
     pin += size;
-    while (--size >= 0) {
-        rem = (rem << PyLong_SHIFT) | *--pin;
-        rem %= n;
-    }
+    while (--size >= 0)
+        rem = ((rem << PyLong_SHIFT) | pin[size]) % n;
     return (digit)rem;
 }
 
@@ -1667,24 +1683,6 @@ rem1(PyLongObject *a, digit n)
     );
 }
 
-/* Divide an integer by a digit, returning both the quotient
-   (as function result) and the remainder (through *prem).
-   The sign of a is ignored; n should not be zero. */
-
-static PyLongObject *
-divrem1(PyLongObject *a, digit n, digit *prem)
-{
-    const Py_ssize_t size = Py_ABS(Py_SIZE(a));
-    PyLongObject *z;
-
-    assert(n > 0 && n <= PyLong_MASK);
-    z = _PyLong_New(size);
-    if (z == NULL)
-        return NULL;
-    *prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n);
-    return long_normalize(z);
-}
-
 /* Convert an integer to a base 10 string.  Returns a new non-shared
    string.  (Return value is non-shared so that callers can modify the
    returned value if necessary.) */

From 6566099ec08c71b8aeca8b7d76987f1ad6461f89 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Mon, 24 Jan 2022 05:27:51 +0800
Subject: [PATCH 10/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index c42a47399e2d20..4074c9edc07187 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1664,7 +1664,8 @@ inplace_rem1(digit *pin, Py_ssize_t size, digit n)
     assert(n > 0 && n <= PyLong_MASK);
     pin += size;
     while (--size >= 0)
-        rem = ((rem << PyLong_SHIFT) | pin[size]) % n;
+        rem = (rem << PyLong_SHIFT) | pin[size];
+        rem %= n;
     return (digit)rem;
 }
 

From 659881974eaa5269a53e42549fe332dac10822ff Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Mon, 24 Jan 2022 05:50:19 +0800
Subject: [PATCH 11/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 4074c9edc07187..e122fa673a828b 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -1662,10 +1662,8 @@ inplace_rem1(digit *pin, Py_ssize_t size, digit n)
     twodigits rem = 0;
 
     assert(n > 0 && n <= PyLong_MASK);
-    pin += size;
     while (--size >= 0)
-        rem = (rem << PyLong_SHIFT) | pin[size];
-        rem %= n;
+        rem = ((rem << PyLong_SHIFT) | pin[size]) % n;
     return (digit)rem;
 }
 

From a66085fd4b12ef50fe4ff3f9061e14ba49074348 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Tue, 25 Jan 2022 10:57:27 +0800
Subject: [PATCH 12/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index e122fa673a828b..f0efa16384fbf7 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -3861,17 +3861,19 @@ l_divmod(PyLongObject *v, PyLongObject *w,
 }
 
 /* Compute
- *     *pmod = mod(v)
- * NULL can be passed for pmod, in which case the function
- * never runs code.  The caller owns a reference to pmod.
+ *     *pmod = v % w
+ * An error should be raised if NULL is passed to pmod.
+ * The caller owns a reference to pmod.
  */
 static int
 l_mod(PyLongObject *v, PyLongObject *w, PyLongObject **pmod)
 {
     PyLongObject *mod;
 
-    if (pmod == NULL)
-        return 0;
+    if (pmod == NULL) {
+        PyErr_SetString(SystemError, "missing pmod argument to l_mod");
+        return -1;
+    }
     if (Py_ABS(Py_SIZE(v)) == 1 && Py_ABS(Py_SIZE(w)) == 1) {
         /* Fast path for single-digit longs */
         *pmod = (PyLongObject *)fast_mod(v, w);
@@ -4410,7 +4412,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
               while the "large exponent" case multiplies directly by base 31
               times.  It can be unboundedly faster to multiply by
               base % modulus instead.
-           We could _always_ do this reduction, but l_divmod() isn't cheap,
+           We could _always_ do this reduction, but l_mod() isn't cheap,
            so we only do it when it buys something. */
         if (Py_SIZE(a) < 0 || Py_SIZE(a) > Py_SIZE(c)) {
             if (l_mod(a, c, &temp) < 0)

From f15747f9b013336269614f9740b27b846f3d5461 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Tue, 25 Jan 2022 11:00:16 +0800
Subject: [PATCH 13/17] bpo-46407: Optimize some modulo operations

---
 Objects/longobject.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index f0efa16384fbf7..33a6417e043da9 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -3871,7 +3871,7 @@ l_mod(PyLongObject *v, PyLongObject *w, PyLongObject **pmod)
     PyLongObject *mod;
 
     if (pmod == NULL) {
-        PyErr_SetString(SystemError, "missing pmod argument to l_mod");
+        PyErr_SetString(PyExc_SystemError, "missing pmod argument to l_mod");
         return -1;
     }
     if (Py_ABS(Py_SIZE(v)) == 1 && Py_ABS(Py_SIZE(w)) == 1) {

From bea9bdeb5b2b631173f118d0be8b22ba0762ab33 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Tue, 25 Jan 2022 12:13:54 +0800
Subject: [PATCH 14/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 33a6417e043da9..5c10e26ec31333 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -3862,18 +3862,14 @@ l_divmod(PyLongObject *v, PyLongObject *w,
 
 /* Compute
  *     *pmod = v % w
- * An error should be raised if NULL is passed to pmod.
- * The caller owns a reference to pmod.
+ * pmod cannot be NULL. The caller owns a reference to pmod.
  */
 static int
 l_mod(PyLongObject *v, PyLongObject *w, PyLongObject **pmod)
 {
     PyLongObject *mod;
 
-    if (pmod == NULL) {
-        PyErr_SetString(PyExc_SystemError, "missing pmod argument to l_mod");
-        return -1;
-    }
+    assert(pmod);
     if (Py_ABS(Py_SIZE(v)) == 1 && Py_ABS(Py_SIZE(w)) == 1) {
         /* Fast path for single-digit longs */
         *pmod = (PyLongObject *)fast_mod(v, w);

From 3d01b63f2ca168499e80a231a249c72252d791af Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Wed, 26 Jan 2022 07:20:23 +0800
Subject: [PATCH 15/17] bpo-46407: Optimizing some modulo operations

---
 Objects/longobject.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Objects/longobject.c b/Objects/longobject.c
index 5c10e26ec31333..a8b56903284230 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -3883,10 +3883,8 @@ l_mod(PyLongObject *v, PyLongObject *w, PyLongObject **pmod)
         temp = (PyLongObject *) long_add(mod, w);
         Py_DECREF(mod);
         mod = temp;
-        if (mod == NULL) {
-            Py_DECREF(div);
+        if (mod == NULL)
             return -1;
-        }
     }
     *pmod = mod;
 

From 7da4d339db9368e02b9aa5359a15a4231039a740 Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Fri, 28 Jan 2022 06:58:04 +0800
Subject: [PATCH 16/17] Update ACKS

---
 Misc/ACKS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Misc/ACKS b/Misc/ACKS
index 7f2e94dfa615f1..6815676eee93a4 100644
--- a/Misc/ACKS
+++ b/Misc/ACKS
@@ -1850,6 +1850,7 @@ Nikita Vetoshkin
 Al Vezza
 Petr Viktorin
 Jacques A. Vidrine
+Jeremiah Vivian (Pascual)
 John Viega
 Dino Viehland
 Olivier Vielpeau

From 1c897fcbc18eb2d49e039e28e8802ef8bc46db4d Mon Sep 17 00:00:00 2001
From: Crowthebird <78076854+thatbirdguythatuknownot@users.noreply.github.com>
Date: Fri, 28 Jan 2022 07:05:56 +0800
Subject: [PATCH 17/17] Update ACKS

---
 Misc/ACKS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Misc/ACKS b/Misc/ACKS
index 6815676eee93a4..6127286db09423 100644
--- a/Misc/ACKS
+++ b/Misc/ACKS
@@ -1850,7 +1850,6 @@ Nikita Vetoshkin
 Al Vezza
 Petr Viktorin
 Jacques A. Vidrine
-Jeremiah Vivian (Pascual)
 John Viega
 Dino Viehland
 Olivier Vielpeau
@@ -1859,6 +1858,7 @@ Kurt Vile
 Norman Vine
 Pauli Virtanen
 Frank Visser
+Jeremiah Vivian (Pascual)
 Johannes Vogel
 Michael Vogt
 Radu Voicilas