diff --git a/Lib/_pydecimal.py b/Lib/_pydecimal.py
index ef889ea0cc834c..8c0afd14d616e8 100644
--- a/Lib/_pydecimal.py
+++ b/Lib/_pydecimal.py
@@ -107,8 +107,8 @@ class DecimalException(ArithmeticError):
     anything, though.
 
     handle  -- Called when context._raise_error is called and the
-               trap_enabler is not set.  First argument is self, second is the
-               context.  More arguments can be given, those being after
+               trap_enabler is not set.  First argument is self, second is
+               the context.  More arguments can be given, those being after
                the explanation in _raise_error (For example,
                context._raise_error(NewError, '(-x)!', self._sign) would
                call NewError().handle(context, self._sign).)
@@ -225,11 +225,12 @@ class InvalidContext(InvalidOperation):
     """Invalid context.  Unknown rounding, for example.
 
     This occurs and signals invalid-operation if an invalid context was
-    detected during an operation.  This can occur if contexts are not checked
-    on creation and either the precision exceeds the capability of the
-    underlying concrete representation or an unknown or unsupported rounding
-    was specified.  These aspects of the context need only be checked when
-    the values are required to be used.  The result is [0,qNaN].
+    detected during an operation.  This can occur if contexts are not
+    checked on creation and either the precision exceeds the capability of
+    the underlying concrete representation or an unknown or unsupported
+    rounding was specified.  These aspects of the context need only be
+    checked when the values are required to be used.  The result is
+    [0,qNaN].
     """
 
     def handle(self, context, *args):
@@ -322,8 +323,9 @@ class FloatOperation(DecimalException, TypeError):
     Decimal.from_float() or context.create_decimal_from_float() do not
     set the flag.
 
-    Otherwise (the signal is trapped), only equality comparisons and explicit
-    conversions are silent. All other mixed operations raise FloatOperation.
+    Otherwise (the signal is trapped), only equality comparisons and
+    explicit conversions are silent.  All other mixed operations raise
+    FloatOperation.
     """
 
 # List of public traps and flags
@@ -2901,8 +2903,8 @@ def compare_total(self, other, context=None):
         """Compares self to other using the abstract representations.
 
         This is not like the standard compare, which use their numerical
-        value. Note that a total ordering is defined for all possible abstract
-        representations.
+        value. Note that a total ordering is defined for all possible
+        abstract representations.
         """
         other = _convert_other(other, raiseit=True)
 
@@ -2973,7 +2975,8 @@ def compare_total(self, other, context=None):
     def compare_total_mag(self, other, context=None):
         """Compares self to other using abstract repr., ignoring sign.
 
-        Like compare_total, but with operand's sign ignored and assumed to be 0.
+        Like compare_total, but with operand's sign ignored and assumed to
+        be 0.
         """
         other = _convert_other(other, raiseit=True)
 
@@ -4110,9 +4113,9 @@ def create_decimal_from_float(self, f):
     def abs(self, a):
         """Returns the absolute value of the operand.
 
-        If the operand is negative, the result is the same as using the minus
-        operation on the operand.  Otherwise, the result is the same as using
-        the plus operation on the operand.
+        If the operand is negative, the result is the same as using the
+        minus operation on the operand.  Otherwise, the result is the same
+        as using the plus operation on the operand.
 
         >>> ExtendedContext.abs(Decimal('2.1'))
         Decimal('2.1')
@@ -4168,16 +4171,17 @@ def canonical(self, a):
     def compare(self, a, b):
         """Compares values numerically.
 
-        If the signs of the operands differ, a value representing each operand
-        ('-1' if the operand is less than zero, '0' if the operand is zero or
-        negative zero, or '1' if the operand is greater than zero) is used in
-        place of that operand for the comparison instead of the actual
-        operand.
+        If the signs of the operands differ, a value representing each
+        operand ('-1' if the operand is less than zero, '0' if the operand
+        is zero or negative zero, or '1' if the operand is greater than
+        zero) is used in place of that operand for the comparison instead of
+        the actual operand.
 
-        The comparison is then effected by subtracting the second operand from
-        the first and then returning a value according to the result of the
-        subtraction: '-1' if the result is less than zero, '0' if the result is
-        zero or negative zero, or '1' if the result is greater than zero.
+        The comparison is then effected by subtracting the second operand
+        from the first and then returning a value according to the result of
+        the subtraction: '-1' if the result is less than zero, '0' if the
+        result is zero or negative zero, or '1' if the result is greater
+        than zero.
 
         >>> ExtendedContext.compare(Decimal('2.1'), Decimal('3'))
         Decimal('-1')
@@ -4240,8 +4244,8 @@ def compare_total(self, a, b):
         """Compares two operands using their abstract representation.
 
         This is not like the standard compare, which use their numerical
-        value. Note that a total ordering is defined for all possible abstract
-        representations.
+        value.  Note that a total ordering is defined for all possible
+        abstract representations.
 
         >>> ExtendedContext.compare_total(Decimal('12.73'), Decimal('127.9'))
         Decimal('-1')
@@ -4268,7 +4272,8 @@ def compare_total(self, a, b):
     def compare_total_mag(self, a, b):
         """Compares two operands using their abstract representation ignoring sign.
 
-        Like compare_total, but with operand's sign ignored and assumed to be 0.
+        Like compare_total, but with operand's sign ignored and assumed to
+        be 0.
         """
         a = _convert_other(a, raiseit=True)
         return a.compare_total_mag(b)
@@ -4926,8 +4931,8 @@ def multiply(self, a, b):
 
         If either operand is a special value then the general rules apply.
         Otherwise, the operands are multiplied together
-        ('long multiplication'), resulting in a number which may be as long as
-        the sum of the lengths of the two operands.
+        ('long multiplication'), resulting in a number which may be as long
+        as the sum of the lengths of the two operands.
 
         >>> ExtendedContext.multiply(Decimal('1.20'), Decimal('3'))
         Decimal('3.60')
@@ -5203,19 +5208,19 @@ def quantize(self, a, b):
         """Returns a value equal to 'a' (rounded), having the exponent of 'b'.
 
         The coefficient of the result is derived from that of the left-hand
-        operand.  It may be rounded using the current rounding setting (if the
-        exponent is being increased), multiplied by a positive power of ten (if
-        the exponent is being decreased), or is unchanged (if the exponent is
-        already equal to that of the right-hand operand).
+        operand.  It may be rounded using the current rounding setting (if
+        the exponent is being increased), multiplied by a positive power of
+        ten (if the exponent is being decreased), or is unchanged (if the
+        exponent is already equal to that of the right-hand operand).
 
         Unlike other operations, if the length of the coefficient after the
         quantize operation would be greater than precision then an Invalid
-        operation condition is raised.  This guarantees that, unless there is
-        an error condition, the exponent of the result of a quantize is always
-        equal to that of the right-hand operand.
+        operation condition is raised.  This guarantees that, unless there
+        is an error condition, the exponent of the result of a quantize is
+        always equal to that of the right-hand operand.
 
-        Also unlike other operations, quantize will never raise Underflow, even
-        if the result is subnormal and inexact.
+        Also unlike other operations, quantize will never raise Underflow,
+        even if the result is subnormal and inexact.
 
         >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.001'))
         Decimal('2.170')
@@ -5269,13 +5274,13 @@ def remainder(self, a, b):
         """Returns the remainder from integer division.
 
         The result is the residue of the dividend after the operation of
-        calculating integer division as described for divide-integer, rounded
-        to precision digits if necessary.  The sign of the result, if
-        non-zero, is the same as that of the original dividend.
+        calculating integer division as described for divide-integer,
+        rounded to precision digits if necessary.  The sign of the result,
+        if non-zero, is the same as that of the original dividend.
 
-        This operation will fail under the same conditions as integer division
-        (that is, if integer division on the same two operands would fail, the
-        remainder cannot be calculated).
+        This operation will fail under the same conditions as integer
+        division (that is, if integer division on the same two operands
+        would fail, the remainder cannot be calculated).
 
         >>> ExtendedContext.remainder(Decimal('2.1'), Decimal('3'))
         Decimal('2.1')
@@ -5309,9 +5314,9 @@ def remainder_near(self, a, b):
         is chosen).  If the result is equal to 0 then its sign will be the
         sign of a.
 
-        This operation will fail under the same conditions as integer division
-        (that is, if integer division on the same two operands would fail, the
-        remainder cannot be calculated).
+        This operation will fail under the same conditions as integer
+        division (that is, if integer division on the same two operands
+        would fail, the remainder cannot be calculated).
 
         >>> ExtendedContext.remainder_near(Decimal('2.1'), Decimal('3'))
         Decimal('-0.9')
@@ -5369,8 +5374,8 @@ def rotate(self, a, b):
     def same_quantum(self, a, b):
         """Returns True if the two operands have the same exponent.
 
-        The result is never affected by either the sign or the coefficient of
-        either operand.
+        The result is never affected by either the sign or the coefficient
+        of either operand.
 
         >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('0.001'))
         False
@@ -5442,8 +5447,8 @@ def shift(self, a, b):
     def sqrt(self, a):
         """Square root of a non-negative number to context precision.
 
-        If the result must be inexact, it is rounded using the round-half-even
-        algorithm.
+        If the result must be inexact, it is rounded using the
+        round-half-even algorithm.
 
         >>> ExtendedContext.sqrt(Decimal('0'))
         Decimal('0')
diff --git a/Modules/_decimal/_decimal.c b/Modules/_decimal/_decimal.c
index 0a8308d9ebce7a..2760792a3fe18e 100644
--- a/Modules/_decimal/_decimal.c
+++ b/Modules/_decimal/_decimal.c
@@ -939,13 +939,13 @@ _decimal.Context.Etop
 
 Return a value equal to Emax - prec + 1.
 
-This is the maximum exponent if the _clamp field of the context is set
-to 1 (IEEE clamp mode).  Etop() must not be negative.
+This is the maximum exponent if the _clamp field of the context is
+set to 1 (IEEE clamp mode).  Etop() must not be negative.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Context_Etop_impl(PyObject *self)
-/*[clinic end generated code: output=f0a3f6e1b829074e input=838a4409316ec728]*/
+/*[clinic end generated code: output=f0a3f6e1b829074e input=35b9defc69d5e5d1]*/
 {
     return PyLong_FromSsize_t(mpd_etop(CTX(self)));
 }
@@ -2997,6 +2997,7 @@ PyDecType_FromSequenceExact(PyTypeObject *type, PyObject *v,
         PyDecType_FromSequenceExact((st)->PyDec_Type, sequence, context)
 
 /*[clinic input]
+@permit_long_docstring_body
 @classmethod
 _decimal.Decimal.from_float
 
@@ -3022,7 +3023,7 @@ Decimal.from_float(0.1) is not the same as Decimal('0.1').
 static PyObject *
 _decimal_Decimal_from_float_impl(PyTypeObject *type, PyTypeObject *cls,
                                  PyObject *pyfloat)
-/*[clinic end generated code: output=fcb7d55d2f9dc790 input=03bc8dbe963e52ca]*/
+/*[clinic end generated code: output=fcb7d55d2f9dc790 input=29abf05dd8fe79e4]*/
 {
     PyObject *context;
     PyObject *result;
@@ -3068,6 +3069,8 @@ PyDecType_FromNumberExact(PyTypeObject *type, PyTypeObject *cls,
 }
 
 /*[clinic input]
+@permit_long_summary
+@permit_long_docstring_body
 @classmethod
 _decimal.Decimal.from_number
 
@@ -3088,7 +3091,7 @@ Class method that converts a real number to a decimal number, exactly.
 static PyObject *
 _decimal_Decimal_from_number_impl(PyTypeObject *type, PyTypeObject *cls,
                                   PyObject *number)
-/*[clinic end generated code: output=4d3ec722b7acfd8b input=271cb4feb3148804]*/
+/*[clinic end generated code: output=4d3ec722b7acfd8b input=34ff3696955d3def]*/
 {
     PyObject *context;
     PyObject *result;
@@ -3959,6 +3962,7 @@ dec_as_long(PyObject *dec, PyObject *context, int round)
 }
 
 /*[clinic input]
+@permit_long_summary
 _decimal.Decimal.as_integer_ratio
 
     cls: defining_class
@@ -3971,7 +3975,7 @@ Raise OverflowError on infinities and a ValueError on NaNs.
 
 static PyObject *
 _decimal_Decimal_as_integer_ratio_impl(PyObject *self, PyTypeObject *cls)
-/*[clinic end generated code: output=eb49c512701f844b input=07e33d8852184761]*/
+/*[clinic end generated code: output=eb49c512701f844b input=136f1dc585ca8d80]*/
 {
     PyObject *numerator = NULL;
     PyObject *denominator = NULL;
@@ -4146,17 +4150,17 @@ _decimal.Decimal.to_integral_exact = _decimal.Decimal.to_integral_value
 
 Round to the nearest integer.
 
-Decimal.to_integral_exact() signals Inexact or Rounded as appropriate
-if rounding occurs.  The rounding mode is determined by the rounding
-parameter if given, else by the given context. If neither parameter is
-given, then the rounding mode of the current default context is used.
+This method signals Inexact or Rounded as appropriate if rounding
+occurs.  The rounding mode is determined by the rounding parameter
+if given, else by the given context.  If neither parameter is given,
+then the rounding mode of the current default context is used.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_to_integral_exact_impl(PyObject *self, PyTypeObject *cls,
                                         PyObject *rounding,
                                         PyObject *context)
-/*[clinic end generated code: output=543a39a02eea9917 input=fabce7a744b8087c]*/
+/*[clinic end generated code: output=543a39a02eea9917 input=d4d8abe543393de1]*/
 {
     PyObject *result;
     uint32_t status = 0;
@@ -4791,13 +4795,14 @@ _decimal.Decimal.sqrt = _decimal.Decimal.exp
 
 Return the square root of the argument to full precision.
 
-The result is correctly rounded using the ROUND_HALF_EVEN rounding mode.
+The result is correctly rounded using the ROUND_HALF_EVEN rounding
+mode.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_sqrt_impl(PyObject *self, PyTypeObject *cls,
                            PyObject *context)
-/*[clinic end generated code: output=deb1280077b5e586 input=3a76afbd39dc20b9]*/
+/*[clinic end generated code: output=deb1280077b5e586 input=c565a7216e9605e7]*/
 Dec_UnaryFuncVA(mpd_qsqrt)
 
 /* Binary arithmetic functions, optional context arg */
@@ -4853,6 +4858,7 @@ _decimal_Decimal_max_impl(PyObject *self, PyTypeObject *cls, PyObject *other,
 Dec_BinaryFuncVA(mpd_qmax)
 
 /*[clinic input]
+@permit_long_summary
 _decimal.Decimal.max_mag = _decimal.Decimal.compare
 
 As the max() method, but compares the absolute values of the operands.
@@ -4861,7 +4867,7 @@ As the max() method, but compares the absolute values of the operands.
 static PyObject *
 _decimal_Decimal_max_mag_impl(PyObject *self, PyTypeObject *cls,
                               PyObject *other, PyObject *context)
-/*[clinic end generated code: output=f71f2c27d9bc7cac input=88b105e66cf138c5]*/
+/*[clinic end generated code: output=f71f2c27d9bc7cac input=5f81b9da49b45e5d]*/
 Dec_BinaryFuncVA(mpd_qmax_mag)
 
 /*[clinic input]
@@ -4880,6 +4886,7 @@ _decimal_Decimal_min_impl(PyObject *self, PyTypeObject *cls, PyObject *other,
 Dec_BinaryFuncVA(mpd_qmin)
 
 /*[clinic input]
+@permit_long_summary
 _decimal.Decimal.min_mag = _decimal.Decimal.compare
 
 As the min() method, but compares the absolute values of the operands.
@@ -4888,7 +4895,7 @@ As the min() method, but compares the absolute values of the operands.
 static PyObject *
 _decimal_Decimal_min_mag_impl(PyObject *self, PyTypeObject *cls,
                               PyObject *other, PyObject *context)
-/*[clinic end generated code: output=018562ad1c22aae3 input=351fa3c0e592746a]*/
+/*[clinic end generated code: output=018562ad1c22aae3 input=94c29817c7f16db7]*/
 Dec_BinaryFuncVA(mpd_qmin_mag)
 
 /*[clinic input]
@@ -4896,16 +4903,16 @@ _decimal.Decimal.next_toward = _decimal.Decimal.compare
 
 Returns the number closest to self, in the direction towards other.
 
-If the two operands are unequal, return the number closest to the first
-operand in the direction of the second operand.  If both operands are
-numerically equal, return a copy of the first operand with the sign set
-to be the same as the sign of the second operand.
+If the two operands are unequal, return the number closest to the
+first operand in the direction of the second operand.  If both
+operands are numerically equal, return a copy of the first operand
+with the sign set to be the same as the sign of the second operand.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_next_toward_impl(PyObject *self, PyTypeObject *cls,
                                   PyObject *other, PyObject *context)
-/*[clinic end generated code: output=71d879bca8bc1019 input=fdf0091ea6e9e416]*/
+/*[clinic end generated code: output=71d879bca8bc1019 input=adc5d453fc140341]*/
 Dec_BinaryFuncVA(mpd_qnext_toward)
 
 /*[clinic input]
@@ -4914,10 +4921,10 @@ _decimal.Decimal.remainder_near = _decimal.Decimal.compare
 Return the remainder from dividing self by other.
 
 This differs from self % other in that the sign of the remainder is
-chosen so as to minimize its absolute value. More precisely, the return
-value is self - n * other where n is the integer nearest to the exact
-value of self / other, and if two integers are equally near then the
-even one is chosen.
+chosen so as to minimize its absolute value. More precisely, the
+return value is self - n * other where n is the integer nearest to
+the exact value of self / other, and if two integers are equally
+near then the even one is chosen.
 
 If the result is zero then its sign will be the sign of self.
 [clinic start generated code]*/
@@ -4925,7 +4932,7 @@ If the result is zero then its sign will be the sign of self.
 static PyObject *
 _decimal_Decimal_remainder_near_impl(PyObject *self, PyTypeObject *cls,
                                      PyObject *other, PyObject *context)
-/*[clinic end generated code: output=d3fbb4985f2077fa input=eb5a8dfe3470b794]*/
+/*[clinic end generated code: output=d3fbb4985f2077fa input=dcb66d4afa0c77c3]*/
 Dec_BinaryFuncVA(mpd_qrem_near)
 
 /* Ternary arithmetic functions, optional context arg */
@@ -4992,6 +4999,7 @@ _decimal_Decimal_is_infinite_impl(PyObject *self)
 Dec_BoolFunc(mpd_isinfinite)
 
 /*[clinic input]
+@permit_long_summary
 _decimal.Decimal.is_nan
 
 Return True if the argument is a (quiet or signaling) NaN, else False.
@@ -4999,7 +5007,7 @@ Return True if the argument is a (quiet or signaling) NaN, else False.
 
 static PyObject *
 _decimal_Decimal_is_nan_impl(PyObject *self)
-/*[clinic end generated code: output=b704e8b49a164388 input=795e5dac85976994]*/
+/*[clinic end generated code: output=b704e8b49a164388 input=b7d8f0d59fe2332a]*/
 Dec_BoolFunc(mpd_isnan)
 
 /*[clinic input]
@@ -5153,13 +5161,13 @@ _decimal.Decimal.radix
 
 Return Decimal(10).
 
-This is the radix (base) in which the Decimal class does
-all its arithmetic. Included for compatibility with the specification.
+This is the radix (base) in which the Decimal class does all its
+arithmetic. Included for compatibility with the specification.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_radix_impl(PyObject *self, PyTypeObject *cls)
-/*[clinic end generated code: output=40a3bc7ec3d99228 input=b0d4cb9f870bbac1]*/
+/*[clinic end generated code: output=40a3bc7ec3d99228 input=d1cdbdbbbdefdec2]*/
 {
     decimal_state *state = PyType_GetModuleState(cls);
     return _dec_mpd_radix(state);
@@ -5250,15 +5258,15 @@ _decimal.Decimal.logb = _decimal.Decimal.exp
 
 Return the adjusted exponent of the operand as a Decimal instance.
 
-If the operand is a zero, then Decimal('-Infinity') is returned and the
-DivisionByZero condition is raised. If the operand is an infinity then
-Decimal('Infinity') is returned.
+If the operand is a zero, then Decimal('-Infinity') is returned and
+the DivisionByZero condition is raised.  If the operand is an
+infinity then Decimal('Infinity') is returned.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_logb_impl(PyObject *self, PyTypeObject *cls,
                            PyObject *context)
-/*[clinic end generated code: output=36b0bda09e934245 input=a8df027d1b8a2b17]*/
+/*[clinic end generated code: output=36b0bda09e934245 input=eeafa6bbf8d8a013]*/
 Dec_UnaryFuncVA(mpd_qlogb)
 
 /*[clinic input]
@@ -5280,14 +5288,15 @@ The returned value is one of the following ten strings:
     * '+Normal', indicating that the operand is a positive normal
       number.
     * '+Infinity', indicating that the operand is positive infinity.
-    * 'NaN', indicating that the operand is a quiet NaN (Not a Number).
+    * 'NaN', indicating that the operand is a quiet NaN (Not a
+      Number).
     * 'sNaN', indicating that the operand is a signaling NaN.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_number_class_impl(PyObject *self, PyTypeObject *cls,
                                    PyObject *context)
-/*[clinic end generated code: output=1ac82412e0849c52 input=447095d2677fa0ca]*/
+/*[clinic end generated code: output=1ac82412e0849c52 input=0b59852b43c521aa]*/
 {
     const char *cp;
 
@@ -5303,19 +5312,19 @@ _decimal.Decimal.to_eng_string = _decimal.Decimal.exp
 
 Convert to an engineering-type string.
 
-Engineering notation has an exponent which is a multiple of 3, so there
-are up to 3 digits left of the decimal place. For example,
+Engineering notation has an exponent which is a multiple of 3, so
+there are up to 3 digits left of the decimal place.  For example,
 Decimal('123E+1') is converted to Decimal('1.23E+3').
 
-The value of context.capitals determines whether the exponent sign is
-lower or upper case. Otherwise, the context does not affect the
+The value of context.capitals determines whether the exponent sign
+is lower or upper case.  Otherwise, the context does not affect the
 operation.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_to_eng_string_impl(PyObject *self, PyTypeObject *cls,
                                     PyObject *context)
-/*[clinic end generated code: output=901f128d437ae5c0 input=b2cb7e01e268e45d]*/
+/*[clinic end generated code: output=901f128d437ae5c0 input=111db4de6561f211]*/
 {
     PyObject *result;
     mpd_ssize_t size;
@@ -5343,31 +5352,31 @@ _decimal.Decimal.compare_total = _decimal.Decimal.compare
 
 Compare two operands using their abstract representation.
 
-Similar to the compare() method, but the result
-gives a total ordering on Decimal instances.  Two Decimal instances with
-the same numeric value but different representations compare unequal
-in this ordering:
+Similar to the compare() method, but the result gives a total
+ordering on Decimal instances.  Two Decimal instances with the same
+numeric value but different representations compare unequal in this
+ordering:
 
     >>> Decimal('12.0').compare_total(Decimal('12'))
     Decimal('-1')
 
-Quiet and signaling NaNs are also included in the total ordering. The
-result of this function is Decimal('0') if both operands have the same
-representation, Decimal('-1') if the first operand is lower in the
-total order than the second, and Decimal('1') if the first operand is
-higher in the total order than the second operand. See the
-specification for details of the total order.
+Quiet and signaling NaNs are also included in the total ordering.
+The result of this function is Decimal('0') if both operands have
+the same representation, Decimal('-1') if the first operand is lower
+in the total order than the second, and Decimal('1') if the first
+operand is higher in the total order than the second operand.  See
+the specification for details of the total order.
 
 This operation is unaffected by context and is quiet: no flags are
-changed and no rounding is performed. As an exception, the C version
-may raise InvalidOperation if the second operand cannot be converted
-exactly.
+changed and no rounding is performed.  As an exception, the C
+version may raise InvalidOperation if the second operand cannot be
+converted exactly.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_compare_total_impl(PyObject *self, PyTypeObject *cls,
                                     PyObject *other, PyObject *context)
-/*[clinic end generated code: output=83649010bad7815f input=6f3111ec5fdbf3c1]*/
+/*[clinic end generated code: output=83649010bad7815f input=d795bf204b9ff2a8]*/
 Dec_BinaryFuncVA_NO_CTX(mpd_compare_total)
 
 /*[clinic input]
@@ -5516,18 +5525,19 @@ _decimal.Decimal.rotate = _decimal.Decimal.compare
 
 Returns a rotated copy of self's digits, value-of-other times.
 
-The second operand must be an integer in the range -precision through
-precision. The absolute value of the second operand gives the number of
-places to rotate. If the second operand is positive then rotation is to
-the left; otherwise rotation is to the right.  The coefficient of the
-first operand is padded on the left with zeros to length precision if
-necessary. The sign and exponent of the first operand are unchanged.
+The second operand must be an integer in the range -precision
+through precision.  The absolute value of the second operand gives
+the number of places to rotate.  If the second operand is positive
+then rotation is to the left; otherwise rotation is to the right.
+The coefficient of the first operand is padded on the left with
+zeros to length precision if necessary.  The sign and exponent of
+the first operand are unchanged.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_rotate_impl(PyObject *self, PyTypeObject *cls,
                              PyObject *other, PyObject *context)
-/*[clinic end generated code: output=09f2737082882b83 input=cde7b032eac43f0b]*/
+/*[clinic end generated code: output=09f2737082882b83 input=4bc840d51842934c]*/
 Dec_BinaryFuncVA(mpd_qrotate)
 
 /*[clinic input]
@@ -5550,18 +5560,18 @@ _decimal.Decimal.shift = _decimal.Decimal.compare
 
 Returns a shifted copy of self's digits, value-of-other times.
 
-The second operand must be an integer in the range -precision through
-precision. The absolute value of the second operand gives the number
-of places to shift. If the second operand is positive, then the shift
-is to the left; otherwise the shift is to the right. Digits shifted
-into the coefficient are zeros. The sign and exponent of the first
-operand are unchanged.
+The second operand must be an integer in the range -precision
+through precision.  The absolute value of the second operand gives
+the number of places to shift.  If the second operand is positive,
+then the shift is to the left; otherwise the shift is to the right.
+Digits shifted into the coefficient are zeros.  The sign and
+exponent of the first operand are unchanged.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_shift_impl(PyObject *self, PyTypeObject *cls,
                             PyObject *other, PyObject *context)
-/*[clinic end generated code: output=82e061a0d9ecc4f5 input=501759c2522cb78e]*/
+/*[clinic end generated code: output=82e061a0d9ecc4f5 input=c05f3fd69fc1f9f9]*/
 Dec_BinaryFuncVA(mpd_qshift)
 
 /*[clinic input]
@@ -5589,18 +5599,18 @@ that of the right-hand operand.
 Also unlike other operations, quantize never signals Underflow, even
 if the result is subnormal and inexact.
 
-If the exponent of the second operand is larger than that of the first,
-then rounding may be necessary. In this case, the rounding mode is
-determined by the rounding argument if given, else by the given context
-argument; if neither argument is given, the rounding mode of the
-current thread's context is used.
+If the exponent of the second operand is larger than that of the
+first, then rounding may be necessary.  In this case, the rounding
+mode is determined by the rounding argument if given, else by the
+given context argument; if neither argument is given, the rounding
+mode of the current thread's context is used.
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Decimal_quantize_impl(PyObject *self, PyTypeObject *cls,
                                PyObject *w, PyObject *rounding,
                                PyObject *context)
-/*[clinic end generated code: output=fc51edf458559913 input=1166e6311e047b74]*/
+/*[clinic end generated code: output=fc51edf458559913 input=7838b0a5f684adb8]*/
 {
     PyObject *a, *b;
     PyObject *result;
@@ -6629,14 +6639,14 @@ _decimal.Context.remainder_near = _decimal.Context.add
 
 Return x - y * n.
 
-Here n is the integer nearest the exact value of x / y (if the result
-is 0 then its sign will be the sign of x).
+Here n is the integer nearest the exact value of x / y (if the
+result is 0 then its sign will be the sign of x).
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Context_remainder_near_impl(PyObject *context, PyTypeObject *cls,
                                      PyObject *x, PyObject *y)
-/*[clinic end generated code: output=7f18c535a12cf8ac input=bafb6327bb314c5c]*/
+/*[clinic end generated code: output=7f18c535a12cf8ac input=60342558000d4be6]*/
 DecCtx_BinaryFunc(mpd_qrem_near)
 
 /*[clinic input]
@@ -6723,13 +6733,14 @@ restrictions hold:
     * all three arguments must be integral
     * 'b' must be nonnegative
     * at least one of 'a' or 'b' must be nonzero
-    * modulo must be nonzero and less than 10**prec in absolute value
+    * modulo must be nonzero and less than 10**prec in absolute
+      value
 [clinic start generated code]*/
 
 static PyObject *
 _decimal_Context_power_impl(PyObject *context, PyTypeObject *cls,
                             PyObject *base, PyObject *exp, PyObject *mod)
-/*[clinic end generated code: output=d06d40c37cdd69dc input=2a70edd03317c666]*/
+/*[clinic end generated code: output=d06d40c37cdd69dc input=178a254468ec189b]*/
 {
     PyObject *a, *b, *c = NULL;
     PyObject *result;
@@ -7276,6 +7287,7 @@ _decimal_Context_copy_sign_impl(PyObject *context, PyTypeObject *cls,
 }
 
 /*[clinic input]
+@permit_long_docstring_body
 _decimal.Context.logical_and = _decimal.Context.add
 
 Applies the logical operation 'and' between each operand's digits.
@@ -7305,7 +7317,7 @@ The operands must be both logical numbers.
 static PyObject *
 _decimal_Context_logical_and_impl(PyObject *context, PyTypeObject *cls,
                                   PyObject *x, PyObject *y)
-/*[clinic end generated code: output=009dfa08ecaa2ac8 input=bcb7d3d6ab7530de]*/
+/*[clinic end generated code: output=009dfa08ecaa2ac8 input=9f8a93a31b9d7088]*/
 DecCtx_BinaryFunc(mpd_qand)
 
 /*[clinic input]
@@ -7342,6 +7354,7 @@ _decimal_Context_logical_or_impl(PyObject *context, PyTypeObject *cls,
 DecCtx_BinaryFunc(mpd_qor)
 
 /*[clinic input]
+@permit_long_docstring_body
 _decimal.Context.logical_xor = _decimal.Context.add
 
 Applies the logical operation 'xor' between each operand's digits.
@@ -7371,7 +7384,7 @@ The operands must be both logical numbers.
 static PyObject *
 _decimal_Context_logical_xor_impl(PyObject *context, PyTypeObject *cls,
                                   PyObject *x, PyObject *y)
-/*[clinic end generated code: output=23cd81fdcd865d5a input=fcaaf828c1d2d089]*/
+/*[clinic end generated code: output=23cd81fdcd865d5a input=119412854ae58440]*/
 DecCtx_BinaryFunc(mpd_qxor)
 
 /*[clinic input]
diff --git a/Modules/_decimal/clinic/_decimal.c.h b/Modules/_decimal/clinic/_decimal.c.h
index b09200845d12e9..c803006ad44382 100644
--- a/Modules/_decimal/clinic/_decimal.c.h
+++ b/Modules/_decimal/clinic/_decimal.c.h
@@ -36,8 +36,8 @@ PyDoc_STRVAR(_decimal_Context_Etop__doc__,
 "\n"
 "Return a value equal to Emax - prec + 1.\n"
 "\n"
-"This is the maximum exponent if the _clamp field of the context is set\n"
-"to 1 (IEEE clamp mode).  Etop() must not be negative.");
+"This is the maximum exponent if the _clamp field of the context is\n"
+"set to 1 (IEEE clamp mode).  Etop() must not be negative.");
 
 #define _DECIMAL_CONTEXT_ETOP_METHODDEF    \
     {"Etop", (PyCFunction)_decimal_Context_Etop, METH_NOARGS, _decimal_Context_Etop__doc__},
@@ -1092,10 +1092,10 @@ PyDoc_STRVAR(_decimal_Decimal_to_integral_exact__doc__,
 "\n"
 "Round to the nearest integer.\n"
 "\n"
-"Decimal.to_integral_exact() signals Inexact or Rounded as appropriate\n"
-"if rounding occurs.  The rounding mode is determined by the rounding\n"
-"parameter if given, else by the given context. If neither parameter is\n"
-"given, then the rounding mode of the current default context is used.");
+"This method signals Inexact or Rounded as appropriate if rounding\n"
+"occurs.  The rounding mode is determined by the rounding parameter\n"
+"if given, else by the given context.  If neither parameter is given,\n"
+"then the rounding mode of the current default context is used.");
 
 #define _DECIMAL_DECIMAL_TO_INTEGRAL_EXACT_METHODDEF    \
     {"to_integral_exact", _PyCFunction_CAST(_decimal_Decimal_to_integral_exact), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_to_integral_exact__doc__},
@@ -1638,7 +1638,8 @@ PyDoc_STRVAR(_decimal_Decimal_sqrt__doc__,
 "\n"
 "Return the square root of the argument to full precision.\n"
 "\n"
-"The result is correctly rounded using the ROUND_HALF_EVEN rounding mode.");
+"The result is correctly rounded using the ROUND_HALF_EVEN rounding\n"
+"mode.");
 
 #define _DECIMAL_DECIMAL_SQRT_METHODDEF    \
     {"sqrt", _PyCFunction_CAST(_decimal_Decimal_sqrt), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_sqrt__doc__},
@@ -2113,10 +2114,10 @@ PyDoc_STRVAR(_decimal_Decimal_next_toward__doc__,
 "\n"
 "Returns the number closest to self, in the direction towards other.\n"
 "\n"
-"If the two operands are unequal, return the number closest to the first\n"
-"operand in the direction of the second operand.  If both operands are\n"
-"numerically equal, return a copy of the first operand with the sign set\n"
-"to be the same as the sign of the second operand.");
+"If the two operands are unequal, return the number closest to the\n"
+"first operand in the direction of the second operand.  If both\n"
+"operands are numerically equal, return a copy of the first operand\n"
+"with the sign set to be the same as the sign of the second operand.");
 
 #define _DECIMAL_DECIMAL_NEXT_TOWARD_METHODDEF    \
     {"next_toward", _PyCFunction_CAST(_decimal_Decimal_next_toward), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_next_toward__doc__},
@@ -2185,10 +2186,10 @@ PyDoc_STRVAR(_decimal_Decimal_remainder_near__doc__,
 "Return the remainder from dividing self by other.\n"
 "\n"
 "This differs from self % other in that the sign of the remainder is\n"
-"chosen so as to minimize its absolute value. More precisely, the return\n"
-"value is self - n * other where n is the integer nearest to the exact\n"
-"value of self / other, and if two integers are equally near then the\n"
-"even one is chosen.\n"
+"chosen so as to minimize its absolute value. More precisely, the\n"
+"return value is self - n * other where n is the integer nearest to\n"
+"the exact value of self / other, and if two integers are equally\n"
+"near then the even one is chosen.\n"
 "\n"
 "If the result is zero then its sign will be the sign of self.");
 
@@ -2671,8 +2672,8 @@ PyDoc_STRVAR(_decimal_Decimal_radix__doc__,
 "\n"
 "Return Decimal(10).\n"
 "\n"
-"This is the radix (base) in which the Decimal class does\n"
-"all its arithmetic. Included for compatibility with the specification.");
+"This is the radix (base) in which the Decimal class does all its\n"
+"arithmetic. Included for compatibility with the specification.");
 
 #define _DECIMAL_DECIMAL_RADIX_METHODDEF    \
     {"radix", _PyCFunction_CAST(_decimal_Decimal_radix), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_radix__doc__},
@@ -2812,9 +2813,9 @@ PyDoc_STRVAR(_decimal_Decimal_logb__doc__,
 "\n"
 "Return the adjusted exponent of the operand as a Decimal instance.\n"
 "\n"
-"If the operand is a zero, then Decimal(\'-Infinity\') is returned and the\n"
-"DivisionByZero condition is raised. If the operand is an infinity then\n"
-"Decimal(\'Infinity\') is returned.");
+"If the operand is a zero, then Decimal(\'-Infinity\') is returned and\n"
+"the DivisionByZero condition is raised.  If the operand is an\n"
+"infinity then Decimal(\'Infinity\') is returned.");
 
 #define _DECIMAL_DECIMAL_LOGB_METHODDEF    \
     {"logb", _PyCFunction_CAST(_decimal_Decimal_logb), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_logb__doc__},
@@ -2894,7 +2895,8 @@ PyDoc_STRVAR(_decimal_Decimal_number_class__doc__,
 "    * \'+Normal\', indicating that the operand is a positive normal\n"
 "      number.\n"
 "    * \'+Infinity\', indicating that the operand is positive infinity.\n"
-"    * \'NaN\', indicating that the operand is a quiet NaN (Not a Number).\n"
+"    * \'NaN\', indicating that the operand is a quiet NaN (Not a\n"
+"      Number).\n"
 "    * \'sNaN\', indicating that the operand is a signaling NaN.");
 
 #define _DECIMAL_DECIMAL_NUMBER_CLASS_METHODDEF    \
@@ -2961,12 +2963,12 @@ PyDoc_STRVAR(_decimal_Decimal_to_eng_string__doc__,
 "\n"
 "Convert to an engineering-type string.\n"
 "\n"
-"Engineering notation has an exponent which is a multiple of 3, so there\n"
-"are up to 3 digits left of the decimal place. For example,\n"
+"Engineering notation has an exponent which is a multiple of 3, so\n"
+"there are up to 3 digits left of the decimal place.  For example,\n"
 "Decimal(\'123E+1\') is converted to Decimal(\'1.23E+3\').\n"
 "\n"
-"The value of context.capitals determines whether the exponent sign is\n"
-"lower or upper case. Otherwise, the context does not affect the\n"
+"The value of context.capitals determines whether the exponent sign\n"
+"is lower or upper case.  Otherwise, the context does not affect the\n"
 "operation.");
 
 #define _DECIMAL_DECIMAL_TO_ENG_STRING_METHODDEF    \
@@ -3033,25 +3035,25 @@ PyDoc_STRVAR(_decimal_Decimal_compare_total__doc__,
 "\n"
 "Compare two operands using their abstract representation.\n"
 "\n"
-"Similar to the compare() method, but the result\n"
-"gives a total ordering on Decimal instances.  Two Decimal instances with\n"
-"the same numeric value but different representations compare unequal\n"
-"in this ordering:\n"
+"Similar to the compare() method, but the result gives a total\n"
+"ordering on Decimal instances.  Two Decimal instances with the same\n"
+"numeric value but different representations compare unequal in this\n"
+"ordering:\n"
 "\n"
 "    >>> Decimal(\'12.0\').compare_total(Decimal(\'12\'))\n"
 "    Decimal(\'-1\')\n"
 "\n"
-"Quiet and signaling NaNs are also included in the total ordering. The\n"
-"result of this function is Decimal(\'0\') if both operands have the same\n"
-"representation, Decimal(\'-1\') if the first operand is lower in the\n"
-"total order than the second, and Decimal(\'1\') if the first operand is\n"
-"higher in the total order than the second operand. See the\n"
-"specification for details of the total order.\n"
+"Quiet and signaling NaNs are also included in the total ordering.\n"
+"The result of this function is Decimal(\'0\') if both operands have\n"
+"the same representation, Decimal(\'-1\') if the first operand is lower\n"
+"in the total order than the second, and Decimal(\'1\') if the first\n"
+"operand is higher in the total order than the second operand.  See\n"
+"the specification for details of the total order.\n"
 "\n"
 "This operation is unaffected by context and is quiet: no flags are\n"
-"changed and no rounding is performed. As an exception, the C version\n"
-"may raise InvalidOperation if the second operand cannot be converted\n"
-"exactly.");
+"changed and no rounding is performed.  As an exception, the C\n"
+"version may raise InvalidOperation if the second operand cannot be\n"
+"converted exactly.");
 
 #define _DECIMAL_DECIMAL_COMPARE_TOTAL_METHODDEF    \
     {"compare_total", _PyCFunction_CAST(_decimal_Decimal_compare_total), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_compare_total__doc__},
@@ -3544,12 +3546,13 @@ PyDoc_STRVAR(_decimal_Decimal_rotate__doc__,
 "\n"
 "Returns a rotated copy of self\'s digits, value-of-other times.\n"
 "\n"
-"The second operand must be an integer in the range -precision through\n"
-"precision. The absolute value of the second operand gives the number of\n"
-"places to rotate. If the second operand is positive then rotation is to\n"
-"the left; otherwise rotation is to the right.  The coefficient of the\n"
-"first operand is padded on the left with zeros to length precision if\n"
-"necessary. The sign and exponent of the first operand are unchanged.");
+"The second operand must be an integer in the range -precision\n"
+"through precision.  The absolute value of the second operand gives\n"
+"the number of places to rotate.  If the second operand is positive\n"
+"then rotation is to the left; otherwise rotation is to the right.\n"
+"The coefficient of the first operand is padded on the left with\n"
+"zeros to length precision if necessary.  The sign and exponent of\n"
+"the first operand are unchanged.");
 
 #define _DECIMAL_DECIMAL_ROTATE_METHODDEF    \
     {"rotate", _PyCFunction_CAST(_decimal_Decimal_rotate), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_rotate__doc__},
@@ -3686,12 +3689,12 @@ PyDoc_STRVAR(_decimal_Decimal_shift__doc__,
 "\n"
 "Returns a shifted copy of self\'s digits, value-of-other times.\n"
 "\n"
-"The second operand must be an integer in the range -precision through\n"
-"precision. The absolute value of the second operand gives the number\n"
-"of places to shift. If the second operand is positive, then the shift\n"
-"is to the left; otherwise the shift is to the right. Digits shifted\n"
-"into the coefficient are zeros. The sign and exponent of the first\n"
-"operand are unchanged.");
+"The second operand must be an integer in the range -precision\n"
+"through precision.  The absolute value of the second operand gives\n"
+"the number of places to shift.  If the second operand is positive,\n"
+"then the shift is to the left; otherwise the shift is to the right.\n"
+"Digits shifted into the coefficient are zeros.  The sign and\n"
+"exponent of the first operand are unchanged.");
 
 #define _DECIMAL_DECIMAL_SHIFT_METHODDEF    \
     {"shift", _PyCFunction_CAST(_decimal_Decimal_shift), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_shift__doc__},
@@ -3774,11 +3777,11 @@ PyDoc_STRVAR(_decimal_Decimal_quantize__doc__,
 "Also unlike other operations, quantize never signals Underflow, even\n"
 "if the result is subnormal and inexact.\n"
 "\n"
-"If the exponent of the second operand is larger than that of the first,\n"
-"then rounding may be necessary. In this case, the rounding mode is\n"
-"determined by the rounding argument if given, else by the given context\n"
-"argument; if neither argument is given, the rounding mode of the\n"
-"current thread\'s context is used.");
+"If the exponent of the second operand is larger than that of the\n"
+"first, then rounding may be necessary.  In this case, the rounding\n"
+"mode is determined by the rounding argument if given, else by the\n"
+"given context argument; if neither argument is given, the rounding\n"
+"mode of the current thread\'s context is used.");
 
 #define _DECIMAL_DECIMAL_QUANTIZE_METHODDEF    \
     {"quantize", _PyCFunction_CAST(_decimal_Decimal_quantize), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_quantize__doc__},
@@ -5197,8 +5200,8 @@ PyDoc_STRVAR(_decimal_Context_remainder_near__doc__,
 "\n"
 "Return x - y * n.\n"
 "\n"
-"Here n is the integer nearest the exact value of x / y (if the result\n"
-"is 0 then its sign will be the sign of x).");
+"Here n is the integer nearest the exact value of x / y (if the\n"
+"result is 0 then its sign will be the sign of x).");
 
 #define _DECIMAL_CONTEXT_REMAINDER_NEAR_METHODDEF    \
     {"remainder_near", _PyCFunction_CAST(_decimal_Context_remainder_near), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Context_remainder_near__doc__},
@@ -5336,7 +5339,8 @@ PyDoc_STRVAR(_decimal_Context_power__doc__,
 "    * all three arguments must be integral\n"
 "    * \'b\' must be nonnegative\n"
 "    * at least one of \'a\' or \'b\' must be nonzero\n"
-"    * modulo must be nonzero and less than 10**prec in absolute value");
+"    * modulo must be nonzero and less than 10**prec in absolute\n"
+"      value");
 
 #define _DECIMAL_CONTEXT_POWER_METHODDEF    \
     {"power", _PyCFunction_CAST(_decimal_Context_power), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Context_power__doc__},
@@ -6980,4 +6984,4 @@ _decimal_Context_same_quantum(PyObject *context, PyTypeObject *cls, PyObject *co
 #ifndef _DECIMAL_CONTEXT_APPLY_METHODDEF
     #define _DECIMAL_CONTEXT_APPLY_METHODDEF
 #endif /* !defined(_DECIMAL_CONTEXT_APPLY_METHODDEF) */
-/*[clinic end generated code: output=b288181c82fdc9f1 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=0eb835634388294e input=a9049054013a1b77]*/