+ jiN^RIHt^RIt^RIt^RIt^RIHtHt^RIH t ^RI H t ^RI H t HtHt]'d^RIHt^RIHt^R IHt^R IHt!R R 4t!R R4t!RR]]R7t!RR]4t!RR]4t!RR4tRRltRRlt]!4R#)) annotationsN)Any TYPE_CHECKING)config)is_function_or_wrapper)SourceLocationVariableTrackerVariableTrackerMeta)Callable)Self)InstructionTranslatorBaseSymNodeVariablec2]tRt^tRtRRltRRltRtR#) LazyCachez+Container to cache the real VariableTrackerc$V^8dQhRRRRRR/#)valuersourcereturnNone)formats"]/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/_dynamo/variables/lazy.py __annotate__LazyCache.__annotate__s! / /c /3 /4 /c \V\4'gV'g \R4hWnW nRVnRVnRVnR#)z9source is required for non-LazySymNodeFormatString valuesN) isinstanceLazySymNodeFormatStringAssertionErrorrr name_hintsource_locationvt)selfrrs&&&r__init__LazyCache.__init__sE%!899$O  %)6:*.rcV^8dQhRR/#rrrr)rs"rrr$s!!!rc vVPe \R4h^RIHp^RIHpVP 4p\VP\4'd,VPPW0P4VnM2VPW0PRR7!VP4VnVPe&VPPVP4VP e>VPP f&VPP#VP 4V=V= V=V=R#)Nz0LazyCache.realize() called but vt is already setInstructionTranslator)builderFallow_lazy_constant)r$r!symbolic_convertr,r- current_txrrr SourcelessBuildercreateVariableBuilderrr" set_name_hintr#set_source_location)r%r,r-txs& rrealizeLazyCache.realize$s 77  !ST T< " - - / djj"9 : ://66r::FDG --KKU.jjDG >> % GG ! !$.. 1    +0G0G0O GG ' '(<(< = J K N  r)r"rr#rr$N__name__ __module__ __qualname____firstlineno____doc__r&r9__static_attributes__rrrrrs5 /!!rrc2]tRt^BtRtRRltRRltRtR#)ComputedLazyCachezILike LazyCache, but for sourceless constants computed from lazy operands.c 0V^8dQhRRRRRRRRR R R R /#) rrr lazy_varszlist[LazyConstantVariable]argslist[VariableTracker]opCallable[..., Any] num_nodesintrrr)rs"rrComputedLazyCache.__annotate__EsF///./$ /  /  / /rc lWnW nW0nW@nWPnRVnRVnRVnR#N)rrErFrHrJr"r#r$)r%rrErFrHrJs&&&&&&rr&ComputedLazyCache.__init__Es3 " "%)6:*.rcV^8dQhRR/#r)r)rs"rrrLVs>>>rc VPe \R4h^RIHp^RIHp^RIHpRpVPF'p\VP4V4'gK%RpK) V'dg^RI H pVP4pVPUu.uFqP4NK p pV!VP4P!Wy/4VnM VP#VP$4VnVP&e&VPP)VP&4VP*eBVPP*f(VPP-VP*4R#R#R#uupi)Nz8ComputedLazyCache.realize() called but vt is already setr+ConstantVariablerFT)BuiltinVariable)r$r!r0r,constantrStensorrrErr9builtinrTr2rFrH call_functionr4rr"r6r#r7) r%r,rSr any_symboliclazy_varrTr8arg realized_argss & rr9ComputedLazyCache.realizeVs 77  J  =.+ H(**,o>># '  0&113B6:ii@is[[]iM@%dgg.<> % GG ! !$.. 1    +0G0G0O GG ' '(<(< =1P +AsE7)rFrEr"rJrHr#rr$Nr;rrrrCrCBsS/">>rrCcda]tRt^ttRtRtR0]Pmt]RR/RRll4t RV3R llt R R lt R R lt RRlt RRltRRltRRltRRltRRltRRltRRltRRltR R!lt]P.t]t]R-R"R#/R$R%lll4tR&R'ltR(R)ltR*R+ltR,tV;t#).LazyVariableTrackera A structure that defers the creation of the actual VariableTracker for a given underlying value until it is accessed. The `realize` function invokes VariableTracker.build() to produce the real object. Once a LazyVariableTracker has been realized, internal bookkeeping will prevent double realization. This object should be utilized for processing containers, or objects that reference other objects where we may not want to take on creating all the VariableTrackers right away. T_cacher8Nc ,V^8dQhRRRRRRRRRR/#) rrrrr8z InstructionTranslatorBase | Noneoptionsrr r)rs"rr LazyVariableTracker.__annotate__sAWWWW - W  W  Wrc L\V4\P9d\P!W3/VB#VeVVeRV'gJVPP pVP V4pVeV#\\W4VR7pWdV&V#\\W43RV/VB#)N)rr) typeLazyConstantVariablesupported_typesr4outputvariable_tracker_cachegetr_r)rrr8rbcachecachedr$s&&$, rr4LazyVariableTracker.creates ;.>> >'..uHH H >f0II44EYYv&F! $Yu%=fMB&MI"9U#;VFVgVVrc$V^8dQhRRRRRR/#)rr`zLazyCache | ComputedLazyCachekwargsrrrr)rs"rrrcs#<PTrc <\V\\34'g"\R\ V4P 24h\ SV`!R/VBWnR#)z>_cache must be a LazyCache or ComputedLazyCache instance, got Nr) rrrCr!rer<superr&r`r%r`ro __class__s&&,rr&LazyVariableTracker.__init__sR&9.?"@AA PQUV\Q]QfQfPgh  "6" rcV^8dQhRR/#rrr r)rs"rrrcsrc VPPf>VPP4VPPf \R4hVPP#)z.Force construction of the real VariableTrackerz"LazyCache.realize() did not set vt)r`r$r9r!r%s&rr9LazyVariableTracker.realizesH ;;>> ! KK   !{{~~%$%IJJ{{~~rc V^8dQhRRRR/#rclsrerboolr)rs"rrrcs;;4;D;rc H\PWP44#)zNCheck isinstance after realizing, used by ImplicitRealizingVariableTrackerMeta)re__instancecheck__r9)r%r|s&&rlazy_isinstance#LazyVariableTracker.lazy_isinstances%%c<<>::rcV^8dQhRR/#)rrzVariableTracker | Selfr)rs"rrrcs.rc VP4'd:VPPf \R4hVPP#V#)z4Return the real VariableTracker if it already existsz*is_realized() returned True but vt is None) is_realizedr`r$r!rxs&runwrapLazyVariableTracker.unwraps>     {{~~%$%QRR;;>> ! rcV^8dQhRR/#rrr}r)rs"rrrcs**T*rc 2VPPRJ#rN)r`r$rxs&rrLazyVariableTracker.is_realizeds{{~~T))rc V^8dQhRRRR/#)rrorrr r)rs"rrrcs>>c>o>rc *VPRVP4VPJd \R4hVPRVP4VPJdVP 4\ P !VP43/VB#)r`z8cannot clone LazyVariableTracker with a different _cacher)rjr`r!rr9r cloner)r%ros&,rrLazyVariableTracker.cloneso ::h ,DKK ? J  ::h ,DKK ? LLN$$T[[]=f==rcV^8dQhRR/#)rrz type[Any]r)rs"rrrcs''9'rc VP4'd \R4h\VPP4#)z=peek_type() called on an already realized LazyVariableTracker)rr!rer`rrxs&r peek_typeLazyVariableTracker.peek_types8      O DKK%%&&rcV^8dQhRR/#rrrr)rs"rrrcs!!C!rc pVP4'd \R4hVPP#)z>peek_value() called on an already realized LazyVariableTrackerrr!r`rrxs&r peek_valueLazyVariableTracker.peek_values3      P {{   rc V^8dQhRRRR/#)rnamestrrrr)rs"rrrcs))#)$)rc VP4'd(VPPPV4R#WPnR#rN)rr`r$r6r")r%rs&&rr6!LazyVariableTracker.set_name_hints1      KKNN ( ( .$(KK !rc V^8dQhRRRR/#)rr#rrrr)rs"rrrcs::>:d:rc WnVP4'd(VPPP V4R#WPnR#rN)r#rr`r$r7)r%r#s&&rr7'LazyVariableTracker.set_source_locations7.      KKNN . . ?*9KK 'rcV^8dQhRR/#rrrr)rs"rrrcsrc RpVP4'd'VR\VP44 R2, pV#VRVP4 R2, pV#)zLazyVariableTracker(z realized: )z unrealized: )rreprrr)r% variable_infos& r__str__LazyVariableTracker.__str__s`.      z$t{{}*=)>a@ @M |DNN,<+=Q? ?Mrc V^8dQhRRRR/#)ritemrrrr)rs"rrrcs----rc 6\VP4V4#rNgetattrr9)r%rs&&r __getattr__LazyVariableTracker.__getattr__st||~t,,rcV^8dQhRR/#rrrer)rs"rrrcs##t#rc \#)aXReturn the VariableTracker type to use for builtin handler dispatch. For regular LazyVariableTracker (not LazyConstantVariable), we return LazyVariableTracker itself so that _make_handler knows it needs to realize the arguments before calling the handler. LazyConstantVariable overrides this to return ConstantVariable since it can stay lazy. )r_rxs&rget_handler_type_for_dispatch1LazyVariableTracker.get_handler_type_for_dispatchs #"rr/Fc(V^8dQhRRRRRRRR/#)rrrrkz!dict[int, tuple[Any, Any]] | Noner/r}rr)rs"rrrcs8III1I " I Irc  aaaSf/o\V4pVS9dSV,^,#\V4p\V\4'dS;'d\ V\ \ 34pV'd\ V\ 4'dlVP4'd%SPVP4SRR7pEMVPPFpVP4K TpEMXTpEMTSPVP4SSR7pEM0\V\4'dOTpWq3SV&VPp VPp V F'p W9gK SPW,SSR7W&K) MV\ Jd%VU u.uFp SPV SSR7NK pp MV\"Jd8\";QJd.VVV3RlV4FNK 5M!VVV3RlV44pM]V\$\&P(39dA\!VP+44U U u/uFwrV SPV SSR7bK pp p MTpWq3SV&V#uup iuup p i)z@ Walk an object and realize all LazyVariableTrackers inside it. Tr.c3L<"TFpSPVSSR7xK R#5i)r.N) realize_all).0vr/rkr|s& r 2LazyVariableTracker.realize_all..6s+A5>QRRs!$)idre issubclassr_rrfComputedLazyConstantVariablerrr9r`rE_ensure_type_guardr __dict___nonvar_fieldslisttupledict collections OrderedDictitems)r|rrkr/idx value_cls keep_lazyresultrZ value_dictnonvarskeyrksf&fd rrLazyVariableTracker.realize_allsI =Ei %<:a= K i!4 5 5, ,.JK1Ie%ABB((**!$!MMOU"1" ). (>(>H$779)?!&"FMMOU@S) ? 3 3F E#JJ**G!%&)oo"DW'6'JO" $ A5>QR F% UUUF4!8!89 9!//DA3??1eAT?UU/ F F_c  's I( IcV^8dQhRR/#rr)rs"rrrcFs$rc .aRRloVP4'd \R4hVPPp\ V\ 4'd;\ ;QJdV3RlV4F 'dK R# R#!V3RlV44#S!V4#)c V^8dQhRRRR/#)rrrrr}r)rs"rr:LazyVariableTracker.is_hashable_lazy..__annotate__Js  3 4 rc\P!V4;'g-\\V4\4;'g \ V4#rN)inspect isbuiltinrrer)rs&r_helper5LazyVariableTracker.is_hashable_lazy.._helperJsA!!%(11d5k4011)%0 rz?is_hashable() called on an already realized LazyVariableTrackerc34<"TF pS!V4xK R#5irNr)rrrs& rr7LazyVariableTracker.is_hashable_lazy..Xs15awqzz5sFT)rr!r`rrrall)r%rrs& @ris_hashable_lazy$LazyVariableTracker.is_hashable_lazyFsz       Q  !! eU # #315133 13 131511 1u~rcV^8dQhRR/#rr)rs"rrrc[s!!!rc pVP4'd \R4hVPP#)zBoriginal_value() called on an already realized LazyVariableTrackerrrxs&roriginal_value"LazyVariableTracker.original_value[s3      T {{   rcV^8dQhRR/#rr)rs"rrrccs"""rc pVP4'd \R4hVPP#)zCoriginal_source() called on an already realized LazyVariableTracker)rr!r`rrxs&roriginal_source#LazyVariableTracker.original_sourcecs3      U {{!!!r)r`r#rN) r<r=r>r?r@_no_implicit_realizer r staticmethodr4r&r9rrrrrrr6r7rrrvisit__repr__ classmethodrrrrrA __classcell__rss@rr_r_ts  @!?!?@NW04 WW,;*>'!) :-#  ! !EHI %* IIV*!""rr_) metaclassca]tRtRtRt]]]]3t 0Rm] Pmt ] RRl4t RV3RlltRRltR V3R lltR V3R lltR RltRRltRRltRRltRV3RlltRtV;t#)rfimaN A lazy variable tracker for constants (int, float, bool, str) that defers guarding until the value is actually used in a way that requires it. This allows constants that are just passed through (e.g., returned without being used in control flow or math) to avoid unnecessary recompilation when their values change. Guards are installed lazily: - TYPE_MATCH guard is installed when type-based methods (python_type, is_tensor, lazy_isinstance) are called - CONSTANT_MATCH guard is installed on full realization (e.g., used in control flow or math), which subsumes any TYPE_MATCH guard c(V^8dQhRRRRRRRR/#)rrrrrbrr r)rs"rr!LazyConstantVariable.__annotate__s6XXXXX  Xrc ,^RIHp^RIHp\ V4\ P 9d#\R\ V4P R24hVf \R4hV!V4'dVP!V3RV/VB#\ \W43RV/VB#)r)is_constant_sourcerRzunsupported type z for LazyConstantVariablez0source must not be None for LazyConstantVariabler) rrrUrSrerfrgr!r<r4r)rrrbrrSs&&, rr4LazyConstantVariable.creates 0. ;2BB B #DK$8$8#99RS  > !ST T f % %#**5KK7K K#Ie$<WVWwWWrc$V^8dQhRRRRRR/#)rr`rrorrrr)rs"rrrs!//y/C/D/rc T<\SV`!V3/VBRVnRVnRVnR#)FN)rqr&_type_guard_installed_type_guard_ref _handler_typerrs&&,rr&LazyConstantVariable.__init__s- *6*%*"$(*.rcV^8dQhRR/#r)r)rs"rrrs % %D %rc VP'gVP4'dR#^RIHpHpVP f \ R4hVP PVP4pV!V4RVnW0n R#)zCInstall TYPE_MATCH guard if not already installed and not realized.N GuardBuilder install_guardz2source must not be None when installing type guardT) rrguardsrrrr! make_guard TYPE_MATCHr)r%rrguards& rr'LazyConstantVariable._ensure_type_guardsh  % % %)9)9);); 8 ;;  !UV V &&|'>'>?e%)"$rcV^8dQhRR/#rvr)rs"rrrsrc <VP4'd\SV` 4#^RIHp^RIHpHp^RIH pVPf \R4h\SV` 4p\WT4'dVPeQVP4pVPP P"P%VP4RVn V!VPP'VP(44V#)z/Force construction of the real VariableTracker.)TracingContextrrRNz;source must not be None when realizing LazyConstantVariable)rrqr9 torch._guardsrrrrrUrSrr!rrrjguards_context dynamo_guardsinnerdiscardrCONSTANT_MATCH)r%rrrrSrtracing_contextrss& rr9LazyConstantVariable.realizes     7?$ $08. ;;  M " f / /##/"0"4"4"6..<<BBJJ(((,$ $++001L1LM N rcV^8dQhRR/#rr)rs"rrrs  T rc <VP4'd\SV` 4#VP4VP 4#)z6Return the Python type without triggering realization.)rrq python_typerrr%rss&rr LazyConstantVariable.python_types9     7&( ( !~~rcV^8dQhRR/#rr)rs"rrrs4rc &VP4R#)z&Primitive constants are never tensors.Frrxs&r is_tensorLazyConstantVariable.is_tensors !rcV^8dQhRR/#rr)rs"rrrs$rc &VP4R#Frrxs&ris_constant_none%LazyConstantVariable.is_constant_nones !rcV^8dQhRR/#)rrz type | Noner)rs"rrrsrc VP4'd\VP44#VP4p\P 'g$V\ Jd\VP44#\P'g$V\Jd\VP44#VP4R#)aCheck if we need to realize to determine the VariableTracker type. Returns None if we can determine the type without realization (and installs TYPE_MATCH guard). Returns the realized type if realization was needed. With specialize_int=False or specialize_float=False, ints/floats may become either ConstantVariable or SymNodeVariable, so we must realize to know. For bool/str, we always know it will be ConstantVariable. N) rrer9rrspecialize_intrKspecialize_floatfloatr)r% value_types& r_maybe_realize_for_type,LazyConstantVariable._maybe_realize_for_types      ' '^^% $$$s): ' '&&&:+> ' ' !rcV^8dQhRR/#rr)rs"rrrs""t"rc VPe VP#^RIHpVP4pVeTMTVnVP#)zReturn the VariableTracker type to use for builtin handler dispatch. This allows builtins like isinstance() and type() to find the correct handler without triggering full realization of the lazy constant. rR)rrUrSr&)r%rS realized_types& rr2LazyConstantVariable.get_handler_type_for_dispatchsN    )%% %.446 *6Mrrr)r<r=r>r?r@rKr$r}rrgr_rrr4r&rr9rrrr&rrrArrs@rrfrfms E4-O  + + NXX,// %<   6""11rrfca]tRtRt$RtR]R&]RRl4tRV3RlltR R lt R V3R llt R V3Rllt RRlt RRlt RRltRRltRtV;t#)ri*a Result of a supported op over lazy constant operands. The value is computed eagerly at trace time but guards are deferred: if never realized, output bytecode recomputes it from the operands (TYPE_MATCH only); realization realizes the operands, installing their CONSTANT_MATCH guards. rCr`c$V^8dQhRRRRRR/#)rrHrIrFrGrzVariableTracker | Noner)rs"rr)ComputedLazyConstantVariable.__annotate__5s&' ' ' #'  ' rc  aa ^RIHp\PpV^8:dR#.o^o RVV 3RllpVUu.uF qT!V4NK ppS V8dR#V!V!pTP T4'gR#S'gTP T4#\\TS\T4TS 44#uupi \dR#i;i)zDCompute op(*args) eagerly; returns None to fall back to realization.rRNc V^8dQhRRRR/#)rr[r rrr)rs"rr9ComputedLazyConstantVariable.create..__annotate__Cs , ,? ,s ,rc<\V\4'doVP4'gYSPVPP 4SVPP , oVPP#\V\4'd8VP4'g"SPV4VP4#VP4#rN) rrrextendr`rErJrrfappendras_python_constant)r[rErJs&r get_value6ComputedLazyConstantVariable.create..get_valueCs#;<02   , ,-11DS)C.D1 y  KE //66#**51 1+ eYT B J  2   sB)B.. B=<B=c$V^8dQhRRRRRR/#)rr`rCrorrrr)rs"rrr1^s"++0+C+D+rc <\V\4'g"\R\V4P 24h\ SV`!V3/VBR#)z1_cache must be a ComputedLazyCache instance, got N)rrCr!rer<rqr&rrs&&,rr&%ComputedLazyConstantVariable.__init__^sG&"344 CDLDYDYCZ[  *6*rcV^8dQhRR/#r)r)rs"rrr1es**T*rc `VPPFpVP4K R#rN)r`rEr)r%rZs& r_ensure_operand_type_guards8ComputedLazyConstantVariable._ensure_operand_type_guardses" --H  ' ' ).rcV^8dQhRR/#rr)rs"rrr1js''T'rc <VP4'd\SV` 4#VP4\ VP P 4#rN)rrqrrFrer`rrs&rr(ComputedLazyConstantVariable.python_typejsA     7&( ( ((*DKK%%&&rcV^8dQhRR/#rr)rs"rrr1ps4rc p<VP4'd\SV` 4#VP4R#r)rrqrrFrs&rr&ComputedLazyConstantVariable.is_tensorps/     7$& & ((*rcV^8dQhRR/#rr)rs"rrr1vsrc ^RIHpVPPFpVP 4'd/\ P WP44'dR#KGVP4pV\Jd\P'gR#V\JgK\P'dKR# R#)rTF)rVrr`rErrerr9rrKrr"r$r#)r%rrZr%s& r_might_realize_symbolic4ComputedLazyConstantVariable._might_realize_symbolicvs+ --H##%%))/;K;K;MNNO&//1 $V-B-B-B&v/F/F/F.rcV^8dQhRR/#rr)rs"rrr1s$$t$rc ^RIHpVP4'g)VP4'gVP 4V#\ VP 44#)rPrR)rUrSrrQrFrer9)r%rSs& rr:ComputedLazyConstantVariable.get_handler_type_for_dispatchsE.!!$*F*F*H*H  , , .# #DLLN##rc V^8dQhRRRR/#r{r)rs"rrr1s1141D1rc ^RIHp^RIHpVP 4'd$\ P WP44#\W!4'g$\W14'gVP4R#VP4'd$\ P WP44#VP4\W!4#)rPrRrF) rUrSrVrrrerr9rrFrQ)r%r|rSrs&& rr,ComputedLazyConstantVariable.lazy_isinstances.+     ))#||~> >*00 : :   , , .  ' ' ) )))#||~> > ((**00rc V^8dQhRRRR/#)rcodegenrrrr)rs"rrr1s L L3 L4 Lrc aa^RIHpVPoSPVV3Rl4SPF pS!V4K SP V!\ SP4R44R#)r)create_call_functioncP<SPRSPP4#)operator)load_import_fromrHr<)rkrZsr:ComputedLazyConstantVariable.reconstruct..sG,,Z9J9JKrFN)bytecode_transformationr\r` add_push_nullrF extend_outputlen)r%rZr\r[rks&f @r reconstruct(ComputedLazyConstantVariable.reconstructsUB  K ::C CL23uzz?EJKrr)r<r=r>r?r@__annotations__rr4r&rFrrrQrrrfrArrs@rrr*sa ' ' R++* ''   $1 L Lrrc.]tRtRtRRltRRltRtR#)r ic$V^8dQhRRRRRR/#)rsym_node_variabler fmt_spec_varr rrr)rs"rr$LazySymNodeFormatString.__annotate__s$  !0 @O  rc ^RIHpWnVPRVP 4,R,4VnR#)rPrRz{:}N)rUrS sym_node_varr4r8fmt_var)r%rkrlrSs&&& rr& LazySymNodeFormatString.__init__s5 /-'.. <224 4s :  rcV^8dQhRR/#rr)rs"rrrms  # rc \PVPP4\VPP 444#rN)rrrqr8rp evaluate_exprrxs&rr LazySymNodeFormatString.__repr__s:zz LL + + - !!//1 2  r)rqrpN)r<r=r>r?r&rrArrrr r s   rr c V^8dQhRRRR/#)rrrrz.Callable[[LazyVariableTracker, Any, Any], Any]r)rs"rrrs    3 rcha\P!\\S44RV3Rll4pV#)c(V^8dQhRRRRRRRR/#)rr%r_rFrrorr)rs"rr1_create_realize_and_forward..__annotate__s,>>!>*->9<> >rcD<\VP4S4!V/VB#rNr)r%rFrors&*,rrealize_and_forward8_create_realize_and_forward..realize_and_forwards"t||~t,d=f==r) functoolswrapsrr )rr|sf r_create_realize_and_forwardrs/__W_d34>5> rcV^8dQhRR/#r)r)rs"rrrsVV4Vrc\PP4FIwrV\P9gK\ V4'gK/\ \V\ V44KK R#rN)r rrr_callablesetattrr)rrs r _populatersH&//557  *33 3+T3Nt3TU8r) __future__rrr~rtypingrrr1rutilsrbaserr r collections.abcr typing_extensionsr r0r rVrrrCr_rfrr rrrrrrs"%*FF(&<'*!*!Z/>/>dv"/5Hv"rz1.z1z}L#6}L@  $ V r