From dfde59f0e18648f874ab9d41774b6be03d66f6a7 Mon Sep 17 00:00:00 2001
From: Stan Ulbrych <89152624+StanFromIreland@users.noreply.github.com>
Date: Wed, 18 Mar 2026 12:43:55 +0000
Subject: [PATCH 01/11] Fix entry in `fuzz_pycompile.dict` (GH-146069)

---
 Modules/_xxtestfuzz/dictionaries/fuzz_pycompile.dict | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Modules/_xxtestfuzz/dictionaries/fuzz_pycompile.dict b/Modules/_xxtestfuzz/dictionaries/fuzz_pycompile.dict
index d36f55a40905d2..322d8180f7baa5 100644
--- a/Modules/_xxtestfuzz/dictionaries/fuzz_pycompile.dict
+++ b/Modules/_xxtestfuzz/dictionaries/fuzz_pycompile.dict
@@ -54,7 +54,7 @@
 "  "
 "\\t"
 ":\\n  "
-"\\\n"
+"\\\\n"
 
 # type signatures and functions
 "-> "

From 64862112b7beb005523e7bca15c59c78c5319e58 Mon Sep 17 00:00:00 2001
From: bkap123 <97006829+bkap123@users.noreply.github.com>
Date: Wed, 18 Mar 2026 08:46:01 -0400
Subject: [PATCH 02/11] gh-146075: Prevent crash in `functools.partial()` from
 malformed `str` subclass (GH-146078)

In `partial_vectorcall`, an error returned by `PyDict_Contains` was
considered to be a truthy value. Now, the error is handled
appropriately.
---
 Lib/test/test_functools.py                           | 12 ++++++++++++
 .../2026-03-17-19-30-45.gh-issue-146075.85sCSh.rst   |  1 +
 Modules/_functoolsmodule.c                           |  6 +++++-
 3 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 Misc/NEWS.d/next/Library/2026-03-17-19-30-45.gh-issue-146075.85sCSh.rst

diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index dda42cb33072c3..efa85b564f7cdf 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -565,7 +565,19 @@ def __repr__(self):
         g_partial = functools.partial(func, trigger, None, None, None, None, arg=None)
         self.assertEqual(repr(g_partial),"functools.partial(Function(old_function), EvilObject, None, None, None, None, arg=None)")
 
+    def test_str_subclass_error(self):
+        class BadStr(str):
+            def __eq__(self, other):
+                raise RuntimeError
+            def __hash__(self):
+                return str.__hash__(self)
+
+        def f(**kwargs):
+            return kwargs
 
+        p = functools.partial(f, poison="")
+        with self.assertRaises(RuntimeError):
+            result = p(**{BadStr("poison"): "new_value"})
 
 @unittest.skipUnless(c_functools, 'requires the C _functools module')
 class TestPartialC(TestPartial, unittest.TestCase):
diff --git a/Misc/NEWS.d/next/Library/2026-03-17-19-30-45.gh-issue-146075.85sCSh.rst b/Misc/NEWS.d/next/Library/2026-03-17-19-30-45.gh-issue-146075.85sCSh.rst
new file mode 100644
index 00000000000000..792ea3ad668690
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2026-03-17-19-30-45.gh-issue-146075.85sCSh.rst
@@ -0,0 +1 @@
+Errors when calling :func:`functools.partial` with a malformed keyword will no longer crash the interpreter.
diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
index 723080ede1d9ae..576494e846ca0c 100644
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -457,7 +457,11 @@ partial_vectorcall(PyObject *self, PyObject *const *args,
         for (Py_ssize_t i = 0; i < nkwds; ++i) {
             key = PyTuple_GET_ITEM(kwnames, i);
             val = args[nargs + i];
-            if (PyDict_Contains(pto->kw, key)) {
+            int contains = PyDict_Contains(pto->kw, key);
+            if (contains < 0) {
+                goto error;
+            }
+            else if (contains == 1) {
                 if (pto_kw_merged == NULL) {
                     pto_kw_merged = PyDict_Copy(pto->kw);
                     if (pto_kw_merged == NULL) {

From d42a04c0450283acf452d8fa6bbc188c27a6c639 Mon Sep 17 00:00:00 2001
From: "Michiel W. Beijen" <mb@x14.nl>
Date: Wed, 18 Mar 2026 13:46:26 +0100
Subject: [PATCH 03/11] GH-60729: Add IEEE format wave audio support
 (GH-145931)

(this re-applies reverted commit 61f2a1a5993967ed4b97ba93a4477c37fe68cf59,
with a test fix)

Co-authored-by: Lionel Koenig <lionelk@google.com>
---
 Doc/library/wave.rst                          |  69 ++++++-
 Doc/whatsnew/3.15.rst                         |  15 ++
 Lib/test/audiodata/pluck-float32.wav          | Bin 0 -> 26514 bytes
 Lib/test/audiotests.py                        |  16 +-
 Lib/test/test_wave.py                         | 190 +++++++++++++++++-
 Lib/wave.py                                   |  88 ++++++--
 ...3-03-10-13-10-06.gh-issue-60729.KCCHTe.rst |   1 +
 7 files changed, 354 insertions(+), 25 deletions(-)
 create mode 100644 Lib/test/audiodata/pluck-float32.wav
 create mode 100644 Misc/NEWS.d/next/Library/2023-03-10-13-10-06.gh-issue-60729.KCCHTe.rst

diff --git a/Doc/library/wave.rst b/Doc/library/wave.rst
index ff020b52da3f23..9d30a14f112937 100644
--- a/Doc/library/wave.rst
+++ b/Doc/library/wave.rst
@@ -9,14 +9,19 @@
 --------------
 
 The :mod:`!wave` module provides a convenient interface to the Waveform Audio
-"WAVE" (or "WAV") file format. Only uncompressed PCM encoded wave files are
-supported.
+"WAVE" (or "WAV") file format.
+
+The module supports uncompressed PCM and IEEE floating-point WAV formats.
 
 .. versionchanged:: 3.12
 
    Support for ``WAVE_FORMAT_EXTENSIBLE`` headers was added, provided that the
    extended format is ``KSDATAFORMAT_SUBTYPE_PCM``.
 
+.. versionchanged:: next
+
+   Support for reading and writing ``WAVE_FORMAT_IEEE_FLOAT`` files was added.
+
 The :mod:`!wave` module defines the following function and exception:
 
 
@@ -60,6 +65,21 @@ The :mod:`!wave` module defines the following function and exception:
    specification or hits an implementation deficiency.
 
 
+.. data:: WAVE_FORMAT_PCM
+
+   Format code for uncompressed PCM audio.
+
+
+.. data:: WAVE_FORMAT_IEEE_FLOAT
+
+   Format code for IEEE floating-point audio.
+
+
+.. data:: WAVE_FORMAT_EXTENSIBLE
+
+   Format code for WAVE extensible headers.
+
+
 .. _wave-read-objects:
 
 Wave_read Objects
@@ -98,6 +118,14 @@ Wave_read Objects
       Returns number of audio frames.
 
 
+   .. method:: getformat()
+
+      Returns the frame format code.
+
+      This is one of :data:`WAVE_FORMAT_PCM`,
+      :data:`WAVE_FORMAT_IEEE_FLOAT`, or :data:`WAVE_FORMAT_EXTENSIBLE`.
+
+
    .. method:: getcomptype()
 
       Returns compression type (``'NONE'`` is the only supported type).
@@ -112,8 +140,8 @@ Wave_read Objects
    .. method:: getparams()
 
       Returns a :func:`~collections.namedtuple` ``(nchannels, sampwidth,
-      framerate, nframes, comptype, compname)``, equivalent to output of the
-      ``get*()`` methods.
+      framerate, nframes, comptype, compname)``, equivalent to output
+      of the ``get*()`` methods.
 
 
    .. method:: readframes(n)
@@ -190,6 +218,9 @@ Wave_write Objects
 
       Set the sample width to *n* bytes.
 
+      For :data:`WAVE_FORMAT_IEEE_FLOAT`, only 4-byte (32-bit) and
+      8-byte (64-bit) sample widths are supported.
+
 
    .. method:: getsampwidth()
 
@@ -238,11 +269,32 @@ Wave_write Objects
       Return the human-readable compression type name.
 
 
+   .. method:: setformat(format)
+
+      Set the frame format code.
+
+      Supported values are :data:`WAVE_FORMAT_PCM` and
+      :data:`WAVE_FORMAT_IEEE_FLOAT`.
+
+      When setting :data:`WAVE_FORMAT_IEEE_FLOAT`, the sample width must be
+      4 or 8 bytes.
+
+
+   .. method:: getformat()
+
+      Return the current frame format code.
+
+
    .. method:: setparams(tuple)
 
-      The *tuple* should be ``(nchannels, sampwidth, framerate, nframes, comptype,
-      compname)``, with values valid for the ``set*()`` methods.  Sets all
-      parameters.
+      The *tuple* should be
+      ``(nchannels, sampwidth, framerate, nframes, comptype, compname, format)``,
+      with values valid for the ``set*()`` methods. Sets all parameters.
+
+      For backwards compatibility, a 6-item tuple without *format* is also
+      accepted and defaults to :data:`WAVE_FORMAT_PCM`.
+
+      For ``format=WAVE_FORMAT_IEEE_FLOAT``, *sampwidth* must be 4 or 8.
 
 
    .. method:: getparams()
@@ -279,3 +331,6 @@ Wave_write Objects
       Note that it is invalid to set any parameters after calling :meth:`writeframes`
       or :meth:`writeframesraw`, and any attempt to do so will raise
       :exc:`wave.Error`.
+
+      For :data:`WAVE_FORMAT_IEEE_FLOAT` output, a ``fact`` chunk is written as
+      required by the WAVE specification for non-PCM formats.
diff --git a/Doc/whatsnew/3.15.rst b/Doc/whatsnew/3.15.rst
index d4c4483bc5eb78..7d5c6e224789be 100644
--- a/Doc/whatsnew/3.15.rst
+++ b/Doc/whatsnew/3.15.rst
@@ -1511,6 +1511,21 @@ typing
 wave
 ----
 
+* Added support for IEEE floating-point WAVE audio
+  (``WAVE_FORMAT_IEEE_FLOAT``) in :mod:`wave`.
+
+* Added :meth:`wave.Wave_read.getformat`, :meth:`wave.Wave_write.getformat`,
+  and :meth:`wave.Wave_write.setformat` for explicit frame format handling.
+
+* :meth:`wave.Wave_write.setparams` accepts both 7-item tuples including
+  ``format`` and 6-item tuples for backwards compatibility (defaulting to
+  ``WAVE_FORMAT_PCM``).
+
+* ``WAVE_FORMAT_IEEE_FLOAT`` output now includes a ``fact`` chunk,
+  as required for non-PCM WAVE formats.
+
+(Contributed by Lionel Koenig and Michiel W. Beijen in :gh:`60729`.)
+
 * Removed the ``getmark()``, ``setmark()`` and ``getmarkers()`` methods
   of the :class:`~wave.Wave_read` and :class:`~wave.Wave_write` classes,
   which were deprecated since Python 3.13.
diff --git a/Lib/test/audiodata/pluck-float32.wav b/Lib/test/audiodata/pluck-float32.wav
new file mode 100644
index 0000000000000000000000000000000000000000..2030fb16d6e3bd797523605091ff1d732b432b88
GIT binary patch
literal 26514
zcmW(+dss~C_unOiFsKZ|NC;sNMzhyyAGZ_2phF153AxW9P6%6)K{N=1Fz$me2x<1a
zW)R|pLDF#@bO>?A<&gVte}8|?^UU)!&8)rNwLZ6ZNZ&qvR!-u$;lB*)J#l)XsxHTI
zl{jy%PFs#M#(HtSoJxLY;<(=vedO0yejFD+E^%C}{1^HWt9Z`8d0x|;z(_IXi?-IF
zd=xJ<hM|2HIRteod`oqaI(itWht`P{=o^2!1LtsJEbsntmlp^3kYWbccDP$=*svXe
z4&nP1=G5=Q@;%Ln|7Qq>b?!@k?G@xdYZMJhcux1V)5tv14PxK<lyj;Im7iKfwqxxh
z3zDZ1_ge!NT^p%_HNx^om1y0-9TdBIH7k0obLi^VVYYb|ruzC-iv2wegt>mK7Qd8)
zC-s@n&l>1S>du~Q`HJFxe|APu)#2`OOFDUYK%{upVsCitJlO_%!>x!akxuI-5bJ&>
zcVaor{v|lFC?Eh!e5#Spz6j*rEpSLJIwQx4k>6Se|L@hI+3$~CHT5DxwXYy~MvF-9
z$~{P!;!Vcy|G_%HOBDL}D=0^eq>^3NVDO4Qkp=trLRm&Scz*7Lpl3(WZLz^4Q*fkm
zU@3H)l;8*}sfM9}bshQ>Z=gd<-$-N5UYPM<FS+{t3gOXpNxWU3&oA9h&b3PRZg3BW
z^TZ8ys_A+(7j&Z1S)(vrJBhfIE-ZpX($)Du$t_k=MaWVpvaBUT*b`>{wvNs)-^lo$
zD=4&Y8_cdbmc+qxq>_lnWO+B2`L;d85-!bfsE!9Rb5ISkd^{;xW+7MxS*4N{jmWaw
zEV(1LFw3WlQsBl`k=)v4Qk%aTIJlB^cIRx26ru<5h6J_zJ%52OH*FX?$_7H+?o^TC
zg^3bi^4CVlRVu)&*7*PRQ%%<Ve?6@cO;MlM(cv-HLe0{1pz2=?dCz7==I%KKA2#=-
zggaLtZ>5pUX}6)Uc@AkF9)_6R9U_g-mw>N01@(`U!9TnyhORcjjV3)Jxr~c2D!!eA
zAL)&!Li#!iM!$nT!+&DQup>}*p*;zQ^x&Dlf-D*9dBvI9Bv!v8EmrFsxz}@8iB}_x
zp4ozSnbu<5{?WvJ7%pX2n@>@#@6pKOWu&j$m=*V2O$G>K7tgGrwAfR4F({3=XQ$A1
zZUlL5`jO-aBy({QSnQiwS=dyExKWZ8O-~~+`>fqEX(4c?tM;-k2bj39-0ojLmQ=4&
zq*~GHNHK4Uw5H%QiSIVrYZ|IWa%JUO+w3N2@NWXTZredIVKbEHw?wX}94u3NQPDI7
zHZSTLdH;0B|F5Sws1ru-nH%YR7l8R+22es^WvpBCE*T%@!~gnLH6jbrm((QR?4#g0
zC6e!s^Dwc3k^b&p*x}|PZOdmt%I2HM)td~?;m9ji8=>%g&q%$2fvWp?@*UufR4d65
zJB7nq+N)^oz(5R`&Wo3mAnTfgET;3kvuZQuK4p~(-}iDDxqZx8)RQHjZc3+aF|=YF
zan7gRCC_}C`}rg}M=T?Ma{#$Mt|H;aMc(^XI^_-<h_&XW(wOuL3_CN7g8t}2nZb3a
zK-B_s+Z$QZynYU0x36Tacuw5jKD;vN6gX?N<aJn$i902&w|*^&^)K0%7dDA>25Y3C
zM(HG;TxT~8{sXx(e{J0--%wTjj`tJ<k#0f?<o-N`>YBHq;Oi-p+E>Pr-}^;=xE}KV
z_2fUc#r7-Qn6<qoRyprL=jD&kx^R?3-7Dw+>*-mQ0tv5<gCb=ee2YCwq3w@A>ay)*
z`?v*$v5n|FIvU0|tr_Y5sRM&w2oo+Wg5PF`M(SJSfMA-%{N;1;zd7RkQ57{|zhlCO
z>+s=l9ER%C;r@nyNO<Q3V%u+auH{InS7Hl?`CTR(nPjBgTqU*n`z|Im9ZC9QwSgO#
zO!~8%=v~$_a?eko`;%9Z>g^v8d~y|)Y4YLPFH33rg{qOIf5wncXK&I4`B6dMH?TdQ
z$(Ae(aBw?MYg^0-b_l)y<C8ia1xs29FN`_Ei+9)Z6Qg$$cQQm<@$D-*mo=C4zx|ZN
z32*JL;W3Qsa@gKxpf*yB%HYLsQ^~zG8q%~E&^a#`rnEgmiYD)%=uw-<gaP&O&F~S9
zJ$qW9`$;7#Z|jR0Q6nOaFUtN`M~CO?A^6mDLZr$$0aC8KM%|u8kkZXVZtE@x3|K}&
z!dA%bt3=!N@$l6c80oPL0%3PD?^?AOdW`vqibuyGJa;C>e)azUdI}2_s5e()M&T)R
zI#-CEx|?B7`<LXL8UUt2!<g`<m1KGMmTXhkFlqD~65j@rFzgQUtw)nedI{U(me7oA
zMlw}4Qkyv|sAczb@+_DLLjP6dnbQ(--YlWoR<B6mosLuu(xt*BKBW7r0T>PoEO?WH
z^yAL)OR7aWbnQoi0Ec)>pT6KaaT?q&>H@!fJGq54-cw^Ya(^wi8)ptjap!xx>p&U_
zQ^F)o>%NiPO44RFuTAb}bs+4z359i=pzO*hQoJmJHy2-FenAzycC?gKts3EaYZHfS
z@z4M7$6Vu0m=YW3aHegAxQgef`xpTOvxY^w%>7}@rO#B-Z7s}ixRZp-n}91l2OjkV
zXnn1Eq$+3ta3fzpXfF{O-rJ3_bR3#Ei!r>t4@QPhb4)v;#D_BvlYZ+bxb#oeNad=%
zuqcbjP^AS(5nYJeQ&UP(t|iOqRjj|GzN4sLAmOsTDCFy@e9&y%b3T>yKNr!%#VbkL
zZYD}jCquvbaOL_661wl?KQvrKSLQy##0C8*>iP>PTksz<MFVr~ufZ(!hmz-2TR1$T
zk3;Fb6*O(`Ghx;m@U?}Yb4-8Gk6uAy`9)r}tO|;=ci7Fh|3dNL0*ULDL;7}h>7R#f
zBDtt2DfHr65PmoE+~9{G4jvEgtxFmA&uNJ0vmCiv@1Vf*kR?p>$2jjP4)OfA|F5U|
z^A(8V-%?bcEuj8a!8ncj|KArsbOOHZ0WvjR0V&nwz8bR?qMRGRwKNeXPWy)3jlm$@
z?t@X?mw=`25VV~?2Cb@iMXGjG!k?y&4sk;h{5C1bVeC~I=S}j9v{{Zp#fu(f+1?qV
zdK@6`)^mILKm}DeR<M>s8$0%#4Ip#9I%rCYr|h+7FnEWNl3Na<*pI8pJM}OHv(+U2
zjOUBG$~#THpO<FOqk;}c(a^6KeMp>*ionNAz0%3t$-5+5`9r2NC&SS!jl=ZpDzsT(
zB;|4fo(7@9Z#fhQK%N`EVEWmEaiP2H7x(@TH(ioywa6mHjR1CP=yNp0`Y>sO8M$ve
z?3OF5B+slGz<s#J>$h%%(jQ)!bh!vJ`}$z%5I?N4Vv)n__y!A1LS$L-B@ko&l59t|
zfoa!GQiX;8e?6TuS^+n@&~Ckw2EoIdI25Dz09TZ$b@~{=`TJ+I%o__?gA!5fyA*6O
zJ{bD+C~P=fInwthhhx+a>Hbp{?p6(QNTt>Bc&|t3d3OR-Bf5jh(Hd?RJ|XcKNCmcY
z%z0)#tL^l4WKjc({j`!rKb}IFSMTGP@97kpO>E;26DfxjkhSk>a^AfrZNIaObe92=
zzf7m3zviO&wJUwAw-3c|C#z5%Wt=eo40qnb5>6h5b{m2m8gFl`HQhzNTi-x-iWXzn
z>;c!ybS8?8L3kWNLUMDdO~OaynglcBReAs1o4{O;qfs?{GW$6G1?n$(B*Vx6=Jf8x
z>yP=$e=`GIiNAnmh6C1YU4@+Ji{1a5;xNVgV9qK#y0*Dsex4I8w+?{qT%f}>tS{_5
zHaSvog}?`s6Aj&$LZjnh4&@(K@ax)=Op7w$uQ~Fb{~iankgX_Om<#HpKcHaM9xxC8
zfwAY_0oR8oOZO%?C}WZ%q_`&fwVH^gUvgmOa}(-MHiq(cZ;8_`k%FR|kSQ*Ul^ptu
zxKE8Jw|EA{{xX9KM_k7bMH!@<kq8f^brkjZ79}LEB3=8(tm27Cv6Y<Q6E>DY*R(+6
zik6h3J%I%?vY6m1k+`4Rc=ekDOn6lSe!3szPHKRc<GmcAL#m@K*9}qf-gM^;2QH)*
zjFIsRxBtAfX8Z-T?Mz|LrSJK&Hiwv)c}^RvJI+2o<04&)CNu6^Z4h0JCGNUP>z<9k
z`8TyIn&g6^eKrc6{g9iE4%LTxs471s#U6MALeplEYPbZ$o78l;qZdNKXhozct{Yt2
z*eOzNN`?LEI*wfZVKA?~NXqXUq1JT|TD)RmN_G*dpN;{p!W7|2%Y-IgMHp4`5OmEK
zgWnY;uIx6!(Q8$0R6OXwl$TCI-lu<%n;ZaH$1jk6^hU}0WHsr1cCzf<t10VNBT`@6
zNq*7{>h*^iKlE8k*2DoAWm->)#f%y%R!~+-JQaMOOR>Mchp^^4x_`VXN)SkI&g?@^
zuQ|-!V<1?5YY4^*2bjAjhwaB-Cz0=fbHZvml0F5Yc<8&<_gFq8oUemoji0=-$pUf@
zR<h7bGck18aTcB13oRYp%zESq6VhI=MZcAzYR^7a&euds_9ICgc-5|3-xxf%XEIlO
z9*A>}VqD*Pn0Ca=5uV=yb&C&^X>L^<-MwRE!o){lt&&3}MJC|x3`SGSaQHRpw@BCZ
z88Gl^7IBSs!_ngU4$p|S5Y_$wx*H-K6l+E5mUafNpg^lo&4*J@SE2Fr1&BYl6h&Pf
zv@PxJ;Of-Dd`C7#Z9M}kCwfP!Kh*|BkwD_q{Zide*GN&mhxw$<ps3dksd}yLq#7}u
zVlWg__pT)xy%s5AJvG5)l+a=sm9;oP$#oORcIG6Ml=3t!qakuKmutUwExNthF=Nm}
zP^}mT?(NIvnkevG@BO4uN8(AYj-!yZ!r1YDGvmXvVAl3P?&%6X|Av;tz$9jBZ2?oi
z_v~f<I?SK1pn?+zSjen8H23`hEa-TX>0V4j;gFK)A7}BRu@xj8zr{4e?!dHT8)N|9
z3MckkO371uVBdLu4$V;&)*2od>308s3Mrkb`tJf)r@_nyO<|CtZ=`8+2YI*cvg;p+
z@Y{^G4%49oNQycM&K95fNlC3Dg%lT`t9%RGbPbf<EryEFL!eV1Mfc+xIPZa<BlnmR
z>jl(tBz3+Coyv>Rm7oD<$z<U6qV&w?IVG&$z+z^uBTIQ*3U{T^w=R=N;g<=EhO8w{
zy#aG#GAaI7UurWll?v!Ag<jGVHzZE$c6X%A%+6@*Th6Y<FGpecPbuU|ZS)<r0`%UI
z%&BOMwaS*rGdCLBCDwH8+1UwAqkbo6?Q>9Z|5xPdFVU7X%4WV}tV}gg!|orgPscTz
z(fX!6S(0s1Y)D)3p$Qn;yn<bMzX~l?!&$6z4XCan6#Vm=*~Wi``1!x0^<N%^Q$v_<
z*Rj~XM`K6M8JX96=c8vqO;pe9gt31eh7V&}koe;>|8u>}A0p23WhF~du}ck8Pc?9u
zRAKO8T?f*aui|Tn!I93}UHDYTW>k%>4qW^75jM|O_|`lN3rE$!v?^ODE-nNYj0khM
zGdxfcF%G#SV<FqR2s!0t`;h<6kt<*=>!&zNwsmzVv{x#nwwpw%%^rS6vV6`@r{fW?
zO=Ma4P4auXlt%tXq)`s1lKFYeJS~`VBh~21FJLL|G~}Ajmx_k9!`RpZptt>$V&=3(
z&x9xndolu}{_%Ere0ZGkY8RFK;sD=1O;D)PQBo~E%qP9P!)#5Sv%+0nsHAv4>N5M2
z$7??5$3{|NKoBa1R3%Qc62+cj%(mt=h^2F(Y{F@lvn>$Kc{yPDXBevgk~#kS`B=f%
zaeN!8!w(hJv3z$Otk_|}+{7J_xVa_?mLUFPw?`;0t|1lDH59Z1_?UeUN&n^$j}cDd
zR`6Q0`@6i~j%)fkKcL?9FE5tW;?;w9fHJ?Iycg@CC;DH;2Wqf5w522FXf5Pscav1N
zS3=ReY~-$F=lOjZPX%`~*{(MaDC%S&y*$2yeAZ5v`%;_tX0e${QdXiRIE(aSd&9Z+
zsWh_BQM%uA0O`BQ`b2<&va;)9K}Z%0I<^A2w`OhG^8V=Aa}|X26e-@*9r^Gk#Kp$r
zmA{@*>0$vVsxMRQWqA)g+X9w@wOGZ3`=Gg0lM*_<V}7Pl<afITX3P69>D@ap>VBh&
zD<8r6qBa!{7Ezd0jm2*cK;`;_AX>XKS8xOhW9#zz_4Co18-V5NHCPh$ih}M=M%U|&
zEZr{vi}fcl;dmNw={=dsu}&H@bPakM^<ovSr>NRdAXRuTAnvDNx9s+i(A8hkcU_NM
z_#yj;DgKeB5Fbcb{Th6`o`i&2`4F`;1oaDRF~y=G_{#@*&uwjsaVIt8S$707qxK+I
zvO=p0na$LBay_=)rqloxq4NTzW+aiWVhPKixPv-fUWxftc9W}#7j9w8X-1{Z<X+mF
zTq~B5v+x@$V+;h%7#4m$9i6WW`8{1{V#%ntAbPFW>T-WY^W7?xzic{s*SttRirzTv
z;RAB+vjDgJq@?h~vz*_XVMSS6imJDfmG6>wQ_^-Q&Pk<SR28Q^8b=jF%0UdNP3F~!
zD74=wMRg8FeVxa^4d`w!e;kLV%n+tnn~wJ<HbG7O%~*V6KV{CDgM70%avrOOov!Ra
zu5&P0_Vxr@)L2#+%%kq#JQkR84~5IKn04?b#vNZPm6UuS?!U`+)$*Mn2A|U&>lYBI
zUeOn}hozvp;vu+mCPV&b4LZ-Sm;8oI#u<%Y5I-&w0}D2g(*Go=74v1>T1`?kO9fl6
z%goxvM&$+#rN=%Z->=Jv>ljQEckZM69~WTip?#G7eiXj!no4C$;%U#?Fj~V|W!)=>
zad(n<vGz(yVyonHIS%rlug2)%eyE!wbJ{n9FsjdYRytz}=65_m%6l42k93n^{#bA>
zeZf@y7}KOR$Mmzm$;x1el+?^b&a|8SmX9V`Z~XxGJH=C3H#hiR`^xxbQ&0$)&-)a2
zK>zNIQNQ*RKmXG*OxV4Y&HuO^4Zc+{XZbF)9veW0&41z=aTBQrJc9f7(a7yF+G9I<
zp=n<UvsF=|WxYQYPq~OCoeG(|$}b=e^I~`J|4riYEm~uf0w&66V$vU8kw(`J7?^ee
zr9AmuZ<0XqW(Yc`Kb1nu7vn(x0?L`H!-q+yDE8nnh)+_Xb4{7_p?^b+8skmLofeS4
z-!KX-e@02oO%!oxDK&X`h>}-EVv4Yzw$xmY{I~^V997P8JJcd9%OlT}zRZ<GOvpUQ
zPy2ly`i|TOEC1Y&2{Y?s?9@|W3><*I8$Yw0&^WBydlTt`LojG#2|0c5@%exDq_PK<
zsFbUOzU>x}0d*i9-$vZ;^?CESO;ob-JQzldA})p?)P0e0L8DRcjD^x6z0f~B3Uw_O
z!?Q`7QM|sMty^~xg%>$6=G-ofeSeMRTu(q_pIwwh8z70@1=HQ(EOW7pS1Je5x6-<(
z$_HAr|CoHP|6_jRs-QdOfRr-uI2k^LLhRkqq-?MOd|F;W&2$fh+1{X`X*;}c>42&M
z<4`|jqm*1{2^POSMq&H=Vm~aTk}WCVs<s9+CzmmoDH@Y{v?j&;+LV8P7R5}vM{B-h
zQk(I|>EoUKWWqC$d^U@8ANJw2y(386+mshqo@J(HImG?l+wL^#NNha`k}kAIeZ7ld
zy>tdsHz_deT}RA*(FK+7uQGRSEgG`dQFi@GSmo+X;`XWRs&9#8@KI4oog)xiU)EfP
z5nPG45Vz_#-dVnu1p5YvOXbPvk~w%~Jqyu9VeI^iApR4By++MM{b47h&fJR?1tK$K
zA41`u27pU8q9@avm9*)B^f8m%Bdt7lqZ^<5*Ar&k)dCZn_M_P2^1PooiVWX(q2c3K
zmi;;kh4qd2_<2jocl3GKv%*Y8CT|pO|AEE^Dl8cE1$BJ|+_!ZFCZ32x_uN8WwRk$t
z%Gyq;jXR*b=rK9@=e)j#FH?lwXIb-q$DpOr<eXJ572RDz{sj)osj`+H&bUq1Pn*fo
z|E;vH{YuJ7*n{bs4iqx84(hJ<XT`TO$i1U3bTVwBg1tMyFz659GS32jJ&n3Auc51H
zC7PehJfdrJmbIcTE{e&Z+%*?qq^p>?kaJRxD(lEKvjf>qw}rHSSCJ*{2R!^^8|edI
z@$Xu$AkU+bFzrZVQXEJCab&s_)UGWi`&U6*O+9)#q+;nRZybN@09y96V0xp>b$2|q
zd(V|I#$Rz-<M)QB+%b=w-|bS;kW`j%qcMf=tA^jQf2R+(>SFB1aWtljtP6B{z%+0E
zM3ti-Xad40endkQDh`p=zY|(#oPdP+T`=(FOVm%);zZvwSaD21<*geKez*_1mo1}S
z!)jsqr1!+xjzlPm>rrBjD%7jdFm&e)BW0e<sk_goi%t_+<huTdETh<6^1KXaK|$@O
z(X;tR<WJY8sPcu#)x9IdHfTj2a}-oRo=vXSX3*5!#tdCEAun$e=0@xWpL-|J()cE*
zZY>1k&NBFRB$-U(55X*po7}Nh$;2NcA+aTizX(!pP8#vkgD`f;28vy>67-&hq_cK}
z%r=!tU;LBjEZ%%<q7MoU>!W_v@2K!yjuq!yVMwFB$nBhN&%3q-Jv-VkzflvAn>SOd
z7N3ET+m|fU;+b#KJyv$QJ0<;F1YrZFP-tE?OsxJJB_CRWWgU03gtBy0dFO+E%^DW>
zREMd9tz`UrII446vz+P?xTf)W^t}~~T}{QPU*V7WSEAA73`CWo3*|Pu50*z2r2i#F
z3Ld(Ga;hoFI7Nx!NkfU(hhow0iIn@M1?>qON9R)96g5CkQt$N?x2ZpcH<s~YR0aFk
zW}7_UlO^YWOC{H^;jru7HnLq=4*3sy$(sI9__neuDvtJpHrt%2n`wsl&48X%`TJUf
zNpo=@-2d{3xXbk=@9`y6x=2aR6vn>1UP8uKtx!M0MEp<rtW}#u>Q*yAee)&b*1pz?
z8aJ<Ax&<mWhhUarFm|fH0^JMy;;wrZ<PP<K+}dkV7#+vHrS(E?MzUmjvj?nITTn^d
zZsy+MOP;6!<jGhK%6}(Qg{cC{|L93M3+JL>9>rF!+=xY$tD?%B!`ot#(0gVk^~#@$
znv3<R!qOI-Sd6G%{vY%?a1Y&d9-=;OK<h6>U|X`B*^ZrphLv8BsP7?7te#KzJIea+
zKLH>P6zKkX9fnlzPwt2L(w?+PTGagvIc<@Y)QiaSRzuEBfqaSP1G_R}1FCdZ$=&@U
zxPE9Mq|b0t%+`bY+7i;8sRpK?x}YCd%s&a(k0$SN;P=~V)QvbHb9#<>Rvm+j&Cii|
z=Y}?ad<Dh%)*yFq9C;2dCV@V|w?8w;FJG?ziW#K->p2+PJz!koRNi$b7~Iyiyt7U_
zbgyrOwYsf9&5;;v-*PJ&&pm;akcRs7N0KTrMAp>3nNW8q=-Vl&B=#&zz8XRXa}23(
z)_{tcW2oZdYnZm873Kdk7FB=eNc&oD!fz#QQ1$H$l;224*TWf9YD_})mJ#H8UB<Lk
zm1rEh1?H}~f|i8>tn7IPb&6FW4xbO=`9m<Kt&_wTO1|Lq3(^$bWU-kAj62$jg3`KS
ziP)K}M{~e5vNdTI&!VJ>?dax!OO!LEGsRD;PSfgpQ><n%THgJTghjuiZA(i~WgcdV
z!#Yr!{vaW&h<EMV&cwPy_}sX0Xc*W5_9(VsZrUMG_qKz|+W`^bE67>z6#uN*S4x`u
zg<+>`GEYh-uGtp8{iqCz9vqF?_a{@5Pb4NCD`3t88KCYo8N}3o?Mg#;RE*gVX^U52
z*2B)Ya(pJbV;i9`e>RE(ig|8?H@YWeOKx_A_nT9lRMSgXT=O2J{QEcJZuXb-cL$O3
z>}~MzsX>`*2cx*ito<=`6UM#hi9zzrwPtL@(11`Xyd!In)8>)t!ZUEzX#oPA<NI_u
zfLy_k?lX!DQ1@$lNG<7#?nDQaJxC$vPYqbEzn8tBH7rXzn<}6l`F1=F)6zqUo2<YB
zp*abkZm{^ip%jvOkW>r8Dfhq>at2nXGTa5uvbrp~ybmhoYd{~C%e!Yy25a{a5~^M2
zRii2xmtPj4n*1Du=B2!O)G`e9+5%zkT48SKSx9eQi)>|8p-q>2R1*H2%{}cRXGJn8
zd){VU2d|~<4-GK8QUdX&NoY8CnpN~|fQElIfcq8k6?J=~TdEGuc1Gk{zJ%i$t5C?O
zC*#RjbSqbZ@1F(0?N8vjbyxE|$rqWhxP<v09Y9V)KPs7GW|~gjDJm`vN*)(6=@~EM
zrAK`6*3CGr?I288Jq)c8W*G*aVEV0-k#j93>)&QDr7dErEte$!&$Cc9y$UP&{Q?@6
z)dfqDjJKP70CVsMCjKqK$nlSf`>Q4!vdJd%Enit<s>ytZwIiEQS^my#$k{u9-!rH+
z`R_@fL{}$Lmn@QJX$=x{UP`uEwOG~@S<9?65?oy}px{~x2*-Cb?)hO}Cq81%KMay5
zxFd+hAKJpFeX;D>QuvVD6;(k6;0#bR{g5aKwjUz1s(>jz7L)73Jj(1aoZcB_O=jvG
zD5@Jz_ot0Olem|eZx2J&n`2<9dIGGwqS3ah8r)|~(Uy}2=KRH2u&V?L-*iV$h3u&;
zTLb#X9l&khD;X-fvkGkiOKhc~imqKqZ1;hc{?n9%iotwE$1N;mj;y_{34^FV)?rfg
zARKdW8IFIEiCmyk>pOcS79P@*__Z@6Os`I!q$K9oq^kVfV%U><*{Ev}2BpCVu-DFp
zsIp$-&F`w?y9-Cjx&K#b(XW?C>{^$S8#X1wnx5pUKO3yqyOYj$DkPj}L1oteSZ-l+
z`S<-sn)q)_Q+ASB8Wc)G?mUP(xCGqm5<#4`3QSMxF`?*J-aU0YQ>D~ldcVy)S7p2u
zs%?boyvZQ!Z;w$acfr{(l{YoX0M#OqtlM_5sDoE1r^y`ZA$!m*`)(jh^he2c;CIsZ
zX@v!r4a`_F17qW^L28S}XgC>z#uyW1g)T(h(BTj=ZxXsg)1h!^V|3<D2F1``plH_>
zoc>=VuH9~XD6_J{kJZT>)Q}QVtB_e&jkx~h5=Ze&G50j+pL7MY&qB<e`U@8E>o7Ka
zHL5r}m^J;dmv3Wo$7J%x+%VbGImMhiDub|iF^k&01l^TKK~Aef7;o30F|8(YUNUDh
z#S!;yXWp}5qO$9)Xqt8*m7N_!`XyahuPZ%BELOsvJb$un7{StWs!;CEx@2uo%xp{Z
zm?~|Lq?)mk7t@o$wyzrK`pyOC-;X4&ht=*0pT{iEr!uZ~Ft1AcA!WC&go>I8VEL~#
zntuNb!j|b^F13RusS7z*rm*~k)8xKCkJgRfNr7S(skc66_xS{Jwfzfp57SuT`-xc4
zP0r069VFxLICSl*fTD*pvEm>38Lsb#h9-SLRrD2{OTO?be8*cJ6!M14)tPXhE$^x}
zkCokJ%sTG_^WFA|Da@~!yHv+i$2u`_eJ5~UXbFki`(S27dkjrkgGah9LyxR^E1&j2
zOS7F!Jo8v9jBiP~lZu%opgyy`U&?xgwUTG+YVba`2?hO7tk^jS{crWh-0m`mn|eZ<
z-F`bIM@G_&n6+eT`zHyTtCBgR2kB>TkScDxWrnyK%=PIa6GQDxkEfY#St{e|J(oB`
z81K2pgQdp_-jI*-cl#=d85<>YP%3kWu4df8Hj+@k9!n~Af#KmYFf0neFj?Oc%LsI{
z-CzlP#7x;^*|kO6Y0OKJ+^rAM!RXzT$ZIL9_XIibbCef{_h9$`6R?7+qwl!{<XTL?
zkR@uA9>$^W^<7Y|Y=x?A;~=)c4qVw>-aXeOW7SZ*J6C?Tn$_Lan<_I)@6}9vc!cTt
z-(k5cZps*E6jMy<#>A@Id2YyEKI}mt+GYo$-+(2kD^14yQn^<@|AIoSx5OQ*rp?W&
zM9P=%SlN$NEXr<TMztM0yLUiTokR?qH32^~n}8)v$0E07Qy#}>Xv3`&DQNsC%9^%{
zsxMkjrQLY)o5)j1frZ(|9cH>ZvCMFEKGRLx#B2xmFlP^*IiCa52XEn>&GUI-;wN4m
zRtNNnrzN5Ih?G0Y$P#R;nfqZ)X6RdoB@8t}+1YiFeX1_z<SNlR_?_(Sya8K92-9uS
zvtF~3Xh`KWY7(}Wjwf4Xe_Hkiibj*ZD1lkp-In+z94dbg!lHe8^a+W_*!IIQ^8sSg
z$!6%T_5;-4PlG8t4J;iTyjU%Z=U$$WoW61`YTS^xirRLKb2YR4Hl5j|tITM=#azGY
znQD0g6Q=p|!i3(u!TvAA*7ZTp-UPI^nu{N%#^9clzoJLc3pl?H5fx>pSm8=v(!bx&
zbSt(qedQXU@jV63z;N^l{1X#mN1@LKgFK6pfs5a$Rjl%-@<oaCq01k1t)q$jQU}wt
zIc+JSRV8x9cV=Zva+teyktB9LB<o_knfNrE`HERgwf;8GWhC2mioT#%zvsDK&9&m(
zc*&47is^zEGF6KKOx>Us6Gp%0tqo03U@e8B4Gpl&Spj-Z_7V<gc~g0u{P`Uy{n~OG
zICmZ8c^#mU?^DRUb^vkrzA<k8_dLZ99hCgh5({T^$AquLF}~wCRIX@<<=150p~G<~
z8Z2u+YX^fqU&jCEeL;*$k(?XX@VbTJ%yRMoAKLgJ6SuczLi7t(z&&TWR~alJc0J>s
zOtW+6c51nBS$BcYkY$NM<?1<@FiVfohX<kitpuENXN0q{j!9B|3Jp9Y_w-RFo~<pF
zExHQ1#@Eo~{!+~O8HqXf=cAx21n$()ywE9ISn9<zDiDE+qc&00j=q#s6hO|7O^JI^
z*Iuzx#y=5XBb-0)GDVV|i9P2r_xzV~_Q}jUH+m#-@_aB1^asn)uRPb`iB^nxEU6X@
zWFE1%eD0ewE_Q8%O`fm0!#BgUwgG5qcn8#(A3zwV1l2YzOKSFtO^i;Zpzm`iZ_7SP
z8NY-|&LSm!4<(_)N}lUtlu~W2Fgc6E=tnY6lr^i^?ANjuJsNd048T9@hK4>-5c>2s
zxD?|-m^hy|`LzN=W(($O>IJ3^xlG-#AyaRwLawV`RPgc=b3L#zm9A9o--Fu!`6p3B
zK7!d>kp0csSbk{=O5Qq*?<~)zX_B2&D9@N?w5F&(m$BFvjOl!RSnR9kph``Fyr5O6
zmvwA$tn76(bpto8ha_AnkYZ-9Bh}}sR61ufWj<*~Ww~X{^GmRN_Cmq>NY3G%Jj&-k
ztt|Vh&zZ8pDW-v@B)-03H%0Nx6F(8eXOqCyG6uNI)j%}u(<-`anYi|e<a$4iai_EG
zp7SAK+0+mGy4OKN@&SmNEpy6%a8OUF!E$?SVb(H{dJT`F*sA+Tnl*!b7IdRjtA;qg
za=v895?1!TIchGghr|Kx@xH1xMjbu^;a<a0f3_i1%pQcMD`UX5KL8bjc7pipG|;b-
zwVAd?$<V?Jl(Y9Tp;*O|F4Q8=;2PvR)tj7+B{_4M$^`p-p8N2DPgwg2G~1eBcIG7X
z>`y?cUti4p*+tey>PnW;6J&oy&Q6-&NWSv3aRtgVY*7{D#>o)*O9rY^FG23BKQXkG
ztgDwCm-8({?Z>ZeB9$?p?HeF#%@1qJ+$@V}RQ1TiXF;!DYm?04c|9s9cSIoR>OW&T
zWgl{RHDE&AK&J521Fqk3;MT^2?d41mrI);-<0!`MXm7VRJ0fRYx@w(S4xU@w4DM$r
zv0(TLh?VN0aI`(BD)vjB5x=plrwb{*uqAb!yN^m|j3RwXJ5q}RsfTul*yfj+?GF{Y
zt6bw1?E*33g%`SinF?X;dZBRQEN|RB992t~ga7L;Sk}!2&T-elH*pQPcWvkON00HY
z6_c3jQ9E}3Tvf_($k-`I{tfT*n6lzJ;~dv{=h>A~LBBVkcq{uZRbnve+z>4P711{>
z8l79bq@)J-AY7p)eZNh-*dT|Ajb=$%eHAFK^5(}+%#d?v^4SYcK&978P+zVrpU1st
zhU_;}tbZ1>n%9sb>=hH`43hHu52hJe09lj0Nz9$Vha9azn(19h-S#{4Up$)JyHlC%
zRwKq8sn80SKZEL8dr0WC8T8$2f?@myCSDlE+iWkGFn9v5s+z*vyjnu?=hj%(d<lH3
z(i}Z!5%fd1ORBNnOiUC>-MR)9Z`w<VBx{trR8-!wH*wSFg88Hu<wOUfe%nUL^71v9
z``JJ|;RX7Sp=hZv@y5ABQ917b#MSC2>t3J0*S{8;z1D+1>kkkoo!46YPD{=sompt3
zr_BF%PR`y0kx<#j#DTJQ)xHX-jx1*S3x9*F>R1rO2n?DWCg-cdF|5Nt<l+ZMc<RX<
zJ}H!Jx#<wvG@H4b<?;H)_0bu+p6@p=9fcZQAt6XUE6sZYmr;j_14`_>eyk(&q76(n
zJeBlSA27?2%~I0QH%v3`Ayn*o%eeFtdFfZY$fg=dv44MI$+stxb&Z_kKDJ*HX_Qp4
zK>qxi&v=``4C;rKp=|DT=FG72$*tsUa^7LylD(T3c6R`O3!quQ1fpiOM)&Ix;PiVY
zIjeS%HYP5SHN?BD@PwSn9M**tK{EHw>OrPw>maB!fN~FeqbcuqW_)V}@l<!<!bM);
zCG(ZW`MmW+Pt=)Qpk6iv-K{EPa%?*^uTBB|slPyY&{ne4HuD^7$UK#|vkFHsi+fdv
zY-#&h^qD}JM|*>-=Pg!tM&3RCDfaYB&Cu53rJU_lV|HE_<Th{RT~(W-`&tl*ElMC^
zrj02(ECJJ@0CYFkK=y&<sCYOC(x>)9#VeUd%<^Nxw;EE>G9%f(ZDy9Hb4j=B856%A
zvwQY_X0eOzf$y>Zn5Ff0$#?x%_DvN>CAZ!)i*Y=uy$&+2Zk$~|Ctu>G%D!LqJ$&x-
zG!S=qLs{q#CT_UKi@|lta-x7YMAQPEwlySV^hf=eL{Rw#qi4W)F!Yf3)rL)4%eEv^
z*!Ho);<Z#5+k{GLzhRl5x|8p)4Dfr|jJRQi5Vhzyb6xxmxcl3+;^LvaEMtS{351xn
zp%@kO4E+9<b;-+K7-AG;|11W~udAcjZo8z9TLR8j=Ox`LZ^pIW&lI;`F!$S|%+<`F
z+-DE+?mgaQ`gb=t6UQ)rs*O$>3#I2eU{KrYXldgIe(#jXACdR7^bIO1JDKm=^AIN0
z#<C+jV5Mm(I!|u|<(+U8lI8%{|Dz=CI-yP9nnV>EBP;xSJSBO`7}tHE*3VO!G`C#9
z_o+ha8$K*)O=VIH8bg+fA56GEj0$es88<hW*M%#XDWe67#$mkhG#YGIszCCI+T<Bk
z39N~=$a(fVujtkr^jbCOmPeySnhx2^6zG075!|n%nXuZ($25^M4%r4qBU31+xC&MD
zeZ<6wFtSwFgX(YyCCu9dQI#JtMW32r+5Aot-|gnbB6$Z*mp#k1RZx8X3@T<spkd@Y
zP|8}7a}PlL=wKAfw@A6xLU5W?64xi5uh_kW`JUY@XCltB%-tM0C%5B$>sBMnW7$*L
zeUe3Y<dDNat>$bSbZL))b4DL1`SAsU3Tu$L>nE@@EnuNHo<QOH8fa>F6KsQJ-dpDi
zgnX9g*XeAqEU-zgDqfIyM$WQZyRoeEgQ?(25#wSWMi}~3BlE>PDE(HK{>RT^p7~RV
z-w68FxVFqq`;u5w{>{$8yyy5Zra#?C)_WRh#e9EoeX9cD$Nb4Nzcqw7y+}W#BRF-l
zKt;pkXWavJ^-{pR|0{^!=Yg|He>wN{kT2(Zk-K9{W^0;2?jz5ba@P}<_@{~t*XuxR
z+m__{G#-L{<<IJSlQ+DW!9>k7UL3oRcXt~G&K+04R#XBp&zfWCgvSuKCK6TI-9i6P
zM|8HDD@7fvjGVjH8O75{pkLCHsq0i>`g=E6iQgs0r7nz6ZS|6MHZv%PJYrn<W6)1(
z%iM}!G^N%BgGB^u%>xiCeqpw#%V4fu#EcE)jN5b$ZC6U6eBmFcdHMzlmieRNZ#M|H
z1j%(I4GcrN$zF9m$y%uoaolz$IGakw6%|a;b1(Q$_9uO=mPMtiD5f-;#4qxlnsHhx
zIxK4oox=Ev5cv$vs)fSb97+8Aj(1nv%a<OlO{$945Ze0{Qz(ba-tc@#s=W++FL%T!
zTNe1{{|&hTo57UYfe8WKKr^X1i5oXdx|@SZ?IUBnBcGVxeEI*jH}bJLt;o5oI|Tid
z@1^Jt@CC`InEsW#M|2sI;lyyzyXS%X=LO($Dx=O;4CY%MQTKZvC>1p*#<r2t?=(Sf
z))B4d_9ZZ^s44U2xx7aEkXbHFVnS4q<f?XqSyQ(_()UL!sr)>Y$ayE9pMl5?EVhRh
zWr3k21S;m<XPnP6NU+~ynz7knYV-<9un2-WO_b;6N8mhFG4{LM+gwps+dmh;=a&Go
z=r~YR;z?hv3Dc)Yk|LB?Xy$s5urhg!9a!RxCZzrbB<&0%Ymbg()5&vf;-`p&@|Uv4
z_#NEsWqxS7!E<My*bSyC<Q{g9cg?-c4FC2AVa5a~=(iT4&o)Ni&nLk+_yTyIG0=;j
zBxCX#2-{nkxblI#vhOdXs443yRD}$KJ~M86QAE133E2*{0L7F>Bz{=R`#yNVY{@l%
zn=_W_Y`=l{IFq-?8n`k%52AjNb*R$;sIMIZ1@$|i7<$HTtJ@m6;a{}Vev!52*{3B{
z9Rq~MK4siqkc6I_CF{I2rhc^z63$4BYrF?+-Llwybv2pG`ZCo|`5wpHQ(Eillg#<?
z6R#=%hY4PzK=Jb$xPtdW#hQ_rtGf>s3qC<~F^9r`-Fbtf3}PRbGS|r^kiIFLxWdpp
zuBa7Lot?sriZrkdmo<b5O7`JqO|q)g6f!rI(n;3yQ^QDT+fXw9E@wB)_rV&T%iQB0
z@~-k`tZei<#<f`!;k=s9oOfjp<Y_N(cU=muv}zb-$b;MwxnRz^4MO!q$(?Km+pIgx
zQ?(n!<b{)a;YF!DNkIwCPc!G^22$ZeUlKy<L*d``<>wc`C&u}ZI-?30E*xgUsF7f)
zmMfKP*bQQ{p5S?(4~FlLK)5;%3OXv0%dMB^`XuMe4=DJ;IWp#56DH+ObIAO|%@pG}
z;9h){oVN2)u3S$}TF8uLMo=~~ve0Fpz>w6D=?2{c{m<1>S+dMeRc#`a=if2s#RI%x
zJp#Jl`$B4x4x<$N!IfPKNqrxKd-^fnH~bY;eA>f8Umb+d%yy*c?*sY{2BuPNlT?G|
zfsxXfII~Qy+kGY#1ygEhJ^6k_Q}SGFNh<w5Nvtj7xwm#X%lj|WKY7W!nr&hwW8}UZ
zQjNKGoMGI<c&(>FAh@zxLGHoVP%?2lBz-#ux=A;IGmOeJ>@0?)t%sR%(MC|ckU3`i
zKlzxK^~uz=53_XLD@9HGi;35LAvd&=?9F%5CO?z$a8EC=YHlz?y>Xx$H-TACn1H*Q
zrp;|6LGGYb_}{KATU81ow^bXrMAj$m-n_Z2HgXDWUctAg5W1&?Sxc6JK0A~-o3G$=
z5AOg=B$LEd<H6Ow8B^9S0oz<JW`6u1s1|OPR2#=K@k2K$sm~Y2Wi`#SbY2f!oorsU
zt~Uz7I#8F~0+ZSb`fzV3*jNA-#b72V4}$8qR^+-L387myGmby6bxxci_fAcw8j>Sv
zE}EIYUP*=}Wi04PAlcf~A=Mi%RvIPa!%3ULxt=5UGH(ctaWc*2Q%rpEC(G?E<K`Q8
zBuk^4yy&atRY8SdSP%oMWk=;%e^kb6eR*Z+HE=Il#f-{h@*TLwWN~!_i(ez+=5&+v
zlRc6;eI8SlzUCGG<TGxw#_l@wkm>(@%a^2Fk$ta;pvzdp#C!8W<#$2Syp(;vH&6Ij
zzf{owy%EHsdc5&jiJYanq}6x*2*UYld{mLlgX$Ns*eY3|2p`7WwdDDjmIY!qX%*+Y
zgLr+Uq`Z*_!pIR)c1Bec$9PMw5dn<*?}y!ZoRjtFb9V8Pob_yVPpeoMf$ldR-sF`J
z?yFN|f3hVcq-_JYctO_s)<ez=6>*+O@O_ZSoQ?%Nw`ClNN7qO~?ZuK}W(?ElYEjhC
z92Py+j}!^-nYv9F%bZe$bX%u^VEoKn*?}OY7c$e7jV$WICYFoY%u`p(IPDBsJLx5P
z;*Nqa{{bJW%m%}e6maL~@y;&C!SG@v(+oHQy^hr;)AD!_mIM)(E%27RDrS+fn(#WG
z7x-0-`@>@wemyShF;DoUuoKKOW*Rt)P0Y1023#{5G9l>@h^tN7ibtzK@gxGAbqDgE
zVHOa(Y}VSgTn3eY3SY7L66nfLGF9~*;JLGunH~*+g25ZXqQ1bJ8aJ1JZ=N=xl6?L@
zH`8W)sEuN(QEO>+P~!BOh|nWH8FwYxZt5QnTvR=6@|Q4FomkIXZkz#k%~s%P&>w6W
zbAbzdou?W)AAFz5{a3FO80+0&s`FcU+fI4j|M}ML9MnNl+5K72^GallOJ`9IFEZY}
z!VG?~OyA@UQ`HECq)M-tdQNL_54px%a%Qg}Yd=#yKfo0EvzVBjrWNsvWY)+%<DIRw
zmhA_fJq%ofy&!2%hKwm&v5KcVz|6eJnLHmdjg3fn_LSER9>4@>AX%zx;cXf1<ovf%
zDoa?(oTo4Is(^LO5;P4ejxA;C_MO3IXwRIx_JBB|on$QD0IJF7dDRAyH~km|oY$XP
zjd2UOe;na+x&5G&xt*c@TF~6u$Xx43f-rkE*v|NZx?xRFUD?PRcF0=hiut@dD)4{x
z<hc`b?83J}yt&2~CT3mKa;09t>GQSmKV_fg`aC}B@1vj|DRZrZQ{=2~Z*V?b!*f1^
zAv3iWsr(v1(!nQ8pSFq@6C-7B-eTt#SCzzuZzNs4w@etAz?3^*F^}aiD_Ojhac6JI
z{@)cocgWvzA4P&ey2w;b1?IVVfSG3PXC-ON822c_F7$50)Gd-h+|pV~IBWrZz$IQ^
zIRxCBM}e^VtyIu(B^Vz+mwPY~?yppmC$<g<Wr>XYV$%xJAl@?ADTy7sN<y55iTe-o
z&cN|9PMZS4yEvww(*Rsj2veqHfp9-f3XR+fVyEuBaC-yqK3ZSymyKH0r>WqsbCp+~
zGlIFAk=gn$0DbX(rhhN%x6hKnIj9z>UwX?t$<7;k{R-|tE3Z4Ml<%12@xqR_yr|mC
zm)v{JoXMkj_bXYeJll~^JyjFkXHxlu(TBjjx{P=4Oabvy7`WeXpzg^-{s%AO%H(YQ
z%s0$Zbq()2)lkmmSF&^C*4dr=Nit{NVd{dO%vH05xkt%*{k=`hY;?#y6wdp`6f*so
z0pNZoXT_G+WzJ>UOkBB3)&eq^Fuk*!*%-*we+~rqKP2f!ndSVZf)~96&`)a&To?Ji
zQrSe{2K~is0r8OeL*997n}X+J2IF?m<+)e4wcL^*$+<@>=b7J2dh2pt|66P3u0BEL
zPo0@-jt_V=^_b3YJ&3P1Nv4%MfJ^#At3Pmr*VmCT+zY3iO%DhCr4rsYKrcUovCQ`C
z2=L%B=6Tc&JgZ{Cnd1lQT^xwDukx;Vf7uf!S)&X@Vfr2UzSCvic}@1hJKba4$Q``+
z`v<LlsjMMHSIEA=CcfaSynFV$`I6hKz>?S$T!yyb>D&=YMwK!lxR$(!-!tc@ExaZ3
zF3-iV2yRmYyXu`u%4Lk1hBasUQx}<dRqoAz157jIFyrFPdFntXbEXc4+**tY!d=O_
z;0TL-X=c_Wvz%{OC2=^DxofJxl`rRe&t!mD^Qc{?j|I**pLeQ2($DG!$}UHlC1e2b
zrkZkYM9vYklb?q<m*-Tix^v+zwc@z0k~n^WBrFA<YyD7CPm7biDR1U%`>%Y@?uF#c
zH_AGfQF1=E$lCfRjWF&a&rLS*!of<sWtJ~E<BMefwG-%6VNCs7XD}Q;$=uFH;J()e
zEVnCoPhT%^FCgABr<hk=J;j&&QCGfmT*907HUZ(oV?N57FW-%J@*JhxRrhzvzC$rs
zIv(YtS{wqEoUtp&kni&S+6WXo`-7=cdk~vCWKFORBs~AbEWaG)#abhI@p+b(JF+f<
z+ZZF|2JQVHc45|lT&DXtk?FhUF#Y6hvi1=z-(AaLx*7eU%<DAcPNYi}#}BiFajRKE
z>ut>0Mv_8V3UiCEc~x#_rtpz<lY46<RR?)b-e}8n!=~6h4=T(4`FdtCgh4M})(nap
zf)I6_sajp<#a(yo;+dwrP`8UD4mo7!Howy9D=n1_t%rbR<xxp^@QAmB?3d3#5;#{y
zN#?h5J^fln==ZvLp_hRdySC?r;>Yq#yC`FvK+sqEB&ilPgpvU#neKtiwVpiZg?)eX
zw&~SDAHSb>j>zCu`?mAW(Xu9z>*Q76b)eE0^RXERm^1!7&%K``xpjy5ia{s9eK&_!
zKRPU9*-~Ehah;5>0zue39=KUyP!?}ywwVpUwB#cb@hZ=8A-T?imOR&Ly;dA^#jYAI
zW0NyirKp34n60wFM8_HCTCkF-7UoI5KlU<HbuE}59buw(9Vy|=Atqc~%sjA@x&6y!
z9J!k5L-+8Ojl-GZ<y^45^+;~zY}uC_X6HU8YTd3KyyC|!=5Fc(g8M5|HK+pCnNH>|
zF6714V`bfY-2ZiS-ElHrU;naL-Dqp|NAHZ1*q!HGZld=giC!L2f&_~s`p>l%yXs)0
zmq+i6Rd=3q<LV?Nqs0>8(RW1{U66QBUjNL;?wH-@-gC~koO3S_lWHRy5oNN?K9eoI
z@Ax}3r<sYCXw|(6Vs=~91&EJyzwX$?Cz<GCiX-oVl^+gzYgaIap9MW^FNp7Rad*rr
zbiX8x1-q3s;yH-WC~!L-2YWza?r!`6^!(}|P7w|b`oP)H%@ABYm0JssLF~}E%E&|B
zdi&!j25yDSxeGaa7lhcUJGu4r8pJMI$b$z9()sFd>Gz<Xi`icVv&wK;?-})y?}3c#
zj^h0&kgYG6jO9FN_{JzPcrLz)tX2U<{`_=D>8Zn2g3P57;(k!!{8f0Q)_TRfsiA~n
zw7%(IDr3H_Sm`_}v*98o3bX)k(b3BDq%XJXS5S7I@mzc}1x3yJAZy+*y$6~pwm%4&
zjk9R&FG5DKpOhTGAB<|dkVQs=w(6if8#Y;_TZkp+2nAm^;4CNA_7T^C6}O#)(yi%S
zTdj~BxROiHV>A3N9~Wn5fNY)!;(uqUx3LOz7UNpRV8D};+l4j~r@arXeK((5;2<zr
zg4?5Kg8Xc=DVGm|Eo~nVz9hrx6+aN3Z-ii0AL5Z4AYjwX+222a-Rdji%qzi~N<1xm
z1l(-_F5?)FoRQo;P?|@ol~CTQrFg>8EM*^g2D1BaXs!JL<imeWxo?N*AKF1ls|pTj
zL;CAV7RD7%R|#cXsNn0G>d>-8Wd&%qp+_p6Z#`jJe=S$KTnnYoEvNIGC22Nvk&@T8
znsz0rJoB6Lh-{*)+2gr>aRGJOTwu3XJ67LVCA!uD;apO3#caqu@Vs(cO$TZJg?e2x
z5dG^TTl$O1R!(-<w_#s+T6xZ@_Y3Jwl*>s*NQdfi7Td=>^v4qNhwFebpcL^J>TB=$
zf%5(;xHsoO@I(&Iy6z5na_8mUmo8SU&2u`B-+?~&7<kH2jmf_d*rcaEy<!L?zx|nu
z4HF@w`zG!VN`+ub1!a9jujgZwaUcn-Hnq9@-*gB(-o)+N8^B#RkBe#7!CsU^XS?!p
z<L3<+tm5G^=XGUeM!-A0l(HX@*XX-ricLj;6|AY)Kl7YSXQnc$633<b=|59mdGfVW
z`eRG6YZOz1l9VL8$ml;$>6og@@Gexwy-Mm(5@B_*jiJbfM4E4^!9AaMR)H?x^T_Jl
zgkuWip<$@Y-9hG0@<m!x9S;|Q%(0i0E>r`8B}*t)IT{$@JNt<I<iCG)SkfC`kh}qA
zckmgF9s=wAz^5}xa#kPBgr$TFIXi%TyDB%XZURwo8yM?uft)f4^vP&0yR0!2?ib`k
z;-@QrxolhpPokwRfnH9yp0b{1B0j|HlqujT9OUxIWRU-)aoK!6xI0fHQ}e(!Dl2_^
z0vKZ-gFHGC{L5BzYwKJP59iP<FcLqQ!QEdd9#fZ6Ez8d1mj0x~tUKW5Y^e;j4p^sk
zrg&Hb?74Z#BU}&)KO9H<IvJ}+ktb0zO8GmG_to|jW%Qm8-aTI{yIc|&OQ)*fy=awu
zV5SNaw~0$gra83RPTV9(IbDGJoAywiVI#TdRz``Bv%tQz6OEFqP#(PEWK`cu^E$cA
zA-yjtR&Ir9mH1e(cgd#M*#+6alBUEQ$mFL!dpYH5<pw^z_ZhJ9rA@bWF3v)i&5SE4
z<PCHK_h<ty_HP6Ge^m2+xeNNiFwoOz4~~`qqjpg)*As_5nVSdu7F5=@2cSFU;jWMP
z#QUZ`@nZlEeUnP((q=&Hm2|E@34oqh8QrLP5I9{;$->{!dZd6X(g%`<r_wyZ_u$^2
z#ohdCAu?eGH!hzCoskz<)I+ci?^Eo=1&Dk$Oj+A$=3<2Q$+U(bt!v0S&h`0E4xsZE
zCdS5YAnkVrMg7Ujv%0F%PC@YR>8y;>E5Kd&HLdkU3`QoXa8gaBS4r|_TB3V{_Tu3^
z;wHURpwB>_z-p*q&1f#FXP~aeQIGVazc|$s-xMdV?RlylchUp5K2uD8dq~b2g$%w7
z>4K$^t^O%wzexv{`c=qo@*3ELpiip5K(0<VBX1=ah1!7Ij8nd^2YdQCx@Y4i_3{UT
zH+OE%K5q_@0>ycxX}n^C3eikrT_r;A!1n(I?u#(6Y$Z&$&sOk^8_mVAW#COlZY*2{
ztlw}`JXr>;NkygIBw*uCm?C))=vp(0Pk#fk9aFd-yZ{1ONz^wd9dLO)SW_;7{$`~z
z;1~pZleQa~3T$9Ehs|mLl5a&es<7#=-BIZSg-~~*+PGssZt>9UbH^fzCA3brn{j1y
z-vn%NcO@q+Lr>OFCFfUF-l=1heIprNCxQATdw}KarC6XVw_4R#*3B61zI=sDEOW%b
zc^GLhQRz~7@z5E<qi^Ooo&_Tm+t%I@hvp%>)6S8<*PwlE=ZN!EcjG>UB%Ly311tE%
z)5{>Atu?(>Mi3v12d}>c@k-*+LvMiW^Bb@WgCJZm2WO{xgVDbz7rhFpa9Uv=7|?>W
zNEB%z2dqmj&1Eb#?W5!^ocx4~cbmX28sbLX&0x<-2HA2wc<aR|qc3Snx2GfjB|cU+
zfwN{qLB`DF`t1y0t4Sx}7BFT$0qcW?*ng)gd1^n5`;+)Vzd0at6hU3F4(LxLGNZBS
zwux7=@m<HbJ74L0E70F{j`Cd0rexnDXuYeYjLMrpyRDS`t2r8_dn!-1^2%B_NZH{n
zC~pr|VguEtmEDy0_ZD2Fe5CAa6**g;i)LUh_~fG<n4mi=o!SPIj~`Ji=7Tft_e8~>
zoOa~Xt)zPoI&xMcWIZ-JqGDT$%Mp$}i{^dy^$D?FCxA^JWO@#D=OT{*-XF=!Zaf#<
zCKPwyo&h#<6xhZ70eN8noyqhNzK79&wFvR=F3Mk;?kV_lGOghgV8NHBNI46B5AE}^
z15o{I@~y`21<Sb)M$g?KZe&yLM=L<zibEYD?(m=^*K<Zecw!Ru<fcKS>=bSsTLrQ)
z{rjT(K%VZP+$}pmv|OZ&$1_2%n~3_S+8}o~MOJix8MZ4cd3=`>_+q-UW=+Q-zs@86
za35K2immr$lx(ydTsmLLN*{MbW_u;q6;-yUr_zItV_5bj53wSMA)hPxPXq2f9;d8f
zwYZ&8h&;YWrtqFZowt^<MoT(hd_d{8gy}oxkj^WFto#{d**`e?2uJzhw!<<$m@;L%
z<JQUob}`1W8aTkxqRdF;W?VMQ0s7yLT*MFtwSEtJXb6nhsbKe^_4=+q*nRWS`Ro)7
z?kLQ4_AgXqNnW~xEMn>vZ$aqFU{ilVe0&=W&k4xPwUxY74c2th#$yl|o=2<ZHn1p{
zh$BHl?^;}EON6E8BsaE9hsf@6+^x0@B6sU>F`d?NP6=f<+YH`jsfwK=zVc=tihn6S
zHxxrTY?>*1dlXxo<aiH$r{vwinE8O#v(~RD_xysvF7&<V>A>dIQS1;88FLAzd^wf4
z)=9~US25vOS0#U2Vv1~?Rpd-L?s?#&Gs9l);U$!A-WEjhKhRS+T3P=t!QiSbN-XJx
zGK;uYy@trVkC4?ai#mU66i4$Q3r#Rt=4D5Jb`{u+fsWn&0C9khKB?<)mUh)lSkj5>
z?)^c&%)zbsJ3xBpfZgymXnzl2F}b*IS{#GD3Xx{-q;zlM_xl!yf{BbXPfKtI+ymqO
zW^il#3ih`vIEy<CGM^xS;5g}{AJAH~kLt)i;>F8p#xR<AL^1^aH<tPZGa)EPb7Ofb
z1UfV!pL8SWb|=w}UPoLYKr>~;vl<cqJ5>)@*;kJ2nrgBdZ;>H)?AZP^+d&w!agMT^
zrem0zX>R`<O4jHA;zI?R|NhPl%>G!}O|sBfO*JZ87J96Xim@-!gEiYLn`XD!KR)Go
zSD)*iWt6Tn3&h38Xx#Z3#j+h3v6m@p@>H~MEmh)mSCsRJTg~Tm=fxK&^HxI^cpoor
z<RYx6XB@xP5exQFO`90<E-J}ohvlZ|+=1(NO~CywA9uwHuv#nyBj*K>C;h-q{R`~G
zr%u9dTE}gI?lYj*S0yn}K8lM1J;10yaa?aKtvz`dTV``P{sMT1_2OFn3Sxc@)F+RC
zxcw8dCtFAdpMw8*X&_@5XL;s<==BXZK3NRj!ELBstOt=u`@do><c>~JVhG)l^e4q!
zAP$)G#9_sDo342oS>mOT6+`~yr`0gHB3ZGD8&UKxtE^_vQQXZ={JaEd(}$*~O&w*;
zJdU0gocbY8(cMRNwem8@p4OUr0+|q=Mzdo%y*%OL3QB$;AFkmC)Q{(*UT_#AyHXTu
zzX*fTE0oOlJqE^=R(el&)SnGOcDM<$lQE9GSO$%|+d(e8<cNi|o)=;rHYS?0Tpi8u
zomO05sX*&cnA^8!gVAUsSW(A73?S?u{uEe)x4v-mXdX<gtvtK(aBI;l6vYUy-gX07
z?Iq~PCWzd(A)(QCT-#T{+ixV-W3G_jklis}{tWh~mr$(V2V#37xcgUwpU(8TCsV<*
zW-zyg)837s{Mbr-^Z4qJ?!Fep`H9M1mJE@k>f|8_@|vQNZ9HM>mV1$XQzR6*7f*B5
z`7!u+qOyA~Le{B)(#vnsT7PUB{R%4ib6Ie^RaR{1YV^|FsP?}=JzXeSp&*8TYNm|o
z3cNFXG)q{M>vqJEe?JA0=Q(Kxs3A)0SJY!hD=V}P^%}Z6Fe4e+GpZpQN1@&!QB0s1
zy}!s|ssZYA0XoycQ0}JnO#R*w<TtT@Py77mn{r(u2PAAHkD}c;5byVZHFqz_(JiTd
z-vQPw&Ga_T&b>8@(aZsHwm%P}eiy}cp61}5c>_AB1Yz|9@bv6L9`Ow@a!lkp*B`((
zUo`Do7eO8l)9>*ku&Y$7?`#I?Z_TYwh%4^3xUR7Ry!ShEcQLJJ*SsJzXg%BZQ~K;|
zh+L-_`irpiWi^^tx@F4UsmNYb^7$uMqdB_Uj%WNhB^ORbw(3)5Kl~Y4)p*DLo$@}t
zA-E}}6}vSOJ%?&5_d*1N!-*Sw*BW)WiDCt5FR#QYqeVsTv8qxZ=q6!tKE+mTaE#G^
zV0dh2(qlAp@zWAzL@h?|S51|!GMzl-0IlUWDBJ(y=)c>b<U>LK6pO6EUSQXEIXdn#
zc{wA}b^nhzTX)Kog-UbjB~L{B2s%V{EWI^|o3tJS8Myu4fKmQAdS69x`$Hxg*(l#f
zmInLjThM!R()S;MTg^*7sJmc)J%#IIw`mq@B-q8TgH`GXy5)#BY)bVR8`D70eOcD)
z^`NJa=fBT}gq1YsJ8C1aRmA(xZh+vZCQ4^p0Cv8%ioNa*dPO%BW3$noeTVGYD<8W~
zeX7kn9An&2%KQEpN$jYkKOJ?S0;sROM!7EzyhDmo&8vdmwpEmD`2hW_p%PzBK+)Pq
zI+H%r*I2nDN^osdS8n`s2xJx_y}u~lD)tcV+Vv?e6$a)kRMyJ1bT?c_<?f!3)|B<c
zRVB(f|2V?ahh|v4#CL0>J$yHLa#tO>QUlBQJru4|gR?3NOjeWp%LQ@ZzB~h3Edmkj
zM9*>pM0`nbmp%fKUtxmDxG^_7&4Fa&^5!v9K6(psBLk847{Zf1+*)%V-2RgYXYPSp
z_8_pQF39DZ(drupHfoJyd>I0Fa%ryXZv%hIXWZ_*0p#bMxVw21$j3*(&P$wpE$Mfe
z3SxH`y6bKLxUZ5?6e&b==k2L~C(J<poTOtWIi9IK6wB5OBl-(v72SgDudh*`pxL>t
zb-?<X;;p=PJV(nawmbt3@^alr3(&pVNQrI*z-rY<d1YQ6Y*t<Am5c}Ok}f#7!DL&X
zqn*D9dDExS?lfD;9@|kC>8;rPrD!LoqtPY>X?_~zf{`dozB1W9K|QlAz_w>cqX_AR
zFS|JYeWf`YRnKI9mFKcuNs!wwfg7F%;z%zrhzp2<Re^nblk|8Bis7#zax9M$fq#IF
zzUtF${w9pePX6K((D9kT>QX<W<``}yJOFn-eQnoW;yp>Io!>w=FOL@aOV;@8+*Lsc
zPie>5tu0_5CH`A~E66B%f8rL9zdb}&a~XIdpDVFt6y0}8eA+G#x<Wma1(Qu9JAHq4
ztfP%KN@lB!k;|ls)-FcTZaqEoWt1NkrJoT+@s`I43@1&|<OGVTRg^Jk9g6w&6k(z1
z`KZ1U`QCudsw@AS9Ng|uTnV~Uz%Ke8+1xC&wx7pCB2mdo`!LXQF!`fvX&#LDU!MiY
zDDJg~G{)|Qras$+I4N=HvoUBtq8zKd#PR-8fH+W!FX1-%P~%^l#-SS^qNq01{+c`q
zs&{F%z%6_M^v?~^O8$#*C$F-Hyav{^qa&NYBJP%x`hKKwA_sx)UI4LnAlD@`ArSB3
zZr%sLmNiBz^gHOWJyDvc!Hqjly}JW+C*&vO+wFu%&sN;pznyApZf=|=tnFo^?zxI)
z6iBah{2$fmp9y>GQa`60`Q$rH_ZHR4<Z&T;XPlC|qA^^(yAnfZARBoOMdK4F)2^6y
z=rw8XfX~yF_<ECF7<gGu*`;@3LJWCTZ_dPrx7JbapBa#ly_yQ{&Bgs^Vw9NkIYdM@
z;z(&|$6rOymXXS+?V!KVaOE!DjPk*sC=M?{5r{+g5dFN04}47ZM?EkA@^&?JORpw=
z|DzMhO<XebRC*v^IWAiqHFc0Yk2~!_cO}oL{W8$S>wsJP1aa4+jvh<?&*>b*cOxJt
z<Ukqw4CLl0(o=td@hf>D-5-GUvNM+t??d21C9can0J->pBkSEDjY@kOcb4?mDscZ7
zf`s&sx#jGJgvp<h@3aG~KE=5;c02h`UKG#QK%fV4oa#yByF5Z&76?O2qg;K~wC?Vv
zI<`7qOeFlT@w>ySk>;sA0^KvuXcl2VY5jqwaUv60;SpxAZEnJ>RP@qaV9d84bqm7%
zx?P;$m>Q%l4}n{V;`V4x?x|UVbbb;9`$j4EnxwiweWGLCl@4f>pC>45!wz&mic<R7
zO6ntZKzrmIWS2^ZWW$jt{+R;$O=GktE~Wm`Jx3S6Py8t>B>bhgoI2N(J1Orrc|ngz
z23B}B`4M%%I8L?DNAF3>05<yt8mB3@w|7SS&Lfb;UYc&6hak!i0=NA=@J|44y}1iU
z*9P2fLZ5x;LcG1{Cde$RJ(G!-9wp3st|*RcaQl-qke_n?-x*Brxw2dg*+KlMhGVZ>
z2cAy|gPW!R8%sK8Z5#5*tDqErnR?t}WYy33?0vCHF5TkTqdF)(%a4(+d8j|S37L*g
zw;EhS7T#m(3E7my(P(5AR(kwFw3d`p?9v4%Qo9QIAxj|qOGWbavhzT0(n&j4fN_)f
z!Q857H@SoQ2jW<JsmE|>q>`<I=m(FIt8A3x22q{{$TO|wh`8}63iJXowK>Wgi$Lei
zjw0n3VCz3|!iS4-cBiSytXCixl>m3lLXhnyfhbiMT(O<F)k&YYdJgR940KPs;AWeR
zZYhet)#P3Ow<rF1knyCerdHwZg<IgCXL9!Q9gtfunY!^!usT!yy+*jCo|^Wy!;r9{
z6xZ>4!A@(;1@43(R^<97apWJ@nC^=8;NMtTx!dM|@uo20&gbN3`v`BMK$oF7e^AYo
zNqLC-OmJj!b0tcCjI3IWk~f#2JUzpalh4u|<3*D_d5L<GiJo=&lq|I$jbA8Eua&@r
zDTWdiMnc3buUOT;LFc17yJ;7MM-bMvp*=c#4-;rUO~;<XgtV`zmy(9Y6!J`eSci6s
zL?dbuN<G)n#U$#D4S_Z6h@#Pa(pd%3$Q~jbp6Y}b72xdgb)TL3?mwOiy5mX^<pz@8
zt4|*L8jwp8P1g1puoVZ;n4bYg`X>C(XOfvzmwVkJ|EM%rZ7HwY7vysPA7Bq`%8k4(
z=ojrkHuwW%r738vr}g}@kg4Au2G2XveecsCVRL=%rtE-(H<jrw?rp%p1Y^{CutpXj
zJv|TX@}-qr)0@17o=9F7i0M6%Z5?RZZ(q{+)0&Ql`4k&amOSC|O7@zC`qyaG@rOy9
zUN^1QS%k$o(ULip-Dek_VIv;3uPFv?`pgkt2u~-yxj2isb}?mdRA9HI^^C0=lCSP#
zLV2pa)d=Uy4J1z>4I{D|^|gsJ`2uLiq@v7Jba!zg>e2Z?RR03q6~y;m#-g~o1=zJ!
zjvJGc>S!sS!9IZObj1`7;nl_tAa8t3HEj{Fif9@S4uNrLA&NR-(4U9UXhb?QCYNa!
zy$-BbG#KhCNSCnbaR#{cn{c-e`6bzi`}}<s^uk`q>itSM7US3r4}&=Igm970mb|J-
zvs&B0TZZDAyZ|xyzZygQ_nQYO;sf9rU{LKFKwOyg$@5qcF9BumIi?;!IsMbAkk!4e
z(uJeZh^|UKWAdbQdt^t_P<B3N%1(b!9o^)JcBCiQ5dIG-px6=%t$h^BBFpsLja9~m
z-yrZM@ug*_!LuNTVu^iBeVce!)MJz{PhntS4`tomgZ5Fck`30O+_4s|RTQ6-GN~>l
zB71+z6n}K5T9ydnN_n(jEvFg&y^iijm>sawMHR;7z`dq5eHYECQVx%AN__-c`#)}*
zR*l^t3im~$;Avo$PSD<8q<=Fw<W3~twCD>{?70NCa}xA)`nnazEhMjXrvl^a%b>rk
zN%ik6_5F@Hj8XlZOB}!DZU}x|iA%m2j9?{hH`)Mhfj!`+t^qf859(+0L4H+%=83-o
z5lz_ox;(Jv)lpVjYr2CposX>;^0JCbUZFm2y&A+52cmm^CRzsJaktH;mGc7r=c(D{
zUZ5EH0~!yb=`76z^zWw{vUQXxUKCSC&La@HSV*~peuc0vO3CtfOr3ZS<@v)X$DTy}
zw4IWBc4P2%W5rIdK{kCK8fzAy&Xb$?*;HixCYX9^50w9m2B9iZ4g{!YdDO91lD5n}
zGi22NKv<e;y0giL%3mGCingGuN{~C=neMZVpgWgBs|;y@+^109BfQR-;aICFk1yXa
zSscaRx1=4HpQHY9UFy@&-*?;seVkqoUU%H$r$Oc_gsz<qZmV@*Y$rUwREoPV))7Cd
z!1e#ukf-qr7>8GYcs+*ViRNz#l~e!q{j4gxke#gz`tLHxhU_8FatmROC!T#lda2iO
z$3MJ=5;gq9TWBpitVFi5rzr=YA|I${oST@1_LwAO%d#uG>kM=c=2y(0%NM-hQO0*$
z!N|<7bioT?4<o*`sxnw52#;E&qMdaNMRQQP`wk2*q}Spr(Kb)hIfHp978Bnn`#)sk
zZux|tG+f0#ATL)&d+JPJjn6vPf6u(-*N{l2`g!#`)7Y&*u89S?k9?0_BSCM=333?q
zGv<aIH;M9ol}6F`B=tRBIBfe*AnTtt?eS+opPB|%$5Y@QqV?%QeAE3GL=}p~{WTox
z=uw(+s)Kgf{ZvoC2Ti_yAWva#Y*+=>(Xw3rxD4dbd!W-7gNV&d&riAkZH!_UzXEsD
zaq`Zpf%u4?V~#TI*Tk(WxAq0>+=?~b<oJtMQ}Q#Kq50?-@v?>F110;cuN1P_cRuTT
zx)b%cFX?`qw}eTvQJ#vX^(^B==H^#27@)ICgl!wb;P(2L>V+R{r1uBAp)rj3(%qWM
z`e!qG)-+MJSc10qI_iTdC?oYy?EIc^zJ9u1+J$OQGmv8`K6gm!%b#~x8Uj0+-7(@{
z0xQtYWY>>@&XW&V-ob=d{eYFr2kxLBXzeRGqAKO&t27i@he<EiMS50>>20Pl`xuDK
zFTgmhAw0hbH~!S%?U|Q+&m+LfJoAaANc&=vPTEa+p(YsQ&snc>a%;~L2plfSb>Btc
zPIw9KGs>CUxg6vEOo~V9Z+<oi#JdcXsygU{6;Td2X^OIwkj>ca(+%GsV{;s9Cgr^#
zJ^l6XD6S_Xi@6#yqW95zJ~t)%4YlP%+2AS7cFo0v*V$<g);pe0$=f_U0wOJPDWea0
zVO{=4-R66+(&#h#7eG-9G2DlE*@<=Ny~ma4y#U3AC#038q5QK2vNhiz>-sdLOSU6l
zyBf$=<*5dK2eL%ivGNfodSBR)-5&v)Rm&8al$$p`nBvcGLI2nVgj)#QM)Sx!jfpq>
z+rVA12CZN^>A*f{@A?tgwnS6+R=`@<1M5jTM9O5Rnejv5wk*u8ZRsFAH182lak<w-
z-F++d*H4;u4)U4GJ_oshG=^E6+vF>WGgNOP#5<!#o9^jE!dzOfHWtYJStydK0Xx%x
zu>2=ef7*j``ijqbcoSK+;f}XL8S>i8qKJ8d+AmS|T<Ta&x1;=GnrRn5hpa_m)CUOT
z=FUcY@O$cKJa!BnrNnN4$kOa|_UI_sy~sz+m_=T~Zz%7iI{N7W4CE%vzqgWb$VZxW
z7Fzq65|7AR$<+@<PYc<U&mGb4Qxw~BQ%;pcO?M5+zULghV>vxTDTiIXMLo%ark#th
zWBDV~Sda)T+yeC3qF|&@ZFo`K6kXQ?%S=XnXfOG5RFf(H+2L67C=U{MC<^js8gaVY
zU|%4eKDZcnJ$pdrZ9u)zouI$1gVrRfvBmP6#&hyr_Ff_HIfeL@ha2hBKn%;yMZsyb
zr$s<49}l7*J=^cSsE<dOl3E$0(*b3P3#NG27}?{OK0Eu*<emGRgg?p0=uj9vYnjry
zhZE<2>R7EdAnQHKw09jP969V5yIrcIvr)W>P|oH<V+SKo@SUmucuO%(G4VJ;7&I4T
R4O;(8AN%OP*ZKcH{|ABhgCqa|

literal 0
HcmV?d00001

diff --git a/Lib/test/audiotests.py b/Lib/test/audiotests.py
index 9d6c4cc2b4b02c..394097df17dca9 100644
--- a/Lib/test/audiotests.py
+++ b/Lib/test/audiotests.py
@@ -27,17 +27,18 @@ def tearDown(self):
         unlink(TESTFN)
 
     def check_params(self, f, nchannels, sampwidth, framerate, nframes,
-                     comptype, compname):
+                     comptype, compname, format):
         self.assertEqual(f.getnchannels(), nchannels)
         self.assertEqual(f.getsampwidth(), sampwidth)
         self.assertEqual(f.getframerate(), framerate)
         self.assertEqual(f.getnframes(), nframes)
         self.assertEqual(f.getcomptype(), comptype)
         self.assertEqual(f.getcompname(), compname)
+        self.assertEqual(f.getformat(), format)
 
         params = f.getparams()
         self.assertEqual(params,
-                (nchannels, sampwidth, framerate, nframes, comptype, compname))
+            (nchannels, sampwidth, framerate, nframes, comptype, compname))
         self.assertEqual(params.nchannels, nchannels)
         self.assertEqual(params.sampwidth, sampwidth)
         self.assertEqual(params.framerate, framerate)
@@ -51,13 +52,17 @@ def check_params(self, f, nchannels, sampwidth, framerate, nframes,
 
 
 class AudioWriteTests(AudioTests):
+    readonly = False
 
     def create_file(self, testfile):
+        if self.readonly:
+            self.skipTest('Read only file format')
         f = self.fout = self.module.open(testfile, 'wb')
         f.setnchannels(self.nchannels)
         f.setsampwidth(self.sampwidth)
         f.setframerate(self.framerate)
         f.setcomptype(self.comptype, self.compname)
+        f.setformat(self.format)
         return f
 
     def check_file(self, testfile, nframes, frames):
@@ -67,13 +72,14 @@ def check_file(self, testfile, nframes, frames):
             self.assertEqual(f.getframerate(), self.framerate)
             self.assertEqual(f.getnframes(), nframes)
             self.assertEqual(f.readframes(nframes), frames)
+            self.assertEqual(f.getformat(), self.format)
 
     def test_write_params(self):
         f = self.create_file(TESTFN)
         f.setnframes(self.nframes)
         f.writeframes(self.frames)
         self.check_params(f, self.nchannels, self.sampwidth, self.framerate,
-                          self.nframes, self.comptype, self.compname)
+                          self.nframes, self.comptype, self.compname, self.format)
         f.close()
 
     def test_write_context_manager_calls_close(self):
@@ -257,7 +263,7 @@ def test_read_params(self):
         f = self.f = self.module.open(self.sndfilepath)
         #self.assertEqual(f.getfp().name, self.sndfilepath)
         self.check_params(f, self.nchannels, self.sampwidth, self.framerate,
-                          self.sndfilenframes, self.comptype, self.compname)
+                          self.sndfilenframes, self.comptype, self.compname, self.format)
 
     def test_close(self):
         with open(self.sndfilepath, 'rb') as testfile:
@@ -298,6 +304,8 @@ def test_read(self):
             f.setpos(f.getnframes() + 1)
 
     def test_copy(self):
+        if self.readonly:
+            self.skipTest('Read only file format')
         f = self.f = self.module.open(self.sndfilepath)
         fout = self.fout = self.module.open(TESTFN, 'wb')
         fout.setparams(f.getparams())
diff --git a/Lib/test/test_wave.py b/Lib/test/test_wave.py
index 05e7d377517798..86886ac768f6d2 100644
--- a/Lib/test/test_wave.py
+++ b/Lib/test/test_wave.py
@@ -1,7 +1,7 @@
 import unittest
 from test import audiotests
 from test import support
-from test.support.os_helper import FakePath
+from test.support.os_helper import FakePath, unlink
 import io
 import os
 import struct
@@ -22,6 +22,7 @@ class WavePCM8Test(WaveTest, unittest.TestCase):
     sampwidth = 1
     framerate = 11025
     nframes = 48
+    format = wave.WAVE_FORMAT_PCM
     comptype = 'NONE'
     compname = 'not compressed'
     frames = bytes.fromhex("""\
@@ -39,6 +40,7 @@ class WavePCM16Test(WaveTest, unittest.TestCase):
     sampwidth = 2
     framerate = 11025
     nframes = 48
+    format = wave.WAVE_FORMAT_PCM
     comptype = 'NONE'
     compname = 'not compressed'
     frames = bytes.fromhex("""\
@@ -60,6 +62,7 @@ class WavePCM24Test(WaveTest, unittest.TestCase):
     sampwidth = 3
     framerate = 11025
     nframes = 48
+    format = wave.WAVE_FORMAT_PCM
     comptype = 'NONE'
     compname = 'not compressed'
     frames = bytes.fromhex("""\
@@ -87,6 +90,8 @@ class WavePCM24ExtTest(WaveTest, unittest.TestCase):
     sampwidth = 3
     framerate = 11025
     nframes = 48
+    format = wave.WAVE_FORMAT_EXTENSIBLE
+    readonly = True  # Writing EXTENSIBLE wave format is not supported.
     comptype = 'NONE'
     compname = 'not compressed'
     frames = bytes.fromhex("""\
@@ -114,6 +119,7 @@ class WavePCM32Test(WaveTest, unittest.TestCase):
     sampwidth = 4
     framerate = 11025
     nframes = 48
+    format = wave.WAVE_FORMAT_PCM
     comptype = 'NONE'
     compname = 'not compressed'
     frames = bytes.fromhex("""\
@@ -134,14 +140,142 @@ class WavePCM32Test(WaveTest, unittest.TestCase):
         frames = wave._byteswap(frames, 4)
 
 
+class WaveIeeeFloatingPointTest(WaveTest, unittest.TestCase):
+    sndfilename = 'pluck-float32.wav'
+    sndfilenframes = 3307
+    nchannels = 2
+    sampwidth = 4
+    framerate = 11025
+    nframes = 48
+    format = wave.WAVE_FORMAT_IEEE_FLOAT
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex("""\
+      3C8B5960BA231400 3F16B41F3BFA5480 3EC44F0E3D1DC580 BF7E46533D843040 \
+      BED084FC3D564C30 3F1153303CFCBE40 BF002FB73C583EC0 3CDAFEE0BC425180 \
+      BF0F5154BD3826E0 BF169F56BDCAFD40 3EA660C0BE21A4EC 3E52E53CBE49332C \
+      BE102E0CBE5B7214 BEE76852BE6C3BDC 3DE05A98BE7A4980 BE06B6B4BE7EB6EC \
+      3F2EB1B0BE6C7CC8 BD195500BE3E0F4C 3E1BBDF8BE03DFEC BE9F4E92BD8D8D58 \
+      BF50E1D4BD111750 BDA079B0BCFBFB20 3D866358BD0C7640 BE833C0EBD17E240 \
+      3E0BFF04BD3978F0 3EFB9AE2BD14A780 BF0710B9BCD342E0 3F4DADB5BBA0CD80 \
+      BEC3B11A3D024EB0 3F063AD33D97A8C0 BEF912803DEC74E0 3F2241733E1515D4 \
+      BE0904D83E3AA604 BF7BF2003E3325BC 3F8000003E2229FC BF8000003E14A738 \
+      3F1338363DEB3B28 3F256E7C3DDBCA00 BE026A683DF5FD88 BEC70C923DFBE128 \
+      BE5A5B183DCEA2D8 3F4689513DA5A7C8 3D8C8FE83DA1FFF0 3EAEE61C3DB0A0E0 \
+      3F2290DF3DE44E18 BF6867373E09D82C BF1216283DEEB360 3F08262F3DA5B488 \
+      """)
+    if sys.byteorder != 'big':
+        frames = wave._byteswap(frames, 4)
+
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
-        not_exported = {'WAVE_FORMAT_PCM', 'WAVE_FORMAT_EXTENSIBLE', 'KSDATAFORMAT_SUBTYPE_PCM'}
+        not_exported = {'KSDATAFORMAT_SUBTYPE_PCM'}
         support.check__all__(self, wave, not_exported=not_exported)
 
 
 class WaveLowLevelTest(unittest.TestCase):
 
+    def test_setparams_6_tuple_defaults_to_pcm(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setformat(wave.WAVE_FORMAT_IEEE_FLOAT)
+            w.setparams((1, 2, 22050, 0, 'NONE', 'not compressed'))
+            self.assertEqual(w.getformat(), wave.WAVE_FORMAT_PCM)
+
+    def test_setparams_7_tuple_uses_format(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setparams((1, 4, 22050, 0, 'NONE', 'not compressed',
+                         wave.WAVE_FORMAT_IEEE_FLOAT))
+            self.assertEqual(w.getformat(), wave.WAVE_FORMAT_IEEE_FLOAT)
+
+    def test_setparams_7_tuple_ieee_64bit_sampwidth(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setparams((1, 8, 22050, 0, 'NONE', 'not compressed',
+                         wave.WAVE_FORMAT_IEEE_FLOAT))
+            self.assertEqual(w.getformat(), wave.WAVE_FORMAT_IEEE_FLOAT)
+            self.assertEqual(w.getsampwidth(), 8)
+
+    def test_getparams_backward_compatible_shape(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setparams((1, 4, 22050, 0, 'NONE', 'not compressed',
+                         wave.WAVE_FORMAT_IEEE_FLOAT))
+            params = w.getparams()
+            self.assertEqual(params, (1, 4, 22050, 0, 'NONE', 'not compressed'))
+
+    def test_getformat_setformat(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setnchannels(1)
+            w.setsampwidth(4)
+            w.setframerate(22050)
+            self.assertEqual(w.getformat(), wave.WAVE_FORMAT_PCM)
+            w.setformat(wave.WAVE_FORMAT_IEEE_FLOAT)
+            self.assertEqual(w.getformat(), wave.WAVE_FORMAT_IEEE_FLOAT)
+
+    def test_setformat_ieee_requires_32_or_64_bit_sampwidth(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setnchannels(1)
+            w.setsampwidth(2)
+            w.setframerate(22050)
+            with self.assertRaisesRegex(wave.Error,
+                                        'unsupported sample width for IEEE float format'):
+                w.setformat(wave.WAVE_FORMAT_IEEE_FLOAT)
+
+    def test_setsampwidth_ieee_requires_32_or_64_bit(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setnchannels(1)
+            w.setframerate(22050)
+            w.setformat(wave.WAVE_FORMAT_IEEE_FLOAT)
+            with self.assertRaisesRegex(wave.Error,
+                                        'unsupported sample width for IEEE float format'):
+                w.setsampwidth(2)
+            w.setsampwidth(4)
+
+    def test_setsampwidth_ieee_accepts_64_bit(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setnchannels(1)
+            w.setframerate(22050)
+            w.setformat(wave.WAVE_FORMAT_IEEE_FLOAT)
+            w.setsampwidth(8)
+            self.assertEqual(w.getsampwidth(), 8)
+
+    def test_read_getformat(self):
+        b = b'RIFF' + struct.pack('<L', 36) + b'WAVE'
+        b += b'fmt ' + struct.pack('<LHHLLHH', 16, 1, 1, 11025, 11025, 1, 8)
+        b += b'data' + struct.pack('<L', 0)
+        with wave.open(io.BytesIO(b), 'rb') as r:
+            self.assertEqual(r.getformat(), wave.WAVE_FORMAT_PCM)
+
     def test_read_no_chunks(self):
         b = b'SPAM'
         with self.assertRaises(EOFError):
@@ -207,6 +341,58 @@ def test_open_in_write_raises(self):
             support.gc_collect()
             self.assertIsNone(cm.unraisable)
 
+    def test_ieee_float_has_fact_chunk(self):
+        nframes = 100
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setnchannels(1)
+            w.setsampwidth(4)
+            w.setframerate(22050)
+            w.setformat(wave.WAVE_FORMAT_IEEE_FLOAT)
+            w.writeframes(b'\x00\x00\x00\x00' * nframes)
+
+        with open(filename, 'rb') as f:
+            f.read(12)
+            fact_found = False
+            fact_samples = None
+            while True:
+                chunk_id = f.read(4)
+                if len(chunk_id) < 4:
+                    break
+                chunk_size = struct.unpack('<L', f.read(4))[0]
+                if chunk_id == b'fact':
+                    fact_found = True
+                    fact_samples = struct.unpack('<L', f.read(4))[0]
+                    break
+                f.seek(chunk_size + (chunk_size & 1), 1)
+
+        self.assertTrue(fact_found)
+        self.assertEqual(fact_samples, nframes)
+
+    def test_pcm_has_no_fact_chunk(self):
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
+            filename = fp.name
+        self.addCleanup(unlink, filename)
+
+        with wave.open(filename, 'wb') as w:
+            w.setnchannels(1)
+            w.setsampwidth(2)
+            w.setframerate(22050)
+            w.writeframes(b'\x00\x00' * 100)
+
+        with open(filename, 'rb') as f:
+            f.read(12)
+            while True:
+                chunk_id = f.read(4)
+                if len(chunk_id) < 4:
+                    break
+                chunk_size = struct.unpack('<L', f.read(4))[0]
+                self.assertNotEqual(chunk_id, b'fact')
+                f.seek(chunk_size + (chunk_size & 1), 1)
+
     @support.subTests('arg', (
         # rounds to 0, should raise:
         0.5,
diff --git a/Lib/wave.py b/Lib/wave.py
index 841da8c49e9a2f..6e84c107b9fb20 100644
--- a/Lib/wave.py
+++ b/Lib/wave.py
@@ -15,6 +15,8 @@
       getsampwidth()  -- returns sample width in bytes
       getframerate()  -- returns sampling frequency
       getnframes()    -- returns number of audio frames
+      getformat()     -- returns frame encoding (WAVE_FORMAT_PCM, WAVE_FORMAT_IEEE_FLOAT
+                         or WAVE_FORMAT_EXTENSIBLE)
       getcomptype()   -- returns compression type ('NONE' for linear samples)
       getcompname()   -- returns human-readable version of
                          compression type ('not compressed' linear samples)
@@ -42,6 +44,9 @@
       setsampwidth(n) -- set the sample width
       setframerate(n) -- set the frame rate
       setnframes(n)   -- set the number of frames
+      setformat(format)
+                      -- set the frame format. Only WAVE_FORMAT_PCM and
+                         WAVE_FORMAT_IEEE_FLOAT are supported.
       setcomptype(type, name)
                       -- set the compression type and the
                          human-readable compression type
@@ -74,12 +79,21 @@
 import sys
 
 
-__all__ = ["open", "Error", "Wave_read", "Wave_write"]
+__all__ = [
+    "open",
+    "Error",
+    "Wave_read",
+    "Wave_write",
+    "WAVE_FORMAT_PCM",
+    "WAVE_FORMAT_IEEE_FLOAT",
+    "WAVE_FORMAT_EXTENSIBLE",
+]
 
 class Error(Exception):
     pass
 
 WAVE_FORMAT_PCM = 0x0001
+WAVE_FORMAT_IEEE_FLOAT = 0x0003
 WAVE_FORMAT_EXTENSIBLE = 0xFFFE
 # Derived from uuid.UUID("00000001-0000-0010-8000-00aa00389b71").bytes_le
 KSDATAFORMAT_SUBTYPE_PCM = b'\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa\x008\x9bq'
@@ -226,6 +240,10 @@ class Wave_read:
               available through the getsampwidth() method
     _framerate -- the sampling frequency
               available through the getframerate() method
+    _format -- frame format
+              One of WAVE_FORMAT_PCM, WAVE_FORMAT_IEEE_FLOAT
+              or WAVE_FORMAT_EXTENSIBLE available through
+              getformat() method
     _comptype -- the AIFF-C compression type ('NONE' if AIFF)
               available through the getcomptype() method
     _compname -- the human-readable AIFF-C compression type
@@ -327,6 +345,9 @@ def getsampwidth(self):
     def getframerate(self):
         return self._framerate
 
+    def getformat(self):
+        return self._format
+
     def getcomptype(self):
         return self._comptype
 
@@ -367,16 +388,16 @@ def readframes(self, nframes):
 
     def _read_fmt_chunk(self, chunk):
         try:
-            wFormatTag, self._nchannels, self._framerate, dwAvgBytesPerSec, wBlockAlign = struct.unpack_from('<HHLLH', chunk.read(14))
+            self._format, self._nchannels, self._framerate, dwAvgBytesPerSec, wBlockAlign = struct.unpack_from('<HHLLH', chunk.read(14))
         except struct.error:
             raise EOFError from None
-        if wFormatTag != WAVE_FORMAT_PCM and wFormatTag != WAVE_FORMAT_EXTENSIBLE:
-            raise Error('unknown format: %r' % (wFormatTag,))
+        if self._format not in (WAVE_FORMAT_PCM, WAVE_FORMAT_IEEE_FLOAT, WAVE_FORMAT_EXTENSIBLE):
+            raise Error('unknown format: %r' % (self._format,))
         try:
             sampwidth = struct.unpack_from('<H', chunk.read(2))[0]
         except struct.error:
             raise EOFError from None
-        if wFormatTag == WAVE_FORMAT_EXTENSIBLE:
+        if self._format == WAVE_FORMAT_EXTENSIBLE:
             try:
                 cbSize, wValidBitsPerSample, dwChannelMask = struct.unpack_from('<HHL', chunk.read(8))
                 # Read the entire UUID from the chunk
@@ -419,6 +440,8 @@ class Wave_write:
               set through the setsampwidth() or setparams() method
     _framerate -- the sampling frequency
               set through the setframerate() or setparams() method
+    _format -- frame format
+              set through setformat() method
     _nframes -- the number of audio frames written to the header
               set through the setnframes() or setparams() method
 
@@ -446,12 +469,14 @@ def initfp(self, file):
         self._file = file
         self._convert = None
         self._nchannels = 0
+        self._format = WAVE_FORMAT_PCM
         self._sampwidth = 0
         self._framerate = 0
         self._nframes = 0
         self._nframeswritten = 0
         self._datawritten = 0
         self._datalength = 0
+        self._fact_sample_count_pos = None
         self._headerwritten = False
 
     def __del__(self):
@@ -481,7 +506,10 @@ def getnchannels(self):
     def setsampwidth(self, sampwidth):
         if self._datawritten:
             raise Error('cannot change parameters after starting to write')
-        if sampwidth < 1 or sampwidth > 4:
+        if self._format == WAVE_FORMAT_IEEE_FLOAT:
+            if sampwidth not in (4, 8):
+                raise Error('unsupported sample width for IEEE float format')
+        elif sampwidth < 1 or sampwidth > 4:
             raise Error('bad sample width')
         self._sampwidth = sampwidth
 
@@ -519,6 +547,18 @@ def setcomptype(self, comptype, compname):
         self._comptype = comptype
         self._compname = compname
 
+    def setformat(self, format):
+        if self._datawritten:
+            raise Error('cannot change parameters after starting to write')
+        if format not in (WAVE_FORMAT_IEEE_FLOAT, WAVE_FORMAT_PCM):
+            raise Error('unsupported wave format')
+        if format == WAVE_FORMAT_IEEE_FLOAT and self._sampwidth and self._sampwidth not in (4, 8):
+            raise Error('unsupported sample width for IEEE float format')
+        self._format = format
+
+    def getformat(self):
+        return self._format
+
     def getcomptype(self):
         return self._comptype
 
@@ -526,10 +566,15 @@ def getcompname(self):
         return self._compname
 
     def setparams(self, params):
-        nchannels, sampwidth, framerate, nframes, comptype, compname = params
         if self._datawritten:
             raise Error('cannot change parameters after starting to write')
+        if len(params) == 6:
+            nchannels, sampwidth, framerate, nframes, comptype, compname = params
+            format = WAVE_FORMAT_PCM
+        else:
+            nchannels, sampwidth, framerate, nframes, comptype, compname, format = params
         self.setnchannels(nchannels)
+        self.setformat(format)
         self.setsampwidth(sampwidth)
         self.setframerate(framerate)
         self.setnframes(nframes)
@@ -590,6 +635,9 @@ def _ensure_header_written(self, datasize):
                 raise Error('sampling rate not specified')
             self._write_header(datasize)
 
+    def _needs_fact_chunk(self):
+        return self._format == WAVE_FORMAT_IEEE_FLOAT
+
     def _write_header(self, initlength):
         assert not self._headerwritten
         self._file.write(b'RIFF')
@@ -600,12 +648,23 @@ def _write_header(self, initlength):
             self._form_length_pos = self._file.tell()
         except (AttributeError, OSError):
             self._form_length_pos = None
-        self._file.write(struct.pack('<L4s4sLHHLLHH4s',
-            36 + self._datalength, b'WAVE', b'fmt ', 16,
-            WAVE_FORMAT_PCM, self._nchannels, self._framerate,
+        has_fact = self._needs_fact_chunk()
+        header_overhead = 36 + (12 if has_fact else 0)
+        self._file.write(struct.pack('<L4s4sLHHLLHH',
+            header_overhead + self._datalength, b'WAVE', b'fmt ', 16,
+            self._format, self._nchannels, self._framerate,
             self._nchannels * self._framerate * self._sampwidth,
             self._nchannels * self._sampwidth,
-            self._sampwidth * 8, b'data'))
+            self._sampwidth * 8))
+        if has_fact:
+            self._file.write(b'fact')
+            self._file.write(struct.pack('<L', 4))
+            try:
+                self._fact_sample_count_pos = self._file.tell()
+            except (AttributeError, OSError):
+                self._fact_sample_count_pos = None
+            self._file.write(struct.pack('<L', self._nframes))
+        self._file.write(b'data')
         if self._form_length_pos is not None:
             self._data_length_pos = self._file.tell()
         self._file.write(struct.pack('<L', self._datalength))
@@ -616,8 +675,13 @@ def _patchheader(self):
         if self._datawritten == self._datalength:
             return
         curpos = self._file.tell()
+        header_overhead = 36 + (12 if self._needs_fact_chunk() else 0)
         self._file.seek(self._form_length_pos, 0)
-        self._file.write(struct.pack('<L', 36 + self._datawritten))
+        self._file.write(struct.pack('<L', header_overhead + self._datawritten))
+        if self._fact_sample_count_pos is not None:
+            self._file.seek(self._fact_sample_count_pos, 0)
+            nframes = self._datawritten // (self._nchannels * self._sampwidth)
+            self._file.write(struct.pack('<L', nframes))
         self._file.seek(self._data_length_pos, 0)
         self._file.write(struct.pack('<L', self._datawritten))
         self._file.seek(curpos, 0)
diff --git a/Misc/NEWS.d/next/Library/2023-03-10-13-10-06.gh-issue-60729.KCCHTe.rst b/Misc/NEWS.d/next/Library/2023-03-10-13-10-06.gh-issue-60729.KCCHTe.rst
new file mode 100644
index 00000000000000..82876cd81e4a19
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-03-10-13-10-06.gh-issue-60729.KCCHTe.rst
@@ -0,0 +1 @@
+Add support for floating point audio wave files in :mod:`wave`.

From 3b06d68d8a3cc1f37359af1d7ebb3d09e1222296 Mon Sep 17 00:00:00 2001
From: Stan Ulbrych <89152624+StanFromIreland@users.noreply.github.com>
Date: Wed, 18 Mar 2026 12:58:08 +0000
Subject: [PATCH 04/11] gh-146076: Fix crash when a `ZoneInfo` subclass is
 missing a `_weak_cache` (#146082)

---
 Lib/test/test_zoneinfo/test_zoneinfo.py              | 12 ++++++++++++
 .../2026-03-17-20-41-27.gh-issue-146076.yoBNnB.rst   |  2 ++
 Modules/_zoneinfo.c                                  |  6 ++++++
 3 files changed, 20 insertions(+)
 create mode 100644 Misc/NEWS.d/next/Library/2026-03-17-20-41-27.gh-issue-146076.yoBNnB.rst

diff --git a/Lib/test/test_zoneinfo/test_zoneinfo.py b/Lib/test/test_zoneinfo/test_zoneinfo.py
index a5dea802a9898d..aaab4709464fd0 100644
--- a/Lib/test/test_zoneinfo/test_zoneinfo.py
+++ b/Lib/test/test_zoneinfo/test_zoneinfo.py
@@ -1595,6 +1595,18 @@ class ZI(self.klass):
             "Unexpected instance of int in ZI weak cache for key 'America/Los_Angeles'"
         )
 
+    def test_deleted_weak_cache(self):
+        class ZI(self.klass):
+            pass
+        delattr(ZI, '_weak_cache')
+
+        # These should not segfault
+        with self.assertRaises(AttributeError):
+            ZI("UTC")
+
+        with self.assertRaises(AttributeError):
+            ZI.clear_cache()
+
     def test_inconsistent_weak_cache_setdefault(self):
         class Cache:
             def get(self, key, default=None):
diff --git a/Misc/NEWS.d/next/Library/2026-03-17-20-41-27.gh-issue-146076.yoBNnB.rst b/Misc/NEWS.d/next/Library/2026-03-17-20-41-27.gh-issue-146076.yoBNnB.rst
new file mode 100644
index 00000000000000..746f5b278829bd
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2026-03-17-20-41-27.gh-issue-146076.yoBNnB.rst
@@ -0,0 +1,2 @@
+:mod:`zoneinfo`: fix crashes when deleting ``_weak_cache`` from a
+:class:`zoneinfo.ZoneInfo` subclass.
diff --git a/Modules/_zoneinfo.c b/Modules/_zoneinfo.c
index 39671d1ab51dfa..e2ab04cc2073c5 100644
--- a/Modules/_zoneinfo.c
+++ b/Modules/_zoneinfo.c
@@ -321,6 +321,9 @@ zoneinfo_ZoneInfo_impl(PyTypeObject *type, PyObject *key)
     }
 
     PyObject *weak_cache = get_weak_cache(state, type);
+    if (weak_cache == NULL) {
+        return NULL;
+    }
     instance = PyObject_CallMethod(weak_cache, "get", "O", key, Py_None);
     if (instance == NULL) {
         Py_DECREF(weak_cache);
@@ -505,6 +508,9 @@ zoneinfo_ZoneInfo_clear_cache_impl(PyTypeObject *type, PyTypeObject *cls,
 {
     zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
     PyObject *weak_cache = get_weak_cache(state, type);
+    if (weak_cache == NULL) {
+        return NULL;
+    }
 
     if (only_keys == NULL || only_keys == Py_None) {
         PyObject *rv = PyObject_CallMethod(weak_cache, "clear", NULL);

From 847f83ef1c1693d75cc024b31c3dcb9bcaca826f Mon Sep 17 00:00:00 2001
From: Lysandros Nikolaou <lisandrosnik@gmail.com>
Date: Wed, 18 Mar 2026 14:18:28 +0100
Subject: [PATCH 05/11] gh-142518: Add thread safety notes for the buffer
 protocol (#145911)

---
 Doc/c-api/typeobj.rst        | 28 ++++++++++++++++++
 Doc/library/stdtypes.rst     |  3 ++
 Doc/library/threadsafety.rst | 56 ++++++++++++++++++++++++++++++++++++
 Doc/reference/datamodel.rst  | 13 +++++++++
 4 files changed, 100 insertions(+)

diff --git a/Doc/c-api/typeobj.rst b/Doc/c-api/typeobj.rst
index 87b488912653b9..cd13c0f4d61a42 100644
--- a/Doc/c-api/typeobj.rst
+++ b/Doc/c-api/typeobj.rst
@@ -3057,6 +3057,24 @@ Buffer Object Structures
 
    (5) Return ``0``.
 
+   **Thread safety:**
+
+   In the :term:`free-threaded build`, implementations must ensure:
+
+   * The export counter increment in step (3) is atomic.
+
+   * The underlying buffer data remains valid and at a stable memory
+     location for the lifetime of all exports.
+
+   * For objects that support resizing or reallocation (such as
+     :class:`bytearray`), the export counter is checked atomically before
+     such operations, and :exc:`BufferError` is raised if exports exist.
+
+   * The function is safe to call concurrently from multiple threads.
+
+   See also :ref:`thread-safety-memoryview` for the Python-level
+   thread safety guarantees of :class:`memoryview` objects.
+
    If *exporter* is part of a chain or tree of buffer providers, two main
    schemes can be used:
 
@@ -3102,6 +3120,16 @@ Buffer Object Structures
 
    (2) If the counter is ``0``, free all memory associated with *view*.
 
+   **Thread safety:**
+
+   In the :term:`free-threaded build`:
+
+   * The export counter decrement in step (1) must be atomic.
+
+   * Resource cleanup when the counter reaches zero must be done atomically,
+     as the final release may race with concurrent releases from other
+     threads and dellocation must only happen once.
+
    The exporter MUST use the :c:member:`~Py_buffer.internal` field to keep
    track of buffer-specific resources. This field is guaranteed to remain
    constant, while a consumer MAY pass a copy of the original buffer as the
diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
index 24f53a3a272d73..48291622d7be89 100644
--- a/Doc/library/stdtypes.rst
+++ b/Doc/library/stdtypes.rst
@@ -5045,6 +5045,9 @@ copying.
 
       .. versionadded:: 3.3
 
+For information on the thread safety of :class:`memoryview` objects in
+the :term:`free-threaded build`, see :ref:`thread-safety-memoryview`.
+
 
 .. _types-set:
 
diff --git a/Doc/library/threadsafety.rst b/Doc/library/threadsafety.rst
index 8063c2ea5011e7..a529f7803affbc 100644
--- a/Doc/library/threadsafety.rst
+++ b/Doc/library/threadsafety.rst
@@ -548,3 +548,59 @@ Thread safety for bytearray objects
 
    Consider external synchronization when sharing :class:`bytearray` instances
    across threads.  See :ref:`freethreading-python-howto` for more information.
+
+
+.. _thread-safety-memoryview:
+
+Thread safety for memoryview objects
+====================================
+
+:class:`memoryview` objects provide access to the internal data of an
+underlying object without copying. Thread safety depends on both the
+memoryview itself and the underlying buffer exporter.
+
+The memoryview implementation uses atomic operations to track its own
+exports in the :term:`free-threaded build`. Creating and
+releasing a memoryview are thread-safe. Attribute access (e.g.,
+:attr:`~memoryview.shape`, :attr:`~memoryview.format`) reads fields that
+are immutable for the lifetime of the memoryview, so concurrent reads
+are safe as long as the memoryview has not been released.
+
+However, the actual data accessed through the memoryview is owned by the
+underlying object. Concurrent access to this data is only safe if the
+underlying object supports it:
+
+* For immutable objects like :class:`bytes`, concurrent reads through
+  multiple memoryviews are safe.
+
+* For mutable objects like :class:`bytearray`, reading and writing the
+  same memory region from multiple threads without external
+  synchronization is not safe and may result in data corruption.
+  Note that even read-only memoryviews of mutable objects do not
+  prevent data races if the underlying object is modified from
+  another thread.
+
+.. code-block::
+   :class: bad
+
+   # NOT safe: concurrent writes to the same buffer
+   data = bytearray(1000)
+   view = memoryview(data)
+   # Thread 1: view[0:500] = b'x' * 500
+   # Thread 2: view[0:500] = b'y' * 500
+
+.. code-block::
+   :class: good
+
+   # Safe: use a lock for concurrent access
+   import threading
+   lock = threading.Lock()
+   data = bytearray(1000)
+   view = memoryview(data)
+
+   with lock:
+       view[0:500] = b'x' * 500
+
+Resizing or reallocating the underlying object (such as calling
+:meth:`bytearray.resize`) while a memoryview is exported raises
+:exc:`BufferError`. This is enforced regardless of threading.
diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst
index 90b8821daaf3fb..1e53c0e0e6f971 100644
--- a/Doc/reference/datamodel.rst
+++ b/Doc/reference/datamodel.rst
@@ -3637,12 +3637,25 @@ implement the protocol in Python.
    provides a convenient way to interpret the flags. The method must return
    a :class:`memoryview` object.
 
+   **Thread safety:** In :term:`free-threaded <free threading>` Python,
+   implementations must manage any internal export counter using atomic
+   operations. The method must be safe to call concurrently from multiple
+   threads, and the returned buffer's underlying data must remain valid
+   until the corresponding :meth:`~object.__release_buffer__` call
+   completes. See :ref:`thread-safety-memoryview` for details.
+
 .. method:: object.__release_buffer__(self, buffer)
 
    Called when a buffer is no longer needed. The *buffer* argument is a
    :class:`memoryview` object that was previously returned by
    :meth:`~object.__buffer__`. The method must release any resources associated
    with the buffer. This method should return ``None``.
+
+   **Thread safety:** In :term:`free-threaded <free threading>` Python,
+   any export counter decrement must use atomic operations. Resource
+   cleanup must be thread-safe, as the final release may race with
+   concurrent releases from other threads.
+
    Buffer objects that do not need to perform any cleanup are not required
    to implement this method.
 

From 70c7e040d4f50219bd2832391e1a98701281fc58 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Wed, 18 Mar 2026 17:04:11 +0200
Subject: [PATCH 06/11] gh-66419: Make optional arguments with nargs=REMAINDER
 consume all arguments (GH-124509)

It no longer stops at the first '--'.
---
 Lib/argparse.py                                    |  2 +-
 Lib/test/test_argparse.py                          | 14 ++++++++++++++
 .../2024-09-25-12-47-50.gh-issue-66419.DVSukU.rst  |  2 ++
 3 files changed, 17 insertions(+), 1 deletion(-)
 create mode 100644 Misc/NEWS.d/next/Library/2024-09-25-12-47-50.gh-issue-66419.DVSukU.rst

diff --git a/Lib/argparse.py b/Lib/argparse.py
index 296a210ad832da..d91707d9eec546 100644
--- a/Lib/argparse.py
+++ b/Lib/argparse.py
@@ -2623,7 +2623,7 @@ def _get_nargs_pattern(self, action):
 
         # allow any number of options or arguments
         elif nargs == REMAINDER:
-            nargs_pattern = '([AO]*)' if option else '(.*)'
+            nargs_pattern = '(.*)'
 
         # allow one argument followed by any number of options or arguments
         elif nargs == PARSER:
diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index 4526efe4b80ef4..e0c32976fd6f0d 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -6605,6 +6605,20 @@ def test_remainder(self):
         args = parser.parse_args(['--foo', 'a', '--', 'b', '--', 'c'])
         self.assertEqual(NS(foo='a', bar=['--', 'b', '--', 'c']), args)
 
+    def test_optional_remainder(self):
+        parser = argparse.ArgumentParser(exit_on_error=False)
+        parser.add_argument('--foo', nargs='...')
+        parser.add_argument('bar', nargs='*')
+
+        args = parser.parse_args(['--', '--foo', 'a', 'b'])
+        self.assertEqual(NS(foo=None, bar=['--foo', 'a', 'b']), args)
+        args = parser.parse_args(['--foo', '--', 'a', 'b'])
+        self.assertEqual(NS(foo=['--', 'a', 'b'], bar=[]), args)
+        args = parser.parse_args(['--foo', 'a', '--', 'b'])
+        self.assertEqual(NS(foo=['a', '--', 'b'], bar=[]), args)
+        args = parser.parse_args(['--foo', 'a', 'b', '--'])
+        self.assertEqual(NS(foo=['a', 'b', '--'], bar=[]), args)
+
     def test_subparser(self):
         parser = argparse.ArgumentParser(exit_on_error=False)
         parser.add_argument('foo')
diff --git a/Misc/NEWS.d/next/Library/2024-09-25-12-47-50.gh-issue-66419.DVSukU.rst b/Misc/NEWS.d/next/Library/2024-09-25-12-47-50.gh-issue-66419.DVSukU.rst
new file mode 100644
index 00000000000000..ceac0616599466
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2024-09-25-12-47-50.gh-issue-66419.DVSukU.rst
@@ -0,0 +1,2 @@
+Optional argument with :ref:`nargs` equals to ``argparse.REMAINDER`` now
+consumes all remaining arguments including ``'--'``.

From 1e4ed932109c4f8ee4f43bc3e6fdb7710a3606bd Mon Sep 17 00:00:00 2001
From: Victor Stinner <vstinner@python.org>
Date: Wed, 18 Mar 2026 17:23:05 +0100
Subject: [PATCH 07/11] gh-146092: Fix error handling in _BINARY_OP_ADD_UNICODE
 opcode (#146117)

Fix also error handling in _BINARY_OP_ADD_FLOAT,
_BINARY_OP_SUBTRACT_FLOAT and _BINARY_OP_MULTIPLY_FLOAT opcodes.
PyStackRef_FromPyObjectSteal() must not be called with a NULL
pointer.
---
 Modules/_testinternalcapi/test_cases.c.h | 19 ++++----
 Python/bytecodes.c                       | 19 ++++----
 Python/executor_cases.c.h                | 57 ++++++++++++++----------
 Python/generated_cases.c.h               | 19 ++++----
 4 files changed, 66 insertions(+), 48 deletions(-)

diff --git a/Modules/_testinternalcapi/test_cases.c.h b/Modules/_testinternalcapi/test_cases.c.h
index 948a413d98ddcd..12480e2cb1962f 100644
--- a/Modules/_testinternalcapi/test_cases.c.h
+++ b/Modules/_testinternalcapi/test_cases.c.h
@@ -141,10 +141,11 @@
                 double dres =
                 ((PyFloatObject *)left_o)->ob_fval +
                 ((PyFloatObject *)right_o)->ob_fval;
-                res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-                if (PyStackRef_IsNull(res)) {
+                PyObject *d = PyFloat_FromDouble(dres);
+                if (d == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(d);
                 l = left;
                 r = right;
             }
@@ -289,10 +290,10 @@
                 assert(PyUnicode_CheckExact(right_o));
                 STAT_INC(BINARY_OP, hit);
                 PyObject *res_o = PyUnicode_Concat(left_o, right_o);
-                res = PyStackRef_FromPyObjectSteal(res_o);
-                if (PyStackRef_IsNull(res)) {
+                if (res_o == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(res_o);
                 l = left;
                 r = right;
             }
@@ -521,10 +522,11 @@
                 double dres =
                 ((PyFloatObject *)left_o)->ob_fval *
                 ((PyFloatObject *)right_o)->ob_fval;
-                res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-                if (PyStackRef_IsNull(res)) {
+                PyObject *d = PyFloat_FromDouble(dres);
+                if (d == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(d);
                 l = left;
                 r = right;
             }
@@ -1270,10 +1272,11 @@
                 double dres =
                 ((PyFloatObject *)left_o)->ob_fval -
                 ((PyFloatObject *)right_o)->ob_fval;
-                res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-                if (PyStackRef_IsNull(res)) {
+                PyObject *d = PyFloat_FromDouble(dres);
+                if (d == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(d);
                 l = left;
                 r = right;
             }
diff --git a/Python/bytecodes.c b/Python/bytecodes.c
index 2fb2c33428255a..e170fd65a20f64 100644
--- a/Python/bytecodes.c
+++ b/Python/bytecodes.c
@@ -710,10 +710,11 @@ dummy_func(
             double dres =
                 ((PyFloatObject *)left_o)->ob_fval *
                 ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 ERROR_NO_POP();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             INPUTS_DEAD();
@@ -729,10 +730,11 @@ dummy_func(
             double dres =
                 ((PyFloatObject *)left_o)->ob_fval +
                 ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 ERROR_NO_POP();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             INPUTS_DEAD();
@@ -748,10 +750,11 @@ dummy_func(
             double dres =
                 ((PyFloatObject *)left_o)->ob_fval -
                 ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 ERROR_NO_POP();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             INPUTS_DEAD();
@@ -772,10 +775,10 @@ dummy_func(
 
             STAT_INC(BINARY_OP, hit);
             PyObject *res_o = PyUnicode_Concat(left_o, right_o);
-            res = PyStackRef_FromPyObjectSteal(res_o);
-            if (PyStackRef_IsNull(res)) {
+            if (res_o == NULL) {
                 ERROR_NO_POP();
             }
+            res = PyStackRef_FromPyObjectSteal(res_o);
             l = left;
             r = right;
             INPUTS_DEAD();
diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h
index d89d512fd5630a..d33c67dd745bbf 100644
--- a/Python/executor_cases.c.h
+++ b/Python/executor_cases.c.h
@@ -4620,11 +4620,12 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval *
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4656,14 +4657,15 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval *
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 stack_pointer[0] = right;
                 stack_pointer += 1;
                 ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4696,8 +4698,8 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval *
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 stack_pointer[0] = left;
                 stack_pointer[1] = right;
                 stack_pointer += 2;
@@ -4705,6 +4707,7 @@
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4733,11 +4736,12 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval +
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4769,14 +4773,15 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval +
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 stack_pointer[0] = right;
                 stack_pointer += 1;
                 ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4809,8 +4814,8 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval +
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 stack_pointer[0] = left;
                 stack_pointer[1] = right;
                 stack_pointer += 2;
@@ -4818,6 +4823,7 @@
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4846,11 +4852,12 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval -
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4882,14 +4889,15 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval -
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 stack_pointer[0] = right;
                 stack_pointer += 1;
                 ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4922,8 +4930,8 @@
             double dres =
             ((PyFloatObject *)left_o)->ob_fval -
             ((PyFloatObject *)right_o)->ob_fval;
-            res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-            if (PyStackRef_IsNull(res)) {
+            PyObject *d = PyFloat_FromDouble(dres);
+            if (d == NULL) {
                 stack_pointer[0] = left;
                 stack_pointer[1] = right;
                 stack_pointer += 2;
@@ -4931,6 +4939,7 @@
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(d);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4957,11 +4966,11 @@
             assert(PyUnicode_CheckExact(right_o));
             STAT_INC(BINARY_OP, hit);
             PyObject *res_o = PyUnicode_Concat(left_o, right_o);
-            res = PyStackRef_FromPyObjectSteal(res_o);
-            if (PyStackRef_IsNull(res)) {
+            if (res_o == NULL) {
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(res_o);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -4991,14 +5000,14 @@
             assert(PyUnicode_CheckExact(right_o));
             STAT_INC(BINARY_OP, hit);
             PyObject *res_o = PyUnicode_Concat(left_o, right_o);
-            res = PyStackRef_FromPyObjectSteal(res_o);
-            if (PyStackRef_IsNull(res)) {
+            if (res_o == NULL) {
                 stack_pointer[0] = right;
                 stack_pointer += 1;
                 ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(res_o);
             l = left;
             r = right;
             _tos_cache2 = r;
@@ -5029,8 +5038,7 @@
             assert(PyUnicode_CheckExact(right_o));
             STAT_INC(BINARY_OP, hit);
             PyObject *res_o = PyUnicode_Concat(left_o, right_o);
-            res = PyStackRef_FromPyObjectSteal(res_o);
-            if (PyStackRef_IsNull(res)) {
+            if (res_o == NULL) {
                 stack_pointer[0] = left;
                 stack_pointer[1] = right;
                 stack_pointer += 2;
@@ -5038,6 +5046,7 @@
                 SET_CURRENT_CACHED_VALUES(0);
                 JUMP_TO_ERROR();
             }
+            res = PyStackRef_FromPyObjectSteal(res_o);
             l = left;
             r = right;
             _tos_cache2 = r;
diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h
index a66d6ccff2d82d..628f0cc4d37310 100644
--- a/Python/generated_cases.c.h
+++ b/Python/generated_cases.c.h
@@ -141,10 +141,11 @@
                 double dres =
                 ((PyFloatObject *)left_o)->ob_fval +
                 ((PyFloatObject *)right_o)->ob_fval;
-                res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-                if (PyStackRef_IsNull(res)) {
+                PyObject *d = PyFloat_FromDouble(dres);
+                if (d == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(d);
                 l = left;
                 r = right;
             }
@@ -289,10 +290,10 @@
                 assert(PyUnicode_CheckExact(right_o));
                 STAT_INC(BINARY_OP, hit);
                 PyObject *res_o = PyUnicode_Concat(left_o, right_o);
-                res = PyStackRef_FromPyObjectSteal(res_o);
-                if (PyStackRef_IsNull(res)) {
+                if (res_o == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(res_o);
                 l = left;
                 r = right;
             }
@@ -521,10 +522,11 @@
                 double dres =
                 ((PyFloatObject *)left_o)->ob_fval *
                 ((PyFloatObject *)right_o)->ob_fval;
-                res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-                if (PyStackRef_IsNull(res)) {
+                PyObject *d = PyFloat_FromDouble(dres);
+                if (d == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(d);
                 l = left;
                 r = right;
             }
@@ -1270,10 +1272,11 @@
                 double dres =
                 ((PyFloatObject *)left_o)->ob_fval -
                 ((PyFloatObject *)right_o)->ob_fval;
-                res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
-                if (PyStackRef_IsNull(res)) {
+                PyObject *d = PyFloat_FromDouble(dres);
+                if (d == NULL) {
                     JUMP_TO_LABEL(error);
                 }
+                res = PyStackRef_FromPyObjectSteal(d);
                 l = left;
                 r = right;
             }

From 5b25eaec373430b628a1e591f7312f9bdafe55b2 Mon Sep 17 00:00:00 2001
From: Lysandros Nikolaou <lisandrosnik@gmail.com>
Date: Wed, 18 Mar 2026 17:42:20 +0100
Subject: [PATCH 08/11] gh-142518: Annotate PyList_* C APIs for thread safety
 (#146109)

---
 Doc/c-api/list.rst        | 44 ++++++++++++++++++++++++++++++
 Doc/data/threadsafety.dat | 56 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 100 insertions(+)

diff --git a/Doc/c-api/list.rst b/Doc/c-api/list.rst
index 758415a76e5cb4..8f560699d355e4 100644
--- a/Doc/c-api/list.rst
+++ b/Doc/c-api/list.rst
@@ -74,11 +74,25 @@ List Objects
    Like :c:func:`PyList_GetItemRef`, but returns a
    :term:`borrowed reference` instead of a :term:`strong reference`.
 
+   .. note::
+
+      In the :term:`free-threaded build`, the returned
+      :term:`borrowed reference` may become invalid if another thread modifies
+      the list concurrently. Prefer :c:func:`PyList_GetItemRef`, which returns
+      a :term:`strong reference`.
+
 
 .. c:function:: PyObject* PyList_GET_ITEM(PyObject *list, Py_ssize_t i)
 
    Similar to :c:func:`PyList_GetItem`, but without error checking.
 
+   .. note::
+
+      In the :term:`free-threaded build`, the returned
+      :term:`borrowed reference` may become invalid if another thread modifies
+      the list concurrently. Prefer :c:func:`PyList_GetItemRef`, which returns
+      a :term:`strong reference`.
+
 
 .. c:function:: int PyList_SetItem(PyObject *list, Py_ssize_t index, PyObject *item)
 
@@ -108,6 +122,14 @@ List Objects
       is being replaced; any reference in *list* at position *i* will be
       leaked.
 
+   .. note::
+
+      In the :term:`free-threaded build`, this macro has no internal
+      synchronization. It is normally only used to fill in new lists where no
+      other thread has a reference to the list. If the list may be shared,
+      use :c:func:`PyList_SetItem` instead, which uses a :term:`per-object
+      lock`.
+
 
 .. c:function:: int PyList_Insert(PyObject *list, Py_ssize_t index, PyObject *item)
 
@@ -138,6 +160,12 @@ List Objects
    Return ``0`` on success, ``-1`` on failure.  Indexing from the end of the
    list is not supported.
 
+   .. note::
+
+      In the :term:`free-threaded build`, when *itemlist* is a :class:`list`,
+      both *list* and *itemlist* are locked for the duration of the operation.
+      For other iterables (or ``NULL``), only *list* is locked.
+
 
 .. c:function:: int PyList_Extend(PyObject *list, PyObject *iterable)
 
@@ -150,6 +178,14 @@ List Objects
 
    .. versionadded:: 3.13
 
+   .. note::
+
+      In the :term:`free-threaded build`, when *iterable* is a :class:`list`,
+      :class:`set`, :class:`dict`, or dict view, both *list* and *iterable*
+      (or its underlying dict) are locked for the duration of the operation.
+      For other iterables, only *list* is locked; *iterable* may be
+      concurrently modified by another thread.
+
 
 .. c:function:: int PyList_Clear(PyObject *list)
 
@@ -168,6 +204,14 @@ List Objects
    Sort the items of *list* in place.  Return ``0`` on success, ``-1`` on
    failure.  This is equivalent to ``list.sort()``.
 
+   .. note::
+
+      In the :term:`free-threaded build`, element comparison via
+      :meth:`~object.__lt__` can execute arbitrary Python code, during which
+      the :term:`per-object lock` may be temporarily released. For built-in
+      types (:class:`str`, :class:`int`, :class:`float`), the lock is not
+      released during comparison.
+
 
 .. c:function:: int PyList_Reverse(PyObject *list)
 
diff --git a/Doc/data/threadsafety.dat b/Doc/data/threadsafety.dat
index f063ca1360d5fb..103e8ef3e97ed1 100644
--- a/Doc/data/threadsafety.dat
+++ b/Doc/data/threadsafety.dat
@@ -17,3 +17,59 @@
 PyMutex_Lock:shared:
 PyMutex_Unlock:shared:
 PyMutex_IsLocked:atomic:
+
+# List objects (Doc/c-api/list.rst)
+
+# Type checks - read ob_type pointer, always safe
+PyList_Check:atomic:
+PyList_CheckExact:atomic:
+
+# Creation - pure allocation, no shared state
+PyList_New:atomic:
+
+# Size - uses atomic load on free-threaded builds
+PyList_Size:atomic:
+PyList_GET_SIZE:atomic:
+
+# Strong-reference lookup - lock-free with atomic ops
+PyList_GetItemRef:atomic:
+
+# Borrowed-reference lookups - no locking; returned borrowed
+# reference is unsafe in free-threaded builds without
+# external synchronization
+PyList_GetItem:compatible:
+PyList_GET_ITEM:compatible:
+
+# Single-item mutations - hold per-object lock for duration;
+# appear atomic to lock-free readers
+PyList_SetItem:atomic:
+PyList_Append:atomic:
+
+# Insert - protected by per-object critical section; shifts
+# elements so lock-free readers may observe intermediate states
+PyList_Insert:shared:
+
+# Initialization macro - no synchronization; normally only used
+# to fill in new lists where there is no previous content
+PyList_SET_ITEM:compatible:
+
+# Bulk operations - hold per-object lock for duration
+PyList_GetSlice:atomic:
+PyList_AsTuple:atomic:
+PyList_Clear:atomic:
+
+# Reverse - protected by per-object critical section; swaps
+# elements so lock-free readers may observe intermediate states
+PyList_Reverse:shared:
+
+# Slice assignment - lock target list; also lock source when it
+# is a list
+PyList_SetSlice:shared:
+
+# Sort - per-object lock held; comparison callbacks may execute
+# arbitrary Python code
+PyList_Sort:shared:
+
+# Extend - lock target list; also lock source when it is a
+# list, set, or dict
+PyList_Extend:shared:

From 2c6afb935ad588f32cb969345d0345e45d3a766e Mon Sep 17 00:00:00 2001
From: Bartosz Grabowski <58475557+bartosz-grabowski@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:49:15 +0100
Subject: [PATCH 09/11] docs: fix f-string in ExceptionGroup example (#146108)

---
 Doc/tutorial/errors.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Doc/tutorial/errors.rst b/Doc/tutorial/errors.rst
index ae21dfdbf0ac44..3c6edf2c4793ab 100644
--- a/Doc/tutorial/errors.rst
+++ b/Doc/tutorial/errors.rst
@@ -549,9 +549,9 @@ caught like any other exception. ::
    >>> try:
    ...     f()
    ... except Exception as e:
-   ...     print(f'caught {type(e)}: e')
+   ...     print(f'caught {type(e)}: {e}')
    ...
-   caught <class 'ExceptionGroup'>: e
+   caught <class 'ExceptionGroup'>: there were problems (2 sub-exceptions)
    >>>
 
 By using ``except*`` instead of ``except``, we can selectively

From 6fe91a9e803e1cae6d7341a02f1f45244ec45b20 Mon Sep 17 00:00:00 2001
From: Hai Zhu <haiizhu@outlook.com>
Date: Thu, 19 Mar 2026 00:58:14 +0800
Subject: [PATCH 10/11] gh-144888:  JIT executor bloom filter wide-type
 optimization and function Inlining (GH-146114)

---
 Include/internal/pycore_optimizer.h | 81 ++++++++++++++++++++++++++-
 Include/internal/pycore_uop.h       | 15 ++++-
 Python/optimizer.c                  | 85 -----------------------------
 3 files changed, 92 insertions(+), 89 deletions(-)

diff --git a/Include/internal/pycore_optimizer.h b/Include/internal/pycore_optimizer.h
index 8b52d77538abf2..6b3c39d64c9c32 100644
--- a/Include/internal/pycore_optimizer.h
+++ b/Include/internal/pycore_optimizer.h
@@ -159,10 +159,87 @@ PyAPI_FUNC(_PyExecutorObject*) _Py_GetExecutor(PyCodeObject *code, int offset);
 
 int _Py_ExecutorInit(_PyExecutorObject *, const _PyBloomFilter *);
 void _Py_ExecutorDetach(_PyExecutorObject *);
-void _Py_BloomFilter_Init(_PyBloomFilter *);
-void _Py_BloomFilter_Add(_PyBloomFilter *bloom, void *obj);
 PyAPI_FUNC(void) _Py_Executor_DependsOn(_PyExecutorObject *executor, void *obj);
 
+/* We use a bloomfilter with k = 6, m = 256
+ * The choice of k and the following constants
+ * could do with a more rigorous analysis,
+ * but here is a simple analysis:
+ *
+ * We want to keep the false positive rate low.
+ * For n = 5 (a trace depends on 5 objects),
+ * we expect 30 bits set, giving a false positive
+ * rate of (30/256)**6 == 2.5e-6 which is plenty
+ * good enough.
+ *
+ * However with n = 10 we expect 60 bits set (worst case),
+ * giving a false positive of (60/256)**6 == 0.0001
+ *
+ * We choose k = 6, rather than a higher number as
+ * it means the false positive rate grows slower for high n.
+ *
+ * n = 5, k = 6 => fp = 2.6e-6
+ * n = 5, k = 8 => fp = 3.5e-7
+ * n = 10, k = 6 => fp = 1.6e-4
+ * n = 10, k = 8 => fp = 0.9e-4
+ * n = 15, k = 6 => fp = 0.18%
+ * n = 15, k = 8 => fp = 0.23%
+ * n = 20, k = 6 => fp = 1.1%
+ * n = 20, k = 8 => fp = 2.3%
+ *
+ * The above analysis assumes perfect hash functions,
+ * but those don't exist, so the real false positive
+ * rates may be worse.
+ */
+
+#define _Py_BLOOM_FILTER_K 6
+#define _Py_BLOOM_FILTER_SEED 20221211
+
+static inline uint64_t
+address_to_hash(void *ptr) {
+    assert(ptr != NULL);
+    uint64_t uhash = _Py_BLOOM_FILTER_SEED;
+    uintptr_t addr = (uintptr_t)ptr;
+    for (int i = 0; i < SIZEOF_VOID_P; i++) {
+        uhash ^= addr & 255;
+        uhash *= (uint64_t)PyHASH_MULTIPLIER;
+        addr >>= 8;
+    }
+    return uhash;
+}
+
+static inline void
+_Py_BloomFilter_Init(_PyBloomFilter *bloom)
+{
+    for (int i = 0; i < _Py_BLOOM_FILTER_WORDS; i++) {
+        bloom->bits[i] = 0;
+    }
+}
+
+static inline void
+_Py_BloomFilter_Add(_PyBloomFilter *bloom, void *ptr)
+{
+    uint64_t hash = address_to_hash(ptr);
+    assert(_Py_BLOOM_FILTER_K <= 8);
+    for (int i = 0; i < _Py_BLOOM_FILTER_K; i++) {
+        uint8_t bits = hash & 255;
+        bloom->bits[bits >> _Py_BLOOM_FILTER_WORD_SHIFT] |=
+            (_Py_bloom_filter_word_t)1 << (bits & (_Py_BLOOM_FILTER_BITS_PER_WORD - 1));
+        hash >>= 8;
+    }
+}
+
+static inline bool
+bloom_filter_may_contain(const _PyBloomFilter *bloom, const _PyBloomFilter *hashes)
+{
+    for (int i = 0; i < _Py_BLOOM_FILTER_WORDS; i++) {
+        if ((bloom->bits[i] & hashes->bits[i]) != hashes->bits[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
 #define _Py_MAX_ALLOWED_BUILTINS_MODIFICATIONS 3
 #define _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS 6
 
diff --git a/Include/internal/pycore_uop.h b/Include/internal/pycore_uop.h
index e7ac7d59ff7e27..7bc8947cfa9a9d 100644
--- a/Include/internal/pycore_uop.h
+++ b/Include/internal/pycore_uop.h
@@ -45,10 +45,21 @@ typedef struct _PyUOpInstruction{
 
 /* Bloom filter with m = 256
  * https://en.wikipedia.org/wiki/Bloom_filter */
-#define _Py_BLOOM_FILTER_WORDS 8
+#ifdef HAVE_GCC_UINT128_T
+#define _Py_BLOOM_FILTER_WORDS 2
+typedef __uint128_t _Py_bloom_filter_word_t;
+#else
+#define _Py_BLOOM_FILTER_WORDS 4
+typedef uint64_t _Py_bloom_filter_word_t;
+#endif
+
+#define _Py_BLOOM_FILTER_BITS_PER_WORD \
+    ((int)(sizeof(_Py_bloom_filter_word_t) * 8))
+#define _Py_BLOOM_FILTER_WORD_SHIFT \
+    ((sizeof(_Py_bloom_filter_word_t) == 16) ? 7 : 6)
 
 typedef struct {
-    uint32_t bits[_Py_BLOOM_FILTER_WORDS];
+    _Py_bloom_filter_word_t bits[_Py_BLOOM_FILTER_WORDS];
 } _PyBloomFilter;
 
 #ifdef __cplusplus
diff --git a/Python/optimizer.c b/Python/optimizer.c
index 83a11f613a2db7..f09bf778587b12 100644
--- a/Python/optimizer.c
+++ b/Python/optimizer.c
@@ -1601,91 +1601,6 @@ uop_optimize(
  *        Executor management
  ****************************************/
 
-/* We use a bloomfilter with k = 6, m = 256
- * The choice of k and the following constants
- * could do with a more rigorous analysis,
- * but here is a simple analysis:
- *
- * We want to keep the false positive rate low.
- * For n = 5 (a trace depends on 5 objects),
- * we expect 30 bits set, giving a false positive
- * rate of (30/256)**6 == 2.5e-6 which is plenty
- * good enough.
- *
- * However with n = 10 we expect 60 bits set (worst case),
- * giving a false positive of (60/256)**6 == 0.0001
- *
- * We choose k = 6, rather than a higher number as
- * it means the false positive rate grows slower for high n.
- *
- * n = 5, k = 6 => fp = 2.6e-6
- * n = 5, k = 8 => fp = 3.5e-7
- * n = 10, k = 6 => fp = 1.6e-4
- * n = 10, k = 8 => fp = 0.9e-4
- * n = 15, k = 6 => fp = 0.18%
- * n = 15, k = 8 => fp = 0.23%
- * n = 20, k = 6 => fp = 1.1%
- * n = 20, k = 8 => fp = 2.3%
- *
- * The above analysis assumes perfect hash functions,
- * but those don't exist, so the real false positive
- * rates may be worse.
- */
-
-#define K 6
-
-#define SEED 20221211
-
-/* TO DO -- Use more modern hash functions with better distribution of bits */
-static uint64_t
-address_to_hash(void *ptr) {
-    assert(ptr != NULL);
-    uint64_t uhash = SEED;
-    uintptr_t addr = (uintptr_t)ptr;
-    for (int i = 0; i < SIZEOF_VOID_P; i++) {
-        uhash ^= addr & 255;
-        uhash *= (uint64_t)PyHASH_MULTIPLIER;
-        addr >>= 8;
-    }
-    return uhash;
-}
-
-void
-_Py_BloomFilter_Init(_PyBloomFilter *bloom)
-{
-    for (int i = 0; i < _Py_BLOOM_FILTER_WORDS; i++) {
-        bloom->bits[i] = 0;
-    }
-}
-
-/* We want K hash functions that each set 1 bit.
- * A hash function that sets 1 bit in M bits can be trivially
- * derived from a log2(M) bit hash function.
- * So we extract 8 (log2(256)) bits at a time from
- * the 64bit hash. */
-void
-_Py_BloomFilter_Add(_PyBloomFilter *bloom, void *ptr)
-{
-    uint64_t hash = address_to_hash(ptr);
-    assert(K <= 8);
-    for (int i = 0; i < K; i++) {
-        uint8_t bits = hash & 255;
-        bloom->bits[bits >> 5] |= (1 << (bits&31));
-        hash >>= 8;
-    }
-}
-
-static bool
-bloom_filter_may_contain(_PyBloomFilter *bloom, _PyBloomFilter *hashes)
-{
-    for (int i = 0; i < _Py_BLOOM_FILTER_WORDS; i++) {
-        if ((bloom->bits[i] & hashes->bits[i]) != hashes->bits[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
 static int
 link_executor(_PyExecutorObject *executor, const _PyBloomFilter *bloom)
 {

From 724c7c8146f44a7c737ec4588a1ee4b9db994f6f Mon Sep 17 00:00:00 2001
From: Victor Stinner <vstinner@python.org>
Date: Wed, 18 Mar 2026 18:20:35 +0100
Subject: [PATCH 11/11] gh-146093: Fix csv _set_str(): check if
 PyUnicode_DecodeASCII() failed (#146113)

The function can fail on a memory allocation failure.

Bug reported by devdanzin.
---
 Modules/_csv.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Modules/_csv.c b/Modules/_csv.c
index c48f44c0f07867..a3f840acbe8c0b 100644
--- a/Modules/_csv.c
+++ b/Modules/_csv.c
@@ -315,8 +315,12 @@ _set_char(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt)
 static int
 _set_str(const char *name, PyObject **target, PyObject *src, const char *dflt)
 {
-    if (src == NULL)
+    if (src == NULL) {
         *target = PyUnicode_DecodeASCII(dflt, strlen(dflt), NULL);
+        if (*target == NULL) {
+            return -1;
+        }
+    }
     else {
         if (!PyUnicode_Check(src)) {
             PyErr_Format(PyExc_TypeError,