iS%SrSSKrSSKrSSKrSSKrSSKrSSKJrJr SSKJ r J r J r J r J r JrJrJrJr SSKJs Jr SSKJs Jr SSKrSSKrSSKJrJr SSKJr SSK J!r! SSK"J#r#J$r$J%r% SS K&J'r' SS K(J)r) SS K*J+r+J,r, SS K-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrM SS KNJOrOJPrPJQrQJRrRJSrSJTrTJUrUJVrV SSKWJXrXJYrY SSKZJ[r[ SSK\J]r]J^r^ SSK_J`r` SSKaJbr SSKcJdrd \"SS55re\"SS55rf\"SS55rg\\g\ \g\\gS44rh\d\iS'\\j\k\l\R\ S4rm\d\iS'\\R\R\R\R\R\R\R4ru\d\iS'\\ S\m4\v4rw\d\iS'\\h\S\ S \ \vS 4\v\k\l\j\x\R\R\R\RS4r|\d\iS '\\ \k\\k4\ \v\\k44r}\d\iS!'"S"S#\RR5r"S$S%\5rg)&aTakes an ExportedArtifact, or a collection of ExportedArtifacts, in execution dialect, and turns them into a single ExecuTorch Program. The provided ExportedArtifact's graph modules are in execution dialect and the emitter parses and converts them into executorch instructions. The emitter walks the provided graphs and as it encounters concrete values such as tensors or ints, it converts them to the serialized format and stores them in a list for later use. The emitter walks the graph by traversing fx.nodes, these can come in a variety of forms and are the primitives of execution at the graph module level. The most common 3 we care about are 'call_function', 'place_holder', and 'output'. 'placeholder' and 'output' handle io for the module and 'call_function' handles everything else. Within 'call_function' we may encounter an operator or delegate call, in such case we parse the schema and emit all the inputs and outputs (unless they have already previously been emitted), and then we convert the actual function call into an executorch instruction such as KernelCall or DelegateCall. When control flow is present in the graphmodule it will take the form of a few different types of 'call_function'. Today (June 14th 2023) only cond and map are supported. The actual operations of these, such as the true/false branches of cond, or the mapping function of map, are stored as sub graphmodules. When these are encountered during emission, the emitter will recursively emit them and their instructions. N) dataclassfield) AnyCallablecastDictListMappingOptionalTupleUnion)executorch_call_delegateis_lowered_module)BackendOpOverload)EdgeOpOverload) ExportErrorExportErrorType InternalError)is_out_variant) is_sym_op)_stacktrace_to_framelist inspect_node) AllocationDetailsBackendDelegateBackendDelegateDataReferenceBackendDelegateInlineDataBoolBoolListBufferChainContainerMetadata DataLocation DelegateCallDouble DoubleListEValue ExecutionPlanExtraTensorInfoFreeCall InstructionIntIntList JumpFalseCall KernelCallMoveCallNullOperatorOptionalTensorList ScalarTypeStringTensorTensorDataLocation TensorListTensorShapeDynamism)AddressSpaceOverflowExceptiondim_order_from_stride layout_enummake_allocation_infomake_tensor_valuememory_format_enumscalar_type_enum TensorSpec) LeafValueSpec ValueSpec) FakeTensor)ExportedProgramExportGraphSignature)Node)_pytree) TypeAliascT\rSrSr%Sr\"\S9r\\ \ S'\"\ S9r \ \\4\ S'\"\ S9r\ \\4\ S'\"SS9r\\\ S'\"S S9r\\\ S '\"\S9r\\\ S '\"\ S9r\ \\4\ S '\"\S9r\\\ S '\"\ S9r\ \\4\ S'\"\ S9r\ \\ \\44\ S'Srg) _ProgramStatefzState shared between all methods of a program and the graph module it represents. Initialized once within emit_program and then shared across each entry point as they are emitted. default_factoryallocated_specscached_spec_hash_valuescached_spec_mutable_hash_valuesc[SS9/$NstoragerrS\/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/executorch/exir/emit/_emitter.py_ProgramState.ws 6RUCVBWrSconstant_bufferc[SS9/$rRrVrWrSrXrYrZys &QTBUAVrSmutable_bufferbackend_delegate_databackend_delegate_data_cacheexternal_constant_bufferexternal_constant_hashexternal_constant_maprWN)__name__ __module__ __qualname____firstlineno____doc__rlistrNr r@__annotations__dictrOrstrintrPr[rr]r^rr_r`bytesrarb__static_attributes__rWrSrXrJrJfs).d(COT*%C/4D.IT#s(^I6;D6Q#T#s(^Q$):W$XOT&\X#(9V#WNDLW>CSW=X4 9:X272Mc3hM-2$,Gd5kG-24-HDcNH8=T7R4T#s(^ 34RrSrJc\rSrSr%Sr\\\S'\\\S'\\ \S'\ \ \ \ 4\ 4\S'\\S'\\S'\"\S 9r\ \\ 4\S 'S \S \ 4S jrSrg) _EmitterStatezState of a single emitter. Local to at least the entry point, and may be local to a subgraph of an entry point originating from control flow. values operators delegatesoperator_cacheemit_stacktraceemit_mutable_buffer_namesrL spec2id_dictspecreturncnXR;dSUR535eURU$)z4Map a TensorSpec to value index in the values array.zSpec is not found: )rxdebugselfrys rXspec2id_EmitterState.spec2ids8(((N,? ~*NN(  &&rSrWN)rcrdrerfrgr r&rir1rrr rkrlboolrrjrxr@rrnrWrSrXrprpsw LH~O$$sCx#-..##*/*EL$z3'E'J'3'rSrpc4\rSrSr%Sr\\S'\\\S'Sr g)_AbstractValuez$Represents an already emitted EValueidtensorrWN) rcrdrerfrgrlrir r5rnrWrSrXrrs. G V rSr. _EmitterValue _PythonValue _SchemaType_Target) _Argument.r_DelegateDebugIdentifierMapc^\rSrSr%Sr\R R\S'SQS\R RS\ S\ S\ S \ \\S \ \\S S4U4S jjjrS\R RS \S \4SjrS\S\R RS\S S4SjrS\\S \4SjrS\\S\S \4SjrS\S \4SjrS\S\ S\S S4SjrSRS\S\S\S\ \S\ \S \ 4 SjjrSSS\S\ \S \4S jjr S\!\"\\\4S \4S!jr#S\S\ \S \4S"jr$S\S \4S#jr%S\&S \'4S$jr(S%\)S S4S&jr*S'\"\S(4S)\ \\S \\4S*jr+S'\"\S(4S)\\S \\4S+jr,S'\"\S(4S)\\S \\4S,jr-S-\.S'\"\S(4S.\/\\4S \'4S/jr0S'\"\S(4S \'4S0jr1SSS1\ S-\.S2S3S S4S4jjr2S2S5S6\ S S4S7jr3S8\S9\ \S \4S:jr4S\"\!\Rj\Rl\Rn\84S \ \4S;jr9S\"\!\Rj\Rl\Rn\84S\S \!\\\\"\S(444S<jr:S2S5S'\"\S(4S.\/\\4S \'4S=jr;STS>\S?\S \"\ \<44S@jjr=S-\.S'\"\S(4S.\/\\4S \'4SAjr>S\S \4SBjr?SC\/\\@4S \\A4SDjrBS-\.S \4U4SEjjrCS-\.S'\"\S(4S.\/\\4S S4SFjrDS-\.S'\"\S(4S.\/\\4S \'4SGjrES-\.S'\"\S(4S.\/\\4S \4SHjrFS-\.S'\"\S(4S.\/\\4S S4SIjrGS-\.S'\"\S(4S.\/\\4S \'4SJjrHSSK.S'\SL\ \/\R R\4S S4U4SMjjjrISN\R RS S4U4SOjjrJSPrKU=rL$)U_EmitterzAn abstract interpreter (https://wiki.mozilla.org/Abstract_Interpretation) used to emit the given traced torch.fx.GraphModule to the flatbuffer schema.nodeN graph_module emitter_state program_stateinstruction_start_offsetbinding_input_valuesbinding_output_valuesrzc>[TU]U5 X lX0l/Ul[ ///SS9UlSURR5;a [S5eX@l XPl X`l Xl [URRR 5UlSUl/Ul0Ul0Ul0Ulg)Ninputsoutputs instructions stacktracenon_const_buffer_sizeszGMust set 'non_const_buffer_sizes' in graph meta in memory planning passr)super__init__rrrr chainmetakeys RuntimeErrorrrrrrhgraphnodesplaceholder_countconcrete_output_idsdebug_handle_mapinstruction_id_to_num_outs_map!instr_id_to_delegate_debug_id_map)r~rrrrrr __class__s rXr_Emitter.__init__s &**"$     $<+<+<+A+A+C CY )A%$8!%:"2>*.t/@/@/F/F/L/L*M "#9; BD>@+  .rSerr_msgcfS[U5S3[URRU5-nU$)z:Returns 'err_msg' with node specific information attached.zFailed with error:  )rkrrr)r~rrs rX_emit_node_specific_error"_Emitter._emit_node_specific_errors8'G ~R8<    # #T<  rSpred assert_msgcFU(d[URX#55eg)zDIf pred is False, construct and raise a node specific error message.N)rr)r~rrrs rX_internal_assert_emitter!_Emitter._internal_assert_emitter s" > >t PQ QrSvalc /nUHn[U[5(aURUR5 M5[U[5(a<URUR UR US55R5 MURSURS5 M [[U55$)aEmits a list of integers as a collection of EValues. For every argument in 'val': - If it is a concrete value, then emit it and then place its location in the boxed list - If it is already an abstract value, then just place its location in the boxed list Int lists are boxed to handle symints whose values are determined at runtime, but could still end up inside lists for ops like view_copy(Tensor self, SymInt[] size) NFz)Unsupported type encountered in int list.) isinstancerappendrrl _emit_evalue_constant_to_evaluerrr&r,)r~r boxed_listitems rX_emit_int_list_Emitter._emit_int_lists D$//!!$''*D#&&!!%%d&>&>tT&JKNN--499&Qgj)**rSval_typec[U[R5(a4[[ [ R "[[U555$[U[R5(aURU5$[U[R5(a4[[[ R "[[U555$[U[R5(az/nUH^n[U[5(deUR!UR"SLUR$S5 UR'UR(5 M` [[+U55$[U[R,5(aUR/5n[U[R5(ag/nUHKnUcUR'S5 M[U[5(deUR'UR(5 MM [[1U55$[3[4R6SU35e)aEmits a list type. Emits the list stored in val. If the list is of Tensors, Optionals, or Ints the emitted list is boxed, otherwise the values are constant at runtime and stored inline. NOTE: When symbool and symfloat are supported bool and float lists will be stored boxed. NzGAbstractValue corresponding to tensor type doesn't contain tensor valuezUnknown list type: )rtorchBoolTyper&rtypingrr rIntTyper FloatTyper%float TensorTyperrrrrrr7 OptionalTypegetElementTyper2rr NOT_SUPPORTED)r~rrrrv actual_typevalss rX _emit_list_Emitter._emit_list*s h / /(6;;tDz3#?@A A h . .&&s+ + h 0 0*V[[ec%BCD D h 0 0 1 1F!!^4444--HHD(II]  add#*V,- - h 2 2 3 3"113K+u'7'788Ay B)!^<<<< ADD)  0677  ) )-@ +K  rSrycUR[UR[5=(a URS:URSUR35 UR[UR [5=(a UR S:URSUR 35 [ URUR 5nU$![a-n[URURUS355eSnAff=f)z3Returns the allocation info for a given TensorSpec.rz8Non-const tensor should be an activation tensor: mem_id zsCrS buffer_datahashedrcURRRU5 [US9nURbURR bURR [R:XaUcS5e[URR5nXpRRU'URRRU5 URURR Xu5 U$U(a^[URR5nXpRRU'URRRU5 U$[URR5nXpRR U'URRRU5 U$)zMSaves a new constant tensor to the constant buffer and returns the buffer idxrTz+Constant tag is not set for external tensor)rrNrrextra_tensor_infofully_qualified_namelocationr6EXTERNALrr`rarr]rPr[rO)r~ryrrrrbufferrs rX_save_new_const_tensor_Emitter._save_new_const_tensors **11$7 ,  " " .&&;;G&&//3E3N3NN( =< =( T//HHIJ@J   5 5f =    7 7 > >{ K  / /&&;;Z T//>>?JIS   > >v F    - - 4 4V < T//??@JAK   6 6v >    . . 5 5f =rSc SnSnURbURbURU5nUR(Ga[R [ R"[RUR5R5-nURS:way[[R"[ R"[RUR5R5[R"U55R 5OSn["R$"U5R'5nU(a4UR(c'UR*R,R/US5nOUR(bUR(R0[2R4:XarUR*R6R/US5nUS:waEUR(R8ceUceUR;UR(R8UU5 O&UR*R<R/US5nUS:XaUR?XXsU5nUR(a_UR5[AU5:waB[CUREURFS[AU5SUR5355e[I[KXCU55$)z/Constructs an EValue from the given TensorSpec.NrrSrzTensor spec has buffer of size z, but expected nbytes of )&rrrconstctypesc_charrrrUntypedStoragerUnbytesallocated_memoryrmdata_ptrPOINTERcontentshashlibsha256 hexdigestrrrPgetrr6rrarrrOrrrrrr&r=)r~ryrrrspec_array_typerrs rX_tensor_spec_to_evalue_Emitter._tensor_spec_to_evaluesk  ;; "t'B"77=O :::  E,@,@$,, O V V XX ((A- KK E$8$8$,,GPPR7h  ^^K0::4_Emitter._get_list_tuple_jit_type.. s+ LOqJq. ) Bahhd.B BCs24rzbCouldn't determine JitType for list/tuple of elements. Only supports int, float, bool, and Tensor.)rrhtupletypeallrrrrlrrrrrrrr)r~ris_tensor_types rX_get_list_tuple_jit_type!_Emitter._get_list_tuple_jit_types $   { nostwoxny z {  LO   ##'') ) A $ $==$$& & A % %>>%%' ' A & &??&&( (  * * t   rSc ^Uc[[55$[U[[45(aUc%[ R "URU55n[U[ R5(aUR5n[U[ R 5(deUR[R"[[U5[R"[UR555$[U[ 5(a[[#U55$[U[$5(a[['U55$[U[(5(a[[+U55$[U[,5(a[[/U55$[U[ R05(a[[+[3U555$[U[ R45(a[[+[7U555$[U[ R85(a[[+[;U555$[U[ RD5(a4[G[HRJURAURBS55e[G[HRJURAURBS[MU5RN355e![<a) [?URAURBSU355ef=f)a'Converts a constant value to an EValue. Returns an EValue given the Python representation and JIT type. On common paths there should always be a JIT type provided. Users can pass in a None to infer the JIT type but this should never be the default case due to the existence of container types. z>Tensor has a memory_format that is unsupported in ExecuTorch: zoconstant_to_evalue should not be encountering constant tensors, they should be emitted through other codepaths.zUnsupported constant type: )(r&r0rrhrrListTyperrrrrrr rrrr$rrrlr+rkr4dtyper?layoutr; memory_formatr>KeyErrorrrrr5rrrrrc)r~rrs rXr_Emitter._constant_to_evaluesp ;$&> ! cD%= ) ) >>11#6(E$6$677#224h77 77?? DOS1 K)@)@)BC  c5 ! !&+& & c4 $s)$ $ c3  #c(# # c3  &+& & c5;; ' '#.s345 5 c5<< ( (#k#./0 0 c5.. / / c"4S"9:;; c5<< ( (--..IIF   ) )  * * 8c9K9K8LM   # #22 XY\X]^ s ?K993L,cURRRU5 [UR[ 5(a UROSn[ [URR5S- U5$)zWrites an EValue to the emitter state. Given an Evalue, adds it to the emitter_state's values table, and returns the AbstractValue representing it. N)rrrrrrr5rr)r~rrs rXr_Emitter._emit_evaluefs\ !!((-&sww77Tc$"4"4";";[U[[45(a%[TR TR S55eTR [U[5TR SU35 TRTRU55nURTRRU'U$)NzBNode spec should be either non-nested container or a scalar objectz/Invalid node spec expected TensorSpec received ) rrhrremit_node_specific_errorrrr@rrrrrx)ryretr~s rX_process%_Emitter._emit_spec.._processss$u ..#11 \  ) )4, A$H  ##D$?$?$EFC47FFD   + +D 1JrS)rArpytreetree_map)r~ryrs` rX _emit_spec_Emitter._emit_specps' = ^ ,x..rSrcbURRRUR5 g)zvMerges the chain generated from subgraphs (like those originating from control flow) back into the main program chain.N)rrextend)r~rs rX _merge_chain_Emitter._merge_chains" &&u'9'9:rSargs. subemitter_binding_output_valuesc Uup4pV[U[RR5(de[ UUR UR UR[URR5-S-[R"[[U5US9nUR5 [U[5(de[![#UR$UR[URR5-[URR5-S-S95nURRR'U5 UR)UR5 [U[RR5(de[ UUR UR UR[URR5-S-[R"[[U5US9n U R5 UR+[-[/S555n [![#U R$UR[URR5-[U RR5-S-S95n URRR'U 5 UR)U R5 U$)a^Emits control_flow.cond. Converts the higher order op into jumps and inlines the submodules of the true and false branches. Control flow can be nested. The general emitted structure is: - decides which branch to take - jumps to End Of Cond after executing true branch rrrrcond_value_indexdestination_instructionF)rrfx GraphModulerrrrrrrrrr rrunr*r-rrrrr&r) r~r r!r true_branch false_branchrtrue_branch_emitterjf_instruction_to_skip_truefalse_branch_emittervaluejf_instruction_to_skip_falses rX _emit_cond_Emitter._emit_condsz37/<+uxx';';<<<<&       %)%B%B$**))*&+&"(T.-A6!J"B   !$////&1 !%(,(E(Edjj--.)/)//<<=)>)  ' # &&'BC -334,(<(<===='       %)%B%B$**))*&+&"(T.-A6!J"B    "!!&e"56'2 !&(,(E(Edjj--.)/*00==>)?) ( $ &&'CD .445//rSc  [U[[45(d SUS35e[U5S:wa[ S[U5S35eUup4n[U[[45(de[U5nUS:wa[ SUS35eUSn[U[ R R5(deUR[[S555nURSSS 9upUR[[S555n [[U URUR[[S555RU R/S 95n URR R#U 5 URS S S 9up[[U URUR[[S555RURS S /S 95n UR$[URR 5-n URR R#U 5 ['UUR(UR*UR$[URR 5-S /UQUS9nUR-5 UR/UR5 URR R15 UR2SRU R4R6S 'U R4R6S U R4R6S'UR9[UR:5S:HUR<S5 URSSS 9up[[U USRUR:SRUR/S95n URR R#U 5 URSSS 9up[[U URUR[[S555RUR/S95n URR R#U 5 UR[[?S555nURSSS 9up[[U URU RUR/S95n URR R#U 5 [[AURU S95nURR R#U5 URSSS 9up[[U URU RUR/S95n URR R#U 5 U$)aiEmits torch.map. Converts the higher order op into a loop constructed from jump instructions and primitive int operations. A concat-like custom op is also injected into the submodule code to handle the construction of the map output. Below is what the input graph that is provided to emit_map looks like. class TestMapCond(torch.nn.Module): def __init__(self): super().__init__() def forward(self, x,y): return control_flow.map(map_fn, x, y) Corresponding graph: def forward(self, arg0_1, arg1_1): submodule_0 = self.submodule_0 map_1 = torch.ops.higher_order.map_impl(submodule_0, arg0_1, arg1_1); submodule_0 = arg0_1 = arg1_1 = None return [map_1] submodule_0: def forward(self, arg0_1, arg1_1): add_tensor = torch.ops.aten.add.Tensor(arg0_1, arg1_1); arg0_1 = arg1_1 = None return add_tensor Post the transformations done by emit_map this is what the submodule program looks like. def forward(self, arg0_1, arg1_1): sym_size = torch.ops.aten.sym_size(arg0_1) # Emitter creates a variable here to track iteration index select_copy_tensor = torch.ops.aten.select(arg0_1, 0, iteration_index) add_tensor = torch.ops.aten.add.Tensor(select_copy_tensor, arg1_1); arg0_1 = arg1_1 = None output_of_map = torch.ops.executorch.prim.et_copy_index(output_of_map, add_tensor, iteration_index) iteration_index = torch.ops.executorch.prim.add.int(iteration_index, 1, iteration_index) done_bool = torch.ops.executorch.prim.eq.int(iteration_index, sym_size, done_bool) # Emitter inserts a instruction here, if done_bool == False jump to selcect_copy op # if not continue. return add_tensor z@Expect a list for subemitter_binding_output_values for map. Got .rz(Multiple outputs are not supported. Got zBEmitting map with more than one mapped args is not supported. Got raten::sym_sizerlnameoverloadop_indexr aten::select_copyint_outrr#z"Map should return only one elementexecutorch_prim::et_copy_indexrr executorch_prim::addScalarFexecutorch_prim::eqr%executorch_prim::sub)!rrhrrrrr(r)rr&r+ _get_operatorr*r.rrrrrrrrr*rpopr instr_argsr rrrrr-)r~r r!f mapped_argsrnum_mapped_argsxiter_idxr;opsym_sizekerneljump_to_instruction map_emitterjump_bool_valuejf_beginning_loops rX _emit_map_Emitter._emit_maps`J ,tUm   r MNnMoop q r  / 0A 5:3?_;`:aabc "&+e}5555";/ a TUdTeefg  N!UXX112222$$VCF^4))!* $$VCF^4 !ddD--fSVn=@@(++N   &&v.))$*  !DD%%fSVn588KK    #;;c JJ # #?   &&v.      %)%B%B$**))*&+#%v"B    +++, ##%&1%E%Ea%H%K%Kr"%+%6%6%;%;B%?r" %%  // 0A 5 II 0 ))1*  4Q7::33A699KK    &&v.))'*  kk4#4#4VCF^#D#G#GU   &&v.++F4;,?@ ))&*  kk8;;0B0BC   &&v.' !0!3!3(;   &&'89))'*  kk8;; <   &&v.//rScUup4pV[U[[45(d!S[U5RSUS35e[U[ R R5(de[U[[45(de[U[[45(de[U[[45(de[U5n[U5n[USU5n [X'S5n US:a[SU35eUR[[S555n URSS S 9upUR[[S555n[[U USR UR[[S555R UR /S 95nUR"R$R'U5 URS S 9unn[)XI5Hunn[[UUR UR UR[[+S555R UR /S 95nUR"R$R'U5 M URSSS 9unn/nUHkn[[UUR UR[[S555R U R SS/S 95nUR'U5 Mm UR,[UR"R$5-nUH(nUR"R$R'U5 M* /nUR/U 5 UR/S/U-5 UR/U5 [1UUR2UR4UR,[UR"R$5-USS9nUR75 UR9UR"5 [;U5HTunnUR<UU-R nUUR>R@S'UUR>R@S'MV URBnUSUnUUSnURE[U5U:HURFSUS[U535 URE[U5[U 5:HURFS[U 5S[U535 [)UU 5Hunn[[UUR UR UR[[+S555R UR /S 95nUR"R$R'U5 M URSSS 9un n[)UU 5H_un!n"[[U U"R U!R U R /S 95nUR"R$R'U5 Ma URSSS 9un#n[[U#U R UR[[S555R U R /S 95nUR"R$R'U5 UR[[+S555n$URSSS 9un%n[[U%U R UR U$R /S 95nUR"R$R'U5 [[IU$R US95n&UR"R$R'U&5 URSSS 9un'n[[U'U R UR U R /S 95nUR"R$R'U5 U$)aWEmits torch.scan. Converts the higher order scan op into a loop constructed from jump instructions and primitive operations. Scan differs from map in that it maintains a carry state that evolves across iterations. Scan signature: scan(combine_fn, init, xs, additional_inputs) - combine_fn: GraphModule that takes (carry, x_slice, *additional_inputs) and returns (next_carry, y_slice) - init: Initial carry state (list of tensors) - xs: Input tensors to scan over (list of tensors, scanned along dim 0) - additional_inputs: Additional arguments passed to combine_fn Output: (final_carry, stacked_ys) - final_carry: The carry state after the last iteration - stacked_ys: All y outputs stacked along dim 0 Memory Layout: - carry_outputs (subemitter_binding_output_values[:num_carry]): Working carry buffers, initialized from init, updated each iteration - y_outputs (subemitter_binding_output_values[num_carry:]): Pre-allocated stacked output buffers, filled via et_copy_index The combine_fn writes to its own temporary output buffers (concrete_output_ids). After each iteration: 1. Copy combine_fn's carry output -> carry_outputs (for next iteration) 2. et_copy_index(y_outputs, combine_fn's y output, iter_idx) This explicit copy approach is used because in-place op.out(x, out=x) is unsafe. z8Expected list for subemitter_binding_output_values. Got z: r5Nrz:Scan requires at least one xs tensor to scan over but got rr6rlr7r:z aten::copy_)r8Fr<r=rr#r>zScan combine_fn should output z carry values, got z y values, got r?rrArBrCr%rD)%rrhrrrcrr(r)rrrr&r+rEr*r.rrrrziprrrrrrr*r enumeraterrGr rrrr-)(r~r r! combine_fninitxsadditional_inputs num_carrynum_xs carry_outputs y_outputsrLr;rMrNrO op_index_copy_init_val carry_outop_index_selectxs_slice_instructionsrKrPr scan_emitterixs_placeholder_idconcrete_outputs carry_tempy_tempcarry_top_index_copy_indexy_ty_out op_index_addrR op_index_eqrS op_index_subs( rX _emit_scan_Emitter._emit_scansfF37/ ":T5MJJ 89BBC2/0 3 J *ehh&:&:;;;;$u ...."tUm,,,,+dE];;;;I R=jyIJ 9*EF A:LVHU $$VCF^4))!* $$VCF^4 !ehh 1 1&Q. A D DhkkR   &&v. --=-A q#&t#; Hi *!  ))&e*=>AA!  F JJ # # * *6 2$<"//$0 !#A ,))&Q.9<<    F " ( ( 0#;;c JJ # #?  ,F JJ # # * *6 2,+-##M2##RD6M2##$56       %)%B%B$**))*&+!5"&   ,,,-"#89IAv , A A)a- P S S ):F   " "2 &):F   " "2 &: (;;%jy1 !)*- %%  Oy ( II,YK7J3z?J[ \ %% K3y> ) II,S^,AA!  F JJ # # * *6 2#A"&!3!31"4" Qfi0JC 0((CFFHKK8F JJ # # * *6 21,,'-  a %kk4#4#4VCF^#D#G#GU   &&v.++F4;,?@++&,  Q $kk8;;0B0BC   &&v.' !0!3!3(;   &&'89,,'-  a %kk8;; <   &&v.//rStargetkwargsc^TRRSnU[RRR LaeUupVpx[ U5n [U[[45(a9XISn U H/n [U [5(dM[RU l M1 OjU[RRRLaC[ U5S:Xde[US[5(de[RUSl [R "U4SjU5n U[RRR"LaTR%X,5$U[RRRLaTR'X,5$U[RRR LaTR)X,5$[+TR-TRSU355e)zWraps common logic for emitting all control flow operations. See the more specific emission functions for more details on how cond, map, or scan get emitted. ryNrrc&>TRU5$r)r)ryr~s rXrY-_Emitter._emit_control_flow..s.rSz#Unsupported control flow operator: )rrrops higher_orderscanrrrhrr@r8 DYNAMIC_BOUNDshape_dynamismmap_implrrcondr2rTrtrr) r~rvr rwspecsrYrZr[r\r]y_specsy_specr!s ` rX_emit_control_flow_Emitter._emit_control_flows v& UYY++00 06: 3JbD I%$// +%F!&*550C0Q0Q-&uyy--66 6u:? "?eAh 33 33&9&G&GE!H #+1?? . , ( UYY++00 0??4J J uyy--66 6>>$I I uyy--22 2??4J J..II!DVHM rScT[U5S:XdeURRSnURnURSL=(a UR SLnU=(d! UR =(a URSLnU(aU(aURU5$URUS[R5nURUS[RR55nURURURRS5[R5nURSSS9up[[!UUR"UR"UR"/S95n UR$R&R)U 5 U$) Nr$ryrrzexecutorch_prim::et_viewdefaultr7r@)rrris_static_shape_tensorrrrrUr_emit_argumentrrr ofIntsrEr*r.rrrr) r~r ry is_staticis_memory_plannedself_argsize_argout_argop_idxrMrOs rX _emit_view_Emitter._emit_viewsg4yA~~yy~~f%// ![[4W4??RV;V- JJ 34<-JK C )88>>JJLK!&&q)G*4WtUm*L*L#g,RSK0A ! !* ->I / / ;.8IINN> *  99>>  n - 904 0B0B>0RD ! !* - .8IINN> * :rSLoweredBackendModuledelegate_instruction_idc0nURbURRS05nURUS.URU'g)z Store the delegate map from this lowered module into the dictionary of delegate maps. It will later be used for various debugging purposes such as linking back to original source code, module hierarchy etc. Nr)r8 delegate_map)rr backend_idr)r~rrrs rX_add_delegate_map_Emitter._add_delegate_mapsP    *)..223ErJL#--(K ../FGrSargarg_typecp[U[5(aU$URURX55$)zEmit an argument to an operator or delegate if it had not already been emitted otherwise return the previously emitted location)rrrr)r~rrs rXr_Emitter._emit_argument/s2 c> * *J  !9!9#!HIIrScSn[U[R5(a%UR[ [ S555nU$[U[R 5(a%UR[ [S555nU$[U[R5(a#UR[ [S555nU$)z% Returns the emit ret for sym value. NrF) rrSymIntrr&r+rrrr$)r~rrs rX _get_sym_ret_Emitter._get_sym_ret8s c5<< ( (##F3q6N3C  U^^ , ,##F4;$78C U__ - -##F6!9$56C rScdURU5nUcURU5nUcS5eU$)NzCan't have a None ret)rr)r~rryrs rX_get_sym_and_fake_tensor_ret%_Emitter._get_sym_and_fake_tensor_retHs< $ ;//$'C7 77 rSc  URn[R"U5R5nURR R U5nSn[URRS[5(a/n[URRS5H\upURURRSUURRSU5n URU 5 M^ GO[URRS[5(Ga[URRS[5(aHURURRSURRSS5n U 4nGO./n[URRS5H\upURURRSUURRSU5n URU 5 M^ [U5nO[URRS[ 5(aCURURRSURRS5n U nO/[#S[%URRS5S35eUcS5eUcc['URR 5nX`RR U'URR(R[+US95 [-UR.[1[2R4US 9UR6S 9n UR8R:RU 5 [<R>"[@[BU5V s/sHn UREU S5RFPM! n n [HRJ"U5SHnU RURF5 M URLRNR[S['UR8R:5S - U S 955 U$s sn f) z`Emit the delegates inputs and outputs as specified by the schema, then emit the delegate's blob.Nryrrzself.node.meta['spec'] z is not supportedzCan't have a None delegate_ret)data)rindex)r processed compile_specsr)delegate_indexr )*processed_bytesrrrrr_rrrrrhrXrrrrCr@NotImplementedErrorrrr^rrrrr"INLINErrrtrrr rrrr tree_flattenrrr*r#)r~rr rwrrr delegate_retrrbrbackend_delegater delegate_argselems rX_emit_delegate_Emitter._emit_delegateUs)880::<++GGKKFS diinnV,d 3 3L%diinnU&;<77IINN5)%0$))..2H2O##C( =  v. 6 6$))../<<77IINN5)499>>&+A!+D!$v ! )$))..*? @HE;; u-e4diinnV6LU6SC!'', !A %\2  v. ; ;33 u%tyy~~f'=CL%)$tyy~~f/E*F)GGXY 'I)II'  !!!3!3!O!OPNES   : :6 B    4 4 ; ;)? +((2%,,N)66   $$++,<= {{4 ?D9 9   T * - -9  '' 5a8D   )9 && #&t'9'9'C'C#Dq#H&  # s&Rr8r9cZX4nURRRU5nUbX@RRU4$[ URR5[ XS9pTURRR U5 X@RRU'XE4$)zuGiven a fully qualified name, lookups the operator in the ExecuTorch Program, or adds it if it is not already presentr7)rrurrsrr1r)r~r8r9keyr;operators rXrE_Emitter._get_operators%%4488=  //99(CC C !3!3!=!=>A ( $$++H519))#.!!rSc  [U[RR[[ 45(d SU35eUR RnSnURS:wa URnS[4SjnURXES9upx/n /n [URR5HupU RU;aX4;d5S [%URR6SR$5S 35eURAURR6S5nUc#UR)[[CS555nO(UREURFRHS 5n[U[J5(aLUR)[[MUVs/sHn[O[PU5R.PM sn555OUn [RRT"U 5SH,nU R+[O[PU5R.5 M. URVRXR+[[[]XyS 955 UR_[!URVRX5S- U5 UR`Rb(aURFRHSnURVRd=(d /nUR+[gU55 URi[!U5[!URVRX5:HURFS[!URVRX5S[!U5S35 UURVl2[O[jU5$s snnfs snf)zUEmits an operator (aten or custom), directly translates to a call_kernel instruction.z target is rrzcr[[[RSS/S/SSSS[R S9 5$)z)Constructs an EValue for an empty tensor.rFN) scalar_typestorage_offsetsizes dim_order requires_gradr data_buffer_idxrr)r&r5r3BYTEr8STATICrWrSrX_get_empty_tensor_evalue9_Emitter._emit_operator.._get_empty_tensor_evalues@ *#$# c"'$%$(#6#=#=   rSr7rrzEOnly returning a single Sym from symbolic ops is supported currently.zKOnly symbolic ops that return a Int Bool Float are supported currently got r5ryr: stack_tracez?Each instruction should have corresponding stacktrace received z" instructions and z stacktraces)6rr_ops OpOverloadrr_overloadpacket_qualified_op_name _overloadnamer&rErX_schema argumentsr8 kwarg_onlyr default_valuerrrrrris_outrrreturnsrrr NumberTyperr+rrrrhr7rrrrrrr*r.rrrvrrrr)r~rvr rwop_name op_overloadrr;r kernel_argsout_argsrh schema_arg kernel_argrbrrrrchain_stacktraces rX_emit_operator_Emitter._emit_operators UZZ**NA" ' / /%-.X613XC.HM#a&sC v  FNN**+q0 WV W0..q1667   < E ]]abhbpbpbxbxyzb{cAcA^B]CCDE  E ##FNN$:$:1$=>C{''s1v7//$)).."89C #t$$   z3"O3C4#<#?#?3"OPQ  ''1!4D   tND9<< =5 &&  HG H  s4::#:#:;a?H    - -))..7K#zz44:   # #$<[$I J  ) )$%TZZ-D-D)EE QRUVZV`V`VmVmRnQop""%&6"7!8 F  %5DJJ !M3''e/,#Ps U0$Uc URRR[[ UR R U5S955 [SS5$)zJEmits a FreeCall instruction to release a given Unbounded Tensor's memory.) value_indexN)rrrr*r)rrrr}s rX _emit_free_Emitter._emit_free"sG && T-?-?-G-G-MN O dD))rS prim_getterscR/nUR5GHup4[R"U5upVUR5n[ ///SS9n/nUGHn [ U [ 5(a%UR[[U 555 M>[ U [5(a%UR[[U 555 Mx[ U [5(a%UR[[U 555 M[ U [5(a%UR[[U 555 M[ U [ R"5(a/UR[[[%U 5555 GM:[ U [ R&5(a/UR[[[)U 5555 GM[ U [ R*5(a6URUR-[.R0"U SS955 GM[3[4R6SUS[9U 5S35e UR[;UU/[=[?S[AU555U///S/[CS U5S 9 5 GM U$) z Given a mapping of function names to return values, emit simple execution plans that just return these constant values. Precondition: All the values are primitives (bool, float, int, str, enum) or structures (list, dict) of them. NrTrzError emitting z which returns a value of type z$. which is not a supported primitiverr r8rrrrchainsrsrtrcontainer_meta_type)"items ex_pytreerto_strr rrrr&r$rrrlr+rkr4rr r?r r;r5rr@ from_tensorrrrrr'rhrangerr!) r~rplansmethodrflattened_outputryrrrrs rX_emit_prim_getters_Emitter._emit_prim_getters*s (..0LF%.%;%;D%A " ;;=D EF'c5))MM&"56T**MM&c"34S))MM&S"23S))MM&"56U[[11MM&-=c-B)C"DEU\\22MM&[-=)>"?@U\\22MM33&223dC&'55)&1PQUVYQZP[[A7(B LL! q#f+!67!7  ,-3(9"d(C  ]1v rSc X>[TU]U5n[U[R5(a3UR UR [R"USS955$[U[RR5(a[[RSUS35eU$)zQFetch weights and other module parameters. If the attribute is a tensor, emit it.Trz Custom class z is not supported in EXIR)r fetch_attrrrr5rrr@r_C ScriptObjectrrr)r~rvattrrs rXr_Emitter.fetch_attrqsw!&) dELL ) )$$++J,B,B4t,TU ehh33 4 4--v%>?  KrScL[URURS55e)9Unsupported in execution IR, so unhandled by the emitter.zcall_module is not supportedrrrr~rvr rws rX call_module_Emitter.call_module&  * *4996T U  rScL[URURS55e)rzcall_method is not supportedrrs rX call_method_Emitter.call_methodrrSc URURnUS:XaOURURURR S55nX@RUR'U=RS- slU$)aPerforms actions for the placeholder node of a graph module. The placeholder node of the top level entry point is handled by TopLevelEmitter. This function only executes on control flow subgraphs. Takes the inputs of the subgraph that had not previously been emitted and emits them. rryr)rrrrrr)r~rvr rwr0s rX placeholder_Emitter.placeholders|))$*@*@A B;%%++DIINN6,BCEAF % %d&<&< = !# rSc[[R"US5S5UlURnUb[R"U5upVUR [ U5[ UR5:HURS5 [URU5HXupxXx:wdM [[URURS95n URRRU 5 MZ gg)aJPerforms actions for the output node of a graph module. The output node of the top level entry point is handled by TopLevelEmitter. This function only executes on control flow subgraphs. Takes the outputs of the subgraph (if any) and inserts instructions to move them to the common output location between control flow branches. rNzCThe number of binding output values should match the args to output) move_frommove_to)rhrrrrrrrrWr*r/rrrr) r~rvr rwrbinding_output_listrbrr instructions rXoutput_Emitter.outputs$((;(;DG(DQ(G#H $ : : ,%+%8%89N%O "   ) )'(C0H0H,II U  '*((*='" '"- 9<<L#KJJ++22;?' -rScZU[R:Xa^[U5S:Xde[R"[ [ [4US5n[R"[ US5nXE$U[R:Xa9[U5S:XdeURURRS5$U[R:XaURU5$U[R:Xa%[U5S:XdeUR!US5$U["R$R&R(["R$R&R*["R$R&R,["R$R&R.4;aUR1XU5$U[2:XasUSn[5U5(deUR7XbSSU5n[UR8R:5S- nUR=XU5 UR?Xh5 U$[AU["RBRD[F[H45(aURKXU5$[MUROURSU355e)aPerforms actions for the call_function node of a graph module. Dispatches based on 'target' and emits the corresponding function. 'call_function' is a powerful node that contains many operations ranging from control_flow, to memory management, to delegate and operator calls. r$rrryNz!invalid target for call_function )(rgetitemrrrr rlrmemoryallocrrrviewrfreerrr{r|rr while_loopr}rrrrrrrrrrrrrrrr) r~rvr rwheadrrrrs rXr_Emitter.call_functions, X%% %t9> !>;;wsM'9:DGDDKKT!W-E;  v|| #t9> !>??499>> : : v{{ "??4( ( v{{ "t9> !>??47+ +  II " " ' ' II " " + + II " " - - II " " ' '   **6@ @ / /!!WN$^44 44##NHfEA&)$***A*A&BQ&F #  " "#:N S  " "> KH  UZZ**N[TU]"/UQUP7SS06 g)zITraverses all nodes in the graph module and emits each one appropriately.enable_io_processingFN)rr*)r~rr rs rXr* _Emitter.runs  CTC;CUCrSnc >Xl[TU] U5nU$![aQn[ U[ [ 45(aUe[ URUR[U555UeSnAff=f)zExecutes and emits the specified node. For more context on what a node is and what execution means see https://pytorch.org/docs/stable/fx.html#torch.fx.Node N) rrrun_node Exceptionrrrrrk)r~r#rrrs rXr%_Emitter.run_node sv   '"1%C  !m[9::#22499c!fE  s A5A A00A5)rrrrrrrrrrrrrrr)rNN)NNr)r)Mrcrdrerfrgrr(rFrir)rprJrlr r rrrkrrrrr&rrrr@rrrrmrrr r rrrrBrrr rr2rTrtrrrrrrrrrrrCrrrr1rErrrr'rrrr r rrr*r%rn __classcell__rs@rXrrsC ((--)*?C@D(hh**(%(% ( #& ( 'tN';< ( (^(<=( ((TehhmmccRR % R;>R R+$y/+f+2- d9o- - - ^8I: Q  Q Q Q  Q(8<&* --- - ""34 - sm - -`?CLLLL.6smLL LL\ y)4 ?:;  4H H ;'H   H TJJ>J/y/]/6;%;D; M0IsN#M0+343G*HM0 n  M0^Q0IsN#Q0+/~*>Q0 n  Q0fj0IsN#j0+/~*>j0 n  j0X**%*9c>%:*DHiDX* *X"uY^4""R<@ ,8,8,8 9 ,8  ,8\ . "%    &JJ(0(=J J 5u~~u RS T . !  5u~~u RS T   tN#^U>3;N5OO P R.RIsN#RS)^$ R  Rh "# " "eCM>R "h(h(%*9c>%:h(DHiDXh( h(T*z*n*EtCH~E$}BUEN^$  %*9c>%: DHiDX    %*9c>%: DHiDX  %*9c>%:DHiDX ,@@%*9c>%:@DHiDX@ @<::%*9c>%::DHiDX: :~AEDDd588==)#;<=D  DD%((--DrSrc ^\rSrSrSrS\S\S\RRS\ S\ SS 4 U4S jjr S \ S \S\\\\44S jrS \ S\\S4S\\\4S\4SjrS \ S\\S4S\\\4SS 4SjrS\4SjrSrU=r$)_TopLevelEmitterizAn emitter that manages the root level operations within a graph module. Exists as a separate class so that 'Emitter' can handle the special behavior of 'placeholder' and 'output' nodes in control flow submodules. r8exported_programrrrrzNc<>[T U]X5U5 XlX l/Ul/UlSUlS[[RS[4SjnU"URR5nU"URR5n[Xx5Ulg)NFryrzc*Ucg[U[R5(d[U55eS/UR-n[ R RRX5n[R"U5up2UR5$)Nrr) rrTreeSpecr num_leavesrutilsrGtree_unflattenrrr)ry dummy_leavestreerbs rXcreate_container_str7_TopLevelEmitter.__init__..create_container_str5sr|dFOO44 @d4j @430L;;&&55lID,,T2GA;;= rS)rrr8r,rrgiven_mutable_buffer_warningr rr/rk call_specin_specout_specr!r) r~r8r,rrrr5inp_container_strout_container_strrs rXr_TopLevelEmitter.__init__%s mD 0!# "$ ,1) !x'@ !S !11A1K1K1S1ST01A1K1K1T1TU#4 $  rSrvrycSnSnXRRR;a&URRRUnX44$XRRR;aURRRUnX0RRRR 5;a4SnUR (d![R"S[SS9 SUlX44$UURRR;a#URRRUnX44$)NFTaMutation on a buffer in the model is detected. ExecuTorch assumes buffers that are mutated in the graph have a meaningless initial state, only the shape and dtype will be serialized, unless a pass which sets meta["et_init_buffer"] to True such as InitializedMutableBufferPass is run.r) stacklevel) r,graph_signatureinputs_to_parametersinputs_to_buffersbuffers_to_mutaterrr7warningswarn UserWarning!inputs_to_lifted_tensor_constants)r~rvryris_mutable_buffers rX_find_fqn_for_placeholder*_TopLevelEmitter._find_fqn_for_placeholderFs4! **::OO O''77LLVTC8%%5,,<<NN N''77II&QC++;;MMTTVV$(!88MMf$#$ 9=D5%% $$44VV W%%55WW  %%rSr .rwc ^URRSnURRRSS5nURRRSS5nSn[U[5(Gai[U[ 5(GaSUR X5umnS[S[S[4S jn UU "URURR5=(a# URSL=(a URSL-nUbeTcS 5eURc[T[ R"S 9UlO0TURl[ R"URlU(aUR(R*(a=URc[T[ R,S 9UlOXTURlOFURb URc,[/UR1URS US SS355eSn TURR2;aURR2Tn SnOTURR4;aURR4Tn SnOdTbaURR75n [9U4SjU 5S5n U bU n SnO)[/UR1URSTS355eU bU R;5(d2U R;[<R>S9(dU RA5n U RBU RE5RC5:waU RG5n U RE5Ul$U RK5Ul%[MURJ5Ul'U(aU(aSUl(OU=(d U(+Ul([U[ 5(aURSXE5OURUUS5n URWU 5nU(a%URXR[UR\5 U$)zEmits the value within the placeholder node. For more information on placeholder nodes see https://pytorch.org/docs/stable/fx.html#torch.fx.Graph.placeholder ryrNet_init_bufferTrr@rzcURS:Xa:[UR[5(aURUR;agg)zl Check if the node is buffer according to the provided graph signature. If it is one return its fqn as well r TF)rMrrvrkrB)rr@s rX _is_buffer0_TopLevelEmitter.placeholder.._is_buffer{s9 77m+!$++s33;;/*K*KK#'rSz6constant tagged tensors require a fully qualified name)rrzMutable buffer "r$z" must have a memory id and offset if we are emitting it without a name. Please either memory plan your mutable buffers or call to_executorch with config=ExecutorchBackendConfig(emit_mutable_buffer_names=True)Fc3B># UHoST:XdM USv M g7f)rrNrW)rrKrs rXr/_TopLevelEmitter.placeholder..sA'QqTS[DAaD's  zCould not find buffer with fqn z in state_dict or named_buffers)r )/rrrrrkr@rIrFrErr,r@rrrr(r6rrrrrwSEGMENTrr state_dict constants named_buffersnext is_contiguousr channels_last contiguousruntyped_storageclonerUstrider:rrrrrrrr)r~rvr rwryrinitialize_buffer is_user_inputrHrN real_tensorbuffersbufevaluer0rs @rXr _TopLevelEmitter.placeholderksyy~~f%yy~~)).$?  IINN../?F fc " "z$ 'C'C%)%C%CF%Q "C"  8L QU  499d&;&;&K&KL0KKt+0OO4/  'OLKL#))1-<-0;M;V;V.D*CFD**?6H6Q6QD**3 %%??--51@14%7%?%?2. GJ..C[[(DOO,C'66 II.vabzl;LMKd++666"33>>sC % --777"33==cB % //==?A'A4H?"%K$)M'66 II=cUBab& --//"00u?R?R0S"-"8"8":K%%)D)D)F)M)M)OO"-"3"3"5K*::< )002 !6t{{!C %6! "/"D3DE $ ++  ' ' ;))$5  !!&)  KK  uxx ( rSc [US[5(a[R"US5upEO'[R "[ [S4US5n[U[5(a&URRUR5 gUHn[U[[[[S545(a"URUR!US55nOU[U["5(a)[%UR'UR(SUS355e[U[5(deURRUR5 M g)zJRecords the ExecutionPlan's outputs based on the output node in the graph.r.Nz Returning z% is not yet supported in the emitter.)rrjrrrrr rrrrrlrrrrrrkrrr)r~rvr rw args_tuplerbrs rXr_TopLevelEmitter.outputs d1gt $ $"//Q8MJU>3+>%?aIJ j. 1 1 LL   .!cCd4j#ABB++D,D,DS$,OPCS))'66 II(-RS&c>:::: ##CFF+"rScp[URURRURUR UR /URRURR[R"[[URRS5URS9 $)z9Returns the execution plan emitted from this entry point.rr)r'r8rrrrrrrsrtrrr rlmodulerr)r~s rXplan_TopLevelEmitter.plan s%%,,;;LLJJ<((22((22$*;;S    !9:$ !% 8 8!  rS)rr,r7rr8r)rcrdrerfrgrkrDrr(r)rJrprrrr r rrIrrrr rr'rirnr(r)s@rXr+r+s   * hh**  %  %    B#&#&%(#& x}d" ##&J@@%*9c>%:@DHiDX@ @D,,%*9c>%:,DHiDX, ,8 m  rSr+)rgrrrrrD dataclassesrrrrrrr r r r r executorch.exir.memoryexirrexecutorch.extension.pytree extensionrrrtorch.fxexecutorch.exir.delegaterr%executorch.exir.dialects.backend._opsr"executorch.exir.dialects.edge._opsrexecutorch.exir.errorrrr executorch.exir.operator.convertr3executorch.exir.passes.executorch_prim_ops_registryrexecutorch.exir.print_programrrexecutorch.exir.schemarrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8executorch.exir.tensorr9r:r;r<r=r>r?r@executorch.exir.typesrArBtorch._subclasses.fake_tensorrCtorch.export.exported_programrDrE torch.fx.noderF torch.utilsrGtyping_extensionsrHrJrprrrirrlrrrr rrr StringTyperrrkrcomplexr r r rrr( Interpreterrr+rWrSrXrss0 (SSS''// PC=MM;IP!!!!!!!!!D   ;4O)' SS SD '' ',  !D(%0C*DD y c5%,,^@T TU iU  NN OO NN MM    Y8C$56;<< k    KK LL  LL   9"*/eCj4U3Z00*Y Iuxx##IX2~ x~ rS