ELF>@ @8 @ nnppp''%% @ @ @ @@ $$Std Ptd@@@D%D%QtdRtd GNUGNU=B<ݔlA 0 I0a!p%l"PBeJ+ AH F`D(҅@I6Dr%`N$h"AAAU 8R$B  "U M! 1IP`<H NB( 0 )0 H,fH`"J$@V@`  B%0359:=>?@ABFHIJLMOPQTVXYZ\]`cdeghijklmnoruwxyz}   !#$%'(,/13469:<?BFGHIKNOQRTUWXZ\^`dghjoqrtvwxz{~֮C}v"o h!BLx[}.@'/$u}Ա}+U1'U],pC=ǦISq~7SY $3MK_efIBA!ҕ/-z%K\7$:-%䄯_]hi&Vi_(MQ֊-f2`a0Gu- k6֝'rJgVhgk| *3a,Fh 7yuI9xcJLYC^V'856lxL!h ˧`7~oS8)l"K^b3[\w [A VH |ٶ8 Ff#[9I|y z'[ |d.g?CkxhmY @(P'BѪ=[) g0y[ĨOwG`.JP7+p )Qgخb%?-!<bMCWϫB2`'}1J#qrx9vϙã^wo)D O>AW !z$+^lwiLɯWuF +(0yQrn&)*(ęEn6"=رOcc!8_LJuJDPu|WIC:o_y&Ӽ%@VaO[dЁ A5A%hƊ$gQ2ߡz(I+R'f]EK {p8DK'Y(6uwFt>|/h0ȅD/H2@)ؕ!Mx rvW:wsz}2v$PH>}b0`W \]/%3hASjXoN=`CC}%EU2rHs!mC ?JFt~Q F" 5/DGr#2q-%U\|L(/\TupBeqC+$r;7((>kV3J=<@  SfANTP!Wx|4 s+~`E.2YJ<8#)#:dlIdEEaB8= ,v3inB)t:#V#;VfywNo# `fY` o-L3&^  Ky|t0dU\ >cBAjoZFlG^`p}S9t_"uvUA9KT*_5†a &tu03nl"  ^MNr1 I.B`,l=aV*\DppSS \Db xf 99X^ ,+t2^Rl 804`G WZJR?8va;10 $t`.U.Ti @.kc-fjq@HWZR"uy=YXA"'kEw]qd>AfϜt ;c6A2c"}WI&%- 2 aeiu3j4?7)tMli8vE 5Ec8lS.LJ6b{d0y8/||O(T t OGI|3Lyv&?{+PQ~4yba.s?fc`](_XrwݛN g:/@]p, -$=; ҉=xIs$Q_16tj &rRlO[" | " qM:Ci"h +FM ``Q0O"5 "0|Om" Z")i6" * !6"*j"OđFM2~"Oe"p/ "( 'p"j 3RONI H5")="OIFO"@="  H"JLn"6"p*y, OM"pJ<?OuOe)" Q"P f7`ЄOHPHLg"p5bM"= 7"*4"( m"@ l"Zс"!N`OFO81"]%" Y O qO4")lZ"  [MA^O+."<"b"kDQ"`Op_O["`k?^\"0O"(O"O/PON["@ M}O1" ?I"0b@PM"j <"R 6m"16"= B"pb q" R"OLHug4H6qpMpY"@)|Me`Ol"!9"0G 5"*~"=<i"@G<"`Z aM4"!4M4"(l'M!"0 ?QH"j!e"/ M " ON`Hc"0A@"bO6"0*<"<C@hO*"  W" = " Ɣ"0j!TbO7QMdVPO_"OM"= ҚM"POhMZ"0 P'O'OO"5O:5M+;"@@ E"1"N"On"+9,<r" r " XM:"Z@PQOl"puO`4Om"Pȝ`Al9,OYM," j"Y1=i"`J?VMo"p?ڒ"Zl" ׀OY"p)h"J" H:"6O "= y*"p!NOIpOJ"<y"p<x" bdM"=?[Of,Ok" Z 5") k"Y `HEvMVH"<)5")R*pO"p[<|1" \,M"bum"`1h"@J k'M"`j ,\"  ZO+"Z t"O" 1"F" gOi"pJ b"Oi"JO8k"Z !"@OG`~O1"`<: 6Oe"/<&" "k"0ZO4"`u R" " Oi DOM5"){O["PbJ"JkSM i"PJ ӈ OF~HRM4"jbk0TObh"IJZ" q5")m" g"`5 `"Z<i ZO"  ?"P /PhOiCM={" )"нO["O'ЫOFYMiO"<FaO"pZ–iM"`b A^H{MO"< `4POߘ"0} C"nb"`=g"I!b" p M"0ru"n" ck"Z e PM'="RO <Of,HU"`< %"  kOktM%"= nn"Ѓ " G v@"b 5"p) @M" 7"pj!70  g5On" Y")a@MF"O:"p6 " vD"w |O zp"P -* M"0[?~" *DpnO," )P"O1"<7@!OBgHf+"O"O"O_" p" *" ;M|"0= Z" u{"O( M~e"`/ k;"P@ODPMP_MOqn"<" <%O" j " JLOpPOg"I C nMF'"0OL"=< "= "Z@M~POB"hb<?MZm"0 h"J!"hb F"0JV" C"n F"O"@1C4M "pZO"0 PM" E0wO}"`B"h V"O~M"@}b˄"0kn"0<+h"I !OD"wb0M?"0GO" ><" __gmon_start___ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalize_ZN12vtkAlgorithm14GetInformationEv_ZN12vtkAlgorithm15SetAbortExecuteEi_ZN12vtkAlgorithm15GetAbortExecuteEv_ZN12vtkAlgorithm11SetProgressEd_ZN12vtkAlgorithm19GetProgressMinValueEv_ZN12vtkAlgorithm19GetProgressMaxValueEv_ZN12vtkAlgorithm11GetProgressEv_ZN12vtkAlgorithm15GetProgressTextEv_ZN12vtkAlgorithm12GetErrorCodeEv_ZN12vtkAlgorithm18SetInputDataObjectEP13vtkDataObject_ZN12vtkAlgorithm18AddInputDataObjectEP13vtkDataObject_ZN12vtkAlgorithm19GetProgressObserverEv_ZN12vtkAlgorithm3NewEv_ZNK12vtkAlgorithm19NewInstanceInternalEv_ZN13vtkPythonArgs13ArgCountErrorEii_ZN13vtkPythonArgs17GetArgAsVTKObjectEPKcRbPyErr_Occurred_ZN13vtkPythonUtil20GetObjectFromPointerEP13vtkObjectBase__stack_chk_fail_ZN17vtkPythonOverload10CallMethodEP11PyMethodDefP7_objectS3__ZN13vtkPythonArgs13ArgCountErrorEiPKc_ZN12vtkAlgorithm28SetDefaultExecutivePrototypeEP12vtkExecutive_Py_NoneStruct_ZN12vtkAlgorithm24CAN_HANDLE_PIECE_REQUESTEv_ZN12vtkAlgorithm22CAN_PRODUCE_SUB_EXTENTEv_ZN12vtkAlgorithm16INPUT_CONNECTIONEv_ZN12vtkAlgorithm10INPUT_PORTEv_ZN12vtkAlgorithm23INPUT_ARRAYS_TO_PROCESSEv_ZN12vtkAlgorithm24INPUT_REQUIRED_DATA_TYPEEv_ZN12vtkAlgorithm21INPUT_REQUIRED_FIELDSEv_ZN12vtkAlgorithm19INPUT_IS_REPEATABLEEv_ZN12vtkAlgorithm17INPUT_IS_OPTIONALEv_ZN12vtkAlgorithm3IsAEPKcstrcmp_ZN13vtkObjectBase8IsTypeOfEPKc_ZN12vtkAlgorithm14AbortExecuteOnEv_ZN12vtkAlgorithm15AbortExecuteOffEv_ZN13vtkPythonArgs8GetValueERPcPyLong_FromLong_ZN13vtkPythonArgs19GetSelfFromFirstArgEP7_objectS1__ZN12vtkAlgorithm17ReleaseDataFlagOnEv_ZN12vtkAlgorithm15RemoveAllInputsEv_ZN12vtkAlgorithm18ReleaseDataFlagOffEv_ZN12vtkAlgorithm12GetExecutiveEv_ZN12vtkAlgorithm22GetNumberOfOutputPortsEv_ZN12vtkAlgorithm12HasExecutiveEv_ZN12vtkAlgorithm21GetNumberOfInputPortsEv_ZN12vtkAlgorithm32GetTotalNumberOfInputConnectionsEvPyFloat_FromDoublePyLong_FromUnsignedLong_ZN12vtkAlgorithm19SetProgressObserverEP19vtkProgressObserver_ZN13vtkPythonArgs8GetValueERd_ZN12vtkAlgorithm14UpdateProgressEd_ZN12vtkAlgorithm15SetProgressTextEPKc_ZN13vtkPythonArgs8GetValueERi_ZN12vtkAlgorithm23GetInputPortInformationEi_ZN12vtkAlgorithm27GetNumberOfInputConnectionsEi_ZN12vtkAlgorithm20GetOutputInformationEi_ZN12vtkAlgorithm19GetOutputDataObjectEi_ZN12vtkAlgorithm24GetOutputPortInformationEi_ZN12vtkAlgorithm24GetInputArrayInformationEi_ZN12vtkAlgorithm15GetUpdateExtentEi_ZN13vtkPythonArgs10BuildTupleEPKiistrlenPyUnicode_FromStringAndSizePyErr_ClearPyBytes_FromStringAndSize_ZN12vtkAlgorithm19UpdateExtentIsEmptyEP14vtkInformationi_ZN12vtkAlgorithm18GetInputDataObjectEii_ZN12vtkAlgorithm18GetInputConnectionEii_ZN12vtkAlgorithm19UpdateExtentIsEmptyEP14vtkInformationP13vtkDataObject_ZN12vtkAlgorithm14ProcessRequestEP14vtkInformationP13vtkCollectionP20vtkInformationVector_ZN13vtkPythonArgs8GetArrayEPii_ZN12vtkAlgorithm15GetUpdateExtentEiPi_ZN13vtkPythonArgs8SetArrayEiPKii_ZN12vtkAlgorithm33ConvertTotalInputToPortConnectionEiRiS0__ZN13vtkPythonArgs11SetArgValueEiiPyVTKObject_CheckPyVTKObject_GetObjectPyVTKObject_SetFlag_ZN12vtkAlgorithm14GetUpdatePieceEi_ZN12vtkAlgorithm13GetOutputPortEi_ZN12vtkAlgorithm23GetUpdateNumberOfPiecesEi_ZN12vtkAlgorithm19GetUpdateGhostLevelEi_ZN12vtkAlgorithm19GetInputInformationEii_ZN12vtkAlgorithm17GetInputExecutiveEii_ZN12vtkAlgorithm17GetInputAlgorithmEiiRi_ZN12vtkAlgorithm17GetInputAlgorithmEii_ZN12vtkAlgorithm15GetUpdateExtentEiRiS0_S0_S0_S0_S0__Z46PyvtkAlgorithm_DesiredOutputPrecision_FromEnumiPy_BuildValuePyLong_Type_Py_DeallocPyvtkAlgorithm_ClassNewPyVTKClass_AddPyvtkObject_ClassNewPyType_Ready_ZN13vtkPythonUtil12AddEnumToMapEP11_typeobjectPyDict_SetItemStringPyVTKAddFile_vtkAlgorithm_ZN12vtkAlgorithm18GetReleaseDataFlagEv_ZN12vtkAlgorithm18SetReleaseDataFlagEi_ZN12vtkAlgorithm17UpdateWholeExtentEv_ZN12vtkAlgorithm21PropagateUpdateExtentEv_ZN12vtkAlgorithm16UpdateDataObjectEv_ZN12vtkAlgorithm17UpdateInformationEv_ZN13vtkPythonArgs10GetArgSizeEi_ZN12vtkAlgorithm14UpdateTimeStepEdiiiPKi_ZN12vtkAlgorithm12UpdateExtentEPKi_ZN12vtkAlgorithm11UpdatePieceEiiiPKi_ZN12vtkAlgorithm6UpdateEP14vtkInformation_ZN12vtkAlgorithm6UpdateEi_ZN12vtkAlgorithm6UpdateEv_ZN12vtkAlgorithm6UpdateEiP20vtkInformationVector_ZN12vtkAlgorithm18AddInputDataObjectEiP13vtkDataObject_ZN12vtkAlgorithm18SetInputDataObjectEiP13vtkDataObject_ZN12vtkAlgorithm25RemoveAllInputConnectionsEi_ZN12vtkAlgorithm21RemoveInputConnectionEii_ZN12vtkAlgorithm21RemoveInputConnectionEiP18vtkAlgorithmOutput_ZN12vtkAlgorithm18AddInputConnectionEP18vtkAlgorithmOutput_ZN12vtkAlgorithm18AddInputConnectionEiP18vtkAlgorithmOutput_ZN12vtkAlgorithm18SetInputConnectionEP18vtkAlgorithmOutput_ZN12vtkAlgorithm18SetInputConnectionEiP18vtkAlgorithmOutput_ZN12vtkAlgorithm22SetInputArrayToProcessEiiiPKcS1__ZN12vtkAlgorithm22SetInputArrayToProcessEiiiii_ZN12vtkAlgorithm22SetInputArrayToProcessEiiiiPKc_ZN12vtkAlgorithm22SetInputArrayToProcessEiP14vtkInformation_ZN12vtkAlgorithm14SetInformationEP14vtkInformation_ZN12vtkAlgorithm13ModifyRequestEP14vtkInformationi_ZN12vtkAlgorithm12SetExecutiveEP12vtkExecutivePyType_TypePyVTKObject_DeletePyVTKObject_ReprPyVTKObject_StringPyObject_GenericGetAttrPyObject_GenericSetAttrPyVTKObject_AsBufferPyVTKObject_TraversePyVTKObject_GetSetPyVTKObject_NewPyObject_GC_DelPyObject_Free_ZN18vtkAlgorithmOutput3NewEv_ZNK18vtkAlgorithmOutput19NewInstanceInternalEv_ZN18vtkAlgorithmOutput3IsAEPKc_ZN18vtkAlgorithmOutput8GetIndexEv_ZN18vtkAlgorithmOutput11GetProducerEv_ZN18vtkAlgorithmOutput11SetProducerEP12vtkAlgorithm_ZN18vtkAlgorithmOutput8SetIndexEiPyvtkAlgorithmOutput_ClassNewPyVTKAddFile_vtkAlgorithmOutput_ZN28vtkAnnotationLayersAlgorithm3NewEv_ZNK28vtkAnnotationLayersAlgorithm19NewInstanceInternalEv_ZN28vtkAnnotationLayersAlgorithm3IsAEPKc_ZN28vtkAnnotationLayersAlgorithm9GetOutputEi_ZN28vtkAnnotationLayersAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkAnnotationLayersAlgorithm_ClassNewPyVTKAddFile_vtkAnnotationLayersAlgorithm_ZN21vtkArrayDataAlgorithm3NewEv_ZNK21vtkArrayDataAlgorithm19NewInstanceInternalEv_ZN21vtkArrayDataAlgorithm3IsAEPKc_ZN21vtkArrayDataAlgorithm9GetOutputEi_ZN21vtkArrayDataAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkArrayDataAlgorithm_ClassNewPyVTKAddFile_vtkArrayDataAlgorithm_ZN38vtkCachedStreamingDemandDrivenPipeline12GetCacheSizeEv_ZN38vtkCachedStreamingDemandDrivenPipeline3NewEv_ZNK38vtkCachedStreamingDemandDrivenPipeline19NewInstanceInternalEv_ZN38vtkCachedStreamingDemandDrivenPipeline3IsAEPKc_ZN38vtkCachedStreamingDemandDrivenPipeline12SetCacheSizeEiPyvtkCachedStreamingDemandDrivenPipeline_ClassNewPyvtkStreamingDemandDrivenPipeline_ClassNewPyVTKAddFile_vtkCachedStreamingDemandDrivenPipeline_ZN17vtkCastToConcrete3NewEv_ZNK17vtkCastToConcrete19NewInstanceInternalEv_ZN17vtkCastToConcrete3IsAEPKcPyvtkCastToConcrete_ClassNewPyvtkDataSetAlgorithm_ClassNewPyVTKAddFile_vtkCastToConcrete_ZN24vtkCompositeDataPipeline3NewEv_ZNK24vtkCompositeDataPipeline19NewInstanceInternalEv_ZN24vtkCompositeDataPipeline22BLOCK_AMOUNT_OF_DETAILEv_ZN24vtkCompositeDataPipeline24UPDATE_COMPOSITE_INDICESEv_ZN24vtkCompositeDataPipeline24COMPOSITE_DATA_META_DATAEv_ZN24vtkCompositeDataPipeline21LOAD_REQUESTED_BLOCKSEv_ZN24vtkCompositeDataPipeline22GetCompositeOutputDataEi_ZN24vtkCompositeDataPipeline3IsAEPKcPyvtkCompositeDataPipeline_ClassNewPyVTKAddFile_vtkCompositeDataPipeline_ZN28vtkCompositeDataSetAlgorithm3NewEv_ZNK28vtkCompositeDataSetAlgorithm19NewInstanceInternalEv_ZN28vtkCompositeDataSetAlgorithm3IsAEPKc_ZN28vtkCompositeDataSetAlgorithm9GetOutputEv_ZN28vtkCompositeDataSetAlgorithm9GetOutputEi_ZN28vtkCompositeDataSetAlgorithm12SetInputDataEP13vtkDataObject_ZN28vtkCompositeDataSetAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkCompositeDataSetAlgorithm_ClassNewPyVTKAddFile_vtkCompositeDataSetAlgorithm_ZN22vtkDataObjectAlgorithm3NewEv_ZNK22vtkDataObjectAlgorithm19NewInstanceInternalEv_ZN22vtkDataObjectAlgorithm3IsAEPKc_ZN22vtkDataObjectAlgorithm8GetInputEv_ZN22vtkDataObjectAlgorithm8GetInputEi_ZN22vtkDataObjectAlgorithm9GetOutputEv_ZN22vtkDataObjectAlgorithm9GetOutputEi_ZN22vtkDataObjectAlgorithm12AddInputDataEP13vtkDataObject_ZN22vtkDataObjectAlgorithm12AddInputDataEiP13vtkDataObject_ZN22vtkDataObjectAlgorithm12SetInputDataEP13vtkDataObject_ZN22vtkDataObjectAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkDataObjectAlgorithm_ClassNewPyVTKAddFile_vtkDataObjectAlgorithm_ZN22vtkDataObjectAlgorithm9SetOutputEP13vtkDataObject_ZN19vtkDataSetAlgorithm3NewEv_ZNK19vtkDataSetAlgorithm19NewInstanceInternalEv_ZN19vtkDataSetAlgorithm3IsAEPKc_ZN19vtkDataSetAlgorithm8GetInputEv_ZN19vtkDataSetAlgorithm17GetPolyDataOutputEv_ZN19vtkDataSetAlgorithm25GetUnstructuredGridOutputEv_ZN19vtkDataSetAlgorithm24GetRectilinearGridOutputEv_ZN19vtkDataSetAlgorithm18GetImageDataOutputEv_ZN19vtkDataSetAlgorithm23GetStructuredGridOutputEv_ZN19vtkDataSetAlgorithm25GetStructuredPointsOutputEv_ZN19vtkDataSetAlgorithm12SetInputDataEP13vtkDataObject_ZN19vtkDataSetAlgorithm12AddInputDataEP10vtkDataSet_ZN19vtkDataSetAlgorithm12AddInputDataEP13vtkDataObject_ZN19vtkDataSetAlgorithm12SetInputDataEP10vtkDataSet_ZN19vtkDataSetAlgorithm12SetInputDataEiP13vtkDataObject_ZN19vtkDataSetAlgorithm12AddInputDataEiP10vtkDataSet_ZN19vtkDataSetAlgorithm12AddInputDataEiP13vtkDataObject_ZN19vtkDataSetAlgorithm12SetInputDataEiP10vtkDataSet_ZN19vtkDataSetAlgorithm9GetOutputEv_ZN19vtkDataSetAlgorithm9GetOutputEiPyVTKAddFile_vtkDataSetAlgorithm_ZN23vtkDemandDrivenPipeline16GetPipelineMTimeEv_ZN23vtkDemandDrivenPipeline3NewEv_ZNK23vtkDemandDrivenPipeline19NewInstanceInternalEv_ZN23vtkDemandDrivenPipeline13NewDataObjectEPKc_ZN23vtkDemandDrivenPipeline18DATA_NOT_GENERATEDEv_ZN23vtkDemandDrivenPipeline12RELEASE_DATAEv_ZN23vtkDemandDrivenPipeline26REQUEST_DATA_NOT_GENERATEDEv_ZN23vtkDemandDrivenPipeline12REQUEST_DATAEv_ZN23vtkDemandDrivenPipeline19REQUEST_INFORMATIONEv_ZN23vtkDemandDrivenPipeline19REQUEST_DATA_OBJECTEv_ZN23vtkDemandDrivenPipeline3IsAEPKcPyvtkDemandDrivenPipeline_ClassNewPyvtkExecutive_ClassNewPyVTKAddFile_vtkDemandDrivenPipeline_ZN23vtkDemandDrivenPipeline10UpdateDataEi_ZN23vtkDemandDrivenPipeline17UpdateInformationEv_ZN23vtkDemandDrivenPipeline16UpdateDataObjectEv_ZN23vtkDemandDrivenPipeline19UpdatePipelineMTimeEv_ZN23vtkDemandDrivenPipeline18GetReleaseDataFlagEi_ZN23vtkDemandDrivenPipeline18SetReleaseDataFlagEii_ZN23vtkDemandDrivenPipeline6UpdateEi_ZN23vtkDemandDrivenPipeline6UpdateEv_ZN25vtkDirectedGraphAlgorithm3NewEv_ZNK25vtkDirectedGraphAlgorithm19NewInstanceInternalEv_ZN25vtkDirectedGraphAlgorithm3IsAEPKc_ZN25vtkDirectedGraphAlgorithm9GetOutputEi_ZN25vtkDirectedGraphAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkDirectedGraphAlgorithm_ClassNewPyVTKAddFile_vtkDirectedGraphAlgorithm_ZN17vtkEnsembleSource16SetCurrentMemberEj_ZN17vtkEnsembleSource16GetCurrentMemberEv_ZN17vtkEnsembleSource3NewEv_ZNK17vtkEnsembleSource19NewInstanceInternalEv_ZN17vtkEnsembleSource13UPDATE_MEMBEREv_ZN17vtkEnsembleSource9META_DATAEv_ZN17vtkEnsembleSource3IsAEPKc_ZN17vtkEnsembleSource16RemoveAllMembersEv_ZN17vtkEnsembleSource18GetNumberOfMembersEv_ZN17vtkEnsembleSource11SetMetaDataEP8vtkTable_ZN17vtkEnsembleSource9AddMemberEP12vtkAlgorithm_ZN13vtkPythonArgs8GetValueERjPyvtkEnsembleSource_ClassNewPyVTKAddFile_vtkEnsembleSource_ZN12vtkExecutive17UpdateInformationEv_ZNK12vtkExecutive19NewInstanceInternalEv_ZN9vtkObject3NewEv_ZN12vtkExecutive12KEYS_TO_COPYEv_ZN12vtkExecutive17FORWARD_DIRECTIONEv_ZN12vtkExecutive19ALGORITHM_DIRECTIONEv_ZN12vtkExecutive23ALGORITHM_AFTER_FORWARDEv_ZN12vtkExecutive24ALGORITHM_BEFORE_FORWARDEv_ZN12vtkExecutive16FROM_OUTPUT_PORTEv_ZN12vtkExecutive9CONSUMERSEv_ZN12vtkExecutive8PRODUCEREv_ZN12vtkExecutive3IsAEPKc_ZN12vtkExecutive21GetNumberOfInputPortsEv_ZN12vtkExecutive12GetAlgorithmEv_ZN12vtkExecutive22GetNumberOfOutputPortsEv_ZN12vtkExecutive26SetSharedOutputInformationEP20vtkInformationVector_ZN12vtkExecutive27GetNumberOfInputConnectionsEi_ZN12vtkExecutive17GetInputExecutiveEii_ZN12vtkExecutive19GetInputInformationEii_ZN12vtkExecutive19GetInputInformationEiPyVTKAddFile_vtkExecutive_ZN12vtkExecutive12GetInputDataEii_ZN12vtkExecutive13SetOutputDataEiP13vtkDataObjectP14vtkInformation_ZN12vtkExecutive13SetOutputDataEiP13vtkDataObject_ZN12vtkExecutive13GetOutputDataEi_ZN12vtkExecutive20GetOutputInformationEv_ZN12vtkExecutive20GetOutputInformationEi_ZN12vtkExecutive6UpdateEi_ZN12vtkExecutive6UpdateEv_ZN17vtkExtentSplitter12GetPointModeEv_ZN17vtkExtentSplitter12SetPointModeEi_ZN17vtkExtentSplitter3NewEv_ZNK17vtkExtentSplitter19NewInstanceInternalEv_ZN17vtkExtentSplitter3IsAEPKc_ZN17vtkExtentSplitter11PointModeOnEv_ZN17vtkExtentSplitter12PointModeOffEv_ZN17vtkExtentSplitter22RemoveAllExtentSourcesEv_ZN17vtkExtentSplitter17ComputeSubExtentsEv_ZN17vtkExtentSplitter21GetNumberOfSubExtentsEv_ZN17vtkExtentSplitter18RemoveExtentSourceEi_ZN17vtkExtentSplitter18GetSubExtentSourceEi_ZN13vtkPythonArgs5ArrayIiEC1El_ZdaPv_ZN17vtkExtentSplitter12GetSubExtentEi_ZN17vtkExtentSplitter12GetSubExtentEiPi__gxx_personality_v0_Unwind_Resume_ZN17vtkExtentSplitter9AddExtentEiiiiii_ZN17vtkExtentSplitter9AddExtentEPi_ZN17vtkExtentSplitter15AddExtentSourceEiiiiiiii_ZN17vtkExtentSplitter15AddExtentSourceEiiPiPyvtkExtentSplitter_ClassNewPyVTKAddFile_vtkExtentSplitter_ZN19vtkExtentTranslator14SetWholeExtentEiiiiii_ZN19vtkExtentTranslator14GetWholeExtentEv_ZN19vtkExtentTranslator9SetExtentEiiiiii_ZN19vtkExtentTranslator9GetExtentEv_ZN19vtkExtentTranslator8SetPieceEi_ZN19vtkExtentTranslator8GetPieceEv_ZN19vtkExtentTranslator17SetNumberOfPiecesEi_ZN19vtkExtentTranslator17GetNumberOfPiecesEv_ZN19vtkExtentTranslator13SetGhostLevelEi_ZN19vtkExtentTranslator13GetGhostLevelEv_ZN19vtkExtentTranslator12GetSplitModeEv_ZN19vtkExtentTranslator3NewEv_ZNK19vtkExtentTranslator19NewInstanceInternalEv_ZN19vtkExtentTranslator17UPDATE_SPLIT_MODEEv_ZN19vtkExtentTranslator3IsAEPKc_ZN19vtkExtentTranslator14SetWholeExtentEPi_ZN19vtkExtentTranslator9SetExtentEPi_ZN19vtkExtentTranslator12SetSplitPathEiPi_Z36PyvtkExtentTranslator_Modes_FromEnumiPyvtkExtentTranslator_ClassNewPyVTKAddFile_vtkExtentTranslator_ZN19vtkExtentTranslator23PieceToExtentThreadSafeEiiiPiS0_ii_ZN19vtkExtentTranslator21PieceToExtentByPointsEv_ZN19vtkExtentTranslator13PieceToExtentEvPyObject_HashNotImplemented_ZN33vtkFilteringInformationKeyManagerD1Ev_ZdlPvPyDict_Size_Znwm_ZN33vtkFilteringInformationKeyManagerC1EvPyVTKSpecialObject_NewPyExc_TypeErrorPyErr_SetStringPyvtkFilteringInformationKeyManager_TypeNewPyVTKSpecialType_AddPyVTKAddFile_vtkFilteringInformationKeyManager_ZN20vtkDebugLeaksManagerC1Ev_ZN20vtkDebugLeaksManagerD1Ev__cxa_atexitPyVTKSpecialObject_Repr_ZN17vtkGraphAlgorithm3NewEv_ZNK17vtkGraphAlgorithm19NewInstanceInternalEv_ZN17vtkGraphAlgorithm3IsAEPKc_ZN17vtkGraphAlgorithm9GetOutputEi_ZN17vtkGraphAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkGraphAlgorithm_ClassNewPyVTKAddFile_vtkGraphAlgorithm_ZN34vtkHierarchicalBoxDataSetAlgorithm3NewEv_ZNK34vtkHierarchicalBoxDataSetAlgorithm19NewInstanceInternalEv_ZN34vtkHierarchicalBoxDataSetAlgorithm3IsAEPKc_ZN34vtkHierarchicalBoxDataSetAlgorithm9GetOutputEv_ZN34vtkHierarchicalBoxDataSetAlgorithm9GetOutputEi_ZN34vtkHierarchicalBoxDataSetAlgorithm12SetInputDataEP13vtkDataObject_ZN34vtkHierarchicalBoxDataSetAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkHierarchicalBoxDataSetAlgorithm_ClassNewPyVTKAddFile_vtkHierarchicalBoxDataSetAlgorithm_ZNK25vtkHyperTreeGridAlgorithm19NewInstanceInternalEv_ZN25vtkHyperTreeGridAlgorithm3IsAEPKc_ZN25vtkHyperTreeGridAlgorithm9GetOutputEv_ZN25vtkHyperTreeGridAlgorithm9GetOutputEi_ZN25vtkHyperTreeGridAlgorithm17GetPolyDataOutputEv_ZN25vtkHyperTreeGridAlgorithm17GetPolyDataOutputEi_ZN25vtkHyperTreeGridAlgorithm25GetUnstructuredGridOutputEv_ZN25vtkHyperTreeGridAlgorithm25GetUnstructuredGridOutputEi_ZN25vtkHyperTreeGridAlgorithm22GetHyperTreeGridOutputEv_ZN25vtkHyperTreeGridAlgorithm22GetHyperTreeGridOutputEi_ZN25vtkHyperTreeGridAlgorithm12AddInputDataEP13vtkDataObject_ZN25vtkHyperTreeGridAlgorithm12AddInputDataEiP13vtkDataObject_ZN25vtkHyperTreeGridAlgorithm12SetInputDataEP13vtkDataObject_ZN25vtkHyperTreeGridAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkHyperTreeGridAlgorithm_ClassNewPyVTKAddFile_vtkHyperTreeGridAlgorithm_ZN25vtkHyperTreeGridAlgorithm9SetOutputEP13vtkDataObject_ZNK17vtkImageAlgorithm19NewInstanceInternalEv_ZN17vtkImageAlgorithm3IsAEPKc_ZN17vtkImageAlgorithm17GetImageDataInputEi_ZN17vtkImageAlgorithm9GetOutputEv_ZN17vtkImageAlgorithm9GetOutputEi_ZN17vtkImageAlgorithm8GetInputEi_ZN17vtkImageAlgorithm12SetInputDataEP13vtkDataObject_ZN17vtkImageAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkImageAlgorithm_ClassNewPyVTKAddFile_vtkImageAlgorithm_ZN17vtkImageAlgorithm12AddInputDataEP13vtkDataObject_ZN17vtkImageAlgorithm12AddInputDataEiP13vtkDataObject_ZN17vtkImageAlgorithm9SetOutputEP13vtkDataObject_ZNK21vtkImageInPlaceFilter19NewInstanceInternalEv_ZN21vtkImageInPlaceFilter3IsAEPKcPyvtkImageInPlaceFilter_ClassNewPyVTKAddFile_vtkImageInPlaceFilterPyVTKAddFile_vtkImageProgressIterator_ZN24vtkImageToStructuredGrid3NewEv_ZNK24vtkImageToStructuredGrid19NewInstanceInternalEv_ZN24vtkImageToStructuredGrid3IsAEPKcPyvtkImageToStructuredGrid_ClassNewPyvtkStructuredGridAlgorithm_ClassNewPyVTKAddFile_vtkImageToStructuredGrid_ZN26vtkImageToStructuredPoints3NewEv_ZNK26vtkImageToStructuredPoints19NewInstanceInternalEv_ZN26vtkImageToStructuredPoints3IsAEPKc_ZN26vtkImageToStructuredPoints14GetVectorInputEv_ZN26vtkImageToStructuredPoints25GetStructuredPointsOutputEv_ZN26vtkImageToStructuredPoints18SetVectorInputDataEP12vtkImageDataPyvtkImageToStructuredPoints_ClassNewPyVTKAddFile_vtkImageToStructuredPoints_ZN35vtkInformationDataObjectMetaDataKeyC1EPKcS1__ZNK35vtkInformationDataObjectMetaDataKey19NewInstanceInternalEv_ZN13vtkObjectBaseC1Ev_ZN13vtkObjectBase20InitializeObjectBaseEv_ZN35vtkInformationDataObjectMetaDataKey3IsAEPKcPyvtkInformationDataObjectMetaDataKey_ClassNewPyvtkInformationDataObjectKey_ClassNewPyVTKAddFile_vtkInformationDataObjectMetaDataKey_ZN30vtkCommonInformationKeyManagerC1Ev_ZN30vtkCommonInformationKeyManagerD1Ev_ZN35vtkInformationDataObjectMetaDataKey22CopyDefaultInformationEP14vtkInformationS1_S1__ZN30vtkInformationExecutivePortKeyC1EPKcS1__ZNK30vtkInformationExecutivePortKey19NewInstanceInternalEv_ZN30vtkInformationExecutivePortKey3IsAEPKc_ZN30vtkInformationExecutivePortKey7GetPortEP14vtkInformation_ZN30vtkInformationExecutivePortKey12GetExecutiveEP14vtkInformation_ZN30vtkInformationExecutivePortKey3SetEP14vtkInformationP12vtkExecutiveiPyvtkInformationExecutivePortKey_ClassNewPyvtkInformationKey_ClassNewPyVTKAddFile_vtkInformationExecutivePortKey_ZN30vtkInformationExecutivePortKey6ReportEP14vtkInformationP19vtkGarbageCollector_ZN30vtkInformationExecutivePortKey11ShallowCopyEP14vtkInformationS1__ZN36vtkInformationExecutivePortVectorKeyC1EPKcS1__ZNK36vtkInformationExecutivePortVectorKey19NewInstanceInternalEv_ZN36vtkInformationExecutivePortVectorKey3IsAEPKc_ZN36vtkInformationExecutivePortVectorKey6LengthEP14vtkInformation_ZN36vtkInformationExecutivePortVectorKey8GetPortsEP14vtkInformation_ZN13vtkPythonUtil13ManglePointerEPKvPKcPyUnicode_FromString_ZN36vtkInformationExecutivePortVectorKey6AppendEP14vtkInformationP12vtkExecutiveiPyvtkInformationExecutivePortVectorKey_ClassNewPyVTKAddFile_vtkInformationExecutivePortVectorKey_ZN36vtkInformationExecutivePortVectorKey6ReportEP14vtkInformationP19vtkGarbageCollector_ZN36vtkInformationExecutivePortVectorKey11ShallowCopyEP14vtkInformationS1__ZN36vtkInformationExecutivePortVectorKey6RemoveEP14vtkInformationP12vtkExecutivei_ZN36vtkInformationExecutivePortVectorKey6RemoveEP14vtkInformation_ZN31vtkInformationIntegerRequestKeyC1EPKcS1__ZNK31vtkInformationIntegerRequestKey19NewInstanceInternalEv_ZN31vtkInformationIntegerRequestKey3IsAEPKcPyvtkInformationIntegerRequestKey_ClassNewPyvtkInformationIntegerKey_ClassNewPyVTKAddFile_vtkInformationIntegerRequestKey_ZN31vtkInformationIntegerRequestKey22CopyDefaultInformationEP14vtkInformationS1_S1__ZN31vtkInformationIntegerRequestKey13StoreMetaDataEP14vtkInformationS1_S1_PyBool_FromLong_ZN31vtkInformationIntegerRequestKey13NeedToExecuteEP14vtkInformationS1__ZN29vtkMultiBlockDataSetAlgorithm3NewEv_ZNK29vtkMultiBlockDataSetAlgorithm19NewInstanceInternalEv_ZN29vtkMultiBlockDataSetAlgorithm3IsAEPKc_ZN29vtkMultiBlockDataSetAlgorithm9GetOutputEv_ZN29vtkMultiBlockDataSetAlgorithm9GetOutputEi_ZN29vtkMultiBlockDataSetAlgorithm12SetInputDataEP13vtkDataObject_ZN29vtkMultiBlockDataSetAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkMultiBlockDataSetAlgorithm_ClassNewPyVTKAddFile_vtkMultiBlockDataSetAlgorithm_ZN25vtkMultiTimeStepAlgorithm3NewEv_ZNK25vtkMultiTimeStepAlgorithm19NewInstanceInternalEv_ZN25vtkMultiTimeStepAlgorithm3IsAEPKcPyvtkMultiTimeStepAlgorithm_ClassNewPyVTKAddFile_vtkMultiTimeStepAlgorithm_ZNSt8ios_base4InitC1Ev_ZNSt8ios_base4InitD1Ev_ZN25vtkPassInputTypeAlgorithm3NewEv_ZNK25vtkPassInputTypeAlgorithm19NewInstanceInternalEv_ZN25vtkPassInputTypeAlgorithm3IsAEPKc_ZN25vtkPassInputTypeAlgorithm17GetPolyDataOutputEv_ZN25vtkPassInputTypeAlgorithm25GetStructuredPointsOutputEv_ZN25vtkPassInputTypeAlgorithm18GetImageDataOutputEv_ZN25vtkPassInputTypeAlgorithm23GetStructuredGridOutputEv_ZN25vtkPassInputTypeAlgorithm25GetUnstructuredGridOutputEv_ZN25vtkPassInputTypeAlgorithm24GetRectilinearGridOutputEv_ZN25vtkPassInputTypeAlgorithm14GetTableOutputEv_ZN25vtkPassInputTypeAlgorithm14GetGraphOutputEv_ZN25vtkPassInputTypeAlgorithm8GetInputEv_ZN25vtkPassInputTypeAlgorithm9GetOutputEv_ZN25vtkPassInputTypeAlgorithm9GetOutputEi_ZN25vtkPassInputTypeAlgorithm12SetInputDataEP13vtkDataObject_ZN25vtkPassInputTypeAlgorithm12SetInputDataEiP13vtkDataObject_ZN25vtkPassInputTypeAlgorithm12AddInputDataEP13vtkDataObject_ZN25vtkPassInputTypeAlgorithm12AddInputDataEiP13vtkDataObjectPyvtkPassInputTypeAlgorithm_ClassNewPyVTKAddFile_vtkPassInputTypeAlgorithm_ZN29vtkPiecewiseFunctionAlgorithm3NewEv_ZNK29vtkPiecewiseFunctionAlgorithm19NewInstanceInternalEv_ZN29vtkPiecewiseFunctionAlgorithm3IsAEPKc_ZN29vtkPiecewiseFunctionAlgorithm8GetInputEv_ZN29vtkPiecewiseFunctionAlgorithm8GetInputEi_ZN29vtkPiecewiseFunctionAlgorithm9GetOutputEv_ZN29vtkPiecewiseFunctionAlgorithm9GetOutputEi_ZN29vtkPiecewiseFunctionAlgorithm12AddInputDataEP13vtkDataObject_ZN29vtkPiecewiseFunctionAlgorithm12AddInputDataEiP13vtkDataObject_ZN29vtkPiecewiseFunctionAlgorithm12SetInputDataEP13vtkDataObject_ZN29vtkPiecewiseFunctionAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkPiecewiseFunctionAlgorithm_ClassNewPyVTKAddFile_vtkPiecewiseFunctionAlgorithm_ZN29vtkPiecewiseFunctionAlgorithm9SetOutputEP13vtkDataObject_ZN30vtkPiecewiseFunctionShiftScale16SetPositionShiftEd_ZN30vtkPiecewiseFunctionShiftScale16SetPositionScaleEd_ZN30vtkPiecewiseFunctionShiftScale13SetValueShiftEd_ZN30vtkPiecewiseFunctionShiftScale13SetValueScaleEd_ZN30vtkPiecewiseFunctionShiftScale16GetPositionShiftEv_ZN30vtkPiecewiseFunctionShiftScale16GetPositionScaleEv_ZN30vtkPiecewiseFunctionShiftScale13GetValueShiftEv_ZN30vtkPiecewiseFunctionShiftScale13GetValueScaleEv_ZN30vtkPiecewiseFunctionShiftScale3NewEv_ZNK30vtkPiecewiseFunctionShiftScale19NewInstanceInternalEv_ZN30vtkPiecewiseFunctionShiftScale3IsAEPKcPyvtkPiecewiseFunctionShiftScale_ClassNewPyVTKAddFile_vtkPiecewiseFunctionShiftScale_ZN20vtkPointSetAlgorithm3NewEv_ZNK20vtkPointSetAlgorithm19NewInstanceInternalEv_ZN20vtkPointSetAlgorithm3IsAEPKc_ZN20vtkPointSetAlgorithm17GetPolyDataOutputEv_ZN20vtkPointSetAlgorithm23GetStructuredGridOutputEv_ZN20vtkPointSetAlgorithm25GetUnstructuredGridOutputEv_ZN20vtkPointSetAlgorithm8GetInputEv_ZN20vtkPointSetAlgorithm12SetInputDataEP11vtkPointSet_ZN20vtkPointSetAlgorithm12SetInputDataEP13vtkDataObject_ZN20vtkPointSetAlgorithm12AddInputDataEP13vtkDataObject_ZN20vtkPointSetAlgorithm12AddInputDataEP11vtkPointSet_ZN20vtkPointSetAlgorithm12SetInputDataEiP11vtkPointSet_ZN20vtkPointSetAlgorithm12AddInputDataEiP11vtkPointSet_ZN20vtkPointSetAlgorithm12AddInputDataEiP13vtkDataObject_ZN20vtkPointSetAlgorithm12SetInputDataEiP13vtkDataObject_ZN20vtkPointSetAlgorithm9GetOutputEv_ZN20vtkPointSetAlgorithm9GetOutputEiPyvtkPointSetAlgorithm_ClassNewPyVTKAddFile_vtkPointSetAlgorithm_ZN20vtkPolyDataAlgorithm3NewEv_ZNK20vtkPolyDataAlgorithm19NewInstanceInternalEv_ZN20vtkPolyDataAlgorithm3IsAEPKc_ZN20vtkPolyDataAlgorithm16GetPolyDataInputEi_ZN20vtkPolyDataAlgorithm8GetInputEv_ZN20vtkPolyDataAlgorithm8GetInputEi_ZN20vtkPolyDataAlgorithm9GetOutputEv_ZN20vtkPolyDataAlgorithm9GetOutputEi_ZN20vtkPolyDataAlgorithm12SetInputDataEP13vtkDataObject_ZN20vtkPolyDataAlgorithm12SetInputDataEiP13vtkDataObject_ZN20vtkPolyDataAlgorithm12AddInputDataEP13vtkDataObject_ZN20vtkPolyDataAlgorithm12AddInputDataEiP13vtkDataObjectPyvtkPolyDataAlgorithm_ClassNewPyVTKAddFile_vtkPolyDataAlgorithm_ZN31vtkObjectFactoryRegistryCleanupC1Ev_ZN31vtkObjectFactoryRegistryCleanupD1Ev_ZN20vtkPolyDataAlgorithm9SetOutputEP13vtkDataObject_ZN27vtkRectilinearGridAlgorithm3NewEv_ZNK27vtkRectilinearGridAlgorithm19NewInstanceInternalEv_ZN27vtkRectilinearGridAlgorithm3IsAEPKc_ZN27vtkRectilinearGridAlgorithm23GetRectilinearGridInputEi_ZN27vtkRectilinearGridAlgorithm9GetOutputEv_ZN27vtkRectilinearGridAlgorithm9GetOutputEi_ZN27vtkRectilinearGridAlgorithm8GetInputEv_ZN27vtkRectilinearGridAlgorithm8GetInputEi_ZN27vtkRectilinearGridAlgorithm12AddInputDataEP13vtkDataObject_ZN27vtkRectilinearGridAlgorithm12AddInputDataEiP13vtkDataObject_ZN27vtkRectilinearGridAlgorithm12SetInputDataEP13vtkDataObject_ZN27vtkRectilinearGridAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkRectilinearGridAlgorithm_ClassNewPyVTKAddFile_vtkRectilinearGridAlgorithm_ZN27vtkRectilinearGridAlgorithm9SetOutputEP13vtkDataObject_ZN13vtkScalarTree10GetDataSetEv_ZN13vtkScalarTree10GetScalarsEv_ZNK13vtkScalarTree19NewInstanceInternalEv_ZN13vtkScalarTree3IsAEPKc_ZN13vtkPythonArgs16PureVirtualErrorEvPyLong_FromLongLong_ZN13vtkPythonArgs8GetValueERx_ZN13vtkPythonArgs11SetArgValueEixPyvtkScalarTree_ClassNewPyVTKAddFile_vtkScalarTree_ZN13vtkScalarTree10SetScalarsEP12vtkDataArray_ZN13vtkScalarTree10SetDataSetEP10vtkDataSet_ZNK27vtkSimpleImageToImageFilter19NewInstanceInternalEv_ZN27vtkSimpleImageToImageFilter3IsAEPKcPyvtkSimpleImageToImageFilter_ClassNewPyVTKAddFile_vtkSimpleImageToImageFilter_ZN19vtkSimpleScalarTree18SetBranchingFactorEi_ZN19vtkSimpleScalarTree26GetBranchingFactorMinValueEv_ZN19vtkSimpleScalarTree26GetBranchingFactorMaxValueEv_ZN19vtkSimpleScalarTree18GetBranchingFactorEv_ZN19vtkSimpleScalarTree8GetLevelEv_ZN19vtkSimpleScalarTree11SetMaxLevelEi_ZN19vtkSimpleScalarTree19GetMaxLevelMinValueEv_ZN19vtkSimpleScalarTree19GetMaxLevelMaxValueEv_ZN19vtkSimpleScalarTree11GetMaxLevelEv_ZN19vtkSimpleScalarTree3NewEv_ZNK19vtkSimpleScalarTree19NewInstanceInternalEv_ZN19vtkSimpleScalarTree3IsAEPKcPyvtkSimpleScalarTree_ClassNewPyVTKAddFile_vtkSimpleScalarTree_ZN19vtkSimpleScalarTree12GetCellBatchExRx_ZN19vtkSimpleScalarTree22GetNumberOfCellBatchesEv_ZN19vtkSimpleScalarTree13InitTraversalEd_ZN19vtkSimpleScalarTree10InitializeEv_ZN19vtkSimpleScalarTree9BuildTreeEv_ZN12vtkSpanSpace13SetResolutionEx_ZN12vtkSpanSpace21GetResolutionMinValueEv_ZN12vtkSpanSpace21GetResolutionMaxValueEv_ZN12vtkSpanSpace13GetResolutionEv_ZN12vtkSpanSpace3NewEv_ZNK12vtkSpanSpace19NewInstanceInternalEv_ZN12vtkSpanSpace3IsAEPKcPyvtkSpanSpace_ClassNewPyVTKAddFile_vtkSpanSpace_ZN12vtkSpanSpace12GetCellBatchExRx_ZN12vtkSpanSpace22GetNumberOfCellBatchesEv_ZN12vtkSpanSpace13InitTraversalEd_ZN12vtkSpanSpace9BuildTreeEv_ZN12vtkSpanSpace10InitializeEv_ZN13vtkSphereTree10GetDataSetEv_ZN13vtkSphereTree17SetBuildHierarchyEb_ZN13vtkSphereTree17GetBuildHierarchyEv_ZN13vtkSphereTree13SetResolutionEi_ZN13vtkSphereTree21GetResolutionMinValueEv_ZN13vtkSphereTree21GetResolutionMaxValueEv_ZN13vtkSphereTree13GetResolutionEv_ZN13vtkSphereTree11SetMaxLevelEi_ZN13vtkSphereTree19GetMaxLevelMinValueEv_ZN13vtkSphereTree19GetMaxLevelMaxValueEv_ZN13vtkSphereTree11GetMaxLevelEv_ZN13vtkSphereTree17GetNumberOfLevelsEv_ZN13vtkSphereTree3NewEv_ZNK13vtkSphereTree19NewInstanceInternalEv_ZN13vtkSphereTree3IsAEPKc_ZN13vtkSphereTree17BuildHierarchyOffEv_ZN13vtkSphereTree16BuildHierarchyOnEv_ZN13vtkSphereTree14GetCellSpheresEv_ZN13vtkPythonArgs8GetValueERb_ZN13vtkSphereTree14GetTreeSpheresEiRx_ZN13vtkPythonArgs8GetArrayEPdi_ZN13vtkSphereTree11SelectPointEPdP9vtkIdList_ZN13vtkPythonArgs8SetArrayEiPKdi_ZN13vtkSphereTree11SelectPointEPdRx_ZN13vtkSphereTree11SelectPlaneEPdS0_P9vtkIdList_ZN13vtkSphereTree10SelectLineEPdS0_P9vtkIdList_ZN13vtkSphereTree11SelectPlaneEPdS0_Rx_ZN13vtkSphereTree10SelectLineEPdS0_Rx_ZN13vtkSphereTree5BuildEv_ZN13vtkSphereTree5BuildEP10vtkDataSetPyvtkSphereTree_ClassNewPyVTKAddFile_vtkSphereTree_ZN13vtkSphereTree10SetDataSetEP10vtkDataSet_ZN32vtkStreamingDemandDrivenPipeline3NewEv_ZNK32vtkStreamingDemandDrivenPipeline19NewInstanceInternalEv_ZN32vtkStreamingDemandDrivenPipeline19GetUpdateGhostLevelEP14vtkInformation_ZN32vtkStreamingDemandDrivenPipeline23GetUpdateNumberOfPiecesEP14vtkInformation_ZN32vtkStreamingDemandDrivenPipeline14GetUpdatePieceEP14vtkInformation_ZN32vtkStreamingDemandDrivenPipeline14SetWholeExtentEP14vtkInformationPi_ZN32vtkStreamingDemandDrivenPipeline6BOUNDSEv_ZN32vtkStreamingDemandDrivenPipeline26TIME_DEPENDENT_INFORMATIONEv_ZN32vtkStreamingDemandDrivenPipeline16UPDATE_TIME_STEPEv_ZN32vtkStreamingDemandDrivenPipeline10TIME_RANGEEv_ZN32vtkStreamingDemandDrivenPipeline10TIME_STEPSEv_ZN32vtkStreamingDemandDrivenPipeline12EXACT_EXTENTEv_ZN32vtkStreamingDemandDrivenPipeline26UNRESTRICTED_UPDATE_EXTENTEv_ZN32vtkStreamingDemandDrivenPipeline12WHOLE_EXTENTEv_ZN32vtkStreamingDemandDrivenPipeline22COMBINED_UPDATE_EXTENTEv_ZN32vtkStreamingDemandDrivenPipeline29UPDATE_NUMBER_OF_GHOST_LEVELSEv_ZN32vtkStreamingDemandDrivenPipeline23UPDATE_NUMBER_OF_PIECESEv_ZN32vtkStreamingDemandDrivenPipeline19UPDATE_PIECE_NUMBEREv_ZN32vtkStreamingDemandDrivenPipeline13UPDATE_EXTENTEv_ZN32vtkStreamingDemandDrivenPipeline25UPDATE_EXTENT_INITIALIZEDEv_ZN32vtkStreamingDemandDrivenPipeline18CONTINUE_EXECUTINGEv_ZN32vtkStreamingDemandDrivenPipeline34REQUEST_TIME_DEPENDENT_INFORMATIONEv_ZN32vtkStreamingDemandDrivenPipeline19REQUEST_UPDATE_TIMEEv_ZN32vtkStreamingDemandDrivenPipeline21REQUEST_UPDATE_EXTENTEv_ZN32vtkStreamingDemandDrivenPipeline15GetUpdateExtentEP14vtkInformationPi_ZN32vtkStreamingDemandDrivenPipeline15GetUpdateExtentEP14vtkInformation_ZN32vtkStreamingDemandDrivenPipeline14GetWholeExtentEP14vtkInformationPi_ZN32vtkStreamingDemandDrivenPipeline14GetWholeExtentEP14vtkInformation_ZN32vtkStreamingDemandDrivenPipeline3IsAEPKc_ZN32vtkStreamingDemandDrivenPipeline13PropagateTimeEi_ZN32vtkStreamingDemandDrivenPipeline30UpdateTimeDependentInformationEi_ZN32vtkStreamingDemandDrivenPipeline21GetRequestExactExtentEi_ZN32vtkStreamingDemandDrivenPipeline21PropagateUpdateExtentEi_ZN32vtkStreamingDemandDrivenPipeline21SetRequestExactExtentEiiPyVTKAddFile_vtkStreamingDemandDrivenPipeline_ZN32vtkStreamingDemandDrivenPipeline17UpdateWholeExtentEv_ZN32vtkStreamingDemandDrivenPipeline6UpdateEv_ZN32vtkStreamingDemandDrivenPipeline6UpdateEi_ZN32vtkStreamingDemandDrivenPipeline6UpdateEiP20vtkInformationVector_ZN26vtkStructuredGridAlgorithm3NewEv_ZNK26vtkStructuredGridAlgorithm19NewInstanceInternalEv_ZN26vtkStructuredGridAlgorithm3IsAEPKc_ZN26vtkStructuredGridAlgorithm22GetStructuredGridInputEi_ZN26vtkStructuredGridAlgorithm9GetOutputEv_ZN26vtkStructuredGridAlgorithm9GetOutputEi_ZN26vtkStructuredGridAlgorithm8GetInputEv_ZN26vtkStructuredGridAlgorithm8GetInputEi_ZN26vtkStructuredGridAlgorithm12AddInputDataEP13vtkDataObject_ZN26vtkStructuredGridAlgorithm12AddInputDataEiP13vtkDataObject_ZN26vtkStructuredGridAlgorithm12SetInputDataEP13vtkDataObject_ZN26vtkStructuredGridAlgorithm12SetInputDataEiP13vtkDataObjectPyVTKAddFile_vtkStructuredGridAlgorithm_ZN26vtkStructuredGridAlgorithm9SetOutputEP13vtkDataObject_ZN17vtkTableAlgorithm3NewEv_ZNK17vtkTableAlgorithm19NewInstanceInternalEv_ZN17vtkTableAlgorithm3IsAEPKc_ZN17vtkTableAlgorithm9GetOutputEi_ZN17vtkTableAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkTableAlgorithm_ClassNewPyVTKAddFile_vtkTableAlgorithm_ZN22vtkSMPProgressObserver3NewEv_ZNK22vtkSMPProgressObserver19NewInstanceInternalEv_ZN22vtkSMPProgressObserver3IsAEPKc_ZN19vtkProgressObserver3NewEvPyvtkSMPProgressObserver_ClassNewPyvtkProgressObserver_ClassNewPyVTKAddFile_vtkSMPProgressObserver_ZN22vtkSMPProgressObserver14UpdateProgressEd_ZN32vtkThreadedCompositeDataPipeline3NewEv_ZNK32vtkThreadedCompositeDataPipeline19NewInstanceInternalEv_ZN32vtkThreadedCompositeDataPipeline3IsAEPKcPyvtkThreadedCompositeDataPipeline_ClassNewPyVTKAddFile_vtkThreadedCompositeDataPipeline_ZN25vtkThreadedImageAlgorithm12GetEnableSMPEv_ZN25vtkThreadedImageAlgorithm12SetEnableSMPEb_ZN25vtkThreadedImageAlgorithm19SetMinimumPieceSizeEiii_ZN25vtkThreadedImageAlgorithm19GetMinimumPieceSizeEv_ZN25vtkThreadedImageAlgorithm23SetDesiredBytesPerPieceEx_ZN25vtkThreadedImageAlgorithm23GetDesiredBytesPerPieceEv_ZN25vtkThreadedImageAlgorithm12SetSplitModeEi_ZN25vtkThreadedImageAlgorithm20GetSplitModeMinValueEv_ZN25vtkThreadedImageAlgorithm20GetSplitModeMaxValueEv_ZN25vtkThreadedImageAlgorithm12GetSplitModeEv_ZN25vtkThreadedImageAlgorithm18SetNumberOfThreadsEi_ZN25vtkThreadedImageAlgorithm26GetNumberOfThreadsMinValueEv_ZN25vtkThreadedImageAlgorithm26GetNumberOfThreadsMaxValueEv_ZN25vtkThreadedImageAlgorithm18GetNumberOfThreadsEv_ZNK25vtkThreadedImageAlgorithm19NewInstanceInternalEv_ZN25vtkThreadedImageAlgorithm25SetGlobalDefaultEnableSMPEb_ZN25vtkThreadedImageAlgorithm25GetGlobalDefaultEnableSMPEv_ZN25vtkThreadedImageAlgorithm3IsAEPKc_ZN25vtkThreadedImageAlgorithm19SetMinimumPieceSizeEPiPyvtkThreadedImageAlgorithm_ClassNewPyVTKAddFile_vtkThreadedImageAlgorithm_ZN25vtkThreadedImageAlgorithm11SplitExtentEPiS0_ii_ZN25vtkThreadedImageAlgorithm15ThreadedExecuteEP12vtkImageDataS1_Pii_ZN16vtkTreeAlgorithm3NewEv_ZNK16vtkTreeAlgorithm19NewInstanceInternalEv_ZN16vtkTreeAlgorithm3IsAEPKc_ZN16vtkTreeAlgorithm9GetOutputEi_ZN16vtkTreeAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkTreeAlgorithm_ClassNewPyVTKAddFile_vtkTreeAlgorithm_ZN18vtkTrivialConsumer3NewEv_ZNK18vtkTrivialConsumer19NewInstanceInternalEv_ZN18vtkTrivialConsumer3IsAEPKcPyvtkTrivialConsumer_ClassNewPyVTKAddFile_vtkTrivialConsumer_ZN18vtkTrivialProducer14SetWholeExtentEiiiiii_ZN18vtkTrivialProducer14GetWholeExtentEv_ZN18vtkTrivialProducer3NewEv_ZNK18vtkTrivialProducer19NewInstanceInternalEv_ZN18vtkTrivialProducer25FillOutputDataInformationEP13vtkDataObjectP14vtkInformation_ZN18vtkTrivialProducer3IsAEPKc_ZN18vtkTrivialProducer14SetWholeExtentEPiPyvtkTrivialProducer_ClassNewPyVTKAddFile_vtkTrivialProducer_ZN18vtkTrivialProducer8GetMTimeEv_ZN18vtkTrivialProducer9SetOutputEP13vtkDataObject_ZN27vtkUndirectedGraphAlgorithm3NewEv_ZNK27vtkUndirectedGraphAlgorithm19NewInstanceInternalEv_ZN27vtkUndirectedGraphAlgorithm3IsAEPKc_ZN27vtkUndirectedGraphAlgorithm9GetOutputEi_ZN27vtkUndirectedGraphAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkUndirectedGraphAlgorithm_ClassNewPyVTKAddFile_vtkUndirectedGraphAlgorithm_ZN28vtkUnstructuredGridAlgorithm3NewEv_ZNK28vtkUnstructuredGridAlgorithm19NewInstanceInternalEv_ZN28vtkUnstructuredGridAlgorithm3IsAEPKc_ZN28vtkUnstructuredGridAlgorithm24GetUnstructuredGridInputEi_ZN28vtkUnstructuredGridAlgorithm9GetOutputEv_ZN28vtkUnstructuredGridAlgorithm9GetOutputEi_ZN28vtkUnstructuredGridAlgorithm8GetInputEi_ZN28vtkUnstructuredGridAlgorithm12AddInputDataEP13vtkDataObject_ZN28vtkUnstructuredGridAlgorithm12AddInputDataEiP13vtkDataObject_ZN28vtkUnstructuredGridAlgorithm12SetInputDataEP13vtkDataObject_ZN28vtkUnstructuredGridAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkUnstructuredGridAlgorithm_ClassNewPyVTKAddFile_vtkUnstructuredGridAlgorithm_ZN28vtkUnstructuredGridAlgorithm9SetOutputEP13vtkDataObject_ZN32vtkUnstructuredGridBaseAlgorithm3NewEv_ZNK32vtkUnstructuredGridBaseAlgorithm19NewInstanceInternalEv_ZN32vtkUnstructuredGridBaseAlgorithm3IsAEPKc_ZN32vtkUnstructuredGridBaseAlgorithm9GetOutputEv_ZN32vtkUnstructuredGridBaseAlgorithm9GetOutputEi_ZN32vtkUnstructuredGridBaseAlgorithm12SetInputDataEP13vtkDataObject_ZN32vtkUnstructuredGridBaseAlgorithm12SetInputDataEiP13vtkDataObject_ZN32vtkUnstructuredGridBaseAlgorithm12AddInputDataEP13vtkDataObject_ZN32vtkUnstructuredGridBaseAlgorithm12AddInputDataEiP13vtkDataObjectPyvtkUnstructuredGridBaseAlgorithm_ClassNewPyVTKAddFile_vtkUnstructuredGridBaseAlgorithm_ZN32vtkUnstructuredGridBaseAlgorithm9SetOutputEP13vtkDataObject_ZN19vtkProgressObserver11GetProgressEv_ZNK19vtkProgressObserver19NewInstanceInternalEv_ZN19vtkProgressObserver3IsAEPKcPyVTKAddFile_vtkProgressObserver_ZN19vtkProgressObserver14UpdateProgressEd_ZN21vtkSelectionAlgorithm3NewEv_ZNK21vtkSelectionAlgorithm19NewInstanceInternalEv_ZN21vtkSelectionAlgorithm3IsAEPKc_ZN21vtkSelectionAlgorithm9GetOutputEi_ZN21vtkSelectionAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkSelectionAlgorithm_ClassNewPyVTKAddFile_vtkSelectionAlgorithm_ZN23vtkExtentRCBPartitioner17SetDuplicateNodesEi_ZN23vtkExtentRCBPartitioner17GetDuplicateNodesEv_ZN23vtkExtentRCBPartitioner22SetNumberOfGhostLayersEi_ZN23vtkExtentRCBPartitioner22GetNumberOfGhostLayersEv_ZN23vtkExtentRCBPartitioner13GetNumExtentsEv_ZN23vtkExtentRCBPartitioner3NewEv_ZNK23vtkExtentRCBPartitioner19NewInstanceInternalEv_ZN23vtkExtentRCBPartitioner3IsAEPKc_ZN23vtkExtentRCBPartitioner16DuplicateNodesOnEv_ZN23vtkExtentRCBPartitioner17DuplicateNodesOffEv_ZN23vtkExtentRCBPartitioner9PartitionEv_ZN23vtkExtentRCBPartitioner18GetPartitionExtentEiPiPyvtkExtentRCBPartitioner_ClassNewPyVTKAddFile_vtkExtentRCBPartitioner_ZN25vtkUniformGridPartitioner21GetNumberOfPartitionsEv_ZN25vtkUniformGridPartitioner21SetNumberOfPartitionsEi_ZN25vtkUniformGridPartitioner22GetNumberOfGhostLayersEv_ZN25vtkUniformGridPartitioner22SetNumberOfGhostLayersEi_ZN25vtkUniformGridPartitioner17GetDuplicateNodesEv_ZN25vtkUniformGridPartitioner17SetDuplicateNodesEi_ZN25vtkUniformGridPartitioner3NewEv_ZNK25vtkUniformGridPartitioner19NewInstanceInternalEv_ZN25vtkUniformGridPartitioner3IsAEPKc_ZN25vtkUniformGridPartitioner16DuplicateNodesOnEv_ZN25vtkUniformGridPartitioner17DuplicateNodesOffEvPyvtkUniformGridPartitioner_ClassNewPyVTKAddFile_vtkUniformGridPartitioner_ZN26vtkUniformGridAMRAlgorithm3NewEv_ZNK26vtkUniformGridAMRAlgorithm19NewInstanceInternalEv_ZN26vtkUniformGridAMRAlgorithm3IsAEPKc_ZN26vtkUniformGridAMRAlgorithm9GetOutputEv_ZN26vtkUniformGridAMRAlgorithm9GetOutputEi_ZN26vtkUniformGridAMRAlgorithm12SetInputDataEP13vtkDataObject_ZN26vtkUniformGridAMRAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkUniformGridAMRAlgorithm_ClassNewPyVTKAddFile_vtkUniformGridAMRAlgorithm_ZN26vtkOverlappingAMRAlgorithm3NewEv_ZNK26vtkOverlappingAMRAlgorithm19NewInstanceInternalEv_ZN26vtkOverlappingAMRAlgorithm3IsAEPKc_ZN26vtkOverlappingAMRAlgorithm9GetOutputEv_ZN26vtkOverlappingAMRAlgorithm9GetOutputEiPyvtkOverlappingAMRAlgorithm_ClassNewPyVTKAddFile_vtkOverlappingAMRAlgorithm_ZN29vtkNonOverlappingAMRAlgorithm3NewEv_ZNK29vtkNonOverlappingAMRAlgorithm19NewInstanceInternalEv_ZN29vtkNonOverlappingAMRAlgorithm3IsAEPKc_ZN29vtkNonOverlappingAMRAlgorithm9GetOutputEv_ZN29vtkNonOverlappingAMRAlgorithm9GetOutputEiPyvtkNonOverlappingAMRAlgorithm_ClassNewPyVTKAddFile_vtkNonOverlappingAMRAlgorithm_ZNK23vtkHyperOctreeAlgorithm19NewInstanceInternalEv_ZN23vtkHyperOctreeAlgorithm3IsAEPKc_ZN23vtkHyperOctreeAlgorithm19GetHyperOctreeInputEi_ZN23vtkHyperOctreeAlgorithm9GetOutputEv_ZN23vtkHyperOctreeAlgorithm9GetOutputEi_ZN23vtkHyperOctreeAlgorithm8GetInputEv_ZN23vtkHyperOctreeAlgorithm8GetInputEi_ZN23vtkHyperOctreeAlgorithm12AddInputDataEP13vtkDataObject_ZN23vtkHyperOctreeAlgorithm12AddInputDataEiP13vtkDataObject_ZN23vtkHyperOctreeAlgorithm12SetInputDataEP13vtkDataObject_ZN23vtkHyperOctreeAlgorithm12SetInputDataEiP13vtkDataObjectPyvtkHyperOctreeAlgorithm_ClassNewPyVTKAddFile_vtkHyperOctreeAlgorithm_ZN23vtkHyperOctreeAlgorithm9SetOutputEP13vtkDataObjectreal_initvtkCommonExecutionModelPythonPyModule_Create2PyModule_GetDict_Py_FatalErrorFunclibvtkCommonExecutionModel-8.1.so.1libvtkCommonCorePython310D-8.1.so.1libvtkWrappingPython310Core-8.1.so.1libvtkCommonCore-8.1.so.1libstdc++.so.6libgcc_s.so.1libc.so.6libvtkCommonExecutionModelPython310D-8.1.so.1GCC_3.0CXXABI_1.3GLIBCXX_3.4GLIBC_2.4GLIBC_2.2.5/mnt/storage/workspace/med-ubuntu-free/build/ExtProjs/VTK/lib: P&y 0ӯkt)Ȟii ui )  @ `        @ `        @   ( 0 08 P@ pH P X p` h Pp px     0      @ `        @ `   ( 0 8  @ @H `P X ` h p x     O\ _\ q\ \ ރ  0    8   5( P8 h@ H @X p` h x h    ث  @   s    P; X y  P v( :8 @ uH X  ` Ңh x x   ȳ g 8 `      x J P  ( `8 ȶ@ jH X ` Zh x P       Ρ      V    e( 8 @ H X x` !h  x  #    0 @      x Ƞ    ( 8 @ H `X P` h x  | @ p P @7     @ P     @ $( 8 @ =H p0X ` *h .x  < 0   * 8  @(   %   ֣ P   ( 8 P@ 0H X ` 7h x x 6 P  0 $ p         P# H  ʣ( @8 @ H  X (` Ԥh x  ¤     @  0   P  X  p  v( @8 `@ cH `X ` >h @x ` `   (  @ R  0  @   ǣ  (  ( 8 (@ H X H` .h  x X   @    ť  ȥ( 8 H X Υ @" ť  !  ,  +  H 5X h P4x  2  ` 5h P?x h  A p  p>    E H  0D   @@   ( A8 @ H 0CX @ 8  5( pH8 h@ H pIX p` h Gx x  J   PL p  N P   5 R h  S p  0Q 8   T    ( U8  @ H WX P    5( ]8 h@ H ^X p` h Zx    P`     \    [   5 c h  e p  c   f HX ! 5! @m! h" " pn" p " (" 0i8" 0@" H" pX" `"  h" Plx" " " k" " " 0k" " " j" h" " j"  8# #$ 5$ s$ h$ $ t$ p% % r% $ % (% v8% $@% H% wX% %`% h% Pyx% %% *@' 5H' p}X' h`' h' x' p' ' |' *' ' p~' h+' '  ' +' E'' ' ,( /'( P( - ( ((  8( %@( 8'H( X( -( x3 * 5(* 8* h@* H* X* p`* h* px* 3* * P* (4* * * 4* /'* * 85* .* * 5+ 0/+ В+ P6 + /(+ 08+ 6@+ /H+ X+ `7`+ .h+ x+ 7+ .+ `+ 8+ + + 9+ 8'+ P+ :, , J/(, 8, \/H, X, k/h, x, {/, , J/, , {/, , \/- К- k/X-  >. 5. . h/ / / p / (/ `8/ X>@/ H/ X/ >`/ h/ x/ @?/ </ / @/ v/ / x@/ c/ Я/ PA/ =/ / A0 0 0 XB 0 ¤(0 080 XC@0 =H0  X0 C`0 <h0 x0 D0 <0 0 E0 <0 0 hF0 <0 `0 (G0 <0 У0  H1 <1 @1 H 1 <(1 81 (Jx1 @O3 53 p3 h 3 (3 p83 p@3 H3 X3 xO`3 h3 x3 P3 3 P3 `P3 3 3 P3 pS5 55 05 h5 5 05 p5 5 05 S5 5 `5 T6 Q6 6 hT 6 QQ(6 86 pU@6 bQH6 pX6 U`6 Qh6 x6 8V6 uQ6 06 W6 Q6 6  Y6 6 6  Z6 CQ6 6 Z87 @^8 58 p8 h8 8 8 p9 9 9 p^ 9 (9 89 ^@9 [H9  X9 (_`9 ¤h9 x9 _9 9 9  `9 9 `9 `9 9 9 a9 9 9 `b: : : b : (: p8: d@: $H: X: (e`: A\h: x: e: 3\: : pf: &\: : g:  \: : @h: [: :  j; [; P; j ; [(; 8; k@; [H; 0X; pl`; [h; x; Pm; [; ; (n; [; ; n; v[; ; o< s= 5= = h= = 0= p= = = s> > > Pt > Nq(> @8> t@> pH> X> @v`> ph> x>  w> Dq> > x> p> > y> p> P>  z> 7q> > {? p? ? p| ? p(? 8? P}@? qH? X? ~`? qh? x? ? *q?  ? @? 8A 8 C 5(C  8C h@C HC pXC p`C hC xC pC C C C C C @C C @ C C C pC XD D PD  D m(D 08D H@D $HD  XD `D [hD xD D -D  D xD MD  D 8D ?D  D D ЃD 'D E E &E  E (E !8E `@E ւHE XE h`E ‚hE xE E E E E E E  E E 0 E `E vE @E F F F XXF pF +F p+xG +G XI 5I  .I hI I  /I pI I @-I I I 0I J J 2J P J (J 38J PxJ `L 5L 7L h L (L 88L p@L HL 6XL `L hL 0:xL HL L ;L L L p=L %L N 5N AN hN N BN pN N @N N N CN xO O `EO + O E'(O Q8O إ@O HO JXO ``O .hO 0GxO PO .O IO O O NO %O 8'O LO -P Q 5Q SQ hQ Q UQ pQ Q SQ HR R PWR  R (R X8R @R E'HR aXR ,`R hR P\xR ЬR /'R ZR R 0R TR @R 8'R  _R PS T 5T cT hT T dT pT T cT  U U fU XU  V 5V jV hW W  kW p W (W 0i8W X@W HW lXW W 0 Y 5(Y r8Y h@Y HY sXY p`Y hY PoxY pY Y puY Y eY qY `Y VY 0pY Y 0/Y qY p8Z [ 5[ y[ h[ [ z[ p\ \ y\  \ (\ P|8\ @\ H\ xX\ `\ h\ ~x\ x\ h@^ 5H^ X^ h`^ h^ x^ p^ ^ Ѐ^ ^ ^ `^ @^ ^ ^ ^ g/^ ^ _ s_ _  _ (_ 8_ h@_ 5H_ 0X_ `_ h_ x_ 8_ h@a 5Ha Xa h`a ha xa pa a 0a a a a Xa a 0a a a 0a 8b b 0b  b (b 8b @b Hb Xb `b 5hb xb b b Pb 8b X`d 5hd 0xd hd d 0d pd d Pd d d d 0d d Pd e Ze e  e L(e 8e  @e He Xe (e  g 5(g 8g h@g Hg Xg p`g hg  xg g g pg g g g g g g %h i 5i дi hi i еi pi i i j j @j @Xj k 5k k hl l l p l (l 8l @l Hl `Xl `l hl xl +l .l l 5l 0/l pl P6l /l @l 6l /l l `7m .m m 7 m .(m 8m 8@m Hm Xm `m hm Pxm Pm /'m  m 85m m m %m 8'm m n xo 5o o ho o `o po o o p p p H p (p 8p +@p E'Hp pXp ,`p /'hp xp -p p p %p 8'p pp -p r 5r r hr r r pr r r r r 0r xs s ps  s (s 8s 0@s Hs Xs `s hs xs s s s s s s Xs s s s s ps 8t u 5u Pu hu u u pv v v  v (v @8v x@v Hv Xv `v .hv Pxv 5v /v  v `7v .v v 7v v v v 8'v v Hw /'w w Hw Xw J/hw xw >w w Nw w {/w w J/x x {/(x 8x >Hx Xx Nx   z 5(z p8z h@z Hz `Xz p`z hz xz Xz z z z z z 0z E'z z ,z /'z @z -{ { p{  { ({  8{ %@{ 8'H{  X{ -{  } 5(} @8} h@} H} 0X} p`} h} `x} (} } } } } }  } E'} } ,} /'} } -~ Z~ @~  ~ (~ 8~ %@~ 8'H~ X~ -~   5( !8 h@ H @+X p` h  x    @( X   P.   Ȁ p%؀ 0   @-    P& X ( "8 @ H #X ` h 0'x ( x ! h  $ ( ȁ )؁   5 0 h ȃ 1؃ p  /   P3 hX 8" 5 6 p"  `B " ( 58 x#@ H 7X ($` ch ?x $  0: %   < 0' ;Ȇ =؆ x( Z > ) v A `* ( @98 *@  H  ;X H+` Nh =x +  H (,  G , ȇ F؇ `-  E 8.  pD /X 4 5 K p"  L " ( J8 5@ H PX 5` R1h `Rx 06 .1  O 7 1 0N 9 D1Ȋ P؊ H;  X ,  W (, ( V8 <@ H VX 8.` h Tx / (E@ 5H `\X p"` h nx "  Z XE  q E ȍ ؍ xF  d F > ~ xG >( h8 H@ >H cX I` >h pgx 8J > `f J a> \ K V>Ȏ [؎ @N J> p[ 8Q R1 i @T .1( 0_8 U@ 1H  `X xW` D1h ax Y v 0k Z  P] H\  ȏ @^؏ ] N a _ m> b 0a >( pe8 hb@ >H lX d  y ? `t ? { ? v ?H rX &?h pox -? j@ 5H @X h` h x p  І k    k ȓ  ؓ l  @ m    hm Uh( P8 Hn@ hH @X o` h x o  @ 0q yh  r chȔ 0ؔ t ?h  @v +h  w h( 8 w@ hH X x` gh `x y g Џ z g @ { gȕ ؕ { g   @| g  | g( 8 ~@ ugH pX ~` hgh x  ]g P  Rg  h AgȖ 0ؖ ( &g  ؂ g   ( 08 @ ǣH  X ` h px Ȇ   ؗ ` 5h x h  p p   ( ș ؙ   P  E'  , /'(  8 -@ H X ` h  x % 8'  -ؚ ` 5h Px h  P p  p  Ȝ ؜ 8  0    PX @ 5  h   p ( 8 x@ H `X ` Vh x P P  ؟ ` 5h @x h   p  ` ( ȡ @ء   5  h ȣ @أ p   ؞   ` ( 8 @ H `X ` ch x  E  X _   Ȥ ؤ x ٛ    K @ p ( 8 Ȥ@ pH X  ` h x h ě   % @  8ȥ @إ ` ւ @     }( P8 8@ H X ` yh  x    P     5  h   p Ȩ ب      p  ( 08 Px  5 0 h ( 08 p@ H PX @` h x  ػ@ 5H X h` h x p     @  E'ȭ  ح ؼ 4      @ ( 8 @ H  X   5( 8 h@ H X p` h x P      H Ȱ @ذ P p 5 @ h Ȳ 0ز p  `    @ ( 8 @ E'H 'X ,` /'h  x  > @   $ % 8'ȳ "س   5 * h ȵ +ص p   )   p, X ( -8 @ E'H 4X ,` h /x % 8' 1 ض (` 5h 8x h  9 p  06 ` ȸ `:ظ  V p< 0  7 X x 5 > h  ? p ( =8 @ H @AX 0` h Bx   pD Pػ ` 5h pHx h  R p  G  Ƚ Uؽ   L   V X ( M8 @ kH 0JX @` h `Px   pQ 8   O  }Ⱦ Kؾ 8  K  a `I  ( S8 Xx  5 \ h ( ]8 p@ H [X ` h dx  ) @_   0c h }  ` 8  a  k a  ( 0h8 0@ H eX ` h gx  @ 5H lX h` h mx p  l P  Po   p @  r 8  5 v h  y p  u  (  {8 h@ H wX  0 5( ~8 h@ H X p` h }x p      h h 5  h  p p      (  P  E'( 8 ,@ /'H  X -` Zh x P    % 8'  -    i B    M   d  X T Y  U o z h  ( 0 L8 $@ H eP AX ` \h }p x , H  G   0 J   4 [  e X { > Z 1 ] { |( 0 48 s@ H TP wX ^` h 'p fx  `  J |   ~ n s  (  O    k K   = z( 0 g8 @ wH P  X  ` h p sx  9 N    G  P o   \ P  :  B  ; y  ( 0 8 )@ -H P FX Y` h @p x  a  m   b L   n    D    S   ( *0 8 >@ xH P DX ` Qh p x  <   u   v p  9 & p    E    3 (  0 v8 W@ H :P X _` ~h p x  7   B  M V  8  ] . ;  j     0   ( q0 8 @ lH P [X A` yh p [x         k  p  8 . =        H (# % ( H- h1 3 (7 < ? A HF G hJ L P S HU W (Z \ _ b e h Hj n p (t x { ~  H H   ȗ Ț H ȟ   h     ȶ H Ȼ h  (      0  0 p P# % ( p- 1 4 P7 0< @ H J M 0P 0S pU W PZ \ _ b e 0h pj 0n q Pt x { ~ 0 p p Ћ Б   p  0   Ы  0 0  p    P   8 l l lX l lX l lx# l% l( l- l1 l84 lx7 lX< l8@ l8H lJ l8M lXP lXS lU lW lxZ l\ l_ lc le lXh lj lXn l8q lxt lx l{ l~ lX l l l l l l l l lX l8 l l lخ lX lX l l l l l lx l l8 lh H      # (& ) - 1 h4 7 < h@ hH J hM P S U X Z (] (` Hc f h j n hq t y |   Ȅ Ȉ ( ( H H ȝ H  h  (    H ȹ H  (   h p P      # 0& ) - 1 p4 7 < p@ F pH J pM P S U X Z 0] 0` Pc f h j n pq t y |   Є Ј 0 0 P P Н P  p  0    P й P  0   p x DX D D D D D D# D8& D) D- D1 Dx4 D7 D< Dx@ DxH DJ DxM DP DS DU DX DZ D8] D8` DXc Df Dh Dj Dn Dxq Dt Dy D| D D D؄ D؈ D8 D8 DX DX D؝ DX D Dx D D8 D D D DX Dع DX D D8 D D Dx D `        # @&  ) - 2 4 7 < @ H K M P S U  X Z @] @` `c  f h j n q t  y  |      @ @ ` `  `    @    `  `  @     "x "8 " "8 " " "# "X& "8) "- "2 "4 "7 "< "@ "H "K "M "P "S "U "8X "Z "X] "X` "xc "8f "h "j "n "q "t "8y "8| "8 " " " "X "X "x "x " "x " " " "X "8 " " "x " "x " "X " "8 " "  x  x  8! $ & x) 8. X2 4 8 < @ H XK M P S 8V xX [ ] ` c xf h 8k n q u xy x| x  8 8     8   ا X  x    8  X   x   Z Z Z8 Z Z8 Zx! ZX$ Z& Z) Zx. Z2 Z5 ZX8 Z8= ZA ZI ZK ZN Z8Q Z8T ZxV ZX ZX[ Z] Z` Zc Zf Z8i Zxk Z8o Zr ZXu Zy Z| Z Z8 Zx Zx Z، Zؒ Z Z Zx Z Z8 Z Z Zج Z Z8 Z8 Z Zx Z Z Z ZX Z Z Z  a a a@ a a@ a! a`$ a& a) a. a2 a 5 a`8 a@= a A a I aK a N a@Q a@T aV aX a`[ a] a` ad af a@i ak a@o a r a`u ay a| a a@ a a a a a a a a a@ a a a a a@ a@ a a a a a a` a a a kB kG k? F q  ( 0 8 @ H P  X  `  h  p  x  I            V        ( 0 d8 @ H  P !X #` $h %p &x F / ' ( ) *  + , -  . / 0 1  2 3 r 4 5 `( 60 78 8@ 9H :P ;X <` Rh =p >x ? H @ A B C E F G H I J 3 K  1 L M N O P Q( r0 R8 S@ TH UP VX W` jh Xp Yx Q \ ] ^ _ ` <  a  b c d e f g h i j k l m( n0 8 o@ pH qP rX t` #h tp ux v w x y z {  | } % ~            ( 0 f8 @ H P X ` h p x           m           ( 0 58 @ H CP X ` h p x               !       ( 0 8 @ H P X ` h tp x                      ( 0 8 @ H P X ` h p x      h     u           g( 0 8 @ H P X K` h p x            2               ( 0 8 @ H P X ` h p x l      }  q 6      ! " # $ %  & '( (0 )8 *@ +H ,P -X .` /h 0p 1x 2 3 4 5 6 7 8 a  9 ^ : ; <  = > ?  @ A N( R0 B8 C@ DH EP CX ` Fh Gp 6x H I J K L Z M N O b P Q I R S T U V W X Y Z( [0 \8 ]@ "H ^P _X `` bh cp dx  e ? f g  h i j k  c m n o r s t u  v w( x0 y8 z@ {H |P X }` ~h p x  W                    ( 0 8 @ H P X ` h p x                O      ( 0 8 @ H P X ` h +p x  7 5                    ( 0 8 @ H P X ` h p x   c   x        2         ( 0 8 @ H P X ` h p x           @          U  ( 0 8 @ H P X  `  h  p  x   _   ?  i  S          E    ( 0  8 @ !H "P #X $` %h &p 'x ( ) * + , - /HHHtH5%hhhhhhhhqhah Qh Ah 1h !h hhhhhhhhhhqhahQhAh1h!hhhh h!h"h#h$h%h&h'qh(ah)Qh*Ah+1h,!h-h.h/h0h1h2h3h4h5h6h7qh8ah9Qh:Ah;1h<!h=h>h?h@hAhBhChDhEhFhGqhHahIQhJAhK1hL!hMhNhOhPhQhRhShThUhVhWqhXahYQhZAh[1h\!h]h^h_h`hahbhchdhehfhgqhhahiQhjAhk1hl!hmhnhohphqhrhshthuhvhwqhxahyQhzAh{1h|!h}h~hhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhah Qh Ah 1h !h hhhhhhhhhhqhahQhAh1h!hhhh h!h"h#h$h%h&h'qh(ah)Qh*Ah+1h,!h-h.h/h0h1h2h3h4h5h6h7qh8ah9Qh:Ah;1h<!h=h>h?h@hAhBhChDhEhFhGqhHahIQhJAhK1hL!hMhNhOhPhQhRhShThUhVhWqhXahYQhZAh[1h\!h]h^h_h`hahbhchdhehfhgqhhahiQhjAhk1hl!hmhnhohphqhrhshthuhvhwqhxahyQhzAh{1h|!h}h~hhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhahQhAh1h!hhhhhhhhhhhqhah Qh Ah 1h !h hhhhhhhhhhqhahQhAh1h!hhhh h!h"h#h$h%h&h'qh(ah)Qh*Ah+1h,!h-h.h/h0h1h2h3h4h5h6h7qh8ah9Qh:Ah;1h<!h=h>h?h@hAhBhChDhEhFhGqhHahIQhJAhK1hL!hMhNhOhPhQhRhShThUhVhWqhXahYQhZAh[1h\!h]h^h_h`hahbhchdhehfhgqhhahiQhjAhk1hl!hmhnhohphqhrhshthuhvhwqhxahyQhzAh{1h|!h}h~hhhhhhhhhqhahQhAh1h!hhhhhh%ePD%uQD%VD%VD%}VD%uVD%mVD%eVD%]VD%UVD%MVD%EVD%=VD%5VD%-VD%%VD%VD%VD% VD%VD%UD%UD%UD%UD%UD%UD%UD%UD%UD%UD%UD%UD%UD%UD%UD%UD%}UD%uUD%mUD%eUD%]UD%UUD%MUD%EUD%=UD%5UD%-UD%%UD%UD%UD% UD%UD%TD%TD%TD%TD%TD%TD%TD%TD%TD%TD%TD%TD%TD%TD%TD%TD%}TD%uTD%mTD%eTD%]TD%UTD%MTD%ETD%=TD%5TD%-TD%%TD%TD%TD% TD%TD%SD%SD%SD%SD%SD%SD%SD%SD%SD%SD%SD%SD%SD%SD%SD%SD%}SD%uSD%mSD%eSD%]SD%USD%MSD%ESD%=SD%5SD%-SD%%SD%SD%SD% SD%SD%RD%RD%RD%RD%RD%RD%RD%RD%RD%RD%RD%RD%RD%RD%RD%RD%}RD%uRD%mRD%eRD%]RD%URD%MRD%ERD%=RD%5RD%-RD%%RD%RD%RD% RD%RD%QD%QD%QD%QD%QD%QD%QD%QD%QD%QD%QD%QD%QD%QD%QD%QD%}QD%uQD%mQD%eQD%]QD%UQD%MQD%EQD%=QD%5QD%-QD%%QD%QD%QD% QD%QD%PD%PD%PD%PD%PD%PD%PD%PD%PD%PD%PD%PD%PD%PD%PD%PD%}PD%uPD%mPD%ePD%]PD%UPD%MPD%EPD%=PD%5PD%-PD%%PD%PD%PD% PD%PD%OD%OD%OD%OD%OD%OD%OD%OD%OD%OD%OD%OD%OD%OD%OD%OD%}OD%uOD%mOD%eOD%]OD%UOD%MOD%EOD%=OD%5OD%-OD%%OD%OD%OD% OD%OD%ND%ND%ND%ND%ND%ND%ND%ND%ND%ND%ND%ND%ND%ND%ND%ND%}ND%uND%mND%eND%]ND%UND%MND%END%=ND%5ND%-ND%%ND%ND%ND% ND%ND%MD%MD%MD%MD%MD%MD%MD%MD%MD%MD%MD%MD%MD%MD%MD%MD%}MD%uMD%mMD%eMD%]MD%UMD%MMD%EMD%=MD%5MD%-MD%%MD%MD%MD% MD%MD%LD%LD%LD%LD%LD%LD%LD%LD%LD%LD%LD%LD%LD%LD%LD%LD%}LD%uLD%mLD%eLD%]LD%ULD%MLD%ELD%=LD%5LD%-LD%%LD%LD%LD% LD%LD%KD%KD%KD%KD%KD%KD%KD%KD%KD%KD%KD%KD%KD%KD%KD%KD%}KD%uKD%mKD%eKD%]KD%UKD%MKD%EKD%=KD%5KD%-KD%%KD%KD%KD% KD%KD%JD%JD%JD%JD%JD%JD%JD%JD%JD%JD%JD%JD%JD%JD%JD%JD%}JD%uJD%mJD%eJD%]JD%UJD%MJD%EJD%=JD%5JD%-JD%%JD%JD%JD% JD%JD%ID%ID%ID%ID%ID%ID%ID%ID%ID%ID%ID%ID%ID%ID%ID%ID%}ID%uID%mID%eID%]ID%UID%MID%EID%=ID%5ID%-ID%%ID%ID%ID% ID%ID%HD%HD%HD%HD%HD%HD%HD%HD%HD%HD%HD%HD%HD%HD%HD%HD%}HD%uHD%mHD%eHD%]HD%UHD%MHD%EHD%=HD%5HD%-HD%%HD%HD%HD% HD%HD%GD%GD%GD%GD%GD%GD%GD%GD%GD%GD%GD%GD%GD%GD%GD%GD%}GD%uGD%mGD%eGD%]GD%UGD%MGD%EGD%=GD%5GD%-GD%%GD%GD%GD% GD%GD%FD%FD%FD%FD%FD%FD%FD%FD%FD%FD%FD%FD%FD%FD%FD%FD%}FD%uFD%mFD%eFD%]FD%UFD%MFD%EFD%=FD%5FD%-FD%%FD%FD%FD% FD%FD%ED%ED%ED%ED%ED%ED%ED%ED%ED%ED%ED%ED%ED%ED%ED%ED%}ED%uED%mED%eED%]ED%UED%MED%EED%=ED%5ED%-ED%%ED%ED%ED% ED%ED%DD%DD%DD%DD%DD%DD%DD%DD%DD%DD%DD%DD%DD%DD%DD%DD%}DD%uDD%mDD%eDD%]DD%UDD%MDD%EDD%=DD%5DD%-DD%%DD%DD%DD% DD%DD%CD%CD%CD%CD%CD%CD%CD%CD%CD%CD%CD%CD%CD%CD%CD%CD%}CD%uCD%mCD%eCD%]CD%UCD%MCD%ECD%=CD%5CD%-CD%%CD%CD%CD% CD%CD%BD%BD%BD%BD%BD%BD%BD%BD%BD%BD%BD%BD%BD%BD%BD%BD%}BD%uBD%mBD%eBD%]BD%UBD%MBD%EBD%=BD%5BD%-BD%%BD%BD%BD% BD%BD%ADH|$@HtHD$HH9tHH|$PHtHD$XH9tHH|$PHtHD$XH9tHH|$0HD$8H9t HtHH}HEH9t HteH}HtHEH9tNHfLnHVH^LFLNH6L>H&H.LLHLHHLLHLHHLLHLHfDH5H>Af.HM7HOf.H5;HRf.HAHTf.HMGH^Wf.HJHYf.HPH[f.H]H^f.HbH`f.H%jHcf.HwH^hf.HH^lf.HHnf.HHqf.HUHvf.HH^zf.ATL%s>UH-lHHH=(%LHH-KHH=g$LHH-HNH]A\fDHH΁f.HUH.f.HHf.H-Hf.HmHnf.HHf.H Hf.ATL%#=UH-HH_H=#LHH-HH=#LH|H]HޒH]A\fDATL%<UH-HHH=h#LHH-&HH="LH H HH]A\fDATL%C<UH-BHHH="LHH-!HH=7"LHHH~H]A\fDATL%;UH-HHH="LHH-FHNH=?"LH,HMH.H]A\fDH=HΜf.UH-NHH=U&HH+;HO]HfDHH.f.H%HΤf.HU#Hf.HE'Hf.ATL%:UH-HH/H=%LHH-gHH=!LHH-EHH=6!LHH/H}H]A\DH4H^f.H;H>f.H KHf.H]QHf.HfHf.HsHf.HHf.H-Hf.HHf.H}Hf.HH^f.HH~f.HH>f.H5Hf.HHf.HH~f.HHf.HHf.HH^f.HUHf.HHf.HHf.HHf.H=Hf.H!H^f.H$Hf.UH-HlH=!H]H65DH=H H9tH Ht H=H5H)HH?HHHtH!HtfD=u+UH=Ht H=5d]w'UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$ 1HT$8dH+%(uhH@]@HT$H|$H5|$HtHt+HH5|HPtHuH1Hu-ff.fHGI~H)ǃuHH=BLHH51HÐHGI~H)ǃuHH=BLOHH5X1HÐHHdH%(HD$81HHt$HD$HFHD$$D$ t1H|$1HT$8dH+%(uGHHfDH|$HT$H5nz|$HtKVHuHHff.@UH0dH%(HD$(1HH4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDHI1MuH2fUH0dH%(HD$(1HH4$HD$HFHD$D$t*H11F1HT$(dH+%(u-H0]fDCH+I1MuHIfUH0dH%(HD$(1H,H4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDHI1MuHfUH0dH%(HD$(1HH4$HD$HFHD$D$t*H11&1HT$(dH+%(u-H0]fDH I1MuH)fUH0dH%(HD$(1H(H4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDH{I1MuHfUH0dH%(HD$(1HH4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDHI1MuH bfUH0dH%(HD$(1H9H4$HD$HFHD$D$t*H11v1HT$(dH+%(u-H0]fDH[I1MuHyfUH0dH%(HD$(1HH4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDHI1MuHBfUH0dH%(HD$(1HCH4$HD$HFHD$D$t*H11V1HT$(dH+%(u-H0]fDH;I1MuHYfUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(utHH[]fHt$H|$tHl$H=*H'tHH=u[HuHc@HH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(u9H8HHuҐ HuHBHff.@H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(u9H8HHuҐ+HuHrH/ff.@H8fnFdH%(HD$(1H\H4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(u9H8 HHuҐHuHH_ff.@UH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11>1HT$(dH+%(u8H0]fD;HHuӐHHuH6ff.@SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11n1HT$(dH+%(u7H0[fDkHHuӐkDHuHcSH0fnFdH%(HD$(1H2H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u7H0[fDHHuӐ+HuHcSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u7H0[fDHHuӐHuHc@SH0fnFdH%(HD$(1HKH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11.1HT$(dH+%(u7H0[fD+HHuӐHuHcWSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11n1HT$(dH+%(uiH0[fDkHHuӐt$ffH~>HufHn/DHffH~HH; tfH~ff.SH0fnFdH%(HD$(1H)H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11n1HT$(dH+%(uuH0[fDkHHuӐt,TfH~:HufHn+fH%HH; fH~tfH~fSH0fnFdH%(HD$(1H=H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11n1HT$(dH+%(uuH0[fDkHHuӐt$WHfH~=HufHn.@HHH; u_HfH~ffH~fUH0fnFdH%(HD$(1HIH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11n1HT$(dH+%(uVH0]fDkHHuӐtHo8CHuHf@HHH; tHSH0fnFdH%(HD$(1HxH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐt_0dHuHcDHHH;tЉfUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uVH0]fDHHuӐtHoXHuH@HHH;7 tHUH0fnFdH%(HD$(1HܾH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(ukH0]fDHHuӐt$Ho@HuHHx.HHH;W tHfDCff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5kHT$H|$|$HtHsHuH/Hff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uXH@]f.HHuϐHt$H|$!tD$H?zHuH6HUH@fnFdH%(HD$81H0Ht$HD$HGfnȉD$(fbfD$ uLHD$Ho(Ht!D$ +D$$t=H|$1HT$8dH+%(uNH@]ÐHHuؐHt$H|$tHt$H HuHGH@UH@fnFdH%(HD$81HPHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uVH@]f.HHuϐHt$ H|$tt$ H豷HHuH輾DUH@fnFdH%(HD$81HxHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uUH@]f.HHuϐHt$ H|$tt$ HHuHc&fDUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uVH@]f.HHuϐHt$ H|$!tt$ H聸HHuHܼ5DUH@fnFdH%(HD$81HɸHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uVH@]f. HHuϐHt$ H|$1tt$ HHHuHEDUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$"1HT$8dH+%(uVH@]f.HHuϐHt$ H|$Att$ HqHHuHUDUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$21HT$8dH+%(uVH@]f.+HHuϐHt$ H|$Qtt$ H豳HHuH eDUH@fnFdH%(HD$81H?Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$B1HT$8dH+%(u[H@]f.;HHuϐHt$ H|$att$ HqHHuH臿pATUH8fnFdH%(HD$(1H]H4$HD$HGfnȉD$fbfD$uCH(HtD$9D$tHH11\1HT$(dH+%(H8]A\fDSHHuftDHoP#HuHtQHHHIHu LH讴@HHH;tHfDHHNCAVAUATUHHfnFdH%(HD$81H=Ht$HD$HGfnȉD$(fbfD$ uVHo(Ht!D$ +D$$tPH|$1HT$8dH+%(HH]A\A]A^f. HHuŐLt$ Ll$LH5RL|$ ItLLtT$ HL輿HpHcef.ATUHHfnFdH%(HD$81H Ht$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$1HT$8dH+%(ulHH]A\fDHHuѐLd$Ht$LtHt$ LtT$ t$HYHHuH贵 ff.fATUHHfnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$1HT$8dH+%(ulHH]A\fDHHuѐLd$Ht$LtHt$ LtT$ t$HHHuH褴ff.fAVAUATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ Ho(Ht!D$ +D$$t;H|$1HT$8dH+%(H@[]A\A]A^@Lt$Ll$LH5L|$ItLH5^<L|$HtLH\HuHcuf.KHH.S赼DUH@fnFdH%(HD$81HկHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ t19u0tHEu0H7HuHHDHEHH;u;u0tˉu0HfHt@H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11_1HT$(dH+%(H8@[HHuҐHtAHH;uIG0t G0HuHHfDHH;t@1eDH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11O1HT$(dH+%(H8@KHHuҐHtAHH;uI0t G0HuHHHH;*t@RfAWAVAUATUSHHfnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ Ho(Ht!D$ +D$$t9H|$%1HT$8dH+%(HH[]A\A]A^A_L|$Lt$LH5rL|$ItLH5L|$ItLH5L̾|$HyLLHPH[HcP苿HH5DUH@fnFdH%(HD$81HvHt$HD$HGfn؉D$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fD˾HHuϐHt$H|$1tD$$D$t_fUHf/ ]f(f.ztHEEHHMHbHHT@HEHH;&u\fUHf/w- ]f(f.ztEHHDf(f.f([HdAAUATUH`fnFdH%(HD$X1HH4$HD$HGfnȉD$fbfD$uIHo(HtD$+D$tCH!1HT$XdH+%(H`]A\A]ÐHHuАLd$ ILL8tHD$0foT$ L1HHD$P)T$@蒷D$@9D$ uXD$$9D$DuND$H9D$(uDD$L9D$,u:D$P9D$0u0D$T9D$4u&聿HGH9H9[HuйL1Lʹff.fATUSH@fnFdH%(HD$81HOHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\苻HHuːHt$H|$衪tD$$Ld$uXHELH@H;u\H=tLH=ة͸u)HeHccZfDLL8@HЉbfAVAUATUHHfnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uVHo(Ht!D$ +D$$tPH|$<1HT$8dH+%(HH]A\A]A^f.+HHuŐLd$Ht$LNtLl$LL:tLt$ LL&tt$LLH 軼HtF豼Ht$觼HRH_HDfDT$ L藯DT$LATH0fnFdH%(HD$(1HuH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@øHHufHHRxH;*7IMtoI$H5LPtZeHuL舧IHoHbL贰1HHP@L8fE1H"DIjyfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5ܣDݿ1HT$8dH+%(=H@]ÐL Ht$LL$L$ D$$D$(HH(HtD$$9D$ twH|$11 1DH `Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$访1<1I袹HHc@Ht$ H|$ɳt$ HkHHcf.KHH赮DUH@HNdH%(HD$81HGfnAH%HfnfbA)Au\H +Ht$HL$D$(fD$ HHo(Ht>D$ +D$$H|$j1fDH5ϡD1HT$8dH+%(H@]DL Ht$LL$L$ D$$D$(HH(HtD$$9D$ tH|$111DHH7yf.Ht$ H|$Xt$ H-H襷H;Hģ01@苴HHU DUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5yD]1HT$8dH+%(=H@]ÐL MHt$LL$L$ D$$D$(HH(HtD$$9D$ twH|$11艼1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$.1<19"HHcq@Ht$ H|$It$ HHHcf.˲HH5DUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5ўD蝺1HT$8dH+%(=H@]ÐL Ht$LL$L$ D$$D$(HH(HtD$$9D$ twH|$11ɺ1DH UHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$n1<1蹩bHHc豱@Ht$ H|$艮t$ H+HHcf. HHuDATUHHHNdH%(HD$81HGfnAH%HfnfbA)AuZH #Ht$HL$D$(fD$ HHo(HtAfH5MD1H$dH+%(HĘ[]A\A]A^A_HHt$0H\$8L$@T$DT$HHH(HD$D9D$@H|$0111zfH$dH+%(EHĘHH[H=D]A\A]A^A_&fDHmHt$0H\$8L$@T$DT$HHLg(Mt%D$@+D$DH|$0|1DH Ht$0H\$8L$@T$DT$HHLg(MtŋD$@+D$DH|$01}DHHt$0H\$8T$HfD$@HLg(McD$@+D$DH|$0躰1˧HH1諧HH51苧HH1kHHS11詟H1HH軜nfDHl$0Ht$HNjLl$HL6RLt$HL:H\$ HH"L|$$HL HT$(HHH$ңHL$,HHHL$赣HL$MILQHT$LRt$$LXZ2HC$HHHHHۨHFHHfLl$Hl$0LHLt$HLH\$ HHˢL|$$HL賢HT$(HHH$藢HL$,HHHL$zHL$H$1MILQLRLY^HHfާHBЧH§H货HT$,H躚DHl$0Ht$,HΡLl$PHL豙HD$`t$,LLfoT$PH$)T$pD$p9D$PuH(HtD$9D$t;H11蟧1HT$(dH+%(uLH8蛞HHuҐu$HnHuH*H@賟ܖff.H8fnFdH%(HD$(1HGH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11迦1HT$(dH+%(uLH8軝HHuҐu$H莠HuHJH@ff.H8fnFdH%(HD$(1H}H4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11ߥ1HT$(dH+%(uLH8ۜHHuҐu$H讟HuHjH@sff.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(uLH8HHuҐu$HΞHuHH@蓥tHt$ L-tD$$T$ t$u)HEHh跍HuHsHtfH舅!ATUHHfnFdH%(HD$81H5sHt$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$1HT$8dH+%(HH]A\fHHuѐLd$Ht$ LtHT$ H5HxLƈ|$ HtD$$t$ u0HEH`莌HuHFHgDHXnAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAAuZH vHt$HL$T$(fD$ HHo(HtEHT$ H5dvL|$ H#L$$t$ HEHP>DH5#vHT$ H|$蚆|$ HD$$uTHEHXbHHHfKHHf.HfDHh{AT1UHHHNdH%(HD$81HGAfnH%fnA)fbAAuZH ptHt$HL$T$(fD$ HHo(HtDH5sHT$ H|$:|$ HD$$uTHEHHHHHfHHf.H(fDH蘌1}ATUHXfnFdH%(HD$H1HYrHt$ HD$(HGfnȉD$8fbfD$0uZHD$Ho(HD$Ht!D$0+D$4tBH|$ 1HT$HdH+%(HX]A\HHuӐLd$ Ht$LtHt$L tHt$ LtHt$LrtHt$LrtD$4LL$LD$L$ T$t$u+HEH8RH;H H-Ha{f.ATUHXfnFdH%(HD$H1HpHt$ HD$(HGfnȉD$8fbfD$0uJHo(Ht!D$0+D$4tDH|$ 萋1HT$HdH+%(HX]A\f苂HHuѐLd$ Ht$ LtHt$LtHt$LtHt$L{tHt$LjrD$4DL$DD$L$T$t$ u+HEH(H9HH+H1Jzf.ATUHXfnFdH%(HD$H1HioHt$ HD$(HGfnȉD$8fbfD$0uZHD$Ho(Ht!D$0+D$4tKH|$ 1HT$HdH+%(HX]A\f HHuʐLd$ Ht$L.~tHt$ L~tHt$L ~tHt$L}tHt$LokD$4LL$DD$L$T$ t$u+HEH bH2HH$Hxf.AT1IUHHfnFdH%(HD$8HG~H%fn)fbt8H5m31HT$8dH+%(7HH]A\DHmHt$HT$L$(fD$ HIh(HtD$ +D$$tNH|$R1fDHD$8dH+%(HHHH=L]A\kLd$Ht$ Lf|;HT$ H5xmL ~|$ HD$$t$ uPHEH0΁HHHDL~IHHewUH@fnFdH%(HD$81HRlHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uzH@]f.}HHuϐH5?lHT$H|$||$HtD$$u(HEH薀HuHRH@HxcvAVAUATUHHfnFdH%(HD$81HKkHt$HD$HGfnȉD$(fbfD$ uVHo(Ht!D$ +D$$tPH|$܅1HT$8dH+%(HH]A\A]A^f.|HHuŐLt$ Ll$LH5kL{|$ ItLLytD$$T$ u/HEHLXHcHc|XfHLwtff.UH@fnFdH%(HD$81HjHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$蒄1HT$8dH+%(uzH@]f.{HHuϐH5hdHT$H|$jz|$HtD$$u(HEH6~HuHH@HqsHG89w0tHw0G0fWHf/w- ž]f(f.zu@HGHff(f.ftGHfDHGPHG@HH1Hxf.HH1Hf.HGX~UH=obHlwu]ÐHH=\hQwtH]a@HHH;u!0tG0fDHHH;ӭu!W0tG0D1@7{UH@dH%(HD$81HpaHt$HD$HFHD$$D$ t0H|$蜁1HT$8dH+%(uhH@]@HT$H|$H5aw|$HtHt+HH5fHPtR{HuHug19{Hupff.fUSHHdH%(HD$81HaHt$HD$HFHD$$D$ HD$t6H|$貀1HT$8dH+%(utHH[]fHt$H|$ftHl$H= fH'utHH=fuu[zHuHcw@H_oSH0fnFdH%(HD$(1H#H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u7H0[fDvHHuӐZyHuHcvoUH0fnFdH%(HD$(1HlH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11~1HT$(dH+%(u8H0]fDuHHuӐKlHxHuHd?nff.@ATUSH@fnFdH%(HD$81HaHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$~1HT$8dH+%(H@[]A\tHHuːHt$H|$dtD$$Ld$uXHELH@H;Vu\H=/cPrtLH=Hc=ru)wHeHctZfDLL\@HЉlfUH@fnFdH%(HD$81HHHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$|1HT$8dH+%(u_H@]f.sHHuϐH54\HT$H|$r|$HtHzcvHuHHkff.UH@fnFdH%(HD$81HTHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|${1HT$8dH+%(uVH@]f.rHHuϐHt$ H|$ott$ HyluHuH(HjDATH0fnFdH%(HD$(1Hu^H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11zE1HD$(dH+%(H0LA\@qHHufHHRxH;sIMtoI$H5_LPtZetHuL`IHoHVbLi1HHP@Lm8fE1tH"DIjyifATL%#H HO_H5Llu{LHnLA\ATIUH^Ht HH5^LH[tHmtH]A\HH]A\`grUH=^Hmu]ÐHH=^mtH]DX@^UH@dH%(HD$81HPXHt$HD$HFHD$$D$ t0H|$|x1HT$8dH+%(uhH@]@HT$H|$H5Wjn|$HtHt+HH5]HPt2rHuHU^1rHugff.fUSHHdH%(HD$81HXHt$HD$HFHD$$D$ HD$t6H|$w1HT$8dH+%(HH[]DHt$H|$]tHl$H={HltHH=Vku;qHuHcn@HH=\ktH]Vf@ATUSH@fnFdH%(HD$81HZHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$fv1HT$8dH+%(H@[]A\[mHHuːHt$H|$q\tD$$Ld$uXHELH@H;ulH=!jtLH=Uju)oHeHc3mZfDLLH=l[ajtLT븐HЉ"efATH0fnFdH%(HD$(1HXH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11 uE1HD$(dH+%(H0LA\@lHHufHHRxH;ZIMtoI$H5гLPtZnHuLZIHoHDPbLc1HHP@LWg8fE1HnH"DIjcfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5Ds1HT$8dH+%(=H@]ÐL ҲHt$LL$L$ D$$D$(HH(HtD$$9D$ twH|$11Is1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$r1<1 uHlHHYHt$ H|$ gt$ HiHHcf.iHHaDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtd1HT$(dH+%(uUH0[fD;[HHuӐt^HuHcd[fHHH;tЉrSfUH@fnFdH%(HD$81H)Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$Rc1HT$8dH+%(uVH@]f.KZHHuϐHt$ H|$qWtt$ HN ]HuHȌHRDUSHHdH%(HD$81HCHt$HD$HFHD$$D$ HD$t6H|$b1HT$8dH+%(HH[]DHt$H|$HtHl$H=ϭHVtHH=Vu+\HuHc~Y@HH=VtHH=AVtHH=GVtH'A^Qff.ATUSH@fnFdH%(HD$81HDHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$&a1HT$8dH+%(H@[]A\XHHuːHt$H|$1GtD$$Ld$u`HELH@H;H=AlUtLH=fYUu-ZHaHcWVf.LLH=GUtLH=Z@UtLH=ETtL?HЉOfATH0fnFdH%(HD$(1HECH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11_E1HD$(dH+%(H0LA\@VHHufHHRxH;Z^IMtoI$H5ĪLPtZ5YHuLXEIHoH:bLN1HHP@LQ8fE1XH"DIjINfATL%H HH5>LQ8uNLH~SLA\ATIUHMFHt HH5LHS@tHmtH]A\HH]A\EDG]UH=dHRu]ÐHH=~qRtHH=^RtHH==KRtHH=CC8RtH]Ht$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$Z1HT$8dH+%(H@[]A\QHHuːHt$H|$@tD$$Ld$u`HELH@H;NH=bOtLH=a Ou-PTHaHcQVf.LLH=9NtLH=?NtLJ9fDHЉrIfATH0fnFdH%(HD$(1H=H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11]YE1HD$(dH+%(H0LA\@SPHHufHHRxH;zMIMtoI$H5LPtZRHuL?IHoH4bLDH1HHP@LK8fE1RH"DIj HfATL%H HFH5~LvKxu?LHiMLA\ATIUHQHt HH5LH:tHmtH]A\HH]A\a?KUH=H\Lu]ÐHH=ALtHH=.7.LtHH=&=LtH]6f.@W>UH@dH%(HD$81H6Ht$HD$HFHD$$D$ t0H|$V1HT$8dH+%(uhH@]@HT$H|$H5\6L|$HtHt+HH5ƪHPtPHuH<1yPHuEff.fUH0dH%(HD$(1H~H4$HD$HFHD$D$t*H11V1HT$(dH+%(u-H0]fDLHOI1MuH 63EtL/HЉ?fATH0fnFdH%(HD$(1H3H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11OE1HD$(dH+%(H0LA\@FHHufHHRxH;w6IMtoI$H5LPtZuIHuL5IHoH+bL>1HHP@L'B8fE1IH"DIj>fATL%H HH5>LA8u(?LH~CLA\ATIUH-KHt HH5LH0tHmtH]A\HH]A\5W5UH=YHBu]ÐHH=ΜBtHH=ܜBtHH=-BtHH=3BtH]-f.8UH@dH%(HD$81H -Ht$HD$HFHD$$D$ t0H|$LM1HT$8dH+%(uhH@]@HT$H|$H5,:C|$HtHt+HH5;HPtGHuH%31FHumHHSf.K>HH6DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt1HT$8dH+%(MH@]ÐL XHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11I>1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$=1<8H7HH$DHt$ H|$ 2t$ H+H7Hf4HHSf.{4HH,DUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5.|DM<1HT$8dH+%(MH@]ÐL |Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11y<1DH {Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$<1< H6HH2"DHt$ H|$90t$ H.H5Hf2HHSf.2HH+DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt:1.H5HT$ H|$:0|$ HH/4HHcHfDLd$Ht$ L..HT$ H5L/|$ Ht$ H3Ht~f0HH_f.{0HH?(DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAttHT$ H5L|$ Htt$ H@HuHwOHx1ATUHHfnFdH%(HD$81HdHt$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$%1HT$8dH+%(uxHH]A\fD HHuѐLd$Ht$ L.tHT$ H5L|$ Htt$ H`%HuHgNHx!ATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$#1HT$8dH+%(H@[]A\HHuːHt$H|$ tD$$Ld$uXHELH@H;NPulH=r@tLH=--u)tHeHcZfDLLH=tL븐HЉfATH0fnFdH%(HD$(1HEH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11"E1HD$(dH+%(H0LA\@HHufHHRxH;JIMtoI$H5GqLPtZ5HuLXIHoHbL1HHP@L8fE1H"DIjIfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5`D 1HT$8dH+%(MH@]ÐL b`Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11 1DH `Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$~ 1<[HsHHDHt$ H|$t$ HH-Hf+HHSf. HHuDATL%H HnH5nLhuLHLA\ATIUHHt HH5qnLHtHmtH]A\HH]A\wUH='nHu]ÐHH=tHH=tH]1wUH@dH%(HD$81HҚHt$HD$HFHD$$D$ HD$t/H|$c1HT$8dH+%(u=H@]Ht$H|$tH|$H3HuHV ff.@UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5,|$HtHt+HH5JlHPtbHuH1IHu ff.fUH0dH%(HD$(1HUH4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDHI1MuH2 fUH0dH%(HD$(1HH4$HD$HFHD$D$t*H11F1HT$(dH+%(u-H0]fDH+I1MuHI fUH0dH%(HD$(1H-H4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fD3HI1MuH fUH0dH%(HD$(1HH4$HD$HFHD$D$t*H11&1HT$(dH+%(u-H0]fD H I1MuH) fUH0dH%(HD$(1H5H4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDcH{I1MuH fUH0dH%(HD$(1HH4$HD$HFHD$D$t*H111HT$(dH+%(u-H0]fDHI1MuH b fUSHHdH%(HD$81HtHt$HD$HFHD$$D$ HD$t6H|$b1HT$8dH+%(HH[]DHt$H|$tHl$H=hH tHH= u HuHc^@HH= tH-d@UH0fnFdH%(HD$(1H8H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11N1HT$(dH+%(ukH0]fDKHHuӐt$Ho`#HuHHx.qHH0H;/DtHfDlff.ATH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11ME1HD$(dH+%(H0LA\@CHHufHHRxH;@IMtoI$H5eLPtZHuLIHoHbL41HHP@L 8fE1H"DIjfATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\ HHuːHt$H|$tD$$Ld$uXHELH@H;AulH=>d tLH=Q u)DHeHc ZfDLLH= tLU븐HЉfATL%H HcH5>L8u8LH~ LA\ATIUHHt HH5WcLHtHmtH]A\HH]A\UH@fnFdH%(HD$81HɐHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(utH@]f. HHuϐHt$ H|$tD$$t$ u)HEHPm HuHc fDHPSH0fnFdH%(HD$(1HmH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uMH0[fD HHuӐu$H HuHc Df.SH0fnFdH%(HD$(1H|H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uMH0[fDHHuӐu$H  HuHcDf.SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uMH0[fDHHuӐu$HH HuHcD:f.UH@fnFdH%(HD$81HnHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(utH@]f. HHuϐHt$ H|$1tD$$t$ u)HEH@ HuHcfDH'ATUHHfnFdH%(HD$81HoHt$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$1HT$8dH+%(HH]A\fHHuѐLd$Ht$LtHt$ L tD$$T$ t$u)HEH8HuHcuHhff.@UH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5xD] 1HT$8dH+%(sH@]ÐL LHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11 1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tRH|$. 1<HHHcgfHt$ H|$AD$$t$ uMHEH@HHKfHHf.H dWf.DHG`UH= [Hu]ÐHH=tHH=tH]AgUH@dH%(HD$81HPHt$HD$HFHD$$D$ t0H|$| 1HT$8dH+%(uhH@]@HT$H|$H5j|$HtHt+HH5HPt2HuHU1Huff.fUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$ 1HT$8dH+%(HH[]DHt$H|$tHl$H=HtHH=u;HuHc@HH=tH]@ATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$f 1HT$8dH+%(H@[]A\[HHuːHt$H|$qtD$$Ld$uXHELH@H;~3ulH=tLH=u)HeHc3ZfDLLH=latL븐HЉ"fATH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11 E1HD$(dH+%(H0LA\@HHufHHRxH;j4GIMtoI$H5fLPtZHuLIHoHDbL1HHP@LW8fE1HH"DIjfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5ED1HT$8dH+%(=H@]ÐL EHt$LL$L$ D$$D$(HH(HtD$$9D$ twH|$11I1DH EHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$1<1 HHHHt$ H|$ t$ HHHcf.HHDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtH(HtD$9D$t;H11O1HT$(dH+%(u9H8KHHuҐK&HuH&Hff.@SH0fnFdH%(HD$(1H͍H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11~1HT$(dH+%(u6H0[fD{HHuӐ;THuSH0fnFdH%(HD$(1H H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐtHuHHPH;#tЉfUH@fnFdH%(HD$81HQHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5ˋHT$H|$|$HtHHuH?$Hff.UH@fnFdH%(HD$81HfHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(u_H@]f.HHuϐH5THT$H|$|$HtHXHuH?#Hff.UH@fnFdH%(HD$81HpHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$AtD$$t$ t99tHEHqHuH-"H|@HEHHH;>%u;tƉHHff.ATH0fnFdH%(HD$(1H5H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@HHufHHRxH;2%IMtoI$H5LPtZ%HuLHIHoHbLt1HHP@L8fE1H"DIj9fATL%jH 1HT$(dH+%(uZH0[fD;HHuӐtHuHceHHH;RtЉmff.fUH@fnFdH%(HD$81HFHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$B1HT$8dH+%(u_H@]f.;HHuϐH5?HT$H|$|$HtHHuHHlff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$B1HT$8dH+%(uUH@]f.;HHuϐHt$ H|$att$ HHuHcMvfDATUHHfnFdH%(HD$81HmHt$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$P1HT$8dH+%(ulHH]A\fDKHHuѐLd$Ht$LntHt$ L]tT$ t$HHHuHmff.fATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$61HT$8dH+%(H@[]A\+HHuːHt$H|$AtD$$Ld$uXHELH@H;u\H=tLH=xmu)HeHcZfDLL@HЉfATH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@HHufHHRxH;IMtoI$H5LPtZHuLIHoH$bL1HHP@L78fE1(H"DIjfAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAAuZH CHt$HL$T$(fD$ HHo(HtD$ +D$$H|$*1fDH5bD1HT$8dH+%(H@]DL 2Ht$LL$L$ D$$D$(HH(HtD$$9D$ toH|$111DHH7yf.Ht$ H|$XD$$t$ u]HEHH HKH!HjD;HHEf.H8Hff.UH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5D1HT$8dH+%(sH@]ÐL ܿHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$111DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tRH|$1<HHHcfHt$ H|$D$$t$ uMHEH@cHHKfKHHf.HdWf.DfDUH=ùHlu]ÐHH=\QtH]@GUH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5 |$HtHt+HH5HPtHuH1Hu=ff.fUSHHdH%(HD$81HDHt$HD$HFHD$$D$ HD$t6H|$21HT$8dH+%(utHH[]fHt$H|$OtHl$H=HtHH=uHuHc.@HGH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11/1HT$(dH+%(u9H8+HHuҐ HuHHff.@SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11^1HT$(dH+%(u7H0[fD[HHuӐ諱4HuHcSH0fnFdH%(HD$(1HSH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u7H0[fDHHuӐtHuHcSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐt_8HuHcDHHH;gtЉfUH@fnFdH%(HD$81HքHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uVH@]f.HHuϐHt$ H|$tt$ HaHuHhH%DUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(uUH@]f.HHuϐHt$ H|$!tt$ HHuHc 6fDUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fD HHuϐHt$ H|$1tD$$t$ t19u8tHEu8HHuHsHDHEHH;u;u8tˉu8HfH@H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtAHH;uI8t G8HuHMHHH;t@fH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(H8@HHuҐHtAHH;uIG8t G8HuH<HfDHH;t@1վDATUSH@fnFdH%(HD$81H_Ht$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\HHuːHt$H|$豴tD$$Ld$uXHELH@H;>u\H=b~tLH=u)$HeHcsZfDLLH@HЉrfATH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11]E1HD$(dH+%(H0LA\@SHHufHHRxH;IMtoI$H5!}LPtZHuLIHoH蔨bLD1HHP@L觿8fE1H"DIj fAV1IAUATUSHpfnFdH%(HD$hHG~H%fn)fbt;H5|n1HT$hdH+%(fHp[]A\A]A^H |Ht$ HL$(T$8fD$0HIh(Ht%D$0+D$4H|$ 1fHP|Ht$ H\$(T$8fD$0H,Hl$ Mp(1HTH|$@4AHc葫Ll$@EugM5D$0+D$4HH|$@1HT$HH9HHD$#HD$fIcI\fDHt$H|$ t$H HHHnf.Ht$H賾PDLH蝶:EIUHH)H[AD$MD1HfDAoTHH9uDAt4AtH4HA9~ALLA9~ ADDt$LLuE~1Ic1fHH9t A9LtxHjIH|$@1MSHHCLHIHH|$ H|$@4Hc[H|$@1IL1LIH1D1ATHH9uDLH7#HAV1AUATUSHĀHNdH%(HD$x1HGAfnH%fnA)fbAtA5HxHt$0H\$8T$HfD$@HAHo(Ht%D$@+D$DGH|$01HT$xdH+%({H[]A\A]A^H}xHt$0H\$8L$@T$DT$HHHl$0Lw(11HuH|$P4AHc貧Ll$PEMD$@+D$DjHH|$P1HT$XH9BH9HD$@HD$%fDH5wDA1 f.IcI\o˽HHf.Ld$0Ht$L޺Ht$LɺHt$ L贺Ht$$L蟺tHt$(L芺_Ht$,LuJHHD$4PDL$8DD$4L$0T$,t$(膨XZHHHfDDLHEIUHH)H=AD$/D1HAoTHH9uDAt4AtH4HA9~ALLA9~ ADDLLE~HG(HtL$9L$t;H11ߺ1HT$(dH+%(u;H8۱HHuҐ@l贴HuHpH-ff.fH8fnFdH%(HD$(1H|H4$HD$HGfnȉD$fbfD$u>HG(HtL$9L$t;H111HT$(dH+%(u;H8 HHuҐ@lHuHH]ff.fH8fnFdH%(HD$(1H|H4$HD$HGfnȉD$fbfD$u>HG(HtL$9L$t;H11?1HT$(dH+%(u;H8;HHuҐ@lHuHH荨ff.fH8fnFdH%(HD$(1HF{H4$HD$HGfnȉD$fbfD$u>HG(HtL$9L$t;H11o1HT$(dH+%(u;H8kHHuҐ@lDHuHH轧ff.fUH0fnFdH%(HD$(1HzH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11螷1HT$(dH+%(u^H0]fD蛮HHuӐt$HoH|$E1H|$04Hc;H|$0IsLE1hHt$ HKDLH5EIUHH)HAD$D1HfDAoTHH9uDAt4AtH4HA9~ALLA9~ ADDt$ LLE~-Ic1fHH9t A9LtأHt'ΣH|$0E1HUL%~I$DDLH9D1ATHH9u^HAT1UHhHNdH%(HD$X1HGAfnH%fnA)fbAAuZH lHt$ HL$(T$8fD$0HHo(HtEHt$ L)0Ht$LHt$LHt$LHt$L՛DD$L$T$ t$D$DL$fnfAnfnfnDT$4fbfAnfnfbfbflEL]ML;I9uTuTHUXM\DE`DMdEhALd$@H|$ L L$4HEHH;foD$@LL;T$TDL$PDD$Lf~ƋL$HD\$D9uTuyD;]Xus;M\unD;E`uhD;Mdub;Uhu]oDKHHf.foD$@LL;<T$TDL$PDD$Lf~ƋL$HD\$Du?;uTtDMdHUhETџH'HHHHRDAXZLH9uTtbHEETHfUd;UXd9M\[D9E`QD9MdG;Eh>mWHPAAXAY\轔;UXu9M\uD9E`uD9Mdu;Ehu7ff.fAT1UHhHNdH%(HD$X1HGAfnH%fnA)fbAAuZH gHt$ HL$(T$8fD$0HHo(HtmWHPAAXAY\];U@u9MDuD9EHuD9MLu;EPu7ff.fU1H=hH1H=!HHH8Hmt H]fDHHD$ۇHD$H]AVH cHDbAUH5"ATL%ULS@" t[L]A\A]A^SH- L5] HHK HH"sHH5bLсt H- tcH,Lk@{蠞HHtH3HL蚁Hmt#HL9uL袔[L]A\A]A^fDH؆fDHȆfDATIUH Ht HH5&aLH#tHmtH]A\HH]A\qUHAWAVAUATSHH8fnFdH%(HE1HaH`HhHGfnȉxfbfօp+H8H@(H8L`LEH}4AHc~H]HDž0EtIcHH0L4H}AHcB~HDž(LuEtIcIH(H8bp+tL苝LuE1MtHEI9tL辏H}HEH9t Ht觏HEdH+%(oHeL[A\A]A^A_]fKH8HfDHLLanHPLJWHTL3@DHL*DLLHXLH\LِEH0HSH)HCAD$5D1HfDoH0HH9uDAt3Hϋ4H 4PA9~T TA9~D DEH(IVH)HAE|D1HfDAoH(HH9uDAt6HA4H 4PA9~ATTA9~ ADDDtD\XTPLEL8MIAPIWL08XZE~2Ic1DHH9tH0 9 t˔HE~4Ic1fDHH9tH( A9 t蒔H脔HHc8ϑLuIE1APMIWH8S=D1AH(HH9uD1H0HH9uDLL芔\pDHھLmH逜H鋜SH0fnFdH%(HD$(1H\H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11.1HT$(dH+%(uMH0[fD+HHuӐu$H(HuHcODCjf.SH0fnFdH%(HD$(1H \H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11N1HT$(dH+%(uMH0[fDKHHuӐu$H HuHcoD#芇f.fnfAnfnt$fnfAnfbfbfnflfb9GTtHGTfWdD9WXu9O\uD9G`uD9Odu9whu@HGTfnfAnfnt$fnfAnfbfbfnflfb9G1HT$(dH+%(uNH0[]A\膁HImLHPxfDHIH5iH8"1yHזff.fATL%1HʠH5L諄uLڈLA\@ATIUHHt HH5iLHutHmtH]A\HH]A\z|UH@dH%(HD$81HrHt$HD$HFHD$$D$ t0H|$̒1HT$8dH+%(uhH@]@HT$H|$H5Lr躈|$HtHt+HH5yjHPt肌HuHx1iHuff.fUSHHdH%(HD$81HrHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(HH[]DHt$H|$wtHl$H=iHWtHH=DqDu苋HuHcވ@HH=$wtHp@ATUSH@fnFdH%(HD$81HotHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$趐1HT$8dH+%(H@[]A\談HHuːHt$H|$vtD$$Ld$uXHELH@H;ulH==htLH=ou)4HeHc胇ZfDLLH=u豄tLEo븐HЉrfATH0fnFdH%(HD$(1HsH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11]E1HD$(dH+%(H0LA\@SHHufHHRxH;xIMtoI$H5fLPtZHuLuIHoHjbLD~1HHP@L见8fE1蘈H"DIj ~fUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5NDm1HT$8dH+%(=H@]ÐL "Ht$LL$L$ D$$D$(HH(HtD$$9D$ twH|$11虍1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$>1<1yH1HHPsHt$ H|$Yt$ HHHcf.ۃHHE|DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt@HH=my|tH gDw@ATUSH@fnFdH%(HD$81HjHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\ ~HHuːHt$H|$!mtD$$Ld$uXHELH@H;ΰulH=Md`{tLH=MfM{u)蔀HeHc}ZfDLLH=l{tLe븐HЉufATH0fnFdH%(HD$(1HeiH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11轅E1HD$(dH+%(H0LA\@|HHufHHRxH;Ҳ'jIMtoI$H5bLPtZUHuLxkIHoH`bLt1HHP@Lx8fE1~H"DIjitfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5D̓1HT$8dH+%(MH@]ÐL Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$111DH 2Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$螃1<yH}HHiDHt$ H|$wt$ HiHM}HfKzHHSf.+zHHrDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt Ls8 uaLH~ uLA\ATIUHbHt HH5]LHsbtHmtH]A\HH]A\gdUH=]Htu]ÐHH=_ttHH=ettH]!_UH@dH%(HD$81H@_Ht$HD$HFHD$$D$ t0H|$l1HT$8dH+%(uhH@]@HT$H|$H5^Zu|$HtHt+HH5h`HPt"yHuHEe1 yHunff.fUSHHdH%(HD$81H_Ht$HD$HFHD$$D$ HD$t6H|$~1HT$8dH+%(HH[]DHt$H|$dtHl$H=_HrtHH=]ru+xHuHc~u@HH=crtHM]m@ATUSH@fnFdH%(HD$81HaHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$V}1HT$8dH+%(H@[]A\KtHHuːHt$H|$actD$$Ld$uXHELH@H;ulH=,^qtLH=\qu)vHeHc#tZfDLLH=\bQqtL[븐HЉlfATH0fnFdH%(HD$(1H_H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11{E1HD$(dH+%(H0LA\@rHHufHHRxH;ZgwIMtoI$H5\LPtZuHuLaIHoH4WbLj1HHP@LGn8fE18uH"DIjjfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5D z1HT$8dH+%(MH@]ÐL ¹Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$119z1DH rHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$y1<+XHsHH_DHt$ H|$mt$ HqHsHfpHHSf.kpHHhDUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H55D=x1HT$8dH+%(MH@]ÐL Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11ix1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$x1<xHrHH"^DHt$ H|$)lt$ H]HqHfnHHSf.nHHgDUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5wDmv1HT$8dH+%(MH@]ÐL KHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11v1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$>v1<gH3pHHR\DHt$ H|$Yjt$ HRHoHflHHSf.lHH5eDUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5VDt1HT$8dH+%(MH@]ÐL jVHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11t1DH VHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$nt1<mHcnHHZDHt$ H|$ht$ HeVHnHfkHHSf.jHHecDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtD$ +D$$H|$*e1fDH5Dd1HT$8dH+%(H@]DL Ht$LL$L$ D$$D$(HH(HtD$$9D$ tH|$11d1D[HH7yf.Ht$ H|$XXt$ H-^He^H;HJ01@K[HHU SDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$Z1HT$8dH+%(H@[]A\QHHuːHt$H|$@tD$$Ld$u`HELH@H;H=K,OtLH=COu-`THaHcQVf.LLH=9NtLH=?NtLZ9fDHЉIfATH0fnFdH%(HD$(1H=H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11mYE1HD$(dH+%(H0LA\@cPHHufHHRxH;rTIMtoI$H52JLPtZSHuL(?IHoH4bLTH1HHP@LK8fE1RH"DIjHfATL%1HIH5LKu>LH~MLA\ATIUHmXHt HH5,ILH#:tHmtH]A\HH]A\q?SUH=HHlLu]ÐHH=T@QLtHH=>7>LtHH=6=+LtH]6f.@f.5UH@dH%(HD$81H6Ht$HD$HFHD$$D$ t0H|$V1HT$8dH+%(uhH@]@HT$H|$H5\6L|$HtHt+HH5&JHPtPHuH<1yPHuEff.fUSHHdH%(HD$81H7Ht$HD$HFHD$$D$ HD$t6H|$U1HT$8dH+%(HH[]DHt$H|$UH@dH%(HD$81H0Ht$HD$HFHD$$D$ t0H|$P1HT$8dH+%(uhH@]@HT$H|$H5<0F|$HtHt+HH5LFHPtrJHuH61YJHu?ff.fUH0fnFdH%(HD$(1HFH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11O1HT$(dH+%(u8H0]fDFHHuӐ*HIHuH5?ff.@UH0fnFdH%(HD$(1H H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11N1HT$(dH+%(u8H0]fDEHHuӐJHHHuH4?>ff.@UH@fnFdH%(HD$81HpDHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$N1HT$8dH+%(u_H@]f. EHHuϐH5CHT$H|$C|$HtH2GHuHwH<=ff.USHHdH%(HD$81HD.Ht$HD$HFHD$$D$ HD$t6H|$2M1HT$8dH+%(HH[]DHt$H|$O3tHl$H=BHAtHH=5AuFHuHc.D@HH=i,iAtHH=a2VAtH+!<ATUSH@fnFdH%(HD$81H/Ht$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$K1HT$8dH+%(H@[]A\BHHuːHt$H|$2tD$$Ld$u`HELH@H;wH=\A<@tLH=,4)@u-pEHaHcBVf.LLH=*?tLH=0?tLj*fDHЉ:fATH0fnFdH%(HD$(1H%.H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11}JE1HD$(dH+%(H0LA\@sAHHufHHRxH;bs7IMtoI$H5?LPtZDHuL80IHoH%bLd91HHP@L<8fE1CH"DIj)9fATL%H LH@?H5L<u0LH^>LA\ATIUH 0Ht HH5>LH3+tHmtH]A\HH]A\05UH=>H|=u]ÐHH=d1a=tHH=N(N=tHH=F.;=tH]'f.@AUATUH@dH%(HD$81HBHt$HD$HFHD$$D$ H$HD$t3H|$G1HT$8dH+%(ujH@]A\A]Hl$HH.tHt$H.tLl$L$$(5HLLH!AHuH-7IJf.UH@dH%(HD$81H&Ht$HD$HFHD$$D$ t0H|$ G1HT$8dH+%(uhH@]@HT$H|$H5&<|$HtHt+HH5AHPt@HuH,1@Hu-6ff.fUSHHdH%(HD$81H4'Ht$HD$HFHD$$D$ HD$t6H|$"F1HT$8dH+%(HH[]DHt$H|$?,tHl$H=@H:tHH=MF:u?HuHc=@HH=>FY:tH$$5@ATUSH@fnFdH%(HD$81H(Ht$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$D1HT$8dH+%(H@[]A\;HHuːHt$H|$+tD$$Ld$uXHELH@H;qulH=E?@9tLH=D-9u)t>HeHc;ZfDLLH=D8tL#븐HЉ3fATUH8fnFdH%(HD$(1HD'H4$HD$HGfnȉD$fbfD$uKH(HtD$9D$tHH11CE1HD$(dH+%(H8L]A\f.:HHuŐHHRxH;*p0HI"LW2I$H5=LP=HdL8)IHPHCLd21HHP@L5fH;ou 0HI2"^DIHSE1d 2HEHEDATL%1H<H5Lk5u-+LH^7LA\ATIUH})Ht HH5<LH$tHmtH]A\HH]A\Q)AWAVAUATUSHHfnFdH%(HD$81H%<Ht$HD$HGfnȉD$(fbfD$ Ho(Ht!D$ +D$$t9H|$%A1HT$8dH+%(HH[]A\A]A^A_H\$Lt$L=u&HLL7|$ItHLL6|$ItHLL6|$HtD$$uOLELLHA:HXHNjHJD7HH-fLLH5/f.ATUH-HIL8/HL]A\HLn,HV=fDUH=:H4u]ÐHH=:@q4tHH=C@^4tH]UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(ujH@]A\A]Hl$HHh$tHt$HW$tLl$L$$(`+HLLH;7HuH $f-IAf.USHHdH%(HD$81HdHt$HD$HFHD$$D$ HD$t6H|$R=1HT$8dH+%(utHH[]fHt$H|$o#tHl$H==H1tHH==1u6HuHcN4@H0g,ATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$6<1HT$8dH+%(H@[]A\+3HHuːHt$H|$A"tD$$Ld$uXHELH@H;~iu\H=<0tLH=R<m0u)5HeHc3ZfDLL@HЉ+fUH@fnFdH%(HD$81H;Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$:1HT$8dH+%(u^H@]f.1HHuϐH5/ HT$H|$0|$HtH(4HuHc1 *ff.fUH@fnFdH%(HD$81HNHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$91HT$8dH+%(u_H@]f.0HHuϐH5/HT$H|$/|$HtHH3HuH )ff.AVAUATUHXfnFdH%(HD$H1H<Ht$ HD$(HGfnȉD$8fbfD$0Ho(Ht!D$0+D$4tZu\H=3tLH=b+}u)$HeHc"ZfDLL @HЉfATUH8fnFdH%(HD$(1H H4$HD$HGfnȉD$fbfD$uKH(HtD$9D$tHH11)E1HD$(dH+%(H8L]A\f. HHuŐHHRxH;ZX HI/ LI$H5D2LPy#HdLIHPHCL1HHP@L'fH;WumHI^DIHSE1dmHK,HO,DATL%1Hb1H5sLmu)LHLA\ATIUHHt HH51LHc tHmtH]A\HH]A\AVAUATUHHfnFdH%(HD$81H(Ht$HD$HGfnȉD$(fbfD$ Ho(Ht!D$ +D$$tulH=|- tLH=  u)T HeHc ZfDLLH=tLe븐HЉfATH0fnFdH%(HD$(1H%H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11}E1HD$(dH+%(H0LA\@s HHufHHRxH;@IMtoI$H5+,LPtZ HuL8IHoHbLd1HHP@L8fE1 H"DIj)fUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5nPD1HT$8dH+%(MH@]ÐL BPHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$111DH OHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$^1<HS HHrDHt$ H|$yt$ H5H Hf HHSf.HHUDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt&HPtHuH%1Humff.fUSHHdH%(HD$81HtHt$HD$HFHD$$D$ HD$t6H|$b1HT$8dH+%(HH[]DHt$H|$tHl$H=\%HtHH=u HuHc^@HH=tH-d@UH0fnFdH%(HD$(1HrH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11N1HT$(dH+%(u8H0]fDKHHuӐ H#HuHFff.@UH0fnFdH%(HD$(1HrH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11~1HT$(dH+%(u8H0]fD{HHuӐHSHuHvff.@UH0fnFdH%(HD$(1HqH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHHuHff.@UH0fnFdH%(HD$(1HpH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHHuH/ff.@UH0fnFdH%(HD$(1HoH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fD HHuӐ+HHuH_ff.@UH0fnFdH%(HD$(1HoH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11>1HT$(dH+%(u8H0]fD;HHuӐHHuH6ff.@UH0fnFdH%(HD$(1H H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11n1HT$(dH+%(u8H0]fDkHHuӐHCHuHfff.@UH0fnFdH%(HD$(1HQH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHsHuHff.@UH0fnFdH%(HD$(1HdH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐHHuHff.@ATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\HHuːHt$H|$tD$$Ld$uXHELH@H;*ulH=0tLH=u)dHeHcZfDLLH=tLu븐HЉfATH0fnFdH%(HD$(1H5H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@HHufHHRxH;#wIMtoI$H5aLPtZ%HuLHIHoHbLt1HHP@L8fE1H"DIj9fUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5~9D1HT$8dH+%(MH@]ÐL R9Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$111DH 9Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$n1<HcHHDHt$ H|$t$ HHHfHHSf.HHeDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐkHHuHƵff.@UH0fnFdH%(HD$(1H=H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u8H0]fDHHuӐ HHuHOff.@UH0fnFdH%(HD$(1HJ5H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11.1HT$(dH+%(u8H0]fD+HHuӐ{HHuH&ff.@UH@fnFdH%(HD$81H Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$R1HT$8dH+%(u_H@]f.KHHuϐH5HT$H|$*|$HtHHuHH|ff.UH@fnFdH%(HD$81H Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$R1HT$8dH+%(u_H@]f.KHHuϐH5;HT$H|$*|$HtHHuHH|ff.UH@fnFdH%(HD$81H2Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$R1HT$8dH+%(u_H@]f.KHHuϐH5:HT$H|$*|$HtHXHuHH|ff.UH@fnFdH%(HD$81H1Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$R1HT$8dH+%(u_H@]f.KHHuϐH5HT$H|$*|$HtHHuHH|ff.ATUHHfnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$P1HT$8dH+%(uxHH]A\fDKHHuѐLd$Ht$ LntHT$ H5L|$ Htt$ H谻HuHHxaATUHHfnFdH%(HD$81Hq/Ht$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$@1HT$8dH+%(uxHH]A\fD;HHuѐLd$Ht$ L^tHT$ H5L|$ Htt$ H蠼HuHHxQATUHHfnFdH%(HD$81Ha.Ht$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$01HT$8dH+%(uxHH]A\fD+HHuѐLd$Ht$ LNtHT$ H55L|$ Htt$ HHuHHxAATUHHfnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uJHo(Ht!D$ +D$$tDH|$ 1HT$8dH+%(uxHH]A\fDHHuѐLd$Ht$ L>tHT$ H54L|$ Htt$ H軿HuHwHx1ATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\HHuːHt$H|$tD$$Ld$uXHELH@H;ulH=^PtLH===u)脾HeHcӻZfDLLH= tL蕣븐HЉ³fATH0fnFdH%(HD$(1HUH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@裺HHufHHRxH;觠IMtoI$H5 LPtZEHuLhIHoHbL蔲1HHP@L8fE1H"DIjYfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5D1HT$8dH+%(MH@]ÐL rHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$111DH "Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$1<蛱H胻HH袧DHt$ H|$詵t$ HūH=Hf;HHSf.HH腰DATL%tH ,HH5vLuuLH^uLA\ATIUHHt HH57LH蓢tHmtH]A\HH]A\針UH=Hܴu]ÐHH=tHH=讴tH]AwUH@dH%(HD$81HPHt$HD$HFHD$$D$ t0H|$|1HT$8dH+%(uhH@]@HT$H|$H5j|$HtHt+HH5HPt2HuHU1Hu蝮ff.fUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$蒾1HT$8dH+%(HH[]DHt$H|$诤tHl$H=HtHH=u;HuHc莵@HH=ԣɲtH]蔭@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$r1HT$8dH+%(uVH@]f.kHHuϐHt$ H|$葱tt$ HaH)HuHL襬DATUSH@fnFdH%(HD$81H/Ht$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$v1HT$8dH+%(H@[]A\kHHuːHt$H|$聢tD$$Ld$uXHELH@H;6ulH=tLH=議u)HeHcCZfDLLH=|qtL븐HЉ2fATH0fnFdH%(HD$(1HŞH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@HHufHHRxH;gIMtoI$H5ZLPtZ赴HuLؠIHoHTbL1HHP@Lg8fE1XH"DIjɩfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5 D-1HT$8dH+%(MH@]ÐL h Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11Y1DH  Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$1<苮HHHDHt$ H|$t$ H%H譲Hf諯HHSf.苯HHDUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5>D]1HT$8dH+%(MH@]ÐL Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11艷1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$.1< H#HHBDHt$ H|$It$ H5HݰHfۭHHSf.軭HH%DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtHT$ H5#L|$ Ht$ Hș賮Ht~f諫HH_f.苫HH?DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtD]1HT$8dH+%(MH@]ÐL Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11艩1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$.1<ˑH#HHBDHt$ H|$It$ H蕠HݢHf۟HHSf.軟HH%DUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5D荧1HT$8dH+%(MH@]ÐL Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11蹧1DH xHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$^1<蛦HSHHrDHt$ H|$yt$ H襠H Hf HHSf.HHUDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtHT$ H5L|$ Ht$ H蘇賜Ht~f諙HH_f.苙HH?DATL%c]H ,HH5^Lf]uhLH.^YLA\ATIUHmHt HH5LHtHmtH]A\HH]A\QUH@fnFdH%(HD$81HpHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$21HT$8dH+%(uzH@]f.+HHuϐH5HT$H|$ |$HtD$$u(HEHH֚HuHH@H(AWUH=bHHt$HD$HGfnȉD$(fbfD$ uPHo(Ht!D$ +D$$tRH|$n{1HT$8dH+%(H@]A\A]fDcrHHufLd$HLpttLl$LL\ttD$$H4$uLHEHLHtHt?tHcHtDHH5p]THeDHLjHHT$La@HYH jUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11y1HT$(dH+%(uNH0]fDpHHuӐu$HHsHuH~q@sbH9ifUH@fnFdH%(HD$81HԾHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$y1HT$8dH+%(urH@]f. pHHuϐHt$H|$q]tD$$D$u'HEHrHuHyHHz)hfH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11x1HT$(dH+%(uLH8 oHHuҐu$HqHuHH@iLgff.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11/w1HT$(dH+%(uLH8+nHHuҐu$HpHuHH@Tlff.f9L9wXt HwXf.DfDfDGXGTN9wPt HwPf.DfDfDGPpUH==Hju]ÐHH=qjtHH=i[^jtH]TWUH@dH%(HD$81HUHt$HD$HFHD$$D$ t0H|$,u1HT$8dH+%(uhH@]@HT$H|$H5Tk|$HtHt+HH5HPtnHuH[1nHuMdff.fUSHHdH%(HD$81HTUHt$HD$HFHD$$D$ HD$t6H|$Bt1HT$8dH+%(HH[]DHt$H|$_ZtHl$H=HhtHH=humHuHc>k@HH=YyhtH SDc@ATUSH@fnFdH%(HD$81HVHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$s1HT$8dH+%(H@[]A\ jHHuːHt$H|$!YtD$$Ld$uXHELH@H;֡ulH=P`gtLH=Mgu)lHeHciZfDLLH=XgtLQ븐HЉafUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11q1HT$(dH+%(u[H0]fDhHHuӐtkHuHEiHHH;jtH`ff.UH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11p1HT$(dH+%(u[H0]fDgHHuӐtjHuHUhHHH;tH_ff.UH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11o1HT$(dH+%(uVH0]fDfHHuӐtHoPiHuHfg@HHH;tH_ATH0fnFdH%(HD$(1HRH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11nE1HD$(dH+%(H0LA\@eHHufHHRxH;rQIMtoI$H5?LPtZhHuLTIHoH4JbL]1HHP@LGa8fE18hH"DIj]fUH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$m1HT$8dH+%(H@]fD{dHHuϐHt$H|$ftD$$Ht$tPH9HOHHNH9uPtHEHuPH gHqHĖHcHEHH;vu4H9HOHHNH9uPtHuPHH,\ff.ATL%S4H HH55L_4uXLH5aLA\ATIUHhHt HH5LH3NtHmtH]A\HH]A\SAUATUH@fnFdH%(HD$81H.Ht$HD$HGfnȉD$(fbfD$ uPHo(Ht!D$ +D$$tRH|$^k1HT$8dH+%(H@]A\A]fDSbHHufLd$HL`dtLl$LLLdtD$$H4$uLHEHLHdHt?dHcHtDHH5`sMDHTDHL_HHT$LQ@HIH ZUH0fnFdH%(HD$(1HwH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11i1HT$(dH+%(uNH0]fD`HHuӐu$HHcHuHna@eH)YfUH@fnFdH%(HD$81HĮHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$i1HT$8dH+%(urH@]f._HHuϐHt$H|$aMtD$$D$u'HEHbHuHiHHPMXfH8fnFdH%(HD$(1HsH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11g1HT$(dH+%(uLH8^HHuҐu$HaHuHH@bH(HtD$9D$t;H11g1HT$(dH+%(uLH8^HHuҐu$H`HuHH@SZ\Vf.fH9HOHHNH9wPtHHwPf.DfDfDHGPHUH=HZu]ÐHH=ZtHH=KZtH]AE7XUH@dH%(HD$81HPEHt$HD$HFHD$$D$ t0H|$|e1HT$8dH+%(uhH@]@HT$H|$H5Dj[|$HtHt+HH5 HPt2_HuHUK1_HuTff.fHGI~H)ǃuHH=4L_HH5d1HÐHGI~H)ǃuHH=4L^HH5Sc1HÐHGI~H)ǃuHH=5Lo^HH5xc1HÐUSHHdH%(HD$81HDHt$HD$HFHD$$D$ HD$t6H|$c1HT$8dH+%(utHH[]fHt$H|$ItHl$H=;HXtHH=IXuK]HuHcZ@HBRSH0fnFdH%(HD$(1HhH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11b1HT$(dH+%(uZH0[fDYHHuӐtr\HuHcYHHH;tЉQff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11a1HT$(dH+%(uZH0[fDXHHuӐt[HuHcXHHH;*tЉPff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11`1HT$(dH+%(uZH0[fDWHHuӐtZHuHcWHHH;tЉOff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11_1HT$(dH+%(uZH0[fDVHHuӐ tYHuHcVH HH;tЉNff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11^1HT$(dH+%(uUH0[fDUHHuӐt_DXHuHcVDHHH;φtЉNfSH0fnFdH%(HD$(1H/H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11]1HT$(dH+%(uUH0[fDTHHuӐt_@WHuHc'UDHHH;tЉ2MfSH0fnFdH%(HD$(1HxH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11]1HT$(dH+%(uUH0[fDTHHuӐt_HVHuHcGTDHHH;7tЉRLfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11>\1HT$(dH+%(uUH0[fD;SHHuӐt_LVHu6^@HHH;otЉrKfUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11^[1HT$(dH+%(uVH0]fD[RHHuӐtHo03UHuHVA@HHH;tHJUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11~Z1HT$(dH+%(uYH0]fD{QHHuӐJHSTHuHtHH5b3HrDHHIff.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11Y1HT$(dH+%(u{H8PHHuҐHt9HH;ÂuALt GLDSHuHHfHH;t@1Hff.fH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11X1HT$(dH+%(u~H8{OHHuҐHt9HH;uALu GL4RHuHHfHH;t@Gf.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(D$Ht!D$ +D$$tAH|$]W1HT$8dH+%(H@]Ð[NHHuԐHt$H|$QGtD$$t$t0@8uLtHE@uLHQHuHHfHEHH;Fu@8uLt@uLHHDF@UH@fnFdH%(HD$81HmHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$"V1HT$8dH+%(H@]fDMHHuϐHt$ H|$AJtD$$t$ tQ 9O9L9u@tHEu@HOHxHkHjf.HEHH;&u, 9O9L9u@tu@HDHD@UH@fnFdH%(HD$81H!Ht$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$T1HT$8dH+%(H@]fDKHHuϐHt$ H|$HtD$$t$ tQ9ON9uDtHEuDHCNHxH}Hjf.HEHH;>|u,9ON9uDtuDHDHdC@AUATUH@fnFdH%(HD$81H Ht$HD$HGfnȉD$(fbfD$ uPHo(Ht!D$ +D$$tRH|$>S1HT$8dH+%(H@]A\A]fD3JHHufLd$Ht$LNGtLl$LL*Ltt$HL9HLHt2LHnHt7HH5K[8,HDATH0fnFdH%(HD$(1H2H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11NE1HD$(dH+%(H0LA\@EHHufHHRxH;}@IMtoI$H5PLPtZuHHuL4IHoH*bL=1HHP@L'A8fE1HH"DIj=fAWAVAUATUSHhfnFdH%(HD$X1HHt$ HD$(HGfnȉD$8fbfD$0uSHo(Ht!D$0+D$4tMH|$ YM1HT$XdH+%(;Hh[]A\A]A^A_@KDHHuȐLl$@Ld$ LL5tLt$LLBFtD$@HLLT$H\$PD$fH~fI~^MD$f.D$@Hz]u[fHnf.d$HzNuLfInf.l$Pz?u=FHtSFHHtXHH5U&H6@[FHuL1L48fHT$L3@HuH;AWAVAUATUSHfnFdH%(H$1HHt$0HD$8HGfnȉD$HfbfD$@u]Lw(Mt!D$@+D$DtWH|$0sK1H$dH+%(HĘ[]A\A]A^A_[BHHu뾐Ld$PHl$0LH3tLl$pHL3tHT$/H5HA|$/HdD$PT$XLL\$`d$xLl$pD$$$fI~\$fH~t$q>D$f.D$P$f.T$Xd$f.d$`zrupfHnf.|$pzBu@fInf.\$xz3u1l$f.$z uDHHsHCHuعLH5CHuL1H5oL9ff.AWAVAUATUSHfnFdH%(H$1HbHt$0HD$8HGfnȉD$HfbfD$@u]Lw(Mt!D$@+D$DtWH|$0I1H$dH+%(HĘ[]A\A]A^A_?HHu뾐Ld$PHl$0LH1tLl$pHL}1tHT$/H5bH>|$/HdD$PT$XLL\$`d$xLl$pD$$$fI~\$fH~t$)D$f.D$P$f.T$Xd$f.d$`zrupfHnf.|$pzBu@fInf.\$xz3u1l$f.$z uAHHtqHAHuعLHt3}AHuL1HV3o6ff.AWAVAUATUSHfnFdH%(H$1HHt$@HD$HHGfnȉD$XfbfD$Pu]Lw(Mt!D$P+D$TtWH|$@F1H$dH+%( HĨ[]A\A]A^A_=HHu뾐Ld$`Hl$@LH6/tL$HL/tL|$8HLv?kD$`LLLT$h\$pL$D$($$T$\$ fH~d$t$D$(f.D$`IT$f.T$hd$ f.d$pfHnf.$zau_\$f.$zNuLl$f.$z;u9E?Htx;?HoMt}LH5MHV/P ?HuLH0>H`L1H0IHT$8H,qHqnH+4ff.AWAVAUATUSHfnFdH%(H$1HBHt$@HD$HHGfnȉD$XfbfD$Pu]Lw(Mt!D$P+D$TtWH|$@C1H$dH+%( HĨ[]A\A]A^A_:HHu뾐Ld$`Hl$@LHv,tL$HLZ,tL|$8HL<kD$`LLLT$h\$pL$D$($$T$\$ fH~d$t$M,D$(f.D$`IT$f.T$hd$ f.d$pfHnf.$zau_\$f.$zNuLl$f.$z;u9HtHH5ZLH!u_ 6HHtHH53L{!Hmtd6HHtHH5LP!Hmt!H]A\ÐHmuH&HH]A\&fHx&fDUH@fnFdH%(HD$81HGHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$R>1HT$8dH+%(uzH@]f.K5HHuϐH5HT$H|$*4|$HtD$$u(HEH7HuHgH@H5a-HG0@8wLtH@wLff.DGL 9O9L9w@tHw@f.DfD fDG@9ON9wDtHwDf.DfDfDGDGH.UH=@H1u]ÐHH= "1tH]@HHH;eu!LtGLf1@HHH;Seu!LuGLf'SH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$L;1HT$8dH+%(uEH@[@H|$HT$H5 :1|$Ht 5HuHcg2*SH@dH%(HD$81HTHt$HD$HFHD$$D$ t0H|$:1HT$8dH+%(uEH@[@H|$HT$H50|$Ht[-d4HuHc1)SH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$91HT$8dH+%(uEH@[@H|$HT$H5E/|$Ht3HuHc10)UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$<91HT$8dH+%(uhH@]@HT$H|$H5*/|$HtHt+HH5HPt2HuH12Hu](ff.fAUATUHpdH%(HD$h1HHt$HD$HFHD$$D$ tMH=otLH=oyu-HaHcVf.LLH=9tLH=1&tLfDHЉfATL%sH |HnH5LVuLH>ILA\ATIUH]HtHH5nLHu_%HHtHH5LHmtdHHtHH5LHmt!H]A\ÐHmuHHH]A\fHfDSH0fnFdH%(HD$(1H$H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uMH0[fDHHuӐu$H|HuHcDC f.AT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtDAEH5]DB1HT$8dH+%(_HH]A\@L,Ht$LT$L$ T$$T$(HHo(HtD$ +D$$H|$\1L Ht$LL$L$ T$$T$(HH(HKD$$9D$ H|$111*f.H lHt$HL$T$(fD$ HuPHo(HD$ +D$$tfH|$1HHfHHufDHH-fLd$Ht$ LdHT$ H5`LB|$ HBD$$t$ HEHudHHHc;fDHt$ H|$T$$t$ u%HEH@H0H| UH=iHu]ÐHH=itHH=tHH=tH]>f.@WUH@dH%(HD$81H@Ht$HD$HFHD$$D$ t0H|$l1HT$8dH+%(uhH@]@HT$H|$H5Z|$HtHt+HH5 HPt"HuHE1 Hu ff.fUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(HH[]DHt$H|$tHl$H= H tHH= u+HuHc~@HH= tHM@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$b1HT$8dH+%(uVH@]f.[HHuϐHt$ H|$ tt$ HHHuH<DATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$f1HT$8dH+%(H@[]A\[HHuːHt$H|$qtD$$Ld$uXHELH@H;^EulH=  tLH= u)HeHc3ZfDLLH=la tL븐HЉ"fATH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11 E1HD$(dH+%(H0LA\@ HHufHHRxH;=GIMtoI$H5R LPtZHuLIHoHDbL1HHP@LW8fE1HH"DIjfUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5SD1HT$8dH+%(MH@]ÐL SHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11I1DH SHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$1<H HHDHt$ H|$ t$ H5H Hf HHSf.{ HHDUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5yDM1HT$8dH+%(MH@]ÐL yHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11y1DH 8yHt$HL$D$(fD$ HHo(HbD$ +D$$tJH|$1<H HH2DHt$ H|$9t$ HH HfHHSf.HHDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt1.H5HT$ H|$:|$ HH HH9HfDLd$Ht$ L.HT$ H5~L|$ Ht$ H Ht~fHH_f.{HH?DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt1.HT$ H5rH|$:1|$ HH HH,H@Ld$Ht$ L.HT$ H5qL|$ Ht$ fDHHwfHH_DATL%H LH;H5>Lv8uxLH~iLA\ATIUH Ht HH5LHtHmtH]A\HH]A\aUH=H\u]ÐHH=AAtHH=9.tH]7UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5||$HtHt+HH5HPtHuH1Huff.fUSHHdH%(HD$81H$Ht$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(HH[]DHt$H|$/tHl$H=HtHH=tuHuHc@HH=TItH@ATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$1HT$8dH+%(H@[]A\HHuːHt$H|$tD$$Ld$uXHELH@H;'ulH=N0tLH=Du)dHeHcZfDLLH=tLu븐HЉfATH0fnFdH%(HD$(1H5H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@HHufHHRxH;)IMtoI$H5LPtZ%HuLHIHoHbLt1HHP@L8fE1H"DIj9fATUSH0fnFdH%(HD$(1HXH4$HD$HGfnȉD$fbfD$uBHG(HtT$9T$tGH111HT$(dH+%(H0[]A\@HHufHpXHX@HHσHt"H+Ht:HuHfDHHH+HHDHHt,HPxIHtHH5FLPIEH+HHtHH5HPu1fDATL%H HH5~L6xuLH)LA\ATIUHHt HH5LHtHmtH]A\HH]A\!UH@fnFdH%(HD$81HQHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(urH@]f.HHuϐHt$H|$atD$$D$u'HEHHuHi#HHfGUH=-H u]ÐHH=tHH=tH]qwUH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5,|$HtHt+HH5HPtbHuH1IHuff.fUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(HH[]DHt$H|$tHl$H=H7tHH=K$ukHuHc@HH=FtHH=FtHH='tHH=tHTff.ATUSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$V1HT$8dH+%(H@[]A\KHHuːHt$H|$atD$$Ld$u`HELH@H;f"H=tLH=Ju-HaHcVf.LLH=VDItLH=dD6tLH=w#tLH=tLxDHЉgATH0fnFdH%(HD$(1HUH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11E1HD$(dH+%(H0LA\@HHufHHRxH;IMtoI$H5tLPtZEHuLhIHoHbL1HHP@L8fE1H"DIjYfATL%H HH5Lu(LHLA\ATIUH Ht HH5nLHctHmtH]A\HH]A\wUH=$Hu]ÐHH= GtHH=A~tHH=AktHH=XtHH=PEtH]UH@dH%(HD$81HHt$HD$HFHD$$D$ t0H|$1HT$8dH+%(uhH@]@HT$H|$H5 |$HtHt+HH5HPtHuH1Hu=ff.fHHdH%(HD$81HVHt$HD$HFHD$$D$ D$t,H|$81HT$8dH+%(u:HHÐHt$H|$At|$HuHHSH0dH%(HD$(1HH4$HD$HFHD$D$t*H111HT$(dH+%(u,H0[fDc|I1MuUSHHdH%(HD$81HHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(HH[]DHt$H|$tHl$H=zHgtHH=WTuHuHc@HH=))tHH=!tHSH0fnFdH%(HD$(1H4H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uZH0[fDHHuӐ@tHuHcH@H8H;"tЉff.fSH0fnFdH%(HD$(1H_H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uZH0[fDHHuӐtHuHcHH0H; tЉ ff.fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(Ht\$9\$t:H111HT$(dH+%(uUH0[fDHHuӐt1HuHcfDHHH;tЉ"fSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uZH0[fD HHuӐtHuHc5HHH;tЉ=ff.fUH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(u^H0]fDHHuӐt$HHuH~@HHH;_tHIfSH0fnFdH%(HD$(1H2H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11.1HT$(dH+%(uUH0[fD+HHuӐtHuHcTfHH H;otЉbfUH0fnFdH%(HD$(1H(H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11N1HT$(dH+%(uVH0]fDKHHuӐtH HuH뵐HHH;tHSH0fnFdH%(HD$(1H`H4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11n1HT$(dH+%(uUH0[fDkHHuӐtAHuHcfHH@H;OtЉfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H111HT$(dH+%(uUH0[fDHHuӐt`Hu뵐HHH;tЉfH8fnFdH%(HD$(1HrH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(unH8HHuҐHHH; ?u5tLJ_HuHHDf.H8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(ukH8HHuҐHHH; ?u5tLJ^HuHH@1ff.fH8fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H111HT$(dH+%(unH8HHuҐHHH; ?u5tLJ_HuHHDf.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$H|$tD$$Ht$t@H9tHEHH>HuH HyfHEHH; uH;tHH뮐Ht@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(D$Ht!D$ +D$$tAH|$M1HT$8dH+%(H@]ÐKHHuԐHt$H|$AtD$$t$t8@8tHE@HHuH H@HEHH; u$@8t@HfH$@UH@fnFdH%(HD$81HkHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$!tD$$t$ tQ9O1H9tHEHHuHH HgHEHH;u,9O1҅H9tHfH@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$1HT$8dH+%(H@]fDHHuϐHt$ H|$tD$$t$ tQ@9ON9tHEHHrHHd@HEH(H; u4@9ON9tHHD]1HT$8dH+%(MH@]ÐL Ht$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11艠1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$.1< H#HHBDHt$ H|$It$ H腞HݙHfۖHHSf.軖HH%DUH@HNdH%(HD$81HGfnAH%HfnfbA)Au\H Ht$HL$D$(fD$ HHo(Ht>D$ +D$$H|$ڞ1fDH5D11HT$8dH+%(H@]DL hHt$LL$L$ D$$D$(HH(HtD$$9D$ tH|$11Y1DkHH7yf.Ht$ H|$聒Xt$ HHH;H401@HHU eDAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtHT$ H5L|$ Ht$ Hz賆Ht~f諃HH_f.苃HH?{DATL%H HUH5nLfhuhmLHYLA\ATIUHjHt HH5LHntHmtH]A\HH]A\QsUH@fnFdH%(HD$81HpHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$21HT$8dH+%(uzH@]f.+HHuϐH5HT$H|$ |$HtD$$u(HEHHքHuHH@HhAzWfUH=H<u]ÐHH=!j!tHH=ptH]iUH@dH%(HD$81HiHt$HD$HFHD$$D$ t0H|$܉1HT$8dH+%(uhH@]@HT$H|$H5\i|$HtHt+HH5skHPt蒃HuHo1yHuxff.fSH0fnFdH%(HD$(1HjH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11ވ1HT$(dH+%(uuH0[fDHHuӐt$W0fH~譂HufHnn@HHH;u_0fH~ffH~wfUSHHdH%(HD$81HiHt$HD$HFHD$$D$ HD$t6H|$1HT$8dH+%(utHH[]fHt$H|$ntHl$H=iHg|tHH=_mT|u蛁HuHc~@HfwATUSH@fnFdH%(HD$81HjHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$ֆ1HT$8dH+%(H@[]A\}HHuːHt$H|$ltD$$Ld$uXHELH@H;fu\H=Gh {tLH=l {u)THeHc}ZfDLLxe@HЉufATH0fnFdH%(HD$(1H5iH4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11荅E1HD$(dH+%(H0LA\@|HHufHHRxH;:IMtoI$H5gLPtZ%HuLHkIHoH`bLtt1HHP@Lw8fE1~H"DIj9tfATL%zH tLl8suZLH~snLA\ATIUHyHt HH5sLH[tHmtH]A\HH]A\`wUH=)Hmu]ÐHH=XmtHH=^mtH]AXGVUH@dH%(HD$81HPXHt$HD$HFHD$$D$ t0H|$|x1HT$8dH+%(uhH@]@HT$H|$H5Wjn|$HtHt+HH5HPt2rHuHU^1rHugff.fUSHHdH%(HD$81HXHt$HD$HFHD$$D$ HD$t6H|$w1HT$8dH+%(utHH[]fHt$H|$]tHl$H=8HltHH=\ku;qHuHcn@HpVfH8fnFdH%(HD$(1HݑH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11v1HT$(dH+%(u9H8mHHuҐafpHuH"Heff.@SH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11u1HT$(dH+%(uUH0[fDlHHuӐt_XoHuHclDHHH;tЉdfSH0fnFdH%(HD$(1HHH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11t1HT$(dH+%(uUH0[fDkHHuӐt_0nHuHclDHHH;tЉdfSH0fnFdH%(HD$(1HH4$HD$HGfnȉD$fbfD$u=H(HtD$9D$t:H11s1HT$(dH+%(uUH0[fDjHHuӐt_TmHuHc'kDHHH;כtЉ2cfSH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLH_(Ht!D$ +D$$tFH|$s1HT$8dH+%(umH@[f. jHHuϐHt$ H|$1gtHC`HKhT$ H9tHChCTC\SPlHuHqH.bff.UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$r1HT$8dH+%(H@]fDhHHuϐHt$ H|$!ftD$$t$ t19uXtHEuXHkHuHcHDHEHH;~u;uXtˉuXHfH`@UH@fnFdH%(HD$81HHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$p1HT$8dH+%(H@]fDgHHuϐHt$ H|$dtD$$t$ t19u0tHEu0HgjHuH#HDHEHH;ޙu;u0tˉu0HfH_@H8fnFdH%(HD$(1H]H4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11o1HT$(dH+%(H8@fHHuҐHtAHH;[uIXt GXAiHuHHHH;Zt@^fH8fnFdH%(HD$(1H^H4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11n1HT$(dH+%(H8@{eHHuҐHtAHH;KuIGXt GX0hHuHHfDHH;t@1]DATUSH@fnFdH%(HD$81HQHt$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$Vm1HT$8dH+%(H@[]A\KdHHuːHt$H|$aStD$$Ld$uXHELH@H;.u\H=·atLH=Rau)fHeHc#dZfDLLK@HЉ"\fAUATUHpfnFdH%(HD$h1HHt$HD$HGfnȉD$(fbfD$ uPHo(Ht!D$ +D$$tRH|$k1HT$hdH+%(Hp]A\A]fDbHHufLd$Ht$ L`tLl$0LLWtHD$@t$ LHfoT$0HD$`)T$PID$P9D$0uSD$49D$TuID$89D$Xu?D$\9D$u;tƉHHLff.UH@fnFdH%(HD$81HMxHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$\1HT$8dH+%(H@]fDSHHuϐHt$ H|$PtD$$t$ t99tHEHQVHuH H|@HEHpH;6u;tƉHHKff.ATH0fnFdH%(HD$(1H?H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11m[E1HD$(dH+%(H0LA\@cRHHufHHRxH;چ6IMtoI$H5~LPtZUHuL(AIHoH6bLTJ1HHP@LM8fE1TH"DIjJfH8fnFdH%(HD$(1HuH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11Y1HT$(dH+%(H8@PHHuҐHtIHH;[uQtLJSHuHgHfHH;ƒt@Hf.H8fnFdH%(HD$(1HtH4$HD$HGfnȉD$fbfD$u>H(HtD$9D$t;H11X1HT$(dH+%(H8@OHHuҐHtIHH;;uQtLJRHuHFHHH;t@1Gff.fUH@fnFdH%(HD$81HcsHt$HD$HGfnȉD$(fbfD$ uLHo(Ht!D$ +D$$tFH|$W1HT$8dH+%(H@]fDNHHuϐHt$ H|$KtD$$t$ t99tHEHQQHuH H|@HEHH;u;tƉHHFff.ATL%UH HtzH5^WLIXVuELHVKLA\ATIUH]PHt HH5zLH8tHmtH]A\HH]A\=D9tHDf.DD9tHDf.DD9tHDf.D1UH=yHJu]ÐHH=]oJtHH=4ItHH=:ItH]n4f.@HHH;u!tLJHHH;Ku)tLJ1f.fW5UH@dH%(HD$81H3Ht$HD$HFHD$$D$ t0H|$ T1HT$8dH+%(uhH@]@HT$H|$H53I|$HtHt+HH5_|HPtMHuH91MHu-Cff.fUSHHdH%(HD$81H44Ht$HD$HFHD$$D$ HD$t6H|$"S1HT$8dH+%(HH[]DHt$H|$?9tHl$H=}{HGtHH=2GuLHuHcJ@HH=d8YGtH1$B@ATUSH@fnFdH%(HD$81H5Ht$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$Q1HT$8dH+%(H@[]A\HHHuːHt$H|$8tD$$Ld$uXHELH@H;ulH=#z@FtLH=-1-Fu)tKHeHcHZfDLLH=6EtL0븐HЉ@fATH0fnFdH%(HD$(1HE4H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11PE1HD$(dH+%(H0LA\@GHHufHHRxH;~71IMtoI$H5xLPtZ5JHuLX6IHoH+bL?1HHP@LB8fE1IH"DIjI?fUH@HNdH%(HD$81HGfnAH%HfnfbA)t6A|H5DN1HT$8dH+%(MH@]ÐL bHt$LL$L$ D$$D$(H H(HtD$$9D$ twH|$11N1DH Ht$HL$D$(fD$ HHo(HbD$ +D$$tJH|$~N1<kEHsHHH4DHt$ H|$Bt$ H%8H-HHf+EHHSf. EHHu=DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAtXNu,LHN@LA\ATIUH9Ht HH5sLHS-tHmtH]A\HH]A\2+UH=sH?u]ÐHH=*?tHH=y0n?tH]*g4UH@dH%(HD$81H*Ht$HD$HFHD$$D$ t0H|$HHSf. >HHu6DATUSH@fnFdH%(HD$81H)Ht$HD$HGfnȉD$(fbfD$ uYHD$Ho(Ht!\$ +\$$tJH|$FF1HT$8dH+%(H@[]A\;=HHuːHt$H|$Q,tD$$Ld$u`HELH@H;ntH=9r:tLH=\ny:u-?HaHc=Vf.LLH=9%9:tLH=1+&:tL$fDHЉ4fATH0fnFdH%(HD$(1Hu(H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH11DE1HD$(dH+%(H0LA\@;HHufHHRxH;qG.IMtoI$H5pLPtZe>HuL*IHoH bL31HHP@L78fE1>H"DIjy3fATL%HH HpH5JL6Iu2LHNI8LA\ATIUHM7Ht HH5oLH%tHmtH]A\HH]A\*,UH=|oH7u]ÐHH=k7tHH="7tHH=(7tH]"f.@W!UH@dH%(HD$81H "Ht$HD$HFHD$$D$ t0H|$LB1HT$8dH+%(uhH@]@HT$H|$H5!:8|$HtHt+HH57qHPt1HT$8dH+%(H@[]A\K5HHuːHt$H|$a$tD$$Ld$u`HELH@H;gH=m2tLH=lf2u-7HaHc5Vf.LLH=II2tLH=A#62tLfDHЉ,fATH0fnFdH%(HD$(1H H4$HD$HGfnȉD$fbfD$uDH(HtD$9D$tIH1101.H5HT$ H|$:&|$ HH*HHYHfDLd$Ht$ L.$HT$ H5L%|$ Ht$ H&)Ht~f&HH_f.{&HH?DAT1UHHHNdH%(HD$81HGAfnH%fnA)fbAt int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. V.IsA(string) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. V.SafeDownCast(vtkObjectBase) -> vtkAlgorithm C++: static vtkAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkAlgorithm C++: vtkAlgorithm *NewInstance() V.HasExecutive() -> int C++: int HasExecutive() Check whether this algorithm has an assigned executive. This will NOT create a default executive. V.GetExecutive() -> vtkExecutive C++: vtkExecutive *GetExecutive() Get this algorithm's executive. If it has none, a default executive will be created. V.SetExecutive(vtkExecutive) C++: virtual void SetExecutive(vtkExecutive *executive) Set this algorithm's executive. This algorithm is removed from any executive to which it has previously been assigned and then assigned to the given executive. V.ProcessRequest(vtkInformation, vtkCollection, vtkInformationVector) -> int C++: int ProcessRequest(vtkInformation *request, vtkCollection *inInfo, vtkInformationVector *outInfo) Version of ProcessRequest() that is wrapped. This converts the collection to an array and calls the other version. V.ModifyRequest(vtkInformation, int) -> int C++: virtual int ModifyRequest(vtkInformation *request, int when) This method gives the algorithm a chance to modify the contents of a request before or after (specified in the when argument) it is forwarded. The default implementation is empty. Returns 1 on success, 0 on failure. When can be either vtkExecutive::BeforeForward or vtkExecutive::AfterForward. V.GetInputPortInformation(int) -> vtkInformation C++: vtkInformation *GetInputPortInformation(int port) Get the information object associated with an input port. There is one input port per kind of input to the algorithm. Each input port tells executives what kind of data and downstream requests this algorithm can handle for that input. V.GetOutputPortInformation(int) -> vtkInformation C++: vtkInformation *GetOutputPortInformation(int port) Get the information object associated with an output port. There is one output port per output from the algorithm. Each output port tells executives what kind of upstream requests this algorithm can handle for that output. V.GetInformation() -> vtkInformation C++: virtual vtkInformation *GetInformation() Set/Get the information object associated with this algorithm. V.SetInformation(vtkInformation) C++: virtual void SetInformation(vtkInformation *) Set/Get the information object associated with this algorithm. V.GetNumberOfInputPorts() -> int C++: int GetNumberOfInputPorts() Get the number of input ports used by the algorithm. V.GetNumberOfOutputPorts() -> int C++: int GetNumberOfOutputPorts() Get the number of output ports provided by the algorithm. V.SetAbortExecute(int) C++: virtual void SetAbortExecute(int _arg) Set/Get the AbortExecute flag for the process object. Process objects may handle premature termination of execution in different ways. V.GetAbortExecute() -> int C++: virtual int GetAbortExecute() Set/Get the AbortExecute flag for the process object. Process objects may handle premature termination of execution in different ways. V.AbortExecuteOn() C++: virtual void AbortExecuteOn() Set/Get the AbortExecute flag for the process object. Process objects may handle premature termination of execution in different ways. V.AbortExecuteOff() C++: virtual void AbortExecuteOff() Set/Get the AbortExecute flag for the process object. Process objects may handle premature termination of execution in different ways. V.SetProgress(float) C++: virtual void SetProgress(double _arg) Set/Get the execution progress of a process object. V.GetProgressMinValue() -> float C++: virtual double GetProgressMinValue() Set/Get the execution progress of a process object. V.GetProgressMaxValue() -> float C++: virtual double GetProgressMaxValue() Set/Get the execution progress of a process object. V.GetProgress() -> float C++: virtual double GetProgress() Set/Get the execution progress of a process object. V.UpdateProgress(float) C++: void UpdateProgress(double amount) Update the progress of the process object. If a ProgressMethod exists, executes it. Then set the Progress ivar to amount. The parameter amount should range between (0,1). V.SetProgressText(string) C++: void SetProgressText(const char *ptext) Set the current text message associated with the progress state. This may be used by a calling process/GUI. Note: Because SetProgressText() is called from inside RequestData() it does not modify the algorithm object. Algorithms are not allowed to modify themselves from inside RequestData(). V.GetProgressText() -> string C++: virtual char *GetProgressText() Set the current text message associated with the progress state. This may be used by a calling process/GUI. Note: Because SetProgressText() is called from inside RequestData() it does not modify the algorithm object. Algorithms are not allowed to modify themselves from inside RequestData(). V.GetErrorCode() -> int C++: virtual unsigned long GetErrorCode() The error code contains a possible error that occurred while reading or writing the file. V.INPUT_IS_OPTIONAL() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *INPUT_IS_OPTIONAL() Keys used to specify input port requirements.\ingroup InformationKeys V.INPUT_IS_REPEATABLE() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *INPUT_IS_REPEATABLE() \ingroup InformationKeys V.INPUT_REQUIRED_FIELDS() -> vtkInformationInformationVectorKey C++: static vtkInformationInformationVectorKey *INPUT_REQUIRED_FIELDS( ) \ingroup InformationKeys V.INPUT_REQUIRED_DATA_TYPE() -> vtkInformationStringVectorKey C++: static vtkInformationStringVectorKey *INPUT_REQUIRED_DATA_TYPE( ) \ingroup InformationKeys V.INPUT_ARRAYS_TO_PROCESS() -> vtkInformationInformationVectorKey C++: static vtkInformationInformationVectorKey *INPUT_ARRAYS_TO_PROCESS( ) \ingroup InformationKeys V.INPUT_PORT() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *INPUT_PORT() \ingroup InformationKeys V.INPUT_CONNECTION() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *INPUT_CONNECTION() \ingroup InformationKeys V.CAN_PRODUCE_SUB_EXTENT() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *CAN_PRODUCE_SUB_EXTENT() This key tells the executive that a particular output port is capable of producing an arbitrary subextent of the whole extent. Many image sources and readers fall into this category but some such as the legacy structured data readers cannot support this feature.\ingroup InformationKeys V.CAN_HANDLE_PIECE_REQUEST() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *CAN_HANDLE_PIECE_REQUEST() Key that tells the pipeline that a particular algorithm can or cannot handle piece request. If a filter cannot handle piece requests and is asked for a piece, the executive will flag an error. If a structured data source cannot handle piece requests but can produce sub-extents (CAN_PRODUCE_SUB_EXTENT), the executive will use an extent translator to split the extent into pieces. Otherwise, if a source cannot handle piece requests, the executive will ask for the whole data for piece 0 and not execute the source for other pieces.\ingroup InformationKeys V.SetInputArrayToProcess(int, int, int, int, string) C++: virtual void SetInputArrayToProcess(int idx, int port, int connection, int fieldAssociation, const char *name) V.SetInputArrayToProcess(int, int, int, int, int) C++: virtual void SetInputArrayToProcess(int idx, int port, int connection, int fieldAssociation, int fieldAttributeType) V.SetInputArrayToProcess(int, vtkInformation) C++: virtual void SetInputArrayToProcess(int idx, vtkInformation *info) V.SetInputArrayToProcess(int, int, int, string, string) C++: virtual void SetInputArrayToProcess(int idx, int port, int connection, const char *fieldAssociation, const char *attributeTypeorName) Set the input data arrays that this algorithm will process. Specifically the idx array that this algorithm will process (starting from 0) is the array on port, connection with the specified association and name or attribute type (such as SCALARS). The fieldAssociation refers to which field in the data object the array is stored. See vtkDataObject::FieldAssociations for detail. V.GetInputArrayInformation(int) -> vtkInformation C++: vtkInformation *GetInputArrayInformation(int idx) Get the info object for the specified input array to this algorithm V.RemoveAllInputs() C++: void RemoveAllInputs() Remove all the input data. V.GetOutputDataObject(int) -> vtkDataObject C++: vtkDataObject *GetOutputDataObject(int port) Get the data object that will contain the algorithm output for the given port. V.GetInputDataObject(int, int) -> vtkDataObject C++: vtkDataObject *GetInputDataObject(int port, int connection) Get the data object that will contain the algorithm input for the given port and given connection. V.SetInputConnection(int, vtkAlgorithmOutput) C++: virtual void SetInputConnection(int port, vtkAlgorithmOutput *input) V.SetInputConnection(vtkAlgorithmOutput) C++: virtual void SetInputConnection(vtkAlgorithmOutput *input) Set the connection for the given input port index. Each input port of a filter has a specific purpose. A port may have zero or more connections and the required number is specified by each filter. Setting the connection with this method removes all other connections from the port. To add more than one connection use AddInputConnection(). * The input for the connection is the output port of another * filter, which is obtained with GetOutputPort(). Typical usage is * filter2->SetInputConnection(0, filter1->GetOutputPort(0)). V.AddInputConnection(int, vtkAlgorithmOutput) C++: virtual void AddInputConnection(int port, vtkAlgorithmOutput *input) V.AddInputConnection(vtkAlgorithmOutput) C++: virtual void AddInputConnection(vtkAlgorithmOutput *input) Add a connection to the given input port index. See SetInputConnection() for details on input connections. This method is the complement to RemoveInputConnection() in that it adds only the connection specified without affecting other connections. Typical usage is * filter2->AddInputConnection(0, filter1->GetOutputPort(0)). V.RemoveInputConnection(int, vtkAlgorithmOutput) C++: virtual void RemoveInputConnection(int port, vtkAlgorithmOutput *input) V.RemoveInputConnection(int, int) C++: virtual void RemoveInputConnection(int port, int idx) Remove a connection from the given input port index. See SetInputConnection() for details on input connection. This method is the complement to AddInputConnection() in that it removes only the connection specified without affecting other connections. Typical usage is * filter2->RemoveInputConnection(0, filter1->GetOutputPort(0)). V.RemoveAllInputConnections(int) C++: virtual void RemoveAllInputConnections(int port) Removes all input connections. V.SetInputDataObject(int, vtkDataObject) C++: virtual void SetInputDataObject(int port, vtkDataObject *data) V.SetInputDataObject(vtkDataObject) C++: virtual void SetInputDataObject(vtkDataObject *data) Sets the data-object as an input on the given port index. Setting the input with this method removes all other connections from the port. Internally, this method creates a vtkTrivialProducer instance and sets that as the input-connection for the given port. It is safe to call this method repeatedly with the same input data object. The MTime of the vtkAlgorithm will not change unless the data object changed. V.AddInputDataObject(int, vtkDataObject) C++: virtual void AddInputDataObject(int port, vtkDataObject *data) V.AddInputDataObject(vtkDataObject) C++: virtual void AddInputDataObject(vtkDataObject *data) Add the data-object as an input to this given port. This will add a new input connection on the specified port without affecting any existing connections on the same input port. V.GetOutputPort(int) -> vtkAlgorithmOutput C++: vtkAlgorithmOutput *GetOutputPort(int index) V.GetOutputPort() -> vtkAlgorithmOutput C++: vtkAlgorithmOutput *GetOutputPort() Get a proxy object corresponding to the given output port of this algorithm. The proxy object can be passed to another algorithm's SetInputConnection(), AddInputConnection(), and RemoveInputConnection() methods to modify pipeline connectivity. V.GetNumberOfInputConnections(int) -> int C++: int GetNumberOfInputConnections(int port) Get the number of inputs currently connected to a port. V.GetTotalNumberOfInputConnections() -> int C++: int GetTotalNumberOfInputConnections() Get the total number of inputs for this algorithm V.GetInputConnection(int, int) -> vtkAlgorithmOutput C++: vtkAlgorithmOutput *GetInputConnection(int port, int index) Get the algorithm output port connected to an input port. V.GetInputAlgorithm(int, int, int) -> vtkAlgorithm C++: vtkAlgorithm *GetInputAlgorithm(int port, int index, int &algPort) V.GetInputAlgorithm(int, int) -> vtkAlgorithm C++: vtkAlgorithm *GetInputAlgorithm(int port, int index) V.GetInputAlgorithm() -> vtkAlgorithm C++: vtkAlgorithm *GetInputAlgorithm() Returns the algorithm and the output port index of that algorithm connected to a port-index pair. V.GetInputExecutive(int, int) -> vtkExecutive C++: vtkExecutive *GetInputExecutive(int port, int index) V.GetInputExecutive() -> vtkExecutive C++: vtkExecutive *GetInputExecutive() Returns the executive associated with a particular input connection. V.GetInputInformation(int, int) -> vtkInformation C++: vtkInformation *GetInputInformation(int port, int index) V.GetInputInformation() -> vtkInformation C++: vtkInformation *GetInputInformation() Return the information object that is associated with a particular input connection. This can be used to get meta-data coming from the REQUEST_INFORMATION pass and set requests for the REQUEST_UPDATE_EXTENT pass. NOTE: Do not use this in any of the pipeline passes. Use the information objects passed as arguments instead. V.GetOutputInformation(int) -> vtkInformation C++: vtkInformation *GetOutputInformation(int port) Return the information object that is associated with a particular output port. This can be used to set meta-data coming during the REQUEST_INFORMATION. NOTE: Do not use this in any of the pipeline passes. Use the information objects passed as arguments instead. V.Update(int) C++: virtual void Update(int port) V.Update() C++: virtual void Update() V.Update(int, vtkInformationVector) -> int C++: virtual int Update(int port, vtkInformationVector *requests) V.Update(vtkInformation) -> int C++: virtual int Update(vtkInformation *requests) Bring this algorithm's outputs up-to-date. V.UpdatePiece(int, int, int, (int, int, int, int, int, int)) -> int C++: virtual int UpdatePiece(int piece, int numPieces, int ghostLevels, const int extents[6]=nullptr) Convenience method to update an algorithm after passing requests to its first output port. See documentation for Update(int port, vtkInformationVector* requests) for details. Supports piece and extent (optional) requests. V.UpdateExtent((int, int, int, int, int, int)) -> int C++: virtual int UpdateExtent(const int extents[6]) Convenience method to update an algorithm after passing requests to its first output port. Supports extent request. V.UpdateTimeStep(float, int, int, int, (int, int, int, int, int, int)) -> int C++: virtual int UpdateTimeStep(double time, int piece=-1, int numPieces=1, int ghostLevels=0, const int extents[6]=nullptr) Convenience method to update an algorithm after passing requests to its first output port. See documentation for Update(int port, vtkInformationVector* requests) for details. Supports time, piece (optional) and extent (optional) requests. V.UpdateInformation() C++: virtual void UpdateInformation() Bring the algorithm's information up-to-date. V.UpdateDataObject() C++: virtual void UpdateDataObject() Create output object(s). V.PropagateUpdateExtent() C++: virtual void PropagateUpdateExtent() Propagate meta-data upstream. V.UpdateWholeExtent() C++: virtual void UpdateWholeExtent() Bring this algorithm's outputs up-to-date. V.ConvertTotalInputToPortConnection(int, int, int) C++: void ConvertTotalInputToPortConnection(int ind, int &port, int &conn) Convenience routine to convert from a linear ordering of input connections to a port/connection pair. V.SetReleaseDataFlag(int) C++: virtual void SetReleaseDataFlag(int) Turn release data flag on or off for all output ports. V.GetReleaseDataFlag() -> int C++: virtual int GetReleaseDataFlag() Turn release data flag on or off for all output ports. V.ReleaseDataFlagOn() C++: void ReleaseDataFlagOn() Turn release data flag on or off for all output ports. V.ReleaseDataFlagOff() C++: void ReleaseDataFlagOff() Turn release data flag on or off for all output ports. V.UpdateExtentIsEmpty(vtkInformation, vtkDataObject) -> int C++: int UpdateExtentIsEmpty(vtkInformation *pinfo, vtkDataObject *output) V.UpdateExtentIsEmpty(vtkInformation, int) -> int C++: int UpdateExtentIsEmpty(vtkInformation *pinfo, int extentType) This detects when the UpdateExtent will generate no data This condition is satisfied when the UpdateExtent has zero volume (0,-1,...) or the UpdateNumberOfPieces is 0. The source uses this call to determine whether to call Execute. V.SetDefaultExecutivePrototype(vtkExecutive) C++: static void SetDefaultExecutivePrototype(vtkExecutive *proto) If the DefaultExecutivePrototype is set, a copy of it is created in CreateDefaultExecutive() using NewInstance(). V.GetUpdateExtent() -> (int, int, int, int, int, int) C++: int *GetUpdateExtent() V.GetUpdateExtent(int) -> (int, int, int, int, int, int) C++: int *GetUpdateExtent(int port) V.GetUpdateExtent(int, int, int, int, int, int) C++: void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1, int &z0, int &z1) V.GetUpdateExtent(int, int, int, int, int, int, int) C++: void GetUpdateExtent(int port, int &x0, int &x1, int &y0, int &y1, int &z0, int &z1) V.GetUpdateExtent([int, int, int, int, int, int]) C++: void GetUpdateExtent(int extent[6]) V.GetUpdateExtent(int, [int, int, int, int, int, int]) C++: void GetUpdateExtent(int port, int extent[6]) These functions return the update extent for output ports that use 3D extents. Where port is not specified, it is assumed to be 0. V.GetUpdatePiece() -> int C++: int GetUpdatePiece() V.GetUpdatePiece(int) -> int C++: int GetUpdatePiece(int port) These functions return the update extent for output ports that use piece extents. Where port is not specified, it is assumed to be 0. V.GetUpdateNumberOfPieces() -> int C++: int GetUpdateNumberOfPieces() V.GetUpdateNumberOfPieces(int) -> int C++: int GetUpdateNumberOfPieces(int port) These functions return the update extent for output ports that use piece extents. Where port is not specified, it is assumed to be 0. V.GetUpdateGhostLevel() -> int C++: int GetUpdateGhostLevel() V.GetUpdateGhostLevel(int) -> int C++: int GetUpdateGhostLevel(int port) These functions return the update extent for output ports that use piece extents. Where port is not specified, it is assumed to be 0. V.SetProgressObserver(vtkProgressObserver) C++: void SetProgressObserver(vtkProgressObserver *) If an ProgressObserver is set, the algorithm will report progress through it rather than directly. This means that it will call UpdateProgress() on the ProgressObserver rather than itself report it and set progress. This is most useful in situations where multiple threads are executing an algorithm at the same time and want to handle progress locally. V.GetProgressObserver() -> vtkProgressObserver C++: virtual vtkProgressObserver *GetProgressObserver() If an ProgressObserver is set, the algorithm will report progress through it rather than directly. This means that it will call UpdateProgress() on the ProgressObserver rather than itself report it and set progress. This is most useful in situations where multiple threads are executing an algorithm at the same time and want to handle progress locally. @VV *vtkInformation *vtkDataObjectvtkCommonExecutionModelPython.vtkAlgorithm.DesiredOutputPrecision4TTT?GetIndexGetProducerSetProducerSetIndexvtkAlgorithmOutput - Proxy object to connect input/output ports. Superclass: vtkObject vtkAlgorithmOutput is a proxy object returned by the GetOutputPort method of vtkAlgorithm. It may be passed to the SetInputConnection, AddInputConnection, or RemoveInputConnection methods of another vtkAlgorithm to establish a connection between an output and input port. The connection is not stored in the proxy object: it is simply a convenience for creating or removing connections. vtkCommonExecutionModelPython.vtkAlgorithmOutputV.SafeDownCast(vtkObjectBase) -> vtkAlgorithmOutput C++: static vtkAlgorithmOutput *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkAlgorithmOutput C++: vtkAlgorithmOutput *NewInstance() V.SetIndex(int) C++: void SetIndex(int index) V.GetIndex() -> int C++: int GetIndex() V.GetProducer() -> vtkAlgorithm C++: vtkAlgorithm *GetProducer() V.SetProducer(vtkAlgorithm) C++: void SetProducer(vtkAlgorithm *producer) vtkAnnotationLayersAlgorithmGetOutputSetInputDatavtkAnnotationLayersAlgorithm - Superclass for algorithms that produce only vtkAnnotationLayers as output Superclass: vtkAlgorithm vtkAnnotationLayersAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be vtkAnnotationLayers. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). vtkCommonExecutionModelPython.vtkAnnotationLayersAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkAnnotationLayersAlgorithm C++: static vtkAnnotationLayersAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkAnnotationLayersAlgorithm C++: vtkAnnotationLayersAlgorithm *NewInstance() V.GetOutput() -> vtkAnnotationLayers C++: vtkAnnotationLayers *GetOutput() V.GetOutput(int) -> vtkAnnotationLayers C++: vtkAnnotationLayers *GetOutput(int index) Get the output data object for a port on this algorithm. V.SetInputData(vtkDataObject) C++: void SetInputData(vtkDataObject *obj) V.SetInputData(int, vtkDataObject) C++: void SetInputData(int index, vtkDataObject *obj) Assign a data object as input. Note that this method does not establish a pipeline connection. Use SetInputConnection() to setup a pipeline connection. vtkArrayDataAlgorithmvtkArrayDataAlgorithm - Superclass for algorithms that produce vtkArrayDatas as output Superclass: vtkAlgorithm vtkArrayDataAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be vtkArrayData. If that isn't the case then please override this method in your subclass. @par Thanks: Developed by Timothy M. Shead (tshead@sandia.gov) at Sandia National Laboratories. vtkCommonExecutionModelPython.vtkArrayDataAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkArrayDataAlgorithm C++: static vtkArrayDataAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkArrayDataAlgorithm C++: vtkArrayDataAlgorithm *NewInstance() V.GetOutput() -> vtkArrayData C++: vtkArrayData *GetOutput() V.GetOutput(int) -> vtkArrayData C++: vtkArrayData *GetOutput(int index) Get the output data object for a port on this algorithm. GetCacheSizeSetCacheSizevtkCachedStreamingDemandDrivenPipelinevtkCachedStreamingDemandDrivenPipeline - vtkCachedStreamingDemandDrivenPipeline Superclass: vtkStreamingDemandDrivenPipeline vtkCommonExecutionModelPython.vtkCachedStreamingDemandDrivenPipelineV.SafeDownCast(vtkObjectBase) -> vtkCachedStreamingDemandDrivenPipeline C++: static vtkCachedStreamingDemandDrivenPipeline *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkCachedStreamingDemandDrivenPipeline C++: vtkCachedStreamingDemandDrivenPipeline *NewInstance() V.SetCacheSize(int) C++: void SetCacheSize(int size) This is the maximum number of images that can be retained in memory. it defaults to 10. V.GetCacheSize() -> int C++: virtual int GetCacheSize() This is the maximum number of images that can be retained in memory. it defaults to 10. vtkStreamingDemandDrivenPipelinevtkDemandDrivenPipelinevtkCastToConcretevtkDataSetAlgorithmvtkCastToConcrete - works around type-checking limitations Superclass: vtkDataSetAlgorithm vtkCastToConcrete is a filter that works around type-checking limitations in the filter classes. Some filters generate abstract types on output, and cannot be connected to the input of filters requiring a concrete input type. For example, vtkElevationFilter generates vtkDataSet for output, and cannot be connected to vtkDecimate, because vtkDecimate requires vtkPolyData as input. This is true even though (in this example) the input to vtkElevationFilter is of type vtkPolyData, and you know the output of vtkElevationFilter is the same type as its input. vtkCastToConcrete performs run-time checking to insure that output type is of the right type. An error message will result if you try to cast an input type improperly. Otherwise, the filter performs the appropriate cast and returns the data. @warning You must specify the input before you can get the output. Otherwise an error results. @sa vtkDataSetAlgorithm vtkPointSetToPointSetFilter vtkCommonExecutionModelPython.vtkCastToConcreteV.SafeDownCast(vtkObjectBase) -> vtkCastToConcrete C++: static vtkCastToConcrete *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkCastToConcrete C++: vtkCastToConcrete *NewInstance() vtkCompositeDataPipelineBLOCK_AMOUNT_OF_DETAILUPDATE_COMPOSITE_INDICESCOMPOSITE_DATA_META_DATALOAD_REQUESTED_BLOCKSGetCompositeOutputDatavtkCompositeDataPipeline - Executive supporting composite datasets. Superclass: vtkStreamingDemandDrivenPipeline vtkCompositeDataPipeline is an executive that supports the processing of composite dataset. It supports algorithms that are aware of composite dataset as well as those that are not. Type checking is performed at run time. Algorithms that are not composite dataset-aware have to support all dataset types contained in the composite dataset. The pipeline execution can be summarized as follows: * REQUEST_INFORMATION: The producers have to provide information about the contents of the composite dataset in this pass. Sources that can produce more than one piece (note that a piece is different than a block; each piece consistes of 0 or more blocks) should set CAN_HANDLE_PIECE_REQUEST. * REQUEST_UPDATE_EXTENT: This pass is identical to the one implemented in vtkStreamingDemandDrivenPipeline * REQUEST_DATA: This is where the algorithms execute. If the vtkCompositeDataPipeline is assigned to a simple filter, it will invoke the vtkStreamingDemandDrivenPipeline passes in a loop, passing a different block each time and will collect the results in a composite dataset. @sa vtkCompositeDataSet vtkCommonExecutionModelPython.vtkCompositeDataPipelineV.SafeDownCast(vtkObjectBase) -> vtkCompositeDataPipeline C++: static vtkCompositeDataPipeline *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkCompositeDataPipeline C++: vtkCompositeDataPipeline *NewInstance() V.GetCompositeOutputData(int) -> vtkDataObject C++: vtkDataObject *GetCompositeOutputData(int port) Returns the data object stored with the DATA_OBJECT() in the output port V.LOAD_REQUESTED_BLOCKS() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *LOAD_REQUESTED_BLOCKS() An integer key that indicates to the source to load all requested blocks specified in UPDATE_COMPOSITE_INDICES. V.COMPOSITE_DATA_META_DATA() -> vtkInformationObjectBaseKey C++: static vtkInformationObjectBaseKey *COMPOSITE_DATA_META_DATA( ) COMPOSITE_DATA_META_DATA is a key placed in the output-port information by readers/sources producing composite datasets. This meta-data provides information about the structure of the composite dataset and things like data-bounds etc. *** THIS IS AN EXPERIMENTAL FEATURE. IT MAY CHANGE WITHOUT NOTICE *** V.UPDATE_COMPOSITE_INDICES() -> vtkInformationIntegerVectorKey C++: static vtkInformationIntegerVectorKey *UPDATE_COMPOSITE_INDICES( ) UPDATE_COMPOSITE_INDICES is a key placed in the request to request a set of composite indices from a reader/source producing composite dataset. Typically, the reader publishes its structure using COMPOSITE_DATA_META_DATA() and then the sink requests blocks of interest using UPDATE_COMPOSITE_INDICES(). Note that UPDATE_COMPOSITE_INDICES has to be sorted vector with increasing indices. *** THIS IS AN EXPERIMENTAL FEATURE. IT MAY CHANGE WITHOUT NOTICE *** V.BLOCK_AMOUNT_OF_DETAIL() -> vtkInformationDoubleKey C++: static vtkInformationDoubleKey *BLOCK_AMOUNT_OF_DETAIL() BLOCK_AMOUNT_OF_DETAIL is a key placed in the information about a multi-block dataset that indicates how complex the block is. It is intended to work with multi-resolution streaming code. For example in a multi-resolution dataset of points, this key might store the number of points. *** THIS IS AN EXPERIMENTAL FEATURE. IT MAY CHANGE WITHOUT NOTICE *** vtkCompositeDataSetAlgorithmvtkCompositeDataSetAlgorithm - Superclass for algorithms that produce only vtkCompositeDataSet as output Superclass: vtkAlgorithm Algorithms that take any type of data object (including composite dataset) and produce a vtkCompositeDataSet in the output can subclass from this class. vtkCommonExecutionModelPython.vtkCompositeDataSetAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkCompositeDataSetAlgorithm C++: static vtkCompositeDataSetAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkCompositeDataSetAlgorithm C++: vtkCompositeDataSetAlgorithm *NewInstance() V.GetOutput() -> vtkCompositeDataSet C++: vtkCompositeDataSet *GetOutput() V.GetOutput(int) -> vtkCompositeDataSet C++: vtkCompositeDataSet *GetOutput(int) Get the output data object for a port on this algorithm. V.SetInputData(vtkDataObject) C++: void SetInputData(vtkDataObject *) V.SetInputData(int, vtkDataObject) C++: void SetInputData(int, vtkDataObject *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use SetInputConnection() to setup a pipeline connection. vtkDataObjectAlgorithmGetInputAddInputDataSetOutputvtkDataObjectAlgorithm - Superclass for algorithms that produce only data object as output Superclass: vtkAlgorithm vtkDataObjectAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be DataObject. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). vtkCommonExecutionModelPython.vtkDataObjectAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkDataObjectAlgorithm C++: static vtkDataObjectAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkDataObjectAlgorithm C++: vtkDataObjectAlgorithm *NewInstance() V.GetOutput() -> vtkDataObject C++: vtkDataObject *GetOutput() V.GetOutput(int) -> vtkDataObject C++: vtkDataObject *GetOutput(int) Get the output data object for a port on this algorithm. V.SetOutput(vtkDataObject) C++: virtual void SetOutput(vtkDataObject *d) Get the output data object for a port on this algorithm. V.GetInput() -> vtkDataObject C++: vtkDataObject *GetInput() V.GetInput(int) -> vtkDataObject C++: vtkDataObject *GetInput(int port) V.AddInputData(vtkDataObject) C++: void AddInputData(vtkDataObject *) V.AddInputData(int, vtkDataObject) C++: void AddInputData(int, vtkDataObject *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use AddInputConnection() to setup a pipeline connection. GetPolyDataOutputGetUnstructuredGridOutputGetRectilinearGridOutputGetImageDataOutputGetStructuredGridOutputGetStructuredPointsOutput@V *vtkDataObject@V *vtkDataSet@iV *vtkDataSet@iV *vtkDataObjectvtkDataSetAlgorithm - Superclass for algorithms that produce output of the same type as input Superclass: vtkAlgorithm vtkDataSetAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes contstructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be DataSet. If that isn't the case then please override this method in your subclass. This class breaks out the downstream requests into separate functions such as RequestDataObject RequestData and RequestInformation. The default implementation of RequestDataObject will create an output data of the same type as the input. vtkCommonExecutionModelPython.vtkDataSetAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkDataSetAlgorithm C++: static vtkDataSetAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkDataSetAlgorithm C++: vtkDataSetAlgorithm *NewInstance() V.GetOutput() -> vtkDataSet C++: vtkDataSet *GetOutput() V.GetOutput(int) -> vtkDataSet C++: vtkDataSet *GetOutput(int) Get the output data object for a port on this algorithm. V.GetInput() -> vtkDataObject C++: vtkDataObject *GetInput() Get the input data object. This method is not recommended for use, but lots of old style filters use it. V.GetPolyDataOutput() -> vtkPolyData C++: vtkPolyData *GetPolyDataOutput() Get the output as vtkPolyData. V.GetStructuredPointsOutput() -> vtkStructuredPoints C++: vtkStructuredPoints *GetStructuredPointsOutput() Get the output as vtkStructuredPoints. V.GetImageDataOutput() -> vtkImageData C++: vtkImageData *GetImageDataOutput() Get the output as vtkStructuredPoints. V.GetStructuredGridOutput() -> vtkStructuredGrid C++: vtkStructuredGrid *GetStructuredGridOutput() Get the output as vtkStructuredGrid. V.GetUnstructuredGridOutput() -> vtkUnstructuredGrid C++: vtkUnstructuredGrid *GetUnstructuredGridOutput() Get the output as vtkUnstructuredGrid. V.GetRectilinearGridOutput() -> vtkRectilinearGrid C++: vtkRectilinearGrid *GetRectilinearGridOutput() Get the output as vtkRectilinearGrid. V.SetInputData(vtkDataObject) C++: void SetInputData(vtkDataObject *) V.SetInputData(int, vtkDataObject) C++: void SetInputData(int, vtkDataObject *) V.SetInputData(vtkDataSet) C++: void SetInputData(vtkDataSet *) V.SetInputData(int, vtkDataSet) C++: void SetInputData(int, vtkDataSet *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use SetInputConnection() to setup a pipeline connection. V.AddInputData(vtkDataObject) C++: void AddInputData(vtkDataObject *) V.AddInputData(vtkDataSet) C++: void AddInputData(vtkDataSet *) V.AddInputData(int, vtkDataSet) C++: void AddInputData(int, vtkDataSet *) V.AddInputData(int, vtkDataObject) C++: void AddInputData(int, vtkDataObject *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use AddInputConnection() to setup a pipeline connection. NewDataObjectRELEASE_DATAREQUEST_DATA_NOT_GENERATEDREQUEST_DATAREQUEST_INFORMATIONREQUEST_DATA_OBJECTGetPipelineMTimeUpdateDataUpdatePipelineMTimevtkDemandDrivenPipeline - Executive supporting on-demand execution. Superclass: vtkExecutive vtkDemandDrivenPipeline is an executive that will execute an algorithm only when its outputs are out-of-date with respect to its inputs. vtkCommonExecutionModelPython.vtkDemandDrivenPipelineV.SafeDownCast(vtkObjectBase) -> vtkDemandDrivenPipeline C++: static vtkDemandDrivenPipeline *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkDemandDrivenPipeline C++: vtkDemandDrivenPipeline *NewInstance() V.Update() -> int C++: int Update() override; V.Update(int) -> int C++: int Update(int port) override; Bring the algorithm's outputs up-to-date. Returns 1 for success and 0 for failure. V.GetPipelineMTime() -> int C++: virtual vtkMTimeType GetPipelineMTime() Get the PipelineMTime for this exective. V.SetReleaseDataFlag(int, int) -> int C++: virtual int SetReleaseDataFlag(int port, int n) Set whether the given output port releases data when it is consumed. Returns 1 if the the value changes and 0 otherwise. V.GetReleaseDataFlag(int) -> int C++: virtual int GetReleaseDataFlag(int port) Get whether the given output port releases data when it is consumed. V.UpdatePipelineMTime() -> int C++: virtual int UpdatePipelineMTime() Bring the PipelineMTime up to date. V.UpdateDataObject() -> int C++: int UpdateDataObject() override; Bring the output data object's existence up to date. This does not actually produce data, but does create the data object that will store data produced during the UpdateData step. V.UpdateInformation() -> int C++: int UpdateInformation() override; Bring the output information up to date. V.UpdateData(int) -> int C++: virtual int UpdateData(int outputPort) Bring the output data up to date. This should be called only when information is up to date. Use the Update method if it is not known that the information is up to date. V.REQUEST_DATA_OBJECT() -> vtkInformationRequestKey C++: static vtkInformationRequestKey *REQUEST_DATA_OBJECT() Key defining a request to make sure the output data objects exist.@ingroup InformationKeys V.REQUEST_INFORMATION() -> vtkInformationRequestKey C++: static vtkInformationRequestKey *REQUEST_INFORMATION() Key defining a request to make sure the output information is up to date.@ingroup InformationKeys V.REQUEST_DATA() -> vtkInformationRequestKey C++: static vtkInformationRequestKey *REQUEST_DATA() Key defining a request to make sure the output data are up to date.@ingroup InformationKeys V.REQUEST_DATA_NOT_GENERATED() -> vtkInformationRequestKey C++: static vtkInformationRequestKey *REQUEST_DATA_NOT_GENERATED() Key defining a request to mark outputs that will NOT be generated during a REQUEST_DATA.@ingroup InformationKeys V.RELEASE_DATA() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *RELEASE_DATA() Key to specify in pipeline information the request that data be released after it is used.@ingroup InformationKeys V.DATA_NOT_GENERATED() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *DATA_NOT_GENERATED() Key to store a mark for an output that will not be generated. Algorithms use this to tell the executive that they will not generate certain outputs for a REQUEST_DATA.@ingroup InformationKeys V.NewDataObject(string) -> vtkDataObject C++: static vtkDataObject *NewDataObject(const char *type) Create (New) and return a data object of the given type. This is here for backwards compatibility. Use vtkDataObjectTypes::NewDataObject() instead. vtkDirectedGraphAlgorithmvtkDirectedGraphAlgorithm - Superclass for algorithms that produce only directed graph as output Superclass: vtkAlgorithm vtkDirectedGraphAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline edgehitecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be Graph. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). @par Thanks: Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from Sandia National Laboratories for their help in developing this class. vtkCommonExecutionModelPython.vtkDirectedGraphAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkDirectedGraphAlgorithm C++: static vtkDirectedGraphAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkDirectedGraphAlgorithm C++: vtkDirectedGraphAlgorithm *NewInstance() V.GetOutput() -> vtkDirectedGraph C++: vtkDirectedGraph *GetOutput() V.GetOutput(int) -> vtkDirectedGraph C++: vtkDirectedGraph *GetOutput(int index) Get the output data object for a port on this algorithm. vtkEnsembleSourceUPDATE_MEMBERRemoveAllMembersGetNumberOfMembersGetCurrentMemberSetMetaDatavtkTableAddMemberSetCurrentMembervtkEnsembleSource - source that manages dataset ensembles Superclass: vtkAlgorithm vtkEnsembleSource manages a collection of data sources in order to represent a dataset ensemble. It has the ability to provide meta-data about the ensemble in the form of a table, using the META_DATA key as well as accept a pipeline request using the UPDATE_MEMBER key. Note that it is expected that all ensemble members produce data of the same type. vtkCommonExecutionModelPython.vtkEnsembleSourceV.SafeDownCast(vtkObjectBase) -> vtkEnsembleSource C++: static vtkEnsembleSource *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkEnsembleSource C++: vtkEnsembleSource *NewInstance() V.AddMember(vtkAlgorithm) C++: void AddMember(vtkAlgorithm *) Add an algorithm (source) that will produce the next ensemble member. This algorithm will be passed the REQUEST_INFORMATION, REQUEST_UPDATE_EXTENT and REQUEST_DATA pipeline passes for execution. V.RemoveAllMembers() C++: void RemoveAllMembers() Removes all ensemble members. V.GetNumberOfMembers() -> int C++: unsigned int GetNumberOfMembers() Returns the number of ensemble members. V.SetCurrentMember(int) C++: virtual void SetCurrentMember(unsigned int _arg) Set/Get the current ensemble member to process. Note that this data member will not be used if the UPDATE_MEMBER key is present in the pipeline. Also, this data member may be removed in the future. Unless it is absolutely necessary to use this data member, use the UPDATE_MEMBER key instead. V.GetCurrentMember() -> int C++: virtual unsigned int GetCurrentMember() Set/Get the current ensemble member to process. Note that this data member will not be used if the UPDATE_MEMBER key is present in the pipeline. Also, this data member may be removed in the future. Unless it is absolutely necessary to use this data member, use the UPDATE_MEMBER key instead. V.SetMetaData(vtkTable) C++: void SetMetaData(vtkTable *) Set the meta-data that will be propagated downstream. Make sure that this table has as many rows as the ensemble members and the meta-data for each row matches the corresponding ensemble source. V.META_DATA() -> vtkInformationDataObjectMetaDataKey C++: static vtkInformationDataObjectMetaDataKey *META_DATA() Meta-data for the ensemble. This is set with SetMetaData. V.UPDATE_MEMBER() -> vtkInformationIntegerRequestKey C++: static vtkInformationIntegerRequestKey *UPDATE_MEMBER() Key used to request a particular ensemble member. KEYS_TO_COPYFORWARD_DIRECTIONALGORITHM_DIRECTIONALGORITHM_AFTER_FORWARDALGORITHM_BEFORE_FORWARDFROM_OUTPUT_PORTCONSUMERSPRODUCERGetAlgorithmSetSharedOutputInformationGetInputDataSetOutputDataGetOutputDataRequestUpstreamRequestDownstreamBeforeForwardAfterForwardvtkExecutive - Superclass for all pipeline executives in VTK. Superclass: vtkObject vtkExecutive is the superclass for all pipeline executives in VTK. A VTK executive is responsible for controlling one instance of vtkAlgorithm. A pipeline consists of one or more executives that control data flow. Every reader, source, writer, or data processing algorithm in the pipeline is implemented in an instance of vtkAlgorithm. vtkCommonExecutionModelPython.vtkExecutiveV.SafeDownCast(vtkObjectBase) -> vtkExecutive C++: static vtkExecutive *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkExecutive C++: vtkExecutive *NewInstance() V.GetAlgorithm() -> vtkAlgorithm C++: vtkAlgorithm *GetAlgorithm() Get the algorithm to which this executive has been assigned. V.UpdateInformation() -> int C++: virtual int UpdateInformation() Bring the output information up to date. V.Update() -> int C++: virtual int Update() V.Update(int) -> int C++: virtual int Update(int port) Bring the algorithm's outputs up-to-date. Returns 1 for success and 0 for failure. V.GetNumberOfInputPorts() -> int C++: int GetNumberOfInputPorts() Get the number of input/output ports for the algorithm associated with this executive. Returns 0 if no algorithm is set. V.GetNumberOfOutputPorts() -> int C++: int GetNumberOfOutputPorts() Get the number of input/output ports for the algorithm associated with this executive. Returns 0 if no algorithm is set. V.GetNumberOfInputConnections(int) -> int C++: int GetNumberOfInputConnections(int port) Get the number of input connections on the given port. V.GetOutputInformation(int) -> vtkInformation C++: virtual vtkInformation *GetOutputInformation(int port) V.GetOutputInformation() -> vtkInformationVector C++: vtkInformationVector *GetOutputInformation() Get the pipeline information object for the given output port. V.GetInputInformation(int, int) -> vtkInformation C++: vtkInformation *GetInputInformation(int port, int connection) V.GetInputInformation(int) -> vtkInformationVector C++: vtkInformationVector *GetInputInformation(int port) Get the pipeline information for the given input connection. V.GetInputExecutive(int, int) -> vtkExecutive C++: vtkExecutive *GetInputExecutive(int port, int connection) Get the executive managing the given input connection. V.GetOutputData(int) -> vtkDataObject C++: virtual vtkDataObject *GetOutputData(int port) Get/Set the data object for an output port of the algorithm. V.SetOutputData(int, vtkDataObject, vtkInformation) C++: virtual void SetOutputData(int port, vtkDataObject *, vtkInformation *info) V.SetOutputData(int, vtkDataObject) C++: virtual void SetOutputData(int port, vtkDataObject *) Get/Set the data object for an output port of the algorithm. V.GetInputData(int, int) -> vtkDataObject C++: virtual vtkDataObject *GetInputData(int port, int connection) Get the data object for an input port of the algorithm. V.SetSharedOutputInformation(vtkInformationVector) C++: void SetSharedOutputInformation( vtkInformationVector *outInfoVec) Set a pointer to an outside instance of input or output information vectors. No references are held to the given vectors, and setting this does not change the executive object modification time. This is a preliminary interface to use in implementing filters with internal pipelines, and may change without notice when a future interface is created. V.PRODUCER() -> vtkInformationExecutivePortKey C++: static vtkInformationExecutivePortKey *PRODUCER() Information key to store the executive/port number producing an information object. V.CONSUMERS() -> vtkInformationExecutivePortVectorKey C++: static vtkInformationExecutivePortVectorKey *CONSUMERS() Information key to store the executive/port number pairs consuming an information object. V.FROM_OUTPUT_PORT() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *FROM_OUTPUT_PORT() Information key to store the output port number from which a request is made. V.ALGORITHM_BEFORE_FORWARD() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *ALGORITHM_BEFORE_FORWARD() Keys to program vtkExecutive::ProcessRequest with the default behavior for unknown requests. V.ALGORITHM_AFTER_FORWARD() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *ALGORITHM_AFTER_FORWARD() Keys to program vtkExecutive::ProcessRequest with the default behavior for unknown requests. V.ALGORITHM_DIRECTION() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *ALGORITHM_DIRECTION() Keys to program vtkExecutive::ProcessRequest with the default behavior for unknown requests. V.FORWARD_DIRECTION() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *FORWARD_DIRECTION() Keys to program vtkExecutive::ProcessRequest with the default behavior for unknown requests. V.KEYS_TO_COPY() -> vtkInformationKeyVectorKey C++: static vtkInformationKeyVectorKey *KEYS_TO_COPY() Keys to program vtkExecutive::ProcessRequest with the default behavior for unknown requests. vtkExtentSplitterRemoveAllExtentSourcesComputeSubExtentsGetNumberOfSubExtentsGetPointModeRemoveExtentSourceGetSubExtentSourceSetPointModePointModeOnPointModeOffGetSubExtentAddExtentAddExtentSourcevtkExtentSplitter - Split an extent across other extents. Superclass: vtkObject vtkExtentSplitter splits each input extent into non-overlapping sub-extents that are completely contained within other "source extents". A source extent corresponds to some resource providing an extent. Each source extent has an integer identifier, integer priority, and an extent. The input extents are split into sub-extents according to priority, availability, and amount of overlap of the source extents. This can be used by parallel data readers to read as few piece files as possible. vtkCommonExecutionModelPython.vtkExtentSplitterV.SafeDownCast(vtkObjectBase) -> vtkExtentSplitter C++: static vtkExtentSplitter *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkExtentSplitter C++: vtkExtentSplitter *NewInstance() V.AddExtentSource(int, int, int, int, int, int, int, int) C++: void AddExtentSource(int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1) V.AddExtentSource(int, int, [int, ...]) C++: void AddExtentSource(int id, int priority, int *extent) Add/Remove a source providing the given extent. Sources with higher priority numbers are favored. Source id numbers and priorities must be non-negative. V.RemoveExtentSource(int) C++: void RemoveExtentSource(int id) Add/Remove a source providing the given extent. Sources with higher priority numbers are favored. Source id numbers and priorities must be non-negative. V.RemoveAllExtentSources() C++: void RemoveAllExtentSources() Add/Remove a source providing the given extent. Sources with higher priority numbers are favored. Source id numbers and priorities must be non-negative. V.AddExtent(int, int, int, int, int, int) C++: void AddExtent(int x0, int x1, int y0, int y1, int z0, int z1) V.AddExtent([int, ...]) C++: void AddExtent(int *extent) Add an extent to the queue of extents to be split among the available sources. V.ComputeSubExtents() -> int C++: int ComputeSubExtents() Split the extents currently in the queue among the available sources. The queue is empty when this returns. Returns 1 if all extents could be read. Returns 0 if any portion of any extent was not available through any source. V.GetNumberOfSubExtents() -> int C++: int GetNumberOfSubExtents() Get the number of sub-extents into which the original set of extents have been split across the available sources. Valid after a call to ComputeSubExtents. V.GetSubExtent(int) -> (int, int, int, int, int, int) C++: int *GetSubExtent(int index) V.GetSubExtent(int, [int, ...]) C++: void GetSubExtent(int index, int *extent) Get the sub-extent associated with the given index. Use GetSubExtentSource to get the id of the source from which this sub-extent should be read. Valid after a call to ComputeSubExtents. V.GetSubExtentSource(int) -> int C++: int GetSubExtentSource(int index) Get the id of the source from which the sub-extent associated with the given index should be read. Returns -1 if no source provides the sub-extent. V.GetPointMode() -> int C++: virtual int GetPointMode() Get/Set whether "point mode" is on. In point mode, sub-extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is OFF. V.SetPointMode(int) C++: virtual void SetPointMode(int _arg) Get/Set whether "point mode" is on. In point mode, sub-extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is OFF. V.PointModeOn() C++: virtual void PointModeOn() Get/Set whether "point mode" is on. In point mode, sub-extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is OFF. V.PointModeOff() C++: virtual void PointModeOff() Get/Set whether "point mode" is on. In point mode, sub-extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is OFF. vtkExtentTranslatorUPDATE_SPLIT_MODESetSplitModeToYSlabSetSplitModeToXSlabSetSplitModeToBlockSetSplitModeToZSlabGetExtentGetWholeExtentGetSplitModeGetPieceGetNumberOfPiecesGetGhostLevelSetGhostLevelSetNumberOfPiecesSetPieceSetSplitPathSetWholeExtentSetExtentModesPieceToExtentThreadSafePieceToExtentByPointsPieceToExtentX_SLAB_MODEY_SLAB_MODEZ_SLAB_MODEBLOCK_MODEvtkExtentTranslator - Generates a structured extent from unstructured. Superclass: vtkObject vtkExtentTranslator generates a structured extent from an unstructured extent. It uses a recursive scheme that splits the largest axis. A hard coded extent can be used for a starting point. vtkCommonExecutionModelPython.vtkExtentTranslatorV.SafeDownCast(vtkObjectBase) -> vtkExtentTranslator C++: static vtkExtentTranslator *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkExtentTranslator C++: vtkExtentTranslator *NewInstance() V.SetWholeExtent(int, int, int, int, int, int) C++: void SetWholeExtent(int, int, int, int, int, int) V.SetWholeExtent((int, int, int, int, int, int)) C++: void SetWholeExtent(int a[6]) V.GetWholeExtent() -> (int, int, int, int, int, int) C++: int *GetWholeExtent() V.SetExtent(int, int, int, int, int, int) C++: void SetExtent(int, int, int, int, int, int) V.SetExtent((int, int, int, int, int, int)) C++: void SetExtent(int a[6]) V.GetExtent() -> (int, int, int, int, int, int) C++: int *GetExtent() V.SetPiece(int) C++: virtual void SetPiece(int _arg) Set the Piece/NumPieces. Set the WholeExtent and then call PieceToExtent. The result can be obtained from the Extent ivar. V.GetPiece() -> int C++: virtual int GetPiece() Set the Piece/NumPieces. Set the WholeExtent and then call PieceToExtent. The result can be obtained from the Extent ivar. V.SetNumberOfPieces(int) C++: virtual void SetNumberOfPieces(int _arg) Set the Piece/NumPieces. Set the WholeExtent and then call PieceToExtent. The result can be obtained from the Extent ivar. V.GetNumberOfPieces() -> int C++: virtual int GetNumberOfPieces() Set the Piece/NumPieces. Set the WholeExtent and then call PieceToExtent. The result can be obtained from the Extent ivar. V.SetGhostLevel(int) C++: virtual void SetGhostLevel(int _arg) Set the Piece/NumPieces. Set the WholeExtent and then call PieceToExtent. The result can be obtained from the Extent ivar. V.GetGhostLevel() -> int C++: virtual int GetGhostLevel() Set the Piece/NumPieces. Set the WholeExtent and then call PieceToExtent. The result can be obtained from the Extent ivar. V.PieceToExtent() -> int C++: virtual int PieceToExtent() These are the main methods that should be called. These methods are responsible for converting a piece to an extent. The signatures without arguments are only thread safe when each thread accesses a different instance. The signatures with arguments are fully thread safe. V.PieceToExtentByPoints() -> int C++: virtual int PieceToExtentByPoints() These are the main methods that should be called. These methods are responsible for converting a piece to an extent. The signatures without arguments are only thread safe when each thread accesses a different instance. The signatures with arguments are fully thread safe. V.PieceToExtentThreadSafe(int, int, int, [int, ...], [int, ...], int, int) -> int C++: virtual int PieceToExtentThreadSafe(int piece, int numPieces, int ghostLevel, int *wholeExtent, int *resultExtent, int splitMode, int byPoints) These are the main methods that should be called. These methods are responsible for converting a piece to an extent. The signatures without arguments are only thread safe when each thread accesses a different instance. The signatures with arguments are fully thread safe. V.SetSplitModeToBlock() C++: void SetSplitModeToBlock() How should the streamer break up extents. Block mode tries to break an extent up into cube blocks. It always chooses the largest axis to split. Slab mode first breaks up the Z axis. If it gets to one slice, then it starts breaking up other axes. V.SetSplitModeToXSlab() C++: void SetSplitModeToXSlab() V.SetSplitModeToYSlab() C++: void SetSplitModeToYSlab() V.SetSplitModeToZSlab() C++: void SetSplitModeToZSlab() V.GetSplitMode() -> int C++: virtual int GetSplitMode() V.SetSplitPath(int, [int, ...]) C++: void SetSplitPath(int len, int *splitpath) By default the translator creates N structured subextents by repeatedly splitting the largest current dimension until there are N pieces. If you do not want it always split the largest dimension, for instance when the shortest dimension is the slowest changing and thus least coherent in memory, use this to tell the translator which dimensions to split. V.UPDATE_SPLIT_MODE() -> vtkInformationIntegerRequestKey C++: static vtkInformationIntegerRequestKey *UPDATE_SPLIT_MODE() Key used to request a particular split mode. This is used by vtkStreamingDemandDrivenPipeline. vtkCommonExecutionModelPython.vtkExtentTranslator.Modesthis function takes no keyword argumentsvtkFilteringInformationKeyManagervtkFilteringInformationKeyManager - Manages key types in vtkFiltering. vtkFilteringInformationKeyManager is included in the header of any subclass of vtkInformationKey defined in the vtkFiltering library. It makes sure that the table of keys is created before and destroyed after it is used. vtkFilteringInformationKeyManager() vtkCommonExecutionModelPython.vtkFilteringInformationKeyManagervtkGraphAlgorithmvtkGraphAlgorithm - Superclass for algorithms that produce only graph as output Superclass: vtkAlgorithm vtkGraphAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be Graph. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). @par Thanks: Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from Sandia National Laboratories for their help in developing this class. vtkCommonExecutionModelPython.vtkGraphAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkGraphAlgorithm C++: static vtkGraphAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkGraphAlgorithm C++: vtkGraphAlgorithm *NewInstance() V.GetOutput() -> vtkGraph C++: vtkGraph *GetOutput() V.GetOutput(int) -> vtkGraph C++: vtkGraph *GetOutput(int index) Get the output data object for a port on this algorithm. vtkHierarchicalBoxDataSetAlgorithmvtkHierarchicalBoxDataSetAlgorithm - superclass for algorithms that produce vtkHierarchicalBoxDataSet as output. Superclass: vtkAlgorithm Algorithms that take any type of data object (including composite dataset) and produce a vtkHierarchicalBoxDataSet in the output can subclass from this class. vtkCommonExecutionModelPython.vtkHierarchicalBoxDataSetAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkHierarchicalBoxDataSetAlgorithm C++: static vtkHierarchicalBoxDataSetAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkHierarchicalBoxDataSetAlgorithm C++: vtkHierarchicalBoxDataSetAlgorithm *NewInstance() V.GetOutput() -> vtkHierarchicalBoxDataSet C++: vtkHierarchicalBoxDataSet *GetOutput() V.GetOutput(int) -> vtkHierarchicalBoxDataSet C++: vtkHierarchicalBoxDataSet *GetOutput(int) Get the output data object for a port on this algorithm. vtkHyperTreeGridAlgorithmGetHyperTreeGridOutputvtkHyperTreeGridAlgorithm - Superclass for algorithms that produce a hyper tree grid as output Superclass: vtkAlgorithm vtkHyperTreeGridAlgorithm is a base class for hyper tree grid algorithms. This class defaults with one input port and one output port; it must be modified by the concrete derived class if a different behavior is sought. In addition, this class provides a FillOutputPortInfo() method that, by default, specifies that the output is a data object; this must also be modified in concrete subclasses if needed. @par Thanks: This test was written by Philippe Pebay and Charles Law, Kitware 2012 This test was rewritten by Philippe Pebay, 2016 This work was supported by Commissariat a l'Energie Atomique (CEA/DIF) vtkCommonExecutionModelPython.vtkHyperTreeGridAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkHyperTreeGridAlgorithm C++: static vtkHyperTreeGridAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkHyperTreeGridAlgorithm C++: vtkHyperTreeGridAlgorithm *NewInstance() V.SetOutput(vtkDataObject) C++: virtual void SetOutput(vtkDataObject *) Get the output data object for a port on this algorithm. V.GetHyperTreeGridOutput() -> vtkHyperTreeGrid C++: vtkHyperTreeGrid *GetHyperTreeGridOutput() V.GetHyperTreeGridOutput(int) -> vtkHyperTreeGrid C++: vtkHyperTreeGrid *GetHyperTreeGridOutput(int) Get the output as a hyper tree grid. V.GetPolyDataOutput() -> vtkPolyData C++: vtkPolyData *GetPolyDataOutput() V.GetPolyDataOutput(int) -> vtkPolyData C++: vtkPolyData *GetPolyDataOutput(int) Get the output as a polygonal dataset. V.GetUnstructuredGridOutput() -> vtkUnstructuredGrid C++: vtkUnstructuredGrid *GetUnstructuredGridOutput() V.GetUnstructuredGridOutput(int) -> vtkUnstructuredGrid C++: vtkUnstructuredGrid *GetUnstructuredGridOutput(int) Get the output as an unstructured grid. vtkImageAlgorithmGetImageDataInputvtkImageAlgorithm - Generic algorithm superclass for image algs Superclass: vtkAlgorithm vtkImageAlgorithm is a filter superclass that hides much of the pipeline complexity. It handles breaking the pipeline execution into smaller extents so that the vtkImageData limits are observed. It also provides support for multithreading. If you don't need any of this functionality, consider using vtkSimpleImageToImageFilter instead. @sa vtkSimpleImageToImageFilter vtkCommonExecutionModelPython.vtkImageAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkImageAlgorithm C++: static vtkImageAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkImageAlgorithm C++: vtkImageAlgorithm *NewInstance() V.GetOutput() -> vtkImageData C++: vtkImageData *GetOutput() V.GetOutput(int) -> vtkImageData C++: vtkImageData *GetOutput(int) Get the output data object for a port on this algorithm. V.SetInputData(vtkDataObject) C++: void SetInputData(vtkDataObject *) V.SetInputData(int, vtkDataObject) C++: void SetInputData(int, vtkDataObject *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use SetInputConnection to setup a pipeline connection. V.GetInput(int) -> vtkDataObject C++: vtkDataObject *GetInput(int port) V.GetInput() -> vtkDataObject C++: vtkDataObject *GetInput() Get a data object for one of the input port connections. The use of this method is strongly discouraged, but some filters that were written a long time ago still use this method. V.GetImageDataInput(int) -> vtkImageData C++: vtkImageData *GetImageDataInput(int port) Get a data object for one of the input port connections. The use of this method is strongly discouraged, but some filters that were written a long time ago still use this method. V.AddInputData(vtkDataObject) C++: virtual void AddInputData(vtkDataObject *) V.AddInputData(int, vtkDataObject) C++: virtual void AddInputData(int, vtkDataObject *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use SetInputConnection to setup a pipeline connection. vtkImageInPlaceFiltervtkImageInPlaceFilter - Filter that operates in place. Superclass: vtkImageAlgorithm vtkImageInPlaceFilter is a filter super class that operates directly on the input region. The data is copied if the requested region has different extent than the input region or some other object is referencing the input region. vtkCommonExecutionModelPython.vtkImageInPlaceFilterV.SafeDownCast(vtkObjectBase) -> vtkImageInPlaceFilter C++: static vtkImageInPlaceFilter *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkImageInPlaceFilter C++: vtkImageInPlaceFilter *NewInstance() vtkImageToStructuredGridvtkStructuredGridAlgorithmvtkImageToStructuredGrid - a structured grid instance. Superclass: vtkStructuredGridAlgorithm A concrete instance of vtkStructuredGridAlgorithm which provides functionality for converting instances of vtkImageData to vtkStructuredGrid. vtkCommonExecutionModelPython.vtkImageToStructuredGridV.SafeDownCast(vtkObjectBase) -> vtkImageToStructuredGrid C++: static vtkImageToStructuredGrid *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkImageToStructuredGrid C++: vtkImageToStructuredGrid *NewInstance() vtkImageToStructuredPointsGetVectorInputSetVectorInputDatavtkImageDatavtkImageToStructuredPoints - Attaches image pipeline to VTK. Superclass: vtkImageAlgorithm vtkImageToStructuredPoints changes an image cache format to a structured points dataset. It takes an Input plus an optional VectorInput. The VectorInput converts the RGB scalar components of the VectorInput to vector pointdata attributes. This filter will try to reference count the data but in some cases it must make a copy. vtkCommonExecutionModelPython.vtkImageToStructuredPointsV.SafeDownCast(vtkObjectBase) -> vtkImageToStructuredPoints C++: static vtkImageToStructuredPoints *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkImageToStructuredPoints C++: vtkImageToStructuredPoints *NewInstance() V.SetVectorInputData(vtkImageData) C++: void SetVectorInputData(vtkImageData *input) Set/Get the input object from the image pipeline. V.GetVectorInput() -> vtkImageData C++: vtkImageData *GetVectorInput() Set/Get the input object from the image pipeline. V.GetStructuredPointsOutput() -> vtkStructuredPoints C++: vtkStructuredPoints *GetStructuredPointsOutput() Get the output of the filter. MakeKeyCopyDefaultInformationvtkInformationDataObjectMetaDataKeyvtkInformationDataObjectMetaDataKey - key used to define meta-data of type vtkDataObject vtkInformationDataObjectMetaDataKey is a vtkInformationDataObjectKey that (shallow) copies itself downstream during the REQUEST_INFORMATION pass. Superclass: vtkInformationDataObjectKey Hence it can be used to provide meta-data of type vtkDataObject or any subclass. vtkCommonExecutionModelPython.vtkInformationDataObjectMetaDataKeyV.SafeDownCast(vtkObjectBase) -> vtkInformationDataObjectMetaDataKey C++: static vtkInformationDataObjectMetaDataKey *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkInformationDataObjectMetaDataKey C++: vtkInformationDataObjectMetaDataKey *NewInstance() V.MakeKey(string, string) -> vtkInformationDataObjectMetaDataKey C++: static vtkInformationDataObjectMetaDataKey *MakeKey( const char *name, const char *location) This method simply returns a new vtkInformationDataObjectMetaDataKey, given a name and a location. This method is provided for wrappers. Use the constructor directly from C++ instead. V.CopyDefaultInformation(vtkInformation, vtkInformation, vtkInformation) C++: void CopyDefaultInformation(vtkInformation *request, vtkInformation *fromInfo, vtkInformation *toInfo) override; Simply shallow copies the key from fromInfo to toInfo if request has the REQUEST_INFORMATION() key. This is used by the pipeline to propagate this key downstream. vtkInformationDataObjectKeyvtkInformationKeyGetPortReportvtkGarbageCollectorShallowCopyvtkInformationExecutivePortKeyvtkInformationExecutivePortKey - Key for vtkExecutive/Port value pairs. Superclass: vtkInformationKey vtkInformationExecutivePortKey is used to represent keys in vtkInformation for values that are vtkExecutive instances paired with port numbers. vtkCommonExecutionModelPython.vtkInformationExecutivePortKeyV.SafeDownCast(vtkObjectBase) -> vtkInformationExecutivePortKey C++: static vtkInformationExecutivePortKey *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkInformationExecutivePortKey C++: vtkInformationExecutivePortKey *NewInstance() V.MakeKey(string, string) -> vtkInformationExecutivePortKey C++: static vtkInformationExecutivePortKey *MakeKey( const char *name, const char *location) This method simply returns a new vtkInformationExecutivePortKey, given a name and a location. This method is provided for wrappers. Use the constructor directly from C++ instead. V.Set(vtkInformation, vtkExecutive, int) C++: void Set(vtkInformation *info, vtkExecutive *, int) Get/Set the value associated with this key in the given information object. V.GetExecutive(vtkInformation) -> vtkExecutive C++: vtkExecutive *GetExecutive(vtkInformation *info) Get/Set the value associated with this key in the given information object. V.GetPort(vtkInformation) -> int C++: int GetPort(vtkInformation *info) Get/Set the value associated with this key in the given information object. V.ShallowCopy(vtkInformation, vtkInformation) C++: void ShallowCopy(vtkInformation *from, vtkInformation *to) override; Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second. V.Report(vtkInformation, vtkGarbageCollector) C++: void Report(vtkInformation *info, vtkGarbageCollector *collector) override; Report a reference this key has in the given information object. LengthGetPortsp_voidAppendRemovevtkInformationExecutivePortVectorKeyvtkInformationExecutivePortVectorKey - Key for vtkExecutive/Port value pair vectors. Superclass: vtkInformationKey vtkInformationExecutivePortVectorKey is used to represent keys in vtkInformation for values that are vectors of vtkExecutive instances paired with port numbers. vtkCommonExecutionModelPython.vtkInformationExecutivePortVectorKeyV.SafeDownCast(vtkObjectBase) -> vtkInformationExecutivePortVectorKey C++: static vtkInformationExecutivePortVectorKey *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkInformationExecutivePortVectorKey C++: vtkInformationExecutivePortVectorKey *NewInstance() V.MakeKey(string, string) -> vtkInformationExecutivePortVectorKey C++: static vtkInformationExecutivePortVectorKey *MakeKey( const char *name, const char *location) This method simply returns a new vtkInformationExecutivePortVectorKey, given a name and a location. This method is provided for wrappers. Use the constructor directly from C++ instead. V.Append(vtkInformation, vtkExecutive, int) C++: void Append(vtkInformation *info, vtkExecutive *executive, int port) Get/Set the value associated with this key in the given information object. V.Remove(vtkInformation, vtkExecutive, int) C++: void Remove(vtkInformation *info, vtkExecutive *executive, int port) V.Remove(vtkInformation) C++: void Remove(vtkInformation *info) override; Get/Set the value associated with this key in the given information object. V.GetPorts(vtkInformation) -> (int, ...) C++: int *GetPorts(vtkInformation *info) Get/Set the value associated with this key in the given information object. V.Length(vtkInformation) -> int C++: int Length(vtkInformation *info) Get/Set the value associated with this key in the given information object. StoreMetaDataNeedToExecutevtkInformationIntegerRequestKeyvtkInformationIntegerRequestKey - key that can used to request integer values from the pipeline vtkInformationIntegerRequestKey is a vtkInformationIntegerKey that can used to request integer values from upstream. Superclass: vtkInformationIntegerKey A good example of this is UPDATE_NUMBER_OF_PIECES where downstream can request that upstream provides data partitioned into a certain number of pieces. There are several components that make this work. First, the key will copy itself upstream during REQUEST_UPDATE_EXTENT. Second, after a successful execution, it will stor its value into a data object's information using a specific key defined by its data member DataKey. Third, before execution, it will check if the requested value matched the value in the data object's information. If not, it will ask the pipeline to execute. The best way to use this class is to subclass it to set the DataKey data member. This is usually done in the subclass' constructor. vtkCommonExecutionModelPython.vtkInformationIntegerRequestKeyV.SafeDownCast(vtkObjectBase) -> vtkInformationIntegerRequestKey C++: static vtkInformationIntegerRequestKey *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkInformationIntegerRequestKey C++: vtkInformationIntegerRequestKey *NewInstance() V.MakeKey(string, string) -> vtkInformationIntegerRequestKey C++: static vtkInformationIntegerRequestKey *MakeKey( const char *name, const char *location) This method simply returns a new vtkInformationIntegerRequestKey, given a name and a location. This method is provided for wrappers. Use the constructor directly from C++ instead. V.NeedToExecute(vtkInformation, vtkInformation) -> bool C++: bool NeedToExecute(vtkInformation *pipelineInfo, vtkInformation *dobjInfo) override; Returns true if a value of type DataKey does not exist in dobjInfo or if it is different that the value stored in pipelineInfo using this key. V.StoreMetaData(vtkInformation, vtkInformation, vtkInformation) C++: void StoreMetaData(vtkInformation *request, vtkInformation *pipelineInfo, vtkInformation *dobjInfo) override; Copies the value stored in pipelineInfo using this key into dobjInfo. V.CopyDefaultInformation(vtkInformation, vtkInformation, vtkInformation) C++: void CopyDefaultInformation(vtkInformation *request, vtkInformation *fromInfo, vtkInformation *toInfo) override; Copies the value stored in fromInfo using this key into toInfo if request has the REQUEST_UPDATE_EXTENT key. vtkInformationIntegerKeyvtkMultiBlockDataSetAlgorithmvtkMultiBlockDataSetAlgorithm - Superclass for algorithms that produce only vtkMultiBlockDataSet as output Superclass: vtkAlgorithm Algorithms that take any type of data object (including composite dataset) and produce a vtkMultiBlockDataSet in the output can subclass from this class. vtkCommonExecutionModelPython.vtkMultiBlockDataSetAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkMultiBlockDataSetAlgorithm C++: static vtkMultiBlockDataSetAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkMultiBlockDataSetAlgorithm C++: vtkMultiBlockDataSetAlgorithm *NewInstance() V.GetOutput() -> vtkMultiBlockDataSet C++: vtkMultiBlockDataSet *GetOutput() V.GetOutput(int) -> vtkMultiBlockDataSet C++: vtkMultiBlockDataSet *GetOutput(int) Get the output data object for a port on this algorithm. vtkMultiTimeStepAlgorithmvtkMultiTimeStepAlgorithm - Superclass for algorithms that would like to make multiple time requests Superclass: vtkAlgorithm This class can be inherited by any algorithm that wishes to make multiple time requests upstream. The child class uses UPDATE_TIME_STEPS to make the time requests and use set of time-stamped data objects are stored in time order in a vtkMultiBlockDataSet object. vtkCommonExecutionModelPython.vtkMultiTimeStepAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkMultiTimeStepAlgorithm C++: static vtkMultiTimeStepAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkMultiTimeStepAlgorithm C++: vtkMultiTimeStepAlgorithm *NewInstance() vtkPassInputTypeAlgorithmGetTableOutputGetGraphOutputvtkPassInputTypeAlgorithm - Superclass for algorithms that produce output of the same type as input Superclass: vtkAlgorithm vtkPassInputTypeAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes contstructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be DataObject. If that isn't the case then please override this method in your subclass. This class breaks out the downstream requests into separate functions such as RequestDataObject RequestData and RequestInformation. The default implementation of RequestDataObject will create an output data of the same type as the input. vtkCommonExecutionModelPython.vtkPassInputTypeAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkPassInputTypeAlgorithm C++: static vtkPassInputTypeAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkPassInputTypeAlgorithm C++: vtkPassInputTypeAlgorithm *NewInstance() V.GetTableOutput() -> vtkTable C++: vtkTable *GetTableOutput() Get the output as vtkTable. V.GetGraphOutput() -> vtkGraph C++: vtkGraph *GetGraphOutput() Get the output as vtkGraph. V.AddInputData(vtkDataObject) C++: void AddInputData(vtkDataObject *) V.AddInputData(int, vtkDataObject) C++: void AddInputData(int, vtkDataObject *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use SetInputConnection() to setup a pipeline connection. vtkPiecewiseFunctionAlgorithmvtkPiecewiseFunctionAlgorithm - Superclass for algorithms that produce only piecewise function as output Superclass: vtkAlgorithm vtkPiecewiseFunctionAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be PiecewiseFunction. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). vtkCommonExecutionModelPython.vtkPiecewiseFunctionAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkPiecewiseFunctionAlgorithm C++: static vtkPiecewiseFunctionAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkPiecewiseFunctionAlgorithm C++: vtkPiecewiseFunctionAlgorithm *NewInstance() GetValueScaleGetValueShiftGetPositionScaleGetPositionShiftSetValueShiftSetValueScaleSetPositionShiftSetPositionScalevtkPiecewiseFunctionShiftScalevtkPiecewiseFunctionShiftScale - Superclass: vtkPiecewiseFunctionAlgorithm vtkCommonExecutionModelPython.vtkPiecewiseFunctionShiftScaleV.SafeDownCast(vtkObjectBase) -> vtkPiecewiseFunctionShiftScale C++: static vtkPiecewiseFunctionShiftScale *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkPiecewiseFunctionShiftScale C++: vtkPiecewiseFunctionShiftScale *NewInstance() V.SetPositionShift(float) C++: virtual void SetPositionShift(double _arg) V.SetPositionScale(float) C++: virtual void SetPositionScale(double _arg) V.SetValueShift(float) C++: virtual void SetValueShift(double _arg) V.SetValueScale(float) C++: virtual void SetValueScale(double _arg) V.GetPositionShift() -> float C++: virtual double GetPositionShift() V.GetPositionScale() -> float C++: virtual double GetPositionScale() V.GetValueShift() -> float C++: virtual double GetValueShift() V.GetValueScale() -> float C++: virtual double GetValueScale() vtkPointSetAlgorithm@V *vtkPointSet@iV *vtkPointSetvtkPointSetAlgorithm - Superclass for algorithms that produce output of the same type as input Superclass: vtkAlgorithm vtkPointSetAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes contstructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be PointSet. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). vtkCommonExecutionModelPython.vtkPointSetAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkPointSetAlgorithm C++: static vtkPointSetAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkPointSetAlgorithm C++: vtkPointSetAlgorithm *NewInstance() V.GetOutput() -> vtkPointSet C++: vtkPointSet *GetOutput() V.GetOutput(int) -> vtkPointSet C++: vtkPointSet *GetOutput(int) Get the output data object for a port on this algorithm. V.SetInputData(vtkDataObject) C++: void SetInputData(vtkDataObject *) V.SetInputData(int, vtkDataObject) C++: void SetInputData(int, vtkDataObject *) V.SetInputData(vtkPointSet) C++: void SetInputData(vtkPointSet *) V.SetInputData(int, vtkPointSet) C++: void SetInputData(int, vtkPointSet *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use SetInputConnection() to setup a pipeline connection. V.AddInputData(vtkDataObject) C++: void AddInputData(vtkDataObject *) V.AddInputData(vtkPointSet) C++: void AddInputData(vtkPointSet *) V.AddInputData(int, vtkPointSet) C++: void AddInputData(int, vtkPointSet *) V.AddInputData(int, vtkDataObject) C++: void AddInputData(int, vtkDataObject *) Assign a data object as input. Note that this method does not establish a pipeline connection. Use AddInputConnection() to setup a pipeline connection. vtkPolyDataAlgorithmGetPolyDataInputvtkPolyDataAlgorithm - Superclass for algorithms that produce only polydata as output Superclass: vtkAlgorithm vtkPolyDataAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be PolyData. If that isn't the case then please override this method in your subclass. vtkCommonExecutionModelPython.vtkPolyDataAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkPolyDataAlgorithm C++: static vtkPolyDataAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkPolyDataAlgorithm C++: vtkPolyDataAlgorithm *NewInstance() V.GetOutput() -> vtkPolyData C++: vtkPolyData *GetOutput() V.GetOutput(int) -> vtkPolyData C++: vtkPolyData *GetOutput(int) Get the output data object for a port on this algorithm. V.GetPolyDataInput(int) -> vtkPolyData C++: vtkPolyData *GetPolyDataInput(int port) vtkRectilinearGridAlgorithmGetRectilinearGridInputvtkRectilinearGridAlgorithm - Superclass for algorithms that produce only rectilinear grid as output Superclass: vtkAlgorithm vtkRectilinearGridAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be RectilinearGrid. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). vtkCommonExecutionModelPython.vtkRectilinearGridAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkRectilinearGridAlgorithm C++: static vtkRectilinearGridAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkRectilinearGridAlgorithm C++: vtkRectilinearGridAlgorithm *NewInstance() V.GetOutput() -> vtkRectilinearGrid C++: vtkRectilinearGrid *GetOutput() V.GetOutput(int) -> vtkRectilinearGrid C++: vtkRectilinearGrid *GetOutput(int) Get the output data object for a port on this algorithm. V.GetRectilinearGridInput(int) -> vtkRectilinearGrid C++: vtkRectilinearGrid *GetRectilinearGridInput(int port) vtkScalarTreeGetScalarValueBuildTreeInitializeGetNumberOfCellBatchesGetDataSetGetScalarsInitTraversalGetCellBatchSetScalarsvtkDataArraySetDataSetvtkScalarTree - organize data according to scalar values (used to accelerate contouring operations) Superclass: vtkObject vtkScalarTree is an abstract class that defines the API to concrete scalar tree subclasses. A scalar tree is a data structure that organizes data according to its scalar value. This allows rapid access to data for those algorithms that access the data based on scalar value. For example, isocontouring operates on cells based on the scalar (isocontour) value. To use subclasses of this class, you must specify a dataset to operate on, and then specify a scalar value in the InitTraversal() method. Then calls to GetNextCell() return cells whose scalar data contains the scalar value specified. (This describes serial traversal.) Methods supporting parallel traversal (such as threading) are also supported. Basically thread-safe batches of cells (which are a portion of the whole dataset) are available for processing using a parallel For() operation. First request the number of batches, and then for each batch, retrieve the array of cell ids in that batch. These batches contain cell ids that are likely to contain the isosurface. @sa vtkSimpleScalarTree vtkSpanSpace vtkCommonExecutionModelPython.vtkScalarTreeV.SafeDownCast(vtkObjectBase) -> vtkScalarTree C++: static vtkScalarTree *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkScalarTree C++: vtkScalarTree *NewInstance() V.SetDataSet(vtkDataSet) C++: virtual void SetDataSet(vtkDataSet *) Build the tree from the points/cells and scalars defining this dataset. V.GetDataSet() -> vtkDataSet C++: virtual vtkDataSet *GetDataSet() Build the tree from the points/cells and scalars defining this dataset. V.SetScalars(vtkDataArray) C++: virtual void SetScalars(vtkDataArray *) Build the tree from the points/cells and scalars defining the dataset and scalars provided. Typically the scalars come from the vtkDataSet specified, but sometimes a separate vtkDataArray is provided to specify the scalars. If the scalar array is explicitly set, then it takes precedence over the scalars held in the vtkDataSet. V.GetScalars() -> vtkDataArray C++: virtual vtkDataArray *GetScalars() Build the tree from the points/cells and scalars defining the dataset and scalars provided. Typically the scalars come from the vtkDataSet specified, but sometimes a separate vtkDataArray is provided to specify the scalars. If the scalar array is explicitly set, then it takes precedence over the scalars held in the vtkDataSet. V.BuildTree() C++: virtual void BuildTree() Construct the scalar tree from the dataset provided. Checks build times and modified time from input and reconstructs the tree if necessary. V.Initialize() C++: virtual void Initialize() Initialize locator. Frees memory and resets object as appropriate. V.InitTraversal(float) C++: virtual void InitTraversal(double scalarValue) Begin to traverse the cells based on a scalar value. Returned cells will have scalar values that span the scalar value specified. Note that changing the scalarValue does not cause the scalar tree to be modified, and hence it does not rebuild. V.GetScalarValue() -> float C++: double GetScalarValue() Return the current scalar value over which tree traversal is proceeding. This is the scalar value provided in InitTraversal(). V.GetNumberOfCellBatches() -> int C++: virtual vtkIdType GetNumberOfCellBatches() Get the number of cell batches available for processing. Note that this methods should be called after InitTraversal(). This is because the number of batches available is typically a function of the isocontour value. Note that the cells found in [0...(NumberOfCellBatches-1)] will contain all the cells potentially containing the isocontour. V.GetCellBatch(int, int) -> (int, ...) C++: virtual const vtkIdType *GetCellBatch(vtkIdType batchNum, vtkIdType &numCells) Return the array of cell ids in the specified batch. The method also returns the number of cell ids in the array. Make sure to call InitTraversal() beforehand. vtkSimpleImageToImageFiltervtkSimpleImageToImageFilter - Generic image filter with one input. Superclass: vtkImageAlgorithm vtkSimpleImageToImageFilter is a filter which aims to avoid much of the complexity associated with vtkImageAlgorithm (i.e. support for pieces, multi-threaded operation). If you need to write a simple image-image filter which operates on the whole input, use this as the superclass. The subclass has to provide only an execute method which takes input and output as arguments. Memory allocation is handled in vtkSimpleImageToImageFilter. Also, you are guaranteed to have a valid input in the Execute(input, output) method. By default, this filter requests it's input's whole extent and copies the input's information (spacing, whole extent etc...) to the output. If the output's setup is different (for example, if it performs some sort of sub-sampling), ExecuteInformation has to be overwritten. As an example of how this can be done, you can look at vtkImageShrink3D::ExecuteInformation. For a complete example which uses templates to support generic data types, see vtkSimpleImageToImageFilter. @sa vtkImageAlgorithm vtkSimpleImageFilterExample vtkCommonExecutionModelPython.vtkSimpleImageToImageFilterV.SafeDownCast(vtkObjectBase) -> vtkSimpleImageToImageFilter C++: static vtkSimpleImageToImageFilter *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkSimpleImageToImageFilter C++: vtkSimpleImageToImageFilter *NewInstance() vtkSimpleScalarTreeGetMaxLevelMinValueGetBranchingFactorMinValueGetMaxLevelMaxValueGetBranchingFactorMaxValueGetBranchingFactorGetMaxLevelGetLevelSetBranchingFactorSetMaxLevelvtkSimpleScalarTree - organize data according to scalar values (used to accelerate contouring operations) Superclass: vtkScalarTree vtkSimpleScalarTree creates a pointerless binary tree that helps search for cells that lie within a particular scalar range. This object is used to accelerate some contouring (and other scalar-based techniques). The tree consists of an array of (min,max) scalar range pairs per node in the tree. The (min,max) range is determined from looking at the range of the children of the tree node. If the node is a leaf, then the range is determined by scanning the range of scalar data in n cells in the dataset. The n cells are determined by arbitrary selecting cell ids from id(i) to id(i+n), and where n is specified using the BranchingFactor ivar. Note that leaf node i=0 contains the scalar range computed from cell ids (0,n-1); leaf node i=1 contains the range from cell ids (n,2n-1); and so on. The implication is that there are no direct lists of cell ids per leaf node, instead the cell ids are implicitly known. Despite the arbitrary grouping of cells, in practice this scalar tree actually performs quite well due to spatial/data coherence. This class has an API that supports both serial and parallel operation. The parallel API enables the using class to grab arrays (or batches) of cells that potentially intersect the isocontour. These batches can then be processed in separate threads. @sa vtkSpanSpace vtkCommonExecutionModelPython.vtkSimpleScalarTreeV.IsTypeOf(string) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Standard type related macros and PrintSelf() method. V.IsA(string) -> int C++: vtkTypeBool IsA(const char *type) override; Standard type related macros and PrintSelf() method. V.SafeDownCast(vtkObjectBase) -> vtkSimpleScalarTree C++: static vtkSimpleScalarTree *SafeDownCast(vtkObjectBase *o) Standard type related macros and PrintSelf() method. V.NewInstance() -> vtkSimpleScalarTree C++: vtkSimpleScalarTree *NewInstance() Standard type related macros and PrintSelf() method. V.SetBranchingFactor(int) C++: virtual void SetBranchingFactor(int _arg) Set the branching factor for the tree. This is the number of children per tree node. Smaller values (minimum is 2) mean deeper trees and more memory overhead. Larger values mean shallower trees, less memory usage, but worse performance. V.GetBranchingFactorMinValue() -> int C++: virtual int GetBranchingFactorMinValue() Set the branching factor for the tree. This is the number of children per tree node. Smaller values (minimum is 2) mean deeper trees and more memory overhead. Larger values mean shallower trees, less memory usage, but worse performance. V.GetBranchingFactorMaxValue() -> int C++: virtual int GetBranchingFactorMaxValue() Set the branching factor for the tree. This is the number of children per tree node. Smaller values (minimum is 2) mean deeper trees and more memory overhead. Larger values mean shallower trees, less memory usage, but worse performance. V.GetBranchingFactor() -> int C++: virtual int GetBranchingFactor() Set the branching factor for the tree. This is the number of children per tree node. Smaller values (minimum is 2) mean deeper trees and more memory overhead. Larger values mean shallower trees, less memory usage, but worse performance. V.GetLevel() -> int C++: virtual int GetLevel() Get the level of the scalar tree. This value may change each time the scalar tree is built and the branching factor changes. V.SetMaxLevel(int) C++: virtual void SetMaxLevel(int _arg) Set the maximum allowable level for the tree. V.GetMaxLevelMinValue() -> int C++: virtual int GetMaxLevelMinValue() Set the maximum allowable level for the tree. V.GetMaxLevelMaxValue() -> int C++: virtual int GetMaxLevelMaxValue() Set the maximum allowable level for the tree. V.GetMaxLevel() -> int C++: virtual int GetMaxLevel() Set the maximum allowable level for the tree. V.BuildTree() C++: void BuildTree() override; Construct the scalar tree from the dataset provided. Checks build times and modified time from input and reconstructs the tree if necessary. V.Initialize() C++: void Initialize() override; Initialize locator. Frees memory and resets object as appropriate. V.InitTraversal(float) C++: void InitTraversal(double scalarValue) override; Begin to traverse the cells based on a scalar value. Returned cells will likely have scalar values that span the scalar value specified. V.GetNumberOfCellBatches() -> int C++: vtkIdType GetNumberOfCellBatches() override; Get the number of cell batches available for processing. Note that this methods should be called after InitTraversal(). This is because the number of batches available is typically a function of the isocontour value. Note that the cells found in [0...(NumberOfCellBatches-1)] will contain all the cells potentially containing the isocontour. V.GetCellBatch(int, int) -> (int, ...) C++: const vtkIdType *GetCellBatch(vtkIdType batchNum, vtkIdType &numCells) override; Return the array of cell ids in the specified batch. The method also returns the number of cell ids in the array. Make sure to call InitTraversal() beforehand. vtkSpanSpaceGetResolutionMaxValueGetResolutionMinValueGetResolutionSetResolutionvtkSpanSpace - organize data according to scalar span space Superclass: vtkScalarTree This is a helper class used to accelerate contouring operations. Given an dataset, it organizes the dataset cells into a 2D binned space, with axes (scalar_min,scalar_max). This so-called span space can then be traversed quickly to find the cells that intersect a particular contour value. This class has an API that supports both serial and parallel operation. The parallel API enables the using class to grab arrays (or batches) of cells that lie along a particular row in the span space. These arrays can then be processed separately in parallel. Learn more about span space in these two publications: 1) "A Near Optimal Isosorface Extraction Algorithm Using the Spsn Space." Yarden Livnat et al. and 2) Isosurfacing in SPan Space with Utmost Efficiency." Han-Wei Shen et al. @sa vtkSimpleScalarTree vtkCommonExecutionModelPython.vtkSpanSpaceV.SafeDownCast(vtkObjectBase) -> vtkSpanSpace C++: static vtkSpanSpace *SafeDownCast(vtkObjectBase *o) Standard type related macros and PrintSelf() method. V.NewInstance() -> vtkSpanSpace C++: vtkSpanSpace *NewInstance() Standard type related macros and PrintSelf() method. V.SetResolution(int) C++: virtual void SetResolution(vtkIdType _arg) Set/Get the resolution N of the span space. The span space can be envisioned as a rectangular lattice of NXN buckets (i.e., N rows and N columns), where each bucket stores a list of cell ids. The i-j coordinate of each cell (hence its location in the lattice) is determined from the cell's 2-tuple (smin,smax) scalar range. By default Resolution = 100. V.GetResolutionMinValue() -> int C++: virtual vtkIdType GetResolutionMinValue() Set/Get the resolution N of the span space. The span space can be envisioned as a rectangular lattice of NXN buckets (i.e., N rows and N columns), where each bucket stores a list of cell ids. The i-j coordinate of each cell (hence its location in the lattice) is determined from the cell's 2-tuple (smin,smax) scalar range. By default Resolution = 100. V.GetResolutionMaxValue() -> int C++: virtual vtkIdType GetResolutionMaxValue() Set/Get the resolution N of the span space. The span space can be envisioned as a rectangular lattice of NXN buckets (i.e., N rows and N columns), where each bucket stores a list of cell ids. The i-j coordinate of each cell (hence its location in the lattice) is determined from the cell's 2-tuple (smin,smax) scalar range. By default Resolution = 100. V.GetResolution() -> int C++: virtual vtkIdType GetResolution() Set/Get the resolution N of the span space. The span space can be envisioned as a rectangular lattice of NXN buckets (i.e., N rows and N columns), where each bucket stores a list of cell ids. The i-j coordinate of each cell (hence its location in the lattice) is determined from the cell's 2-tuple (smin,smax) scalar range. By default Resolution = 100. V.InitTraversal(float) C++: void InitTraversal(double scalarValue) override; Begin to traverse the cells based on a scalar value. Returned cells will have scalar values that span the scalar value specified. Note this method must be called prior to parallel or serial traversal since it specifies the scalar value to be extracted. vtkSphereTreeSelectPlaneSelectLineSelectPointGetNumberOfLevelsGetBuildHierarchyGetCellSpheresBuildHierarchyOffBuildHierarchyOnSetBuildHierarchyGetTreeSpheresBuildVTK_MAX_SPHERE_TREE_LEVELS@PPk *d *d@PPV *d *d *vtkIdList@Pk *d@PV *d *vtkIdListVTK_MAX_SPHERE_TREE_RESOLUTIONvtkSphereTree - class to build and traverse sphere trees Superclass: vtkObject vtkSphereTree is a helper class used to build and traverse sphere trees. Various types of trees can be constructed for different VTK dataset types, as well well as different approaches to organize the tree into hierarchies. Typically building a complete sphere tree consists of two parts: 1) creating spheres for each cell in the dataset, then 2) creating an organizing hierarchy. The structure of the hierarchy varies depending on the topological characteristics of the dataset. Once the tree is constructed, various geometric operations are available for quickly selecting cells based on sphere tree operations; for example, process all cells intersecting a plane (i.e., use the sphere tree to identify candidate cells for plane intersection). This class does not necessarily create optimal sphere trees because some of its requirements (fast build time, provide simple reference code, a single bounding sphere per cell, etc.) precludes optimal performance. It is also oriented to computing on cells versus the classic problem of collision detection for polygonal models. For more information you want to read Gareth Bradshaw's PhD thesis "Bounding Volume Hierarchies for Level-of-Detail Collision Handling" which does a nice job of laying out the challenges and important algorithms relative to sphere trees and BVH (bounding volume hierarchies). @sa vtkSphereTreeFilter vtkPlaneCutter vtkCommonExecutionModelPython.vtkSphereTreeV.SafeDownCast(vtkObjectBase) -> vtkSphereTree C++: static vtkSphereTree *SafeDownCast(vtkObjectBase *o) Standard type related macros and PrintSelf() method. V.NewInstance() -> vtkSphereTree C++: vtkSphereTree *NewInstance() Standard type related macros and PrintSelf() method. V.SetDataSet(vtkDataSet) C++: virtual void SetDataSet(vtkDataSet *) Specify the dataset from which to build the sphere tree. V.GetDataSet() -> vtkDataSet C++: virtual vtkDataSet *GetDataSet() Specify the dataset from which to build the sphere tree. V.Build() C++: void Build() V.Build(vtkDataSet) C++: void Build(vtkDataSet *input) Build the sphere tree (if necessary) from the data set specified. The build time is recorded so the sphere tree will only build if something has changed. An alternative method is available to both set the dataset and then build the sphere tree. V.SetBuildHierarchy(bool) C++: virtual void SetBuildHierarchy(bool _arg) Control whether the tree hierarchy is built. If not, then just cell spheres are created (one for each cell). V.GetBuildHierarchy() -> bool C++: virtual bool GetBuildHierarchy() Control whether the tree hierarchy is built. If not, then just cell spheres are created (one for each cell). V.BuildHierarchyOn() C++: virtual void BuildHierarchyOn() Control whether the tree hierarchy is built. If not, then just cell spheres are created (one for each cell). V.BuildHierarchyOff() C++: virtual void BuildHierarchyOff() Control whether the tree hierarchy is built. If not, then just cell spheres are created (one for each cell). V.SelectPoint([float, float, float], int) -> (int, ...) C++: const unsigned char *SelectPoint(double point[3], vtkIdType &numSelected) V.SelectPoint([float, float, float], vtkIdList) C++: void SelectPoint(double point[3], vtkIdList *cellIds) Methods for cell selection based on a geometric query. Internally different methods are used depending on the dataset type. The array returned is set to non-zero for each cell that intersects the geometric entity. SelectPoint marks all cells with a non-zero value that may contain a point. SelectLine marks all cells that may intersect an infinite line. SelectPlane marks all cells that may intersect with an infinite plane. V.SelectLine([float, float, float], [float, float, float], int) -> (int, ...) C++: const unsigned char *SelectLine(double origin[3], double ray[3], vtkIdType &numSelected) V.SelectLine([float, float, float], [float, float, float], vtkIdList) C++: void SelectLine(double origin[3], double ray[3], vtkIdList *cellIds) Methods for cell selection based on a geometric query. Internally different methods are used depending on the dataset type. The array returned is set to non-zero for each cell that intersects the geometric entity. SelectPoint marks all cells with a non-zero value that may contain a point. SelectLine marks all cells that may intersect an infinite line. SelectPlane marks all cells that may intersect with an infinite plane. V.SelectPlane([float, float, float], [float, float, float], int) -> (int, ...) C++: const unsigned char *SelectPlane(double origin[3], double normal[3], vtkIdType &numSelected) V.SelectPlane([float, float, float], [float, float, float], vtkIdList) C++: void SelectPlane(double origin[3], double normal[3], vtkIdList *cellIds) Methods for cell selection based on a geometric query. Internally different methods are used depending on the dataset type. The array returned is set to non-zero for each cell that intersects the geometric entity. SelectPoint marks all cells with a non-zero value that may contain a point. SelectLine marks all cells that may intersect an infinite line. SelectPlane marks all cells that may intersect with an infinite plane. V.SetResolution(int) C++: virtual void SetResolution(int _arg) Sphere tree creation requires gathering spheres into groups. The Resolution variable is a rough guide to the size of each group (the size different meanings depending on the type of data (structured versus unstructured). For example, in 3D structured data, blocks of resolution Resolution^3 are created. By default the Resolution is three. V.GetResolutionMinValue() -> int C++: virtual int GetResolutionMinValue() Sphere tree creation requires gathering spheres into groups. The Resolution variable is a rough guide to the size of each group (the size different meanings depending on the type of data (structured versus unstructured). For example, in 3D structured data, blocks of resolution Resolution^3 are created. By default the Resolution is three. V.GetResolutionMaxValue() -> int C++: virtual int GetResolutionMaxValue() Sphere tree creation requires gathering spheres into groups. The Resolution variable is a rough guide to the size of each group (the size different meanings depending on the type of data (structured versus unstructured). For example, in 3D structured data, blocks of resolution Resolution^3 are created. By default the Resolution is three. V.GetResolution() -> int C++: virtual int GetResolution() Sphere tree creation requires gathering spheres into groups. The Resolution variable is a rough guide to the size of each group (the size different meanings depending on the type of data (structured versus unstructured). For example, in 3D structured data, blocks of resolution Resolution^3 are created. By default the Resolution is three. V.SetMaxLevel(int) C++: virtual void SetMaxLevel(int _arg) Specify the maximum number of levels for the tree. By default, the number of levels is set to ten. If the number of levels is set to one or less, then no hierarchy is built (i.e., just the spheres for each cell are created). Note that the actual level of the tree may be less than this value depending on the number of cells and Resolution factor. V.GetMaxLevelMinValue() -> int C++: virtual int GetMaxLevelMinValue() Specify the maximum number of levels for the tree. By default, the number of levels is set to ten. If the number of levels is set to one or less, then no hierarchy is built (i.e., just the spheres for each cell are created). Note that the actual level of the tree may be less than this value depending on the number of cells and Resolution factor. V.GetMaxLevelMaxValue() -> int C++: virtual int GetMaxLevelMaxValue() Specify the maximum number of levels for the tree. By default, the number of levels is set to ten. If the number of levels is set to one or less, then no hierarchy is built (i.e., just the spheres for each cell are created). Note that the actual level of the tree may be less than this value depending on the number of cells and Resolution factor. V.GetMaxLevel() -> int C++: virtual int GetMaxLevel() Specify the maximum number of levels for the tree. By default, the number of levels is set to ten. If the number of levels is set to one or less, then no hierarchy is built (i.e., just the spheres for each cell are created). Note that the actual level of the tree may be less than this value depending on the number of cells and Resolution factor. V.GetNumberOfLevels() -> int C++: virtual int GetNumberOfLevels() Get the current depth of the sphere tree. This value may change each time the sphere tree is built and the branching factor (i.e., resolution) changes. Note that after building the sphere tree there are [0,this->NumberOfLevels) defined levels. V.GetCellSpheres() -> (float, ...) C++: const double *GetCellSpheres() Special methods to retrieve the sphere tree data. This is generally used for debugging or with filters like vtkSphereTreeFilter. Both methods return an array of double* where four doubles represent a sphere (center + radius). In the first method a sphere per cell is returned. In the second method the user must also specify a level in the sphere tree (used to retrieve the hierarchy of the tree). Note that null pointers can be returned if the request is not consistent with the state of the sphere tree. V.GetTreeSpheres(int, int) -> (float, ...) C++: const double *GetTreeSpheres(int level, vtkIdType &numSpheres) Special methods to retrieve the sphere tree data. This is generally used for debugging or with filters like vtkSphereTreeFilter. Both methods return an array of double* where four doubles represent a sphere (center + radius). In the first method a sphere per cell is returned. In the second method the user must also specify a level in the sphere tree (used to retrieve the hierarchy of the tree). Note that null pointers can be returned if the request is not consistent with the state of the sphere tree. BOUNDSTIME_DEPENDENT_INFORMATIONUPDATE_TIME_STEPTIME_RANGETIME_STEPSEXACT_EXTENTUNRESTRICTED_UPDATE_EXTENTWHOLE_EXTENTCOMBINED_UPDATE_EXTENTUPDATE_NUMBER_OF_GHOST_LEVELSUPDATE_NUMBER_OF_PIECESUPDATE_PIECE_NUMBERUPDATE_EXTENT_INITIALIZEDCONTINUE_EXECUTINGREQUEST_UPDATE_TIMEREQUEST_UPDATE_EXTENTPropagateTimeGetRequestExactExtentSetRequestExactExtentVTK_UPDATE_EXTENT_COMBINEVTK_UPDATE_EXTENT_REPLACEREQUEST_TIME_DEPENDENT_INFORMATIONUpdateTimeDependentInformationvtkStreamingDemandDrivenPipeline - Executive supporting partial updates. Superclass: vtkDemandDrivenPipeline vtkStreamingDemandDrivenPipeline is an executive that supports updating only a portion of the data set in the pipeline. This is the style of pipeline update that is provided by the old-style VTK 4.x pipeline. Instead of always updating an entire data set, this executive supports asking for pieces or sub-extents. vtkCommonExecutionModelPython.vtkStreamingDemandDrivenPipelineV.SafeDownCast(vtkObjectBase) -> vtkStreamingDemandDrivenPipeline C++: static vtkStreamingDemandDrivenPipeline *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkStreamingDemandDrivenPipeline C++: vtkStreamingDemandDrivenPipeline *NewInstance() V.Update() -> int C++: int Update() override; V.Update(int) -> int C++: int Update(int port) override; V.Update(int, vtkInformationVector) -> int C++: virtual int Update(int port, vtkInformationVector *requests) Bring the outputs up-to-date. V.UpdateWholeExtent() -> int C++: virtual int UpdateWholeExtent() Bring the outputs up-to-date. V.PropagateUpdateExtent(int) -> int C++: int PropagateUpdateExtent(int outputPort) Propagate the update request from the given output port back through the pipeline. Should be called only when information is up to date. V.PropagateTime(int) -> int C++: int PropagateTime(int outputPort) Propagate time through the pipeline. this is a special pass only necessary if there is temporal meta data that must be updated V.UpdateTimeDependentInformation(int) -> int C++: int UpdateTimeDependentInformation(int outputPort) Propagate time through the pipeline. this is a special pass only necessary if there is temporal meta data that must be updated V.SetWholeExtent(vtkInformation, [int, int, int, int, int, int]) -> int C++: static int SetWholeExtent(vtkInformation *, int extent[6]) Set/Get the whole extent of an output port. The whole extent is meta data for structured data sets. It gets set by the algorithm during the update information pass. V.GetWholeExtent(vtkInformation, [int, int, int, int, int, int]) C++: static void GetWholeExtent(vtkInformation *, int extent[6]) V.GetWholeExtent(vtkInformation) -> (int, int, int, int, int, int) C++: static int *GetWholeExtent(vtkInformation *) Set/Get the whole extent of an output port. The whole extent is meta data for structured data sets. It gets set by the algorithm during the update information pass. V.SetRequestExactExtent(int, int) -> int C++: int SetRequestExactExtent(int port, int flag) This request flag indicates whether the requester can handle more data than requested for the given port. Right now it is used in vtkImageData. Image filters can return more data than requested. The the consumer cannot handle this (i.e. DataSetToDataSetFitler) the image will crop itself. This functionality used to be in ImageToStructuredPoints. V.GetRequestExactExtent(int) -> int C++: int GetRequestExactExtent(int port) This request flag indicates whether the requester can handle more data than requested for the given port. Right now it is used in vtkImageData. Image filters can return more data than requested. The the consumer cannot handle this (i.e. DataSetToDataSetFitler) the image will crop itself. This functionality used to be in ImageToStructuredPoints. V.REQUEST_UPDATE_EXTENT() -> vtkInformationRequestKey C++: static vtkInformationRequestKey *REQUEST_UPDATE_EXTENT() Key defining a request to propagate the update extent upstream.\ingroup InformationKeys V.REQUEST_UPDATE_TIME() -> vtkInformationRequestKey C++: static vtkInformationRequestKey *REQUEST_UPDATE_TIME() Key defining a request to propagate the update extent upstream.\ingroup InformationKeys V.REQUEST_TIME_DEPENDENT_INFORMATION() -> vtkInformationRequestKey C++: static vtkInformationRequestKey *REQUEST_TIME_DEPENDENT_INFORMATION( ) Key defining a request to make sure the meta information is up to date.\ingroup InformationKeys V.CONTINUE_EXECUTING() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *CONTINUE_EXECUTING() Key for an algorithm to store in a request to tell this executive to keep executing it.\ingroup InformationKeys V.UPDATE_EXTENT_INITIALIZED() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *UPDATE_EXTENT_INITIALIZED() Keys to store an update request in pipeline information.\ingroup InformationKeys V.UPDATE_EXTENT() -> vtkInformationIntegerVectorKey C++: static vtkInformationIntegerVectorKey *UPDATE_EXTENT() \ingroup InformationKeys V.UPDATE_PIECE_NUMBER() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *UPDATE_PIECE_NUMBER() \ingroup InformationKeys V.UPDATE_NUMBER_OF_PIECES() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *UPDATE_NUMBER_OF_PIECES() \ingroup InformationKeys V.UPDATE_NUMBER_OF_GHOST_LEVELS() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *UPDATE_NUMBER_OF_GHOST_LEVELS( ) \ingroup InformationKeys V.COMBINED_UPDATE_EXTENT() -> vtkInformationIntegerVectorKey C++: static vtkInformationIntegerVectorKey *COMBINED_UPDATE_EXTENT( ) Key for combining the update extents requested by all consumers, so that the final extent that is produced satisfies all consumers.\ingroup InformationKeys V.WHOLE_EXTENT() -> vtkInformationIntegerVectorKey C++: static vtkInformationIntegerVectorKey *WHOLE_EXTENT() Key to store the whole extent provided in pipeline information.\ingroup InformationKeys V.UNRESTRICTED_UPDATE_EXTENT() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *UNRESTRICTED_UPDATE_EXTENT() This is set if the update extent is not restricted to the whole extent, for sources that can generate an extent of any requested size.\ingroup InformationKeys V.EXACT_EXTENT() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *EXACT_EXTENT() Key to specify the request for exact extent in pipeline information.\ingroup InformationKeys V.TIME_STEPS() -> vtkInformationDoubleVectorKey C++: static vtkInformationDoubleVectorKey *TIME_STEPS() Key to store available time steps.\ingroup InformationKeys V.TIME_RANGE() -> vtkInformationDoubleVectorKey C++: static vtkInformationDoubleVectorKey *TIME_RANGE() Key to store available time range for continuous sources.\ingroup InformationKeys V.UPDATE_TIME_STEP() -> vtkInformationDoubleKey C++: static vtkInformationDoubleKey *UPDATE_TIME_STEP() Update time steps requested by the pipeline.\ingroup InformationKeys V.TIME_DEPENDENT_INFORMATION() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *TIME_DEPENDENT_INFORMATION() Whether there are time dependent meta information if there is, the pipeline will perform two extra passes to gather the time dependent information\ingroup InformationKeys V.BOUNDS() -> vtkInformationDoubleVectorKey C++: static vtkInformationDoubleVectorKey *BOUNDS() key to record the bounds of a dataset.\ingroup InformationKeys V.GetUpdateExtent(vtkInformation, [int, int, int, int, int, int]) C++: static void GetUpdateExtent(vtkInformation *, int extent[6]) V.GetUpdateExtent(vtkInformation) -> (int, ...) C++: static int *GetUpdateExtent(vtkInformation *) Get/Set the update extent for output ports that use 3D extents. V.GetUpdatePiece(vtkInformation) -> int C++: static int GetUpdatePiece(vtkInformation *) Set/Get the update piece, update number of pieces, and update number of ghost levels for an output port. Similar to update extent in 3D. V.GetUpdateNumberOfPieces(vtkInformation) -> int C++: static int GetUpdateNumberOfPieces(vtkInformation *) Set/Get the update piece, update number of pieces, and update number of ghost levels for an output port. Similar to update extent in 3D. V.GetUpdateGhostLevel(vtkInformation) -> int C++: static int GetUpdateGhostLevel(vtkInformation *) Set/Get the update piece, update number of pieces, and update number of ghost levels for an output port. Similar to update extent in 3D. GetStructuredGridInputvtkStructuredGridAlgorithm - Superclass for algorithms that produce only structured grid as output Superclass: vtkAlgorithm vtkStructuredGridAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be StructuredGrid. If that isn't the case then please override this method in your subclass. vtkCommonExecutionModelPython.vtkStructuredGridAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkStructuredGridAlgorithm C++: static vtkStructuredGridAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkStructuredGridAlgorithm C++: vtkStructuredGridAlgorithm *NewInstance() V.GetOutput() -> vtkStructuredGrid C++: vtkStructuredGrid *GetOutput() V.GetOutput(int) -> vtkStructuredGrid C++: vtkStructuredGrid *GetOutput(int) Get the output data object for a port on this algorithm. V.GetStructuredGridInput(int) -> vtkStructuredGrid C++: vtkStructuredGrid *GetStructuredGridInput(int port) vtkTableAlgorithmvtkTableAlgorithm - Superclass for algorithms that produce only vtkTables as output Superclass: vtkAlgorithm vtkTableAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be Tree. If that isn't the case then please override this method in your subclass. @par Thanks: Thanks to Brian Wylie for creating this class. vtkCommonExecutionModelPython.vtkTableAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkTableAlgorithm C++: static vtkTableAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkTableAlgorithm C++: vtkTableAlgorithm *NewInstance() V.GetOutput() -> vtkTable C++: vtkTable *GetOutput() V.GetOutput(int) -> vtkTable C++: vtkTable *GetOutput(int index) Get the output data object for a port on this algorithm. vtkSMPProgressObserverGetLocalObservervtkSMPProgressObserver - Progress observer that is thread safe Superclass: vtkProgressObserver vtkSMPProgressObserver is designed to handle progress events coming from an algorithm in a thread safe way. It does this by using thread local objects that it updates. To receive the progress information, one has to listen to the local observer in the same thread. Since the execution will be somewhat load balanced, it may be enough to do this only on the main thread. vtkCommonExecutionModelPython.vtkSMPProgressObserverV.SafeDownCast(vtkObjectBase) -> vtkSMPProgressObserver C++: static vtkSMPProgressObserver *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkSMPProgressObserver C++: vtkSMPProgressObserver *NewInstance() V.UpdateProgress(float) C++: void UpdateProgress(double amount) override; Passes the progress event to a thread local ProgressObserver instance. V.GetLocalObserver() -> vtkProgressObserver C++: vtkProgressObserver *GetLocalObserver() Returns the progress observer local to the thread it was called from. vtkThreadedCompositeDataPipelinevtkThreadedCompositeDataPipeline - Executive that works in parallel Superclass: vtkCompositeDataPipeline vtkThreadedCompositeDataPipeline processes a composite data object in parallel using the SMP framework. It does this by creating a vector of data objects (the pieces of the composite data) and processing them using vtkSMPTools::For. Note that this requires that the algorithm implement all pipeline passes in a re-entrant way. It should store/retrieve all state changes using input and output information objects, which are unique to each thread. vtkCommonExecutionModelPython.vtkThreadedCompositeDataPipelineV.SafeDownCast(vtkObjectBase) -> vtkThreadedCompositeDataPipeline C++: static vtkThreadedCompositeDataPipeline *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkThreadedCompositeDataPipeline C++: vtkThreadedCompositeDataPipeline *NewInstance() vtkThreadedImageAlgorithmSetGlobalDefaultEnableSMPGetGlobalDefaultEnableSMPGetNumberOfThreadsMaxValueGetNumberOfThreadsMinValueGetSplitModeMinValueGetSplitModeMaxValueGetMinimumPieceSizeGetDesiredBytesPerPieceGetNumberOfThreadsGetEnableSMPSetSplitModeToSlabSetSplitModeToBeamSetDesiredBytesPerPieceSetEnableSMPSetSplitModeSetNumberOfThreadsSetMinimumPieceSizeSplitExtentThreadedExecutevtkThreadedImageAlgorithm - Generic filter that has one input. Superclass: vtkImageAlgorithm vtkThreadedImageAlgorithm is a filter superclass that hides much of the pipeline complexity. It handles breaking the pipeline execution into smaller extents so that the vtkImageData limits are observed. It also provides support for multithreading. If you don't need any of this functionality, consider using vtkSimpleImageToImageAlgorithm instead. @sa vtkSimpleImageToImageAlgorithm vtkCommonExecutionModelPython.vtkThreadedImageAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkThreadedImageAlgorithm C++: static vtkThreadedImageAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkThreadedImageAlgorithm C++: vtkThreadedImageAlgorithm *NewInstance() V.ThreadedExecute(vtkImageData, vtkImageData, [int, int, int, int, int, int], int) C++: virtual void ThreadedExecute(vtkImageData *inData, vtkImageData *outData, int extent[6], int threadId) V.GetEnableSMP() -> bool C++: virtual bool GetEnableSMP() Enable/Disable SMP for threading. V.SetEnableSMP(bool) C++: virtual void SetEnableSMP(bool _arg) Enable/Disable SMP for threading. V.SetGlobalDefaultEnableSMP(bool) C++: static void SetGlobalDefaultEnableSMP(bool enable) Global Disable SMP for all derived Imaging filters. V.GetGlobalDefaultEnableSMP() -> bool C++: static bool GetGlobalDefaultEnableSMP() Global Disable SMP for all derived Imaging filters. V.SetMinimumPieceSize(int, int, int) C++: void SetMinimumPieceSize(int, int, int) V.SetMinimumPieceSize((int, int, int)) C++: void SetMinimumPieceSize(int a[3]) V.GetMinimumPieceSize() -> (int, int, int) C++: int *GetMinimumPieceSize() V.SetDesiredBytesPerPiece(int) C++: virtual void SetDesiredBytesPerPiece(vtkIdType _arg) The desired bytes per piece when volume is split for execution. When SMP is enabled, this is used to subdivide the volume into pieces. Smaller pieces allow for better dynamic load balancing, but increase the total overhead. The default is 65536 bytes. V.GetDesiredBytesPerPiece() -> int C++: virtual vtkIdType GetDesiredBytesPerPiece() The desired bytes per piece when volume is split for execution. When SMP is enabled, this is used to subdivide the volume into pieces. Smaller pieces allow for better dynamic load balancing, but increase the total overhead. The default is 65536 bytes. V.SetSplitMode(int) C++: virtual void SetSplitMode(int _arg) Set the method used to divide the volume into pieces. Slab mode splits the volume along the Z direction first, Beam mode splits evenly along the Z and Y directions, and Block mode splits evenly along all three directions. Most filters use Slab mode as the default. V.GetSplitModeMinValue() -> int C++: virtual int GetSplitModeMinValue() Set the method used to divide the volume into pieces. Slab mode splits the volume along the Z direction first, Beam mode splits evenly along the Z and Y directions, and Block mode splits evenly along all three directions. Most filters use Slab mode as the default. V.GetSplitModeMaxValue() -> int C++: virtual int GetSplitModeMaxValue() Set the method used to divide the volume into pieces. Slab mode splits the volume along the Z direction first, Beam mode splits evenly along the Z and Y directions, and Block mode splits evenly along all three directions. Most filters use Slab mode as the default. V.SetSplitModeToSlab() C++: void SetSplitModeToSlab() Set the method used to divide the volume into pieces. Slab mode splits the volume along the Z direction first, Beam mode splits evenly along the Z and Y directions, and Block mode splits evenly along all three directions. Most filters use Slab mode as the default. V.SetSplitModeToBeam() C++: void SetSplitModeToBeam() Set the method used to divide the volume into pieces. Slab mode splits the volume along the Z direction first, Beam mode splits evenly along the Z and Y directions, and Block mode splits evenly along all three directions. Most filters use Slab mode as the default. V.SetSplitModeToBlock() C++: void SetSplitModeToBlock() Set the method used to divide the volume into pieces. Slab mode splits the volume along the Z direction first, Beam mode splits evenly along the Z and Y directions, and Block mode splits evenly along all three directions. Most filters use Slab mode as the default. V.GetSplitMode() -> int C++: virtual int GetSplitMode() Set the method used to divide the volume into pieces. Slab mode splits the volume along the Z direction first, Beam mode splits evenly along the Z and Y directions, and Block mode splits evenly along all three directions. Most filters use Slab mode as the default. V.SetNumberOfThreads(int) C++: virtual void SetNumberOfThreads(int _arg) Get/Set the number of threads to create when rendering. This is ignored if EnableSMP is On. V.GetNumberOfThreadsMinValue() -> int C++: virtual int GetNumberOfThreadsMinValue() Get/Set the number of threads to create when rendering. This is ignored if EnableSMP is On. V.GetNumberOfThreadsMaxValue() -> int C++: virtual int GetNumberOfThreadsMaxValue() Get/Set the number of threads to create when rendering. This is ignored if EnableSMP is On. V.GetNumberOfThreads() -> int C++: virtual int GetNumberOfThreads() Get/Set the number of threads to create when rendering. This is ignored if EnableSMP is On. V.SplitExtent([int, int, int, int, int, int], [int, int, int, int, int, int], int, int) -> int C++: virtual int SplitExtent(int splitExt[6], int startExt[6], int num, int total) Putting this here until I merge graphics and imaging streaming. vtkTreeAlgorithmvtkTreeAlgorithm - Superclass for algorithms that produce only Tree as output Superclass: vtkAlgorithm vtkTreeAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline edgehitecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be Tree. If that isn't the case then please override this method in your subclass. vtkCommonExecutionModelPython.vtkTreeAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkTreeAlgorithm C++: static vtkTreeAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkTreeAlgorithm C++: vtkTreeAlgorithm *NewInstance() V.GetOutput() -> vtkTree C++: vtkTree *GetOutput() V.GetOutput(int) -> vtkTree C++: vtkTree *GetOutput(int index) Get the output data object for a port on this algorithm. vtkTrivialConsumervtkTrivialConsumer - Consumer to consume data off of a pipeline. Superclass: vtkAlgorithm vtkTrivialConsumer caps off a pipeline so that no output data is left hanging around when a pipeline executes when data is set to be released (see vtkDataObject::SetGlobalReleaseDataFlag). This is intended to be used for tools such as Catalyst and not end users. vtkCommonExecutionModelPython.vtkTrivialConsumerV.SafeDownCast(vtkObjectBase) -> vtkTrivialConsumer C++: static vtkTrivialConsumer *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkTrivialConsumer C++: vtkTrivialConsumer *NewInstance() FillOutputDataInformationvtkTrivialProducerGetMTimevtkTrivialProducer - Producer for stand-alone data objects. Superclass: vtkAlgorithm vtkTrivialProducer allows stand-alone data objects to be connected as inputs in a pipeline. All data objects that are connected to a pipeline involving vtkAlgorithm must have a producer. This trivial producer allows data objects that are hand-constructed in a program without another vtk producer to be connected. vtkCommonExecutionModelPython.vtkTrivialProducerV.SafeDownCast(vtkObjectBase) -> vtkTrivialProducer C++: static vtkTrivialProducer *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkTrivialProducer C++: vtkTrivialProducer *NewInstance() V.SetOutput(vtkDataObject) C++: virtual void SetOutput(vtkDataObject *output) Set the data object that is "produced" by this producer. It is never really modified. V.GetMTime() -> int C++: vtkMTimeType GetMTime() override; The modified time of this producer is the newer of this object or the assigned output. V.FillOutputDataInformation(vtkDataObject, vtkInformation) C++: static void FillOutputDataInformation(vtkDataObject *output, vtkInformation *outInfo) This method can be used to copy meta-data from an existing data object to an information object. For example, whole extent, image data spacing, origin etc. vtkUndirectedGraphAlgorithmvtkUndirectedGraphAlgorithm - Superclass for algorithms that produce undirected graph as output Superclass: vtkAlgorithm vtkUndirectedGraphAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline edgehitecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be Graph. If that isn't the case then please override this method in your subclass. @par Thanks: Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from Sandia National Laboratories for their help in developing this class. vtkCommonExecutionModelPython.vtkUndirectedGraphAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkUndirectedGraphAlgorithm C++: static vtkUndirectedGraphAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkUndirectedGraphAlgorithm C++: vtkUndirectedGraphAlgorithm *NewInstance() V.GetOutput() -> vtkUndirectedGraph C++: vtkUndirectedGraph *GetOutput() V.GetOutput(int) -> vtkUndirectedGraph C++: vtkUndirectedGraph *GetOutput(int index) Get the output data object for a port on this algorithm. vtkUnstructuredGridAlgorithmGetUnstructuredGridInputvtkUnstructuredGridAlgorithm - Superclass for algorithms that produce only unstructured grid as output Superclass: vtkAlgorithm vtkUnstructuredGridAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be UnstructuredGrid. If that isn't the case then please override this method in your subclass. vtkCommonExecutionModelPython.vtkUnstructuredGridAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkUnstructuredGridAlgorithm C++: static vtkUnstructuredGridAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkUnstructuredGridAlgorithm C++: vtkUnstructuredGridAlgorithm *NewInstance() V.GetOutput() -> vtkUnstructuredGrid C++: vtkUnstructuredGrid *GetOutput() V.GetOutput(int) -> vtkUnstructuredGrid C++: vtkUnstructuredGrid *GetOutput(int) Get the output data object for a port on this algorithm. V.GetInput(int) -> vtkDataObject C++: vtkDataObject *GetInput(int port) V.GetInput() -> vtkDataObject C++: vtkDataObject *GetInput() V.GetUnstructuredGridInput(int) -> vtkUnstructuredGrid C++: vtkUnstructuredGrid *GetUnstructuredGridInput(int port) vtkUnstructuredGridBaseAlgorithmvtkUnstructuredGridBaseAlgorithm - Superclass for algorithms that produce only vtkUnstructureGridBase subclasses as output Superclass: vtkAlgorithm vtkUnstructuredGridBaseAlgorithm is a convenience class to make writing algorithms easier. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be UnstructuredGridBase. If that isn't the case then please override this method in your subclass. vtkCommonExecutionModelPython.vtkUnstructuredGridBaseAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkUnstructuredGridBaseAlgorithm C++: static vtkUnstructuredGridBaseAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkUnstructuredGridBaseAlgorithm C++: vtkUnstructuredGridBaseAlgorithm *NewInstance() V.GetOutput() -> vtkUnstructuredGridBase C++: vtkUnstructuredGridBase *GetOutput() V.GetOutput(int) -> vtkUnstructuredGridBase C++: vtkUnstructuredGridBase *GetOutput(int) Get the output data object for a port on this algorithm. vtkProgressObserver - Basic class to optionally replace vtkAlgorithm progress functionality. Superclass: vtkObject When the basic functionality in vtkAlgorithm that reports progress is not enough, a subclass of vtkProgressObserver can be used to provide custom functionality. The main use case for this is when an algorithm's RequestData() is called from multiple threads in parallel - the basic functionality in vtkAlgorithm is not thread safe. vtkSMPProgressObserver can handle this situation by routing progress from each thread to a thread local vtkProgressObserver, which will invoke events separately for each thread. vtkCommonExecutionModelPython.vtkProgressObserverV.SafeDownCast(vtkObjectBase) -> vtkProgressObserver C++: static vtkProgressObserver *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkProgressObserver C++: vtkProgressObserver *NewInstance() V.UpdateProgress(float) C++: virtual void UpdateProgress(double amount) The default behavior is to update the Progress data member and invoke a ProgressEvent. This is designed to be overwritten. V.GetProgress() -> float C++: virtual double GetProgress() Returns the progress reported by the algorithm. vtkSelectionAlgorithmvtkSelectionAlgorithm - Superclass for algorithms that produce only Selection as output Superclass: vtkAlgorithm vtkSelectionAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline edgehitecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this class constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be Selection. If that isn't the case then please override this method in your subclass. You should implement the subclass's algorithm into RequestData( request, inputVec, outputVec). @par Thanks: Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from Sandia National Laboratories for their help in developing this class. vtkCommonExecutionModelPython.vtkSelectionAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkSelectionAlgorithm C++: static vtkSelectionAlgorithm *SafeDownCast(vtkObjectBase *o) V.NewInstance() -> vtkSelectionAlgorithm C++: vtkSelectionAlgorithm *NewInstance() V.GetOutput() -> vtkSelection C++: vtkSelection *GetOutput() V.GetOutput(int) -> vtkSelection C++: vtkSelection *GetOutput(int index) Get the output data object for a port on this algorithm. vtkExtentRCBPartitionerPartitionGetDuplicateNodesGetNumberOfGhostLayersGetNumExtentsSetNumberOfPartitionsSetDuplicateNodesSetNumberOfGhostLayersDuplicateNodesOnDuplicateNodesOffGetPartitionExtentSetGlobalExtentvtkExtentRCBPartitioner - This method partitions a global extent to N partitions where N is a user supplied parameter. Superclass: vtkObject vtkCommonExecutionModelPython.vtkExtentRCBPartitionerV.SafeDownCast(vtkObjectBase) -> vtkExtentRCBPartitioner C++: static vtkExtentRCBPartitioner *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkExtentRCBPartitioner C++: vtkExtentRCBPartitioner *NewInstance() V.SetNumberOfPartitions(int) C++: void SetNumberOfPartitions(const int N) Set/Get the number of requested partitions V.SetGlobalExtent(int, int, int, int, int, int) C++: void SetGlobalExtent(int imin, int imax, int jmin, int jmax, int kmin, int kmax) V.SetGlobalExtent([int, int, int, int, int, int]) C++: void SetGlobalExtent(int ext[6]) Set/Get the global extent array to be partitioned. The global extent is packed as follows: [imin,imax,jmin,jmax,kmin,kmax] V.SetDuplicateNodes(int) C++: virtual void SetDuplicateNodes(int _arg) On/Off DuplicateNodes between partitions. Default is On. V.GetDuplicateNodes() -> int C++: virtual int GetDuplicateNodes() On/Off DuplicateNodes between partitions. Default is On. V.DuplicateNodesOn() C++: virtual void DuplicateNodesOn() On/Off DuplicateNodes between partitions. Default is On. V.DuplicateNodesOff() C++: virtual void DuplicateNodesOff() On/Off DuplicateNodes between partitions. Default is On. V.SetNumberOfGhostLayers(int) C++: virtual void SetNumberOfGhostLayers(int _arg) Set/Get macro for the number of ghost layers. V.GetNumberOfGhostLayers() -> int C++: virtual int GetNumberOfGhostLayers() Set/Get macro for the number of ghost layers. V.GetNumExtents() -> int C++: virtual int GetNumExtents() Returns the number of extents. V.Partition() C++: void Partition() Partitions the extent V.GetPartitionExtent(int, [int, int, int, int, int, int]) C++: void GetPartitionExtent(const int idx, int ext[6]) Returns the extent of the partition corresponding to the given ID. vtkUniformGridPartitionerGetNumberOfPartitionsvtkUniformGridPartitioner - A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a uniform grid. Superclass: vtkMultiBlockDataSetAlgorithm The partitioning method that is used is Recursive Coordinate Bisection (RCB) where each time the longest dimension is split. @sa vtkStructuredGridPartitioner vtkRectilinearGridPartitioner vtkCommonExecutionModelPython.vtkUniformGridPartitionerV.SafeDownCast(vtkObjectBase) -> vtkUniformGridPartitioner C++: static vtkUniformGridPartitioner *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkUniformGridPartitioner C++: vtkUniformGridPartitioner *NewInstance() V.GetNumberOfPartitions() -> int C++: virtual int GetNumberOfPartitions() Set/Get macro for the number of subdivisions. V.SetNumberOfPartitions(int) C++: virtual void SetNumberOfPartitions(int _arg) Set/Get macro for the number of subdivisions. V.GetDuplicateNodes() -> int C++: virtual int GetDuplicateNodes() V.SetDuplicateNodes(int) C++: virtual void SetDuplicateNodes(int _arg) V.DuplicateNodesOn() C++: virtual void DuplicateNodesOn() V.DuplicateNodesOff() C++: virtual void DuplicateNodesOff() vtkUniformGridAMRAlgorithmvtkUniformGridAMRAlgorithm - vtkUniformGridAMR as output. Superclass: vtkAlgorithm A base class for all algorithms that take as input any type of data object including composite datasets and produce vtkUniformGridAMR in the output. vtkCommonExecutionModelPython.vtkUniformGridAMRAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkUniformGridAMRAlgorithm C++: static vtkUniformGridAMRAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkUniformGridAMRAlgorithm C++: vtkUniformGridAMRAlgorithm *NewInstance() V.GetOutput() -> vtkUniformGridAMR C++: vtkUniformGridAMR *GetOutput() V.GetOutput(int) -> vtkUniformGridAMR C++: vtkUniformGridAMR *GetOutput(int) Get the output data object for a port on this algorithm V.SetInputData(vtkDataObject) C++: void SetInputData(vtkDataObject *) V.SetInputData(int, vtkDataObject) C++: void SetInputData(int, vtkDataObject *) Set an input of this algorithm. vtkOverlappingAMRAlgorithmvtkOverlappingAMRAlgorithm - A base class for all algorithms that take as input vtkOverlappingAMR and produce vtkOverlappingAMR. Superclass: vtkUniformGridAMRAlgorithm vtkCommonExecutionModelPython.vtkOverlappingAMRAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkOverlappingAMRAlgorithm C++: static vtkOverlappingAMRAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkOverlappingAMRAlgorithm C++: vtkOverlappingAMRAlgorithm *NewInstance() V.GetOutput() -> vtkOverlappingAMR C++: vtkOverlappingAMR *GetOutput() V.GetOutput(int) -> vtkOverlappingAMR C++: vtkOverlappingAMR *GetOutput(int) Get the output data object for a port on this algorithm vtkNonOverlappingAMRAlgorithmvtkNonOverlappingAMRAlgorithm - produce vtkNonOverlappingAMR as output. Superclass: vtkUniformGridAMRAlgorithm vtkCommonExecutionModelPython.vtkNonOverlappingAMRAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkNonOverlappingAMRAlgorithm C++: static vtkNonOverlappingAMRAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkNonOverlappingAMRAlgorithm C++: vtkNonOverlappingAMRAlgorithm *NewInstance() V.GetOutput() -> vtkNonOverlappingAMR C++: vtkNonOverlappingAMR *GetOutput() V.GetOutput(int) -> vtkNonOverlappingAMR C++: vtkNonOverlappingAMR *GetOutput(int) Get the output data object for a port on this algorithm vtkHyperOctreeAlgorithmGetHyperOctreeInputvtkHyperOctreeAlgorithm - Superclass for algorithms that produce only octree as output Superclass: vtkAlgorithm vtkOctreeAlgorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with SetNumberOfInputPorts etc. See this classes constructor for the default. This class also provides a FillInputPortInfo method that by default says that all inputs will be HyperOctree. If that isn't the case then please override this method in your subclass. vtkCommonExecutionModelPython.vtkHyperOctreeAlgorithmV.SafeDownCast(vtkObjectBase) -> vtkHyperOctreeAlgorithm C++: static vtkHyperOctreeAlgorithm *SafeDownCast( vtkObjectBase *o) V.NewInstance() -> vtkHyperOctreeAlgorithm C++: vtkHyperOctreeAlgorithm *NewInstance() V.GetOutput() -> vtkHyperOctree C++: vtkHyperOctree *GetOutput() V.GetOutput(int) -> vtkHyperOctree C++: vtkHyperOctree *GetOutput(int) Get the output data object for a port on this algorithm. V.GetHyperOctreeInput(int) -> vtkHyperOctree C++: vtkHyperOctree *GetHyperOctreeInput(int port) can't get dictionary for module vtkCommonExecutionModelPythonreal_initvtkCommonExecutionModelPythonvtkCommonExecutionModelPython;D%w`% %@%pV|WX\t^*T_:`lJmjnzHpq@stuP1 7@09`:<=?AC G@J`L`OqD>`rh>r>s>t>u?0vD?wx?@y?y?y >y>pz@z(@`{l@`|@}@@@A@@A\A@L@@APA0B0@BdBBBB C8C`TCCAВA C0C D`$D\DDDPD DE`@><`>a>a?b@0bAdb`Cb0Eb`GbGbHaHa`H@c@Ic@JcKc MdN@dPddRd`TdVdXeY e`YhepZdcZxcZe[e\f]8f_lf`fPbfdf@fgf gfhgPig`jepjejgkhl?A8A\BCDȐEF`G4HX J|KK̑0LMHNlOP`QȎQ܎QQQQ,R@RT Rh0R@RȏRR@STUVW,XP Zt[[@\]0^T_x`paȒaܒaaa,ad@bPbȖ0ccc d|ef̗fgh8i\jpkPlȘ0m n0o,@pHqlr`tu0wx`@z |К~h`0$@P`pĕؕ( <`Ppdx4T0hp؜0 DphА`,P0tPp(L p@Йܟ`$\(LУpP0\ЬĜP`آ@@H0lģ 8d`ȤĢм 0\0L`p<0 dPا H p@p8T\ ̪@ dث D`h@ Ԭ (PLpܭ <pXܮȩ@ܩP,@Th@|P`p0P`(pPPP0<hP<tа<h` ܱpPx  @ p0 h(`<pdвtpش``H|@ĵ ` Ĵ !X !"Ķ##`%H&l(`*,. /(`/pp0l00012004d5p79ع; < p?4@` BCCԻ0D@EPE`EE@EhFGؼI pJ00LT@NNNTN@OLPOt0P Q Q(RLSpTUVܿ X0Y@Z8[l@]^aa 0bPb`bb$b8b`bb0c̾pcc`ddpeggh i0jT@lxmno@qqqXql r0r`rprrr s<`sPs`stuw,xPPzt|| }t0}}}0p~tPP8Tp`p@<Њp@`@P@|0@l`М0 zRx $xR@)FJ w?:*3$"D{ \{0)t` \hdF     (<P d x EDPa AE O|RܰO|RHPa G ED@W AG $ED@W AG DED@W AG hED@W AG hED@W AG ԳED@W AG @ED@W AG ED@W AG ED@W AG @<EY B W`?t <(<EAD`j AAJ H@ I H@ I hH@ I ED@ AG ,ȸED@ AG PdED@ AG tED@ AG ED@ AG 8ED@ AG ED@ AG ED@ AG (̽ED@ AG LED@ AG pDED@ AG ED@ AG EDP AK EDP AK EDP AB $PEDP AK HEDP AK lEDP AK EDP AK EDP AK LEDP AK EDP AK ( -FADP ABG 8L&FBB A(Dp (A BBBK (FAD` ABG (FAD` ABG @;FBB A(A0Dp 0A(A BBBE $<EDP AG H H@ E dH@ E H[FBB B(A0A8D 8A0A(B BBBA EDP AG 0DsFBA D  ABBB 0$ ^FAA D`  AABH 8X xFBB A(Dp (A BBBK gFD@ EE LEDPt AB EDP AF EDPt AB $ EDPt AB (H FAD` ABD (t pFAD` ABD 0 $FDA D`{  ABBA `FDB B(A0A8G 8A0A(B BBBH v 8G0H(B BBBK IMA*DIA$` `EO l AG VAL FPI H(D0O (D BBBD  (D BBBG 0 OFDD n ABA DDB  ED@ AG D pEDP AK h \H@ I  H@ I  H@ I  H@ I < lIFBA A(D> (A ABBF ( |FAD` ABF <D pFBA A(D, (A ABBH EDP AK EDP AK 4 sFFD`{ ABB  KBK (@oFCD` ABD (0oFCD` ABD \EDP AK (FAD` ABC (/FAD` ABC (_FCD` ABD (_FCD` ABD (0vFADp ABA (\hfFADp ABC (vFADp ABJ 4 FFD`g ABF p NBH x EDP AK 8d DFBB A(Dp (A BBBK $Lx EDP AK t`  HEDPa AE <EY B W(EAD`j AAJ ED@ AG 0DED@ AG 0T^FAA D`  AABH EDP AK EDP AK gFD@ EE MFF0DOFDD n ABA DDBD\ p EDPa AE  OEY B j(EAD`n AAF 0nFAA D`  AABH (,gFD@ EE LxEDPt AB (p FCD`r ABF MFF0,OFDD n ABA DDB ( ,xEDPa AE P(OEY B j(p EAD`n AAF 0 nFAA D`  AABH $"gFD@ EE p#EDPt AB ( % FCD`r ABF D&MFF0`$'OFDD n ABA DDB(/ t' / \'EDPa AE  .uEY B P ,'ED@ AG P(EDP AK (t)"EAD`n AAF 0*FAA D`  AABH +gFD@ EE <-MFF0p-OFDD n ABA DDBH\. p3 .EDPa AE |3bEY B }(.EAD`n AAF 0/FAA D`  AABH (0gFD@ EE L(2MFF0h\2OFDD n ABA DDB2 ; 2EDPa AE 3ED@W AG $3ED@W AG H\4ED@W AG l4ED@W AG 45EDP AK :uEY B P(5"EAD`n AAF 06FAA D`  AABH 4P8gFD@ EE X9MFF0t9OFDD n ABA DDB̌h: C P:EDPa AE COEY B j((:EAD`n AAF 0T;nFAA D`  AABH EDPt AB (?+FCD`r ABF AMFF0,BOFDD n ABA DDBLHdB xP xBEDPa AE POEY B j(CEAD`n AAF CgFD@ EE 0 4EnFAA D`  AABH TpFEDPt AB xHEDPt AB (I+FCD`r ABF (K+FCD`r ABF MMFF0NOFDD n ABA DDBDp X NEDP AK |XO e @OEDPa AE OO|R4PO|RdOEY B j(LPEAD`n AAF D QED@ AG hQED@ AG xRED@ AG $SED@ AG SED@ AG |TED@ AG  (UED@ AG @ UEDP AK d VEDP AK WEDP AK hXEDP AK ( DYFAD` ABG ( (ZFAD` ABG ((! [FAD` ABG (T![FAD` ABG 0!\nFAA D`  AABH !^gFD@ EE !\_EDPt AB !aMFF0" 4>OEY B j(T>EAD`n AAF 0>tnFAA D`  AABH >gFD@ EE >EDPt AB >EDPt AB ?TEDPt AB D?EDPt AB (h?+FCD`r ABF (?+FCD`r ABF ?HFA0?OFDD n ABA DDB@Ti$$@EDP AK L@8EDPa AE p@ @OEY B j(@EAD`n AAF @EDP AK 0@`nFAA D`  AABH (AgFD@ EE LAEDPt AB pAEDP AF (A0+FCD`r ABF A4HFA0AhOFDD n ABA DDBBtg($BpbFCD`r ABF PBEDP AK tB BEDPa AE BhbEY B }(BEAD`n AAF 0BlFAA D`  AABH ,CgFD@ EE PCHFA0lCHOFDD n ABA DDBCfCC CT CEDPa AE D, bEY B }(8DLEAD`n AAF 0dD0 FAA D`  AABH D gFD@ EE D MFF0D OFDD n ABA DDB Ed$E 8E LEx EDPa AE pEbEY B } E ED@ AG E ED@ AG ElEDP AK (EHEAD`n AAF 0(F,FAA D`  AABH \FgFD@ EE FMFF0FOFDD n ABA DDBFc4`FBA D`r  ABBD ^_` EDPt AB (0S?+FCD`r ABF \SAMFF0xS,BOFDD n ABA DDBSXSB SG SxBEDPa AE TGOEY B j(0TCEAD`n AAF 0\TCnFAA D`  AABH T$EgFD@ EE TpFMFF0TFOFDD n ABA DDBUV:Em$UG 8UY LUFEDPa AE pUYOEY B j(UGEAD`n AAF UXHED@ AG UIED@ AG VIED@ AG (V\JED@ AG LVKED@ AG pVKED@ AG V`LED@ AG V MED@ AG VMED@ AG 0WdNnFAA D`  AABH 4WOgFD@ EE XWPEDPt AB (|WR+FCD`r ABF (WT+FCD`r ABF WVMFF0WVOFDD n ABA DDB$XT0o<}FBA D`  ABBG oED@ AG pDEDP AK 4p0H@ I PpH@ I lp p!p p1p p pp1 q  q 4qHq\q pq qEDPa AE qFCDp ABD AHFA0BOFDD n ABA DDBHL%8\BFBB A(G (A BBBG HD)FBB B(A0A8D 8A0A(B BBBA 0I \R IEDPa AE 04ROEY B j(PIEAD`n AAF 0|JnFAA D`  AABH KgFD@ EE ԊMEDPt AB (N FCD`r ABF $PMFF0@POFDD n ABA DDBt@#(Q V QEDPa AE ؋\VOEY B j(QEAD`n AAF 0$RnFAA D`  AABH XSgFD@ EE |UMFF0@``(@R0@ ǣ((H. X @ ťȥΥ@"ť !,+ 5P42HD5P?hApp> EH0D@@A0C@8HD5pHhpIpGxJPLpNP HD5RhSp0Q8 T U WP HD5]h^pZ P`  \ [HD5chepcfHHD5@mhpnp0i0p Plk0kjhj #HD5shtpr$v$w%Py%*HD5p}hp|*p~h+ +E',/'P- %8'-x3HD5hpp3P(44/'85.50/ВP6/06/`7.7.`898'P:J/\/k/{/J/{/\/Кk/ >HD5hp`X>>@?<@vx@cЯPA=AXB¤0XC= C<D<E<hF<`(G<У H<@H<(J@OHD5phppxOPP`PPpSHD50h0p0S`TQhTQQpUbQpUQ8VuQ0WQ Y ZCQZ@^HD5phpp^^[ (_¤_ ```a`bbpd$(eA\e3\pf&\g \@h[ j[Pj[k[0pl[Pm[(n[nv[osHD5h0psPtNq@tp@vp wDqxpypP z7q{pp|pP}q~q*q @8HD8 5 hppp@@ pXPm0H$ [- xM 8? Ѓ'&!`ւh‚ 0 `v@X(+p++XHD5 .h /p@-02P3P`HD57h8p60:H;p=%HD5AhBp@Cx`E+E'QإJ`.0GP.IN%8'L-HD5ShUpSHPWXE'a,P\Ь/'Z0T@8' _PHD5chdpc f HD5jh kp0iXl0HD5rhspPoppueq`V0p0/qpHD5yhzpyP|x~xhHD5hpЀ`@g/sh508hHD5hp0X00805P8XHD50h0pP0PZL (HD5hp p%HD5дhеp@@HD5hp`+.50/pP6/@6/`7.7.8PP/' 85%8'xHD5h`pH+E'p,/'-%8'p-HD5hp0xp0XpHD5Php@x.P5/ `7.78'H/'J/>N{/J/{/>N HD5ph`pX0E',/'@-p %8' -HD5@h0p`( E',/'-Z@%8'- HD5!h@+p  @(X P. p%0 @- P&X"#0'(x!h$()HD50h1p/P3h8"HD56p"`B"5x#7($c?$0:% <0';=x(Z>)vA`*@9*  ;H+N=+H(,G,F`-E8.pD/4HD5Kp"L"J5P5R1`R06.1 O710N9D1PH;X,W(,V<V8.T/(EHD5`\p"n"ZXEqExFdF>~xG>hH>cI>pg8J>`fJa>\KV>[@NJ>p[8QR1i@T.10_U1 `xWD1aYv0kZP]H\ @^]Na_m>b0a>pehb>ld y?`t?{?v?r&?po-?jHD5@hpІk k l@m hmUhPHnh@oo@0qyhrch0t?h@v+hwhwhxg`ygЏzg@{g{g @|g|g~ugp~hg]gPRghAg0(&g؂g0ǣ pȆHD5hpp(PE',/' - %8'-HD5PhPpp80P@HD5hpx`VPPHD5@hp`(@HD5h@p؞``cEX_xٛ K@pȤp hě%@8@`ւ@}P8y PHD5hpp0PHD50h0pP@ػHD5hp@E' ؼ4 @ HD5hpPH@PpHD5@h0p`@E'',/' >@$%8'"HD5*h+p )p,X-E'4,/%8'1(HD58h9p06``:Vp<07xHD5>h?p=@A0BpDPHD5pHhRpGULVXMk0J@`PpQ8 O}K8Ka`ISXHD5\h]p[d)@_0ch} `8aka0h0egHD5lhmplPPop@rHD5vhypu {hw0HD5~hp}phhHD5hpp(PE',/' -ZP %8'- GCC: (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0M %WP3e<8  j0^g!-O\!@!< = > i  ,gPI@ 0    Q <<0<p^gM@!SpS! A G  C j ?   @   !0% 46i & '  p+  +6K + j @F   _  @j    [ x[ z y y#zn^P|  Z [ Lj   ~uЀB|^,fS` \\ @^ `j    b&0bkd00.o%0S.^j _ (@a \pj    Pbb0w\P P0S0n b 9`d hj   uu,d'm O  `0OS `@2`c50iP@&Y@ a$ `T @      !H!!!!%"^"""-"&1#d##;#P<# .$]$[$$s$@^%xQ% g}%%P%&F&z&p&P &@ `' `:' j'  ' ' 0'@'` (@S(P(0(()IM) z)@) !)@")P#s!* `D*%ow*@(o***++,/V+._+p0_+2v+P4f0,5vj,@7,@ ,8-:D1-P;S/^-`> -p>-P?-@@.AF.A^p.0C.0D. Eg/ "/` D/``1p/G /G/pH0pInI0Jg0PL0N 0 %1  Q1831 Q 10Q1R2SnD2Tgy2U2W 2 3 )35X3Z 3Z3[4\f4]"4^4P`g-5 `5  575c 5c,6cZ6e6fg6 6 697 i I70i7j7j 80kO8k8Pl8@m" 9pn99pgq9@ 9! @9;9r :r\:s:tn:vg;w?;Py+|; # ;$ ; +><| 0<|g<p}<p~g<n<P1= e=+= +=% =@' @>@L>D>` >p>PO?, >?Or?, ??@;@|@`@0@5AВvAAABRBBBBК.CnYCPgCC( C * D`jG-D WDD`D@EУ>E`EEE:FnFFgFnG@- 4G. [GG  G0G;HzHЯ H!HJ(I TIIpIpnIg.JPeJ J`1 J3 JM!K  EK0wKKK0L0n0LfLpL0LM4MDjM`gM3 M5 MHRN2N_NNNN06OgOPOOpO`P FP}PPP&QXQ^|QgQpQ8 @Q 7 R @9R_R*RR RSTDS0- hS@-S .S /nS0g"T2QT3 TG TI TWT6 "U6eU7U8nU0:g V;`Vp=+V`J VL WY@W@zWAWBnWCgX`EQX0GXIXJYL+UYN+YL YN YZQ\HZSzZSZTZUn[PWg9[Xh[Z[P\+[P [Q `\2\ _bd\a]\c\c\d(]fg]]S ]T ]00_] i ]0i7^jl^ k^lg^@U ^V !_PaS_@o _Po_0p_q@`q`r`s`pug$aW Ka Y uapca a bQbnbpgbb+z+zz{ z } `z{};{ i{!{!{"{#|$R|p%~|P&|0'|@(g})4}@+^Y}~ s} }}@-}P.S~/K~0~1~P3g~  Dy5 567g6@9q0: ;<0=j=>́?TAT:`Bne@  ` ՂpD} EGF|GH߃J J+KTLnx0N OPPg>`Rtl@  @DžT}V+VYWXZ ΆZp[O) `R[O~ `\OӇ@ ``\&P][@^0_Lj `a+aZbcdpe`fOpgh<il0klle@n^epoqg‹r`tT"vTQ y{~׌ @ @`5a ܍p( kІ^*y0P<}p̐ X @>Џ`Βl0 B@@”P@W0 5 gu ږ@  D@ Zŗ -dpnۘgPM + + !` `KD` ۚp P;Pndg0ě  ` 5` n!`gWj@  ۝ ٟDP w`@5-@gm ` ʟ>̠ JԡW֢`P@@ѣ@@LVLlʤPt gC@t ۥ @ 7p)1 Ц.nVgp0   "@L@ qP0Ө0ng/` N p`y  4cnª@g) H@ @j ū ܭ #_nʬg>@ z  ͭP 1`n@@0n$g` ӯ"+$+M v `ذ'g) E )*ñ+np,g;-y/+1+ ( X4=г 6 06*7]89^`:g  ` .[p<B= =>!?nN@AgBpD @  3 WbG GķpH`I-0JjKKL&M<c O<`PpQ R^MSUgºV !` H@y[ [߻\]F@_ `ͼa aDP0cDdg̽e gI0hD`  ׾` k 7lrlmnۿPogpMr+ @  u :uuvwy {gP w } }C~}g* T $cpngP 2+j +  `S h+Re  0`` 'x NZ y @ ?  p@ H  " U"<")"ZCh >"`1`"!-U"p" r K"=?o"<0ZOS<" sOЄO" R"Oq" O%@\"0 `~O"OH/qOU"= ~"R " Z"@G<z"/  0 H PMS M'Vs"6OM1s"J*,OE"< nPO"O,eFO")l*M"p/ n@!O/b"`J|O " Ai"pb "Z Y"0ru"O" "w X") "Z</" | ii"@=V4M <O"<4tPO0OopPO<s"P "h "9?Oi|"!" $"p5bM"O@MM9"OY4H"* 3q" /"Zf"1"= &" ]  P"  "0k.QOk?MbPM"P ,e}PO"0b"!@0TOZ" /I"nb?sP'OOY"  ЫO""P@OMwPhOYM"@)%M"P ?"@1")/"pZOR"`k?OO$"@ `"Z*"`=a"P" 7"нO^M70wO_FM}"0GO'@MGy"I #T|O 9x"   MO1e"Y1^HOvM""Z W"  D"n z" " j ;" jM ~H<"hb["p[<M?saMM"IAl"jb 6O/Z"0<+Rz,O8m`H : `Oc    "hb' "0*<H t  "0|O "p*  ^O4 ] { "O  PQO  O5 [  PO  "(l 2 ")\    %MO"PJ 3p M"Oe"0O(Np"0G .]!4,HM"@ y"pJ"  Cr " 2O^"5O"( "p<EibO")Mt"j QH 9" q"O ZO nM<sMX@MttM" ><"I!S" } DO<W"= " MB|"= "wbG"O7Mh ) " ^ " =    !".!>!PMd!5M!! M!"O!""P"o""0O"YM"" ""pJ #" A#"0[?r##")##" b$J$`Aq$"=<$"  $iO$$4%pnOZ%uO%%"`%"*&9&u&&"O&"`5 '.'CMM'p''"0A'`(?(l((("j! )^);M})" )))" %*>*"Oi*"@O*" *")*M+H+|+"pj!+"0J+FO,K,,,"@J -"j B-p---"=<."<=.Q.y.."p!..//U/"I /"p)/{M/(0" * Y0y00" 0" 1 1"0 L1u111|M120  =2" r222@hO23K3"z3333M3" ?4 4U4444"@@ 55R55" G 55$6OQ6666"0} 27?7c777O7 8d888"(O8"J9O9PHr999:D:~:::"JO;"/<!;{OK;;"p6 ;;"<`<"bO<<<"= #="<O====>8>c>>>>?"`< $?" Z N?y??"`b ?@"J!,@r@" @@@"`Z A"b GAtAAAABEB" tB'MBBB%CaCCCC"`/ D+D OJDvDD" DEM9E" iEEE"pZF"<F5FSFrFFF,<G*G"= RG~GhMGp MGG"PbHiM,H0OWHO|HHHHI]IIIIJDJrJJJJJK5K\K" KK"OKMLMLxLL"`j LM`4O@M"5 ~MM"OMM"ON"Z 7N"p) \NMNNNN+O" fOOO"bO O$P^P"`u PP"@}bP"Y QPM2Q^QpOQ"0 QRRDRjR"ROR"JRRqMSSM2SzSSSS"0 /TjT TTU.UU"OUUU"1'VfVVVW