j\dZddlmZddlZddlZddlZddlZddlmZm Z m Z m ZddlmZmZmZmZdZdZdZd Zd Zd ZdQdZejdejejzZejdZejdZ dRdZ!GddeZ"dSdZ#dTdZ$dUdZ%GddeZ&d d!dVd%Z'dWd&Z(dXd(Z)dYd)Z*dYd*Z+dYd+Z,dZd-Z-d.Z.d/Z/dddd0d[d6Z0d\d8Z1d]d:Z2e3d;Z4d^d>Z5Gd?d@eZ6d_dCZ7e7Z8GdDdEeZ9d`dFZ:dGa;dadIZddJdddPZ?dS)eaThe core-pin comparison and the runtime repair, owned by the core and shared by every consumer. WHY IT LIVES HERE. Every distribution that consumes this package asks the same question: is the invisible-core that is about to execute the one my own metadata declares? Written when two did - the Playwright wrapper and the profile manager, the latter deleted 2026-08-18 - and copies of that comparison drift, so a diagnosis that differs between products is worse than no diagnosis at all. One comparison, one message set, one requirement parser, parameterised by the asking distribution's name. WHY IT EXISTS AT RUNTIME AT ALL. Once a consumer's [project].dependencies carries an exact `invisible-core==N.M.0`, pip refuses the obvious ways to get this wrong and `pip check` reports the rest. Two paths still slip through, both measured: * `pip install --no-deps ` and lockfile installers that resolve each distribution separately. Nothing at install time leaves a trace, and nobody runs `pip check` inside a built container. * a partial install: the files under site-packages/invisible_core were replaced but the .dist-info was not (a clobbering copy, a hand-patched image layer). pip and `pip check` both read the record, so both call that environment healthy. The files are what actually runs. WHAT IS COMPARED, and why this pair rather than the obvious one. WANT the `==` version parsed back out of the CONSUMER's metadata, i.e. out of its pyproject. One source, no constant in code to drift. HAVE invisible_core._version.__version__, recomputed from the packaged seal.json on every import. This is the truth of the code that will execute, and it is read by importing this package's own sibling module, never through importlib.metadata. RECORDED importlib.metadata.version("invisible-core"), the installer's record. Diagnostics ONLY. It never triggers on its own: asserting on it gives a false green on both cases above, and a false red on any editable checkout whose dist-info was frozen at install time. ONE PARSER. `invisible-core==X` is spelled several legal ways in a Requires-Dist line, and every place that reads one used to carry its own regex with its own acceptance set. That is this project's original bug in miniature: N copies of one thing that must agree, and the weakest copy decides. parse_requirement() below is the only implementation. pin_from_requirements() is the only place that decides which requirement is the pin, and it takes the requirement strings from whatever source the caller has (importlib.metadata, a doctor's own facts object, a pyproject's [project].dependencies), so nothing has a reason to write a second one. WHAT THIS MODULE DOES AT IMPORT TIME, AND WHY IT IS ALLOWED TO. enforce_core_pin() does not just report a mismatch, it repairs it: it installs the declared version and picks it up in-process, so the user's script keeps running. The window that makes that sound is narrow and the guards below are what keep it narrow: * it runs from the FIRST line of a consumer's package __init__, at which instant invisible_core has not been imported by anybody else. The consumer captures that fact before importing us and passes it in as core_preimported; when it is true the repair is refused, because swapping the core underneath objects somebody already holds is not a reload, it is two versions alive at once. * one attempt per environment, enforced by a module flag AND an env var, so a re-exec cannot turn a failing repair into a loop. * every failure degrades to the message that was printed before this existed. A missing network, a read-only site-packages or a locked-down image gets a remedy to run, never a traceback and never a retry. * it says what it is about to do before it does it, and what it did after. A package that silently mutates the environment it was imported into is worse than one that asks. An EDITABLE core is repaired too, on purpose, and that is the one case where the repair costs the user something: installing over `pip install -e` detaches the environment from their working tree. The tree survives, but imports stop coming from it. So the path is captured BEFORE the install and the exact command that reattaches it is printed afterwards, prominently. WHAT THIS MODULE CANNOT SEE, and who owns that. By the time anything in here runs, invisible_core has already been imported successfully - this module is part of it. So "the core is not installed", "the core is installed but its own dependencies are missing" and "the core is installed but so damaged it cannot derive its own version" are not states this module can ever report on. They belong to the import floor in each consumer's package __init__, which catches the failure of `from invisible_core._pin import ...` and classifies it. That split is deliberate; it is why pin_problem() no longer takes a parameter describing the health of the core, and why there is no probe of it here. "NOT CHECKABLE" IS NOT "HEALTHY". A consumer that declares no `invisible-core==` requirement, or whose install record is missing entirely, leaves nothing to enforce. That is a graceful skip, not a pass: pin_report() returns verdict="not-checkable" with the reason, exactly as `python -m invisible_core doctor` prints it. Only verdict="violated" raises or repairs. It never checks the seal DIGEST - the consumer has no independent expectation of the core's bytes without hardcoding one, which is a second source of truth and the original bug again. Content belongs to the publish gate, where the previous release's digest is available to compare against. Keep this module's imports to the standard library, and keep the two sibling imports it needs inside the functions that need them. If it ever grows a module-level import of anything heavier, a core that is broken in some other way produces a traceback about an internal module instead of the remedy. ) annotationsN)PackageNotFoundError distributionrequiresversion)Iterable NamedTupleOptionalSequencezinvisible-coreINVISIBLE_CORE_PININVISIBLE_CORE_AUTOFIX INVISIBLE_CORE_AUTOFIX_ATTEMPTEDINVISIBLE_CORE_AUTOFIX_TIMEOUTgr@returnfloatctjtd}|r) t |}|dkr|Sn#t $rYnwxYwtS)aWSeconds, from the env var when it parses to a positive number. A malformed or non-positive value falls back to the default rather than raising or disabling the bound: this is read on the import path, and there is no sensible reason for a typo in an env var to break someone's import, nor to silently turn the timeout off. r)osenvirongetINSTALL_TIMEOUT_ENVstripr ValueError_INSTALL_TIMEOUT_DEFAULT)rawvs CC:\Projects\Historical\venv\Lib\site-packages\invisible_core/pin.py_install_timeoutrsw *..,b 1 1 7 7 9 9C  c A1uu    D  ##sA A A zj^\s*(?P[A-Za-z0-9][A-Za-z0-9._-]*)\s* (?:\[(?P[^\]]*)\])?\s* (?P.*)$z^==(?P[^\s,;()\[\]]+)$z \bextra\s*==markerstrOptional[bool]c|sdS ddlm}n#t$rYdSwxYw t||S#t $rYdSwxYw)a/True / False when the marker can be evaluated here, None when it cannot. A marker that is FALSE on this host means pip never installed that requirement, so there is no pin here to compare. Reading it as an active pin is a false RED on an environment `pip check` calls healthy, and because the guard runs at import time it makes the package refuse to load on exactly the platform the marker was written to exclude. The evaluation is `packaging`'s and never a parser of ours: marker syntax is a language, and a second implementation of it is the defect this module already carries a comment about. `packaging` is not one of our runtime dependencies, so when it is absent the honest answer is "cannot tell" - which is reported as nothing-to-compare, never as a violation. Tr)MarkerN)packaging.markersr# ImportErrorboolevaluate Exception)rr#s r_marker_appliesr)s t,,,,,,, ttFF6NN++--... tts )A AAcPeZdZUdZded<ded<ded<ded<ded<d ed <d S) RequirementaOne requirement string, reduced to what it MEANS. name PEP 503 normalised, so invisible_core, Invisible.Core and invisible-core are one name. extras normalised and sorted, so [b,a] and [A, B] are one extras set. specifier all whitespace removed and one layer of the parenthesised dialect stripped, so `(== 1.2.3)` and `==1.2.3` are one specifier. Empty for a bare requirement. marker the environment marker, whitespace-collapsed. Empty when absent. pinned the version when the specifier is exactly one `==`, else None. None is "declares no comparable version", which covers a bare name, a range, and a direct reference (`name @ url`). r rnametupleextras specifierr Optional[str]pinnedN__name__ __module__ __qualname____doc____annotations__rr+r+sW   HHH IIIMMMNNNKKKr9r+r,cRtjdd|S)zHPEP 503: invisible_core, Invisible.Core and invisible-core are one name.z[-_.]+-)resublower)r,s rnormalise_namer?s" 6)S$ ' ' - - / //r9reqOptional[Requirement]c tt|}|dS|dpdd\}}}t jdd|}|dr|dr |dd }|d pd}ttd | d D}d | }t|} tt|t|d|||| r| dndS)zParse one requirement string. None when it does not even start with a distribution name, which is the only shape this refuses.Nrestr;z\s+()r.c3K|]9}|t|V:dS)N)rr?).0es r z$parse_requirement..s\OO&'AGGIIOqwwyy!!OOOOOOr9, r,r)rr,r.r/rr1)_REQ_REmatchr group partitionr<r= startswithendswithr-sortedsplitjoin _PINNED_REr+r?) r@m spec_part_ marker_partr/ raw_extrasr.rr1s rparse_requirementr^s  c#hhAyt!"!6B A A# F FIq+vr9--IC  $Y%7%7%<%<$adO ""(bJ 6OO+5+;+;C+@+@OOOOOPPF XXk'')) * *F   i ( (F  HH AGGFOO , ,*0:v||I&&&d    r9c(t|}|4dt|S|jrdd|jdnd}|jr d|jnd}|j||j|S)aUA requirement reduced to a comparable string, so two spellings of the same requirement compare equal. A name spelled with an underscore, a space around the operator and the parenthesised dialect all describe the same requirement, and a gate that compares the raw literals refuses a push over a space and then reports that the pin "disagrees with the core", which is false. Anything parse_requirement cannot take apart falls back to whitespace collapsing, which can only ever make two requirements compare UNEQUAL, so a gate built on this keeps failing closed. NrN[rM]rz; )r^rWr rVr.rr,r/)r@parsedr.rs rcanonical_requirementrcss # #F ~xxC(()))/5} D +&-(( + + + +"F%+] : !&- ! ! !Fk =6 =6#3 =V = ==r9c2eZdZUdZded<ded<ded<dS)PinDeclarationaWhat the asking distribution declares about invisible-core. status is one of: "pinned" - exactly one `invisible-core==X` requirement. version is X. "no_record" - the distribution has no install record (a source checkout), so it never declared anything. "no_pin" - installed, but no comparable requirement: either no invisible-core requirement at all, or one with no `==` (a bare direct reference carries no version), or one hidden behind an extra. "ambiguous" - more than one invisible-core `==` requirement, disagreeing. Only "pinned" is checkable. The other three are reported as such, never as a pass. r0rr statusdetailNr2r8r9rrere#s?  KKKr9rezthis distribution dist_namer Iterable[str]ric g}d}d}d}d}|D]}t|}||jtkr$t|jrd}Ft |j} | dur | durd}nd}h|jd}r||j|s^|r|dtd} n=|r|dtd} n-|r|dtd} n|r|dtd } n |d td } tdd | Stt|} t| d krBtdd|dt| dtdd | zSt| dddS)a;Pick the invisible-core pin out of a list of requirement strings. THE single implementation. Feed it importlib.metadata.requires(), a doctor's own DistFacts.requires, or a pyproject's [project].dependencies: the acceptance set is then the same everywhere by construction rather than by review. FNT requires zC with no == version (a direct reference declares no version at all)z declares zG only behind an extra, so a default install resolves nothing to comparez~ only under an environment marker that is false on this host, so this install never resolved it and there is no pin to comparez} under an environment marker this environment cannot evaluate (packaging is not importable), so the pin is not checkable herez declares no z requirementno_pinrG ambiguousz disagreeing z pins: z, rr1)r^r, CORE_NAME_EXTRA_MARKER_REsearchrr)r1appendrerUsetlenrW) rrifoundsaw_core_without_pinsaw_core_under_extrasaw_core_under_false_marker saw_core_under_unreadable_markerrrbappliesrgdistincts rpin_from_requirementsr|7sN E  "'',$$$"3'' >V[I55   " "6= 1 1 #' !&-00 $  %.2++370  = #'  V]#### 6  H"IIiIIIFF ! H"JJiJJJFF ( H"DDiDDDFF. H"GGiGGGFF"GG GGGFdHf555c%jj!!H 8}}q + R RCMM R R R R Rii!! "## # (1+x 6 66r9c t|pg}nL#t$rtdd|dcYSt$r }tdd|d|cYd}~Sd}~wwxYwt ||S)zEParse the `invisible-core==` requirement out of dist_name's metadata.N no_recordzO has no install record, so it declares nothing (running from a source checkout)z metadata unreadable: rh) _requiresrrer(r|)rireqsrKs rpin_declarationrusZ##)r 111 + 0 0 011 1 1 1 ZZZdKI1X1XUV1X1XYYYYYYYYZ  ; ; ;;sA AAAAr0c*t|jS)zThe `invisible-core==X` version dist_name declares, or None. None means "nothing to enforce", NOT "healthy". Callers that need to tell those apart use pin_declaration() or pin_report()["verdict"]. )rrrhs rdeclared_core_pinrs 9 % % --r9c~ ddlm}n#t$rYdSwxYwt|}|pdS)aTThe version of the core code that will actually run, derived live. Read from the sibling _version module, which recomputes the version from the packaged seal.json (seal tag + CORE_REVISION) on every import. There is deliberately NO fallback to invisible_core.__version__: that attribute is importlib.metadata.version("invisible-core"), i.e. the installer's record, and falling back to it would hand back the record in the exact case this function exists to catch - a site-packages whose files were clobbered while the .dist-info stayed put. The old fallback made that environment report as healthy. None means "could not be determined", and it is rendered as such in the mismatch message rather than assumed healthy. The import is INSIDE the function on purpose, and it is what makes the in-process repair work: after repair_core() drops invisible_core.* from sys.modules and re-imports the package, this line resolves to the freshly installed _version module, so the same function object reports the new version without the process restarting. rG) __version__N)_versionrr(r r)derivedtexts rinstalled_core_versionrs_(4444444 tt w<<    D <4s  cf ttS#t$rYdSt$rYdSwxYw)z0What the installer wrote down. Diagnostics only.N) _pkg_versionrorr(r8r9rrecorded_core_versionrsPI&&& tt tts 0 00c ttd}n#t$rYdSwxYw|sdS ddl}||}n#t$rYdSwxYw|didsdSt|dd}|dr0dd l m }m }dd l m }||||jS|pdS) aThe source tree an editable core points at, or None. PEP 610: pip records direct_url.json for anything not installed from an index, and marks dir_info.editable for `pip install -e`. An install with no direct_url.json is by definition not editable. Read BEFORE any repair runs: the install replaces the .dist-info, so afterwards there is nothing left to read and the reattach command could not be printed. zdirect_url.jsonNrdir_infoeditableurlrzfile:///)unquoteurlparse) url2pathname) _distributionro read_textr(jsonloadsrr rS urllib.parserrurllib.requestrpath)rrinforrrrs reditable_core_pathrsFI&&001BCC tt t zz# tt 88J # # ' ' 3 3t dhhub!! " "C ~~j!!922222222//////|GGHHSMM$677888 ;$s'* 88A A('A(r-c|ttdttjDS)aEvery invisible_core module currently in sys.modules, sorted. The repair's soundness turns on this being empty before the consumer's import ran: nobody can be holding an object from the version we are about to replace if nothing imported it yet. c3PK|]!}|dks|d|V"dS)invisible_corezinvisible_core.N)rS)rJrYs rrLz&core_modules_loaded..sPEE  ALL1B$C$C  EEr9)r-rUlistsysmodulesr8r9rcore_modules_loadedrsR EE $$EEEEE F FFr9z:invisible_core/_version.py, from seal.json + CORE_REVISIONzan undeterminable version)recorded editable_path dist_versionwanthaverrrc2|r|d|n|}|rdtd|dnd|}|sdS||krdS|pt}|rhtdtd|d td|d |d td|d td tdddt |gd|d|d|dt dS|J||krDtd|d td|dtd|d tdtd|d|dtd|dStd|d td|dtd|d td|S)a1Pure verdict. Returns the message to raise, or None when there is nothing to raise about. None covers two different situations on purpose, and the caller is expected to keep them apart: the pin holds, or there was no pin to check. Split out from pin_report so every branch is testable without building a broken environment - but note that the fact-gathering functions above are tested against real constructed site-packages layouts, not through this seam, since a pure verdict function proves nothing about what is fed into it. rNz pip install "=="zpip install --force-reinstall Nz version mismatch, and z is an editable install. z requires z editable source z that tree builds z (z) Repairing this replaces the editable install with a copy from the index: the tree above stays on disk, but imports stop coming from it and edits in it stop having any effect. To reattach it afterwards: pipinstall-ez, To keep this pair instead, move the pin in z's pyproject.toml to z., or roll the core's seal back to the release z1 was built against. To run this pair anyway: set z=allowzJ version mismatch, and its install record disagrees with its own files. z the files on disk say z) the install record says z pip and pip check read the record, so both report this environment as healthy. The files are what actually runs, and a plain install is a no-op here because pip believes z9 is already present. Run: pip install --force-reinstall "z version mismatch. z installed aa) This pair is not tested together. The prefs, the spoofed User-Agent and the protocol expectations are generated per engine release, so a core from another release describes a browser you are not running. An install that skipped dependency resolution is the usual cause: pip install --no-deps, or a lockfile that pins the two packages separately. Run: )ro _UNDETERMINED _DERIVED_FROMformat_commandr SKIP_ENV) rirrrrrconsumerwant_cmdshowns r pin_problemrs&1=K),,l,,,)H8<B4 44T4444AiAA  t t||t  !ME  = = = = = =&/ = =37 = =%2 = =&/ = =27 = ==J = =  4]9K9K LMM = =;D = = = =EN = =-5 = = = D 0 0 H H H H&/ H H37 H H)2 H H5: H H@M H H*3  H H6>  H H04 H H4= H HAE H H H       "+  /3  !*  -2  8E     r9dictc dt|}|j}t}t}t } t |}n#t $rd}YnwxYwt||||||}|d\}} n|r|rd\}} nd}|jp td} |||j ||||| |du|d S)aNon-raising form. What a doctor command prints. verdict is the field to read, and it has three values, not two: "holds" - a pin was declared and the code that will run matches it; "violated" - problem carries the message; "not-checkable" - nothing was declared, or the declaration cannot be compared. reason says which. This is NOT a pass, and collapsing it into one was how a wrapper with an unparsed pin reported itself healthy. N)rirrrrr)violatedN)holdsNz not-checkablez derives no version) distrdeclared_statusrrrverdictreasonokproblem) rrrrrrr(rrgrorf) ri declarationrrrrrrrrs r pin_reportr=s"),,K  D ! # #D$&&H!##H#I..  $TH\G* I$I'!#H)'H'H'H&-o  sA A! A!Nonect|}|ddS|d}tjtdkrt j|tddSt|)a\Raise ImportError when the core that will run is not the one dist_name declares. A pin that cannot be checked is a silent pass here and a named "not checkable" in pin_report(). This is the REPORTING form and it installs nothing. It is what the doctor and the tests use. The import-time form that repairs is enforce_core_pin(). rNallow stacklevel) rrrrrwarningswarnRuntimeWarningr%)rireportmsgs rassert_core_pinrosn " "F i   C z~~h7** c>a8888 c  r9z=<>[]!;&|$`"'*? cmd Sequence[str]c@dd|DS)z5A command list rendered so a human can paste it back.rNc3TK|]#}t|tzrd|dn|V$dS)rN)rs_NEEDS_QUOTING)rJtokens rrLz!format_command..sWQQCHE ^3> E QQQQQQr9)rW)rs rrrs< 88QQLOQQQ Q QQr9c.eZdZUded<ded<ded<dS)InstallOutcomer&rr commandrgN)r3r4r5r7r8r9rrrs+ HHHLLLKKKKKr9rexecuter&c t|}|std|dSddl} |t |ddt }ns#|j$r,td|dt dtd cYSt$r2}td|t|j d |cYd}~Sd}~wwxYw|j dkrtd|d Sd |j pd d z|jpd z}td|d|j d |ddS)a_The single choke point every pip command in this module goes through. The seam is deliberately used for FORMATTING as well as for running: execute=False renders the command and runs nothing. If it only ever fired on execution it would be dead in normal operation, and dead code is exactly what lets an installer be wired into a module whose tests are still green. Nothing raises out of here. A locked-down environment, a read-only site-packages, no network and no pip at all are all the same answer: ok is False and detail says why, and the caller degrades to the message. Fz not executedrNT)capture_outputrtimeoutzpip did not finish within z5s and was stopped. Run the command by hand, or raise .: z pip exited 0rNrz pip exited ip)rr subprocessrunrrTimeoutExpiredrr(typer3 returncoderWstderrstdoutrV)rrrr completedrKtails r_run_piprs 3  E <eUN;;; HNN499T+;+=+=#??  $III 5 H)9);); H H1D H H HII I I I HHHeUtAww/?,F,F1,F,FGGGGGGGGHq  dE>::: 88i&,"3y7G7M2NUUWW X XD %([i6J([([dSWSXSXk([([ \ \\s#2A3C  C 'CC C cPeZdZUdZded<ded<ded<ded<ded <ded <d S) RepairResulta,attempted says whether the installer was reached at all, repaired says whether the environment is now correct IN THIS PROCESS. They are separate because "we ran pip and it worked" is not the claim that matters; the claim that matters is that the import about to happen gets the new files.r& attemptedrepairedr rrr0rrecoveryNr2r8r9rrrs\KKOOONNNKKKLLL    r9rctjtddvS)z>False only when the kill switch is set. Repair is the default.r)off0nofalse)rrr AUTOFIX_ENVrr>r8r9rautofix_enabledrs= :>>+r * * 0 0 2 2 8 8 : :C# ##r9Frct t|||dS#t$rYdSwxYw)N)file)printflushr()streamrs r_sayrsM  d           s %) 77)rcore_preimportedc ||n tj}|stddddddStjddddtd |g}t |}t stddd td |ddS|r;tddtd ttd |d|ddSts$tj trtddd|ddS ddlm}m}||t} nT#t$$rG} tdddtdt'| jd| dtd |ddcYd} ~ Sd} ~ wwxYw| v| jso| jr d| jnd} | jrt ddd| jgn dtd} tddtd| d| jd| dtd |ddSda d tj t<t1} | r t dddt3| gnd}t5pt6}t9|d!|d"td#|d$|d%td |d& | rt9|d!|d'td(| d)t9|d!|d*| t;t=|d+}n?#t$$r2}t?d|t'|jd|}Yd}~nd}~wwxYw|j s4t9|d!|d,|j!tdd|j!|| |StD]"}tj"#|d#d-dl$}|% |&d.nd#t$$rW}t9|d!|d/td |d0t'|jd| tddd1||| |cYd}~Sd}~wwxYwt5}||krBt9|d!|d2td3|pt6d4|d& tddd5|pd6|| |St9|d!|d7td#|d8|rRt9|dt9|d!|d"td9| d:t9|d;|t9|dtddd<|| |S)=auInstall `want` and pick it up in this process. Never raises. core_preimported is not computed here on purpose: by the time any line of this module runs, invisible_core IS imported, so a check made here would always say yes and the guard would be theatre. The consumer captures it at the top of its own __init__, before it imports us, and passes it in. NFznothing is declared to installrz-mrrz--force-reinstallrz&the automatic repair is switched off (rFz- was already imported before this check ran (z| of its modules are live), so replacing it now would leave objects from two different versions alive in one process. Import z) first, or run the command above yourselfzPan automatic repair was already attempted in this environment and is not retriedrG) _dist_facts _editable_ofzcould not determine whether z is an editable install (rzw), and this repair overwrites whatever is there. Refusing rather than guessing. Run the command above yourself, or set z=off for the sessionz at rzpip install -e z is an EDITABLE installz (z), so the automatic repair would overwrite a working tree with a published wheel. Refusing. Fix the environment yourself - usually `z ` - or set T1r`z] rNz is installed, but rlrz] NOTE: z$ is an EDITABLE install pointing at zi. Repairing it detaches this environment from that tree: the sources stay, imports stop coming from them.z] repairing it now: )rz(] the automatic repair did not succeed: rrz] the repair installed z! but the result does not import: z,the freshly installed core does not import: z] the repair ran but z still derives z, not z)after the install the core still derives nothingz] repaired in place: z= is now the version this process will run. No restart needed.z3 is NO LONGER an editable install. Your sources at zD are untouched, but nothing imports them any more. To reattach them:z r)'rrr executablerorrrrtr_REPAIR_ATTEMPTEDrrrAUTOFIX_ATTEMPTED_ENV_envrrr(rr3safe_to_reinstallrwhyrr rrrINSTALL_RUNNERrrrrgrpop importlibinvalidate_caches import_module)rirrroutrrrrrexcwhereremedyrrbeforeoutcomerKr,r nows r repair_corers&&&CJC \E5*JBPTVZ[[[ >4 3F ! !4 ! ! #C 3  E   X 5 C[ C C CUDRVXX X 5 K K'))** K K  K K K 4  BJNN+@AA 5  4  B 33333333,{{95566  5 B9 B BS " B B&) B B!, B B B 4       7#<)0=%w|%%%2\O.%D',!GHHH'N)'N'N'N  5 E E E E'+ E E E E$/ E E E 4  (+BJ$%"##H KS\~uis8}}EFFFX\H # % % 6F/)//y//6//i//#//'+///000G SFiFFFFFFF G G G 8)8888999K cD999 KKK $q''2B/I/Ia/I/IJJK :T SYiYYYYZZZD%(SSS $%%$$ d#### !!!' 01111 ''' S>i>> >>T>>&*1gg&6>>:;>> ? ? ? %KKK 8X'' ' ' ' ' ' '' ! " "C d{{ S9i99i99)M9915999 : : : %WSEUIWW 8X'' ' ;);;);;c;;;<<< S"  S-i--9-- (--- . . . S###$$$ S" dJx J JJsU:!D E-&r"s)aaD#"""""  <;;;;;;;;;;;    ' ;7 $$$$P "*J    RZ: ; ; 2:o..6*,0000 2>>>>(Z*2E;7;7;7;7;7;7| < < < <....8D F F F F"M , ##'"&GGGGGGT////d.*++QQQQ Z %]%]%]%]T     :   ####      hKhKhKhKhKhKV    HL::::::::r9