j<ddlmZddlmZddlmZGddZy))Callable)ClassVar)c_astc : eZdZUdZeed<eed<ddeddfdZdefdZ d e jdefd Z d e jdzdefd Z d e jdefd Zd e j defdZdee j&defdZd e j*defdZd e j&defdZd e j0defdZd e j4defdZd e j8defdZd e j<defdZd e j@defdZ!d e jDdefdZ#d e jHdefdZ%d e jLdefdZ'd e jPdefdZ)d e jTdefdZ+idddd d!d"d#d$d%d&d'd(d)d(d*d+d,d+d-d+d.d+d/d0d1d0d2d3d4d3d5d6d7d6d8d6iZ,e-e.eefed9<d e j^defd:Z0d e jbdefd;Z2d e jfdefd<Z4d e jjdefd=Z6d e jndefd>Z8d e jrdefd?Z:dd@d e jdAedefdBZ;dd e jxdCedefdDZ=d e j|defdEZ?d e jde je jze jzdzfdFZCdGe jdHe jdefdIZDdJee jdee jee jzfdKZEdJee jdefdLZFd e jdefdMZHd e jdefdNZJd e jdefdOZLd e jdefdPZNd e jdefdQZOd e jdefdRZQd e jdefdSZSd e jdefdTZUd e jdefdUZWd e jdefdVZYd e jdefdWZ[d e jdefdXZ]d e jdefdYZ_d e jdefdZZad e jdefd[Zcd e jdefd\Zed e jdefd]Zgd e jdefd^Zid e jdefd_Zkd e jdefd`Zmd e jdefdaZod e jdefdbZqd e jdefdcZsd e jdefddZud e jdefdeZwd e jdefdfZyd e jdefdgZ{d e jdefdhZ}d e jdefdiZ~d e jdefdjZd e jdefdkZd e jdefdlZd e jdefdmZd e j defdnZd e jdefdoZd e jdefdpZd e jdefdqZd e je jze jzdredefdsZddJee jdtedefduZdvee je j<zdefdwZdd e jdtedefdxZd e jxdefdyZd e jdefdzZ dd e jd{ee jdzd|ed}edef d~Zd e jdee jgefdefdZd e jdefdZd e jdefdZy) CGeneratorzUses the same visitor pattern as c_ast.NodeVisitor, but modified to return a value from each visit method, using string accumulation in generic_visit. indent_levelreduce_parenthesesFreturnNc d|_||_y)zConstructs C-code generator reduce_parentheses: if True, eliminates needless parentheses on binary operators rN)r r )selfr s b/home/oem/CyberBrain26-unified/dev-env/.venv/lib/python3.12/site-packages/pycparser/c_generator.py__init__zCGenerator.__init__s"4c d|jzSN )r )r s r _make_indentzCGenerator._make_indent#sT&&&&rnodecnd|jjz}t|||j|S)Nvisit_) __class____name__getattr generic_visit)r rmethods rvisitzCGenerator.visit&s2DNN3338wtVT%7%78>>rcZ|ydjfd|jDS)Nc3FK|]\}}j|ywNr).0c_namecr s r z+CGenerator.generic_visit...sJYVQ4::a=Js!)joinchildren)r rs` rrzCGenerator.generic_visit*s& <77J$--/JJ Jrnc|jSr!)valuer r)s rvisit_ConstantzCGenerator.visit_Constant0s wwrc|jSr!namer,s rvisit_IDzCGenerator.visit_ID3s vv r attributesc8djfd|DS)Nrc3@K|]}j|ywr!r")r# attributer s rr&z2CGenerator._generate_attributes..7sJ) 9-J)r')r r2s` r_generate_attributeszCGenerator._generate_attributes6sxxJzJJJrc|j|jdznd|jz}|j|d|jzdzz }|S)Nz::r()) namespacer0 argumentsr r)ss rvisit_AttributezCGenerator.visit_Attribute9sK#$;;#:Q[[4 aff L ;; " q{{"S( (ArcXddjfd|jDzdzS)Nz[[, c3@K|]}j|ywr!r"r#ar s rr&z6CGenerator.visit_AttributeSpecifier..@sD! 1 Dr6z]])r'r2r,s` rvisit_AttributeSpecifierz#CGenerator.visit_AttributeSpecifier?s&diiDq||DDDtKKrc8|j|jSr!)r7r2r,s rvisit_AttributeDeclarationz%CGenerator.visit_AttributeDeclarationBs((66rcv|j|jdz|j|jzSr)rtyper7r2r,s rvisit_AttributedTypezCGenerator.visit_AttributedTypeEs.zz!&&!C'$*C*CALL*QQQrc|j|jdz|j|jj zSr)r7r2_generate_stmtstmtlstripr,s rvisit_AttributedStatementz$CGenerator.visit_AttributedStatementHsA  % %all 3 !!!&&)002 3 rct|jtjr!d|j |jzdzSd}|jr|d|jzz }|S)Nz_Pragma(r:z#pragmar) isinstancestringrConstantr)r r)rets r visit_PragmazCGenerator.visit_PragmaOsT ahh / 188 44s: : 88 3> !C rc|j|j}|dz|j|jdzdzS)N[T allow_comma])_parenthesize_unless_simpler0 _visit_expr subscript)r r)arrrefs rvisit_ArrayRefzCGenerator.visit_ArrayRefWs?11!&&9|d..q{{.MMPSSSrc|j|j}||jz|j|jzSr!)r[r0rIrfield)r r)srefs rvisit_StructRefzCGenerator.visit_StructRef[s6//7aff}tzz!''222rc|j|j}|j|j|jnd}|dz|zdzS)Nrr9r:)r[r0argsr)r r)frefres rvisit_FuncCallzCGenerator.visit_FuncCall_sG//7%&VV%7tzz!&&!RczD 3&&rcj|j}djfd|jD}d|d|dS)NrAc3@K|]}j|ywr!r"rCs rr&z4CGenerator.visit_GenericSelection..is G1A Gr6z _Generic(r:)r\exprr' associations)r r)rjrks` rvisit_GenericSelectionz!CGenerator.visit_GenericSelectionesF'yy G GG 4&<.22rc|j|j|jnd}|d|j|jS)Ndefaultz: )rIrr\rjr r)typs rvisit_GenericAssociationz#CGenerator.visit_GenericAssociationls@$%FF$6djj Ib))!&&1233rcR|jxdk(r"d|j|jddSxdk(r!|j|j}|dSdk(r |j|j}|d S |j|j}|j|S) Nsizeofzsizeof(TrXr:zp++z++zp--z--)opr\rjr[)r r)operands r visit_UnaryOpzCGenerator.visit_UnaryOppsdd!!1!1!&&d!1!K LANN::166B!"~%::166B!"~%::166B$$y))rz||rz&&r|^&z==z!=>z>=>z<<+-* /%precedence_mapcjjfd}jjfd}|djd|S)Ncj|xsyjxrkt|tjxsOt|tj xr3j |jj jk\ Sr!_is_simple_noder rQrUnaryOpBinaryOprrtdr)r s rz+CGenerator.visit_BinaryOp..s|((+.."1emm4S%a8S //59L9LQTT9RR rcj|xsyjxrkt|tjxsOt|tj xr3j |jj jkD Sr!rrs rrz+CGenerator.visit_BinaryOp..s|((+.."1emm4R%a8R //58K8KADD8QQ rr)_parenthesize_ifleftrightrt)r r)lval_strrval_strs`` rvisit_BinaryOpzCGenerator.visit_BinaryOps\(( FF   *(( GG   1QTTF!H:..rc|j|jd}|j|jd|jd|S)Nc6t|tjSr!)rQr Assignment)r)s rrz-CGenerator.visit_Assignment..s 1e.>.> ?rr)rrvaluer\lvaluert)r r)rs rvisit_AssignmentzCGenerator.visit_AssignmentsI(( HH? ""188,-QqttfAhZ@@rc8dj|jSr)r'namesr,s rvisit_IdentifierTypezCGenerator.visit_IdentifierTypesxx  rcy)Nrr,s rvisit_InferredTypezCGenerator.visit_InferredTypesrcX|jd|j|jdS)Nr9r:)rtr\rjr,s r visit_TypeOfzCGenerator.visit_TypeOfs)$$q))!&&12!44rc~|jr|jdznd}|d|j|jdS)Nrrz_BitInt(r:) signednessr\width)r r)signs rvisit_BitIntTypezCGenerator.visit_BitIntTypes;%&\\q||c!rx 0 0 9:!<s r visit_DeclzCGenerator.visit_Decls    u  =$$Q' 99 ))!))44 4A 66 ))!&&11 1Arc|j|jd}|jddD]^}t|tjr)|d|j z|j|zz }F|d|j |dzz }`t|jdtjr|d|j zz }|S)Nrr rAT)r)rdeclsrQrPragmarr)r r)r>decls rvisit_DeclListzCGenerator.visit_DeclLists JJqwwqz "GGABK @D$ -TD--//$**T2BBBTDOOD$O???  @ aggbk5<< 0 ))++ +Arct|tjtjfsy|j}t|tj tj tjtjtjfrd|j}t|tj tj tjtjtjfrdt|tjtjfr|j|St|tjr|j|Sy)aReturn the struct, union, or enum body this declarator defines. ``union { struct a b; } u, *uu`` both return that same union node. ``struct Foo x`` has no body, so it returns None. Callers compare the result with ``is``: two anonymous structs that only look alike are different nodes. Attribute wrappers are skipped too, since each declarator can have its own wrapper around the shared body. N)rQrDeclTypedefrIPtrDecl ArrayDeclFuncDeclTypeDeclAttributedTypeStructUnionrEnumvaluesros r _defined_typezCGenerator._defined_types!ejj%--89ff  $$    ((C  $$     cELL%++6 7CIIt|t|uryt|tjrt|tjrj|j|jk(xrO|j |j k(xr4|j |j k(xr|j|jk(St|tjrNt|tjr4|j|jk(xr|j |j k(Sy)aXReturn whether two declarators have the same specifiers. ``static struct { int a; } x, y`` matches: both names are ``static``. ``static struct { int a; } x`` followed by ``struct { int a; } y`` does not, because only ``x`` is ``static``. Qualifiers, alignment, and function specifiers are compared too. F) rIrQrrqualsalignstoragefuncspecr)r rrs r_same_decl_specszCGenerator._same_decl_specs's :T%[ ( dEJJ 'Juejj,I ekk)4JJ%++-4LLEMM14MMU^^3   dEMM *z%/O::,N1N Nrnodescg}d}|t|kr||}|j|}||j||dz }=|dz}|t|krU|j|||r@|j|||urn)|dz }|t|kr|j|||r@||dzk(r|j|n|jt ||||}|t|kr|S)aGroup consecutive declarators that share one type definition. ``union { struct a b; } u, *uu = &u`` is one group: both names point at that union and their specifiers match. ``struct { int a; } x; struct { int a; } y;`` stays two items, because those are different definition nodes. One name on its own, or a name whose specifiers differ from the next, is left alone. rr)lenrappendrlist)r rgroupedindexrdefinedends r_coalesce_defined_typesz"CGenerator._coalesce_defined_types<s8:c%j \\D % %all 3c 9r 99 !))$s* *A T  ((rcd|j|jdzdz}|dz|j|jzS)Nr9F emit_declnamer:r)rto_typer[rjr=s r visit_CastzCGenerator.visit_CastzsC $%%aiiu%E E K3w99!&&AAArcg}|jD]"}|j|j|$dj|SNrAexprsrr\r'r r)visited_subexprsrjs rvisit_ExprListzCGenerator.visit_ExprList~DGG .sM!t2215Mr6r)rrr body param_declsr')r r)rrknrdeclss` r visit_FuncDefzCGenerator.visit_FuncDefs{zz!&&!zz!&&! ==wwMq}}MMH$;)D047 7$;%, ,rcd}|j|jD]}t|tr||j |dzz }+|xt j dx\||j|z }Xt jdx\||j|dzz } ||j|dzz }|S)Nr; rr) rextrQrrrFuncDefrr)r r)r>r s r visit_FileASTzCGenerator.visit_FileASTs //6 1C#t$T++C0588$U]]_C(A%\\^C4//A$C500A 1rc|jdz}|xjdz c_|jr||j|jz }|xjdzc_||jdzz }|S)N{ rxz} )rr block_items_generate_bodyr=s rvisit_CompoundzCGenerator.visit_Compoundst    % ' Q == $$Q]]3 3A Q T   5 ((rc|jrdj|jdznd}d|z|j|jzdz|j|jzdzS)Nrrr9z){r)rr'rrIr)r r)rs rvisit_CompoundLiteralz CGenerator.visit_CompoundLiteralsZ/0yy#((199%+bW}tzz!&&11D84::aff;MMPSSSrcy)N;rr,s rvisit_EmptyStatementzCGenerator.visit_EmptyStatementsrcLdjfd|jDS)NrAc3@K|]}j|ywr!r")r#paramr s rr&z-CGenerator.visit_ParamList..sAuE*Ar6)r'paramsr,s` rvisit_ParamListzCGenerator.visit_ParamListsyyAAAArcnd}|jr#|d|j|jdzz }|dzS)Nr rTrXr)rjr\r=s r visit_ReturnzCGenerator.visit_Returns:  66 t''D'AA AA3wrcy)Nzbreak;rr,s r visit_BreakzCGenerator.visit_Breaksrcy)Nz continue;rr,s rvisit_ContinuezCGenerator.visit_Continuesrcd|j|jzdz}|d|j|jzdzz }|d|j|jzdzz }|S)Nr9z) ? z) : r:)r\condiftrueiffalser=s rvisit_TernaryOpzCGenerator.visit_TernaryOpsk $""166* *V 3 S4##AHH- - 66 S4##AII. . 44rc0d}|jr ||j|jdz }|dz }||j|jdz }|jr6||j dzz }||j|jdz }|S)Nzif (TrX)  add_indentzelse )r&r\rLr'r(rr=s rvisit_IfzCGenerator.visit_Ifs  66 !!!&&d!; ;A U  T d ;; 99 ""$x/ /A $$QYY4$@ @Arc|d}|jr ||j|jdz }|dz }|jr#|d|j|jdzz }|dz }|jr#|d|j|jdzz }|dz }||j |j dz }|S)Nzfor (TrXrrr+r,)rr\r&nextrLrMr=s r visit_ForzCGenerator.visit_Fors  66 !!!&&d!; ;A S 66 t''D'AA AA S 66 t''D'AA AA U  T D 99rcd}|jr ||j|jdz }|dz }||j|jdz }|S)Nwhile (TrXr+r,)r&r\rLrMr=s r visit_WhilezCGenerator.visit_WhilesX  66 !!!&&d!; ;A U  T D 99rcd}||j|jdz }||jdzz }|jr ||j |jdz }|dz }|S)Nzdo Tr,r3rXz);)rLrMrr&r\r=s r visit_DoWhilezCGenerator.visit_DoWhilesp  T D 99 T   9 ,, 66 !!!&&d!; ;A T rcd}||j|jz }|jr#|dz }||j|jz }|dz }|S)Nz_Static_assert(rAr:)r\r&messagerr=s rvisit_StaticAssertzCGenerator.visit_StaticAssertsU  T  aff %% 99 IA AII& &A Srcd|j|jdzdz}||j|jdz }|S)Nzswitch (TrXr+r,)r\r&rLrMr=s r visit_SwitchzCGenerator.visit_Switch sH ))!&&d)C Ce K T D 99rc|jr|j|jdznd}|d|j|jzdzz }||j |j xsgdzS)Nrrzcase : Tr,)r2r7r\rjrstmtsr=s r visit_CasezCGenerator.visit_Casesi=>\\D % %all 3c 9r Wt''/ /% 774&&qww}"&FFFrc|jr|j|jdznd}|dz }||j|jxsgdzS)Nrrz default: Tr,)r2r7rr>r=s r visit_DefaultzCGenerator.visit_DefaultsP=>\\D % %all 3c 9r \4&&qww}"&FFFrc|jr|j|jdznd}||jzdz|j|jzS)Nrrr=)r2r7r0rLrMr=s r visit_LabelzCGenerator.visit_LabelsJ=>\\D % %all 3c 9r166zE!D$7$7$???rc&d|jzdzS)Nzgoto rr/r,s r visit_GotozCGenerator.visit_Gotos#%%rcy)Nz...rr,s rvisit_EllipsisParamzCGenerator.visit_EllipsisParam src&|j|dS)Nstructrr,s r visit_StructzCGenerator.visit_Struct#s//8<\\D % %all 3c 9r4&&qvv...rc&|j|dS)Nunionrr,s r visit_UnionzCGenerator.visit_Union*s//7;;rcDd|j|jzdzS)NrWrZ)r\rjr,s rvisit_ArrayDesignatorz CGenerator.visit_ArrayDesignator-s!T%%aff--33rcd}|jD]C}t|tjr|d|jzz }0||j |z }E|d|j |j zz }|S)Nr.r)r0rQrIDrr\rj)r r)r>r0s rvisit_NamedInitializerz!CGenerator.visit_NamedInitializer0sr FF &D$)S499_$TZZ%%  & UT%%aff- --rc$|j|Sr!rr,s rvisit_FuncDeclzCGenerator.visit_FuncDecl:s""1%%rc(|j|dSNFrrWr,s rvisit_ArrayDeclzCGenerator.visit_ArrayDecl=""1E"::rc(|j|dSrZrWr,s rvisit_TypeDeclzCGenerator.visit_TypeDecl@r\rc(|j|dSrZrWr,s r visit_PtrDeclzCGenerator.visit_PtrDeclCr\rr0cF|dvrEt|tjtjfsJ|j}|j }nS|dk(sJt|tj sJ|jdn|jj}|j}|jr|j|jdznd}|dz|z|jxsdz}t|tj r;|j/|jdz|j|jz}|h|dz }||j!z }|xj"dz c_|d z }|||z }|xj"dzc_||j!d zz }|S) zlGenerates code for structs, unions, and enums. name should be 'struct', 'union', or 'enum'. )rIrNrNrrrrrxrr)rQrrrrrrr enumerators_generate_enum_bodyr2r7r0underlying_typerstriprrr )r r)r0members body_functionr2r>s rrz&CGenerator._generate_struct_union_enumFs| & &a%,, !<= ==ggG //M6> !>a, ,,hh.dAHH4H4HG 44M=>\\D % %all 3c 9r  3J #qvv| 4 a $):):)F U"TZZ0A0A%BBA   IA ""$ $A    "  JA w' 'A    "  ""$s* *Arr-c4|j}|r|dz }g}|j|D][}t|tr'|j ||j |zdz:|j |j ||]dj|S)zEmit statements or members, grouping shared type definitions. Callers handle braces and indentation levels; _generate_stmt supplies the punctuation for individual statements, declarations, and pragmas. z r r,r)rrrQrrrrLr')r rr-indentpartsitems rrzCGenerator._generate_bodygs ""$  dNF007 OD$% Vd&<&t |}|j|j |j|||dddz||<dj|S)Nrr)rQrrrrLrrr')r rfrjlast_enumeratormembers rrczCGenerator._generate_enum_bodyxs 1F&%,,/ T0089"%e* TZZ/0  1  &%*?%;CR%@4%GE/ "wwu~rc"|r|xjdz c_|j}|r|xjdzc_|xxtjdx\nxtjdx\noxtj dx\nVxtj dx\n=xtjdx\n$xtjdx\n xtjdx\nxtjdx\nxtjdx\nxtjdx\nxtjdx\nxtjdx\n{xtjdx\ncxtj dx\nKxtj"dx\n3xtj$dx\nxtj&dx\nn||j)|zdzSxtj*dx\|j)|Sxtj,dx\||j)|zStj.dx\||j)|zS ||j)|zdzS)zGeneration from a statement node. This method exists as a wrapper for individual visit_* methods to handle different treatment of some statements in this context. rxrr r)r rrrrCastrr TernaryOpFuncCallArrayRef StructRefrSrTrrCompoundLiteralGenericSelection StaticAssertAttributeDeclarationrrAttributedStatementIf)r r)r-ris rrLzCGenerator._generate_stmts     " ""$     " /  $%""$$%**,,!%--//"%..""#%//##"%..""%.."#%//#"%.."%((*!%--/"%..")%'')*%((*&%$$&.%,,.!/( 1 -55!! zz!}$ " -**, 1 --- 1 -- 1 -44rc|jrj|jdznd}|jr!|dj|jdzz }|jr!|dj|jdzz }|j r*|djfd|j Ddzz }t |jtjtjtjtjfr |j|jz }|S|jr!|dj|jdzz }|j|jz }|S)zGeneration from a Decl node.rrc3@K|]}j|ywr!r")r#rr s rr&z,CGenerator._generate_decl..sA$**U+Ar6)r2r7rr'rrrQrIrrrrrrr_generate_type_specifierr=s` rrzCGenerator._generate_decls"=>\\D % %all 3c 9r :: !**%+ +A 99 !))$s* *A 77 AAACG GA  FFU^^U]]EOOU^^T  $$QVV, ,AwwSXXagg&,, ..qvv6 6Arcft|tjrH|j|jj dz|j |jzSt|tjr%d|jvrd|j|zdzS|j|S)Nr_Atomicz_Atomic(r:) rQrrr~rIrer7r2Typenamerrrr,s rr~z#CGenerator._generate_type_specifiers a-- .--aff5<<>++ALL9:  a (Y!''-A 1 -3 3""1%%r modifiersrrc|g}|xtjdx\d}|rK|jr!|dj|jdzz }||j |j z }|j r|r |j nd}|jr!|d|j|jzz }t|D] \}}|xtjdx\|dk7r(t||dz tjrd|zdz}|dz }|jr!|dj|jdzz }|j||j|jz }|d z }|js|d|j|jzz }xtj dx\|dk7r(t||dz tjrd|zdz}|j"|j |j"nd} |d| zdzz }|jsc|d|j|jzz }tjdx\d } |jr!| d|j|jzz } |jr!| ddj|jzz } |r|js |jrdnd} | | z|z} #|s|S|r|j%}||rdnd|zz }|Sxtj&dx\|j)|j Sxtj*dxP\|jr|j|jdznd} | |j-|j || zSxtj.dx!\dj|j0dzSxtjdx\n3xtjdx\nxtj dx\nn$|j-|j ||gz|| S |j |S) a|Recursive generation from a type node. n is the type node. modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers encountered on the way down to a TypeDecl, to allow proper generation from it. emit_base_type controls whether the shared type specifier and its qualifiers are emitted, independently of the declarator parts. rrrrrr9r:rWrZr)rr)rrrr'rrIdeclnamer2r7 enumeraterrQr dim_qualsdimr\rrererrrrIdentifierTyper) r r)rrrr>nstrimodifierreprefix separators rrzCGenerator._generate_types  I!!!wwSXXagg.44AFF++A%&ZZMqzzr<<C$";";ALL"IIID $-Y#7)=KAx".U__. Av*Yq1u5Eu}}*U'*TzC'7 CKD'11 $1C1C(Ds(J J'||7 $(8(8(F F CKD'22 $d.G.G$,$7$7/")"!"/.U^^- Av*Yq1u5Eu}}*U'*TzC'7$,==#<!% 8== 9%'! !C$J$44D'22 $d.G.G$,$7$7/")"!".#]]_%(F'22 &#0I0I$,$7$71"+"!" (~~ &#0H*H H$(X-@-@HNN!$%'& $*I#5#s rrzCGenerator._parenthesize_ifDs.   Q  Q<7S= Hrc.j|fdS)z$Common use case for _parenthesize_ifc(j| Sr!)r)rr s rrz8CGenerator._parenthesize_unless_simple..Rsd6J6J16M2Mr)rr,s` rr[z&CGenerator._parenthesize_unless_simplePs$$Q(MNNrc t|tjtjtjtj tj tjfS)zyReturns True for nodes that are "simple" - i.e. nodes that always have higher precedence than operators. )rQrrSrTrtrursrwr,s rrzCGenerator._is_simple_nodeTsE &&    r)F)NTT)r __module__ __qualname____doc__int__annotations__boolrstrrrNoderrrSr-rTr1rAttributeSpecifierr7 Attributer?rEryrGrrJrzrOrrUrtr_rurcrsrgrwrlGenericAssociationrqrrvrrdictrrrrrr InferredTyperTypeOfr BitIntTyperr\rrrrrrrrrrrrrrqrrrrrrAlignasr Enumeratorrrr FileASTrrrrvrEmptyStatementr ParamListrReturnr Breakr"Continuer$rrr)r{r.Forr1Whiler4DoWhiler6rxr9Switchr;Caser?DefaultrALabelrCGotorE EllipsisParamrGrJrrLrOArrayDesignatorrQNamedInitializerrUrrXrr[rr^rr`rrrcrLrr~rrrr[rrrrrrsp   54 5D 5'c'?%**??K%**t"3KK 3%((sKtE4L4L/MKRUKS L%*B*BLsL7E,F,F737Re&:&:RsR 5+D+D  ellsTT3T33S3''3' 3(>(>3334%*B*B4s4*u}}**"0 a0 a 0 Q 0 Q 0 Q0 a0 a0 Q0 a0 Q0 a0 a0 a0 Q!0" Q#0$ Q%0& Q'0( Q)0NHT#s(^,.././3./`A%"2"2AsA !e&:&:!s!E$6$635ell5s5=%"2"2=s=AF%UZZ%%#%" EJJ  #   3   #ejj 04 7>UZZ t*%**% ejj4 ++ ,B1tEJJ'71C1,u}}BEJJB3B++3+ ++3+ @EJJ@3@(>3&&3&;;S;;;3;;u}};; +ejj8@C BD$4$SV"E,,u||;< "-5 -5-5-5^ s* &%** & & .2"# h% ::h% #d*h% h%  h% h%T  (0%**t1C(D   OUZZOCO   rrN)collections.abcrtypingrrrrrrrrs%S  S  r