gfqdZddlmZmZmZmZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Zddl mZmZddl mZmZmZddl mZmZddl mZmZmZmZddl mZmZ d#d Zd Zd Zd Z d$d Z dZ! d#dZ" d%dZ# d&dZ$ d'dZ%d(dZ&ddddddfdZ'd%dZ( d)dZ) d*dZ* d+dZ+dfdZ,d Z-d!Z.e/d"k(r(eejae jbyy),zP PyMRT: code that is now deprecated but can still be useful for legacy scripts. )divisionabsolute_importprint_functionunicode_literalsN)INFOPATH)VERB_LVL D_VERB_LVLVERB_LVL_NAMES)elapsedreport)msgdbgfmtfmtm)HAS_JITjitciddddddddd d d d d ddddddddddddddddddd }||vr||}n||jvr|}nd!}|r1tjjrd"j ||#S|S)$a Add color TTY-compatible color code to a string, for pretty-printing. DEPRECATED! (use `blessed` module) Args: text (str): The text to color. color (str|int|None): Identifier for the color coding. Lowercase letters modify the forground color. Uppercase letters modify the background color. Available colors: - r/R: red - g/G: green - b/B: blue - c/C: cyan - m/M: magenta - y/Y: yellow (brown) - k/K: black (gray) - w/W: white (gray) Returns: text (str): The colored text. See also: tty_colors rg b"c$m#y!w%kR)G*B,C.M-Y+W/K(Nz[1;{color}m{})color)valuessysstdoutisattyformat)textr5 tty_colors tty_colors n/var/dept/share/cheung/public_html/OutSchool/python/env/lib/python3.12/site-packages/flyingcircus/_obsolete.py tty_colorifyr?s< Rbr#&,/58">A2GJB Rbr#&,/58">A2GJBJ  u% *##% %  SZZ&&(*11$i1HH ct|dk(xs |dk7xr|dz }d}|s||z|kr||z }|dz }|s ||z|kr| S)a Determine if num is a prime number. A prime number is only divisible by 1 and itself. 0 and 1 are considered special cases; in this implementations they are considered primes. It is implemented by directly testing for possible factors. Args: val (int): The number to check for primality. Only works for numbers larger than 1. Returns: is_divisible (bool): The result of the primality. Examples: >>> is_prime_verbose(100) False >>> is_prime_verbose(101) True >>> is_prime_verbose(-100) False >>> is_prime_verbose(-101) True >>> is_prime_verbose(2 ** 17) False >>> is_prime_verbose(17 * 19) False >>> is_prime_verbose(2 ** 17 - 1) True >>> is_prime_verbose(0) False >>> is_prime_verbose(1) False )val is_divisibleis r>is_prime_verboserIOsbL!8;q :#']L Aq1us{!G}  Qq1us{ r@cz|dkr| }|dzs|dkDrytdt|dzdzdD] }||zr yy)a Determine if num is a prime number. A prime number is only divisible by 1 and itself. 0 and 1 are considered special cases; in this implementations they are considered primes. It is implemented by directly testing for possible factors. Args: val (int): The number to check for primality. Only works for numbers larger than 1. Returns: is_divisible (bool): The result of the primality. Examples: >>> is_prime_optimized(100) False >>> is_prime_optimized(101) True >>> is_prime_optimized(-100) False >>> is_prime_optimized(-101) True >>> is_prime_optimized(2 ** 17) False >>> is_prime_optimized(17 * 19) False >>> is_prime_optimized(2 ** 17 - 1) True >>> is_prime_optimized(0) True >>> is_prime_optimized(1) True rrCFrDg?rBT)rangeint)rFrHs r>is_prime_optimizedrMsWL Qwd !Gq 1c#*o)1 -a r@c|d|dz S)a' Calculate the (signed) size of an interval given as a 2-tuple (A,B) DEPRECATED! (by `numpy.ptp()`) Args: interval (float,float): Interval for computation Returns: val (float): The converted value Examples: >>> interval_size((0, 1)) 1 rBrrE)intervals r> interval_sizerPs A;! $$r@c#Kt|s# t|}|rtj|}|D]0}||s| t|r||n t |2y#t$r|f}d}Y]wxYw#t $rYywxYww)a Replace items matching a specific condition. This is fairly useless: If `replace` is callable: replace_iter(items, condition, replace) becomes: [replace(x) if condition(x) else x for x in items] If `replace` is not Iterable: list(replace_iter(items, condition, replace)) becomes: [replace if condition(x) else x for x in items] If `replace` is Iterable and cycle == False: list(replace_iter(items, condition, replace)) becomes: iter_replace = iter(replace) [next(iter_replace) if condition(x) else x for x in items] If `replace` is Iterable and cycle == True: list(replace_iter(items, condition, replace)) becomes: iter_replace = itertools.cycle(replace) [next(iter_replace) if condition(x) else x for x in items] Args: items (Iterable): The input items. condition (callable): The condition for the replacement. replace (any|Iterable|callable): The replacement. If Iterable, its elements are used for replacement. If callable, it is applied to the elements matching `condition`. Otherwise, the object itself is used. cycle (bool): Cycle through the replace. If True and `replace` is Iterable, its elements are cycled through. Otherwise `items` beyond last replacement are lost. Yields: item: The next item from items or its replacement. Examples: >>> ll = list(range(10)) >>> list(replace_iter(ll, lambda x: x % 2 == 0)) [None, 1, None, 3, None, 5, None, 7, None, 9] >>> list(replace_iter(ll, lambda x: x % 2 == 0, lambda x: x ** 2)) [0, 1, 4, 3, 16, 5, 36, 7, 64, 9] >>> list(replace_iter(ll, lambda x: x % 2 == 0, 100)) [100, 1, 100, 3, 100, 5, 100, 7, 100, 9] >>> list(replace_iter(ll, lambda x: x % 2 == 0, range(10, 0, -1))) [10, 1, 9, 3, 8, 5, 7, 7, 6, 9] >>> list(replace_iter(ll, lambda x: x % 2 == 0, range(10, 8, -1))) [10, 1, 9, 3, 10, 5, 9, 7, 10, 9] >>> list(replace_iter( ... ll, lambda x: x % 2 == 0, range(10, 8, -1), False)) [10, 1, 9, 3] >>> ll = list(range(10)) >>> (list(replace_iter(ll, lambda x: x % 2 == 0, lambda x: x ** 2)) ... == [x ** 2 if x % 2 == 0 else x for x in ll]) True >>> (list(replace_iter(ll, lambda x: x % 2 == 0, 'X')) ... == ['X' if x % 2 == 0 else x for x in ll]) True >>> iter_ascii_letters = iter(string.ascii_letters) >>> (list(replace_iter(ll, lambda x: x % 2 == 0, string.ascii_letters)) ... == [next(iter_ascii_letters) if x % 2 == 0 else x for x in ll]) True TN)callableiter TypeError itertoolscyclenext StopIteration)items conditionreplacerVitems r> replace_iterr]sV G  7mG oog.GJ '/'8gdmd7mK   jGE !  sK B  A')B  A;$B 'A85B 7A88B ; BB BB cdkr dvrydzrdkDr dzrdkDsydk(sdk(rytfdtjdDryy) a Determine if number is prime. WARNING! DO NOT USE THIS ALGORITHM AS IT IS EXTREMELY INEFFICIENT! A prime number is only divisible by 1 and itself. 0 and 1 are considered special cases; in this implementations they are considered primes. It is implemented by using the binomial triangle primality test. This is known to be extremely inefficient. Args: val (int): The number to check for primality. Only works for numbers larger than 1. Returns: is_divisible (bool): The result of the primality. Examples: >>> is_prime_binomial(100) False >>> is_prime_binomial(101) True >>> is_prime_binomial(-100) False >>> is_prime_binomial(-101) True >>> is_prime_binomial(2 ** 17) False >>> is_prime_binomial(17 * 19) False >>> is_prime_binomial(2 ** 13 - 1) True >>> is_prime_binomial(0) True >>> is_prime_binomial(1) True See Also: - flyingcircus.is_prime() - flyingcircus.primes_range() - https://en.wikipedia.org/wiki/Prime_number r)rrBTrCrDFc34K|]}|dkDr|z ywrBNrE).0nrFs r> z$is_prime_binomial..Ws& 1uSM s)full)allfcget_binomial_coeffs)rFs`r>is_prime_binomialrh"stZ Qwd f} 1WqsQw37 SAX  #%#9#9#E#J  r@c|dkr| }dnDttr ttjdnt t D]}||zr ||kcStj}t fdtd|dzD}t tj||d|zfz}t|}d}|d}||z|kr!||zsy|||z }|dz }||z}||z|kr!y)aH Determine if a number is prime. This uses a wheel factorization implementation. A prime number is only divisible by 1 and itself. 0 and 1 are considered special cases; in this implementations they are considered primes. It is implemented by testing for possible factors using wheel increment. Args: num (int): The number to check for primality. Only works for numbers larger than 1. wheel (int|Sequence[int]|None): The generators of the wheel. If int, this is the number of prime numbers to use (must be > 1), generated using `flyingcircus.gen_primes()`. If Sequence, it must consist of the first N prime numbers in increasing order. If None, uses a hard-coded (2, 3) wheel, which is faster for smaller inputs. Returns: is_divisible (bool): The result of the primality. Examples: >>> is_prime_wheel(100) False >>> is_prime_wheel(101) True >>> is_prime_wheel(-100) False >>> is_prime_wheel(-101) True >>> is_prime_wheel(2 ** 17) False >>> is_prime_wheel(17 * 19) False >>> is_prime_wheel(2 ** 17 - 1) True >>> is_prime_wheel(2 ** 31 - 1) True >>> is_prime_wheel(2 ** 17 - 1, 2) True >>> is_prime_wheel(2 ** 17 - 1, (2, 3)) True >>> is_prime_wheel(2 ** 17 - 1, (2, 3, 5)) True >>> is_prime_wheel(0) True >>> is_prime_wheel(1) True See Also: - flyingcircus.is_prime() - flyingcircus.primes_range() References: - https://en.wikipedia.org/wiki/Prime_number - https://en.wikipedia.org/wiki/Trial_division - https://en.wikipedia.org/wiki/Wheel_factorization rrCrDrCc3LK|]tfdDryw)c3PK|]}tj|dk(ywr`)mathgcd)rar#rbs r>rcz+is_prime_wheel...s 2qtxx1~"2s#&N)re)rarbwheels @r>rcz!is_prime_wheel..s'4 2E2 2 4s $FrBT) isinstancerLlistrf get_primestuplesortedprodrKdifflen) numror# prod_wheelcoprimesdeltas len_deltasjrHs ` r>is_prime_wheelr~`sD Qwd } E3 R]]5!,-fUm$ Qw!8OJ4JN+44H2778x{Z'?&AAB CFVJ A A a%3,a VAY Q Z a%3, r@rCrDc#dKd||z}d}||kr||r||z}d}n||z}d}||kryyw)a Generate steps for `step_sort()` (Shell sort). These are of the form a ** n * b ** m with n == m or n == m + 1 Args: n (int): The length of the sequence. a (int): The first number. b (int): The second number. Yields: int: The next step. Examples: >>> list(steps_alt(100000)) [1, 6, 18, 36, 108, 216, 648, 1296, 3888, 7776, 23328, 46656] >>> list(steps_alt(100000, 3, 2)) [1, 6, 12, 36, 72, 216, 432, 1296, 2592, 7776, 15552, 46656, 93312] rBrNrE)rbarxps r> steps_altrsO. G AA A a% FAA FAA a%+00c#K |D]}| |z|z}||kr|||z|z}||kryy#t$r d}|Y2wxYww)uj Generate steps for `step_sort()` (Shell sort). These are of the form: x(k) = m * x(k - 1) // d with some initial predefined values. Must be that `m > d`. If `init=(1, 4, 10, 23, 57, 132, 301, 701), m=9, d=4` this has been empirically suggested as yielding optimum empirical performances in the average case [Ciura2001], but unknown worst-case. If `init=(1, 4,), m=9, d=4` this is very close to yielding near-optimal empirical performances in the average case [Tokuda1992], but unknown worst-case. Args: n (int): The length of the sequence. init (Iterable[int]): The initial sequence. m (int): The multiplier for subsequent values. d (int): The divider for subsequent values. Yields: int: The next step. Examples: >>> list(steps_m_d(50000)) [1, 4, 10, 23, 57, 132, 301, 701, 1577, 3548, 7983, 17961, 40412] >>> list(steps_m_d(50000, (1, 4))) [1, 4, 9, 20, 45, 101, 227, 510, 1147, 2580, 5805, 13061, 29387] See Also: - Ciura, Marcin (2001). "Best Increments for the Average Case of Shellsort" (PDF). In Freiwalds, Rusins (ed.). Proceedings of the 13th International Symposium on Fundamentals of Computation Theory. London: Springer-Verlag. pp. 106–117. ISBN 978-3-540-42487-1 - Tokuda, Naoyuki (1992). "An Improved Shellsort". In van Leeuven, Jan (ed.). Proceedings of the IFIP 12th World Computer Congress on Algorithms, Software, Architecture. Amsterdam: North-Holland Publishing Co. pp. 449–457. ISBN 978-0-444-89747-3. rBN) ValueError)rbinitrdrs r> steps_m_drskZ AG  A A a% EQJ a%  s*A 1AAAAAAc#jKt|r ||}| ||z|z}|dkDr|ndyw)uY Generate steps for `step_sort()` (Shell sort). These are of the form: x(k) = m * x(k - 1) // d with initial value equal `n`. Must be that `d > m`. If `d=11, m=4`, this is yielding near-optimal empirical performances in the average case [Gonnet1991], but unknown worst-case. Args: n (int): The length of the sequence. d (int): The divider for subsequent values. m (int): The multiplier for subsequent values. stopping (callable|None): The modifier for the stopping value. If None, defaults to `n`. If callable, must have the signature: stopping(int): int. The input is `n`. Yields: int: The next step. Examples: >>> list(steps_d_m(100000)) [45454, 20660, 9390, 4268, 1940, 881, 400, 181, 82, 37, 16, 7, 3, 1] See Also: - Gonnet, Gaston H.; Baeza-Yates, Ricardo (1991). "Shellsort". Handbook of Algorithms and Data Structures: In Pascal and C (2nd ed.). Reading, Massachusetts: Addison-Wesley. pp. 161–163. ISBN 978-0-201-41607-7. rBNrR)rbrrstoppings r> steps_d_mrsHL QK  EQJ q5GG  s13rBc#rK||kr.|ttj|}|dz }||kr-yyw)a~ Generate steps for `step_sort()` (Shell sort). These follow an exponential law. Args: n (int): The length of the sequence. x (int): The initial value. k (int): The initial exponent. Yields: int: The next step. Examples: >>> list(steps_exp(100000)) [1, 7, 20, 54, 148, 403, 1096, 2980, 8103, 22026, 59874] rBN)rLrmexp)rbrr#s r> steps_exprQs8$ a%   Q a%277c |dzS)NrDrE)rs r>rqs 16r@c#rKt|r||}||kr|||z|z|z}|dz }||kryyw)u[ Generate steps for `step_sort()` (Shell sort). These are of the form: x(k) = (b ** k + c) // d with some initial value. With `x=1, k=2, b=2, c=-1, d=1, stopping=None` this has worst-case complexity O(n √n) [Hibbard1963]. With `x=1, k=2, b=2, c=1, d=1, stopping=None` this has worst-case complexity O(n √n) [Papernov1965]. With `x=1, k=2, b=3, c=-1, d=2, stopping=lambda x: x // 3` this has worst-case complexity O(n √n) [Knuth1973]. Args: n (int): The length of the sequence. x (int): The initial value. k (int): The initial exponent. b (int): The base. c (int): The constant term. d (int): The deonominator. stopping (callable|None): The modifier for the stopping value. If None, defaults to `n`. If callable, must have the signature: stopping(int): int. The input is `n`. Yields: int: The next step. Examples: >>> list(steps_pow_k(500000)) [1, 4, 13, 40, 121, 364, 1093, 3280, 9841, 29524, 88573] >>> list(steps_pow_k(20000, x=1, k=2, b=2, c=-1, d=1, stopping=None)) [1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383] >>> list(steps_pow_k(20000, x=1, k=2, b=2, c=1, d=1, stopping=None)) [1, 5, 9, 17, 33, 65, 129, 257, 513, 1025, 2049, 4097, 8193, 16385] See Also: - Knuth, Donald E. (1997). "Shell's method". The Art of Computer Programming. Volume 3: Sorting and Searching (2nd ed.). Reading, Massachusetts: Addison-Wesley. pp. 83–95. ISBN 978-0-201-89685-5. rBNr)rbrr#rrrrs r> steps_pow_krjsJb QK a% !VaZA  Q a%rc#Ktj|}t|D]/}t|dzD]}||z }||z||zz}||ks|1yw)uX Generate steps for `step_sort()` (Shell sort). These are of the form: x(k) = (a ** i) * (b ** j) with some initial value. With `a=2, b=3` this has worst-case complexity O(n log² n) [Pratt1971]. However, for applications, other sequences are preferred as they perform generally faster, even if they have inferior worst-case complexity. Args: n (int): The length of the sequence. a (int): The first base. b (int): The second base. Yields: int: The next step. Examples: >>> sorted(steps_bi_factors(100)) [1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32, 36, 48, 54, 72, 81] See Also: - Pratt, Vaughan Ronald (1979). Shellsort and Sorting Networks (Outstanding Dissertations in the Computer Sciences). Garland. ISBN 978-0-8240-4406-0. rBN)rfilog2rK)rbrrrr#rHr}rs r>steps_bi_factorsrse8  A 1Xq1u AAAQaA1u  s A A Ac #Kt|dz ||kr;||tfdtt||Dz}dz ||kr:yyw)uH Generate steps for `step_sort()` (Shell sort). These are of the form: x(k) = (b ** k + c) // d with some initial value. With `x=1, k=0, a=(1, 3), b=(4, 2), c=1` this has worst-case complexity O(n ^ (4/3)) [Sedgewick1985]. Args: n (int): The length of the sequence. x (int): The initial value. k (int): The initial exponent. a (int): The amplitudes. Must match the number of elements. b (int): The bases. c (int): The constant term. Yields: int: The next step. Examples: >>> list(steps_sum_pow_k(2000000)) [1, 8, 23, 77, 281, 1073, 4193, 16577, 65921, 262913, 1050113] See Also: - Sedgewick, Robert (1998). Algorithms in C. 1 (3rd ed.). Addison-Wesley. pp. 273–281. ISBN 978-0-201-31452-6. rBc3FK|]\}\}}||z|z zzywNrE)rarHa_ib_ir#offsets r>rcz"steps_sum_pow_k..s37:C #!f*q.) )7s!N)rwsum enumeratezip)rbrr#rrrrs ` @r>steps_sum_pow_krs`HVaZF a% 7!*3q!9!577 7 Q a%s A AAc#dK||kr'|||dzz||zz|z|z|z}|dz }||kr&yyw)u[ Generate steps for `step_sort()` (Shell sort). These are of the form: x(k) = (m ** (k + 1) // d ** k + a) // b + c with some initial value. With `x=1, k=1, m=9, d=4, a=-4, b=5, c=1` this has near optimal empirical average-case complexity [Tokuda1992]. This is very similar, but not identical to: `steps_m_d(init=(1, 4), m=9, d=4)`. Args: n (int): The length of the sequence. x (int): The initial value. k (int): The initial exponent. a (int): The amplitudes. Must match the number of elements. b (int): The bases. c (int): The constant term. Yields: int: The next step. Examples: >>> list(steps_pow_frac(50000)) [1, 4, 9, 20, 46, 103, 233, 525, 1182, 2660, 5985, 13467, 30301] See Also: - Tokuda, Naoyuki (1992). "An Improved Shellsort". In van Leeuven, Jan (ed.). Proceedings of the IFIP 12th World Computer Congress on Algorithms, Software, Architecture. Amsterdam: North-Holland Publishing Co. pp. 449–457. ISBN 978-0-444-89747-3. rBNrE)rbrr#rrrrrs r>steps_pow_fracrsLV a% 1q5\Q!V #a 'A - 1 Q a%rc #K| ||kDrdnd}|tj|}ttt ||z |dz|z dzD]}|||zz}|r t ||}|yw)a Generate a sequence that steps linearly from start to stop. Args: start (int|float): The starting value. stop (int|float): The final value. This value is present in the resulting sequence only if the step is a multiple of the interval size. step (int|float): The step value. If None, it is automatically set to unity (with appropriate sign). precision (int): The number of decimal places to use for rounding. If None, this is estimated from the `step` paramenter. Yields: item (int|float): the next element of the sequence. Examples: >>> list(sequence(0, 1, 0.1)) [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] >>> list(sequence(0, 1, 0.3)) [0.0, 0.3, 0.6, 0.9] >>> list(sequence(0, 10, 1)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> list(sequence(0.4, 4.6, 0.72)) [0.4, 1.12, 1.84, 2.56, 3.28, 4.0] >>> list(sequence(0.4, 4.72, 0.72, 2)) [0.4, 1.12, 1.84, 2.56, 3.28, 4.0, 4.72] >>> list(sequence(0.4, 4.72, 0.72, 4)) [0.4, 1.12, 1.84, 2.56, 3.28, 4.0, 4.72] >>> list(sequence(0.4, 4.72, 0.72, 1)) [0.4, 1.1, 1.8, 2.6, 3.3, 4.0, 4.7] >>> list(sequence(0.73, 5.29)) [0.73, 1.73, 2.73, 3.73, 4.73] >>> list(sequence(-3.5, 3.5)) [-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5] >>> list(sequence(3.5, -3.5)) [3.5, 2.5, 1.5, 0.5, -0.5, -1.5, -2.5, -3.5] >>> list(sequence(10, 1, -1)) [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] >>> list(sequence(10, 1, 1)) [] >>> list(sequence(10, 20, 10)) [10, 20] >>> list(sequence(10, 20, 15)) [10] NrBr)rfguess_decimalsrKrLround)startstopstep precisionrHr\s r>sequencer*sf |5Lqb%%d+ 3uTE\9q=9D@AAE Fq4x y)D sA-A/c ||zSrrE)rrs r>rrks !a%r@c tt|Dcgc]'}tj|t |d|dz)c}Scc}w)a Cumulatively apply the specified function to the elements of the list. Args: items (Iterable): The items to process. func (callable): func(x,y) -> z The function applied cumulatively to the first n items of the list. Defaults to cumulative sum. Returns: lst (list): The cumulative list. See Also: itertools.accumulate. Examples: >>> accumulate(list(range(5))) [0, 1, 3, 6, 10] >>> accumulate(list(range(5)), lambda x, y: (x + 1) * y) [0, 1, 4, 15, 64] >>> accumulate([1, 2, 3, 4, 5, 6, 7, 8], lambda x, y: x * y) [1, 2, 6, 24, 120, 720, 5040, 40320] NrB)rKrw functoolsreducerq)rYfuncrHs r> accumulaterisI6s5z" $  tE{6AE23 $$ $s,Ac:i}|D]}|j||S)a Merge dictionaries into a new dict (new keys overwrite the old ones). This is obsoleted by `flyingcircus.join()`. Args: items (Iterable[dict]): Dictionaries to be merged together. Returns: merged (dict): The merged dict (new keys overwrite the old ones). Examples: >>> d1 = {1: 2, 3: 4, 5: 6} >>> d2 = {2: 1, 4: 3, 6: 5} >>> d3 = {1: 1, 3: 3, 6: 5} >>> dd = merge_dicts((d1, d2)) >>> print(tuple(sorted(dd.items()))) ((1, 2), (2, 1), (3, 4), (4, 3), (5, 6), (6, 5)) >>> dd = merge_dicts((d1, d3)) >>> print(tuple(sorted(dd.items()))) ((1, 1), (3, 3), (5, 6), (6, 5)) )update)rYmergedr\s r> merge_dictsrs).F d Mr@cfd}|S)WIPcddlm}d}d}||fz}|D]B} ||}|j|d}|jd|j d|}n |S#t t ttf$r}||ur|Yd}~rd}~wwxYw)Nr) import_module)gzipbz2builtinsrbrB)fp) importlibropenreadseekOSErrorIOErrorAttributeError ImportError) rrzip_module_namesfallback_module_nameopen_module_namesopen_module_name open_moduletmp_fpers r>_wrappedz)transparent_compression.._wrappeds+)),0D/FF 1   +,<= $))"d3 A  A r{WnkB #';;G< s+A""B ;BB rE)rrs` r>transparent_compressionrs* Or@__main__r)NTrj))rB 9i-i r) N)rBrC)rBr)rBrD)rrCrB)rBrBrrrrB)NN)2__doc__ __future__rrrrosr7rmrdocteststringrU flyingcircusrfrrr r r r r rrrrrrr?rIrMrPr]rhr~rrrrrrrrrrrr__name__striptestmodrEr@r>rsV CC   #==(,,% ,`,`-b%. Z|:@[B !N/ 6x  /f6 !6t"P   *` .j ;B $><8 z GOOr@