cwiSrSSKrSSKJr SSKJr SSKJrJrJ r J r J r J r J r JrJr \R S:aSSKJr SS KJrJrJrJrJrJrJrJr SS KJrJr SS KJr SS K J!r! SS K"J#r# SSK$J%r%J&r&J'r' SSK(J)r)J*r*J+r+ SSK,J-r- SSK.J/r/ SSK0J1r1 SS/r2"SS\5r3"SS5r4\Rj"\"S5SS9S5r6\Rj"\"S5SS9S5r7"SS5r8g)a This module contains the `clingo.control.Control` class responsible for controling grounding and solving. Examples -------- The following example shows the basic ground solve process: >>> from clingo.symbol import Number >>> from clingo.control import Control >>> >>> ctl = Control() >>> ctl.add("q.") >>> >>> ctl.ground() >>> print(ctl.solve(on_model=print)) q SAT The following example shows basic (multishot) grounding and solving: >>> from clingo.symbol import Number >>> from clingo.control import Control >>> >>> ctl = Control() >>> ctl.add("a", [], "q.") >>> ctl.add("b", ["t"], "q(t).") >>> >>> ctl.ground([("a", [])]) >>> print(ctl.solve(on_model=print)) q SAT >>> ctl.ground([("b", [Number(1)]), ("b", [Number(2)])]) >>> print(ctl.solve(on_model=print)) q q(1) q(2) SAT >>> ctl.ground([("b", [Number(3)])]) >>> print(ctl.solve(on_model=print)) q q(1) q(2) q(3) SAT N)abc)IntEnum) AnyCallableIteratorOptionalSequenceTupleUnioncastoverload)Literal)_c_call_cb_error_handler_CBData_Error_ffi _handle_error_lib _overwritten)BackendObserver) Configuration)Logger) Propagator)Model SolveHandle SolveResult) StatisticsMap_mutable_statistics _statistics)Symbol) SymbolicAtoms) TheoryAtomControl BackendTypecd\rSrSrSr\R r\Rr \Rr Sr g)r*Tz$ Enumeration of available backends. N) __name__ __module__ __qualname____firstlineno____doc__rclingo_backend_type_aspifAspifclingo_backend_type_smodelsSmodelsclingo_backend_type_reifyReify__static_attributes__r-H/home/james-whalen/.local/lib/python3.13/site-packages/clingo/control.pyr*r*Ts=  * *E..G  * *Er:c2\rSrSrSrSrSrSrSrSr g) _SolveEventHandlergc4XlX lX0lX@lgN) _on_model _on_unsat_on_statistics _on_finish)selfon_modelon_unsat on_statistics on_finishs r;__init___SolveEventHandler.__init__is!!+#r:cSnURbUR[U55n[U=(d USL5$r@)rAr bool)rEmrets r;rF_SolveEventHandler.on_modelos7 >> %..q*CC&3$;''r:cBURbURU5 ggr@)rB)rElowers r;rG_SolveEventHandler.on_unsatus >> % NN5 ! &r:cTURbUR[U55 ggr@)rDr")rEress r;rI_SolveEventHandler.on_finishys" ?? & OOK, - 'r:chURb%UR[U5[U55 ggr@)rCr$)rEstepaccus r;rH _SolveEventHandler.on_statistics}s/    *    3D 9;Nt;T U +r:)rDrArCrBN) r.r/r0r1rJrFrGrIrHr9r-r:r;r=r=gs$ ( ".Vr:r=datapyclingo_solve_event_callback)onerrornamec[R"U5RnU[R:Xa)UR [R "SU5S5 U[R:Xa)UR[R "SU55US'U[R:Xa[R "SU5n[R "SUS5n[[R "SUS55nUR[U5Vs/sHoUPM sn5 U[R:Xa/[R "SU5n URU SU S5 g s snf) z Low-level solve event handler. zclingo_solve_result_bitset_t*rzclingo_model_t*zvoid**zint64_t*size_trzclingo_statistics_t**T)r from_handler[rclingo_solve_event_type_finishrIr clingo_solve_event_type_modelrFclingo_solve_event_type_unsatintrGrange"clingo_solve_event_type_statisticsrH) type_eventr[goonhandlerc_argsc_lowersizeip_statss r;_pyclingo_solve_event_callbackrqs"t$))G 333$))$CUKANO 222""499->#FGQ 2228U+))Jq 2499Xvay12eDk:k!*k:; 777))3U;gaj'!*5  ;sE4pyclingo_ground_callbackcP[R"U5Rn[R"U5R 5n[ Uc[ RSOUU5n /n [U5Hn U R[X+55 M! U "U 6n [U [R5(a [U 5OU /n [R"S[!U 55n[#U 5HupUR$X'M ['U"U[!U 5U55 g)z Low-level ground callback. __main__clingo_symbol_t[]T)rrar[stringdecodegetattrsysmodulesrfappendr& isinstancerIterablelistnewlen enumerate_repr)locationr^ argumentsarguments_sizer[symbol_callbacksymbol_callback_datacontextpy_namefunargsrorOsymbols c_symbolssyms r;_pyclingo_ground_callbackrst$))Gkk$&&(G W_#++j)'7 SC D > " F9<()# t*C%c3<<88d3iseG,c'l;IG$xx %/)S\;OPQ r:cF \rSrSrSr/SS4S\\S\\S\ 4Sjjr S r \ S \S \\S \S S4Sj5r \ S \S S4Sj5r SUSjr S \S S4SjrS \S \\S \S S4SjrS\\\ 4S \ 4SjrSUSjrS\\\\ 4S\S S4SjrS\\\\ 4S S4SjrS\\\\ 4S S4SjrSUSjrS\\\ 4S\\S S4SjrS \4SjrSUS jrS \S \\4S!jrSVS"\\\\\4S#\S S4S$jjr SUS%jr!S&\S S4S'jr"S(\\S S4S)jr#SWS+\$S,\S S4S-jjr%SXS.\&S/\S,\S0\S1\S S4 S2jjr'S3\(S S4S4jr)S\\\ 4S S4S5jr*\+RXS6:Ga^\ SYS*S*S7.S8\\\\\4\ 4S9\\-\./\\4S:\\-\\ /S4S;\\-\/\//S4S<\\-\0/S4S=\\-\\ /S4S>\\-\./S4S?\1S*S@\1S*S \04SAjjj5r2\ SZS*SB.S8\\\\\4\ 4S9\\-\./\\4S:\\-\\ /S4S;\\-\/\//S4S<\\-\0/S4S=\\-\\ /S4S?\1SCS@\S \34SDjjj5r2\ SZS*SE.S8\\\\\4\ 4S9\\-\./\\4S:\\-\\ /S4S;\\-\/\//S4S<\\-\0/S4S=\\-\\ /S4S?\S@\1SCS \34SFjjj5r2Op\ SYS8\\\\\4\ 4S9\\-\./\\4S:\\-\\ /S4S;\\-\/\//S4S<\\-\0/S4S=\\-\\ /S4S>\\-\./S4S \04SGjj5r2\ S[S8\\\\\4\ 4S9\\-\./\\4S:\\-\\ /S4S;\\-\/\//S4S<\\-\0/S4S=\\-\\ /S4S>\\-\./S4S?\S@\S \\3\044SHjj5r2S[S8\\\\\4\ 4S9\\-\./\\4S:\\-\\ /S4S;\\-\/\//S4S<\\-\0/S4S=\\-\\ /S4S>\\-\./S4S?\S@\S \\3\044SIjjr2\4S \54SJj5r6\4S \4SKj5r7\7RpSL\S S4SMj5r7\4S \4SNj5r9\9RpSL\S S4SOj5r9\4S \4SPj5r:\4S \;4SQj5r<\4S \=4SRj5r>\4S \?\@4SSj5rASTrBg)\r)a Control object for the grounding/solving process. Parameters ---------- arguments Arguments to the grounder and solver. logger Function to intercept messages normally printed to standard error. message_limit The maximum number of messages passed to the logger. Notes ----- Note that only gringo options (without `--text`) and clasp's search options are supported. Furthermore, you must not call any functions of a `Control` object while a solve call is active. Nrlogger message_limitc SUl/Ul[U[R5(Ga UbB[ R "U5n[RnURRU5 O [ Rn[ Rn/n[ R"S[U55n[U5H@upUR[ R"SU R555 USXx'MB [S[R U[U5UUU5UlSUlOXlSUlSUlSUl[+5Ulg)NFchar*[]char[]zclingo_control_t *Tg)_free_memr|rr r new_handlerpyclingo_logger_callbackr{NULLrrrencoderclingo_control_newr_handlerr%_statistics_callr_error) rErrrc_handlec_cbc_memrlroargs r;rJControl.__init__s  i . .!??6244   *99yyEXXiY8F#I. TXXh =>!"I / $''IDIDJ!I  $h r:chUR(a![R"UR5 ggr@)rrclingo_control_freerrEs r;__del__Control.__del__s ::  $ $TYY / r:r^ parametersprogramreturncg)a$ Extend the logic program with the given non-ground logic program in string form. Parameters ---------- name The name of program block to add. parameters The parameters of the program block to add. program The non-ground program in string form. See Also -------- Control.ground Nr-)rEr^rrs r;add Control.addr:cg)z Extend the logic program with the given non-ground logic program in string form. Parameters ---------- name The name of program block to add. Notes ----- This function is equivalent to calling `add("base", [], program)`. Nr-rErs r;rrrr:c[U5[U5-nUS:XaUR"U0UD6 gUR"U0UD6 g)a Extend the logic program with the given non-ground logic program in string form. This function provides two overloads: ```python def add(self, name: str, parameters: Sequence[str], program: str) -> None: ... def add(self, program: str) -> None: return self.add("base", [], program) ``` Parameters ---------- name The name of program block to add. parameters The parameters of the program block to add. program The non-ground program in string form. See Also -------- Control.ground rN)r_add1_add2)rErkwargsns r;rr!s?6 IF # 6 JJ ' ' JJ ' 'r:c*URS/U5 g)Nbase)rrs r;r Control._add1Bs 62w'r:c /n[R"S[U55n[U5H@upgUR [R"SUR 555 USXV'MB [ [R"URUR 5U[U5UR 555 g)Nrrr) rrrrr{rrrclingo_control_addr)rEr^rrrc_paramsroparams r;r Control._add2Es88Is:7!*-HA LL(ELLN; <)HK.   # # 4;;=(C OW^^EU  r:litcp[U[5(aU$URUnUcS$UR$)Nr)r|resymbolic_atomsliteral)rErsatoms r; _program_atomControl._program_atomQs7 c3  J##C(Mq4u}}4r:cV[[R"UR55 g)z Remove all minimize constraints from the program. This function removes all minimize constraints that were previously added to the program. N)rrclingo_control_remove_minimizerrs r;remove_minimizeControl.remove_minimizeWs d99$))DEr:atomsr{c [R"S[U55n[U5HupEUR U5X4'M [ [ R"URU[U5U55 g)Nzclingo_atom_t[]) rrrrrrrclingo_control_update_projectr)rErr{p_projrors r;_update_projectControl._update_project_sb+SZ8&FA**3/FI'   . .tyy&#e*f U r:c$URUSS9 g)a0 Add atoms to project on to the program. Parameters ---------- atoms List of atoms or program literals (see `clingo.symbolic_atoms.SymbolicAtom.literal`) to project on. Notes ----- The function extends the set of atoms to project on with the given atoms. See Also -------- Control.replace_project Tr{NrrErs r; add_projectControl.add_projectjs" U40r:c$URUSS9 g)aJ Set atoms to project on. Parameters ---------- atoms List of atoms or program literals (see `clingo.symbolic_atoms.SymbolicAtom.literal`) to project on. Notes ----- The function sets the atoms to project on to the given atoms thereby replacing any previously added project statements. See Also -------- Control.add_project FrNrrs r;replace_projectControl.replace_project}s$ U51r:c$UR/SS9 g)zE Remove all projection atoms. See Also -------- Control.add_project FrNrrs r;remove_projectControl.remove_projects R.r:externaltruthcUc[RnO(U(a[RnO[Rn[ [R "UR URU5U55 g)a> Assign a truth value to an external atom. Parameters ---------- external A symbol or program literal representing the external atom. truth A Boolean fixes the external to the respective truth value; and None leaves its truth value open. See Also -------- Control.release_external, clingo.solving.SolveControl.symbolic_atoms, clingo.symbolic_atoms.SymbolicAtom.is_external Notes ----- The truth value of an external atom can be changed before each solve call. An atom is treated as external if it has been declared using an `#external` directive, and has not been released by calling `Control.release_external` or defined in a logic program with some rule. If the given atom is not external, then the function has no effect. For convenience, the truth assigned to atoms over negative program literals is inverted. N)rclingo_external_type_freeclingo_external_type_trueclingo_external_type_falserclingo_control_assign_externalrr)rErrvals r;assign_externalControl.assign_externalsZ@ =00C 00C11C  / / 4--h7  r:ct[[S[RUR5UR 5$)zy Returns a `Backend` object providing a low level interface to extend a logic program. See Also -------- clingo.backend zclingo_backend_t*)rrrclingo_control_backendrrrs r;backendControl.backends/ ')D)Ddii P KK  r:cV[[R"UR55 g)a; Cleanup the domain used for grounding by incorporating information from the solver. This function cleans up the domain used for grounding. This is done by first simplifying the current program representation (falsifying released external atoms). Afterwards, the top-level implications are used to either remove atoms from the domain or mark them as facts. See Also -------- Control.enable_cleanup Notes ----- Any atoms falsified are completely removed from the logic program. Hence, a definition for such an atom in a successive step introduces a fresh atom. With the current implementation, the function only has an effect if called after solving and before any function is called that starts a new step. Typically, it is not necessary to call this function manually because automatic cleanups are enabled by default. N)rrclingo_control_cleanuprrs r;cleanupControl.cleanups6 d11$))<=r:c [S[RURUR 55(dg[ [S[R URUR 555$)z Return the symbol for a constant definition of form: #const name = symbol. Parameters ---------- name The name of the constant to retrieve. Returns ------- The function returns `None` if no matching constant definition exists. rMNclingo_symbol_t)rrclingo_control_has_constrrr&clingo_control_get_const)rEr^s r; get_constControl.get_constsYvt<)FK LL"5s47|D E!"IFM#DG,#&88 a -d1g,FK0   & &tyy'3u:t T  r:cD[R"UR5 g)a! Interrupt the active solve call. Notes ----- This function is thread-safe and can be called from a signal handler. If no search is active, the subsequent call to `Control.solve` is interrupted. The result of the `Control.solve` method can be used to query if the search was interrupted. N)rclingo_control_interruptrrs r; interruptControl.interrupt:s %%dii0r:pathct[[R"URUR 555 g)z Extend the logic program with a (non-ground) logic program in a file. Parameters ---------- path The path of the file to load. N)rrclingo_control_loadrr)rErs r;load Control.loadGs# d..tyy$++-HIr:filesc N/n[R"S[U55n[U5H@upEUR [R"SUR 555 USX4'MB [ [R"URU[U555 g)a Extend the logic program with a program in aspif format. This function should be called on an empty control object. If more than one file is given, they are merged into one file. Only the first one should have a preamble. Parameters ---------- files A list of files to load. rrrN) rrrrr{rrrclingo_control_load_aspifr)rEr rc_filesrors r; load_aspifControl.load_aspifRsw((9c%j1 'GA LL(DKKM: ;rGJ( d44TYYUTUr:Fobserverreplacec[R"S[[US5(a[R O[R [[US5(a[RO[R [[US5(a[RO[R [[US5(a[RO[R [[US5(a[RO[R [[US5(a[RO[R [[US5(a[RO[R [[US 5(a[RO[R [[US 5(a[RO[R [[US 5(a[RO[R [[US 5(a[R O[R [[US 5(a[R"O[R [[US5(a[R$O[R [[US5(a[R&O[R [[US5(a[R(O[R [[US5(a[R*O[R [[US5(a[R,O[R [[US5(a[R.O[R [[US5(a[R0O[R 45n[R2"[5XR655nUR8R;U5 [=[R>"UR@X2U55 g)aw Registers the given observer to inspect the produced grounding. Parameters ---------- observer The observer to register. See below for a description of the required interface. replace If set to true, the output is just passed to the observer and no longer to the underlying solver (or any previously registered observers). See Also -------- clingo.backend z!clingo_ground_program_observer_t* init_program begin_stepend_steprule weight_ruleminimizeproject output_atom output_termrassume heuristic acyc_edgetheory_term_numbertheory_term_stringtheory_term_compoundtheory_element theory_atomtheory_atom_with_guardN)!rrrrrpyclingo_observer_init_programrpyclingo_observer_begin_steppyclingo_observer_end_steppyclingo_observer_rulepyclingo_observer_weight_rulepyclingo_observer_minimizepyclingo_observer_projectpyclingo_observer_output_atompyclingo_observer_output_termpyclingo_observer_externalpyclingo_observer_assumepyclingo_observer_heuristicpyclingo_observer_acyc_edge$pyclingo_observer_theory_term_number$pyclingo_observer_theory_term_string&pyclingo_observer_theory_term_compound pyclingo_observer_theory_elementpyclingo_observer_theory_atom(pyclingo_observer_theory_atom_with_guardrrrrr{r clingo_control_register_observerr)rErr c_observerrs r;register_observerControl.register_observerfs$XX /$HhGG77$Hh EE55$Hh CC33$Hh??//$Hh FF66$Hh CC33$Hh BB22$Hh FF66$Hh FF66$Hh CC33$HhAA11$Hh DD44$Hh DD44$Hh8LMM==$Hh8LMM==$Hh8NOO??$Hh8HII99$Hh FF66$Hh8PQQAA}` c H;;!?@    1 1 :  r:typefile reify_sccs reify_stepscURnU(aU[R-nU(aU[R-n[ [R "UR XbR5U55 g)a Registers a backend of the given type. This function is similar to register_observer but instead registers a predefined backend. Parameters ---------- type The type of backend to register. file: The path of the file to write to. replace If set to true, the output is just passed to the backend and no longer to the underlying solver (or any previously registered backends/observers). reify_sccs Whether to reify sccs. reify_steps Whether to reify steps. See Also -------- clingo.backend N)valuerclingo_backend_type_reify_sccsclingo_backend_type_reify_stepsrclingo_control_register_backendrr)rEr?r@rrArBbitsets r;register_backendControl.register_backendsZ> dAAAF dBBBF  0 0 6;;='  r: propagatorc "[R"S[[US5(a[R O[R [[US5(a[RO[R [[US5(a[RO[R [[US5(a[RO[R [[US5(a[RO[R 45n[R"[XR55nURRU5 [![R""UR$X#S55 g) z Registers the given propagator with all solvers. Parameters ---------- propagator The propagator to register. See Also -------- clingo.propagator zclingo_propagator_t*init propagateundocheckdecideFN)rrrrrpyclingo_propagator_initrpyclingo_propagator_propagatepyclingo_propagator_undopyclingo_propagator_checkpyclingo_propagator_deciderrrrr{r"clingo_control_register_propagatorr)rErK c_propagatorrs r;register_propagatorControl.register_propagatorsxx "$J FCC11$J KHH66$J FCC11$J GDD22$J HEE331  <[[!AB    3 3 <  r:cv[[R"URUR U555 g)a Release an external atom represented by the given symbol or program literal. This function causes the corresponding atom to become permanently false if there is no definition for the atom in the program. Otherwise, the function has no effect. Parameters ---------- external The symbolic atom or program atom to release. Notes ----- If the program literal is negative, the corresponding atom is released. Examples -------- The following example shows the effect of assigning and releasing and external atom. >>> from clingo.symbol import Function >>> from clingo.control import Control >>> >>> ctl = Control() >>> ctl.add("base", [], "a. #external b.") >>> ctl.ground([("base", [])]) >>> ctl.assign_external(Function("b"), True) >>> print(ctl.solve(on_model=print)) b a SAT >>> ctl.release_external(Function("b")) >>> print(ctl.solve(on_model=print)) a SAT N)rrclingo_control_release_externalrr)rErs r;release_externalControl.release_externalBs/L   0 0 4--h7  r:r)yield_async_ assumptionsrFrGrHrIon_coreon_lastr_r`cgr@r- rErarFrGrHrIrbrcr_r`s r;solve Control.solversr:)r`Tcgr@r- rErarFrGrHrIrbr_r`s r;rfrgr:)r_cgr@r-ris r;rfrgrjr:cgr@r-)rErarFrGrHrIrbrcs r;rfrgsr:c gr@r-res r;rfrgs+.r:c (URR5 [X#XE5n [XR5n [R "U 5Ul[Rn U(aSn [R"S[U55n [U5Hcup[U[5(aXU'M U c URn URUSnUcSO URnUS(aUOU*X'Me SnU(aU[R -nU (aU[R"-n[%['S[R(UR*UU [U5[R,UR U S9 U 5nU(dmU (dfU UR/5nUb'UR0(aU"UR355 UbUR55nUbU"U5 UsSSS5 $U$!,(df  U$=f)a Starts a search. Parameters ---------- assumptions List of (atom, boolean) tuples or program literals (see `clingo.symbolic_atoms.SymbolicAtom.literal`) that serve as assumptions for the solve call, e.g., solving under assumptions `[(Function("a"), True)]` only admits answer sets that contain atom `a`. on_model Optional callback for intercepting models. A `clingo.solving.Model` object is passed to the callback. The search can be interrupted from the model callback by returning False. on_unsat Optional callback to intercept lower bounds during optimization. on_statistics Optional callback to update statistics. The step and accumulated statistics are passed as arguments. on_finish Optional callback called once search has finished. A `clingo.solving.SolveResult` also indicating whether the solve call has been interrupted is passed to the callback. on_core Optional callback called with the assumptions that made a problem unsatisfiable. on_last Optional callback for getting the last model computed for a satisfiable problem. A `clingo.solving.Model` object is passed to the callback. yield_ The resulting `clingo.solving.SolveHandle` is iterable yielding `clingo.solving.Model` objects. async_ The solve call and the method `clingo.solving.SolveHandle.resume` of the returned handle are non-blocking. Returns ------- The return value depends on the parameters. If either `yield_` or `async_` is true, then a handle is returned. Otherwise, a `clingo.solving.SolveResult` is returned. See Also -------- clingo.solving Notes ----- If neither `yield_` nor `async_` is set, the function returns a `clingo.solving.SolveResult` right away. In gringo or in clingo with lparse or text output enabled, this function just grounds and returns a `clingo.solving.SolveResult` where `clingo.solving.SolveResult.unknown` is true. If this function is used in embedded Python code, you might want to start clingo using the `--outf=3` option to disable all output from clingo. Asynchronous solving is only available in clingo with thread support enabled. Furthermore, the on_model and on_finish callbacks are called from another thread. To ensure that the methods can be called, make sure to not use any functions that block Python's GIL indefinitely. This function as well as blocking functions on the `clingo.solving.SolveHandle` release the GIL but are not thread-safe. Nzclingo_literal_t[]rrrzclingo_solve_handle_t*)rk)rrr=rrrrrrrrr|rerrrclingo_solve_mode_yieldclingo_solve_mode_asyncr!rclingo_control_solverr\get unsatisfiablecorelast)rErarFrGrHrIrbrcr_r`rkr[p_assrroratomslitmodehandlerOrNs r;rfrgs` $XRw ,-   EHH13{3CDE#K0c3''"!H} $ 3 3..s1v6D!%24<* * X    >: c hv&6 :9H+ c8F#3345+ +   + Z 1 J J JV V$V(| (| T| d| D ! ( ( (  (  (  (  ( T2 j2 T2 h* vs{);* * \ 6! FHDHBFAEAE9= &+%* !%fdl(;S(@"AB x$(?@A x#(=>?   $-7=>   +)< => h '<=> hw}56 EN EN     FHDHBFAEAE ! !%fdl(;S(@"AB x$(?@A x#(=>?  $-7=>  +)< => h '<=> DM      FHDHBFAEAE ! !%fdl(;S(@"AB x$(?@A x#(=>?  $-7=>  +)< => h '<=>  DM    " FHDHBFAEAE9= !%fdl(;S(@"AB x$(?@A x#(=>?  $-7=>  +)< => h '<=> hw}56    BD@D>BRV=A=A59 .eE&$,$7$<=> .8UGXd^$;<= .8Xc]OT$9:; .  -)G)M NO . Hk]D%89: .(HSM?D#89: .(E7D=12 . . . {K' ( . .BD@D>BRV=A=A59BeE&$,$7$<=>B8UGXd^$;<=B8Xc]OT$9:; B  -)G)M NO B Hk]D%89: B(HSM?D#89:B(E7D=12BBB {K' (BH(}((AAA PDPTPPPtPP,#)) 4 D *  = = =',D',',R   )hz2))r:)9r2ry collectionsrenumrtypingrrrrr r r r r rr _internalrrrrrrrrrrrrrrtrrKrsolvingr r!r"rr#r$r%symbolr&rr'rr(__all__r*r= def_externrqrr)r-r:r;rs(T    v   '("44GG)$ m $'&VV6 f %,K0*629STUBQ)Q)r: