{"version":3,"sources":["lib/ReportRunState.ts","components/elements/DocString/DocString.tsx","components/shared/ErrorBoundary/ErrorBoundary.tsx","components/widgets/CustomComponent/ComponentInstance.tsx","components/elements/ExceptionElement/ExceptionElement.tsx","components/elements/Json/Json.tsx","components/elements/Markdown/Markdown.tsx","components/elements/Table/Table.tsx","components/elements/Text/Text.tsx","components/widgets/CustomComponent/ComponentRegistry.tsx","components/core/Maybe/Maybe.tsx","components/core/Block/Block.tsx","components/core/Sidebar/Sidebar.tsx","lib/ConnectionState.ts","components/core/ReportView/ReportView.tsx","lib/Timer.ts","components/core/StreamlitDialog/StreamlitDialog.tsx","components/core/StatusWidget/StatusWidget.tsx","components/core/MainMenu/component/ScreencastOption.tsx","components/core/MainMenu/MainMenu.tsx","components/core/StreamlitDialog/ScriptChangedDialog.tsx","components/core/StreamlitDialog/SettingsDialog.tsx","lib/s3helper.ts","lib/StaticConnection.ts","lib/ForwardMessageCache.ts","lib/Resolver.ts","lib/WebsocketConnection.tsx","lib/ConnectionManager.ts","lib/WidgetStateManager.ts","lib/SessionEventDispatcher.ts","lib/MetricsManager.ts","lib/DeltaParser.ts","lib/FileUploadClient.ts","lib/HttpClient.ts","lib/ScreenCastRecorder.ts","hocs/withScreencast/components/ScreencastDialog/ScreencastDialog.tsx","hocs/withScreencast/components/VideoRecordedDialog/VideoRecordedDialog.tsx","hocs/withScreencast/components/UnsupportedBrowserDialog/UnsupportedBrowserDialog.tsx","components/core/Countdown/Countdown.tsx","hocs/withScreencast/withScreencast.tsx","App.tsx","index.tsx","lib/dataFrameProto.ts","components/shared/ErrorElement/ErrorElement.tsx","components/shared/ErrorElement/index.tsx","lib/log.ts","components/shared/FullScreenWrapper/FullScreenWrapper.tsx","components/shared/FullScreenWrapper/index.tsx","lib/widgetTheme.ts","autogen/proto.js","components/elements/Alert/Alert.tsx","components/elements/Alert/index.tsx","lib/IFrameUtil.ts","hocs/withFullScreenWrapper/withFullScreenWrapper.tsx","hocs/withFullScreenWrapper/index.tsx","autogen/scssVariables.ts","lib/baseconsts.ts","lib/SessionInfo.ts","lib/immutableProto.ts","lib/utils.ts","assets/img/icon_running.gif","lib/UriUtil.ts","components/shared/Icon/Icon.tsx","components/shared/Icon/index.tsx","lib/format.ts","../node_modules/which-browser/data sync /^/models/-.*$","../node_modules/which-browser/data/indices sync /^/models/-.*$","components/elements/CodeBlock/CopyButton.tsx","components/elements/CodeBlock/CodeBlock.tsx","components/shared/StreamlitMarkdown.tsx"],"names":["ReportRunState","DocString","this","props","element","width","name","get","module","docString","type","signature","moduleHtml","className","key","nameHtml","signatureHtml","typeHtml","style","PureComponent","ErrorBoundary","state","error","componentDidCatch","info","logError","message","stack","ErrorElement","href","rel","target","children","React","getDerivedStateFromError","ComponentMessageType","StreamlitMessageType","ExceptionElement","messageNode","stackTrace","isWarning","markdown","StreamlitMarkdown","source","allowHTML","stackTraceNode","size","map","row","indx","wrapperClasses","classNames","Json","body","styleProp","bodyObject","undefined","JSON","parse","e","pos","parseInt","replace","substr","src","displayDataTypes","displayObjectSize","font","Markdown","Table","dataFrameGetDimensions","headerRows","rows","cols","hasNoData","df","header","colSpan","TableRows","endRow","rowArray","rowIdx","push","Fragment","TableRow","entries","colIdx","dataFrameGet","contents","styles","formattedContents","toFormattedString","scope","Error","withFullScreenWrapper","Text","ComponentInstance","iframeRef","createRef","componentReady","lastRenderArgs","lastRenderDataframes","frameHeight","componentDidMount","current","contentWindow","registry","registerListener","onBackMsg","componentWillUnmount","deregisterListener","data","COMPONENT_READY","apiVersion","setState","componentError","sendForwardMsg","RENDER","args","dfs","SET_COMPONENT_VALUE","handleSetComponentValue","fromUi","logWarning","SET_FRAME_HEIGHT","handleSetFrameHeight","value","tryGetValue","widgetId","widgetMgr","setJsonValue","height","toString","postMessage","render","renderArgs","renderDfs","componentName","url","getComponentURL","queryString","stringifyUrl","query","streamlitUrl","window","location","toJS","err","disabled","allow","DEFAULT_IFRAME_FEATURE_POLICY","ref","scrolling","sandbox","DEFAULT_IFRAME_SANDBOX_POLICY","title","obj","defaultValue","hasOwnProperty","ComponentRegistry","getServerUri","msgListeners","Map","cachedServerUri","listener","has","set","delete","path","serverUri","buildHttpUri","onMessageEvent","event","addEventListener","Maybe","nextProps","nextState","nextContext","enable","Component","Audio","lazy","Balloons","BokehChart","DataFrame","DeckGlChart","DeckGlJsonChart","Favicon","GraphVizChart","IFrame","ImageList","PlotlyChart","VegaLiteChart","Video","Button","Checkbox","ColorPicker","DateInput","Multiselect","Progress","Radio","Selectbox","Slider","FileUploader","TextArea","TextInput","TimeInput","NumberInput","Block","renderElements","elements","toArray","reportElement","index","List","renderBlock","renderElementWithErrorBoundary","filter","node","renderElement","metadata","widgetProps","widgetsDisabled","elementDimensionSpec","Math","min","dispatchOneOf","alert","el","Alert","audio","balloons","bokehChart","dataFrame","deckGlChart","deckGlJsonChart","empty","exception","favicon","graphvizChart","iframe","imgs","json","multiselect","plotlyChart","progress","table","text","vegaLiteChart","video","button","checkbox","colorPicker","dateInput","radio","selectbox","slider","fileUploader","widgetStateManager","uploadClient","textArea","textInput","timeInput","numberInput","componentInstance","componentRegistry","disableHeight","reportRunState","RERUN_REQUESTED","RUNNING","reportId","showStaleElementIndicator","isHidden","isElementStale","component","elementType","shouldComponentBeEnabled","isStale","isComponentStale","getClassNames","fallback","makeElementWithInfoText","FullScreenWrapper","isFullScreen","join","Sidebar","sidebarRef","handleClickOutside","innerWidth","contains","collapsedSidebar","checkMobileOnResize","toggleCollapse","onChange","sectionClassName","outline","onClick","Icon","document","removeEventListener","defaultProps","ConnectionState","ReportView","hasSidebar","sidebar","isEmpty","wide","reportViewClassName","theme","sidebarWidgetTheme","tabIndex","mainWidgetTheme","main","DialogType","Timer","timerHandle","duration","startTime","_isRunning","handler","time","cancel","Date","now","setTimeout","clearTimeout","elapsed","max","StatusWidget","sessionEventConn","curView","minimizePromptTimer","keyHandlers","handleScroll","statusMinimized","shouldMinimize","onReportPromptHover","promptHovered","onReportPromptUnhover","promptMinimized","minimizePromptAfterTimeout","handleStopReportClick","stopReport","handleRerunClick","rerunReport","handleAlwaysRerunClick","reportChangedOnDisk","a","sessionEventDispatcher","onSessionEvent","connect","handleSessionEvent","disconnect","connectionState","CONNECTED","timeout","remainingTime","animateIn","renderView","prevView","renderWidget","appear","in","unmountOnExit","isConnected","renderReportIsRunning","RERUN_PROMPT_MODAL_DIALOG","renderRerunReportPrompt","renderConnectionStatus","ui","getConnectionStateUI","id","icon","label","placement","tooltip","stopRequested","STOP_REQUESTED","stopButton","promptButton","iconRunning","alt","rerunRequested","minimized","handlers","attach","focused","onMouseEnter","onMouseLeave","scrollY","color","INITIAL","PINGING_SERVER","CONNECTING","STATIC","DISCONNECTED_FOREVER","ScreencastOption","screenCastState","MainMenu","toggle","dropdownOpen","getOpenInWindowCallback","open","isServerDisconnected","isServerConnected","isOpen","right","quickRerunCallback","clearCacheCallback","divider","screencastCallback","sharingEnabled","shareCallback","settingsCallback","aboutCallback","ScriptChangedDialog","rerun","onRerun","alwaysRerun","BasicDialog","onClose","SettingsDialog","_settings","handleCancelButtonClick","onOpened","handleDialogOpen","checked","runOnSave","handleCheckboxChange","wideMode","handleSaveButtonClick","changeSingleSetting","onSave","settings","StreamlitDialog","dialogProps","ABOUT","SessionInfo","streamlitVersion","CLEAR_CACHE","enter","defaultAction","confirmCallback","clearCacheDialog","RERUN_SCRIPT","autoFocus","getCommandLine","setCommandLine","rerunCallback","rerunScriptDialog","SETTINGS","settingsDialog","SCRIPT_CHANGED","SCRIPT_COMPILE_ERROR","scriptCompileErrorDialog","UPLOAD_PROGRESS","animated","uploadProgressDialog","UPLOADED","onCopy","uploadedDialog","WARNING","msg","warningDialog","noDialog","typeNotRecognizedDialog","getReportObjectPath","objName","pathname","resourceRoot","substring","lastIndexOf","startsWith","objectPath","getReportObject","fetch","FETCH_PARAMS","response","ok","status","responseText","StaticConnection","onConnectionStateChange","getAllMessages","numMessages","manifest","msgIdx","arrayBuffer","onMessage","ForwardMsg","decode","Uint8Array","CacheEntry","reportRunCount","curReportRunCount","ForwardMsgCache","messages","maxMessageAge","forEach","entry","hash","getAge","logMessage","maybeCacheMessage","newMsg","getCachedMessage","refHash","fetchMessagePayload","ForwardMsgMetadata","create","serverURI","rsp","statusText","cacheable","updateReportRunCount","cached","Resolver","resolve","reject","promise","Promise","resFn","rejFn","LOG","WebsocketConnection","cache","uriIndex","lastDispatchedMessageIndex","nextMessageIndex","messageQueue","websocket","wsConnectionTimeoutId","getBaseUriParts","stepFsm","baseUriPartsList","errMsg","pingServer","connectToWebSocket","cancelConnectionAttempt","setFsmState","uris","_","i","doHealthPing","onRetry","uri","buildWsUri","WebSocket","setConnectionTimeout","localWebsocket","checkWebsocket","onmessage","handleMessage","catch","reason","onopen","onclose","onerror","readyState","close","BackMsg","buffer","encode","finish","send","incrementRunCount","messageIndex","readFileAsync","result","resultArray","processMessagePayload","dispatchMessageIndex","uriList","timeoutMs","retryCallback","resolver","totalTries","uriNumber","tryTimestamp","retryImmediately","length","retry","errorNode","tryDuration","retryTimeout","retryWhenTheresNoResponse","URL","hostname","commandLine","isSet","axios","then","code","request","reader","FileReader","onload","readAsArrayBuffer","ConnectionManager","connection","setConnectionState","connectionStateChanged","onConnectionError","showRetryError","totalRetries","latestError","sendMessage","incrementMessageCacheRunCount","IS_SHARED_REPORT","connectBasedOnManifest","connectToRunningServer","baseUriParts","getWindowBaseUriParts","fetchManifest","serverStatus","StaticManifest","ServerStatus","connectToRunningServerFromManifest","connectToStaticReportFromManifest","configuredServerAddress","internalServerIP","externalServerIP","parts","port","serverPort","basePath","serverBasePath","host","s","WidgetStateManager","sendBackMsg","widgetStates","getOrCreateWidgetStateProto","triggerValue","maybeSendUpdateWidgetsMessage","deleteWidgetStateProto","getWidgetStateProto","boolValue","intValue","floatValue","stringValue","stringArrayValue","StringArray","fromObject","floatArrayValue","FloatArray","intArrayValue","IntArray","jsonValue","stringify","sendUpdateWidgetsMessage","updateWidgets","createWigetStatesMsg","active_ids","includes","WidgetStates","widgets","WidgetState","SessionEventDispatcher","Signal","emit","MetricsManager","initialized","actuallySendMetrics","pendingEvents","pendingDeltaCounter","pendingCustomComponentCounter","reportHash","setReportHash","gatherUsageStats","userTraits","authorEmail","identify","installationId","sendPendingEvents","logAlways","evName","evData","deltaType","deltaCounter","clearDeltaCounter","customInstanceName","customComponentCounter","clearCustomComponentCounter","dev","IS_DEV_ENV","track","analytics","applyDelta","deltaMsg","delta","toImmutableProto","Delta","parentBlock","requireNonNull","parentBlockPath","container","BlockPath","Container","MAIN","deltaPath","deltaId","newElement","currentElement","getIn","setIn","incrementDeltaCounter","incrementCustomComponentCounter","equals","ImmutableMap","handleNewElementMessage","newBlock","updateIn","handleNewBlockMessage","addRows","namedDataSet","update","handleAddRowsMessage","FileUploadClient","files","onUploadProgress","cancelToken","form","FormData","append","sessionId","file","method","csrfEnabled","params","xsrf_cookie","getCookie","headers","Object","assign","withCredentials","ScreenCastRecorder","recordAudio","inputStream","recordedChunks","mediaRecorder","navigator","mediaDevices","getDisplayMedia","desktopStream","tracks","getTracks","getUserMedia","voiceStream","concat","getAudioTracks","MediaStream","MediaRecorder","mimeType","ondataavailable","start","r","onstop","stop","buildOutputBlob","Blob","ScreencastDialog","handleRecordAudioCheckbox","toggleRecordAudio","handleStartButton","startRecording","margin","VideoRecordedDialog","handleDownloadButton","getVideoSource","videoBlob","createObjectURL","fileName","videoSource","controls","download","role","aria-label","UnsupportedBrowserDialog","Countdown","countdown","onAnimationEnd","endCallback","newCountdown","SUPPORTED_BROWSERS","Chrome","Firefox","Opera","Edge","withScreencast","WrappedComponent","ComponentWithScreencast","recorder","currentState","showDialog","checkSupportedBrowser","stopRecording","initialize","getState","outputBlob","onCountdownEnd","getScreenCastProps","closeDialog","whichBrowser","WhichBrowser","userAgent","keys","browser","browserVersion","isBrowser","some","supported","screenCast","displayName","hoistNonReactStatics","statusWidgetRef","connectionManager","elementListBuffer","elementListBufferTimerIsSet","rerunScript","c","openClearCacheDialog","esc","handleConnectionStateChanged","newState","dialog","setCookie","msgProto","funcs","whichOne","dispatchProto","initializeMsg","handleInitialize","sessionStateChanged","handleSessionStateChanged","sessionEvent","evtMsg","newReport","newReportMsg","handleNewReport","handleDeltaMsg","reportFinished","handleReportFinished","uploadReportProgress","handleUploadReportProgress","reportUploaded","handleReportUploaded","showError","newDialog","openDialog","environmentInfo","userInfo","config","sessionState","hasStreamlitVersionChanged","reload","pythonVersion","email","maxCachedMessageAge","userMapboxToken","mapboxToken","Boolean","enqueue","stateChangeProto","prevState","reportIsRunning","COMPILATION_ERROR","NOT_RUNNING","getAndResetDeltaCounter","getAndResetCustomComponentCounter","count","userSettings","handleSessionEventMsg","scriptCompilationException","newReportProto","reportName","scriptPath","newReportHash","hashString","clearAppState","clearOldElements","simpleElement","clearedElements","classList","remove","saveSettings","newSettings","prevRunOnSave","backMsg","setRunOnSave","metadataMsg","isStaticConnection","shareReport","cloudUpload","alwaysRunOnSave","clearCache","handleConnectionError","errNode","date","moment","format","fromJS","streamlitDebug","closeConnection","bind","isEmbeddedInIFrame","add","currentStreamlitVersion","ReportFinishedStatus","FINISHED_SUCCESSFULLY","active_widget_ids","flattenElements","union","clean","outerDivClass","engine","Styletron","prefix","popupZIndex","Number","SCSS_VARS","ReactDOM","LightTheme","zIndex","getElementById","STRING_COLLATOR","Intl","Collator","numeric","sensitivity","compareValues","b","compareStrings","compare","getSortedDataRowIndices","sortColumnIdx","sortAscending","tableGetRowsAndCols","nRows","nCols","col","cmp","mapOneOf","strings","doubles","int64s","datetimes","timedeltas","indices","Array","sort","aRowIdx","bRowIdx","aValue","tableData","bValue","columns","indexGetLevelsAndLength","headerCols","dataRowsCheck","dataColsCheck","dataRows","dataCols","anyArrayLen","dataFrameToArrayOfDicts","dataArr","dfColumns","dfData","rowDict","indexGet","tableGet","customDisplayValue","tableStyle","columnIndex","rowIndex","cellStyle","tableStyleGetDisplayValue","tableStyleGetCSS","cssStyles","item","property","camelcase","anyArrayGet","anyArrayData","plainIndex","idx","rangeIndex","multiIndex","int_64Index","float_64Index","datetimeIndex","timedeltaIndex","level","levels","nanosToDate","nanosToDuration","anyArray","getData","dataframeToModify","newDataFrame","newRows","namedDataSets","first","namedDataSetEntry","findEntry","ds","getNamedDataSet","chart","_else","getNamedDataSets","existingDatasetIndex","existingDataSet","namedDataset","updateOneOf","datasets","pushNamedDataSet","existingDataFrame","deckGlMap","getDataFrame","setDataFrame","index1","index2","indexLen","type1","type2","concatAnyArray","concatIndex","zipWith","col1","col2","style_cols","array1","array2","concatCellStyleArray","setDataFrameInNamedDataSet","anyArray1","anyArray2","array","stackArray","split","shift","cleanedStack","trim","console","log","warn","expanded","fullWidth","fullHeight","controlKeys","keyCode","zoomOut","zoomIn","overflow","convertScssRemValueToPixels","scssValue","parseFloat","getComputedStyle","documentElement","fontSize","updateWindowDimensions","padding","paddingTop","innerHeight","buttonClassName","buttonImage","buttonOnClick","buttonTitle","black","borderRadius","fontFamilyMono","fontFamilySans","fontSizeBase","fontSizeSm","grayDark","gray","grayLight","grayLighter","grayLightest","labelFontSize","lineHeightBase","lineHeightTight","primary","primaryA50","smallTextMargin","textMargin","tinyTextMargin","white","fontStyles","fontFamily","fontWeight","lineHeight","sliderOverrides","Root","Thumb","backgroundColor","$disabled","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","borderStyle","boxShadow","InnerThumb","display","Tick","ThumbValue","paddingBottom","top","position","whiteSpace","TickBar","paddingLeft","paddingRight","justifyContent","alignItems","TickBarItem","Track","InnerTrack","background","fileUploaderOverrides","FileDragAndDrop","$theme","$isDragActive","flexDirection","borderColor","colors","mono200","borderWidth","ContentSeparator","ContentMessage","ButtonComponent","overrides","BaseButton","textTransform","textDecoration","datePickerOverrides","Popover","POPOVER_PLACEMENT","bottomLeft","CalendarContainer","CalendarHeader","MonthHeader","Week","Day","$selected","PrevButton","NextButton","Input","maskChar","buttonOverrides","border","multiSelectOverrides","ValueContainer","minHeight","ClearIcon","SearchIcon","MultiValue","radioOverrides","$isFocused","marginBottom","marginTop","RadioMarkInner","$checked","checkboxOverrides","Checkmark","$isFocusVisible","mainThemePrimitives","lightThemePrimitives","primaryFontFamily","primary100","primary200","primary300","primary400","primary500","primary600","primary700","mono100","mono300","mono400","mono500","mono600","mono700","mono800","mono900","mono1000","rating200","rating400","themeOverrides","borders","radius100","radius200","radius300","radius400","buttonBorderRadius","inputBorderRadius","popoverBorderRadius","surfaceBorderRadius","typography","font100","font150","font200","font250","font300","font350","font400","font450","font460","font470","font500","font600","LabelXSmall","LabelSmall","LabelMedium","LabelLarge","ParagraphSmall","primaryA","accent","tagPrimarySolidBackground","borderFocus","contentPrimary","inputFill","inputPlaceholder","inputBorder","inputFillActive","tickMarkFillDisabled","tickFillDisabled","tickMarkFill","tickFillSelected","calendarHeaderForegroundDisabled","calendarDayBackgroundSelected","calendarDayBackgroundSelectedHighlighted","calendarDayForegroundSelected","calendarDayForegroundSelectedHighlighted","createTheme","$Reader","$protobuf","$Writer","$util","$root","properties","prototype","writer","call","uint32","string","int32","encodeDelimited","ldelim","end","len","tag","skipType","decodeDelimited","verify","isString","object","String","toObject","options","defaults","enums","Format","toJSON","constructor","toJSONOptions","valuesById","values","ArrowDataframe","ArrowTable","fork","isInteger","TypeError","newBuffer","styler","bytes","Styler","base64","slice","uuid","caption","displayValues","$oneOfFields","defineProperty","oneOfGetter","oneOfSetter","bool","oneofs","executionId","Type","emptyArray","end2","isArray","arrays","j","figure","useContainerWidth","argsDataframe","argsJson","ArgsDataframe","Index","TableStyle","PlainIndex","RangeIndex","MultiIndex","DatetimeIndex","TimedeltaIndex","Int64Index","Float64Index","AnyArray","Long","fromBits","int64","low","high","fromValue","unsigned","LongBits","toNumber","long","longs","labels","Int32Array","Int64Array","DoubleArray","double","isFinite","UInt32Array","CSSStyle","CellStyle","css","displayValue","hasDisplayValue","CellStyleArray","isRange","layers","spec","DeckGLLayer","Element","NamedDataSet","Empty","Exception","MultiSelect","unused","messageIsMarkdown","maxUploadSizeMb","multipleFiles","updateReportProperties","Initialize","NewReport","SessionState","SessionEvent","ReportProperties","ElementDimensionSpec","srcdoc","hasWidth","float","Image","UserInfo","Config","EnvironmentInfo","allowHtml","hasName","hasMin","hasMax","dataType","step","DataType","Figure","reportWasManuallyStopped","externalServerIp","internalServerIp","maxChars","sint64","ALERT_CSS_CLASS","AlertProto","SUCCESS","INFO","ERROR","getAlertCSSClass","cname","getIFrameSandboxPolicy","allowSameOrigin","sandboxPolicy","ComponentWithFullScreenWrapper","passThroughProps","WEBSOCKET_PORT_DEV","redirect","credentials","mode","singleton","sm","messageType","x","debounce","delay","fn","timerId","embed","xxhash","h32","reduce","acc","ImmutableSet","of","isFromMac","test","platform","cookie","match","expiration","expirationDate","expirationStr","toUTCString","exports","FINAL_SLASH_RE","INITIAL_SLASH_RE","isHttps","protocol","fullPath","makePath","subPath","buildMediaUri","data-glyph","aria-hidden","Duration","millis","nanos","m","hour","minute","second","getTime","n","numbro","dateToString","durationToString","webpackContext","req","webpackContextResolve","__webpack_require__","o","CopyButton","clipboard","Clipboard","destroy","data-clipboard-text","CodeBlock","language","lang","Prism","languages","toLowerCase","languageClassName","python","safeHtml","highlight","dangerouslySetInnerHTML","__html","renderers","link","linkWithTargetBlank","linkReference","linkReferenceHasParens","inlineMath","math","plugins","RemarkMathPlugin","RemarkEmoji","astPlugins","htmlParser","escapeHtml"],"mappings":";0IAiBYA,E,6KAAAA,K,yBAAAA,E,kBAAAA,E,iCAAAA,E,+BAAAA,E,sCAAAA,M,0BC6DGC,G,wLAhDqB,IAAD,EACJC,KAAKC,MAAxBC,EADuB,EACvBA,QAASC,EADc,EACdA,MAEXC,EAAOF,EAAQG,IAAI,QACnBC,EAASJ,EAAQG,IAAI,UACrBE,EAAYL,EAAQG,IAAI,aACxBG,EAAON,EAAQG,IAAI,QACnBI,EAAYP,EAAQG,IAAI,aAExBK,EACJ,0BAAMC,UAAU,aAAaC,IAAI,UAC9BN,EADH,KAIIO,EACJ,0BAAMF,UAAU,WAAWC,IAAI,QAC5BR,GAGCU,EACJ,0BAAMH,UAAU,gBAAgBC,IAAI,aACjCH,GAGCM,EACJ,0BAAMH,IAAI,OAAOD,UAAU,YACxBH,GAKL,OACE,yBAAKG,UAAU,iBAAiBK,MAAO,CAAEb,UACvC,yBAAKQ,UAAU,cACZP,EACG,CACEE,EAASI,EAAa,GACtBG,EACAJ,EAAYK,EAAgB,IAE9B,CAACC,IAEP,yBAAKJ,UAAU,cAAcJ,Q,GA3CbU,kB,iBCIlBC,E,2MACGC,MAAe,CACpBC,MAAO,M,EAUFC,kBAAoB,SAACD,EAAcE,GACxCC,YAAS,GAAD,OAAIH,EAAMhB,KAAV,aAAmBgB,EAAMI,QAAzB,aAAqCJ,EAAMK,S,wEAGnB,IACxBL,EAAUpB,KAAKmB,MAAfC,MAER,OAAIA,EACiB,mBAAfA,EAAMhB,KAEN,kBAACsB,EAAA,EAAD,CACEvB,MAAOH,KAAKC,MAAME,MAClBC,KAAK,gBACLoB,QACE,8IAGE,6BAHF,mDAIkD,mCAJlD,KAMU,uCANV,QAMgC,sCANhC,IAOE,6BAPF,8EASe,IACb,uBACEG,KAAK,yFACLC,IAAI,sBACJC,OAAO,UAHT,WAcR,kBAACH,EAAA,EAAD,CACEvB,MAAOH,KAAKC,MAAME,MAClBC,KAAMgB,EAAMhB,KACZoB,QAASJ,EAAMI,QACfC,MAAOL,EAAMK,QAKZzB,KAAKC,MAAM6B,a,GA3DMC,IAAMd,eAA5BC,EAKUc,yBAA2B,SAACZ,GAExC,MAAO,CACLA,MAAOA,IAuDEF,IC3DHe,EAiBAC,ED0CGhB,I,iBEHAiB,G,wLA7De,IAYtBC,EAZqB,EACEpC,KAAKC,MAAxBC,EADiB,EACjBA,QAASC,EADQ,EACRA,MAEXK,EAAON,EAAQG,IAAI,QACnBmB,EAAUtB,EAAQG,IAAI,WACtBgC,EAAanC,EAAQG,IAAI,cACzBiC,EAAYpC,EAAQG,IAAI,aAO9B,GAAIH,EAAQG,IAAI,qBAAsB,CACpC,IAAIkC,EAAQ,YAAQ/B,EAAR,MACRgB,IACFe,GAAQ,YAASf,IAEnBY,EAAc,kBAACI,EAAA,EAAD,CAAmBC,OAAQF,EAAUG,WAAW,SAE9DN,EACE,oCACE,0BAAMzB,UAAU,QAAQH,GACZ,MAAXgB,EAAA,YAAuBA,GAAY,MAM1C,IAAImB,EAA4B,KAC5BN,GAAcA,EAAWO,KAAO,IAClCD,EACE,oCACE,yBAAKhC,UAAU,qBAAf,cACA,yBAAKA,UAAU,eACb,8BACG0B,EAAWQ,KAAI,SAACC,EAAaC,GAAd,OACd,yBAAKpC,UAAU,kBAAkBC,IAAKmC,GACnCD,UASf,IAAME,EAAiBC,IAAW,QAAS,YAAa,cAAe,CACrE,gBAAiBX,EACjB,gBAAiBA,IAGnB,OACE,yBAAK3B,UAAWqC,EAAgBhC,MAAO,CAAEb,UACvC,yBAAKQ,UAAU,WAAWyB,GACzBO,O,GAxDsB1B,kB,kBC+BhBiC,G,wLA7Be,IAAD,EACElD,KAAKC,MAAxBC,EADiB,EACjBA,QAASC,EADQ,EACRA,MACXgD,EAAOjD,EAAQG,IAAI,QACnB+C,EAAY,CAAEjD,SAEhBkD,OAAaC,EACjB,IACED,EAAaE,KAAKC,MAAML,GACxB,MAAOM,GAGP,IAAMC,EAAMC,SAASF,EAAEjC,QAAQoC,QAAQ,UAAW,IAAK,IAEvD,MADAH,EAAEjC,SAAF,YAAkB2B,EAAKU,OAAO,EAAGH,EAAM,GAAvC,gBACMD,EAER,OACE,yBAAK9C,UAAU,6BAA6BK,MAAOoC,GACjD,kBAAC,IAAD,CACEU,IAAKT,EACLU,kBAAkB,EAClBC,mBAAmB,EACnB5D,MAAM,EACNY,MAAO,CAAEiD,KAAM,W,GAvBNlC,IAAMd,gBCcViD,E,iLAde,IAAD,EACElE,KAAKC,MAAxBC,EADiB,EACjBA,QAASC,EADQ,EACRA,MACXgD,EAAOjD,EAAQG,IAAI,QACnB+C,EAAY,CAAEjD,SAEduC,EAAYxC,EAAQG,IAAI,aAC9B,OACE,yBAAKM,UAAU,qCAAqCK,MAAOoC,GACzD,kBAACZ,EAAA,EAAD,CAAmBC,OAAQU,EAAMT,UAAWA,S,GAT7BX,IAAMd,e,iCCEhBkD,G,OAAb,iLACyB,IACbjE,EAAYF,KAAKC,MAAjBC,QADY,EAEekE,YAAuBlE,GAAlDmE,EAFY,EAEZA,WAAYC,EAFA,EAEAA,KAAMC,EAFN,EAEMA,KAEpBC,EAAYF,IAASD,EAI3B,OACE,yBAAK1D,UAAU,2BACb,kBAAC,QAAD,CAAYA,UAAW6D,EAAY,cAAgB,IACjD,+BACE,kBAAC,EAAD,CACEC,GAAIvE,EACJwE,QAAQ,EACRL,WAAYA,EACZC,KAAMA,EACNC,KAAMA,KAGV,+BACGC,EACC,4BACE,wBAAIG,QAASJ,GAAQ,GAArB,UAGF,kBAAC,EAAD,CACEE,GAAIvE,EACJmE,WAAYA,EACZC,KAAMA,EACNC,KAAMA,WA/BtB,GAA2BtD,kBA0DrB2D,EAAuC,SAAA3E,GAK3C,IALqD,IAC7CwE,EAAuCxE,EAAvCwE,GAAIC,EAAmCzE,EAAnCyE,OAAQL,EAA2BpE,EAA3BoE,WAAYC,EAAerE,EAAfqE,KAAMC,EAAStE,EAATsE,KAEhCM,EAASH,EAASL,EAAaC,EAC/BQ,EAAW,GACRC,EAHQL,EAAS,EAAIL,EAGFU,EAASF,EAAQE,IAC3CD,EAASE,KACP,wBAAIpE,IAAKmE,GACP,kBAAC,EAAD,CAAUN,GAAIA,EAAIM,OAAQA,EAAQR,KAAMA,MAI9C,OAAO,kBAAC,IAAMU,SAAP,KAAiBH,IAiBpBI,EAAqC,SAACjF,GAG1C,IAHoE,IAC5DwE,EAAqBxE,EAArBwE,GAAIM,EAAiB9E,EAAjB8E,OAAQR,EAAStE,EAATsE,KACdY,EAAU,GACPC,EAAS,EAAGA,EAASb,EAAMa,IAAU,CAAC,IAAD,EACTC,YAAaZ,EAAIW,EAAQL,GAApDO,EADoC,EACpCA,SAAUC,EAD0B,EAC1BA,OAAQ/E,EADkB,EAClBA,KACpBgF,EAAoBC,YAAkBH,GAC5C,GAAa,WAAT9E,EACF2E,EAAQH,KAAK,wBAAIpE,IAAKwE,GAAT,cACR,GAAa,eAAT5E,EACT2E,EAAQH,KACN,wBAAIpE,IAAKwE,EAAQM,MAAM,OACpBF,SAGA,GAAa,eAAThF,EACT2E,EAAQH,KAAK,wBAAIpE,IAAKwE,GAASI,QAC1B,IAAa,SAAThF,EAOT,MAAM,IAAImF,MAAJ,6BAAgCnF,EAAhC,OANN2E,EAAQH,KACN,wBAAIhE,MAAOuE,EAAQ3E,IAAKwE,GACrBI,KAOT,OAAO,kBAAC,IAAMP,SAAP,KAAiBE,IAGXS,cAAsBzB,GCxGtB0B,E,iLAbe,IAAD,EACE7F,KAAKC,MAAxBC,EADiB,EACjBA,QAASC,EADQ,EACRA,MACXgD,EAAOjD,EAAQG,IAAI,QACnB+C,EAAY,CAAEjD,SAEpB,OACE,yBAAKQ,UAAWsC,IAAW,cAAe,UAAWjC,MAAOoC,GACzDD,O,GARUpB,IAAMd,e,qCLMbgB,K,2CAAAA,E,kDAAAA,E,6CAAAA,M,cAiBAC,K,2BAAAA,M,KAmBL,IAAM4D,EAAb,YAQE,WAAmB7F,GAAe,IAAD,8BAC/B,4CAAMA,KARA8F,UAAYC,sBAOa,EALzBC,gBAAiB,EAKQ,EAJzBC,eAAiB,GAIQ,EAHzBC,qBAAuB,GAGE,EAFzBC,YAAc,EAEW,EAK1BC,kBAAoB,WACK,MAA1B,EAAKN,UAAUO,QAQyB,MAAxC,EAAKP,UAAUO,QAAQC,cAQ3B,EAAKtG,MAAMuG,SAASC,iBAClB,EAAKV,UAAUO,QAAQC,cACvB,EAAKG,WARLnF,YAAS,0FARTA,YAAS,iFARoB,EA4B1BoF,qBAAuB,WAEA,MAA1B,EAAKZ,UAAUO,SACyB,MAAxC,EAAKP,UAAUO,QAAQC,eAKzB,EAAKtG,MAAMuG,SAASI,mBAClB,EAAKb,UAAUO,QAAQC,gBArCM,EA4CzBG,UAAY,SAAClG,EAAcqG,GACjC,OAAQrG,GACN,KAAKyB,EAAqB6E,gBAOxB,IAAMC,EAAaF,EAAI,WApGa,IAqGhCE,EAGF,EAAKC,SAAS,CACZC,eAAgB,IAAItB,MAAJ,+CAC0BoB,EAD1B,SAKlB,EAAKd,gBAAiB,EACtB,EAAKiB,eAAehF,EAAqBiF,OAAQ,CAC/CC,KAAM,EAAKlB,eACXmB,IAAK,EAAKlB,wBAGd,MAEF,KAAKlE,EAAqBqF,oBACnB,EAAKrB,eAKR,EAAKsB,wBAAwBV,EAAM,CAAEW,QAAQ,IAJ7CC,YAAW,OAAD,OACDjH,EADC,mBACcyB,EAAqB6E,gBADnC,MAMZ,MAEF,KAAK7E,EAAqByF,iBACnB,EAAKzB,eAKR,EAAK0B,qBAAqBd,GAJ1BY,YAAW,OAAD,OACDjH,EADC,mBACcyB,EAAqB6E,gBADnC,MAMZ,MAEF,QACEW,YAAW,sCAAD,OAAuCjH,MA5FtB,EAiGzB+G,wBAA0B,SAACV,EAAWpE,GAC5C,IAAMmF,EAAQC,EAAYhB,EAAM,SAChC,QAAcvD,IAAVsE,EAAJ,CAKA,IAAME,EAAmB,EAAK7H,MAAMC,QAAQG,IAAI,MAChD,EAAKJ,MAAM8H,UAAUC,aAAaF,EAAUF,EAAOnF,QALjDgF,YAAW,kDApGkB,EA6GzBE,qBAAuB,SAACd,GAC9B,IAAMoB,EAA6BJ,EAAYhB,EAAM,eACtCvD,IAAX2E,EAKAA,IAAW,EAAK7B,cAKU,MAA1B,EAAKL,UAAUO,SAWnB,EAAKF,YAAc6B,EACnB,EAAKlC,UAAUO,QAAQ2B,OAAS,EAAK7B,YAAY8B,YAV/CT,YAAW,iDAXXA,YAAW,gDAhHkB,EAwIzBP,eAAiB,SAAC1G,EAA4BqG,GACtB,MAA1B,EAAKd,UAAUO,QAMyB,MAAxC,EAAKP,UAAUO,QAAQC,cAM3B,EAAKR,UAAUO,QAAQC,cAAc4B,YAArC,aAEI3H,KAAMA,GACHqG,GAEL,KATAY,YAAW,uDANXA,YAAW,+CA3IkB,EA8J1BW,OAAS,WACd,GAAiC,MAA7B,EAAKjH,MAAM8F,eAEb,OACE,kBAACvF,EAAA,EAAD,CACEtB,KAAM,EAAKe,MAAM8F,eAAe7G,KAChCoB,QAAS,EAAKL,MAAM8F,eAAezF,UAWzC,IAAI6G,EACAC,EACAxE,EACAyE,EACJ,IAGEA,EAAgB,EAAKtI,MAAMC,QAAQG,IAAI,iBACvC,IAAMmI,EAAM,EAAKvI,MAAMC,QAAQG,IAAI,OAEjCyD,EADS,MAAP0E,GAAuB,KAARA,EACXA,EAEA,EAAKvI,MAAMuG,SAASiC,gBAAgBF,EAAe,cAI3DzE,EAAM4E,IAAYC,aAAa,CAC7BH,IAAK1E,EACL8E,MAAO,CAAEC,aAAcC,OAAOC,SAASpH,QAIzC0G,EAAa9E,KAAKC,MAAM,EAAKvD,MAAMC,QAAQG,IAAI,aAC/CiI,EAAY,EAAKrI,MAAMC,QAAQG,IAAI,iBAAiB2I,OACpD,MAAOC,GAEP,YADA,EAAKjC,SAAS,CAAEC,eAAgBgC,IAkClC,OA9BI,EAAKhD,gBAEP,EAAKiB,eAAehF,EAAqBiF,OAAQ,CAC/CC,KAAMiB,EACNhB,IAAKiB,EACLY,SAAU,EAAKjJ,MAAMiJ,WAUzB,EAAKhD,eAAiBmC,EACtB,EAAKlC,qBAAuBmC,EAe1B,4BACEa,MAAOC,IACPC,IAAK,EAAKtD,UACVjC,IAAKA,EACL3D,MAAO,EAAKF,MAAME,MAClB8H,OAAQ,EAAK7B,YACbkD,UAAU,KACVC,QAASC,IACTC,MAAOlB,KAjPX,EAAKpH,MAAQ,GAFkB,EARnC,2BAAuCY,IAAMd,eAkQ7C,SAAS4G,EACP6B,EACAtJ,GAEM,IADNuJ,EACK,4DADerG,EAEpB,OAAOoG,EAAIE,eAAexJ,GAAQsJ,EAAItJ,GAAQuJ,E,aMnTnCE,GAQX,WAAmBC,GAA+C,IAAD,gCAPhDA,kBAOgD,OANhDC,aAAe,IAAIC,IAM6B,KAFzDC,qBAEyD,OAQ1DxD,iBAAmB,SACxBhE,EACAyH,GAEI,EAAKH,aAAaI,IAAI1H,IACxBgF,YAAW,gDAAiDhF,GAG9D,EAAKsH,aAAaK,IAAI3H,EAAQyH,IAhBiC,KAmB1DtD,mBAAqB,SAACnE,GACX,EAAKsH,aAAaM,OAAO5H,IAEvCgF,YAAW,0DAtBkD,KA0B1DgB,gBAAkB,SAACF,EAAuB+B,GAI/C,IAAIC,EAAY,EAAKT,eACrB,QAAkBxG,IAAdiH,EAAyB,CAC3B,QAA6BjH,IAAzB,EAAK2G,gBACP,MAAM,IAAItE,MAAM,oDAElB4E,EAAY,EAAKN,gBAInB,OADA,EAAKA,gBAAkBM,EAChBC,aAAaD,EAAD,oBAAyBhC,EAAzB,YAA0C+B,KAvCE,KA0CzDG,eAAiB,SAACC,GACxB,GACgB,MAAdA,EAAM7D,MACL6D,EAAM7D,KAAK+C,eAAe,sBAM7B,GAAoB,MAAhBc,EAAMjI,OAAV,CAOA,IAAMyH,EAAW,EAAKH,aAAa1J,IAAIqK,EAAMjI,QAC7C,GAAgB,MAAZyH,EAAJ,CAQA,IAAM1J,EAAOkK,EAAM7D,KAAN,KACD,MAARrG,EAMJ0J,EAAS1J,EAAMkK,EAAM7D,MALnBY,YAAW,2CAA4CiD,EAAM7D,WAT7DY,YAAW,iEAETiD,EAAM7D,WATRY,YAAW,kDAAmDiD,EAAM7D,OApDtE7G,KAAK8J,aAAeA,EACpBhB,OAAO6B,iBAAiB,UAAW3K,KAAKyK,iBCA7BG,G,8LAZXC,EACAC,EACAC,GAEA,OAAOF,EAAUG,S,+BAIjB,OAAOhL,KAAKC,MAAM6B,a,GAVFC,IAAMkJ,WCqBpBC,GAAQnJ,IAAMoJ,MAAK,kBAAM,mCACzBC,GAAWrJ,IAAMoJ,MAAK,kBAAM,mCAC5BE,GAAatJ,IAAMoJ,MAAK,kBAAM,iEAC9BG,GAAYvJ,IAAMoJ,MAAK,kBAAM,mCAC7BI,GAAcxJ,IAAMoJ,MAAK,kBAC7B,gEAEIK,GAAkBzJ,IAAMoJ,MAAK,kBACjC,+EAEIM,GAAU1J,IAAMoJ,MAAK,kBAAM,mCAC3BO,GAAgB3J,IAAMoJ,MAAK,kBAC/B,iEAEIQ,GAAS5J,IAAMoJ,MAAK,kBAAM,mCAC1BS,GAAY7J,IAAMoJ,MAAK,kBAAM,mCAC7BU,GAAc9J,IAAMoJ,MAAK,kBAC7B,0DAEIW,GAAgB/J,IAAMoJ,MAAK,kBAC/B,iEAEIY,GAAQhK,IAAMoJ,MAAK,kBAAM,mCAGzBa,GAASjK,IAAMoJ,MAAK,kBAAM,mCAC1Bc,GAAWlK,IAAMoJ,MAAK,kBAAM,mCAC5Be,GAAcnK,IAAMoJ,MAAK,kBAAM,wEAC/BgB,GAAYpK,IAAMoJ,MAAK,kBAAM,8EAC7BiB,GAAcrK,IAAMoJ,MAAK,kBAAM,wEAC/BkB,GAAWtK,IAAMoJ,MAAK,kBAAM,mCAC5BmB,GAAQvK,IAAMoJ,MAAK,kBAAM,mCACzBoB,GAAYxK,IAAMoJ,MAAK,kBAAM,gEAC7BqB,GAASzK,IAAMoJ,MAAK,kBAAM,0DAC1BsB,GAAe1K,IAAMoJ,MAAK,kBAC9B,0DAEIuB,GAAW3K,IAAMoJ,MAAK,kBAAM,yDAC5BwB,GAAY5K,IAAMoJ,MAAK,kBAAM,yDAC7ByB,GAAY7K,IAAMoJ,MAAK,kBAAM,uEAC7B0B,GAAc9K,IAAMoJ,MAAK,kBAAM,yDA8UtB2B,G,2MAhULC,eAAiB,SAAC5M,GAIxB,OAHyB,EAAKF,MAAM+M,SAIjCC,UACApK,KAAI,SAACqK,EAA8BC,GAClC,IAAMjN,EAAUgN,EAAc7M,IAAI,WAElC,OAAIH,aAAmBkN,OACd,EAAKC,YAAYnN,EAAyBiN,EAAOhN,GAEjD,EAAKmN,+BACVJ,EACAC,EACAhN,MAILoN,QAAO,SAACC,GAAD,OAA+C,MAARA,M,EAuG3CC,cAAgB,SACtBvN,EACAiN,EACAhN,EACAuN,GAEA,IAAKxN,EACH,MAAM,IAAIyF,MAAM,uBAGlB,IAKIsC,EALE0F,EAAc,CAClB5F,UAAW,EAAK9H,MAAM8H,UACtBmB,SAAU,EAAKjJ,MAAM2N,iBAyBvB,OAnBIF,GAAYA,EAASG,uBAErBH,GACAA,EAASG,sBACTH,EAASG,qBAAqB1N,OAC9BuN,EAASG,qBAAqB1N,MAAQ,IAEtCA,EAAQ2N,KAAKC,IAAIL,EAASG,qBAAqB1N,MAAOA,IAGtDuN,GACAA,EAASG,sBACTH,EAASG,qBAAqB5F,QAC9ByF,EAASG,qBAAqB5F,OAAS,IAEvCA,EAASyF,EAASG,qBAAqB5F,SAIpC+F,YAAc9N,EAAS,OAAQ,CACpC+N,MAAO,SAACC,GAAD,OAAuB,kBAACC,EAAA,EAAD,CAAOjO,QAASgO,EAAI/N,MAAOA,KACzDiO,MAAO,SAACF,GAAD,OAAuB,kBAAChD,GAAD,CAAOhL,QAASgO,EAAI/N,MAAOA,KACzDkO,SAAU,SAACH,GAAD,OAAuB,kBAAC9C,GAAD,CAAUlL,QAASgO,EAAI/N,MAAOA,KAC/DmO,WAAY,SAACJ,GAAD,OACV,kBAAC7C,GAAD,CAAYnL,QAASgO,EAAIf,MAAOA,EAAOhN,MAAOA,KAEhDoO,UAAW,SAACL,GAAD,OACT,kBAAC5C,GAAD,CAAWpL,QAASgO,EAAI/N,MAAOA,EAAO8H,OAAQA,KAEhDuG,YAAa,SAACN,GAAD,OACX,kBAAC3C,GAAD,CAAarL,QAASgO,EAAI/N,MAAOA,KAEnCsO,gBAAiB,SAACP,GAAD,OACf,kBAAC1C,GAAD,CAAiBtL,QAASgO,EAAI/N,MAAOA,KAEvCI,UAAW,SAAC2N,GAAD,OACT,kBAAC,EAAD,CAAWhO,QAASgO,EAAI/N,MAAOA,KAEjCuO,MAAO,kBAAM,yBAAK/N,UAAU,WAAWC,IAAKuM,KAC5CwB,UAAW,SAACT,GAAD,OACT,kBAAC,EAAD,CAAkBhO,QAASgO,EAAI/N,MAAOA,KAExCyO,QAAS,SAACV,GAAD,OAAuB,kBAACzC,GAAD,CAASvL,QAASgO,KAClDW,cAAe,SAACX,GAAD,OACb,kBAACxC,GAAD,CAAexL,QAASgO,EAAIf,MAAOA,EAAOhN,MAAOA,KAEnD2O,OAAQ,SAACZ,GAAD,OAAuB,kBAACvC,GAAD,CAAQzL,QAASgO,EAAI/N,MAAOA,KAC3D4O,KAAM,SAACb,GAAD,OAAuB,kBAACtC,GAAD,CAAW1L,QAASgO,EAAI/N,MAAOA,KAC5D6O,KAAM,SAACd,GAAD,OAAuB,kBAAC,EAAD,CAAMhO,QAASgO,EAAI/N,MAAOA,KACvDoC,SAAU,SAAC2L,GAAD,OAAuB,kBAAC,EAAD,CAAUhO,QAASgO,EAAI/N,MAAOA,KAC/D8O,YAAa,SAACf,GAAD,OACX,kBAAC9B,GAAD,eACExL,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRuB,YAAa,SAAChB,GAAD,OACX,kBAACrC,GAAD,CAAa3L,QAASgO,EAAI/N,MAAOA,KAEnCgP,SAAU,SAACjB,GAAD,OAAuB,kBAAC7B,GAAD,CAAUnM,QAASgO,EAAI/N,MAAOA,KAC/DiP,MAAO,SAAClB,GAAD,OAAuB,kBAAC,EAAD,CAAOhO,QAASgO,EAAI/N,MAAOA,KACzDkP,KAAM,SAACnB,GAAD,OAAuB,kBAAC,EAAD,CAAMhO,QAASgO,EAAI/N,MAAOA,KACvDmP,cAAe,SAACpB,GAAD,OACb,kBAACpC,GAAD,CAAe5L,QAASgO,EAAI/N,MAAOA,KAErCoP,MAAO,SAACrB,GAAD,OAAuB,kBAACnC,GAAD,CAAO7L,QAASgO,EAAI/N,MAAOA,KAEzDqP,OAAQ,SAACtB,GAAD,OACN,kBAAClC,GAAD,eAAQ9L,QAASgO,EAAI/N,MAAOA,GAAWwN,KAEzC8B,SAAU,SAACvB,GAAD,OACR,kBAACjC,GAAD,eACErL,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGR+B,YAAa,SAACxB,GAAD,OACX,kBAAChC,GAAD,eACEtL,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRgC,UAAW,SAACzB,GAAD,OACT,kBAAC/B,GAAD,eACEvL,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRiC,MAAO,SAAC1B,GAAD,OACL,kBAAC5B,GAAD,eACE1L,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRkC,UAAW,SAAC3B,GAAD,OACT,kBAAC3B,GAAD,eACE3L,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRmC,OAAQ,SAAC5B,GAAD,OACN,kBAAC1B,GAAD,eACE5L,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRoC,aAAc,SAAC7B,GAAD,OACZ,kBAACzB,GAAD,CACE7L,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,EACP6P,mBAAoBrC,EAAY5F,UAChCkI,aAAc,EAAKhQ,MAAMgQ,aACzB/G,SAAUyE,EAAYzE,YAG1BgH,SAAU,SAAChC,GAAD,OACR,kBAACxB,GAAD,eACE9L,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRwC,UAAW,SAACjC,GAAD,OACT,kBAACvB,GAAD,eACE/L,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGRyC,UAAW,SAAClC,GAAD,OACT,kBAACtB,GAAD,eACEhM,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGR0C,YAAa,SAACnC,GAAD,OACX,kBAACrB,GAAD,eACEjM,IAAKsN,EAAG7N,IAAI,MACZH,QAASgO,EACT/N,MAAOA,GACHwN,KAGR2C,kBAAmB,SAACpC,GAAD,OACjB,kBAAC,EAAD,eACE1H,SAAU,EAAKvG,MAAMsQ,kBACrBrQ,QAASgO,EACT/N,MAAOA,GACHwN,Q,EAMLvF,OAAS,kBACd,kBAAC,YAAD,CAAWoI,eAAe,IACvB,gBAAGrQ,EAAH,EAAGA,MAAH,OAAe,EAAK4M,eAAe5M,O,8EArSjB+M,GACrB,OAAIlN,KAAKC,MAAMwQ,iBAAmB3Q,EAAe4Q,iBAItC1Q,KAAKC,MAAMwQ,iBAAmB3Q,EAAe6Q,SAC/CzD,EAAc7M,IAAI,cAAgBL,KAAKC,MAAM2Q,W,kCAOtD1Q,EACAiN,EACAhN,GAEA,OACE,yBAAKS,IAAKuM,EAAOxM,UAAU,UAAUK,MAAO,CAAEb,UAC5C,kBAAC2M,EAAD,CACEE,SAAU9M,EACV0Q,SAAU5Q,KAAKC,MAAM2Q,SACrBH,eAAgBzQ,KAAKC,MAAMwQ,eAC3BI,0BAA2B7Q,KAAKC,MAAM4Q,0BACtC9I,UAAW/H,KAAKC,MAAM8H,UACtBkI,aAAcjQ,KAAKC,MAAMgQ,aACzBrC,gBAAiB5N,KAAKC,MAAM2N,gBAC5B2C,kBAAmBvQ,KAAKC,MAAMsQ,uB,+CAiBLO,GAC/B,OAAQA,GAAY9Q,KAAKC,MAAMwQ,iBAAmB3Q,EAAe6Q,U,uCAIjE3F,EACAkC,GAEA,OACGlC,GACAhL,KAAKC,MAAM4Q,2BACV7Q,KAAK+Q,eAAe7D,K,qDAKxBA,EACAC,EACAhN,GAEA,IAAMD,EAAUgN,EAAc7M,IAAI,WAC5B2Q,EAAYhR,KAAKyN,cACrBvN,EACAiN,EACAhN,EACA+M,EAAc7M,IAAI,aAGd4Q,EAAc/Q,EAAQG,IAAI,QAC1ByQ,EAA2B,UAAhBG,GAA2C,YAAhBA,EACtCjG,EAAShL,KAAKkR,yBAAyBJ,GACvCK,EAAUnR,KAAKoR,iBAAiBpG,EAAQkC,GACxCvM,EAAYmM,EAAMuE,cAAcF,EAASL,GAEzClQ,EADgBV,EAAQG,IAAI4Q,GACR5Q,IAAI,OAAS8M,EAEvC,OACE,kBAAC,GAAD,CAAOnC,OAAQA,EAAQpK,IAAKA,GAC1B,yBAAKD,UAAWA,EAAWK,MAAO,CAAEb,UAClC,kBAAC,EAAD,CAAeA,MAAOA,GACpB,kBAAC,WAAD,CACEmR,SACE,kBAACnD,EAAA,EAAD,CACEjO,QAASqR,YAAwB,cAAclR,IAAI,SACnDF,MAAOA,KAIV6Q,S,qCA3DgBG,EAAkBL,GAC7C,IAAM7N,EAAa,CAAC,qBAOpB,OANIkO,IAAYK,IAAkBC,cAChCxO,EAAW+B,KAAK,iBAEd8L,GACF7N,EAAW+B,KAAK,YAEX/B,EAAWyO,KAAK,S,GAhEPzQ,iB,SC9Dd0Q,I,mBAOJ,WAAY1R,GAAe,IAAD,uBACxB,4CAAMA,KAHA2R,WAAa7P,IAAMiE,YAED,EAsB1B6L,mBAAqB,SAACnH,GACpB,GAAI,EAAKkH,YAAc9I,OAAQ,CAAC,IACtBxC,EAAY,EAAKsL,WAAjBtL,QACAwL,EAAehJ,OAAfgJ,WAGNxL,IACCA,EAAQyL,SAASrH,EAAM7I,SACxBiQ,GAvCqB,QAyCrB,EAAK9K,SAAS,CAAEgL,kBAAkB,MAhCd,EAqC1BC,oBAAsB,WACpB,QAAKnJ,SAEkBA,OAAfgJ,YAjDiB,QAoDvB,EAAK9K,SAAS,CAAEgL,kBAAkB,KAE7B,IA7CiB,EAgD1BE,eAAiB,WAAa,IACpBF,EAAqB,EAAK7Q,MAA1B6Q,iBACAG,EAAa,EAAKlS,MAAlBkS,SAER,EAAKnL,SAAS,CAAEgL,kBAAmBA,IAAoB,WAAO,IACpDA,EAAqB,EAAK7Q,MAA1B6Q,iBAERG,EAASH,OAvDa,EA2DnB5J,OAAS,WAAqB,IAC3B4J,EAAqB,EAAK7Q,MAA1B6Q,iBACAlQ,EAAa,EAAK7B,MAAlB6B,SAEFsQ,EAAmBnP,IAAW,UAAW,CAC7C,cAAe+O,IAIjB,OACE,6BAASrR,UAAWyR,EAAkB/I,IAAK,EAAKuI,YAC9C,yBAAKjR,UAAU,mBACb,kBAAC,SAAD,CACE0R,SAAO,EACPC,QAAS,EAAKJ,eACdvR,UAAU,iBAEV,kBAAC4R,GAAA,EAAD,CAAM/R,KAAK,OAGZsB,GAEH,kBAAC,SAAD,CACEuQ,SAAO,EACPC,QAAS,EAAKJ,eACdvR,UAAU,4BAEV,kBAAC4R,GAAA,EAAD,CAAM/R,KAAK,qBAtFO,IAGhBsR,GAAehJ,QAAU,IAAzBgJ,WAHgB,OAKxB,EAAK3Q,MAAQ,CACX6Q,mBAAkBF,GACdA,GAhBmB,QASD,E,iFAaxBhJ,OAAO6B,iBAAiB,SAAU3K,KAAKiS,qBACvCO,SAAS7H,iBAAiB,YAAa3K,KAAK6R,sB,6CAI5C/I,OAAO2J,oBAAoB,SAAUzS,KAAKiS,qBAC1CO,SAASC,oBAAoB,YAAazS,KAAK6R,wB,GA1B7B5Q,kBAAhB0Q,GACUe,aAA+B,CAC3CP,SAAU,cAkGCR,ICxHHgB,GDwHGhB,M,oBENAiB,I,yNA3DLC,WAAa,kBAAgB,EAAK5S,MAAM+M,SAAS8F,QAAQC,W,EAE1D3K,OAAS,WAAkB,IACxB4K,EAAS,EAAK/S,MAAd+S,KAEFC,EAAsBhQ,IAAW,uBAAwB,CAC7D,SAAU+P,IAIZ,OACE,yBAAKrS,UAAWsS,GACb,EAAKJ,cACJ,kBAAC,GAAD,KACE,yBAAKlS,UAAU,mBACb,kBAAC,KAAD,CAAeuS,MAAOC,MACpB,kBAAC,GAAD,CACEnG,SAAU,EAAK/M,MAAM+M,SAAS8F,QAC9BlC,SAAU,EAAK3Q,MAAM2Q,SACrBH,eAAgB,EAAKxQ,MAAMwQ,eAC3BI,0BACE,EAAK5Q,MAAM4Q,0BAEb9I,UAAW,EAAK9H,MAAM8H,UACtB6F,gBAAiB,EAAK3N,MAAM2N,gBAC5BqC,aAAc,EAAKhQ,MAAMgQ,aACzBM,kBAAmB,EAAKtQ,MAAMsQ,uBAMxC,6BAAS5P,UAAU,OAAOyS,SAAU,GAClC,yBAAKzS,UAAU,mBACb,kBAAC,KAAD,CAAeuS,MAAOG,MACpB,kBAAC,GAAD,CACErG,SAAU,EAAK/M,MAAM+M,SAASsG,KAC9B1C,SAAU,EAAK3Q,MAAM2Q,SACrBH,eAAgB,EAAKxQ,MAAMwQ,eAC3BI,0BACE,EAAK5Q,MAAM4Q,0BAEb9I,UAAW,EAAK9H,MAAM8H,UACtB6F,gBAAiB,EAAK3N,MAAM2N,gBAC5BqC,aAAc,EAAKhQ,MAAMgQ,aACzBM,kBAAmB,EAAKtQ,MAAMsQ,sBAKpC,6CACY,uBAAG5O,KAAK,kBAAR,iB,6BApDGV,kB,6BDtDb0R,K,sBAAAA,E,4CAAAA,E,kBAAAA,E,gCAAAA,E,wBAAAA,E,iBAAAA,Q,KEIL,ICuCKY,GDvCCC,GAAb,iDACUC,iBADV,OAEUC,SAAW,EAFrB,KAGUC,UAAY,EAHtB,KAIUC,YAAa,EAJvB,uDAwBoBC,EAAqBC,GAAqB,IAAD,OACzD9T,KAAK+T,SACL/T,KAAK2T,UAAYK,KAAKC,MACtBjU,KAAK0T,SAAWI,EAChB9T,KAAK4T,YAAa,EAClB5T,KAAKyT,YAAc3K,OAAOoL,YAAW,WACnC,EAAKN,YAAa,EAClBC,MACCC,KAhCP,oCAqC6BxQ,IAArBtD,KAAKyT,cACP3K,OAAOqL,aAAanU,KAAKyT,aACzBzT,KAAKyT,iBAAcnQ,EACnBtD,KAAK4T,YAAa,KAxCxB,gCAQI,OAAO5T,KAAK4T,aARhB,oCAaI,IAAK5T,KAAK4T,WACR,OAAO,EAET,IAAMQ,EAAUJ,KAAKC,MAAQjU,KAAK2T,UAClC,OAAO7F,KAAKuG,IAAIrU,KAAK0T,SAAWU,EAAS,OAjB7C,K,qBEsFaE,I,OAAb,YAUE,WAAYrU,GAAe,IAAD,8BACxB,4CAAMA,KATAsU,sBAQkB,IAPlBC,aAOkB,IALTC,oBAAsB,IAAIjB,GAKjB,EAJTkB,iBAIS,IAyElBC,aAAe,WACrB,EAAK3N,SAAS,CACZ4N,gBAAiBN,EAAaO,oBA3ER,EA8OlBC,oBAAsB,WAC5B,EAAK9N,SAAS,CAAE+N,eAAe,KA/OP,EAkPlBC,sBAAwB,WAC9B,EAAKhO,SAAS,CAAE+N,eAAe,EAAOE,iBAAiB,IACvD,EAAKC,2BArQ+B,MAiBZ,EAuPlBC,sBAAwB,WAC9B,EAAKlV,MAAMmV,cAxPa,EA2PlBC,iBAAmB,WACzB,EAAKpV,MAAMqV,aAAY,IA5PC,EA+PlBC,uBAAyB,WAC/B,EAAKtV,MAAMqV,aAAY,IA7PvB,EAAKnU,MAAQ,CACXyT,gBAAiBN,EAAaO,iBAC9BI,iBAAiB,EACjBO,qBAAqB,EACrBT,eAAe,GAGjB,EAAKL,YAAc,CACjBe,EAAG,EAAKF,wBAXc,EAV5B,iFAuCoC,IAAD,OAC/BvV,KAAKuU,iBAAmBvU,KAAKC,MAAMyV,uBAAuBC,eAAeC,SACvE,SAAAnS,GAAC,OAAI,EAAKoS,mBAAmBpS,MAE/BqF,OAAO6B,iBAAiB,SAAU3K,KAAK2U,gBA3C3C,kDA+CkCrR,IAA1BtD,KAAKuU,mBACPvU,KAAKuU,iBAAiBuB,aACtB9V,KAAKuU,sBAAmBjR,GAG1BtD,KAAKyU,oBAAoBV,SAEzBjL,OAAO2J,oBAAoB,SAAUzS,KAAK2U,gBAtD9C,oCA0DI,OAAO3U,KAAKC,MAAM8V,kBAAoBpD,GAAgBqD,YA1D1D,yCA6D6BtL,GACN,wBAAfA,EAAMlK,OACRR,KAAKgH,SAAS,CAAEwO,qBAAqB,EAAMP,iBAAiB,IAC5DjV,KAAKkV,2BA3E+B,SAW1C,iDAoEqCe,GAAwB,IAAD,OAIpDA,EAAUjW,KAAKyU,oBAAoByB,eACrClW,KAAKyU,oBAAoBP,YAAW,WAClC,EAAKlN,SAAS,CAAEiO,iBAAiB,MAChCgB,KA3ET,+BA+FI,IAMIE,EACAC,EAPEC,EAAWrW,KAAKwU,QAEtB,OADAxU,KAAKwU,QAAUxU,KAAKsW,eACJ,MAAZD,GAAoC,MAAhBrW,KAAKwU,QACpB,MAKW,MAAhBxU,KAAKwU,SACP2B,GAAY,EACZC,EAAapW,KAAKwU,UAElB2B,GAAY,EACZC,EAAaC,GAMb,kBAAC,iBAAD,CACEE,QAAQ,EACRC,GAAIL,EACJF,QAAS,IACTQ,eAAe,EACfxT,WAAW,gBAEX,yBAAKrC,IAAI,gBAAgBwV,OAzHjC,qCA+HI,GAAIpW,KAAK0W,cAAe,CACtB,GACE1W,KAAKC,MAAMwQ,iBAAmB3Q,EAAe6Q,SAC7C3Q,KAAKC,MAAMwQ,iBAAmB3Q,EAAe4Q,gBAO7C,OAAO1Q,KAAK2W,wBACP,IACJC,MACD5W,KAAKmB,MAAMqU,oBAEX,OAAOxV,KAAK6W,0BAIhB,OAAO7W,KAAK8W,2BAlJhB,+CAuJI,IAAMC,EAAKzC,EAAa0C,qBAAqBhX,KAAKC,MAAM8V,iBACxD,YAAWzS,IAAPyT,EACK,KAIP,6BACE,yBACEE,GAAG,mBACHtW,UAAWX,KAAKmB,MAAMyT,gBAAkB,YAAc,IAEtD,kBAACrC,GAAA,EAAD,CAAM5R,UAAU,OAAOH,KAAMuW,EAAGG,OAChC,+BAAQH,EAAGI,QAEb,kBAAC,sBAAD,CAAqBC,UAAU,SAASvV,OAAO,oBAC5CkV,EAAGM,YAtKd,8CA8KI,IAAMC,EACJtX,KAAKC,MAAMwQ,iBAAmB3Q,EAAeyX,eACzCC,EAAalD,EAAamD,aAC9BH,EAAgB,cAAgB,OAChCA,EACAtX,KAAKmV,uBAGP,OACE,yBACE8B,GAAG,eACHtW,UACEX,KAAKmB,MAAMyT,gBAAkB,8BAAgC,IAG/D,yBACEjU,UAAU,oBACVmD,IAAK4T,KACLC,IAAI,eAEN,6CACCH,EACAxX,KAAKmB,MAAMyT,gBACV,kBAAC,sBAAD,CAAqBwC,UAAU,SAASvV,OAAO,gBAA/C,oCAIA,MAzMV,gDAoNI,IAAM+V,EACJ5X,KAAKC,MAAMwQ,iBAAmB3Q,EAAe4Q,gBACzCmH,EAAY7X,KAAKmB,MAAM8T,kBAAoBjV,KAAKmB,MAAM4T,cAI5D,OACE,kBAAC,UAAD,CAAS+C,SAAU9X,KAAK0U,YAAaqD,OAAQjP,OAAQkP,SAAS,GAC5D,yBACEC,aAAcjY,KAAK8U,oBACnBoD,aAAclY,KAAKgV,uBAEnB,yBACEiC,GAAG,eACHtW,UAAWkX,EAAY,yBAA2B,IAElD,kBAACtF,GAAA,EAAD,CAAM5R,UAAU,OAAOH,KAAK,SAC5B,2BAAOG,UAAU,UAAjB,wBAEC2T,EAAamD,aACZ,yBAAK9W,UAAU,wBAAf,SACAiX,EACA5X,KAAKqV,kBAGNf,EAAamD,aACZ,yBAAK9W,UAAU,wBAAf,gBACAiX,EACA5X,KAAKuV,8BAhPnB,gDA6ByCtV,GAGrC,OAAIA,EAAMwQ,iBAAmB3Q,EAAe6Q,QACnC,CAAE6E,qBAAqB,EAAOT,eAAe,GAG/C,OApCX,uCAgFI,OAAOjM,OAAOqP,QAAU,KAhF5B,mCA8QI1O,EACAP,EACAoJ,GAEA,OACE,kBAAC,SAAD,CACED,SAAO,EACPzP,KAAK,KACLwV,MAAM,OACNlP,SAAUA,EACVoJ,QAASA,GAET,6BAAM7I,MA1Rd,2CAgSItI,GAEA,OAAQA,GACN,KAAKwR,GAAgB0F,QACrB,KAAK1F,GAAgB2F,eACrB,KAAK3F,GAAgB4F,WACnB,MAAO,CACLrB,KAAM,WACNC,MAAO,aACPE,QAAS,kCAGb,KAAK1E,GAAgBqD,UACrB,KAAKrD,GAAgB6F,OACnB,OAEF,KAAK7F,GAAgB8F,qBACrB,QACE,MAAO,CACLvB,KAAM,UACNC,MAAO,QACPE,QAAS,8CArTnB,GAAkCpW,kBCtDnByX,GA5BU,SAAC,GAGC,IAFzBC,EAEwB,EAFxBA,gBACArG,EACwB,EADxBA,QAEA,MAAwB,cAApBqG,EAEA,kBAAC,eAAD,CAAcrG,QAASA,GACrB,mDACA,0BAAM3R,UAAU,YAAhB,QAKkB,cAApBgY,EAEA,kBAAC,eAAD,CAAcrG,QAASA,EAAS3R,UAAU,kBACxC,8BACE,mDAGF,0BAAMA,UAAU,YAAhB,QAKC,kBAAC,eAAD,CAAc2R,QAASA,GAAvB,wBC0HMsG,I,mBArGb,WAAY3Y,GAAe,IAAD,8BACxB,4CAAMA,KAMR4Y,OAAS,WACP,EAAK7R,UAAS,kBAAuB,CACnC8R,cADY,EAAGA,kBARO,EAa1BC,wBAA0B,SAACvQ,GAAD,OAAiB,WACzCM,OAAOkQ,KAAKxQ,EAAK,YAZjB,EAAKrH,MAAQ,CACX2X,cAAc,GAHQ,E,sEAkBxB,IAAMG,GAAwBjZ,KAAKC,MAAMiZ,oBAEzC,OACE,kBAAC,WAAD,CACEjC,GAAG,WACHkC,OAAQnZ,KAAKmB,MAAM2X,aACnBD,OAAQ7Y,KAAK6Y,QAEb,kBAAC,iBAAD,CAAgBxG,SAAO,EAAC+F,MAAM,YAAYnB,GAAG,kBAC3C,kBAAC1E,GAAA,EAAD,CAAM/R,KAAK,SAEqB,cAA/BR,KAAKC,MAAM0Y,iBACV,0BAAMhY,UAAU,yBAIpB,kBAAC,eAAD,CAAcyY,OAAK,GACjB,kBAAC,eAAD,CACElQ,SAAU+P,EACV3G,QAAStS,KAAKC,MAAMoZ,oBAEpB,uCACA,0BAAM1Y,UAAU,YAAhB,MAGF,kBAAC,eAAD,CACEuI,SAAU+P,EACV3G,QAAStS,KAAKC,MAAMqZ,oBAEpB,6CACA,0BAAM3Y,UAAU,YAAhB,MAGF,kBAAC,eAAD,CAAc4Y,SAAO,IAErB,kBAAC,GAAD,CACEZ,gBAAiB3Y,KAAKC,MAAM0Y,gBAC5BrG,QAAStS,KAAKC,MAAMuZ,qBAIrBxZ,KAAKC,MAAMwZ,gBACV,kBAAC,eAAD,CACEvQ,SAAU+P,EACV3G,QAAStS,KAAKC,MAAMyZ,eAFtB,mBAQF,kBAAC,eAAD,CAAcH,SAAO,IAErB,kBAAC,eAAD,CACEjH,QAAStS,KAAK+Y,wBAjHF,8BAgHd,iBAMA,kBAAC,eAAD,CAAczG,QAAStS,KAAK+Y,wBArHhB,iCAqHZ,kBAIA,kBAAC,eAAD,CAAczG,QAAStS,KAAK+Y,wBAvHtB,6DAuHN,gBAIA,kBAAC,eAAD,CAAcQ,SAAO,IAErB,kBAAC,eAAD,CAAcjH,QAAStS,KAAK+Y,wBA9HpB,kCA8HR,uBAIA,kBAAC,eAAD,CAAczG,QAAStS,KAAKC,MAAM0Z,kBAAlC,YAIA,kBAAC,eAAD,CAAcrH,QAAStS,KAAKC,MAAM2Z,eAAlC,e,GAlGa3Y,kB,qBClCV4Y,GAAb,YAKE,WAAY5Z,GAAe,IAAD,8BACxB,4CAAMA,KALSyU,iBAIS,IA4ClBoF,MAAQ,WACd,EAAK7Z,MAAM8Z,SAAQ,IA7CK,EAgDlBC,YAAc,WACpB,EAAK/Z,MAAM8Z,SAAQ,IA9CnB,EAAKrF,YAAc,CACjBe,EAAG,EAAKuE,aAJc,EAL5B,sEAmBI,OACE,kBAAC,UAAD,CAASlC,SAAU9X,KAAK0U,YAAaqD,OAAQjP,OAAQkP,SAAS,GAC5D,kBAACiC,GAAD,CAAaC,QAASla,KAAKC,MAAMia,SAC/B,kBAAC,cAAD,CAAarB,OAAQ7Y,KAAKC,MAAMia,SAAhC,eACA,kBAAC,YAAD,KACE,qFAEF,kBAAC,cAAD,KACE,kBAAC,SAAD,CACEvZ,UAAU,uBACV0R,SAAO,EACP+F,MAAM,YACN9F,QAAStS,KAAKga,aAJhB,gBAOU,IACV,kBAAC,SAAD,CACErZ,UAAU,uBACV0R,SAAO,EACP+F,MAAM,UACN9F,QAAStS,KAAK8Z,OAJhB,gBAnCZ,GAAyC7Y,iB,SCD5BkZ,GAAb,YAGE,WAAYla,GAAe,IAAD,8BACxB,4CAAMA,KAHAma,eAEkB,IAUnBhS,OAAS,WACd,OACE,gBAAC,QAAD,CACE+Q,QAAQ,EACRN,OAAQ,EAAKwB,wBACbC,SAAU,EAAKC,kBAEf,gBAAC,cAAD,CAAa1B,OAAQ,EAAKwB,yBAA1B,YAIA,gBAAC,YAAD,KACE,6BACE,yBACEnR,UAAW,EAAKjJ,MAAMiZ,kBACtB1Y,KAAK,WACLJ,KAAK,YACLoa,QAAS,EAAKrZ,MAAMsZ,WAAa,EAAKxa,MAAMiZ,kBAC5C/G,SAAU,EAAKuI,uBACd,IAPL,eAUA,2BACA,6BACE,yBACEla,KAAK,WACLJ,KAAK,WACLoa,QAAS,EAAKrZ,MAAMwZ,SACpBxI,SAAU,EAAKuI,uBACd,IANL,0BAWF,gBAAC,cAAD,KACE,gBAAC,SAAD,CACErI,SAAO,EACP+F,MAAM,YACN9F,QAAS,EAAK+H,yBAHhB,UAOA,gBAAC,SAAD,CAAQhI,SAAO,EAAC+F,MAAM,UAAU9F,QAAS,EAAKsI,uBAA9C,WApDkB,EA4DlBL,iBAAmB,WACzB,EAAKvT,SAAL,eAAmB,EAAKoT,aA7DA,EAgElBS,oBAAsB,SAACza,EAAcwH,GAI3C,EAAKZ,UAAS,SAAA7F,GAAK,sBAAUA,EAAV,gBAAkBf,EAAOwH,QApEpB,EAuElB8S,qBAAuB,SAACjX,GAC9B,EAAKoX,oBAAoBpX,EAAE5B,OAAOzB,KAAMqD,EAAE5B,OAAO2Y,UAxEzB,EA2ElBH,wBAA0B,WAGhC,EAAKpa,MAAMia,WA9Ea,EAiFlBU,sBAAwB,WAC9B,EAAKR,UAAL,eAAsB,EAAKjZ,OAC3B,EAAKlB,MAAM6a,OAAO,EAAKV,WACvB,EAAKna,MAAMia,WAhFX,EAAK/Y,MAAL,eAAkB,EAAKlB,MAAM8a,UAG7B,EAAKX,UAAL,eAAsB,EAAKna,MAAM8a,UAPT,EAH5B,2BAAoC9Z,iB,gBLwC7B,SAAS+Z,GAAgBC,GAC9B,OAAQA,EAAYza,MAClB,KAAK+S,GAAW2H,MACd,OAgCejb,EAhCIgb,EAkCrB,kBAAChB,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,cAAD,CAAarB,OAAQ5Y,EAAMia,SAA3B,SACA,kBAAC,YAAD,KACE,2CACciB,KAAY7U,QAAQ8U,iBAChC,6BACA,uBAAGzZ,KAAK,wBAAR,wBACA,6BAJF,uDAQF,kBAAC,cAAD,KACE,kBAAC,SAAD,CAAQ0Q,SAAO,EAAC+F,MAAM,UAAU9F,QAASrS,EAAMia,SAA/C,WA7CJ,KAAK3G,GAAW8H,YACd,OAsEN,SAA0Bpb,GACxB,IAAMyU,EAAc,CAClB4G,MAAO,kBAAMrb,EAAMsb,kBAKrB,OACE,kBAAC,UAAD,CAASzD,SAAUpD,EAAaqD,OAAQjP,QACtC,kBAACmR,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,YAAD,KACE,mEACqC,2CADrC,qBAKF,kBAAC,cAAD,KACE,kBAAC,SAAD,CAAQ7H,SAAO,EAAC+F,MAAM,YAAY9F,QAASrS,EAAMia,SAAjD,UAEU,IACV,kBAAC,SAAD,CAAQ7H,SAAO,EAAC+F,MAAM,UAAU9F,QAASrS,EAAMub,iBAA/C,kBA1FGC,CAAiBR,GAC1B,KAAK1H,GAAWmI,aACd,OAuHN,SAA2Bzb,GACzB,IAAMyU,EAAc,CAClB4G,MAAO,kBAAMrb,EAAMsb,kBAKrB,OACE,kBAAC,UAAD,CAASzD,SAAUpD,EAAaqD,OAAQjP,QACtC,kBAACmR,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,YAAD,KACE,yBAAKvZ,UAAU,gBAAf,iBACA,6BACE,8BACEgb,WAAS,EACThb,UAAU,eACViH,MAAO3H,EAAM2b,iBACbzJ,SAAU,SAAAzH,GAAK,OAAIzK,EAAM4b,eAAenR,EAAM7I,OAAO+F,YAI3D,kBAAC,cAAD,KACE,kBAAC,SAAD,CAAQyK,SAAO,EAAC+F,MAAM,YAAY9F,QAASrS,EAAMia,SAAjD,UAEU,IACV,kBAAC,SAAD,CACE7H,SAAO,EACP+F,MAAM,UACN9F,QAAS,kBAAMrS,EAAM6b,kBAHvB,YAhJGC,CAAkBd,GAC3B,KAAK1H,GAAWyI,SACd,OA4LN,SAAwB/b,GACtB,OAAO,kBAAC,GAAmBA,GA7LhBgc,CAAehB,GACxB,KAAK1H,GAAW2I,eACd,OAAO,kBAAC,GAAwBjB,GAClC,KAAK1H,GAAW4I,qBACd,OA6JN,SACElc,GAEA,OACE,kBAACga,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,cAAD,CAAarB,OAAQ5Y,EAAMia,SAA3B,0BACA,kBAAC,YAAD,KACE,6BACE,6BACE,8BACGja,EAAM0O,UAAY1O,EAAM0O,UAAUnN,QAAU,iBAKrD,kBAAC,cAAD,KACE,kBAAC,SAAD,CAAQ6Q,SAAO,EAAC+F,MAAM,UAAU9F,QAASrS,EAAMia,SAA/C,WA7KKkC,CAAyBnB,GAClC,KAAK1H,GAAW8I,gBACd,OAmMN,SAA8Bpc,GAC5B,OACE,kBAACga,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,YAAD,KACE,yBAAKvZ,UAAU,+BAAf,0BAGA,6BACE,kBAAC,WAAD,CAAU2b,UAAQ,EAAC1U,MAAO3H,EAAMkP,cA3M7BoN,CAAqBtB,GAC9B,KAAK1H,GAAWiJ,SACd,OAyNN,SAAwBvc,GACtB,OACE,kBAACga,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,YAAD,KACE,yBAAKvZ,UAAU,+BAAf,0BAGA,yBAAKsW,GAAG,wBACN,uBAAGtV,KAAM1B,EAAMuI,IAAK3G,OAAO,SAASD,IAAI,uBACrC3B,EAAMuI,OAIb,kBAAC,cAAD,KACE,kBAAC,KAAD,CAAiB6G,KAAMpP,EAAMuI,IAAKiU,OAAQxc,EAAMia,SAC9C,kBAAC,SAAD,CAAQ7H,SAAO,EAAC1R,UAAU,WAA1B,sBAGiB,IACnB,kBAAC,SAAD,CACE0R,SAAO,EACPC,QAAS,WACPxJ,OAAOkQ,KAAK/Y,EAAMuI,IAAK,UACvBvI,EAAMia,YAJV,QASA,kBAAC,SAAD,CAAQ7H,SAAO,EAACC,QAASrS,EAAMia,SAA/B,UArPKwC,CAAezB,GACxB,KAAK1H,GAAWoJ,QACd,OAqQN,SAAuB1c,GACrB,OACE,kBAACga,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,cAAD,KAAcja,EAAMwJ,OACpB,kBAAC,YAAD,KAAYxJ,EAAM2c,KAClB,kBAAC,cAAD,KACE,kBAAC,SAAD,CAAQvK,SAAO,EAACC,QAASrS,EAAMia,SAA/B,UA3QK2C,CAAc5B,GACvB,UAAK3X,EACH,OAmSN,YAA8E,IAA1D4W,EAAyD,EAAzDA,QAClB,OAAO,kBAACD,GAAD,CAAaC,QAASA,IApSlB4C,CAAS7B,GAClB,QACE,OA6SN,SAAiChb,GAC/B,OACE,kBAACga,GAAD,CAAaC,QAASja,EAAMia,SAC1B,kBAAC,YAAD,4BAA4Bja,EAAMO,KAAlC,uBAhTOuc,CAAwB9B,GAYrC,IAAqBhb,EAmQd,SAASga,GAAT,GAMW,IALhBnY,EAKe,EALfA,SACAoY,EAIe,EAJfA,QAKMf,OAAsB7V,IAAbxB,EACf,OACE,kBAAC,QAAD,CAAOqX,OAAQA,EAAQN,OAAQqB,EAASvZ,UAAU,oBAC/CmB,I,SA5TKyR,K,cAAAA,E,yBAAAA,E,2BAAAA,E,oBAAAA,E,+BAAAA,E,0CAAAA,E,iCAAAA,E,oBAAAA,E,mBAAAA,Q,mEMnCL,SAASyJ,GACdpM,EACAqM,GACS,IACDC,EAAa1U,KAAIhF,MAAMsF,OAAOC,SAASpH,MAAM,GAA7Cub,SAEJC,EAAe,GACH,MAAZD,IAOFC,EAAeD,EAASE,UAAU,EAAGF,EAASG,YAAY,OAGzCC,WAAW,OAC1BH,EAAeA,EAAaC,UAAU,IAI1C,IAAMG,EAAU,kBAAc3M,EAAd,YAA0BqM,GAC1C,MAAwB,KAAjBE,EAAA,WACCI,GADD,WAECJ,EAFD,YAEiBI,GASnB,SAAeC,GAAtB,qC,gDAAO,WACL5M,EACAqM,GAFK,kBAAAxH,EAAA,sEAIkBgI,MACrBT,GAAoBpM,EAAUqM,GAC9BS,MANG,WAICC,EAJD,QASSC,GATT,oBAUqB,MAApBD,EAASE,OAVV,sBAYK,IAAIlY,MAAM,mBAZf,wBAc0BgY,EAAStO,OAdnC,cAcKyO,EAdL,OAeK,IAAInY,MACR,4BAAqBgY,EAASE,OAA9B,+BACoBC,IAjBrB,iCAsBEH,GAtBF,6C,sBClBA,IAAMI,GAAb,WACE,WAAY9d,GAAe,oBACzBA,EAAM+d,wBAAwBrL,GAAgB6F,QAG9CuF,EAAiBE,eAAehe,GALpC,2GAQsCA,GARtC,8EASYie,EAAgBje,EAAMke,SAAtBD,YAECE,EAAS,EAXtB,YAWyBA,EAASF,GAXlC,0CAa+BV,GAAgBvd,EAAM2Q,SAAP,UAAoBwN,EAApB,QAb9C,cAacT,EAbd,gBAckCA,EAASU,cAd3C,OAccA,EAdd,OAeQpe,EAAMqe,UAAUC,KAAWC,OAAO,IAAIC,WAAWJ,KAfzD,kDAiBQ9c,YAAS,yBAAD,OAA0B6c,EAA1B,oBAjBhB,QAW+CA,IAX/C,uI,qBCpBMM,G,WAQJ,WAAY9B,EAAiB+B,GAAyB,yBAPtC/B,SAOqC,OAN9C+B,eAAiB,EAOtB3e,KAAK4c,IAAMA,EACX5c,KAAK2e,eAAiBA,E,mDANVC,GACZ,OAAOA,EAAoB5e,KAAK2e,mB,KAYvBE,GAAb,WAeE,WAAY/U,GAA+C,yBAd1CgV,SAAW,IAAI9U,IAc0B,KARzCF,kBAQyC,OAFlD6U,eAAiB,EAGvB3e,KAAK8J,aAAeA,EAhBxB,8DA6B2BiV,GAA8B,IAAD,OACpD/e,KAAK2e,gBAAkB,EAIvB3e,KAAK8e,SAASE,SAAQ,SAACC,EAAOC,GACxBD,EAAME,OAAO,EAAKR,gBAAkBI,IACtCK,YAAW,qCAAD,OAAsCF,EAAtC,MACV,EAAKJ,SAASzU,OAAO6U,SArC7B,uFAqDqCtC,GArDrC,2EAsDI5c,KAAKqf,kBAAkBzC,GAEN,YAAbA,EAAIpc,KAxDZ,yCAyDaoc,GAzDb,UA6DkB,OADV0C,EAAStf,KAAKuf,iBAAiB3C,EAAI4C,SAAS,IA5DpD,gBA8DMJ,YAAW,+BAAD,OAAgCxC,EAAI4C,QAApC,MA9DhB,8BAiEMJ,YAAW,gCAAD,OAAiCxC,EAAI4C,QAArC,MAjEhB,UAkEqBxf,KAAKyf,oBAAoB7C,EAAI4C,SAlElD,QAkEMF,EAlEN,OAmEMtf,KAAKqf,kBAAkBC,GAnE7B,WAuES1C,EAAIlP,SAvEb,uBAwEY,IAAI/H,MAAM,8BAxEtB,eA0EI2Z,EAAO5R,SAAWgS,KAAmBC,OAAO/C,EAAIlP,UA1EpD,kBA2EW4R,GA3EX,6LAqFoCJ,GArFpC,wFAuFsB5b,KADZsc,EAAY5f,KAAK8J,gBAtF3B,sBAwFY,IAAInE,MACR,+DAzFR,cA6FU6C,EAAMgC,aAAaoV,EAAD,uBAA4BV,IA7FxD,SA8FsBzB,MAAMjV,GA9F5B,WA8FUqX,EA9FV,QA+FajC,GA/Fb,sBAkGY,IAAIjY,MAAJ,8CACmCuZ,EADnC,cAC6CW,EAAIC,aAnG7D,wBAuGuBD,EAAIxB,cAvG3B,eAuGUxX,EAvGV,OAwGUwX,EAAc,IAAII,WAAW5X,GAxGvC,4BA0Ga0X,KAAWC,OAAOH,IA1G/B,yCA4GY,IAAI1Y,MAAJ,4CACiCuZ,EADjC,cAC2C,KAAE1d,UA7GzD,0JAqH4Bob,GACP,YAAbA,EAAIpc,MAQHoc,EAAIlP,UAAakP,EAAIlP,SAASqS,gBAKWzc,IAA1CtD,KAAKuf,iBAAiB3C,EAAIsC,MAAM,KAQpCE,YAAW,4BAAD,OAA6BxC,EAAIsC,KAAjC,MACVlf,KAAK8e,SAAS1U,IACZwS,EAAIsC,KACJ,IAAIR,GAAWH,KAAWoB,OAAO/C,GAAM5c,KAAK2e,oBA9IlD,uCA0JIO,EACAc,GAEA,IAAMC,EAASjgB,KAAK8e,SAASze,IAAI6e,GACjC,GAAc,MAAVe,EAOJ,OAHID,IACFC,EAAOtB,eAAiB3e,KAAK2e,gBAExBJ,KAAWoB,OAAOM,EAAOrD,SArKpC,KClBqBsD,GAKnB,aAAe,IAAD,gCAJPC,aAIO,OAHPC,YAGO,OAFPC,aAEO,EAEZrgB,KAAKmgB,QAAU,aACfngB,KAAKogB,OAAS,aAEdpgB,KAAKqgB,QAAU,IAAIC,SAAW,SAACC,EAAOC,GACpC,EAAKL,QAAUI,EACf,EAAKH,OAASI,MCDdC,GAAM,sBAkGCC,GAAb,WAiDE,WAAYzgB,GAAc,IAAD,gCAhDRmH,UAgDQ,OA1CRuZ,WA0CQ,OArCjBC,SAAW,EAqCM,KA/BjBC,4BAA8B,EA+Bb,KA1BjBC,iBAAmB,EA0BF,KApBjBC,aAA6B,GAoBZ,KAfjB5f,MAAQwR,GAAgB0F,QAeP,KAVjB2I,eAUiB,OAFjBC,2BAEiB,EACvBjhB,KAAKoH,KAAOnH,EACZD,KAAK2gB,MAAQ,IAAI9B,IAAgB,kBAAM,EAAKqC,qBAC5ClhB,KAAKmhB,QAAQ,eApDjB,8DA4DI,GAAInhB,KAAKmB,QAAUwR,GAAgBqD,UACjC,OAAOhW,KAAKoH,KAAKga,iBAAiBphB,KAAK4gB,YA7D7C,kCAmEsBzf,EAAwBkgB,GAM1C,OALAjC,YAAWqB,GAAD,qBAAoBtf,IAC9BnB,KAAKmB,MAAQA,EACbnB,KAAKoH,KAAK4W,wBAAwB7c,EAAOkgB,GAGjCrhB,KAAKmB,OACX,KAAKwR,GAAgB2F,eACnBtY,KAAKshB,aACL,MAEF,KAAK3O,GAAgB4F,WACnBvY,KAAKuhB,qBACL,MAEF,KAAK5O,GAAgB8F,qBACnBzY,KAAKwhB,0BACL,MAEF,KAAK7O,GAAgBqD,UACrB,KAAKrD,GAAgB0F,YAvF3B,8BAqGkB3N,EAAc2W,GAG5B,GAFAjC,YAAWqB,GAAD,iBAAgBzgB,KAAKmB,MAArB,oBAAsCuJ,IAGpC,gBAAVA,GACA1K,KAAKmB,QAAUwR,GAAgB8F,qBAFjC,CAaA,OAAQzY,KAAKmB,OACX,KAAKwR,GAAgB0F,QACnB,GAAc,gBAAV3N,EAEF,YADA1K,KAAKyhB,YAAY9O,GAAgB4F,YAGnC,MAEF,KAAK5F,GAAgB4F,WACnB,GAAc,yBAAV7N,EAEF,YADA1K,KAAKyhB,YAAY9O,GAAgBqD,WAE5B,GACK,yBAAVtL,GACU,qBAAVA,GACU,sBAAVA,EAGA,YADA1K,KAAKyhB,YAAY9O,GAAgB2F,gBAGnC,MAEF,KAAK3F,GAAgBqD,UACnB,GAAc,sBAAVtL,GAA2C,qBAAVA,EAEnC,YADA1K,KAAKyhB,YAAY9O,GAAgB2F,gBAGnC,MAEF,KAAK3F,GAAgB2F,eACnB,GAAc,0BAAV5N,EAEF,YADA1K,KAAKyhB,YAAY9O,GAAgB4F,YAGnC,MAEF,KAAK5F,GAAgB8F,qBASnB,YAJAhR,YACEgZ,GADQ,qBAEM/V,EAFN,qBAEwBiI,GAAgB8F,uBAQtD,MAAM,IAAI9S,MACR,mDACY3F,KAAKmB,MADjB,uBAEYuJ,IA7DZ1K,KAAKyhB,YAAY9O,GAAgB8F,qBAAsB4I,KA9G7D,oKAgLUK,EAAO1hB,KAAKoH,KAAKga,iBAAiBve,KAAI,SAAC8e,EAAGC,GAAJ,OAC1CpX,aAAa,EAAKpD,KAAKga,iBAAiBQ,GA9QrB,cA6FzB,SAoL0BC,GACpBH,EAxQuB,IA0QvB1hB,KAAKoH,KAAK0a,SAvLhB,OAoLI9hB,KAAK4gB,SApLT,OA0LI5gB,KAAKmhB,QAAQ,yBA1LjB,iJA6LsC,IAAD,OAC3BY,EAAMC,aACVhiB,KAAKoH,KAAKga,iBAAiBphB,KAAK4gB,UAvRR,UA2R1B,GAAsB,MAAlB5gB,KAAKghB,UAGP,MAAM,IAAIrb,MAAM,4BAGlByZ,YAAWqB,GAAK,sBAChBzgB,KAAKghB,UAAY,IAAIiB,UAAUF,GAE/B/hB,KAAKkiB,qBAAqBH,GAE1B,IAAMI,EAAiBniB,KAAKghB,UACtBoB,EAAiB,kBAAeD,IAAmB,EAAKnB,WAE9DhhB,KAAKghB,UAAUqB,UAAY,SAAC3X,GACtB0X,KACF,EAAKE,cAAc5X,EAAM7D,MAAM0b,OAAM,SAAAC,GACnC,IAAMvZ,EAAG,iDAA6CuZ,EAA7C,KACTjhB,YAASkf,GAAKxX,GACd,EAAKkY,QAAQ,cAAelY,OAKlCjJ,KAAKghB,UAAUyB,OAAS,WAClBL,MACFhD,YAAWqB,GAAK,oBAChB,EAAKU,QAAQ,0BAIjBnhB,KAAKghB,UAAU0B,QAAU,WACnBN,MACFhD,YAAWqB,GAAK,qBAChB,EAAKe,0BACL,EAAKL,QAAQ,uBAIjBnhB,KAAKghB,UAAU2B,QAAU,WACnBP,MACFhD,YAAWqB,GAAK,qBAChB,EAAKe,0BACL,EAAKL,QAAQ,wBA9OrB,2CAmP+BY,GAAoB,IAAD,OAC9C,GAAkC,MAA9B/hB,KAAKihB,sBAGP,MAAM,IAAItb,MAAM,6BAGlB,IAAMwc,EAAiBniB,KAAKghB,UAE5BhhB,KAAKihB,sBAAwBnY,OAAOoL,YAAW,WAC7C,GAAIiO,IAAmB,EAAKnB,UAA5B,CAIA,GAAkC,MAA9B,EAAKC,sBAMT,OAAsB,MAAlB,EAAKD,WAIP,EAAKQ,+BACL,EAAKL,QAAQ,cAAe,gDAII,IAA9B,EAAKH,UAAU4B,aACjBxD,YAAWqB,GAAD,UAASsB,EAAT,eACV,EAAKP,0BACL,EAAKL,QAAQ,0BAhBb1Z,YAAWgZ,GAAK,uCAhVK,KAmWzBrB,YAAWqB,GAAD,yBAAwBzgB,KAAKihB,0BAtR3C,gDAgSQjhB,KAAKghB,YACPhhB,KAAKghB,UAAU6B,QACf7iB,KAAKghB,eAAY1d,GAGe,MAA9BtD,KAAKihB,wBACP7B,YAAWqB,GAAD,8BAA6BzgB,KAAKihB,wBAC5CnY,OAAOqL,aAAanU,KAAKihB,uBACzBjhB,KAAKihB,2BAAwB3d,KAxSnC,kCAgTqBoG,GACjB,GAAK1J,KAAKghB,UAAV,CAGA,IAAMpE,EAAMkG,KAAQnD,OAAOjW,GACrBqZ,EAASD,KAAQE,OAAOpG,GAAKqG,SACnCjjB,KAAKghB,UAAUkC,KAAKH,MAtTxB,oDA6TuChE,GACnC/e,KAAK2gB,MAAMwC,kBAAkBpE,KA9TjC,+EAiU8BlY,GAjU9B,uFAmUUuc,EAAepjB,KAAK8gB,iBAC1B9gB,KAAK8gB,kBAAoB,EApU7B,SAuUyBuC,GAAcxc,GAvUvC,UAuUUyc,EAvUV,OAwU6B,MAArBtjB,KAAK+gB,aAxUb,sBAyUY,IAAIpb,MAAM,qBAzUtB,UA4UkB,MAAV2d,GAAoC,kBAAXA,EA5UjC,sBA6UY,IAAI3d,MAAJ,6CAAgD2d,EAAhD,MA7UZ,cAgVUC,EAAc,IAAI9E,WAAW6E,GAC7B1G,EAAM2B,KAAWC,OAAO+E,GAjVlC,UAkV4CvjB,KAAK2gB,MAAM6C,sBACjD5G,GAnVN,QA0VI,IARA5c,KAAK+gB,aAAaqC,GAlVtB,OA0VWpjB,KAAK6gB,2BAA6B,KAAK7gB,KAAK+gB,cAC3C0C,EAAuBzjB,KAAK6gB,2BAA6B,EAC/D7gB,KAAKoH,KAAKkX,UAAUte,KAAK+gB,aAAa0C,WAC/BzjB,KAAK+gB,aAAa0C,GACzBzjB,KAAK6gB,2BAA6B4C,EA9VxC,+GAwWA,SAAS5B,GACP6B,EACAC,EACAC,GAEA,IAAMC,EAAW,IAAI3D,GACjB4D,EAAa,EACbC,EAAY,EACZC,EAAehQ,KAAKC,MAGpB2B,EAAU,aAERqO,EAAmB,aACvBF,GACiBL,EAAQQ,SACvBH,EAAY,GAGdnO,KAMIuO,EAAQ,SAACC,GACb,IAAMC,GAAerQ,KAAKC,MAAQ+P,GAAgB,IAC5CM,EAAeD,EAAcV,EAAYA,EAAYU,EAAc,EAEzET,EAAcE,EAAYM,GAE1Btb,OAAOoL,WAAW+P,EAAkBK,IAGhCC,EAA4B,WAGhC,GAAqB,cAFT,IAAIC,IAAId,EAAQK,IAEpBU,SAA0B,CAChC,IAAMC,EAAcvJ,KAAYwJ,QAC5BxJ,KAAY7U,QAAQoe,YACpB,8BACJP,EACE,kBAAC,WAAD,KACE,mIAIA,6BACE,0BAAMxjB,UAAU,QAAQ+jB,WAK9BP,EAAM,qCAoEV,OAnDAvO,EAAU,WACR,IAAMmM,EAAM2B,EAAQK,GACpB3E,YAAWqB,GAAD,mCAAkCsB,EAAlC,MACViC,EAAehQ,KAAKC,MAEF,IAAd8P,GACFD,IAGFc,KACGvkB,IAAI0hB,EAAK,CACR9L,QAAS0N,IAEVkB,MAAK,WACJhB,EAAS1D,QAAQ4D,MAElBxB,OAAM,SAAAnhB,GACL,GAAmB,iBAAfA,EAAM0jB,KACR,OAAOX,EAAM,yBAGf,GAAI/iB,EAAMuc,SAAU,OAIOvc,EAAMuc,SAAvB9W,EAJU,EAIVA,KAAMgX,EAJI,EAIJA,OAEd,OAAiC,IAA7BA,EACK0G,IACa,MAAX1G,OAzCjBsG,EACE,kBAAC,WAAD,KACE,8EACA,mIAEyC,IACvC,uBAAGxiB,KA9eX,0DA8eQ,QAHF,gBAyCWwiB,EACL,wCAAiCtG,EAAjC,8BACmBhX,EADnB,OAIC,OAAIzF,EAAM2jB,QAIRR,IAGAJ,EAAM/iB,EAAMI,gBAOpBqiB,EAASxD,QAMlB,SAASgD,GAAcxc,GACrB,OAAO,IAAIyZ,SAAa,SAACH,EAASC,GAChC,IAAM4E,EAAS,IAAIC,WACnBD,EAAOE,OAAS,kBAAM/E,EAAQ6E,EAAO1B,SACrC0B,EAAOrC,QAAUvC,EACjB4E,EAAOG,kBAAkBte,MC5kB7B,IAsBaue,GAAb,WAKE,WAAYnlB,GAAe,IAAD,gCAJTA,WAIS,OAHlBolB,gBAGkB,OAFlBtP,gBAAmCpD,GAAgB0F,QAEjC,KAqElBiN,mBAAqB,SAC3BvP,EACAsL,GAEI,EAAKtL,kBAAoBA,IAC3B,EAAKA,gBAAkBA,EACvB,EAAK9V,MAAMslB,uBAAuBxP,KAGhCsL,GAAUtL,IAAoBpD,GAAgB8F,uBAChD,EAAKxY,MAAMulB,kBAAkBnE,GAAU,YA/EjB,KAmFlBoE,eAAiB,SACvBC,EACAC,GAhH4B,KAkHxBD,GACF,EAAKzlB,MAAMulB,kBAAkBG,IAvF/B3lB,KAAKC,MAAQA,EAGbD,KAAK4V,UATT,0DAgBI,OAAO5V,KAAK+V,kBAAoBpD,GAAgBqD,YAhBpD,2CAqBI,OAAOhW,KAAK+V,kBAAoBpD,GAAgB6F,SArBpD,wCA6BI,OAAIxY,KAAKqlB,sBAAsB3E,GACtB1gB,KAAKqlB,WAAWnE,uBAEvB,IAhCN,kCAoCqBxX,GACb1J,KAAKqlB,sBAAsB3E,IAAuB1gB,KAAK0W,cACzD1W,KAAKqlB,WAAWO,YAAYlc,GAG5BnI,YAAS,oDAAD,OAAqDmI,MAzCnE,oDAiDuCqV,GAE/B/e,KAAKqlB,sBAAsB3E,IAC7B1gB,KAAKqlB,WAAWQ,8BAA8B9G,KApDpD,oKA0DU+G,KA1DV,yBA2D0Btd,KAAIhF,MAAMsF,OAAOC,SAASpH,MAAM,GAA1CiH,EA3DhB,EA2DgBA,MACFgI,EAAWhI,EAAMqO,GA5D/B,SA6DgCjX,KAAK+lB,uBAAuBnV,GA7D5D,OA6DQ5Q,KAAKqlB,WA7Db,+CA+DgCrlB,KAAKgmB,yBA/DrC,QA+DQhmB,KAAKqlB,WA/Db,iEAkEM9jB,YAAS,KAAIC,SACbxB,KAAKslB,mBACH3S,GAAgB8F,qBAChB,KAAIjX,SArEZ,+JAkGI,IAAMykB,EAAeC,eAErB,OAAO,IAAIxF,GAAoB,CAC7BU,iBAAkB,CAAC6E,GACnB3H,UAAWte,KAAKC,MAAMqe,UACtBN,wBAAyBhe,KAAKslB,mBAC9BxD,QAAS9hB,KAAKylB,mBAxGpB,wFAiHI7U,GAjHJ,wFAmH2BwU,EAAkBe,cAAcvV,GAnH3D,cAmHUuN,EAnHV,yBAqHWA,EAASiI,eAAiBC,KAAeC,aAAa3V,QACzD3Q,KAAKumB,mCAAmCpI,GACxCne,KAAKwmB,kCAAkC5V,EAAUuN,IAvHzD,gKA2HIA,GACsB,IAAD,OAEnBsI,EAKEtI,EALFsI,wBACAC,EAIEvI,EAJFuI,iBACAC,EAGExI,EAHFwI,iBAKIC,EAAQ,CAAEC,KAFZ1I,EAFF2I,WAIgCC,SAF9B5I,EADF6I,gBAKI5F,EAAmBqF,EACrB,CAAC,eAAKG,EAAN,CAAaK,KAAMR,KACnB,CAAC,eACMG,EADP,CACcK,KAAMN,IADpB,eAEOC,EAFP,CAEcK,KAAMP,KAGxB,OAAO,IAAIhG,GAAoB,CAC7BU,mBACA9C,UAAWte,KAAKC,MAAMqe,UACtBN,wBAAyB,SAAAkJ,GAAC,OAAI,EAAK5B,mBAAmB4B,IACtDpF,QAAS9hB,KAAKylB,mBAlJpB,wDAuJI7U,EACAuN,GACmB,IAAD,OAClB,OAAO,IAAIJ,GAAiB,CAC1BI,WACAvN,WACA0N,UAAWte,KAAKC,MAAMqe,UACtBN,wBAAyB,SAAAkJ,GAAC,OAAI,EAAK5B,mBAAmB4B,SA9J5D,gFAmKItW,GAnKJ,mGAsKyB4M,GAAgB5M,EAAU,eAtKnD,cAsKY/J,EAtKZ,gBAuKgCA,EAAKwX,cAvKrC,cAuKYA,EAvKZ,yBAyKagI,KAAe7H,OAAO,IAAIC,WAAWJ,KAzKlD,wCA2KM9c,YAAS,EAAD,IACF,IAAIoE,MAAM,yBA5KtB,wHCnBawhB,GAAb,WAQE,WAAYC,GAAuC,yBANlCA,iBAMiC,OALjCC,aAAyC,IAAIrd,IAM5DhK,KAAKonB,YAAcA,EATvB,4DAwByBtf,EAAkBrF,GACvCzC,KAAKsnB,4BAA4Bxf,GAAUyf,cAAe,EAC1DvnB,KAAKwnB,8BAA8B/kB,GACnCzC,KAAKynB,uBAAuB3f,KA3BhC,mCA8BsBA,GAClB,IAAM3G,EAAQnB,KAAK0nB,oBAAoB5f,GACvC,GAAa,MAAT3G,GAAiC,cAAhBA,EAAMyG,MACzB,OAAOzG,EAAMwmB,YAjCnB,mCAuCsB7f,EAAkBF,EAAgBnF,GACpDzC,KAAKsnB,4BAA4Bxf,GAAU6f,UAAY/f,EACvD5H,KAAKwnB,8BAA8B/kB,KAzCvC,kCA4CqBqF,GACjB,IAAM3G,EAAQnB,KAAK0nB,oBAAoB5f,GACvC,GAAa,MAAT3G,GAAiC,aAAhBA,EAAMyG,MACzB,OAAOzG,EAAMymB,WA/CnB,kCAqDqB9f,EAAkBF,EAAenF,GAClDzC,KAAKsnB,4BAA4Bxf,GAAU8f,SAAWhgB,EACtD5H,KAAKwnB,8BAA8B/kB,KAvDvC,oCA0DuBqF,GACnB,IAAM3G,EAAQnB,KAAK0nB,oBAAoB5f,GACvC,GAAa,MAAT3G,GAAiC,eAAhBA,EAAMyG,MACzB,OAAOzG,EAAM0mB,aA7DnB,oCAmEuB/f,EAAkBF,EAAenF,GACpDzC,KAAKsnB,4BAA4Bxf,GAAU+f,WAAajgB,EACxD5H,KAAKwnB,8BAA8B/kB,KArEvC,qCAwEwBqF,GACpB,IAAM3G,EAAQnB,KAAK0nB,oBAAoB5f,GACvC,GAAa,MAAT3G,GAAiC,gBAAhBA,EAAMyG,MACzB,OAAOzG,EAAM2mB,cA3EnB,qCAkFIhgB,EACAF,EACAnF,GAEAzC,KAAKsnB,4BAA4Bxf,GAAUggB,YAAclgB,EACzD5H,KAAKwnB,8BAA8B/kB,KAvFvC,0CA2FIqF,EACAF,EACAnF,GAEAzC,KAAKsnB,4BACHxf,GACAigB,iBAAmBC,KAAYC,WAAW,CAAEphB,KAAMe,IACpD5H,KAAKwnB,8BAA8B/kB,KAlGvC,yCAqG4BqF,GACxB,IAAM3G,EAAQnB,KAAK0nB,oBAAoB5f,GACvC,GACW,MAAT3G,GACgB,oBAAhBA,EAAMyG,OACmB,MAAzBzG,EAAM+mB,iBACyB,MAA/B/mB,EAAM+mB,gBAAgBtgB,MAEtB,OAAOzG,EAAM+mB,gBAAgBtgB,QA7GnC,yCAoHIE,EACAF,EACAnF,GAEAzC,KAAKsnB,4BACHxf,GACAogB,gBAAkBC,KAAWF,WAAW,CAAErgB,UAC5C5H,KAAKwnB,8BAA8B/kB,KA3HvC,uCA8H0BqF,GACtB,IAAM3G,EAAQnB,KAAK0nB,oBAAoB5f,GACvC,GACW,MAAT3G,GACgB,kBAAhBA,EAAMyG,OACiB,MAAvBzG,EAAMinB,eACuB,MAA7BjnB,EAAMinB,cAAcxgB,MAEpB,OAAOzG,EAAMinB,cAAcxgB,QAtIjC,uCA6IIE,EACAF,EACAnF,GAEAzC,KAAKsnB,4BACHxf,GACAsgB,cAAgBC,KAASJ,WAAW,CAAErgB,UACxC5H,KAAKwnB,8BAA8B/kB,KApJvC,mCAuJsBqF,GAClB,IAAM3G,EAAQnB,KAAK0nB,oBAAoB5f,GACvC,GAAa,MAAT3G,GAAiC,cAAhBA,EAAMyG,MACzB,OAAOzG,EAAMmnB,YA1JnB,mCAiKIxgB,EACAF,EACAnF,GAEAzC,KAAKsnB,4BAA4Bxf,GAAUwgB,UAAY/kB,KAAKglB,UAC1D3gB,GAEF5H,KAAKwnB,8BAA8B/kB,KAxKvC,oDA2KwCA,GAChCA,EAAO+E,QACTxH,KAAKwoB,6BA7KX,iDAkLIxoB,KAAKonB,YAAY,CAAEqB,cAAezoB,KAAK0oB,2BAlL3C,4BAwLeC,GAAyC,IAAD,OACnD3oB,KAAKqnB,aAAarI,SAAQ,SAACpX,EAAOhH,GAC3B+nB,EAAWC,SAAShoB,IACvB,EAAK6mB,uBAAuB7mB,QA3LpC,6CAiMI,IAAMgc,EAAM,IAAIiM,KAEhB,OADA7oB,KAAKqnB,aAAarI,SAAQ,SAAApX,GAAK,OAAIgV,EAAIkM,QAAQ9jB,KAAK4C,MAC7CgV,IAnMX,kDA0MsC3F,GAClC,IAAI9V,EAAQnB,KAAK0nB,oBAAoBzQ,GAKrC,OAJa,MAAT9V,IACFA,EAAQ,IAAI4nB,KAAY,CAAE9R,OAC1BjX,KAAKqnB,aAAajd,IAAI6M,EAAI9V,IAErBA,IAhNX,6CAsNiC8V,GAC7BjX,KAAKqnB,aAAahd,OAAO4M,KAvN7B,0CA0N8BA,GAC1B,OAAOjX,KAAKqnB,aAAahnB,IAAI4W,KA3NjC,8BAiBI,OAAkC,IAA3BjX,KAAKqnB,aAAazkB,SAjB7B,K,UCfaomB,GAAb,iDAEkBrT,eAAiB,IAAIsT,UAFvC,kEAK+BrM,GAC3B5c,KAAK2V,eAAeuT,KAAKtM,OAN7B,K,UCuBauM,GAAb,4DACUC,aAAc,EADxB,KAMUC,qBAAsB,EANhC,KAYUC,cAAyB,GAZnC,KAkBUC,oBAAoC,GAlB9C,KAwBUC,8BAAwD,GAxBlE,KAgCUC,WAAa,kBAhCvB,KAmHSC,cAAgB,SAACD,GACtB,EAAKA,WAAaA,GApHtB,0DA6CY,IAHRE,EAGO,EAHPA,iBAOA,GAHA3pB,KAAKopB,aAAc,EACnBppB,KAAKqpB,oBAAsBM,EAEvB3pB,KAAKqpB,qBAAuBvD,KAAkB,CAEhD,IAAM8D,EAAkB,GACgB,KAApCzO,KAAY7U,QAAQujB,cACtBD,EAAU,YAAkBzO,KAAY7U,QAAQujB,aAElD7pB,KAAK8pB,SAAS3O,KAAY7U,QAAQyjB,eAAgBH,GAClD5pB,KAAKgqB,oBAGPC,YAAU,uBAAwBjqB,KAAKqpB,uBA3D3C,8BA8DiBa,GAA6D,IAA7CC,EAA4C,uDAAV,GAC1DnqB,KAAKopB,YAKLppB,KAAKqpB,qBAIVrpB,KAAKkjB,KAAKgH,EAAQC,GARhBnqB,KAAKspB,cAActkB,KAAK,CAACklB,EAAQC,MAhEvC,0CA4EInqB,KAAKupB,oBAAsB,KA5E/B,4CA+E+Ba,GACgB,MAAvCpqB,KAAKupB,oBAAoBa,GAC3BpqB,KAAKupB,oBAAoBa,GAAa,EAEtCpqB,KAAKupB,oBAAoBa,OAnF/B,gDAwFI,IAAMC,EAAerqB,KAAKupB,oBAE1B,OADAvpB,KAAKsqB,oBACED,IA1FX,oDA8FIrqB,KAAKwpB,8BAAgC,KA9FzC,sDAiGyCe,GACyB,MAA1DvqB,KAAKwpB,8BAA8Be,GACrCvqB,KAAKwpB,8BAA8Be,GAAsB,EAEzDvqB,KAAKwpB,8BAA8Be,OArGzC,0DA0GI,IAAMC,EAAyBxqB,KAAKwpB,8BAEpC,OADAxpB,KAAKyqB,8BACED,IA5GX,2BAuHeN,GAA6D,IAA7CC,EAA4C,uDAAV,GACvDtjB,EAAI,eACLsjB,EADK,CAERV,WAAYzpB,KAAKypB,WACjBiB,IAAKC,KACLloB,OAAQ,UACR2Y,iBAAkBD,KAAY7U,QAAQ8U,mBAMpCuP,KACFV,YAAU,2CAA4CC,EAAQrjB,GAE9D7G,KAAK4qB,MAAMV,EAAQrjB,KAtIzB,0CA0IqC,IAAD,OAChC7G,KAAKspB,cAActK,SAAQ,YAAuB,IAAD,mBAApBkL,EAAoB,KAAZC,EAAY,KAC/C,EAAKjH,KAAKgH,EAAQC,MAEpBnqB,KAAKspB,cAAgB,KA9IzB,+BAmJmBrS,EAAYpQ,GAC3BgkB,UAAUf,SAAS7S,EAAIpQ,KApJ3B,4BAuJgBqjB,EAAgBrjB,GAC5BgkB,UAAUD,MAAMV,EAAQrjB,OAxJ5B,KCJO,SAASikB,GACd9d,EACA4D,EACAma,EACArd,GAEA,IAAKA,EACH,MAAM,IAAI/H,MAAM,8BAGlB,IAAMqlB,EAAQC,YAAiBC,KAAOH,GAChCI,EAAcC,YAAe1d,EAASyd,aACtCE,EAAkBD,YAAeD,EAAY7gB,MAG7CghB,EAFuBF,YAAeD,EAAYG,aAG7BC,KAAUC,UAAUC,KAAO,OAAS,UACzDC,EAAS,uBAAOL,GAAP,CAAwB3d,EAASie,UAkChD,OAhCA3d,YAAcgd,EAAO,OAAQ,CAC3BY,WAAY,SAAC1rB,GACX,IAAM2rB,EAAgC7e,EAASse,GAAWQ,MACxDJ,GAGF1e,EAASse,GAAate,EAASse,GAAWS,MACxCL,EA4BR,SACEJ,EACApe,EACAhN,EACA0Q,EACAlD,GAMA,GAJAyb,GAAe7iB,QAAQ0lB,sBAAsBV,GAC7CnC,GAAe7iB,QAAQ0lB,sBAAsB9rB,EAAQG,IAAI,SAG7B,sBAAxBH,EAAQG,IAAI,QAAiC,CAC/C,IAAMkI,EAAgBrI,EAAQ4rB,MAAM,CAAC,oBAAqB,kBAC1D3C,GAAe7iB,QAAQ2lB,gCAAgC1jB,GAMzD,GAAI2E,GAAiBA,EAAc7M,IAAI,WAAW6rB,OAAOhsB,GACvD,OAAOgN,EAAc9C,IAAI,WAAYwG,GAAUxG,IAAI,WAAYsD,GAGjE,OAAOye,cAAa,CAClBvb,WACA1Q,UACAwN,aArDI0e,CACEd,EACAO,EACA3rB,EACA0Q,EACAlD,KAIN2e,SAAU,WACRrf,EAASse,GAAate,EAASse,GAAWgB,SACxCZ,GACA,SAAAxe,GAAa,OA6CrB,SACEoe,EACApe,GAKA,GAHAic,GAAe7iB,QAAQ0lB,sBAAsBV,GAC7CnC,GAAe7iB,QAAQ0lB,sBAAsB,aAEzC9e,EAAc7M,IAAI,qBAAsB+M,OAC1C,OAAOF,EAGT,OAAOA,EAAc9C,IAAI,UAAWgD,kBAxDbmf,CAAsBjB,EAAWpe,OAGtDsf,QAAS,SAACC,GACRzf,EAASse,GAAate,EAASse,GAAWgB,SACxCZ,GACA,SAAAxe,GAAa,OAqDrB,SACEoe,EACApe,EACAuf,GAKA,OAHAtD,GAAe7iB,QAAQ0lB,sBAAsBV,GAC7CnC,GAAe7iB,QAAQ0lB,sBAAsB,YAEtC9e,EAAcwf,OAAO,WAAW,SAAAxsB,GAAO,OAC5CssB,YAAQtsB,EAASusB,MA7DXE,CAAqBrB,EAAWpe,EAAeuf,SAKhDzf,ED/CImc,GAuCG7iB,QAA0B,IAAI6iB,G,IE1DjCyD,GAAb,+NAUI9kB,EACA+kB,EACAC,EACAC,GAbJ,8FAgBsBzpB,KADZsc,EAAY5f,KAAK8J,gBAf3B,sBAiBY,IAAInE,MAAM,iDAjBtB,OAuBI,KAHMqnB,EAAO,IAAIC,UACZC,OAAO,YAAa/R,KAAY7U,QAAQ6mB,WAC7CH,EAAKE,OAAO,WAAYplB,GAtB5B,4BAuBI,EAAmB+kB,EAAnB,+CAAWO,EAAe,QACxBJ,EAAKE,OAAOE,EAAKhtB,KAAMgtB,GAxB7B,0PA2BUptB,KAAK+kB,QAAQ,CACjBgI,YAAaA,EACbvkB,IAAKgC,aAAaoV,EAAW,eAC7ByN,OAAQ,OACRxmB,KAAMmmB,EACNF,qBAhCN,8I,WCGE,WACEhjB,EACAwjB,GACC,yBANgBxjB,kBAMjB,OALiBwjB,iBAKjB,EACAttB,KAAK8J,aAAeA,EACpB9J,KAAKstB,YAAcA,E,oDAONC,GACb,GAAIvtB,KAAKstB,YAAa,CACpB,IAAME,EAAcC,YAAU,SACX,MAAfD,IACFD,EAAOG,QAAUC,OAAOC,OACtB,CAAE,cAAeJ,GACjBD,EAAOG,SAAW,IAEpBH,EAAOM,iBAAkB,GAG7B,OAAOjJ,KAAMG,QAAQwI,O,kDCgFVO,G,WAtGb,cAAyD,IAA3CC,EAA0C,EAA1CA,YAA0C,yBALxDA,iBAKwD,OAJxDC,iBAIwD,OAHxDC,oBAGwD,OAFxDC,mBAEwD,EACtDluB,KAAK+tB,YAAcA,EAEnB/tB,KAAKguB,YAAc,KACnBhuB,KAAKiuB,eAAiB,GAEtBjuB,KAAKkuB,cAAgB,K,uMASOC,UAAUC,aAAaC,gBAAgB,CACjE9e,OAAO,I,UADH+e,E,OAIFC,EAASD,EAAcE,aAEvBxuB,KAAK+tB,Y,gCACmBI,UAAUC,aAAaK,aAAa,CAC5Dlf,OAAO,EACPnB,OAAO,I,OAFHsgB,E,OAINH,EAASA,EAAOI,OAAOD,EAAYE,kB,OAGrC5uB,KAAKiuB,eAAiB,GAEtBjuB,KAAKguB,YAAc,IAAIa,YAAYN,GAEnCvuB,KAAKkuB,cAAgB,IAAIY,cAAc9uB,KAAKguB,YAAa,CACvDe,SA9CY,eAiDd/uB,KAAKkuB,cAAcc,gBAAkB,SAAAvrB,GAAC,OAAI,EAAKwqB,eAAejpB,KAAKvB,EAAEoD,O,wIAIrE,OAAI7G,KAAKkuB,cACAluB,KAAKkuB,cAAc/sB,MAGrB,a,8BAUP,IAAKnB,KAAKkuB,cACR,OAAO,EAGT,IACEluB,KAAKkuB,cAAce,QACnB,MAAOxrB,GACP,OAAO,EAGT,OAAO,I,6BAU0B,IAAD,OAChC,GAAKzD,KAAKkuB,cAAV,CAIA,IAAIrK,EAEExD,EAAU,IAAIC,SAAQ,SAAA4O,GAC1BrL,EAAWqL,KAWb,OARAlvB,KAAKkuB,cAAciB,OAAS,kBAAMtL,KAClC7jB,KAAKkuB,cAAckB,OAEfpvB,KAAKguB,cACPhuB,KAAKguB,YAAYQ,YAAYxP,SAAQ,SAAAkI,GAAC,OAAIA,EAAEkI,UAC5CpvB,KAAKguB,YAAc,MAGd3N,EAAQwE,MAAK,kBAAM,EAAKwK,wB,wCAI/B,OAAO,IAAIC,KAAKtvB,KAAKiuB,eAAgB,CAAEztB,KA9GzB,mB,0BCgFH+uB,G,2MA1DbpuB,MAAQ,CACN4sB,YAAa,EAAK9tB,MAAM8tB,a,EAG1ByB,0BAA4B,SAAC/rB,GAA4C,IAC/D+W,EAAY/W,EAAE5B,OAAd2Y,QACAuT,EAAgB,EAAK5sB,MAArB4sB,YACA0B,EAAsB,EAAKxvB,MAA3BwvB,kBAEJjV,IAAYuT,GACd,EAAK/mB,SAAS,CAAE+mB,YAAavT,GAAWiV,I,EAI5CC,kBAAoB,WAAa,IAAD,EACM,EAAKzvB,MAAjC0vB,EADsB,EACtBA,eAAgBzV,EADM,EACNA,QAExByV,IACAzV,K,EAGK9R,OAAS,WAAkB,IACxB2lB,EAAgB,EAAK5sB,MAArB4sB,YACA7T,EAAY,EAAKja,MAAjBia,QAER,OACE,kBAAC,QAAD,CAAOf,QAAQ,EAAMN,OAAQqB,EAASvZ,UAAU,oBAC9C,kBAAC,cAAD,CAAakY,OAAQqB,GAArB,uBACA,kBAAC,YAAD,KACE,iJAIA,2BACE,2BAAOlZ,MAAO,CAAE4uB,OAAQ,IACtB,2BACEpvB,KAAK,WACLJ,KAAK,cACLoa,QAASuT,EACT5b,SAAU,EAAKqd,4BACd,IANL,sBAUF,uBAAGxuB,MAAO,CAAE4uB,OAAQ,IAApB,SACQ,oCADR,iCAIF,kBAAC,cAAD,KACE,kBAAC,SAAD,CAAQvd,SAAO,EAAC+F,MAAM,UAAU9F,QAAS,EAAKod,mBAA9C,uB,6BAlDqBzuB,iBC2DhB4uB,I,kNAjEbC,qBAAuB,YAGrB5V,EAFoB,EAAKja,MAAjBia,Y,EAKV6V,eAAiB,WAAe,IACtBC,EAAc,EAAK/vB,MAAnB+vB,UAER,OAAOxL,IAAIyL,gBAAgBD,I,EAGtB5nB,OAAS,WAAkB,IAAD,EACD,EAAKnI,MAA3Bia,EADuB,EACvBA,QAASgW,EADc,EACdA,SACXC,EAAc,EAAKJ,iBAEzB,OACE,kBAAC,QAAD,CAAOntB,KAAK,KAAKuW,QAAQ,EAAMxY,UAAU,+BACvC,kBAAC,cAAD,CAAakY,OAAQqB,GAArB,cACA,kBAAC,YAAD,KACE,yBAAKvZ,UAAU,mBACb,yBAAKA,UAAU,2BAAf,UACA,yBAAKA,UAAU,4BACb,wDACA,2BAAOmD,IAAKqsB,EAAaC,UAAQ,KAEnC,yBAAKzvB,UAAU,4BAEf,yBAAKA,UAAU,4BAAf,UACA,yBAAKA,UAAU,6BACb,kBAAC,SAAD,CACE0R,SAAO,EACP+F,MAAM,UACNzW,KAAMwuB,EACNE,SAAQ,UAAKH,EAAL,aACR5d,QAAS,EAAKwd,qBACdnvB,UAAU,mBANZ,sBAUA,2BACE,8DAC+B,IAC7B,uBAAGgB,KAAK,gCAAR,eAFF,6HASJ,yBAAKhB,UAAU,2BAAf,UACA,yBAAKA,UAAU,4BAAf,sFAEoB,IAClB,0BAAM2vB,KAAK,MAAMC,aAAW,SAA5B,qB,6BAvDoBtvB,kBCkBnBuvB,G,2MAvBNpoB,OAAS,WAAkB,IACxB8R,EAAY,EAAKja,MAAjBia,QAER,OACE,kBAAC,QAAD,CAAOf,QAAQ,EAAMN,OAAQqB,EAASvZ,UAAU,oBAC9C,kBAAC,cAAD,CAAakY,OAAQqB,GAArB,uBACA,kBAAC,YAAD,KACE,yBAAKvZ,UAAU,2BACb,0BAAM2vB,KAAK,MAAMC,aAAW,iBAA5B,gBAGA,iK,6BAZ2BtvB,iBCKjCwvB,I,kNAKJtvB,MAAQ,CACNuvB,UAAW,EAAKzwB,MAAMywB,W,EAGxBC,e,wBAAiB,iCAAAlb,EAAA,sDACPib,EAAc,EAAKvvB,MAAnBuvB,UACAE,EAAgB,EAAK3wB,MAArB2wB,aACFC,EAAeH,EAAY,IAEb,GAClB,EAAK1pB,SAAS,CACZ0pB,UAAWG,IAIM,IAAjBA,GACFD,IAZa,2C,wEAgBI,IACXF,EAAqB1wB,KAAKmB,MAA1BuvB,UAER,OACE,yBACE/vB,UAAU,YACVgwB,eAAgB3wB,KAAK2wB,eACrB/vB,IAAK,QAAU8vB,GAGf,8BAAOA,Q,GAnCSzvB,kBAAlBwvB,GACU/d,aAA+B,CAC3Cke,YAAa,cAuCFH,UCjBTK,GAA0B,CAC9BC,OAAQ,KACRC,QAAS,KACTC,MAAO,KACPC,KAAM,MAgMOC,ICupBAA,GDp1Bf,SACEC,GACqB,IACfC,EADc,2MAQlBC,cARkB,IAUlBnwB,MAAQ,CACN+uB,SAAU,uBACVnC,aAAa,EACbwD,aAAc,OAbE,EAgBlB9B,kBAAoB,WAAa,IACvB1B,EAAgB,EAAK5sB,MAArB4sB,YAER,EAAK/mB,SAAS,CACZ+mB,aAAcA,KApBA,EAwBlByD,WAAa,SAACtB,GAA4B,IAChCqB,EAAiB,EAAKpwB,MAAtBowB,aAEH,EAAKE,wBAKa,QAAjBF,EACF,EAAKvqB,SAAS,CACZkpB,WACAqB,aAAc,UAGhB,EAAKG,gBAVP,EAAK1qB,SAAS,CACZuqB,aAAc,iBA7BF,EA2ClB5B,eA3CkB,wBA2CD,6BAAAla,EAAA,6DACPsY,EAAgB,EAAK5sB,MAArB4sB,YAER,EAAKuD,SAAW,IAAIxD,GAAmB,CAAEC,gBAH1B,kBAMP,EAAKuD,SAASK,aANP,uDASb,EAAK3qB,SAAS,CACZuqB,aAAc,gBAVH,QAcf,EAAKvqB,SAAS,CACZuqB,aAAc,cAfD,yDA3CC,EA8DlBG,cA9DkB,wBA8DF,+BAAAjc,EAAA,yDAKO,SAHb8b,EAAiB,EAAKpwB,MAAtBowB,eAGuC,MAAjB,EAAKD,SALrB,oDASO,cAAjBC,GACF,EAAKvqB,SAAS,CACZuqB,aAAc,QAKC,cAAjBA,GAC6B,aAA7B,EAAKD,SAASM,WAjBF,gCAmBO,EAAKN,SAASlC,OAnBrB,OAmBZyC,EAnBY,OAqBZ,EAAK7qB,SAAS,CACZ6qB,aACAN,aAAc,iBAvBJ,2CA9DE,EA0FlBO,eA1FkB,wBA0FD,uBAAArc,EAAA,yDACM,MAAjB,EAAK6b,SADM,sBAGP,IAAI3rB,MAAM,2CAHH,OAMI,EAAK2rB,SAASrC,QAG/B,EAAKjoB,SAAS,CACZuqB,aAAc,cAGhB,EAAKG,gBAbQ,2CA1FC,EA2GlBK,mBAAqB,iBAAsB,CACzCR,aAAc,EAAKpwB,MAAMowB,aACzB9B,kBAAmB,EAAKA,kBACxBE,eAAgB,EAAK6B,WACrBE,cAAe,EAAKA,gBA/GJ,EAkHlBM,YAAc,WACZ,EAAKhrB,SAAS,CACZuqB,aAAc,SApHA,EAwHlBE,sBAAwB,WACtB,IACGtD,UAAUC,eACVD,UAAUC,aAAaK,eAEvBN,UAAUC,aAAaC,gBAExB,OAAO,EAGT,IAAM4D,EAAe,IAAIC,KAAa/D,UAAUgE,WAQhD,OANexE,OAAOyE,KAAKtB,IAAoBjuB,KAAI,SAAAwvB,GACjD,IAAMC,EAAiBxB,GAAmBuB,GAE1C,OAAOJ,EAAaM,UAAUF,EAAS,KAAMC,MAGjCE,MAAK,SAAAC,GAAS,OAAIA,MA1IhB,wEA6IG,IAAD,EAMOzyB,KAAKmB,MAJ5B0wB,EAFgB,EAEhBA,WACA3B,EAHgB,EAGhBA,SACAnC,EAJgB,EAIhBA,YACAwD,EALgB,EAKhBA,aAGF,OACE,yBAAK5wB,UAAU,kBACb,kBAACywB,EAAD,CAAkBsB,WAAY1yB,KAAK+xB,uBAEjB,gBAAjBR,GACC,kBAAC,GAAD,CAA0BrX,QAASla,KAAKgyB,cAGxB,UAAjBT,GACC,kBAAC,GAAD,CACExD,YAAaA,EACb7T,QAASla,KAAKgyB,YACdrC,eAAgB3vB,KAAK2vB,eACrBF,kBAAmBzvB,KAAKyvB,oBAIV,cAAjB8B,GACC,kBAAC,GAAD,CAAWb,UAAW,EAAGE,YAAa5wB,KAAK8xB,iBAG3B,iBAAjBP,GAAmCM,GAClC,kBAAC,GAAD,CACE3X,QAASla,KAAKgyB,YACdhC,UAAW6B,EACX3B,SAAUA,SA9KF,GACkBjvB,iBAuLtC,OAvLMowB,EAIYsB,YALE,yBAK8BvB,EAAiBuB,aAC/DvB,EAAiBhxB,KAND,KAwLbwyB,KAAqBvB,EAAyBD,GC0pBxCD,CA3yBf,YAUE,WAAYlxB,GAAe,IAAD,8BACxB,4CAAMA,KAVSyV,4BASS,IARTmd,qBAQS,IAPlBC,uBAOkB,IANT/qB,eAMS,IALTkI,kBAKS,IAJlB8iB,uBAIkB,IAHlBC,iCAGkB,IAFTziB,uBAES,IAmD1BmE,YAAc,CAEZwa,EAAG,kBAAY,EAAK+D,eAGpBC,EAAG,kBAAY,EAAKC,wBAEpBC,IAAK,EAAKnzB,MAAMyyB,WAAWhB,eA1DH,EA8G1B2B,6BAA+B,SAACC,GAC9BlU,YAAW,iCAAD,OACyB,EAAKje,MAAM4U,gBADpC,eAC0Dud,IAGpE,EAAKtsB,SAAS,CAAE+O,gBAAiBud,IAE7BA,IAAa3gB,GAAgBqD,WAC/BoJ,YACE,oEAEF,EAAKrX,UAAUygB,2BACf,EAAKxhB,SAAS,CAAEusB,OAAQ,QAExBC,YAAU,QAAS,KA5HG,EAmI1BlR,cAAgB,SAACmR,GAYf,KATsB,SAAC/pB,EAAUtJ,EAAcszB,GAC7C,IAAMC,EAAWjqB,EAAItJ,GACrB,GAAIuzB,KAAYD,EACd,OAAOA,EAAMC,GAAUjqB,EAAIiqB,IAE3B,MAAM,IAAIhuB,MAAJ,wBAA2BvF,EAA3B,aAAoCuzB,EAApC,OAKRC,CAAcH,EAAU,OAAQ,CAC9B9B,WAAY,SAACkC,GAAD,OACV,EAAKC,iBAAiBD,IACxBE,oBAAqB,SAACnX,GAAD,OACnB,EAAKoX,0BAA0BpX,IACjCqX,aAAc,SAACC,GAAD,OACZ,EAAKre,mBAAmBqe,IAC1BC,UAAW,SAACC,GAAD,OACT,EAAKC,gBAAgBD,IACvBpJ,MAAO,SAACD,GAAD,OACL,EAAKuJ,eAAevJ,EAAU0I,EAAS/lB,WACzC6mB,eAAgB,SAAC1W,GAAD,OACd,EAAK2W,qBAAqB3W,IAC5B4W,qBAAsB,SAACtlB,GAAD,OACpB,EAAKulB,2BAA2BvlB,IAClCwlB,eAAgB,SAACnsB,GAAD,OAAiB,EAAKosB,qBAAqBpsB,MAE7D,MAAOS,GACP1H,YAAS0H,GACT,EAAK4rB,UAAU,qBAAsB5rB,EAAIzH,WAnKnB,EAuK1BkzB,2BAA6B,SAACvlB,GAC5B,IAAM2lB,EAAyB,CAC7Bt0B,KAAM+S,GAAW8I,gBACjBlN,SAAUA,EACV+K,QAAS,cAEX,EAAK6a,WAAWD,IA7KQ,EAgL1BF,qBAAuB,SAACpsB,GACtB,IAAMssB,EAAyB,CAC7Bt0B,KAAM+S,GAAWiJ,SACjBhU,IAAKA,EACL0R,QAAS,cAEX,EAAK6a,WAAWD,IAtLQ,EA8L1BhB,iBAAmB,SAACD,GAAqC,IAErD1G,EAKE0G,EALF1G,UACA6H,EAIEnB,EAJFmB,gBACAC,EAGEpB,EAHFoB,SACAC,EAEErB,EAFFqB,OACAC,EACEtB,EADFsB,aAGF,GACe,MAAbhI,IACC6H,IACAC,IACAC,IACAC,EAED,MAAM,IAAIxvB,MAAM,6CAGd,EAAKyvB,2BAA2BvB,GAClC/qB,OAAOC,SAASssB,UAKlBla,KAAY7U,QAAU,IAAI6U,KAAY,CACpCgS,UAAWA,EACX/R,iBAAkB4Z,EAAgB5Z,iBAClCka,cAAeN,EAAgBM,cAC/BvL,eAAgBkL,EAASlL,eACzBF,YAAaoL,EAASM,MACtBC,oBAAqBN,EAAOM,oBAC5B9Q,YAAamP,EAAcnP,YAC3B+Q,gBAAiBP,EAAOQ,cAG1BvM,GAAe7iB,QAAQqrB,WAAW,CAChChI,iBAAkBgM,QAAQT,EAAOvL,oBAGnCR,GAAe7iB,QAAQsvB,QAAQ,eAAgB,CAC7CN,cAAena,KAAY7U,QAAQgvB,gBAGrC,EAAKtuB,SAAS,CACZyS,eAAgBkc,QAAQT,EAAOzb,kBAGjC,EAAKua,0BAA0BmB,KA9OP,EAqP1BnB,0BAA4B,SAAC6B,GAC3B,EAAK7uB,UAAS,SAAC8uB,GAEb,IAAIrlB,EAAiBqlB,EAAUrlB,eAC3B8iB,EAASuC,EAAUvC,OAEvB,GACEsC,EAAiBE,iBACjBD,EAAUrlB,iBAAmB3Q,EAAeyX,eAI5C9G,EAAiB3Q,EAAe6Q,QAKpB,MAAV4iB,GACAA,EAAO/yB,OAAS+S,GAAW4I,uBAE3BoX,OAASjwB,QAEN,IACJuyB,EAAiBE,iBAClBD,EAAUrlB,iBAAmB3Q,EAAe4Q,iBAC5ColB,EAAUrlB,iBAAmB3Q,EAAek2B,kBAC5C,CAIAvlB,EAAiB3Q,EAAem2B,YAEhC9M,GAAe7iB,QAAQsvB,QACrB,aACAzM,GAAe7iB,QAAQ4vB,2BAGzB,IAAM1L,EAAyBrB,GAAe7iB,QAAQ6vB,oCACtDxI,OAAOxoB,QAAQqlB,GAAwBxL,SAAQ,YAAoB,IAAD,mBAAjB5e,EAAiB,KAAXg2B,EAAW,KAChEjN,GAAe7iB,QAAQsvB,QAAQ,uBAAwB,CACrDx1B,OACAg2B,aAKN,MAAO,CACLC,aAAa,eACRP,EAAUO,aADH,CAEV5b,UAAWkb,QAAQE,EAAiBpb,aAEtC8Y,SACA9iB,sBAzSoB,EAkT1BoF,mBAAqB,SAACoe,GAEpB,GADA,EAAKve,uBAAuB4gB,sBAAsBrC,GACxB,+BAAtBA,EAAazzB,KAAuC,CACtD,EAAKwG,SAAS,CAAEyJ,eAAgB3Q,EAAek2B,oBAC/C,IAAMlB,EAAyB,CAC7Bt0B,KAAM+S,GAAW4I,qBACjBxN,UAAWslB,EAAasC,2BACxBrc,QAAS,cAEX,EAAK6a,WAAWD,QACX,GACLle,MACsB,wBAAtBqd,EAAazzB,KACb,CACA,IAAMs0B,EAAyB,CAC7Bt0B,KAAM+S,GAAW2I,eACjBnC,QAAS,EAAKkZ,YACd/Y,QAAS,cAEX,EAAK6a,WAAWD,KArUM,EA6U1BT,gBAAkB,SAACmC,GAAqC,IAC9C/M,EAAe,EAAKtoB,MAApBsoB,WACI7Y,EAA2C4lB,EAA/Cvf,GAAoBwf,EAA2BD,EAAjCp2B,KAAkBs2B,EAAeF,EAAfE,WAElCC,EAAgBC,YACpBzb,KAAY7U,QAAQyjB,eAAiB2M,GAGvClkB,SAAS/I,MAAT,UAAoBgtB,EAApB,mBAEAtN,GAAe7iB,QAAQojB,cAAciN,GACrCxN,GAAe7iB,QAAQgkB,oBAEvBnB,GAAe7iB,QAAQsvB,QAAQ,gBAE3BnM,IAAekN,EACjB,EAAK3vB,SAAS,CACZ4J,aAGF,EAAKimB,cAAcF,EAAe/lB,EAAU6lB,IAjWtB,EAuZ1BK,iBAAmB,SAAC9pB,EAAe4D,GACjC,OAAO5D,EACJnK,KAAI,SAACqK,GACJ,IAAM6pB,EAAgB7pB,EAAc7M,IAAI,WAExC,GAAI02B,aAAyB3pB,OAAM,CACjC,IAAM4pB,EAAkB,EAAKF,iBAC3BC,EACAnmB,GAEF,OAAOomB,EAAgBp0B,KAAO,EAAIo0B,EAAkB,KAGtD,OAAO9pB,EAAc7M,IAAI,cAAgBuQ,EACrC1D,EACA,QAELK,QAAO,SAACL,GAAD,OAA0C,OAAlBA,MAxaV,EA8c1B8kB,YAAc,WAOZxf,SAASrP,KAAK8zB,UAAUC,OAAO,cAE/B,EAAKlwB,SAAS,CAAEusB,YAAQjwB,KAvdA,EA6d1B6zB,aAAe,SAACC,GACd,IAAMC,EAAgB,EAAKl2B,MAAMk1B,aAAa5b,UACxCA,EAAY2c,EAAY3c,UAI9B,GAFA,EAAKzT,SAAS,CAAEqvB,aAAce,IAE1BC,IAAkB5c,GAAa,EAAKvB,oBAAqB,CAC3D,IAAMoe,EAAU,IAAIxU,KAAQ,CAAEyU,aAAc9c,IAC5C6c,EAAQ92B,KAAO,eACf,EAAK4mB,YAAYkQ,KAteK,EAgf1BhD,eAAiB,SACfvJ,EACAyM,GASA,GAPA,EAAKzE,kBAAoBjI,GACvB,EAAK3pB,MAAM6L,SACX,EAAK7L,MAAMyP,SACXma,EACAyM,IAGG,EAAKxE,4BAA6B,CACrC,EAAKA,6BAA8B,EAMnC,IAAMyE,IAAqB,EAAK3E,mBAC5B,EAAKA,kBAAkB2E,qBAErB1B,EACJ,EAAK50B,MAAMsP,iBAAmB3Q,EAAe6Q,QAE/CuD,YAAW,WAET,GADA,EAAK8e,6BAA8B,GAC/ByE,GAAsB1B,IAGpB,EAAKhD,kBAAmB,CAC1B,IAAM/lB,EAAkB,eACnB,EAAK+lB,mBAEV,EAAK/rB,SAAS,CAAEgG,SAAUA,OAniBC,MAkBX,EAsiB1B0qB,YAAc,WACZ,GAAI,EAAKxe,oBACP,GAAI,EAAK/X,MAAMsY,eAAgB,CAC7B0P,GAAe7iB,QAAQsvB,QAAQ,eAC/B,IAAM0B,EAAU,IAAIxU,KAAQ,CAAE6U,aAAa,IAC3CL,EAAQ92B,KAAO,cACf,EAAK4mB,YAAYkQ,OACZ,CACL,IAAMxC,EAAyB,CAC7Bt0B,KAAM+S,GAAWoJ,QACjBlT,MAAO,oBACPmT,IACE,kBAAC,WAAD,KACE,oEACA,8CACiB,IACf,uBAAGjb,KAAK,6BAAR,qBAFF,uBAOJuY,QAAS,cAEX,EAAK6a,WAAWD,QAGlBvzB,YAAS,kDAhkBa,EA2kB1B0xB,YAAc,WAAoC,IAAnC2E,EAAkC,wDAG/C,GAFA,EAAK5F,cAEA,EAAK9Y,qBAKV,GACE,EAAK/X,MAAMsP,iBAAmB3Q,EAAe6Q,SAC7C,EAAKxP,MAAMsP,iBAAmB3Q,EAAe4Q,gBAF/C,CAQAyY,GAAe7iB,QAAQsvB,QAAQ,eAE/B,EAAK5uB,SAAS,CAAEyJ,eAAgB3Q,EAAe4Q,mBAIvB,IAApBknB,GAIF,EAAKT,aAAL,eAAuB,EAAKh2B,MAAMk1B,aAAlC,CAAgD5b,WAAW,KAG7D,IAAM6c,EAAU,IAAIxU,KAAQ,CAAEmQ,aAAa,IAC3CqE,EAAQ92B,KAAO,cACf,EAAK4mB,YAAYkQ,SA3Bf/1B,YAAS,uDA/kBa,EA8mB1B6T,WAAa,WACX,GAAK,EAAK8D,qBAKV,GACE,EAAK/X,MAAMsP,iBAAmB3Q,EAAem2B,aAC7C,EAAK90B,MAAMsP,iBAAmB3Q,EAAeyX,eAF/C,CAQA,IAAM+f,EAAU,IAAIxU,KAAQ,CAAE1N,YAAY,IAC1CkiB,EAAQ92B,KAAO,aACf,EAAK4mB,YAAYkQ,GACjB,EAAKtwB,SAAS,CAAEyJ,eAAgB3Q,EAAeyX,uBAf7ChW,YAAS,mDAhnBa,EAqoB1B4xB,qBAAuB,WACrB,GAAI,EAAKja,oBAAqB,CAC5B,IAAM4b,EAAyB,CAC7Bt0B,KAAM+S,GAAW8H,YACjBG,gBAAiB,EAAKqc,WACtBtc,cAAe,EAAKsc,WACpB3d,QAAS,cAGX,EAAK6a,WAAWD,QAEhBvzB,YAAS,iDAhpBa,EAupB1Bs2B,WAAa,WAEX,GADA,EAAK7F,cACD,EAAK9Y,oBAAqB,CAC5BiQ,GAAe7iB,QAAQsvB,QAAQ,cAC/B,IAAM0B,EAAU,IAAIxU,KAAQ,CAAE+U,YAAY,IAC1CP,EAAQ92B,KAAO,aACf,EAAK4mB,YAAYkQ,QAEjB/1B,YAAS,iDA/pBa,EAsqBlB6lB,YAAc,SAACxK,GACjB,EAAKkW,mBACP1T,YAAWxC,GACX,EAAKkW,kBAAkBlN,YAAYhJ,IAEnCrb,YAAS,4CAAD,OAA6Cqb,KA3qB/B,EAkrB1Bkb,sBAAwB,SAACC,GACvB,EAAKlD,UAAU,mBAAoBkD,IAnrBX,EAyrB1B7e,kBAAoB,WAClB,QAAO,EAAK4Z,mBACR,EAAKA,kBAAkBpc,eA3rBH,EA+rB1BiD,iBAAmB,WACjB,IAAMmb,EAAyB,CAC7Bt0B,KAAM+S,GAAWyI,SACjB9C,kBAAmB,EAAKA,oBACxB6B,SAAU,EAAK5Z,MAAMk1B,aACrBvb,OAAQ,EAAKqc,aACbjd,QAAS,cAEX,EAAK6a,WAAWD,IAvsBQ,EA0sB1Blb,cAAgB,WACd,IAAMkb,EAAyB,CAC7Bt0B,KAAM+S,GAAW2H,MACjBhB,QAAS,EAAK8X,aAEhB,EAAK+C,WAAWD,IA/sBQ,EAktB1Btb,mBAAqB,WAAa,IACxBid,EAAe,EAAKt1B,MAApBs1B,WACA9G,EAAmB,EAAK1vB,MAAMyyB,WAA9B/C,eACFqI,EAAOC,MAASC,OAAO,uBAE7BvI,EAAe,aAAD,OAAc8G,EAAd,YAA4BuB,KAptB1C,EAAK72B,MAAQ,CACX4U,gBAAiBpD,GAAgB0F,QACjCrL,SAAU,CACRsG,KAAM6kB,iBAAO,CACX,CACEj4B,QAASqR,YAAwB,kBACjC7D,SAAU,GACVkD,SAAU,eAGdkC,QAASqlB,iBAAO,KAElB1B,WAAY,GACZ7lB,SAAU,SACV6Y,WAAY,KACZhZ,eAAgB3Q,EAAem2B,YAC/BI,aAAc,CACZ1b,UAAU,EACVF,WAAW,IAIf,EAAK/E,uBAAyB,IAAIsT,GAClC,EAAK6J,gBAAkB9wB,IAAMiE,YAC7B,EAAK8sB,kBAAoB,KACzB,EAAK/qB,UAAY,IAAIof,IAAmB,SAACvK,GACvC,EAAKwK,YAAY,IAAItE,KAAQlG,OAE/B,EAAK3M,aAAe,IAAI2c,IAAiB,WACvC,OAAO,EAAKkG,kBACR,EAAKA,kBAAkB5R,uBACvB5d,KACH,GACH,EAAKiN,kBAAoB,IAAI1G,IAAkB,WAC7C,OAAO,EAAKipB,kBACR,EAAKA,kBAAkB5R,uBACvB5d,KAEN,EAAK0vB,6BAA8B,EACnC,EAAKD,kBAAoB,KAEzBjqB,OAAOsvB,eAAiB,GACxBtvB,OAAOsvB,eAAeC,gBAAkB,EAAKA,gBAAgBC,KAArB,gBA7ChB,EAV5B,iFA0EIt4B,KAAK8yB,kBAAoB,IAAI1N,GAAkB,CAC7C9G,UAAWte,KAAKsiB,cAChBkD,kBAAmBxlB,KAAK83B,sBACxBvS,uBAAwBvlB,KAAKqzB,+BAG3BkF,eACF/lB,SAASrP,KAAK8zB,UAAUuB,IAAI,YAG9BrP,GAAe7iB,QAAQsvB,QAAQ,gBApFnC,gCAuFYnsB,EAAe2a,GACvB7iB,YAAS6iB,GACT,IAAM0Q,EAAyB,CAC7Bt0B,KAAM+S,GAAWoJ,QACjBlT,MAAOA,EACPmT,IAAKwH,EACLlK,QAAS,cAEXla,KAAK+0B,WAAWD,KA/FpB,iDAqG6BjB,GACzB,GAAI1Y,KAAYwJ,QAAS,CAAC,IACE8T,EAA4Btd,KAAY7U,QAA1D8U,iBACA4Z,EAAoBnB,EAApBmB,gBAER,GACqB,MAAnBA,GACoC,MAApCA,EAAgB5Z,iBAEhB,OAAOqd,EAA0BzD,EAAgB5Z,iBAIrD,OAAO,IAlHX,2CAmXuByC,GAAgD,IAAD,OAClE,GAAIA,IAAWU,KAAWma,qBAAqBC,sBAAuB,CAkBpE,GAdA34B,KAAKgH,UACH,gBAAGgG,EAAH,EAAGA,SAAU4D,EAAb,EAAaA,SAAb,MAA6B,CAC3B5D,SAAU,CACRsG,KAAM,EAAKwjB,iBAAiB9pB,EAASsG,KAAM1C,GAC3CkC,QAAS,EAAKgkB,iBAAiB9pB,EAAS8F,QAASlC,QAGrD,WACE,EAAKmiB,kBAAoB,EAAK5xB,MAAM6L,YAMpChN,KAAK+yB,kBAAmB,CAC1B,IAAM6F,EAAoBC,YAAgB74B,KAAK+yB,kBAAkBzf,MAC9DwlB,MAAMD,YAAgB74B,KAAK+yB,kBAAkBjgB,UAC7CjQ,KAAI,SAACY,GACJ,IAAMjD,EAAOiD,EAAEpD,IAAI,QACnB,OAAOoD,EAAEpD,IAAIG,GAAMH,IAAI,SAExBkN,QAAO,SAAA0J,GAAE,OAAU,MAANA,KAChBjX,KAAK+H,UAAUgxB,MAAMH,GAMQ,OAA3B54B,KAAK8yB,mBACP9yB,KAAK8yB,kBAAkBjN,8BACrB1K,KAAY7U,QAAQkvB,wBAtZ9B,oCAybI/L,EACA7Y,EACA6lB,GACO,IAAD,OACNz2B,KAAKgH,SACH,CACE4J,WACA6lB,aACAhN,aACAzc,SAAU,CACRsG,KAAM6kB,iBAAO,IACbrlB,QAASqlB,iBAAO,OAGpB,WACE,EAAKpF,kBAAoB,EAAK5xB,MAAM6L,SACpC,EAAKjF,UAAUgxB,MAAMZ,iBAAO,UAzcpC,iCAidald,GACTjb,KAAKgH,SAAS,CAAEusB,OAAQtY,MAld5B,wCAsiBI,GAAIjb,KAAKkZ,oBAAqB,CAC5B,IAAMoe,EAAU,IAAIxU,KAAQ,CAAEuV,iBAAiB,IAC/Cf,EAAQ92B,KAAO,kBACfR,KAAKonB,YAAYkQ,MAziBvB,+BAquBI,IAAM0B,EAAgB/1B,IAAW,QAAS,CACxC,qBAAsBs1B,cACtB,iBAAkBv4B,KAAKmB,MAAMk1B,aAAa1b,WAGxC4Y,EAA0B,KAC1BvzB,KAAKmB,MAAMoyB,SAKbA,EAASvY,GAJqB,eACzBhb,KAAKmB,MAAMoyB,OADc,CAE5BrZ,QAASla,KAAKgyB,gBASlB,OACE,kBAAC,UAAD,CAASla,SAAU9X,KAAK0U,YAAaqD,OAAQjP,OAAQkP,SAAS,GAC5D,yBAAKrX,UAAWq4B,GAEd,4BAAQ5lB,UAAW,GACjB,yBAAKzS,UAAU,eACf,yBAAKA,UAAU,WACb,kBAAC,GAAD,CACE0I,IAAKrJ,KAAK6yB,gBACV9c,gBAAiB/V,KAAKmB,MAAM4U,gBAC5BL,uBAAwB1V,KAAK0V,uBAC7BjF,eAAgBzQ,KAAKmB,MAAMsP,eAC3B6E,YAAatV,KAAKizB,YAClB7d,WAAYpV,KAAKoV,aAEnB,kBAAC,GAAD,CACEqE,gBAA8C,IAA9BzZ,KAAKmB,MAAMsY,eAC3BP,kBAAmBlZ,KAAKkZ,kBACxBQ,cAAe1Z,KAAK03B,YACpBre,mBAAoBrZ,KAAKizB,YACzB3Z,mBAAoBtZ,KAAKmzB,qBACzBxZ,iBAAkB3Z,KAAK2Z,iBACvBC,cAAe5Z,KAAK4Z,cACpBJ,mBAAoBxZ,KAAKwZ,mBACzBb,gBAAiB3Y,KAAKC,MAAMyyB,WAAWnB,iBAK7C,kBAAC,GAAD,CACEve,KAAMhT,KAAKmB,MAAMk1B,aAAa1b,SAC9B3N,SAAUhN,KAAKmB,MAAM6L,SACrB4D,SAAU5Q,KAAKmB,MAAMyP,SACrBH,eAAgBzQ,KAAKmB,MAAMsP,eAC3BI,0BACE7Q,KAAKmB,MAAM4U,kBAAoBpD,GAAgB6F,OAEjDzQ,UAAW/H,KAAK+H,UAChB6F,gBACE5N,KAAKmB,MAAM4U,kBAAoBpD,GAAgBqD,UAEjD/F,aAAcjQ,KAAKiQ,aACnBM,kBAAmBvQ,KAAKuQ,oBAGzBgjB,QApyBX,GAAyBtyB,kB,kDC5EnBg4B,GAAS,IAAIC,UAAU,CAAEC,OAAQ,QACjCC,GAAcC,OAAOC,KAAU,wBAErCC,IAASnxB,OACP,kBAAC,YAAD,CAAmBR,MAAOqxB,IAKxB,kBAAC,KAAD,CAAc/lB,MAAOsmB,KAAYC,OAAQL,IACvC,kBAAC,GAAD,QAGJ5mB,SAASknB,eAAe,U,uWCVpBC,EAAkB,IAAIC,KAAKC,SAAS,KAAM,CAC9CC,SAAS,EACTC,YAAa,SAGf,SAASC,EAAcvkB,EAAQwkB,GAC7B,OAAIxkB,EAAIwkB,GACE,EACCxkB,EAAIwkB,EACN,EAEF,EAGT,SAASC,EAAezkB,EAAWwkB,GAGjC,OAAON,EAAgBQ,QAAQ1kB,EAAGwkB,GAQ7B,SAASG,EACd31B,EACA41B,EACAC,GAEA,IAAMlrB,EAAQ3K,EAAGpE,IAAI,QADd,EAEgBk6B,EAAoBnrB,GAFpC,mBAEAorB,EAFA,KAEOC,EAFP,KAGP,GAAIJ,EAAgB,GAAKA,GAAiBI,EACxC,MAAM,IAAI90B,MAAJ,4BACiB00B,EADjB,+BACqDI,EADrD,MAeR,IAVA,IAAMC,EAAMtrB,EAAM0c,MAAM,CAAC,OAAQuO,IAC3BM,EAAMC,YAASF,EAAK,OAAQ,CAChCG,QAASX,EACTY,QAASd,EACTe,OAAQf,EACRgB,UAAWhB,EACXiB,WAAYjB,IAGRkB,EAAU,IAAIC,MAAMX,GACjB5Y,EAAI,EAAGA,EAAI4Y,EAAO5Y,GAAK,EAC9BsZ,EAAQtZ,GAAKA,EAQf,OANAsZ,EAAQE,MAAK,SAACC,EAASC,GACrB,IAAMC,EAASC,EAAUpsB,EAAOirB,EAAegB,GACzCI,EAASD,EAAUpsB,EAAOirB,EAAeiB,GAC/C,OAAOhB,EAAgBK,EAAIY,EAAQE,GAAUd,EAAIc,EAAQF,MAGpDL,EAYF,SAAS92B,EAAuBK,GACrC,IAAM0I,EAAQ1I,EAAKA,EAAGpE,IAAI,SAAW,KAC/BwG,EAAOpC,EAAKA,EAAGpE,IAAI,QAAU,KAC7Bq7B,EAAUj3B,EAAKA,EAAGpE,IAAI,WAAa,KAHU,EAKf8M,EAChCwuB,EAAwBxuB,GACxB,CAAC,EAAG,GAP2C,mBAK5CyuB,EAL4C,KAKhCC,EALgC,OAQfH,EAChCC,EAAwBD,GACxB,CAAC,EAAG,GAV2C,mBAQ5Cr3B,EAR4C,KAQhCy3B,EARgC,OAWtBj1B,EAAO0zB,EAAoB1zB,GAAQ,CAAC,EAAG,GAXjB,mBAW5Ck1B,EAX4C,KAWlCC,EAXkC,KAanD,GACgB,IAAbD,GAAkBA,IAAaF,GAClB,IAAbG,GAAkBA,IAAaF,EAEhC,MAAM,IAAIn2B,MACR,oDACUo2B,EADV,eACyBF,EADzB,wBAEUG,EAFV,eAEyBF,EAFzB,MASJ,MAAO,CACLz3B,aACAu3B,aACAG,WACAC,WACAz3B,KARWq3B,EAAaI,EASxB13B,KARWD,EAAa03B,GAerB,SAASxB,EAAoBnrB,GAClC,IAAKA,IAAUA,EAAM/O,IAAI,QACvB,MAAO,CAAC,EAAG,GAGb,IAAMkE,EAAO6K,EAAM/O,IAAI,QAAQuC,KAC/B,OAAa,IAAT2B,EACK,CAAC,EAAG,GAGN,CADM03B,EAAY7sB,EAAM0c,MAAM,CAAC,OAAQ,KAChCvnB,GAaT,SAAS23B,EAAwBz3B,GAOtC,IANA,IAAM03B,EAAU,GADuD,EAEhD5B,EAAoB91B,EAAGpE,IAAI,SAFqB,mBAEhEm6B,EAFgE,KAEzDC,EAFyD,KAIjE2B,EAAY33B,EAAGpE,IAAI,WACnBg8B,EAAS53B,EAAGpE,IAAI,QAEb6uB,EAAI,EAAGA,EAAIsL,EAAOtL,IAAK,CAG9B,IAFA,IAAMoN,EAAkC,GAE/BpJ,EAAI,EAAGA,EAAIuH,EAAOvH,IACzBoJ,EAAQC,EAASH,EAAW,EAAGlJ,IAAMsJ,EAASH,EAAQnJ,EAAGhE,GAG3DiN,EAAQn3B,KAAKs3B,GAKf,OAAOH,EAYF,SAAS92B,EAAaZ,EAASi2B,EAAU53B,GAAgB,IAAD,EAC1BsB,EAAuBK,GAAlDJ,EADqD,EACrDA,WAAYu3B,EADyC,EACzCA,WACpB,GAAIlB,EAAMkB,EACR,OAAI94B,EAAMuB,EACD,CACLiB,SAAU,GACVC,OAAQ,GACR/E,KAAM,UAGD,CACL8E,SAAUi3B,EAAS93B,EAAGpE,IAAI,SAAUq6B,EAAK53B,EAAMuB,GAC/CkB,OAAQ,GACR/E,KAAM,cAIV,GAAIsC,EAAMuB,EACR,MAAO,CACLiB,SAAUi3B,EAAS93B,EAAGpE,IAAI,WAAYyC,EAAK43B,EAAMkB,GACjDr2B,OAAQ,GACR/E,KAAM,cAKR,IAAMi8B,EA6BL,SACLC,EACAC,EACAC,GAEA,GAAkB,MAAdF,EACF,OAGF,IAAMG,EAAYH,EAAW5Q,MAC3B,CAAC,OAAQ6Q,EAAa,SAAUC,QAChCt5B,GAEF,GAAiB,MAAbu5B,EACF,OAGF,OAAOA,EAAUx8B,IAAI,mBACjBw8B,EAAUx8B,IAAI,qBACdiD,EAhD2Bw5B,CACzBr4B,EAAGpE,IAAI,SACPq6B,EAAMkB,EACN94B,EAAMuB,GAQR,MAAO,CACLiB,SALsB,MAAtBm3B,EACIA,EACAD,EAAS/3B,EAAGpE,IAAI,QAASq6B,EAAMkB,EAAY94B,EAAMuB,GAIrDkB,OACEw3B,EACEt4B,EAAGpE,IAAI,SACPq6B,EAAMkB,EACN94B,EAAMuB,IACH,GACP7D,KAAM,QAoCP,SAASu8B,EACdL,EACAC,EACAC,GAEA,GAAkB,MAAdF,EAAJ,CAIA,IAAMM,EAAYN,EAAW5Q,MAC3B,CAAC,OAAQ6Q,EAAa,SAAUC,EAAU,YAC1Ct5B,GAEF,GAAiB,MAAb05B,EAAJ,CAIA,IAAMz3B,EAAiC,GAOvC,OANAy3B,EAAUhe,SAAQ,SAACie,GAEjB,IAAMC,EAAWD,EAAK58B,IAAI,YAC1BkF,EAAO43B,IAAUD,IAAaD,EAAK58B,IAAI,YAGlCkF,IAMF,SAASi3B,EAASptB,EAAYutB,EAAkBC,GACrD,OAAOQ,EAAYhuB,EAAM0c,MAAM,CAAC,OAAQ6Q,IAAeC,GAMlD,SAASpB,EAAUpsB,EAAYutB,EAAkBC,GACtD,OAAOS,EAAajuB,EAAM0c,MAAM,CAAC,OAAQ6Q,KAAet8B,IAAIu8B,GAOvD,SAASjB,EAAwBxuB,GACtC,OAAOa,YAAcb,EAAO,OAAQ,CAClCmwB,WAAY,SAACC,GAAD,MAAc,CAAC,EAAGtB,EAAYsB,EAAIl9B,IAAI,WAClDm9B,WAAY,SAACD,GAAD,MAAc,CAAC,EAAGA,EAAIl9B,IAAI,QAAUk9B,EAAIl9B,IAAI,WACxDo9B,WAAY,SAACF,GAAD,OACiB,IAA3BA,EAAIl9B,IAAI,UAAUuC,KACd,CAAC,EAAG,GACJ,CAAC26B,EAAIl9B,IAAI,UAAUuC,KAAM26B,EAAIzR,MAAM,CAAC,SAAU,EAAG,SAASlpB,OAChE86B,YAAa,SAACH,GAAD,MAAc,CAAC,EAAGA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,OAC3D+6B,cAAe,SAACJ,GAAD,MAAc,CAAC,EAAGA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,OAC7Dg7B,cAAe,SAACL,GAAD,MAAc,CAAC,EAAGA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,OAC7Di7B,eAAgB,SAACN,GAAD,MAAc,CAAC,EAAGA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,SAO3D,SAAS25B,EAASpvB,EAAY2wB,EAAYlc,GAC/C,IAAMphB,EAAO2M,EAAM9M,IAAI,QACvB,GAAa,eAATG,GAAmC,IAAVs9B,EAC3B,MAAM,IAAIn4B,MAAJ,qCAAwCm4B,EAAxC,iBAAsDt9B,EAAtD,MAER,OAAOwN,YAAcb,EAAO,OAAQ,CAClCmwB,WAAY,SAACC,GAAD,OAAcH,EAAYG,EAAIl9B,IAAI,QAASuhB,IACvD4b,WAAY,SAACD,GAAD,OAAcA,EAAIl9B,IAAI,SAAWuhB,GAC7C6b,WAAY,SAACF,GACX,IAAMQ,EAASR,EAAIzR,MAAM,CAAC,SAAUgS,IAE9B3mB,EADSomB,EAAIzR,MAAM,CAAC,SAAUgS,IACfhS,MAAM,CAAC,OAAQlK,IACpC,OAAIzK,EAAQ,EACH,MAEAolB,EAASwB,EAAQ,EAAG5mB,IAG/BumB,YAAa,SAACH,GAAD,OAAcA,EAAIzR,MAAM,CAAC,OAAQ,OAAQlK,KACtD+b,cAAe,SAACJ,GAAD,OAAcA,EAAIzR,MAAM,CAAC,OAAQ,OAAQlK,KACxDgc,cAAe,SAACL,GAAD,OACbrF,IAAO8F,YAAYT,EAAIzR,MAAM,CAAC,OAAQ,OAAQlK,MAChDic,eAAgB,SAACN,GAAD,OACdrF,IAAO+F,gBAAgBV,EAAIzR,MAAM,CAAC,OAAQ,OAAQlK,QAqBxD,SAASqa,EAAYiC,GACnB,OAAOb,EAAaa,GAAUt7B,KAMhC,SAASw6B,EAAYc,EAAetc,GAClC,IAAMuc,EAAU,SAACz0B,GAAD,OAAmBA,EAAIrJ,IAAI,QAAQA,IAAIuhB,IACvD,OAAO5T,YAAckwB,EAAU,OAAQ,CACrCrD,QAASsD,EACTrD,QAASqD,EACTpD,OAAQoD,EACRnD,UAAW,SAACtxB,GAAD,OAAcwuB,IAAO8F,YAAYG,EAAQz0B,KACpDuxB,WAAY,SAACvxB,GAAD,OAAcwuB,IAAO+F,gBAAgBE,EAAQz0B,OAO7D,SAAS2zB,EAAaa,GACpB,IAAMC,EAAU,SAACz0B,GAAD,OAAmBA,EAAIrJ,IAAI,SAC3C,OAAO2N,YAAckwB,EAAU,OAAQ,CACrCrD,QAASsD,EACTrD,QAASqD,EACTpD,OAAQoD,EACRnD,UAAWmD,EACXlD,WAAYkD,IAOT,SAAS3R,EAAQtsB,EAAcusB,GACpC,IAQI2R,EAgCAC,EAxCEj+B,EAAOqsB,EAAapsB,IAAI,WAAaosB,EAAapsB,IAAI,QAAU,KAChEi+B,EAAU7R,EAAapsB,IAAI,QAF2B,EAwL9D,SAAyBk+B,EAAoBn+B,GAC3C,GAAqB,MAAjBm+B,EAAuB,CACzB,GAA2B,IAAvBA,EAAc37B,KAEhB,MAAO,CAAC,EADkB27B,EAAcC,SAI1C,IAAMC,EAAoBF,EAAcG,WACtC,SAACC,GAAD,OAAaA,EAAGt+B,IAAI,YAAcs+B,EAAGt+B,IAAI,UAAYD,KAGvD,GAAIq+B,EACF,OAAOA,EAIX,MAAO,EAAE,EAAG,MAnMoCG,CAsKlD,SAA0B1+B,GACxB,OAAO8N,YAAc9N,EAAS,OAAQ,CACpCoP,cAAe,SAACuvB,GAAD,OAAgBA,EAAMx+B,IAAI,aACzCy+B,MAAO,kBAAM,QA3KOC,CAAiB7+B,GAIrCE,GAP0D,mBAKrD4+B,EALqD,KAK/BC,EAL+B,KAmB5D,GAAIxS,EAAapsB,IAAI,WAAY,CAC/B,IAAI4+B,EAGF,OAsMN,SAA0B/+B,EAAcg/B,GACtC,OAAOC,YAAYj/B,EAAS,OAAQ,CAClCoP,cAAe,SAACuvB,GAAD,OACbA,EAAMnS,OAAO,YAAY,SAAC0S,GAAD,OAAmBA,EAASp6B,KAAKk6B,SAzMnDG,CAAiBn/B,EAASusB,GAFjC2R,EAAoBa,EAAgB5+B,IAAI,YAIrC,CACL,IAAMi/B,EAuIV,SAAsBp/B,GACpB,OAAO8N,YAAc9N,EAAS,OAAQ,CACpC2+B,MAAO,SAACA,GAAD,OAAgBA,EAAMx+B,IAAI,SACjCkO,UAAW,SAAC9J,GAAD,OAAaA,GACxB2K,MAAO,SAAC3K,GAAD,OAAaA,GACpB86B,UAAW,SAACrxB,GAAD,OAAaA,EAAG7N,IAAI,SAC/BiP,cAAe,SAACuvB,GAAD,OAAgBA,EAAMx+B,IAAI,WA7Ifm/B,CAAat/B,GACvC,GAAIo/B,EACFlB,EAAoBkB,MACf,KAAIL,EAGT,OAAOQ,EAAav/B,EAASo+B,GAF7BF,EAAoBa,EAAgB5+B,IAAI,SAuC5C,OAjCqC,MAAjC+9B,EAAkB/9B,IAAI,UAExB+9B,GADAA,EAAoBA,EAAkBh0B,IAAI,OAAQ+tB,iBAAO,CAAE5zB,KAAM,OAC3B6F,IAAI,QAAS+tB,iBAAO,CAAE5zB,KAAM,OAWlE85B,EALAD,EACG/9B,IAAI,QACJA,IAAI,QACJ0S,UAEYurB,EAEAF,EACZ1R,OAAO,SAAS,SAACvf,GAAD,OA+BvB,SAAqBuyB,EAAaC,GAEhC,GAAyB,IAArBC,EAASF,GACX,OAAOC,EAIT,IAAME,EAAQH,EAAOr/B,IAAI,QACnBy/B,EAAQH,EAAOt/B,IAAI,QACzB,GAAIw/B,IAAUC,EACZ,MAAM,IAAIn6B,MAAJ,6BAAgCk6B,EAAhC,iBAA8CC,EAA9C,MAIR,OAAOX,YAAYO,EAAQ,OAAQ,CACjCpC,WAAY,SAACC,GAAD,OACVA,EAAI7Q,OAAO,QAAQ,SAAC7lB,GAAD,OACjBk5B,EAAel5B,EAAM84B,EAAO7T,MAAM,CAAC,aAAc,cAErD0R,WAAY,SAACD,GAAD,OACVA,EAAI7Q,OAAO,QAAQ,SAAC0C,GAAD,OAAeA,EAAOwQ,EAASD,OAEpDjC,YAAa,SAACH,GAAD,OACXA,EAAIjR,SAAS,CAAC,OAAQ,SAAS,SAACzlB,GAAD,OAC7BA,EAAK8nB,OAAOgR,EAAO7T,MAAM,CAAC,cAAe,OAAQ,cAErD6R,cAAe,SAACJ,GAAD,OACbA,EAAIjR,SAAS,CAAC,OAAQ,SAAS,SAACzlB,GAAD,OAC7BA,EAAK8nB,OAAOgR,EAAO7T,MAAM,CAAC,gBAAiB,OAAQ,cAEvD8R,cAAe,SAACL,GAAD,OACbA,EAAIjR,SAAS,CAAC,OAAQ,SAAS,SAACzlB,GAAD,OAC7BA,EAAK8nB,OAAOgR,EAAO7T,MAAM,CAAC,gBAAiB,OAAQ,cAEvD+R,eAAgB,SAACN,GAAD,OACdA,EAAIjR,SAAS,CAAC,OAAQ,SAAS,SAACzlB,GAAD,OAC7BA,EAAK8nB,OAAOgR,EAAO7T,MAAM,CAAC,iBAAkB,OAAQ,gBAlEpDkU,CAAY7yB,EAAOmxB,EAAQj+B,IAAI,aAEhCisB,SAAS,CAAC,OAAQ,SAAS,SAAC/nB,GAC3B,OAAOA,EAAK07B,SACV,SAACC,EAAWC,GAAZ,OAA0BJ,EAAeG,EAAMC,KAC/C7B,EAAQxS,MAAM,CAAC,OAAQ,aAG1BQ,SAAS,CAAC,QAAS,SAAS,SAAC8T,GAC5B,OAAOA,EAAWH,SAChB,SAACC,EAAWC,GAAZ,OAoFV,SAA8BE,EAAaC,GAEzC,GAAoC,IAAhCD,EAAOhgC,IAAI,UAAU6jB,OACvB,OAAOoc,EAET,OAAOD,EAAO3T,OAAO,UAAU,SAACnnB,GAAD,OAC7BA,EAAOopB,OAAO2R,EAAOjgC,IAAI,cA1FOkgC,CAAqBL,EAAMC,KACrD7B,EAAQxS,MAAM,CAAC,QAAS,aAK5BmT,EAmKN,SAAoC/+B,EAAciN,EAAY1I,GAC5D,OAAO06B,YAAYj/B,EAAS,OAAQ,CAClCoP,cAAe,SAACuvB,GAAD,OACbA,EAAM9S,MAAM,CAAC,WAAY5e,EAAO,QAAS1I,MArKpC+7B,CACLtgC,EACA8+B,EACAX,GAGKoB,EAAav/B,EAASm+B,GAmDjC,SAAS0B,EAAeU,EAAgBC,GAEtC,GAA+B,IAA3BzE,EAAYwE,GACd,OAAOC,EAGT,IAAMb,EAAQY,EAAUpgC,IAAI,QACtBy/B,EAAQY,EAAUrgC,IAAI,QAC5B,GAAIw/B,IAAUC,EACZ,MAAM,IAAIn6B,MAAJ,6BAAgCk6B,EAAhC,gBAA6CC,EAA7C,MAGR,OAAOW,EAAUnU,SAAS,CAACuT,EAAO,SAAS,SAACc,GAAD,OACzCA,EAAMhS,OAAO+R,EAAU5U,MAAM,CAACgU,EAAO,aAmEzC,SAASL,EAAav/B,EAAcuE,GAClC,OAAO06B,YAAYj/B,EAAS,OAAQ,CAClC2+B,MAAO,SAACA,GAAD,OAAgBA,EAAMz0B,IAAI,OAAQ3F,IACzC8J,UAAW,kBAAM9J,GACjB2K,MAAO,kBAAM3K,GACb86B,UAAW,SAACrxB,GAAD,OAAaA,EAAG9D,IAAI,OAAQ3F,IACvC6K,cAAe,SAACuvB,GAAD,OAAgBA,EAAMz0B,IAAI,OAAQ3F,MA6BrD,SAASm7B,EAASzyB,GAChB,OAAOa,YAAcb,EAAO,OAAQ,CAClCmwB,WAAY,SAACC,GAAD,OAActB,EAAYsB,EAAIl9B,IAAI,UAC9Cm9B,WAAY,SAACD,GAAD,OAAcA,EAAIl9B,IAAI,QAAUk9B,EAAIl9B,IAAI,UACpDo9B,WAAY,SAACF,GAAD,OACiB,IAA3BA,EAAIl9B,IAAI,UAAUuC,KAAa,EAAI26B,EAAIzR,MAAM,CAAC,SAAU,IAAIlpB,MAC9D86B,YAAa,SAACH,GAAD,OAAcA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,MACvD+6B,cAAe,SAACJ,GAAD,OAAcA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,MACzDg7B,cAAe,SAACL,GAAD,OAAcA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,MACzDi7B,eAAgB,SAACN,GAAD,OAAcA,EAAIzR,MAAM,CAAC,OAAQ,SAASlpB,U,mGCjmB/ClB,E,iLAvBqB,IAAD,EACE1B,KAAKC,MAA9BG,EADuB,EACvBA,KAAMoB,EADiB,EACjBA,QAASC,EADQ,EACRA,MAIjBm/B,EAAan/B,EAAQA,EAAMo/B,MAAM,MAAQ,GAC/CD,EAAWE,QACX,IAAMC,EAAeH,EAAW/9B,KAAI,SAAAqkB,GAAC,OAAIA,EAAE8Z,UAAQtvB,KAAK,MAExD,OACE,kBAAC,QAAD,CAAO0G,MAAM,SAASpX,MAAO,CAAEb,MAAOH,KAAKC,MAAME,QAC/C,gCAASC,EAAT,MACCoB,EACAC,EACC,yBAAKd,UAAU,SACb,8BAAOogC,IAEP,U,GAlBe9/B,iBCjC3B,mC,gCCAA,oJAsBO,SAASme,IACG,IAAD,EAAZuL,MACF,EAAAsW,SAAQC,IAAR,mBASG,SAASz5B,IACG,IAAD,EAAZkjB,MACF,EAAAsW,SAAQE,KAAR,mBAUG,SAAS5/B,IAAgC,IAAD,GAC7C,EAAA0/B,SAAQ7/B,MAAR,mBAQK,SAAS6oB,IAAiC,IAAD,GAC9C,EAAAgX,SAAQC,IAAR,qB,kICLI1vB,G,kNAGGrQ,MAAe,CAAEigC,UAAU,EAAOC,UAAW,EAAGC,WAAY,G,EAanEC,YAAc,SAAC72B,GAAsB,IAC3B02B,EAAa,EAAKjgC,MAAlBigC,SAEc,KAAlB12B,EAAM82B,SAAkBJ,GAE1B,EAAKK,W,EAITC,OAAS,WACPlvB,SAASrP,KAAKnC,MAAM2gC,SAAW,SAC/BnwB,EAAkBC,cAAe,EACjC,EAAKzK,SAAS,CAAEo6B,UAAU,K,EAG5BK,QAAU,WACRjvB,SAASrP,KAAKnC,MAAM2gC,SAAW,QAC/BnwB,EAAkBC,cAAe,EACjC,EAAKzK,SAAS,CAAEo6B,UAAU,K,EAG5BQ,4BAA8B,SAACC,GAE7B,OADiBC,WAAWD,GAG1BC,WAAWC,iBAAiBvvB,SAASwvB,iBAAiBC,W,EAI1DC,uBAAyB,WACvB,IAAMC,EAAU,EAAKP,4BACnBtI,IAAU,wBAEN8I,EAAa,EAAKR,4BACtBtI,IAAU,4BAEZ,EAAKtyB,SAAS,CACZq6B,UAAWv4B,OAAOgJ,WAAuB,EAAVqwB,EAC/Bb,WAAYx4B,OAAOu5B,aAAeF,EAAUC,M,mFAhD9CpiC,KAAKkiC,yBACLp5B,OAAO6B,iBAAiB,SAAU3K,KAAKkiC,wBACvC1vB,SAAS7H,iBAAiB,UAAW3K,KAAKuhC,aAAa,K,6CAIvDz4B,OAAO2J,oBAAoB,SAAUzS,KAAKkiC,wBAC1C1vB,SAASC,oBAAoB,UAAWzS,KAAKuhC,aAAa,K,+BA6C9B,IAAD,EACiBvhC,KAAKmB,MAAzCigC,EADmB,EACnBA,SAAUC,EADS,EACTA,UAAWC,EADF,EACEA,WADF,EAESthC,KAAKC,MAAjC6B,EAFmB,EAEnBA,SAAU3B,EAFS,EAETA,MAAO8H,EAFE,EAEFA,OAErBq6B,EAAkB,4BAClBC,EAAc,mBACdC,EAAgBxiC,KAAK0hC,OACrBe,EAAc,kBASlB,OAPIrB,IACFkB,EAAkB,2BAClBC,EAAc,kBACdC,EAAgBxiC,KAAKyhC,QACrBgB,EAAc,mBAId,yBAAK9hC,UAAS,yBAAoBygC,EAAW,aAAe,KAC1D,4BACEzgC,UAAW2hC,EACXhwB,QAASkwB,EACT/4B,MAAOg5B,GAEP,kBAAClwB,EAAA,EAAD,CAAM/R,KAAM+hC,KAGVzgC,EADHs/B,EACY,CAAEjhC,MAAOkhC,EAAWp5B,OAAQq5B,EAAYF,YACxC,CAAEjhC,QAAO8H,SAAQm5B,kB,GArFNngC,kBAA1BuQ,EACGC,cAAe,EA0FTD,QC7If,mC,2YCwBMkxB,EAAQpJ,IAAS,OACjBqJ,EAAerJ,IAAU,kBACzBsJ,EAAiBtJ,IAAU,0BAC3BuJ,EAAiBvJ,IAAU,2BAC3BwJ,EAAexJ,IAAU,mBACzByJ,EAAazJ,IAAU,iBACvB0J,EAAW1J,IAAU,cACrB2J,EAAO3J,IAAS,MAChB4J,EAAY5J,IAAU,eACtB6J,EAAc7J,IAAU,iBACxB8J,EAAe9J,IAAU,kBACzB+J,EAAgB/J,IAAU,iBAC1BgK,EAAiBhK,IAAU,qBAC3BiK,EAAkBjK,IAAU,sBAC5BkK,EAAUlK,IAAS,SACnBmK,EAAanK,IAAU,gBACvBoK,EAAkBpK,IAAU,sBAC5BqK,EAAarK,IAAU,iBACvBsK,EAAiBtK,IAAU,sBAC3BuK,EAAQvK,IAAS,OAEjBwK,EAAa,CACjBC,WAAYlB,EACZZ,SAAUa,EACVkB,WAAY,SACZC,WAAYX,GAGDY,EAAkB,CAC7BC,KAAM,CACJnjC,MAAO,CACLohC,WAAYsB,IAGhBU,MAAO,CACLpjC,MAAO,kBAA4C,CACjDqjC,gBADK,EAAGC,UACqBrB,EAAOO,EACpCe,oBAAqB,OACrBC,qBAAsB,OACtBC,uBAAwB,OACxBC,wBAAyB,OACzBC,YAAa,OACbC,UAAW,OACX38B,OAAQqxB,IAAU,wBAClBn5B,MAAOm5B,IAAU,wBACjB,SAAU,CACRsL,UAAU,gBAAD,OAAkBnB,GAC3BpxB,QAAS,WAIfwyB,WAAY,CACV7jC,MAAO,CACL8jC,QAAS,SAGbC,KAAM,CACJ/jC,MAAO,CACL+iC,WAAYnB,EACZX,SAAUoB,IAGd2B,WAAY,CACVhkC,MAAO,gBAAGsjC,EAAH,EAAGA,UAAH,MAA4C,CACjDP,WAAYnB,EACZX,SAAUoB,EACV4B,cAAevB,EACftrB,MAAOksB,EAAYrB,EAAOO,EAC1B0B,IAAK,QACLC,SAAU,WACVC,WAAY,SACZf,gBAAiB,cACjBJ,WAAYX,EACZU,WAAY,YAGhBqB,QAAS,CACPrkC,MAAO,CACLikC,cAAe,EACfK,YAAa,EACbC,aAAc,EACdnD,WAAYsB,EACZ8B,eAAgB,gBAChBC,WAAY,SACZX,QAAS,SAGbY,YAAa,CACX1kC,MAAO,CACLijC,WAAYX,EACZU,WAAY,SACZ/B,SAAUoB,EACVU,WAAYnB,IAGhB+C,MAAO,CACL3kC,MAAO,CACLikC,cAAe,EACfK,YAAa,EACbC,aAAc,EACdnD,WAAYsB,IAGhBkC,WAAY,CACV5kC,MAAO,qBAAGsjC,UACI,CAAEuB,WAAY1C,GAAgB,MAInC2C,EAA2D,CAEtEC,gBAAiB,CACf/kC,MAAO,gBACLglC,EADK,EACLA,OACAC,EAFK,EAELA,cAFK,MAMA,CACLtD,eACAmC,QAAS,OACT1sB,MAAO4qB,EACPf,SAAUc,EACVkB,WAAYV,EACZ2C,cAAe,SACfV,eAAgB,SAChBpD,WAAY,UACZ6C,cAAe,UACfK,YAAa,UACbC,aAAc,UACdt9B,OAAQ,UACRk+B,YAAaF,EAAgBzC,EAAU,cACvCa,gBAAiB4B,EAAgBxC,EAAauC,EAAOI,OAAOC,QAC5D1B,YAAa,QACb2B,YAAa,MACb,SAAU,CACRj0B,QAAS,EACT8zB,YAAa3C,MAInB+C,iBAAkB,CAChBvlC,MAAO,CACLihC,SAAUc,EACV3qB,MAAO4qB,EACPiB,WAAYV,EACZuB,QAAS,KAGb0B,eAAgB,CACdxlC,MAAO,CACLihC,SAAUc,EACV3qB,MAAO4qB,EACPiB,WAAYV,EACZuB,QAAS,KAGb2B,gBAAiB,CACfxmC,MAAO,CACLymC,UAAW,CACTC,WAAY,CACV3lC,MAAO,CACLoX,MAAOorB,EACPvB,SAAUc,EACVkB,WAAYV,EACZ0B,cAAe,EACfK,YAAa,SACbC,aAAc,SACdnD,WAAY,EACZwE,cAAe,YACf,SAAU,CACRvC,gBAAiB,cACjBwC,eAAgB,aAElB,UAAW,CACTxC,gBAAiB,cACjBwC,eAAgB,aAElB,YAAa,CACXxC,gBAAiB,cACjBjsB,MAAO4qB,GAET,SAAU,CACR3wB,QAAS,EACTgyB,gBAAiB,qBASlByC,EAAsB,CACjCC,QAAS,CACP9mC,MAAO,CACLmX,UAAW4vB,IAAkBC,aAGjCC,kBAAmB,CACjBlmC,MAAO,CACLihC,SAAUc,IAGdoE,eAAgB,CACdnmC,MAAO,CAELqjC,gBAAiBpB,IAGrBmE,YAAa,CACXpmC,MAAO,CAELqjC,gBAAiBpB,IAGrBoE,KAAM,CACJrmC,MAAO,CACLihC,SAAUc,IAGduE,IAAK,CACHtmC,MAAO,kBAA4C,CACjD,UAAW,CACTmlC,YAFG,EAAGoB,UAEmB,cAAgB,OAI/CC,WAAY,CACVxmC,MAAO,iBAAO,CAEZ8jC,QAAS,OACTW,WAAY,SACZD,eAAgB,SAEhB,UAAW,CACTnB,gBAAiB,eAEnB,SAAU,CACRA,gBAAiB,cACjBhyB,QAAS,MAIfo1B,WAAY,CACVzmC,MAAO,CAEL8jC,QAAS,OACTW,WAAY,SACZD,eAAgB,SAEhB,UAAW,CACTnB,gBAAiB,eAEnB,SAAU,CACRA,gBAAiB,cACjBhyB,QAAS,KAIfq1B,MAAO,CACLznC,MAAO,CAGL0nC,SAAU,QAKHC,EAAkB,CAC7BjB,WAAY,CACV3lC,MAAO,CACLohC,WAAYwB,EACZqB,cAAerB,EACf0B,YAAa3B,EACb4B,aAAc5B,EACdU,gBAAiBR,EAKjBgE,OAAO,aAAD,OAAe1E,GACrB/qB,MAAOsqB,EACP,SAAU,CACR2B,gBAAiB,cACjB8B,YAAa3C,EACbprB,MAAOorB,GAET,SAAU,CACRa,gBAAiBR,EACjBsC,YAAa3C,EACboB,UAAU,gBAAD,OAAkBnB,GAC3BrrB,MAAOorB,EACPnxB,QAAS,QAEX,UAAW,CACT+F,MAAOyrB,GAET,YAAa,CACXQ,gBAAiBlB,EACjBgD,YAAa,cACb/tB,MAAO6qB,GAET,kBAAmB,CACjBoB,gBAAiBlB,EACjBgD,YAAa,cACb/tB,MAAO6qB,MAMF6E,EAAuB,CAClCC,eAAgB,CACd/mC,MAAO,iBAAO,CAUZgnC,UAAW,UAGfC,UAAW,CACTjnC,MAAO,CACLoX,MAAO4qB,IAGXkF,WAAY,CACVlnC,MAAO,CACLoX,MAAO4qB,IAGXmF,WAAY,CACVloC,MAAO,CACLymC,UAAW,CACTvC,KAAM,CACJnjC,MAAO,CACLihC,SAAU,aAQTmG,EAAiB,CAC5BjE,KAAM,CACJnjC,MAAO,gBAAGqnC,EAAH,EAAGA,WAAH,MAA8C,CACnDC,aAAc,EACdC,UAAW,EACXhD,aAAc7B,EACdW,gBAAiBgE,EAAajF,EAAe,GAC7CmB,oBAAqB5B,EACrB6B,qBAAsB7B,EACtB8B,uBAAwB9B,EACxB+B,wBAAyB/B,KAG7B6F,eAAgB,CACdxnC,MAAO,gBAAGynC,EAAH,EAAGA,SAAH,MAA0C,CAC/CxgC,OAAQwgC,EAAW,MAAQ,OAC3BtoC,MAAOsoC,EAAW,MAAQ,WAKnBC,EAAiB,eACzBN,EADyB,CAE5BO,UAAW,CACT3nC,MAAO,gBACL4nC,EADK,EACLA,gBACAH,EAFK,EAELA,SAFK,MAMA,CACLnC,YAAa,MACbj0B,QAAS,EACTuyB,UACEgE,GAAmBH,EAAnB,uBAA8ChF,GAAe,QAY/DoF,EAAmB,eACpBC,IADoB,CAGvBC,kBAAmBzP,IAAU,2BAE7B0P,WAAYxF,EACZyF,WAAYzF,EACZ0F,WAAY1F,EACZ2F,WAAY3F,EACZ4F,WAAY5F,EACZ6F,WAAY7F,EACZ8F,WAAY9F,EAIZ+F,QAAS1F,EACTwC,QAASjD,EACToG,QAASrG,EACTsG,QAAStG,EACTuG,QAASzG,EACT0G,QAAS1G,EACT2G,QAAS3G,EACT4G,QAAS7G,EACT8G,QAAS9G,EACT+G,SAAUrH,EAEVsH,UAAW,UACXC,UAAW,YAMPC,EAAiB,CACrBC,QAAS,CACPC,UAAWzH,EACX0H,UAAW1H,EACX2H,UAAW3H,EACX4H,UAAW5H,EACX6H,mBAAoB7H,EACpB8H,kBAAmB9H,EACnB+H,oBAAqB/H,EACrBgI,oBAAqBhI,GAEvBiI,WAAY,CAGVC,QAAS,GACTC,QAAQ,eAAMhH,GACdiH,QAAS,GACTC,QAAS,GACTC,QAAQ,eAAMnH,GACdoH,QAAQ,eAAMpH,GACdqH,QAAQ,eAAMrH,GACdsH,QAAQ,eAAMtH,GACduH,QAAQ,eAAMvH,GACdwH,QAAQ,eAAMxH,GACdyH,QAAQ,eAAMzH,GACd0H,QAAS,GAETC,YAAY,eAAM3H,GAClB4H,WAAW,eAAM5H,GACjB6H,YAAY,eAAM7H,GAClB8H,WAAW,eAAM9H,GACjB+H,eAAe,eAAM/H,IAGvBsC,OAAQ,CACNvC,MAAOA,EACPnB,MAAOA,EACPc,QAASA,EACTsI,SAAUtI,EACVuI,OAAQtI,EACRuI,0BAA2BxI,EAC3ByI,YAAazI,EACb0I,eAAgBxJ,EAChByJ,UAAW/I,EACXgJ,iBAAkBpJ,EAClBqJ,YAAajJ,EACbkJ,gBAAiBlJ,EACjBmJ,qBAAsBpJ,EACtBqJ,iBAAkBvJ,EAClBwJ,aAAcrJ,EACdsJ,iBAAkBlJ,EAClBmJ,iCAAkCzJ,EAClC0J,8BAA+BpJ,EAC/BqJ,yCAA0CrJ,EAC1CsJ,8BAA+BjJ,EAC/BkJ,yCAA0ClJ,IAIjCxwB,EAAkB25B,YAAYnE,EAAqBqB,GAEnD/2B,EAAqB65B,YAAY,eAEvCnE,EAFsC,CAMzCU,QAAS1F,EACTwC,QAASxC,EACT2F,QAAS3F,EACT4F,QAASvG,IATgC,eAYtCgH,EAZsC,CAazC9D,OAAO,eACF8D,EAAe9D,OADd,CAEJ+F,UAAWtI,EACXyI,gBAAiBzI,OAMvBzkB,YAAW,kBAAmB/L,GAC9B+L,YAAW,qBAAsBjM,I,gCCzhBjC,6kBAMM85B,EAAUC,SAAkBC,EAAUD,SAAkBE,EAAQF,OAGhEG,EAAQH,QAAA,UAA+BA,QAAA,QAA6B,IAE7D/+B,EAAQk/B,EAAMl/B,MAAS,WAkBhC,SAASA,EAAMm/B,GACX,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyOhD,OAhOAzT,EAAMo/B,UAAUpqC,KAAO,GAQvBgL,EAAMo/B,UAAUrV,OAAS,EAUzB/pB,EAAMwR,OAAS,SAAgB2tB,GAC3B,OAAO,IAAIn/B,EAAMm/B,IAYrBn/B,EAAM6U,OAAS,SAAgBxhB,EAASgsC,GAOpC,OANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ2B,MAAgBwqB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2B,MACtC,MAAlB3B,EAAQ02B,QAAkBvK,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQ02B,QACpDsV,GAYXr/B,EAAM0/B,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC3/B,EAAMqQ,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMl/B,MAChF6W,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ2B,KAAO6hB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQ02B,OAASlT,EAAO4oB,QACxB,MACJ,QACI5oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2M,EAAMggC,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCv/B,EAAMigC,OAAS,SAAgB5sC,GAC3B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ2B,MACxB,MAAO,wBACf,GAAsB,MAAlB3B,EAAQ02B,QAAkB12B,EAAQoI,eAAe,UACjD,OAAQpI,EAAQ02B,QAChB,QACI,MAAO,8BACX,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,GAGT,OAAO,MAWX/pB,EAAM8Z,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAMl/B,MACxB,OAAOmgC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMl/B,MAGxB,OAFmB,MAAfmgC,EAAOnrC,OACP3B,EAAQ2B,KAAOorC,OAAOD,EAAOnrC,OACzBmrC,EAAOpW,QACf,IAAK,SACL,KAAK,EACD12B,EAAQ02B,OAAS,EACjB,MACJ,IAAK,QACL,KAAK,EACD12B,EAAQ02B,OAAS,EACjB,MACJ,IAAK,UACL,KAAK,EACD12B,EAAQ02B,OAAS,EACjB,MACJ,IAAK,OACL,KAAK,EACD12B,EAAQ02B,OAAS,EACjB,MACJ,IAAK,UACL,KAAK,EACD12B,EAAQ02B,OAAS,EAGrB,OAAO12B,GAYX2M,EAAMqgC,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOnrC,KAAO,GACdmrC,EAAOpW,OAASuW,EAAQE,QAAUJ,OAAS,SAAW,GAEtC,MAAhB/sC,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC/C0kC,EAAOnrC,KAAO3B,EAAQ2B,MACJ,MAAlB3B,EAAQ02B,QAAkB12B,EAAQoI,eAAe,YACjD0kC,EAAOpW,OAASuW,EAAQE,QAAUJ,OAASlB,EAAMl/B,MAAMygC,OAAOptC,EAAQ02B,QAAU12B,EAAQ02B,QACrFoW,GAUXngC,EAAMo/B,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAa1D5gC,EAAMygC,OAAU,WACZ,IAAMI,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAM9C,OALAC,EAAOD,EAAW,GAAK,UAAY,EACnCC,EAAOD,EAAW,GAAK,SAAW,EAClCC,EAAOD,EAAW,GAAK,WAAa,EACpCC,EAAOD,EAAW,GAAK,QAAU,EACjCC,EAAOD,EAAW,GAAK,WAAa,EAC7BC,EAPK,GAUT9gC,EA/PyB,GAsuCvB2U,GAp+BiBuqB,EAAM6B,eAAkB,WAmBlD,SAASA,EAAe5B,GACpB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmNhD,OA1MAstB,EAAe3B,UAAU1mC,KAAO,KAQhCqoC,EAAe3B,UAAUtlC,OAAS,EAQlCinC,EAAe3B,UAAUptC,MAAQ,EAUjC+uC,EAAevvB,OAAS,SAAgB2tB,GACpC,OAAO,IAAI4B,EAAe5B,IAY9B4B,EAAelsB,OAAS,SAAgBxhB,EAASgsC,GAS7C,OARKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAM8B,WAAWnsB,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACrE,MAAlBtsC,EAAQyG,QAAkB0lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQyG,QACvC,MAAjBzG,EAAQrB,OAAiBwtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQrB,OACrDqtC,GAYX0B,EAAerB,gBAAkB,SAAyBrsC,EAASgsC,GAC/D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCoB,EAAe1wB,OAAS,SAAgBwG,EAAQd,GACtCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM6B,eAChFlqB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAM8B,WAAW3wB,OAAOwG,EAAQA,EAAO0oB,UACtD,MACJ,KAAK,EACDlsC,EAAQyG,OAAS+c,EAAO0oB,SACxB,MACJ,KAAK,EACDlsC,EAAQrB,MAAQ6kB,EAAO0oB,SACvB,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0tC,EAAef,gBAAkB,SAAyBnpB,GAGtD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCwB,EAAed,OAAS,SAAgB5sC,GACpC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAM8B,WAAWf,OAAO5sC,EAAQqF,MAC5C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAsB,MAAlBI,EAAQyG,QAAkBzG,EAAQoI,eAAe,YAC5CwjC,EAAMiC,UAAU7tC,EAAQyG,QAClB,2BACM,MAAjBzG,EAAQrB,OAAiBqB,EAAQoI,eAAe,WAC3CwjC,EAAMiC,UAAU7tC,EAAQrB,OAClB,0BACR,MAWX+uC,EAAejnB,WAAa,SAAoBqmB,GAC5C,GAAIA,aAAkBjB,EAAM6B,eACxB,OAAOZ,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM6B,eACxB,GAAmB,MAAfZ,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,yCACpB9tC,EAAQqF,KAAOwmC,EAAM8B,WAAWlnB,WAAWqmB,EAAOznC,MAMtD,OAJqB,MAAjBynC,EAAOrmC,SACPzG,EAAQyG,OAASqmC,EAAOrmC,SAAW,GACnB,MAAhBqmC,EAAOnuC,QACPqB,EAAQrB,MAAQmuC,EAAOnuC,QAAU,GAC9BqB,GAYX0tC,EAAeV,SAAW,SAAkBhtC,EAASitC,GAC5CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOznC,KAAO,KACdynC,EAAOrmC,OAAS,EAChBqmC,EAAOnuC,MAAQ,GAEC,MAAhBqB,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAM8B,WAAWX,SAAShtC,EAAQqF,KAAM4nC,IACpC,MAAlBjtC,EAAQyG,QAAkBzG,EAAQoI,eAAe,YACjD0kC,EAAOrmC,OAASzG,EAAQyG,QACP,MAAjBzG,EAAQrB,OAAiBqB,EAAQoI,eAAe,WAChD0kC,EAAOnuC,MAAQqB,EAAQrB,OACpBmuC,GAUXY,EAAe3B,UAAUsB,OAAS,WAC9B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDG,EA1O2C,GA6O5B7B,EAAM8B,WAAc,WAoB1C,SAASA,EAAW7B,GAChB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmQhD,OA1PAutB,EAAW5B,UAAU1mC,KAAOumC,EAAMmC,UAAU,IAQ5CJ,EAAW5B,UAAUpgC,MAAQigC,EAAMmC,UAAU,IAQ7CJ,EAAW5B,UAAU7R,QAAU0R,EAAMmC,UAAU,IAQ/CJ,EAAW5B,UAAUiC,OAAS,KAU9BL,EAAWxvB,OAAS,SAAgB2tB,GAChC,OAAO,IAAI6B,EAAW7B,IAY1B6B,EAAWnsB,OAAS,SAAgBxhB,EAASgsC,GAWzC,OAVKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAI+B,MAAMjuC,EAAQqF,MACtC,MAAjBrF,EAAQ2L,OAAiBwgB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAI+B,MAAMjuC,EAAQ2L,OACpC,MAAnB3L,EAAQk6B,SAAmB/N,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAI+B,MAAMjuC,EAAQk6B,SACrC,MAAlBl6B,EAAQguC,QAAkB7hB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9D6rC,EAAMqC,OAAO1sB,OAAOxhB,EAAQguC,OAAQhC,EAAOE,OAA8B,IAAI0B,QAAQtB,SAClFN,GAYX2B,EAAWtB,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCqB,EAAW3wB,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM8B,WAChFnqB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOme,EAAOyqB,QACtB,MACJ,KAAK,EACDjuC,EAAQ2L,MAAQ6X,EAAOyqB,QACvB,MACJ,KAAK,EACDjuC,EAAQk6B,QAAU1W,EAAOyqB,QACzB,MACJ,KAAK,EACDjuC,EAAQguC,OAASnC,EAAMqC,OAAOlxB,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2tC,EAAWhB,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCyB,EAAWf,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,WACzCpI,EAAQqF,MAAuC,kBAAxBrF,EAAQqF,KAAKqd,QAAuBkpB,EAAMiB,SAAS7sC,EAAQqF,OACpF,MAAO,wBACf,GAAqB,MAAjBrF,EAAQ2L,OAAiB3L,EAAQoI,eAAe,YAC1CpI,EAAQ2L,OAAyC,kBAAzB3L,EAAQ2L,MAAM+W,QAAuBkpB,EAAMiB,SAAS7sC,EAAQ2L,QACtF,MAAO,yBACf,GAAuB,MAAnB3L,EAAQk6B,SAAmBl6B,EAAQoI,eAAe,cAC5CpI,EAAQk6B,SAA6C,kBAA3Bl6B,EAAQk6B,QAAQxX,QAAuBkpB,EAAMiB,SAAS7sC,EAAQk6B,UAC1F,MAAO,2BACf,GAAsB,MAAlBl6B,EAAQguC,QAAkBhuC,EAAQoI,eAAe,UAAW,CAC5D,IAAIxI,EAAQisC,EAAMqC,OAAOtB,OAAO5sC,EAAQguC,QACxC,GAAIpuC,EACA,MAAO,UAAYA,EAE3B,OAAO,MAWX+tC,EAAWlnB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAM8B,WACxB,OAAOb,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM8B,WAgBxB,GAfmB,MAAfb,EAAOznC,OACoB,kBAAhBynC,EAAOznC,KACdumC,EAAMuC,OAAOnxB,OAAO8vB,EAAOznC,KAAMrF,EAAQqF,KAAOumC,EAAMmC,UAAUnC,EAAMuC,OAAOzrB,OAAOoqB,EAAOznC,OAAQ,GAC9FynC,EAAOznC,KAAKqd,SACjB1iB,EAAQqF,KAAOynC,EAAOznC,OACV,MAAhBynC,EAAOnhC,QACqB,kBAAjBmhC,EAAOnhC,MACdigC,EAAMuC,OAAOnxB,OAAO8vB,EAAOnhC,MAAO3L,EAAQ2L,MAAQigC,EAAMmC,UAAUnC,EAAMuC,OAAOzrB,OAAOoqB,EAAOnhC,QAAS,GACjGmhC,EAAOnhC,MAAM+W,SAClB1iB,EAAQ2L,MAAQmhC,EAAOnhC,QACT,MAAlBmhC,EAAO5S,UACuB,kBAAnB4S,EAAO5S,QACd0R,EAAMuC,OAAOnxB,OAAO8vB,EAAO5S,QAASl6B,EAAQk6B,QAAU0R,EAAMmC,UAAUnC,EAAMuC,OAAOzrB,OAAOoqB,EAAO5S,UAAW,GACvG4S,EAAO5S,QAAQxX,SACpB1iB,EAAQk6B,QAAU4S,EAAO5S,UACZ,MAAjB4S,EAAOkB,OAAgB,CACvB,GAA6B,kBAAlBlB,EAAOkB,OACd,MAAMF,UAAU,uCACpB9tC,EAAQguC,OAASnC,EAAMqC,OAAOznB,WAAWqmB,EAAOkB,QAEpD,OAAOhuC,GAYX2tC,EAAWX,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAiCb,OAhCIG,EAAQC,WACJD,EAAQgB,QAAUlB,OAClBD,EAAOznC,KAAO,IAEdynC,EAAOznC,KAAO,GACV4nC,EAAQgB,QAAUtU,QAClBmT,EAAOznC,KAAOumC,EAAMmC,UAAUjB,EAAOznC,QAEzC4nC,EAAQgB,QAAUlB,OAClBD,EAAOnhC,MAAQ,IAEfmhC,EAAOnhC,MAAQ,GACXshC,EAAQgB,QAAUtU,QAClBmT,EAAOnhC,MAAQigC,EAAMmC,UAAUjB,EAAOnhC,SAE1CshC,EAAQgB,QAAUlB,OAClBD,EAAO5S,QAAU,IAEjB4S,EAAO5S,QAAU,GACb+S,EAAQgB,QAAUtU,QAClBmT,EAAO5S,QAAU0R,EAAMmC,UAAUjB,EAAO5S,WAEhD4S,EAAOkB,OAAS,MAEA,MAAhBhuC,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAO4nC,EAAQgB,QAAUlB,OAASnB,EAAMuC,OAAO3sB,OAAOxhB,EAAQqF,KAAM,EAAGrF,EAAQqF,KAAKqd,QAAUuqB,EAAQgB,QAAUtU,MAAQA,MAAMoS,UAAUqC,MAAMnC,KAAKjsC,EAAQqF,MAAQrF,EAAQqF,MACjK,MAAjBrF,EAAQ2L,OAAiB3L,EAAQoI,eAAe,WAChD0kC,EAAOnhC,MAAQshC,EAAQgB,QAAUlB,OAASnB,EAAMuC,OAAO3sB,OAAOxhB,EAAQ2L,MAAO,EAAG3L,EAAQ2L,MAAM+W,QAAUuqB,EAAQgB,QAAUtU,MAAQA,MAAMoS,UAAUqC,MAAMnC,KAAKjsC,EAAQ2L,OAAS3L,EAAQ2L,OACnK,MAAnB3L,EAAQk6B,SAAmBl6B,EAAQoI,eAAe,aAClD0kC,EAAO5S,QAAU+S,EAAQgB,QAAUlB,OAASnB,EAAMuC,OAAO3sB,OAAOxhB,EAAQk6B,QAAS,EAAGl6B,EAAQk6B,QAAQxX,QAAUuqB,EAAQgB,QAAUtU,MAAQA,MAAMoS,UAAUqC,MAAMnC,KAAKjsC,EAAQk6B,SAAWl6B,EAAQk6B,SAC5K,MAAlBl6B,EAAQguC,QAAkBhuC,EAAQoI,eAAe,YACjD0kC,EAAOkB,OAASnC,EAAMqC,OAAOlB,SAAShtC,EAAQguC,OAAQf,IACnDH,GAUXa,EAAW5B,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDI,EA3RmC,GA8RxB9B,EAAMqC,OAAU,WAoBlC,SAASA,EAAOpC,GACZ,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4OhD,OAnOA8tB,EAAOnC,UAAUsC,KAAO,GAQxBH,EAAOnC,UAAUuC,QAAU,GAQ3BJ,EAAOnC,UAAUhoC,OAAS,GAQ1BmqC,EAAOnC,UAAUwC,cAAgB3C,EAAMmC,UAAU,IAUjDG,EAAO/vB,OAAS,SAAgB2tB,GAC5B,OAAO,IAAIoC,EAAOpC,IAYtBoC,EAAO1sB,OAAS,SAAgBxhB,EAASgsC,GAWrC,OAVKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQquC,MAAgBliB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQquC,MACrC,MAAnBruC,EAAQsuC,SAAmBniB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQsuC,SACtC,MAAlBtuC,EAAQ+D,QAAkBooB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ+D,QAC/B,MAAzB/D,EAAQuuC,eAAyBpiB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrEgsC,EAAOE,OAA8B,IAAI+B,MAAMjuC,EAAQuuC,eACpDvC,GAYXkC,EAAO7B,gBAAkB,SAAyBrsC,EAASgsC,GACvD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC4B,EAAOlxB,OAAS,SAAgBwG,EAAQd,GAC9Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMqC,OAChF1qB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQquC,KAAO7qB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQsuC,QAAU9qB,EAAO2oB,SACzB,MACJ,KAAK,EACDnsC,EAAQ+D,OAASyf,EAAO2oB,SACxB,MACJ,KAAK,EACDnsC,EAAQuuC,cAAgB/qB,EAAOyqB,QAC/B,MACJ,QACIzqB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXkuC,EAAOvB,gBAAkB,SAAyBnpB,GAG9C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCgC,EAAOtB,OAAS,SAAgB5sC,GAC5B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQquC,MAAgBruC,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQquC,MACjB,wBACQ,MAAnBruC,EAAQsuC,SAAmBtuC,EAAQoI,eAAe,aAC7CwjC,EAAMiB,SAAS7sC,EAAQsuC,SACjB,2BACO,MAAlBtuC,EAAQ+D,QAAkB/D,EAAQoI,eAAe,YAC5CwjC,EAAMiB,SAAS7sC,EAAQ+D,QACjB,0BACc,MAAzB/D,EAAQuuC,eAAyBvuC,EAAQoI,eAAe,oBAClDpI,EAAQuuC,eAAyD,kBAAjCvuC,EAAQuuC,cAAc7rB,QAAuBkpB,EAAMiB,SAAS7sC,EAAQuuC,gBAC/F,iCACR,MAWXL,EAAOznB,WAAa,SAAoBqmB,GACpC,GAAIA,aAAkBjB,EAAMqC,OACxB,OAAOpB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMqC,OAYxB,OAXmB,MAAfpB,EAAOuB,OACPruC,EAAQquC,KAAOtB,OAAOD,EAAOuB,OACX,MAAlBvB,EAAOwB,UACPtuC,EAAQsuC,QAAUvB,OAAOD,EAAOwB,UACf,MAAjBxB,EAAO/oC,SACP/D,EAAQ+D,OAASgpC,OAAOD,EAAO/oC,SACP,MAAxB+oC,EAAOyB,gBAC6B,kBAAzBzB,EAAOyB,cACd3C,EAAMuC,OAAOnxB,OAAO8vB,EAAOyB,cAAevuC,EAAQuuC,cAAgB3C,EAAMmC,UAAUnC,EAAMuC,OAAOzrB,OAAOoqB,EAAOyB,gBAAiB,GACzHzB,EAAOyB,cAAc7rB,SAC1B1iB,EAAQuuC,cAAgBzB,EAAOyB,gBAChCvuC,GAYXkuC,EAAOlB,SAAW,SAAkBhtC,EAASitC,GACpCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAqBb,OApBIG,EAAQC,WACRJ,EAAOuB,KAAO,GACdvB,EAAOwB,QAAU,GACjBxB,EAAO/oC,OAAS,GACZkpC,EAAQgB,QAAUlB,OAClBD,EAAOyB,cAAgB,IAEvBzB,EAAOyB,cAAgB,GACnBtB,EAAQgB,QAAUtU,QAClBmT,EAAOyB,cAAgB3C,EAAMmC,UAAUjB,EAAOyB,kBAGtC,MAAhBvuC,EAAQquC,MAAgBruC,EAAQoI,eAAe,UAC/C0kC,EAAOuB,KAAOruC,EAAQquC,MACH,MAAnBruC,EAAQsuC,SAAmBtuC,EAAQoI,eAAe,aAClD0kC,EAAOwB,QAAUtuC,EAAQsuC,SACP,MAAlBtuC,EAAQ+D,QAAkB/D,EAAQoI,eAAe,YACjD0kC,EAAO/oC,OAAS/D,EAAQ+D,QACC,MAAzB/D,EAAQuuC,eAAyBvuC,EAAQoI,eAAe,mBACxD0kC,EAAOyB,cAAgBtB,EAAQgB,QAAUlB,OAASnB,EAAMuC,OAAO3sB,OAAOxhB,EAAQuuC,cAAe,EAAGvuC,EAAQuuC,cAAc7rB,QAAUuqB,EAAQgB,QAAUtU,MAAQA,MAAMoS,UAAUqC,MAAMnC,KAAKjsC,EAAQuuC,eAAiBvuC,EAAQuuC,eACnNzB,GAUXoB,EAAOnC,UAAUsB,OAAS,WACtB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDW,EApQ2B,GAuQjBrC,EAAMniC,MAAS,WAkBhC,SAASA,EAAMoiC,GACX,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLA1W,EAAMqiC,UAAU/kC,IAAM,GAQtB0C,EAAMqiC,UAAU55B,UAAY,EAU5BzI,EAAMyU,OAAS,SAAgB2tB,GAC3B,OAAO,IAAIpiC,EAAMoiC,IAYrBpiC,EAAM8X,OAAS,SAAgBxhB,EAASgsC,GAOpC,OANKA,IACDA,EAASL,EAAQxtB,UACI,MAArBne,EAAQmS,WAAqBga,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQmS,WACxC,MAAfnS,EAAQgH,KAAemlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQgH,KACrDglC,GAYXtiC,EAAM2iC,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC5iC,EAAMsT,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMniC,MAChF8Z,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQgH,IAAMwc,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQmS,UAAYqR,EAAO4oB,QAC3B,MACJ,QACI5oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0J,EAAMijC,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCxiC,EAAMkjC,OAAS,SAAgB5sC,GAC3B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACQ,MAAfA,EAAQgH,KAAehH,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQgH,KACjB,uBACU,MAArBhH,EAAQmS,WAAqBnS,EAAQoI,eAAe,eAC/CwjC,EAAMiC,UAAU7tC,EAAQmS,WAClB,8BACR,MAWXzI,EAAM+c,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAMniC,MACxB,OAAOojC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMniC,MAKxB,OAJkB,MAAdojC,EAAO9lC,MACPhH,EAAQgH,IAAM+lC,OAAOD,EAAO9lC,MACR,MAApB8lC,EAAO36B,YACPnS,EAAQmS,UAA+B,EAAnB26B,EAAO36B,WACxBnS,GAYX0J,EAAMsjC,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAO36B,UAAY,EACnB26B,EAAO9lC,IAAM,IAEQ,MAArBhH,EAAQmS,WAAqBnS,EAAQoI,eAAe,eACpD0kC,EAAO36B,UAAYnS,EAAQmS,WACZ,MAAfnS,EAAQgH,KAAehH,EAAQoI,eAAe,SAC9C0kC,EAAO9lC,IAAMhH,EAAQgH,KAClB8lC,GAUXpjC,EAAMqiC,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD7jC,EA/MyB,GAkNbmiC,EAAMvqB,QAAW,WAuBpC,SAASA,EAAQwqB,GACb,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4DhD,IAAIouB,EAiSJ,OApVAltB,EAAQyqB,UAAU5V,aAAc,EAQhC7U,EAAQyqB,UAAUta,aAAc,EAQhCnQ,EAAQyqB,UAAU1V,YAAa,EAQ/B/U,EAAQyqB,UAAUhW,cAAe,EAQjCzU,EAAQyqB,UAAUn4B,YAAa,EAQ/B0N,EAAQyqB,UAAU9kB,cAAgB,KAQlC3F,EAAQyqB,UAAUlV,iBAAkB,EAWpC1K,OAAOsiB,eAAentB,EAAQyqB,UAAW,OAAQ,CAC7CltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,cAAe,cAAe,aAAc,eAAgB,aAAc,gBAAiB,oBAClI5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BltB,EAAQnD,OAAS,SAAgB2tB,GAC7B,OAAO,IAAIxqB,EAAQwqB,IAYvBxqB,EAAQE,OAAS,SAAgBxhB,EAASgsC,GAiBtC,OAhBKA,IACDA,EAASL,EAAQxtB,UACM,MAAvBne,EAAQm2B,aAAuBhK,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQm2B,aAC/B,MAAvBn2B,EAAQyxB,aAAuBtF,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQyxB,aAChC,MAAtBzxB,EAAQq2B,YAAsBlK,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQq2B,YAC9B,MAAxBr2B,EAAQ+1B,cAAwB5J,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,iBACpEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ+1B,cAChC,MAAtB/1B,EAAQ4T,YAAsBuY,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ4T,YAC7B,MAAzB5T,EAAQinB,eAAyBkF,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrE6rC,EAAMxkB,aAAa7F,OAAOxhB,EAAQinB,cAAe+kB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACvE,MAA3BtsC,EAAQ62B,iBAA2B1K,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,oBACvEgsC,EAAOE,OAA+B,IAAI0C,KAAK5uC,EAAQ62B,iBACpDmV,GAYX1qB,EAAQ+qB,gBAAkB,SAAyBrsC,EAASgsC,GACxD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxChrB,EAAQtE,OAAS,SAAgBwG,EAAQd,GAC/Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMvqB,QAChFkC,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQm2B,YAAc3S,EAAOorB,OAC7B,MACJ,KAAK,EACD5uC,EAAQyxB,YAAcjO,EAAOorB,OAC7B,MACJ,KAAK,EACD5uC,EAAQq2B,WAAa7S,EAAOorB,OAC5B,MACJ,KAAK,EACD5uC,EAAQ+1B,aAAevS,EAAOorB,OAC9B,MACJ,KAAK,EACD5uC,EAAQ4T,WAAa4P,EAAOorB,OAC5B,MACJ,KAAK,EACD5uC,EAAQinB,cAAgB4kB,EAAMxkB,aAAarK,OAAOwG,EAAQA,EAAO0oB,UACjE,MACJ,KAAK,GACDlsC,EAAQ62B,gBAAkBrT,EAAOorB,OACjC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXshB,EAAQqrB,gBAAkB,SAAyBnpB,GAG/C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC5qB,EAAQsrB,OAAS,SAAgB5sC,GAC7B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAA2B,MAAvB9rC,EAAQm2B,aAAuBn2B,EAAQoI,eAAe,iBACtD0jC,EAAW9sC,KAAO,EACiB,mBAAxBgB,EAAQm2B,aACf,MAAO,gCAEf,GAA2B,MAAvBn2B,EAAQyxB,aAAuBzxB,EAAQoI,eAAe,eAAgB,CACtE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,EACiB,mBAAxBgB,EAAQyxB,YACf,MAAO,gCAEf,GAA0B,MAAtBzxB,EAAQq2B,YAAsBr2B,EAAQoI,eAAe,cAAe,CACpE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,EACgB,mBAAvBgB,EAAQq2B,WACf,MAAO,+BAEf,GAA4B,MAAxBr2B,EAAQ+1B,cAAwB/1B,EAAQoI,eAAe,gBAAiB,CACxE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,EACkB,mBAAzBgB,EAAQ+1B,aACf,MAAO,iCAEf,GAA0B,MAAtB/1B,EAAQ4T,YAAsB5T,EAAQoI,eAAe,cAAe,CACpE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,EACgB,mBAAvBgB,EAAQ4T,WACf,MAAO,+BAEf,GAA6B,MAAzB5T,EAAQinB,eAAyBjnB,EAAQoI,eAAe,iBAAkB,CAC1E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMxkB,aAAaulB,OAAO5sC,EAAQinB,eAC9C,GAAIrnB,EACA,MAAO,iBAAmBA,EAGtC,GAA+B,MAA3BI,EAAQ62B,iBAA2B72B,EAAQoI,eAAe,mBAAoB,CAC9E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,EACqB,mBAA5BgB,EAAQ62B,gBACf,MAAO,oCAEf,OAAO,MAWXvV,EAAQmF,WAAa,SAAoBqmB,GACrC,GAAIA,aAAkBjB,EAAMvqB,QACxB,OAAOwrB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMvqB,QAWxB,GAV0B,MAAtBwrB,EAAO3W,cACPn2B,EAAQm2B,YAAchC,QAAQ2Y,EAAO3W,cACf,MAAtB2W,EAAOrb,cACPzxB,EAAQyxB,YAAc0C,QAAQ2Y,EAAOrb,cAChB,MAArBqb,EAAOzW,aACPr2B,EAAQq2B,WAAalC,QAAQ2Y,EAAOzW,aACb,MAAvByW,EAAO/W,eACP/1B,EAAQ+1B,aAAe5B,QAAQ2Y,EAAO/W,eACjB,MAArB+W,EAAOl5B,aACP5T,EAAQ4T,WAAaugB,QAAQ2Y,EAAOl5B,aACZ,MAAxBk5B,EAAO7lB,cAAuB,CAC9B,GAAoC,kBAAzB6lB,EAAO7lB,cACd,MAAM6mB,UAAU,2CACpB9tC,EAAQinB,cAAgB4kB,EAAMxkB,aAAaZ,WAAWqmB,EAAO7lB,eAIjE,OAF8B,MAA1B6lB,EAAOjW,kBACP72B,EAAQ62B,gBAAkB1C,QAAQ2Y,EAAOjW,kBACtC72B,GAYXshB,EAAQ0rB,SAAW,SAAkBhtC,EAASitC,GACrCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAoCb,OAnC2B,MAAvB9sC,EAAQm2B,aAAuBn2B,EAAQoI,eAAe,iBACtD0kC,EAAO3W,YAAcn2B,EAAQm2B,YACzB8W,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEK,MAAvBgB,EAAQyxB,aAAuBzxB,EAAQoI,eAAe,iBACtD0kC,EAAOrb,YAAczxB,EAAQyxB,YACzBwb,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEI,MAAtBgB,EAAQq2B,YAAsBr2B,EAAQoI,eAAe,gBACrD0kC,EAAOzW,WAAar2B,EAAQq2B,WACxB4W,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEM,MAAxBgB,EAAQ+1B,cAAwB/1B,EAAQoI,eAAe,kBACvD0kC,EAAO/W,aAAe/1B,EAAQ+1B,aAC1BkX,EAAQ4B,SACR/B,EAAO9tC,KAAO,iBAEI,MAAtBgB,EAAQ4T,YAAsB5T,EAAQoI,eAAe,gBACrD0kC,EAAOl5B,WAAa5T,EAAQ4T,WACxBq5B,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEO,MAAzBgB,EAAQinB,eAAyBjnB,EAAQoI,eAAe,mBACxD0kC,EAAO7lB,cAAgB4kB,EAAMxkB,aAAa2lB,SAAShtC,EAAQinB,cAAegmB,GACtEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,kBAES,MAA3BgB,EAAQ62B,iBAA2B72B,EAAQoI,eAAe,qBAC1D0kC,EAAOjW,gBAAkB72B,EAAQ62B,gBAC7BoW,EAAQ4B,SACR/B,EAAO9tC,KAAO,oBAEf8tC,GAUXxrB,EAAQyqB,UAAUsB,OAAS,WACvB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDjsB,EAxX6B,IA2X3B1X,EAAWiiC,EAAMjiC,SAAY,WAkBtC,SAASA,EAASkiC,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyOhD,OAhOAxW,EAASmiC,UAAU/sC,KAAO,EAQ1B4K,EAASmiC,UAAU+C,YAAc,EAUjCllC,EAASuU,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIliC,EAASkiC,IAYxBliC,EAAS4X,OAAS,SAAgBxhB,EAASgsC,GAOvC,OANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQhB,MAAgBmtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,GAAGE,MAAMpsC,EAAQhB,MAC/B,MAAvBgB,EAAQ8uC,aAAuB3iB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnEgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQ8uC,aACrD9C,GAYXpiC,EAASyiC,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC1iC,EAASoT,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMjiC,SAChF4Z,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQhB,KAAOwkB,EAAO4oB,QACtB,MACJ,KAAK,EACDpsC,EAAQ8uC,YAActrB,EAAO0oB,SAC7B,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX4J,EAAS+iC,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCtiC,EAASgjC,OAAS,SAAgB5sC,GAC9B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQhB,MAAgBgB,EAAQoI,eAAe,QAC/C,OAAQpI,EAAQhB,MAChB,QACI,MAAO,4BACX,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,GAGT,OAA2B,MAAvBgB,EAAQ8uC,aAAuB9uC,EAAQoI,eAAe,iBACjDwjC,EAAMiC,UAAU7tC,EAAQ8uC,aAClB,gCACR,MAWXllC,EAAS6c,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMjiC,SACxB,OAAOkjC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMjiC,SACxB,OAAQkjC,EAAO9tC,MACf,IAAK,UACL,KAAK,EACDgB,EAAQhB,KAAO,EACf,MACJ,IAAK,UACL,KAAK,EACDgB,EAAQhB,KAAO,EACf,MACJ,IAAK,aACL,KAAK,EACDgB,EAAQhB,KAAO,EACf,MACJ,IAAK,YACL,KAAK,EACDgB,EAAQhB,KAAO,EACf,MACJ,IAAK,YACL,KAAK,EACDgB,EAAQhB,KAAO,EAKnB,OAF0B,MAAtB8tC,EAAOgC,cACP9uC,EAAQ8uC,YAAchC,EAAOgC,cAAgB,GAC1C9uC,GAYX4J,EAASojC,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAO9tC,KAAOiuC,EAAQE,QAAUJ,OAAS,UAAY,EACrDD,EAAOgC,YAAc,GAEL,MAAhB9uC,EAAQhB,MAAgBgB,EAAQoI,eAAe,UAC/C0kC,EAAO9tC,KAAOiuC,EAAQE,QAAUJ,OAASlB,EAAMjiC,SAASmlC,KAAK/uC,EAAQhB,MAAQgB,EAAQhB,MAC9D,MAAvBgB,EAAQ8uC,aAAuB9uC,EAAQoI,eAAe,iBACtD0kC,EAAOgC,YAAc9uC,EAAQ8uC,aAC1BhC,GAUXljC,EAASmiC,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAa1D3jC,EAASmlC,KAAQ,WACb,IAAMvB,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAM9C,OALAC,EAAOD,EAAW,GAAK,WAAa,EACpCC,EAAOD,EAAW,GAAK,WAAa,EACpCC,EAAOD,EAAW,GAAK,cAAgB,EACvCC,EAAOD,EAAW,GAAK,aAAe,EACtCC,EAAOD,EAAW,GAAK,aAAe,EAC/BC,EAPM,GAUV7jC,EA/P+B,GAkQ7BmgB,EAAY8hB,EAAM9hB,UAAa,WAkBxC,SAASA,EAAU+hB,GAEf,GADAttC,KAAKsK,KAAO,GACRgjC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAkPhD,OAzOA2J,EAAUgiB,UAAUjiB,UAAY,EAQhCC,EAAUgiB,UAAUjjC,KAAO8iC,EAAMoD,WAUjCjlB,EAAU5L,OAAS,SAAgB2tB,GAC/B,OAAO,IAAI/hB,EAAU+hB,IAYzB/hB,EAAUvI,OAAS,SAAgBxhB,EAASgsC,GAKxC,GAJKA,IACDA,EAASL,EAAQxtB,UACI,MAArBne,EAAQ8pB,WAAqBqC,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,GAAGE,MAAMpsC,EAAQ8pB,WACtC,MAAhB9pB,EAAQ8I,MAAgB9I,EAAQ8I,KAAK4Z,OAAQ,CAC7CspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAQ8I,KAAK4Z,SAAUtC,EACvC4rB,EAAOE,OAAOlsC,EAAQ8I,KAAKsX,IAC/B4rB,EAAOM,SAEX,OAAON,GAYXjiB,EAAUsiB,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCviB,EAAU/M,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM9hB,UAChFvG,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ8pB,UAAYtG,EAAO4oB,QAC3B,MACJ,KAAK,EAGD,GAFMpsC,EAAQ8I,MAAQ9I,EAAQ8I,KAAK4Z,SAC/B1iB,EAAQ8I,KAAO,IACD,KAAP,EAAN2jC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAQ8I,KAAKtF,KAAKggB,EAAO0oB,eAE7BlsC,EAAQ8I,KAAKtF,KAAKggB,EAAO0oB,UAC7B,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX+pB,EAAU4iB,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCniB,EAAU6iB,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAyB,MAArBA,EAAQ8pB,WAAqB9pB,EAAQoI,eAAe,aACpD,OAAQpI,EAAQ8pB,WAChB,QACI,MAAO,iCACX,KAAK,EACL,KAAK,EACL,KAAK,GAGT,GAAoB,MAAhB9pB,EAAQ8I,MAAgB9I,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQ8I,MACvB,MAAO,uBACX,IAAK,IAAIsX,EAAI,EAAGA,EAAIpgB,EAAQ8I,KAAK4Z,SAAUtC,EACvC,IAAKwrB,EAAMiC,UAAU7tC,EAAQ8I,KAAKsX,IAC9B,MAAO,2BAEnB,OAAO,MAWX2J,EAAUtD,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAM9hB,UACxB,OAAO+iB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM9hB,UACxB,OAAQ+iB,EAAOhjB,WACf,IAAK,SACL,KAAK,EACD9pB,EAAQ8pB,UAAY,EACpB,MACJ,IAAK,OACL,KAAK,EACD9pB,EAAQ8pB,UAAY,EACpB,MACJ,IAAK,UACL,KAAK,EACD9pB,EAAQ8pB,UAAY,EAGxB,GAAIgjB,EAAOhkC,KAAM,CACb,IAAK6wB,MAAMuV,QAAQpC,EAAOhkC,MACtB,MAAMglC,UAAU,mCACpB9tC,EAAQ8I,KAAO,GACf,IAAK,IAAIsX,EAAI,EAAGA,EAAI0sB,EAAOhkC,KAAK4Z,SAAUtC,EACtCpgB,EAAQ8I,KAAKsX,GAAK0sB,EAAOhkC,KAAKsX,KAAO,EAE7C,OAAOpgB,GAYX+pB,EAAUijB,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAOb,IANIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOhkC,KAAO,IACdmkC,EAAQC,WACRJ,EAAOhjB,UAAYmjB,EAAQE,QAAUJ,OAAS,SAAW,GACpC,MAArB/sC,EAAQ8pB,WAAqB9pB,EAAQoI,eAAe,eACpD0kC,EAAOhjB,UAAYmjB,EAAQE,QAAUJ,OAASlB,EAAM9hB,UAAUC,UAAUhqB,EAAQ8pB,WAAa9pB,EAAQ8pB,WACrG9pB,EAAQ8I,MAAQ9I,EAAQ8I,KAAK4Z,OAAQ,CACrCoqB,EAAOhkC,KAAO,GACd,IAAK,IAAIsmC,EAAI,EAAGA,EAAIpvC,EAAQ8I,KAAK4Z,SAAU0sB,EACvCtC,EAAOhkC,KAAKsmC,GAAKpvC,EAAQ8I,KAAKsmC,GAEtC,OAAOtC,GAUX/iB,EAAUgiB,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAW1DxjB,EAAUC,UAAa,WACnB,IAAMwjB,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAI9C,OAHAC,EAAOD,EAAW,GAAK,UAAY,EACnCC,EAAOD,EAAW,GAAK,QAAU,EACjCC,EAAOD,EAAW,GAAK,WAAa,EAC7BC,EALY,GAQhB1jB,EAzQiC,GAkvH/BvD,GAt+GaqlB,EAAMhiC,WAAc,WAkB1C,SAASA,EAAWiiC,GAChB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLAvW,EAAWkiC,UAAUsD,OAAS,GAQ9BxlC,EAAWkiC,UAAUuD,mBAAoB,EAUzCzlC,EAAWsU,OAAS,SAAgB2tB,GAChC,OAAO,IAAIjiC,EAAWiiC,IAY1BjiC,EAAW2X,OAAS,SAAgBxhB,EAASgsC,GAOzC,OANKA,IACDA,EAASL,EAAQxtB,UACC,MAAlBne,EAAQqvC,QAAkBljB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQqvC,QAC3B,MAA7BrvC,EAAQsvC,mBAA6BnjB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQsvC,mBACnDtD,GAYXniC,EAAWwiC,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCziC,EAAWmT,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMhiC,WAChF2Z,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqvC,OAAS7rB,EAAO2oB,SACxB,MACJ,KAAK,EACDnsC,EAAQsvC,kBAAoB9rB,EAAOorB,OACnC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX6J,EAAW8iC,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCriC,EAAW+iC,OAAS,SAAgB5sC,GAChC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACW,MAAlBA,EAAQqvC,QAAkBrvC,EAAQoI,eAAe,YAC5CwjC,EAAMiB,SAAS7sC,EAAQqvC,QACjB,0BACkB,MAA7BrvC,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,sBACnB,mBAA9BpI,EAAQsvC,kBACR,sCACR,MAWXzlC,EAAW4c,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAMhiC,WACxB,OAAOijC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMhiC,WAKxB,OAJqB,MAAjBijC,EAAOuC,SACPrvC,EAAQqvC,OAAStC,OAAOD,EAAOuC,SACH,MAA5BvC,EAAOwC,oBACPtvC,EAAQsvC,kBAAoBnb,QAAQ2Y,EAAOwC,oBACxCtvC,GAYX6J,EAAWmjC,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOuC,OAAS,GAChBvC,EAAOwC,mBAAoB,GAET,MAAlBtvC,EAAQqvC,QAAkBrvC,EAAQoI,eAAe,YACjD0kC,EAAOuC,OAASrvC,EAAQqvC,QACK,MAA7BrvC,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,uBAC5D0kC,EAAOwC,kBAAoBtvC,EAAQsvC,mBAChCxC,GAUXjjC,EAAWkiC,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD1jC,EA/MmC,GAkNxBgiC,EAAMrhC,OAAU,WAmBlC,SAASA,EAAOshC,GACZ,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8MhD,OArMA5V,EAAOuhC,UAAUt2B,GAAK,GAQtBjL,EAAOuhC,UAAUp2B,MAAQ,GAQzBnL,EAAOuhC,UAAP,SAA8B,EAU9BvhC,EAAO2T,OAAS,SAAgB2tB,GAC5B,OAAO,IAAIthC,EAAOshC,IAYtBthC,EAAOgX,OAAS,SAAgBxhB,EAASgsC,GASrC,OARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAO,SAClDgsC,GAYXxhC,EAAO6hC,gBAAkB,SAAyBrsC,EAASgsC,GACvD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC9hC,EAAOwS,OAAS,SAAgBwG,EAAQd,GAC9Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMrhC,OAChFgZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAOorB,OAC5B,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXwK,EAAOmiC,gBAAkB,SAAyBnpB,GAG9C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC1hC,EAAOoiC,OAAS,SAAgB5sC,GAC5B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACO,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACjB,sBACM,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACjB,yBACW,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,YACnB,mBAAvBpI,EAAO,QACP,4BACR,MAWXwK,EAAOic,WAAa,SAAoBqmB,GACpC,GAAIA,aAAkBjB,EAAMrhC,OACxB,OAAOsiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMrhC,OAOxB,OANiB,MAAbsiC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAcm0B,QAAQ2Y,EAAM,UAChC9sC,GAYXwK,EAAOwiC,SAAW,SAAkBhtC,EAASitC,GACpCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,SAAc,GAEN,MAAd9sC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SACxB8sC,GAUXtiC,EAAOuhC,UAAUsB,OAAS,WACtB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD/iC,EArO2B,GAwOdqhC,EAAMphC,SAAY,WAmBtC,SAASA,EAASqhC,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8MhD,OArMA3V,EAASshC,UAAUt2B,GAAK,GAQxBhL,EAASshC,UAAUp2B,MAAQ,GAQ3BlL,EAASshC,UAAT,SAAgC,EAUhCthC,EAAS0T,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIrhC,EAASqhC,IAYxBrhC,EAAS+W,OAAS,SAAgBxhB,EAASgsC,GASvC,OARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAO,SAClDgsC,GAYXvhC,EAAS4hC,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC7hC,EAASuS,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMphC,SAChF+Y,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAOorB,OAC5B,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXyK,EAASkiC,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCzhC,EAASmiC,OAAS,SAAgB5sC,GAC9B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACO,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACjB,sBACM,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACjB,yBACW,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,YACnB,mBAAvBpI,EAAO,QACP,4BACR,MAWXyK,EAASgc,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMphC,SACxB,OAAOqiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMphC,SAOxB,OANiB,MAAbqiC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAcm0B,QAAQ2Y,EAAM,UAChC9sC,GAYXyK,EAASuiC,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,SAAc,GAEN,MAAd9sC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SACxB8sC,GAUXriC,EAASshC,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD9iC,EArO+B,GAwOfohC,EAAMnhC,YAAe,WAmB5C,SAASA,EAAYohC,GACjB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8MhD,OArMA1V,EAAYqhC,UAAUt2B,GAAK,GAQ3B/K,EAAYqhC,UAAUp2B,MAAQ,GAQ9BjL,EAAYqhC,UAAZ,QAAmC,GAUnCrhC,EAAYyT,OAAS,SAAgB2tB,GACjC,OAAO,IAAIphC,EAAYohC,IAY3BphC,EAAY8W,OAAS,SAAgBxhB,EAASgsC,GAS1C,OARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAO,SACpDgsC,GAYXthC,EAAY2hC,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC5hC,EAAYsS,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMnhC,YAChF8Y,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAO2oB,SAC5B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0K,EAAYiiC,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCxhC,EAAYkiC,OAAS,SAAgB5sC,GACjC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACO,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACjB,sBACM,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACjB,yBACW,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aAChDwjC,EAAMiB,SAAS7sC,EAAO,SAChB,2BACR,MAWX0K,EAAY+b,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMnhC,YACxB,OAAOoiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMnhC,YAOxB,OANiB,MAAboiC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAc+sC,OAAOD,EAAM,UAC/B9sC,GAYX0K,EAAYsiC,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,QAAc,IAEN,MAAd9sC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SACxB8sC,GAUXpiC,EAAYqhC,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD7iC,EArOqC,GAwOfmhC,EAAMvnC,kBAAqB,WAqBxD,SAASA,EAAkBwnC,GAEvB,GADAttC,KAAK+wC,cAAgB,GACjBzD,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA6QhD,OApQA9b,EAAkBynC,UAAUt2B,GAAK,GAQjCnR,EAAkBynC,UAAUyD,SAAW,GAQvClrC,EAAkBynC,UAAUwD,cAAgB3D,EAAMoD,WAQlD1qC,EAAkBynC,UAAUhlC,cAAgB,GAQ5CzC,EAAkBynC,UAAU/kC,IAAM,GAUlC1C,EAAkB6Z,OAAS,SAAgB2tB,GACvC,OAAO,IAAIxnC,EAAkBwnC,IAYjCxnC,EAAkBkd,OAAS,SAAgBxhB,EAASgsC,GAOhD,GANKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACpC,MAApBzV,EAAQwvC,UAAoBrjB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQwvC,UAC/B,MAAzBxvC,EAAQuvC,eAAyBvvC,EAAQuvC,cAAc7sB,OACvD,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQuvC,cAAc7sB,SAAUtC,EAChDyrB,EAAM4D,cAAcjuB,OAAOxhB,EAAQuvC,cAAcnvB,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAK9G,OAJ6B,MAAzBtsC,EAAQ+G,eAAyBolB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ+G,eACzC,MAAf/G,EAAQgH,KAAemlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQgH,KACrDglC,GAYX1nC,EAAkB+nC,gBAAkB,SAAyBrsC,EAASgsC,GAClE,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxChoC,EAAkB0Y,OAAS,SAAgBwG,EAAQd,GACzCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMvnC,kBAChFkf,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQwvC,SAAWhsB,EAAO2oB,SAC1B,MACJ,KAAK,EACKnsC,EAAQuvC,eAAiBvvC,EAAQuvC,cAAc7sB,SACjD1iB,EAAQuvC,cAAgB,IAC5BvvC,EAAQuvC,cAAc/rC,KAAKqoC,EAAM4D,cAAczyB,OAAOwG,EAAQA,EAAO0oB,WACrE,MACJ,KAAK,EACDlsC,EAAQ+G,cAAgByc,EAAO2oB,SAC/B,MACJ,KAAK,EACDnsC,EAAQgH,IAAMwc,EAAO2oB,SACrB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXsE,EAAkBqoC,gBAAkB,SAAyBnpB,GAGzD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC5nC,EAAkBsoC,OAAS,SAAgB5sC,GACvC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAwB,MAApBzV,EAAQwvC,UAAoBxvC,EAAQoI,eAAe,cAC9CwjC,EAAMiB,SAAS7sC,EAAQwvC,UACxB,MAAO,4BACf,GAA6B,MAAzBxvC,EAAQuvC,eAAyBvvC,EAAQoI,eAAe,iBAAkB,CAC1E,IAAKuxB,MAAMuV,QAAQlvC,EAAQuvC,eACvB,MAAO,gCACX,IAAK,IAAInvB,EAAI,EAAGA,EAAIpgB,EAAQuvC,cAAc7sB,SAAUtC,EAAG,CACnD,IAAIxgB,EAAQisC,EAAM4D,cAAc7C,OAAO5sC,EAAQuvC,cAAcnvB,IAC7D,GAAIxgB,EACA,MAAO,iBAAmBA,GAGtC,OAA6B,MAAzBI,EAAQ+G,eAAyB/G,EAAQoI,eAAe,mBACnDwjC,EAAMiB,SAAS7sC,EAAQ+G,eACjB,iCACI,MAAf/G,EAAQgH,KAAehH,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQgH,KACjB,uBACR,MAWX1C,EAAkBmiB,WAAa,SAAoBqmB,GAC/C,GAAIA,aAAkBjB,EAAMvnC,kBACxB,OAAOwoC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMvnC,kBAKxB,GAJiB,MAAbwoC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACR,MAAnBq3B,EAAO0C,WACPxvC,EAAQwvC,SAAWzC,OAAOD,EAAO0C,WACjC1C,EAAOyC,cAAe,CACtB,IAAK5V,MAAMuV,QAAQpC,EAAOyC,eACtB,MAAMzB,UAAU,oDACpB9tC,EAAQuvC,cAAgB,GACxB,IAAK,IAAInvB,EAAI,EAAGA,EAAI0sB,EAAOyC,cAAc7sB,SAAUtC,EAAG,CAClD,GAAuC,kBAA5B0sB,EAAOyC,cAAcnvB,GAC5B,MAAM0tB,UAAU,qDACpB9tC,EAAQuvC,cAAcnvB,GAAKyrB,EAAM4D,cAAchpB,WAAWqmB,EAAOyC,cAAcnvB,KAOvF,OAJ4B,MAAxB0sB,EAAO/lC,gBACP/G,EAAQ+G,cAAgBgmC,OAAOD,EAAO/lC,gBACxB,MAAd+lC,EAAO9lC,MACPhH,EAAQgH,IAAM+lC,OAAOD,EAAO9lC,MACzBhH,GAYXsE,EAAkB0oC,SAAW,SAAkBhtC,EAASitC,GAC/CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAab,IAZIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOyC,cAAgB,IACvBtC,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAO0C,SAAW,GAClB1C,EAAO/lC,cAAgB,GACvB+lC,EAAO9lC,IAAM,IAEC,MAAdhH,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACA,MAApBzV,EAAQwvC,UAAoBxvC,EAAQoI,eAAe,cACnD0kC,EAAO0C,SAAWxvC,EAAQwvC,UAC1BxvC,EAAQuvC,eAAiBvvC,EAAQuvC,cAAc7sB,OAAQ,CACvDoqB,EAAOyC,cAAgB,GACvB,IAAK,IAAIH,EAAI,EAAGA,EAAIpvC,EAAQuvC,cAAc7sB,SAAU0sB,EAChDtC,EAAOyC,cAAcH,GAAKvD,EAAM4D,cAAczC,SAAShtC,EAAQuvC,cAAcH,GAAInC,GAMzF,OAJ6B,MAAzBjtC,EAAQ+G,eAAyB/G,EAAQoI,eAAe,mBACxD0kC,EAAO/lC,cAAgB/G,EAAQ+G,eAChB,MAAf/G,EAAQgH,KAAehH,EAAQoI,eAAe,SAC9C0kC,EAAO9lC,IAAMhH,EAAQgH,KAClB8lC,GAUXxoC,EAAkBynC,UAAUsB,OAAS,WACjC,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDjpC,EAvSiD,GA0S/BunC,EAAM4D,cAAiB,WAkBhD,SAASA,EAAc3D,GACnB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8LhD,OArLAqvB,EAAc1D,UAAU3sC,IAAM,GAQ9BqwC,EAAc1D,UAAU3lC,MAAQ,KAUhCqpC,EAActxB,OAAS,SAAgB2tB,GACnC,OAAO,IAAI2D,EAAc3D,IAY7B2D,EAAcjuB,OAAS,SAAgBxhB,EAASgsC,GAO5C,OANKA,IACDA,EAASL,EAAQxtB,UACF,MAAfne,EAAQZ,KAAe+sB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQZ,KACvC,MAAjBY,EAAQoG,OAAiB+lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAM6B,eAAelsB,OAAOxhB,EAAQoG,MAAO4lC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzFN,GAYXyD,EAAcpD,gBAAkB,SAAyBrsC,EAASgsC,GAC9D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCmD,EAAczyB,OAAS,SAAgBwG,EAAQd,GACrCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM4D,cAChFjsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQZ,IAAMokB,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQoG,MAAQylC,EAAM6B,eAAe1wB,OAAOwG,EAAQA,EAAO0oB,UAC3D,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXyvC,EAAc9C,gBAAkB,SAAyBnpB,GAGrD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCuD,EAAc7C,OAAS,SAAgB5sC,GACnC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAmB,MAAfA,EAAQZ,KAAeY,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQZ,KACxB,MAAO,uBACf,GAAqB,MAAjBY,EAAQoG,OAAiBpG,EAAQoI,eAAe,SAAU,CAC1D,IAAIxI,EAAQisC,EAAM6B,eAAed,OAAO5sC,EAAQoG,OAChD,GAAIxG,EACA,MAAO,SAAWA,EAE1B,OAAO,MAWX6vC,EAAchpB,WAAa,SAAoBqmB,GAC3C,GAAIA,aAAkBjB,EAAM4D,cACxB,OAAO3C,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM4D,cAGxB,GAFkB,MAAd3C,EAAO1tC,MACPY,EAAQZ,IAAM2tC,OAAOD,EAAO1tC,MACZ,MAAhB0tC,EAAO1mC,MAAe,CACtB,GAA4B,kBAAjB0mC,EAAO1mC,MACd,MAAM0nC,UAAU,yCACpB9tC,EAAQoG,MAAQylC,EAAM6B,eAAejnB,WAAWqmB,EAAO1mC,OAE3D,OAAOpG,GAYXyvC,EAAczC,SAAW,SAAkBhtC,EAASitC,GAC3CA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAO1tC,IAAM,GACb0tC,EAAO1mC,MAAQ,MAEA,MAAfpG,EAAQZ,KAAeY,EAAQoI,eAAe,SAC9C0kC,EAAO1tC,IAAMY,EAAQZ,KACJ,MAAjBY,EAAQoG,OAAiBpG,EAAQoI,eAAe,WAChD0kC,EAAO1mC,MAAQylC,EAAM6B,eAAeV,SAAShtC,EAAQoG,MAAO6mC,IACzDH,GAUX2C,EAAc1D,UAAUsB,OAAS,WAC7B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDkC,EApNyC,GAuN3B5D,EAAM/hC,UAAa,WAoBxC,SAASA,EAAUgiC,GACf,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAuPhD,OA9OAtW,EAAUiiC,UAAU1mC,KAAO,KAQ3ByE,EAAUiiC,UAAUpgC,MAAQ,KAQ5B7B,EAAUiiC,UAAU7R,QAAU,KAQ9BpwB,EAAUiiC,UAAUvsC,MAAQ,KAU5BsK,EAAUqU,OAAS,SAAgB2tB,GAC/B,OAAO,IAAIhiC,EAAUgiC,IAYzBhiC,EAAU0X,OAAS,SAAgBxhB,EAASgsC,GAWxC,OAVKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMlpC,MAAM6e,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACjE,MAAjBtsC,EAAQ2L,OAAiBwgB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAM6D,MAAMluB,OAAOxhB,EAAQ2L,MAAOqgC,EAAOE,OAA8B,IAAI0B,QAAQtB,SAChE,MAAnBtsC,EAAQk6B,SAAmB/N,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/D6rC,EAAM6D,MAAMluB,OAAOxhB,EAAQk6B,QAAS8R,EAAOE,OAA8B,IAAI0B,QAAQtB,SACpE,MAAjBtsC,EAAQR,OAAiB2sB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAM8D,WAAWnuB,OAAOxhB,EAAQR,MAAOwsC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACrFN,GAYXliC,EAAUuiC,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCxiC,EAAUkT,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM/hC,UAChF0Z,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAMlpC,MAAMqa,OAAOwG,EAAQA,EAAO0oB,UACjD,MACJ,KAAK,EACDlsC,EAAQ2L,MAAQkgC,EAAM6D,MAAM1yB,OAAOwG,EAAQA,EAAO0oB,UAClD,MACJ,KAAK,EACDlsC,EAAQk6B,QAAU2R,EAAM6D,MAAM1yB,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,KAAK,EACDlsC,EAAQR,MAAQqsC,EAAM8D,WAAW3yB,OAAOwG,EAAQA,EAAO0oB,UACvD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX8J,EAAU6iC,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCpiC,EAAU8iC,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAMlpC,MAAMiqC,OAAO5sC,EAAQqF,MACvC,GAAIzF,EACA,MAAO,QAAUA,EAEzB,GAAqB,MAAjBI,EAAQ2L,OAAiB3L,EAAQoI,eAAe,SAAU,CAC1D,IAAIxI,EAAQisC,EAAM6D,MAAM9C,OAAO5sC,EAAQ2L,OACvC,GAAI/L,EACA,MAAO,SAAWA,EAE1B,GAAuB,MAAnBI,EAAQk6B,SAAmBl6B,EAAQoI,eAAe,WAAY,CAC9D,IAAIxI,EAAQisC,EAAM6D,MAAM9C,OAAO5sC,EAAQk6B,SACvC,GAAIt6B,EACA,MAAO,WAAaA,EAE5B,GAAqB,MAAjBI,EAAQR,OAAiBQ,EAAQoI,eAAe,SAAU,CAC1D,IAAIxI,EAAQisC,EAAM8D,WAAW/C,OAAO5sC,EAAQR,OAC5C,GAAII,EACA,MAAO,SAAWA,EAE1B,OAAO,MAWXkK,EAAU2c,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAM/hC,UACxB,OAAOgjC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM/hC,UACxB,GAAmB,MAAfgjC,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,oCACpB9tC,EAAQqF,KAAOwmC,EAAMlpC,MAAM8jB,WAAWqmB,EAAOznC,MAEjD,GAAoB,MAAhBynC,EAAOnhC,MAAe,CACtB,GAA4B,kBAAjBmhC,EAAOnhC,MACd,MAAMmiC,UAAU,qCACpB9tC,EAAQ2L,MAAQkgC,EAAM6D,MAAMjpB,WAAWqmB,EAAOnhC,OAElD,GAAsB,MAAlBmhC,EAAO5S,QAAiB,CACxB,GAA8B,kBAAnB4S,EAAO5S,QACd,MAAM4T,UAAU,uCACpB9tC,EAAQk6B,QAAU2R,EAAM6D,MAAMjpB,WAAWqmB,EAAO5S,SAEpD,GAAoB,MAAhB4S,EAAOttC,MAAe,CACtB,GAA4B,kBAAjBstC,EAAOttC,MACd,MAAMsuC,UAAU,qCACpB9tC,EAAQR,MAAQqsC,EAAM8D,WAAWlpB,WAAWqmB,EAAOttC,OAEvD,OAAOQ,GAYX8J,EAAUkjC,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAeb,OAdIG,EAAQC,WACRJ,EAAOznC,KAAO,KACdynC,EAAOnhC,MAAQ,KACfmhC,EAAO5S,QAAU,KACjB4S,EAAOttC,MAAQ,MAEC,MAAhBQ,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAMlpC,MAAMqqC,SAAShtC,EAAQqF,KAAM4nC,IAChC,MAAjBjtC,EAAQ2L,OAAiB3L,EAAQoI,eAAe,WAChD0kC,EAAOnhC,MAAQkgC,EAAM6D,MAAM1C,SAAShtC,EAAQ2L,MAAOshC,IAChC,MAAnBjtC,EAAQk6B,SAAmBl6B,EAAQoI,eAAe,aAClD0kC,EAAO5S,QAAU2R,EAAM6D,MAAM1C,SAAShtC,EAAQk6B,QAAS+S,IACtC,MAAjBjtC,EAAQR,OAAiBQ,EAAQoI,eAAe,WAChD0kC,EAAOttC,MAAQqsC,EAAM8D,WAAW3C,SAAShtC,EAAQR,MAAOytC,IACrDH,GAUXhjC,EAAUiiC,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDzjC,EA/QiC,GAkRvB+hC,EAAM6D,MAAS,WAuBhC,SAASA,EAAM5D,GACX,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4DhD,IAAIouB,EAqUJ,OAxXAkB,EAAM3D,UAAUjQ,WAAa,KAQ7B4T,EAAM3D,UAAU/P,WAAa,KAQ7B0T,EAAM3D,UAAU9P,WAAa,KAQ7ByT,EAAM3D,UAAU3P,cAAgB,KAQhCsT,EAAM3D,UAAU1P,eAAiB,KAQjCqT,EAAM3D,UAAU7P,YAAc,KAQ9BwT,EAAM3D,UAAU5P,cAAgB,KAWhChQ,OAAOsiB,eAAeiB,EAAM3D,UAAW,OAAQ,CAC3CltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,aAAc,aAAc,aAAc,gBAAiB,iBAAkB,cAAe,kBACnI5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BkB,EAAMvxB,OAAS,SAAgB2tB,GAC3B,OAAO,IAAI4D,EAAM5D,IAYrB4D,EAAMluB,OAAS,SAAgBxhB,EAASgsC,GAiBpC,OAhBKA,IACDA,EAASL,EAAQxtB,UACK,MAAtBne,EAAQ87B,YAAsB3P,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClE6rC,EAAM+D,WAAWpuB,OAAOxhB,EAAQ87B,WAAYkQ,EAAOE,OAA8B,IAAI0B,QAAQtB,SACvE,MAAtBtsC,EAAQg8B,YAAsB7P,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClE6rC,EAAMgE,WAAWruB,OAAOxhB,EAAQg8B,WAAYgQ,EAAOE,OAA8B,IAAI0B,QAAQtB,SACvE,MAAtBtsC,EAAQi8B,YAAsB9P,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClE6rC,EAAMiE,WAAWtuB,OAAOxhB,EAAQi8B,WAAY+P,EAAOE,OAA8B,IAAI0B,QAAQtB,SACpE,MAAzBtsC,EAAQo8B,eAAyBjQ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrE6rC,EAAMkE,cAAcvuB,OAAOxhB,EAAQo8B,cAAe4P,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzE,MAA1BtsC,EAAQq8B,gBAA0BlQ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,mBACtE6rC,EAAMmE,eAAexuB,OAAOxhB,EAAQq8B,eAAgB2P,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC9E,MAAvBtsC,EAAQk8B,aAAuB/P,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnE6rC,EAAMoE,WAAWzuB,OAAOxhB,EAAQk8B,YAAa8P,EAAOE,OAA8B,IAAI0B,QAAQtB,SACrE,MAAzBtsC,EAAQm8B,eAAyBhQ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrE6rC,EAAMqE,aAAa1uB,OAAOxhB,EAAQm8B,cAAe6P,EAAOE,OAA+B,IAAI0B,QAAQtB,SAChGN,GAYX0D,EAAMrD,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCoD,EAAM1yB,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM6D,MAChFlsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ87B,WAAa+P,EAAM+D,WAAW5yB,OAAOwG,EAAQA,EAAO0oB,UAC5D,MACJ,KAAK,EACDlsC,EAAQg8B,WAAa6P,EAAMgE,WAAW7yB,OAAOwG,EAAQA,EAAO0oB,UAC5D,MACJ,KAAK,EACDlsC,EAAQi8B,WAAa4P,EAAMiE,WAAW9yB,OAAOwG,EAAQA,EAAO0oB,UAC5D,MACJ,KAAK,EACDlsC,EAAQo8B,cAAgByP,EAAMkE,cAAc/yB,OAAOwG,EAAQA,EAAO0oB,UAClE,MACJ,KAAK,EACDlsC,EAAQq8B,eAAiBwP,EAAMmE,eAAehzB,OAAOwG,EAAQA,EAAO0oB,UACpE,MACJ,KAAK,EACDlsC,EAAQk8B,YAAc2P,EAAMoE,WAAWjzB,OAAOwG,EAAQA,EAAO0oB,UAC7D,MACJ,KAAK,GACDlsC,EAAQm8B,cAAgB0P,EAAMqE,aAAalzB,OAAOwG,EAAQA,EAAO0oB,UACjE,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0vC,EAAM/C,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCwD,EAAM9C,OAAS,SAAgB5sC,GAC3B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAA0B,MAAtB9rC,EAAQ87B,YAAsB97B,EAAQoI,eAAe,cAAe,CACpE0jC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM+D,WAAWhD,OAAO5sC,EAAQ87B,YAC5C,GAAIl8B,EACA,MAAO,cAAgBA,EAGnC,GAA0B,MAAtBI,EAAQg8B,YAAsBh8B,EAAQoI,eAAe,cAAe,CACpE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMgE,WAAWjD,OAAO5sC,EAAQg8B,YAC5C,GAAIp8B,EACA,MAAO,cAAgBA,EAGnC,GAA0B,MAAtBI,EAAQi8B,YAAsBj8B,EAAQoI,eAAe,cAAe,CACpE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMiE,WAAWlD,OAAO5sC,EAAQi8B,YAC5C,GAAIr8B,EACA,MAAO,cAAgBA,EAGnC,GAA6B,MAAzBI,EAAQo8B,eAAyBp8B,EAAQoI,eAAe,iBAAkB,CAC1E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMkE,cAAcnD,OAAO5sC,EAAQo8B,eAC/C,GAAIx8B,EACA,MAAO,iBAAmBA,EAGtC,GAA8B,MAA1BI,EAAQq8B,gBAA0Br8B,EAAQoI,eAAe,kBAAmB,CAC5E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMmE,eAAepD,OAAO5sC,EAAQq8B,gBAChD,GAAIz8B,EACA,MAAO,kBAAoBA,EAGvC,GAA2B,MAAvBI,EAAQk8B,aAAuBl8B,EAAQoI,eAAe,eAAgB,CACtE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMoE,WAAWrD,OAAO5sC,EAAQk8B,aAC5C,GAAIt8B,EACA,MAAO,eAAiBA,EAGpC,GAA6B,MAAzBI,EAAQm8B,eAAyBn8B,EAAQoI,eAAe,iBAAkB,CAC1E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMqE,aAAatD,OAAO5sC,EAAQm8B,eAC9C,GAAIv8B,EACA,MAAO,iBAAmBA,EAGtC,OAAO,MAWX8vC,EAAMjpB,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAM6D,MACxB,OAAO5C,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM6D,MACxB,GAAyB,MAArB5C,EAAOhR,WAAoB,CAC3B,GAAiC,kBAAtBgR,EAAOhR,WACd,MAAMgS,UAAU,sCACpB9tC,EAAQ87B,WAAa+P,EAAM+D,WAAWnpB,WAAWqmB,EAAOhR,YAE5D,GAAyB,MAArBgR,EAAO9Q,WAAoB,CAC3B,GAAiC,kBAAtB8Q,EAAO9Q,WACd,MAAM8R,UAAU,sCACpB9tC,EAAQg8B,WAAa6P,EAAMgE,WAAWppB,WAAWqmB,EAAO9Q,YAE5D,GAAyB,MAArB8Q,EAAO7Q,WAAoB,CAC3B,GAAiC,kBAAtB6Q,EAAO7Q,WACd,MAAM6R,UAAU,sCACpB9tC,EAAQi8B,WAAa4P,EAAMiE,WAAWrpB,WAAWqmB,EAAO7Q,YAE5D,GAA4B,MAAxB6Q,EAAO1Q,cAAuB,CAC9B,GAAoC,kBAAzB0Q,EAAO1Q,cACd,MAAM0R,UAAU,yCACpB9tC,EAAQo8B,cAAgByP,EAAMkE,cAActpB,WAAWqmB,EAAO1Q,eAElE,GAA6B,MAAzB0Q,EAAOzQ,eAAwB,CAC/B,GAAqC,kBAA1ByQ,EAAOzQ,eACd,MAAMyR,UAAU,0CACpB9tC,EAAQq8B,eAAiBwP,EAAMmE,eAAevpB,WAAWqmB,EAAOzQ,gBAEpE,GAA0B,MAAtByQ,EAAO5Q,YAAqB,CAC5B,GAAkC,kBAAvB4Q,EAAO5Q,YACd,MAAM4R,UAAU,uCACpB9tC,EAAQk8B,YAAc2P,EAAMoE,WAAWxpB,WAAWqmB,EAAO5Q,aAE7D,GAA4B,MAAxB4Q,EAAO3Q,cAAuB,CAC9B,GAAoC,kBAAzB2Q,EAAO3Q,cACd,MAAM2R,UAAU,yCACpB9tC,EAAQm8B,cAAgB0P,EAAMqE,aAAazpB,WAAWqmB,EAAO3Q,eAEjE,OAAOn8B,GAYX0vC,EAAM1C,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAoCb,OAnC0B,MAAtB9sC,EAAQ87B,YAAsB97B,EAAQoI,eAAe,gBACrD0kC,EAAOhR,WAAa+P,EAAM+D,WAAW5C,SAAShtC,EAAQ87B,WAAYmR,GAC9DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEI,MAAtBgB,EAAQg8B,YAAsBh8B,EAAQoI,eAAe,gBACrD0kC,EAAO9Q,WAAa6P,EAAMgE,WAAW7C,SAAShtC,EAAQg8B,WAAYiR,GAC9DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEI,MAAtBgB,EAAQi8B,YAAsBj8B,EAAQoI,eAAe,gBACrD0kC,EAAO7Q,WAAa4P,EAAMiE,WAAW9C,SAAShtC,EAAQi8B,WAAYgR,GAC9DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEO,MAAzBgB,EAAQo8B,eAAyBp8B,EAAQoI,eAAe,mBACxD0kC,EAAO1Q,cAAgByP,EAAMkE,cAAc/C,SAAShtC,EAAQo8B,cAAe6Q,GACvEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,kBAEQ,MAA1BgB,EAAQq8B,gBAA0Br8B,EAAQoI,eAAe,oBACzD0kC,EAAOzQ,eAAiBwP,EAAMmE,eAAehD,SAAShtC,EAAQq8B,eAAgB4Q,GAC1EA,EAAQ4B,SACR/B,EAAO9tC,KAAO,mBAEK,MAAvBgB,EAAQk8B,aAAuBl8B,EAAQoI,eAAe,iBACtD0kC,EAAO5Q,YAAc2P,EAAMoE,WAAWjD,SAAShtC,EAAQk8B,YAAa+Q,GAChEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEO,MAAzBgB,EAAQm8B,eAAyBn8B,EAAQoI,eAAe,mBACxD0kC,EAAO3Q,cAAgB0P,EAAMqE,aAAalD,SAAShtC,EAAQm8B,cAAe8Q,GACtEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,kBAEf8tC,GAUX4C,EAAM3D,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDmC,EA5ZyB,GA+ZV7D,EAAM+D,WAAc,WAiB1C,SAASA,EAAW9D,GAChB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwKhD,OA/JAwvB,EAAW7D,UAAU1mC,KAAO,KAU5BuqC,EAAWzxB,OAAS,SAAgB2tB,GAChC,OAAO,IAAI8D,EAAW9D,IAY1B8D,EAAWpuB,OAAS,SAAgBxhB,EAASgsC,GAKzC,OAJKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMsE,SAAS3uB,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SAClFN,GAYX4D,EAAWvD,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCsD,EAAW5yB,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM+D,WAChFpsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAMsE,SAASnzB,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX4vC,EAAWjD,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC0D,EAAWhD,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAMsE,SAASvD,OAAO5sC,EAAQqF,MAC1C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAO,MAWXgwC,EAAWnpB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAM+D,WACxB,OAAO9C,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM+D,WACxB,GAAmB,MAAf9C,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,qCACpB9tC,EAAQqF,KAAOwmC,EAAMsE,SAAS1pB,WAAWqmB,EAAOznC,MAEpD,OAAOrF,GAYX4vC,EAAW5C,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOznC,KAAO,MACE,MAAhBrF,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAMsE,SAASnD,SAAShtC,EAAQqF,KAAM4nC,IACjDH,GAUX8C,EAAW7D,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDqC,EA7LmC,GAgMpB/D,EAAMgE,WAAc,WAkB1C,SAASA,EAAW/D,GAChB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAqNhD,OA5MAyvB,EAAW9D,UAAUte,MAAQme,EAAMwE,KAAOxE,EAAMwE,KAAKC,SAAS,EAAE,GAAE,GAAS,EAQ3ER,EAAW9D,UAAUne,KAAOge,EAAMwE,KAAOxE,EAAMwE,KAAKC,SAAS,EAAE,GAAE,GAAS,EAU1ER,EAAW1xB,OAAS,SAAgB2tB,GAChC,OAAO,IAAI+D,EAAW/D,IAY1B+D,EAAWruB,OAAS,SAAgBxhB,EAASgsC,GAOzC,OANKA,IACDA,EAASL,EAAQxtB,UACA,MAAjBne,EAAQytB,OAAiBtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,GAAGoE,MAAMtwC,EAAQytB,OACtC,MAAhBztB,EAAQ4tB,MAAgBzB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIoE,MAAMtwC,EAAQ4tB,MACpDoe,GAYX6D,EAAWxD,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCuD,EAAW7yB,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMgE,WAChFrsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQytB,MAAQjK,EAAO8sB,QACvB,MACJ,KAAK,EACDtwC,EAAQ4tB,KAAOpK,EAAO8sB,QACtB,MACJ,QACI9sB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX6vC,EAAWlD,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC2D,EAAWjD,OAAS,SAAgB5sC,GAChC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACU,MAAjBA,EAAQytB,QAAiBztB,EAAQoI,eAAe,UAC3CwjC,EAAMiC,UAAU7tC,EAAQytB,QAAYztB,EAAQytB,OAASme,EAAMiC,UAAU7tC,EAAQytB,MAAM8iB,MAAQ3E,EAAMiC,UAAU7tC,EAAQytB,MAAM+iB,MAE9G,MAAhBxwC,EAAQ4tB,OAAgB5tB,EAAQoI,eAAe,SAC1CwjC,EAAMiC,UAAU7tC,EAAQ4tB,OAAW5tB,EAAQ4tB,MAAQge,EAAMiC,UAAU7tC,EAAQ4tB,KAAK2iB,MAAQ3E,EAAMiC,UAAU7tC,EAAQ4tB,KAAK4iB,MAEvH,KADQ,8BAHA,gCAenBX,EAAWppB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAMgE,WACxB,OAAO/C,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMgE,WAmBxB,OAlBoB,MAAhB/C,EAAOrf,QACHme,EAAMwE,MACLpwC,EAAQytB,MAAQme,EAAMwE,KAAKK,UAAU3D,EAAOrf,QAAQijB,UAAW,EACnC,kBAAjB5D,EAAOrf,MACnBztB,EAAQytB,MAAQtrB,SAAS2qC,EAAOrf,MAAO,IACV,kBAAjBqf,EAAOrf,MACnBztB,EAAQytB,MAAQqf,EAAOrf,MACM,kBAAjBqf,EAAOrf,QACnBztB,EAAQytB,MAAQ,IAAIme,EAAM+E,SAAS7D,EAAOrf,MAAM8iB,MAAQ,EAAGzD,EAAOrf,MAAM+iB,OAAS,GAAGI,aACzE,MAAf9D,EAAOlf,OACHge,EAAMwE,MACLpwC,EAAQ4tB,KAAOge,EAAMwE,KAAKK,UAAU3D,EAAOlf,OAAO8iB,UAAW,EAClC,kBAAhB5D,EAAOlf,KACnB5tB,EAAQ4tB,KAAOzrB,SAAS2qC,EAAOlf,KAAM,IACT,kBAAhBkf,EAAOlf,KACnB5tB,EAAQ4tB,KAAOkf,EAAOlf,KACM,kBAAhBkf,EAAOlf,OACnB5tB,EAAQ4tB,KAAO,IAAIge,EAAM+E,SAAS7D,EAAOlf,KAAK2iB,MAAQ,EAAGzD,EAAOlf,KAAK4iB,OAAS,GAAGI,aAClF5wC,GAYX6vC,EAAW7C,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GACb,GAAIG,EAAQC,SAAU,CAClB,GAAItB,EAAMwE,KAAM,CACZ,IAAIS,EAAO,IAAIjF,EAAMwE,KAAK,EAAG,GAAG,GAChCtD,EAAOrf,MAAQwf,EAAQ6D,QAAU/D,OAAS8D,EAAKnqC,WAAaumC,EAAQ6D,QAAUjZ,OAASgZ,EAAKD,WAAaC,OAEzG/D,EAAOrf,MAAQwf,EAAQ6D,QAAU/D,OAAS,IAAM,EACpD,GAAInB,EAAMwE,KAAM,CACZ,IAAIS,EAAO,IAAIjF,EAAMwE,KAAK,EAAG,GAAG,GAChCtD,EAAOlf,KAAOqf,EAAQ6D,QAAU/D,OAAS8D,EAAKnqC,WAAaumC,EAAQ6D,QAAUjZ,OAASgZ,EAAKD,WAAaC,OAExG/D,EAAOlf,KAAOqf,EAAQ6D,QAAU/D,OAAS,IAAM,EAYvD,OAVqB,MAAjB/sC,EAAQytB,OAAiBztB,EAAQoI,eAAe,WACnB,kBAAlBpI,EAAQytB,MACfqf,EAAOrf,MAAQwf,EAAQ6D,QAAU/D,OAASA,OAAO/sC,EAAQytB,OAASztB,EAAQytB,MAE1Eqf,EAAOrf,MAAQwf,EAAQ6D,QAAU/D,OAASnB,EAAMwE,KAAKrE,UAAUrlC,SAASulC,KAAKjsC,EAAQytB,OAASwf,EAAQ6D,QAAUjZ,OAAS,IAAI+T,EAAM+E,SAAS3wC,EAAQytB,MAAM8iB,MAAQ,EAAGvwC,EAAQytB,MAAM+iB,OAAS,GAAGI,WAAa5wC,EAAQytB,OACxM,MAAhBztB,EAAQ4tB,MAAgB5tB,EAAQoI,eAAe,UACnB,kBAAjBpI,EAAQ4tB,KACfkf,EAAOlf,KAAOqf,EAAQ6D,QAAU/D,OAASA,OAAO/sC,EAAQ4tB,MAAQ5tB,EAAQ4tB,KAExEkf,EAAOlf,KAAOqf,EAAQ6D,QAAU/D,OAASnB,EAAMwE,KAAKrE,UAAUrlC,SAASulC,KAAKjsC,EAAQ4tB,MAAQqf,EAAQ6D,QAAUjZ,OAAS,IAAI+T,EAAM+E,SAAS3wC,EAAQ4tB,KAAK2iB,MAAQ,EAAGvwC,EAAQ4tB,KAAK4iB,OAAS,GAAGI,WAAa5wC,EAAQ4tB,MACjNkf,GAUX+C,EAAW9D,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDsC,EA3OmC,GA8OpBhE,EAAMiE,WAAc,WAkB1C,SAASA,EAAWhE,GAGhB,GAFAttC,KAAK+9B,OAAS,GACd/9B,KAAKuyC,OAAS,GACVjF,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAiOhD,OAxNA0vB,EAAW/D,UAAUxP,OAASqP,EAAMoD,WAQpCc,EAAW/D,UAAUgF,OAASnF,EAAMoD,WAUpCc,EAAW3xB,OAAS,SAAgB2tB,GAChC,OAAO,IAAIgE,EAAWhE,IAY1BgE,EAAWtuB,OAAS,SAAgBxhB,EAASgsC,GAGzC,GAFKA,IACDA,EAASL,EAAQxtB,UACC,MAAlBne,EAAQu8B,QAAkBv8B,EAAQu8B,OAAO7Z,OACzC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQu8B,OAAO7Z,SAAUtC,EACzCyrB,EAAM6D,MAAMluB,OAAOxhB,EAAQu8B,OAAOnc,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC/F,GAAsB,MAAlBtsC,EAAQ+wC,QAAkB/wC,EAAQ+wC,OAAOruB,OACzC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQ+wC,OAAOruB,SAAUtC,EACzCyrB,EAAMmF,WAAWxvB,OAAOxhB,EAAQ+wC,OAAO3wB,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACpG,OAAON,GAYX8D,EAAWzD,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCwD,EAAW9yB,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMiE,WAChFtsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQu8B,QAAUv8B,EAAQu8B,OAAO7Z,SACnC1iB,EAAQu8B,OAAS,IACrBv8B,EAAQu8B,OAAO/4B,KAAKqoC,EAAM6D,MAAM1yB,OAAOwG,EAAQA,EAAO0oB,WACtD,MACJ,KAAK,EACKlsC,EAAQ+wC,QAAU/wC,EAAQ+wC,OAAOruB,SACnC1iB,EAAQ+wC,OAAS,IACrB/wC,EAAQ+wC,OAAOvtC,KAAKqoC,EAAMmF,WAAWh0B,OAAOwG,EAAQA,EAAO0oB,WAC3D,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX8vC,EAAWnD,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC4D,EAAWlD,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAsB,MAAlBA,EAAQu8B,QAAkBv8B,EAAQoI,eAAe,UAAW,CAC5D,IAAKuxB,MAAMuV,QAAQlvC,EAAQu8B,QACvB,MAAO,yBACX,IAAK,IAAInc,EAAI,EAAGA,EAAIpgB,EAAQu8B,OAAO7Z,SAAUtC,EAAG,CAC5C,IAAIxgB,EAAQisC,EAAM6D,MAAM9C,OAAO5sC,EAAQu8B,OAAOnc,IAC9C,GAAIxgB,EACA,MAAO,UAAYA,GAG/B,GAAsB,MAAlBI,EAAQ+wC,QAAkB/wC,EAAQoI,eAAe,UAAW,CAC5D,IAAKuxB,MAAMuV,QAAQlvC,EAAQ+wC,QACvB,MAAO,yBACX,IAAK,IAAI3wB,EAAI,EAAGA,EAAIpgB,EAAQ+wC,OAAOruB,SAAUtC,EAAG,CAC5C,IAAIxgB,EAAQisC,EAAMmF,WAAWpE,OAAO5sC,EAAQ+wC,OAAO3wB,IACnD,GAAIxgB,EACA,MAAO,UAAYA,GAG/B,OAAO,MAWXkwC,EAAWrpB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAMiE,WACxB,OAAOhD,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMiE,WACxB,GAAIhD,EAAOvQ,OAAQ,CACf,IAAK5C,MAAMuV,QAAQpC,EAAOvQ,QACtB,MAAMuR,UAAU,sCACpB9tC,EAAQu8B,OAAS,GACjB,IAAK,IAAInc,EAAI,EAAGA,EAAI0sB,EAAOvQ,OAAO7Z,SAAUtC,EAAG,CAC3C,GAAgC,kBAArB0sB,EAAOvQ,OAAOnc,GACrB,MAAM0tB,UAAU,uCACpB9tC,EAAQu8B,OAAOnc,GAAKyrB,EAAM6D,MAAMjpB,WAAWqmB,EAAOvQ,OAAOnc,KAGjE,GAAI0sB,EAAOiE,OAAQ,CACf,IAAKpX,MAAMuV,QAAQpC,EAAOiE,QACtB,MAAMjD,UAAU,sCACpB9tC,EAAQ+wC,OAAS,GACjB,IAAK,IAAI3wB,EAAI,EAAGA,EAAI0sB,EAAOiE,OAAOruB,SAAUtC,EAAG,CAC3C,GAAgC,kBAArB0sB,EAAOiE,OAAO3wB,GACrB,MAAM0tB,UAAU,uCACpB9tC,EAAQ+wC,OAAO3wB,GAAKyrB,EAAMmF,WAAWvqB,WAAWqmB,EAAOiE,OAAO3wB,KAGtE,OAAOpgB,GAYX8vC,EAAW9C,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,IAJIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOvQ,OAAS,GAChBuQ,EAAOiE,OAAS,IAEhB/wC,EAAQu8B,QAAUv8B,EAAQu8B,OAAO7Z,OAAQ,CACzCoqB,EAAOvQ,OAAS,GAChB,IAAK,IAAI6S,EAAI,EAAGA,EAAIpvC,EAAQu8B,OAAO7Z,SAAU0sB,EACzCtC,EAAOvQ,OAAO6S,GAAKvD,EAAM6D,MAAM1C,SAAShtC,EAAQu8B,OAAO6S,GAAInC,GAEnE,GAAIjtC,EAAQ+wC,QAAU/wC,EAAQ+wC,OAAOruB,OAAQ,CACzCoqB,EAAOiE,OAAS,GAChB,IAAK,IAAI3B,EAAI,EAAGA,EAAIpvC,EAAQ+wC,OAAOruB,SAAU0sB,EACzCtC,EAAOiE,OAAO3B,GAAKvD,EAAMmF,WAAWhE,SAAShtC,EAAQ+wC,OAAO3B,GAAInC,GAExE,OAAOH,GAUXgD,EAAW/D,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDuC,EAzPmC,GA4PjBjE,EAAMkE,cAAiB,WAiBhD,SAASA,EAAcjE,GACnB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwKhD,OA/JA2vB,EAAchE,UAAU1mC,KAAO,KAU/B0qC,EAAc5xB,OAAS,SAAgB2tB,GACnC,OAAO,IAAIiE,EAAcjE,IAY7BiE,EAAcvuB,OAAS,SAAgBxhB,EAASgsC,GAK5C,OAJKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMoF,WAAWzvB,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACpFN,GAYX+D,EAAc1D,gBAAkB,SAAyBrsC,EAASgsC,GAC9D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCyD,EAAc/yB,OAAS,SAAgBwG,EAAQd,GACrCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMkE,cAChFvsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAMoF,WAAWj0B,OAAOwG,EAAQA,EAAO0oB,UACtD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX+vC,EAAcpD,gBAAkB,SAAyBnpB,GAGrD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC6D,EAAcnD,OAAS,SAAgB5sC,GACnC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAMoF,WAAWrE,OAAO5sC,EAAQqF,MAC5C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAO,MAWXmwC,EAActpB,WAAa,SAAoBqmB,GAC3C,GAAIA,aAAkBjB,EAAMkE,cACxB,OAAOjD,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMkE,cACxB,GAAmB,MAAfjD,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,wCACpB9tC,EAAQqF,KAAOwmC,EAAMoF,WAAWxqB,WAAWqmB,EAAOznC,MAEtD,OAAOrF,GAYX+vC,EAAc/C,SAAW,SAAkBhtC,EAASitC,GAC3CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOznC,KAAO,MACE,MAAhBrF,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAMoF,WAAWjE,SAAShtC,EAAQqF,KAAM4nC,IACnDH,GAUXiD,EAAchE,UAAUsB,OAAS,WAC7B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDwC,EA7LyC,GAgMtBlE,EAAMmE,eAAkB,WAiBlD,SAASA,EAAelE,GACpB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwKhD,OA/JA4vB,EAAejE,UAAU1mC,KAAO,KAUhC2qC,EAAe7xB,OAAS,SAAgB2tB,GACpC,OAAO,IAAIkE,EAAelE,IAY9BkE,EAAexuB,OAAS,SAAgBxhB,EAASgsC,GAK7C,OAJKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMoF,WAAWzvB,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACpFN,GAYXgE,EAAe3D,gBAAkB,SAAyBrsC,EAASgsC,GAC/D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC0D,EAAehzB,OAAS,SAAgBwG,EAAQd,GACtCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMmE,eAChFxsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAMoF,WAAWj0B,OAAOwG,EAAQA,EAAO0oB,UACtD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXgwC,EAAerD,gBAAkB,SAAyBnpB,GAGtD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC8D,EAAepD,OAAS,SAAgB5sC,GACpC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAMoF,WAAWrE,OAAO5sC,EAAQqF,MAC5C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAO,MAWXowC,EAAevpB,WAAa,SAAoBqmB,GAC5C,GAAIA,aAAkBjB,EAAMmE,eACxB,OAAOlD,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMmE,eACxB,GAAmB,MAAflD,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,yCACpB9tC,EAAQqF,KAAOwmC,EAAMoF,WAAWxqB,WAAWqmB,EAAOznC,MAEtD,OAAOrF,GAYXgwC,EAAehD,SAAW,SAAkBhtC,EAASitC,GAC5CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOznC,KAAO,MACE,MAAhBrF,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAMoF,WAAWjE,SAAShtC,EAAQqF,KAAM4nC,IACnDH,GAUXkD,EAAejE,UAAUsB,OAAS,WAC9B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDyC,EA7L2C,GAgM5BnE,EAAMoE,WAAc,WAiB1C,SAASA,EAAWnE,GAChB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwKhD,OA/JA6vB,EAAWlE,UAAU1mC,KAAO,KAU5B4qC,EAAW9xB,OAAS,SAAgB2tB,GAChC,OAAO,IAAImE,EAAWnE,IAY1BmE,EAAWzuB,OAAS,SAAgBxhB,EAASgsC,GAKzC,OAJKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMoF,WAAWzvB,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACpFN,GAYXiE,EAAW5D,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC2D,EAAWjzB,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMoE,WAChFzsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAMoF,WAAWj0B,OAAOwG,EAAQA,EAAO0oB,UACtD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXiwC,EAAWtD,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC+D,EAAWrD,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAMoF,WAAWrE,OAAO5sC,EAAQqF,MAC5C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAO,MAWXqwC,EAAWxpB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAMoE,WACxB,OAAOnD,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMoE,WACxB,GAAmB,MAAfnD,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,qCACpB9tC,EAAQqF,KAAOwmC,EAAMoF,WAAWxqB,WAAWqmB,EAAOznC,MAEtD,OAAOrF,GAYXiwC,EAAWjD,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOznC,KAAO,MACE,MAAhBrF,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAMoF,WAAWjE,SAAShtC,EAAQqF,KAAM4nC,IACnDH,GAUXmD,EAAWlE,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD0C,EA7LmC,GAgMlBpE,EAAMqE,aAAgB,WAiB9C,SAASA,EAAapE,GAClB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwKhD,OA/JA8vB,EAAanE,UAAU1mC,KAAO,KAU9B6qC,EAAa/xB,OAAS,SAAgB2tB,GAClC,OAAO,IAAIoE,EAAapE,IAY5BoE,EAAa1uB,OAAS,SAAgBxhB,EAASgsC,GAK3C,OAJKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMqF,YAAY1vB,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACrFN,GAYXkE,EAAa7D,gBAAkB,SAAyBrsC,EAASgsC,GAC7D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC4D,EAAalzB,OAAS,SAAgBwG,EAAQd,GACpCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMqE,aAChF1sB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAMqF,YAAYl0B,OAAOwG,EAAQA,EAAO0oB,UACvD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXkwC,EAAavD,gBAAkB,SAAyBnpB,GAGpD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCgE,EAAatD,OAAS,SAAgB5sC,GAClC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAMqF,YAAYtE,OAAO5sC,EAAQqF,MAC7C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAO,MAWXswC,EAAazpB,WAAa,SAAoBqmB,GAC1C,GAAIA,aAAkBjB,EAAMqE,aACxB,OAAOpD,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMqE,aACxB,GAAmB,MAAfpD,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,uCACpB9tC,EAAQqF,KAAOwmC,EAAMqF,YAAYzqB,WAAWqmB,EAAOznC,MAEvD,OAAOrF,GAYXkwC,EAAalD,SAAW,SAAkBhtC,EAASitC,GAC1CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOznC,KAAO,MACE,MAAhBrF,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAMqF,YAAYlE,SAAShtC,EAAQqF,KAAM4nC,IACpDH,GAUXoD,EAAanE,UAAUsB,OAAS,WAC5B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD2C,EA7LuC,GAgMvBrE,EAAMrlB,YAAe,WAiB5C,SAASA,EAAYslB,GAEjB,GADAttC,KAAK6G,KAAO,GACRymC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAkLhD,OAzKAoG,EAAYulB,UAAU1mC,KAAOumC,EAAMoD,WAUnCxoB,EAAYrI,OAAS,SAAgB2tB,GACjC,OAAO,IAAItlB,EAAYslB,IAY3BtlB,EAAYhF,OAAS,SAAgBxhB,EAASgsC,GAG1C,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgBrF,EAAQqF,KAAKqd,OACrC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC4rB,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQqF,KAAK+a,IACrE,OAAO4rB,GAYXxlB,EAAY6lB,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC9lB,EAAYxJ,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMrlB,YAChFhD,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQqF,MAAQrF,EAAQqF,KAAKqd,SAC/B1iB,EAAQqF,KAAO,IACnBrF,EAAQqF,KAAK7B,KAAKggB,EAAO2oB,UACzB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXwmB,EAAYmmB,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC1lB,EAAYomB,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQqF,MACvB,MAAO,uBACX,IAAK,IAAI+a,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC,IAAKwrB,EAAMiB,SAAS7sC,EAAQqF,KAAK+a,IAC7B,MAAO,0BAEnB,OAAO,MAWXoG,EAAYC,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMrlB,YACxB,OAAOsmB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMrlB,YACxB,GAAIsmB,EAAOznC,KAAM,CACb,IAAKs0B,MAAMuV,QAAQpC,EAAOznC,MACtB,MAAMyoC,UAAU,qCACpB9tC,EAAQqF,KAAO,GACf,IAAK,IAAI+a,EAAI,EAAGA,EAAI0sB,EAAOznC,KAAKqd,SAAUtC,EACtCpgB,EAAQqF,KAAK+a,GAAK2sB,OAAOD,EAAOznC,KAAK+a,IAE7C,OAAOpgB,GAYXwmB,EAAYwmB,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOznC,KAAO,IACdrF,EAAQqF,MAAQrF,EAAQqF,KAAKqd,OAAQ,CACrCoqB,EAAOznC,KAAO,GACd,IAAK,IAAI+pC,EAAI,EAAGA,EAAIpvC,EAAQqF,KAAKqd,SAAU0sB,EACvCtC,EAAOznC,KAAK+pC,GAAKpvC,EAAQqF,KAAK+pC,GAEtC,OAAOtC,GAUXtmB,EAAYulB,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD/mB,EAxMqC,IA+8GnCkD,GApwGcmiB,EAAMqF,YAAe,WAiB5C,SAASA,EAAYpF,GAEjB,GADAttC,KAAK6G,KAAO,GACRymC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA0LhD,OAjLA8wB,EAAYnF,UAAU1mC,KAAOumC,EAAMoD,WAUnCkC,EAAY/yB,OAAS,SAAgB2tB,GACjC,OAAO,IAAIoF,EAAYpF,IAY3BoF,EAAY1vB,OAAS,SAAgBxhB,EAASgsC,GAG1C,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgBrF,EAAQqF,KAAKqd,OAAQ,CAC7CspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC4rB,EAAOmF,OAAOnxC,EAAQqF,KAAK+a,IAC/B4rB,EAAOM,SAEX,OAAON,GAYXkF,EAAY7E,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC4E,EAAYl0B,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMqF,YAChF1tB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EAGD,GAFMzsC,EAAQqF,MAAQrF,EAAQqF,KAAKqd,SAC/B1iB,EAAQqF,KAAO,IACD,KAAP,EAANonC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAQqF,KAAK7B,KAAKggB,EAAO2tB,eAE7BnxC,EAAQqF,KAAK7B,KAAKggB,EAAO2tB,UAC7B,MACJ,QACI3tB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXkxC,EAAYvE,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCgF,EAAYtE,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQqF,MACvB,MAAO,uBACX,IAAK,IAAI+a,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC,GAA+B,kBAApBpgB,EAAQqF,KAAK+a,GACpB,MAAO,0BAEnB,OAAO,MAWX8wB,EAAYzqB,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMqF,YACxB,OAAOpE,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMqF,YACxB,GAAIpE,EAAOznC,KAAM,CACb,IAAKs0B,MAAMuV,QAAQpC,EAAOznC,MACtB,MAAMyoC,UAAU,qCACpB9tC,EAAQqF,KAAO,GACf,IAAK,IAAI+a,EAAI,EAAGA,EAAI0sB,EAAOznC,KAAKqd,SAAUtC,EACtCpgB,EAAQqF,KAAK+a,GAAKyX,OAAOiV,EAAOznC,KAAK+a,IAE7C,OAAOpgB,GAYXkxC,EAAYlE,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOznC,KAAO,IACdrF,EAAQqF,MAAQrF,EAAQqF,KAAKqd,OAAQ,CACrCoqB,EAAOznC,KAAO,GACd,IAAK,IAAI+pC,EAAI,EAAGA,EAAIpvC,EAAQqF,KAAKqd,SAAU0sB,EACvCtC,EAAOznC,KAAK+pC,GAAKnC,EAAQz/B,OAAS4jC,SAASpxC,EAAQqF,KAAK+pC,IAAMrC,OAAO/sC,EAAQqF,KAAK+pC,IAAMpvC,EAAQqF,KAAK+pC,GAE7G,OAAOtC,GAUXoE,EAAYnF,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD2D,EAhNqC,GAmNtBrF,EAAMmF,WAAc,WAiB1C,SAASA,EAAWlF,GAEhB,GADAttC,KAAK6G,KAAO,GACRymC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA0LhD,OAjLA4wB,EAAWjF,UAAU1mC,KAAOumC,EAAMoD,WAUlCgC,EAAW7yB,OAAS,SAAgB2tB,GAChC,OAAO,IAAIkF,EAAWlF,IAY1BkF,EAAWxvB,OAAS,SAAgBxhB,EAASgsC,GAGzC,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgBrF,EAAQqF,KAAKqd,OAAQ,CAC7CspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC4rB,EAAOI,MAAMpsC,EAAQqF,KAAK+a,IAC9B4rB,EAAOM,SAEX,OAAON,GAYXgF,EAAW3E,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC0E,EAAWh0B,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMmF,WAChFxtB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EAGD,GAFMzsC,EAAQqF,MAAQrF,EAAQqF,KAAKqd,SAC/B1iB,EAAQqF,KAAO,IACD,KAAP,EAANonC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAQqF,KAAK7B,KAAKggB,EAAO4oB,cAE7BpsC,EAAQqF,KAAK7B,KAAKggB,EAAO4oB,SAC7B,MACJ,QACI5oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXgxC,EAAWrE,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC8E,EAAWpE,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQqF,MACvB,MAAO,uBACX,IAAK,IAAI+a,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC,IAAKwrB,EAAMiC,UAAU7tC,EAAQqF,KAAK+a,IAC9B,MAAO,2BAEnB,OAAO,MAWX4wB,EAAWvqB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAMmF,WACxB,OAAOlE,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMmF,WACxB,GAAIlE,EAAOznC,KAAM,CACb,IAAKs0B,MAAMuV,QAAQpC,EAAOznC,MACtB,MAAMyoC,UAAU,oCACpB9tC,EAAQqF,KAAO,GACf,IAAK,IAAI+a,EAAI,EAAGA,EAAI0sB,EAAOznC,KAAKqd,SAAUtC,EACtCpgB,EAAQqF,KAAK+a,GAAsB,EAAjB0sB,EAAOznC,KAAK+a,GAEtC,OAAOpgB,GAYXgxC,EAAWhE,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOznC,KAAO,IACdrF,EAAQqF,MAAQrF,EAAQqF,KAAKqd,OAAQ,CACrCoqB,EAAOznC,KAAO,GACd,IAAK,IAAI+pC,EAAI,EAAGA,EAAIpvC,EAAQqF,KAAKqd,SAAU0sB,EACvCtC,EAAOznC,KAAK+pC,GAAKpvC,EAAQqF,KAAK+pC,GAEtC,OAAOtC,GAUXkE,EAAWjF,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDyD,EAhNmC,GAmNpBnF,EAAMoF,WAAc,WAiB1C,SAASA,EAAWnF,GAEhB,GADAttC,KAAK6G,KAAO,GACRymC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAoMhD,OA3LA6wB,EAAWlF,UAAU1mC,KAAOumC,EAAMoD,WAUlCiC,EAAW9yB,OAAS,SAAgB2tB,GAChC,OAAO,IAAImF,EAAWnF,IAY1BmF,EAAWzvB,OAAS,SAAgBxhB,EAASgsC,GAGzC,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgBrF,EAAQqF,KAAKqd,OAAQ,CAC7CspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC4rB,EAAOsE,MAAMtwC,EAAQqF,KAAK+a,IAC9B4rB,EAAOM,SAEX,OAAON,GAYXiF,EAAW5E,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC2E,EAAWj0B,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMoF,WAChFztB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EAGD,GAFMzsC,EAAQqF,MAAQrF,EAAQqF,KAAKqd,SAC/B1iB,EAAQqF,KAAO,IACD,KAAP,EAANonC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAQqF,KAAK7B,KAAKggB,EAAO8sB,cAE7BtwC,EAAQqF,KAAK7B,KAAKggB,EAAO8sB,SAC7B,MACJ,QACI9sB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXixC,EAAWtE,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC+E,EAAWrE,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQqF,MACvB,MAAO,uBACX,IAAK,IAAI+a,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC,IAAKwrB,EAAMiC,UAAU7tC,EAAQqF,KAAK+a,OAASpgB,EAAQqF,KAAK+a,IAAMwrB,EAAMiC,UAAU7tC,EAAQqF,KAAK+a,GAAGmwB,MAAQ3E,EAAMiC,UAAU7tC,EAAQqF,KAAK+a,GAAGowB,OAClI,MAAO,gCAEnB,OAAO,MAWXS,EAAWxqB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAMoF,WACxB,OAAOnE,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMoF,WACxB,GAAInE,EAAOznC,KAAM,CACb,IAAKs0B,MAAMuV,QAAQpC,EAAOznC,MACtB,MAAMyoC,UAAU,oCACpB9tC,EAAQqF,KAAO,GACf,IAAK,IAAI+a,EAAI,EAAGA,EAAI0sB,EAAOznC,KAAKqd,SAAUtC,EAClCwrB,EAAMwE,MACLpwC,EAAQqF,KAAK+a,GAAKwrB,EAAMwE,KAAKK,UAAU3D,EAAOznC,KAAK+a,KAAKswB,UAAW,EACrC,kBAAnB5D,EAAOznC,KAAK+a,GACxBpgB,EAAQqF,KAAK+a,GAAKje,SAAS2qC,EAAOznC,KAAK+a,GAAI,IACZ,kBAAnB0sB,EAAOznC,KAAK+a,GACxBpgB,EAAQqF,KAAK+a,GAAK0sB,EAAOznC,KAAK+a,GACC,kBAAnB0sB,EAAOznC,KAAK+a,KACxBpgB,EAAQqF,KAAK+a,GAAK,IAAIwrB,EAAM+E,SAAS7D,EAAOznC,KAAK+a,GAAGmwB,MAAQ,EAAGzD,EAAOznC,KAAK+a,GAAGowB,OAAS,GAAGI,YAEtG,OAAO5wC,GAYXixC,EAAWjE,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOznC,KAAO,IACdrF,EAAQqF,MAAQrF,EAAQqF,KAAKqd,OAAQ,CACrCoqB,EAAOznC,KAAO,GACd,IAAK,IAAI+pC,EAAI,EAAGA,EAAIpvC,EAAQqF,KAAKqd,SAAU0sB,EACR,kBAApBpvC,EAAQqF,KAAK+pC,GACpBtC,EAAOznC,KAAK+pC,GAAKnC,EAAQ6D,QAAU/D,OAASA,OAAO/sC,EAAQqF,KAAK+pC,IAAMpvC,EAAQqF,KAAK+pC,GAEnFtC,EAAOznC,KAAK+pC,GAAKnC,EAAQ6D,QAAU/D,OAASnB,EAAMwE,KAAKrE,UAAUrlC,SAASulC,KAAKjsC,EAAQqF,KAAK+pC,IAAMnC,EAAQ6D,QAAUjZ,OAAS,IAAI+T,EAAM+E,SAAS3wC,EAAQqF,KAAK+pC,GAAGmB,MAAQ,EAAGvwC,EAAQqF,KAAK+pC,GAAGoB,OAAS,GAAGI,WAAa5wC,EAAQqF,KAAK+pC,GAE7O,OAAOtC,GAUXmE,EAAWlF,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD0D,EA1NmC,GA6NnBpF,EAAMwF,YAAe,WAiB5C,SAASA,EAAYvF,GAEjB,GADAttC,KAAK6G,KAAO,GACRymC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA0LhD,OAjLAixB,EAAYtF,UAAU1mC,KAAOumC,EAAMoD,WAUnCqC,EAAYlzB,OAAS,SAAgB2tB,GACjC,OAAO,IAAIuF,EAAYvF,IAY3BuF,EAAY7vB,OAAS,SAAgBxhB,EAASgsC,GAG1C,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgBrF,EAAQqF,KAAKqd,OAAQ,CAC7CspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC4rB,EAAOE,OAAOlsC,EAAQqF,KAAK+a,IAC/B4rB,EAAOM,SAEX,OAAON,GAYXqF,EAAYhF,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC+E,EAAYr0B,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMwF,YAChF7tB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EAGD,GAFMzsC,EAAQqF,MAAQrF,EAAQqF,KAAKqd,SAC/B1iB,EAAQqF,KAAO,IACD,KAAP,EAANonC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAQqF,KAAK7B,KAAKggB,EAAO0oB,eAE7BlsC,EAAQqF,KAAK7B,KAAKggB,EAAO0oB,UAC7B,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXqxC,EAAY1E,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCmF,EAAYzE,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQqF,MACvB,MAAO,uBACX,IAAK,IAAI+a,EAAI,EAAGA,EAAIpgB,EAAQqF,KAAKqd,SAAUtC,EACvC,IAAKwrB,EAAMiC,UAAU7tC,EAAQqF,KAAK+a,IAC9B,MAAO,2BAEnB,OAAO,MAWXixB,EAAY5qB,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMwF,YACxB,OAAOvE,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMwF,YACxB,GAAIvE,EAAOznC,KAAM,CACb,IAAKs0B,MAAMuV,QAAQpC,EAAOznC,MACtB,MAAMyoC,UAAU,qCACpB9tC,EAAQqF,KAAO,GACf,IAAK,IAAI+a,EAAI,EAAGA,EAAI0sB,EAAOznC,KAAKqd,SAAUtC,EACtCpgB,EAAQqF,KAAK+a,GAAK0sB,EAAOznC,KAAK+a,KAAO,EAE7C,OAAOpgB,GAYXqxC,EAAYrE,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOznC,KAAO,IACdrF,EAAQqF,MAAQrF,EAAQqF,KAAKqd,OAAQ,CACrCoqB,EAAOznC,KAAO,GACd,IAAK,IAAI+pC,EAAI,EAAGA,EAAIpvC,EAAQqF,KAAKqd,SAAU0sB,EACvCtC,EAAOznC,KAAK+pC,GAAKpvC,EAAQqF,KAAK+pC,GAEtC,OAAOtC,GAUXuE,EAAYtF,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD8D,EAhNqC,GAmNxBxF,EAAMyF,SAAY,WAkBtC,SAASA,EAASxF,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLAkxB,EAASvF,UAAUrQ,SAAW,GAQ9B4V,EAASvF,UAAU3lC,MAAQ,GAU3BkrC,EAASnzB,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIwF,EAASxF,IAYxBwF,EAAS9vB,OAAS,SAAgBxhB,EAASgsC,GAOvC,OANKA,IACDA,EAASL,EAAQxtB,UACG,MAApBne,EAAQ07B,UAAoBvP,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ07B,UACvC,MAAjB17B,EAAQoG,OAAiB+lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQoG,OACrD4lC,GAYXsF,EAASjF,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCgF,EAASt0B,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMyF,SAChF9tB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ07B,SAAWlY,EAAO2oB,SAC1B,MACJ,KAAK,EACDnsC,EAAQoG,MAAQod,EAAO2oB,SACvB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXsxC,EAAS3E,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCoF,EAAS1E,OAAS,SAAgB5sC,GAC9B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACa,MAApBA,EAAQ07B,UAAoB17B,EAAQoI,eAAe,cAC9CwjC,EAAMiB,SAAS7sC,EAAQ07B,UACjB,4BACM,MAAjB17B,EAAQoG,OAAiBpG,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQoG,OACjB,yBACR,MAWXkrC,EAAS7qB,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMyF,SACxB,OAAOxE,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMyF,SAKxB,OAJuB,MAAnBxE,EAAOpR,WACP17B,EAAQ07B,SAAWqR,OAAOD,EAAOpR,WACjB,MAAhBoR,EAAO1mC,QACPpG,EAAQoG,MAAQ2mC,OAAOD,EAAO1mC,QAC3BpG,GAYXsxC,EAAStE,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOpR,SAAW,GAClBoR,EAAO1mC,MAAQ,IAEK,MAApBpG,EAAQ07B,UAAoB17B,EAAQoI,eAAe,cACnD0kC,EAAOpR,SAAW17B,EAAQ07B,UACT,MAAjB17B,EAAQoG,OAAiBpG,EAAQoI,eAAe,WAChD0kC,EAAO1mC,MAAQpG,EAAQoG,OACpB0mC,GAUXwE,EAASvF,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD+D,EA/M+B,GAkNjBzF,EAAM0F,UAAa,WAmBxC,SAASA,EAAUzF,GAEf,GADAttC,KAAKgzC,IAAM,GACP1F,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmOhD,OA1NAmxB,EAAUxF,UAAUyF,IAAM5F,EAAMoD,WAQhCuC,EAAUxF,UAAU0F,aAAe,GAQnCF,EAAUxF,UAAU2F,iBAAkB,EAUtCH,EAAUpzB,OAAS,SAAgB2tB,GAC/B,OAAO,IAAIyF,EAAUzF,IAYzByF,EAAU/vB,OAAS,SAAgBxhB,EAASgsC,GAGxC,GAFKA,IACDA,EAASL,EAAQxtB,UACF,MAAfne,EAAQwxC,KAAexxC,EAAQwxC,IAAI9uB,OACnC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQwxC,IAAI9uB,SAAUtC,EACtCyrB,EAAMyF,SAAS9vB,OAAOxhB,EAAQwxC,IAAIpxB,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAK/F,OAJ4B,MAAxBtsC,EAAQyxC,cAAwBtlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,iBACpEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyxC,cAC7B,MAA3BzxC,EAAQ0xC,iBAA2BvlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,oBACvEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ0xC,iBACnD1F,GAYXuF,EAAUlF,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCiF,EAAUv0B,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM0F,UAChF/tB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQwxC,KAAOxxC,EAAQwxC,IAAI9uB,SAC7B1iB,EAAQwxC,IAAM,IAClBxxC,EAAQwxC,IAAIhuC,KAAKqoC,EAAMyF,SAASt0B,OAAOwG,EAAQA,EAAO0oB,WACtD,MACJ,KAAK,EACDlsC,EAAQyxC,aAAejuB,EAAO2oB,SAC9B,MACJ,KAAK,EACDnsC,EAAQ0xC,gBAAkBluB,EAAOorB,OACjC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXuxC,EAAU5E,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCqF,EAAU3E,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAmB,MAAfA,EAAQwxC,KAAexxC,EAAQoI,eAAe,OAAQ,CACtD,IAAKuxB,MAAMuV,QAAQlvC,EAAQwxC,KACvB,MAAO,sBACX,IAAK,IAAIpxB,EAAI,EAAGA,EAAIpgB,EAAQwxC,IAAI9uB,SAAUtC,EAAG,CACzC,IAAIxgB,EAAQisC,EAAMyF,SAAS1E,OAAO5sC,EAAQwxC,IAAIpxB,IAC9C,GAAIxgB,EACA,MAAO,OAASA,GAG5B,OAA4B,MAAxBI,EAAQyxC,cAAwBzxC,EAAQoI,eAAe,kBAClDwjC,EAAMiB,SAAS7sC,EAAQyxC,cACjB,gCACgB,MAA3BzxC,EAAQ0xC,iBAA2B1xC,EAAQoI,eAAe,oBACnB,mBAA5BpI,EAAQ0xC,gBACR,oCACR,MAWXH,EAAU9qB,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAM0F,UACxB,OAAOzE,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM0F,UACxB,GAAIzE,EAAO0E,IAAK,CACZ,IAAK7X,MAAMuV,QAAQpC,EAAO0E,KACtB,MAAM1D,UAAU,kCACpB9tC,EAAQwxC,IAAM,GACd,IAAK,IAAIpxB,EAAI,EAAGA,EAAI0sB,EAAO0E,IAAI9uB,SAAUtC,EAAG,CACxC,GAA6B,kBAAlB0sB,EAAO0E,IAAIpxB,GAClB,MAAM0tB,UAAU,mCACpB9tC,EAAQwxC,IAAIpxB,GAAKyrB,EAAMyF,SAAS7qB,WAAWqmB,EAAO0E,IAAIpxB,KAO9D,OAJ2B,MAAvB0sB,EAAO2E,eACPzxC,EAAQyxC,aAAe1E,OAAOD,EAAO2E,eACX,MAA1B3E,EAAO4E,kBACP1xC,EAAQ0xC,gBAAkBvd,QAAQ2Y,EAAO4E,kBACtC1xC,GAYXuxC,EAAUvE,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAOb,IANIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO0E,IAAM,IACbvE,EAAQC,WACRJ,EAAO2E,aAAe,GACtB3E,EAAO4E,iBAAkB,GAEzB1xC,EAAQwxC,KAAOxxC,EAAQwxC,IAAI9uB,OAAQ,CACnCoqB,EAAO0E,IAAM,GACb,IAAK,IAAIpC,EAAI,EAAGA,EAAIpvC,EAAQwxC,IAAI9uB,SAAU0sB,EACtCtC,EAAO0E,IAAIpC,GAAKvD,EAAMyF,SAAStE,SAAShtC,EAAQwxC,IAAIpC,GAAInC,GAMhE,OAJ4B,MAAxBjtC,EAAQyxC,cAAwBzxC,EAAQoI,eAAe,kBACvD0kC,EAAO2E,aAAezxC,EAAQyxC,cACH,MAA3BzxC,EAAQ0xC,iBAA2B1xC,EAAQoI,eAAe,qBAC1D0kC,EAAO4E,gBAAkB1xC,EAAQ0xC,iBAC9B5E,GAUXyE,EAAUxF,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDgE,EA3PiC,GA8Pd1F,EAAM8F,eAAkB,WAiBlD,SAASA,EAAe7F,GAEpB,GADAttC,KAAKuF,OAAS,GACV+nC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAuLhD,OA9KAuxB,EAAe5F,UAAUhoC,OAAS6nC,EAAMoD,WAUxC2C,EAAexzB,OAAS,SAAgB2tB,GACpC,OAAO,IAAI6F,EAAe7F,IAY9B6F,EAAenwB,OAAS,SAAgBxhB,EAASgsC,GAG7C,GAFKA,IACDA,EAASL,EAAQxtB,UACC,MAAlBne,EAAQ+D,QAAkB/D,EAAQ+D,OAAO2e,OACzC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQ+D,OAAO2e,SAAUtC,EACzCyrB,EAAM0F,UAAU/vB,OAAOxhB,EAAQ+D,OAAOqc,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACnG,OAAON,GAYX2F,EAAetF,gBAAkB,SAAyBrsC,EAASgsC,GAC/D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCqF,EAAe30B,OAAS,SAAgBwG,EAAQd,GACtCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM8F,eAChFnuB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQ+D,QAAU/D,EAAQ+D,OAAO2e,SACnC1iB,EAAQ+D,OAAS,IACrB/D,EAAQ+D,OAAOP,KAAKqoC,EAAM0F,UAAUv0B,OAAOwG,EAAQA,EAAO0oB,WAC1D,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2xC,EAAehF,gBAAkB,SAAyBnpB,GAGtD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCyF,EAAe/E,OAAS,SAAgB5sC,GACpC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAsB,MAAlBA,EAAQ+D,QAAkB/D,EAAQoI,eAAe,UAAW,CAC5D,IAAKuxB,MAAMuV,QAAQlvC,EAAQ+D,QACvB,MAAO,yBACX,IAAK,IAAIqc,EAAI,EAAGA,EAAIpgB,EAAQ+D,OAAO2e,SAAUtC,EAAG,CAC5C,IAAIxgB,EAAQisC,EAAM0F,UAAU3E,OAAO5sC,EAAQ+D,OAAOqc,IAClD,GAAIxgB,EACA,MAAO,UAAYA,GAG/B,OAAO,MAWX+xC,EAAelrB,WAAa,SAAoBqmB,GAC5C,GAAIA,aAAkBjB,EAAM8F,eACxB,OAAO7E,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM8F,eACxB,GAAI7E,EAAO/oC,OAAQ,CACf,IAAK41B,MAAMuV,QAAQpC,EAAO/oC,QACtB,MAAM+pC,UAAU,0CACpB9tC,EAAQ+D,OAAS,GACjB,IAAK,IAAIqc,EAAI,EAAGA,EAAI0sB,EAAO/oC,OAAO2e,SAAUtC,EAAG,CAC3C,GAAgC,kBAArB0sB,EAAO/oC,OAAOqc,GACrB,MAAM0tB,UAAU,2CACpB9tC,EAAQ+D,OAAOqc,GAAKyrB,EAAM0F,UAAU9qB,WAAWqmB,EAAO/oC,OAAOqc,KAGrE,OAAOpgB,GAYX2xC,EAAe3E,SAAW,SAAkBhtC,EAASitC,GAC5CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO/oC,OAAS,IAChB/D,EAAQ+D,QAAU/D,EAAQ+D,OAAO2e,OAAQ,CACzCoqB,EAAO/oC,OAAS,GAChB,IAAK,IAAIqrC,EAAI,EAAGA,EAAIpvC,EAAQ+D,OAAO2e,SAAU0sB,EACzCtC,EAAO/oC,OAAOqrC,GAAKvD,EAAM0F,UAAUvE,SAAShtC,EAAQ+D,OAAOqrC,GAAInC,GAEvE,OAAOH,GAUX6E,EAAe5F,UAAUsB,OAAS,WAC9B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDoE,EA7M2C,GAgN9B9F,EAAMsE,SAAY,WAqBtC,SAASA,EAASrE,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4ChD,IAAIouB,EAmRJ,OAtTA2B,EAASpE,UAAU1S,QAAU,KAQ7B8W,EAASpE,UAAUzS,QAAU,KAQ7B6W,EAASpE,UAAUxS,OAAS,KAQ5B4W,EAASpE,UAAUvS,UAAY,KAQ/B2W,EAASpE,UAAUtS,WAAa,KAWhCtN,OAAOsiB,eAAe0B,EAASpE,UAAW,OAAQ,CAC9CltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,UAAW,UAAW,SAAU,YAAa,eACpF5lC,IAAKgjC,EAAM+C,YAAYH,KAW3B2B,EAAShyB,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIqE,EAASrE,IAYxBqE,EAAS3uB,OAAS,SAAgBxhB,EAASgsC,GAavC,OAZKA,IACDA,EAASL,EAAQxtB,UACE,MAAnBne,EAAQq5B,SAAmBlN,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/D6rC,EAAMrlB,YAAYhF,OAAOxhB,EAAQq5B,QAAS2S,EAAOE,OAA8B,IAAI0B,QAAQtB,SACxE,MAAnBtsC,EAAQs5B,SAAmBnN,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/D6rC,EAAMqF,YAAY1vB,OAAOxhB,EAAQs5B,QAAS0S,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzE,MAAlBtsC,EAAQu5B,QAAkBpN,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9D6rC,EAAMoF,WAAWzvB,OAAOxhB,EAAQu5B,OAAQyS,EAAOE,OAA8B,IAAI0B,QAAQtB,SACpE,MAArBtsC,EAAQw5B,WAAqBrN,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAMoF,WAAWzvB,OAAOxhB,EAAQw5B,UAAWwS,EAAOE,OAA8B,IAAI0B,QAAQtB,SACtE,MAAtBtsC,EAAQy5B,YAAsBtN,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClE6rC,EAAMoF,WAAWzvB,OAAOxhB,EAAQy5B,WAAYuS,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC1FN,GAYXmE,EAAS9D,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC6D,EAASnzB,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMsE,SAChF3sB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQq5B,QAAUwS,EAAMrlB,YAAYxJ,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,EACDlsC,EAAQs5B,QAAUuS,EAAMqF,YAAYl0B,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,EACDlsC,EAAQu5B,OAASsS,EAAMoF,WAAWj0B,OAAOwG,EAAQA,EAAO0oB,UACxD,MACJ,KAAK,EACDlsC,EAAQw5B,UAAYqS,EAAMoF,WAAWj0B,OAAOwG,EAAQA,EAAO0oB,UAC3D,MACJ,KAAK,EACDlsC,EAAQy5B,WAAaoS,EAAMoF,WAAWj0B,OAAOwG,EAAQA,EAAO0oB,UAC5D,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXmwC,EAASxD,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCiE,EAASvD,OAAS,SAAgB5sC,GAC9B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAAuB,MAAnB9rC,EAAQq5B,SAAmBr5B,EAAQoI,eAAe,WAAY,CAC9D0jC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMrlB,YAAYomB,OAAO5sC,EAAQq5B,SAC7C,GAAIz5B,EACA,MAAO,WAAaA,EAGhC,GAAuB,MAAnBI,EAAQs5B,SAAmBt5B,EAAQoI,eAAe,WAAY,CAC9D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMqF,YAAYtE,OAAO5sC,EAAQs5B,SAC7C,GAAI15B,EACA,MAAO,WAAaA,EAGhC,GAAsB,MAAlBI,EAAQu5B,QAAkBv5B,EAAQoI,eAAe,UAAW,CAC5D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMoF,WAAWrE,OAAO5sC,EAAQu5B,QAC5C,GAAI35B,EACA,MAAO,UAAYA,EAG/B,GAAyB,MAArBI,EAAQw5B,WAAqBx5B,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMoF,WAAWrE,OAAO5sC,EAAQw5B,WAC5C,GAAI55B,EACA,MAAO,aAAeA,EAGlC,GAA0B,MAAtBI,EAAQy5B,YAAsBz5B,EAAQoI,eAAe,cAAe,CACpE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMoF,WAAWrE,OAAO5sC,EAAQy5B,YAC5C,GAAI75B,EACA,MAAO,cAAgBA,EAGnC,OAAO,MAWXuwC,EAAS1pB,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMsE,SACxB,OAAOrD,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMsE,SACxB,GAAsB,MAAlBrD,EAAOzT,QAAiB,CACxB,GAA8B,kBAAnByT,EAAOzT,QACd,MAAMyU,UAAU,sCACpB9tC,EAAQq5B,QAAUwS,EAAMrlB,YAAYC,WAAWqmB,EAAOzT,SAE1D,GAAsB,MAAlByT,EAAOxT,QAAiB,CACxB,GAA8B,kBAAnBwT,EAAOxT,QACd,MAAMwU,UAAU,sCACpB9tC,EAAQs5B,QAAUuS,EAAMqF,YAAYzqB,WAAWqmB,EAAOxT,SAE1D,GAAqB,MAAjBwT,EAAOvT,OAAgB,CACvB,GAA6B,kBAAlBuT,EAAOvT,OACd,MAAMuU,UAAU,qCACpB9tC,EAAQu5B,OAASsS,EAAMoF,WAAWxqB,WAAWqmB,EAAOvT,QAExD,GAAwB,MAApBuT,EAAOtT,UAAmB,CAC1B,GAAgC,kBAArBsT,EAAOtT,UACd,MAAMsU,UAAU,wCACpB9tC,EAAQw5B,UAAYqS,EAAMoF,WAAWxqB,WAAWqmB,EAAOtT,WAE3D,GAAyB,MAArBsT,EAAOrT,WAAoB,CAC3B,GAAiC,kBAAtBqT,EAAOrT,WACd,MAAMqU,UAAU,yCACpB9tC,EAAQy5B,WAAaoS,EAAMoF,WAAWxqB,WAAWqmB,EAAOrT,YAE5D,OAAOz5B,GAYXmwC,EAASnD,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GA0Bb,OAzBuB,MAAnB9sC,EAAQq5B,SAAmBr5B,EAAQoI,eAAe,aAClD0kC,EAAOzT,QAAUwS,EAAMrlB,YAAYwmB,SAAShtC,EAAQq5B,QAAS4T,GACzDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,YAEC,MAAnBgB,EAAQs5B,SAAmBt5B,EAAQoI,eAAe,aAClD0kC,EAAOxT,QAAUuS,EAAMqF,YAAYlE,SAAShtC,EAAQs5B,QAAS2T,GACzDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,YAEA,MAAlBgB,EAAQu5B,QAAkBv5B,EAAQoI,eAAe,YACjD0kC,EAAOvT,OAASsS,EAAMoF,WAAWjE,SAAShtC,EAAQu5B,OAAQ0T,GACtDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,WAEG,MAArBgB,EAAQw5B,WAAqBx5B,EAAQoI,eAAe,eACpD0kC,EAAOtT,UAAYqS,EAAMoF,WAAWjE,SAAShtC,EAAQw5B,UAAWyT,GAC5DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEI,MAAtBgB,EAAQy5B,YAAsBz5B,EAAQoI,eAAe,gBACrD0kC,EAAOrT,WAAaoS,EAAMoF,WAAWjE,SAAShtC,EAAQy5B,WAAYwT,GAC9DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEf8tC,GAUXqD,EAASpE,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD4C,EAxV+B,GA2VrBtE,EAAMlpC,MAAS,WAiBhC,SAASA,EAAMmpC,GAEX,GADAttC,KAAKuE,KAAO,GACR+oC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAuLhD,OA9KAzd,EAAMopC,UAAUhpC,KAAO6oC,EAAMoD,WAU7BrsC,EAAMwb,OAAS,SAAgB2tB,GAC3B,OAAO,IAAInpC,EAAMmpC,IAYrBnpC,EAAM6e,OAAS,SAAgBxhB,EAASgsC,GAGpC,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ+C,MAAgB/C,EAAQ+C,KAAK2f,OACrC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQ+C,KAAK2f,SAAUtC,EACvCyrB,EAAMsE,SAAS3uB,OAAOxhB,EAAQ+C,KAAKqd,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAChG,OAAON,GAYXrpC,EAAM0pC,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC3pC,EAAMqa,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMlpC,MAChF6gB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQ+C,MAAQ/C,EAAQ+C,KAAK2f,SAC/B1iB,EAAQ+C,KAAO,IACnB/C,EAAQ+C,KAAKS,KAAKqoC,EAAMsE,SAASnzB,OAAOwG,EAAQA,EAAO0oB,WACvD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2C,EAAMgqC,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCvpC,EAAMiqC,OAAS,SAAgB5sC,GAC3B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQ+C,MAAgB/C,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQ+C,MACvB,MAAO,uBACX,IAAK,IAAIqd,EAAI,EAAGA,EAAIpgB,EAAQ+C,KAAK2f,SAAUtC,EAAG,CAC1C,IAAIxgB,EAAQisC,EAAMsE,SAASvD,OAAO5sC,EAAQ+C,KAAKqd,IAC/C,GAAIxgB,EACA,MAAO,QAAUA,GAG7B,OAAO,MAWX+C,EAAM8jB,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAMlpC,MACxB,OAAOmqC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMlpC,MACxB,GAAImqC,EAAO/pC,KAAM,CACb,IAAK42B,MAAMuV,QAAQpC,EAAO/pC,MACtB,MAAM+qC,UAAU,+BACpB9tC,EAAQ+C,KAAO,GACf,IAAK,IAAIqd,EAAI,EAAGA,EAAI0sB,EAAO/pC,KAAK2f,SAAUtC,EAAG,CACzC,GAA8B,kBAAnB0sB,EAAO/pC,KAAKqd,GACnB,MAAM0tB,UAAU,gCACpB9tC,EAAQ+C,KAAKqd,GAAKyrB,EAAMsE,SAAS1pB,WAAWqmB,EAAO/pC,KAAKqd,KAGhE,OAAOpgB,GAYX2C,EAAMqqC,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO/pC,KAAO,IACd/C,EAAQ+C,MAAQ/C,EAAQ+C,KAAK2f,OAAQ,CACrCoqB,EAAO/pC,KAAO,GACd,IAAK,IAAIqsC,EAAI,EAAGA,EAAIpvC,EAAQ+C,KAAK2f,SAAU0sB,EACvCtC,EAAO/pC,KAAKqsC,GAAKvD,EAAMsE,SAASnD,SAAShtC,EAAQ+C,KAAKqsC,GAAInC,GAElE,OAAOH,GAUXnqC,EAAMopC,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD5qC,EA7MyB,GAgNVkpC,EAAM8D,WAAc,WAiB1C,SAASA,EAAW7D,GAEhB,GADAttC,KAAKuE,KAAO,GACR+oC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAuLhD,OA9KAuvB,EAAW5D,UAAUhpC,KAAO6oC,EAAMoD,WAUlCW,EAAWxxB,OAAS,SAAgB2tB,GAChC,OAAO,IAAI6D,EAAW7D,IAY1B6D,EAAWnuB,OAAS,SAAgBxhB,EAASgsC,GAGzC,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ+C,MAAgB/C,EAAQ+C,KAAK2f,OACrC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQ+C,KAAK2f,SAAUtC,EACvCyrB,EAAM8F,eAAenwB,OAAOxhB,EAAQ+C,KAAKqd,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACtG,OAAON,GAYX2D,EAAWtD,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCqD,EAAW3yB,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM8D,WAChFnsB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQ+C,MAAQ/C,EAAQ+C,KAAK2f,SAC/B1iB,EAAQ+C,KAAO,IACnB/C,EAAQ+C,KAAKS,KAAKqoC,EAAM8F,eAAe30B,OAAOwG,EAAQA,EAAO0oB,WAC7D,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2vC,EAAWhD,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCyD,EAAW/C,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQ+C,MAAgB/C,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQ+C,MACvB,MAAO,uBACX,IAAK,IAAIqd,EAAI,EAAGA,EAAIpgB,EAAQ+C,KAAK2f,SAAUtC,EAAG,CAC1C,IAAIxgB,EAAQisC,EAAM8F,eAAe/E,OAAO5sC,EAAQ+C,KAAKqd,IACrD,GAAIxgB,EACA,MAAO,QAAUA,GAG7B,OAAO,MAWX+vC,EAAWlpB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAM8D,WACxB,OAAO7C,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM8D,WACxB,GAAI7C,EAAO/pC,KAAM,CACb,IAAK42B,MAAMuV,QAAQpC,EAAO/pC,MACtB,MAAM+qC,UAAU,oCACpB9tC,EAAQ+C,KAAO,GACf,IAAK,IAAIqd,EAAI,EAAGA,EAAI0sB,EAAO/pC,KAAK2f,SAAUtC,EAAG,CACzC,GAA8B,kBAAnB0sB,EAAO/pC,KAAKqd,GACnB,MAAM0tB,UAAU,qCACpB9tC,EAAQ+C,KAAKqd,GAAKyrB,EAAM8F,eAAelrB,WAAWqmB,EAAO/pC,KAAKqd,KAGtE,OAAOpgB,GAYX2vC,EAAW3C,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO/pC,KAAO,IACd/C,EAAQ+C,MAAQ/C,EAAQ+C,KAAK2f,OAAQ,CACrCoqB,EAAO/pC,KAAO,GACd,IAAK,IAAIqsC,EAAI,EAAGA,EAAIpvC,EAAQ+C,KAAK2f,SAAU0sB,EACvCtC,EAAO/pC,KAAKqsC,GAAKvD,EAAM8F,eAAe3E,SAAShtC,EAAQ+C,KAAKqsC,GAAInC,GAExE,OAAOH,GAUX6C,EAAW5D,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDoC,EA7MmC,GAgNrB9D,EAAMlhC,UAAa,WAsBxC,SAASA,EAAUmhC,GAEf,GADAttC,KAAA,QAAkB,GACdstC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA6RhD,OApRAzV,EAAUohC,UAAUt2B,GAAK,GAQzB9K,EAAUohC,UAAUp2B,MAAQ,GAQ5BhL,EAAUohC,UAAV,QAAiCH,EAAMoD,WAQvCrkC,EAAUohC,UAAUx/B,IAAM,GAQ1B5B,EAAUohC,UAAUl5B,IAAM,GAQ1BlI,EAAUohC,UAAU6F,SAAU,EAU9BjnC,EAAUwT,OAAS,SAAgB2tB,GAC/B,OAAO,IAAInhC,EAAUmhC,IAYzBnhC,EAAU6W,OAAS,SAAgBxhB,EAASgsC,GAOxC,GANKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBA,EAAO,QAAY0iB,OACjD,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAO,QAAY0iB,SAAUtC,EAC7C4rB,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAO,QAAYogB,IAO3E,OANmB,MAAfpgB,EAAQuM,KAAe4f,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQuM,KACzC,MAAfvM,EAAQ6S,KAAesZ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ6S,KACrC,MAAnB7S,EAAQ4xC,SAAmBzlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ4xC,SACnD5F,GAYXrhC,EAAU0hC,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC3hC,EAAUqS,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMlhC,UAChF6Y,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACKnsC,EAAO,SAAeA,EAAO,QAAY0iB,SAC3C1iB,EAAO,QAAc,IACzBA,EAAO,QAAYwD,KAAKggB,EAAO2oB,UAC/B,MACJ,KAAK,EACDnsC,EAAQuM,IAAMiX,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQ6S,IAAM2Q,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQ4xC,QAAUpuB,EAAOorB,OACzB,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2K,EAAUgiC,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCvhC,EAAUiiC,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAA0B,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,WAAY,CACjE,IAAKuxB,MAAMuV,QAAQlvC,EAAO,SACtB,MAAO,0BACX,IAAK,IAAIogB,EAAI,EAAGA,EAAIpgB,EAAO,QAAY0iB,SAAUtC,EAC7C,IAAKwrB,EAAMiB,SAAS7sC,EAAO,QAAYogB,IACnC,MAAO,6BAEnB,OAAmB,MAAfpgB,EAAQuM,KAAevM,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQuM,KACjB,uBACI,MAAfvM,EAAQ6S,KAAe7S,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQ6S,KACjB,uBACQ,MAAnB7S,EAAQ4xC,SAAmB5xC,EAAQoI,eAAe,YACnB,mBAApBpI,EAAQ4xC,QACR,4BACR,MAWXjnC,EAAU8b,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAMlhC,UACxB,OAAOmiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMlhC,UAKxB,GAJiB,MAAbmiC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QAC9Bm3B,EAAM,QAAa,CACnB,IAAKnT,MAAMuV,QAAQpC,EAAM,SACrB,MAAMgB,UAAU,sCACpB9tC,EAAO,QAAc,GACrB,IAAK,IAAIogB,EAAI,EAAGA,EAAI0sB,EAAM,QAAYpqB,SAAUtC,EAC5CpgB,EAAO,QAAYogB,GAAK2sB,OAAOD,EAAM,QAAY1sB,IAQzD,OANkB,MAAd0sB,EAAOvgC,MACPvM,EAAQuM,IAAMwgC,OAAOD,EAAOvgC,MACd,MAAdugC,EAAOj6B,MACP7S,EAAQ6S,IAAMk6B,OAAOD,EAAOj6B,MACV,MAAlBi6B,EAAO8E,UACP5xC,EAAQ4xC,QAAUzd,QAAQ2Y,EAAO8E,UAC9B5xC,GAYX2K,EAAUqiC,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAcb,IAbIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAM,QAAc,IACpBG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAOvgC,IAAM,GACbugC,EAAOj6B,IAAM,GACbi6B,EAAO8E,SAAU,GAEH,MAAd5xC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACvB3V,EAAO,SAAeA,EAAO,QAAY0iB,OAAQ,CACjDoqB,EAAM,QAAc,GACpB,IAAK,IAAIsC,EAAI,EAAGA,EAAIpvC,EAAO,QAAY0iB,SAAU0sB,EAC7CtC,EAAM,QAAYsC,GAAKpvC,EAAO,QAAYovC,GAQlD,OANmB,MAAfpvC,EAAQuM,KAAevM,EAAQoI,eAAe,SAC9C0kC,EAAOvgC,IAAMvM,EAAQuM,KACN,MAAfvM,EAAQ6S,KAAe7S,EAAQoI,eAAe,SAC9C0kC,EAAOj6B,IAAM7S,EAAQ6S,KACF,MAAnB7S,EAAQ4xC,SAAmB5xC,EAAQoI,eAAe,aAClD0kC,EAAO8E,QAAU5xC,EAAQ4xC,SACtB9E,GAUXniC,EAAUohC,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD5iC,EAxTiC,GA2TjBkhC,EAAM9hC,YAAe,WAoB5C,SAASA,EAAY+hC,GAEjB,GADAttC,KAAKqzC,OAAS,GACV/F,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA6PhD,OApPArW,EAAYgiC,UAAU1mC,KAAO,KAQ7B0E,EAAYgiC,UAAU+F,KAAO,GAQ7B/nC,EAAYgiC,UAAU8F,OAASjG,EAAMoD,WAQrCjlC,EAAYgiC,UAAUuD,mBAAoB,EAU1CvlC,EAAYoU,OAAS,SAAgB2tB,GACjC,OAAO,IAAI/hC,EAAY+hC,IAY3B/hC,EAAYyX,OAAS,SAAgBxhB,EAASgsC,GAO1C,GANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAM/hC,UAAU0X,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACtE,MAAhBtsC,EAAQ8xC,MAAgB3lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ8xC,MACtC,MAAlB9xC,EAAQ6xC,QAAkB7xC,EAAQ6xC,OAAOnvB,OACzC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQ6xC,OAAOnvB,SAAUtC,EACzCyrB,EAAMkG,YAAYvwB,OAAOxhB,EAAQ6xC,OAAOzxB,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAGrG,OAFiC,MAA7BtsC,EAAQsvC,mBAA6BnjB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQsvC,mBACnDtD,GAYXjiC,EAAYsiC,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCviC,EAAYiT,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM9hC,YAChFyZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAM/hC,UAAUkT,OAAOwG,EAAQA,EAAO0oB,UACrD,MACJ,KAAK,EACDlsC,EAAQ8xC,KAAOtuB,EAAO2oB,SACtB,MACJ,KAAK,EACKnsC,EAAQ6xC,QAAU7xC,EAAQ6xC,OAAOnvB,SACnC1iB,EAAQ6xC,OAAS,IACrB7xC,EAAQ6xC,OAAOruC,KAAKqoC,EAAMkG,YAAY/0B,OAAOwG,EAAQA,EAAO0oB,WAC5D,MACJ,KAAK,EACDlsC,EAAQsvC,kBAAoB9rB,EAAOorB,OACnC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX+J,EAAY4iC,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCniC,EAAY6iC,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAM/hC,UAAU8iC,OAAO5sC,EAAQqF,MAC3C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,GAAoB,MAAhBI,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ8xC,MACxB,MAAO,wBACf,GAAsB,MAAlB9xC,EAAQ6xC,QAAkB7xC,EAAQoI,eAAe,UAAW,CAC5D,IAAKuxB,MAAMuV,QAAQlvC,EAAQ6xC,QACvB,MAAO,yBACX,IAAK,IAAIzxB,EAAI,EAAGA,EAAIpgB,EAAQ6xC,OAAOnvB,SAAUtC,EAAG,CAC5C,IAAIxgB,EAAQisC,EAAMkG,YAAYnF,OAAO5sC,EAAQ6xC,OAAOzxB,IACpD,GAAIxgB,EACA,MAAO,UAAYA,GAG/B,OAAiC,MAA7BI,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,sBACnB,mBAA9BpI,EAAQsvC,kBACR,sCACR,MAWXvlC,EAAY0c,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAM9hC,YACxB,OAAO+iC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM9hC,YACxB,GAAmB,MAAf+iC,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,sCACpB9tC,EAAQqF,KAAOwmC,EAAM/hC,UAAU2c,WAAWqmB,EAAOznC,MAIrD,GAFmB,MAAfynC,EAAOgF,OACP9xC,EAAQ8xC,KAAO/E,OAAOD,EAAOgF,OAC7BhF,EAAO+E,OAAQ,CACf,IAAKlY,MAAMuV,QAAQpC,EAAO+E,QACtB,MAAM/D,UAAU,uCACpB9tC,EAAQ6xC,OAAS,GACjB,IAAK,IAAIzxB,EAAI,EAAGA,EAAI0sB,EAAO+E,OAAOnvB,SAAUtC,EAAG,CAC3C,GAAgC,kBAArB0sB,EAAO+E,OAAOzxB,GACrB,MAAM0tB,UAAU,wCACpB9tC,EAAQ6xC,OAAOzxB,GAAKyrB,EAAMkG,YAAYtrB,WAAWqmB,EAAO+E,OAAOzxB,KAKvE,OAFgC,MAA5B0sB,EAAOwC,oBACPtvC,EAAQsvC,kBAAoBnb,QAAQ2Y,EAAOwC,oBACxCtvC,GAYX+J,EAAYijC,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,IAXIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO+E,OAAS,IAChB5E,EAAQC,WACRJ,EAAOznC,KAAO,KACdynC,EAAOgF,KAAO,GACdhF,EAAOwC,mBAAoB,GAEX,MAAhBtvC,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAM/hC,UAAUkjC,SAAShtC,EAAQqF,KAAM4nC,IACrC,MAAhBjtC,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC/C0kC,EAAOgF,KAAO9xC,EAAQ8xC,MACtB9xC,EAAQ6xC,QAAU7xC,EAAQ6xC,OAAOnvB,OAAQ,CACzCoqB,EAAO+E,OAAS,GAChB,IAAK,IAAIzC,EAAI,EAAGA,EAAIpvC,EAAQ6xC,OAAOnvB,SAAU0sB,EACzCtC,EAAO+E,OAAOzC,GAAKvD,EAAMkG,YAAY/E,SAAShtC,EAAQ6xC,OAAOzC,GAAInC,GAIzE,OAFiC,MAA7BjtC,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,uBAC5D0kC,EAAOwC,kBAAoBtvC,EAAQsvC,mBAChCxC,GAUX/iC,EAAYgiC,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDxjC,EAtRqC,GAyRrB8hC,EAAMkG,YAAe,WAkB5C,SAASA,EAAYjG,GACjB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8LhD,OArLA2xB,EAAYhG,UAAU1mC,KAAO,KAQ7B0sC,EAAYhG,UAAU+F,KAAO,GAU7BC,EAAY5zB,OAAS,SAAgB2tB,GACjC,OAAO,IAAIiG,EAAYjG,IAY3BiG,EAAYvwB,OAAS,SAAgBxhB,EAASgsC,GAO1C,OANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAM/hC,UAAU0X,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACtE,MAAhBtsC,EAAQ8xC,MAAgB3lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ8xC,MACrD9F,GAYX+F,EAAY1F,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCyF,EAAY/0B,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMkG,YAChFvuB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqF,KAAOwmC,EAAM/hC,UAAUkT,OAAOwG,EAAQA,EAAO0oB,UACrD,MACJ,KAAK,EACDlsC,EAAQ8xC,KAAOtuB,EAAO2oB,SACtB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX+xC,EAAYpF,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC6F,EAAYnF,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAM/hC,UAAU8iC,OAAO5sC,EAAQqF,MAC3C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAoB,MAAhBI,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ8xC,MACjB,wBACR,MAWXC,EAAYtrB,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMkG,YACxB,OAAOjF,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMkG,YACxB,GAAmB,MAAfjF,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,sCACpB9tC,EAAQqF,KAAOwmC,EAAM/hC,UAAU2c,WAAWqmB,EAAOznC,MAIrD,OAFmB,MAAfynC,EAAOgF,OACP9xC,EAAQ8xC,KAAO/E,OAAOD,EAAOgF,OAC1B9xC,GAYX+xC,EAAY/E,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOznC,KAAO,KACdynC,EAAOgF,KAAO,IAEE,MAAhB9xC,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAM/hC,UAAUkjC,SAAShtC,EAAQqF,KAAM4nC,IACrC,MAAhBjtC,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC/C0kC,EAAOgF,KAAO9xC,EAAQ8xC,MACnBhF,GAUXiF,EAAYhG,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDwE,EApNqC,GAuNjBlG,EAAM7hC,gBAAmB,WAmBpD,SAASA,EAAgB8hC,GACrB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8MhD,OArMApW,EAAgB+hC,UAAUv+B,KAAO,GAQjCxD,EAAgB+hC,UAAUl2B,QAAU,GAQpC7L,EAAgB+hC,UAAUuD,mBAAoB,EAU9CtlC,EAAgBmU,OAAS,SAAgB2tB,GACrC,OAAO,IAAI9hC,EAAgB8hC,IAY/B9hC,EAAgBwX,OAAS,SAAgBxhB,EAASgsC,GAS9C,OARKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQwN,MAAgB2e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQwN,MACrC,MAAnBxN,EAAQ6V,SAAmBsW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ6V,SAC3B,MAA7B7V,EAAQsvC,mBAA6BnjB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQsvC,mBACnDtD,GAYXhiC,EAAgBqiC,gBAAkB,SAAyBrsC,EAASgsC,GAChE,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCtiC,EAAgBgT,OAAS,SAAgBwG,EAAQd,GACvCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM7hC,gBAChFwZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQwN,KAAOgW,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQ6V,QAAU2N,EAAO2oB,SACzB,MACJ,KAAK,EACDnsC,EAAQsvC,kBAAoB9rB,EAAOorB,OACnC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXgK,EAAgB2iC,gBAAkB,SAAyBnpB,GAGvD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCliC,EAAgB4iC,OAAS,SAAgB5sC,GACrC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQwN,MAAgBxN,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQwN,MACjB,wBACQ,MAAnBxN,EAAQ6V,SAAmB7V,EAAQoI,eAAe,aAC7CwjC,EAAMiB,SAAS7sC,EAAQ6V,SACjB,2BACkB,MAA7B7V,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,sBACnB,mBAA9BpI,EAAQsvC,kBACR,sCACR,MAWXtlC,EAAgByc,WAAa,SAAoBqmB,GAC7C,GAAIA,aAAkBjB,EAAM7hC,gBACxB,OAAO8iC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM7hC,gBAOxB,OANmB,MAAf8iC,EAAOt/B,OACPxN,EAAQwN,KAAOu/B,OAAOD,EAAOt/B,OACX,MAAlBs/B,EAAOj3B,UACP7V,EAAQ6V,QAAUk3B,OAAOD,EAAOj3B,UACJ,MAA5Bi3B,EAAOwC,oBACPtvC,EAAQsvC,kBAAoBnb,QAAQ2Y,EAAOwC,oBACxCtvC,GAYXgK,EAAgBgjC,SAAW,SAAkBhtC,EAASitC,GAC7CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOt/B,KAAO,GACds/B,EAAOj3B,QAAU,GACjBi3B,EAAOwC,mBAAoB,GAEX,MAAhBtvC,EAAQwN,MAAgBxN,EAAQoI,eAAe,UAC/C0kC,EAAOt/B,KAAOxN,EAAQwN,MACH,MAAnBxN,EAAQ6V,SAAmB7V,EAAQoI,eAAe,aAClD0kC,EAAOj3B,QAAU7V,EAAQ6V,SACI,MAA7B7V,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,uBAC5D0kC,EAAOwC,kBAAoBtvC,EAAQsvC,mBAChCxC,GAUX9iC,EAAgB+hC,UAAUsB,OAAS,WAC/B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDvjC,EArO6C,GAwOnC6hC,EAAMniB,MAAS,WAmBhC,SAASA,EAAMoiB,GACX,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4BhD,IAAIouB,EA2NJ,OA9OA9kB,EAAMqiB,UAAU3hB,WAAa,KAQ7BV,EAAMqiB,UAAUlhB,UAAW,EAQ3BnB,EAAMqiB,UAAU/gB,QAAU,KAW1BmB,OAAOsiB,eAAe/kB,EAAMqiB,UAAW,OAAQ,CAC3CltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,aAAc,WAAY,YACjE5lC,IAAKgjC,EAAM+C,YAAYH,KAW3B9kB,EAAMvL,OAAS,SAAgB2tB,GAC3B,OAAO,IAAIpiB,EAAMoiB,IAYrBpiB,EAAMlI,OAAS,SAAgBxhB,EAASgsC,GASpC,OARKA,IACDA,EAASL,EAAQxtB,UACK,MAAtBne,EAAQoqB,YAAsB+B,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClE6rC,EAAMmG,QAAQxwB,OAAOxhB,EAAQoqB,WAAY4hB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACtE,MAApBtsC,EAAQ6qB,UAAoBsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ6qB,UACnC,MAAnB7qB,EAAQgrB,SAAmBmB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/D6rC,EAAMoG,aAAazwB,OAAOxhB,EAAQgrB,QAASghB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzFN,GAYXtiB,EAAM2iB,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC5iB,EAAM1M,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMniB,MAChFlG,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQoqB,WAAayhB,EAAMmG,QAAQh1B,OAAOwG,EAAQA,EAAO0oB,UACzD,MACJ,KAAK,EACDlsC,EAAQ6qB,SAAWrH,EAAOorB,OAC1B,MACJ,KAAK,EACD5uC,EAAQgrB,QAAU6gB,EAAMoG,aAAaj1B,OAAOwG,EAAQA,EAAO0oB,UAC3D,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0pB,EAAMijB,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCxiB,EAAMkjB,OAAS,SAAgB5sC,GAC3B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAA0B,MAAtB9rC,EAAQoqB,YAAsBpqB,EAAQoI,eAAe,cAAe,CACpE0jC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMmG,QAAQpF,OAAO5sC,EAAQoqB,YACzC,GAAIxqB,EACA,MAAO,cAAgBA,EAGnC,GAAwB,MAApBI,EAAQ6qB,UAAoB7qB,EAAQoI,eAAe,YAAa,CAChE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,EACc,mBAArBgB,EAAQ6qB,SACf,MAAO,6BAEf,GAAuB,MAAnB7qB,EAAQgrB,SAAmBhrB,EAAQoI,eAAe,WAAY,CAC9D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMoG,aAAarF,OAAO5sC,EAAQgrB,SAC9C,GAAIprB,EACA,MAAO,WAAaA,EAGhC,OAAO,MAWX8pB,EAAMjD,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAMniB,MACxB,OAAOojB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMniB,MACxB,GAAyB,MAArBojB,EAAO1iB,WAAoB,CAC3B,GAAiC,kBAAtB0iB,EAAO1iB,WACd,MAAM0jB,UAAU,sCACpB9tC,EAAQoqB,WAAayhB,EAAMmG,QAAQvrB,WAAWqmB,EAAO1iB,YAIzD,GAFuB,MAAnB0iB,EAAOjiB,WACP7qB,EAAQ6qB,SAAWsJ,QAAQ2Y,EAAOjiB,WAChB,MAAlBiiB,EAAO9hB,QAAiB,CACxB,GAA8B,kBAAnB8hB,EAAO9hB,QACd,MAAM8iB,UAAU,mCACpB9tC,EAAQgrB,QAAU6gB,EAAMoG,aAAaxrB,WAAWqmB,EAAO9hB,SAE3D,OAAOhrB,GAYX0pB,EAAMsjB,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAgBb,OAf0B,MAAtB9sC,EAAQoqB,YAAsBpqB,EAAQoI,eAAe,gBACrD0kC,EAAO1iB,WAAayhB,EAAMmG,QAAQhF,SAAShtC,EAAQoqB,WAAY6iB,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEE,MAApBgB,EAAQ6qB,UAAoB7qB,EAAQoI,eAAe,cACnD0kC,EAAOjiB,SAAW7qB,EAAQ6qB,SACtBoiB,EAAQ4B,SACR/B,EAAO9tC,KAAO,aAEC,MAAnBgB,EAAQgrB,SAAmBhrB,EAAQoI,eAAe,aAClD0kC,EAAO9hB,QAAU6gB,EAAMoG,aAAajF,SAAShtC,EAAQgrB,QAASiiB,GAC1DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,YAEf8tC,GAUXpjB,EAAMqiB,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD7jB,EA9QyB,IA81FvB3M,GA7kFY8uB,EAAMttC,UAAa,WAqBxC,SAASA,EAAUutC,GACf,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwPhD,OA/OA7hB,EAAUwtC,UAAUntC,KAAO,GAQ3BL,EAAUwtC,UAAUjtC,OAAS,GAQ7BP,EAAUwtC,UAAUhtC,UAAY,GAQhCR,EAAUwtC,UAAU/sC,KAAO,GAQ3BT,EAAUwtC,UAAU9sC,UAAY,GAUhCV,EAAU4f,OAAS,SAAgB2tB,GAC/B,OAAO,IAAIvtC,EAAUutC,IAYzBvtC,EAAUijB,OAAS,SAAgBxhB,EAASgsC,GAaxC,OAZKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQpB,MAAgButB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQpB,MACtC,MAAlBoB,EAAQlB,QAAkBqtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQlB,QACnC,MAArBkB,EAAQjB,WAAqBotB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQjB,WACxC,MAAhBiB,EAAQhB,MAAgBmtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQhB,MACnC,MAArBgB,EAAQf,WAAqBktB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQf,WACrD+sC,GAYXztC,EAAU8tC,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC/tC,EAAUye,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMttC,UAChFilB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQpB,KAAO4kB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQlB,OAAS0kB,EAAO2oB,SACxB,MACJ,KAAK,EACDnsC,EAAQjB,UAAYykB,EAAO2oB,SAC3B,MACJ,KAAK,EACDnsC,EAAQhB,KAAOwkB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQf,UAAYukB,EAAO2oB,SAC3B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXzB,EAAUouC,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC3tC,EAAUquC,OAAS,SAAgB5sC,GAC/B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQpB,MACjB,wBACO,MAAlBoB,EAAQlB,QAAkBkB,EAAQoI,eAAe,YAC5CwjC,EAAMiB,SAAS7sC,EAAQlB,QACjB,0BACU,MAArBkB,EAAQjB,WAAqBiB,EAAQoI,eAAe,eAC/CwjC,EAAMiB,SAAS7sC,EAAQjB,WACjB,6BACK,MAAhBiB,EAAQhB,MAAgBgB,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQhB,MACjB,wBACU,MAArBgB,EAAQf,WAAqBe,EAAQoI,eAAe,eAC/CwjC,EAAMiB,SAAS7sC,EAAQf,WACjB,6BACR,MAWXV,EAAUkoB,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAMttC,UACxB,OAAOuuC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMttC,UAWxB,OAVmB,MAAfuuC,EAAOluC,OACPoB,EAAQpB,KAAOmuC,OAAOD,EAAOluC,OACZ,MAAjBkuC,EAAOhuC,SACPkB,EAAQlB,OAASiuC,OAAOD,EAAOhuC,SACX,MAApBguC,EAAO/tC,YACPiB,EAAQjB,UAAYguC,OAAOD,EAAO/tC,YACnB,MAAf+tC,EAAO9tC,OACPgB,EAAQhB,KAAO+tC,OAAOD,EAAO9tC,OACT,MAApB8tC,EAAO7tC,YACPe,EAAQf,UAAY8tC,OAAOD,EAAO7tC,YAC/Be,GAYXzB,EAAUyuC,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAkBb,OAjBIG,EAAQC,WACRJ,EAAOluC,KAAO,GACdkuC,EAAOhuC,OAAS,GAChBguC,EAAO/tC,UAAY,GACnB+tC,EAAO9tC,KAAO,GACd8tC,EAAO7tC,UAAY,IAEH,MAAhBe,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC/C0kC,EAAOluC,KAAOoB,EAAQpB,MACJ,MAAlBoB,EAAQlB,QAAkBkB,EAAQoI,eAAe,YACjD0kC,EAAOhuC,OAASkB,EAAQlB,QACH,MAArBkB,EAAQjB,WAAqBiB,EAAQoI,eAAe,eACpD0kC,EAAO/tC,UAAYiB,EAAQjB,WACX,MAAhBiB,EAAQhB,MAAgBgB,EAAQoI,eAAe,UAC/C0kC,EAAO9tC,KAAOgB,EAAQhB,MACD,MAArBgB,EAAQf,WAAqBe,EAAQoI,eAAe,eACpD0kC,EAAO7tC,UAAYe,EAAQf,WACxB6tC,GAUXvuC,EAAUwtC,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDhvC,EAjRiC,GAoRrBstC,EAAMmG,QAAW,WAoDpC,SAASA,EAAQlG,GACb,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAoShD,IAAIouB,EA0hCJ,OArzCAwD,EAAQjG,UAAUt/B,MAAQ,KAQ1BulC,EAAQjG,UAAUn/B,MAAQ,KAQ1BolC,EAAQjG,UAAUl/B,SAAW,KAQ7BmlC,EAAQjG,UAAUj/B,WAAa,KAQ/BklC,EAAQjG,UAAU/9B,OAAS,KAQ3BgkC,EAAQjG,UAAU99B,SAAW,KAQ7B+jC,EAAQjG,UAAU79B,YAAc,KAQhC8jC,EAAQjG,UAAUj9B,kBAAoB,KAQtCkjC,EAAQjG,UAAUh/B,UAAY,KAQ9BilC,EAAQjG,UAAUn+B,MAAQ,KAQ1BokC,EAAQjG,UAAU59B,UAAY,KAQ9B6jC,EAAQjG,UAAU/+B,YAAc,KAQhCglC,EAAQjG,UAAU9+B,gBAAkB,KAQpC+kC,EAAQjG,UAAUhtC,UAAY,KAQ9BizC,EAAQjG,UAAU7+B,MAAQ,KAQ1B8kC,EAAQjG,UAAU5+B,UAAY,KAQ9B6kC,EAAQjG,UAAU3+B,QAAU,KAQ5B4kC,EAAQjG,UAAUx9B,aAAe,KAQjCyjC,EAAQjG,UAAU1+B,cAAgB,KAQlC2kC,EAAQjG,UAAUz+B,OAAS,KAQ3B0kC,EAAQjG,UAAUx+B,KAAO,KAQzBykC,EAAQjG,UAAUv+B,KAAO,KAQzBwkC,EAAQjG,UAAUhrC,SAAW,KAQ7BixC,EAAQjG,UAAUt+B,YAAc,KAQhCukC,EAAQjG,UAAUl9B,YAAc,KAQhCmjC,EAAQjG,UAAUr+B,YAAc,KAQhCskC,EAAQjG,UAAUp+B,SAAW,KAQ7BqkC,EAAQjG,UAAU39B,MAAQ,KAQ1B4jC,EAAQjG,UAAU19B,UAAY,KAQ9B2jC,EAAQjG,UAAUz9B,OAAS,KAQ3B0jC,EAAQjG,UAAUl+B,KAAO,KAQzBmkC,EAAQjG,UAAUr9B,SAAW,KAQ7BsjC,EAAQjG,UAAUp9B,UAAY,KAQ9BqjC,EAAQjG,UAAUn9B,UAAY,KAQ9BojC,EAAQjG,UAAUj+B,cAAgB,KAQlCkkC,EAAQjG,UAAUh+B,MAAQ,KAW1Boe,OAAOsiB,eAAeuD,EAAQjG,UAAW,OAAQ,CAC7CltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,QAAS,QAAS,WAAY,aAAc,SAAU,WAAY,cAAe,oBAAqB,YAAa,QAAS,YAAa,cAAe,kBAAmB,YAAa,QAAS,YAAa,UAAW,eAAgB,gBAAiB,SAAU,OAAQ,OAAQ,WAAY,cAAe,cAAe,cAAe,WAAY,QAAS,YAAa,SAAU,OAAQ,WAAY,YAAa,YAAa,gBAAiB,UAC/d5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BwD,EAAQ7zB,OAAS,SAAgB2tB,GAC7B,OAAO,IAAIkG,EAAQlG,IAYvBkG,EAAQxwB,OAAS,SAAgBxhB,EAASgsC,GA2EtC,OA1EKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ6N,MAAgBse,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMxnC,KAAKmd,OAAOxhB,EAAQ6N,KAAMm+B,EAAOE,OAA8B,IAAI0B,QAAQtB,SAChE,MAAjBtsC,EAAQkN,OAAiBif,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAMqG,MAAM1wB,OAAOxhB,EAAQkN,MAAO8+B,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC9D,MAArBtsC,EAAQ+M,WAAqBof,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAM/hC,UAAU0X,OAAOxhB,EAAQ+M,UAAWi/B,EAAOE,OAA8B,IAAI0B,QAAQtB,SACvE,MAApBtsC,EAAQ2N,UAAoBwe,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChE6rC,EAAMhhC,SAAS2W,OAAOxhB,EAAQ2N,SAAUq+B,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzE,MAAhBtsC,EAAQuN,MAAgB4e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMzhC,UAAUoX,OAAOxhB,EAAQuN,KAAMy+B,EAAOE,OAA8B,IAAI0B,QAAQtB,SACjE,MAArBtsC,EAAQjB,WAAqBotB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAMttC,UAAUijB,OAAOxhB,EAAQjB,UAAWitC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACtE,MAArBtsC,EAAQmN,WAAqBgf,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAMsG,UAAU3wB,OAAOxhB,EAAQmN,UAAW6+B,EAAOE,OAA8B,IAAI0B,QAAQtB,SAClE,MAAzBtsC,EAAQ8N,eAAyBqe,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrE6rC,EAAMvhC,cAAckX,OAAOxhB,EAAQ8N,cAAek+B,EAAOE,OAA+B,IAAI0B,QAAQtB,SACnF,MAAjBtsC,EAAQ4N,OAAiBue,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAM/hC,UAAU0X,OAAOxhB,EAAQ4N,MAAOo+B,EAAOE,OAA+B,IAAI0B,QAAQtB,SACpE,MAApBtsC,EAAQ6M,UAAoBsf,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChE6rC,EAAMjiC,SAAS4X,OAAOxhB,EAAQ6M,SAAUm/B,EAAOE,OAA+B,IAAI0B,QAAQtB,SACzE,MAAjBtsC,EAAQ4M,OAAiBuf,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAMniC,MAAM8X,OAAOxhB,EAAQ4M,MAAOo/B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACpE,MAAjBtsC,EAAQ+N,OAAiBoe,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAMthC,MAAMiX,OAAOxhB,EAAQ+N,MAAOi+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC9D,MAAvBtsC,EAAQgN,aAAuBmf,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnE6rC,EAAM9hC,YAAYyX,OAAOxhB,EAAQgN,YAAag/B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC1E,MAAvBtsC,EAAQ0N,aAAuBye,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnE6rC,EAAMxhC,YAAYmX,OAAOxhB,EAAQ0N,YAAas+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC3E,MAAtBtsC,EAAQ8M,YAAsBqf,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClE6rC,EAAMhiC,WAAW2X,OAAOxhB,EAAQ8M,WAAYk/B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACtE,MAAzBtsC,EAAQqN,eAAyB8e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrE6rC,EAAM3hC,cAAcsX,OAAOxhB,EAAQqN,cAAe2+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACnF,MAAlBtsC,EAAQgO,QAAkBme,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9D6rC,EAAMrhC,OAAOgX,OAAOxhB,EAAQgO,OAAQg+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACnE,MAApBtsC,EAAQiO,UAAoBke,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChE6rC,EAAMphC,SAAS+W,OAAOxhB,EAAQiO,SAAU+9B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACzE,MAAlBtsC,EAAQsO,QAAkB6d,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9D6rC,EAAM7gC,OAAOwW,OAAOxhB,EAAQsO,OAAQ09B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACnE,MAApBtsC,EAAQ0O,UAAoByd,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChE6rC,EAAM3gC,SAASsW,OAAOxhB,EAAQ0O,SAAUs9B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC1E,MAAjBtsC,EAAQoO,OAAiB+d,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAM/gC,MAAM0W,OAAOxhB,EAAQoO,MAAO49B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAChE,MAArBtsC,EAAQ2O,WAAqBwd,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAM1gC,UAAUqW,OAAOxhB,EAAQ2O,UAAWq9B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACxE,MAArBtsC,EAAQqO,WAAqB8d,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAM9gC,UAAUyW,OAAOxhB,EAAQqO,UAAW29B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACxE,MAArBtsC,EAAQ4O,WAAqBud,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAMzgC,UAAUoW,OAAOxhB,EAAQ4O,UAAWo9B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACxE,MAArBtsC,EAAQmO,WAAqBge,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAMlhC,UAAU6W,OAAOxhB,EAAQmO,UAAW69B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACtE,MAAvBtsC,EAAQyN,aAAuB0e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnE6rC,EAAMuG,YAAY5wB,OAAOxhB,EAAQyN,YAAau+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC7E,MAApBtsC,EAAQe,UAAoBorB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChE6rC,EAAMnpC,SAAS8e,OAAOxhB,EAAQe,SAAUirC,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC1E,MAAjBtsC,EAAQyM,OAAiB0f,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAMl/B,MAAM6U,OAAOxhB,EAAQyM,MAAOu/B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACrE,MAAhBtsC,EAAQwN,MAAgB2e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAMnqC,KAAK8f,OAAOxhB,EAAQwN,KAAMw+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC5D,MAAvBtsC,EAAQ6O,aAAuBsd,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnE6rC,EAAMxgC,YAAYmW,OAAOxhB,EAAQ6O,YAAam9B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACzE,MAAxBtsC,EAAQuO,cAAwB4d,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,iBACpE6rC,EAAM5gC,aAAauW,OAAOxhB,EAAQuO,aAAcy9B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACxE,MAA3BtsC,EAAQiN,iBAA2Bkf,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,oBACvE6rC,EAAM7hC,gBAAgBwX,OAAOxhB,EAAQiN,gBAAiB++B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAClF,MAAvBtsC,EAAQkO,aAAuBie,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnE6rC,EAAMnhC,YAAY8W,OAAOxhB,EAAQkO,YAAa89B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC9E,MAAnBtsC,EAAQoN,SAAmB+e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/D6rC,EAAM5hC,QAAQuX,OAAOxhB,EAAQoN,QAAS4+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC5D,MAA7BtsC,EAAQ8O,mBAA6Bqd,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzE6rC,EAAMvnC,kBAAkBkd,OAAOxhB,EAAQ8O,kBAAmBk9B,EAAOE,OAA+B,KAAK0B,QAAQtB,SAC3F,MAAlBtsC,EAAQsN,QAAkB6e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9D6rC,EAAM1hC,OAAOqX,OAAOxhB,EAAQsN,OAAQ0+B,EAAOE,OAA+B,KAAK0B,QAAQtB,SACpFN,GAYXgG,EAAQ3F,gBAAkB,SAAyBrsC,EAASgsC,GACxD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC0F,EAAQh1B,OAAS,SAAgBwG,EAAQd,GAC/Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMmG,QAChFxuB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,GACDzsC,EAAQyM,MAAQo/B,EAAMl/B,MAAMqQ,OAAOwG,EAAQA,EAAO0oB,UAClD,MACJ,KAAK,GACDlsC,EAAQ4M,MAAQi/B,EAAMniC,MAAMsT,OAAOwG,EAAQA,EAAO0oB,UAClD,MACJ,KAAK,GACDlsC,EAAQ6M,SAAWg/B,EAAMjiC,SAASoT,OAAOwG,EAAQA,EAAO0oB,UACxD,MACJ,KAAK,GACDlsC,EAAQ8M,WAAa++B,EAAMhiC,WAAWmT,OAAOwG,EAAQA,EAAO0oB,UAC5D,MACJ,KAAK,GACDlsC,EAAQgO,OAAS69B,EAAMrhC,OAAOwS,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,KAAK,GACDlsC,EAAQiO,SAAW49B,EAAMphC,SAASuS,OAAOwG,EAAQA,EAAO0oB,UACxD,MACJ,KAAK,GACDlsC,EAAQkO,YAAc29B,EAAMnhC,YAAYsS,OAAOwG,EAAQA,EAAO0oB,UAC9D,MACJ,KAAK,GACDlsC,EAAQ8O,kBAAoB+8B,EAAMvnC,kBAAkB0Y,OAAOwG,EAAQA,EAAO0oB,UAC1E,MACJ,KAAK,EACDlsC,EAAQ+M,UAAY8+B,EAAM/hC,UAAUkT,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,GACDlsC,EAAQ4N,MAAQi+B,EAAM/hC,UAAUkT,OAAOwG,EAAQA,EAAO0oB,UACtD,MACJ,KAAK,GACDlsC,EAAQmO,UAAY09B,EAAMlhC,UAAUqS,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,GACDlsC,EAAQgN,YAAc6+B,EAAM9hC,YAAYiT,OAAOwG,EAAQA,EAAO0oB,UAC9D,MACJ,KAAK,GACDlsC,EAAQiN,gBAAkB4+B,EAAM7hC,gBAAgBgT,OAAOwG,EAAQA,EAAO0oB,UACtE,MACJ,KAAK,EACDlsC,EAAQjB,UAAY8sC,EAAMttC,UAAUye,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,EACDlsC,EAAQkN,MAAQ2+B,EAAMqG,MAAMl1B,OAAOwG,EAAQA,EAAO0oB,UAClD,MACJ,KAAK,EACDlsC,EAAQmN,UAAY0+B,EAAMsG,UAAUn1B,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,GACDlsC,EAAQoN,QAAUy+B,EAAM5hC,QAAQ+S,OAAOwG,EAAQA,EAAO0oB,UACtD,MACJ,KAAK,GACDlsC,EAAQuO,aAAes9B,EAAM5gC,aAAa+R,OAAOwG,EAAQA,EAAO0oB,UAChE,MACJ,KAAK,GACDlsC,EAAQqN,cAAgBw+B,EAAM3hC,cAAc8S,OAAOwG,EAAQA,EAAO0oB,UAClE,MACJ,KAAK,GACDlsC,EAAQsN,OAASu+B,EAAM1hC,OAAO6S,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,KAAK,EACDlsC,EAAQuN,KAAOs+B,EAAMzhC,UAAU4S,OAAOwG,EAAQA,EAAO0oB,UACrD,MACJ,KAAK,GACDlsC,EAAQwN,KAAOq+B,EAAMnqC,KAAKsb,OAAOwG,EAAQA,EAAO0oB,UAChD,MACJ,KAAK,GACDlsC,EAAQe,SAAW8qC,EAAMnpC,SAASsa,OAAOwG,EAAQA,EAAO0oB,UACxD,MACJ,KAAK,GACDlsC,EAAQyN,YAAco+B,EAAMuG,YAAYp1B,OAAOwG,EAAQA,EAAO0oB,UAC9D,MACJ,KAAK,GACDlsC,EAAQ6O,YAAcg9B,EAAMxgC,YAAY2R,OAAOwG,EAAQA,EAAO0oB,UAC9D,MACJ,KAAK,GACDlsC,EAAQ0N,YAAcm+B,EAAMxhC,YAAY2S,OAAOwG,EAAQA,EAAO0oB,UAC9D,MACJ,KAAK,EACDlsC,EAAQ2N,SAAWk+B,EAAMhhC,SAASmS,OAAOwG,EAAQA,EAAO0oB,UACxD,MACJ,KAAK,GACDlsC,EAAQoO,MAAQy9B,EAAM/gC,MAAMkS,OAAOwG,EAAQA,EAAO0oB,UAClD,MACJ,KAAK,GACDlsC,EAAQqO,UAAYw9B,EAAM9gC,UAAUiS,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,GACDlsC,EAAQsO,OAASu9B,EAAM7gC,OAAOgS,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,KAAK,EACDlsC,EAAQ6N,KAAOg+B,EAAMxnC,KAAK2Y,OAAOwG,EAAQA,EAAO0oB,UAChD,MACJ,KAAK,GACDlsC,EAAQ0O,SAAWm9B,EAAM3gC,SAAS8R,OAAOwG,EAAQA,EAAO0oB,UACxD,MACJ,KAAK,GACDlsC,EAAQ2O,UAAYk9B,EAAM1gC,UAAU6R,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,GACDlsC,EAAQ4O,UAAYi9B,EAAMzgC,UAAU4R,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,GACDlsC,EAAQ8N,cAAgB+9B,EAAMvhC,cAAc0S,OAAOwG,EAAQA,EAAO0oB,UAClE,MACJ,KAAK,GACDlsC,EAAQ+N,MAAQ89B,EAAMthC,MAAMyS,OAAOwG,EAAQA,EAAO0oB,UAClD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXgyC,EAAQrF,gBAAkB,SAAyBnpB,GAG/C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC8F,EAAQpF,OAAS,SAAgB5sC,GAC7B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAAqB,MAAjB9rC,EAAQyM,OAAiBzM,EAAQoI,eAAe,SAAU,CAC1D0jC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMl/B,MAAMigC,OAAO5sC,EAAQyM,OACvC,GAAI7M,EACA,MAAO,SAAWA,EAG9B,GAAqB,MAAjBI,EAAQ4M,OAAiB5M,EAAQoI,eAAe,SAAU,CAC1D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMniC,MAAMkjC,OAAO5sC,EAAQ4M,OACvC,GAAIhN,EACA,MAAO,SAAWA,EAG9B,GAAwB,MAApBI,EAAQ6M,UAAoB7M,EAAQoI,eAAe,YAAa,CAChE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMjiC,SAASgjC,OAAO5sC,EAAQ6M,UAC1C,GAAIjN,EACA,MAAO,YAAcA,EAGjC,GAA0B,MAAtBI,EAAQ8M,YAAsB9M,EAAQoI,eAAe,cAAe,CACpE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMhiC,WAAW+iC,OAAO5sC,EAAQ8M,YAC5C,GAAIlN,EACA,MAAO,cAAgBA,EAGnC,GAAsB,MAAlBI,EAAQgO,QAAkBhO,EAAQoI,eAAe,UAAW,CAC5D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMrhC,OAAOoiC,OAAO5sC,EAAQgO,QACxC,GAAIpO,EACA,MAAO,UAAYA,EAG/B,GAAwB,MAApBI,EAAQiO,UAAoBjO,EAAQoI,eAAe,YAAa,CAChE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMphC,SAASmiC,OAAO5sC,EAAQiO,UAC1C,GAAIrO,EACA,MAAO,YAAcA,EAGjC,GAA2B,MAAvBI,EAAQkO,aAAuBlO,EAAQoI,eAAe,eAAgB,CACtE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMnhC,YAAYkiC,OAAO5sC,EAAQkO,aAC7C,GAAItO,EACA,MAAO,eAAiBA,EAGpC,GAAiC,MAA7BI,EAAQ8O,mBAA6B9O,EAAQoI,eAAe,qBAAsB,CAClF,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMvnC,kBAAkBsoC,OAAO5sC,EAAQ8O,mBACnD,GAAIlP,EACA,MAAO,qBAAuBA,EAG1C,GAAyB,MAArBI,EAAQ+M,WAAqB/M,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM/hC,UAAU8iC,OAAO5sC,EAAQ+M,WAC3C,GAAInN,EACA,MAAO,aAAeA,EAGlC,GAAqB,MAAjBI,EAAQ4N,OAAiB5N,EAAQoI,eAAe,SAAU,CAC1D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM/hC,UAAU8iC,OAAO5sC,EAAQ4N,OAC3C,GAAIhO,EACA,MAAO,SAAWA,EAG9B,GAAyB,MAArBI,EAAQmO,WAAqBnO,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMlhC,UAAUiiC,OAAO5sC,EAAQmO,WAC3C,GAAIvO,EACA,MAAO,aAAeA,EAGlC,GAA2B,MAAvBI,EAAQgN,aAAuBhN,EAAQoI,eAAe,eAAgB,CACtE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM9hC,YAAY6iC,OAAO5sC,EAAQgN,aAC7C,GAAIpN,EACA,MAAO,eAAiBA,EAGpC,GAA+B,MAA3BI,EAAQiN,iBAA2BjN,EAAQoI,eAAe,mBAAoB,CAC9E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM7hC,gBAAgB4iC,OAAO5sC,EAAQiN,iBACjD,GAAIrN,EACA,MAAO,mBAAqBA,EAGxC,GAAyB,MAArBI,EAAQjB,WAAqBiB,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMttC,UAAUquC,OAAO5sC,EAAQjB,WAC3C,GAAIa,EACA,MAAO,aAAeA,EAGlC,GAAqB,MAAjBI,EAAQkN,OAAiBlN,EAAQoI,eAAe,SAAU,CAC1D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMqG,MAAMtF,OAAO5sC,EAAQkN,OACvC,GAAItN,EACA,MAAO,SAAWA,EAG9B,GAAyB,MAArBI,EAAQmN,WAAqBnN,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMsG,UAAUvF,OAAO5sC,EAAQmN,WAC3C,GAAIvN,EACA,MAAO,aAAeA,EAGlC,GAAuB,MAAnBI,EAAQoN,SAAmBpN,EAAQoI,eAAe,WAAY,CAC9D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM5hC,QAAQ2iC,OAAO5sC,EAAQoN,SACzC,GAAIxN,EACA,MAAO,WAAaA,EAGhC,GAA4B,MAAxBI,EAAQuO,cAAwBvO,EAAQoI,eAAe,gBAAiB,CACxE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM5gC,aAAa2hC,OAAO5sC,EAAQuO,cAC9C,GAAI3O,EACA,MAAO,gBAAkBA,EAGrC,GAA6B,MAAzBI,EAAQqN,eAAyBrN,EAAQoI,eAAe,iBAAkB,CAC1E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM3hC,cAAc0iC,OAAO5sC,EAAQqN,eAC/C,GAAIzN,EACA,MAAO,iBAAmBA,EAGtC,GAAsB,MAAlBI,EAAQsN,QAAkBtN,EAAQoI,eAAe,UAAW,CAC5D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM1hC,OAAOyiC,OAAO5sC,EAAQsN,QACxC,GAAI1N,EACA,MAAO,UAAYA,EAG/B,GAAoB,MAAhBI,EAAQuN,MAAgBvN,EAAQoI,eAAe,QAAS,CACxD,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMzhC,UAAUwiC,OAAO5sC,EAAQuN,MAC3C,GAAI3N,EACA,MAAO,QAAUA,EAG7B,GAAoB,MAAhBI,EAAQwN,MAAgBxN,EAAQoI,eAAe,QAAS,CACxD,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMnqC,KAAKkrC,OAAO5sC,EAAQwN,MACtC,GAAI5N,EACA,MAAO,QAAUA,EAG7B,GAAwB,MAApBI,EAAQe,UAAoBf,EAAQoI,eAAe,YAAa,CAChE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMnpC,SAASkqC,OAAO5sC,EAAQe,UAC1C,GAAInB,EACA,MAAO,YAAcA,EAGjC,GAA2B,MAAvBI,EAAQyN,aAAuBzN,EAAQoI,eAAe,eAAgB,CACtE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMuG,YAAYxF,OAAO5sC,EAAQyN,aAC7C,GAAI7N,EACA,MAAO,eAAiBA,EAGpC,GAA2B,MAAvBI,EAAQ6O,aAAuB7O,EAAQoI,eAAe,eAAgB,CACtE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMxgC,YAAYuhC,OAAO5sC,EAAQ6O,aAC7C,GAAIjP,EACA,MAAO,eAAiBA,EAGpC,GAA2B,MAAvBI,EAAQ0N,aAAuB1N,EAAQoI,eAAe,eAAgB,CACtE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMxhC,YAAYuiC,OAAO5sC,EAAQ0N,aAC7C,GAAI9N,EACA,MAAO,eAAiBA,EAGpC,GAAwB,MAApBI,EAAQ2N,UAAoB3N,EAAQoI,eAAe,YAAa,CAChE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMhhC,SAAS+hC,OAAO5sC,EAAQ2N,UAC1C,GAAI/N,EACA,MAAO,YAAcA,EAGjC,GAAqB,MAAjBI,EAAQoO,OAAiBpO,EAAQoI,eAAe,SAAU,CAC1D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM/gC,MAAM8hC,OAAO5sC,EAAQoO,OACvC,GAAIxO,EACA,MAAO,SAAWA,EAG9B,GAAyB,MAArBI,EAAQqO,WAAqBrO,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM9gC,UAAU6hC,OAAO5sC,EAAQqO,WAC3C,GAAIzO,EACA,MAAO,aAAeA,EAGlC,GAAsB,MAAlBI,EAAQsO,QAAkBtO,EAAQoI,eAAe,UAAW,CAC5D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM7gC,OAAO4hC,OAAO5sC,EAAQsO,QACxC,GAAI1O,EACA,MAAO,UAAYA,EAG/B,GAAoB,MAAhBI,EAAQ6N,MAAgB7N,EAAQoI,eAAe,QAAS,CACxD,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMxnC,KAAKuoC,OAAO5sC,EAAQ6N,MACtC,GAAIjO,EACA,MAAO,QAAUA,EAG7B,GAAwB,MAApBI,EAAQ0O,UAAoB1O,EAAQoI,eAAe,YAAa,CAChE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM3gC,SAAS0hC,OAAO5sC,EAAQ0O,UAC1C,GAAI9O,EACA,MAAO,YAAcA,EAGjC,GAAyB,MAArBI,EAAQ2O,WAAqB3O,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM1gC,UAAUyhC,OAAO5sC,EAAQ2O,WAC3C,GAAI/O,EACA,MAAO,aAAeA,EAGlC,GAAyB,MAArBI,EAAQ4O,WAAqB5O,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMzgC,UAAUwhC,OAAO5sC,EAAQ4O,WAC3C,GAAIhP,EACA,MAAO,aAAeA,EAGlC,GAA6B,MAAzBI,EAAQ8N,eAAyB9N,EAAQoI,eAAe,iBAAkB,CAC1E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMvhC,cAAcsiC,OAAO5sC,EAAQ8N,eAC/C,GAAIlO,EACA,MAAO,iBAAmBA,EAGtC,GAAqB,MAAjBI,EAAQ+N,OAAiB/N,EAAQoI,eAAe,SAAU,CAC1D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMthC,MAAMqiC,OAAO5sC,EAAQ+N,OACvC,GAAInO,EACA,MAAO,SAAWA,EAG9B,OAAO,MAWXoyC,EAAQvrB,WAAa,SAAoBqmB,GACrC,GAAIA,aAAkBjB,EAAMmG,QACxB,OAAOlF,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMmG,QACxB,GAAoB,MAAhBlF,EAAOrgC,MAAe,CACtB,GAA4B,kBAAjBqgC,EAAOrgC,MACd,MAAMqhC,UAAU,mCACpB9tC,EAAQyM,MAAQo/B,EAAMl/B,MAAM8Z,WAAWqmB,EAAOrgC,OAElD,GAAoB,MAAhBqgC,EAAOlgC,MAAe,CACtB,GAA4B,kBAAjBkgC,EAAOlgC,MACd,MAAMkhC,UAAU,mCACpB9tC,EAAQ4M,MAAQi/B,EAAMniC,MAAM+c,WAAWqmB,EAAOlgC,OAElD,GAAuB,MAAnBkgC,EAAOjgC,SAAkB,CACzB,GAA+B,kBAApBigC,EAAOjgC,SACd,MAAMihC,UAAU,sCACpB9tC,EAAQ6M,SAAWg/B,EAAMjiC,SAAS6c,WAAWqmB,EAAOjgC,UAExD,GAAyB,MAArBigC,EAAOhgC,WAAoB,CAC3B,GAAiC,kBAAtBggC,EAAOhgC,WACd,MAAMghC,UAAU,wCACpB9tC,EAAQ8M,WAAa++B,EAAMhiC,WAAW4c,WAAWqmB,EAAOhgC,YAE5D,GAAqB,MAAjBggC,EAAO9+B,OAAgB,CACvB,GAA6B,kBAAlB8+B,EAAO9+B,OACd,MAAM8/B,UAAU,oCACpB9tC,EAAQgO,OAAS69B,EAAMrhC,OAAOic,WAAWqmB,EAAO9+B,QAEpD,GAAuB,MAAnB8+B,EAAO7+B,SAAkB,CACzB,GAA+B,kBAApB6+B,EAAO7+B,SACd,MAAM6/B,UAAU,sCACpB9tC,EAAQiO,SAAW49B,EAAMphC,SAASgc,WAAWqmB,EAAO7+B,UAExD,GAA0B,MAAtB6+B,EAAO5+B,YAAqB,CAC5B,GAAkC,kBAAvB4+B,EAAO5+B,YACd,MAAM4/B,UAAU,yCACpB9tC,EAAQkO,YAAc29B,EAAMnhC,YAAY+b,WAAWqmB,EAAO5+B,aAE9D,GAAgC,MAA5B4+B,EAAOh+B,kBAA2B,CAClC,GAAwC,kBAA7Bg+B,EAAOh+B,kBACd,MAAMg/B,UAAU,+CACpB9tC,EAAQ8O,kBAAoB+8B,EAAMvnC,kBAAkBmiB,WAAWqmB,EAAOh+B,mBAE1E,GAAwB,MAApBg+B,EAAO//B,UAAmB,CAC1B,GAAgC,kBAArB+/B,EAAO//B,UACd,MAAM+gC,UAAU,uCACpB9tC,EAAQ+M,UAAY8+B,EAAM/hC,UAAU2c,WAAWqmB,EAAO//B,WAE1D,GAAoB,MAAhB+/B,EAAOl/B,MAAe,CACtB,GAA4B,kBAAjBk/B,EAAOl/B,MACd,MAAMkgC,UAAU,mCACpB9tC,EAAQ4N,MAAQi+B,EAAM/hC,UAAU2c,WAAWqmB,EAAOl/B,OAEtD,GAAwB,MAApBk/B,EAAO3+B,UAAmB,CAC1B,GAAgC,kBAArB2+B,EAAO3+B,UACd,MAAM2/B,UAAU,uCACpB9tC,EAAQmO,UAAY09B,EAAMlhC,UAAU8b,WAAWqmB,EAAO3+B,WAE1D,GAA0B,MAAtB2+B,EAAO9/B,YAAqB,CAC5B,GAAkC,kBAAvB8/B,EAAO9/B,YACd,MAAM8gC,UAAU,yCACpB9tC,EAAQgN,YAAc6+B,EAAM9hC,YAAY0c,WAAWqmB,EAAO9/B,aAE9D,GAA8B,MAA1B8/B,EAAO7/B,gBAAyB,CAChC,GAAsC,kBAA3B6/B,EAAO7/B,gBACd,MAAM6gC,UAAU,6CACpB9tC,EAAQiN,gBAAkB4+B,EAAM7hC,gBAAgByc,WAAWqmB,EAAO7/B,iBAEtE,GAAwB,MAApB6/B,EAAO/tC,UAAmB,CAC1B,GAAgC,kBAArB+tC,EAAO/tC,UACd,MAAM+uC,UAAU,uCACpB9tC,EAAQjB,UAAY8sC,EAAMttC,UAAUkoB,WAAWqmB,EAAO/tC,WAE1D,GAAoB,MAAhB+tC,EAAO5/B,MAAe,CACtB,GAA4B,kBAAjB4/B,EAAO5/B,MACd,MAAM4gC,UAAU,mCACpB9tC,EAAQkN,MAAQ2+B,EAAMqG,MAAMzrB,WAAWqmB,EAAO5/B,OAElD,GAAwB,MAApB4/B,EAAO3/B,UAAmB,CAC1B,GAAgC,kBAArB2/B,EAAO3/B,UACd,MAAM2gC,UAAU,uCACpB9tC,EAAQmN,UAAY0+B,EAAMsG,UAAU1rB,WAAWqmB,EAAO3/B,WAE1D,GAAsB,MAAlB2/B,EAAO1/B,QAAiB,CACxB,GAA8B,kBAAnB0/B,EAAO1/B,QACd,MAAM0gC,UAAU,qCACpB9tC,EAAQoN,QAAUy+B,EAAM5hC,QAAQwc,WAAWqmB,EAAO1/B,SAEtD,GAA2B,MAAvB0/B,EAAOv+B,aAAsB,CAC7B,GAAmC,kBAAxBu+B,EAAOv+B,aACd,MAAMu/B,UAAU,0CACpB9tC,EAAQuO,aAAes9B,EAAM5gC,aAAawb,WAAWqmB,EAAOv+B,cAEhE,GAA4B,MAAxBu+B,EAAOz/B,cAAuB,CAC9B,GAAoC,kBAAzBy/B,EAAOz/B,cACd,MAAMygC,UAAU,2CACpB9tC,EAAQqN,cAAgBw+B,EAAM3hC,cAAcuc,WAAWqmB,EAAOz/B,eAElE,GAAqB,MAAjBy/B,EAAOx/B,OAAgB,CACvB,GAA6B,kBAAlBw/B,EAAOx/B,OACd,MAAMwgC,UAAU,oCACpB9tC,EAAQsN,OAASu+B,EAAM1hC,OAAOsc,WAAWqmB,EAAOx/B,QAEpD,GAAmB,MAAfw/B,EAAOv/B,KAAc,CACrB,GAA2B,kBAAhBu/B,EAAOv/B,KACd,MAAMugC,UAAU,kCACpB9tC,EAAQuN,KAAOs+B,EAAMzhC,UAAUqc,WAAWqmB,EAAOv/B,MAErD,GAAmB,MAAfu/B,EAAOt/B,KAAc,CACrB,GAA2B,kBAAhBs/B,EAAOt/B,KACd,MAAMsgC,UAAU,kCACpB9tC,EAAQwN,KAAOq+B,EAAMnqC,KAAK+kB,WAAWqmB,EAAOt/B,MAEhD,GAAuB,MAAnBs/B,EAAO/rC,SAAkB,CACzB,GAA+B,kBAApB+rC,EAAO/rC,SACd,MAAM+sC,UAAU,sCACpB9tC,EAAQe,SAAW8qC,EAAMnpC,SAAS+jB,WAAWqmB,EAAO/rC,UAExD,GAA0B,MAAtB+rC,EAAOr/B,YAAqB,CAC5B,GAAkC,kBAAvBq/B,EAAOr/B,YACd,MAAMqgC,UAAU,yCACpB9tC,EAAQyN,YAAco+B,EAAMuG,YAAY3rB,WAAWqmB,EAAOr/B,aAE9D,GAA0B,MAAtBq/B,EAAOj+B,YAAqB,CAC5B,GAAkC,kBAAvBi+B,EAAOj+B,YACd,MAAMi/B,UAAU,yCACpB9tC,EAAQ6O,YAAcg9B,EAAMxgC,YAAYob,WAAWqmB,EAAOj+B,aAE9D,GAA0B,MAAtBi+B,EAAOp/B,YAAqB,CAC5B,GAAkC,kBAAvBo/B,EAAOp/B,YACd,MAAMogC,UAAU,yCACpB9tC,EAAQ0N,YAAcm+B,EAAMxhC,YAAYoc,WAAWqmB,EAAOp/B,aAE9D,GAAuB,MAAnBo/B,EAAOn/B,SAAkB,CACzB,GAA+B,kBAApBm/B,EAAOn/B,SACd,MAAMmgC,UAAU,sCACpB9tC,EAAQ2N,SAAWk+B,EAAMhhC,SAAS4b,WAAWqmB,EAAOn/B,UAExD,GAAoB,MAAhBm/B,EAAO1+B,MAAe,CACtB,GAA4B,kBAAjB0+B,EAAO1+B,MACd,MAAM0/B,UAAU,mCACpB9tC,EAAQoO,MAAQy9B,EAAM/gC,MAAM2b,WAAWqmB,EAAO1+B,OAElD,GAAwB,MAApB0+B,EAAOz+B,UAAmB,CAC1B,GAAgC,kBAArBy+B,EAAOz+B,UACd,MAAMy/B,UAAU,uCACpB9tC,EAAQqO,UAAYw9B,EAAM9gC,UAAU0b,WAAWqmB,EAAOz+B,WAE1D,GAAqB,MAAjBy+B,EAAOx+B,OAAgB,CACvB,GAA6B,kBAAlBw+B,EAAOx+B,OACd,MAAMw/B,UAAU,oCACpB9tC,EAAQsO,OAASu9B,EAAM7gC,OAAOyb,WAAWqmB,EAAOx+B,QAEpD,GAAmB,MAAfw+B,EAAOj/B,KAAc,CACrB,GAA2B,kBAAhBi/B,EAAOj/B,KACd,MAAMigC,UAAU,kCACpB9tC,EAAQ6N,KAAOg+B,EAAMxnC,KAAKoiB,WAAWqmB,EAAOj/B,MAEhD,GAAuB,MAAnBi/B,EAAOp+B,SAAkB,CACzB,GAA+B,kBAApBo+B,EAAOp+B,SACd,MAAMo/B,UAAU,sCACpB9tC,EAAQ0O,SAAWm9B,EAAM3gC,SAASub,WAAWqmB,EAAOp+B,UAExD,GAAwB,MAApBo+B,EAAOn+B,UAAmB,CAC1B,GAAgC,kBAArBm+B,EAAOn+B,UACd,MAAMm/B,UAAU,uCACpB9tC,EAAQ2O,UAAYk9B,EAAM1gC,UAAUsb,WAAWqmB,EAAOn+B,WAE1D,GAAwB,MAApBm+B,EAAOl+B,UAAmB,CAC1B,GAAgC,kBAArBk+B,EAAOl+B,UACd,MAAMk/B,UAAU,uCACpB9tC,EAAQ4O,UAAYi9B,EAAMzgC,UAAUqb,WAAWqmB,EAAOl+B,WAE1D,GAA4B,MAAxBk+B,EAAOh/B,cAAuB,CAC9B,GAAoC,kBAAzBg/B,EAAOh/B,cACd,MAAMggC,UAAU,2CACpB9tC,EAAQ8N,cAAgB+9B,EAAMvhC,cAAcmc,WAAWqmB,EAAOh/B,eAElE,GAAoB,MAAhBg/B,EAAO/+B,MAAe,CACtB,GAA4B,kBAAjB++B,EAAO/+B,MACd,MAAM+/B,UAAU,mCACpB9tC,EAAQ+N,MAAQ89B,EAAMthC,MAAMkc,WAAWqmB,EAAO/+B,OAElD,OAAO/N,GAYXgyC,EAAQhF,SAAW,SAAkBhtC,EAASitC,GACrCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAqLb,OApLoB,MAAhB9sC,EAAQ6N,MAAgB7N,EAAQoI,eAAe,UAC/C0kC,EAAOj/B,KAAOg+B,EAAMxnC,KAAK2oC,SAAShtC,EAAQ6N,KAAMo/B,GAC5CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,SAED,MAAjBgB,EAAQkN,OAAiBlN,EAAQoI,eAAe,WAChD0kC,EAAO5/B,MAAQ2+B,EAAMqG,MAAMlF,SAAShtC,EAAQkN,MAAO+/B,GAC/CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,UAEG,MAArBgB,EAAQ+M,WAAqB/M,EAAQoI,eAAe,eACpD0kC,EAAO//B,UAAY8+B,EAAM/hC,UAAUkjC,SAAShtC,EAAQ+M,UAAWkgC,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEE,MAApBgB,EAAQ2N,UAAoB3N,EAAQoI,eAAe,cACnD0kC,EAAOn/B,SAAWk+B,EAAMhhC,SAASmiC,SAAShtC,EAAQ2N,SAAUs/B,GACxDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,aAEF,MAAhBgB,EAAQuN,MAAgBvN,EAAQoI,eAAe,UAC/C0kC,EAAOv/B,KAAOs+B,EAAMzhC,UAAU4iC,SAAShtC,EAAQuN,KAAM0/B,GACjDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,SAEG,MAArBgB,EAAQjB,WAAqBiB,EAAQoI,eAAe,eACpD0kC,EAAO/tC,UAAY8sC,EAAMttC,UAAUyuC,SAAShtC,EAAQjB,UAAWkuC,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEG,MAArBgB,EAAQmN,WAAqBnN,EAAQoI,eAAe,eACpD0kC,EAAO3/B,UAAY0+B,EAAMsG,UAAUnF,SAAShtC,EAAQmN,UAAW8/B,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEO,MAAzBgB,EAAQ8N,eAAyB9N,EAAQoI,eAAe,mBACxD0kC,EAAOh/B,cAAgB+9B,EAAMvhC,cAAc0iC,SAAShtC,EAAQ8N,cAAem/B,GACvEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,kBAED,MAAjBgB,EAAQ4N,OAAiB5N,EAAQoI,eAAe,WAChD0kC,EAAOl/B,MAAQi+B,EAAM/hC,UAAUkjC,SAAShtC,EAAQ4N,MAAOq/B,GACnDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,UAEE,MAApBgB,EAAQ6M,UAAoB7M,EAAQoI,eAAe,cACnD0kC,EAAOjgC,SAAWg/B,EAAMjiC,SAASojC,SAAShtC,EAAQ6M,SAAUogC,GACxDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,aAED,MAAjBgB,EAAQ4M,OAAiB5M,EAAQoI,eAAe,WAChD0kC,EAAOlgC,MAAQi/B,EAAMniC,MAAMsjC,SAAShtC,EAAQ4M,MAAOqgC,GAC/CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,UAED,MAAjBgB,EAAQ+N,OAAiB/N,EAAQoI,eAAe,WAChD0kC,EAAO/+B,MAAQ89B,EAAMthC,MAAMyiC,SAAShtC,EAAQ+N,MAAOk/B,GAC/CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,UAEK,MAAvBgB,EAAQgN,aAAuBhN,EAAQoI,eAAe,iBACtD0kC,EAAO9/B,YAAc6+B,EAAM9hC,YAAYijC,SAAShtC,EAAQgN,YAAaigC,GACjEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEK,MAAvBgB,EAAQ0N,aAAuB1N,EAAQoI,eAAe,iBACtD0kC,EAAOp/B,YAAcm+B,EAAMxhC,YAAY2iC,SAAShtC,EAAQ0N,YAAau/B,GACjEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEI,MAAtBgB,EAAQ8M,YAAsB9M,EAAQoI,eAAe,gBACrD0kC,EAAOhgC,WAAa++B,EAAMhiC,WAAWmjC,SAAShtC,EAAQ8M,WAAYmgC,GAC9DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEO,MAAzBgB,EAAQqN,eAAyBrN,EAAQoI,eAAe,mBACxD0kC,EAAOz/B,cAAgBw+B,EAAM3hC,cAAc8iC,SAAShtC,EAAQqN,cAAe4/B,GACvEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,kBAEA,MAAlBgB,EAAQgO,QAAkBhO,EAAQoI,eAAe,YACjD0kC,EAAO9+B,OAAS69B,EAAMrhC,OAAOwiC,SAAShtC,EAAQgO,OAAQi/B,GAClDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,WAEE,MAApBgB,EAAQiO,UAAoBjO,EAAQoI,eAAe,cACnD0kC,EAAO7+B,SAAW49B,EAAMphC,SAASuiC,SAAShtC,EAAQiO,SAAUg/B,GACxDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,aAEA,MAAlBgB,EAAQsO,QAAkBtO,EAAQoI,eAAe,YACjD0kC,EAAOx+B,OAASu9B,EAAM7gC,OAAOgiC,SAAShtC,EAAQsO,OAAQ2+B,GAClDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,WAEE,MAApBgB,EAAQ0O,UAAoB1O,EAAQoI,eAAe,cACnD0kC,EAAOp+B,SAAWm9B,EAAM3gC,SAAS8hC,SAAShtC,EAAQ0O,SAAUu+B,GACxDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,aAED,MAAjBgB,EAAQoO,OAAiBpO,EAAQoI,eAAe,WAChD0kC,EAAO1+B,MAAQy9B,EAAM/gC,MAAMkiC,SAAShtC,EAAQoO,MAAO6+B,GAC/CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,UAEG,MAArBgB,EAAQ2O,WAAqB3O,EAAQoI,eAAe,eACpD0kC,EAAOn+B,UAAYk9B,EAAM1gC,UAAU6hC,SAAShtC,EAAQ2O,UAAWs+B,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEG,MAArBgB,EAAQqO,WAAqBrO,EAAQoI,eAAe,eACpD0kC,EAAOz+B,UAAYw9B,EAAM9gC,UAAUiiC,SAAShtC,EAAQqO,UAAW4+B,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEG,MAArBgB,EAAQ4O,WAAqB5O,EAAQoI,eAAe,eACpD0kC,EAAOl+B,UAAYi9B,EAAMzgC,UAAU4hC,SAAShtC,EAAQ4O,UAAWq+B,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEG,MAArBgB,EAAQmO,WAAqBnO,EAAQoI,eAAe,eACpD0kC,EAAO3+B,UAAY09B,EAAMlhC,UAAUqiC,SAAShtC,EAAQmO,UAAW8+B,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAEK,MAAvBgB,EAAQyN,aAAuBzN,EAAQoI,eAAe,iBACtD0kC,EAAOr/B,YAAco+B,EAAMuG,YAAYpF,SAAShtC,EAAQyN,YAAaw/B,GACjEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEE,MAApBgB,EAAQe,UAAoBf,EAAQoI,eAAe,cACnD0kC,EAAO/rC,SAAW8qC,EAAMnpC,SAASsqC,SAAShtC,EAAQe,SAAUksC,GACxDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,aAED,MAAjBgB,EAAQyM,OAAiBzM,EAAQoI,eAAe,WAChD0kC,EAAOrgC,MAAQo/B,EAAMl/B,MAAMqgC,SAAShtC,EAAQyM,MAAOwgC,GAC/CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,UAEF,MAAhBgB,EAAQwN,MAAgBxN,EAAQoI,eAAe,UAC/C0kC,EAAOt/B,KAAOq+B,EAAMnqC,KAAKsrC,SAAShtC,EAAQwN,KAAMy/B,GAC5CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,SAEK,MAAvBgB,EAAQ6O,aAAuB7O,EAAQoI,eAAe,iBACtD0kC,EAAOj+B,YAAcg9B,EAAMxgC,YAAY2hC,SAAShtC,EAAQ6O,YAAao+B,GACjEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEM,MAAxBgB,EAAQuO,cAAwBvO,EAAQoI,eAAe,kBACvD0kC,EAAOv+B,aAAes9B,EAAM5gC,aAAa+hC,SAAShtC,EAAQuO,aAAc0+B,GACpEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,iBAES,MAA3BgB,EAAQiN,iBAA2BjN,EAAQoI,eAAe,qBAC1D0kC,EAAO7/B,gBAAkB4+B,EAAM7hC,gBAAgBgjC,SAAShtC,EAAQiN,gBAAiBggC,GAC7EA,EAAQ4B,SACR/B,EAAO9tC,KAAO,oBAEK,MAAvBgB,EAAQkO,aAAuBlO,EAAQoI,eAAe,iBACtD0kC,EAAO5+B,YAAc29B,EAAMnhC,YAAYsiC,SAAShtC,EAAQkO,YAAa++B,GACjEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,gBAEC,MAAnBgB,EAAQoN,SAAmBpN,EAAQoI,eAAe,aAClD0kC,EAAO1/B,QAAUy+B,EAAM5hC,QAAQ+iC,SAAShtC,EAAQoN,QAAS6/B,GACrDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,YAEW,MAA7BgB,EAAQ8O,mBAA6B9O,EAAQoI,eAAe,uBAC5D0kC,EAAOh+B,kBAAoB+8B,EAAMvnC,kBAAkB0oC,SAAShtC,EAAQ8O,kBAAmBm+B,GACnFA,EAAQ4B,SACR/B,EAAO9tC,KAAO,sBAEA,MAAlBgB,EAAQsN,QAAkBtN,EAAQoI,eAAe,YACjD0kC,EAAOx/B,OAASu+B,EAAM1hC,OAAO6iC,SAAShtC,EAAQsN,OAAQ2/B,GAClDA,EAAQ4B,SACR/B,EAAO9tC,KAAO,WAEf8tC,GAUXkF,EAAQjG,UAAUsB,OAAS,WACvB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDyE,EAt3C6B,GAy3CnBnG,EAAMqG,MAAS,WAiBhC,SAASA,EAAMpG,GACX,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmKhD,OA1JA8xB,EAAMnG,UAAUsG,QAAS,EAUzBH,EAAM/zB,OAAS,SAAgB2tB,GAC3B,OAAO,IAAIoG,EAAMpG,IAYrBoG,EAAM1wB,OAAS,SAAgBxhB,EAASgsC,GAKpC,OAJKA,IACDA,EAASL,EAAQxtB,UACC,MAAlBne,EAAQqyC,QAAkBlmB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,GAAG0C,KAAK5uC,EAAQqyC,QAClDrG,GAYXkG,EAAM7F,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC4F,EAAMl1B,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMqG,MAChF1uB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQqyC,OAAS7uB,EAAOorB,OACxB,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXkyC,EAAMvF,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCgG,EAAMtF,OAAS,SAAgB5sC,GAC3B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACW,MAAlBA,EAAQqyC,QAAkBryC,EAAQoI,eAAe,WACnB,mBAAnBpI,EAAQqyC,OACR,2BACR,MAWXH,EAAMzrB,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAMqG,MACxB,OAAOpF,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMqG,MAGxB,OAFqB,MAAjBpF,EAAOuF,SACPryC,EAAQqyC,OAASle,QAAQ2Y,EAAOuF,SAC7BryC,GAYXkyC,EAAMlF,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOuF,QAAS,GACE,MAAlBryC,EAAQqyC,QAAkBryC,EAAQoI,eAAe,YACjD0kC,EAAOuF,OAASryC,EAAQqyC,QACrBvF,GAUXoF,EAAMnG,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD2E,EAxLyB,GA2LXrG,EAAMsG,UAAa,WAqBxC,SAASA,EAAUrG,GAEf,GADAttC,KAAKqC,WAAa,GACdirC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwQhD,OA/PA+xB,EAAUpG,UAAU/sC,KAAO,GAQ3BmzC,EAAUpG,UAAU/rC,QAAU,GAQ9BmyC,EAAUpG,UAAUuG,mBAAoB,EAQxCH,EAAUpG,UAAUlrC,WAAa+qC,EAAMoD,WAQvCmD,EAAUpG,UAAUjrC,WAAY,EAUhCqxC,EAAUh0B,OAAS,SAAgB2tB,GAC/B,OAAO,IAAIqG,EAAUrG,IAYzBqG,EAAU3wB,OAAS,SAAgBxhB,EAASgsC,GAOxC,GANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQhB,MAAgBmtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQhB,MACrC,MAAnBgB,EAAQA,SAAmBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQA,SAClC,MAAtBA,EAAQa,YAAsBb,EAAQa,WAAW6hB,OACjD,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQa,WAAW6hB,SAAUtC,EAC7C4rB,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQa,WAAWuf,IAK3E,OAJiC,MAA7BpgB,EAAQsyC,mBAA6BnmB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQsyC,mBACjC,MAArBtyC,EAAQc,WAAqBqrB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQc,WACnDkrC,GAYXmG,EAAU9F,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC6F,EAAUn1B,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMsG,UAChF3uB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQhB,KAAOwkB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQA,QAAUwjB,EAAO2oB,SACzB,MACJ,KAAK,EACDnsC,EAAQsyC,kBAAoB9uB,EAAOorB,OACnC,MACJ,KAAK,EACK5uC,EAAQa,YAAcb,EAAQa,WAAW6hB,SAC3C1iB,EAAQa,WAAa,IACzBb,EAAQa,WAAW2C,KAAKggB,EAAO2oB,UAC/B,MACJ,KAAK,EACDnsC,EAAQc,UAAY0iB,EAAOorB,OAC3B,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXmyC,EAAUxF,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCiG,EAAUvF,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQhB,MAAgBgB,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQhB,MACxB,MAAO,wBACf,GAAuB,MAAnBgB,EAAQA,SAAmBA,EAAQoI,eAAe,aAC7CwjC,EAAMiB,SAAS7sC,EAAQA,SACxB,MAAO,2BACf,GAAiC,MAA7BA,EAAQsyC,mBAA6BtyC,EAAQoI,eAAe,sBACnB,mBAA9BpI,EAAQsyC,kBACf,MAAO,sCACf,GAA0B,MAAtBtyC,EAAQa,YAAsBb,EAAQoI,eAAe,cAAe,CACpE,IAAKuxB,MAAMuV,QAAQlvC,EAAQa,YACvB,MAAO,6BACX,IAAK,IAAIuf,EAAI,EAAGA,EAAIpgB,EAAQa,WAAW6hB,SAAUtC,EAC7C,IAAKwrB,EAAMiB,SAAS7sC,EAAQa,WAAWuf,IACnC,MAAO,gCAEnB,OAAyB,MAArBpgB,EAAQc,WAAqBd,EAAQoI,eAAe,cACnB,mBAAtBpI,EAAQc,UACR,8BACR,MAWXqxC,EAAU1rB,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAMsG,UACxB,OAAOrF,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMsG,UAOxB,GANmB,MAAfrF,EAAO9tC,OACPgB,EAAQhB,KAAO+tC,OAAOD,EAAO9tC,OACX,MAAlB8tC,EAAO9sC,UACPA,EAAQA,QAAU+sC,OAAOD,EAAO9sC,UACJ,MAA5B8sC,EAAOwF,oBACPtyC,EAAQsyC,kBAAoBne,QAAQ2Y,EAAOwF,oBAC3CxF,EAAOjsC,WAAY,CACnB,IAAK84B,MAAMuV,QAAQpC,EAAOjsC,YACtB,MAAMitC,UAAU,yCACpB9tC,EAAQa,WAAa,GACrB,IAAK,IAAIuf,EAAI,EAAGA,EAAI0sB,EAAOjsC,WAAW6hB,SAAUtC,EAC5CpgB,EAAQa,WAAWuf,GAAK2sB,OAAOD,EAAOjsC,WAAWuf,IAIzD,OAFwB,MAApB0sB,EAAOhsC,YACPd,EAAQc,UAAYqzB,QAAQ2Y,EAAOhsC,YAChCd,GAYXmyC,EAAUnF,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAab,IAZIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOjsC,WAAa,IACpBosC,EAAQC,WACRJ,EAAO9tC,KAAO,GACd8tC,EAAO9sC,QAAU,GACjB8sC,EAAOwF,mBAAoB,EAC3BxF,EAAOhsC,WAAY,GAEH,MAAhBd,EAAQhB,MAAgBgB,EAAQoI,eAAe,UAC/C0kC,EAAO9tC,KAAOgB,EAAQhB,MACH,MAAnBgB,EAAQA,SAAmBA,EAAQoI,eAAe,aAClD0kC,EAAO9sC,QAAUA,EAAQA,SACzBA,EAAQa,YAAcb,EAAQa,WAAW6hB,OAAQ,CACjDoqB,EAAOjsC,WAAa,GACpB,IAAK,IAAIuuC,EAAI,EAAGA,EAAIpvC,EAAQa,WAAW6hB,SAAU0sB,EAC7CtC,EAAOjsC,WAAWuuC,GAAKpvC,EAAQa,WAAWuuC,GAMlD,OAJiC,MAA7BpvC,EAAQsyC,mBAA6BtyC,EAAQoI,eAAe,uBAC5D0kC,EAAOwF,kBAAoBtyC,EAAQsyC,mBACd,MAArBtyC,EAAQc,WAAqBd,EAAQoI,eAAe,eACpD0kC,EAAOhsC,UAAYd,EAAQc,WACxBgsC,GAUXqF,EAAUpG,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD4E,EAlSiC,GAqSrBtG,EAAM5hC,QAAW,WAiBpC,SAASA,EAAQ6hC,GACb,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmKhD,OA1JAnW,EAAQ8hC,UAAU/kC,IAAM,GAUxBiD,EAAQkU,OAAS,SAAgB2tB,GAC7B,OAAO,IAAI7hC,EAAQ6hC,IAYvB7hC,EAAQuX,OAAS,SAAgBxhB,EAASgsC,GAKtC,OAJKA,IACDA,EAASL,EAAQxtB,UACF,MAAfne,EAAQgH,KAAemlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQgH,KACrDglC,GAYX/hC,EAAQoiC,gBAAkB,SAAyBrsC,EAASgsC,GACxD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCriC,EAAQ+S,OAAS,SAAgBwG,EAAQd,GAC/Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM5hC,QAChFuZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQgH,IAAMwc,EAAO2oB,SACrB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXiK,EAAQ0iC,gBAAkB,SAAyBnpB,GAG/C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCjiC,EAAQ2iC,OAAS,SAAgB5sC,GAC7B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACQ,MAAfA,EAAQgH,KAAehH,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQgH,KACjB,uBACR,MAWXiD,EAAQwc,WAAa,SAAoBqmB,GACrC,GAAIA,aAAkBjB,EAAM5hC,QACxB,OAAO6iC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM5hC,QAGxB,OAFkB,MAAd6iC,EAAO9lC,MACPhH,EAAQgH,IAAM+lC,OAAOD,EAAO9lC,MACzBhH,GAYXiK,EAAQ+iC,SAAW,SAAkBhtC,EAASitC,GACrCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAO9lC,IAAM,IACE,MAAfhH,EAAQgH,KAAehH,EAAQoI,eAAe,SAC9C0kC,EAAO9lC,IAAMhH,EAAQgH,KAClB8lC,GAUX7iC,EAAQ8hC,UAAUsB,OAAS,WACvB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDtjC,EAxL6B,GA2LZ4hC,EAAM5gC,aAAgB,WAqB9C,SAASA,EAAa6gC,GAElB,GADAttC,KAAKQ,KAAO,GACR8sC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwQhD,OA/PAnV,EAAa8gC,UAAUt2B,GAAK,GAQ5BxK,EAAa8gC,UAAUp2B,MAAQ,GAQ/B1K,EAAa8gC,UAAU/sC,KAAO4sC,EAAMoD,WAQpC/jC,EAAa8gC,UAAUwG,gBAAkB,EAQzCtnC,EAAa8gC,UAAUyG,eAAgB,EAUvCvnC,EAAakT,OAAS,SAAgB2tB,GAClC,OAAO,IAAI7gC,EAAa6gC,IAY5B7gC,EAAauW,OAAS,SAAgBxhB,EAASgsC,GAO3C,GANKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OACxC,MAAhB3V,EAAQhB,MAAgBgB,EAAQhB,KAAK0jB,OACrC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQhB,KAAK0jB,SAAUtC,EACvC4rB,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQhB,KAAKohB,IAKrE,OAJ+B,MAA3BpgB,EAAQuyC,iBAA2BpmB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,oBACvEgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQuyC,iBAC9B,MAAzBvyC,EAAQwyC,eAAyBrmB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQwyC,eACnDxG,GAYX/gC,EAAaohC,gBAAkB,SAAyBrsC,EAASgsC,GAC7D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCrhC,EAAa+R,OAAS,SAAgBwG,EAAQd,GACpCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM5gC,aAChFuY,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACKnsC,EAAQhB,MAAQgB,EAAQhB,KAAK0jB,SAC/B1iB,EAAQhB,KAAO,IACnBgB,EAAQhB,KAAKwE,KAAKggB,EAAO2oB,UACzB,MACJ,KAAK,EACDnsC,EAAQuyC,gBAAkB/uB,EAAO4oB,QACjC,MACJ,KAAK,EACDpsC,EAAQwyC,cAAgBhvB,EAAOorB,OAC/B,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXiL,EAAa0hC,gBAAkB,SAAyBnpB,GAGpD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCjhC,EAAa2hC,OAAS,SAAgB5sC,GAClC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAAoB,MAAhB3V,EAAQhB,MAAgBgB,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQhB,MACvB,MAAO,uBACX,IAAK,IAAIohB,EAAI,EAAGA,EAAIpgB,EAAQhB,KAAK0jB,SAAUtC,EACvC,IAAKwrB,EAAMiB,SAAS7sC,EAAQhB,KAAKohB,IAC7B,MAAO,0BAEnB,OAA+B,MAA3BpgB,EAAQuyC,iBAA2BvyC,EAAQoI,eAAe,qBACrDwjC,EAAMiC,UAAU7tC,EAAQuyC,iBAClB,oCACc,MAAzBvyC,EAAQwyC,eAAyBxyC,EAAQoI,eAAe,kBACnB,mBAA1BpI,EAAQwyC,cACR,kCACR,MAWXvnC,EAAawb,WAAa,SAAoBqmB,GAC1C,GAAIA,aAAkBjB,EAAM5gC,aACxB,OAAO6hC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM5gC,aAKxB,GAJiB,MAAb6hC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QAC9Bm3B,EAAO9tC,KAAM,CACb,IAAK26B,MAAMuV,QAAQpC,EAAO9tC,MACtB,MAAM8uC,UAAU,sCACpB9tC,EAAQhB,KAAO,GACf,IAAK,IAAIohB,EAAI,EAAGA,EAAI0sB,EAAO9tC,KAAK0jB,SAAUtC,EACtCpgB,EAAQhB,KAAKohB,GAAK2sB,OAAOD,EAAO9tC,KAAKohB,IAM7C,OAJ8B,MAA1B0sB,EAAOyF,kBACPvyC,EAAQuyC,gBAA2C,EAAzBzF,EAAOyF,iBACT,MAAxBzF,EAAO0F,gBACPxyC,EAAQwyC,cAAgBre,QAAQ2Y,EAAO0F,gBACpCxyC,GAYXiL,EAAa+hC,SAAW,SAAkBhtC,EAASitC,GAC1CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAab,IAZIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO9tC,KAAO,IACdiuC,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAOyF,gBAAkB,EACzBzF,EAAO0F,eAAgB,GAET,MAAdxyC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACvB3V,EAAQhB,MAAQgB,EAAQhB,KAAK0jB,OAAQ,CACrCoqB,EAAO9tC,KAAO,GACd,IAAK,IAAIowC,EAAI,EAAGA,EAAIpvC,EAAQhB,KAAK0jB,SAAU0sB,EACvCtC,EAAO9tC,KAAKowC,GAAKpvC,EAAQhB,KAAKowC,GAMtC,OAJ+B,MAA3BpvC,EAAQuyC,iBAA2BvyC,EAAQoI,eAAe,qBAC1D0kC,EAAOyF,gBAAkBvyC,EAAQuyC,iBACR,MAAzBvyC,EAAQwyC,eAAyBxyC,EAAQoI,eAAe,mBACxD0kC,EAAO0F,cAAgBxyC,EAAQwyC,eAC5B1F,GAUX7hC,EAAa8gC,UAAUsB,OAAS,WAC5B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDtiC,EAlSuC,GAqSxB4gC,EAAM9uB,WAAc,WA4B1C,SAASA,EAAW+uB,GAChB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAoGhD,IAAIouB,EAobJ,OA/gBAzxB,EAAWgvB,UAAUruB,KAAO,GAQ5BX,EAAWgvB,UAAU7/B,SAAW,KAQhC6Q,EAAWgvB,UAAU5b,WAAa,KAQlCpT,EAAWgvB,UAAUpZ,UAAY,KAQjC5V,EAAWgvB,UAAUviB,MAAQ,KAQ7BzM,EAAWgvB,UAAU0G,uBAAyB,KAQ9C11B,EAAWgvB,UAAUhZ,eAAiB,EAQtChW,EAAWgvB,UAAU9Y,qBAAuB,EAQ5ClW,EAAWgvB,UAAU5Y,eAAiB,GAQtCpW,EAAWgvB,UAAUxZ,oBAAsB,KAQ3CxV,EAAWgvB,UAAUtZ,aAAe,KAQpC1V,EAAWgvB,UAAU/tB,QAAU,GAW/BmO,OAAOsiB,eAAe1xB,EAAWgvB,UAAW,OAAQ,CAChDltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,aAAc,YAAa,QAAS,yBAA0B,iBAAkB,uBAAwB,iBAAkB,sBAAuB,eAAgB,YACxM5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BzxB,EAAWoB,OAAS,SAAgB2tB,GAChC,OAAO,IAAI/uB,EAAW+uB,IAY1B/uB,EAAWyE,OAAS,SAAgBxhB,EAASgsC,GA2BzC,OA1BKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ0d,MAAgByO,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ0d,MACpC,MAApB1d,EAAQkM,UAAoBigB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChE6rC,EAAM3tB,mBAAmBsD,OAAOxhB,EAAQkM,SAAU8/B,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC7E,MAAtBtsC,EAAQmwB,YAAsBhE,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClE6rC,EAAM6G,WAAWlxB,OAAOxhB,EAAQmwB,WAAY6b,EAAOE,OAA8B,IAAI0B,QAAQtB,SACxE,MAArBtsC,EAAQ2yB,WAAqBxG,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjE6rC,EAAM8G,UAAUnxB,OAAOxhB,EAAQ2yB,UAAWqZ,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC1E,MAAjBtsC,EAAQwpB,OAAiB2C,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7D6rC,EAAMniB,MAAMlI,OAAOxhB,EAAQwpB,MAAOwiB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzD,MAA1BtsC,EAAQ+yB,gBAA0B5G,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,mBACtEgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQ+yB,gBACvB,MAAhC/yB,EAAQizB,sBAAgC9G,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,yBAC5EgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQizB,sBAC9B,MAA1BjzB,EAAQmzB,gBAA0BhH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,mBACtEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQmzB,gBACzB,MAA/BnzB,EAAQuyB,qBAA+BpG,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,wBAC3E6rC,EAAM+G,aAAapxB,OAAOxhB,EAAQuyB,oBAAqByZ,EAAOE,OAA8B,IAAI0B,QAAQtB,SAChF,MAAxBtsC,EAAQyyB,cAAwBtG,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,iBACpE6rC,EAAMgH,aAAarxB,OAAOxhB,EAAQyyB,aAAcuZ,EAAOE,OAA+B,IAAI0B,QAAQtB,SAC/E,MAAnBtsC,EAAQge,SAAmBmO,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA+B,IAAIC,OAAOnsC,EAAQge,SACvB,MAAlChe,EAAQyyC,wBAAkCtmB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,2BAC9E6rC,EAAMiH,iBAAiBtxB,OAAOxhB,EAAQyyC,uBAAwBzG,EAAOE,OAA+B,IAAI0B,QAAQtB,SAC7GN,GAYXjvB,EAAWsvB,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCvvB,EAAWC,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM9uB,WAChFyG,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ0d,KAAO8F,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQkM,SAAW2/B,EAAM3tB,mBAAmBlB,OAAOwG,EAAQA,EAAO0oB,UAClE,MACJ,KAAK,EACDlsC,EAAQmwB,WAAa0b,EAAM6G,WAAW11B,OAAOwG,EAAQA,EAAO0oB,UAC5D,MACJ,KAAK,EACDlsC,EAAQ2yB,UAAYkZ,EAAM8G,UAAU31B,OAAOwG,EAAQA,EAAO0oB,UAC1D,MACJ,KAAK,EACDlsC,EAAQwpB,MAAQqiB,EAAMniB,MAAM1M,OAAOwG,EAAQA,EAAO0oB,UAClD,MACJ,KAAK,GACDlsC,EAAQyyC,uBAAyB5G,EAAMiH,iBAAiB91B,OAAOwG,EAAQA,EAAO0oB,UAC9E,MACJ,KAAK,EACDlsC,EAAQ+yB,eAAiBvP,EAAO4oB,QAChC,MACJ,KAAK,EACDpsC,EAAQizB,qBAAuBzP,EAAO0oB,SACtC,MACJ,KAAK,EACDlsC,EAAQmzB,eAAiB3P,EAAO2oB,SAChC,MACJ,KAAK,EACDnsC,EAAQuyB,oBAAsBsZ,EAAM+G,aAAa51B,OAAOwG,EAAQA,EAAO0oB,UACvE,MACJ,KAAK,GACDlsC,EAAQyyB,aAAeoZ,EAAMgH,aAAa71B,OAAOwG,EAAQA,EAAO0oB,UAChE,MACJ,KAAK,GACDlsC,EAAQge,QAAUwF,EAAO2oB,SACzB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX+c,EAAW4vB,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCnvB,EAAW6vB,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAAoB,MAAhB9rC,EAAQ0d,MAAgB1d,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ0d,MACxB,MAAO,wBACf,GAAwB,MAApB1d,EAAQkM,UAAoBlM,EAAQoI,eAAe,YAAa,CAChE,IAAIxI,EAAQisC,EAAM3tB,mBAAmB0uB,OAAO5sC,EAAQkM,UACpD,GAAItM,EACA,MAAO,YAAcA,EAE7B,GAA0B,MAAtBI,EAAQmwB,YAAsBnwB,EAAQoI,eAAe,cAAe,CACpE0jC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM6G,WAAW9F,OAAO5sC,EAAQmwB,YAC5C,GAAIvwB,EACA,MAAO,cAAgBA,EAGnC,GAAyB,MAArBI,EAAQ2yB,WAAqB3yB,EAAQoI,eAAe,aAAc,CAClE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM8G,UAAU/F,OAAO5sC,EAAQ2yB,WAC3C,GAAI/yB,EACA,MAAO,aAAeA,EAGlC,GAAqB,MAAjBI,EAAQwpB,OAAiBxpB,EAAQoI,eAAe,SAAU,CAC1D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMniB,MAAMkjB,OAAO5sC,EAAQwpB,OACvC,GAAI5pB,EACA,MAAO,SAAWA,EAG9B,GAAsC,MAAlCI,EAAQyyC,wBAAkCzyC,EAAQoI,eAAe,0BAA2B,CAC5F,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMiH,iBAAiBlG,OAAO5sC,EAAQyyC,wBAClD,GAAI7yC,EACA,MAAO,0BAA4BA,EAG/C,GAA8B,MAA1BI,EAAQ+yB,gBAA0B/yB,EAAQoI,eAAe,kBAAmB,CAC5E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,OADA8sC,EAAW9sC,KAAO,EACVgB,EAAQ+yB,gBAChB,QACI,MAAO,sCACX,KAAK,EACL,KAAK,IAIT,GAAoC,MAAhC/yB,EAAQizB,sBAAgCjzB,EAAQoI,eAAe,wBAAyB,CACxF,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,GACb4sC,EAAMiC,UAAU7tC,EAAQizB,sBACzB,MAAO,yCAEf,GAA8B,MAA1BjzB,EAAQmzB,gBAA0BnzB,EAAQoI,eAAe,kBAAmB,CAC5E,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,GACb4sC,EAAMiB,SAAS7sC,EAAQmzB,gBACxB,MAAO,kCAEf,GAAmC,MAA/BnzB,EAAQuyB,qBAA+BvyB,EAAQoI,eAAe,uBAAwB,CACtF,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAM+G,aAAahG,OAAO5sC,EAAQuyB,qBAC9C,GAAI3yB,EACA,MAAO,uBAAyBA,EAG5C,GAA4B,MAAxBI,EAAQyyB,cAAwBzyB,EAAQoI,eAAe,gBAAiB,CACxE,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMgH,aAAajG,OAAO5sC,EAAQyyB,cAC9C,GAAI7yB,EACA,MAAO,gBAAkBA,EAGrC,GAAuB,MAAnBI,EAAQge,SAAmBhe,EAAQoI,eAAe,WAAY,CAC9D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,GACb4sC,EAAMiB,SAAS7sC,EAAQge,SACxB,MAAO,2BAEf,OAAO,MAWXjB,EAAW0J,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAM9uB,WACxB,OAAO+vB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM9uB,WAGxB,GAFmB,MAAf+vB,EAAOpvB,OACP1d,EAAQ0d,KAAOqvB,OAAOD,EAAOpvB,OACV,MAAnBovB,EAAO5gC,SAAkB,CACzB,GAA+B,kBAApB4gC,EAAO5gC,SACd,MAAM4hC,UAAU,yCACpB9tC,EAAQkM,SAAW2/B,EAAM3tB,mBAAmBuI,WAAWqmB,EAAO5gC,UAElE,GAAyB,MAArB4gC,EAAO3c,WAAoB,CAC3B,GAAiC,kBAAtB2c,EAAO3c,WACd,MAAM2d,UAAU,2CACpB9tC,EAAQmwB,WAAa0b,EAAM6G,WAAWjsB,WAAWqmB,EAAO3c,YAE5D,GAAwB,MAApB2c,EAAOna,UAAmB,CAC1B,GAAgC,kBAArBma,EAAOna,UACd,MAAMmb,UAAU,0CACpB9tC,EAAQ2yB,UAAYkZ,EAAM8G,UAAUlsB,WAAWqmB,EAAOna,WAE1D,GAAoB,MAAhBma,EAAOtjB,MAAe,CACtB,GAA4B,kBAAjBsjB,EAAOtjB,MACd,MAAMskB,UAAU,sCACpB9tC,EAAQwpB,MAAQqiB,EAAMniB,MAAMjD,WAAWqmB,EAAOtjB,OAElD,GAAqC,MAAjCsjB,EAAO2F,uBAAgC,CACvC,GAA6C,kBAAlC3F,EAAO2F,uBACd,MAAM3E,UAAU,uDACpB9tC,EAAQyyC,uBAAyB5G,EAAMiH,iBAAiBrsB,WAAWqmB,EAAO2F,wBAE9E,OAAQ3F,EAAO/Z,gBACf,IAAK,wBACL,KAAK,EACD/yB,EAAQ+yB,eAAiB,EACzB,MACJ,IAAK,8BACL,KAAK,EACD/yB,EAAQ+yB,eAAiB,EAO7B,GAJmC,MAA/B+Z,EAAO7Z,uBACPjzB,EAAQizB,qBAAuB6Z,EAAO7Z,uBAAyB,GACtC,MAAzB6Z,EAAO3Z,iBACPnzB,EAAQmzB,eAAiB4Z,OAAOD,EAAO3Z,iBACT,MAA9B2Z,EAAOva,oBAA6B,CACpC,GAA0C,kBAA/Bua,EAAOva,oBACd,MAAMub,UAAU,oDACpB9tC,EAAQuyB,oBAAsBsZ,EAAM+G,aAAansB,WAAWqmB,EAAOva,qBAEvE,GAA2B,MAAvBua,EAAOra,aAAsB,CAC7B,GAAmC,kBAAxBqa,EAAOra,aACd,MAAMqb,UAAU,6CACpB9tC,EAAQyyB,aAAeoZ,EAAMgH,aAAapsB,WAAWqmB,EAAOra,cAIhE,OAFsB,MAAlBqa,EAAO9uB,UACPhe,EAAQge,QAAU+uB,OAAOD,EAAO9uB,UAC7Bhe,GAYX+c,EAAWiwB,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GA2Db,OA1DIG,EAAQC,WACRJ,EAAOpvB,KAAO,GACdovB,EAAO5gC,SAAW,MAEF,MAAhBlM,EAAQ0d,MAAgB1d,EAAQoI,eAAe,UAC/C0kC,EAAOpvB,KAAO1d,EAAQ0d,MACF,MAApB1d,EAAQkM,UAAoBlM,EAAQoI,eAAe,cACnD0kC,EAAO5gC,SAAW2/B,EAAM3tB,mBAAmB8uB,SAAShtC,EAAQkM,SAAU+gC,IAChD,MAAtBjtC,EAAQmwB,YAAsBnwB,EAAQoI,eAAe,gBACrD0kC,EAAO3c,WAAa0b,EAAM6G,WAAW1F,SAAShtC,EAAQmwB,WAAY8c,GAC9DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,eAEG,MAArBgB,EAAQ2yB,WAAqB3yB,EAAQoI,eAAe,eACpD0kC,EAAOna,UAAYkZ,EAAM8G,UAAU3F,SAAShtC,EAAQ2yB,UAAWsa,GAC3DA,EAAQ4B,SACR/B,EAAO9tC,KAAO,cAED,MAAjBgB,EAAQwpB,OAAiBxpB,EAAQoI,eAAe,WAChD0kC,EAAOtjB,MAAQqiB,EAAMniB,MAAMsjB,SAAShtC,EAAQwpB,MAAOyjB,GAC/CA,EAAQ4B,SACR/B,EAAO9tC,KAAO,UAEQ,MAA1BgB,EAAQ+yB,gBAA0B/yB,EAAQoI,eAAe,oBACzD0kC,EAAO/Z,eAAiBka,EAAQE,QAAUJ,OAASlB,EAAM9uB,WAAWma,qBAAqBl3B,EAAQ+yB,gBAAkB/yB,EAAQ+yB,eACvHka,EAAQ4B,SACR/B,EAAO9tC,KAAO,mBAEc,MAAhCgB,EAAQizB,sBAAgCjzB,EAAQoI,eAAe,0BAC/D0kC,EAAO7Z,qBAAuBjzB,EAAQizB,qBAClCga,EAAQ4B,SACR/B,EAAO9tC,KAAO,yBAEQ,MAA1BgB,EAAQmzB,gBAA0BnzB,EAAQoI,eAAe,oBACzD0kC,EAAO3Z,eAAiBnzB,EAAQmzB,eAC5B8Z,EAAQ4B,SACR/B,EAAO9tC,KAAO,mBAEa,MAA/BgB,EAAQuyB,qBAA+BvyB,EAAQoI,eAAe,yBAC9D0kC,EAAOva,oBAAsBsZ,EAAM+G,aAAa5F,SAAShtC,EAAQuyB,oBAAqB0a,GAClFA,EAAQ4B,SACR/B,EAAO9tC,KAAO,wBAEM,MAAxBgB,EAAQyyB,cAAwBzyB,EAAQoI,eAAe,kBACvD0kC,EAAOra,aAAeoZ,EAAMgH,aAAa7F,SAAShtC,EAAQyyB,aAAcwa,GACpEA,EAAQ4B,SACR/B,EAAO9tC,KAAO,iBAEC,MAAnBgB,EAAQge,SAAmBhe,EAAQoI,eAAe,aAClD0kC,EAAO9uB,QAAUhe,EAAQge,QACrBivB,EAAQ4B,SACR/B,EAAO9tC,KAAO,YAEgB,MAAlCgB,EAAQyyC,wBAAkCzyC,EAAQoI,eAAe,4BACjE0kC,EAAO2F,uBAAyB5G,EAAMiH,iBAAiB9F,SAAShtC,EAAQyyC,uBAAwBxF,GAC5FA,EAAQ4B,SACR/B,EAAO9tC,KAAO,2BAEf8tC,GAUX/vB,EAAWgvB,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAU1DxwB,EAAWma,qBAAwB,WAC/B,IAAMsW,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAG9C,OAFAC,EAAOD,EAAW,GAAK,yBAA2B,EAClDC,EAAOD,EAAW,GAAK,+BAAiC,EACjDC,EAJwB,GAO5B1wB,EAxjBmC,IA2jBjCmB,EAAqB2tB,EAAM3tB,mBAAsB,WAoB1D,SAASA,EAAmB4tB,GACxB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA6OhD,OApOAlC,EAAmB6tB,UAAUxtB,WAAY,EAQzCL,EAAmB6tB,UAAU5hB,QAAU,EAQvCjM,EAAmB6tB,UAAUpiB,YAAc,KAQ3CzL,EAAmB6tB,UAAU1/B,qBAAuB,KAUpD6R,EAAmBC,OAAS,SAAgB2tB,GACxC,OAAO,IAAI5tB,EAAmB4tB,IAYlC5tB,EAAmBsD,OAAS,SAAgBxhB,EAASgsC,GAWjD,OAVKA,IACDA,EAASL,EAAQxtB,UACI,MAArBne,EAAQue,WAAqB4N,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,GAAG0C,KAAK5uC,EAAQue,WAClC,MAAnBve,EAAQmqB,SAAmBgC,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQmqB,SACjC,MAAvBnqB,EAAQ2pB,aAAuBwC,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnE6rC,EAAM9hB,UAAUvI,OAAOxhB,EAAQ2pB,YAAaqiB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC7D,MAAhCtsC,EAAQqM,sBAAgC8f,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,yBAC5E6rC,EAAMkH,qBAAqBvxB,OAAOxhB,EAAQqM,qBAAsB2/B,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC9GN,GAYX9tB,EAAmBmuB,gBAAkB,SAAyBrsC,EAASgsC,GACnE,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCpuB,EAAmBlB,OAAS,SAAgBwG,EAAQd,GAC1Cc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM3tB,mBAChFsF,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQue,UAAYiF,EAAOorB,OAC3B,MACJ,KAAK,EACD5uC,EAAQmqB,QAAU3G,EAAO0oB,SACzB,MACJ,KAAK,EACDlsC,EAAQ2pB,YAAckiB,EAAM9hB,UAAU/M,OAAOwG,EAAQA,EAAO0oB,UAC5D,MACJ,KAAK,EACDlsC,EAAQqM,qBAAuBw/B,EAAMkH,qBAAqB/1B,OAAOwG,EAAQA,EAAO0oB,UAChF,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXke,EAAmByuB,gBAAkB,SAAyBnpB,GAG1D,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtChuB,EAAmB0uB,OAAS,SAAgB5sC,GACxC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAyB,MAArBA,EAAQue,WAAqBve,EAAQoI,eAAe,cACnB,mBAAtBpI,EAAQue,UACf,MAAO,8BACf,GAAuB,MAAnBve,EAAQmqB,SAAmBnqB,EAAQoI,eAAe,aAC7CwjC,EAAMiC,UAAU7tC,EAAQmqB,SACzB,MAAO,4BACf,GAA2B,MAAvBnqB,EAAQ2pB,aAAuB3pB,EAAQoI,eAAe,eAAgB,CACtE,IAAIxI,EAAQisC,EAAM9hB,UAAU6iB,OAAO5sC,EAAQ2pB,aAC3C,GAAI/pB,EACA,MAAO,eAAiBA,EAEhC,GAAoC,MAAhCI,EAAQqM,sBAAgCrM,EAAQoI,eAAe,wBAAyB,CACxF,IAAIxI,EAAQisC,EAAMkH,qBAAqBnG,OAAO5sC,EAAQqM,sBACtD,GAAIzM,EACA,MAAO,wBAA0BA,EAEzC,OAAO,MAWXse,EAAmBuI,WAAa,SAAoBqmB,GAChD,GAAIA,aAAkBjB,EAAM3tB,mBACxB,OAAO4uB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM3tB,mBAKxB,GAJwB,MAApB4uB,EAAOvuB,YACPve,EAAQue,UAAY4V,QAAQ2Y,EAAOvuB,YACjB,MAAlBuuB,EAAO3iB,UACPnqB,EAAQmqB,QAAU2iB,EAAO3iB,UAAY,GACf,MAAtB2iB,EAAOnjB,YAAqB,CAC5B,GAAkC,kBAAvBmjB,EAAOnjB,YACd,MAAMmkB,UAAU,oDACpB9tC,EAAQ2pB,YAAckiB,EAAM9hB,UAAUtD,WAAWqmB,EAAOnjB,aAE5D,GAAmC,MAA/BmjB,EAAOzgC,qBAA8B,CACrC,GAA2C,kBAAhCygC,EAAOzgC,qBACd,MAAMyhC,UAAU,6DACpB9tC,EAAQqM,qBAAuBw/B,EAAMkH,qBAAqBtsB,WAAWqmB,EAAOzgC,sBAEhF,OAAOrM,GAYXke,EAAmB8uB,SAAW,SAAkBhtC,EAASitC,GAChDA,IACDA,EAAU,IACd,IAAIH,EAAS,GAeb,OAdIG,EAAQC,WACRJ,EAAOvuB,WAAY,EACnBuuB,EAAO3iB,QAAU,EACjB2iB,EAAOnjB,YAAc,KACrBmjB,EAAOzgC,qBAAuB,MAET,MAArBrM,EAAQue,WAAqBve,EAAQoI,eAAe,eACpD0kC,EAAOvuB,UAAYve,EAAQue,WACR,MAAnBve,EAAQmqB,SAAmBnqB,EAAQoI,eAAe,aAClD0kC,EAAO3iB,QAAUnqB,EAAQmqB,SACF,MAAvBnqB,EAAQ2pB,aAAuB3pB,EAAQoI,eAAe,iBACtD0kC,EAAOnjB,YAAckiB,EAAM9hB,UAAUijB,SAAShtC,EAAQ2pB,YAAasjB,IACnC,MAAhCjtC,EAAQqM,sBAAgCrM,EAAQoI,eAAe,0BAC/D0kC,EAAOzgC,qBAAuBw/B,EAAMkH,qBAAqB/F,SAAShtC,EAAQqM,qBAAsB4gC,IAC7FH,GAUX5uB,EAAmB6tB,UAAUsB,OAAS,WAClC,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDrvB,EArQmD,GAkhHjD7S,GA1wGuBwgC,EAAMkH,qBAAwB,WAkB9D,SAASA,EAAqBjH,GAC1B,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLA2yB,EAAqBhH,UAAUptC,MAAQ,EAQvCo0C,EAAqBhH,UAAUtlC,OAAS,EAUxCssC,EAAqB50B,OAAS,SAAgB2tB,GAC1C,OAAO,IAAIiH,EAAqBjH,IAYpCiH,EAAqBvxB,OAAS,SAAgBxhB,EAASgsC,GAOnD,OANKA,IACDA,EAASL,EAAQxtB,UACA,MAAjBne,EAAQrB,OAAiBwtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,GAAGA,OAAOlsC,EAAQrB,OACrC,MAAlBqB,EAAQyG,QAAkB0lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQyG,QACrDulC,GAYX+G,EAAqB1G,gBAAkB,SAAyBrsC,EAASgsC,GACrE,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCyG,EAAqB/1B,OAAS,SAAgBwG,EAAQd,GAC5Cc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMkH,qBAChFvvB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQrB,MAAQ6kB,EAAO0oB,SACvB,MACJ,KAAK,EACDlsC,EAAQyG,OAAS+c,EAAO0oB,SACxB,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX+yC,EAAqBpG,gBAAkB,SAAyBnpB,GAG5D,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC6G,EAAqBnG,OAAS,SAAgB5sC,GAC1C,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACU,MAAjBA,EAAQrB,OAAiBqB,EAAQoI,eAAe,WAC3CwjC,EAAMiC,UAAU7tC,EAAQrB,OAClB,0BACO,MAAlBqB,EAAQyG,QAAkBzG,EAAQoI,eAAe,YAC5CwjC,EAAMiC,UAAU7tC,EAAQyG,QAClB,2BACR,MAWXssC,EAAqBtsB,WAAa,SAAoBqmB,GAClD,GAAIA,aAAkBjB,EAAMkH,qBACxB,OAAOjG,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMkH,qBAKxB,OAJoB,MAAhBjG,EAAOnuC,QACPqB,EAAQrB,MAAQmuC,EAAOnuC,QAAU,GAChB,MAAjBmuC,EAAOrmC,SACPzG,EAAQyG,OAASqmC,EAAOrmC,SAAW,GAChCzG,GAYX+yC,EAAqB/F,SAAW,SAAkBhtC,EAASitC,GAClDA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOnuC,MAAQ,EACfmuC,EAAOrmC,OAAS,GAEC,MAAjBzG,EAAQrB,OAAiBqB,EAAQoI,eAAe,WAChD0kC,EAAOnuC,MAAQqB,EAAQrB,OACL,MAAlBqB,EAAQyG,QAAkBzG,EAAQoI,eAAe,YACjD0kC,EAAOrmC,OAASzG,EAAQyG,QACrBqmC,GAUXiG,EAAqBhH,UAAUsB,OAAS,WACpC,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDwF,EA/MuD,GAkNrClH,EAAM3hC,cAAiB,WAkBhD,SAASA,EAAc4hC,GACnB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLAlW,EAAc6hC,UAAU+F,KAAO,GAQ/B5nC,EAAc6hC,UAAUuD,mBAAoB,EAU5CplC,EAAciU,OAAS,SAAgB2tB,GACnC,OAAO,IAAI5hC,EAAc4hC,IAY7B5hC,EAAcsX,OAAS,SAAgBxhB,EAASgsC,GAO5C,OANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ8xC,MAAgB3lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ8xC,MAC3B,MAA7B9xC,EAAQsvC,mBAA6BnjB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQsvC,mBACnDtD,GAYX9hC,EAAcmiC,gBAAkB,SAAyBrsC,EAASgsC,GAC9D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCpiC,EAAc8S,OAAS,SAAgBwG,EAAQd,GACrCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM3hC,cAChFsZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ8xC,KAAOtuB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQsvC,kBAAoB9rB,EAAOorB,OACnC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXkK,EAAcyiC,gBAAkB,SAAyBnpB,GAGrD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtChiC,EAAc0iC,OAAS,SAAgB5sC,GACnC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ8xC,MACjB,wBACkB,MAA7B9xC,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,sBACnB,mBAA9BpI,EAAQsvC,kBACR,sCACR,MAWXplC,EAAcuc,WAAa,SAAoBqmB,GAC3C,GAAIA,aAAkBjB,EAAM3hC,cACxB,OAAO4iC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM3hC,cAKxB,OAJmB,MAAf4iC,EAAOgF,OACP9xC,EAAQ8xC,KAAO/E,OAAOD,EAAOgF,OACD,MAA5BhF,EAAOwC,oBACPtvC,EAAQsvC,kBAAoBnb,QAAQ2Y,EAAOwC,oBACxCtvC,GAYXkK,EAAc8iC,SAAW,SAAkBhtC,EAASitC,GAC3CA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOgF,KAAO,GACdhF,EAAOwC,mBAAoB,GAEX,MAAhBtvC,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC/C0kC,EAAOgF,KAAO9xC,EAAQ8xC,MACO,MAA7B9xC,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,uBAC5D0kC,EAAOwC,kBAAoBtvC,EAAQsvC,mBAChCxC,GAUX5iC,EAAc6hC,UAAUsB,OAAS,WAC7B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDrjC,EA/MyC,GAkN9B2hC,EAAM1hC,OAAU,WAsBlC,SAASA,EAAO2hC,GACZ,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAoDhD,IAAIouB,EAkPJ,OA7RArkC,EAAO4hC,UAAUzpC,IAAM,GAQvB6H,EAAO4hC,UAAUiH,OAAS,GAQ1B7oC,EAAO4hC,UAAUptC,MAAQ,EAQzBwL,EAAO4hC,UAAUkH,UAAW,EAQ5B9oC,EAAO4hC,UAAUtlC,OAAS,EAQ1B0D,EAAO4hC,UAAUjkC,WAAY,EAW7BqkB,OAAOsiB,eAAetkC,EAAO4hC,UAAW,OAAQ,CAC5CltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,MAAO,WAC9C5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BrkC,EAAOgU,OAAS,SAAgB2tB,GAC5B,OAAO,IAAI3hC,EAAO2hC,IAYtB3hC,EAAOqX,OAAS,SAAgBxhB,EAASgsC,GAerC,OAdKA,IACDA,EAASL,EAAQxtB,UACF,MAAfne,EAAQsC,KAAe6pB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQsC,KACtC,MAAlBtC,EAAQgzC,QAAkB7mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQgzC,QACvC,MAAjBhzC,EAAQrB,OAAiBwtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIgH,MAAMlzC,EAAQrB,OACnC,MAApBqB,EAAQizC,UAAoB9mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQizC,UACpC,MAAlBjzC,EAAQyG,QAAkB0lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIgH,MAAMlzC,EAAQyG,QAClC,MAArBzG,EAAQ8H,WAAqBqkB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ8H,WACnDkkC,GAYX7hC,EAAOkiC,gBAAkB,SAAyBrsC,EAASgsC,GACvD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCniC,EAAO6S,OAAS,SAAgBwG,EAAQd,GAC9Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM1hC,OAChFqZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQsC,IAAMkhB,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQgzC,OAASxvB,EAAO2oB,SACxB,MACJ,KAAK,EACDnsC,EAAQrB,MAAQ6kB,EAAO0vB,QACvB,MACJ,KAAK,EACDlzC,EAAQizC,SAAWzvB,EAAOorB,OAC1B,MACJ,KAAK,EACD5uC,EAAQyG,OAAS+c,EAAO0vB,QACxB,MACJ,KAAK,EACDlzC,EAAQ8H,UAAY0b,EAAOorB,OAC3B,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXmK,EAAOwiC,gBAAkB,SAAyBnpB,GAG9C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC/hC,EAAOyiC,OAAS,SAAgB5sC,GAC5B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAAmB,MAAf9rC,EAAQsC,KAAetC,EAAQoI,eAAe,SAC9C0jC,EAAW9sC,KAAO,GACb4sC,EAAMiB,SAAS7sC,EAAQsC,MACxB,MAAO,uBAEf,GAAsB,MAAlBtC,EAAQgzC,QAAkBhzC,EAAQoI,eAAe,UAAW,CAC5D,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,GACb4sC,EAAMiB,SAAS7sC,EAAQgzC,QACxB,MAAO,0BAEf,OAAqB,MAAjBhzC,EAAQrB,OAAiBqB,EAAQoI,eAAe,UACnB,kBAAlBpI,EAAQrB,MACR,yBACS,MAApBqB,EAAQizC,UAAoBjzC,EAAQoI,eAAe,aACnB,mBAArBpI,EAAQizC,SACR,6BACO,MAAlBjzC,EAAQyG,QAAkBzG,EAAQoI,eAAe,WACnB,kBAAnBpI,EAAQyG,OACR,0BACU,MAArBzG,EAAQ8H,WAAqB9H,EAAQoI,eAAe,cACnB,mBAAtBpI,EAAQ8H,UACR,8BACR,MAWXqC,EAAOsc,WAAa,SAAoBqmB,GACpC,GAAIA,aAAkBjB,EAAM1hC,OACxB,OAAO2iC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM1hC,OAaxB,OAZkB,MAAd2iC,EAAOxqC,MACPtC,EAAQsC,IAAMyqC,OAAOD,EAAOxqC,MACX,MAAjBwqC,EAAOkG,SACPhzC,EAAQgzC,OAASjG,OAAOD,EAAOkG,SACf,MAAhBlG,EAAOnuC,QACPqB,EAAQrB,MAAQk5B,OAAOiV,EAAOnuC,QACX,MAAnBmuC,EAAOmG,WACPjzC,EAAQizC,SAAW9e,QAAQ2Y,EAAOmG,WACjB,MAAjBnG,EAAOrmC,SACPzG,EAAQyG,OAASoxB,OAAOiV,EAAOrmC,SACX,MAApBqmC,EAAOhlC,YACP9H,EAAQ8H,UAAYqsB,QAAQ2Y,EAAOhlC,YAChC9H,GAYXmK,EAAO6iC,SAAW,SAAkBhtC,EAASitC,GACpCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAyBb,OAxBIG,EAAQC,WACRJ,EAAOnuC,MAAQ,EACfmuC,EAAOmG,UAAW,EAClBnG,EAAOrmC,OAAS,EAChBqmC,EAAOhlC,WAAY,GAEJ,MAAf9H,EAAQsC,KAAetC,EAAQoI,eAAe,SAC9C0kC,EAAOxqC,IAAMtC,EAAQsC,IACjB2qC,EAAQ4B,SACR/B,EAAO9tC,KAAO,QAEA,MAAlBgB,EAAQgzC,QAAkBhzC,EAAQoI,eAAe,YACjD0kC,EAAOkG,OAAShzC,EAAQgzC,OACpB/F,EAAQ4B,SACR/B,EAAO9tC,KAAO,WAED,MAAjBgB,EAAQrB,OAAiBqB,EAAQoI,eAAe,WAChD0kC,EAAOnuC,MAAQsuC,EAAQz/B,OAAS4jC,SAASpxC,EAAQrB,OAASouC,OAAO/sC,EAAQrB,OAASqB,EAAQrB,OACtE,MAApBqB,EAAQizC,UAAoBjzC,EAAQoI,eAAe,cACnD0kC,EAAOmG,SAAWjzC,EAAQizC,UACR,MAAlBjzC,EAAQyG,QAAkBzG,EAAQoI,eAAe,YACjD0kC,EAAOrmC,OAASwmC,EAAQz/B,OAAS4jC,SAASpxC,EAAQyG,QAAUsmC,OAAO/sC,EAAQyG,QAAUzG,EAAQyG,QACxE,MAArBzG,EAAQ8H,WAAqB9H,EAAQoI,eAAe,eACpD0kC,EAAOhlC,UAAY9H,EAAQ8H,WACxBglC,GAUX3iC,EAAO4hC,UAAUsB,OAAS,WACtB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDpjC,EAhU2B,GAmUjB0hC,EAAMsH,MAAS,WAkBhC,SAASA,EAAMrH,GACX,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLA+yB,EAAMpH,UAAU/kC,IAAM,GAQtBmsC,EAAMpH,UAAUuC,QAAU,GAU1B6E,EAAMh1B,OAAS,SAAgB2tB,GAC3B,OAAO,IAAIqH,EAAMrH,IAYrBqH,EAAM3xB,OAAS,SAAgBxhB,EAASgsC,GAOpC,OANKA,IACDA,EAASL,EAAQxtB,UACE,MAAnBne,EAAQsuC,SAAmBniB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQsuC,SACzC,MAAftuC,EAAQgH,KAAemlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQgH,KACrDglC,GAYXmH,EAAM9G,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC6G,EAAMn2B,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMsH,MAChF3vB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQgH,IAAMwc,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQsuC,QAAU9qB,EAAO2oB,SACzB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXmzC,EAAMxG,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCiH,EAAMvG,OAAS,SAAgB5sC,GAC3B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACQ,MAAfA,EAAQgH,KAAehH,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQgH,KACjB,uBACQ,MAAnBhH,EAAQsuC,SAAmBtuC,EAAQoI,eAAe,aAC7CwjC,EAAMiB,SAAS7sC,EAAQsuC,SACjB,2BACR,MAWX6E,EAAM1sB,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAMsH,MACxB,OAAOrG,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMsH,MAKxB,OAJkB,MAAdrG,EAAO9lC,MACPhH,EAAQgH,IAAM+lC,OAAOD,EAAO9lC,MACV,MAAlB8lC,EAAOwB,UACPtuC,EAAQsuC,QAAUvB,OAAOD,EAAOwB,UAC7BtuC,GAYXmzC,EAAMnG,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOwB,QAAU,GACjBxB,EAAO9lC,IAAM,IAEM,MAAnBhH,EAAQsuC,SAAmBtuC,EAAQoI,eAAe,aAClD0kC,EAAOwB,QAAUtuC,EAAQsuC,SACV,MAAftuC,EAAQgH,KAAehH,EAAQoI,eAAe,SAC9C0kC,EAAO9lC,IAAMhH,EAAQgH,KAClB8lC,GAUXqG,EAAMpH,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD4F,EA/MyB,GAkNXtH,EAAMzhC,UAAa,WAkBxC,SAASA,EAAU0hC,GAEf,GADAttC,KAAK+O,KAAO,GACRu+B,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA6MhD,OApMAhW,EAAU2hC,UAAUx+B,KAAOq+B,EAAMoD,WAQjC5kC,EAAU2hC,UAAUptC,MAAQ,EAU5ByL,EAAU+T,OAAS,SAAgB2tB,GAC/B,OAAO,IAAI1hC,EAAU0hC,IAYzB1hC,EAAUoX,OAAS,SAAgBxhB,EAASgsC,GAGxC,GAFKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQuN,MAAgBvN,EAAQuN,KAAKmV,OACrC,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQuN,KAAKmV,SAAUtC,EACvCyrB,EAAMsH,MAAM3xB,OAAOxhB,EAAQuN,KAAK6S,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAG7F,OAFqB,MAAjBtsC,EAAQrB,OAAiBwtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQrB,OACpDqtC,GAYX5hC,EAAUiiC,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCliC,EAAU4S,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMzhC,UAChFoZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQuN,MAAQvN,EAAQuN,KAAKmV,SAC/B1iB,EAAQuN,KAAO,IACnBvN,EAAQuN,KAAK/J,KAAKqoC,EAAMsH,MAAMn2B,OAAOwG,EAAQA,EAAO0oB,WACpD,MACJ,KAAK,EACDlsC,EAAQrB,MAAQ6kB,EAAO4oB,QACvB,MACJ,QACI5oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXoK,EAAUuiC,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC9hC,EAAUwiC,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQuN,MAAgBvN,EAAQoI,eAAe,QAAS,CACxD,IAAKuxB,MAAMuV,QAAQlvC,EAAQuN,MACvB,MAAO,uBACX,IAAK,IAAI6S,EAAI,EAAGA,EAAIpgB,EAAQuN,KAAKmV,SAAUtC,EAAG,CAC1C,IAAIxgB,EAAQisC,EAAMsH,MAAMvG,OAAO5sC,EAAQuN,KAAK6S,IAC5C,GAAIxgB,EACA,MAAO,QAAUA,GAG7B,OAAqB,MAAjBI,EAAQrB,OAAiBqB,EAAQoI,eAAe,WAC3CwjC,EAAMiC,UAAU7tC,EAAQrB,OAClB,0BACR,MAWXyL,EAAUqc,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAMzhC,UACxB,OAAO0iC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMzhC,UACxB,GAAI0iC,EAAOv/B,KAAM,CACb,IAAKosB,MAAMuV,QAAQpC,EAAOv/B,MACtB,MAAMugC,UAAU,mCACpB9tC,EAAQuN,KAAO,GACf,IAAK,IAAI6S,EAAI,EAAGA,EAAI0sB,EAAOv/B,KAAKmV,SAAUtC,EAAG,CACzC,GAA8B,kBAAnB0sB,EAAOv/B,KAAK6S,GACnB,MAAM0tB,UAAU,oCACpB9tC,EAAQuN,KAAK6S,GAAKyrB,EAAMsH,MAAM1sB,WAAWqmB,EAAOv/B,KAAK6S,KAK7D,OAFoB,MAAhB0sB,EAAOnuC,QACPqB,EAAQrB,MAAuB,EAAfmuC,EAAOnuC,OACpBqB,GAYXoK,EAAU4iC,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,IAJIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOv/B,KAAO,IACd0/B,EAAQC,WACRJ,EAAOnuC,MAAQ,GACfqB,EAAQuN,MAAQvN,EAAQuN,KAAKmV,OAAQ,CACrCoqB,EAAOv/B,KAAO,GACd,IAAK,IAAI6hC,EAAI,EAAGA,EAAIpvC,EAAQuN,KAAKmV,SAAU0sB,EACvCtC,EAAOv/B,KAAK6hC,GAAKvD,EAAMsH,MAAMnG,SAAShtC,EAAQuN,KAAK6hC,GAAInC,GAI/D,OAFqB,MAAjBjtC,EAAQrB,OAAiBqB,EAAQoI,eAAe,WAChD0kC,EAAOnuC,MAAQqB,EAAQrB,OACpBmuC,GAUX1iC,EAAU2hC,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDnjC,EApOiC,GAuOlByhC,EAAM6G,WAAc,WAsB1C,SAASA,EAAW5G,GAChB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAiShD,OAxRAsyB,EAAW3G,UAAUtY,SAAW,KAQhCif,EAAW3G,UAAUrY,OAAS,KAQ9Bgf,EAAW3G,UAAUvY,gBAAkB,KAQvCkf,EAAW3G,UAAUpY,aAAe,KAQpC+e,EAAW3G,UAAU7oB,YAAc,GAQnCwvB,EAAW3G,UAAUpgB,UAAY,GAUjC+mB,EAAWv0B,OAAS,SAAgB2tB,GAChC,OAAO,IAAI4G,EAAW5G,IAY1B4G,EAAWlxB,OAAS,SAAgBxhB,EAASgsC,GAezC,OAdKA,IACDA,EAASL,EAAQxtB,UACG,MAApBne,EAAQyzB,UAAoBtH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChE6rC,EAAMuH,SAAS5xB,OAAOxhB,EAAQyzB,SAAUuY,EAAOE,OAA8B,IAAI0B,QAAQtB,SACvE,MAAlBtsC,EAAQ0zB,QAAkBvH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9D6rC,EAAMwH,OAAO7xB,OAAOxhB,EAAQ0zB,OAAQsY,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC1D,MAA3BtsC,EAAQwzB,iBAA2BrH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,oBACvE6rC,EAAMyH,gBAAgB9xB,OAAOxhB,EAAQwzB,gBAAiBwY,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC/E,MAAxBtsC,EAAQ2zB,cAAwBxH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,iBACpE6rC,EAAM+G,aAAapxB,OAAOxhB,EAAQ2zB,aAAcqY,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC1E,MAAvBtsC,EAAQkjB,aAAuBiJ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQkjB,aACnC,MAArBljB,EAAQ2rB,WAAqBQ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2rB,WACrDqgB,GAYX0G,EAAWrG,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCoG,EAAW11B,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM6G,WAChFlvB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyzB,SAAWoY,EAAMuH,SAASp2B,OAAOwG,EAAQA,EAAO0oB,UACxD,MACJ,KAAK,EACDlsC,EAAQ0zB,OAASmY,EAAMwH,OAAOr2B,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,KAAK,EACDlsC,EAAQwzB,gBAAkBqY,EAAMyH,gBAAgBt2B,OAAOwG,EAAQA,EAAO0oB,UACtE,MACJ,KAAK,EACDlsC,EAAQ2zB,aAAekY,EAAM+G,aAAa51B,OAAOwG,EAAQA,EAAO0oB,UAChE,MACJ,KAAK,EACDlsC,EAAQkjB,YAAcM,EAAO2oB,SAC7B,MACJ,KAAK,EACDnsC,EAAQ2rB,UAAYnI,EAAO2oB,SAC3B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0yC,EAAW/F,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCwG,EAAW9F,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAwB,MAApBA,EAAQyzB,UAAoBzzB,EAAQoI,eAAe,YAAa,CAChE,IAAIxI,EAAQisC,EAAMuH,SAASxG,OAAO5sC,EAAQyzB,UAC1C,GAAI7zB,EACA,MAAO,YAAcA,EAE7B,GAAsB,MAAlBI,EAAQ0zB,QAAkB1zB,EAAQoI,eAAe,UAAW,CAC5D,IAAIxI,EAAQisC,EAAMwH,OAAOzG,OAAO5sC,EAAQ0zB,QACxC,GAAI9zB,EACA,MAAO,UAAYA,EAE3B,GAA+B,MAA3BI,EAAQwzB,iBAA2BxzB,EAAQoI,eAAe,mBAAoB,CAC9E,IAAIxI,EAAQisC,EAAMyH,gBAAgB1G,OAAO5sC,EAAQwzB,iBACjD,GAAI5zB,EACA,MAAO,mBAAqBA,EAEpC,GAA4B,MAAxBI,EAAQ2zB,cAAwB3zB,EAAQoI,eAAe,gBAAiB,CACxE,IAAIxI,EAAQisC,EAAM+G,aAAahG,OAAO5sC,EAAQ2zB,cAC9C,GAAI/zB,EACA,MAAO,gBAAkBA,EAEjC,OAA2B,MAAvBI,EAAQkjB,aAAuBljB,EAAQoI,eAAe,iBACjDwjC,EAAMiB,SAAS7sC,EAAQkjB,aACjB,+BACU,MAArBljB,EAAQ2rB,WAAqB3rB,EAAQoI,eAAe,eAC/CwjC,EAAMiB,SAAS7sC,EAAQ2rB,WACjB,6BACR,MAWX+mB,EAAWjsB,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAM6G,WACxB,OAAO5F,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM6G,WACxB,GAAuB,MAAnB5F,EAAOrZ,SAAkB,CACzB,GAA+B,kBAApBqZ,EAAOrZ,SACd,MAAMqa,UAAU,yCACpB9tC,EAAQyzB,SAAWoY,EAAMuH,SAAS3sB,WAAWqmB,EAAOrZ,UAExD,GAAqB,MAAjBqZ,EAAOpZ,OAAgB,CACvB,GAA6B,kBAAlBoZ,EAAOpZ,OACd,MAAMoa,UAAU,uCACpB9tC,EAAQ0zB,OAASmY,EAAMwH,OAAO5sB,WAAWqmB,EAAOpZ,QAEpD,GAA8B,MAA1BoZ,EAAOtZ,gBAAyB,CAChC,GAAsC,kBAA3BsZ,EAAOtZ,gBACd,MAAMsa,UAAU,gDACpB9tC,EAAQwzB,gBAAkBqY,EAAMyH,gBAAgB7sB,WAAWqmB,EAAOtZ,iBAEtE,GAA2B,MAAvBsZ,EAAOnZ,aAAsB,CAC7B,GAAmC,kBAAxBmZ,EAAOnZ,aACd,MAAMma,UAAU,6CACpB9tC,EAAQ2zB,aAAekY,EAAM+G,aAAansB,WAAWqmB,EAAOnZ,cAMhE,OAJ0B,MAAtBmZ,EAAO5pB,cACPljB,EAAQkjB,YAAc6pB,OAAOD,EAAO5pB,cAChB,MAApB4pB,EAAOnhB,YACP3rB,EAAQ2rB,UAAYohB,OAAOD,EAAOnhB,YAC/B3rB,GAYX0yC,EAAW1F,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAqBb,OApBIG,EAAQC,WACRJ,EAAOrZ,SAAW,KAClBqZ,EAAOpZ,OAAS,KAChBoZ,EAAOtZ,gBAAkB,KACzBsZ,EAAOnZ,aAAe,KACtBmZ,EAAO5pB,YAAc,GACrB4pB,EAAOnhB,UAAY,IAEC,MAApB3rB,EAAQyzB,UAAoBzzB,EAAQoI,eAAe,cACnD0kC,EAAOrZ,SAAWoY,EAAMuH,SAASpG,SAAShtC,EAAQyzB,SAAUwZ,IAC1C,MAAlBjtC,EAAQ0zB,QAAkB1zB,EAAQoI,eAAe,YACjD0kC,EAAOpZ,OAASmY,EAAMwH,OAAOrG,SAAShtC,EAAQ0zB,OAAQuZ,IAC3B,MAA3BjtC,EAAQwzB,iBAA2BxzB,EAAQoI,eAAe,qBAC1D0kC,EAAOtZ,gBAAkBqY,EAAMyH,gBAAgBtG,SAAShtC,EAAQwzB,gBAAiByZ,IACzD,MAAxBjtC,EAAQ2zB,cAAwB3zB,EAAQoI,eAAe,kBACvD0kC,EAAOnZ,aAAekY,EAAM+G,aAAa5F,SAAShtC,EAAQ2zB,aAAcsZ,IACjD,MAAvBjtC,EAAQkjB,aAAuBljB,EAAQoI,eAAe,iBACtD0kC,EAAO5pB,YAAcljB,EAAQkjB,aACR,MAArBljB,EAAQ2rB,WAAqB3rB,EAAQoI,eAAe,eACpD0kC,EAAOnhB,UAAY3rB,EAAQ2rB,WACxBmhB,GAUX4F,EAAW3G,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDmF,EA3TmC,GA8TxB7G,EAAMwH,OAAU,WAoBlC,SAASA,EAAOvH,GACZ,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmOhD,OA1NAizB,EAAOtH,UAAU9zB,gBAAiB,EAQlCo7B,EAAOtH,UAAU5jB,kBAAmB,EAQpCkrB,EAAOtH,UAAU/X,oBAAsB,EAQvCqf,EAAOtH,UAAU7X,YAAc,GAU/Bmf,EAAOl1B,OAAS,SAAgB2tB,GAC5B,OAAO,IAAIuH,EAAOvH,IAYtBuH,EAAO7xB,OAAS,SAAgBxhB,EAASgsC,GAWrC,OAVKA,IACDA,EAASL,EAAQxtB,UACS,MAA1Bne,EAAQiY,gBAA0BkU,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,mBACtEgsC,EAAOE,OAA8B,GAAG0C,KAAK5uC,EAAQiY,gBACzB,MAA5BjY,EAAQmoB,kBAA4BgE,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,qBACxEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQmoB,kBACvB,MAA/BnoB,EAAQg0B,qBAA+B7H,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,wBAC3EgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQg0B,qBAChC,MAAvBh0B,EAAQk0B,aAAuB/H,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQk0B,aACrD8X,GAYXqH,EAAOhH,gBAAkB,SAAyBrsC,EAASgsC,GACvD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC+G,EAAOr2B,OAAS,SAAgBwG,EAAQd,GAC9Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMwH,OAChF7vB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQiY,eAAiBuL,EAAOorB,OAChC,MACJ,KAAK,EACD5uC,EAAQmoB,iBAAmB3E,EAAOorB,OAClC,MACJ,KAAK,EACD5uC,EAAQg0B,oBAAsBxQ,EAAO4oB,QACrC,MACJ,KAAK,EACDpsC,EAAQk0B,YAAc1Q,EAAO2oB,SAC7B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXqzC,EAAO1G,gBAAkB,SAAyBnpB,GAG9C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCmH,EAAOzG,OAAS,SAAgB5sC,GAC5B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACmB,MAA1BA,EAAQiY,gBAA0BjY,EAAQoI,eAAe,mBACnB,mBAA3BpI,EAAQiY,eACR,mCACiB,MAA5BjY,EAAQmoB,kBAA4BnoB,EAAQoI,eAAe,qBACnB,mBAA7BpI,EAAQmoB,iBACR,qCACoB,MAA/BnoB,EAAQg0B,qBAA+Bh0B,EAAQoI,eAAe,yBACzDwjC,EAAMiC,UAAU7tC,EAAQg0B,qBAClB,wCACY,MAAvBh0B,EAAQk0B,aAAuBl0B,EAAQoI,eAAe,iBACjDwjC,EAAMiB,SAAS7sC,EAAQk0B,aACjB,+BACR,MAWXmf,EAAO5sB,WAAa,SAAoBqmB,GACpC,GAAIA,aAAkBjB,EAAMwH,OACxB,OAAOvG,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMwH,OASxB,OAR6B,MAAzBvG,EAAO70B,iBACPjY,EAAQiY,eAAiBkc,QAAQ2Y,EAAO70B,iBACb,MAA3B60B,EAAO3kB,mBACPnoB,EAAQmoB,iBAAmBgM,QAAQ2Y,EAAO3kB,mBACZ,MAA9B2kB,EAAO9Y,sBACPh0B,EAAQg0B,oBAAmD,EAA7B8Y,EAAO9Y,qBACf,MAAtB8Y,EAAO5Y,cACPl0B,EAAQk0B,YAAc6Y,OAAOD,EAAO5Y,cACjCl0B,GAYXqzC,EAAOrG,SAAW,SAAkBhtC,EAASitC,GACpCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAeb,OAdIG,EAAQC,WACRJ,EAAO70B,gBAAiB,EACxB60B,EAAO3kB,kBAAmB,EAC1B2kB,EAAO9Y,oBAAsB,EAC7B8Y,EAAO5Y,YAAc,IAEK,MAA1Bl0B,EAAQiY,gBAA0BjY,EAAQoI,eAAe,oBACzD0kC,EAAO70B,eAAiBjY,EAAQiY,gBACJ,MAA5BjY,EAAQmoB,kBAA4BnoB,EAAQoI,eAAe,sBAC3D0kC,EAAO3kB,iBAAmBnoB,EAAQmoB,kBACH,MAA/BnoB,EAAQg0B,qBAA+Bh0B,EAAQoI,eAAe,yBAC9D0kC,EAAO9Y,oBAAsBh0B,EAAQg0B,qBACd,MAAvBh0B,EAAQk0B,aAAuBl0B,EAAQoI,eAAe,iBACtD0kC,EAAO5Y,YAAcl0B,EAAQk0B,aAC1B4Y,GAUXuG,EAAOtH,UAAUsB,OAAS,WACtB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD8F,EA3P2B,GA8PdxH,EAAMuH,SAAY,WAkBtC,SAASA,EAAStH,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLAgzB,EAASrH,UAAUxjB,eAAiB,GAQpC6qB,EAASrH,UAAUhY,MAAQ,GAU3Bqf,EAASj1B,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIsH,EAAStH,IAYxBsH,EAAS5xB,OAAS,SAAgBxhB,EAASgsC,GAOvC,OANKA,IACDA,EAASL,EAAQxtB,UACS,MAA1Bne,EAAQuoB,gBAA0B4D,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,mBACtEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQuoB,gBACvC,MAAjBvoB,EAAQ+zB,OAAiB5H,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ+zB,OACrDiY,GAYXoH,EAAS/G,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC8G,EAASp2B,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMuH,SAChF5vB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQuoB,eAAiB/E,EAAO2oB,SAChC,MACJ,KAAK,EACDnsC,EAAQ+zB,MAAQvQ,EAAO2oB,SACvB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXozC,EAASzG,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCkH,EAASxG,OAAS,SAAgB5sC,GAC9B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACmB,MAA1BA,EAAQuoB,gBAA0BvoB,EAAQoI,eAAe,oBACpDwjC,EAAMiB,SAAS7sC,EAAQuoB,gBACjB,kCACM,MAAjBvoB,EAAQ+zB,OAAiB/zB,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ+zB,OACjB,yBACR,MAWXqf,EAAS3sB,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMuH,SACxB,OAAOtG,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMuH,SAKxB,OAJ6B,MAAzBtG,EAAOvkB,iBACPvoB,EAAQuoB,eAAiBwkB,OAAOD,EAAOvkB,iBACvB,MAAhBukB,EAAO/Y,QACP/zB,EAAQ+zB,MAAQgZ,OAAOD,EAAO/Y,QAC3B/zB,GAYXozC,EAASpG,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOvkB,eAAiB,GACxBukB,EAAO/Y,MAAQ,IAEW,MAA1B/zB,EAAQuoB,gBAA0BvoB,EAAQoI,eAAe,oBACzD0kC,EAAOvkB,eAAiBvoB,EAAQuoB,gBACf,MAAjBvoB,EAAQ+zB,OAAiB/zB,EAAQoI,eAAe,WAChD0kC,EAAO/Y,MAAQ/zB,EAAQ+zB,OACpB+Y,GAUXsG,EAASrH,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD6F,EA/M+B,GAkNXvH,EAAMyH,gBAAmB,WAkBpD,SAASA,EAAgBxH,GACrB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLAkzB,EAAgBvH,UAAUnyB,iBAAmB,GAQ7C05B,EAAgBvH,UAAUjY,cAAgB,GAU1Cwf,EAAgBn1B,OAAS,SAAgB2tB,GACrC,OAAO,IAAIwH,EAAgBxH,IAY/BwH,EAAgB9xB,OAAS,SAAgBxhB,EAASgsC,GAO9C,OANKA,IACDA,EAASL,EAAQxtB,UACW,MAA5Bne,EAAQ4Z,kBAA4BuS,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,qBACxEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ4Z,kBAC/B,MAAzB5Z,EAAQ8zB,eAAyB3H,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ8zB,eACrDkY,GAYXsH,EAAgBjH,gBAAkB,SAAyBrsC,EAASgsC,GAChE,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCgH,EAAgBt2B,OAAS,SAAgBwG,EAAQd,GACvCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMyH,gBAChF9vB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ4Z,iBAAmB4J,EAAO2oB,SAClC,MACJ,KAAK,EACDnsC,EAAQ8zB,cAAgBtQ,EAAO2oB,SAC/B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXszC,EAAgB3G,gBAAkB,SAAyBnpB,GAGvD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCoH,EAAgB1G,OAAS,SAAgB5sC,GACrC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACqB,MAA5BA,EAAQ4Z,kBAA4B5Z,EAAQoI,eAAe,sBACtDwjC,EAAMiB,SAAS7sC,EAAQ4Z,kBACjB,oCACc,MAAzB5Z,EAAQ8zB,eAAyB9zB,EAAQoI,eAAe,mBACnDwjC,EAAMiB,SAAS7sC,EAAQ8zB,eACjB,iCACR,MAWXwf,EAAgB7sB,WAAa,SAAoBqmB,GAC7C,GAAIA,aAAkBjB,EAAMyH,gBACxB,OAAOxG,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMyH,gBAKxB,OAJ+B,MAA3BxG,EAAOlzB,mBACP5Z,EAAQ4Z,iBAAmBmzB,OAAOD,EAAOlzB,mBACjB,MAAxBkzB,EAAOhZ,gBACP9zB,EAAQ8zB,cAAgBiZ,OAAOD,EAAOhZ,gBACnC9zB,GAYXszC,EAAgBtG,SAAW,SAAkBhtC,EAASitC,GAC7CA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOlzB,iBAAmB,GAC1BkzB,EAAOhZ,cAAgB,IAEK,MAA5B9zB,EAAQ4Z,kBAA4B5Z,EAAQoI,eAAe,sBAC3D0kC,EAAOlzB,iBAAmB5Z,EAAQ4Z,kBACT,MAAzB5Z,EAAQ8zB,eAAyB9zB,EAAQoI,eAAe,mBACxD0kC,EAAOhZ,cAAgB9zB,EAAQ8zB,eAC5BgZ,GAUXwG,EAAgBvH,UAAUsB,OAAS,WAC/B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD+F,EA/M6C,GAkNpCzH,EAAMnqC,KAAQ,WAiB9B,SAASA,EAAKoqC,GACV,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmKhD,OA1JA1e,EAAKqqC,UAAUpqC,KAAO,GAUtBD,EAAKyc,OAAS,SAAgB2tB,GAC1B,OAAO,IAAIpqC,EAAKoqC,IAYpBpqC,EAAK8f,OAAS,SAAgBxhB,EAASgsC,GAKnC,OAJKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ2B,MAAgBwqB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2B,MACrDqqC,GAYXtqC,EAAK2qC,gBAAkB,SAAyBrsC,EAASgsC,GACrD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC5qC,EAAKsb,OAAS,SAAgBwG,EAAQd,GAC5Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMnqC,KAChF8hB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ2B,KAAO6hB,EAAO2oB,SACtB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0B,EAAKirC,gBAAkB,SAAyBnpB,GAG5C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCxqC,EAAKkrC,OAAS,SAAgB5sC,GAC1B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ2B,MACjB,wBACR,MAWXD,EAAK+kB,WAAa,SAAoBqmB,GAClC,GAAIA,aAAkBjB,EAAMnqC,KACxB,OAAOorC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMnqC,KAGxB,OAFmB,MAAforC,EAAOnrC,OACP3B,EAAQ2B,KAAOorC,OAAOD,EAAOnrC,OAC1B3B,GAYX0B,EAAKsrC,SAAW,SAAkBhtC,EAASitC,GAClCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOnrC,KAAO,IACE,MAAhB3B,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC/C0kC,EAAOnrC,KAAO3B,EAAQ2B,MACnBmrC,GAUXprC,EAAKqqC,UAAUsB,OAAS,WACpB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD7rC,EAxLuB,GA2LVmqC,EAAMnpC,SAAY,WAkBtC,SAASA,EAASopC,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLA1d,EAASqpC,UAAUpqC,KAAO,GAQ1Be,EAASqpC,UAAUwH,WAAY,EAU/B7wC,EAASyb,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIppC,EAASopC,IAYxBppC,EAAS8e,OAAS,SAAgBxhB,EAASgsC,GAOvC,OANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ2B,MAAgBwqB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2B,MACnC,MAArB3B,EAAQuzC,WAAqBpnB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQuzC,WACnDvH,GAYXtpC,EAAS2pC,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC5pC,EAASsa,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMnpC,SAChF8gB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ2B,KAAO6hB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQuzC,UAAY/vB,EAAOorB,OAC3B,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX0C,EAASiqC,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCxpC,EAASkqC,OAAS,SAAgB5sC,GAC9B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ2B,MACjB,wBACU,MAArB3B,EAAQuzC,WAAqBvzC,EAAQoI,eAAe,cACnB,mBAAtBpI,EAAQuzC,UACR,8BACR,MAWX7wC,EAAS+jB,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMnpC,SACxB,OAAOoqC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMnpC,SAKxB,OAJmB,MAAfoqC,EAAOnrC,OACP3B,EAAQ2B,KAAOorC,OAAOD,EAAOnrC,OACT,MAApBmrC,EAAOyG,YACPvzC,EAAQuzC,UAAYpf,QAAQ2Y,EAAOyG,YAChCvzC,GAYX0C,EAASsqC,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOnrC,KAAO,GACdmrC,EAAOyG,WAAY,GAEH,MAAhBvzC,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC/C0kC,EAAOnrC,KAAO3B,EAAQ2B,MACD,MAArB3B,EAAQuzC,WAAqBvzC,EAAQoI,eAAe,eACpD0kC,EAAOyG,UAAYvzC,EAAQuzC,WACxBzG,GAUXpqC,EAASqpC,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD7qC,EA/M+B,GAkNfmpC,EAAMuG,YAAe,WAoB5C,SAASA,EAAYtG,GAGjB,GAFAttC,KAAA,QAAkB,GAClBA,KAAKyuC,QAAU,GACXnB,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA2QhD,OAlQAgyB,EAAYrG,UAAUt2B,GAAK,GAQ3B28B,EAAYrG,UAAUp2B,MAAQ,GAQ9By8B,EAAYrG,UAAZ,QAAmCH,EAAMoD,WAQzCoD,EAAYrG,UAAUkB,QAAUrB,EAAMoD,WAUtCoD,EAAYj0B,OAAS,SAAgB2tB,GACjC,OAAO,IAAIsG,EAAYtG,IAY3BsG,EAAY5wB,OAAS,SAAgBxhB,EAASgsC,GAO1C,GANKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBA,EAAO,QAAY0iB,OAAQ,CACzDspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAO,QAAY0iB,SAAUtC,EAC7C4rB,EAAOI,MAAMpsC,EAAO,QAAYogB,IACpC4rB,EAAOM,SAEX,GAAuB,MAAnBtsC,EAAQitC,SAAmBjtC,EAAQitC,QAAQvqB,OAC3C,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQitC,QAAQvqB,SAAUtC,EAC1C4rB,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQitC,QAAQ7sB,IACxE,OAAO4rB,GAYXoG,EAAY/F,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC8F,EAAYp1B,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMuG,YAChF5uB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EAGD,GAFMnsC,EAAO,SAAeA,EAAO,QAAY0iB,SAC3C1iB,EAAO,QAAc,IACP,KAAP,EAANysC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAO,QAAYwD,KAAKggB,EAAO4oB,cAEnCpsC,EAAO,QAAYwD,KAAKggB,EAAO4oB,SACnC,MACJ,KAAK,EACKpsC,EAAQitC,SAAWjtC,EAAQitC,QAAQvqB,SACrC1iB,EAAQitC,QAAU,IACtBjtC,EAAQitC,QAAQzpC,KAAKggB,EAAO2oB,UAC5B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXoyC,EAAYzF,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCkG,EAAYxF,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAA0B,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,WAAY,CACjE,IAAKuxB,MAAMuV,QAAQlvC,EAAO,SACtB,MAAO,0BACX,IAAK,IAAIogB,EAAI,EAAGA,EAAIpgB,EAAO,QAAY0iB,SAAUtC,EAC7C,IAAKwrB,EAAMiC,UAAU7tC,EAAO,QAAYogB,IACpC,MAAO,8BAEnB,GAAuB,MAAnBpgB,EAAQitC,SAAmBjtC,EAAQoI,eAAe,WAAY,CAC9D,IAAKuxB,MAAMuV,QAAQlvC,EAAQitC,SACvB,MAAO,0BACX,IAAK,IAAI7sB,EAAI,EAAGA,EAAIpgB,EAAQitC,QAAQvqB,SAAUtC,EAC1C,IAAKwrB,EAAMiB,SAAS7sC,EAAQitC,QAAQ7sB,IAChC,MAAO,6BAEnB,OAAO,MAWXgyB,EAAY3rB,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMuG,YACxB,OAAOtF,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMuG,YAKxB,GAJiB,MAAbtF,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QAC9Bm3B,EAAM,QAAa,CACnB,IAAKnT,MAAMuV,QAAQpC,EAAM,SACrB,MAAMgB,UAAU,wCACpB9tC,EAAO,QAAc,GACrB,IAAK,IAAIogB,EAAI,EAAGA,EAAI0sB,EAAM,QAAYpqB,SAAUtC,EAC5CpgB,EAAO,QAAYogB,GAA4B,EAAvB0sB,EAAM,QAAY1sB,GAElD,GAAI0sB,EAAOG,QAAS,CAChB,IAAKtT,MAAMuV,QAAQpC,EAAOG,SACtB,MAAMa,UAAU,wCACpB9tC,EAAQitC,QAAU,GAClB,IAAK,IAAI7sB,EAAI,EAAGA,EAAI0sB,EAAOG,QAAQvqB,SAAUtC,EACzCpgB,EAAQitC,QAAQ7sB,GAAK2sB,OAAOD,EAAOG,QAAQ7sB,IAEnD,OAAOpgB,GAYXoyC,EAAYpF,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAab,IAZIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAM,QAAc,GACpBA,EAAOG,QAAU,IAEjBA,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,IAED,MAAd3V,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACvB3V,EAAO,SAAeA,EAAO,QAAY0iB,OAAQ,CACjDoqB,EAAM,QAAc,GACpB,IAAK,IAAIsC,EAAI,EAAGA,EAAIpvC,EAAO,QAAY0iB,SAAU0sB,EAC7CtC,EAAM,QAAYsC,GAAKpvC,EAAO,QAAYovC,GAElD,GAAIpvC,EAAQitC,SAAWjtC,EAAQitC,QAAQvqB,OAAQ,CAC3CoqB,EAAOG,QAAU,GACjB,IAAK,IAAImC,EAAI,EAAGA,EAAIpvC,EAAQitC,QAAQvqB,SAAU0sB,EAC1CtC,EAAOG,QAAQmC,GAAKpvC,EAAQitC,QAAQmC,GAE5C,OAAOtC,GAUXsF,EAAYrG,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD6E,EArSqC,GAwSpBvG,EAAMoG,aAAgB,WAmB9C,SAASA,EAAanG,GAClB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmNhD,OA1MA6xB,EAAalG,UAAUntC,KAAO,GAQ9BqzC,EAAalG,UAAUyH,SAAU,EAQjCvB,EAAalG,UAAU1mC,KAAO,KAU9B4sC,EAAa9zB,OAAS,SAAgB2tB,GAClC,OAAO,IAAImG,EAAanG,IAY5BmG,EAAazwB,OAAS,SAAgBxhB,EAASgsC,GAS3C,OARKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQpB,MAAgButB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQpB,MACxC,MAAhBoB,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAM/hC,UAAU0X,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SACnE,MAAnBtsC,EAAQwzC,SAAmBrnB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQwzC,SACnDxH,GAYXiG,EAAa5F,gBAAkB,SAAyBrsC,EAASgsC,GAC7D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC2F,EAAaj1B,OAAS,SAAgBwG,EAAQd,GACpCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMoG,aAChFzuB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQpB,KAAO4kB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQwzC,QAAUhwB,EAAOorB,OACzB,MACJ,KAAK,EACD5uC,EAAQqF,KAAOwmC,EAAM/hC,UAAUkT,OAAOwG,EAAQA,EAAO0oB,UACrD,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXiyC,EAAatF,gBAAkB,SAAyBnpB,GAGpD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC+F,EAAarF,OAAS,SAAgB5sC,GAClC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQpB,MACxB,MAAO,wBACf,GAAuB,MAAnBoB,EAAQwzC,SAAmBxzC,EAAQoI,eAAe,YACnB,mBAApBpI,EAAQwzC,QACf,MAAO,4BACf,GAAoB,MAAhBxzC,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAM/hC,UAAU8iC,OAAO5sC,EAAQqF,MAC3C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,OAAO,MAWXqyC,EAAaxrB,WAAa,SAAoBqmB,GAC1C,GAAIA,aAAkBjB,EAAMoG,aACxB,OAAOnF,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMoG,aAKxB,GAJmB,MAAfnF,EAAOluC,OACPoB,EAAQpB,KAAOmuC,OAAOD,EAAOluC,OACX,MAAlBkuC,EAAO0G,UACPxzC,EAAQwzC,QAAUrf,QAAQ2Y,EAAO0G,UAClB,MAAf1G,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,uCACpB9tC,EAAQqF,KAAOwmC,EAAM/hC,UAAU2c,WAAWqmB,EAAOznC,MAErD,OAAOrF,GAYXiyC,EAAajF,SAAW,SAAkBhtC,EAASitC,GAC1CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOluC,KAAO,GACdkuC,EAAOznC,KAAO,KACdynC,EAAO0G,SAAU,GAED,MAAhBxzC,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC/C0kC,EAAOluC,KAAOoB,EAAQpB,MACN,MAAhBoB,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAM/hC,UAAUkjC,SAAShtC,EAAQqF,KAAM4nC,IAClC,MAAnBjtC,EAAQwzC,SAAmBxzC,EAAQoI,eAAe,aAClD0kC,EAAO0G,QAAUxzC,EAAQwzC,SACtB1G,GAUXmF,EAAalG,UAAUsB,OAAS,WAC5B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD0E,EA1OuC,GA6OzBpG,EAAM8G,UAAa,WAmBxC,SAASA,EAAU7G,GACf,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8MhD,OArMAuyB,EAAU5G,UAAUt2B,GAAK,GAQzBk9B,EAAU5G,UAAUntC,KAAO,GAQ3B+zC,EAAU5G,UAAU7W,WAAa,GAUjCyd,EAAUx0B,OAAS,SAAgB2tB,GAC/B,OAAO,IAAI6G,EAAU7G,IAYzB6G,EAAUnxB,OAAS,SAAgBxhB,EAASgsC,GASxC,OARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACxC,MAAhBzV,EAAQpB,MAAgButB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQpB,MAClC,MAAtBoB,EAAQk1B,YAAsB/I,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQk1B,YACrD8W,GAYX2G,EAAUtG,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCqG,EAAU31B,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM8G,UAChFnvB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQpB,KAAO4kB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQk1B,WAAa1R,EAAO2oB,SAC5B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2yC,EAAUhG,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCyG,EAAU/F,OAAS,SAAgB5sC,GAC/B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACO,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACjB,sBACK,MAAhBzV,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQpB,MACjB,wBACW,MAAtBoB,EAAQk1B,YAAsBl1B,EAAQoI,eAAe,gBAChDwjC,EAAMiB,SAAS7sC,EAAQk1B,YACjB,8BACR,MAWXyd,EAAUlsB,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAM8G,UACxB,OAAO7F,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM8G,UAOxB,OANiB,MAAb7F,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACZ,MAAfq3B,EAAOluC,OACPoB,EAAQpB,KAAOmuC,OAAOD,EAAOluC,OACR,MAArBkuC,EAAO5X,aACPl1B,EAAQk1B,WAAa6X,OAAOD,EAAO5X,aAChCl1B,GAYX2yC,EAAU3F,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOluC,KAAO,GACdkuC,EAAO5X,WAAa,IAEN,MAAdl1B,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACJ,MAAhBzV,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC/C0kC,EAAOluC,KAAOoB,EAAQpB,MACA,MAAtBoB,EAAQk1B,YAAsBl1B,EAAQoI,eAAe,gBACrD0kC,EAAO5X,WAAal1B,EAAQk1B,YACzB4X,GAUX6F,EAAU5G,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDoF,EArOiC,GAwOjB9G,EAAMxgC,YAAe,WA0B5C,SAASA,EAAYygC,GACjB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4XhD,OAnXA/U,EAAY0gC,UAAUt2B,GAAK,GAQ3BpK,EAAY0gC,UAAUp2B,MAAQ,GAQ9BtK,EAAY0gC,UAAUrV,OAAS,GAQ/BrrB,EAAY0gC,UAAU0H,QAAS,EAQ/BpoC,EAAY0gC,UAAU2H,QAAS,EAQ/BroC,EAAY0gC,UAAU4H,SAAW,EAQjCtoC,EAAY0gC,UAAZ,QAAmC,EAQnC1gC,EAAY0gC,UAAU6H,KAAO,EAQ7BvoC,EAAY0gC,UAAUx/B,IAAM,EAQ5BlB,EAAY0gC,UAAUl5B,IAAM,EAU5BxH,EAAY8S,OAAS,SAAgB2tB,GACjC,OAAO,IAAIzgC,EAAYygC,IAY3BzgC,EAAYmW,OAAS,SAAgBxhB,EAASgsC,GAuB1C,OAtBKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OACtC,MAAlB3V,EAAQ02B,QAAkBvK,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ02B,QACtC,MAAlB12B,EAAQyzC,QAAkBtnB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA+B,IAAI0C,KAAK5uC,EAAQyzC,QACrC,MAAlBzzC,EAAQ0zC,QAAkBvnB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA+B,IAAI0C,KAAK5uC,EAAQ0zC,QACnC,MAApB1zC,EAAQ2zC,UAAoBxnB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA+B,KAAKE,MAAMpsC,EAAQ2zC,UACnC,MAAtB3zC,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA+B,KAAKiF,OAAOnxC,EAAO,SACzC,MAAhBA,EAAQ4zC,MAAgBznB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA+B,KAAKiF,OAAOnxC,EAAQ4zC,MAC3C,MAAf5zC,EAAQuM,KAAe4f,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA+B,KAAKiF,OAAOnxC,EAAQuM,KAC3C,MAAfvM,EAAQ6S,KAAesZ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA+B,KAAKiF,OAAOnxC,EAAQ6S,KACvDm5B,GAYX3gC,EAAYghC,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCjhC,EAAY2R,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMxgC,YAChFmY,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAQ02B,OAASlT,EAAO2oB,SACxB,MACJ,KAAK,GACDnsC,EAAQyzC,OAASjwB,EAAOorB,OACxB,MACJ,KAAK,GACD5uC,EAAQ0zC,OAASlwB,EAAOorB,OACxB,MACJ,KAAK,GACD5uC,EAAQ2zC,SAAWnwB,EAAO4oB,QAC1B,MACJ,KAAK,GACDpsC,EAAO,QAAcwjB,EAAO2tB,SAC5B,MACJ,KAAK,GACDnxC,EAAQ4zC,KAAOpwB,EAAO2tB,SACtB,MACJ,KAAK,GACDnxC,EAAQuM,IAAMiX,EAAO2tB,SACrB,MACJ,KAAK,GACDnxC,EAAQ6S,IAAM2Q,EAAO2tB,SACrB,MACJ,QACI3tB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXqL,EAAYshC,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC7gC,EAAYuhC,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAAsB,MAAlB3V,EAAQ02B,QAAkB12B,EAAQoI,eAAe,YAC5CwjC,EAAMiB,SAAS7sC,EAAQ02B,QACxB,MAAO,0BACf,GAAsB,MAAlB12B,EAAQyzC,QAAkBzzC,EAAQoI,eAAe,WACnB,mBAAnBpI,EAAQyzC,OACf,MAAO,2BACf,GAAsB,MAAlBzzC,EAAQ0zC,QAAkB1zC,EAAQoI,eAAe,WACnB,mBAAnBpI,EAAQ0zC,OACf,MAAO,2BACf,GAAwB,MAApB1zC,EAAQ2zC,UAAoB3zC,EAAQoI,eAAe,YACnD,OAAQpI,EAAQ2zC,UAChB,QACI,MAAO,gCACX,KAAK,EACL,KAAK,GAGT,OAA0B,MAAtB3zC,EAAO,SAAuBA,EAAQoI,eAAe,YACnB,kBAAvBpI,EAAO,QACP,2BACK,MAAhBA,EAAQ4zC,MAAgB5zC,EAAQoI,eAAe,SACnB,kBAAjBpI,EAAQ4zC,KACR,wBACI,MAAf5zC,EAAQuM,KAAevM,EAAQoI,eAAe,QACnB,kBAAhBpI,EAAQuM,IACR,uBACI,MAAfvM,EAAQ6S,KAAe7S,EAAQoI,eAAe,QACnB,kBAAhBpI,EAAQ6S,IACR,uBACR,MAWXxH,EAAYob,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMxgC,YACxB,OAAOyhC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMxgC,YAWxB,OAViB,MAAbyhC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACb,MAAjBm3B,EAAOpW,SACP12B,EAAQ02B,OAASqW,OAAOD,EAAOpW,SACd,MAAjBoW,EAAO2G,SACPzzC,EAAQyzC,OAAStf,QAAQ2Y,EAAO2G,SACf,MAAjB3G,EAAO4G,SACP1zC,EAAQ0zC,OAASvf,QAAQ2Y,EAAO4G,SAC5B5G,EAAO6G,UACf,IAAK,MACL,KAAK,EACD3zC,EAAQ2zC,SAAW,EACnB,MACJ,IAAK,QACL,KAAK,EACD3zC,EAAQ2zC,SAAW,EAWvB,OARyB,MAArB7G,EAAM,UACN9sC,EAAO,QAAc63B,OAAOiV,EAAM,UACnB,MAAfA,EAAO8G,OACP5zC,EAAQ4zC,KAAO/b,OAAOiV,EAAO8G,OACf,MAAd9G,EAAOvgC,MACPvM,EAAQuM,IAAMsrB,OAAOiV,EAAOvgC,MACd,MAAdugC,EAAOj6B,MACP7S,EAAQ6S,IAAMglB,OAAOiV,EAAOj6B,MACzB7S,GAYXqL,EAAY2hC,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAiCb,OAhCIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAOpW,OAAS,GAChBoW,EAAO2G,QAAS,EAChB3G,EAAO4G,QAAS,EAChB5G,EAAO6G,SAAW1G,EAAQE,QAAUJ,OAAS,MAAQ,EACrDD,EAAM,QAAc,EACpBA,EAAO8G,KAAO,EACd9G,EAAOvgC,IAAM,EACbugC,EAAOj6B,IAAM,GAEC,MAAd7S,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACL,MAAlB3V,EAAQ02B,QAAkB12B,EAAQoI,eAAe,YACjD0kC,EAAOpW,OAAS12B,EAAQ02B,QACN,MAAlB12B,EAAQyzC,QAAkBzzC,EAAQoI,eAAe,YACjD0kC,EAAO2G,OAASzzC,EAAQyzC,QACN,MAAlBzzC,EAAQ0zC,QAAkB1zC,EAAQoI,eAAe,YACjD0kC,EAAO4G,OAAS1zC,EAAQ0zC,QACJ,MAApB1zC,EAAQ2zC,UAAoB3zC,EAAQoI,eAAe,cACnD0kC,EAAO6G,SAAW1G,EAAQE,QAAUJ,OAASlB,EAAMxgC,YAAYwoC,SAAS7zC,EAAQ2zC,UAAY3zC,EAAQ2zC,UAC9E,MAAtB3zC,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAcG,EAAQz/B,OAAS4jC,SAASpxC,EAAO,SAAe+sC,OAAO/sC,EAAO,SAAeA,EAAO,SACxF,MAAhBA,EAAQ4zC,MAAgB5zC,EAAQoI,eAAe,UAC/C0kC,EAAO8G,KAAO3G,EAAQz/B,OAAS4jC,SAASpxC,EAAQ4zC,MAAQ7G,OAAO/sC,EAAQ4zC,MAAQ5zC,EAAQ4zC,MACxE,MAAf5zC,EAAQuM,KAAevM,EAAQoI,eAAe,SAC9C0kC,EAAOvgC,IAAM0gC,EAAQz/B,OAAS4jC,SAASpxC,EAAQuM,KAAOwgC,OAAO/sC,EAAQuM,KAAOvM,EAAQuM,KACrE,MAAfvM,EAAQ6S,KAAe7S,EAAQoI,eAAe,SAC9C0kC,EAAOj6B,IAAMo6B,EAAQz/B,OAAS4jC,SAASpxC,EAAQ6S,KAAOk6B,OAAO/sC,EAAQ6S,KAAO7S,EAAQ6S,KACjFi6B,GAUXzhC,EAAY0gC,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAU1DliC,EAAYwoC,SAAY,WACpB,IAAMrG,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAG9C,OAFAC,EAAOD,EAAW,GAAK,OAAS,EAChCC,EAAOD,EAAW,GAAK,SAAW,EAC3BC,EAJa,GAOjBpiC,EA1ZqC,IA6vEnCL,GAh2Dc6gC,EAAMxhC,YAAe,WAmB5C,SAASA,EAAYyhC,GACjB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4BhD,IAAIouB,EAgNJ,OAnOAnkC,EAAY0hC,UAAU/kC,IAAM,GAQ5BqD,EAAY0hC,UAAUsD,OAAS,KAQ/BhlC,EAAY0hC,UAAUuD,mBAAoB,EAW1CnjB,OAAOsiB,eAAepkC,EAAY0hC,UAAW,QAAS,CAClDltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,MAAO,WAC9C5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BnkC,EAAY8T,OAAS,SAAgB2tB,GACjC,OAAO,IAAIzhC,EAAYyhC,IAY3BzhC,EAAYmX,OAAS,SAAgBxhB,EAASgsC,GAS1C,OARKA,IACDA,EAASL,EAAQxtB,UACF,MAAfne,EAAQgH,KAAemlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQgH,KACtC,MAAlBhH,EAAQqvC,QAAkBljB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9D6rC,EAAMiI,OAAOtyB,OAAOxhB,EAAQqvC,OAAQrD,EAAOE,OAA8B,IAAI0B,QAAQtB,SACxD,MAA7BtsC,EAAQsvC,mBAA6BnjB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQsvC,mBACnDtD,GAYX3hC,EAAYgiC,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCjiC,EAAY2S,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMxhC,YAChFmZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQgH,IAAMwc,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQqvC,OAASxD,EAAMiI,OAAO92B,OAAOwG,EAAQA,EAAO0oB,UACpD,MACJ,KAAK,EACDlsC,EAAQsvC,kBAAoB9rB,EAAOorB,OACnC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXqK,EAAYsiC,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC7hC,EAAYuiC,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAAmB,MAAf9rC,EAAQgH,KAAehH,EAAQoI,eAAe,SAC9C0jC,EAAWzO,MAAQ,GACduO,EAAMiB,SAAS7sC,EAAQgH,MACxB,MAAO,uBAEf,GAAsB,MAAlBhH,EAAQqvC,QAAkBrvC,EAAQoI,eAAe,UAAW,CAC5D,GAAyB,IAArB0jC,EAAWzO,MACX,MAAO,yBACXyO,EAAWzO,MAAQ,EAEf,IAAIz9B,EAAQisC,EAAMiI,OAAOlH,OAAO5sC,EAAQqvC,QACxC,GAAIzvC,EACA,MAAO,UAAYA,EAG/B,OAAiC,MAA7BI,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,sBACnB,mBAA9BpI,EAAQsvC,kBACR,sCACR,MAWXjlC,EAAYoc,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMxhC,YACxB,OAAOyiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMxhC,YAGxB,GAFkB,MAAdyiC,EAAO9lC,MACPhH,EAAQgH,IAAM+lC,OAAOD,EAAO9lC,MACX,MAAjB8lC,EAAOuC,OAAgB,CACvB,GAA6B,kBAAlBvC,EAAOuC,OACd,MAAMvB,UAAU,wCACpB9tC,EAAQqvC,OAASxD,EAAMiI,OAAOrtB,WAAWqmB,EAAOuC,QAIpD,OAFgC,MAA5BvC,EAAOwC,oBACPtvC,EAAQsvC,kBAAoBnb,QAAQ2Y,EAAOwC,oBACxCtvC,GAYXqK,EAAY2iC,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAeb,OAdIG,EAAQC,WACRJ,EAAOwC,mBAAoB,GACZ,MAAftvC,EAAQgH,KAAehH,EAAQoI,eAAe,SAC9C0kC,EAAO9lC,IAAMhH,EAAQgH,IACjBimC,EAAQ4B,SACR/B,EAAOzP,MAAQ,QAED,MAAlBr9B,EAAQqvC,QAAkBrvC,EAAQoI,eAAe,YACjD0kC,EAAOuC,OAASxD,EAAMiI,OAAO9G,SAAShtC,EAAQqvC,OAAQpC,GAClDA,EAAQ4B,SACR/B,EAAOzP,MAAQ,WAEU,MAA7Br9B,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,uBAC5D0kC,EAAOwC,kBAAoBtvC,EAAQsvC,mBAChCxC,GAUXziC,EAAY0hC,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDljC,EAnQqC,GAsQ1BwhC,EAAMiI,OAAU,WAkBlC,SAASA,EAAOhI,GACZ,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLA0zB,EAAO/H,UAAU+F,KAAO,GAQxBgC,EAAO/H,UAAUrY,OAAS,GAU1BogB,EAAO31B,OAAS,SAAgB2tB,GAC5B,OAAO,IAAIgI,EAAOhI,IAYtBgI,EAAOtyB,OAAS,SAAgBxhB,EAASgsC,GAOrC,OANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ8xC,MAAgB3lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ8xC,MACtC,MAAlB9xC,EAAQ0zB,QAAkBvH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ0zB,QACrDsY,GAYX8H,EAAOzH,gBAAkB,SAAyBrsC,EAASgsC,GACvD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCwH,EAAO92B,OAAS,SAAgBwG,EAAQd,GAC9Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMiI,OAChFtwB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ8xC,KAAOtuB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQ0zB,OAASlQ,EAAO2oB,SACxB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX8zC,EAAOnH,gBAAkB,SAAyBnpB,GAG9C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC4H,EAAOlH,OAAS,SAAgB5sC,GAC5B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ8xC,MACjB,wBACO,MAAlB9xC,EAAQ0zB,QAAkB1zB,EAAQoI,eAAe,YAC5CwjC,EAAMiB,SAAS7sC,EAAQ0zB,QACjB,0BACR,MAWXogB,EAAOrtB,WAAa,SAAoBqmB,GACpC,GAAIA,aAAkBjB,EAAMiI,OACxB,OAAOhH,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMiI,OAKxB,OAJmB,MAAfhH,EAAOgF,OACP9xC,EAAQ8xC,KAAO/E,OAAOD,EAAOgF,OACZ,MAAjBhF,EAAOpZ,SACP1zB,EAAQ0zB,OAASqZ,OAAOD,EAAOpZ,SAC5B1zB,GAYX8zC,EAAO9G,SAAW,SAAkBhtC,EAASitC,GACpCA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAOgF,KAAO,GACdhF,EAAOpZ,OAAS,IAEA,MAAhB1zB,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC/C0kC,EAAOgF,KAAO9xC,EAAQ8xC,MACJ,MAAlB9xC,EAAQ0zB,QAAkB1zB,EAAQoI,eAAe,YACjD0kC,EAAOpZ,OAAS1zB,EAAQ0zB,QACrBoZ,GAUXgH,EAAO/H,UAAUsB,OAAS,WACtB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDuG,EA/M2B,GAkNdjI,EAAMhhC,SAAY,WAiBtC,SAASA,EAASihC,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmKhD,OA1JAvV,EAASkhC,UAAU3lC,MAAQ,EAU3ByE,EAASsT,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIjhC,EAASihC,IAYxBjhC,EAAS2W,OAAS,SAAgBxhB,EAASgsC,GAKvC,OAJKA,IACDA,EAASL,EAAQxtB,UACA,MAAjBne,EAAQoG,OAAiB+lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,GAAGA,OAAOlsC,EAAQoG,OACpD4lC,GAYXnhC,EAASwhC,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCzhC,EAASmS,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMhhC,SAChF2Y,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQoG,MAAQod,EAAO0oB,SACvB,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX6K,EAAS8hC,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCrhC,EAAS+hC,OAAS,SAAgB5sC,GAC9B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACU,MAAjBA,EAAQoG,OAAiBpG,EAAQoI,eAAe,WAC3CwjC,EAAMiC,UAAU7tC,EAAQoG,OAClB,0BACR,MAWXyE,EAAS4b,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMhhC,SACxB,OAAOiiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMhhC,SAGxB,OAFoB,MAAhBiiC,EAAO1mC,QACPpG,EAAQoG,MAAQ0mC,EAAO1mC,QAAU,GAC9BpG,GAYX6K,EAASmiC,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAO1mC,MAAQ,GACE,MAAjBpG,EAAQoG,OAAiBpG,EAAQoI,eAAe,WAChD0kC,EAAO1mC,MAAQpG,EAAQoG,OACpB0mC,GAUXjiC,EAASkhC,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD1iC,EAxL+B,GA2LrBghC,EAAM/gC,MAAS,WAoBhC,SAASA,EAAMghC,GAEX,GADAttC,KAAKyuC,QAAU,GACXnB,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmPhD,OA1OAtV,EAAMihC,UAAUt2B,GAAK,GAQrB3K,EAAMihC,UAAUp2B,MAAQ,GAQxB7K,EAAMihC,UAAN,QAA6B,EAQ7BjhC,EAAMihC,UAAUkB,QAAUrB,EAAMoD,WAUhClkC,EAAMqT,OAAS,SAAgB2tB,GAC3B,OAAO,IAAIhhC,EAAMghC,IAYrBhhC,EAAM0W,OAAS,SAAgBxhB,EAASgsC,GASpC,GARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAO,SACnC,MAAnBA,EAAQitC,SAAmBjtC,EAAQitC,QAAQvqB,OAC3C,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQitC,QAAQvqB,SAAUtC,EAC1C4rB,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQitC,QAAQ7sB,IACxE,OAAO4rB,GAYXlhC,EAAMuhC,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCxhC,EAAMkS,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM/gC,MAChF0Y,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAO4oB,QAC5B,MACJ,KAAK,EACKpsC,EAAQitC,SAAWjtC,EAAQitC,QAAQvqB,SACrC1iB,EAAQitC,QAAU,IACtBjtC,EAAQitC,QAAQzpC,KAAKggB,EAAO2oB,UAC5B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX8K,EAAM6hC,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCphC,EAAM8hC,OAAS,SAAgB5sC,GAC3B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAA0B,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aAChDwjC,EAAMiC,UAAU7tC,EAAO,SACxB,MAAO,4BACf,GAAuB,MAAnBA,EAAQitC,SAAmBjtC,EAAQoI,eAAe,WAAY,CAC9D,IAAKuxB,MAAMuV,QAAQlvC,EAAQitC,SACvB,MAAO,0BACX,IAAK,IAAI7sB,EAAI,EAAGA,EAAIpgB,EAAQitC,QAAQvqB,SAAUtC,EAC1C,IAAKwrB,EAAMiB,SAAS7sC,EAAQitC,QAAQ7sB,IAChC,MAAO,6BAEnB,OAAO,MAWXtV,EAAM2b,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAM/gC,MACxB,OAAOgiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM/gC,MAOxB,GANiB,MAAbgiC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAkC,EAApB8sC,EAAM,SAC3BA,EAAOG,QAAS,CAChB,IAAKtT,MAAMuV,QAAQpC,EAAOG,SACtB,MAAMa,UAAU,kCACpB9tC,EAAQitC,QAAU,GAClB,IAAK,IAAI7sB,EAAI,EAAGA,EAAI0sB,EAAOG,QAAQvqB,SAAUtC,EACzCpgB,EAAQitC,QAAQ7sB,GAAK2sB,OAAOD,EAAOG,QAAQ7sB,IAEnD,OAAOpgB,GAYX8K,EAAMkiC,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAcb,IAbIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOG,QAAU,IACjBA,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,QAAc,GAEN,MAAd9sC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SAC3BA,EAAQitC,SAAWjtC,EAAQitC,QAAQvqB,OAAQ,CAC3CoqB,EAAOG,QAAU,GACjB,IAAK,IAAImC,EAAI,EAAGA,EAAIpvC,EAAQitC,QAAQvqB,SAAU0sB,EAC1CtC,EAAOG,QAAQmC,GAAKpvC,EAAQitC,QAAQmC,GAE5C,OAAOtC,GAUXhiC,EAAMihC,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDziC,EA5QyB,GA+QJ+gC,EAAMiH,iBAAoB,WAkBtD,SAASA,EAAiBhH,GACtB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLA0yB,EAAiB/G,UAAU9jC,MAAQ,GAQnC6qC,EAAiB/G,UAAU3+B,QAAU,GAUrC0lC,EAAiB30B,OAAS,SAAgB2tB,GACtC,OAAO,IAAIgH,EAAiBhH,IAYhCgH,EAAiBtxB,OAAS,SAAgBxhB,EAASgsC,GAO/C,OANKA,IACDA,EAASL,EAAQxtB,UACA,MAAjBne,EAAQiI,OAAiBkkB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQiI,OACrC,MAAnBjI,EAAQoN,SAAmB+e,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAC/DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQoN,SACrD4+B,GAYX8G,EAAiBzG,gBAAkB,SAAyBrsC,EAASgsC,GACjE,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCwG,EAAiB91B,OAAS,SAAgBwG,EAAQd,GACxCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMiH,iBAChFtvB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQiI,MAAQub,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAQoN,QAAUoW,EAAO2oB,SACzB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX8yC,EAAiBnG,gBAAkB,SAAyBnpB,GAGxD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC4G,EAAiBlG,OAAS,SAAgB5sC,GACtC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACU,MAAjBA,EAAQiI,OAAiBjI,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQiI,OACjB,yBACQ,MAAnBjI,EAAQoN,SAAmBpN,EAAQoI,eAAe,aAC7CwjC,EAAMiB,SAAS7sC,EAAQoN,SACjB,2BACR,MAWX0lC,EAAiBrsB,WAAa,SAAoBqmB,GAC9C,GAAIA,aAAkBjB,EAAMiH,iBACxB,OAAOhG,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMiH,iBAKxB,OAJoB,MAAhBhG,EAAO7kC,QACPjI,EAAQiI,MAAQ8kC,OAAOD,EAAO7kC,QACZ,MAAlB6kC,EAAO1/B,UACPpN,EAAQoN,QAAU2/B,OAAOD,EAAO1/B,UAC7BpN,GAYX8yC,EAAiB9F,SAAW,SAAkBhtC,EAASitC,GAC9CA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAO7kC,MAAQ,GACf6kC,EAAO1/B,QAAU,IAEA,MAAjBpN,EAAQiI,OAAiBjI,EAAQoI,eAAe,WAChD0kC,EAAO7kC,MAAQjI,EAAQiI,OACJ,MAAnBjI,EAAQoN,SAAmBpN,EAAQoI,eAAe,aAClD0kC,EAAO1/B,QAAUpN,EAAQoN,SACtB0/B,GAUXgG,EAAiB/G,UAAUsB,OAAS,WAChC,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDuF,EA/M+C,GAkNjCjH,EAAM9gC,UAAa,WAoBxC,SAASA,EAAU+gC,GAEf,GADAttC,KAAKyuC,QAAU,GACXnB,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmPhD,OA1OArV,EAAUghC,UAAUt2B,GAAK,GAQzB1K,EAAUghC,UAAUp2B,MAAQ,GAQ5B5K,EAAUghC,UAAV,QAAiC,EAQjChhC,EAAUghC,UAAUkB,QAAUrB,EAAMoD,WAUpCjkC,EAAUoT,OAAS,SAAgB2tB,GAC/B,OAAO,IAAI/gC,EAAU+gC,IAYzB/gC,EAAUyW,OAAS,SAAgBxhB,EAASgsC,GASxC,GARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAO,SACnC,MAAnBA,EAAQitC,SAAmBjtC,EAAQitC,QAAQvqB,OAC3C,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQitC,QAAQvqB,SAAUtC,EAC1C4rB,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQitC,QAAQ7sB,IACxE,OAAO4rB,GAYXjhC,EAAUshC,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCvhC,EAAUiS,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM9gC,UAChFyY,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAO4oB,QAC5B,MACJ,KAAK,EACKpsC,EAAQitC,SAAWjtC,EAAQitC,QAAQvqB,SACrC1iB,EAAQitC,QAAU,IACtBjtC,EAAQitC,QAAQzpC,KAAKggB,EAAO2oB,UAC5B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX+K,EAAU4hC,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCnhC,EAAU6hC,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAA0B,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aAChDwjC,EAAMiC,UAAU7tC,EAAO,SACxB,MAAO,4BACf,GAAuB,MAAnBA,EAAQitC,SAAmBjtC,EAAQoI,eAAe,WAAY,CAC9D,IAAKuxB,MAAMuV,QAAQlvC,EAAQitC,SACvB,MAAO,0BACX,IAAK,IAAI7sB,EAAI,EAAGA,EAAIpgB,EAAQitC,QAAQvqB,SAAUtC,EAC1C,IAAKwrB,EAAMiB,SAAS7sC,EAAQitC,QAAQ7sB,IAChC,MAAO,6BAEnB,OAAO,MAWXrV,EAAU0b,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAM9gC,UACxB,OAAO+hC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM9gC,UAOxB,GANiB,MAAb+hC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAkC,EAApB8sC,EAAM,SAC3BA,EAAOG,QAAS,CAChB,IAAKtT,MAAMuV,QAAQpC,EAAOG,SACtB,MAAMa,UAAU,sCACpB9tC,EAAQitC,QAAU,GAClB,IAAK,IAAI7sB,EAAI,EAAGA,EAAI0sB,EAAOG,QAAQvqB,SAAUtC,EACzCpgB,EAAQitC,QAAQ7sB,GAAK2sB,OAAOD,EAAOG,QAAQ7sB,IAEnD,OAAOpgB,GAYX+K,EAAUiiC,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAcb,IAbIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOG,QAAU,IACjBA,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,QAAc,GAEN,MAAd9sC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SAC3BA,EAAQitC,SAAWjtC,EAAQitC,QAAQvqB,OAAQ,CAC3CoqB,EAAOG,QAAU,GACjB,IAAK,IAAImC,EAAI,EAAGA,EAAIpvC,EAAQitC,QAAQvqB,SAAU0sB,EAC1CtC,EAAOG,QAAQmC,GAAKpvC,EAAQitC,QAAQmC,GAE5C,OAAOtC,GAUX/hC,EAAUghC,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDxiC,EA5QiC,GA+QhB8gC,EAAMgH,aAAgB,WAmB9C,SAASA,EAAa/G,GAClB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA4BhD,IAAIouB,EAqNJ,OAxOAqE,EAAa9G,UAAU/3B,qBAAsB,EAQ7C6+B,EAAa9G,UAAUgI,0BAA2B,EAQlDlB,EAAa9G,UAAUhX,2BAA6B,KAWpD5I,OAAOsiB,eAAeoE,EAAa9G,UAAW,OAAQ,CAClDltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,sBAAuB,2BAA4B,+BAC1F5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BqE,EAAa10B,OAAS,SAAgB2tB,GAClC,OAAO,IAAI+G,EAAa/G,IAY5B+G,EAAarxB,OAAS,SAAgBxhB,EAASgsC,GAS3C,OARKA,IACDA,EAASL,EAAQxtB,UACc,MAA/Bne,EAAQgU,qBAA+BmY,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,wBAC3EgsC,EAAOE,OAA8B,GAAG0C,KAAK5uC,EAAQgU,qBACjB,MAApChU,EAAQ+zC,0BAAoC5nB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,6BAChFgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ+zC,0BAChB,MAAtC/zC,EAAQ+0B,4BAAsC5I,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,+BAClF6rC,EAAMsG,UAAU3wB,OAAOxhB,EAAQ+0B,2BAA4BiX,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzGN,GAYX6G,EAAaxG,gBAAkB,SAAyBrsC,EAASgsC,GAC7D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCuG,EAAa71B,OAAS,SAAgBwG,EAAQd,GACpCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMgH,aAChFrvB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQgU,oBAAsBwP,EAAOorB,OACrC,MACJ,KAAK,EACD5uC,EAAQ+zC,yBAA2BvwB,EAAOorB,OAC1C,MACJ,KAAK,EACD5uC,EAAQ+0B,2BAA6B8W,EAAMsG,UAAUn1B,OAAOwG,EAAQA,EAAO0oB,UAC3E,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX6yC,EAAalG,gBAAkB,SAAyBnpB,GAGpD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC2G,EAAajG,OAAS,SAAgB5sC,GAClC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAAmC,MAA/B9rC,EAAQgU,qBAA+BhU,EAAQoI,eAAe,yBAC9D0jC,EAAW9sC,KAAO,EACyB,mBAAhCgB,EAAQgU,qBACf,MAAO,wCAEf,GAAwC,MAApChU,EAAQ+zC,0BAAoC/zC,EAAQoI,eAAe,4BAA6B,CAChG,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBAEX,GADA8sC,EAAW9sC,KAAO,EAC8B,mBAArCgB,EAAQ+zC,yBACf,MAAO,6CAEf,GAA0C,MAAtC/zC,EAAQ+0B,4BAAsC/0B,EAAQoI,eAAe,8BAA+B,CACpG,GAAwB,IAApB0jC,EAAW9sC,KACX,MAAO,wBACX8sC,EAAW9sC,KAAO,EAEd,IAAIY,EAAQisC,EAAMsG,UAAUvF,OAAO5sC,EAAQ+0B,4BAC3C,GAAIn1B,EACA,MAAO,8BAAgCA,EAGnD,OAAO,MAWXizC,EAAapsB,WAAa,SAAoBqmB,GAC1C,GAAIA,aAAkBjB,EAAMgH,aACxB,OAAO/F,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMgH,aAKxB,GAJkC,MAA9B/F,EAAO94B,sBACPhU,EAAQgU,oBAAsBmgB,QAAQ2Y,EAAO94B,sBACV,MAAnC84B,EAAOiH,2BACP/zC,EAAQ+zC,yBAA2B5f,QAAQ2Y,EAAOiH,2BACb,MAArCjH,EAAO/X,2BAAoC,CAC3C,GAAiD,kBAAtC+X,EAAO/X,2BACd,MAAM+Y,UAAU,6DACpB9tC,EAAQ+0B,2BAA6B8W,EAAMsG,UAAU1rB,WAAWqmB,EAAO/X,4BAE3E,OAAO/0B,GAYX6yC,EAAa7F,SAAW,SAAkBhtC,EAASitC,GAC1CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAgBb,OAfmC,MAA/B9sC,EAAQgU,qBAA+BhU,EAAQoI,eAAe,yBAC9D0kC,EAAO94B,oBAAsBhU,EAAQgU,oBACjCi5B,EAAQ4B,SACR/B,EAAO9tC,KAAO,wBAEkB,MAApCgB,EAAQ+zC,0BAAoC/zC,EAAQoI,eAAe,8BACnE0kC,EAAOiH,yBAA2B/zC,EAAQ+zC,yBACtC9G,EAAQ4B,SACR/B,EAAO9tC,KAAO,6BAEoB,MAAtCgB,EAAQ+0B,4BAAsC/0B,EAAQoI,eAAe,gCACrE0kC,EAAO/X,2BAA6B8W,EAAMsG,UAAUnF,SAAShtC,EAAQ+0B,2BAA4BkY,GAC7FA,EAAQ4B,SACR/B,EAAO9tC,KAAO,+BAEf8tC,GAUX+F,EAAa9G,UAAUsB,OAAS,WAC5B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDsF,EAxQuC,GA2QtBhH,EAAM+G,aAAgB,WAkB9C,SAASA,EAAa9G,GAClB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAyLhD,OAhLAwyB,EAAa7G,UAAU9yB,WAAY,EAQnC25B,EAAa7G,UAAUxX,iBAAkB,EAUzCqe,EAAaz0B,OAAS,SAAgB2tB,GAClC,OAAO,IAAI8G,EAAa9G,IAY5B8G,EAAapxB,OAAS,SAAgBxhB,EAASgsC,GAO3C,OANKA,IACDA,EAASL,EAAQxtB,UACI,MAArBne,EAAQiZ,WAAqBkT,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,GAAG0C,KAAK5uC,EAAQiZ,WAC1B,MAA3BjZ,EAAQu0B,iBAA2BpI,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,oBACvEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQu0B,iBACnDyX,GAYX4G,EAAavG,gBAAkB,SAAyBrsC,EAASgsC,GAC7D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCsG,EAAa51B,OAAS,SAAgBwG,EAAQd,GACpCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM+G,aAChFpvB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQiZ,UAAYuK,EAAOorB,OAC3B,MACJ,KAAK,EACD5uC,EAAQu0B,gBAAkB/Q,EAAOorB,OACjC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX4yC,EAAajG,gBAAkB,SAAyBnpB,GAGpD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC0G,EAAahG,OAAS,SAAgB5sC,GAClC,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACc,MAArBA,EAAQiZ,WAAqBjZ,EAAQoI,eAAe,cACnB,mBAAtBpI,EAAQiZ,UACR,8BACgB,MAA3BjZ,EAAQu0B,iBAA2Bv0B,EAAQoI,eAAe,oBACnB,mBAA5BpI,EAAQu0B,gBACR,oCACR,MAWXqe,EAAansB,WAAa,SAAoBqmB,GAC1C,GAAIA,aAAkBjB,EAAM+G,aACxB,OAAO9F,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM+G,aAKxB,OAJwB,MAApB9F,EAAO7zB,YACPjZ,EAAQiZ,UAAYkb,QAAQ2Y,EAAO7zB,YACT,MAA1B6zB,EAAOvY,kBACPv0B,EAAQu0B,gBAAkBJ,QAAQ2Y,EAAOvY,kBACtCv0B,GAYX4yC,EAAa5F,SAAW,SAAkBhtC,EAASitC,GAC1CA,IACDA,EAAU,IACd,IAAIH,EAAS,GASb,OARIG,EAAQC,WACRJ,EAAO7zB,WAAY,EACnB6zB,EAAOvY,iBAAkB,GAEJ,MAArBv0B,EAAQiZ,WAAqBjZ,EAAQoI,eAAe,eACpD0kC,EAAO7zB,UAAYjZ,EAAQiZ,WACA,MAA3BjZ,EAAQu0B,iBAA2Bv0B,EAAQoI,eAAe,qBAC1D0kC,EAAOvY,gBAAkBv0B,EAAQu0B,iBAC9BuY,GAUX8F,EAAa7G,UAAUsB,OAAS,WAC5B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDqF,EA/MuC,GAkN5B/G,EAAM7gC,OAAU,WAwBlC,SAASA,EAAO8gC,GAEZ,GADAttC,KAAA,QAAkB,GACdstC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA+XhD,OAtXApV,EAAO+gC,UAAUt2B,GAAK,GAQtBzK,EAAO+gC,UAAUp2B,MAAQ,GAQzB3K,EAAO+gC,UAAUrV,OAAS,GAQ1B1rB,EAAO+gC,UAAU4H,SAAW,EAQ5B3oC,EAAO+gC,UAAP,QAA8BH,EAAMoD,WAQpChkC,EAAO+gC,UAAUx/B,IAAM,EAQvBvB,EAAO+gC,UAAUl5B,IAAM,EAQvB7H,EAAO+gC,UAAU6H,KAAO,EAUxB5oC,EAAOmT,OAAS,SAAgB2tB,GAC5B,OAAO,IAAI9gC,EAAO8gC,IAYtB9gC,EAAOwW,OAAS,SAAgBxhB,EAASgsC,GASrC,GARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OACtC,MAAlB3V,EAAQ02B,QAAkBvK,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ02B,QAClC,MAAtB12B,EAAO,SAAuBA,EAAO,QAAY0iB,OAAQ,CACzDspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAO,QAAY0iB,SAAUtC,EAC7C4rB,EAAOmF,OAAOnxC,EAAO,QAAYogB,IACrC4rB,EAAOM,SAUX,OARmB,MAAftsC,EAAQuM,KAAe4f,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIiF,OAAOnxC,EAAQuM,KACzC,MAAfvM,EAAQ6S,KAAesZ,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA+B,IAAIiF,OAAOnxC,EAAQ6S,KACzC,MAAhB7S,EAAQ4zC,MAAgBznB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA+B,IAAIiF,OAAOnxC,EAAQ4zC,MACrC,MAApB5zC,EAAQ2zC,UAAoBxnB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA+B,IAAIE,MAAMpsC,EAAQ2zC,UACrD3H,GAYXhhC,EAAOqhC,gBAAkB,SAAyBrsC,EAASgsC,GACvD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCthC,EAAOgS,OAAS,SAAgBwG,EAAQd,GAC9Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM7gC,OAChFwY,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAQ02B,OAASlT,EAAO2oB,SACxB,MACJ,KAAK,GACDnsC,EAAQ2zC,SAAWnwB,EAAO4oB,QAC1B,MACJ,KAAK,EAGD,GAFMpsC,EAAO,SAAeA,EAAO,QAAY0iB,SAC3C1iB,EAAO,QAAc,IACP,KAAP,EAANysC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAO,QAAYwD,KAAKggB,EAAO2tB,eAEnCnxC,EAAO,QAAYwD,KAAKggB,EAAO2tB,UACnC,MACJ,KAAK,EACDnxC,EAAQuM,IAAMiX,EAAO2tB,SACrB,MACJ,KAAK,GACDnxC,EAAQ6S,IAAM2Q,EAAO2tB,SACrB,MACJ,KAAK,GACDnxC,EAAQ4zC,KAAOpwB,EAAO2tB,SACtB,MACJ,QACI3tB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXgL,EAAO2hC,gBAAkB,SAAyBnpB,GAG9C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtClhC,EAAO4hC,OAAS,SAAgB5sC,GAC5B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAAsB,MAAlB3V,EAAQ02B,QAAkB12B,EAAQoI,eAAe,YAC5CwjC,EAAMiB,SAAS7sC,EAAQ02B,QACxB,MAAO,0BACf,GAAwB,MAApB12B,EAAQ2zC,UAAoB3zC,EAAQoI,eAAe,YACnD,OAAQpI,EAAQ2zC,UAChB,QACI,MAAO,gCACX,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,GAGT,GAA0B,MAAtB3zC,EAAO,SAAuBA,EAAQoI,eAAe,WAAY,CACjE,IAAKuxB,MAAMuV,QAAQlvC,EAAO,SACtB,MAAO,0BACX,IAAK,IAAIogB,EAAI,EAAGA,EAAIpgB,EAAO,QAAY0iB,SAAUtC,EAC7C,GAAqC,kBAA1BpgB,EAAO,QAAYogB,GAC1B,MAAO,6BAEnB,OAAmB,MAAfpgB,EAAQuM,KAAevM,EAAQoI,eAAe,QACnB,kBAAhBpI,EAAQuM,IACR,uBACI,MAAfvM,EAAQ6S,KAAe7S,EAAQoI,eAAe,QACnB,kBAAhBpI,EAAQ6S,IACR,uBACK,MAAhB7S,EAAQ4zC,MAAgB5zC,EAAQoI,eAAe,SACnB,kBAAjBpI,EAAQ4zC,KACR,wBACR,MAWX5oC,EAAOyb,WAAa,SAAoBqmB,GACpC,GAAIA,aAAkBjB,EAAM7gC,OACxB,OAAO8hC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM7gC,OAOxB,OANiB,MAAb8hC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACb,MAAjBm3B,EAAOpW,SACP12B,EAAQ02B,OAASqW,OAAOD,EAAOpW,SAC3BoW,EAAO6G,UACf,IAAK,MACL,KAAK,EACD3zC,EAAQ2zC,SAAW,EACnB,MACJ,IAAK,QACL,KAAK,EACD3zC,EAAQ2zC,SAAW,EACnB,MACJ,IAAK,WACL,KAAK,EACD3zC,EAAQ2zC,SAAW,EACnB,MACJ,IAAK,OACL,KAAK,EACD3zC,EAAQ2zC,SAAW,EACnB,MACJ,IAAK,OACL,KAAK,EACD3zC,EAAQ2zC,SAAW,EAGvB,GAAI7G,EAAM,QAAa,CACnB,IAAKnT,MAAMuV,QAAQpC,EAAM,SACrB,MAAMgB,UAAU,mCACpB9tC,EAAO,QAAc,GACrB,IAAK,IAAIogB,EAAI,EAAGA,EAAI0sB,EAAM,QAAYpqB,SAAUtC,EAC5CpgB,EAAO,QAAYogB,GAAKyX,OAAOiV,EAAM,QAAY1sB,IAQzD,OANkB,MAAd0sB,EAAOvgC,MACPvM,EAAQuM,IAAMsrB,OAAOiV,EAAOvgC,MACd,MAAdugC,EAAOj6B,MACP7S,EAAQ6S,IAAMglB,OAAOiV,EAAOj6B,MACb,MAAfi6B,EAAO8G,OACP5zC,EAAQ4zC,KAAO/b,OAAOiV,EAAO8G,OAC1B5zC,GAYXgL,EAAOgiC,SAAW,SAAkBhtC,EAASitC,GACpCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAkBb,IAjBIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAM,QAAc,IACpBG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAOpW,OAAS,GAChBoW,EAAOvgC,IAAM,EACbugC,EAAOj6B,IAAM,EACbi6B,EAAO8G,KAAO,EACd9G,EAAO6G,SAAW1G,EAAQE,QAAUJ,OAAS,MAAQ,GAEvC,MAAd/sC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACL,MAAlB3V,EAAQ02B,QAAkB12B,EAAQoI,eAAe,YACjD0kC,EAAOpW,OAAS12B,EAAQ02B,QACxB12B,EAAO,SAAeA,EAAO,QAAY0iB,OAAQ,CACjDoqB,EAAM,QAAc,GACpB,IAAK,IAAIsC,EAAI,EAAGA,EAAIpvC,EAAO,QAAY0iB,SAAU0sB,EAC7CtC,EAAM,QAAYsC,GAAKnC,EAAQz/B,OAAS4jC,SAASpxC,EAAO,QAAYovC,IAAMrC,OAAO/sC,EAAO,QAAYovC,IAAMpvC,EAAO,QAAYovC,GAUrI,OARmB,MAAfpvC,EAAQuM,KAAevM,EAAQoI,eAAe,SAC9C0kC,EAAOvgC,IAAM0gC,EAAQz/B,OAAS4jC,SAASpxC,EAAQuM,KAAOwgC,OAAO/sC,EAAQuM,KAAOvM,EAAQuM,KACrE,MAAfvM,EAAQ6S,KAAe7S,EAAQoI,eAAe,SAC9C0kC,EAAOj6B,IAAMo6B,EAAQz/B,OAAS4jC,SAASpxC,EAAQ6S,KAAOk6B,OAAO/sC,EAAQ6S,KAAO7S,EAAQ6S,KACpE,MAAhB7S,EAAQ4zC,MAAgB5zC,EAAQoI,eAAe,UAC/C0kC,EAAO8G,KAAO3G,EAAQz/B,OAAS4jC,SAASpxC,EAAQ4zC,MAAQ7G,OAAO/sC,EAAQ4zC,MAAQ5zC,EAAQ4zC,MACnE,MAApB5zC,EAAQ2zC,UAAoB3zC,EAAQoI,eAAe,cACnD0kC,EAAO6G,SAAW1G,EAAQE,QAAUJ,OAASlB,EAAM7gC,OAAO6oC,SAAS7zC,EAAQ2zC,UAAY3zC,EAAQ2zC,UAC5F7G,GAUX9hC,EAAO+gC,UAAUsB,OAAS,WACtB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAa1DviC,EAAO6oC,SAAY,WACf,IAAMrG,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAM9C,OALAC,EAAOD,EAAW,GAAK,OAAS,EAChCC,EAAOD,EAAW,GAAK,SAAW,EAClCC,EAAOD,EAAW,GAAK,YAAc,EACrCC,EAAOD,EAAW,GAAK,QAAU,EACjCC,EAAOD,EAAW,GAAK,QAAU,EAC1BC,EAPQ,GAUZziC,EA5Z2B,IA+ZzB6Z,EAAiBgnB,EAAMhnB,eAAkB,WAwBlD,SAASA,EAAeinB,GACpB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAkVhD,OAzUAyE,EAAeknB,UAAUntC,KAAO,GAQhCimB,EAAeknB,UAAUrvB,YAAc,EAQvCmI,EAAeknB,UAAUnnB,aAAe,EAQxCC,EAAeknB,UAAU9mB,wBAA0B,GAQnDJ,EAAeknB,UAAUiI,iBAAmB,GAQ5CnvB,EAAeknB,UAAUkI,iBAAmB,GAQ5CpvB,EAAeknB,UAAUzmB,WAAa,EAQtCT,EAAeknB,UAAUvmB,eAAiB,GAU1CX,EAAe1G,OAAS,SAAgB2tB,GACpC,OAAO,IAAIjnB,EAAeinB,IAY9BjnB,EAAerD,OAAS,SAAgBxhB,EAASgsC,GAmB7C,OAlBKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQpB,MAAgButB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQpB,MACjC,MAAvBoB,EAAQ0c,aAAuByP,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnEgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQ0c,aAChC,MAAxB1c,EAAQ4kB,cAAwBuH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,iBACpEgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQ4kB,cACpB,MAAnC5kB,EAAQilB,yBAAmCkH,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,4BAC/EgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQilB,yBAC5B,MAA5BjlB,EAAQg0C,kBAA4B7nB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,qBACxEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQg0C,kBAC5B,MAA5Bh0C,EAAQi0C,kBAA4B9nB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,qBACxEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQi0C,kBAClC,MAAtBj0C,EAAQslB,YAAsB6G,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClEgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQslB,YAC9B,MAA1BtlB,EAAQwlB,gBAA0B2G,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,mBACtEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQwlB,gBACrDwmB,GAYXnnB,EAAewnB,gBAAkB,SAAyBrsC,EAASgsC,GAC/D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCznB,EAAe7H,OAAS,SAAgBwG,EAAQd,GACtCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMhnB,eAChFrB,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQpB,KAAO4kB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQ0c,YAAc8G,EAAO0oB,SAC7B,MACJ,KAAK,EACDlsC,EAAQ4kB,aAAepB,EAAO4oB,QAC9B,MACJ,KAAK,EACDpsC,EAAQilB,wBAA0BzB,EAAO2oB,SACzC,MACJ,KAAK,EACDnsC,EAAQg0C,iBAAmBxwB,EAAO2oB,SAClC,MACJ,KAAK,EACDnsC,EAAQi0C,iBAAmBzwB,EAAO2oB,SAClC,MACJ,KAAK,EACDnsC,EAAQslB,WAAa9B,EAAO0oB,SAC5B,MACJ,KAAK,EACDlsC,EAAQwlB,eAAiBhC,EAAO2oB,SAChC,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX6kB,EAAe8nB,gBAAkB,SAAyBnpB,GAGtD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCrnB,EAAe+nB,OAAS,SAAgB5sC,GACpC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQpB,MACxB,MAAO,wBACf,GAA2B,MAAvBoB,EAAQ0c,aAAuB1c,EAAQoI,eAAe,iBACjDwjC,EAAMiC,UAAU7tC,EAAQ0c,aACzB,MAAO,gCACf,GAA4B,MAAxB1c,EAAQ4kB,cAAwB5kB,EAAQoI,eAAe,gBACvD,OAAQpI,EAAQ4kB,cAChB,QACI,MAAO,oCACX,KAAK,EACL,KAAK,GAGT,OAAuC,MAAnC5kB,EAAQilB,yBAAmCjlB,EAAQoI,eAAe,6BAC7DwjC,EAAMiB,SAAS7sC,EAAQilB,yBACjB,2CACiB,MAA5BjlB,EAAQg0C,kBAA4Bh0C,EAAQoI,eAAe,sBACtDwjC,EAAMiB,SAAS7sC,EAAQg0C,kBACjB,oCACiB,MAA5Bh0C,EAAQi0C,kBAA4Bj0C,EAAQoI,eAAe,sBACtDwjC,EAAMiB,SAAS7sC,EAAQi0C,kBACjB,oCACW,MAAtBj0C,EAAQslB,YAAsBtlB,EAAQoI,eAAe,gBAChDwjC,EAAMiC,UAAU7tC,EAAQslB,YAClB,+BACe,MAA1BtlB,EAAQwlB,gBAA0BxlB,EAAQoI,eAAe,oBACpDwjC,EAAMiB,SAAS7sC,EAAQwlB,gBACjB,kCACR,MAWXX,EAAe4B,WAAa,SAAoBqmB,GAC5C,GAAIA,aAAkBjB,EAAMhnB,eACxB,OAAOioB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMhnB,eAKxB,OAJmB,MAAfioB,EAAOluC,OACPoB,EAAQpB,KAAOmuC,OAAOD,EAAOluC,OACP,MAAtBkuC,EAAOpwB,cACP1c,EAAQ0c,YAAcowB,EAAOpwB,cAAgB,GACzCowB,EAAOloB,cACf,IAAK,UACL,KAAK,EACD5kB,EAAQ4kB,aAAe,EACvB,MACJ,IAAK,OACL,KAAK,EACD5kB,EAAQ4kB,aAAe,EAa3B,OAVsC,MAAlCkoB,EAAO7nB,0BACPjlB,EAAQilB,wBAA0B8nB,OAAOD,EAAO7nB,0BACrB,MAA3B6nB,EAAOkH,mBACPh0C,EAAQg0C,iBAAmBjH,OAAOD,EAAOkH,mBACd,MAA3BlH,EAAOmH,mBACPj0C,EAAQi0C,iBAAmBlH,OAAOD,EAAOmH,mBACpB,MAArBnH,EAAOxnB,aACPtlB,EAAQslB,WAAawnB,EAAOxnB,aAAe,GAClB,MAAzBwnB,EAAOtnB,iBACPxlB,EAAQwlB,eAAiBunB,OAAOD,EAAOtnB,iBACpCxlB,GAYX6kB,EAAemoB,SAAW,SAAkBhtC,EAASitC,GAC5CA,IACDA,EAAU,IACd,IAAIH,EAAS,GA2Bb,OA1BIG,EAAQC,WACRJ,EAAOluC,KAAO,GACdkuC,EAAOpwB,YAAc,EACrBowB,EAAOloB,aAAeqoB,EAAQE,QAAUJ,OAAS,UAAY,EAC7DD,EAAO7nB,wBAA0B,GACjC6nB,EAAOkH,iBAAmB,GAC1BlH,EAAOmH,iBAAmB,GAC1BnH,EAAOxnB,WAAa,EACpBwnB,EAAOtnB,eAAiB,IAER,MAAhBxlB,EAAQpB,MAAgBoB,EAAQoI,eAAe,UAC/C0kC,EAAOluC,KAAOoB,EAAQpB,MACC,MAAvBoB,EAAQ0c,aAAuB1c,EAAQoI,eAAe,iBACtD0kC,EAAOpwB,YAAc1c,EAAQ0c,aACL,MAAxB1c,EAAQ4kB,cAAwB5kB,EAAQoI,eAAe,kBACvD0kC,EAAOloB,aAAeqoB,EAAQE,QAAUJ,OAASlB,EAAMhnB,eAAeC,aAAa9kB,EAAQ4kB,cAAgB5kB,EAAQ4kB,cAChF,MAAnC5kB,EAAQilB,yBAAmCjlB,EAAQoI,eAAe,6BAClE0kC,EAAO7nB,wBAA0BjlB,EAAQilB,yBACb,MAA5BjlB,EAAQg0C,kBAA4Bh0C,EAAQoI,eAAe,sBAC3D0kC,EAAOkH,iBAAmBh0C,EAAQg0C,kBACN,MAA5Bh0C,EAAQi0C,kBAA4Bj0C,EAAQoI,eAAe,sBAC3D0kC,EAAOmH,iBAAmBj0C,EAAQi0C,kBACZ,MAAtBj0C,EAAQslB,YAAsBtlB,EAAQoI,eAAe,gBACrD0kC,EAAOxnB,WAAatlB,EAAQslB,YACF,MAA1BtlB,EAAQwlB,gBAA0BxlB,EAAQoI,eAAe,oBACzD0kC,EAAOtnB,eAAiBxlB,EAAQwlB,gBAC7BsnB,GAUXjoB,EAAeknB,UAAUsB,OAAS,WAC9B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAU1D1oB,EAAeC,aAAgB,WAC3B,IAAM0oB,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAG9C,OAFAC,EAAOD,EAAW,GAAK,WAAa,EACpCC,EAAOD,EAAW,GAAK,QAAU,EAC1BC,EAJoB,GAOxB5oB,EA9W2C,GAg0BzC1Z,GA/cO0gC,EAAMxnC,KAAQ,WAiB9B,SAASA,EAAKynC,GACV,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmKhD,OA1JA/b,EAAK0nC,UAAUpqC,KAAO,GAUtB0C,EAAK8Z,OAAS,SAAgB2tB,GAC1B,OAAO,IAAIznC,EAAKynC,IAYpBznC,EAAKmd,OAAS,SAAgBxhB,EAASgsC,GAKnC,OAJKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ2B,MAAgBwqB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2B,MACrDqqC,GAYX3nC,EAAKgoC,gBAAkB,SAAyBrsC,EAASgsC,GACrD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCjoC,EAAK2Y,OAAS,SAAgBwG,EAAQd,GAC5Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMxnC,KAChFmf,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ2B,KAAO6hB,EAAO2oB,SACtB,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXqE,EAAKsoC,gBAAkB,SAAyBnpB,GAG5C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC7nC,EAAKuoC,OAAS,SAAgB5sC,GAC1B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACS,MAAhBA,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ2B,MACjB,wBACR,MAWX0C,EAAKoiB,WAAa,SAAoBqmB,GAClC,GAAIA,aAAkBjB,EAAMxnC,KACxB,OAAOyoC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMxnC,KAGxB,OAFmB,MAAfyoC,EAAOnrC,OACP3B,EAAQ2B,KAAOorC,OAAOD,EAAOnrC,OAC1B3B,GAYXqE,EAAK2oC,SAAW,SAAkBhtC,EAASitC,GAClCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAKb,OAJIG,EAAQC,WACRJ,EAAOnrC,KAAO,IACE,MAAhB3B,EAAQ2B,MAAgB3B,EAAQoI,eAAe,UAC/C0kC,EAAOnrC,KAAO3B,EAAQ2B,MACnBmrC,GAUXzoC,EAAK0nC,UAAUsB,OAAS,WACpB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDlpC,EAxLuB,GA2LVwnC,EAAM3gC,SAAY,WAqBtC,SAASA,EAAS4gC,GACd,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAwPhD,OA/OAlV,EAAS6gC,UAAUt2B,GAAK,GAQxBvK,EAAS6gC,UAAUp2B,MAAQ,GAQ3BzK,EAAS6gC,UAAT,QAAgC,GAQhC7gC,EAAS6gC,UAAUtlC,OAAS,EAQ5ByE,EAAS6gC,UAAUmI,SAAW,EAU9BhpC,EAASiT,OAAS,SAAgB2tB,GAC9B,OAAO,IAAI5gC,EAAS4gC,IAYxB5gC,EAASsW,OAAS,SAAgBxhB,EAASgsC,GAavC,OAZKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAO,SACrC,MAAlBA,EAAQyG,QAAkB0lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,WAC9DgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQyG,QACpC,MAApBzG,EAAQk0C,UAAoB/nB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQk0C,UACrDlI,GAYX9gC,EAASmhC,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCphC,EAAS8R,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM3gC,SAChFsY,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAO2oB,SAC5B,MACJ,KAAK,EACDnsC,EAAQyG,OAAS+c,EAAO0oB,SACxB,MACJ,KAAK,EACDlsC,EAAQk0C,SAAW1wB,EAAO0oB,SAC1B,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXkL,EAASyhC,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtChhC,EAAS0hC,OAAS,SAAgB5sC,GAC9B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACO,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACjB,sBACM,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACjB,yBACW,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aAChDwjC,EAAMiB,SAAS7sC,EAAO,SAChB,2BACO,MAAlBA,EAAQyG,QAAkBzG,EAAQoI,eAAe,YAC5CwjC,EAAMiC,UAAU7tC,EAAQyG,QAClB,2BACS,MAApBzG,EAAQk0C,UAAoBl0C,EAAQoI,eAAe,cAC9CwjC,EAAMiC,UAAU7tC,EAAQk0C,UAClB,6BACR,MAWXhpC,EAASub,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAM3gC,SACxB,OAAO4hC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM3gC,SAWxB,OAViB,MAAb4hC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAc+sC,OAAOD,EAAM,UACjB,MAAjBA,EAAOrmC,SACPzG,EAAQyG,OAASqmC,EAAOrmC,SAAW,GAChB,MAAnBqmC,EAAOoH,WACPl0C,EAAQk0C,SAAWpH,EAAOoH,WAAa,GACpCl0C,GAYXkL,EAAS8hC,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAkBb,OAjBIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,QAAc,GACpBA,EAAOrmC,OAAS,EAChBqmC,EAAOoH,SAAW,GAEJ,MAAdl0C,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SACT,MAAlBA,EAAQyG,QAAkBzG,EAAQoI,eAAe,YACjD0kC,EAAOrmC,OAASzG,EAAQyG,QACJ,MAApBzG,EAAQk0C,UAAoBl0C,EAAQoI,eAAe,cACnD0kC,EAAOoH,SAAWl0C,EAAQk0C,UACvBpH,GAUX5hC,EAAS6gC,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDriC,EAjR+B,GAoRjB2gC,EAAM1gC,UAAa,WAqBxC,SAASA,EAAU2gC,GACf,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAmRhD,OA1QAjV,EAAU4gC,UAAUt2B,GAAK,GAQzBtK,EAAU4gC,UAAUp2B,MAAQ,GAQ5BxK,EAAU4gC,UAAV,QAAiC,GAQjC5gC,EAAU4gC,UAAU/sC,KAAO,EAQ3BmM,EAAU4gC,UAAUmI,SAAW,EAU/B/oC,EAAUgT,OAAS,SAAgB2tB,GAC/B,OAAO,IAAI3gC,EAAU2gC,IAYzB3gC,EAAUqW,OAAS,SAAgBxhB,EAASgsC,GAaxC,OAZKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAO,SACvC,MAAhBA,EAAQhB,MAAgBmtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQhB,MACnC,MAApBgB,EAAQk0C,UAAoB/nB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA8B,IAAIA,OAAOlsC,EAAQk0C,UACrDlI,GAYX7gC,EAAUkhC,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCnhC,EAAU6R,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAM1gC,UAChFqY,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAO2oB,SAC5B,MACJ,KAAK,EACDnsC,EAAQhB,KAAOwkB,EAAO4oB,QACtB,MACJ,KAAK,EACDpsC,EAAQk0C,SAAW1wB,EAAO0oB,SAC1B,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXmL,EAAUwhC,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC/gC,EAAUyhC,OAAS,SAAgB5sC,GAC/B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAkB,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAAqB,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACxB,MAAO,yBACf,GAA0B,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aAChDwjC,EAAMiB,SAAS7sC,EAAO,SACvB,MAAO,2BACf,GAAoB,MAAhBA,EAAQhB,MAAgBgB,EAAQoI,eAAe,QAC/C,OAAQpI,EAAQhB,MAChB,QACI,MAAO,4BACX,KAAK,EACL,KAAK,GAGT,OAAwB,MAApBgB,EAAQk0C,UAAoBl0C,EAAQoI,eAAe,cAC9CwjC,EAAMiC,UAAU7tC,EAAQk0C,UAClB,6BACR,MAWX/oC,EAAUsb,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAM1gC,UACxB,OAAO2hC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAM1gC,UAOxB,OANiB,MAAb2hC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAc+sC,OAAOD,EAAM,UAC9BA,EAAO9tC,MACf,IAAK,UACL,KAAK,EACDgB,EAAQhB,KAAO,EACf,MACJ,IAAK,WACL,KAAK,EACDgB,EAAQhB,KAAO,EAKnB,OAFuB,MAAnB8tC,EAAOoH,WACPl0C,EAAQk0C,SAAWpH,EAAOoH,WAAa,GACpCl0C,GAYXmL,EAAU6hC,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAkBb,OAjBIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,QAAc,GACpBA,EAAO9tC,KAAOiuC,EAAQE,QAAUJ,OAAS,UAAY,EACrDD,EAAOoH,SAAW,GAEJ,MAAdl0C,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SACX,MAAhBA,EAAQhB,MAAgBgB,EAAQoI,eAAe,UAC/C0kC,EAAO9tC,KAAOiuC,EAAQE,QAAUJ,OAASlB,EAAM1gC,UAAU4jC,KAAK/uC,EAAQhB,MAAQgB,EAAQhB,MAClE,MAApBgB,EAAQk0C,UAAoBl0C,EAAQoI,eAAe,cACnD0kC,EAAOoH,SAAWl0C,EAAQk0C,UACvBpH,GAUX3hC,EAAU4gC,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAU1DpiC,EAAU4jC,KAAQ,WACd,IAAMvB,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAG9C,OAFAC,EAAOD,EAAW,GAAK,WAAa,EACpCC,EAAOD,EAAW,GAAK,YAAc,EAC9BC,EAJO,GAOXtiC,EA5SiC,IAgzB/BZ,GAjgBYshC,EAAMzgC,UAAa,WAmBxC,SAASA,EAAU0gC,GACf,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA8MhD,OArMAhV,EAAU2gC,UAAUt2B,GAAK,GAQzBrK,EAAU2gC,UAAUp2B,MAAQ,GAQ5BvK,EAAU2gC,UAAV,QAAiC,GAUjC3gC,EAAU+S,OAAS,SAAgB2tB,GAC/B,OAAO,IAAI1gC,EAAU0gC,IAYzB1gC,EAAUoW,OAAS,SAAgBxhB,EAASgsC,GASxC,OARKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IACvC,MAAjBzV,EAAQ2V,OAAiBwW,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,UAC7DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ2V,OAClC,MAAtB3V,EAAO,SAAuBmsB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,YAClEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAO,SACpDgsC,GAYX5gC,EAAUihC,gBAAkB,SAAyBrsC,EAASgsC,GAC1D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxClhC,EAAU4R,OAAS,SAAgBwG,EAAQd,GACjCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMzgC,UAChFoY,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ2V,MAAQ6N,EAAO2oB,SACvB,MACJ,KAAK,EACDnsC,EAAO,QAAcwjB,EAAO2oB,SAC5B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXoL,EAAUuhC,gBAAkB,SAAyBnpB,GAGjD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC9gC,EAAUwhC,OAAS,SAAgB5sC,GAC/B,MAAuB,kBAAZA,GAAoC,OAAZA,EACxB,kBACO,MAAdA,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACjB,sBACM,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAC3CwjC,EAAMiB,SAAS7sC,EAAQ2V,OACjB,yBACW,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aAChDwjC,EAAMiB,SAAS7sC,EAAO,SAChB,2BACR,MAWXoL,EAAUqb,WAAa,SAAoBqmB,GACvC,GAAIA,aAAkBjB,EAAMzgC,UACxB,OAAO0hC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMzgC,UAOxB,OANiB,MAAb0hC,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACX,MAAhBq3B,EAAOn3B,QACP3V,EAAQ2V,MAAQo3B,OAAOD,EAAOn3B,QACT,MAArBm3B,EAAM,UACN9sC,EAAO,QAAc+sC,OAAOD,EAAM,UAC/B9sC,GAYXoL,EAAU4hC,SAAW,SAAkBhtC,EAASitC,GACvCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAOr3B,GAAK,GACZq3B,EAAOn3B,MAAQ,GACfm3B,EAAM,QAAc,IAEN,MAAd9sC,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACH,MAAjBzV,EAAQ2V,OAAiB3V,EAAQoI,eAAe,WAChD0kC,EAAOn3B,MAAQ3V,EAAQ2V,OACD,MAAtB3V,EAAO,SAAuBA,EAAQoI,eAAe,aACrD0kC,EAAM,QAAc9sC,EAAO,SACxB8sC,GAUX1hC,EAAU2gC,UAAUsB,OAAS,WACzB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDniC,EArOiC,GAwOfygC,EAAMvhC,cAAiB,WAoBhD,SAASA,EAAcwhC,GAEnB,GADAttC,KAAKo/B,SAAW,GACZkO,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA6PhD,OApPA9V,EAAcyhC,UAAU+F,KAAO,GAQ/BxnC,EAAcyhC,UAAU1mC,KAAO,KAQ/BiF,EAAcyhC,UAAUnO,SAAWgO,EAAMoD,WAQzC1kC,EAAcyhC,UAAUuD,mBAAoB,EAU5ChlC,EAAc6T,OAAS,SAAgB2tB,GACnC,OAAO,IAAIxhC,EAAcwhC,IAY7BxhC,EAAckX,OAAS,SAAgBxhB,EAASgsC,GAO5C,GANKA,IACDA,EAASL,EAAQxtB,UACD,MAAhBne,EAAQ8xC,MAAgB3lB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQ8xC,MACxC,MAAhB9xC,EAAQqF,MAAgB8mB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5D6rC,EAAM/hC,UAAU0X,OAAOxhB,EAAQqF,KAAM2mC,EAAOE,OAA8B,IAAI0B,QAAQtB,SAClE,MAApBtsC,EAAQ49B,UAAoB59B,EAAQ49B,SAASlb,OAC7C,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQ49B,SAASlb,SAAUtC,EAC3CyrB,EAAMoG,aAAazwB,OAAOxhB,EAAQ49B,SAASxd,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAGxG,OAFiC,MAA7BtsC,EAAQsvC,mBAA6BnjB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,sBACzEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQsvC,mBACnDtD,GAYX1hC,EAAc+hC,gBAAkB,SAAyBrsC,EAASgsC,GAC9D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxChiC,EAAc0S,OAAS,SAAgBwG,EAAQd,GACrCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMvhC,cAChFkZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQ8xC,KAAOtuB,EAAO2oB,SACtB,MACJ,KAAK,EACDnsC,EAAQqF,KAAOwmC,EAAM/hC,UAAUkT,OAAOwG,EAAQA,EAAO0oB,UACrD,MACJ,KAAK,EACKlsC,EAAQ49B,UAAY59B,EAAQ49B,SAASlb,SACvC1iB,EAAQ49B,SAAW,IACvB59B,EAAQ49B,SAASp6B,KAAKqoC,EAAMoG,aAAaj1B,OAAOwG,EAAQA,EAAO0oB,WAC/D,MACJ,KAAK,EACDlsC,EAAQsvC,kBAAoB9rB,EAAOorB,OACnC,MACJ,QACIprB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXsK,EAAcqiC,gBAAkB,SAAyBnpB,GAGrD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC5hC,EAAcsiC,OAAS,SAAgB5sC,GACnC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAoB,MAAhBA,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC1CwjC,EAAMiB,SAAS7sC,EAAQ8xC,MACxB,MAAO,wBACf,GAAoB,MAAhB9xC,EAAQqF,MAAgBrF,EAAQoI,eAAe,QAAS,CACxD,IAAIxI,EAAQisC,EAAM/hC,UAAU8iC,OAAO5sC,EAAQqF,MAC3C,GAAIzF,EACA,MAAO,QAAUA,EAEzB,GAAwB,MAApBI,EAAQ49B,UAAoB59B,EAAQoI,eAAe,YAAa,CAChE,IAAKuxB,MAAMuV,QAAQlvC,EAAQ49B,UACvB,MAAO,2BACX,IAAK,IAAIxd,EAAI,EAAGA,EAAIpgB,EAAQ49B,SAASlb,SAAUtC,EAAG,CAC9C,IAAIxgB,EAAQisC,EAAMoG,aAAarF,OAAO5sC,EAAQ49B,SAASxd,IACvD,GAAIxgB,EACA,MAAO,YAAcA,GAGjC,OAAiC,MAA7BI,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,sBACnB,mBAA9BpI,EAAQsvC,kBACR,sCACR,MAWXhlC,EAAcmc,WAAa,SAAoBqmB,GAC3C,GAAIA,aAAkBjB,EAAMvhC,cACxB,OAAOwiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMvhC,cAGxB,GAFmB,MAAfwiC,EAAOgF,OACP9xC,EAAQ8xC,KAAO/E,OAAOD,EAAOgF,OACd,MAAfhF,EAAOznC,KAAc,CACrB,GAA2B,kBAAhBynC,EAAOznC,KACd,MAAMyoC,UAAU,wCACpB9tC,EAAQqF,KAAOwmC,EAAM/hC,UAAU2c,WAAWqmB,EAAOznC,MAErD,GAAIynC,EAAOlP,SAAU,CACjB,IAAKjE,MAAMuV,QAAQpC,EAAOlP,UACtB,MAAMkQ,UAAU,2CACpB9tC,EAAQ49B,SAAW,GACnB,IAAK,IAAIxd,EAAI,EAAGA,EAAI0sB,EAAOlP,SAASlb,SAAUtC,EAAG,CAC7C,GAAkC,kBAAvB0sB,EAAOlP,SAASxd,GACvB,MAAM0tB,UAAU,4CACpB9tC,EAAQ49B,SAASxd,GAAKyrB,EAAMoG,aAAaxrB,WAAWqmB,EAAOlP,SAASxd,KAK5E,OAFgC,MAA5B0sB,EAAOwC,oBACPtvC,EAAQsvC,kBAAoBnb,QAAQ2Y,EAAOwC,oBACxCtvC,GAYXsK,EAAc0iC,SAAW,SAAkBhtC,EAASitC,GAC3CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,IAXIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOlP,SAAW,IAClBqP,EAAQC,WACRJ,EAAOgF,KAAO,GACdhF,EAAOznC,KAAO,KACdynC,EAAOwC,mBAAoB,GAEX,MAAhBtvC,EAAQ8xC,MAAgB9xC,EAAQoI,eAAe,UAC/C0kC,EAAOgF,KAAO9xC,EAAQ8xC,MACN,MAAhB9xC,EAAQqF,MAAgBrF,EAAQoI,eAAe,UAC/C0kC,EAAOznC,KAAOwmC,EAAM/hC,UAAUkjC,SAAShtC,EAAQqF,KAAM4nC,IACrDjtC,EAAQ49B,UAAY59B,EAAQ49B,SAASlb,OAAQ,CAC7CoqB,EAAOlP,SAAW,GAClB,IAAK,IAAIwR,EAAI,EAAGA,EAAIpvC,EAAQ49B,SAASlb,SAAU0sB,EAC3CtC,EAAOlP,SAASwR,GAAKvD,EAAMoG,aAAajF,SAAShtC,EAAQ49B,SAASwR,GAAInC,GAI9E,OAFiC,MAA7BjtC,EAAQsvC,mBAA6BtvC,EAAQoI,eAAe,uBAC5D0kC,EAAOwC,kBAAoBtvC,EAAQsvC,mBAChCxC,GAUXxiC,EAAcyhC,UAAUsB,OAAS,WAC7B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDjjC,EAtRyC,GAyR/BuhC,EAAMthC,MAAS,WAmBhC,SAASA,EAAMuhC,GACX,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAgPhD,OAvOA7V,EAAMwhC,UAAU/kC,IAAM,GAQtBuD,EAAMwhC,UAAU55B,UAAY,EAQ5B5H,EAAMwhC,UAAU/sC,KAAO,EAUvBuL,EAAM4T,OAAS,SAAgB2tB,GAC3B,OAAO,IAAIvhC,EAAMuhC,IAYrBvhC,EAAMiX,OAAS,SAAgBxhB,EAASgsC,GASpC,OARKA,IACDA,EAASL,EAAQxtB,UACI,MAArBne,EAAQmS,WAAqBga,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQmS,WACvC,MAAhBnS,EAAQhB,MAAgBmtB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,SAC5DgsC,EAAOE,OAA8B,IAAIE,MAAMpsC,EAAQhB,MACxC,MAAfgB,EAAQgH,KAAemlB,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,QAC3DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQgH,KACrDglC,GAYXzhC,EAAM8hC,gBAAkB,SAAyBrsC,EAASgsC,GACtD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC/hC,EAAMyS,OAAS,SAAgBwG,EAAQd,GAC7Bc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMthC,MAChFiZ,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQgH,IAAMwc,EAAO2oB,SACrB,MACJ,KAAK,EACDnsC,EAAQmS,UAAYqR,EAAO4oB,QAC3B,MACJ,KAAK,EACDpsC,EAAQhB,KAAOwkB,EAAO4oB,QACtB,MACJ,QACI5oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXuK,EAAMoiC,gBAAkB,SAAyBnpB,GAG7C,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC3hC,EAAMqiC,OAAS,SAAgB5sC,GAC3B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAmB,MAAfA,EAAQgH,KAAehH,EAAQoI,eAAe,SACzCwjC,EAAMiB,SAAS7sC,EAAQgH,KACxB,MAAO,uBACf,GAAyB,MAArBhH,EAAQmS,WAAqBnS,EAAQoI,eAAe,eAC/CwjC,EAAMiC,UAAU7tC,EAAQmS,WACzB,MAAO,8BACf,GAAoB,MAAhBnS,EAAQhB,MAAgBgB,EAAQoI,eAAe,QAC/C,OAAQpI,EAAQhB,MAChB,QACI,MAAO,4BACX,KAAK,EACL,KAAK,EACL,KAAK,GAGT,OAAO,MAWXuL,EAAMkc,WAAa,SAAoBqmB,GACnC,GAAIA,aAAkBjB,EAAMthC,MACxB,OAAOuiC,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMthC,MAKxB,OAJkB,MAAduiC,EAAO9lC,MACPhH,EAAQgH,IAAM+lC,OAAOD,EAAO9lC,MACR,MAApB8lC,EAAO36B,YACPnS,EAAQmS,UAA+B,EAAnB26B,EAAO36B,WACvB26B,EAAO9tC,MACf,IAAK,SACL,KAAK,EACDgB,EAAQhB,KAAO,EACf,MACJ,IAAK,SACL,KAAK,EACDgB,EAAQhB,KAAO,EACf,MACJ,IAAK,iBACL,KAAK,EACDgB,EAAQhB,KAAO,EAGnB,OAAOgB,GAYXuK,EAAMyiC,SAAW,SAAkBhtC,EAASitC,GACnCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAYb,OAXIG,EAAQC,WACRJ,EAAO36B,UAAY,EACnB26B,EAAO9tC,KAAOiuC,EAAQE,QAAUJ,OAAS,SAAW,EACpDD,EAAO9lC,IAAM,IAEQ,MAArBhH,EAAQmS,WAAqBnS,EAAQoI,eAAe,eACpD0kC,EAAO36B,UAAYnS,EAAQmS,WACX,MAAhBnS,EAAQhB,MAAgBgB,EAAQoI,eAAe,UAC/C0kC,EAAO9tC,KAAOiuC,EAAQE,QAAUJ,OAASlB,EAAMthC,MAAMwkC,KAAK/uC,EAAQhB,MAAQgB,EAAQhB,MACnE,MAAfgB,EAAQgH,KAAehH,EAAQoI,eAAe,SAC9C0kC,EAAO9lC,IAAMhH,EAAQgH,KAClB8lC,GAUXviC,EAAMwhC,UAAUsB,OAAS,WACrB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAW1DhjC,EAAMwkC,KAAQ,WACV,IAAMvB,EAAa,GAAIC,EAASthB,OAAOhO,OAAOqvB,GAI9C,OAHAC,EAAOD,EAAW,GAAK,UAAY,EACnCC,EAAOD,EAAW,GAAK,UAAY,EACnCC,EAAOD,EAAW,GAAK,kBAAoB,EACpCC,EALG,GAQPljC,EAvQyB,IA0QvB8c,EAAewkB,EAAMxkB,aAAgB,WAiB9C,SAASA,EAAaykB,GAElB,GADAttC,KAAK8oB,QAAU,GACXwkB,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAuLhD,OA9KAiH,EAAa0kB,UAAUzkB,QAAUskB,EAAMoD,WAUvC3nB,EAAalJ,OAAS,SAAgB2tB,GAClC,OAAO,IAAIzkB,EAAaykB,IAY5BzkB,EAAa7F,OAAS,SAAgBxhB,EAASgsC,GAG3C,GAFKA,IACDA,EAASL,EAAQxtB,UACE,MAAnBne,EAAQsnB,SAAmBtnB,EAAQsnB,QAAQ5E,OAC3C,IAAK,IAAItC,EAAI,EAAGA,EAAIpgB,EAAQsnB,QAAQ5E,SAAUtC,EAC1CyrB,EAAMtkB,YAAY/F,OAAOxhB,EAAQsnB,QAAQlH,GAAI4rB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACtG,OAAON,GAYX3kB,EAAaglB,gBAAkB,SAAyBrsC,EAASgsC,GAC7D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCjlB,EAAarK,OAAS,SAAgBwG,EAAQd,GACpCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMxkB,aAChF7D,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACKzsC,EAAQsnB,SAAWtnB,EAAQsnB,QAAQ5E,SACrC1iB,EAAQsnB,QAAU,IACtBtnB,EAAQsnB,QAAQ9jB,KAAKqoC,EAAMtkB,YAAYvK,OAAOwG,EAAQA,EAAO0oB,WAC7D,MACJ,QACI1oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXqnB,EAAaslB,gBAAkB,SAAyBnpB,GAGpD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC7kB,EAAaulB,OAAS,SAAgB5sC,GAClC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAuB,MAAnBA,EAAQsnB,SAAmBtnB,EAAQoI,eAAe,WAAY,CAC9D,IAAKuxB,MAAMuV,QAAQlvC,EAAQsnB,SACvB,MAAO,0BACX,IAAK,IAAIlH,EAAI,EAAGA,EAAIpgB,EAAQsnB,QAAQ5E,SAAUtC,EAAG,CAC7C,IAAIxgB,EAAQisC,EAAMtkB,YAAYqlB,OAAO5sC,EAAQsnB,QAAQlH,IACrD,GAAIxgB,EACA,MAAO,WAAaA,GAGhC,OAAO,MAWXynB,EAAaZ,WAAa,SAAoBqmB,GAC1C,GAAIA,aAAkBjB,EAAMxkB,aACxB,OAAOylB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMxkB,aACxB,GAAIylB,EAAOxlB,QAAS,CAChB,IAAKqS,MAAMuV,QAAQpC,EAAOxlB,SACtB,MAAMwmB,UAAU,yCACpB9tC,EAAQsnB,QAAU,GAClB,IAAK,IAAIlH,EAAI,EAAGA,EAAI0sB,EAAOxlB,QAAQ5E,SAAUtC,EAAG,CAC5C,GAAiC,kBAAtB0sB,EAAOxlB,QAAQlH,GACtB,MAAM0tB,UAAU,0CACpB9tC,EAAQsnB,QAAQlH,GAAKyrB,EAAMtkB,YAAYd,WAAWqmB,EAAOxlB,QAAQlH,KAGzE,OAAOpgB,GAYXqnB,EAAa2lB,SAAW,SAAkBhtC,EAASitC,GAC1CA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAOxlB,QAAU,IACjBtnB,EAAQsnB,SAAWtnB,EAAQsnB,QAAQ5E,OAAQ,CAC3CoqB,EAAOxlB,QAAU,GACjB,IAAK,IAAI8nB,EAAI,EAAGA,EAAIpvC,EAAQsnB,QAAQ5E,SAAU0sB,EAC1CtC,EAAOxlB,QAAQ8nB,GAAKvD,EAAMtkB,YAAYylB,SAAShtC,EAAQsnB,QAAQ8nB,GAAInC,GAE3E,OAAOH,GAUXzlB,EAAa0kB,UAAUsB,OAAS,WAC5B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDlmB,EA7MuC,GAgNrCE,EAAcskB,EAAMtkB,YAAe,WA0B5C,SAASA,EAAYukB,GACjB,GAAIA,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAoFhD,IAAIouB,EA2WJ,OAtbAjnB,EAAYwkB,UAAUt2B,GAAK,GAQ3B8R,EAAYwkB,UAAUhmB,cAAe,EAQrCwB,EAAYwkB,UAAU5lB,WAAY,EAQlCoB,EAAYwkB,UAAU1lB,WAAa,EAQnCkB,EAAYwkB,UAAU3lB,SAAWwlB,EAAMwE,KAAOxE,EAAMwE,KAAKC,SAAS,EAAE,GAAE,GAAS,EAQ/E9oB,EAAYwkB,UAAUzlB,YAAc,GAQpCiB,EAAYwkB,UAAUrlB,gBAAkB,KAQxCa,EAAYwkB,UAAUnlB,cAAgB,KAQtCW,EAAYwkB,UAAUxlB,iBAAmB,KAQzCgB,EAAYwkB,UAAUjlB,UAAY,GAWlCqF,OAAOsiB,eAAelnB,EAAYwkB,UAAW,QAAS,CAClDltC,IAAK+sC,EAAM8C,YAAYF,EAAe,CAAC,eAAgB,YAAa,aAAc,WAAY,cAAe,kBAAmB,gBAAiB,mBAAoB,cACrK5lC,IAAKgjC,EAAM+C,YAAYH,KAW3BjnB,EAAYpJ,OAAS,SAAgB2tB,GACjC,OAAO,IAAIvkB,EAAYukB,IAY3BvkB,EAAY/F,OAAS,SAAgBxhB,EAASgsC,GAuB1C,OAtBKA,IACDA,EAASL,EAAQxtB,UACH,MAAdne,EAAQyV,IAAc0W,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,OAC1DgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQyV,IAChC,MAAxBzV,EAAQ+lB,cAAwBoG,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,iBACpEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQ+lB,cACjC,MAArB/lB,EAAQmmB,WAAqBgG,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA8B,IAAI0C,KAAK5uC,EAAQmmB,WAChC,MAAtBnmB,EAAQqmB,YAAsB8F,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,eAClEgsC,EAAOE,OAA8B,IAAIiF,OAAOnxC,EAAQqmB,YACpC,MAApBrmB,EAAQomB,UAAoB+F,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,aAChEgsC,EAAOE,OAA8B,IAAIiI,OAAOn0C,EAAQomB,UACjC,MAAvBpmB,EAAQsmB,aAAuB6F,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,gBACnEgsC,EAAOE,OAA8B,IAAIC,OAAOnsC,EAAQsmB,aAC7B,MAA3BtmB,EAAQ0mB,iBAA2ByF,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,oBACvE6rC,EAAMllB,WAAWnF,OAAOxhB,EAAQ0mB,gBAAiBslB,EAAOE,OAA8B,IAAI0B,QAAQtB,SACzE,MAAzBtsC,EAAQ4mB,eAAyBuF,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,kBACrE6rC,EAAMhlB,SAASrF,OAAOxhB,EAAQ4mB,cAAeolB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAClE,MAA5BtsC,EAAQumB,kBAA4B4F,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,qBACxE6rC,EAAMrlB,YAAYhF,OAAOxhB,EAAQumB,iBAAkBylB,EAAOE,OAA8B,IAAI0B,QAAQtB,SAC/E,MAArBtsC,EAAQ8mB,WAAqBqF,OAAO/jB,eAAe6jC,KAAKjsC,EAAS,cACjEgsC,EAAOE,OAA+B,IAAIC,OAAOnsC,EAAQ8mB,WACtDklB,GAYXzkB,EAAY8kB,gBAAkB,SAAyBrsC,EAASgsC,GAC5D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC/kB,EAAYvK,OAAS,SAAgBwG,EAAQd,GACnCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMtkB,YAChF/D,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EACDzsC,EAAQyV,GAAK+N,EAAO2oB,SACpB,MACJ,KAAK,EACDnsC,EAAQ+lB,aAAevC,EAAOorB,OAC9B,MACJ,KAAK,EACD5uC,EAAQmmB,UAAY3C,EAAOorB,OAC3B,MACJ,KAAK,EACD5uC,EAAQqmB,WAAa7C,EAAO2tB,SAC5B,MACJ,KAAK,EACDnxC,EAAQomB,SAAW5C,EAAO2wB,SAC1B,MACJ,KAAK,EACDn0C,EAAQsmB,YAAc9C,EAAO2oB,SAC7B,MACJ,KAAK,EACDnsC,EAAQ0mB,gBAAkBmlB,EAAMllB,WAAW3J,OAAOwG,EAAQA,EAAO0oB,UACjE,MACJ,KAAK,EACDlsC,EAAQ4mB,cAAgBilB,EAAMhlB,SAAS7J,OAAOwG,EAAQA,EAAO0oB,UAC7D,MACJ,KAAK,EACDlsC,EAAQumB,iBAAmBslB,EAAMrlB,YAAYxJ,OAAOwG,EAAQA,EAAO0oB,UACnE,MACJ,KAAK,GACDlsC,EAAQ8mB,UAAYtD,EAAO2oB,SAC3B,MACJ,QACI3oB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaXunB,EAAYolB,gBAAkB,SAAyBnpB,GAGnD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtC3kB,EAAYqlB,OAAS,SAAgB5sC,GACjC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,IAAI8rC,EAAa,GACjB,GAAkB,MAAd9rC,EAAQyV,IAAczV,EAAQoI,eAAe,QACxCwjC,EAAMiB,SAAS7sC,EAAQyV,IACxB,MAAO,sBACf,GAA4B,MAAxBzV,EAAQ+lB,cAAwB/lB,EAAQoI,eAAe,kBACvD0jC,EAAW1lC,MAAQ,EACiB,mBAAzBpG,EAAQ+lB,cACf,MAAO,iCAEf,GAAyB,MAArB/lB,EAAQmmB,WAAqBnmB,EAAQoI,eAAe,aAAc,CAClE,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBAEX,GADA0lC,EAAW1lC,MAAQ,EACc,mBAAtBpG,EAAQmmB,UACf,MAAO,8BAEf,GAA0B,MAAtBnmB,EAAQqmB,YAAsBrmB,EAAQoI,eAAe,cAAe,CACpE,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBAEX,GADA0lC,EAAW1lC,MAAQ,EACe,kBAAvBpG,EAAQqmB,WACf,MAAO,8BAEf,GAAwB,MAApBrmB,EAAQomB,UAAoBpmB,EAAQoI,eAAe,YAAa,CAChE,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBAEX,GADA0lC,EAAW1lC,MAAQ,GACdwlC,EAAMiC,UAAU7tC,EAAQomB,aAAepmB,EAAQomB,UAAYwlB,EAAMiC,UAAU7tC,EAAQomB,SAASmqB,MAAQ3E,EAAMiC,UAAU7tC,EAAQomB,SAASoqB,OACtI,MAAO,kCAEf,GAA2B,MAAvBxwC,EAAQsmB,aAAuBtmB,EAAQoI,eAAe,eAAgB,CACtE,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBAEX,GADA0lC,EAAW1lC,MAAQ,GACdwlC,EAAMiB,SAAS7sC,EAAQsmB,aACxB,MAAO,+BAEf,GAA+B,MAA3BtmB,EAAQ0mB,iBAA2B1mB,EAAQoI,eAAe,mBAAoB,CAC9E,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBACX0lC,EAAW1lC,MAAQ,EAEf,IAAIxG,EAAQisC,EAAMllB,WAAWimB,OAAO5sC,EAAQ0mB,iBAC5C,GAAI9mB,EACA,MAAO,mBAAqBA,EAGxC,GAA6B,MAAzBI,EAAQ4mB,eAAyB5mB,EAAQoI,eAAe,iBAAkB,CAC1E,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBACX0lC,EAAW1lC,MAAQ,EAEf,IAAIxG,EAAQisC,EAAMhlB,SAAS+lB,OAAO5sC,EAAQ4mB,eAC1C,GAAIhnB,EACA,MAAO,iBAAmBA,EAGtC,GAAgC,MAA5BI,EAAQumB,kBAA4BvmB,EAAQoI,eAAe,oBAAqB,CAChF,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBACX0lC,EAAW1lC,MAAQ,EAEf,IAAIxG,EAAQisC,EAAMrlB,YAAYomB,OAAO5sC,EAAQumB,kBAC7C,GAAI3mB,EACA,MAAO,oBAAsBA,EAGzC,GAAyB,MAArBI,EAAQ8mB,WAAqB9mB,EAAQoI,eAAe,aAAc,CAClE,GAAyB,IAArB0jC,EAAW1lC,MACX,MAAO,yBAEX,GADA0lC,EAAW1lC,MAAQ,GACdwlC,EAAMiB,SAAS7sC,EAAQ8mB,WACxB,MAAO,6BAEf,OAAO,MAWXS,EAAYd,WAAa,SAAoBqmB,GACzC,GAAIA,aAAkBjB,EAAMtkB,YACxB,OAAOulB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMtkB,YAoBxB,GAnBiB,MAAbulB,EAAOr3B,KACPzV,EAAQyV,GAAKs3B,OAAOD,EAAOr3B,KACJ,MAAvBq3B,EAAO/mB,eACP/lB,EAAQ+lB,aAAeoO,QAAQ2Y,EAAO/mB,eAClB,MAApB+mB,EAAO3mB,YACPnmB,EAAQmmB,UAAYgO,QAAQ2Y,EAAO3mB,YACd,MAArB2mB,EAAOzmB,aACPrmB,EAAQqmB,WAAawR,OAAOiV,EAAOzmB,aAChB,MAAnBymB,EAAO1mB,WACHwlB,EAAMwE,MACLpwC,EAAQomB,SAAWwlB,EAAMwE,KAAKK,UAAU3D,EAAO1mB,WAAWsqB,UAAW,EACtC,kBAApB5D,EAAO1mB,SACnBpmB,EAAQomB,SAAWjkB,SAAS2qC,EAAO1mB,SAAU,IACb,kBAApB0mB,EAAO1mB,SACnBpmB,EAAQomB,SAAW0mB,EAAO1mB,SACM,kBAApB0mB,EAAO1mB,WACnBpmB,EAAQomB,SAAW,IAAIwlB,EAAM+E,SAAS7D,EAAO1mB,SAASmqB,MAAQ,EAAGzD,EAAO1mB,SAASoqB,OAAS,GAAGI,aAC3E,MAAtB9D,EAAOxmB,cACPtmB,EAAQsmB,YAAcymB,OAAOD,EAAOxmB,cACV,MAA1BwmB,EAAOpmB,gBAAyB,CAChC,GAAsC,kBAA3BomB,EAAOpmB,gBACd,MAAMonB,UAAU,iDACpB9tC,EAAQ0mB,gBAAkBmlB,EAAMllB,WAAWF,WAAWqmB,EAAOpmB,iBAEjE,GAA4B,MAAxBomB,EAAOlmB,cAAuB,CAC9B,GAAoC,kBAAzBkmB,EAAOlmB,cACd,MAAMknB,UAAU,+CACpB9tC,EAAQ4mB,cAAgBilB,EAAMhlB,SAASJ,WAAWqmB,EAAOlmB,eAE7D,GAA+B,MAA3BkmB,EAAOvmB,iBAA0B,CACjC,GAAuC,kBAA5BumB,EAAOvmB,iBACd,MAAMunB,UAAU,kDACpB9tC,EAAQumB,iBAAmBslB,EAAMrlB,YAAYC,WAAWqmB,EAAOvmB,kBAInE,OAFwB,MAApBumB,EAAOhmB,YACP9mB,EAAQ8mB,UAAYimB,OAAOD,EAAOhmB,YAC/B9mB,GAYXunB,EAAYylB,SAAW,SAAkBhtC,EAASitC,GACzCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAqDb,OApDIG,EAAQC,WACRJ,EAAOr3B,GAAK,IACE,MAAdzV,EAAQyV,IAAczV,EAAQoI,eAAe,QAC7C0kC,EAAOr3B,GAAKzV,EAAQyV,IACI,MAAxBzV,EAAQ+lB,cAAwB/lB,EAAQoI,eAAe,kBACvD0kC,EAAO/mB,aAAe/lB,EAAQ+lB,aAC1BknB,EAAQ4B,SACR/B,EAAO1mC,MAAQ,iBAEE,MAArBpG,EAAQmmB,WAAqBnmB,EAAQoI,eAAe,eACpD0kC,EAAO3mB,UAAYnmB,EAAQmmB,UACvB8mB,EAAQ4B,SACR/B,EAAO1mC,MAAQ,cAEG,MAAtBpG,EAAQqmB,YAAsBrmB,EAAQoI,eAAe,gBACrD0kC,EAAOzmB,WAAa4mB,EAAQz/B,OAAS4jC,SAASpxC,EAAQqmB,YAAc0mB,OAAO/sC,EAAQqmB,YAAcrmB,EAAQqmB,WACrG4mB,EAAQ4B,SACR/B,EAAO1mC,MAAQ,eAEC,MAApBpG,EAAQomB,UAAoBpmB,EAAQoI,eAAe,cACnB,kBAArBpI,EAAQomB,SACf0mB,EAAO1mB,SAAW6mB,EAAQ6D,QAAU/D,OAASA,OAAO/sC,EAAQomB,UAAYpmB,EAAQomB,SAEhF0mB,EAAO1mB,SAAW6mB,EAAQ6D,QAAU/D,OAASnB,EAAMwE,KAAKrE,UAAUrlC,SAASulC,KAAKjsC,EAAQomB,UAAY6mB,EAAQ6D,QAAUjZ,OAAS,IAAI+T,EAAM+E,SAAS3wC,EAAQomB,SAASmqB,MAAQ,EAAGvwC,EAAQomB,SAASoqB,OAAS,GAAGI,WAAa5wC,EAAQomB,SAChO6mB,EAAQ4B,SACR/B,EAAO1mC,MAAQ,aAEI,MAAvBpG,EAAQsmB,aAAuBtmB,EAAQoI,eAAe,iBACtD0kC,EAAOxmB,YAActmB,EAAQsmB,YACzB2mB,EAAQ4B,SACR/B,EAAO1mC,MAAQ,gBAEQ,MAA3BpG,EAAQ0mB,iBAA2B1mB,EAAQoI,eAAe,qBAC1D0kC,EAAOpmB,gBAAkBmlB,EAAMllB,WAAWqmB,SAAShtC,EAAQ0mB,gBAAiBumB,GACxEA,EAAQ4B,SACR/B,EAAO1mC,MAAQ,oBAEM,MAAzBpG,EAAQ4mB,eAAyB5mB,EAAQoI,eAAe,mBACxD0kC,EAAOlmB,cAAgBilB,EAAMhlB,SAASmmB,SAAShtC,EAAQ4mB,cAAeqmB,GAClEA,EAAQ4B,SACR/B,EAAO1mC,MAAQ,kBAES,MAA5BpG,EAAQumB,kBAA4BvmB,EAAQoI,eAAe,sBAC3D0kC,EAAOvmB,iBAAmBslB,EAAMrlB,YAAYwmB,SAAShtC,EAAQumB,iBAAkB0mB,GAC3EA,EAAQ4B,SACR/B,EAAO1mC,MAAQ,qBAEE,MAArBpG,EAAQ8mB,WAAqB9mB,EAAQoI,eAAe,eACpD0kC,EAAOhmB,UAAY9mB,EAAQ8mB,UACvBmmB,EAAQ4B,SACR/B,EAAO1mC,MAAQ,cAEhB0mC,GAUXvlB,EAAYwkB,UAAUsB,OAAS,WAC3B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnDhmB,EA7dqC,GAgenCZ,EAAaklB,EAAMllB,WAAc,WAiB1C,SAASA,EAAWmlB,GAEhB,GADAttC,KAAK4H,MAAQ,GACT0lC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KA0LhD,OAjLAuG,EAAWolB,UAAU3lC,MAAQwlC,EAAMoD,WAUnCroB,EAAWxI,OAAS,SAAgB2tB,GAChC,OAAO,IAAInlB,EAAWmlB,IAY1BnlB,EAAWnF,OAAS,SAAgBxhB,EAASgsC,GAGzC,GAFKA,IACDA,EAASL,EAAQxtB,UACA,MAAjBne,EAAQoG,OAAiBpG,EAAQoG,MAAMsc,OAAQ,CAC/CspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAQoG,MAAMsc,SAAUtC,EACxC4rB,EAAOmF,OAAOnxC,EAAQoG,MAAMga,IAChC4rB,EAAOM,SAEX,OAAON,GAYXrlB,EAAW0lB,gBAAkB,SAAyBrsC,EAASgsC,GAC3D,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxC3lB,EAAW3J,OAAS,SAAgBwG,EAAQd,GAClCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMllB,WAChFnD,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EAGD,GAFMzsC,EAAQoG,OAASpG,EAAQoG,MAAMsc,SACjC1iB,EAAQoG,MAAQ,IACF,KAAP,EAANqmC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAQoG,MAAM5C,KAAKggB,EAAO2tB,eAE9BnxC,EAAQoG,MAAM5C,KAAKggB,EAAO2tB,UAC9B,MACJ,QACI3tB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX2mB,EAAWgmB,gBAAkB,SAAyBnpB,GAGlD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCvlB,EAAWimB,OAAS,SAAgB5sC,GAChC,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAqB,MAAjBA,EAAQoG,OAAiBpG,EAAQoI,eAAe,SAAU,CAC1D,IAAKuxB,MAAMuV,QAAQlvC,EAAQoG,OACvB,MAAO,wBACX,IAAK,IAAIga,EAAI,EAAGA,EAAIpgB,EAAQoG,MAAMsc,SAAUtC,EACxC,GAAgC,kBAArBpgB,EAAQoG,MAAMga,GACrB,MAAO,2BAEnB,OAAO,MAWXuG,EAAWF,WAAa,SAAoBqmB,GACxC,GAAIA,aAAkBjB,EAAMllB,WACxB,OAAOmmB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMllB,WACxB,GAAImmB,EAAO1mC,MAAO,CACd,IAAKuzB,MAAMuV,QAAQpC,EAAO1mC,OACtB,MAAM0nC,UAAU,qCACpB9tC,EAAQoG,MAAQ,GAChB,IAAK,IAAIga,EAAI,EAAGA,EAAI0sB,EAAO1mC,MAAMsc,SAAUtC,EACvCpgB,EAAQoG,MAAMga,GAAKyX,OAAOiV,EAAO1mC,MAAMga,IAE/C,OAAOpgB,GAYX2mB,EAAWqmB,SAAW,SAAkBhtC,EAASitC,GACxCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO1mC,MAAQ,IACfpG,EAAQoG,OAASpG,EAAQoG,MAAMsc,OAAQ,CACvCoqB,EAAO1mC,MAAQ,GACf,IAAK,IAAIgpC,EAAI,EAAGA,EAAIpvC,EAAQoG,MAAMsc,SAAU0sB,EACxCtC,EAAO1mC,MAAMgpC,GAAKnC,EAAQz/B,OAAS4jC,SAASpxC,EAAQoG,MAAMgpC,IAAMrC,OAAO/sC,EAAQoG,MAAMgpC,IAAMpvC,EAAQoG,MAAMgpC,GAEjH,OAAOtC,GAUXnmB,EAAWolB,UAAUsB,OAAS,WAC1B,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD5mB,EAhNmC,GAmNjCE,EAAWglB,EAAMhlB,SAAY,WAiBtC,SAASA,EAASilB,GAEd,GADAttC,KAAK4H,MAAQ,GACT0lC,EACA,IAAK,IAAIlb,EAAOzE,OAAOyE,KAAKkb,GAAa1rB,EAAI,EAAGA,EAAIwQ,EAAKlO,SAAUtC,EACpC,MAAvB0rB,EAAWlb,EAAKxQ,MAChB5hB,KAAKoyB,EAAKxQ,IAAM0rB,EAAWlb,EAAKxQ,KAoMhD,OA3LAyG,EAASklB,UAAU3lC,MAAQwlC,EAAMoD,WAUjCnoB,EAAS1I,OAAS,SAAgB2tB,GAC9B,OAAO,IAAIjlB,EAASilB,IAYxBjlB,EAASrF,OAAS,SAAgBxhB,EAASgsC,GAGvC,GAFKA,IACDA,EAASL,EAAQxtB,UACA,MAAjBne,EAAQoG,OAAiBpG,EAAQoG,MAAMsc,OAAQ,CAC/CspB,EAAOE,OAA8B,IAAI0B,OACzC,IAAK,IAAIxtB,EAAI,EAAGA,EAAIpgB,EAAQoG,MAAMsc,SAAUtC,EACxC4rB,EAAOmI,OAAOn0C,EAAQoG,MAAMga,IAChC4rB,EAAOM,SAEX,OAAON,GAYXnlB,EAASwlB,gBAAkB,SAAyBrsC,EAASgsC,GACzD,OAAOxtC,KAAKgjB,OAAOxhB,EAASgsC,GAAQM,UAcxCzlB,EAAS7J,OAAS,SAAgBwG,EAAQd,GAChCc,aAAkBioB,IACpBjoB,EAASioB,EAAQttB,OAAOqF,IAE5B,IADA,IAAI+oB,OAAiBzqC,IAAX4gB,EAAuBc,EAAOgpB,IAAMhpB,EAAOthB,IAAMwgB,EAAQ1iB,EAAU,IAAI6rC,EAAMhlB,SAChFrD,EAAOthB,IAAMqqC,GAAK,CACrB,IAAIE,EAAMjpB,EAAO0oB,SACjB,OAAQO,IAAQ,GAChB,KAAK,EAGD,GAFMzsC,EAAQoG,OAASpG,EAAQoG,MAAMsc,SACjC1iB,EAAQoG,MAAQ,IACF,KAAP,EAANqmC,GAED,IADA,IAAIwC,EAAOzrB,EAAO0oB,SAAW1oB,EAAOthB,IAC7BshB,EAAOthB,IAAM+sC,GAChBjvC,EAAQoG,MAAM5C,KAAKggB,EAAO2wB,eAE9Bn0C,EAAQoG,MAAM5C,KAAKggB,EAAO2wB,UAC9B,MACJ,QACI3wB,EAAOkpB,SAAe,EAAND,IAIxB,OAAOzsC,GAaX6mB,EAAS8lB,gBAAkB,SAAyBnpB,GAGhD,OAFMA,aAAkBioB,IACpBjoB,EAAS,IAAIioB,EAAQjoB,IAClBhlB,KAAKwe,OAAOwG,EAAQA,EAAO0oB,WAWtCrlB,EAAS+lB,OAAS,SAAgB5sC,GAC9B,GAAuB,kBAAZA,GAAoC,OAAZA,EAC/B,MAAO,kBACX,GAAqB,MAAjBA,EAAQoG,OAAiBpG,EAAQoI,eAAe,SAAU,CAC1D,IAAKuxB,MAAMuV,QAAQlvC,EAAQoG,OACvB,MAAO,wBACX,IAAK,IAAIga,EAAI,EAAGA,EAAIpgB,EAAQoG,MAAMsc,SAAUtC,EACxC,IAAKwrB,EAAMiC,UAAU7tC,EAAQoG,MAAMga,OAASpgB,EAAQoG,MAAMga,IAAMwrB,EAAMiC,UAAU7tC,EAAQoG,MAAMga,GAAGmwB,MAAQ3E,EAAMiC,UAAU7tC,EAAQoG,MAAMga,GAAGowB,OACtI,MAAO,iCAEnB,OAAO,MAWX3pB,EAASJ,WAAa,SAAoBqmB,GACtC,GAAIA,aAAkBjB,EAAMhlB,SACxB,OAAOimB,EACX,IAAI9sC,EAAU,IAAI6rC,EAAMhlB,SACxB,GAAIimB,EAAO1mC,MAAO,CACd,IAAKuzB,MAAMuV,QAAQpC,EAAO1mC,OACtB,MAAM0nC,UAAU,mCACpB9tC,EAAQoG,MAAQ,GAChB,IAAK,IAAIga,EAAI,EAAGA,EAAI0sB,EAAO1mC,MAAMsc,SAAUtC,EACnCwrB,EAAMwE,MACLpwC,EAAQoG,MAAMga,GAAKwrB,EAAMwE,KAAKK,UAAU3D,EAAO1mC,MAAMga,KAAKswB,UAAW,EACtC,kBAApB5D,EAAO1mC,MAAMga,GACzBpgB,EAAQoG,MAAMga,GAAKje,SAAS2qC,EAAO1mC,MAAMga,GAAI,IACb,kBAApB0sB,EAAO1mC,MAAMga,GACzBpgB,EAAQoG,MAAMga,GAAK0sB,EAAO1mC,MAAMga,GACA,kBAApB0sB,EAAO1mC,MAAMga,KACzBpgB,EAAQoG,MAAMga,GAAK,IAAIwrB,EAAM+E,SAAS7D,EAAO1mC,MAAMga,GAAGmwB,MAAQ,EAAGzD,EAAO1mC,MAAMga,GAAGowB,OAAS,GAAGI,YAEzG,OAAO5wC,GAYX6mB,EAASmmB,SAAW,SAAkBhtC,EAASitC,GACtCA,IACDA,EAAU,IACd,IAAIH,EAAS,GAGb,IAFIG,EAAQkC,QAAUlC,EAAQC,YAC1BJ,EAAO1mC,MAAQ,IACfpG,EAAQoG,OAASpG,EAAQoG,MAAMsc,OAAQ,CACvCoqB,EAAO1mC,MAAQ,GACf,IAAK,IAAIgpC,EAAI,EAAGA,EAAIpvC,EAAQoG,MAAMsc,SAAU0sB,EACR,kBAArBpvC,EAAQoG,MAAMgpC,GACrBtC,EAAO1mC,MAAMgpC,GAAKnC,EAAQ6D,QAAU/D,OAASA,OAAO/sC,EAAQoG,MAAMgpC,IAAMpvC,EAAQoG,MAAMgpC,GAEtFtC,EAAO1mC,MAAMgpC,GAAKnC,EAAQ6D,QAAU/D,OAASnB,EAAMwE,KAAKrE,UAAUrlC,SAASulC,KAAKjsC,EAAQoG,MAAMgpC,IAAMnC,EAAQ6D,QAAUjZ,OAAS,IAAI+T,EAAM+E,SAAS3wC,EAAQoG,MAAMgpC,GAAGmB,MAAQ,EAAGvwC,EAAQoG,MAAMgpC,GAAGoB,OAAS,GAAGI,WAAa5wC,EAAQoG,MAAMgpC,GAElP,OAAOtC,GAUXjmB,EAASklB,UAAUsB,OAAS,WACxB,OAAO7uC,KAAK8uC,YAAYN,SAASxuC,KAAMktC,OAAe6B,gBAGnD1mB,EA1N+B,I,8ICv1qBpCutB,G,cAAkBzpB,eAAY,mBACjC0pB,IAAWjH,OAAOkH,QAAU,iBADK,cAEjCD,IAAWjH,OAAOmH,KAAO,cAFQ,cAGjCF,IAAWjH,OAAOjyB,QAAU,iBAHK,cAIjCk5B,IAAWjH,OAAOoH,MAAQ,gBAJO,KAO7B,SAASC,EAAiB/d,GAC/B,IAAMge,EAAQN,EAAgBv1C,IAAI63B,EAAOhwB,YACzC,GAAIguC,EACF,OAAOA,EAEP,MAAM,IAAIvwC,MAAJ,iCAAoCuyB,I,IAgC/B/pB,E,iLAlBe,IAAD,EACEnO,KAAKC,MAAxBC,EADiB,EACjBA,QAASC,EADQ,EACRA,MACXgD,EAAOjD,EAAQG,IAAI,QACnB63B,EAASh4B,EAAQG,IAAI,UAE3B,OACE,yBACEM,UAAWsC,IAAW,QAASgzC,EAAiB/d,GAAS,WACzDl3B,MAAO,CAAEb,UAET,yBAAKQ,UAAU,2BACb,kBAAC6B,EAAA,EAAD,CAAmBC,OAAQU,EAAMT,WAAW,U,GAZlCX,IAAMd,eCrD1B,mC,iCCAA,sGA2BO,IAAMuI,EAAgC,CAM3C,cAGA,eASA,eAGA,iCAUA,iBAWAkI,KAAK,KAMMtI,EAAgC,CAE3C,gBAGA,uBAGA,WAGA,UAGA,SAMA,kBAGA,kBASA,aAGA,cAGA,YAGA,oBAGA,uBAGA,eAGA,aAGA,OAMA,mBAGA,UAGA,qBAGA,4BAGA,WAGA,MAGA,MAGA,YAGA,uBACAsI,KAAK,MAMA,SAASykC,EAAuBC,GACrC,IAAIC,EAAgB7sC,EAIpB,OAHI4sC,IACFC,GAAiB,sBAEZA,I,gIC5GMzwC,MAhCf,SACEwrB,GACqB,IACfklB,EADc,iLAOG,IAAD,EAC6Bt2C,KAAKC,MAA5CE,EADU,EACVA,MAAO8H,EADG,EACHA,OAAWsuC,EADR,kCAGlB,OACE,kBAAC/kC,EAAA,EAAD,CAAmBrR,MAAOA,EAAO8H,OAAQA,IACtC,gBAAG9H,EAAH,EAAGA,MAAO8H,EAAV,EAAUA,OAAQm5B,EAAlB,EAAkBA,SAAlB,OACC,kBAAChQ,EAAD,eACEjxB,MAAOA,EACP8H,OAAQA,EACRwJ,aAAc2vB,GACVmV,WAjBI,GACyBt1C,iBA0B7C,OA1BMq1C,EAGY3jB,YAJE,gCAIqCvB,EAAiBuB,aACtEvB,EAAiBhxB,KALD,KA2BbwyB,IAAqB0jB,EAAgCllB,IC3D9D,mC,gCCAA,kCAAO,IAAMkI,EACb,CACE,OAAU,OACV,YAAa,UACb,YAAa,UACb,YAAa,UACb,YAAa,UACb,YAAa,UACb,YAAa,UACb,YAAa,UACb,YAAa,UACb,YAAa,UACb,YAAa,UACb,aAAc,UACd,OAAU,UACV,KAAQ,UACR,QAAW,UACX,MAAS,UACT,OAAU,UACV,cAAe,UACf,iBAAkB,UAClB,gBAAiB,UACjB,cAAe,UACf,MAAS,UACT,aAAc,UACd,eAAgB,UAChB,gBAAiB,UACjB,SAAY,UACZ,WAAc,UACd,OAAU,UACV,MAAS,UACT,eAAgB,uBAChB,aAAc,SACd,aAAc,SACd,0BAA2B,6BAC3B,yBAA0B,4BAC1B,kBAAmB,OACnB,gBAAiB,QACjB,oBAAqB,MACrB,qBAAsB,OACtB,iBAAkB,SAClB,oBAAqB,SACrB,uBAAwB,SACxB,qBAAsB,SACtB,sBAAuB,MACvB,0BAA2B,MAC3B,kBAAmB,MACnB,uBAAwB,MACxB,mBAAoB,MACpB,qBAAsB,YACtB,qBAAsB,YACtB,uBAAwB,WACxB,iBAAkB,QAClB,qBAAsB,QACtB,iBAAkB,SAClB,cAAe,OACf,iBAAkB,QAClB,qBAAsB,OACtB,sBAAuB,SACvB,0BAA2B,SAC3B,qBAAsB,SACtB,oBAAqB,SACrB,8BAA+B,MAC/B,6BAA8B,MAC9B,6BAA8B,QAC9B,cAAe,UACf,aAAc,UACd,UAAW,UACX,aAAc,Y,gCCpEhB,+LA8Bakd,EAAqB,KAKrB7rB,EAXe,OAWD7hB,OAAOC,SAAS8d,KAK9Bf,EACuC,MAAlDtd,IAAIhF,MAAMsF,OAAOC,SAASpH,MAAM,GAAMiH,MAAMqO,GAKjCyG,EAA4B,CACvC+4B,SAAU,SACVC,YAAa,cACbC,KAAM,QASK//B,GAA4B,G,qFC9B5BuE,EAAb,WA8CE,cASU,IARRgS,EAQO,EARPA,UACA/R,EAOO,EAPPA,iBACAka,EAMO,EANPA,cACAvL,EAKO,EALPA,eACAF,EAIO,EAJPA,YACA2L,EAGO,EAHPA,oBACA9Q,EAEO,EAFPA,YACA+Q,EACO,EADPA,gBAEA,GADO,yBArDOtI,eAqDP,OApDO/R,sBAoDP,OAnDOka,mBAmDP,OAlDOvL,oBAkDP,OAjDOF,iBAiDP,OAhDO2L,yBAgDP,OA/CO9Q,iBA+CP,OAvCO+Q,qBAuCP,EAEQ,MAAbtI,GACoB,MAApB/R,GACiB,MAAjBka,GACkB,MAAlBvL,GACe,MAAfF,GACuB,MAAvB2L,GACe,MAAf9Q,GACmB,MAAnB+Q,EAEA,MAAM,IAAI9vB,MAAM,0CAGlB3F,KAAKmtB,UAAYA,EACjBntB,KAAKob,iBAAmBA,EACxBpb,KAAKs1B,cAAgBA,EACrBt1B,KAAK+pB,eAAiBA,EACtB/pB,KAAK6pB,YAAcA,EACnB7pB,KAAKw1B,oBAAsBA,EAC3Bx1B,KAAK0kB,YAAcA,EACnB1kB,KAAKy1B,gBAAkBA,EA5E3B,yDAuCI,OAAgC,MAAzBta,EAAYy7B,YAvCvB,8BA4BI,IAAKz7B,EAAYy7B,UACf,MAAM,IAAIjxC,MAAM,sDAElB,OAAOwV,EAAYy7B,WA/BvB,aAkC4BC,GACxB17B,EAAYy7B,UAAYC,IAnC5B,8BA2CI,MAAoC,oBAA7B72C,KAAKsG,QAAQoe,gBA3CxB,KAAavJ,EAyBIy7B,e,mCCrDjB,oKAwBO,SAAS3rB,EAAiB6rB,EAAkBt1C,GACjD,IAAMu1C,EAAID,EAAYtI,SAAShtC,EAAS,CACtCktC,UAAU,EACV2B,QAAQ,IAKV,OAHI1lB,KACFvL,YAAW,aAAc23B,GAEpB5e,iBAAO4e,GAcT,SAAS/oC,EACdtE,EACAtJ,EACAszB,GAEA,IAAMC,EAAWjqB,EAAIrJ,IAAID,GACzB,GAAIuzB,KAAYD,EACd,OAAOA,EAAMC,GAAUjqB,EAAIrJ,IAAIszB,IAC1B,GAAID,EAAMoL,MACf,OAAOpL,EAAMoL,QAEb,MAAM,IAAIn5B,MAAJ,wBAA2BvF,EAA3B,aAAoCuzB,EAApC,OAWH,SAASwL,EACdz1B,EACAtJ,EACAszB,GAEA,IAAMC,EAAWjqB,EAAIrJ,IAAID,GACzB,GAAIuzB,KAAYD,EACd,OAAOhqB,EAAIgjB,OAAOiH,EAAUD,EAAMC,IAElC,MAAM,IAAIhuB,MAAJ,wBAA2BvF,EAA3B,aAAoCuzB,EAApC,OAWH,SAASiH,EACdlxB,EACAtJ,EACA6uC,GAEA,IAAMtb,EAAWjqB,EAAIrJ,IAAID,GACzB,GAAIuzB,KAAYsb,EACd,OAAOA,EAAOtb,GAGhB,MAAM,IAAIhuB,MAAJ,wBAA2BvF,EAA3B,aAAoCuzB,EAApC,S,gCClGR,yWAmCO,SAASqjB,EAASC,EAAeC,GACtC,IAAIC,EAEJ,OAAO,WAA0B,IAAD,uBAAb/vC,EAAa,yBAAbA,EAAa,gBAC1B+vC,GACFhjC,aAAagjC,GAGfA,EAAUjjC,YAAW,WACnBgjC,EAAE,WAAF,EAAM9vC,GACN+vC,EAAU,OACTF,IAQA,SAAS1e,IACd,MAA6D,SAAtD/vB,IAAIhF,MAAMsF,OAAOC,SAASpH,MAAM,GAAMiH,MAAMwuC,MAO9C,SAAS7lC,EACdlC,GAEA,OAAO8oB,iBAAO,CACZ33B,KAAM,QACNyN,MAAO,CACL9K,KAAMkM,EACN6oB,OAAQ2d,IAAWjH,OAAOmH,QASzB,SAASnf,EAAW1P,GACzB,OAAOmwB,IAAOC,IAAIpwB,EAAG,YAAYhf,SAAS,IAOrC,SAASkjB,EAAkB1hB,GAChC,GAAW,MAAPA,EACF,MAAM,IAAI/D,MAAM,iBAElB,OAAO+D,EAOF,SAASmvB,EACd7rB,GAEA,OAAOA,EAASuqC,QACd,SAACC,EAAkCtqC,GACjC,IAAMhN,EAAUgN,EAAc7M,IAAI,WAElC,OAAIH,aAAmBkN,OACdyrB,EAAgB34B,GAElBs3C,EAAI1e,MAAM2e,MAAaC,GAAGx3C,MAEnCu3C,MAAaC,MAeV,SAASC,IACd,MAAO,OAAOC,KAAKzpB,UAAU0pB,UAMxB,SAASpqB,EAAUrtB,GACxB,IAAM8uB,EAAI1c,SAASslC,OAAOC,MAAM,MAAQ33C,EAAO,eAC/C,OAAO8uB,EAAIA,EAAE,QAAK5rB,EAMb,SAASkwB,EACdpzB,EACAwH,EACAowC,GAEA,IAAMC,EAAiBrwC,EAAQowC,EAAa,IAAIhkC,KAC1CkkC,EAAwBD,EAAc,kBAC7BA,EAAeE,cADc,KAExC,GACJ3lC,SAASslC,OAAT,UAAqB13C,EAArB,YAA6BwH,EAA7B,YAAsCswC,EAAtC,Y,kBCpJF53C,EAAO83C,QAAU,swI,uECAjB,oJA4BMC,EAAiB,OACjBC,EAAmB,OAKlB,SAASpyB,IAmBd,MAAO,CAAEe,KAfIne,OAAOC,SAAS0b,SAedoC,KAZF8D,IACT6rB,IACA1tC,OAAOC,SAAS8d,KACdwS,OAAOvwB,OAAOC,SAAS8d,MACvB0xB,IACE,IACA,GAMaxxB,SAJJje,OAAOC,SAASmU,SAC9BtZ,QAAQy0C,EAAgB,IACxBz0C,QAAQ00C,EAAkB,KAQxB,SAASt2B,EAAT,EAEL1X,GACS,IAFP2c,EAEM,EAFNA,KAAMJ,EAEA,EAFAA,KAAME,EAEN,EAFMA,SAGRyxB,EAAWD,IAAY,MAAQ,KAC/BE,EAAWC,EAAS3xB,EAAUzc,GACpC,MAAM,GAAN,OAAUkuC,EAAV,cAAwBvxB,EAAxB,YAAgCJ,EAAhC,YAAwC4xB,GAMnC,SAASjuC,EAAT,EAELF,GACS,IAFP2c,EAEM,EAFNA,KAAMJ,EAEA,EAFAA,KAAME,EAEN,EAFMA,SAGRyxB,EAAWD,IAAY,QAAU,OACjCE,EAAWC,EAAS3xB,EAAUzc,GACpC,MAAM,GAAN,OAAUkuC,EAAV,cAAwBvxB,EAAxB,YAAgCJ,EAAhC,YAAwC4xB,GAG1C,SAASC,EAAS3xB,EAAkB4xB,GAIlC,OAHA5xB,EAAWA,EAASnjB,QAAQy0C,EAAgB,IAAIz0C,QAAQ00C,EAAkB,IAC1EK,EAAUA,EAAQ/0C,QAAQy0C,EAAgB,IAAIz0C,QAAQ00C,EAAkB,IAEhD,IAApBvxB,EAAS7C,OACJy0B,EAGH,GAAN,OAAU5xB,EAAV,YAAsB4xB,GAMxB,SAASJ,IACP,OAAOzvC,OAAOC,SAASpH,KAAK2b,WAAW,YAOlC,SAASs7B,EAAc72B,GAC5B,OAAOA,EAAIzE,WAAW,UAClB9S,EAAa0b,IAAyBnE,GACtCA,I,oECvESxP,G,OATF,SAAC,GAAD,IAAG/R,EAAH,EAAGA,KAAMG,EAAT,EAASA,UAAT,OACX,0BACEA,UAAWsC,IAAW,cAAetC,GACrCk4C,aAAYr4C,EACZiJ,MAAOjJ,EACPs4C,cAAY,WC9BhB,mC,qdCwBMC,E,WAGJ,WAAYC,GAAiB,yBAFZA,YAEW,EAC1Bh5C,KAAKg5C,OAASA,E,sDAId,OAAOh5C,KAAKg5C,W,KA2BV9gB,EAAS,I,oGAtBD+gB,GACV,OAAO,IAAIjlC,KAAKilC,EAAQ,O,sCAGVA,GACd,OAAO,IAAIF,EAASE,EAAQ,O,mCAGjBjhB,GACX,IAAMkhB,EAAIjhB,IAAOD,GACbE,EAAS,MAIb,OAHiB,IAAbghB,EAAEC,QAA+B,IAAfD,EAAEE,UAAiC,IAAfF,EAAEG,WAC1CnhB,EAAS,MAEJghB,EAAEhhB,OAAOA,K,uCAGDxkB,GACf,OAAOukB,IAAOvkB,SAASA,EAAS4lC,WAAWphB,a,MAS/C,SAASzyB,EAAkBsxC,GACzB,OAcewC,EAdHxC,EAeL1d,OAAOkgB,KAAOA,GAAKA,EAAI,IAAM,EAd3BC,IAAOzC,GAAG7e,OAAO,YACf6e,aAAa/iC,KACfkkB,EAAOuhB,aAAa1C,GAClBA,aAAagC,EACf7gB,EAAOwhB,iBAAiB3C,GAExBA,EAAE7uC,WAOb,IAAiBqxC,I,sFC/EjB,IAAI12C,EAAM,CACT,mBAAoB,IACpB,sBAAuB,IACvB,gBAAiB,IACjB,mBAAoB,IACpB,gBAAiB,IACjB,mBAAoB,IACpB,sBAAuB,IACvB,yBAA0B,IAC1B,gBAAiB,IACjB,mBAAoB,IACpB,mBAAoB,IACpB,sBAAuB,IACvB,qBAAsB,IACtB,wBAAyB,IACzB,eAAgB,IAChB,kBAAmB,IACnB,gBAAiB,IACjB,mBAAoB,IACpB,kBAAmB,IACnB,qBAAsB,IACtB,mBAAoB,IACpB,sBAAuB,IACvB,eAAgB,IAChB,kBAAmB,IACnB,mBAAoB,IACpB,sBAAuB,IACvB,iBAAkB,IAClB,oBAAqB,IACrB,oBAAqB,IACrB,uBAAwB,IACxB,cAAe,IACf,iBAAkB,IAClB,cAAe,IACf,iBAAkB,KAInB,SAAS82C,EAAeC,GACvB,IAAI3iC,EAAK4iC,EAAsBD,GAC/B,OAAOE,EAAoB7iC,GAE5B,SAAS4iC,EAAsBD,GAC9B,IAAIE,EAAoBC,EAAEl3C,EAAK+2C,GAAM,CACpC,IAAIn2C,EAAI,IAAIkC,MAAM,uBAAyBi0C,EAAM,KAEjD,MADAn2C,EAAEqhB,KAAO,mBACHrhB,EAEP,OAAOZ,EAAI+2C,GAEZD,EAAevnB,KAAO,WACrB,OAAOzE,OAAOyE,KAAKvvB,IAEpB82C,EAAex5B,QAAU05B,EACzBv5C,EAAO83C,QAAUuB,EACjBA,EAAe1iC,GAAK,K,oBCvDpB,IAAIpU,EAAM,CACT,mBAAoB,IACpB,sBAAuB,IACvB,gBAAiB,IACjB,mBAAoB,IACpB,gBAAiB,IACjB,mBAAoB,IACpB,gBAAiB,IACjB,mBAAoB,IACpB,mBAAoB,IACpB,sBAAuB,IACvB,qBAAsB,IACtB,wBAAyB,IACzB,gBAAiB,IACjB,mBAAoB,IACpB,kBAAmB,IACnB,qBAAsB,IACtB,mBAAoB,IACpB,sBAAuB,IACvB,eAAgB,IAChB,kBAAmB,IACnB,mBAAoB,IACpB,sBAAuB,IACvB,iBAAkB,IAClB,oBAAqB,IACrB,oBAAqB,IACrB,uBAAwB,IACxB,cAAe,IACf,iBAAkB,IAClB,cAAe,IACf,iBAAkB,KAInB,SAAS82C,EAAeC,GACvB,IAAI3iC,EAAK4iC,EAAsBD,GAC/B,OAAOE,EAAoB7iC,GAE5B,SAAS4iC,EAAsBD,GAC9B,IAAIE,EAAoBC,EAAEl3C,EAAK+2C,GAAM,CACpC,IAAIn2C,EAAI,IAAIkC,MAAM,uBAAyBi0C,EAAM,KAEjD,MADAn2C,EAAEqhB,KAAO,mBACHrhB,EAEP,OAAOZ,EAAI+2C,GAEZD,EAAevnB,KAAO,WACrB,OAAOzE,OAAOyE,KAAKvvB,IAEpB82C,EAAex5B,QAAU05B,EACzBv5C,EAAO83C,QAAUuB,EACjBA,EAAe1iC,GAAK,K,0WCIL+iC,E,2MA7BLxqC,OAASxJ,sB,EACTi0C,UAAgC,K,EAEjC5zC,kBAAoB,WACzB,IAAMmH,EAAO,EAAKgC,OAAOlJ,QAEZ,OAATkH,IACF,EAAKysC,UAAY,IAAIC,IAAU1sC,K,EAI5B7G,qBAAuB,WACL,OAAnB,EAAKszC,WACP,EAAKA,UAAUE,W,EAIZ/xC,OAAS,kBACd,4BACEzH,UAAU,aACV8I,MAAM,oBACNJ,IAAK,EAAKmG,OACV4qC,sBAAqB,EAAKn6C,MAAMoP,MAEhC,kBAAC,OAAD,CAAUzM,KAAK,S,6BAzBI3B,iBC6DVo5C,G,wLAzCX,GAA2B,MAAvBr6C,KAAKC,MAAMq6C,SACb,OACE,yBAAK35C,UAAU,eACb,kBAAC,EAAD,CAAY0O,KAAMrP,KAAKC,MAAM2H,QAC7B,6BACE,8BAAO5H,KAAKC,MAAM2H,SAO1B,IAAI2yC,EAAOC,IAAMC,UAAUz6C,KAAKC,MAAMq6C,SAASI,eAC3CC,EAAiB,mBAAe36C,KAAKC,MAAMq6C,eAElCh3C,IAATi3C,IACFtZ,QAAQE,KAAR,qCACgCnhC,KAAKC,MAAMq6C,SAD3C,2BAGAC,EAAOC,IAAMC,UAAUG,OACvBD,EAAoB,mBAGtB,IAAME,EAAW76C,KAAKC,MAAM2H,MACxB4yC,IAAMM,UAAU96C,KAAKC,MAAM2H,MAAO2yC,EAAM,IACxC,GAEJ,OACE,yBAAK55C,UAAU,eACb,kBAAC,EAAD,CAAY0O,KAAMrP,KAAKC,MAAM2H,QAC7B,6BACE,0BACEjH,UAAWg6C,EACXI,wBAAyB,CAAEC,OAAQH,W,GAnCvB55C,kB,yCCKjB,IAAMuB,EAAb,2MACSnB,kBAAoB,WAAa,IAC9BoB,EAAW,EAAKxC,MAAhBwC,OAER,MAAMkrB,OAAOC,OAAO,IAAIjoB,MAAS,CAC/BvF,KAAM,gDACNoB,QAAS,2BAAIiB,GACbhB,MAAO,QAPb,EAWS2G,OAAS,WAAkB,IAAD,EACD,EAAKnI,MAA3BwC,EADuB,EACvBA,OAAQC,EADe,EACfA,UAEVu4C,EAAY,CAChBn2B,KAAMu1B,EACNa,KAAMC,EACNC,cAAeC,EACfC,WAAY,SAACr7C,GAAD,OACV,kBAAC,aAAD,KAAaA,EAAM2H,QAErB2zC,KAAM,SAACt7C,GAAD,OACJ,kBAAC,YAAD,KAAYA,EAAM2H,SAIhB4zC,EAAU,CAACC,IAAkBC,KAC7BC,EAAaj5C,EAAY,CAACk5C,OAAgB,GAEhD,OACE,kBAAC,IAAD,CACEn5C,OAAQA,EACRo5C,YAAan5C,EACbi5C,WAAYA,EACZH,QAASA,EACTP,UAAWA,KAnCnB,6BAAuCh6C,iBAqDhC,SAASk6C,EAAoBl7C,GAClC,OACE,uBAAG0B,KAAM1B,EAAM0B,KAAME,OAAO,SAASD,IAAI,uBACtC3B,EAAM6B,UAON,SAASu5C,EACdp7C,GACsB,IACd0B,EAAmB1B,EAAnB0B,KAAMG,EAAa7B,EAAb6B,SAEd,OAAKH,EAOH,uBAAGA,KAAMA,EAAME,OAAO,SAASD,IAAI,uBAChCE,GAPIA,EAASoiB,OACd,kBAAC,WAAD,SAAYpiB,EAAS,GAAG7B,MAAM6B,SAA9B,KACE,O","file":"static/js/main.c9563d9f.chunk.js","sourcesContent":["/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport enum ReportRunState {\r\n  NOT_RUNNING = \"notRunning\",\r\n  RUNNING = \"running\",\r\n  RERUN_REQUESTED = \"rerunRequested\", // report *not* running, but user requested it be re-run\r\n  STOP_REQUESTED = \"stopRequested\", // report *is* running, but user requested it be stopped\r\n  COMPILATION_ERROR = \"compilationError\", // report's script failed with a compilation error\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent } from \"react\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\nimport \"./DocString.scss\"\r\n\r\nexport interface Props {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n}\r\n\r\n/**\r\n * Functional element representing formatted text.\r\n */\r\nclass DocString extends PureComponent<Props> {\r\n  public render(): React.ReactNode {\r\n    const { element, width } = this.props\r\n\r\n    const name = element.get(\"name\")\r\n    const module = element.get(\"module\")\r\n    const docString = element.get(\"docString\")\r\n    const type = element.get(\"type\")\r\n    const signature = element.get(\"signature\")\r\n\r\n    const moduleHtml = (\r\n      <span className=\"doc-module\" key=\"module\">\r\n        {module}.\r\n      </span>\r\n    )\r\n    const nameHtml = (\r\n      <span className=\"doc-name\" key=\"name\">\r\n        {name}\r\n      </span>\r\n    )\r\n    const signatureHtml = (\r\n      <span className=\"doc-signature\" key=\"signature\">\r\n        {signature}\r\n      </span>\r\n    )\r\n    const typeHtml = (\r\n      <span key=\"type\" className=\"doc-type\">\r\n        {type}\r\n      </span>\r\n    )\r\n\r\n    // Put it all together into a nice little html view.\r\n    return (\r\n      <div className=\"doc-containter\" style={{ width }}>\r\n        <div className=\"doc-header\">\r\n          {name\r\n            ? [\r\n                module ? moduleHtml : \"\",\r\n                nameHtml,\r\n                signature ? signatureHtml : \"\",\r\n              ]\r\n            : [typeHtml]}\r\n        </div>\r\n        <div className=\"doc-string\">{docString}</div>\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default DocString\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React from \"react\"\r\nimport ErrorElement from \"components/shared/ErrorElement/\"\r\nimport { logError } from \"lib/log\"\r\n\r\nexport interface Props {\r\n  width?: number\r\n}\r\n\r\nexport interface State {\r\n  error?: Error | null\r\n}\r\n\r\n/**\r\n * A component that catches errors that take place when React is asynchronously\r\n * rendering child components.\r\n */\r\nclass ErrorBoundary extends React.PureComponent<Props, State> {\r\n  public state: State = {\r\n    error: null,\r\n  }\r\n\r\n  public static getDerivedStateFromError = (error: Error): State => {\r\n    // Return the state update so the next render will show the fallback UI.\r\n    return {\r\n      error: error,\r\n    }\r\n  }\r\n\r\n  public componentDidCatch = (error: Error, info: React.ErrorInfo): void => {\r\n    logError(`${error.name}: ${error.message}\\n${error.stack}`)\r\n  }\r\n\r\n  public render(): React.ReactNode {\r\n    const { error } = this.state\r\n\r\n    if (error) {\r\n      if (error.name === \"ChunkLoadError\") {\r\n        return (\r\n          <ErrorElement\r\n            width={this.props.width}\r\n            name=\"Network issue\"\r\n            message={\r\n              <p>\r\n                Cannot load Streamlit frontend code. This can happen when you\r\n                update Streamlit while a Streamlit app is running.\r\n                <br />\r\n                To fix this, simply reload this app by pressing <kbd>\r\n                  F5\r\n                </kbd>, <kbd>Ctrl+R</kbd>, or <kbd>Cmd+R</kbd>.\r\n                <br />\r\n                If the error persists, try force-clearing your browser's cache\r\n                as described{\" \"}\r\n                <a\r\n                  href=\"https://en.wikipedia.org/wiki/Wikipedia:Bypass_your_cache#Cache_clearing_and_disabling\"\r\n                  rel=\"noopener noreferrer\"\r\n                  target=\"_blank\"\r\n                >\r\n                  here\r\n                </a>\r\n              </p>\r\n            }\r\n          />\r\n        )\r\n      }\r\n\r\n      return (\r\n        <ErrorElement\r\n          width={this.props.width}\r\n          name={error.name}\r\n          message={error.message}\r\n          stack={error.stack}\r\n        />\r\n      )\r\n    }\r\n\r\n    return this.props.children\r\n  }\r\n}\r\n\r\nexport default ErrorBoundary\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport ErrorElement from \"components/shared/ErrorElement\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\nimport {\r\n  DEFAULT_IFRAME_FEATURE_POLICY,\r\n  DEFAULT_IFRAME_SANDBOX_POLICY,\r\n} from \"lib/IFrameUtil\"\r\nimport { logError, logWarning } from \"lib/log\"\r\nimport { Source, WidgetStateManager } from \"lib/WidgetStateManager\"\r\nimport React, { createRef, ReactNode } from \"react\"\r\nimport { ComponentRegistry } from \"./ComponentRegistry\"\r\nimport queryString from \"query-string\"\r\n\r\n/**\r\n * The current custom component API version. If our API changes,\r\n * this value must be incremented. ComponentInstances send their API\r\n * version in the COMPONENT_READY call.\r\n */\r\nexport const CUSTOM_COMPONENT_API_VERSION = 1\r\n\r\n/** Messages from Component -> Streamlit */\r\nexport enum ComponentMessageType {\r\n  // A component sends this message when it's ready to receive messages\r\n  // from Streamlit. Streamlit won't send any messages until it gets this.\r\n  // Data: { apiVersion: number }\r\n  COMPONENT_READY = \"streamlit:componentReady\",\r\n\r\n  // The component has a new value. Send it back to Streamlit, which\r\n  // will then re-run the app.\r\n  // Data: { value: any }\r\n  SET_COMPONENT_VALUE = \"streamlit:setComponentValue\",\r\n\r\n  // The component has a new height for its iframe.\r\n  // Data: { height: number }\r\n  SET_FRAME_HEIGHT = \"streamlit:setFrameHeight\",\r\n}\r\n\r\n/** Messages from Streamlit -> Component */\r\nexport enum StreamlitMessageType {\r\n  // Sent by Streamlit when the component should re-render.\r\n  // Data: { args: any, disabled: boolean }\r\n  RENDER = \"streamlit:render\",\r\n}\r\n\r\ninterface Props {\r\n  registry: ComponentRegistry\r\n  widgetMgr: WidgetStateManager\r\n\r\n  disabled: boolean\r\n  element: ImmutableMap<string, any>\r\n  width: number\r\n}\r\n\r\ninterface State {\r\n  componentError?: Error\r\n}\r\n\r\nexport class ComponentInstance extends React.PureComponent<Props, State> {\r\n  private iframeRef = createRef<HTMLIFrameElement>()\r\n  // True when we've received the COMPONENT_READY message\r\n  private componentReady = false\r\n  private lastRenderArgs = {}\r\n  private lastRenderDataframes = []\r\n  private frameHeight = 0\r\n\r\n  public constructor(props: Props) {\r\n    super(props)\r\n    this.state = {}\r\n  }\r\n\r\n  public componentDidMount = (): void => {\r\n    if (this.iframeRef.current == null) {\r\n      // This should not be possible.\r\n      logError(\r\n        `ComponentInstance does not have an iframeRef, and will not receive messages!`\r\n      )\r\n      return\r\n    }\r\n\r\n    if (this.iframeRef.current.contentWindow == null) {\r\n      // Nor should this.\r\n      logError(\r\n        `ComponentInstance iframe does not have a contentWindow, and will not receive messages!`\r\n      )\r\n      return\r\n    }\r\n\r\n    this.props.registry.registerListener(\r\n      this.iframeRef.current.contentWindow,\r\n      this.onBackMsg\r\n    )\r\n  }\r\n\r\n  public componentWillUnmount = (): void => {\r\n    if (\r\n      this.iframeRef.current == null ||\r\n      this.iframeRef.current.contentWindow == null\r\n    ) {\r\n      return\r\n    }\r\n\r\n    this.props.registry.deregisterListener(\r\n      this.iframeRef.current.contentWindow\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Receive a ComponentBackMsg from our component iframe.\r\n   */\r\n  private onBackMsg = (type: string, data: any): void => {\r\n    switch (type) {\r\n      case ComponentMessageType.COMPONENT_READY:\r\n        // Our component is ready to begin receiving messages. Send off its\r\n        // first render message! It is *not* an error to get multiple\r\n        // COMPONENT_READY messages. This can happen if a component is being\r\n        // served from the webpack dev server, and gets reloaded. We\r\n        // always respond to this message with the most recent render\r\n        // arguments.\r\n        const apiVersion = data[\"apiVersion\"]\r\n        if (apiVersion !== CUSTOM_COMPONENT_API_VERSION) {\r\n          // In the future, we may end up with multiple API versions we\r\n          // need to support. For now, we just have the one.\r\n          this.setState({\r\n            componentError: new Error(\r\n              `Unrecognized component API version: '${apiVersion}'`\r\n            ),\r\n          })\r\n        } else {\r\n          this.componentReady = true\r\n          this.sendForwardMsg(StreamlitMessageType.RENDER, {\r\n            args: this.lastRenderArgs,\r\n            dfs: this.lastRenderDataframes,\r\n          })\r\n        }\r\n        break\r\n\r\n      case ComponentMessageType.SET_COMPONENT_VALUE:\r\n        if (!this.componentReady) {\r\n          logWarning(\r\n            `Got ${type} before ${ComponentMessageType.COMPONENT_READY}!`\r\n          )\r\n        } else {\r\n          this.handleSetComponentValue(data, { fromUi: true })\r\n        }\r\n        break\r\n\r\n      case ComponentMessageType.SET_FRAME_HEIGHT:\r\n        if (!this.componentReady) {\r\n          logWarning(\r\n            `Got ${type} before ${ComponentMessageType.COMPONENT_READY}!`\r\n          )\r\n        } else {\r\n          this.handleSetFrameHeight(data)\r\n        }\r\n        break\r\n\r\n      default:\r\n        logWarning(`Unrecognized ComponentBackMsgType: ${type}`)\r\n    }\r\n  }\r\n\r\n  /** The component set a new value. Send it back to Streamlit. */\r\n  private handleSetComponentValue = (data: any, source: Source): void => {\r\n    const value = tryGetValue(data, \"value\")\r\n    if (value === undefined) {\r\n      logWarning(`handleSetComponentValue: missing 'value' prop`)\r\n      return\r\n    }\r\n\r\n    const widgetId: string = this.props.element.get(\"id\")\r\n    this.props.widgetMgr.setJsonValue(widgetId, value, source)\r\n  }\r\n\r\n  /** The component has a new height. Resize its iframe. */\r\n  private handleSetFrameHeight = (data: any): void => {\r\n    const height: number | undefined = tryGetValue(data, \"height\")\r\n    if (height === undefined) {\r\n      logWarning(`handleSetFrameHeight: missing 'height' prop`)\r\n      return\r\n    }\r\n\r\n    if (height === this.frameHeight) {\r\n      // Nothing to do!\r\n      return\r\n    }\r\n\r\n    if (this.iframeRef.current == null) {\r\n      // This should not be possible.\r\n      logWarning(`handleSetFrameHeight: missing our iframeRef!`)\r\n      return\r\n    }\r\n\r\n    // We shove our new frameHeight directly into our iframe, to avoid\r\n    // triggering a re-render. Otherwise, components will receive the RENDER\r\n    // event several times during startup (because they will generally\r\n    // immediately change their frameHeight after mounting). This is wasteful,\r\n    // and it also breaks certain components.\r\n    this.frameHeight = height\r\n    this.iframeRef.current.height = this.frameHeight.toString()\r\n  }\r\n\r\n  private sendForwardMsg = (type: StreamlitMessageType, data: any): void => {\r\n    if (this.iframeRef.current == null) {\r\n      // This should never happen!\r\n      logWarning(\"Can't send ForwardMsg; missing our iframe!\")\r\n      return\r\n    }\r\n\r\n    if (this.iframeRef.current.contentWindow == null) {\r\n      // Nor should this!\r\n      logWarning(\"Can't send ForwardMsg; iframe has no contentWindow!\")\r\n      return\r\n    }\r\n\r\n    this.iframeRef.current.contentWindow.postMessage(\r\n      {\r\n        type: type,\r\n        ...data,\r\n      },\r\n      \"*\"\r\n    )\r\n  }\r\n\r\n  public render = (): ReactNode => {\r\n    if (this.state.componentError != null) {\r\n      // If we have an error, display it and bail.\r\n      return (\r\n        <ErrorElement\r\n          name={this.state.componentError.name}\r\n          message={this.state.componentError.message}\r\n        />\r\n      )\r\n    }\r\n\r\n    // Parse the component's arguments and src URL.\r\n    // Some of these steps may throw an exception, so we wrap them in a\r\n    // try-catch. If we catch an error, we set this.state.componentError\r\n    // and bail. The error will be displayed in the next call to render,\r\n    // which will be triggered immediately. (This will not cause an infinite\r\n    // loop.)\r\n    let renderArgs: any\r\n    let renderDfs: any\r\n    let src: string\r\n    let componentName: string\r\n    try {\r\n      // Determine the component iframe's src. If a URL is specified, we just\r\n      // use that. Otherwise, we derive the URL from the component's ID.\r\n      componentName = this.props.element.get(\"componentName\")\r\n      const url = this.props.element.get(\"url\")\r\n      if (url != null && url !== \"\") {\r\n        src = url\r\n      } else {\r\n        src = this.props.registry.getComponentURL(componentName, \"index.html\")\r\n      }\r\n\r\n      // Add streamlitUrl query parameter to src.\r\n      src = queryString.stringifyUrl({\r\n        url: src,\r\n        query: { streamlitUrl: window.location.href },\r\n      })\r\n\r\n      // Parse arguments\r\n      renderArgs = JSON.parse(this.props.element.get(\"argsJson\"))\r\n      renderDfs = this.props.element.get(\"argsDataframe\").toJS()\r\n    } catch (err) {\r\n      this.setState({ componentError: err })\r\n      return undefined\r\n    }\r\n\r\n    if (this.componentReady) {\r\n      // The component has loaded. Send it a new render message immediately.\r\n      this.sendForwardMsg(StreamlitMessageType.RENDER, {\r\n        args: renderArgs,\r\n        dfs: renderDfs,\r\n        disabled: this.props.disabled,\r\n      })\r\n    }\r\n\r\n    // We always store the most recent render arguments in order to respond\r\n    // to COMPONENT_READY messages. Components can indicate that they're ready\r\n    // multiple times (this will happen if a plugin auto-reloads itself -\r\n    // for example, if it's being served from a webpack dev server). When\r\n    // component sends the COMPONENT_READY message, we send it the most\r\n    // recent render arguments.\r\n    this.lastRenderArgs = renderArgs\r\n    this.lastRenderDataframes = renderDfs\r\n\r\n    // Render the iframe. We set scrolling=\"no\", because we don't want\r\n    // scrollbars to appear; instead, we want components to properly auto-size\r\n    // themselves.\r\n    //\r\n    // Without this, there is a potential for a scrollbar to\r\n    // appear for a brief moment after an iframe's content gets bigger,\r\n    // and before it sends the \"setFrameHeight\" message back to Streamlit.\r\n    //\r\n    // We may ultimately want to give components control over the \"scrolling\"\r\n    // property.\r\n    //\r\n    // TODO: make sure horizontal scrolling still works!\r\n    return (\r\n      <iframe\r\n        allow={DEFAULT_IFRAME_FEATURE_POLICY}\r\n        ref={this.iframeRef}\r\n        src={src}\r\n        width={this.props.width}\r\n        height={this.frameHeight}\r\n        scrolling=\"no\"\r\n        sandbox={DEFAULT_IFRAME_SANDBOX_POLICY}\r\n        title={componentName}\r\n      />\r\n    )\r\n  }\r\n}\r\n\r\n/** Return the property with the given name, if it exists. */\r\nfunction tryGetValue(\r\n  obj: any,\r\n  name: string,\r\n  defaultValue: any = undefined\r\n): any {\r\n  return obj.hasOwnProperty(name) ? obj[name] : defaultValue\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { ReactNode, PureComponent } from \"react\"\r\nimport classNames from \"classnames\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\nimport { StreamlitMarkdown } from \"components/shared/StreamlitMarkdown\"\r\nimport \"./ExceptionElement.scss\"\r\n\r\nexport interface Props {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n}\r\n\r\n/**\r\n * Functional element representing formatted text.\r\n */\r\nclass ExceptionElement extends PureComponent<Props> {\r\n  public render(): ReactNode {\r\n    const { element, width } = this.props\r\n\r\n    const type = element.get(\"type\")\r\n    const message = element.get(\"message\")\r\n    const stackTrace = element.get(\"stackTrace\")\r\n    const isWarning = element.get(\"isWarning\")\r\n\r\n    // Build the message display.\r\n    // On the backend, we use the StreamlitException type for errors that\r\n    // originate from inside Streamlit. These errors have Markdown-formatted\r\n    // messages, and so we wrap those messages inside our Markdown renderer.\r\n    let messageNode: ReactNode\r\n    if (element.get(\"messageIsMarkdown\")) {\r\n      let markdown = `**${type}**`\r\n      if (message) {\r\n        markdown += `: ${message}`\r\n      }\r\n      messageNode = <StreamlitMarkdown source={markdown} allowHTML={false} />\r\n    } else {\r\n      messageNode = (\r\n        <>\r\n          <span className=\"type\">{type}</span>\r\n          {message != null ? `: ${message}` : null}\r\n        </>\r\n      )\r\n    }\r\n\r\n    // Build the stack trace display, if we got a stack trace.\r\n    let stackTraceNode: ReactNode = null\r\n    if (stackTrace && stackTrace.size > 0) {\r\n      stackTraceNode = (\r\n        <>\r\n          <div className=\"stack-trace-title\">Traceback:</div>\r\n          <pre className=\"stack-trace\">\r\n            <code>\r\n              {stackTrace.map((row: string, indx: string) => (\r\n                <div className=\"stack-trace-row\" key={indx}>\r\n                  {row}\r\n                </div>\r\n              ))}\r\n            </code>\r\n          </pre>\r\n        </>\r\n      )\r\n    }\r\n\r\n    const wrapperClasses = classNames(\"alert\", \"exception\", \"stException\", {\r\n      \"alert-danger\": !isWarning,\r\n      \"alert-warning\": isWarning,\r\n    })\r\n\r\n    return (\r\n      <div className={wrapperClasses} style={{ width }}>\r\n        <div className=\"message\">{messageNode}</div>\r\n        {stackTraceNode}\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default ExceptionElement\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { ReactNode } from \"react\"\r\n\r\nimport ReactJson from \"react-json-view\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\n\r\nimport \"assets/css/write.scss\"\r\n\r\ninterface Props {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n}\r\n\r\n/**\r\n * Functional element representing JSON structured text.\r\n */\r\nclass Json extends React.PureComponent<Props> {\r\n  public render(): ReactNode {\r\n    const { element, width } = this.props\r\n    const body = element.get(\"body\")\r\n    const styleProp = { width }\r\n\r\n    let bodyObject = undefined\r\n    try {\r\n      bodyObject = JSON.parse(body)\r\n    } catch (e) {\r\n      // If content fails to parse as Json, rebuild the error message\r\n      // to show where the problem occurred.\r\n      const pos = parseInt(e.message.replace(/[^0-9]/g, \"\"), 10)\r\n      e.message += `\\n${body.substr(0, pos + 1)} ← here`\r\n      throw e\r\n    }\r\n    return (\r\n      <div className=\"json-text-container stJson\" style={styleProp}>\r\n        <ReactJson\r\n          src={bodyObject}\r\n          displayDataTypes={false}\r\n          displayObjectSize={false}\r\n          name={false}\r\n          style={{ font: \"\" }} // Unset so we can style via a CSS file.\r\n        />\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default Json\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { StreamlitMarkdown } from \"components/shared/StreamlitMarkdown\"\r\nimport React, { ReactNode } from \"react\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\n\r\nimport \"assets/css/write.scss\"\r\n\r\nexport interface Props {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n}\r\n\r\n/**\r\n * Functional element representing Markdown formatted text.\r\n */\r\nclass Markdown extends React.PureComponent<Props> {\r\n  public render(): ReactNode {\r\n    const { element, width } = this.props\r\n    const body = element.get(\"body\")\r\n    const styleProp = { width }\r\n\r\n    const allowHTML = element.get(\"allowHtml\")\r\n    return (\r\n      <div className=\"markdown-text-container stMarkdown\" style={styleProp}>\r\n        <StreamlitMarkdown source={body} allowHTML={allowHTML} />\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default Markdown\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent } from \"react\"\r\nimport { Table as ReactTable } from \"reactstrap\"\r\nimport { toFormattedString } from \"lib/format\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\nimport { dataFrameGet, dataFrameGetDimensions } from \"lib/dataFrameProto\"\r\nimport withFullScreenWrapper from \"hocs/withFullScreenWrapper\"\r\nimport \"./Table.scss\"\r\n\r\n/**\r\n * Functional element representing a DataFrame.\r\n */\r\nexport interface Props {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n}\r\n\r\nexport class Table extends PureComponent<Props> {\r\n  render(): JSX.Element {\r\n    const { element } = this.props\r\n    const { headerRows, rows, cols } = dataFrameGetDimensions(element)\r\n\r\n    const hasNoData = rows === headerRows\r\n\r\n    // TODO(tvst): Make tables have a max width with overflow: scroll (when\r\n    // media==screen). But need to fix the autosizer first.\r\n    return (\r\n      <div className=\"streamlit-table stTable\">\r\n        <ReactTable className={hasNoData ? \"empty-table\" : \"\"}>\r\n          <thead>\r\n            <TableRows\r\n              df={element}\r\n              header={true}\r\n              headerRows={headerRows}\r\n              rows={rows}\r\n              cols={cols}\r\n            />\r\n          </thead>\r\n          <tbody>\r\n            {hasNoData ? (\r\n              <tr>\r\n                <td colSpan={cols || 1}>empty</td>\r\n              </tr>\r\n            ) : (\r\n              <TableRows\r\n                df={element}\r\n                headerRows={headerRows}\r\n                rows={rows}\r\n                cols={cols}\r\n              />\r\n            )}\r\n          </tbody>\r\n        </ReactTable>\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\n/**\r\n * Purely functional component returning a list of rows.\r\n *\r\n * df         - The dataFrame to display.\r\n * header     - Whether to display the header.\r\n * headerRows - Number of rows in the header.\r\n * rows       - Number of rows in the table (header + data).\r\n * cols       - Number of colums in the table.\r\n */\r\ninterface TableRowsProps {\r\n  df: ImmutableMap<string, any>\r\n  header?: boolean | false\r\n  headerRows: number\r\n  rows: number\r\n  cols: number\r\n}\r\n\r\nconst TableRows: React.SFC<TableRowsProps> = props => {\r\n  const { df, header, headerRows, rows, cols } = props\r\n  const startRow = header ? 0 : headerRows\r\n  const endRow = header ? headerRows : rows\r\n  const rowArray = []\r\n  for (let rowIdx = startRow; rowIdx < endRow; rowIdx++) {\r\n    rowArray.push(\r\n      <tr key={rowIdx}>\r\n        <TableRow df={df} rowIdx={rowIdx} cols={cols} />\r\n      </tr>\r\n    )\r\n  }\r\n  return <React.Fragment>{rowArray}</React.Fragment>\r\n}\r\n\r\n/**\r\n * Purely functional component returning a list entries for a row.\r\n *\r\n * df     - The dataFrame to display.\r\n * rowIdx - The row index.\r\n * cols   - numver of colums in the table.\r\n */\r\n\r\ninterface TableRowProps {\r\n  df: ImmutableMap<string, any>\r\n  rowIdx: number\r\n  cols: number\r\n}\r\n\r\nconst TableRow: React.SFC<TableRowProps> = (props: TableRowProps) => {\r\n  const { df, rowIdx, cols } = props\r\n  const entries = []\r\n  for (let colIdx = 0; colIdx < cols; colIdx++) {\r\n    const { contents, styles, type } = dataFrameGet(df, colIdx, rowIdx)\r\n    const formattedContents = toFormattedString(contents)\r\n    if (type === \"corner\") {\r\n      entries.push(<th key={colIdx}>&nbsp;</th>)\r\n    } else if (type === \"row-header\") {\r\n      entries.push(\r\n        <th key={colIdx} scope=\"row\">\r\n          {formattedContents}\r\n        </th>\r\n      )\r\n    } else if (type === \"col-header\") {\r\n      entries.push(<th key={colIdx}>{formattedContents}</th>)\r\n    } else if (type === \"data\") {\r\n      entries.push(\r\n        <td style={styles} key={colIdx}>\r\n          {formattedContents}\r\n        </td>\r\n      )\r\n    } else {\r\n      throw new Error(`Cannot parse type \"${type}\".`)\r\n    }\r\n  }\r\n  return <React.Fragment>{entries}</React.Fragment>\r\n}\r\n\r\nexport default withFullScreenWrapper(Table)\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { ReactNode } from \"react\"\r\nimport classNames from \"classnames\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\n\r\nimport \"assets/css/write.scss\"\r\n\r\nexport interface Props {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n}\r\n\r\n/**\r\n * Functional element representing preformatted (plain) text.\r\n */\r\nclass Text extends React.PureComponent<Props> {\r\n  public render(): ReactNode {\r\n    const { element, width } = this.props\r\n    const body = element.get(\"body\")\r\n    const styleProp = { width }\r\n\r\n    return (\r\n      <div className={classNames(\"fixed-width\", \"stText\")} style={styleProp}>\r\n        {body}\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default Text\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { logWarning } from \"lib/log\"\r\nimport { BaseUriParts, buildHttpUri } from \"lib/UriUtil\"\r\nimport { ComponentMessageType } from \"./ComponentInstance\"\r\n\r\nexport type ComponentMessageListener = (\r\n  type: ComponentMessageType,\r\n  data: any\r\n) => void\r\n\r\n/**\r\n * Dispatches iframe messages to ComponentInstances.\r\n */\r\nexport class ComponentRegistry {\r\n  private readonly getServerUri: () => BaseUriParts | undefined\r\n  private readonly msgListeners = new Map<\r\n    MessageEventSource,\r\n    ComponentMessageListener\r\n  >()\r\n  private cachedServerUri?: BaseUriParts\r\n\r\n  public constructor(getServerUri: () => BaseUriParts | undefined) {\r\n    this.getServerUri = getServerUri\r\n    window.addEventListener(\"message\", this.onMessageEvent)\r\n  }\r\n\r\n  /**\r\n   * Register a listener for component messages dispatched by the given source.\r\n   */\r\n  public registerListener = (\r\n    source: MessageEventSource,\r\n    listener: ComponentMessageListener\r\n  ): void => {\r\n    if (this.msgListeners.has(source)) {\r\n      logWarning(`MessageEventSource registered multiple times!`, source)\r\n    }\r\n\r\n    this.msgListeners.set(source, listener)\r\n  }\r\n\r\n  public deregisterListener = (source: MessageEventSource): void => {\r\n    const removed = this.msgListeners.delete(source)\r\n    if (!removed) {\r\n      logWarning(`Could not deregister unregistered MessageEventSource!`)\r\n    }\r\n  }\r\n\r\n  public getComponentURL = (componentName: string, path: string): string => {\r\n    // Fetch the server URI. If our server is disconnected, this will return\r\n    // undefined, in which case we default to the most recent cached value\r\n    // of the URI.\r\n    let serverUri = this.getServerUri()\r\n    if (serverUri === undefined) {\r\n      if (this.cachedServerUri === undefined) {\r\n        throw new Error(\"Can't fetch component: not connected to a server\")\r\n      }\r\n      serverUri = this.cachedServerUri\r\n    }\r\n\r\n    this.cachedServerUri = serverUri\r\n    return buildHttpUri(serverUri, `component/${componentName}/${path}`)\r\n  }\r\n\r\n  private onMessageEvent = (event: MessageEvent): void => {\r\n    if (\r\n      event.data == null ||\r\n      !event.data.hasOwnProperty(\"isStreamlitMessage\")\r\n    ) {\r\n      // Disregard messages that don't come from components.\r\n      return\r\n    }\r\n\r\n    if (event.source == null) {\r\n      // This should not be possible.\r\n      logWarning(`Received component message with no eventSource!`, event.data)\r\n      return\r\n    }\r\n\r\n    // Get the ComponentInstance associated with the event\r\n    const listener = this.msgListeners.get(event.source)\r\n    if (listener == null) {\r\n      logWarning(\r\n        `Received component message for unregistered ComponentInstance!`,\r\n        event.data\r\n      )\r\n      return\r\n    }\r\n\r\n    const type = event.data[\"type\"]\r\n    if (type == null) {\r\n      logWarning(`Received Streamlit message with no type!`, event.data)\r\n      return\r\n    }\r\n\r\n    // Forward the message on to the appropriate ComponentInstance.\r\n    listener(type, event.data)\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React from \"react\"\r\n\r\nexport interface Props {\r\n  enable: boolean\r\n}\r\n\r\nexport interface State {}\r\n\r\nclass Maybe extends React.Component<Props, State> {\r\n  public shouldComponentUpdate(\r\n    nextProps: Readonly<Props>,\r\n    nextState: Readonly<State>,\r\n    nextContext: any\r\n  ): boolean {\r\n    return nextProps.enable\r\n  }\r\n\r\n  public render(): React.ReactNode {\r\n    return this.props.children\r\n  }\r\n}\r\n\r\nexport default Maybe\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ReactNode, Suspense } from \"react\"\r\nimport { AutoSizer } from \"react-virtualized\"\r\nimport { List } from \"immutable\"\r\nimport { dispatchOneOf } from \"lib/immutableProto\"\r\nimport { ReportRunState } from \"lib/ReportRunState\"\r\nimport { WidgetStateManager } from \"lib/WidgetStateManager\"\r\nimport { makeElementWithInfoText } from \"lib/utils\"\r\nimport { IForwardMsgMetadata } from \"autogen/proto\"\r\nimport { ReportElement, BlockElement, SimpleElement } from \"lib/DeltaParser\"\r\nimport { FileUploadClient } from \"lib/FileUploadClient\"\r\n\r\n// Load (non-lazy) elements.\r\nimport Alert from \"components/elements/Alert/\"\r\nimport DocString from \"components/elements/DocString/\"\r\nimport ErrorBoundary from \"components/shared/ErrorBoundary/\"\r\nimport FullScreenWrapper from \"components/shared/FullScreenWrapper/\"\r\nimport ExceptionElement from \"components/elements/ExceptionElement/\"\r\nimport Json from \"components/elements/Json/\"\r\nimport Markdown from \"components/elements/Markdown/\"\r\nimport Table from \"components/elements/Table/\"\r\nimport Text from \"components/elements/Text/\"\r\nimport {\r\n  ComponentInstance,\r\n  ComponentRegistry,\r\n} from \"components/widgets/CustomComponent/\"\r\n\r\nimport Maybe from \"components/core/Maybe/\"\r\n\r\n// Lazy-load elements.\r\nconst Audio = React.lazy(() => import(\"components/elements/Audio/\"))\r\nconst Balloons = React.lazy(() => import(\"components/elements/Balloons/\"))\r\nconst BokehChart = React.lazy(() => import(\"components/elements/BokehChart/\"))\r\nconst DataFrame = React.lazy(() => import(\"components/elements/DataFrame/\"))\r\nconst DeckGlChart = React.lazy(() =>\r\n  import(\"components/elements/DeckGlChart/\")\r\n)\r\nconst DeckGlJsonChart = React.lazy(() =>\r\n  import(\"components/elements/DeckGlJsonChart/\")\r\n)\r\nconst Favicon = React.lazy(() => import(\"components/elements/Favicon/\"))\r\nconst GraphVizChart = React.lazy(() =>\r\n  import(\"components/elements/GraphVizChart/\")\r\n)\r\nconst IFrame = React.lazy(() => import(\"components/elements/IFrame/\"))\r\nconst ImageList = React.lazy(() => import(\"components/elements/ImageList/\"))\r\nconst PlotlyChart = React.lazy(() =>\r\n  import(\"components/elements/PlotlyChart/\")\r\n)\r\nconst VegaLiteChart = React.lazy(() =>\r\n  import(\"components/elements/VegaLiteChart/\")\r\n)\r\nconst Video = React.lazy(() => import(\"components/elements/Video/\"))\r\n\r\n// Lazy-load widgets.\r\nconst Button = React.lazy(() => import(\"components/widgets/Button/\"))\r\nconst Checkbox = React.lazy(() => import(\"components/widgets/Checkbox/\"))\r\nconst ColorPicker = React.lazy(() => import(\"components/widgets/ColorPicker\"))\r\nconst DateInput = React.lazy(() => import(\"components/widgets/DateInput/\"))\r\nconst Multiselect = React.lazy(() => import(\"components/widgets/Multiselect/\"))\r\nconst Progress = React.lazy(() => import(\"components/elements/Progress/\"))\r\nconst Radio = React.lazy(() => import(\"components/widgets/Radio/\"))\r\nconst Selectbox = React.lazy(() => import(\"components/widgets/Selectbox/\"))\r\nconst Slider = React.lazy(() => import(\"components/widgets/Slider/\"))\r\nconst FileUploader = React.lazy(() =>\r\n  import(\"components/widgets/FileUploader/\")\r\n)\r\nconst TextArea = React.lazy(() => import(\"components/widgets/TextArea/\"))\r\nconst TextInput = React.lazy(() => import(\"components/widgets/TextInput/\"))\r\nconst TimeInput = React.lazy(() => import(\"components/widgets/TimeInput/\"))\r\nconst NumberInput = React.lazy(() => import(\"components/widgets/NumberInput/\"))\r\n\r\ninterface Props {\r\n  elements: BlockElement\r\n  reportId: string\r\n  reportRunState: ReportRunState\r\n  showStaleElementIndicator: boolean\r\n  widgetMgr: WidgetStateManager\r\n  uploadClient: FileUploadClient\r\n  widgetsDisabled: boolean\r\n  componentRegistry: ComponentRegistry\r\n}\r\n\r\nclass Block extends PureComponent<Props> {\r\n  private renderElements = (width: number): ReactNode[] => {\r\n    const elementsToRender = this.props.elements\r\n\r\n    // Transform Streamlit elements into ReactNodes.\r\n    return elementsToRender\r\n      .toArray()\r\n      .map((reportElement: ReportElement, index: number): ReactNode | null => {\r\n        const element = reportElement.get(\"element\")\r\n\r\n        if (element instanceof List) {\r\n          return this.renderBlock(element as BlockElement, index, width)\r\n        } else {\r\n          return this.renderElementWithErrorBoundary(\r\n            reportElement,\r\n            index,\r\n            width\r\n          )\r\n        }\r\n      })\r\n      .filter((node: ReactNode | null): ReactNode => node != null)\r\n  }\r\n\r\n  private isElementStale(reportElement: ReportElement): boolean {\r\n    if (this.props.reportRunState === ReportRunState.RERUN_REQUESTED) {\r\n      // If a rerun was just requested, all of our current elements\r\n      // are about to become stale.\r\n      return true\r\n    } else if (this.props.reportRunState === ReportRunState.RUNNING) {\r\n      return reportElement.get(\"reportId\") !== this.props.reportId\r\n    } else {\r\n      return false\r\n    }\r\n  }\r\n\r\n  private renderBlock(\r\n    element: BlockElement,\r\n    index: number,\r\n    width: number\r\n  ): ReactNode {\r\n    return (\r\n      <div key={index} className=\"stBlock\" style={{ width }}>\r\n        <Block\r\n          elements={element}\r\n          reportId={this.props.reportId}\r\n          reportRunState={this.props.reportRunState}\r\n          showStaleElementIndicator={this.props.showStaleElementIndicator}\r\n          widgetMgr={this.props.widgetMgr}\r\n          uploadClient={this.props.uploadClient}\r\n          widgetsDisabled={this.props.widgetsDisabled}\r\n          componentRegistry={this.props.componentRegistry}\r\n        />\r\n      </div>\r\n    )\r\n  }\r\n\r\n  private static getClassNames(isStale: boolean, isHidden: boolean): string {\r\n    const classNames = [\"element-container\"]\r\n    if (isStale && !FullScreenWrapper.isFullScreen) {\r\n      classNames.push(\"stale-element\")\r\n    }\r\n    if (isHidden) {\r\n      classNames.push(\"stHidden\")\r\n    }\r\n    return classNames.join(\" \")\r\n  }\r\n\r\n  private shouldComponentBeEnabled(isHidden: boolean): boolean {\r\n    return !isHidden || this.props.reportRunState !== ReportRunState.RUNNING\r\n  }\r\n\r\n  private isComponentStale(\r\n    enable: boolean,\r\n    reportElement: ReportElement\r\n  ): boolean {\r\n    return (\r\n      !enable ||\r\n      (this.props.showStaleElementIndicator &&\r\n        this.isElementStale(reportElement))\r\n    )\r\n  }\r\n\r\n  private renderElementWithErrorBoundary(\r\n    reportElement: ReportElement,\r\n    index: number,\r\n    width: number\r\n  ): ReactNode | null {\r\n    const element = reportElement.get(\"element\") as SimpleElement\r\n    const component = this.renderElement(\r\n      element,\r\n      index,\r\n      width,\r\n      reportElement.get(\"metadata\")\r\n    )\r\n\r\n    const elementType = element.get(\"type\")\r\n    const isHidden = elementType === \"empty\" || elementType === \"favicon\"\r\n    const enable = this.shouldComponentBeEnabled(isHidden)\r\n    const isStale = this.isComponentStale(enable, reportElement)\r\n    const className = Block.getClassNames(isStale, isHidden)\r\n    const simpleElement = element.get(elementType)\r\n    const key = simpleElement.get(\"id\") || index\r\n\r\n    return (\r\n      <Maybe enable={enable} key={key}>\r\n        <div className={className} style={{ width }}>\r\n          <ErrorBoundary width={width}>\r\n            <Suspense\r\n              fallback={\r\n                <Alert\r\n                  element={makeElementWithInfoText(\"Loading...\").get(\"alert\")}\r\n                  width={width}\r\n                />\r\n              }\r\n            >\r\n              {component}\r\n            </Suspense>\r\n          </ErrorBoundary>\r\n        </div>\r\n      </Maybe>\r\n    )\r\n  }\r\n\r\n  private renderElement = (\r\n    element: SimpleElement,\r\n    index: number,\r\n    width: number,\r\n    metadata: IForwardMsgMetadata\r\n  ): ReactNode => {\r\n    if (!element) {\r\n      throw new Error(\"Transmission error.\")\r\n    }\r\n\r\n    const widgetProps = {\r\n      widgetMgr: this.props.widgetMgr,\r\n      disabled: this.props.widgetsDisabled,\r\n    }\r\n\r\n    let height: number | undefined\r\n\r\n    // Modify width using the value from the spec as passed with the message when applicable\r\n    if (metadata && metadata.elementDimensionSpec) {\r\n      if (\r\n        metadata &&\r\n        metadata.elementDimensionSpec &&\r\n        metadata.elementDimensionSpec.width &&\r\n        metadata.elementDimensionSpec.width > 0\r\n      ) {\r\n        width = Math.min(metadata.elementDimensionSpec.width, width)\r\n      }\r\n      if (\r\n        metadata &&\r\n        metadata.elementDimensionSpec &&\r\n        metadata.elementDimensionSpec.height &&\r\n        metadata.elementDimensionSpec.height > 0\r\n      ) {\r\n        height = metadata.elementDimensionSpec.height\r\n      }\r\n    }\r\n\r\n    return dispatchOneOf(element, \"type\", {\r\n      alert: (el: SimpleElement) => <Alert element={el} width={width} />,\r\n      audio: (el: SimpleElement) => <Audio element={el} width={width} />,\r\n      balloons: (el: SimpleElement) => <Balloons element={el} width={width} />,\r\n      bokehChart: (el: SimpleElement) => (\r\n        <BokehChart element={el} index={index} width={width} />\r\n      ),\r\n      dataFrame: (el: SimpleElement) => (\r\n        <DataFrame element={el} width={width} height={height} />\r\n      ),\r\n      deckGlChart: (el: SimpleElement) => (\r\n        <DeckGlChart element={el} width={width} />\r\n      ),\r\n      deckGlJsonChart: (el: SimpleElement) => (\r\n        <DeckGlJsonChart element={el} width={width} />\r\n      ),\r\n      docString: (el: SimpleElement) => (\r\n        <DocString element={el} width={width} />\r\n      ),\r\n      empty: () => <div className=\"stHidden\" key={index} />,\r\n      exception: (el: SimpleElement) => (\r\n        <ExceptionElement element={el} width={width} />\r\n      ),\r\n      favicon: (el: SimpleElement) => <Favicon element={el} />,\r\n      graphvizChart: (el: SimpleElement) => (\r\n        <GraphVizChart element={el} index={index} width={width} />\r\n      ),\r\n      iframe: (el: SimpleElement) => <IFrame element={el} width={width} />,\r\n      imgs: (el: SimpleElement) => <ImageList element={el} width={width} />,\r\n      json: (el: SimpleElement) => <Json element={el} width={width} />,\r\n      markdown: (el: SimpleElement) => <Markdown element={el} width={width} />,\r\n      multiselect: (el: SimpleElement) => (\r\n        <Multiselect\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      plotlyChart: (el: SimpleElement) => (\r\n        <PlotlyChart element={el} width={width} />\r\n      ),\r\n      progress: (el: SimpleElement) => <Progress element={el} width={width} />,\r\n      table: (el: SimpleElement) => <Table element={el} width={width} />,\r\n      text: (el: SimpleElement) => <Text element={el} width={width} />,\r\n      vegaLiteChart: (el: SimpleElement) => (\r\n        <VegaLiteChart element={el} width={width} />\r\n      ),\r\n      video: (el: SimpleElement) => <Video element={el} width={width} />,\r\n      // Widgets\r\n      button: (el: SimpleElement) => (\r\n        <Button element={el} width={width} {...widgetProps} />\r\n      ),\r\n      checkbox: (el: SimpleElement) => (\r\n        <Checkbox\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      colorPicker: (el: SimpleElement) => (\r\n        <ColorPicker\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      dateInput: (el: SimpleElement) => (\r\n        <DateInput\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      radio: (el: SimpleElement) => (\r\n        <Radio\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      selectbox: (el: SimpleElement) => (\r\n        <Selectbox\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      slider: (el: SimpleElement) => (\r\n        <Slider\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      fileUploader: (el: SimpleElement) => (\r\n        <FileUploader\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          widgetStateManager={widgetProps.widgetMgr}\r\n          uploadClient={this.props.uploadClient}\r\n          disabled={widgetProps.disabled}\r\n        />\r\n      ),\r\n      textArea: (el: SimpleElement) => (\r\n        <TextArea\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      textInput: (el: SimpleElement) => (\r\n        <TextInput\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      timeInput: (el: SimpleElement) => (\r\n        <TimeInput\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      numberInput: (el: SimpleElement) => (\r\n        <NumberInput\r\n          key={el.get(\"id\")}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n      componentInstance: (el: SimpleElement) => (\r\n        <ComponentInstance\r\n          registry={this.props.componentRegistry}\r\n          element={el}\r\n          width={width}\r\n          {...widgetProps}\r\n        />\r\n      ),\r\n    })\r\n  }\r\n\r\n  public render = (): ReactNode => (\r\n    <AutoSizer disableHeight={true}>\r\n      {({ width }) => this.renderElements(width)}\r\n    </AutoSizer>\r\n  )\r\n}\r\n\r\nexport default Block\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ReactElement } from \"react\"\r\nimport classNames from \"classnames\"\r\nimport Icon from \"components/shared/Icon\"\r\nimport { Button } from \"reactstrap\"\r\n\r\nimport \"./Sidebar.scss\"\r\n\r\ninterface Props {\r\n  children?: ReactElement\r\n  onChange: (collapsedSidebar: boolean) => void\r\n}\r\n\r\ninterface State {\r\n  collapsedSidebar: boolean\r\n}\r\n\r\n// Bootstrap medium breakpoint. See\r\n// https://getbootstrap.com/docs/4.3/layout/overview/.\r\nconst MEDIUM_BREAKPOINT_PX = 991.98\r\n\r\nclass Sidebar extends PureComponent<Props, State> {\r\n  public static defaultProps: Partial<Props> = {\r\n    onChange: () => {},\r\n  }\r\n\r\n  private sidebarRef = React.createRef<HTMLDivElement>()\r\n\r\n  constructor(props: Props) {\r\n    super(props)\r\n\r\n    const { innerWidth } = window || {}\r\n\r\n    this.state = {\r\n      collapsedSidebar: innerWidth\r\n        ? innerWidth <= MEDIUM_BREAKPOINT_PX\r\n        : false,\r\n    }\r\n  }\r\n\r\n  componentDidMount(): void {\r\n    window.addEventListener(\"resize\", this.checkMobileOnResize)\r\n    document.addEventListener(\"mousedown\", this.handleClickOutside)\r\n  }\r\n\r\n  componentWillUnmount(): void {\r\n    window.removeEventListener(\"resize\", this.checkMobileOnResize)\r\n    document.removeEventListener(\"mousedown\", this.handleClickOutside)\r\n  }\r\n\r\n  handleClickOutside = (event: any): void => {\r\n    if (this.sidebarRef && window) {\r\n      const { current } = this.sidebarRef\r\n      const { innerWidth } = window\r\n\r\n      if (\r\n        current &&\r\n        !current.contains(event.target) &&\r\n        innerWidth <= MEDIUM_BREAKPOINT_PX\r\n      ) {\r\n        this.setState({ collapsedSidebar: true })\r\n      }\r\n    }\r\n  }\r\n\r\n  checkMobileOnResize = (): boolean => {\r\n    if (!window) return false\r\n\r\n    const { innerWidth } = window\r\n\r\n    if (innerWidth <= MEDIUM_BREAKPOINT_PX)\r\n      this.setState({ collapsedSidebar: true })\r\n\r\n    return true\r\n  }\r\n\r\n  toggleCollapse = (): void => {\r\n    const { collapsedSidebar } = this.state\r\n    const { onChange } = this.props\r\n\r\n    this.setState({ collapsedSidebar: !collapsedSidebar }, () => {\r\n      const { collapsedSidebar } = this.state\r\n\r\n      onChange(collapsedSidebar)\r\n    })\r\n  }\r\n\r\n  public render = (): ReactElement => {\r\n    const { collapsedSidebar } = this.state\r\n    const { children } = this.props\r\n\r\n    const sectionClassName = classNames(\"sidebar\", {\r\n      \"--collapsed\": collapsedSidebar,\r\n    })\r\n\r\n    // The tabindex is required to support scrolling by arrow keys.\r\n    return (\r\n      <section className={sectionClassName} ref={this.sidebarRef}>\r\n        <div className=\"sidebar-content\">\r\n          <Button\r\n            outline\r\n            onClick={this.toggleCollapse}\r\n            className=\"sidebar-close\"\r\n          >\r\n            <Icon type=\"x\" />\r\n          </Button>\r\n\r\n          {children}\r\n        </div>\r\n        <Button\r\n          outline\r\n          onClick={this.toggleCollapse}\r\n          className=\"sidebar-collapse-control\"\r\n        >\r\n          <Icon type=\"chevron-right\" />\r\n        </Button>\r\n      </section>\r\n    )\r\n  }\r\n}\r\n\r\nexport default Sidebar\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport enum ConnectionState {\r\n  CONNECTED = \"CONNECTED\",\r\n  DISCONNECTED_FOREVER = \"DISCONNECTED_FOREVER\",\r\n  INITIAL = \"INITIAL\",\r\n  PINGING_SERVER = \"PINGING_SERVER\",\r\n  CONNECTING = \"CONNECTING\",\r\n  STATIC = \"STATIC\",\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ReactNode } from \"react\"\r\nimport classNames from \"classnames\"\r\n\r\nimport Block from \"components/core/Block/\"\r\nimport Sidebar from \"components/core/Sidebar\"\r\nimport { ReportRunState } from \"lib/ReportRunState\"\r\nimport { WidgetStateManager } from \"lib/WidgetStateManager\"\r\nimport { FileUploadClient } from \"lib/FileUploadClient\"\r\nimport { ComponentRegistry } from \"components/widgets/CustomComponent\"\r\n\r\nimport { ThemeProvider } from \"baseui\"\r\nimport { BlockElement } from \"lib/DeltaParser\"\r\nimport { mainWidgetTheme, sidebarWidgetTheme } from \"lib/widgetTheme\"\r\n\r\nimport \"./ReportView.scss\"\r\nimport \"./Widget.scss\"\r\n\r\ninterface Elements {\r\n  main: BlockElement\r\n  sidebar: BlockElement\r\n}\r\n\r\ninterface Props {\r\n  elements: Elements\r\n\r\n  // The unique ID for the most recent run of the report.\r\n  reportId: string\r\n\r\n  reportRunState: ReportRunState\r\n\r\n  /**\r\n   * If true, \"stale\" elements (that is, elements that were created during a previous\r\n   * run of a currently-running report) will be faded out.\r\n   *\r\n   * (When we're viewing a shared report, this is set to false.)\r\n   */\r\n  showStaleElementIndicator: boolean\r\n\r\n  widgetMgr: WidgetStateManager\r\n\r\n  uploadClient: FileUploadClient\r\n\r\n  // Disable the widgets when not connected to the server.\r\n  widgetsDisabled: boolean\r\n\r\n  // Wide mode\r\n  wide: boolean\r\n\r\n  componentRegistry: ComponentRegistry\r\n}\r\n\r\n/**\r\n * Renders a Streamlit report. Reports consist of 0 or more elements.\r\n */\r\nclass ReportView extends PureComponent<Props> {\r\n  private hasSidebar = (): boolean => !this.props.elements.sidebar.isEmpty()\r\n\r\n  public render = (): ReactNode => {\r\n    const { wide } = this.props\r\n\r\n    const reportViewClassName = classNames(\"reportview-container\", {\r\n      \"--wide\": wide,\r\n    })\r\n\r\n    // The tabindex is required to support scrolling by arrow keys.\r\n    return (\r\n      <div className={reportViewClassName}>\r\n        {this.hasSidebar() && (\r\n          <Sidebar>\r\n            <div className=\"block-container\">\r\n              <ThemeProvider theme={sidebarWidgetTheme}>\r\n                <Block\r\n                  elements={this.props.elements.sidebar}\r\n                  reportId={this.props.reportId}\r\n                  reportRunState={this.props.reportRunState}\r\n                  showStaleElementIndicator={\r\n                    this.props.showStaleElementIndicator\r\n                  }\r\n                  widgetMgr={this.props.widgetMgr}\r\n                  widgetsDisabled={this.props.widgetsDisabled}\r\n                  uploadClient={this.props.uploadClient}\r\n                  componentRegistry={this.props.componentRegistry}\r\n                />\r\n              </ThemeProvider>\r\n            </div>\r\n          </Sidebar>\r\n        )}\r\n        <section className=\"main\" tabIndex={0}>\r\n          <div className=\"block-container\">\r\n            <ThemeProvider theme={mainWidgetTheme}>\r\n              <Block\r\n                elements={this.props.elements.main}\r\n                reportId={this.props.reportId}\r\n                reportRunState={this.props.reportRunState}\r\n                showStaleElementIndicator={\r\n                  this.props.showStaleElementIndicator\r\n                }\r\n                widgetMgr={this.props.widgetMgr}\r\n                widgetsDisabled={this.props.widgetsDisabled}\r\n                uploadClient={this.props.uploadClient}\r\n                componentRegistry={this.props.componentRegistry}\r\n              />\r\n            </ThemeProvider>\r\n          </div>\r\n\r\n          <footer>\r\n            Made with <a href=\"//streamlit.io\">Streamlit</a>\r\n          </footer>\r\n        </section>\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default ReportView\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\n/**\r\n * A wrapper around setTimeout that adds some useful features, like getting the\r\n * remaining time.\r\n */\r\nexport class Timer {\r\n  private timerHandle?: number\r\n  private duration = 0\r\n  private startTime = 0\r\n  private _isRunning = false\r\n\r\n  /** True if the timer is currently running */\r\n  public get isRunning(): boolean {\r\n    return this._isRunning\r\n  }\r\n\r\n  /** Remaining time before timeout, or 0 if the timer is not running */\r\n  public get remainingTime(): number {\r\n    if (!this._isRunning) {\r\n      return 0\r\n    }\r\n    const elapsed = Date.now() - this.startTime\r\n    return Math.max(this.duration - elapsed, 0)\r\n  }\r\n\r\n  /**\r\n   * Starts the Timer with the given callback.\r\n   * If the Timer is already running, it will be canceled first.\r\n   */\r\n  public setTimeout(handler: () => void, time: number): void {\r\n    this.cancel()\r\n    this.startTime = Date.now()\r\n    this.duration = time\r\n    this._isRunning = true\r\n    this.timerHandle = window.setTimeout(() => {\r\n      this._isRunning = false\r\n      handler()\r\n    }, time)\r\n  }\r\n\r\n  /** Cancels the Timer. If the Timer is not already running, this is a no-op. */\r\n  public cancel(): void {\r\n    if (this.timerHandle !== undefined) {\r\n      window.clearTimeout(this.timerHandle)\r\n      this.timerHandle = undefined\r\n      this._isRunning = false\r\n    }\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport CopyToClipboard from \"react-copy-to-clipboard\"\r\nimport React, { ReactElement, ReactNode } from \"react\"\r\nimport {\r\n  Button,\r\n  Modal,\r\n  ModalBody,\r\n  ModalFooter,\r\n  ModalHeader,\r\n  Progress,\r\n} from \"reactstrap\"\r\nimport { HotKeys } from \"react-hotkeys\"\r\n\r\nimport {\r\n  ScriptChangedDialog,\r\n  Props as ScriptChangedDialogProps,\r\n} from \"components/core/StreamlitDialog/ScriptChangedDialog\"\r\nimport { IException } from \"autogen/proto\"\r\nimport { Props as SettingsDialogProps, SettingsDialog } from \"./SettingsDialog\"\r\nimport { SessionInfo } from \"lib/SessionInfo\"\r\n\r\nimport \"./StreamlitDialog.scss\"\r\n\r\ntype PlainEventHandler = () => void\r\n\r\ninterface SettingsProps extends SettingsDialogProps {\r\n  type: DialogType.SETTINGS\r\n}\r\n\r\ninterface ScriptChangedProps extends ScriptChangedDialogProps {\r\n  type: DialogType.SCRIPT_CHANGED\r\n}\r\n\r\nexport type DialogProps =\r\n  | AboutProps\r\n  | ClearCacheProps\r\n  | RerunScriptProps\r\n  | SettingsProps\r\n  | ScriptChangedProps\r\n  | ScriptCompileErrorProps\r\n  | UploadProgressProps\r\n  | UploadedProps\r\n  | WarningProps\r\n\r\nexport enum DialogType {\r\n  ABOUT = \"about\",\r\n  CLEAR_CACHE = \"clearCache\",\r\n  RERUN_SCRIPT = \"rerunScript\",\r\n  SETTINGS = \"settings\",\r\n  SCRIPT_CHANGED = \"scriptChanged\",\r\n  SCRIPT_COMPILE_ERROR = \"scriptCompileError\",\r\n  UPLOAD_PROGRESS = \"uploadProgress\",\r\n  UPLOADED = \"uploaded\",\r\n  WARNING = \"warning\",\r\n}\r\n\r\nexport function StreamlitDialog(dialogProps: DialogProps): ReactNode {\r\n  switch (dialogProps.type) {\r\n    case DialogType.ABOUT:\r\n      return aboutDialog(dialogProps)\r\n    case DialogType.CLEAR_CACHE:\r\n      return clearCacheDialog(dialogProps)\r\n    case DialogType.RERUN_SCRIPT:\r\n      return rerunScriptDialog(dialogProps)\r\n    case DialogType.SETTINGS:\r\n      return settingsDialog(dialogProps)\r\n    case DialogType.SCRIPT_CHANGED:\r\n      return <ScriptChangedDialog {...dialogProps} />\r\n    case DialogType.SCRIPT_COMPILE_ERROR:\r\n      return scriptCompileErrorDialog(dialogProps)\r\n    case DialogType.UPLOAD_PROGRESS:\r\n      return uploadProgressDialog(dialogProps)\r\n    case DialogType.UPLOADED:\r\n      return uploadedDialog(dialogProps)\r\n    case DialogType.WARNING:\r\n      return warningDialog(dialogProps)\r\n    case undefined:\r\n      return noDialog(dialogProps)\r\n    default:\r\n      return typeNotRecognizedDialog(dialogProps)\r\n  }\r\n}\r\n\r\ninterface AboutProps {\r\n  type: DialogType.ABOUT\r\n\r\n  /** Callback to close the dialog */\r\n  onClose: PlainEventHandler\r\n}\r\n\r\n/** About Dialog */\r\nfunction aboutDialog(props: AboutProps): ReactElement {\r\n  return (\r\n    <BasicDialog onClose={props.onClose}>\r\n      <ModalHeader toggle={props.onClose}>About</ModalHeader>\r\n      <ModalBody>\r\n        <div>\r\n          Streamlit v{SessionInfo.current.streamlitVersion}\r\n          <br />\r\n          <a href=\"https://streamlit.io\">https://streamlit.io</a>\r\n          <br />\r\n          Copyright 2020 Streamlit Inc. All rights reserved.\r\n        </div>\r\n      </ModalBody>\r\n      <ModalFooter>\r\n        <Button outline color=\"primary\" onClick={props.onClose}>\r\n          Close\r\n        </Button>\r\n      </ModalFooter>\r\n    </BasicDialog>\r\n  )\r\n}\r\n\r\ninterface ClearCacheProps {\r\n  type: DialogType.CLEAR_CACHE\r\n  /** callback to send the clear_cache request to the Proxy */\r\n  confirmCallback: () => void\r\n\r\n  /** callback to close the dialog */\r\n  onClose: PlainEventHandler\r\n\r\n  /** callback to run the default action */\r\n  defaultAction: () => void\r\n}\r\n\r\n/**\r\n * Dialog shown when the user wants to clear the cache.\r\n *\r\n * confirmCallback - callback to send the clear_cache request to the Proxy\r\n * onClose         - callback to close the dialog\r\n */\r\nfunction clearCacheDialog(props: ClearCacheProps): ReactElement {\r\n  const keyHandlers = {\r\n    enter: () => props.defaultAction(),\r\n  }\r\n\r\n  // Not sure exactly why attach is necessary on the HotKeys\r\n  // component here but it's not working without it\r\n  return (\r\n    <HotKeys handlers={keyHandlers} attach={window}>\r\n      <BasicDialog onClose={props.onClose}>\r\n        <ModalBody>\r\n          <div>\r\n            Are you sure you want to clear the <code>@st.cache</code> function\r\n            cache?\r\n          </div>\r\n        </ModalBody>\r\n        <ModalFooter>\r\n          <Button outline color=\"secondary\" onClick={props.onClose}>\r\n            Cancel\r\n          </Button>{\" \"}\r\n          <Button outline color=\"primary\" onClick={props.confirmCallback}>\r\n            Clear cache\r\n          </Button>\r\n        </ModalFooter>\r\n      </BasicDialog>\r\n    </HotKeys>\r\n  )\r\n}\r\n\r\ninterface RerunScriptProps {\r\n  type: DialogType.RERUN_SCRIPT\r\n\r\n  /** Callback to get the script's command line */\r\n  getCommandLine: () => string | string[]\r\n\r\n  /** Callback to set the script's command line */\r\n  setCommandLine: (value: string) => void\r\n\r\n  /** Callback to rerun the script */\r\n  rerunCallback: () => void\r\n\r\n  /** Callback to close the dialog */\r\n  onClose: PlainEventHandler\r\n\r\n  /** Callback to run the default action */\r\n  defaultAction: () => void\r\n}\r\n\r\n/**\r\n * Dialog shown when the user wants to rerun a script.\r\n */\r\nfunction rerunScriptDialog(props: RerunScriptProps): ReactElement {\r\n  const keyHandlers = {\r\n    enter: () => props.defaultAction(),\r\n  }\r\n\r\n  // Not sure exactly why attach is necessary on the HotKeys\r\n  // component here but it's not working without it\r\n  return (\r\n    <HotKeys handlers={keyHandlers} attach={window}>\r\n      <BasicDialog onClose={props.onClose}>\r\n        <ModalBody>\r\n          <div className=\"rerun-header\">Command line:</div>\r\n          <div>\r\n            <textarea\r\n              autoFocus\r\n              className=\"command-line\"\r\n              value={props.getCommandLine()}\r\n              onChange={event => props.setCommandLine(event.target.value)}\r\n            />\r\n          </div>\r\n        </ModalBody>\r\n        <ModalFooter>\r\n          <Button outline color=\"secondary\" onClick={props.onClose}>\r\n            Cancel\r\n          </Button>{\" \"}\r\n          <Button\r\n            outline\r\n            color=\"primary\"\r\n            onClick={() => props.rerunCallback()}\r\n          >\r\n            Rerun\r\n          </Button>\r\n        </ModalFooter>\r\n      </BasicDialog>\r\n    </HotKeys>\r\n  )\r\n}\r\n\r\ninterface ScriptCompileErrorProps {\r\n  type: DialogType.SCRIPT_COMPILE_ERROR\r\n  exception: IException | null | undefined\r\n  onClose: PlainEventHandler\r\n}\r\n\r\nfunction scriptCompileErrorDialog(\r\n  props: ScriptCompileErrorProps\r\n): ReactElement {\r\n  return (\r\n    <BasicDialog onClose={props.onClose}>\r\n      <ModalHeader toggle={props.onClose}>Script execution error</ModalHeader>\r\n      <ModalBody>\r\n        <div>\r\n          <pre>\r\n            <code>\r\n              {props.exception ? props.exception.message : \"No message\"}\r\n            </code>\r\n          </pre>\r\n        </div>\r\n      </ModalBody>\r\n      <ModalFooter>\r\n        <Button outline color=\"primary\" onClick={props.onClose}>\r\n          Close\r\n        </Button>\r\n      </ModalFooter>\r\n    </BasicDialog>\r\n  )\r\n}\r\n\r\n/**\r\n * Shows the settings dialog.\r\n */\r\nfunction settingsDialog(props: SettingsProps): ReactElement {\r\n  return <SettingsDialog {...props} />\r\n}\r\n\r\ninterface UploadProgressProps {\r\n  type: DialogType.UPLOAD_PROGRESS\r\n  progress?: string | number\r\n  onClose: PlainEventHandler\r\n}\r\n\r\n/**\r\n * Shows the progress of an upload in progress.\r\n */\r\nfunction uploadProgressDialog(props: UploadProgressProps): ReactElement {\r\n  return (\r\n    <BasicDialog onClose={props.onClose}>\r\n      <ModalBody>\r\n        <div className=\"streamlit-upload-first-line\">\r\n          Saving app snapshot...\r\n        </div>\r\n        <div>\r\n          <Progress animated value={props.progress} />\r\n        </div>\r\n      </ModalBody>\r\n    </BasicDialog>\r\n  )\r\n}\r\n\r\ninterface UploadedProps {\r\n  type: DialogType.UPLOADED\r\n  url: string\r\n  onClose: PlainEventHandler\r\n}\r\n\r\n/**\r\n * Shows the URL after something has been uploaded.\r\n */\r\nfunction uploadedDialog(props: UploadedProps): ReactElement {\r\n  return (\r\n    <BasicDialog onClose={props.onClose}>\r\n      <ModalBody>\r\n        <div className=\"streamlit-upload-first-line\">\r\n          App snapshot saved to:\r\n        </div>\r\n        <pre id=\"streamlit-upload-url\">\r\n          <a href={props.url} target=\"_blank\" rel=\"noopener noreferrer\">\r\n            {props.url}\r\n          </a>\r\n        </pre>\r\n      </ModalBody>\r\n      <ModalFooter>\r\n        <CopyToClipboard text={props.url} onCopy={props.onClose}>\r\n          <Button outline className=\"mr-auto\">\r\n            Copy to clipboard\r\n          </Button>\r\n        </CopyToClipboard>{\" \"}\r\n        <Button\r\n          outline\r\n          onClick={() => {\r\n            window.open(props.url, \"_blank\")\r\n            props.onClose()\r\n          }}\r\n        >\r\n          Open\r\n        </Button>\r\n        <Button outline onClick={props.onClose}>\r\n          Done\r\n        </Button>\r\n      </ModalFooter>\r\n    </BasicDialog>\r\n  )\r\n}\r\n\r\ninterface WarningProps {\r\n  type: DialogType.WARNING\r\n  title: string\r\n  msg: ReactNode\r\n  onClose: PlainEventHandler\r\n}\r\n\r\n/**\r\n * Prints out a warning\r\n */\r\nfunction warningDialog(props: WarningProps): ReactElement {\r\n  return (\r\n    <BasicDialog onClose={props.onClose}>\r\n      <ModalHeader>{props.title}</ModalHeader>\r\n      <ModalBody>{props.msg}</ModalBody>\r\n      <ModalFooter>\r\n        <Button outline onClick={props.onClose}>\r\n          Done\r\n        </Button>\r\n      </ModalFooter>\r\n    </BasicDialog>\r\n  )\r\n}\r\n\r\nexport function BasicDialog({\r\n  children,\r\n  onClose,\r\n}: {\r\n  children?: ReactNode\r\n  onClose?: PlainEventHandler\r\n}): ReactElement {\r\n  const isOpen = children !== undefined\r\n  return (\r\n    <Modal isOpen={isOpen} toggle={onClose} className=\"streamlit-dialog\">\r\n      {children}\r\n    </Modal>\r\n  )\r\n}\r\n\r\n/**\r\n * Returns an empty dictionary, indicating that no object is to be displayed.\r\n */\r\nfunction noDialog({ onClose }: { onClose: PlainEventHandler }): ReactElement {\r\n  return <BasicDialog onClose={onClose} />\r\n}\r\n\r\ninterface NotRecognizedProps {\r\n  type: string\r\n  onClose: PlainEventHandler\r\n}\r\n\r\n/**\r\n * If the dialog type is not recognized, display this dialog.\r\n */\r\nfunction typeNotRecognizedDialog(props: NotRecognizedProps): ReactElement {\r\n  return (\r\n    <BasicDialog onClose={props.onClose}>\r\n      <ModalBody>{`Dialog type \"${props.type}\" not recognized.`}</ModalBody>\r\n    </BasicDialog>\r\n  )\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { RERUN_PROMPT_MODAL_DIALOG } from \"lib/baseconsts\"\r\nimport React, { PureComponent, ReactNode } from \"react\"\r\nimport { HotKeys } from \"react-hotkeys\"\r\nimport { CSSTransition } from \"react-transition-group\"\r\nimport { Button, UncontrolledTooltip } from \"reactstrap\"\r\nimport { SignalConnection } from \"typed-signals\"\r\n\r\nimport { ConnectionState } from \"lib/ConnectionState\"\r\nimport { SessionEvent } from \"autogen/proto\"\r\nimport { SessionEventDispatcher } from \"lib/SessionEventDispatcher\"\r\nimport { ReportRunState } from \"lib/ReportRunState\"\r\nimport { Timer } from \"lib/Timer\"\r\nimport Icon from \"components/shared/Icon\"\r\n\r\n/*\r\n * IMPORTANT: If you change the asset import below, make sure it still works if Streamlit is served\r\n * from a subpath.\r\n */\r\nimport iconRunning from \"assets/img/icon_running.gif\"\r\n\r\nimport \"./StatusWidget.scss\"\r\n\r\n/** Component props */\r\ninterface Props {\r\n  /** State of our connection to the server. */\r\n  connectionState: ConnectionState\r\n\r\n  /** Dispatches transient SessionEvents received from the server. */\r\n  sessionEventDispatcher: SessionEventDispatcher\r\n\r\n  /** Report's current runstate */\r\n  reportRunState: ReportRunState\r\n\r\n  /**\r\n   * Function called when the user chooses to re-run the report\r\n   * in response to its source file changing.\r\n   * @param alwaysRerun if true, also change the run-on-save setting for this report\r\n   */\r\n  rerunReport: (alwaysRerun: boolean) => void\r\n\r\n  /** Function called when the user chooses to stop the running report. */\r\n  stopReport: () => void\r\n}\r\n\r\n/** Component state */\r\ninterface State {\r\n  /**\r\n   * True if our ReportStatus or ConnectionStatus should be minimized.\r\n   * Does not affect ReportStatus prompts.\r\n   */\r\n  statusMinimized: boolean\r\n\r\n  /**\r\n   * If true, the server has told us that the report has changed and is\r\n   * not being automatically re-run; we'll prompt the user to manually\r\n   * re-run when this happens.\r\n   *\r\n   * This is reverted to false in getDerivedStateFromProps when the report\r\n   * begins running again.\r\n   */\r\n  reportChangedOnDisk: boolean\r\n\r\n  /** True if our Report Changed prompt should be minimized. */\r\n  promptMinimized: boolean\r\n\r\n  /**\r\n   * True if our Report Changed prompt is being hovered. Hovered prompts are always\r\n   * shown, even if they'd otherwise be minimized.\r\n   */\r\n  promptHovered: boolean\r\n}\r\n\r\ninterface ConnectionStateUI {\r\n  icon: string\r\n  label: string\r\n  tooltip: string\r\n}\r\n\r\n// Amount of time to display the \"Report Changed. Rerun?\" prompt when it first appears.\r\nconst PROMPT_DISPLAY_INITIAL_TIMEOUT_MS = 15 * 1000\r\n\r\n// Amount of time to display the Report Changed prompt after the user has hovered\r\n// and then unhovered on it.\r\nconst PROMPT_DISPLAY_HOVER_TIMEOUT_MS = 1.0 * 1000\r\n\r\n/**\r\n * Displays various report- and connection-related info: our WebSocket\r\n * connection status, the run-state of our report, and transient report-related\r\n * events.\r\n */\r\nexport class StatusWidget extends PureComponent<Props, State> {\r\n  /** onSessionEvent signal connection */\r\n  private sessionEventConn?: SignalConnection\r\n  private curView?: ReactNode\r\n\r\n  private readonly minimizePromptTimer = new Timer()\r\n  private readonly keyHandlers: {\r\n    [key: string]: (keyEvent?: KeyboardEvent) => void\r\n  }\r\n\r\n  constructor(props: Props) {\r\n    super(props)\r\n\r\n    this.state = {\r\n      statusMinimized: StatusWidget.shouldMinimize(),\r\n      promptMinimized: false,\r\n      reportChangedOnDisk: false,\r\n      promptHovered: false,\r\n    }\r\n\r\n    this.keyHandlers = {\r\n      a: this.handleAlwaysRerunClick,\r\n      // No handler for 'r' since it's handled by app.jsx and precedence\r\n      // isn't working when multiple components handle the same key\r\n      // 'r': this.handleRerunClick,\r\n    }\r\n  }\r\n\r\n  /** Called by React on prop changes */\r\n  public static getDerivedStateFromProps(props: Props): Partial<State> | null {\r\n    // Reset transient event-related state when prop changes\r\n    // render that state irrelevant\r\n    if (props.reportRunState === ReportRunState.RUNNING) {\r\n      return { reportChangedOnDisk: false, promptHovered: false }\r\n    }\r\n\r\n    return null\r\n  }\r\n\r\n  public componentDidMount(): void {\r\n    this.sessionEventConn = this.props.sessionEventDispatcher.onSessionEvent.connect(\r\n      e => this.handleSessionEvent(e)\r\n    )\r\n    window.addEventListener(\"scroll\", this.handleScroll)\r\n  }\r\n\r\n  public componentWillUnmount(): void {\r\n    if (this.sessionEventConn !== undefined) {\r\n      this.sessionEventConn.disconnect()\r\n      this.sessionEventConn = undefined\r\n    }\r\n\r\n    this.minimizePromptTimer.cancel()\r\n\r\n    window.removeEventListener(\"scroll\", this.handleScroll)\r\n  }\r\n\r\n  private isConnected(): boolean {\r\n    return this.props.connectionState === ConnectionState.CONNECTED\r\n  }\r\n\r\n  private handleSessionEvent(event: SessionEvent): void {\r\n    if (event.type === \"reportChangedOnDisk\") {\r\n      this.setState({ reportChangedOnDisk: true, promptMinimized: false })\r\n      this.minimizePromptAfterTimeout(PROMPT_DISPLAY_INITIAL_TIMEOUT_MS)\r\n    }\r\n  }\r\n\r\n  private minimizePromptAfterTimeout(timeout: number): void {\r\n    // Don't cut an existing timer short. If our timer is already\r\n    // running, and is due to expire later than the new timeout\r\n    // value, leave the timer alone.\r\n    if (timeout > this.minimizePromptTimer.remainingTime) {\r\n      this.minimizePromptTimer.setTimeout(() => {\r\n        this.setState({ promptMinimized: true })\r\n      }, timeout)\r\n    }\r\n  }\r\n\r\n  private static shouldMinimize(): boolean {\r\n    return window.scrollY > 32\r\n  }\r\n\r\n  private handleScroll = (): void => {\r\n    this.setState({\r\n      statusMinimized: StatusWidget.shouldMinimize(),\r\n    })\r\n  }\r\n\r\n  public render(): ReactNode {\r\n    // The StatusWidget fades in on appear and fades out on disappear.\r\n    // We keep track of our most recent result from `renderWidget`,\r\n    // via `this.curView`, so that we can fade out our previous state\r\n    // if `renderWidget` returns null after returning a non-null value.\r\n\r\n    const prevView = this.curView\r\n    this.curView = this.renderWidget()\r\n    if (prevView == null && this.curView == null) {\r\n      return null\r\n    }\r\n\r\n    let animateIn: boolean\r\n    let renderView: ReactNode\r\n    if (this.curView != null) {\r\n      animateIn = true\r\n      renderView = this.curView\r\n    } else {\r\n      animateIn = false\r\n      renderView = prevView\r\n    }\r\n\r\n    // NB: the `timeout` value here must match the transition\r\n    // times specified in the StatusWidget-*-active CSS classes\r\n    return (\r\n      <CSSTransition\r\n        appear={true}\r\n        in={animateIn}\r\n        timeout={200}\r\n        unmountOnExit={true}\r\n        classNames=\"StatusWidget\"\r\n      >\r\n        <div key=\"StatusWidget\">{renderView}</div>\r\n      </CSSTransition>\r\n    )\r\n  }\r\n\r\n  private renderWidget(): ReactNode {\r\n    if (this.isConnected()) {\r\n      if (\r\n        this.props.reportRunState === ReportRunState.RUNNING ||\r\n        this.props.reportRunState === ReportRunState.RERUN_REQUESTED\r\n      ) {\r\n        // Show reportIsRunning when the report is actually running,\r\n        // but also when the user has just requested a re-run.\r\n        // In the latter case, the server should get around to actually\r\n        // re-running the report in a second or two, but we can appear\r\n        // more responsive by claiming it's started immemdiately.\r\n        return this.renderReportIsRunning()\r\n      } else if (\r\n        !RERUN_PROMPT_MODAL_DIALOG &&\r\n        this.state.reportChangedOnDisk\r\n      ) {\r\n        return this.renderRerunReportPrompt()\r\n      }\r\n    }\r\n\r\n    return this.renderConnectionStatus()\r\n  }\r\n\r\n  /** E.g. \"Disconnected [Icon]\" */\r\n  private renderConnectionStatus(): ReactNode {\r\n    const ui = StatusWidget.getConnectionStateUI(this.props.connectionState)\r\n    if (ui === undefined) {\r\n      return null\r\n    }\r\n\r\n    return (\r\n      <div>\r\n        <div\r\n          id=\"ConnectionStatus\"\r\n          className={this.state.statusMinimized ? \"minimized\" : \"\"}\r\n        >\r\n          <Icon className=\"icon\" type={ui.icon} />\r\n          <label>{ui.label}</label>\r\n        </div>\r\n        <UncontrolledTooltip placement=\"bottom\" target=\"ConnectionStatus\">\r\n          {ui.tooltip}\r\n        </UncontrolledTooltip>\r\n      </div>\r\n    )\r\n  }\r\n\r\n  /** \"Running... [Stop]\" */\r\n  private renderReportIsRunning(): ReactNode {\r\n    const stopRequested =\r\n      this.props.reportRunState === ReportRunState.STOP_REQUESTED\r\n    const stopButton = StatusWidget.promptButton(\r\n      stopRequested ? \"Stopping...\" : \"Stop\",\r\n      stopRequested,\r\n      this.handleStopReportClick\r\n    )\r\n\r\n    return (\r\n      <div\r\n        id=\"ReportStatus\"\r\n        className={\r\n          this.state.statusMinimized ? \"report-is-running-minimized\" : \"\"\r\n        }\r\n      >\r\n        <img\r\n          className=\"ReportRunningIcon\"\r\n          src={iconRunning}\r\n          alt=\"Running...\"\r\n        />\r\n        <label>Running...</label>\r\n        {stopButton}\r\n        {this.state.statusMinimized ? (\r\n          <UncontrolledTooltip placement=\"bottom\" target=\"ReportStatus\">\r\n            This script is currently running\r\n          </UncontrolledTooltip>\r\n        ) : (\r\n          \"\"\r\n        )}\r\n      </div>\r\n    )\r\n  }\r\n\r\n  /**\r\n   * \"Source file changed. [Rerun] [Always Rerun]\"\r\n   * (This is only shown when the RERUN_PROMPT_MODAL_DIALOG feature flag is false)\r\n   */\r\n  private renderRerunReportPrompt(): ReactNode {\r\n    const rerunRequested =\r\n      this.props.reportRunState === ReportRunState.RERUN_REQUESTED\r\n    const minimized = this.state.promptMinimized && !this.state.promptHovered\r\n\r\n    // Not sure exactly why attach and focused are necessary on the\r\n    // HotKeys component here but its not working without them\r\n    return (\r\n      <HotKeys handlers={this.keyHandlers} attach={window} focused={true}>\r\n        <div\r\n          onMouseEnter={this.onReportPromptHover}\r\n          onMouseLeave={this.onReportPromptUnhover}\r\n        >\r\n          <div\r\n            id=\"ReportStatus\"\r\n            className={minimized ? \"rerun-prompt-minimized\" : \"\"}\r\n          >\r\n            <Icon className=\"icon\" type=\"info\" />\r\n            <label className=\"prompt\">Source file changed.</label>\r\n\r\n            {StatusWidget.promptButton(\r\n              <div className=\"underlineFirstLetter\">Rerun</div>,\r\n              rerunRequested,\r\n              this.handleRerunClick\r\n            )}\r\n\r\n            {StatusWidget.promptButton(\r\n              <div className=\"underlineFirstLetter\">Always rerun</div>,\r\n              rerunRequested,\r\n              this.handleAlwaysRerunClick\r\n            )}\r\n          </div>\r\n        </div>\r\n      </HotKeys>\r\n    )\r\n  }\r\n\r\n  private onReportPromptHover = (): void => {\r\n    this.setState({ promptHovered: true })\r\n  }\r\n\r\n  private onReportPromptUnhover = (): void => {\r\n    this.setState({ promptHovered: false, promptMinimized: false })\r\n    this.minimizePromptAfterTimeout(PROMPT_DISPLAY_HOVER_TIMEOUT_MS)\r\n  }\r\n\r\n  private handleStopReportClick = (): void => {\r\n    this.props.stopReport()\r\n  }\r\n\r\n  private handleRerunClick = (): void => {\r\n    this.props.rerunReport(false)\r\n  }\r\n\r\n  private handleAlwaysRerunClick = (): void => {\r\n    this.props.rerunReport(true)\r\n  }\r\n\r\n  private static promptButton(\r\n    title: ReactNode,\r\n    disabled: boolean,\r\n    onClick: () => void\r\n  ): ReactNode {\r\n    return (\r\n      <Button\r\n        outline\r\n        size=\"sm\"\r\n        color=\"info\"\r\n        disabled={disabled}\r\n        onClick={onClick}\r\n      >\r\n        <div>{title}</div>\r\n      </Button>\r\n    )\r\n  }\r\n\r\n  private static getConnectionStateUI(\r\n    state: ConnectionState\r\n  ): ConnectionStateUI | undefined {\r\n    switch (state) {\r\n      case ConnectionState.INITIAL:\r\n      case ConnectionState.PINGING_SERVER:\r\n      case ConnectionState.CONNECTING:\r\n        return {\r\n          icon: \"ellipses\",\r\n          label: \"Connecting\",\r\n          tooltip: \"Connecting to Streamlit server\",\r\n        }\r\n\r\n      case ConnectionState.CONNECTED:\r\n      case ConnectionState.STATIC:\r\n        return undefined\r\n\r\n      case ConnectionState.DISCONNECTED_FOREVER:\r\n      default:\r\n        return {\r\n          icon: \"warning\",\r\n          label: \"Error\",\r\n          tooltip: \"Unable to connect to Streamlit server\",\r\n        }\r\n    }\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React from \"react\"\r\nimport { DropdownItem } from \"reactstrap\"\r\n\r\ninterface Props {\r\n  screenCastState: string\r\n  onClick: () => void\r\n}\r\n\r\nconst ScreencastOption = ({\r\n  screenCastState,\r\n  onClick,\r\n}: Props): JSX.Element => {\r\n  if (screenCastState === \"COUNTDOWN\") {\r\n    return (\r\n      <DropdownItem onClick={onClick}>\r\n        <span>Cancel screencast</span>\r\n        <span className=\"shortcut\">ESC</span>\r\n      </DropdownItem>\r\n    )\r\n  }\r\n\r\n  if (screenCastState === \"RECORDING\") {\r\n    return (\r\n      <DropdownItem onClick={onClick} className=\"stop-recording\">\r\n        <span>\r\n          <strong>Stop recording</strong>\r\n        </span>\r\n\r\n        <span className=\"shortcut\">ESC</span>\r\n      </DropdownItem>\r\n    )\r\n  }\r\n\r\n  return <DropdownItem onClick={onClick}>Record a screencast</DropdownItem>\r\n}\r\n\r\nexport default ScreencastOption\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent } from \"react\"\r\nimport {\r\n  Dropdown,\r\n  DropdownItem,\r\n  DropdownMenu,\r\n  DropdownToggle,\r\n} from \"reactstrap\"\r\nimport Icon from \"components/shared/Icon\"\r\n\r\nimport ScreencastOption from \"./component/ScreencastOption\"\r\nimport \"./MainMenu.scss\"\r\n\r\nconst ONLINE_DOCS_URL = \"https://docs.streamlit.io\"\r\nconst COMMUNITY_URL = \"https://discuss.streamlit.io\"\r\nconst TEAMS_URL = \"https://streamlit.io/forteams\"\r\nconst BUG_URL = \"https://github.com/streamlit/streamlit/issues/new/choose\"\r\n\r\ninterface Props {\r\n  /** True if report sharing is properly configured and enabled. */\r\n  sharingEnabled: boolean\r\n\r\n  /** True if we're connected to the Streamlit server. */\r\n  isServerConnected: () => boolean\r\n\r\n  /** Rerun the report. */\r\n  quickRerunCallback: () => void\r\n\r\n  /** Clear the cache. */\r\n  clearCacheCallback: () => void\r\n\r\n  /** Show the screen recording dialog. */\r\n  screencastCallback: () => void\r\n\r\n  /** Share the report to S3. */\r\n  shareCallback: () => void\r\n\r\n  /** Show the Settings dialog. */\r\n  settingsCallback: () => void\r\n\r\n  /** Show the About dialog. */\r\n  aboutCallback: () => void\r\n\r\n  screenCastState: string\r\n}\r\n\r\ninterface State {\r\n  /** True if the menu is currently visible. */\r\n  dropdownOpen: boolean\r\n}\r\n\r\nclass MainMenu extends PureComponent<Props, State> {\r\n  /**\r\n   * Constructor.\r\n   */\r\n  constructor(props: Props) {\r\n    super(props)\r\n    this.state = {\r\n      dropdownOpen: false,\r\n    }\r\n  }\r\n\r\n  toggle = (): void => {\r\n    this.setState(({ dropdownOpen }) => ({\r\n      dropdownOpen: !dropdownOpen,\r\n    }))\r\n  }\r\n\r\n  getOpenInWindowCallback = (url: string) => (): void => {\r\n    window.open(url, \"_blank\")\r\n  }\r\n\r\n  public render(): JSX.Element {\r\n    const isServerDisconnected = !this.props.isServerConnected()\r\n\r\n    return (\r\n      <Dropdown\r\n        id=\"MainMenu\"\r\n        isOpen={this.state.dropdownOpen}\r\n        toggle={this.toggle}\r\n      >\r\n        <DropdownToggle outline color=\"secondary\" id=\"MainMenuButton\">\r\n          <Icon type=\"menu\" />\r\n\r\n          {this.props.screenCastState === \"RECORDING\" && (\r\n            <span className=\"recording-indicator\" />\r\n          )}\r\n        </DropdownToggle>\r\n\r\n        <DropdownMenu right>\r\n          <DropdownItem\r\n            disabled={isServerDisconnected}\r\n            onClick={this.props.quickRerunCallback}\r\n          >\r\n            <span>Rerun</span>\r\n            <span className=\"shortcut\">R</span>\r\n          </DropdownItem>\r\n\r\n          <DropdownItem\r\n            disabled={isServerDisconnected}\r\n            onClick={this.props.clearCacheCallback}\r\n          >\r\n            <span>Clear cache</span>\r\n            <span className=\"shortcut\">C</span>\r\n          </DropdownItem>\r\n\r\n          <DropdownItem divider />\r\n\r\n          <ScreencastOption\r\n            screenCastState={this.props.screenCastState}\r\n            onClick={this.props.screencastCallback}\r\n          />\r\n\r\n          {/* We hide 'Share Report' + divider if sharing is not configured */}\r\n          {this.props.sharingEnabled && (\r\n            <DropdownItem\r\n              disabled={isServerDisconnected}\r\n              onClick={this.props.shareCallback}\r\n            >\r\n              Save a snapshot\r\n            </DropdownItem>\r\n          )}\r\n\r\n          <DropdownItem divider />\r\n\r\n          <DropdownItem\r\n            onClick={this.getOpenInWindowCallback(ONLINE_DOCS_URL)}\r\n          >\r\n            Documentation\r\n          </DropdownItem>\r\n\r\n          <DropdownItem onClick={this.getOpenInWindowCallback(COMMUNITY_URL)}>\r\n            Ask a question\r\n          </DropdownItem>\r\n\r\n          <DropdownItem onClick={this.getOpenInWindowCallback(BUG_URL)}>\r\n            Report a bug\r\n          </DropdownItem>\r\n\r\n          <DropdownItem divider />\r\n\r\n          <DropdownItem onClick={this.getOpenInWindowCallback(TEAMS_URL)}>\r\n            Streamlit for teams\r\n          </DropdownItem>\r\n\r\n          <DropdownItem onClick={this.props.settingsCallback}>\r\n            Settings\r\n          </DropdownItem>\r\n\r\n          <DropdownItem onClick={this.props.aboutCallback}>About</DropdownItem>\r\n        </DropdownMenu>\r\n      </Dropdown>\r\n    )\r\n  }\r\n}\r\n\r\nexport default MainMenu\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { BasicDialog } from \"components/core/StreamlitDialog/StreamlitDialog\"\r\nimport React, { PureComponent, ReactNode } from \"react\"\r\nimport { HotKeys } from \"react-hotkeys\"\r\nimport { Button, ModalBody, ModalFooter, ModalHeader } from \"reactstrap\"\r\n\r\nexport interface Props {\r\n  /** Called to close the dialog without rerunning the report. */\r\n  onClose: () => void\r\n\r\n  /**\r\n   * Called when the user chooses to re-run the report in response to its source file changing.\r\n   * @param alwaysRerun if true, also change the run-on-save setting for this report\r\n   */\r\n  onRerun: (alwaysRerun: boolean) => void\r\n}\r\n\r\nexport class ScriptChangedDialog extends PureComponent<Props> {\r\n  private readonly keyHandlers: {\r\n    [key: string]: (keyEvent?: KeyboardEvent) => void\r\n  }\r\n\r\n  constructor(props: Props) {\r\n    super(props)\r\n\r\n    this.keyHandlers = {\r\n      a: this.alwaysRerun,\r\n      // No handler for 'r' since it's handled by app.jsx and precedence\r\n      // isn't working when multiple components handle the same key\r\n      // 'r': this.rerun,\r\n    }\r\n  }\r\n\r\n  public render(): ReactNode {\r\n    // Not sure exactly why attach and focused are necessary on the\r\n    // HotKeys component here but its not working without them\r\n    return (\r\n      <HotKeys handlers={this.keyHandlers} attach={window} focused={true}>\r\n        <BasicDialog onClose={this.props.onClose}>\r\n          <ModalHeader toggle={this.props.onClose}>App changed</ModalHeader>\r\n          <ModalBody>\r\n            <div>The source files for this app have changed on disk.</div>\r\n          </ModalBody>\r\n          <ModalFooter>\r\n            <Button\r\n              className=\"underlineFirstLetter\"\r\n              outline\r\n              color=\"secondary\"\r\n              onClick={this.alwaysRerun}\r\n            >\r\n              Always rerun\r\n            </Button>{\" \"}\r\n            <Button\r\n              className=\"underlineFirstLetter\"\r\n              outline\r\n              color=\"primary\"\r\n              onClick={this.rerun}\r\n            >\r\n              Rerun\r\n            </Button>\r\n          </ModalFooter>\r\n        </BasicDialog>\r\n      </HotKeys>\r\n    )\r\n  }\r\n\r\n  private rerun = (): void => {\r\n    this.props.onRerun(false)\r\n  }\r\n\r\n  private alwaysRerun = (): void => {\r\n    this.props.onRerun(true)\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport * as React from \"react\"\r\nimport { ChangeEvent, PureComponent, ReactNode } from \"react\"\r\nimport { Button, Modal, ModalBody, ModalFooter, ModalHeader } from \"reactstrap\"\r\nimport { UserSettings } from \"./UserSettings\"\r\n\r\nexport interface Props {\r\n  isServerConnected: boolean\r\n  onClose: () => void\r\n  onSave: (settings: UserSettings) => void\r\n  settings: UserSettings\r\n}\r\n\r\n/**\r\n * Implements a dialog that is used to configure user settings.\r\n */\r\nexport class SettingsDialog extends PureComponent<Props, UserSettings> {\r\n  private _settings: UserSettings\r\n\r\n  constructor(props: Props) {\r\n    super(props)\r\n\r\n    // Holds the settings that will be saved when the \"save\" button is clicked.\r\n    this.state = { ...this.props.settings }\r\n\r\n    // Holds the actual settings that Streamlit is using.\r\n    this._settings = { ...this.props.settings }\r\n  }\r\n\r\n  public render = (): ReactNode => {\r\n    return (\r\n      <Modal\r\n        isOpen={true}\r\n        toggle={this.handleCancelButtonClick}\r\n        onOpened={this.handleDialogOpen}\r\n      >\r\n        <ModalHeader toggle={this.handleCancelButtonClick}>\r\n          Settings\r\n        </ModalHeader>\r\n\r\n        <ModalBody>\r\n          <label>\r\n            <input\r\n              disabled={!this.props.isServerConnected}\r\n              type=\"checkbox\"\r\n              name=\"runOnSave\"\r\n              checked={this.state.runOnSave && this.props.isServerConnected}\r\n              onChange={this.handleCheckboxChange}\r\n            />{\" \"}\r\n            Run on save\r\n          </label>\r\n          <br />\r\n          <label>\r\n            <input\r\n              type=\"checkbox\"\r\n              name=\"wideMode\"\r\n              checked={this.state.wideMode}\r\n              onChange={this.handleCheckboxChange}\r\n            />{\" \"}\r\n            Show app in wide mode\r\n          </label>\r\n        </ModalBody>\r\n\r\n        <ModalFooter>\r\n          <Button\r\n            outline\r\n            color=\"secondary\"\r\n            onClick={this.handleCancelButtonClick}\r\n          >\r\n            Cancel\r\n          </Button>\r\n          <Button outline color=\"primary\" onClick={this.handleSaveButtonClick}>\r\n            Save\r\n          </Button>\r\n        </ModalFooter>\r\n      </Modal>\r\n    )\r\n  }\r\n\r\n  private handleDialogOpen = (): void => {\r\n    this.setState({ ...this._settings })\r\n  }\r\n\r\n  private changeSingleSetting = (name: string, value: boolean): void => {\r\n    // TypeScript doesn't currently have a good solution for setState with\r\n    // a dynamic key name:\r\n    // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/26635\r\n    this.setState(state => ({ ...state, [name]: value }))\r\n  }\r\n\r\n  private handleCheckboxChange = (e: ChangeEvent<HTMLInputElement>): void => {\r\n    this.changeSingleSetting(e.target.name, e.target.checked)\r\n  }\r\n\r\n  private handleCancelButtonClick = (): void => {\r\n    // Discard settings from this.state by not saving them in this.settings.\r\n    // this.settings = {...this.state};\r\n    this.props.onClose()\r\n  }\r\n\r\n  private handleSaveButtonClick = (): void => {\r\n    this._settings = { ...this.state }\r\n    this.props.onSave(this._settings)\r\n    this.props.onClose()\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { FETCH_PARAMS } from \"./baseconsts\"\r\nimport url from \"url\"\r\n\r\n/**\r\n * Returns the local path for a static report resource.\r\n * @param reportId the report ID of the resource to fetch\r\n * @param objName the name of the resource to fetch\r\n */\r\nexport function getReportObjectPath(\r\n  reportId: string,\r\n  objName: string\r\n): string {\r\n  const { pathname } = url.parse(window.location.href, true)\r\n\r\n  let resourceRoot = \"\"\r\n  if (pathname != null) {\r\n    // If we have a pathname, it will look like either\r\n    // 1) /some/s3/path/0.49.0-HdbX/index.html?id=1234 OR\r\n    // 2) /index.html?id=1234\r\n    // We want everything after the leading '/', and before the final '/'.\r\n\r\n    // Strip the trailing \"/\" and everything after it\r\n    resourceRoot = pathname.substring(0, pathname.lastIndexOf(\"/\"))\r\n\r\n    // Strip the leading slash, if it exists\r\n    if (resourceRoot.startsWith(\"/\")) {\r\n      resourceRoot = resourceRoot.substring(1)\r\n    }\r\n  }\r\n\r\n  const objectPath = `reports/${reportId}/${objName}`\r\n  return resourceRoot === \"\"\r\n    ? `/${objectPath}`\r\n    : `/${resourceRoot}/${objectPath}`\r\n}\r\n\r\n/**\r\n * Fetch a static report resource from S3. Error if it doesn't exist.\r\n *\r\n * @param reportId the report ID of the resource to fetch\r\n * @param objName the name of the resource to fetch\r\n */\r\nexport async function getReportObject(\r\n  reportId: string,\r\n  objName: string\r\n): Promise<Response> {\r\n  const response = await fetch(\r\n    getReportObjectPath(reportId, objName),\r\n    FETCH_PARAMS\r\n  )\r\n\r\n  if (!response.ok) {\r\n    if (response.status === 403) {\r\n      // Can't subclass Error class in Babel, so this is my crappy solution.\r\n      throw new Error(\"PermissionError\")\r\n    } else {\r\n      const responseText = await response.text()\r\n      throw new Error(\r\n        `HTTP status code: ${response.status}\\n` +\r\n          `Response text: ${responseText}`\r\n      )\r\n    }\r\n  }\r\n\r\n  return response\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { ForwardMsg, StaticManifest } from \"autogen/proto\"\r\nimport { ConnectionState } from \"lib/ConnectionState\"\r\nimport { logError } from \"lib/log\"\r\nimport { getReportObject } from \"lib/s3helper\"\r\n\r\ninterface Props {\r\n  reportId: string\r\n\r\n  /** Manifest protobuf from the server. */\r\n  manifest: StaticManifest\r\n\r\n  /** Function called when we receive a new message. */\r\n  onMessage: (message: ForwardMsg) => void\r\n\r\n  /**\r\n   * Function called when our ConnectionState changes.\r\n   */\r\n  onConnectionStateChange: (connectionState: ConnectionState) => void\r\n}\r\n\r\n/**\r\n * This class is the \"brother\" of WebsocketConnection. The class implements\r\n * loading ForwardMsgs over an HTTP connection (as opposed to with websockets).\r\n */\r\nexport class StaticConnection {\r\n  constructor(props: Props) {\r\n    props.onConnectionStateChange(ConnectionState.STATIC)\r\n\r\n    // This method returns a promise, but we don't care about its result.\r\n    StaticConnection.getAllMessages(props)\r\n  }\r\n\r\n  private static async getAllMessages(props: Props): Promise<void> {\r\n    const { numMessages } = props.manifest\r\n\r\n    for (let msgIdx = 0; msgIdx < numMessages; msgIdx++) {\r\n      try {\r\n        const response = await getReportObject(props.reportId, `${msgIdx}.pb`)\r\n        const arrayBuffer = await response.arrayBuffer()\r\n        props.onMessage(ForwardMsg.decode(new Uint8Array(arrayBuffer)))\r\n      } catch (error) {\r\n        logError(`Error loading message ${msgIdx}: ${error}`)\r\n      }\r\n    }\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { ForwardMsg, ForwardMsgMetadata } from \"autogen/proto\"\r\nimport { logMessage } from \"lib/log\"\r\nimport { BaseUriParts, buildHttpUri } from \"lib/UriUtil\"\r\n\r\nclass CacheEntry {\r\n  public readonly msg: ForwardMsg\r\n  public reportRunCount = 0\r\n\r\n  public getAge(curReportRunCount: number): number {\r\n    return curReportRunCount - this.reportRunCount\r\n  }\r\n\r\n  constructor(msg: ForwardMsg, reportRunCount: number) {\r\n    this.msg = msg\r\n    this.reportRunCount = reportRunCount\r\n  }\r\n}\r\n\r\n/**\r\n * Handles ForwardMsg caching for WebsocketConnection.\r\n */\r\nexport class ForwardMsgCache {\r\n  private readonly messages = new Map<string, CacheEntry>()\r\n\r\n  /**\r\n   * A function that returns our server's base URI, or undefined\r\n   * if we're not connected.\r\n   */\r\n  private readonly getServerUri: () => BaseUriParts | undefined\r\n\r\n  /**\r\n   * A counter that tracks the number of times the underyling report\r\n   * has been run. We use this to expire our cache entries.\r\n   */\r\n  private reportRunCount = 0\r\n\r\n  constructor(getServerUri: () => BaseUriParts | undefined) {\r\n    this.getServerUri = getServerUri\r\n  }\r\n\r\n  /**\r\n   * Increment our reportRunCount, and remove all entries from the cache\r\n   * that have expired. This should be called after the report has finished\r\n   * running.\r\n   *\r\n   * @param maxMessageAge Max age of a message in the cache.\r\n   * The \"age\" of a message is defined by how many times the underyling report\r\n   * has finished running (without a compile error) since the message was\r\n   * last accessed.\r\n   */\r\n  public incrementRunCount(maxMessageAge: number): void {\r\n    this.reportRunCount += 1\r\n\r\n    // It is safe to delete from a map during forEach iteration:\r\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach#Description\r\n    this.messages.forEach((entry, hash) => {\r\n      if (entry.getAge(this.reportRunCount) > maxMessageAge) {\r\n        logMessage(`Removing expired ForwardMsg [hash=${hash}]`)\r\n        this.messages.delete(hash)\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Process a ForwardMsg, \"de-referencing\" it if it's a reference to\r\n   * a cached message.\r\n   *\r\n   * - If the message is cacheable, store it in the cache and return it\r\n   *   unmodified.\r\n   * - If the message is instead a reference to another message, look for\r\n   *   the referenced message in the cache, and return it.\r\n   * - If the referenced message isn't in our cache, request it from the\r\n   *   server, cache it, and return it.\r\n   */\r\n  public async processMessagePayload(msg: ForwardMsg): Promise<ForwardMsg> {\r\n    this.maybeCacheMessage(msg)\r\n\r\n    if (msg.type !== \"refHash\") {\r\n      return msg\r\n    }\r\n\r\n    let newMsg = this.getCachedMessage(msg.refHash, true)\r\n    if (newMsg != null) {\r\n      logMessage(`Cached ForwardMsg HIT [hash=${msg.refHash}]`)\r\n    } else {\r\n      // Cache miss: fetch from the server\r\n      logMessage(`Cached ForwardMsg MISS [hash=${msg.refHash}]`)\r\n      newMsg = await this.fetchMessagePayload(msg.refHash)\r\n      this.maybeCacheMessage(newMsg)\r\n    }\r\n\r\n    // Copy the metadata from the refMsg into our new message\r\n    if (!msg.metadata) {\r\n      throw new Error(\"ForwardMsg has no metadata\")\r\n    }\r\n    newMsg.metadata = ForwardMsgMetadata.create(msg.metadata)\r\n    return newMsg\r\n  }\r\n\r\n  /**\r\n   * Fetches a message from the server by its hash. This happens when\r\n   * we have a ForwardMsg cache miss - that is, when the server sends\r\n   * us a ForwardMsg reference, and we don't have it in our local\r\n   * cache. This should happen rarely, as the client and server's\r\n   * caches should generally be in sync.\r\n   */\r\n  private async fetchMessagePayload(hash: string): Promise<ForwardMsg> {\r\n    const serverURI = this.getServerUri()\r\n    if (serverURI === undefined) {\r\n      throw new Error(\r\n        \"Cannot retrieve uncached message: not connected to a server\"\r\n      )\r\n    }\r\n\r\n    const url = buildHttpUri(serverURI, `message?hash=${hash}`)\r\n    const rsp = await fetch(url)\r\n    if (!rsp.ok) {\r\n      // `fetch` doesn't reject for bad HTTP statuses, so\r\n      // we explicitly check for that.\r\n      throw new Error(\r\n        `Failed to retrieve ForwardMsg (hash=${hash}): ${rsp.statusText}`\r\n      )\r\n    }\r\n\r\n    const data = await rsp.arrayBuffer()\r\n    const arrayBuffer = new Uint8Array(data)\r\n    try {\r\n      return ForwardMsg.decode(arrayBuffer)\r\n    } catch (e) {\r\n      throw new Error(\r\n        `Failed to decode ForwardMsg (hash=${hash}): ${e.message}`\r\n      )\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add a new message to the cache if appropriate.\r\n   */\r\n  private maybeCacheMessage(msg: ForwardMsg): void {\r\n    if (msg.type === \"refHash\") {\r\n      // We never cache reference messages. These messages\r\n      // may have `metadata.cacheable` set, but this is\r\n      // only because they carry the metadata for the messages\r\n      // they refer to.\r\n      return\r\n    }\r\n\r\n    if (!msg.metadata || !msg.metadata.cacheable) {\r\n      // Don't cache messages that the server hasn't marked as cacheable.\r\n      return\r\n    }\r\n\r\n    if (this.getCachedMessage(msg.hash, true) !== undefined) {\r\n      // We've already cached this message; don't need to do\r\n      // anything more. (Using getCachedMessage() here ensures\r\n      // that the message's reportRunCount value gets updated as\r\n      // expected.)\r\n      return\r\n    }\r\n\r\n    logMessage(`Caching ForwardMsg [hash=${msg.hash}]`)\r\n    this.messages.set(\r\n      msg.hash,\r\n      new CacheEntry(ForwardMsg.create(msg), this.reportRunCount)\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Return a new copy of the ForwardMsg with the given hash\r\n   * from the cache, or undefined if no such message exists.\r\n   *\r\n   * If the message's entry exists, its reportRunCount will be\r\n   * updated to the current value.\r\n   */\r\n  private getCachedMessage(\r\n    hash: string,\r\n    updateReportRunCount: boolean\r\n  ): ForwardMsg | undefined {\r\n    const cached = this.messages.get(hash)\r\n    if (cached == null) {\r\n      return undefined\r\n    }\r\n\r\n    if (updateReportRunCount) {\r\n      cached.reportRunCount = this.reportRunCount\r\n    }\r\n    return ForwardMsg.create(cached.msg)\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\n/**\r\n * A promise wrapper that makes resolve/reject functions public.\r\n */\r\nexport default class Resolver<T> {\r\n  public resolve: (arg?: T) => void | Promise<any>\r\n  public reject: (reason?: any) => void | Promise<any>\r\n  public promise: Promise<T>\r\n\r\n  constructor() {\r\n    // Initialize to something so TS is happy.\r\n    this.resolve = () => {}\r\n    this.reject = () => {}\r\n\r\n    this.promise = new Promise<T>((resFn, rejFn) => {\r\n      this.resolve = resFn\r\n      this.reject = rejFn\r\n    })\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { BackMsg, ForwardMsg, IBackMsg } from \"autogen/proto\"\r\n\r\nimport axios from \"axios\"\r\nimport { ConnectionState } from \"lib/ConnectionState\"\r\nimport { ForwardMsgCache } from \"lib/ForwardMessageCache\"\r\nimport { logError, logMessage, logWarning } from \"lib/log\"\r\nimport Resolver from \"lib/Resolver\"\r\nimport { SessionInfo } from \"lib/SessionInfo\"\r\nimport { BaseUriParts, buildHttpUri, buildWsUri } from \"lib/UriUtil\"\r\nimport React, { Fragment } from \"react\"\r\n\r\n/**\r\n * Name of the logger.\r\n */\r\nconst LOG = \"WebsocketConnection\"\r\n\r\n/**\r\n * The path where we should ping (via HTTP) to see if the server is up.\r\n */\r\nconst SERVER_PING_PATH = \"healthz\"\r\n\r\n/**\r\n * The path of the server's websocket endpoint.\r\n */\r\nconst WEBSOCKET_STREAM_PATH = \"stream\"\r\n\r\n/**\r\n * Wait this long between pings, in millis.\r\n */\r\nconst PING_RETRY_PERIOD_MS = 500\r\n\r\n/**\r\n * Timeout when attempting to connect to a websocket, in millis.\r\n * This should be <= bootstrap.py#BROWSER_WAIT_TIMEOUT_SEC.\r\n */\r\nconst WEBSOCKET_TIMEOUT_MS = 1000\r\n\r\n/**\r\n * If the ping retrieves a 403 status code a message will be displayed.\r\n * This constant is the link to the documentation.\r\n */\r\nconst CORS_ERROR_MESSAGE_DOCUMENTATION_LINK =\r\n  \"https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS\"\r\n\r\ntype OnMessage = (ForwardMsg: any) => void\r\ntype OnConnectionStateChange = (\r\n  connectionState: ConnectionState,\r\n  errMsg?: string\r\n) => void\r\ntype OnRetry = (totalTries: number, errorNode: React.ReactNode) => void\r\n\r\ninterface Args {\r\n  /**\r\n   * List of URLs to connect to. We'll try the first, then the second, etc. If\r\n   * all fail, we'll retry from the top. The number of retries depends on\r\n   * whether this is a local connection.\r\n   */\r\n  baseUriPartsList: BaseUriParts[]\r\n\r\n  /**\r\n   * Function called when our ConnectionState changes.\r\n   * If the new ConnectionState is ERROR, errMsg will be defined.\r\n   */\r\n  onConnectionStateChange: OnConnectionStateChange\r\n\r\n  /**\r\n   * Function called every time we ping the server for sign of life.\r\n   */\r\n  onRetry: OnRetry\r\n\r\n  /**\r\n   * Function called when we receive a new message.\r\n   */\r\n  onMessage: OnMessage\r\n}\r\n\r\ninterface MessageQueue {\r\n  [index: number]: any\r\n}\r\n\r\n/**\r\n * Events of the WebsocketConnection state machine. Here's what the FSM looks\r\n * like:\r\n *\r\n *   INITIAL\r\n *     │\r\n *     │               on conn succeed\r\n *     v               :\r\n *   CONNECTING ───────────────> CONNECTED\r\n *     │  ^                          │\r\n *     │  │:on ping succeed          │\r\n *     │:on timeout/error/closed     │\r\n *     v  │                          │:on error/closed\r\n *   PINGING_SERVER <────────────────┘\r\n *\r\n *                    on fatal error\r\n *                    :\r\n *   <ANY_STATE> ──────────────> DISCONNECTED_FOREVER\r\n */\r\ntype Event =\r\n  | \"INITIALIZED\"\r\n  | \"CONNECTION_CLOSED\"\r\n  | \"CONNECTION_ERROR\"\r\n  | \"CONNECTION_SUCCEEDED\"\r\n  | \"CONNECTION_TIMED_OUT\"\r\n  | \"SERVER_PING_SUCCEEDED\"\r\n  | \"FATAL_ERROR\" // Unrecoverable error. This should never happen!\r\n\r\n/**\r\n * This class is the \"brother\" of StaticConnection. The class connects to the\r\n * server and gets deltas over a websocket connection.\r\n */\r\nexport class WebsocketConnection {\r\n  private readonly args: Args\r\n\r\n  /**\r\n   * ForwardMessages get passed through this cache. This gets initialized\r\n   * once we connect to the server.\r\n   */\r\n  private readonly cache: ForwardMsgCache\r\n\r\n  /**\r\n   * Index to the URI in uriList that we're going to try to connect to.\r\n   */\r\n  private uriIndex = 0\r\n\r\n  /**\r\n   * To guarantee packet transmission order, this is the index of the last\r\n   * dispatched incoming message.\r\n   */\r\n  private lastDispatchedMessageIndex = -1\r\n\r\n  /**\r\n   * And this is the index of the next message we recieve.\r\n   */\r\n  private nextMessageIndex = 0\r\n\r\n  /**\r\n   * This dictionary stores recieved messages that we haven't sent out yet\r\n   * (because we're still decoding previous messages)\r\n   */\r\n  private messageQueue: MessageQueue = {}\r\n\r\n  /**\r\n   * The current state of this object's state machine.\r\n   */\r\n  private state = ConnectionState.INITIAL\r\n\r\n  /**\r\n   * The WebSocket object we're connecting with.\r\n   */\r\n  private websocket?: WebSocket\r\n\r\n  /**\r\n   * WebSocket objects don't support retries, so we have to implement them\r\n   * ourselves. We use setTimeout to wait for a connection and retry once the\r\n   * timeout fire. This is the timer ID from setTimeout, so we can cancel it if\r\n   * needed.\r\n   */\r\n  private wsConnectionTimeoutId?: number\r\n\r\n  constructor(props: Args) {\r\n    this.args = props\r\n    this.cache = new ForwardMsgCache(() => this.getBaseUriParts())\r\n    this.stepFsm(\"INITIALIZED\")\r\n  }\r\n\r\n  /**\r\n   * Return the BaseUriParts for the server we're connected to,\r\n   * if we are connected to a server.\r\n   */\r\n  public getBaseUriParts(): BaseUriParts | undefined {\r\n    if (this.state === ConnectionState.CONNECTED) {\r\n      return this.args.baseUriPartsList[this.uriIndex]\r\n    }\r\n    return undefined\r\n  }\r\n\r\n  // This should only be called inside stepFsm().\r\n  private setFsmState(state: ConnectionState, errMsg?: string): void {\r\n    logMessage(LOG, `New state: ${state}`)\r\n    this.state = state\r\n    this.args.onConnectionStateChange(state, errMsg)\r\n\r\n    // Perform actions when entering certain states.\r\n    switch (this.state) {\r\n      case ConnectionState.PINGING_SERVER:\r\n        this.pingServer()\r\n        break\r\n\r\n      case ConnectionState.CONNECTING:\r\n        this.connectToWebSocket()\r\n        break\r\n\r\n      case ConnectionState.DISCONNECTED_FOREVER:\r\n        this.cancelConnectionAttempt()\r\n        break\r\n\r\n      case ConnectionState.CONNECTED:\r\n      case ConnectionState.INITIAL:\r\n      default:\r\n        break\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Process an event in our FSM.\r\n   *\r\n   * @param event The event to process.\r\n   * @param errMsg an optional error message to send to the OnStateChanged\r\n   * callback. This is meaningful only for the FATAL_ERROR event. The message\r\n   * will be displayed to the user in a \"Connection Error\" dialog.\r\n   */\r\n  private stepFsm(event: Event, errMsg?: string): void {\r\n    logMessage(LOG, `State: ${this.state}; Event: ${event}`)\r\n\r\n    if (\r\n      event === \"FATAL_ERROR\" &&\r\n      this.state !== ConnectionState.DISCONNECTED_FOREVER\r\n    ) {\r\n      // If we get a fatal error, we transition to DISCONNECTED_FOREVER\r\n      // regardless of our current state.\r\n      this.setFsmState(ConnectionState.DISCONNECTED_FOREVER, errMsg)\r\n      return\r\n    }\r\n\r\n    // Any combination of state+event that is not explicitly called out\r\n    // below is illegal and raises an error.\r\n\r\n    switch (this.state) {\r\n      case ConnectionState.INITIAL:\r\n        if (event === \"INITIALIZED\") {\r\n          this.setFsmState(ConnectionState.CONNECTING)\r\n          return\r\n        }\r\n        break\r\n\r\n      case ConnectionState.CONNECTING:\r\n        if (event === \"CONNECTION_SUCCEEDED\") {\r\n          this.setFsmState(ConnectionState.CONNECTED)\r\n          return\r\n        } else if (\r\n          event === \"CONNECTION_TIMED_OUT\" ||\r\n          event === \"CONNECTION_ERROR\" ||\r\n          event === \"CONNECTION_CLOSED\"\r\n        ) {\r\n          this.setFsmState(ConnectionState.PINGING_SERVER)\r\n          return\r\n        }\r\n        break\r\n\r\n      case ConnectionState.CONNECTED:\r\n        if (event === \"CONNECTION_CLOSED\" || event === \"CONNECTION_ERROR\") {\r\n          this.setFsmState(ConnectionState.PINGING_SERVER)\r\n          return\r\n        }\r\n        break\r\n\r\n      case ConnectionState.PINGING_SERVER:\r\n        if (event === \"SERVER_PING_SUCCEEDED\") {\r\n          this.setFsmState(ConnectionState.CONNECTING)\r\n          return\r\n        }\r\n        break\r\n\r\n      case ConnectionState.DISCONNECTED_FOREVER:\r\n        // If we're in the DISCONNECTED_FOREVER state, we can't reasonably\r\n        // process any events, and it's possible we're in this state because\r\n        // of a fatal error. Just log these events rather than throwing more\r\n        // exceptions.\r\n        logWarning(\r\n          LOG,\r\n          `Discarding ${event} while in ${ConnectionState.DISCONNECTED_FOREVER}`\r\n        )\r\n        return\r\n\r\n      default:\r\n        break\r\n    }\r\n\r\n    throw new Error(\r\n      \"Unsupported state transition.\\n\" +\r\n        `State: ${this.state}\\n` +\r\n        `Event: ${event}`\r\n    )\r\n  }\r\n\r\n  private async pingServer(): Promise<void> {\r\n    const uris = this.args.baseUriPartsList.map((_, i) =>\r\n      buildHttpUri(this.args.baseUriPartsList[i], SERVER_PING_PATH)\r\n    )\r\n\r\n    this.uriIndex = await doHealthPing(\r\n      uris,\r\n      PING_RETRY_PERIOD_MS,\r\n      this.args.onRetry\r\n    )\r\n\r\n    this.stepFsm(\"SERVER_PING_SUCCEEDED\")\r\n  }\r\n\r\n  private connectToWebSocket(): void {\r\n    const uri = buildWsUri(\r\n      this.args.baseUriPartsList[this.uriIndex],\r\n      WEBSOCKET_STREAM_PATH\r\n    )\r\n\r\n    if (this.websocket != null) {\r\n      // This should never happen. We set the websocket to null in both FSM\r\n      // nodes that lead to this one.\r\n      throw new Error(\"Websocket already exists\")\r\n    }\r\n\r\n    logMessage(LOG, \"creating WebSocket\")\r\n    this.websocket = new WebSocket(uri)\r\n\r\n    this.setConnectionTimeout(uri)\r\n\r\n    const localWebsocket = this.websocket\r\n    const checkWebsocket = (): boolean => localWebsocket === this.websocket\r\n\r\n    this.websocket.onmessage = (event: MessageEvent) => {\r\n      if (checkWebsocket()) {\r\n        this.handleMessage(event.data).catch(reason => {\r\n          const err = `Failed to process a Websocket message (${reason})`\r\n          logError(LOG, err)\r\n          this.stepFsm(\"FATAL_ERROR\", err)\r\n        })\r\n      }\r\n    }\r\n\r\n    this.websocket.onopen = () => {\r\n      if (checkWebsocket()) {\r\n        logMessage(LOG, \"WebSocket onopen\")\r\n        this.stepFsm(\"CONNECTION_SUCCEEDED\")\r\n      }\r\n    }\r\n\r\n    this.websocket.onclose = () => {\r\n      if (checkWebsocket()) {\r\n        logMessage(LOG, \"WebSocket onclose\")\r\n        this.cancelConnectionAttempt()\r\n        this.stepFsm(\"CONNECTION_CLOSED\")\r\n      }\r\n    }\r\n\r\n    this.websocket.onerror = () => {\r\n      if (checkWebsocket()) {\r\n        logMessage(LOG, \"WebSocket onerror\")\r\n        this.cancelConnectionAttempt()\r\n        this.stepFsm(\"CONNECTION_ERROR\")\r\n      }\r\n    }\r\n  }\r\n\r\n  private setConnectionTimeout(uri: string): void {\r\n    if (this.wsConnectionTimeoutId != null) {\r\n      // This should never happen. We set the timeout ID to null in both FSM\r\n      // nodes that lead to this one.\r\n      throw new Error(\"WS timeout is already set\")\r\n    }\r\n\r\n    const localWebsocket = this.websocket\r\n\r\n    this.wsConnectionTimeoutId = window.setTimeout(() => {\r\n      if (localWebsocket !== this.websocket) {\r\n        return\r\n      }\r\n\r\n      if (this.wsConnectionTimeoutId == null) {\r\n        // Sometimes the clearTimeout doesn't work. No idea why :-/\r\n        logWarning(LOG, \"Timeout fired after cancellation\")\r\n        return\r\n      }\r\n\r\n      if (this.websocket == null) {\r\n        // This should never happen! The only place we call\r\n        // setConnectionTimeout() should be immediately before setting\r\n        // this.websocket.\r\n        this.cancelConnectionAttempt()\r\n        this.stepFsm(\"FATAL_ERROR\", \"Null Websocket in setConnectionTimeout\")\r\n        return\r\n      }\r\n\r\n      if (this.websocket.readyState === 0 /* CONNECTING */) {\r\n        logMessage(LOG, `${uri} timed out`)\r\n        this.cancelConnectionAttempt()\r\n        this.stepFsm(\"CONNECTION_TIMED_OUT\")\r\n      }\r\n    }, WEBSOCKET_TIMEOUT_MS)\r\n    logMessage(LOG, `Set WS timeout ${this.wsConnectionTimeoutId}`)\r\n  }\r\n\r\n  private cancelConnectionAttempt(): void {\r\n    // Need to make sure the websocket is closed in the same function that\r\n    // cancels the connection timer. Otherwise, due to javascript's concurrency\r\n    // model, when the onclose event fires it can get handled in between the\r\n    // two functions, causing two events to be sent to the FSM: a\r\n    // CONNECTION_TIMED_OUT and a CONNECTION_ERROR.\r\n\r\n    if (this.websocket) {\r\n      this.websocket.close()\r\n      this.websocket = undefined\r\n    }\r\n\r\n    if (this.wsConnectionTimeoutId != null) {\r\n      logMessage(LOG, `Clearing WS timeout ${this.wsConnectionTimeoutId}`)\r\n      window.clearTimeout(this.wsConnectionTimeoutId)\r\n      this.wsConnectionTimeoutId = undefined\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Encodes the message with the outgoingMessageType and sends it over the\r\n   * wire.\r\n   */\r\n  public sendMessage(obj: IBackMsg): void {\r\n    if (!this.websocket) {\r\n      return\r\n    }\r\n    const msg = BackMsg.create(obj)\r\n    const buffer = BackMsg.encode(msg).finish()\r\n    this.websocket.send(buffer)\r\n  }\r\n\r\n  /**\r\n   * Called when our report has finished running. Calls through\r\n   * to the ForwardMsgCache, to handle cached entry expiry.\r\n   */\r\n  public incrementMessageCacheRunCount(maxMessageAge: number): void {\r\n    this.cache.incrementRunCount(maxMessageAge)\r\n  }\r\n\r\n  private async handleMessage(data: any): Promise<void> {\r\n    // Assign this message an index.\r\n    const messageIndex = this.nextMessageIndex\r\n    this.nextMessageIndex += 1\r\n\r\n    // Read in the message data.\r\n    const result = await readFileAsync(data)\r\n    if (this.messageQueue == null) {\r\n      throw new Error(\"No message queue.\")\r\n    }\r\n\r\n    if (result == null || typeof result === \"string\") {\r\n      throw new Error(`Unexpected result from FileReader: ${result}.`)\r\n    }\r\n\r\n    const resultArray = new Uint8Array(result)\r\n    const msg = ForwardMsg.decode(resultArray)\r\n    this.messageQueue[messageIndex] = await this.cache.processMessagePayload(\r\n      msg\r\n    )\r\n\r\n    // Dispatch any pending messages in the queue. This may *not* result\r\n    // in our just-decoded message being dispatched: if there are other\r\n    // messages that were received earlier than this one but are being\r\n    // downloaded, our message won't be sent until they're done.\r\n    while (this.lastDispatchedMessageIndex + 1 in this.messageQueue) {\r\n      const dispatchMessageIndex = this.lastDispatchedMessageIndex + 1\r\n      this.args.onMessage(this.messageQueue[dispatchMessageIndex])\r\n      delete this.messageQueue[dispatchMessageIndex]\r\n      this.lastDispatchedMessageIndex = dispatchMessageIndex\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Attempts to connect to the URIs in uriList (in round-robin fashion) and\r\n * retries forever until one of the URIs responds with 'ok'.\r\n * Returns a promise with the index of the URI that worked.\r\n */\r\nfunction doHealthPing(\r\n  uriList: string[],\r\n  timeoutMs: number,\r\n  retryCallback: OnRetry\r\n): Promise<number> {\r\n  const resolver = new Resolver<number>()\r\n  let totalTries = 0\r\n  let uriNumber = 0\r\n  let tryTimestamp = Date.now()\r\n\r\n  // Hoist the connect() declaration.\r\n  let connect = (): void => {}\r\n\r\n  const retryImmediately = (): void => {\r\n    uriNumber++\r\n    if (uriNumber >= uriList.length) {\r\n      uriNumber = 0\r\n    }\r\n\r\n    connect()\r\n  }\r\n\r\n  // Make sure we don't retry faster than timeoutMs. This is required because\r\n  // in some cases things fail very quickly, and all our fast retries end up\r\n  // bogging down the browser.\r\n  const retry = (errorNode: React.ReactNode): void => {\r\n    const tryDuration = (Date.now() - tryTimestamp) / 1000\r\n    const retryTimeout = tryDuration < timeoutMs ? timeoutMs - tryDuration : 0\r\n\r\n    retryCallback(totalTries, errorNode)\r\n\r\n    window.setTimeout(retryImmediately, retryTimeout)\r\n  }\r\n\r\n  const retryWhenTheresNoResponse = (): void => {\r\n    const uri = new URL(uriList[uriNumber])\r\n\r\n    if (uri.hostname === \"localhost\") {\r\n      const commandLine = SessionInfo.isSet()\r\n        ? SessionInfo.current.commandLine\r\n        : \"streamlit run yourscript.py\"\r\n      retry(\r\n        <Fragment>\r\n          <p>\r\n            Is Streamlit still running? If you accidentally stopped Streamlit,\r\n            just restart it in your terminal:\r\n          </p>\r\n          <pre>\r\n            <code className=\"bash\">{commandLine}</code>\r\n          </pre>\r\n        </Fragment>\r\n      )\r\n    } else {\r\n      retry(\"Connection failed with status 0.\")\r\n    }\r\n  }\r\n\r\n  const retryWhenIsForbidden = (): void => {\r\n    retry(\r\n      <Fragment>\r\n        <p>Cannot connect to Streamlit (HTTP status: 403).</p>\r\n        <p>\r\n          If you are trying to access a Streamlit app running on another\r\n          server, this could be due to the app's{\" \"}\r\n          <a href={CORS_ERROR_MESSAGE_DOCUMENTATION_LINK}>CORS</a> settings.\r\n        </p>\r\n      </Fragment>\r\n    )\r\n  }\r\n\r\n  connect = () => {\r\n    const uri = uriList[uriNumber]\r\n    logMessage(LOG, `Attempting to connect to ${uri}.`)\r\n    tryTimestamp = Date.now()\r\n\r\n    if (uriNumber === 0) {\r\n      totalTries++\r\n    }\r\n\r\n    axios\r\n      .get(uri, {\r\n        timeout: timeoutMs,\r\n      })\r\n      .then(() => {\r\n        resolver.resolve(uriNumber)\r\n      })\r\n      .catch(error => {\r\n        if (error.code === \"ECONNABORTED\") {\r\n          return retry(\"Connection timed out.\")\r\n        }\r\n\r\n        if (error.response) {\r\n          // The request was made and the server responded with a status code\r\n          // that falls out of the range of 2xx\r\n\r\n          const { data, status } = error.response\r\n\r\n          if (status === /* NO RESPONSE */ 0) {\r\n            return retryWhenTheresNoResponse()\r\n          } else if (status === 403) {\r\n            return retryWhenIsForbidden()\r\n          } else {\r\n            return retry(\r\n              `Connection failed with status ${status}, ` +\r\n                `and response \"${data}\".`\r\n            )\r\n          }\r\n        } else if (error.request) {\r\n          // The request was made but no response was received\r\n          // `error.request` is an instance of XMLHttpRequest in the browser and an instance of\r\n          // http.ClientRequest in node.js\r\n          return retryWhenTheresNoResponse()\r\n        } else {\r\n          // Something happened in setting up the request that triggered an Error\r\n          return retry(error.message)\r\n        }\r\n      })\r\n  }\r\n\r\n  connect()\r\n\r\n  return resolver.promise\r\n}\r\n\r\n/**\r\n * Wrap FileReader.readAsArrayBuffer in a Promise.\r\n */\r\nfunction readFileAsync(data: any): Promise<string | ArrayBuffer | null> {\r\n  return new Promise<any>((resolve, reject) => {\r\n    const reader = new FileReader()\r\n    reader.onload = () => resolve(reader.result)\r\n    reader.onerror = reject\r\n    reader.readAsArrayBuffer(data)\r\n  })\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { BackMsg, ForwardMsg, StaticManifest } from \"autogen/proto\"\r\nimport { BaseUriParts, getWindowBaseUriParts } from \"lib/UriUtil\"\r\nimport { ReactNode } from \"react\"\r\nimport url from \"url\"\r\nimport { IS_SHARED_REPORT } from \"./baseconsts\"\r\n\r\nimport { ConnectionState } from \"./ConnectionState\"\r\nimport { logError } from \"./log\"\r\nimport { getReportObject } from \"./s3helper\"\r\nimport { StaticConnection } from \"./StaticConnection\"\r\nimport { WebsocketConnection } from \"./WebsocketConnection\"\r\n\r\n/**\r\n * When the websocket connection retries this many times, we show a dialog\r\n * letting the user know we're having problems connecting.\r\n */\r\nconst RETRY_COUNT_FOR_WARNING = 30 // around 15s\r\n\r\ninterface Props {\r\n  /**\r\n   * Function to be called when we receive a message from the server.\r\n   */\r\n  onMessage: (message: ForwardMsg) => void\r\n\r\n  /**\r\n   * Function to be called when the connection errors out.\r\n   */\r\n  onConnectionError: (errNode: ReactNode) => void\r\n\r\n  /**\r\n   * Called when our ConnectionState is changed.\r\n   */\r\n  connectionStateChanged: (connectionState: ConnectionState) => void\r\n}\r\n\r\n/**\r\n * Manages our connection to the Server.\r\n */\r\nexport class ConnectionManager {\r\n  private readonly props: Props\r\n  private connection?: WebsocketConnection | StaticConnection\r\n  private connectionState: ConnectionState = ConnectionState.INITIAL\r\n\r\n  constructor(props: Props) {\r\n    this.props = props\r\n\r\n    // This method returns a promise, but we don't care about its result.\r\n    this.connect()\r\n  }\r\n\r\n  /**\r\n   * Indicates whether we're connected to the server.\r\n   */\r\n  public isConnected(): boolean {\r\n    return this.connectionState === ConnectionState.CONNECTED\r\n  }\r\n\r\n  // A \"static\" connection is the one that runs in S3\r\n  public isStaticConnection(): boolean {\r\n    return this.connectionState === ConnectionState.STATIC\r\n  }\r\n\r\n  /**\r\n   * Return the BaseUriParts for the server we're connected to,\r\n   * if we are connected to a server.\r\n   */\r\n  public getBaseUriParts(): BaseUriParts | undefined {\r\n    if (this.connection instanceof WebsocketConnection) {\r\n      return this.connection.getBaseUriParts()\r\n    } else {\r\n      return undefined\r\n    }\r\n  }\r\n\r\n  public sendMessage(obj: BackMsg): void {\r\n    if (this.connection instanceof WebsocketConnection && this.isConnected()) {\r\n      this.connection.sendMessage(obj)\r\n    } else {\r\n      // Don't need to make a big deal out of this. Just print to console.\r\n      logError(`Cannot send message when server is disconnected: ${obj}`)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Increment the runCount on our message cache, and clear entries\r\n   * whose age is greater than the max.\r\n   */\r\n  public incrementMessageCacheRunCount(maxMessageAge: number): void {\r\n    // StaticConnection does not use a MessageCache.\r\n    if (this.connection instanceof WebsocketConnection) {\r\n      this.connection.incrementMessageCacheRunCount(maxMessageAge)\r\n    }\r\n  }\r\n\r\n  private async connect(): Promise<void> {\r\n    try {\r\n      if (IS_SHARED_REPORT) {\r\n        const { query } = url.parse(window.location.href, true)\r\n        const reportId = query.id as string\r\n        this.connection = await this.connectBasedOnManifest(reportId)\r\n      } else {\r\n        this.connection = await this.connectToRunningServer()\r\n      }\r\n    } catch (err) {\r\n      logError(err.message)\r\n      this.setConnectionState(\r\n        ConnectionState.DISCONNECTED_FOREVER,\r\n        err.message\r\n      )\r\n    }\r\n  }\r\n\r\n  private setConnectionState = (\r\n    connectionState: ConnectionState,\r\n    errMsg?: string\r\n  ): void => {\r\n    if (this.connectionState !== connectionState) {\r\n      this.connectionState = connectionState\r\n      this.props.connectionStateChanged(connectionState)\r\n    }\r\n\r\n    if (errMsg || connectionState === ConnectionState.DISCONNECTED_FOREVER) {\r\n      this.props.onConnectionError(errMsg || \"unknown\")\r\n    }\r\n  }\r\n\r\n  private showRetryError = (\r\n    totalRetries: number,\r\n    latestError: ReactNode\r\n  ): void => {\r\n    if (totalRetries === RETRY_COUNT_FOR_WARNING) {\r\n      this.props.onConnectionError(latestError)\r\n    }\r\n  }\r\n\r\n  private connectToRunningServer(): WebsocketConnection {\r\n    const baseUriParts = getWindowBaseUriParts()\r\n\r\n    return new WebsocketConnection({\r\n      baseUriPartsList: [baseUriParts],\r\n      onMessage: this.props.onMessage,\r\n      onConnectionStateChange: this.setConnectionState,\r\n      onRetry: this.showRetryError,\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Opens either a static connection or a websocket connection, based on what\r\n   * the manifest says.\r\n   */\r\n  private async connectBasedOnManifest(\r\n    reportId: string\r\n  ): Promise<WebsocketConnection | StaticConnection> {\r\n    const manifest = await ConnectionManager.fetchManifest(reportId)\r\n\r\n    return manifest.serverStatus === StaticManifest.ServerStatus.RUNNING\r\n      ? this.connectToRunningServerFromManifest(manifest)\r\n      : this.connectToStaticReportFromManifest(reportId, manifest)\r\n  }\r\n\r\n  private connectToRunningServerFromManifest(\r\n    manifest: any\r\n  ): WebsocketConnection {\r\n    const {\r\n      configuredServerAddress,\r\n      internalServerIP,\r\n      externalServerIP,\r\n      serverPort,\r\n      serverBasePath,\r\n    } = manifest\r\n\r\n    const parts = { port: serverPort, basePath: serverBasePath }\r\n\r\n    const baseUriPartsList = configuredServerAddress\r\n      ? [{ ...parts, host: configuredServerAddress }]\r\n      : [\r\n          { ...parts, host: externalServerIP },\r\n          { ...parts, host: internalServerIP },\r\n        ]\r\n\r\n    return new WebsocketConnection({\r\n      baseUriPartsList,\r\n      onMessage: this.props.onMessage,\r\n      onConnectionStateChange: s => this.setConnectionState(s),\r\n      onRetry: this.showRetryError,\r\n    })\r\n  }\r\n\r\n  private connectToStaticReportFromManifest(\r\n    reportId: string,\r\n    manifest: StaticManifest\r\n  ): StaticConnection {\r\n    return new StaticConnection({\r\n      manifest,\r\n      reportId,\r\n      onMessage: this.props.onMessage,\r\n      onConnectionStateChange: s => this.setConnectionState(s),\r\n    })\r\n  }\r\n\r\n  private static async fetchManifest(\r\n    reportId: string\r\n  ): Promise<StaticManifest> {\r\n    try {\r\n      const data = await getReportObject(reportId, \"manifest.pb\")\r\n      const arrayBuffer = await data.arrayBuffer()\r\n\r\n      return StaticManifest.decode(new Uint8Array(arrayBuffer))\r\n    } catch (err) {\r\n      logError(err)\r\n      throw new Error(\"Unable to fetch data.\")\r\n    }\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport {\r\n  IBackMsg,\r\n  IntArray,\r\n  FloatArray,\r\n  StringArray,\r\n  WidgetState,\r\n  WidgetStates,\r\n} from \"autogen/proto\"\r\n\r\nimport { Set as ImmutableSet } from \"immutable\"\r\nimport { Long } from \"protobufjs\"\r\n\r\nexport interface Source {\r\n  fromUi: boolean\r\n}\r\n\r\n/**\r\n * Manages widget values, and sends widget update messages back to the server.\r\n */\r\nexport class WidgetStateManager {\r\n  // Called to deliver a message to the server\r\n  private readonly sendBackMsg: (msg: IBackMsg) => void\r\n  private readonly widgetStates: Map<string, WidgetState> = new Map<\r\n    string,\r\n    WidgetState\r\n  >()\r\n\r\n  constructor(sendBackMsg: (msg: IBackMsg) => void) {\r\n    this.sendBackMsg = sendBackMsg\r\n  }\r\n\r\n  /**\r\n   * True if our widget state dict is empty. This will be the case only when the browser\r\n   * initially connects to the server for the first time.\r\n   */\r\n  public get isEmpty(): boolean {\r\n    return this.widgetStates.size === 0\r\n  }\r\n\r\n  /**\r\n   * Sets the trigger value for the given widget ID to true, sends an updateWidgets message\r\n   * to the server, and then immediately unsets the trigger value.\r\n   */\r\n  public setTriggerValue(widgetId: string, source: Source): void {\r\n    this.getOrCreateWidgetStateProto(widgetId).triggerValue = true\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n    this.deleteWidgetStateProto(widgetId)\r\n  }\r\n\r\n  public getBoolValue(widgetId: string): boolean | undefined {\r\n    const state = this.getWidgetStateProto(widgetId)\r\n    if (state != null && state.value === \"boolValue\") {\r\n      return state.boolValue\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  public setBoolValue(widgetId: string, value: boolean, source: Source): void {\r\n    this.getOrCreateWidgetStateProto(widgetId).boolValue = value\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  public getIntValue(widgetId: string): number | Long | undefined {\r\n    const state = this.getWidgetStateProto(widgetId)\r\n    if (state != null && state.value === \"intValue\") {\r\n      return state.intValue\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  public setIntValue(widgetId: string, value: number, source: Source): void {\r\n    this.getOrCreateWidgetStateProto(widgetId).intValue = value\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  public getFloatValue(widgetId: string): number | undefined {\r\n    const state = this.getWidgetStateProto(widgetId)\r\n    if (state != null && state.value === \"floatValue\") {\r\n      return state.floatValue\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  public setFloatValue(widgetId: string, value: number, source: Source): void {\r\n    this.getOrCreateWidgetStateProto(widgetId).floatValue = value\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  public getStringValue(widgetId: string): string | undefined {\r\n    const state = this.getWidgetStateProto(widgetId)\r\n    if (state != null && state.value === \"stringValue\") {\r\n      return state.stringValue\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  public setStringValue(\r\n    widgetId: string,\r\n    value: string,\r\n    source: Source\r\n  ): void {\r\n    this.getOrCreateWidgetStateProto(widgetId).stringValue = value\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  public setStringArrayValue(\r\n    widgetId: string,\r\n    value: string[],\r\n    source: Source\r\n  ): void {\r\n    this.getOrCreateWidgetStateProto(\r\n      widgetId\r\n    ).stringArrayValue = StringArray.fromObject({ data: value })\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  public getFloatArrayValue(widgetId: string): number[] | undefined {\r\n    const state = this.getWidgetStateProto(widgetId)\r\n    if (\r\n      state != null &&\r\n      state.value === \"floatArrayValue\" &&\r\n      state.floatArrayValue != null &&\r\n      state.floatArrayValue.value != null\r\n    ) {\r\n      return state.floatArrayValue.value\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  public setFloatArrayValue(\r\n    widgetId: string,\r\n    value: number[],\r\n    source: Source\r\n  ): void {\r\n    this.getOrCreateWidgetStateProto(\r\n      widgetId\r\n    ).floatArrayValue = FloatArray.fromObject({ value })\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  public getIntArrayValue(widgetId: string): (number | Long)[] | undefined {\r\n    const state = this.getWidgetStateProto(widgetId)\r\n    if (\r\n      state != null &&\r\n      state.value === \"intArrayValue\" &&\r\n      state.intArrayValue != null &&\r\n      state.intArrayValue.value != null\r\n    ) {\r\n      return state.intArrayValue.value\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  public setIntArrayValue(\r\n    widgetId: string,\r\n    value: number[],\r\n    source: Source\r\n  ): void {\r\n    this.getOrCreateWidgetStateProto(\r\n      widgetId\r\n    ).intArrayValue = IntArray.fromObject({ value })\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  public getJsonValue(widgetId: string): string | undefined {\r\n    const state = this.getWidgetStateProto(widgetId)\r\n    if (state != null && state.value === \"jsonValue\") {\r\n      return state.jsonValue\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  public setJsonValue(\r\n    widgetId: string,\r\n    value: number[],\r\n    source: Source\r\n  ): void {\r\n    this.getOrCreateWidgetStateProto(widgetId).jsonValue = JSON.stringify(\r\n      value\r\n    )\r\n    this.maybeSendUpdateWidgetsMessage(source)\r\n  }\r\n\r\n  private maybeSendUpdateWidgetsMessage(source: Source): void {\r\n    if (source.fromUi) {\r\n      this.sendUpdateWidgetsMessage()\r\n    }\r\n  }\r\n\r\n  public sendUpdateWidgetsMessage(): void {\r\n    this.sendBackMsg({ updateWidgets: this.createWigetStatesMsg() })\r\n  }\r\n\r\n  /**\r\n   * Remove the state of widgets that are not contained in `active_ids`.\r\n   */\r\n  public clean(active_ids: ImmutableSet<string>): void {\r\n    this.widgetStates.forEach((value, key) => {\r\n      if (!active_ids.includes(key)) {\r\n        this.deleteWidgetStateProto(key)\r\n      }\r\n    })\r\n  }\r\n\r\n  private createWigetStatesMsg(): WidgetStates {\r\n    const msg = new WidgetStates()\r\n    this.widgetStates.forEach(value => msg.widgets.push(value))\r\n    return msg\r\n  }\r\n\r\n  /**\r\n   * Returns the WidgetState proto for the widget with the given ID.\r\n   * If no such WidgetState exists yet, one will be created.\r\n   */\r\n  private getOrCreateWidgetStateProto(id: string): WidgetState {\r\n    let state = this.getWidgetStateProto(id)\r\n    if (state == null) {\r\n      state = new WidgetState({ id })\r\n      this.widgetStates.set(id, state)\r\n    }\r\n    return state\r\n  }\r\n\r\n  /**\r\n   * Removes the WidgetState proto with the given id, if it exists\r\n   */\r\n  private deleteWidgetStateProto(id: string): void {\r\n    this.widgetStates.delete(id)\r\n  }\r\n\r\n  private getWidgetStateProto(id: string): WidgetState | undefined {\r\n    return this.widgetStates.get(id)\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { Signal } from \"typed-signals\"\r\nimport { SessionEvent } from \"../autogen/proto\"\r\n\r\n/** Redispatches SessionEvent messages received from the server. */\r\nexport class SessionEventDispatcher {\r\n  /** Dispatched when a SessionEvent is received */\r\n  public readonly onSessionEvent = new Signal<(evt: SessionEvent) => void>()\r\n\r\n  /** Redispatches a ForwardMsg.SessionEvent via a signal. */\r\n  public handleSessionEventMsg(msg: SessionEvent): void {\r\n    this.onSessionEvent.emit(msg)\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { IS_DEV_ENV, IS_SHARED_REPORT } from \"./baseconsts\"\r\nimport { SessionInfo } from \"lib/SessionInfo\"\r\nimport { logAlways } from \"./log\"\r\n\r\n/**\r\n * The analytics is the Segment.io object. It comes from index.html.\r\n */\r\ndeclare const analytics: any\r\n\r\n/**\r\n * A mapping of [delta type] -> [count] which is used to upload delta stats\r\n * when the app is idle.\r\n */\r\ninterface DeltaCounter {\r\n  [name: string]: number\r\n}\r\n\r\n/**\r\n * A mapping of [component instance name] -> [count] which is used to upload\r\n * custom component stats when the app is idle.\r\n */\r\ninterface CustomComponentCounter {\r\n  [name: string]: number\r\n}\r\n\r\ntype Event = [string, Record<string, unknown>]\r\n\r\nexport class MetricsManager {\r\n  private initialized = false\r\n\r\n  /**\r\n   * Whether to send metrics to the server.\r\n   */\r\n  private actuallySendMetrics = false\r\n\r\n  /**\r\n   * Queue of metrics events that were enqueued before this MetricsManager was\r\n   * initialized.\r\n   */\r\n  private pendingEvents: Event[] = []\r\n\r\n  /**\r\n   * Object used to count the number of delta types seen in a given report.\r\n   * Maps type of delta (string) to count (number).\r\n   */\r\n  private pendingDeltaCounter: DeltaCounter = {}\r\n\r\n  /**\r\n   * Object used to count the number of custom instance names seen in a given report.\r\n   * Maps type of custom instance name (string) to count (number).\r\n   */\r\n  private pendingCustomComponentCounter: CustomComponentCounter = {}\r\n\r\n  /**\r\n   * Report hash uniquely identifies \"projects\" so we can tell\r\n   * how many projects are being created with Streamlit while still keeping\r\n   * possibly-sensitive info like the scriptPath outside of our metrics\r\n   * services.\r\n   */\r\n  private reportHash = \"Not initialized\"\r\n\r\n  /**\r\n   * Singleton MetricsManager object. The reason we're using a singleton here\r\n   * instead of just exporting a module-level instance is so we can easily\r\n   * override it in tests.\r\n   */\r\n  public static current: MetricsManager = new MetricsManager()\r\n\r\n  public initialize({\r\n    gatherUsageStats,\r\n  }: {\r\n    gatherUsageStats: boolean\r\n  }): void {\r\n    this.initialized = true\r\n    this.actuallySendMetrics = gatherUsageStats\r\n\r\n    if (this.actuallySendMetrics || IS_SHARED_REPORT) {\r\n      // Only record the user's email if they entered a non-empty one.\r\n      const userTraits: any = {}\r\n      if (SessionInfo.current.authorEmail !== \"\") {\r\n        userTraits[\"authoremail\"] = SessionInfo.current.authorEmail\r\n      }\r\n      this.identify(SessionInfo.current.installationId, userTraits)\r\n      this.sendPendingEvents()\r\n    }\r\n\r\n    logAlways(\"Gather usage stats: \", this.actuallySendMetrics)\r\n  }\r\n\r\n  public enqueue(evName: string, evData: Record<string, unknown> = {}): void {\r\n    if (!this.initialized) {\r\n      this.pendingEvents.push([evName, evData])\r\n      return\r\n    }\r\n\r\n    if (!this.actuallySendMetrics) {\r\n      return\r\n    }\r\n\r\n    this.send(evName, evData)\r\n  }\r\n\r\n  public clearDeltaCounter(): void {\r\n    this.pendingDeltaCounter = {}\r\n  }\r\n\r\n  public incrementDeltaCounter(deltaType: string): void {\r\n    if (this.pendingDeltaCounter[deltaType] == null) {\r\n      this.pendingDeltaCounter[deltaType] = 1\r\n    } else {\r\n      this.pendingDeltaCounter[deltaType]++\r\n    }\r\n  }\r\n\r\n  public getAndResetDeltaCounter(): DeltaCounter {\r\n    const deltaCounter = this.pendingDeltaCounter\r\n    this.clearDeltaCounter()\r\n    return deltaCounter\r\n  }\r\n\r\n  public clearCustomComponentCounter(): void {\r\n    this.pendingCustomComponentCounter = {}\r\n  }\r\n\r\n  public incrementCustomComponentCounter(customInstanceName: string): void {\r\n    if (this.pendingCustomComponentCounter[customInstanceName] == null) {\r\n      this.pendingCustomComponentCounter[customInstanceName] = 1\r\n    } else {\r\n      this.pendingCustomComponentCounter[customInstanceName]++\r\n    }\r\n  }\r\n\r\n  public getAndResetCustomComponentCounter(): CustomComponentCounter {\r\n    const customComponentCounter = this.pendingCustomComponentCounter\r\n    this.clearCustomComponentCounter()\r\n    return customComponentCounter\r\n  }\r\n\r\n  // Report hash gets set when update report happens.\r\n  // This means that it will be attached to most, but not all, metrics events.\r\n  // The viewReport and createReport events are sent before updateReport happens,\r\n  // so they will not include the reportHash.\r\n  public setReportHash = (reportHash: string): void => {\r\n    this.reportHash = reportHash\r\n  }\r\n\r\n  private send(evName: string, evData: Record<string, unknown> = {}): void {\r\n    const data = {\r\n      ...evData,\r\n      reportHash: this.reportHash,\r\n      dev: IS_DEV_ENV,\r\n      source: \"browser\",\r\n      streamlitVersion: SessionInfo.current.streamlitVersion,\r\n    }\r\n\r\n    // Don't actually track events when in dev mode, just print them instead.\r\n    // This is just to keep us from tracking too many events and having to pay\r\n    // for all of them.\r\n    if (IS_DEV_ENV) {\r\n      logAlways(\"[Dev mode] Not tracking stat datapoint: \", evName, data)\r\n    } else {\r\n      this.track(evName, data)\r\n    }\r\n  }\r\n\r\n  private sendPendingEvents(): void {\r\n    this.pendingEvents.forEach(([evName, evData]) => {\r\n      this.send(evName, evData)\r\n    })\r\n    this.pendingEvents = []\r\n  }\r\n\r\n  // Wrap analytics methods for mocking:\r\n\r\n  private identify(id: string, data: Record<string, unknown>): void {\r\n    analytics.identify(id, data)\r\n  }\r\n\r\n  private track(evName: string, data: Record<string, unknown>): void {\r\n    analytics.track(evName, data)\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport {\r\n  BlockPath,\r\n  Delta,\r\n  IForwardMsgMetadata,\r\n  NamedDataSet,\r\n} from \"autogen/proto\"\r\nimport { List, Map as ImmutableMap } from \"immutable\"\r\nimport { addRows } from \"lib/dataFrameProto\"\r\nimport { dispatchOneOf, toImmutableProto } from \"lib/immutableProto\"\r\nimport { MetricsManager } from \"lib/MetricsManager\"\r\nimport { requireNonNull } from \"lib/utils\"\r\n\r\ntype Container = \"main\" | \"sidebar\"\r\nexport type SimpleElement = ImmutableMap<string, any>\r\nexport interface BlockElement extends List<ReportElement> {}\r\n\r\nexport interface Elements {\r\n  main: BlockElement\r\n  sidebar: BlockElement\r\n}\r\n\r\nexport type ReportElement = ImmutableMap<string, any>\r\n\r\nexport function applyDelta(\r\n  elements: Elements,\r\n  reportId: string,\r\n  deltaMsg: Delta,\r\n  metadata: IForwardMsgMetadata | null | undefined\r\n): Elements {\r\n  if (!metadata) {\r\n    throw new Error(\"Delta metadata is required\")\r\n  }\r\n\r\n  const delta = toImmutableProto(Delta, deltaMsg)\r\n  const parentBlock = requireNonNull(metadata.parentBlock)\r\n  const parentBlockPath = requireNonNull(parentBlock.path)\r\n  const parentBlockContainer = requireNonNull(parentBlock.container)\r\n\r\n  const container =\r\n    parentBlockContainer === BlockPath.Container.MAIN ? \"main\" : \"sidebar\"\r\n  const deltaPath = [...parentBlockPath, metadata.deltaId]\r\n\r\n  dispatchOneOf(delta, \"type\", {\r\n    newElement: (element: SimpleElement) => {\r\n      const currentElement: ReportElement = elements[container].getIn(\r\n        deltaPath\r\n      )\r\n\r\n      elements[container] = elements[container].setIn(\r\n        deltaPath,\r\n        handleNewElementMessage(\r\n          container,\r\n          currentElement,\r\n          element,\r\n          reportId,\r\n          metadata\r\n        )\r\n      )\r\n    },\r\n    newBlock: () => {\r\n      elements[container] = elements[container].updateIn(\r\n        deltaPath,\r\n        reportElement => handleNewBlockMessage(container, reportElement)\r\n      )\r\n    },\r\n    addRows: (namedDataSet: NamedDataSet) => {\r\n      elements[container] = elements[container].updateIn(\r\n        deltaPath,\r\n        reportElement =>\r\n          handleAddRowsMessage(container, reportElement, namedDataSet)\r\n      )\r\n    },\r\n  })\r\n\r\n  return elements\r\n}\r\n\r\nfunction handleNewElementMessage(\r\n  container: Container,\r\n  reportElement: ReportElement,\r\n  element: SimpleElement,\r\n  reportId: string,\r\n  metadata: IForwardMsgMetadata\r\n): ReportElement {\r\n  MetricsManager.current.incrementDeltaCounter(container)\r\n  MetricsManager.current.incrementDeltaCounter(element.get(\"type\"))\r\n\r\n  // Track component instance name.\r\n  if (element.get(\"type\") === \"componentInstance\") {\r\n    const componentName = element.getIn([\"componentInstance\", \"componentName\"])\r\n    MetricsManager.current.incrementCustomComponentCounter(componentName)\r\n  }\r\n\r\n  // Set reportId on elements so we can clear old elements\r\n  // when the report script is re-executed.\r\n  // Set metadata on elements so that we can use them downstream.\r\n  if (reportElement && reportElement.get(\"element\").equals(element)) {\r\n    return reportElement.set(\"reportId\", reportId).set(\"metadata\", metadata)\r\n  }\r\n\r\n  return ImmutableMap({\r\n    reportId,\r\n    element,\r\n    metadata,\r\n  })\r\n}\r\n\r\nfunction handleNewBlockMessage(\r\n  container: Container,\r\n  reportElement: ReportElement\r\n): ReportElement {\r\n  MetricsManager.current.incrementDeltaCounter(container)\r\n  MetricsManager.current.incrementDeltaCounter(\"new block\")\r\n\r\n  if (reportElement.get(\"element\") instanceof List) {\r\n    return reportElement\r\n  }\r\n\r\n  return reportElement.set(\"element\", List())\r\n}\r\n\r\nfunction handleAddRowsMessage(\r\n  container: Container,\r\n  reportElement: ReportElement,\r\n  namedDataSet: NamedDataSet\r\n): ReportElement {\r\n  MetricsManager.current.incrementDeltaCounter(container)\r\n  MetricsManager.current.incrementDeltaCounter(\"add rows\")\r\n\r\n  return reportElement.update(\"element\", element =>\r\n    addRows(element, namedDataSet)\r\n  )\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { CancelToken } from \"axios\"\r\nimport HttpClient from \"lib/HttpClient\"\r\nimport { SessionInfo } from \"lib/SessionInfo\"\r\nimport { buildHttpUri } from \"lib/UriUtil\"\r\n\r\n/**\r\n * Handles uploading files to the server.\r\n */\r\nexport class FileUploadClient extends HttpClient {\r\n  /**\r\n   * Upload a file to the server. It will be associated with this browser's sessionID.\r\n   *\r\n   * @param widgetId: the ID of the FileUploader widget that's doing the upload.\r\n   * @param files: the files to upload.\r\n   * @param onUploadProgress: an optional function that will be called repeatedly with progress events during the upload.\r\n   * @param cancelToken: an optional axios CancelToken that can be used to cancel the in-progress upload.\r\n   */\r\n  public async uploadFiles(\r\n    widgetId: string,\r\n    files: File[],\r\n    onUploadProgress?: (progressEvent: any) => void,\r\n    cancelToken?: CancelToken\r\n  ): Promise<void> {\r\n    const serverURI = this.getServerUri()\r\n    if (serverURI === undefined) {\r\n      throw new Error(\"Cannot upload file: not connected to a server\")\r\n    }\r\n\r\n    const form = new FormData()\r\n    form.append(\"sessionId\", SessionInfo.current.sessionId)\r\n    form.append(\"widgetId\", widgetId)\r\n    for (const file of files) {\r\n      form.append(file.name, file)\r\n    }\r\n\r\n    await this.request({\r\n      cancelToken: cancelToken,\r\n      url: buildHttpUri(serverURI, \"upload_file\"),\r\n      method: \"POST\",\r\n      data: form,\r\n      onUploadProgress,\r\n    })\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport axios, { AxiosRequestConfig, AxiosResponse } from \"axios\"\r\nimport { BaseUriParts } from \"lib/UriUtil\"\r\nimport { getCookie } from \"lib/utils\"\r\n\r\n/**\r\n * Base class for HTTP Clients\r\n */\r\nexport default class HttpClient {\r\n  protected readonly getServerUri: () => BaseUriParts | undefined\r\n  protected readonly csrfEnabled: boolean\r\n\r\n  public constructor(\r\n    getServerUri: () => BaseUriParts | undefined,\r\n    csrfEnabled: boolean\r\n  ) {\r\n    this.getServerUri = getServerUri\r\n    this.csrfEnabled = csrfEnabled\r\n  }\r\n\r\n  /**\r\n   * Wrapper around axios.request to update the request config with\r\n   * CSRF headers if client has CSRF protection enabled.\r\n   */\r\n  public request(params: AxiosRequestConfig): Promise<AxiosResponse> {\r\n    if (this.csrfEnabled) {\r\n      const xsrf_cookie = getCookie(\"_xsrf\")\r\n      if (xsrf_cookie != null) {\r\n        params.headers = Object.assign(\r\n          { \"X-Xsrftoken\": xsrf_cookie },\r\n          params.headers || {}\r\n        )\r\n        params.withCredentials = true\r\n      }\r\n    }\r\n    return axios.request(params)\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nconst BLOB_TYPE = \"video/webm\"\r\n\r\ninterface ScreenCastRecorderOptions {\r\n  recordAudio: boolean\r\n}\r\n\r\nclass ScreenCastRecorder {\r\n  recordAudio: boolean\r\n  inputStream: MediaStream | null\r\n  recordedChunks: Blob[]\r\n  mediaRecorder: MediaRecorder | null\r\n\r\n  constructor({ recordAudio }: ScreenCastRecorderOptions) {\r\n    this.recordAudio = recordAudio\r\n\r\n    this.inputStream = null\r\n    this.recordedChunks = []\r\n\r\n    this.mediaRecorder = null\r\n  }\r\n\r\n  /**\r\n   * This asynchronous method will initialize the screen recording object asking\r\n   * for permissions to the user which are needed to start recording.\r\n   */\r\n  async initialize(): Promise<void> {\r\n    // @ts-ignore reason: https://github.com/microsoft/TypeScript/issues/33232\r\n    const desktopStream = await navigator.mediaDevices.getDisplayMedia({\r\n      video: true,\r\n    })\r\n\r\n    let tracks = desktopStream.getTracks()\r\n\r\n    if (this.recordAudio) {\r\n      const voiceStream = await navigator.mediaDevices.getUserMedia({\r\n        video: false,\r\n        audio: true,\r\n      })\r\n      tracks = tracks.concat(voiceStream.getAudioTracks())\r\n    }\r\n\r\n    this.recordedChunks = []\r\n\r\n    this.inputStream = new MediaStream(tracks)\r\n\r\n    this.mediaRecorder = new MediaRecorder(this.inputStream, {\r\n      mimeType: BLOB_TYPE,\r\n    })\r\n\r\n    this.mediaRecorder.ondataavailable = e => this.recordedChunks.push(e.data)\r\n  }\r\n\r\n  getState(): string {\r\n    if (this.mediaRecorder) {\r\n      return this.mediaRecorder.state\r\n    }\r\n\r\n    return \"inactive\"\r\n  }\r\n\r\n  /**\r\n   * This method will start the screen recording if the user has granted permissions\r\n   * and the mediaRecorder has been initialized\r\n   *\r\n   * @returns {boolean}\r\n   */\r\n  start(): boolean {\r\n    if (!this.mediaRecorder) {\r\n      return false\r\n    }\r\n\r\n    try {\r\n      this.mediaRecorder.start()\r\n    } catch (e) {\r\n      return false\r\n    }\r\n\r\n    return true\r\n  }\r\n\r\n  /**\r\n   * This method will stop recording and then return the generated Blob\r\n   *\r\n   * @returns {(Promise|undefined)}\r\n   *  A Promise which will return the generated Blob\r\n   *  Undefined if the MediaRecorder could not initialize\r\n   */\r\n  stop(): Promise<Blob> | undefined {\r\n    if (!this.mediaRecorder) {\r\n      return undefined\r\n    }\r\n\r\n    let resolver: () => void\r\n\r\n    const promise = new Promise(r => {\r\n      resolver = r\r\n    })\r\n\r\n    this.mediaRecorder.onstop = () => resolver()\r\n    this.mediaRecorder.stop()\r\n\r\n    if (this.inputStream) {\r\n      this.inputStream.getTracks().forEach(s => s.stop())\r\n      this.inputStream = null\r\n    }\r\n\r\n    return promise.then(() => this.buildOutputBlob())\r\n  }\r\n\r\n  buildOutputBlob(): Blob {\r\n    return new Blob(this.recordedChunks, { type: BLOB_TYPE })\r\n  }\r\n}\r\n\r\nexport default ScreenCastRecorder\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { ChangeEvent, PureComponent, ReactNode } from \"react\"\r\nimport { Button, Modal, ModalBody, ModalFooter, ModalHeader } from \"reactstrap\"\r\n\r\nexport interface Props {\r\n  /** Callback to close the dialog */\r\n  onClose: () => void\r\n\r\n  toggleRecordAudio: () => void\r\n\r\n  recordAudio: boolean\r\n\r\n  startRecording: () => void\r\n}\r\n\r\ninterface State {\r\n  recordAudio: boolean\r\n}\r\n\r\n/**\r\n * A dialog that allows a screencast to be configured and recorded.\r\n */\r\nclass ScreencastDialog extends PureComponent<Props, State> {\r\n  state = {\r\n    recordAudio: this.props.recordAudio,\r\n  }\r\n\r\n  handleRecordAudioCheckbox = (e: ChangeEvent<HTMLInputElement>): void => {\r\n    const { checked } = e.target\r\n    const { recordAudio } = this.state\r\n    const { toggleRecordAudio } = this.props\r\n\r\n    if (checked !== recordAudio) {\r\n      this.setState({ recordAudio: checked }, toggleRecordAudio)\r\n    }\r\n  }\r\n\r\n  handleStartButton = (): void => {\r\n    const { startRecording, onClose } = this.props\r\n\r\n    startRecording()\r\n    onClose()\r\n  }\r\n\r\n  public render = (): ReactNode => {\r\n    const { recordAudio } = this.state\r\n    const { onClose } = this.props\r\n\r\n    return (\r\n      <Modal isOpen={true} toggle={onClose} className=\"streamlit-dialog\">\r\n        <ModalHeader toggle={onClose}>Record a screencast</ModalHeader>\r\n        <ModalBody>\r\n          <p>\r\n            This will record a video with the contents of your screen, so you\r\n            can easily share what you're seeing with others.\r\n          </p>\r\n          <p>\r\n            <label style={{ margin: 0 }}>\r\n              <input\r\n                type=\"checkbox\"\r\n                name=\"recordAudio\"\r\n                checked={recordAudio}\r\n                onChange={this.handleRecordAudioCheckbox}\r\n              />{\" \"}\r\n              Also record audio\r\n            </label>\r\n          </p>\r\n          <p style={{ margin: 0 }}>\r\n            Press <kbd>Esc</kbd> any time to stop recording.\r\n          </p>\r\n        </ModalBody>\r\n        <ModalFooter>\r\n          <Button outline color=\"primary\" onClick={this.handleStartButton}>\r\n            Start recording!\r\n          </Button>\r\n        </ModalFooter>\r\n      </Modal>\r\n    )\r\n  }\r\n}\r\n\r\nexport default ScreencastDialog\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ReactNode } from \"react\"\r\nimport { Button, Modal, ModalBody, ModalHeader } from \"reactstrap\"\r\n\r\nimport \"./style.scss\"\r\n\r\nexport interface Props {\r\n  /** Callback to close the dialog */\r\n  onClose: () => void\r\n\r\n  videoBlob: Blob\r\n\r\n  fileName: string\r\n}\r\n\r\nclass VideoRecordedDialog extends PureComponent<Props> {\r\n  handleDownloadButton = (): void => {\r\n    const { onClose } = this.props\r\n\r\n    onClose()\r\n  }\r\n\r\n  getVideoSource = (): string => {\r\n    const { videoBlob } = this.props\r\n\r\n    return URL.createObjectURL(videoBlob)\r\n  }\r\n\r\n  public render = (): ReactNode => {\r\n    const { onClose, fileName } = this.props\r\n    const videoSource = this.getVideoSource()\r\n\r\n    return (\r\n      <Modal size=\"lg\" isOpen={true} className=\"streamlit-dialog screencast\">\r\n        <ModalHeader toggle={onClose}>Next steps</ModalHeader>\r\n        <ModalBody>\r\n          <div className=\"steps-container\">\r\n            <div className=\"first-column first-step\">Step 1</div>\r\n            <div className=\"second-column first-step\">\r\n              <p>Preview your video below:</p>\r\n              <video src={videoSource} controls />\r\n            </div>\r\n            <div className=\"third-column first-step\" />\r\n\r\n            <div className=\"first-column second-step\">Step 2</div>\r\n            <div className=\"second-column second-step\">\r\n              <Button\r\n                outline\r\n                color=\"primary\"\r\n                href={videoSource}\r\n                download={`${fileName}.webm.mp4`}\r\n                onClick={this.handleDownloadButton}\r\n                className=\"download-button\"\r\n              >\r\n                Save video to disk\r\n              </Button>\r\n              <p>\r\n                <small>\r\n                  This video is encoded in the{\" \"}\r\n                  <a href=\"https://www.webmproject.org/\">WebM format</a>, which\r\n                  is only supported by newer video players. You can also play\r\n                  it by dragging the file directly into your browser.\r\n                </small>\r\n              </p>\r\n            </div>\r\n\r\n            <div className=\"first-column third-step\">Step 3</div>\r\n            <div className=\"second-column third-step\">\r\n              Share your video with the world on Twitter, LinkedIn, YouTube, or\r\n              just plain email!{\" \"}\r\n              <span role=\"img\" aria-label=\"Happy\">\r\n                😀\r\n              </span>\r\n            </div>\r\n          </div>\r\n        </ModalBody>\r\n      </Modal>\r\n    )\r\n  }\r\n}\r\n\r\nexport default VideoRecordedDialog\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ReactNode } from \"react\"\r\nimport { Modal, ModalBody, ModalHeader } from \"reactstrap\"\r\n\r\nexport interface Props {\r\n  /** Callback to close the dialog */\r\n  onClose: () => void\r\n}\r\n\r\nclass UnsupportedBrowserDialog extends PureComponent<Props> {\r\n  public render = (): ReactNode => {\r\n    const { onClose } = this.props\r\n\r\n    return (\r\n      <Modal isOpen={true} toggle={onClose} className=\"streamlit-dialog\">\r\n        <ModalHeader toggle={onClose}>Record a screencast</ModalHeader>\r\n        <ModalBody>\r\n          <div className=\"screenCastWarningDialog\">\r\n            <span role=\"img\" aria-label=\"Alien Monster\">\r\n              👾\r\n            </span>\r\n            <p>\r\n              Due to limitations with some browsers, this feature is only\r\n              supported on recent desktop versions of Chrome, Firefox, and\r\n              Edge.\r\n            </p>\r\n          </div>\r\n        </ModalBody>\r\n      </Modal>\r\n    )\r\n  }\r\n}\r\n\r\nexport default UnsupportedBrowserDialog\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ReactNode } from \"react\"\r\n\r\nimport \"./Countdown.scss\"\r\n\r\ninterface Props {\r\n  countdown: number\r\n  endCallback: () => void\r\n}\r\n\r\ninterface State {\r\n  countdown: number\r\n}\r\n\r\nclass Countdown extends PureComponent<Props, State> {\r\n  public static defaultProps: Partial<Props> = {\r\n    endCallback: () => {},\r\n  }\r\n\r\n  state = {\r\n    countdown: this.props.countdown,\r\n  }\r\n\r\n  onAnimationEnd = async (): Promise<any> => {\r\n    const { countdown } = this.state\r\n    const { endCallback } = this.props\r\n    const newCountdown = countdown - 1\r\n\r\n    if (newCountdown >= 0) {\r\n      this.setState({\r\n        countdown: newCountdown,\r\n      })\r\n    }\r\n\r\n    if (newCountdown === 0) {\r\n      endCallback()\r\n    }\r\n  }\r\n\r\n  render(): ReactNode {\r\n    const { countdown }: State = this.state\r\n\r\n    return (\r\n      <div\r\n        className=\"countdown\"\r\n        onAnimationEnd={this.onAnimationEnd}\r\n        key={\"frame\" + countdown}\r\n      >\r\n        {/* The key forces DOM mutations, for animation to restart. */}\r\n        <span>{countdown}</span>\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default Countdown\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport WhichBrowser from \"which-browser\"\r\nimport ScreenCastRecorder from \"lib/ScreenCastRecorder\"\r\nimport hoistNonReactStatics from \"hoist-non-react-statics\"\r\nimport React, { PureComponent, ComponentType, ReactNode } from \"react\"\r\n\r\nimport {\r\n  UnsupportedBrowserDialog,\r\n  ScreencastDialog,\r\n  VideoRecordedDialog,\r\n} from \"hocs/withScreencast/components\"\r\nimport Countdown from \"components/core/Countdown\"\r\n\r\nexport type Steps =\r\n  | \"UNSUPPORTED\"\r\n  | \"OFF\"\r\n  | \"SETUP\"\r\n  | \"COUNTDOWN\"\r\n  | \"RECORDING\"\r\n  | \"PREVIEW_FILE\"\r\n\r\ninterface WithScreenCastProps {}\r\n\r\ninterface WithScreenCastState {\r\n  fileName: string\r\n  recordAudio: boolean\r\n  outputBlob?: Blob\r\n  currentState: Steps\r\n}\r\n\r\nexport interface ScreenCastHOC {\r\n  currentState: Steps\r\n  toggleRecordAudio: () => void\r\n  startRecording: (fileName: string) => void\r\n  stopRecording: () => void\r\n}\r\n\r\n// Supported browsers taken from https://caniuse.com/#search=getdisplaymedia\r\nconst SUPPORTED_BROWSERS: any = {\r\n  Chrome: \"72\",\r\n  Firefox: \"66\",\r\n  Opera: \"64\",\r\n  Edge: \"17\",\r\n}\r\n\r\nfunction withScreencast(\r\n  WrappedComponent: ComponentType<any>\r\n): ComponentType<any> {\r\n  class ComponentWithScreencast extends PureComponent<\r\n    WithScreenCastProps,\r\n    WithScreenCastState\r\n  > {\r\n    static readonly displayName = `withScreencast(${WrappedComponent.displayName ||\r\n      WrappedComponent.name})`\r\n\r\n    recorder?: ScreenCastRecorder | null\r\n\r\n    state = {\r\n      fileName: \"streamlit-screencast\",\r\n      recordAudio: false,\r\n      currentState: \"OFF\" as Steps,\r\n    }\r\n\r\n    toggleRecordAudio = (): void => {\r\n      const { recordAudio } = this.state\r\n\r\n      this.setState({\r\n        recordAudio: !recordAudio,\r\n      })\r\n    }\r\n\r\n    showDialog = (fileName: string): void => {\r\n      const { currentState } = this.state\r\n\r\n      if (!this.checkSupportedBrowser()) {\r\n        this.setState({\r\n          currentState: \"UNSUPPORTED\",\r\n        })\r\n      } else {\r\n        if (currentState === \"OFF\") {\r\n          this.setState({\r\n            fileName,\r\n            currentState: \"SETUP\",\r\n          })\r\n        } else {\r\n          this.stopRecording()\r\n        }\r\n      }\r\n    }\r\n\r\n    startRecording = async (): Promise<any> => {\r\n      const { recordAudio } = this.state\r\n\r\n      this.recorder = new ScreenCastRecorder({ recordAudio })\r\n\r\n      try {\r\n        await this.recorder.initialize()\r\n      } catch (e) {\r\n        // Just in case if there's something wrong when initializing the recorder\r\n        this.setState({\r\n          currentState: \"UNSUPPORTED\",\r\n        })\r\n      }\r\n\r\n      this.setState({\r\n        currentState: \"COUNTDOWN\",\r\n      })\r\n    }\r\n\r\n    stopRecording = async (): Promise<any> => {\r\n      let outputBlob\r\n      const { currentState } = this.state\r\n\r\n      // We should do nothing if the user try to stop recording when it is not started\r\n      if (currentState === \"OFF\" || this.recorder == null) {\r\n        return\r\n      }\r\n\r\n      if (currentState === \"COUNTDOWN\") {\r\n        this.setState({\r\n          currentState: \"OFF\",\r\n        })\r\n      }\r\n\r\n      if (\r\n        currentState === \"RECORDING\" &&\r\n        this.recorder.getState() !== \"inactive\"\r\n      ) {\r\n        outputBlob = await this.recorder.stop()\r\n\r\n        this.setState({\r\n          outputBlob,\r\n          currentState: \"PREVIEW_FILE\",\r\n        })\r\n      }\r\n    }\r\n\r\n    onCountdownEnd = async (): Promise<any> => {\r\n      if (this.recorder == null) {\r\n        // Should never happen.\r\n        throw new Error(\"Countdown finished but recorder is null\")\r\n      }\r\n\r\n      const hasStarted = this.recorder.start()\r\n\r\n      if (hasStarted) {\r\n        this.setState({\r\n          currentState: \"RECORDING\",\r\n        })\r\n      } else {\r\n        this.stopRecording()\r\n      }\r\n    }\r\n\r\n    getScreenCastProps = (): ScreenCastHOC => ({\r\n      currentState: this.state.currentState,\r\n      toggleRecordAudio: this.toggleRecordAudio,\r\n      startRecording: this.showDialog,\r\n      stopRecording: this.stopRecording,\r\n    })\r\n\r\n    closeDialog = (): void => {\r\n      this.setState({\r\n        currentState: \"OFF\",\r\n      })\r\n    }\r\n\r\n    checkSupportedBrowser = (): boolean => {\r\n      if (\r\n        !navigator.mediaDevices ||\r\n        !navigator.mediaDevices.getUserMedia ||\r\n        // @ts-ignore reason: https://github.com/microsoft/TypeScript/issues/33232\r\n        !navigator.mediaDevices.getDisplayMedia\r\n      ) {\r\n        return false\r\n      }\r\n\r\n      const whichBrowser = new WhichBrowser(navigator.userAgent)\r\n\r\n      const result = Object.keys(SUPPORTED_BROWSERS).map(browser => {\r\n        const browserVersion = SUPPORTED_BROWSERS[browser]\r\n\r\n        return whichBrowser.isBrowser(browser, \">=\", browserVersion)\r\n      })\r\n\r\n      return result.some(supported => supported)\r\n    }\r\n\r\n    render(): ReactNode {\r\n      const {\r\n        outputBlob,\r\n        fileName,\r\n        recordAudio,\r\n        currentState,\r\n      }: WithScreenCastState = this.state\r\n\r\n      return (\r\n        <div className=\"withScreencast\">\r\n          <WrappedComponent screenCast={this.getScreenCastProps()} />\r\n\r\n          {currentState === \"UNSUPPORTED\" && (\r\n            <UnsupportedBrowserDialog onClose={this.closeDialog} />\r\n          )}\r\n\r\n          {currentState === \"SETUP\" && (\r\n            <ScreencastDialog\r\n              recordAudio={recordAudio}\r\n              onClose={this.closeDialog}\r\n              startRecording={this.startRecording}\r\n              toggleRecordAudio={this.toggleRecordAudio}\r\n            />\r\n          )}\r\n\r\n          {currentState === \"COUNTDOWN\" && (\r\n            <Countdown countdown={3} endCallback={this.onCountdownEnd} />\r\n          )}\r\n\r\n          {currentState === \"PREVIEW_FILE\" && outputBlob && (\r\n            <VideoRecordedDialog\r\n              onClose={this.closeDialog}\r\n              videoBlob={outputBlob}\r\n              fileName={fileName}\r\n            />\r\n          )}\r\n        </div>\r\n      )\r\n    }\r\n  }\r\n\r\n  // Static methods must be copied over\r\n  // https://en.reactjs.org/docs/higher-order-components.html#static-methods-must-be-copied-over\r\n  return hoistNonReactStatics(ComponentWithScreencast, WrappedComponent)\r\n}\r\n\r\nexport default withScreencast\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { Fragment, PureComponent, ReactNode } from \"react\"\r\nimport moment from \"moment\"\r\nimport { HotKeys } from \"react-hotkeys\"\r\nimport { fromJS, List } from \"immutable\"\r\nimport classNames from \"classnames\"\r\n// Other local imports.\r\nimport ReportView from \"components/core/ReportView/\"\r\nimport { StatusWidget } from \"components/core/StatusWidget/\"\r\nimport MainMenu from \"components/core/MainMenu/\"\r\nimport {\r\n  DialogProps,\r\n  DialogType,\r\n  StreamlitDialog,\r\n} from \"components/core/StreamlitDialog/\"\r\nimport { ConnectionManager } from \"lib/ConnectionManager\"\r\nimport { WidgetStateManager } from \"lib/WidgetStateManager\"\r\nimport { ConnectionState } from \"lib/ConnectionState\"\r\nimport { ReportRunState } from \"lib/ReportRunState\"\r\nimport { SessionEventDispatcher } from \"lib/SessionEventDispatcher\"\r\nimport {\r\n  applyDelta,\r\n  BlockElement,\r\n  Elements,\r\n  ReportElement,\r\n  SimpleElement,\r\n} from \"lib/DeltaParser\"\r\nimport { setCookie } from \"lib/utils\"\r\nimport {\r\n  BackMsg,\r\n  Delta,\r\n  ForwardMsg,\r\n  IBackMsg,\r\n  IForwardMsgMetadata,\r\n  Initialize,\r\n  ISessionState,\r\n  NewReport,\r\n  SessionEvent,\r\n} from \"autogen/proto\"\r\n\r\nimport { RERUN_PROMPT_MODAL_DIALOG } from \"lib/baseconsts\"\r\nimport { SessionInfo } from \"lib/SessionInfo\"\r\nimport { MetricsManager } from \"lib/MetricsManager\"\r\nimport { FileUploadClient } from \"lib/FileUploadClient\"\r\nimport {\r\n  flattenElements,\r\n  hashString,\r\n  isEmbeddedInIFrame,\r\n  makeElementWithInfoText,\r\n} from \"lib/utils\"\r\nimport { logError, logMessage } from \"lib/log\"\r\n// WARNING: order matters\r\nimport \"assets/css/theme.scss\"\r\nimport \"./App.scss\"\r\nimport \"assets/css/header.scss\"\r\nimport { UserSettings } from \"components/core/StreamlitDialog/UserSettings\"\r\nimport { ComponentRegistry } from \"./components/widgets/CustomComponent\"\r\n\r\nimport withScreencast, {\r\n  ScreenCastHOC,\r\n} from \"./hocs/withScreencast/withScreencast\"\r\n\r\nexport interface Props {\r\n  screenCast: ScreenCastHOC\r\n}\r\n\r\ninterface State {\r\n  connectionState: ConnectionState\r\n  elements: Elements\r\n  reportId: string\r\n  reportName: string\r\n  reportHash: string | null\r\n  reportRunState: ReportRunState\r\n  userSettings: UserSettings\r\n  dialog?: DialogProps | null\r\n  sharingEnabled?: boolean\r\n}\r\n\r\nconst ELEMENT_LIST_BUFFER_TIMEOUT_MS = 10\r\n\r\ndeclare global {\r\n  interface Window {\r\n    streamlitDebug: any\r\n  }\r\n}\r\n\r\nexport class App extends PureComponent<Props, State> {\r\n  private readonly sessionEventDispatcher: SessionEventDispatcher\r\n  private readonly statusWidgetRef: React.RefObject<StatusWidget>\r\n  private connectionManager: ConnectionManager | null\r\n  private readonly widgetMgr: WidgetStateManager\r\n  private readonly uploadClient: FileUploadClient\r\n  private elementListBuffer: Elements | null\r\n  private elementListBufferTimerIsSet: boolean\r\n  private readonly componentRegistry: ComponentRegistry\r\n\r\n  constructor(props: Props) {\r\n    super(props)\r\n\r\n    this.state = {\r\n      connectionState: ConnectionState.INITIAL,\r\n      elements: {\r\n        main: fromJS([\r\n          {\r\n            element: makeElementWithInfoText(\"Please wait...\"),\r\n            metadata: {},\r\n            reportId: \"no report\",\r\n          },\r\n        ]),\r\n        sidebar: fromJS([]),\r\n      },\r\n      reportName: \"\",\r\n      reportId: \"<null>\",\r\n      reportHash: null,\r\n      reportRunState: ReportRunState.NOT_RUNNING,\r\n      userSettings: {\r\n        wideMode: false,\r\n        runOnSave: false,\r\n      },\r\n    }\r\n\r\n    this.sessionEventDispatcher = new SessionEventDispatcher()\r\n    this.statusWidgetRef = React.createRef<StatusWidget>()\r\n    this.connectionManager = null\r\n    this.widgetMgr = new WidgetStateManager((msg: IBackMsg) => {\r\n      this.sendBackMsg(new BackMsg(msg))\r\n    })\r\n    this.uploadClient = new FileUploadClient(() => {\r\n      return this.connectionManager\r\n        ? this.connectionManager.getBaseUriParts()\r\n        : undefined\r\n    }, true)\r\n    this.componentRegistry = new ComponentRegistry(() => {\r\n      return this.connectionManager\r\n        ? this.connectionManager.getBaseUriParts()\r\n        : undefined\r\n    })\r\n    this.elementListBufferTimerIsSet = false\r\n    this.elementListBuffer = null\r\n\r\n    window.streamlitDebug = {}\r\n    window.streamlitDebug.closeConnection = this.closeConnection.bind(this)\r\n  }\r\n\r\n  /**\r\n   * Global keyboard shortcuts.\r\n   */\r\n  keyHandlers = {\r\n    // The r key reruns the script.\r\n    r: (): void => this.rerunScript(),\r\n\r\n    // The c key clears the cache.\r\n    c: (): void => this.openClearCacheDialog(),\r\n\r\n    esc: this.props.screenCast.stopRecording,\r\n  }\r\n\r\n  componentDidMount(): void {\r\n    // Initialize connection manager here, to avoid\r\n    // \"Can't call setState on a component that is not yet mounted.\" error.\r\n    this.connectionManager = new ConnectionManager({\r\n      onMessage: this.handleMessage,\r\n      onConnectionError: this.handleConnectionError,\r\n      connectionStateChanged: this.handleConnectionStateChanged,\r\n    })\r\n\r\n    if (isEmbeddedInIFrame()) {\r\n      document.body.classList.add(\"embedded\")\r\n    }\r\n\r\n    MetricsManager.current.enqueue(\"viewReport\")\r\n  }\r\n\r\n  showError(title: string, errorNode: ReactNode): void {\r\n    logError(errorNode)\r\n    const newDialog: DialogProps = {\r\n      type: DialogType.WARNING,\r\n      title: title,\r\n      msg: errorNode,\r\n      onClose: () => {},\r\n    }\r\n    this.openDialog(newDialog)\r\n  }\r\n\r\n  /**\r\n   * Checks if the code version from the backend is different than the frontend\r\n   */\r\n  hasStreamlitVersionChanged(initializeMsg: Initialize): boolean {\r\n    if (SessionInfo.isSet()) {\r\n      const { streamlitVersion: currentStreamlitVersion } = SessionInfo.current\r\n      const { environmentInfo } = initializeMsg\r\n\r\n      if (\r\n        environmentInfo != null &&\r\n        environmentInfo.streamlitVersion != null\r\n      ) {\r\n        return currentStreamlitVersion < environmentInfo.streamlitVersion\r\n      }\r\n    }\r\n\r\n    return false\r\n  }\r\n\r\n  /**\r\n   * Called by ConnectionManager when our connection state changes\r\n   */\r\n  handleConnectionStateChanged = (newState: ConnectionState): void => {\r\n    logMessage(\r\n      `Connection state changed from ${this.state.connectionState} to ${newState}`\r\n    )\r\n\r\n    this.setState({ connectionState: newState })\r\n\r\n    if (newState === ConnectionState.CONNECTED) {\r\n      logMessage(\r\n        \"Reconnected to server; Requesting a run (which may be preheated)\"\r\n      )\r\n      this.widgetMgr.sendUpdateWidgetsMessage()\r\n      this.setState({ dialog: null })\r\n    } else {\r\n      setCookie(\"_xsrf\", \"\")\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Callback when we get a message from the server.\r\n   */\r\n  handleMessage = (msgProto: ForwardMsg): void => {\r\n    // We don't have an immutableProto here, so we can't use\r\n    // the dispatchOneOf helper\r\n    const dispatchProto = (obj: any, name: string, funcs: any): any => {\r\n      const whichOne = obj[name]\r\n      if (whichOne in funcs) {\r\n        return funcs[whichOne](obj[whichOne])\r\n      } else {\r\n        throw new Error(`Cannot handle ${name} \"${whichOne}\".`)\r\n      }\r\n    }\r\n\r\n    try {\r\n      dispatchProto(msgProto, \"type\", {\r\n        initialize: (initializeMsg: Initialize) =>\r\n          this.handleInitialize(initializeMsg),\r\n        sessionStateChanged: (msg: ISessionState) =>\r\n          this.handleSessionStateChanged(msg),\r\n        sessionEvent: (evtMsg: SessionEvent) =>\r\n          this.handleSessionEvent(evtMsg),\r\n        newReport: (newReportMsg: NewReport) =>\r\n          this.handleNewReport(newReportMsg),\r\n        delta: (deltaMsg: Delta) =>\r\n          this.handleDeltaMsg(deltaMsg, msgProto.metadata),\r\n        reportFinished: (status: ForwardMsg.ReportFinishedStatus) =>\r\n          this.handleReportFinished(status),\r\n        uploadReportProgress: (progress: string | number) =>\r\n          this.handleUploadReportProgress(progress),\r\n        reportUploaded: (url: string) => this.handleReportUploaded(url),\r\n      })\r\n    } catch (err) {\r\n      logError(err)\r\n      this.showError(\"Bad message format\", err.message)\r\n    }\r\n  }\r\n\r\n  handleUploadReportProgress = (progress: string | number): void => {\r\n    const newDialog: DialogProps = {\r\n      type: DialogType.UPLOAD_PROGRESS,\r\n      progress: progress,\r\n      onClose: () => {},\r\n    }\r\n    this.openDialog(newDialog)\r\n  }\r\n\r\n  handleReportUploaded = (url: string): void => {\r\n    const newDialog: DialogProps = {\r\n      type: DialogType.UPLOADED,\r\n      url: url,\r\n      onClose: () => {},\r\n    }\r\n    this.openDialog(newDialog)\r\n  }\r\n\r\n  /**\r\n   * Handler for ForwardMsg.initialize messages\r\n   * @param initializeMsg an Initialize protobuf\r\n   */\r\n\r\n  handleInitialize = (initializeMsg: Initialize): void => {\r\n    const {\r\n      sessionId,\r\n      environmentInfo,\r\n      userInfo,\r\n      config,\r\n      sessionState,\r\n    } = initializeMsg\r\n\r\n    if (\r\n      sessionId == null ||\r\n      !environmentInfo ||\r\n      !userInfo ||\r\n      !config ||\r\n      !sessionState\r\n    ) {\r\n      throw new Error(\"InitializeMsg is missing a required field\")\r\n    }\r\n\r\n    if (this.hasStreamlitVersionChanged(initializeMsg)) {\r\n      window.location.reload()\r\n\r\n      return\r\n    }\r\n\r\n    SessionInfo.current = new SessionInfo({\r\n      sessionId: sessionId,\r\n      streamlitVersion: environmentInfo.streamlitVersion,\r\n      pythonVersion: environmentInfo.pythonVersion,\r\n      installationId: userInfo.installationId,\r\n      authorEmail: userInfo.email,\r\n      maxCachedMessageAge: config.maxCachedMessageAge,\r\n      commandLine: initializeMsg.commandLine,\r\n      userMapboxToken: config.mapboxToken,\r\n    })\r\n\r\n    MetricsManager.current.initialize({\r\n      gatherUsageStats: Boolean(config.gatherUsageStats),\r\n    })\r\n\r\n    MetricsManager.current.enqueue(\"createReport\", {\r\n      pythonVersion: SessionInfo.current.pythonVersion,\r\n    })\r\n\r\n    this.setState({\r\n      sharingEnabled: Boolean(config.sharingEnabled),\r\n    })\r\n\r\n    this.handleSessionStateChanged(sessionState)\r\n  }\r\n\r\n  /**\r\n   * Handler for ForwardMsg.sessionStateChanged messages\r\n   * @param stateChangeProto a SessionState protobuf\r\n   */\r\n  handleSessionStateChanged = (stateChangeProto: ISessionState): void => {\r\n    this.setState((prevState: State) => {\r\n      // Determine our new ReportRunState\r\n      let reportRunState = prevState.reportRunState\r\n      let dialog = prevState.dialog\r\n\r\n      if (\r\n        stateChangeProto.reportIsRunning &&\r\n        prevState.reportRunState !== ReportRunState.STOP_REQUESTED\r\n      ) {\r\n        // If the report is running, we change our ReportRunState only\r\n        // if we don't have a pending stop request\r\n        reportRunState = ReportRunState.RUNNING\r\n\r\n        // If the scriptCompileError dialog is open and the report starts\r\n        // running, close it.\r\n        if (\r\n          dialog != null &&\r\n          dialog.type === DialogType.SCRIPT_COMPILE_ERROR\r\n        ) {\r\n          dialog = undefined\r\n        }\r\n      } else if (\r\n        !stateChangeProto.reportIsRunning &&\r\n        prevState.reportRunState !== ReportRunState.RERUN_REQUESTED &&\r\n        prevState.reportRunState !== ReportRunState.COMPILATION_ERROR\r\n      ) {\r\n        // If the report is not running, we change our ReportRunState only\r\n        // if we don't have a pending rerun request, and we don't have\r\n        // a script compilation failure\r\n        reportRunState = ReportRunState.NOT_RUNNING\r\n\r\n        MetricsManager.current.enqueue(\r\n          \"deltaStats\",\r\n          MetricsManager.current.getAndResetDeltaCounter()\r\n        )\r\n\r\n        const customComponentCounter = MetricsManager.current.getAndResetCustomComponentCounter()\r\n        Object.entries(customComponentCounter).forEach(([name, count]) => {\r\n          MetricsManager.current.enqueue(\"customComponentStats\", {\r\n            name,\r\n            count,\r\n          })\r\n        })\r\n      }\r\n\r\n      return {\r\n        userSettings: {\r\n          ...prevState.userSettings,\r\n          runOnSave: Boolean(stateChangeProto.runOnSave),\r\n        },\r\n        dialog,\r\n        reportRunState,\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Handler for ForwardMsg.sessionEvent messages\r\n   * @param sessionEvent a SessionEvent protobuf\r\n   */\r\n  handleSessionEvent = (sessionEvent: SessionEvent): void => {\r\n    this.sessionEventDispatcher.handleSessionEventMsg(sessionEvent)\r\n    if (sessionEvent.type === \"scriptCompilationException\") {\r\n      this.setState({ reportRunState: ReportRunState.COMPILATION_ERROR })\r\n      const newDialog: DialogProps = {\r\n        type: DialogType.SCRIPT_COMPILE_ERROR,\r\n        exception: sessionEvent.scriptCompilationException,\r\n        onClose: () => {},\r\n      }\r\n      this.openDialog(newDialog)\r\n    } else if (\r\n      RERUN_PROMPT_MODAL_DIALOG &&\r\n      sessionEvent.type === \"reportChangedOnDisk\"\r\n    ) {\r\n      const newDialog: DialogProps = {\r\n        type: DialogType.SCRIPT_CHANGED,\r\n        onRerun: this.rerunScript,\r\n        onClose: () => {},\r\n      }\r\n      this.openDialog(newDialog)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handler for ForwardMsg.newReport messages\r\n   * @param newReportProto a NewReport protobuf\r\n   */\r\n  handleNewReport = (newReportProto: NewReport): void => {\r\n    const { reportHash } = this.state\r\n    const { id: reportId, name: reportName, scriptPath } = newReportProto\r\n\r\n    const newReportHash = hashString(\r\n      SessionInfo.current.installationId + scriptPath\r\n    )\r\n\r\n    document.title = `${reportName} · Streamlit`\r\n\r\n    MetricsManager.current.setReportHash(newReportHash)\r\n    MetricsManager.current.clearDeltaCounter()\r\n\r\n    MetricsManager.current.enqueue(\"updateReport\")\r\n\r\n    if (reportHash === newReportHash) {\r\n      this.setState({\r\n        reportId,\r\n      })\r\n    } else {\r\n      this.clearAppState(newReportHash, reportId, reportName)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handler for ForwardMsg.reportFinished messages\r\n   * @param status the ReportFinishedStatus that the report finished with\r\n   */\r\n  handleReportFinished(status: ForwardMsg.ReportFinishedStatus): void {\r\n    if (status === ForwardMsg.ReportFinishedStatus.FINISHED_SUCCESSFULLY) {\r\n      // Clear any stale elements left over from the previous run.\r\n      // (We don't do this if our script had a compilation error and didn't\r\n      // finish successfully.)\r\n      this.setState(\r\n        ({ elements, reportId }) => ({\r\n          elements: {\r\n            main: this.clearOldElements(elements.main, reportId),\r\n            sidebar: this.clearOldElements(elements.sidebar, reportId),\r\n          },\r\n        }),\r\n        () => {\r\n          this.elementListBuffer = this.state.elements\r\n        }\r\n      )\r\n\r\n      // This step removes from the WidgetManager the state of those widgets\r\n      // that are not shown on the page.\r\n      if (this.elementListBuffer) {\r\n        const active_widget_ids = flattenElements(this.elementListBuffer.main)\r\n          .union(flattenElements(this.elementListBuffer.sidebar))\r\n          .map((e: SimpleElement) => {\r\n            const type = e.get(\"type\")\r\n            return e.get(type).get(\"id\") as string\r\n          })\r\n          .filter(id => id != null)\r\n        this.widgetMgr.clean(active_widget_ids)\r\n      }\r\n\r\n      // Tell the ConnectionManager to increment the message cache run\r\n      // count. This will result in expired ForwardMsgs being removed from\r\n      // the cache.\r\n      if (this.connectionManager !== null) {\r\n        this.connectionManager.incrementMessageCacheRunCount(\r\n          SessionInfo.current.maxCachedMessageAge\r\n        )\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Removes old elements. The term old is defined as:\r\n   *  - simple elements whose reportIds are no longer current\r\n   *  - empty block elements\r\n   */\r\n  clearOldElements = (elements: any, reportId: string): BlockElement => {\r\n    return elements\r\n      .map((reportElement: ReportElement) => {\r\n        const simpleElement = reportElement.get(\"element\")\r\n\r\n        if (simpleElement instanceof List) {\r\n          const clearedElements = this.clearOldElements(\r\n            simpleElement,\r\n            reportId\r\n          )\r\n          return clearedElements.size > 0 ? clearedElements : null\r\n        }\r\n\r\n        return reportElement.get(\"reportId\") === reportId\r\n          ? reportElement\r\n          : null\r\n      })\r\n      .filter((reportElement: any) => reportElement !== null)\r\n  }\r\n\r\n  /*\r\n   * Clear all elements from the state.\r\n   */\r\n  clearAppState(\r\n    reportHash: string,\r\n    reportId: string,\r\n    reportName: string\r\n  ): void {\r\n    this.setState(\r\n      {\r\n        reportId,\r\n        reportName,\r\n        reportHash,\r\n        elements: {\r\n          main: fromJS([]),\r\n          sidebar: fromJS([]),\r\n        },\r\n      },\r\n      () => {\r\n        this.elementListBuffer = this.state.elements\r\n        this.widgetMgr.clean(fromJS([]))\r\n      }\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Opens a dialog with the specified state.\r\n   */\r\n  openDialog(dialogProps: DialogProps): void {\r\n    this.setState({ dialog: dialogProps })\r\n  }\r\n\r\n  /**\r\n   * Closes the upload dialog if it's open.\r\n   */\r\n  closeDialog = (): void => {\r\n    // HACK: Remove modal-open class that Bootstrap uses to hide scrollbars\r\n    // when a modal is open. Otherwise, when the user causes a syntax error in\r\n    // Python and we show an \"Error\" modal, and then the user presses \"R\" while\r\n    // that modal is showing, this causes \"modal-open\" to *not* be removed\r\n    // properly from <body>, thereby breaking scrolling. This seems to be\r\n    // related to the modal-close animation taking too long.\r\n    document.body.classList.remove(\"modal-open\")\r\n\r\n    this.setState({ dialog: undefined })\r\n  }\r\n\r\n  /**\r\n   * Saves a UserSettings object.\r\n   */\r\n  saveSettings = (newSettings: UserSettings): void => {\r\n    const prevRunOnSave = this.state.userSettings.runOnSave\r\n    const runOnSave = newSettings.runOnSave\r\n\r\n    this.setState({ userSettings: newSettings })\r\n\r\n    if (prevRunOnSave !== runOnSave && this.isServerConnected()) {\r\n      const backMsg = new BackMsg({ setRunOnSave: runOnSave })\r\n      backMsg.type = \"setRunOnSave\"\r\n      this.sendBackMsg(backMsg)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Updates elementListBuffer with the given delta, and sets up a timer to\r\n   * update the elementList in the state as well. This buffer allows us to\r\n   * receive deltas extremely quickly without spamming React with lots of\r\n   * render() calls.\r\n   */\r\n  handleDeltaMsg = (\r\n    deltaMsg: Delta,\r\n    metadataMsg: IForwardMsgMetadata | undefined | null\r\n  ): void => {\r\n    this.elementListBuffer = applyDelta(\r\n      this.state.elements,\r\n      this.state.reportId,\r\n      deltaMsg,\r\n      metadataMsg\r\n    )\r\n\r\n    if (!this.elementListBufferTimerIsSet) {\r\n      this.elementListBufferTimerIsSet = true\r\n\r\n      // (BUG #685) When user presses stop, stop adding elements to\r\n      // report immediately to avoid race condition.\r\n      // The one exception is static connections, which do not depend on\r\n      // the report state (and don't have a stop button).\r\n      const isStaticConnection = this.connectionManager\r\n        ? this.connectionManager.isStaticConnection()\r\n        : false\r\n      const reportIsRunning =\r\n        this.state.reportRunState === ReportRunState.RUNNING\r\n\r\n      setTimeout(() => {\r\n        this.elementListBufferTimerIsSet = false\r\n        if (isStaticConnection || reportIsRunning) {\r\n          // Create brand new `elements` instance, so components that depend on\r\n          // this for re-rendering catch the change.\r\n          if (this.elementListBuffer) {\r\n            const elements: Elements = {\r\n              ...this.elementListBuffer,\r\n            }\r\n            this.setState({ elements: elements })\r\n          }\r\n        }\r\n      }, ELEMENT_LIST_BUFFER_TIMEOUT_MS)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Used by e2e tests to test disabling widgets\r\n   */\r\n  closeConnection(): void {\r\n    if (this.isServerConnected()) {\r\n      const backMsg = new BackMsg({ closeConnection: true })\r\n      backMsg.type = \"closeConnection\"\r\n      this.sendBackMsg(backMsg)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Callback to call when we want to share the report.\r\n   */\r\n  shareReport = (): void => {\r\n    if (this.isServerConnected()) {\r\n      if (this.state.sharingEnabled) {\r\n        MetricsManager.current.enqueue(\"shareReport\")\r\n        const backMsg = new BackMsg({ cloudUpload: true })\r\n        backMsg.type = \"cloudUpload\"\r\n        this.sendBackMsg(backMsg)\r\n      } else {\r\n        const newDialog: DialogProps = {\r\n          type: DialogType.WARNING,\r\n          title: \"Error sharing app\",\r\n          msg: (\r\n            <Fragment>\r\n              <div>You do not have sharing configured.</div>\r\n              <div>\r\n                Please contact{\" \"}\r\n                <a href=\"mailto:hello@streamlit.io\">Streamlit Support</a> to\r\n                setup sharing.\r\n              </div>\r\n            </Fragment>\r\n          ),\r\n          onClose: () => {},\r\n        }\r\n        this.openDialog(newDialog)\r\n      }\r\n    } else {\r\n      logError(\"Cannot save app when disconnected from server\")\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reruns the script.\r\n   *\r\n   * @param alwaysRunOnSave a boolean. If true, UserSettings.runOnSave\r\n   * will be set to true, which will result in a request to the Server\r\n   * to enable runOnSave for this report.\r\n   */\r\n  rerunScript = (alwaysRunOnSave = false): void => {\r\n    this.closeDialog()\r\n\r\n    if (!this.isServerConnected()) {\r\n      logError(\"Cannot rerun script when disconnected from server.\")\r\n      return\r\n    }\r\n\r\n    if (\r\n      this.state.reportRunState === ReportRunState.RUNNING ||\r\n      this.state.reportRunState === ReportRunState.RERUN_REQUESTED\r\n    ) {\r\n      // Don't queue up multiple rerunScript requests\r\n      return\r\n    }\r\n\r\n    MetricsManager.current.enqueue(\"rerunScript\")\r\n\r\n    this.setState({ reportRunState: ReportRunState.RERUN_REQUESTED })\r\n\r\n    // Note: `rerunScript` is incorrectly called in some places.\r\n    // We can remove `=== true` after adding type information\r\n    if (alwaysRunOnSave === true) {\r\n      // Update our run-on-save setting *before* calling rerunScript.\r\n      // The rerunScript message currently blocks all BackMsgs from\r\n      // being processed until the script has completed executing.\r\n      this.saveSettings({ ...this.state.userSettings, runOnSave: true })\r\n    }\r\n\r\n    const backMsg = new BackMsg({ rerunScript: true })\r\n    backMsg.type = \"rerunScript\"\r\n    this.sendBackMsg(backMsg)\r\n  }\r\n\r\n  /** Requests that the server stop running the report */\r\n  stopReport = (): void => {\r\n    if (!this.isServerConnected()) {\r\n      logError(\"Cannot stop app when disconnected from server.\")\r\n      return\r\n    }\r\n\r\n    if (\r\n      this.state.reportRunState === ReportRunState.NOT_RUNNING ||\r\n      this.state.reportRunState === ReportRunState.STOP_REQUESTED\r\n    ) {\r\n      // Don't queue up multiple stopReport requests\r\n      return\r\n    }\r\n\r\n    const backMsg = new BackMsg({ stopReport: true })\r\n    backMsg.type = \"stopReport\"\r\n    this.sendBackMsg(backMsg)\r\n    this.setState({ reportRunState: ReportRunState.STOP_REQUESTED })\r\n  }\r\n\r\n  /**\r\n   * Shows a dialog asking the user to confirm they want to clear the cache\r\n   */\r\n  openClearCacheDialog = (): void => {\r\n    if (this.isServerConnected()) {\r\n      const newDialog: DialogProps = {\r\n        type: DialogType.CLEAR_CACHE,\r\n        confirmCallback: this.clearCache,\r\n        defaultAction: this.clearCache,\r\n        onClose: () => {},\r\n      }\r\n      // This will be called if enter is pressed.\r\n      this.openDialog(newDialog)\r\n    } else {\r\n      logError(\"Cannot clear cache: disconnected from server\")\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Asks the server to clear the st_cache\r\n   */\r\n  clearCache = (): void => {\r\n    this.closeDialog()\r\n    if (this.isServerConnected()) {\r\n      MetricsManager.current.enqueue(\"clearCache\")\r\n      const backMsg = new BackMsg({ clearCache: true })\r\n      backMsg.type = \"clearCache\"\r\n      this.sendBackMsg(backMsg)\r\n    } else {\r\n      logError(\"Cannot clear cache: disconnected from server\")\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sends a message back to the server.\r\n   */\r\n  private sendBackMsg = (msg: BackMsg): void => {\r\n    if (this.connectionManager) {\r\n      logMessage(msg)\r\n      this.connectionManager.sendMessage(msg)\r\n    } else {\r\n      logError(`Not connected. Cannot send back message: ${msg}`)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Updates the report body when there's a connection error.\r\n   */\r\n  handleConnectionError = (errNode: ReactNode): void => {\r\n    this.showError(\"Connection error\", errNode)\r\n  }\r\n\r\n  /**\r\n   * Indicates whether we're connected to the server.\r\n   */\r\n  isServerConnected = (): boolean => {\r\n    return this.connectionManager\r\n      ? this.connectionManager.isConnected()\r\n      : false\r\n  }\r\n\r\n  settingsCallback = (): void => {\r\n    const newDialog: DialogProps = {\r\n      type: DialogType.SETTINGS,\r\n      isServerConnected: this.isServerConnected(),\r\n      settings: this.state.userSettings,\r\n      onSave: this.saveSettings,\r\n      onClose: () => {},\r\n    }\r\n    this.openDialog(newDialog)\r\n  }\r\n\r\n  aboutCallback = (): void => {\r\n    const newDialog: DialogProps = {\r\n      type: DialogType.ABOUT,\r\n      onClose: this.closeDialog,\r\n    }\r\n    this.openDialog(newDialog)\r\n  }\r\n\r\n  screencastCallback = (): void => {\r\n    const { reportName } = this.state\r\n    const { startRecording } = this.props.screenCast\r\n    const date = moment().format(\"YYYY-MM-DD-HH-MM-SS\")\r\n\r\n    startRecording(`streamlit-${reportName}-${date}`)\r\n  }\r\n\r\n  render(): JSX.Element {\r\n    const outerDivClass = classNames(\"stApp\", {\r\n      \"streamlit-embedded\": isEmbeddedInIFrame(),\r\n      \"streamlit-wide\": this.state.userSettings.wideMode,\r\n    })\r\n\r\n    let dialog: React.ReactNode = null\r\n    if (this.state.dialog) {\r\n      const dialogProps: DialogProps = {\r\n        ...this.state.dialog,\r\n        onClose: this.closeDialog,\r\n      }\r\n      dialog = StreamlitDialog(dialogProps)\r\n    }\r\n\r\n    // Attach and focused props provide a way to handle Global Hot Keys\r\n    // https://github.com/greena13/react-hotkeys/issues/41\r\n    // attach: DOM element the keyboard listeners should attach to\r\n    // focused: A way to force focus behaviour\r\n    return (\r\n      <HotKeys handlers={this.keyHandlers} attach={window} focused={true}>\r\n        <div className={outerDivClass}>\r\n          {/* The tabindex below is required for testing. */}\r\n          <header tabIndex={-1}>\r\n            <div className=\"decoration\" />\r\n            <div className=\"toolbar\">\r\n              <StatusWidget\r\n                ref={this.statusWidgetRef}\r\n                connectionState={this.state.connectionState}\r\n                sessionEventDispatcher={this.sessionEventDispatcher}\r\n                reportRunState={this.state.reportRunState}\r\n                rerunReport={this.rerunScript}\r\n                stopReport={this.stopReport}\r\n              />\r\n              <MainMenu\r\n                sharingEnabled={this.state.sharingEnabled === true}\r\n                isServerConnected={this.isServerConnected}\r\n                shareCallback={this.shareReport}\r\n                quickRerunCallback={this.rerunScript}\r\n                clearCacheCallback={this.openClearCacheDialog}\r\n                settingsCallback={this.settingsCallback}\r\n                aboutCallback={this.aboutCallback}\r\n                screencastCallback={this.screencastCallback}\r\n                screenCastState={this.props.screenCast.currentState}\r\n              />\r\n            </div>\r\n          </header>\r\n\r\n          <ReportView\r\n            wide={this.state.userSettings.wideMode}\r\n            elements={this.state.elements}\r\n            reportId={this.state.reportId}\r\n            reportRunState={this.state.reportRunState}\r\n            showStaleElementIndicator={\r\n              this.state.connectionState !== ConnectionState.STATIC\r\n            }\r\n            widgetMgr={this.widgetMgr}\r\n            widgetsDisabled={\r\n              this.state.connectionState !== ConnectionState.CONNECTED\r\n            }\r\n            uploadClient={this.uploadClient}\r\n            componentRegistry={this.componentRegistry}\r\n          />\r\n\r\n          {dialog}\r\n        </div>\r\n      </HotKeys>\r\n    )\r\n  }\r\n}\r\n\r\nexport default withScreencast(App)\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React from \"react\"\r\nimport ReactDOM from \"react-dom\"\r\nimport App from \"./App\"\r\n\r\nimport { Client as Styletron } from \"styletron-engine-atomic\"\r\nimport { LightTheme, BaseProvider } from \"baseui\"\r\nimport { Provider as StyletronProvider } from \"styletron-react\"\r\nimport { SCSS_VARS } from \"autogen/scssVariables\"\r\n\r\nconst engine = new Styletron({ prefix: \"st-\" })\r\nconst popupZIndex = Number(SCSS_VARS[\"$z-index-popup-menu\"])\r\n\r\nReactDOM.render(\r\n  <StyletronProvider value={engine}>\r\n    {/*\r\n      The BaseProvider type definition doesn't support zIndex, but the object\r\n      actually does. See: https://baseweb.design/components/base-provider/\r\n      // @ts-ignore */}\r\n    <BaseProvider theme={LightTheme} zIndex={popupZIndex}>\r\n      <App />\r\n    </BaseProvider>\r\n  </StyletronProvider>,\r\n  document.getElementById(\"root\")\r\n)\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\n/**\r\n * Utilities to get information out of a proto.DataFrame.\r\n */\r\n\r\nimport camelcase from \"camelcase\"\r\nimport { dispatchOneOf, mapOneOf, updateOneOf } from \"./immutableProto\"\r\nimport { fromJS } from \"immutable\"\r\nimport { format } from \"./format\"\r\n\r\n// Must match dict_builder.py\r\nexport const INDEX_COLUMN_DESIGNATOR = \"(index)\"\r\n\r\nconst STRING_COLLATOR = new Intl.Collator(\"en\", {\r\n  numeric: false,\r\n  sensitivity: \"base\",\r\n})\r\n\r\nfunction compareValues(a: any, b: any): number {\r\n  if (a < b) {\r\n    return -1\r\n  } else if (a > b) {\r\n    return 1\r\n  }\r\n  return 0\r\n}\r\n\r\nfunction compareStrings(a: string, b: string): number {\r\n  // using a Collator is faster than string.localeCompare:\r\n  // https://stackoverflow.com/questions/14677060/400x-sorting-speedup-by-switching-a-localecompareb-to-ab-1ab10/52369951#52369951\r\n  return STRING_COLLATOR.compare(a, b)\r\n}\r\n\r\n/**\r\n * Returns the row indices for a DataFrame, sorted based on the values in the given\r\n * columnIdx. (Note that the columnIdx is 0-based, and so does *not* include the header column;\r\n * similarly, the sorted row indices will not include the header row.)\r\n */\r\nexport function getSortedDataRowIndices(\r\n  df: any,\r\n  sortColumnIdx: number,\r\n  sortAscending: boolean\r\n): any[] {\r\n  const table = df.get(\"data\")\r\n  const [nRows, nCols] = tableGetRowsAndCols(table)\r\n  if (sortColumnIdx < 0 || sortColumnIdx >= nCols) {\r\n    throw new Error(\r\n      `Bad sortColumnIdx ${sortColumnIdx} (should be >= 0, < ${nCols})`\r\n    )\r\n  }\r\n\r\n  const col = table.getIn([\"cols\", sortColumnIdx])\r\n  const cmp = mapOneOf(col, \"type\", {\r\n    strings: compareStrings,\r\n    doubles: compareValues,\r\n    int64s: compareValues,\r\n    datetimes: compareValues,\r\n    timedeltas: compareValues,\r\n  })\r\n\r\n  const indices = new Array(nRows)\r\n  for (let i = 0; i < nRows; i += 1) {\r\n    indices[i] = i\r\n  }\r\n  indices.sort((aRowIdx, bRowIdx) => {\r\n    const aValue = tableData(table, sortColumnIdx, aRowIdx)\r\n    const bValue = tableData(table, sortColumnIdx, bRowIdx)\r\n    return sortAscending ? cmp(aValue, bValue) : cmp(bValue, aValue)\r\n  })\r\n\r\n  return indices\r\n}\r\n\r\n/**\r\n * Returns a dictionary of integers:\r\n *   { headerRows, headerCols, dataRows, dataCols, cols, rows }\r\n * for this DataFrame, where rows and cols are sums of the header and data\r\n * components.\r\n *\r\n * If df is null, this returns zeroes. If any of index/data/columns are null,\r\n * this treats them as empty (so their dimensions are [0, 0]).\r\n */\r\nexport function dataFrameGetDimensions(df: any): any {\r\n  const index = df ? df.get(\"index\") : null\r\n  const data = df ? df.get(\"data\") : null\r\n  const columns = df ? df.get(\"columns\") : null\r\n\r\n  const [headerCols, dataRowsCheck] = index\r\n    ? indexGetLevelsAndLength(index)\r\n    : [0, 0]\r\n  const [headerRows, dataColsCheck] = columns\r\n    ? indexGetLevelsAndLength(columns)\r\n    : [0, 0]\r\n  const [dataRows, dataCols] = data ? tableGetRowsAndCols(data) : [0, 0]\r\n\r\n  if (\r\n    (dataRows !== 0 && dataRows !== dataRowsCheck) ||\r\n    (dataCols !== 0 && dataCols !== dataColsCheck)\r\n  ) {\r\n    throw new Error(\r\n      \"Dataframe dimensions don't align: \" +\r\n        `rows(${dataRows} != ${dataRowsCheck}) OR ` +\r\n        `cols(${dataCols} != ${dataColsCheck})`\r\n    )\r\n  }\r\n\r\n  const cols = headerCols + dataCols\r\n  const rows = headerRows + dataRows\r\n\r\n  return {\r\n    headerRows,\r\n    headerCols,\r\n    dataRows,\r\n    dataCols,\r\n    cols,\r\n    rows,\r\n  }\r\n}\r\n\r\n/**\r\n * Returns [rows, cls] for this table.\r\n */\r\nexport function tableGetRowsAndCols(table: any): number[] {\r\n  if (!table || !table.get(\"cols\")) {\r\n    return [0, 0]\r\n  }\r\n\r\n  const cols = table.get(\"cols\").size\r\n  if (cols === 0) {\r\n    return [0, 0]\r\n  }\r\n  const rows = anyArrayLen(table.getIn([\"cols\", 0]))\r\n  return [rows, cols]\r\n}\r\n\r\n/**\r\n * Converts dataframe to array-of-dicts format.\r\n *\r\n * Example:\r\n *\r\n * [\r\n *   {index1: row1_col1, index2: row1_col2, ...},\r\n *   {index1: row2_col1, index2: row2_col2, ...},\r\n * ]\r\n */\r\nexport function dataFrameToArrayOfDicts(df: any): { [key: string]: any } {\r\n  const dataArr = []\r\n  const [nRows, nCols] = tableGetRowsAndCols(df.get(\"data\"))\r\n\r\n  const dfColumns = df.get(\"columns\")\r\n  const dfData = df.get(\"data\")\r\n\r\n  for (let r = 0; r < nRows; r++) {\r\n    const rowDict: { [key: string]: any } = {}\r\n\r\n    for (let c = 0; c < nCols; c++) {\r\n      rowDict[indexGet(dfColumns, 0, c)] = tableGet(dfData, c, r)\r\n    }\r\n\r\n    dataArr.push(rowDict)\r\n  }\r\n\r\n  // TODO: Handle indices too.\r\n\r\n  return dataArr\r\n}\r\n\r\n/**\r\n * Return the (i, j)th element of the DataFrame viewed as a big table including\r\n * header columns and rows. Returns a dict of\r\n * {\r\n *  contents: <the cell contents, nicely formatted as a string>,\r\n *  styles: {property1: value1, ...} <css styles to apply to the cell>\r\n *  type: 'corner' | 'row-header' | 'col-header' | 'data'\r\n * }\r\n */\r\nexport function dataFrameGet(df: any, col: any, row: any): any {\r\n  const { headerRows, headerCols } = dataFrameGetDimensions(df)\r\n  if (col < headerCols) {\r\n    if (row < headerRows) {\r\n      return {\r\n        contents: \"\",\r\n        styles: {},\r\n        type: \"corner\",\r\n      }\r\n    } else {\r\n      return {\r\n        contents: indexGet(df.get(\"index\"), col, row - headerRows),\r\n        styles: {},\r\n        type: \"col-header\",\r\n      }\r\n    }\r\n  } else {\r\n    if (row < headerRows) {\r\n      return {\r\n        contents: indexGet(df.get(\"columns\"), row, col - headerCols),\r\n        styles: {},\r\n        type: \"row-header\",\r\n      }\r\n    } else {\r\n      // If we have a formatted display value for the cell, return that.\r\n      // Else return the data itself.\r\n      const customDisplayValue = tableStyleGetDisplayValue(\r\n        df.get(\"style\"),\r\n        col - headerCols,\r\n        row - headerRows\r\n      )\r\n\r\n      const contents =\r\n        customDisplayValue != null\r\n          ? customDisplayValue\r\n          : tableGet(df.get(\"data\"), col - headerCols, row - headerRows)\r\n\r\n      return {\r\n        contents: contents,\r\n        styles:\r\n          tableStyleGetCSS(\r\n            df.get(\"style\"),\r\n            col - headerCols,\r\n            row - headerRows\r\n          ) || {},\r\n        type: \"data\",\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Returns the formatted string for the given element in a TableStyle,\r\n * or undefined if there's no such value.\r\n */\r\nexport function tableStyleGetDisplayValue(\r\n  tableStyle: any,\r\n  columnIndex: any,\r\n  rowIndex: any\r\n): any | undefined {\r\n  if (tableStyle == null) {\r\n    return undefined\r\n  }\r\n\r\n  const cellStyle = tableStyle.getIn(\r\n    [\"cols\", columnIndex, \"styles\", rowIndex],\r\n    undefined\r\n  )\r\n  if (cellStyle == null) {\r\n    return undefined\r\n  }\r\n\r\n  return cellStyle.get(\"hasDisplayValue\")\r\n    ? cellStyle.get(\"displayValue\")\r\n    : undefined\r\n}\r\n\r\n/**\r\n * Returns a CSS style dictionary with keys that are formatted for use in a\r\n * JSX element's {style} attribute, or undefined if table/cell has no style.\r\n */\r\nexport function tableStyleGetCSS(\r\n  tableStyle: any,\r\n  columnIndex: any,\r\n  rowIndex: any\r\n): any | undefined {\r\n  if (tableStyle == null) {\r\n    return undefined\r\n  }\r\n\r\n  const cssStyles = tableStyle.getIn(\r\n    [\"cols\", columnIndex, \"styles\", rowIndex, \"css\"],\r\n    undefined\r\n  )\r\n  if (cssStyles == null) {\r\n    return undefined\r\n  }\r\n\r\n  const styles: { [key: string]: any } = {}\r\n  cssStyles.forEach((item: any) => {\r\n    // React style property names are camelCased\r\n    const property = item.get(\"property\")\r\n    styles[camelcase(property)] = item.get(\"value\")\r\n  })\r\n\r\n  return styles\r\n}\r\n\r\n/**\r\n * Returns the given element from the table, formatted for display.\r\n */\r\nexport function tableGet(table: any, columnIndex: any, rowIndex: any): any {\r\n  return anyArrayGet(table.getIn([\"cols\", columnIndex]), rowIndex)\r\n}\r\n\r\n/**\r\n * Returns the raw data of the given element from the table.\r\n */\r\nexport function tableData(table: any, columnIndex: any, rowIndex: any): any {\r\n  return anyArrayData(table.getIn([\"cols\", columnIndex])).get(rowIndex)\r\n}\r\n\r\n/**\r\n * Returns [levels, length]. The former is the length of the index, while the\r\n * latter is 1 (or >1 for MultiIndex).\r\n */\r\nexport function indexGetLevelsAndLength(index: any): any {\r\n  return dispatchOneOf(index, \"type\", {\r\n    plainIndex: (idx: any) => [1, anyArrayLen(idx.get(\"data\"))],\r\n    rangeIndex: (idx: any) => [1, idx.get(\"stop\") - idx.get(\"start\")],\r\n    multiIndex: (idx: any) =>\r\n      idx.get(\"labels\").size === 0\r\n        ? [0, 0]\r\n        : [idx.get(\"labels\").size, idx.getIn([\"labels\", 0, \"data\"]).size],\r\n    int_64Index: (idx: any) => [1, idx.getIn([\"data\", \"data\"]).size],\r\n    float_64Index: (idx: any) => [1, idx.getIn([\"data\", \"data\"]).size],\r\n    datetimeIndex: (idx: any) => [1, idx.getIn([\"data\", \"data\"]).size],\r\n    timedeltaIndex: (idx: any) => [1, idx.getIn([\"data\", \"data\"]).size],\r\n  })\r\n}\r\n\r\n/**\r\n * Returns the ith index value of the given level.\r\n */\r\nexport function indexGet(index: any, level: any, i: any): any {\r\n  const type = index.get(\"type\")\r\n  if (type !== \"multiIndex\" && level !== 0) {\r\n    throw new Error(`Attempting to access level ${level} of a ${type}.`)\r\n  }\r\n  return dispatchOneOf(index, \"type\", {\r\n    plainIndex: (idx: any) => anyArrayGet(idx.get(\"data\"), i),\r\n    rangeIndex: (idx: any) => idx.get(\"start\") + i,\r\n    multiIndex: (idx: any) => {\r\n      const levels = idx.getIn([\"levels\", level])\r\n      const labels = idx.getIn([\"labels\", level])\r\n      const label = labels.getIn([\"data\", i])\r\n      if (label < 0) {\r\n        return \"NaN\"\r\n      } else {\r\n        return indexGet(levels, 0, label)\r\n      }\r\n    },\r\n    int_64Index: (idx: any) => idx.getIn([\"data\", \"data\", i]),\r\n    float_64Index: (idx: any) => idx.getIn([\"data\", \"data\", i]),\r\n    datetimeIndex: (idx: any) =>\r\n      format.nanosToDate(idx.getIn([\"data\", \"data\", i])),\r\n    timedeltaIndex: (idx: any) =>\r\n      format.nanosToDuration(idx.getIn([\"data\", \"data\", i])),\r\n  })\r\n}\r\n\r\n/**\r\n * Returns the numerical index of the column with the specified name within\r\n * this table. If no such column exists, returns -1.\r\n */\r\nexport function indexGetByName(index: any, name: string): number {\r\n  const len = indexLen(index)\r\n  for (let i = 0; i < len; i++) {\r\n    if (indexGet(index, 0, i) === name) {\r\n      return i\r\n    }\r\n  }\r\n  return -1\r\n}\r\n\r\n/**\r\n * Returns the length of an AnyArray.\r\n */\r\nfunction anyArrayLen(anyArray: any): number {\r\n  return anyArrayData(anyArray).size\r\n}\r\n\r\n/**\r\n * Returns the ith element of this AnyArray.\r\n */\r\nfunction anyArrayGet(anyArray: any, i: any): any {\r\n  const getData = (obj: any): any => obj.get(\"data\").get(i)\r\n  return dispatchOneOf(anyArray, \"type\", {\r\n    strings: getData,\r\n    doubles: getData,\r\n    int64s: getData,\r\n    datetimes: (obj: any) => format.nanosToDate(getData(obj)),\r\n    timedeltas: (obj: any) => format.nanosToDuration(getData(obj)),\r\n  })\r\n}\r\n\r\n/**\r\n * Returns the data array of an proto.AnyArray.\r\n */\r\nfunction anyArrayData(anyArray: any): any {\r\n  const getData = (obj: any): any => obj.get(\"data\")\r\n  return dispatchOneOf(anyArray, \"type\", {\r\n    strings: getData,\r\n    doubles: getData,\r\n    int64s: getData,\r\n    datetimes: getData,\r\n    timedeltas: getData,\r\n  })\r\n}\r\n\r\n/**\r\n * Concatenates namedDataSet into element, returning a new element.\r\n */\r\nexport function addRows(element: any, namedDataSet: any): any {\r\n  const name = namedDataSet.get(\"hasName\") ? namedDataSet.get(\"name\") : null\r\n  const newRows = namedDataSet.get(\"data\")\r\n  const namedDataSets = getNamedDataSets(element)\r\n\r\n  const [existingDatasetIndex, existingDataSet] = getNamedDataSet(\r\n    namedDataSets,\r\n    name\r\n  )\r\n  let dataframeToModify\r\n\r\n  // There are 5 cases to consider:\r\n  // 1. add_rows has a named dataset\r\n  //   a) element has a named dataset with that name -> use that one\r\n  //   b) element has no named dataset with that name -> put the new dataset into the element\r\n  // 2. add_rows as an unnamed dataset\r\n  //   a) element has an unnamed dataset -> use that one\r\n  //   b) element has only named datasets -> use the first named dataset\r\n  //   c) element has no dataset -> put the new dataset into the element\r\n  if (namedDataSet.get(\"hasName\")) {\r\n    if (existingDataSet) {\r\n      dataframeToModify = existingDataSet.get(\"data\")\r\n    } else {\r\n      return pushNamedDataSet(element, namedDataSet)\r\n    }\r\n  } else {\r\n    const existingDataFrame = getDataFrame(element)\r\n    if (existingDataFrame) {\r\n      dataframeToModify = existingDataFrame\r\n    } else if (existingDataSet) {\r\n      dataframeToModify = existingDataSet.get(\"data\")\r\n    } else {\r\n      return setDataFrame(element, newRows)\r\n    }\r\n  }\r\n\r\n  if (dataframeToModify.get(\"data\") == null) {\r\n    dataframeToModify = dataframeToModify.set(\"data\", fromJS({ cols: [] }))\r\n    dataframeToModify = dataframeToModify.set(\"style\", fromJS({ cols: [] }))\r\n  }\r\n\r\n  let newDataFrame\r\n\r\n  if (\r\n    dataframeToModify\r\n      .get(\"data\")\r\n      .get(\"cols\")\r\n      .isEmpty()\r\n  ) {\r\n    newDataFrame = newRows\r\n  } else {\r\n    newDataFrame = dataframeToModify\r\n      .update(\"index\", (index: any) =>\r\n        concatIndex(index, newRows.get(\"index\"))\r\n      )\r\n      .updateIn([\"data\", \"cols\"], (cols: any) => {\r\n        return cols.zipWith(\r\n          (col1: any, col2: any) => concatAnyArray(col1, col2),\r\n          newRows.getIn([\"data\", \"cols\"])\r\n        )\r\n      })\r\n      .updateIn([\"style\", \"cols\"], (style_cols: any) => {\r\n        return style_cols.zipWith(\r\n          (col1: any, col2: any) => concatCellStyleArray(col1, col2),\r\n          newRows.getIn([\"style\", \"cols\"])\r\n        )\r\n      })\r\n  }\r\n\r\n  if (existingDataSet) {\r\n    return setDataFrameInNamedDataSet(\r\n      element,\r\n      existingDatasetIndex,\r\n      newDataFrame\r\n    )\r\n  } else {\r\n    return setDataFrame(element, newDataFrame)\r\n  }\r\n}\r\n\r\n/**\r\n * Concatenates the indices and returns a new index.\r\n */\r\nfunction concatIndex(index1: any, index2: any): any {\r\n  // Special case if index1 is empty.\r\n  if (indexLen(index1) === 0) {\r\n    return index2\r\n  }\r\n\r\n  // Otherwise, make sure the types match.\r\n  const type1 = index1.get(\"type\")\r\n  const type2 = index2.get(\"type\")\r\n  if (type1 !== type2) {\r\n    throw new Error(`Cannot concatenate ${type1} with ${type2}.`)\r\n  }\r\n\r\n  // ...and dispatch based on type.\r\n  return updateOneOf(index1, \"type\", {\r\n    plainIndex: (idx: any) =>\r\n      idx.update(\"data\", (data: any) =>\r\n        concatAnyArray(data, index2.getIn([\"plainIndex\", \"data\"]))\r\n      ),\r\n    rangeIndex: (idx: any) =>\r\n      idx.update(\"stop\", (stop: any) => stop + indexLen(index2)),\r\n    // multiIndex: <not supported>,\r\n    int_64Index: (idx: any) =>\r\n      idx.updateIn([\"data\", \"data\"], (data: any) =>\r\n        data.concat(index2.getIn([\"int_64Index\", \"data\", \"data\"]))\r\n      ),\r\n    float_64Index: (idx: any) =>\r\n      idx.updateIn([\"data\", \"data\"], (data: any) =>\r\n        data.concat(index2.getIn([\"float_64Index\", \"data\", \"data\"]))\r\n      ),\r\n    datetimeIndex: (idx: any) =>\r\n      idx.updateIn([\"data\", \"data\"], (data: any) =>\r\n        data.concat(index2.getIn([\"datetimeIndex\", \"data\", \"data\"]))\r\n      ),\r\n    timedeltaIndex: (idx: any) =>\r\n      idx.updateIn([\"data\", \"data\"], (data: any) =>\r\n        data.concat(index2.getIn([\"timedeltaIndex\", \"data\", \"data\"]))\r\n      ),\r\n  })\r\n}\r\n\r\n/**\r\n * Concatenates both anyArrays, returning the result.\r\n */\r\nfunction concatAnyArray(anyArray1: any, anyArray2: any): any {\r\n  // Special case if the left array is empty.\r\n  if (anyArrayLen(anyArray1) === 0) {\r\n    return anyArray2\r\n  }\r\n\r\n  const type1 = anyArray1.get(\"type\")\r\n  const type2 = anyArray2.get(\"type\")\r\n  if (type1 !== type2) {\r\n    throw new Error(`Cannot concatenate ${type1} and ${type2}.`)\r\n  }\r\n\r\n  return anyArray1.updateIn([type1, \"data\"], (array: any) =>\r\n    array.concat(anyArray2.getIn([type2, \"data\"]))\r\n  )\r\n}\r\n\r\n/**\r\n * Concatenates both CellStyleArrays, returning the result\r\n */\r\nfunction concatCellStyleArray(array1: any, array2: any): any {\r\n  // Special case if the left array is empty.\r\n  if (array1.get(\"styles\").length === 0) {\r\n    return array2\r\n  }\r\n  return array1.update(\"styles\", (styles: any) =>\r\n    styles.concat(array2.get(\"styles\"))\r\n  )\r\n}\r\n\r\n/**\r\n * Extracts the dataframe from an element. The name is only used if it makes\r\n * sense for the given element.\r\n */\r\nfunction getDataFrame(element: any): any {\r\n  return dispatchOneOf(element, \"type\", {\r\n    chart: (chart: any) => chart.get(\"data\"),\r\n    dataFrame: (df: any) => df,\r\n    table: (df: any) => df,\r\n    deckGlMap: (el: any) => el.get(\"data\"),\r\n    vegaLiteChart: (chart: any) => chart.get(\"data\"),\r\n  })\r\n}\r\n\r\nfunction getNamedDataSets(element: any): any {\r\n  return dispatchOneOf(element, \"type\", {\r\n    vegaLiteChart: (chart: any) => chart.get(\"datasets\"),\r\n    _else: () => null,\r\n  })\r\n}\r\n\r\n/**\r\n * If there is only one NamedDataSet, returns [0, NamedDataSet] with the 0th\r\n * NamedDataSet.\r\n * Otherwise, returns the [index, NamedDataSet] with the NamedDataSet\r\n * matching the given name.\r\n */\r\nfunction getNamedDataSet(namedDataSets: any, name: any): any {\r\n  if (namedDataSets != null) {\r\n    if (namedDataSets.size === 1) {\r\n      const firstNamedDataSet = namedDataSets.first()\r\n      return [0, firstNamedDataSet]\r\n    }\r\n\r\n    const namedDataSetEntry = namedDataSets.findEntry(\r\n      (ds: any) => ds.get(\"hasName\") && ds.get(\"name\") === name\r\n    )\r\n\r\n    if (namedDataSetEntry) {\r\n      return namedDataSetEntry\r\n    }\r\n  }\r\n\r\n  return [-1, null]\r\n}\r\n\r\n/**\r\n * Sets the dataframe of this element.\r\n * Returns a new element -- NOT A DATAFRAME!\r\n */\r\nfunction setDataFrame(element: any, df: any): any {\r\n  return updateOneOf(element, \"type\", {\r\n    chart: (chart: any) => chart.set(\"data\", df),\r\n    dataFrame: () => df,\r\n    table: () => df,\r\n    deckGlMap: (el: any) => el.set(\"data\", df),\r\n    vegaLiteChart: (chart: any) => chart.set(\"data\", df),\r\n  })\r\n}\r\n\r\n/**\r\n * Adds a named dataset to this element.\r\n * Returns a new element -- NOT A DATAFRAME!\r\n */\r\nfunction pushNamedDataSet(element: any, namedDataset: any): any {\r\n  return updateOneOf(element, \"type\", {\r\n    vegaLiteChart: (chart: any) =>\r\n      chart.update(\"datasets\", (datasets: any) => datasets.push(namedDataset)),\r\n  })\r\n}\r\n\r\n/**\r\n * Sets the named dataset of this element.\r\n * Returns a new element -- NOT A DATAFRAME!\r\n */\r\nfunction setDataFrameInNamedDataSet(element: any, index: any, df: any): any {\r\n  return updateOneOf(element, \"type\", {\r\n    vegaLiteChart: (chart: any) =>\r\n      chart.setIn([\"datasets\", index, \"data\"], df),\r\n  })\r\n}\r\n\r\n/**\r\n * Returns the number of elements in an index.\r\n */\r\nfunction indexLen(index: any): any {\r\n  return dispatchOneOf(index, \"type\", {\r\n    plainIndex: (idx: any) => anyArrayLen(idx.get(\"data\")),\r\n    rangeIndex: (idx: any) => idx.get(\"stop\") - idx.get(\"start\"),\r\n    multiIndex: (idx: any) =>\r\n      idx.get(\"labels\").size === 0 ? 0 : idx.getIn([\"labels\", 0]).size,\r\n    int_64Index: (idx: any) => idx.getIn([\"data\", \"data\"]).size,\r\n    float_64Index: (idx: any) => idx.getIn([\"data\", \"data\"]).size,\r\n    datetimeIndex: (idx: any) => idx.getIn([\"data\", \"data\"]).size,\r\n    timedeltaIndex: (idx: any) => idx.getIn([\"data\", \"data\"]).size,\r\n  })\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ReactElement } from \"react\"\r\nimport { Alert } from \"reactstrap\"\r\n\r\nexport interface Props {\r\n  name: string\r\n  message: string | ReactElement\r\n  stack?: string\r\n  width?: number\r\n}\r\n\r\n/**\r\n * A component that draws an error on the screen. This is for internal use\r\n * only. That is, this should not be an element that a user purposefully places\r\n * in a Streamlit report. For that, see st.exception / Exception.tsx or\r\n * st.error / Text.tsx.\r\n */\r\nclass ErrorElement extends PureComponent<Props> {\r\n  public render(): React.ReactNode {\r\n    const { name, message, stack } = this.props\r\n\r\n    // Remove first line from stack (because it's just the error message) and\r\n    // trim indentation.\r\n    const stackArray = stack ? stack.split(\"\\n\") : []\r\n    stackArray.shift()\r\n    const cleanedStack = stackArray.map(s => s.trim()).join(\"\\n\")\r\n\r\n    return (\r\n      <Alert color=\"danger\" style={{ width: this.props.width }}>\r\n        <strong>{name}: </strong>\r\n        {message}\r\n        {stack ? (\r\n          <pre className=\"error\">\r\n            <code>{cleanedStack}</code>\r\n          </pre>\r\n        ) : null}\r\n      </Alert>\r\n    )\r\n  }\r\n}\r\n\r\nexport default ErrorElement\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport { default } from \"./ErrorElement\"\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { IS_DEV_ENV } from \"./baseconsts\"\r\n\r\n/**\r\n * Log a message to the console, but only if in dev mode.\r\n */\r\nexport function logMessage(...args: any[]): void {\r\n  if (IS_DEV_ENV) {\r\n    console.log(...args)\r\n  }\r\n}\r\n\r\n/**\r\n * Log an warning to the console, but only if in dev mode.\r\n * USE ONLY FOR WARNINGS: Meaning, only things that have a small impact on the\r\n * user experience, if any.\r\n */\r\nexport function logWarning(...args: any[]): void {\r\n  if (IS_DEV_ENV) {\r\n    console.warn(...args)\r\n  }\r\n}\r\n\r\n/**\r\n * Log an error to the console. ALWAYS does this, even if in prod mode, because\r\n * errors are _that_ important.\r\n * USE ONLY FOR ERRORS: Meaning, only things that somehow \"break\" the user\r\n * experience.\r\n */\r\nexport function logError(...args: any[]): void {\r\n  console.error(...args)\r\n  // TODO: Send error report to our servers when there's an error.\r\n}\r\n\r\n/**\r\n * Log a message to the console. ALWAYS does this, even if in prod mode.\r\n * USE SPARINGLY!\r\n */\r\nexport function logAlways(...args: any[]): void {\r\n  console.log(...args)\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent } from \"react\"\r\nimport Icon from \"../Icon\"\r\nimport { SCSS_VARS } from \"autogen/scssVariables\"\r\nimport \"./FullScreenWrapper.scss\"\r\n\r\nexport type Size = {\r\n  width: number\r\n  expanded: boolean\r\n  height?: number\r\n}\r\n\r\n/*\r\n * Function responsible for rendering children.\r\n * This function should implement the following signature:\r\n * ({ height, width }) => PropTypes.element\r\n */\r\ninterface Props {\r\n  children: (props: Size) => React.ReactNode\r\n  width: number\r\n  height?: number\r\n}\r\n\r\ninterface State {\r\n  expanded: boolean\r\n  fullWidth: number\r\n  fullHeight: number\r\n}\r\n\r\n/*\r\n * A component that draws a button on the top right of the\r\n * wrapper element. OnClick, change the element container\r\n * to fixed and cover all screen, updating wrapped element height and width\r\n */\r\nclass FullScreenWrapper extends PureComponent<Props, State> {\r\n  static isFullScreen = false\r\n\r\n  public state: State = { expanded: false, fullWidth: 0, fullHeight: 0 }\r\n\r\n  componentDidMount(): void {\r\n    this.updateWindowDimensions()\r\n    window.addEventListener(\"resize\", this.updateWindowDimensions)\r\n    document.addEventListener(\"keydown\", this.controlKeys, false)\r\n  }\r\n\r\n  componentWillUnmount(): void {\r\n    window.removeEventListener(\"resize\", this.updateWindowDimensions)\r\n    document.removeEventListener(\"keydown\", this.controlKeys, false)\r\n  }\r\n\r\n  controlKeys = (event: any): void => {\r\n    const { expanded } = this.state\r\n\r\n    if (event.keyCode === 27 && expanded) {\r\n      // Exit fullscreen\r\n      this.zoomOut()\r\n    }\r\n  }\r\n\r\n  zoomIn = (): void => {\r\n    document.body.style.overflow = \"hidden\"\r\n    FullScreenWrapper.isFullScreen = true\r\n    this.setState({ expanded: true })\r\n  }\r\n\r\n  zoomOut = (): void => {\r\n    document.body.style.overflow = \"unset\"\r\n    FullScreenWrapper.isFullScreen = false\r\n    this.setState({ expanded: false })\r\n  }\r\n\r\n  convertScssRemValueToPixels = (scssValue: string): number => {\r\n    const remValue = parseFloat(scssValue)\r\n    return (\r\n      remValue *\r\n      parseFloat(getComputedStyle(document.documentElement).fontSize)\r\n    )\r\n  }\r\n\r\n  updateWindowDimensions = (): void => {\r\n    const padding = this.convertScssRemValueToPixels(\r\n      SCSS_VARS[\"$fullscreen-padding\"]\r\n    )\r\n    const paddingTop = this.convertScssRemValueToPixels(\r\n      SCSS_VARS[\"$fullscreen-padding-top\"]\r\n    )\r\n    this.setState({\r\n      fullWidth: window.innerWidth - padding * 2, // Left and right\r\n      fullHeight: window.innerHeight - (padding + paddingTop), // Bottom and Top\r\n    })\r\n  }\r\n\r\n  public render(): JSX.Element {\r\n    const { expanded, fullWidth, fullHeight } = this.state\r\n    const { children, width, height } = this.props\r\n\r\n    let buttonClassName = \"overlayBtn stButton-enter\"\r\n    let buttonImage = \"fullscreen-enter\"\r\n    let buttonOnClick = this.zoomIn\r\n    let buttonTitle = \"View fullscreen\"\r\n\r\n    if (expanded) {\r\n      buttonClassName = \"overlayBtn stButton-exit\"\r\n      buttonImage = \"fullscreen-exit\"\r\n      buttonOnClick = this.zoomOut\r\n      buttonTitle = \"Exit fullscreen\"\r\n    }\r\n\r\n    return (\r\n      <div className={`fullScreenFrame${expanded ? \"--expanded\" : \"\"}`}>\r\n        <button\r\n          className={buttonClassName}\r\n          onClick={buttonOnClick}\r\n          title={buttonTitle}\r\n        >\r\n          <Icon type={buttonImage} />\r\n        </button>\r\n        {expanded\r\n          ? children({ width: fullWidth, height: fullHeight, expanded })\r\n          : children({ width, height, expanded })}\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default FullScreenWrapper\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport { default } from \"./FullScreenWrapper\"\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { Theme } from \"baseui/theme\"\r\nimport { createTheme, lightThemePrimitives } from \"baseui\"\r\nimport { PLACEMENT as POPOVER_PLACEMENT } from \"baseui/popover\"\r\nimport { logMessage } from \"lib/log\"\r\nimport { SCSS_VARS } from \"autogen/scssVariables\"\r\nimport { FileUploaderOverrides, StyleProps } from \"baseui/file-uploader\"\r\n\r\nconst black = SCSS_VARS[\"$black\"]\r\nconst borderRadius = SCSS_VARS[\"$border-radius\"]\r\nconst fontFamilyMono = SCSS_VARS[\"$font-family-monospace\"]\r\nconst fontFamilySans = SCSS_VARS[\"$font-family-sans-serif\"]\r\nconst fontSizeBase = SCSS_VARS[\"$font-size-base\"]\r\nconst fontSizeSm = SCSS_VARS[\"$font-size-sm\"]\r\nconst grayDark = SCSS_VARS[\"$gray-dark\"]\r\nconst gray = SCSS_VARS[\"$gray\"]\r\nconst grayLight = SCSS_VARS[\"$gray-light\"]\r\nconst grayLighter = SCSS_VARS[\"$gray-lighter\"]\r\nconst grayLightest = SCSS_VARS[\"$gray-lightest\"]\r\nconst labelFontSize = SCSS_VARS[\"$font-size-sm\"]\r\nconst lineHeightBase = SCSS_VARS[\"$line-height-base\"]\r\nconst lineHeightTight = SCSS_VARS[\"$line-height-tight\"]\r\nconst primary = SCSS_VARS[\"$primary\"]\r\nconst primaryA50 = SCSS_VARS[\"$primary-a50\"]\r\nconst smallTextMargin = SCSS_VARS[\"$m2-3-font-size-sm\"]\r\nconst textMargin = SCSS_VARS[\"$font-size-sm\"]\r\nconst tinyTextMargin = SCSS_VARS[\"$m1-2-font-size-sm\"]\r\nconst white = SCSS_VARS[\"$white\"]\r\n\r\nconst fontStyles = {\r\n  fontFamily: fontFamilySans,\r\n  fontSize: fontSizeBase,\r\n  fontWeight: \"normal\",\r\n  lineHeight: lineHeightBase,\r\n}\r\n\r\nexport const sliderOverrides = {\r\n  Root: {\r\n    style: {\r\n      paddingTop: smallTextMargin,\r\n    },\r\n  },\r\n  Thumb: {\r\n    style: ({ $disabled }: { $disabled: boolean }) => ({\r\n      backgroundColor: $disabled ? gray : primary,\r\n      borderTopLeftRadius: \"100%\",\r\n      borderTopRightRadius: \"100%\",\r\n      borderBottomLeftRadius: \"100%\",\r\n      borderBottomRightRadius: \"100%\",\r\n      borderStyle: \"none\",\r\n      boxShadow: \"none\",\r\n      height: SCSS_VARS[\"$border-radius-large\"],\r\n      width: SCSS_VARS[\"$border-radius-large\"],\r\n      \":focus\": {\r\n        boxShadow: `0 0 0 0.2rem ${primaryA50}`,\r\n        outline: \"none\",\r\n      },\r\n    }),\r\n  },\r\n  InnerThumb: {\r\n    style: {\r\n      display: \"none\",\r\n    },\r\n  },\r\n  Tick: {\r\n    style: {\r\n      fontFamily: fontFamilyMono,\r\n      fontSize: labelFontSize,\r\n    },\r\n  },\r\n  ThumbValue: {\r\n    style: ({ $disabled }: { $disabled: boolean }) => ({\r\n      fontFamily: fontFamilyMono,\r\n      fontSize: labelFontSize,\r\n      paddingBottom: smallTextMargin,\r\n      color: $disabled ? gray : primary,\r\n      top: \"-22px\",\r\n      position: \"absolute\",\r\n      whiteSpace: \"nowrap\",\r\n      backgroundColor: \"transparent\",\r\n      lineHeight: lineHeightBase,\r\n      fontWeight: \"normal\",\r\n    }),\r\n  },\r\n  TickBar: {\r\n    style: {\r\n      paddingBottom: 0,\r\n      paddingLeft: 0,\r\n      paddingRight: 0,\r\n      paddingTop: smallTextMargin,\r\n      justifyContent: \"space-between\",\r\n      alignItems: \"center\",\r\n      display: \"flex\",\r\n    },\r\n  },\r\n  TickBarItem: {\r\n    style: {\r\n      lineHeight: lineHeightBase,\r\n      fontWeight: \"normal\",\r\n      fontSize: labelFontSize,\r\n      fontFamily: fontFamilyMono,\r\n    },\r\n  },\r\n  Track: {\r\n    style: {\r\n      paddingBottom: 0,\r\n      paddingLeft: 0,\r\n      paddingRight: 0,\r\n      paddingTop: smallTextMargin,\r\n    },\r\n  },\r\n  InnerTrack: {\r\n    style: ({ $disabled }: { $disabled: boolean }) =>\r\n      $disabled ? { background: grayLighter } : {},\r\n  },\r\n}\r\n\r\nexport const fileUploaderOverrides: FileUploaderOverrides<StyleProps> = {\r\n  // Important: these values must match the ones in FileUploader.scss!\r\n  FileDragAndDrop: {\r\n    style: ({\r\n      $theme,\r\n      $isDragActive,\r\n    }: {\r\n      $theme: Theme\r\n      $isDragActive: boolean\r\n    }) => ({\r\n      borderRadius,\r\n      display: \"flex\",\r\n      color: grayDark,\r\n      fontSize: fontSizeSm,\r\n      lineHeight: lineHeightTight,\r\n      flexDirection: \"column\",\r\n      justifyContent: \"center\",\r\n      paddingTop: \"0.25rem\",\r\n      paddingBottom: \"0.25rem\",\r\n      paddingLeft: \"0.25rem\",\r\n      paddingRight: \"0.25rem\",\r\n      height: \"4.25rem\",\r\n      borderColor: $isDragActive ? primary : \"transparent\",\r\n      backgroundColor: $isDragActive ? primaryA50 : $theme.colors.mono200,\r\n      borderStyle: \"solid\",\r\n      borderWidth: \"1px\",\r\n      \":focus\": {\r\n        outline: 0,\r\n        borderColor: primary,\r\n      },\r\n    }),\r\n  },\r\n  ContentSeparator: {\r\n    style: {\r\n      fontSize: fontSizeSm,\r\n      color: grayDark,\r\n      lineHeight: lineHeightTight,\r\n      display: \"\",\r\n    },\r\n  },\r\n  ContentMessage: {\r\n    style: {\r\n      fontSize: fontSizeSm,\r\n      color: grayDark,\r\n      lineHeight: lineHeightTight,\r\n      display: \"\",\r\n    },\r\n  },\r\n  ButtonComponent: {\r\n    props: {\r\n      overrides: {\r\n        BaseButton: {\r\n          style: {\r\n            color: primary,\r\n            fontSize: fontSizeSm,\r\n            lineHeight: lineHeightTight,\r\n            paddingBottom: 0,\r\n            paddingLeft: \"0.25em\",\r\n            paddingRight: \"0.25em\",\r\n            paddingTop: 0,\r\n            textTransform: \"lowercase\",\r\n            \":hover\": {\r\n              backgroundColor: \"transparent\",\r\n              textDecoration: \"underline\",\r\n            },\r\n            \":active\": {\r\n              backgroundColor: \"transparent\",\r\n              textDecoration: \"underline\",\r\n            },\r\n            \":disabled\": {\r\n              backgroundColor: \"transparent\",\r\n              color: grayDark,\r\n            },\r\n            \":focus\": {\r\n              outline: 0,\r\n              backgroundColor: \"transparent\",\r\n            },\r\n          },\r\n        },\r\n      },\r\n    },\r\n  },\r\n}\r\n\r\nexport const datePickerOverrides = {\r\n  Popover: {\r\n    props: {\r\n      placement: POPOVER_PLACEMENT.bottomLeft,\r\n    },\r\n  },\r\n  CalendarContainer: {\r\n    style: {\r\n      fontSize: fontSizeSm,\r\n    },\r\n  },\r\n  CalendarHeader: {\r\n    style: {\r\n      // Make header look nicer.\r\n      backgroundColor: gray,\r\n    },\r\n  },\r\n  MonthHeader: {\r\n    style: {\r\n      // Make header look nicer.\r\n      backgroundColor: gray,\r\n    },\r\n  },\r\n  Week: {\r\n    style: {\r\n      fontSize: fontSizeSm,\r\n    },\r\n  },\r\n  Day: {\r\n    style: ({ $selected }: { $selected: boolean }) => ({\r\n      \"::after\": {\r\n        borderColor: $selected ? \"transparent\" : \"\",\r\n      },\r\n    }),\r\n  },\r\n  PrevButton: {\r\n    style: () => ({\r\n      // Align icon to the center of the button.\r\n      display: \"flex\",\r\n      alignItems: \"center\",\r\n      justifyContent: \"center\",\r\n      // Remove primary-color click effect.\r\n      \":active\": {\r\n        backgroundColor: \"transparent\",\r\n      },\r\n      \":focus\": {\r\n        backgroundColor: \"transparent\",\r\n        outline: 0,\r\n      },\r\n    }),\r\n  },\r\n  NextButton: {\r\n    style: {\r\n      // Align icon to the center of the button.\r\n      display: \"flex\",\r\n      alignItems: \"center\",\r\n      justifyContent: \"center\",\r\n      // Remove primary-color click effect.\r\n      \":active\": {\r\n        backgroundColor: \"transparent\",\r\n      },\r\n      \":focus\": {\r\n        backgroundColor: \"transparent\",\r\n        outline: 0,\r\n      },\r\n    },\r\n  },\r\n  Input: {\r\n    props: {\r\n      // The default maskChar ` ` causes empty dates to display as ` / / `\r\n      // Clearing the maskChar so empty dates will not display\r\n      maskChar: null,\r\n    },\r\n  },\r\n}\r\n\r\nexport const buttonOverrides = {\r\n  BaseButton: {\r\n    style: {\r\n      paddingTop: tinyTextMargin,\r\n      paddingBottom: tinyTextMargin,\r\n      paddingLeft: textMargin,\r\n      paddingRight: textMargin,\r\n      backgroundColor: white,\r\n      // We shouldn't mix shorthand properties with longhand -- which usually\r\n      // means we should use longhand for everything. But BaseUI's Button\r\n      // actually uses the shorthand \"border\" property, so that's what I'm\r\n      // using here too.\r\n      border: `1px solid ${grayLighter}`,\r\n      color: black,\r\n      \":hover\": {\r\n        backgroundColor: \"transparent\",\r\n        borderColor: primary,\r\n        color: primary,\r\n      },\r\n      \":focus\": {\r\n        backgroundColor: white,\r\n        borderColor: primary,\r\n        boxShadow: `0 0 0 0.2rem ${primaryA50}`,\r\n        color: primary,\r\n        outline: \"none\",\r\n      },\r\n      \":active\": {\r\n        color: white,\r\n      },\r\n      \":disabled\": {\r\n        backgroundColor: grayLighter,\r\n        borderColor: \"transparent\",\r\n        color: gray,\r\n      },\r\n      \":hover:disabled\": {\r\n        backgroundColor: grayLighter,\r\n        borderColor: \"transparent\",\r\n        color: gray,\r\n      },\r\n    },\r\n  },\r\n}\r\n\r\nexport const multiSelectOverrides = {\r\n  ValueContainer: {\r\n    style: () => ({\r\n      /*\r\n        This minHeight is needed to fix a bug from BaseWeb in which the\r\n        div that contains the options changes their height from 40px to 44px.\r\n\r\n        You could check this behavior in their documentation as well:\r\n        https://v8-17-1.baseweb.design/components/select/#select-as-multi-pick-search\r\n\r\n        Issue related: https://github.com/streamlit/streamlit/issues/590\r\n       */\r\n      minHeight: \"44px\",\r\n    }),\r\n  },\r\n  ClearIcon: {\r\n    style: {\r\n      color: grayDark,\r\n    },\r\n  },\r\n  SearchIcon: {\r\n    style: {\r\n      color: grayDark,\r\n    },\r\n  },\r\n  MultiValue: {\r\n    props: {\r\n      overrides: {\r\n        Root: {\r\n          style: {\r\n            fontSize: \"12px\",\r\n          },\r\n        },\r\n      },\r\n    },\r\n  },\r\n}\r\n\r\nexport const radioOverrides = {\r\n  Root: {\r\n    style: ({ $isFocused }: { $isFocused: boolean }) => ({\r\n      marginBottom: 0,\r\n      marginTop: 0,\r\n      paddingRight: smallTextMargin,\r\n      backgroundColor: $isFocused ? grayLightest : \"\",\r\n      borderTopLeftRadius: borderRadius,\r\n      borderTopRightRadius: borderRadius,\r\n      borderBottomLeftRadius: borderRadius,\r\n      borderBottomRightRadius: borderRadius,\r\n    }),\r\n  },\r\n  RadioMarkInner: {\r\n    style: ({ $checked }: { $checked: boolean }) => ({\r\n      height: $checked ? \"6px\" : \"16px\",\r\n      width: $checked ? \"6px\" : \"16px\",\r\n    }),\r\n  },\r\n}\r\n\r\nexport const checkboxOverrides = {\r\n  ...radioOverrides,\r\n  Checkmark: {\r\n    style: ({\r\n      $isFocusVisible,\r\n      $checked,\r\n    }: {\r\n      $isFocusVisible: boolean\r\n      $checked: boolean\r\n    }) => ({\r\n      borderWidth: \"2px\",\r\n      outline: 0,\r\n      boxShadow:\r\n        $isFocusVisible && $checked ? `0 0 0 0.2rem ${primaryA50}` : \"\",\r\n    }),\r\n  },\r\n}\r\n\r\n// Theme primitives. See lightThemePrimitives for what's available. These are\r\n// used to create a large JSON-style structure with theme values for all\r\n// widgets.\r\n// - See node_modules/baseui/themes/light-theme-primitives.js for an example\r\n// of primitives we can use here.\r\n// - See node_modules/baseui/themes/creator.js for the mapping of values from\r\n// this file to output values.\r\nconst mainThemePrimitives = {\r\n  ...lightThemePrimitives,\r\n\r\n  primaryFontFamily: SCSS_VARS[\"$font-family-sans-serif\"],\r\n\r\n  primary100: primary,\r\n  primary200: primary,\r\n  primary300: primary,\r\n  primary400: primary,\r\n  primary500: primary,\r\n  primary600: primary,\r\n  primary700: primary,\r\n\r\n  // Override gray values based on what is actually used in BaseWeb, and the\r\n  // way we want it to match our Bootstrap theme.\r\n  mono100: white, // Popup menu\r\n  mono200: grayLightest, // Text input, text area, selectbox\r\n  mono300: grayLighter, // Disabled widget background\r\n  mono400: grayLighter, // Slider track\r\n  mono500: gray, // Clicked checkbox and radio\r\n  mono600: gray, // Disabled widget text\r\n  mono700: gray, // Unselected checkbox and radio\r\n  mono800: grayDark, // Selectbox text\r\n  mono900: grayDark, // Not used, but just in case.\r\n  mono1000: black,\r\n\r\n  rating200: \"#FFE1A5\",\r\n  rating400: \"#FFC043\",\r\n}\r\n\r\n// Theme overrides.\r\n// NOTE: A lot of the properties we can override here don't seem to actually\r\n// be used anywhere in BaseWeb's source. Will report a bug about it.\r\nconst themeOverrides = {\r\n  borders: {\r\n    radius100: borderRadius,\r\n    radius200: borderRadius,\r\n    radius300: borderRadius,\r\n    radius400: borderRadius,\r\n    buttonBorderRadius: borderRadius,\r\n    inputBorderRadius: borderRadius,\r\n    popoverBorderRadius: borderRadius,\r\n    surfaceBorderRadius: borderRadius,\r\n  },\r\n  typography: {\r\n    // Here we override some fonts that are used in widgets. We don't care\r\n    // about the ones that are not used.\r\n    font100: {},\r\n    font150: { ...fontStyles }, // Popup menus\r\n    font200: {},\r\n    font250: {},\r\n    font300: { ...fontStyles }, // Popup menus\r\n    font350: { ...fontStyles }, // Checkbox\r\n    font400: { ...fontStyles }, // Textinput, textarea, selectboxes\r\n    font450: { ...fontStyles }, // Radio\r\n    font460: { ...fontStyles }, // Calendar header buttons\r\n    font470: { ...fontStyles }, // Button\r\n    font500: { ...fontStyles }, // Selected items in selectbox\r\n    font600: {},\r\n\r\n    LabelXSmall: { ...fontStyles },\r\n    LabelSmall: { ...fontStyles },\r\n    LabelMedium: { ...fontStyles },\r\n    LabelLarge: { ...fontStyles },\r\n    ParagraphSmall: { ...fontStyles },\r\n  },\r\n\r\n  colors: {\r\n    white: white,\r\n    black: black,\r\n    primary: primary,\r\n    primaryA: primary,\r\n    accent: primaryA50,\r\n    tagPrimarySolidBackground: primary,\r\n    borderFocus: primary,\r\n    contentPrimary: black,\r\n    inputFill: grayLightest,\r\n    inputPlaceholder: grayDark,\r\n    inputBorder: grayLightest,\r\n    inputFillActive: grayLightest,\r\n    tickMarkFillDisabled: grayLighter,\r\n    tickFillDisabled: gray,\r\n    tickMarkFill: grayLightest,\r\n    tickFillSelected: primary,\r\n    calendarHeaderForegroundDisabled: grayLight,\r\n    calendarDayBackgroundSelected: primary,\r\n    calendarDayBackgroundSelectedHighlighted: primary,\r\n    calendarDayForegroundSelected: white,\r\n    calendarDayForegroundSelectedHighlighted: white,\r\n  },\r\n}\r\n\r\nexport const mainWidgetTheme = createTheme(mainThemePrimitives, themeOverrides)\r\n\r\nexport const sidebarWidgetTheme = createTheme(\r\n  {\r\n    ...mainThemePrimitives,\r\n\r\n    // Override gray values based on what is actually used in BaseWeb, and the\r\n    // way we want it to match our Bootstrap theme.\r\n    mono100: white, // Popup menu\r\n    mono200: white, // Text input, text area, selectbox\r\n    mono300: white, // Disabled widget background\r\n    mono400: grayLight, // Slider track\r\n  },\r\n  {\r\n    ...themeOverrides,\r\n    colors: {\r\n      ...themeOverrides.colors,\r\n      inputFill: white,\r\n      inputFillActive: white,\r\n    },\r\n  }\r\n)\r\n\r\n// Log the widget theme just for debug purposes.\r\nlogMessage(\"mainWidgetTheme\", mainWidgetTheme)\r\nlogMessage(\"sidebarWidgetTheme\", sidebarWidgetTheme)\r\n","/* eslint-disable */\n\n/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/\nimport * as $protobuf from \"protobufjs/minimal\";\n\n// Common aliases\nconst $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;\n\n// Exported root namespace\nconst $root = $protobuf.roots[\"default\"] || ($protobuf.roots[\"default\"] = {});\n\nexport const Alert = $root.Alert = (() => {\n\n    /**\n     * Properties of an Alert.\n     * @exports IAlert\n     * @interface IAlert\n     * @property {string|null} [body] Alert body\n     * @property {Alert.Format|null} [format] Alert format\n     */\n\n    /**\n     * Constructs a new Alert.\n     * @exports Alert\n     * @classdesc Represents an Alert.\n     * @implements IAlert\n     * @constructor\n     * @param {IAlert=} [properties] Properties to set\n     */\n    function Alert(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Alert body.\n     * @member {string} body\n     * @memberof Alert\n     * @instance\n     */\n    Alert.prototype.body = \"\";\n\n    /**\n     * Alert format.\n     * @member {Alert.Format} format\n     * @memberof Alert\n     * @instance\n     */\n    Alert.prototype.format = 0;\n\n    /**\n     * Creates a new Alert instance using the specified properties.\n     * @function create\n     * @memberof Alert\n     * @static\n     * @param {IAlert=} [properties] Properties to set\n     * @returns {Alert} Alert instance\n     */\n    Alert.create = function create(properties) {\n        return new Alert(properties);\n    };\n\n    /**\n     * Encodes the specified Alert message. Does not implicitly {@link Alert.verify|verify} messages.\n     * @function encode\n     * @memberof Alert\n     * @static\n     * @param {IAlert} message Alert message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Alert.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.body != null && Object.hasOwnProperty.call(message, \"body\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.body);\n        if (message.format != null && Object.hasOwnProperty.call(message, \"format\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.format);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Alert message, length delimited. Does not implicitly {@link Alert.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Alert\n     * @static\n     * @param {IAlert} message Alert message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Alert.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Alert message from the specified reader or buffer.\n     * @function decode\n     * @memberof Alert\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Alert} Alert\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Alert.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Alert();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.body = reader.string();\n                break;\n            case 2:\n                message.format = reader.int32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Alert message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Alert\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Alert} Alert\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Alert.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Alert message.\n     * @function verify\n     * @memberof Alert\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Alert.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            if (!$util.isString(message.body))\n                return \"body: string expected\";\n        if (message.format != null && message.hasOwnProperty(\"format\"))\n            switch (message.format) {\n            default:\n                return \"format: enum value expected\";\n            case 0:\n            case 1:\n            case 2:\n            case 3:\n            case 4:\n                break;\n            }\n        return null;\n    };\n\n    /**\n     * Creates an Alert message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Alert\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Alert} Alert\n     */\n    Alert.fromObject = function fromObject(object) {\n        if (object instanceof $root.Alert)\n            return object;\n        let message = new $root.Alert();\n        if (object.body != null)\n            message.body = String(object.body);\n        switch (object.format) {\n        case \"UNUSED\":\n        case 0:\n            message.format = 0;\n            break;\n        case \"ERROR\":\n        case 1:\n            message.format = 1;\n            break;\n        case \"WARNING\":\n        case 2:\n            message.format = 2;\n            break;\n        case \"INFO\":\n        case 3:\n            message.format = 3;\n            break;\n        case \"SUCCESS\":\n        case 4:\n            message.format = 4;\n            break;\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Alert message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Alert\n     * @static\n     * @param {Alert} message Alert\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Alert.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.body = \"\";\n            object.format = options.enums === String ? \"UNUSED\" : 0;\n        }\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            object.body = message.body;\n        if (message.format != null && message.hasOwnProperty(\"format\"))\n            object.format = options.enums === String ? $root.Alert.Format[message.format] : message.format;\n        return object;\n    };\n\n    /**\n     * Converts this Alert to JSON.\n     * @function toJSON\n     * @memberof Alert\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Alert.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Format enum.\n     * @name Alert.Format\n     * @enum {number}\n     * @property {number} UNUSED=0 UNUSED value\n     * @property {number} ERROR=1 ERROR value\n     * @property {number} WARNING=2 WARNING value\n     * @property {number} INFO=3 INFO value\n     * @property {number} SUCCESS=4 SUCCESS value\n     */\n    Alert.Format = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"UNUSED\"] = 0;\n        values[valuesById[1] = \"ERROR\"] = 1;\n        values[valuesById[2] = \"WARNING\"] = 2;\n        values[valuesById[3] = \"INFO\"] = 3;\n        values[valuesById[4] = \"SUCCESS\"] = 4;\n        return values;\n    })();\n\n    return Alert;\n})();\n\nexport const ArrowDataframe = $root.ArrowDataframe = (() => {\n\n    /**\n     * Properties of an ArrowDataframe.\n     * @exports IArrowDataframe\n     * @interface IArrowDataframe\n     * @property {IArrowTable|null} [data] ArrowDataframe data\n     * @property {number|null} [height] ArrowDataframe height\n     * @property {number|null} [width] ArrowDataframe width\n     */\n\n    /**\n     * Constructs a new ArrowDataframe.\n     * @exports ArrowDataframe\n     * @classdesc Represents an ArrowDataframe.\n     * @implements IArrowDataframe\n     * @constructor\n     * @param {IArrowDataframe=} [properties] Properties to set\n     */\n    function ArrowDataframe(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ArrowDataframe data.\n     * @member {IArrowTable|null|undefined} data\n     * @memberof ArrowDataframe\n     * @instance\n     */\n    ArrowDataframe.prototype.data = null;\n\n    /**\n     * ArrowDataframe height.\n     * @member {number} height\n     * @memberof ArrowDataframe\n     * @instance\n     */\n    ArrowDataframe.prototype.height = 0;\n\n    /**\n     * ArrowDataframe width.\n     * @member {number} width\n     * @memberof ArrowDataframe\n     * @instance\n     */\n    ArrowDataframe.prototype.width = 0;\n\n    /**\n     * Creates a new ArrowDataframe instance using the specified properties.\n     * @function create\n     * @memberof ArrowDataframe\n     * @static\n     * @param {IArrowDataframe=} [properties] Properties to set\n     * @returns {ArrowDataframe} ArrowDataframe instance\n     */\n    ArrowDataframe.create = function create(properties) {\n        return new ArrowDataframe(properties);\n    };\n\n    /**\n     * Encodes the specified ArrowDataframe message. Does not implicitly {@link ArrowDataframe.verify|verify} messages.\n     * @function encode\n     * @memberof ArrowDataframe\n     * @static\n     * @param {IArrowDataframe} message ArrowDataframe message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ArrowDataframe.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.ArrowTable.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.height != null && Object.hasOwnProperty.call(message, \"height\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.height);\n        if (message.width != null && Object.hasOwnProperty.call(message, \"width\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.width);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ArrowDataframe message, length delimited. Does not implicitly {@link ArrowDataframe.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ArrowDataframe\n     * @static\n     * @param {IArrowDataframe} message ArrowDataframe message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ArrowDataframe.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an ArrowDataframe message from the specified reader or buffer.\n     * @function decode\n     * @memberof ArrowDataframe\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ArrowDataframe} ArrowDataframe\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ArrowDataframe.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ArrowDataframe();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.ArrowTable.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.height = reader.uint32();\n                break;\n            case 3:\n                message.width = reader.uint32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an ArrowDataframe message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ArrowDataframe\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ArrowDataframe} ArrowDataframe\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ArrowDataframe.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an ArrowDataframe message.\n     * @function verify\n     * @memberof ArrowDataframe\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ArrowDataframe.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.ArrowTable.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            if (!$util.isInteger(message.height))\n                return \"height: integer expected\";\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            if (!$util.isInteger(message.width))\n                return \"width: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates an ArrowDataframe message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ArrowDataframe\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ArrowDataframe} ArrowDataframe\n     */\n    ArrowDataframe.fromObject = function fromObject(object) {\n        if (object instanceof $root.ArrowDataframe)\n            return object;\n        let message = new $root.ArrowDataframe();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".ArrowDataframe.data: object expected\");\n            message.data = $root.ArrowTable.fromObject(object.data);\n        }\n        if (object.height != null)\n            message.height = object.height >>> 0;\n        if (object.width != null)\n            message.width = object.width >>> 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an ArrowDataframe message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ArrowDataframe\n     * @static\n     * @param {ArrowDataframe} message ArrowDataframe\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ArrowDataframe.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.data = null;\n            object.height = 0;\n            object.width = 0;\n        }\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.ArrowTable.toObject(message.data, options);\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            object.height = message.height;\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            object.width = message.width;\n        return object;\n    };\n\n    /**\n     * Converts this ArrowDataframe to JSON.\n     * @function toJSON\n     * @memberof ArrowDataframe\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ArrowDataframe.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ArrowDataframe;\n})();\n\nexport const ArrowTable = $root.ArrowTable = (() => {\n\n    /**\n     * Properties of an ArrowTable.\n     * @exports IArrowTable\n     * @interface IArrowTable\n     * @property {Uint8Array|null} [data] ArrowTable data\n     * @property {Uint8Array|null} [index] ArrowTable index\n     * @property {Uint8Array|null} [columns] ArrowTable columns\n     * @property {IStyler|null} [styler] ArrowTable styler\n     */\n\n    /**\n     * Constructs a new ArrowTable.\n     * @exports ArrowTable\n     * @classdesc Represents an ArrowTable.\n     * @implements IArrowTable\n     * @constructor\n     * @param {IArrowTable=} [properties] Properties to set\n     */\n    function ArrowTable(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ArrowTable data.\n     * @member {Uint8Array} data\n     * @memberof ArrowTable\n     * @instance\n     */\n    ArrowTable.prototype.data = $util.newBuffer([]);\n\n    /**\n     * ArrowTable index.\n     * @member {Uint8Array} index\n     * @memberof ArrowTable\n     * @instance\n     */\n    ArrowTable.prototype.index = $util.newBuffer([]);\n\n    /**\n     * ArrowTable columns.\n     * @member {Uint8Array} columns\n     * @memberof ArrowTable\n     * @instance\n     */\n    ArrowTable.prototype.columns = $util.newBuffer([]);\n\n    /**\n     * ArrowTable styler.\n     * @member {IStyler|null|undefined} styler\n     * @memberof ArrowTable\n     * @instance\n     */\n    ArrowTable.prototype.styler = null;\n\n    /**\n     * Creates a new ArrowTable instance using the specified properties.\n     * @function create\n     * @memberof ArrowTable\n     * @static\n     * @param {IArrowTable=} [properties] Properties to set\n     * @returns {ArrowTable} ArrowTable instance\n     */\n    ArrowTable.create = function create(properties) {\n        return new ArrowTable(properties);\n    };\n\n    /**\n     * Encodes the specified ArrowTable message. Does not implicitly {@link ArrowTable.verify|verify} messages.\n     * @function encode\n     * @memberof ArrowTable\n     * @static\n     * @param {IArrowTable} message ArrowTable message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ArrowTable.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.data);\n        if (message.index != null && Object.hasOwnProperty.call(message, \"index\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.index);\n        if (message.columns != null && Object.hasOwnProperty.call(message, \"columns\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.columns);\n        if (message.styler != null && Object.hasOwnProperty.call(message, \"styler\"))\n            $root.Styler.encode(message.styler, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ArrowTable message, length delimited. Does not implicitly {@link ArrowTable.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ArrowTable\n     * @static\n     * @param {IArrowTable} message ArrowTable message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ArrowTable.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an ArrowTable message from the specified reader or buffer.\n     * @function decode\n     * @memberof ArrowTable\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ArrowTable} ArrowTable\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ArrowTable.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ArrowTable();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = reader.bytes();\n                break;\n            case 2:\n                message.index = reader.bytes();\n                break;\n            case 3:\n                message.columns = reader.bytes();\n                break;\n            case 5:\n                message.styler = $root.Styler.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an ArrowTable message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ArrowTable\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ArrowTable} ArrowTable\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ArrowTable.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an ArrowTable message.\n     * @function verify\n     * @memberof ArrowTable\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ArrowTable.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            if (!(message.data && typeof message.data.length === \"number\" || $util.isString(message.data)))\n                return \"data: buffer expected\";\n        if (message.index != null && message.hasOwnProperty(\"index\"))\n            if (!(message.index && typeof message.index.length === \"number\" || $util.isString(message.index)))\n                return \"index: buffer expected\";\n        if (message.columns != null && message.hasOwnProperty(\"columns\"))\n            if (!(message.columns && typeof message.columns.length === \"number\" || $util.isString(message.columns)))\n                return \"columns: buffer expected\";\n        if (message.styler != null && message.hasOwnProperty(\"styler\")) {\n            let error = $root.Styler.verify(message.styler);\n            if (error)\n                return \"styler.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates an ArrowTable message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ArrowTable\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ArrowTable} ArrowTable\n     */\n    ArrowTable.fromObject = function fromObject(object) {\n        if (object instanceof $root.ArrowTable)\n            return object;\n        let message = new $root.ArrowTable();\n        if (object.data != null)\n            if (typeof object.data === \"string\")\n                $util.base64.decode(object.data, message.data = $util.newBuffer($util.base64.length(object.data)), 0);\n            else if (object.data.length)\n                message.data = object.data;\n        if (object.index != null)\n            if (typeof object.index === \"string\")\n                $util.base64.decode(object.index, message.index = $util.newBuffer($util.base64.length(object.index)), 0);\n            else if (object.index.length)\n                message.index = object.index;\n        if (object.columns != null)\n            if (typeof object.columns === \"string\")\n                $util.base64.decode(object.columns, message.columns = $util.newBuffer($util.base64.length(object.columns)), 0);\n            else if (object.columns.length)\n                message.columns = object.columns;\n        if (object.styler != null) {\n            if (typeof object.styler !== \"object\")\n                throw TypeError(\".ArrowTable.styler: object expected\");\n            message.styler = $root.Styler.fromObject(object.styler);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an ArrowTable message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ArrowTable\n     * @static\n     * @param {ArrowTable} message ArrowTable\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ArrowTable.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            if (options.bytes === String)\n                object.data = \"\";\n            else {\n                object.data = [];\n                if (options.bytes !== Array)\n                    object.data = $util.newBuffer(object.data);\n            }\n            if (options.bytes === String)\n                object.index = \"\";\n            else {\n                object.index = [];\n                if (options.bytes !== Array)\n                    object.index = $util.newBuffer(object.index);\n            }\n            if (options.bytes === String)\n                object.columns = \"\";\n            else {\n                object.columns = [];\n                if (options.bytes !== Array)\n                    object.columns = $util.newBuffer(object.columns);\n            }\n            object.styler = null;\n        }\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = options.bytes === String ? $util.base64.encode(message.data, 0, message.data.length) : options.bytes === Array ? Array.prototype.slice.call(message.data) : message.data;\n        if (message.index != null && message.hasOwnProperty(\"index\"))\n            object.index = options.bytes === String ? $util.base64.encode(message.index, 0, message.index.length) : options.bytes === Array ? Array.prototype.slice.call(message.index) : message.index;\n        if (message.columns != null && message.hasOwnProperty(\"columns\"))\n            object.columns = options.bytes === String ? $util.base64.encode(message.columns, 0, message.columns.length) : options.bytes === Array ? Array.prototype.slice.call(message.columns) : message.columns;\n        if (message.styler != null && message.hasOwnProperty(\"styler\"))\n            object.styler = $root.Styler.toObject(message.styler, options);\n        return object;\n    };\n\n    /**\n     * Converts this ArrowTable to JSON.\n     * @function toJSON\n     * @memberof ArrowTable\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ArrowTable.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ArrowTable;\n})();\n\nexport const Styler = $root.Styler = (() => {\n\n    /**\n     * Properties of a Styler.\n     * @exports IStyler\n     * @interface IStyler\n     * @property {string|null} [uuid] Styler uuid\n     * @property {string|null} [caption] Styler caption\n     * @property {string|null} [styles] Styler styles\n     * @property {Uint8Array|null} [displayValues] Styler displayValues\n     */\n\n    /**\n     * Constructs a new Styler.\n     * @exports Styler\n     * @classdesc Represents a Styler.\n     * @implements IStyler\n     * @constructor\n     * @param {IStyler=} [properties] Properties to set\n     */\n    function Styler(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Styler uuid.\n     * @member {string} uuid\n     * @memberof Styler\n     * @instance\n     */\n    Styler.prototype.uuid = \"\";\n\n    /**\n     * Styler caption.\n     * @member {string} caption\n     * @memberof Styler\n     * @instance\n     */\n    Styler.prototype.caption = \"\";\n\n    /**\n     * Styler styles.\n     * @member {string} styles\n     * @memberof Styler\n     * @instance\n     */\n    Styler.prototype.styles = \"\";\n\n    /**\n     * Styler displayValues.\n     * @member {Uint8Array} displayValues\n     * @memberof Styler\n     * @instance\n     */\n    Styler.prototype.displayValues = $util.newBuffer([]);\n\n    /**\n     * Creates a new Styler instance using the specified properties.\n     * @function create\n     * @memberof Styler\n     * @static\n     * @param {IStyler=} [properties] Properties to set\n     * @returns {Styler} Styler instance\n     */\n    Styler.create = function create(properties) {\n        return new Styler(properties);\n    };\n\n    /**\n     * Encodes the specified Styler message. Does not implicitly {@link Styler.verify|verify} messages.\n     * @function encode\n     * @memberof Styler\n     * @static\n     * @param {IStyler} message Styler message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Styler.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.uuid != null && Object.hasOwnProperty.call(message, \"uuid\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.uuid);\n        if (message.caption != null && Object.hasOwnProperty.call(message, \"caption\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.caption);\n        if (message.styles != null && Object.hasOwnProperty.call(message, \"styles\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message.styles);\n        if (message.displayValues != null && Object.hasOwnProperty.call(message, \"displayValues\"))\n            writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.displayValues);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Styler message, length delimited. Does not implicitly {@link Styler.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Styler\n     * @static\n     * @param {IStyler} message Styler message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Styler.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Styler message from the specified reader or buffer.\n     * @function decode\n     * @memberof Styler\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Styler} Styler\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Styler.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Styler();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.uuid = reader.string();\n                break;\n            case 2:\n                message.caption = reader.string();\n                break;\n            case 3:\n                message.styles = reader.string();\n                break;\n            case 4:\n                message.displayValues = reader.bytes();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Styler message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Styler\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Styler} Styler\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Styler.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Styler message.\n     * @function verify\n     * @memberof Styler\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Styler.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.uuid != null && message.hasOwnProperty(\"uuid\"))\n            if (!$util.isString(message.uuid))\n                return \"uuid: string expected\";\n        if (message.caption != null && message.hasOwnProperty(\"caption\"))\n            if (!$util.isString(message.caption))\n                return \"caption: string expected\";\n        if (message.styles != null && message.hasOwnProperty(\"styles\"))\n            if (!$util.isString(message.styles))\n                return \"styles: string expected\";\n        if (message.displayValues != null && message.hasOwnProperty(\"displayValues\"))\n            if (!(message.displayValues && typeof message.displayValues.length === \"number\" || $util.isString(message.displayValues)))\n                return \"displayValues: buffer expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Styler message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Styler\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Styler} Styler\n     */\n    Styler.fromObject = function fromObject(object) {\n        if (object instanceof $root.Styler)\n            return object;\n        let message = new $root.Styler();\n        if (object.uuid != null)\n            message.uuid = String(object.uuid);\n        if (object.caption != null)\n            message.caption = String(object.caption);\n        if (object.styles != null)\n            message.styles = String(object.styles);\n        if (object.displayValues != null)\n            if (typeof object.displayValues === \"string\")\n                $util.base64.decode(object.displayValues, message.displayValues = $util.newBuffer($util.base64.length(object.displayValues)), 0);\n            else if (object.displayValues.length)\n                message.displayValues = object.displayValues;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Styler message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Styler\n     * @static\n     * @param {Styler} message Styler\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Styler.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.uuid = \"\";\n            object.caption = \"\";\n            object.styles = \"\";\n            if (options.bytes === String)\n                object.displayValues = \"\";\n            else {\n                object.displayValues = [];\n                if (options.bytes !== Array)\n                    object.displayValues = $util.newBuffer(object.displayValues);\n            }\n        }\n        if (message.uuid != null && message.hasOwnProperty(\"uuid\"))\n            object.uuid = message.uuid;\n        if (message.caption != null && message.hasOwnProperty(\"caption\"))\n            object.caption = message.caption;\n        if (message.styles != null && message.hasOwnProperty(\"styles\"))\n            object.styles = message.styles;\n        if (message.displayValues != null && message.hasOwnProperty(\"displayValues\"))\n            object.displayValues = options.bytes === String ? $util.base64.encode(message.displayValues, 0, message.displayValues.length) : options.bytes === Array ? Array.prototype.slice.call(message.displayValues) : message.displayValues;\n        return object;\n    };\n\n    /**\n     * Converts this Styler to JSON.\n     * @function toJSON\n     * @memberof Styler\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Styler.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Styler;\n})();\n\nexport const Audio = $root.Audio = (() => {\n\n    /**\n     * Properties of an Audio.\n     * @exports IAudio\n     * @interface IAudio\n     * @property {string|null} [url] Audio url\n     * @property {number|null} [startTime] Audio startTime\n     */\n\n    /**\n     * Constructs a new Audio.\n     * @exports Audio\n     * @classdesc Represents an Audio.\n     * @implements IAudio\n     * @constructor\n     * @param {IAudio=} [properties] Properties to set\n     */\n    function Audio(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Audio url.\n     * @member {string} url\n     * @memberof Audio\n     * @instance\n     */\n    Audio.prototype.url = \"\";\n\n    /**\n     * Audio startTime.\n     * @member {number} startTime\n     * @memberof Audio\n     * @instance\n     */\n    Audio.prototype.startTime = 0;\n\n    /**\n     * Creates a new Audio instance using the specified properties.\n     * @function create\n     * @memberof Audio\n     * @static\n     * @param {IAudio=} [properties] Properties to set\n     * @returns {Audio} Audio instance\n     */\n    Audio.create = function create(properties) {\n        return new Audio(properties);\n    };\n\n    /**\n     * Encodes the specified Audio message. Does not implicitly {@link Audio.verify|verify} messages.\n     * @function encode\n     * @memberof Audio\n     * @static\n     * @param {IAudio} message Audio message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Audio.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.startTime != null && Object.hasOwnProperty.call(message, \"startTime\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.startTime);\n        if (message.url != null && Object.hasOwnProperty.call(message, \"url\"))\n            writer.uint32(/* id 5, wireType 2 =*/42).string(message.url);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Audio message, length delimited. Does not implicitly {@link Audio.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Audio\n     * @static\n     * @param {IAudio} message Audio message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Audio.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Audio message from the specified reader or buffer.\n     * @function decode\n     * @memberof Audio\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Audio} Audio\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Audio.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Audio();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 5:\n                message.url = reader.string();\n                break;\n            case 3:\n                message.startTime = reader.int32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Audio message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Audio\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Audio} Audio\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Audio.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Audio message.\n     * @function verify\n     * @memberof Audio\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Audio.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            if (!$util.isString(message.url))\n                return \"url: string expected\";\n        if (message.startTime != null && message.hasOwnProperty(\"startTime\"))\n            if (!$util.isInteger(message.startTime))\n                return \"startTime: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates an Audio message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Audio\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Audio} Audio\n     */\n    Audio.fromObject = function fromObject(object) {\n        if (object instanceof $root.Audio)\n            return object;\n        let message = new $root.Audio();\n        if (object.url != null)\n            message.url = String(object.url);\n        if (object.startTime != null)\n            message.startTime = object.startTime | 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Audio message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Audio\n     * @static\n     * @param {Audio} message Audio\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Audio.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.startTime = 0;\n            object.url = \"\";\n        }\n        if (message.startTime != null && message.hasOwnProperty(\"startTime\"))\n            object.startTime = message.startTime;\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            object.url = message.url;\n        return object;\n    };\n\n    /**\n     * Converts this Audio to JSON.\n     * @function toJSON\n     * @memberof Audio\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Audio.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Audio;\n})();\n\nexport const BackMsg = $root.BackMsg = (() => {\n\n    /**\n     * Properties of a BackMsg.\n     * @exports IBackMsg\n     * @interface IBackMsg\n     * @property {boolean|null} [cloudUpload] BackMsg cloudUpload\n     * @property {boolean|null} [rerunScript] BackMsg rerunScript\n     * @property {boolean|null} [clearCache] BackMsg clearCache\n     * @property {boolean|null} [setRunOnSave] BackMsg setRunOnSave\n     * @property {boolean|null} [stopReport] BackMsg stopReport\n     * @property {IWidgetStates|null} [updateWidgets] BackMsg updateWidgets\n     * @property {boolean|null} [closeConnection] BackMsg closeConnection\n     */\n\n    /**\n     * Constructs a new BackMsg.\n     * @exports BackMsg\n     * @classdesc Represents a BackMsg.\n     * @implements IBackMsg\n     * @constructor\n     * @param {IBackMsg=} [properties] Properties to set\n     */\n    function BackMsg(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * BackMsg cloudUpload.\n     * @member {boolean} cloudUpload\n     * @memberof BackMsg\n     * @instance\n     */\n    BackMsg.prototype.cloudUpload = false;\n\n    /**\n     * BackMsg rerunScript.\n     * @member {boolean} rerunScript\n     * @memberof BackMsg\n     * @instance\n     */\n    BackMsg.prototype.rerunScript = false;\n\n    /**\n     * BackMsg clearCache.\n     * @member {boolean} clearCache\n     * @memberof BackMsg\n     * @instance\n     */\n    BackMsg.prototype.clearCache = false;\n\n    /**\n     * BackMsg setRunOnSave.\n     * @member {boolean} setRunOnSave\n     * @memberof BackMsg\n     * @instance\n     */\n    BackMsg.prototype.setRunOnSave = false;\n\n    /**\n     * BackMsg stopReport.\n     * @member {boolean} stopReport\n     * @memberof BackMsg\n     * @instance\n     */\n    BackMsg.prototype.stopReport = false;\n\n    /**\n     * BackMsg updateWidgets.\n     * @member {IWidgetStates|null|undefined} updateWidgets\n     * @memberof BackMsg\n     * @instance\n     */\n    BackMsg.prototype.updateWidgets = null;\n\n    /**\n     * BackMsg closeConnection.\n     * @member {boolean} closeConnection\n     * @memberof BackMsg\n     * @instance\n     */\n    BackMsg.prototype.closeConnection = false;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * BackMsg type.\n     * @member {\"cloudUpload\"|\"rerunScript\"|\"clearCache\"|\"setRunOnSave\"|\"stopReport\"|\"updateWidgets\"|\"closeConnection\"|undefined} type\n     * @memberof BackMsg\n     * @instance\n     */\n    Object.defineProperty(BackMsg.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"cloudUpload\", \"rerunScript\", \"clearCache\", \"setRunOnSave\", \"stopReport\", \"updateWidgets\", \"closeConnection\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new BackMsg instance using the specified properties.\n     * @function create\n     * @memberof BackMsg\n     * @static\n     * @param {IBackMsg=} [properties] Properties to set\n     * @returns {BackMsg} BackMsg instance\n     */\n    BackMsg.create = function create(properties) {\n        return new BackMsg(properties);\n    };\n\n    /**\n     * Encodes the specified BackMsg message. Does not implicitly {@link BackMsg.verify|verify} messages.\n     * @function encode\n     * @memberof BackMsg\n     * @static\n     * @param {IBackMsg} message BackMsg message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    BackMsg.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.cloudUpload != null && Object.hasOwnProperty.call(message, \"cloudUpload\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.cloudUpload);\n        if (message.rerunScript != null && Object.hasOwnProperty.call(message, \"rerunScript\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.rerunScript);\n        if (message.clearCache != null && Object.hasOwnProperty.call(message, \"clearCache\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).bool(message.clearCache);\n        if (message.setRunOnSave != null && Object.hasOwnProperty.call(message, \"setRunOnSave\"))\n            writer.uint32(/* id 6, wireType 0 =*/48).bool(message.setRunOnSave);\n        if (message.stopReport != null && Object.hasOwnProperty.call(message, \"stopReport\"))\n            writer.uint32(/* id 7, wireType 0 =*/56).bool(message.stopReport);\n        if (message.updateWidgets != null && Object.hasOwnProperty.call(message, \"updateWidgets\"))\n            $root.WidgetStates.encode(message.updateWidgets, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();\n        if (message.closeConnection != null && Object.hasOwnProperty.call(message, \"closeConnection\"))\n            writer.uint32(/* id 10, wireType 0 =*/80).bool(message.closeConnection);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified BackMsg message, length delimited. Does not implicitly {@link BackMsg.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof BackMsg\n     * @static\n     * @param {IBackMsg} message BackMsg message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    BackMsg.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a BackMsg message from the specified reader or buffer.\n     * @function decode\n     * @memberof BackMsg\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {BackMsg} BackMsg\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    BackMsg.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.BackMsg();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 2:\n                message.cloudUpload = reader.bool();\n                break;\n            case 3:\n                message.rerunScript = reader.bool();\n                break;\n            case 5:\n                message.clearCache = reader.bool();\n                break;\n            case 6:\n                message.setRunOnSave = reader.bool();\n                break;\n            case 7:\n                message.stopReport = reader.bool();\n                break;\n            case 9:\n                message.updateWidgets = $root.WidgetStates.decode(reader, reader.uint32());\n                break;\n            case 10:\n                message.closeConnection = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a BackMsg message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof BackMsg\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {BackMsg} BackMsg\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    BackMsg.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a BackMsg message.\n     * @function verify\n     * @memberof BackMsg\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    BackMsg.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.cloudUpload != null && message.hasOwnProperty(\"cloudUpload\")) {\n            properties.type = 1;\n            if (typeof message.cloudUpload !== \"boolean\")\n                return \"cloudUpload: boolean expected\";\n        }\n        if (message.rerunScript != null && message.hasOwnProperty(\"rerunScript\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (typeof message.rerunScript !== \"boolean\")\n                return \"rerunScript: boolean expected\";\n        }\n        if (message.clearCache != null && message.hasOwnProperty(\"clearCache\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (typeof message.clearCache !== \"boolean\")\n                return \"clearCache: boolean expected\";\n        }\n        if (message.setRunOnSave != null && message.hasOwnProperty(\"setRunOnSave\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (typeof message.setRunOnSave !== \"boolean\")\n                return \"setRunOnSave: boolean expected\";\n        }\n        if (message.stopReport != null && message.hasOwnProperty(\"stopReport\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (typeof message.stopReport !== \"boolean\")\n                return \"stopReport: boolean expected\";\n        }\n        if (message.updateWidgets != null && message.hasOwnProperty(\"updateWidgets\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.WidgetStates.verify(message.updateWidgets);\n                if (error)\n                    return \"updateWidgets.\" + error;\n            }\n        }\n        if (message.closeConnection != null && message.hasOwnProperty(\"closeConnection\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (typeof message.closeConnection !== \"boolean\")\n                return \"closeConnection: boolean expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a BackMsg message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof BackMsg\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {BackMsg} BackMsg\n     */\n    BackMsg.fromObject = function fromObject(object) {\n        if (object instanceof $root.BackMsg)\n            return object;\n        let message = new $root.BackMsg();\n        if (object.cloudUpload != null)\n            message.cloudUpload = Boolean(object.cloudUpload);\n        if (object.rerunScript != null)\n            message.rerunScript = Boolean(object.rerunScript);\n        if (object.clearCache != null)\n            message.clearCache = Boolean(object.clearCache);\n        if (object.setRunOnSave != null)\n            message.setRunOnSave = Boolean(object.setRunOnSave);\n        if (object.stopReport != null)\n            message.stopReport = Boolean(object.stopReport);\n        if (object.updateWidgets != null) {\n            if (typeof object.updateWidgets !== \"object\")\n                throw TypeError(\".BackMsg.updateWidgets: object expected\");\n            message.updateWidgets = $root.WidgetStates.fromObject(object.updateWidgets);\n        }\n        if (object.closeConnection != null)\n            message.closeConnection = Boolean(object.closeConnection);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a BackMsg message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof BackMsg\n     * @static\n     * @param {BackMsg} message BackMsg\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    BackMsg.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (message.cloudUpload != null && message.hasOwnProperty(\"cloudUpload\")) {\n            object.cloudUpload = message.cloudUpload;\n            if (options.oneofs)\n                object.type = \"cloudUpload\";\n        }\n        if (message.rerunScript != null && message.hasOwnProperty(\"rerunScript\")) {\n            object.rerunScript = message.rerunScript;\n            if (options.oneofs)\n                object.type = \"rerunScript\";\n        }\n        if (message.clearCache != null && message.hasOwnProperty(\"clearCache\")) {\n            object.clearCache = message.clearCache;\n            if (options.oneofs)\n                object.type = \"clearCache\";\n        }\n        if (message.setRunOnSave != null && message.hasOwnProperty(\"setRunOnSave\")) {\n            object.setRunOnSave = message.setRunOnSave;\n            if (options.oneofs)\n                object.type = \"setRunOnSave\";\n        }\n        if (message.stopReport != null && message.hasOwnProperty(\"stopReport\")) {\n            object.stopReport = message.stopReport;\n            if (options.oneofs)\n                object.type = \"stopReport\";\n        }\n        if (message.updateWidgets != null && message.hasOwnProperty(\"updateWidgets\")) {\n            object.updateWidgets = $root.WidgetStates.toObject(message.updateWidgets, options);\n            if (options.oneofs)\n                object.type = \"updateWidgets\";\n        }\n        if (message.closeConnection != null && message.hasOwnProperty(\"closeConnection\")) {\n            object.closeConnection = message.closeConnection;\n            if (options.oneofs)\n                object.type = \"closeConnection\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this BackMsg to JSON.\n     * @function toJSON\n     * @memberof BackMsg\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    BackMsg.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return BackMsg;\n})();\n\nexport const Balloons = $root.Balloons = (() => {\n\n    /**\n     * Properties of a Balloons.\n     * @exports IBalloons\n     * @interface IBalloons\n     * @property {Balloons.Type|null} [type] Balloons type\n     * @property {number|null} [executionId] Balloons executionId\n     */\n\n    /**\n     * Constructs a new Balloons.\n     * @exports Balloons\n     * @classdesc Represents a Balloons.\n     * @implements IBalloons\n     * @constructor\n     * @param {IBalloons=} [properties] Properties to set\n     */\n    function Balloons(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Balloons type.\n     * @member {Balloons.Type} type\n     * @memberof Balloons\n     * @instance\n     */\n    Balloons.prototype.type = 0;\n\n    /**\n     * Balloons executionId.\n     * @member {number} executionId\n     * @memberof Balloons\n     * @instance\n     */\n    Balloons.prototype.executionId = 0;\n\n    /**\n     * Creates a new Balloons instance using the specified properties.\n     * @function create\n     * @memberof Balloons\n     * @static\n     * @param {IBalloons=} [properties] Properties to set\n     * @returns {Balloons} Balloons instance\n     */\n    Balloons.create = function create(properties) {\n        return new Balloons(properties);\n    };\n\n    /**\n     * Encodes the specified Balloons message. Does not implicitly {@link Balloons.verify|verify} messages.\n     * @function encode\n     * @memberof Balloons\n     * @static\n     * @param {IBalloons} message Balloons message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Balloons.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.type != null && Object.hasOwnProperty.call(message, \"type\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);\n        if (message.executionId != null && Object.hasOwnProperty.call(message, \"executionId\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.executionId);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Balloons message, length delimited. Does not implicitly {@link Balloons.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Balloons\n     * @static\n     * @param {IBalloons} message Balloons message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Balloons.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Balloons message from the specified reader or buffer.\n     * @function decode\n     * @memberof Balloons\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Balloons} Balloons\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Balloons.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Balloons();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.type = reader.int32();\n                break;\n            case 2:\n                message.executionId = reader.uint32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Balloons message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Balloons\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Balloons} Balloons\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Balloons.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Balloons message.\n     * @function verify\n     * @memberof Balloons\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Balloons.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            switch (message.type) {\n            default:\n                return \"type: enum value expected\";\n            case 0:\n            case 1:\n            case 2:\n            case 3:\n            case 4:\n                break;\n            }\n        if (message.executionId != null && message.hasOwnProperty(\"executionId\"))\n            if (!$util.isInteger(message.executionId))\n                return \"executionId: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Balloons message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Balloons\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Balloons} Balloons\n     */\n    Balloons.fromObject = function fromObject(object) {\n        if (object instanceof $root.Balloons)\n            return object;\n        let message = new $root.Balloons();\n        switch (object.type) {\n        case \"DEFAULT\":\n        case 0:\n            message.type = 0;\n            break;\n        case \"BALLOON\":\n        case 1:\n            message.type = 1;\n            break;\n        case \"HAPPY_FACE\":\n        case 2:\n            message.type = 2;\n            break;\n        case \"STAR_FACE\":\n        case 3:\n            message.type = 3;\n            break;\n        case \"COOL_FACE\":\n        case 4:\n            message.type = 4;\n            break;\n        }\n        if (object.executionId != null)\n            message.executionId = object.executionId >>> 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Balloons message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Balloons\n     * @static\n     * @param {Balloons} message Balloons\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Balloons.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.type = options.enums === String ? \"DEFAULT\" : 0;\n            object.executionId = 0;\n        }\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            object.type = options.enums === String ? $root.Balloons.Type[message.type] : message.type;\n        if (message.executionId != null && message.hasOwnProperty(\"executionId\"))\n            object.executionId = message.executionId;\n        return object;\n    };\n\n    /**\n     * Converts this Balloons to JSON.\n     * @function toJSON\n     * @memberof Balloons\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Balloons.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Type enum.\n     * @name Balloons.Type\n     * @enum {number}\n     * @property {number} DEFAULT=0 DEFAULT value\n     * @property {number} BALLOON=1 BALLOON value\n     * @property {number} HAPPY_FACE=2 HAPPY_FACE value\n     * @property {number} STAR_FACE=3 STAR_FACE value\n     * @property {number} COOL_FACE=4 COOL_FACE value\n     */\n    Balloons.Type = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"DEFAULT\"] = 0;\n        values[valuesById[1] = \"BALLOON\"] = 1;\n        values[valuesById[2] = \"HAPPY_FACE\"] = 2;\n        values[valuesById[3] = \"STAR_FACE\"] = 3;\n        values[valuesById[4] = \"COOL_FACE\"] = 4;\n        return values;\n    })();\n\n    return Balloons;\n})();\n\nexport const BlockPath = $root.BlockPath = (() => {\n\n    /**\n     * Properties of a BlockPath.\n     * @exports IBlockPath\n     * @interface IBlockPath\n     * @property {BlockPath.Container|null} [container] BlockPath container\n     * @property {Array.<number>|null} [path] BlockPath path\n     */\n\n    /**\n     * Constructs a new BlockPath.\n     * @exports BlockPath\n     * @classdesc Represents a BlockPath.\n     * @implements IBlockPath\n     * @constructor\n     * @param {IBlockPath=} [properties] Properties to set\n     */\n    function BlockPath(properties) {\n        this.path = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * BlockPath container.\n     * @member {BlockPath.Container} container\n     * @memberof BlockPath\n     * @instance\n     */\n    BlockPath.prototype.container = 0;\n\n    /**\n     * BlockPath path.\n     * @member {Array.<number>} path\n     * @memberof BlockPath\n     * @instance\n     */\n    BlockPath.prototype.path = $util.emptyArray;\n\n    /**\n     * Creates a new BlockPath instance using the specified properties.\n     * @function create\n     * @memberof BlockPath\n     * @static\n     * @param {IBlockPath=} [properties] Properties to set\n     * @returns {BlockPath} BlockPath instance\n     */\n    BlockPath.create = function create(properties) {\n        return new BlockPath(properties);\n    };\n\n    /**\n     * Encodes the specified BlockPath message. Does not implicitly {@link BlockPath.verify|verify} messages.\n     * @function encode\n     * @memberof BlockPath\n     * @static\n     * @param {IBlockPath} message BlockPath message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    BlockPath.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.container != null && Object.hasOwnProperty.call(message, \"container\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.container);\n        if (message.path != null && message.path.length) {\n            writer.uint32(/* id 2, wireType 2 =*/18).fork();\n            for (let i = 0; i < message.path.length; ++i)\n                writer.uint32(message.path[i]);\n            writer.ldelim();\n        }\n        return writer;\n    };\n\n    /**\n     * Encodes the specified BlockPath message, length delimited. Does not implicitly {@link BlockPath.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof BlockPath\n     * @static\n     * @param {IBlockPath} message BlockPath message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    BlockPath.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a BlockPath message from the specified reader or buffer.\n     * @function decode\n     * @memberof BlockPath\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {BlockPath} BlockPath\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    BlockPath.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.BlockPath();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.container = reader.int32();\n                break;\n            case 2:\n                if (!(message.path && message.path.length))\n                    message.path = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message.path.push(reader.uint32());\n                } else\n                    message.path.push(reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a BlockPath message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof BlockPath\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {BlockPath} BlockPath\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    BlockPath.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a BlockPath message.\n     * @function verify\n     * @memberof BlockPath\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    BlockPath.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.container != null && message.hasOwnProperty(\"container\"))\n            switch (message.container) {\n            default:\n                return \"container: enum value expected\";\n            case 0:\n            case 1:\n            case 2:\n                break;\n            }\n        if (message.path != null && message.hasOwnProperty(\"path\")) {\n            if (!Array.isArray(message.path))\n                return \"path: array expected\";\n            for (let i = 0; i < message.path.length; ++i)\n                if (!$util.isInteger(message.path[i]))\n                    return \"path: integer[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a BlockPath message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof BlockPath\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {BlockPath} BlockPath\n     */\n    BlockPath.fromObject = function fromObject(object) {\n        if (object instanceof $root.BlockPath)\n            return object;\n        let message = new $root.BlockPath();\n        switch (object.container) {\n        case \"UNUSED\":\n        case 0:\n            message.container = 0;\n            break;\n        case \"MAIN\":\n        case 1:\n            message.container = 1;\n            break;\n        case \"SIDEBAR\":\n        case 2:\n            message.container = 2;\n            break;\n        }\n        if (object.path) {\n            if (!Array.isArray(object.path))\n                throw TypeError(\".BlockPath.path: array expected\");\n            message.path = [];\n            for (let i = 0; i < object.path.length; ++i)\n                message.path[i] = object.path[i] >>> 0;\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a BlockPath message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof BlockPath\n     * @static\n     * @param {BlockPath} message BlockPath\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    BlockPath.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.path = [];\n        if (options.defaults)\n            object.container = options.enums === String ? \"UNUSED\" : 0;\n        if (message.container != null && message.hasOwnProperty(\"container\"))\n            object.container = options.enums === String ? $root.BlockPath.Container[message.container] : message.container;\n        if (message.path && message.path.length) {\n            object.path = [];\n            for (let j = 0; j < message.path.length; ++j)\n                object.path[j] = message.path[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this BlockPath to JSON.\n     * @function toJSON\n     * @memberof BlockPath\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    BlockPath.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Container enum.\n     * @name BlockPath.Container\n     * @enum {number}\n     * @property {number} UNUSED=0 UNUSED value\n     * @property {number} MAIN=1 MAIN value\n     * @property {number} SIDEBAR=2 SIDEBAR value\n     */\n    BlockPath.Container = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"UNUSED\"] = 0;\n        values[valuesById[1] = \"MAIN\"] = 1;\n        values[valuesById[2] = \"SIDEBAR\"] = 2;\n        return values;\n    })();\n\n    return BlockPath;\n})();\n\nexport const BokehChart = $root.BokehChart = (() => {\n\n    /**\n     * Properties of a BokehChart.\n     * @exports IBokehChart\n     * @interface IBokehChart\n     * @property {string|null} [figure] BokehChart figure\n     * @property {boolean|null} [useContainerWidth] BokehChart useContainerWidth\n     */\n\n    /**\n     * Constructs a new BokehChart.\n     * @exports BokehChart\n     * @classdesc Represents a BokehChart.\n     * @implements IBokehChart\n     * @constructor\n     * @param {IBokehChart=} [properties] Properties to set\n     */\n    function BokehChart(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * BokehChart figure.\n     * @member {string} figure\n     * @memberof BokehChart\n     * @instance\n     */\n    BokehChart.prototype.figure = \"\";\n\n    /**\n     * BokehChart useContainerWidth.\n     * @member {boolean} useContainerWidth\n     * @memberof BokehChart\n     * @instance\n     */\n    BokehChart.prototype.useContainerWidth = false;\n\n    /**\n     * Creates a new BokehChart instance using the specified properties.\n     * @function create\n     * @memberof BokehChart\n     * @static\n     * @param {IBokehChart=} [properties] Properties to set\n     * @returns {BokehChart} BokehChart instance\n     */\n    BokehChart.create = function create(properties) {\n        return new BokehChart(properties);\n    };\n\n    /**\n     * Encodes the specified BokehChart message. Does not implicitly {@link BokehChart.verify|verify} messages.\n     * @function encode\n     * @memberof BokehChart\n     * @static\n     * @param {IBokehChart} message BokehChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    BokehChart.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.figure != null && Object.hasOwnProperty.call(message, \"figure\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.figure);\n        if (message.useContainerWidth != null && Object.hasOwnProperty.call(message, \"useContainerWidth\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.useContainerWidth);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified BokehChart message, length delimited. Does not implicitly {@link BokehChart.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof BokehChart\n     * @static\n     * @param {IBokehChart} message BokehChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    BokehChart.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a BokehChart message from the specified reader or buffer.\n     * @function decode\n     * @memberof BokehChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {BokehChart} BokehChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    BokehChart.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.BokehChart();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.figure = reader.string();\n                break;\n            case 2:\n                message.useContainerWidth = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a BokehChart message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof BokehChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {BokehChart} BokehChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    BokehChart.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a BokehChart message.\n     * @function verify\n     * @memberof BokehChart\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    BokehChart.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.figure != null && message.hasOwnProperty(\"figure\"))\n            if (!$util.isString(message.figure))\n                return \"figure: string expected\";\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            if (typeof message.useContainerWidth !== \"boolean\")\n                return \"useContainerWidth: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a BokehChart message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof BokehChart\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {BokehChart} BokehChart\n     */\n    BokehChart.fromObject = function fromObject(object) {\n        if (object instanceof $root.BokehChart)\n            return object;\n        let message = new $root.BokehChart();\n        if (object.figure != null)\n            message.figure = String(object.figure);\n        if (object.useContainerWidth != null)\n            message.useContainerWidth = Boolean(object.useContainerWidth);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a BokehChart message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof BokehChart\n     * @static\n     * @param {BokehChart} message BokehChart\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    BokehChart.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.figure = \"\";\n            object.useContainerWidth = false;\n        }\n        if (message.figure != null && message.hasOwnProperty(\"figure\"))\n            object.figure = message.figure;\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            object.useContainerWidth = message.useContainerWidth;\n        return object;\n    };\n\n    /**\n     * Converts this BokehChart to JSON.\n     * @function toJSON\n     * @memberof BokehChart\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    BokehChart.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return BokehChart;\n})();\n\nexport const Button = $root.Button = (() => {\n\n    /**\n     * Properties of a Button.\n     * @exports IButton\n     * @interface IButton\n     * @property {string|null} [id] Button id\n     * @property {string|null} [label] Button label\n     * @property {boolean|null} [\"default\"] Button default\n     */\n\n    /**\n     * Constructs a new Button.\n     * @exports Button\n     * @classdesc Represents a Button.\n     * @implements IButton\n     * @constructor\n     * @param {IButton=} [properties] Properties to set\n     */\n    function Button(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Button id.\n     * @member {string} id\n     * @memberof Button\n     * @instance\n     */\n    Button.prototype.id = \"\";\n\n    /**\n     * Button label.\n     * @member {string} label\n     * @memberof Button\n     * @instance\n     */\n    Button.prototype.label = \"\";\n\n    /**\n     * Button default.\n     * @member {boolean} default\n     * @memberof Button\n     * @instance\n     */\n    Button.prototype[\"default\"] = false;\n\n    /**\n     * Creates a new Button instance using the specified properties.\n     * @function create\n     * @memberof Button\n     * @static\n     * @param {IButton=} [properties] Properties to set\n     * @returns {Button} Button instance\n     */\n    Button.create = function create(properties) {\n        return new Button(properties);\n    };\n\n    /**\n     * Encodes the specified Button message. Does not implicitly {@link Button.verify|verify} messages.\n     * @function encode\n     * @memberof Button\n     * @static\n     * @param {IButton} message Button message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Button.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).bool(message[\"default\"]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Button message, length delimited. Does not implicitly {@link Button.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Button\n     * @static\n     * @param {IButton} message Button message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Button.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Button message from the specified reader or buffer.\n     * @function decode\n     * @memberof Button\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Button} Button\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Button.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Button();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Button message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Button\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Button} Button\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Button.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Button message.\n     * @function verify\n     * @memberof Button\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Button.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (typeof message[\"default\"] !== \"boolean\")\n                return \"default: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Button message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Button\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Button} Button\n     */\n    Button.fromObject = function fromObject(object) {\n        if (object instanceof $root.Button)\n            return object;\n        let message = new $root.Button();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = Boolean(object[\"default\"]);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Button message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Button\n     * @static\n     * @param {Button} message Button\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Button.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = false;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        return object;\n    };\n\n    /**\n     * Converts this Button to JSON.\n     * @function toJSON\n     * @memberof Button\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Button.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Button;\n})();\n\nexport const Checkbox = $root.Checkbox = (() => {\n\n    /**\n     * Properties of a Checkbox.\n     * @exports ICheckbox\n     * @interface ICheckbox\n     * @property {string|null} [id] Checkbox id\n     * @property {string|null} [label] Checkbox label\n     * @property {boolean|null} [\"default\"] Checkbox default\n     */\n\n    /**\n     * Constructs a new Checkbox.\n     * @exports Checkbox\n     * @classdesc Represents a Checkbox.\n     * @implements ICheckbox\n     * @constructor\n     * @param {ICheckbox=} [properties] Properties to set\n     */\n    function Checkbox(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Checkbox id.\n     * @member {string} id\n     * @memberof Checkbox\n     * @instance\n     */\n    Checkbox.prototype.id = \"\";\n\n    /**\n     * Checkbox label.\n     * @member {string} label\n     * @memberof Checkbox\n     * @instance\n     */\n    Checkbox.prototype.label = \"\";\n\n    /**\n     * Checkbox default.\n     * @member {boolean} default\n     * @memberof Checkbox\n     * @instance\n     */\n    Checkbox.prototype[\"default\"] = false;\n\n    /**\n     * Creates a new Checkbox instance using the specified properties.\n     * @function create\n     * @memberof Checkbox\n     * @static\n     * @param {ICheckbox=} [properties] Properties to set\n     * @returns {Checkbox} Checkbox instance\n     */\n    Checkbox.create = function create(properties) {\n        return new Checkbox(properties);\n    };\n\n    /**\n     * Encodes the specified Checkbox message. Does not implicitly {@link Checkbox.verify|verify} messages.\n     * @function encode\n     * @memberof Checkbox\n     * @static\n     * @param {ICheckbox} message Checkbox message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Checkbox.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).bool(message[\"default\"]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Checkbox message, length delimited. Does not implicitly {@link Checkbox.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Checkbox\n     * @static\n     * @param {ICheckbox} message Checkbox message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Checkbox.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Checkbox message from the specified reader or buffer.\n     * @function decode\n     * @memberof Checkbox\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Checkbox} Checkbox\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Checkbox.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Checkbox();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Checkbox message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Checkbox\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Checkbox} Checkbox\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Checkbox.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Checkbox message.\n     * @function verify\n     * @memberof Checkbox\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Checkbox.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (typeof message[\"default\"] !== \"boolean\")\n                return \"default: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Checkbox message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Checkbox\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Checkbox} Checkbox\n     */\n    Checkbox.fromObject = function fromObject(object) {\n        if (object instanceof $root.Checkbox)\n            return object;\n        let message = new $root.Checkbox();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = Boolean(object[\"default\"]);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Checkbox message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Checkbox\n     * @static\n     * @param {Checkbox} message Checkbox\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Checkbox.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = false;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        return object;\n    };\n\n    /**\n     * Converts this Checkbox to JSON.\n     * @function toJSON\n     * @memberof Checkbox\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Checkbox.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Checkbox;\n})();\n\nexport const ColorPicker = $root.ColorPicker = (() => {\n\n    /**\n     * Properties of a ColorPicker.\n     * @exports IColorPicker\n     * @interface IColorPicker\n     * @property {string|null} [id] ColorPicker id\n     * @property {string|null} [label] ColorPicker label\n     * @property {string|null} [\"default\"] ColorPicker default\n     */\n\n    /**\n     * Constructs a new ColorPicker.\n     * @exports ColorPicker\n     * @classdesc Represents a ColorPicker.\n     * @implements IColorPicker\n     * @constructor\n     * @param {IColorPicker=} [properties] Properties to set\n     */\n    function ColorPicker(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ColorPicker id.\n     * @member {string} id\n     * @memberof ColorPicker\n     * @instance\n     */\n    ColorPicker.prototype.id = \"\";\n\n    /**\n     * ColorPicker label.\n     * @member {string} label\n     * @memberof ColorPicker\n     * @instance\n     */\n    ColorPicker.prototype.label = \"\";\n\n    /**\n     * ColorPicker default.\n     * @member {string} default\n     * @memberof ColorPicker\n     * @instance\n     */\n    ColorPicker.prototype[\"default\"] = \"\";\n\n    /**\n     * Creates a new ColorPicker instance using the specified properties.\n     * @function create\n     * @memberof ColorPicker\n     * @static\n     * @param {IColorPicker=} [properties] Properties to set\n     * @returns {ColorPicker} ColorPicker instance\n     */\n    ColorPicker.create = function create(properties) {\n        return new ColorPicker(properties);\n    };\n\n    /**\n     * Encodes the specified ColorPicker message. Does not implicitly {@link ColorPicker.verify|verify} messages.\n     * @function encode\n     * @memberof ColorPicker\n     * @static\n     * @param {IColorPicker} message ColorPicker message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ColorPicker.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message[\"default\"]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ColorPicker message, length delimited. Does not implicitly {@link ColorPicker.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ColorPicker\n     * @static\n     * @param {IColorPicker} message ColorPicker message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ColorPicker.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a ColorPicker message from the specified reader or buffer.\n     * @function decode\n     * @memberof ColorPicker\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ColorPicker} ColorPicker\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ColorPicker.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ColorPicker();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a ColorPicker message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ColorPicker\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ColorPicker} ColorPicker\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ColorPicker.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a ColorPicker message.\n     * @function verify\n     * @memberof ColorPicker\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ColorPicker.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (!$util.isString(message[\"default\"]))\n                return \"default: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a ColorPicker message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ColorPicker\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ColorPicker} ColorPicker\n     */\n    ColorPicker.fromObject = function fromObject(object) {\n        if (object instanceof $root.ColorPicker)\n            return object;\n        let message = new $root.ColorPicker();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = String(object[\"default\"]);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a ColorPicker message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ColorPicker\n     * @static\n     * @param {ColorPicker} message ColorPicker\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ColorPicker.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = \"\";\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        return object;\n    };\n\n    /**\n     * Converts this ColorPicker to JSON.\n     * @function toJSON\n     * @memberof ColorPicker\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ColorPicker.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ColorPicker;\n})();\n\nexport const ComponentInstance = $root.ComponentInstance = (() => {\n\n    /**\n     * Properties of a ComponentInstance.\n     * @exports IComponentInstance\n     * @interface IComponentInstance\n     * @property {string|null} [id] ComponentInstance id\n     * @property {string|null} [argsJson] ComponentInstance argsJson\n     * @property {Array.<IArgsDataframe>|null} [argsDataframe] ComponentInstance argsDataframe\n     * @property {string|null} [componentName] ComponentInstance componentName\n     * @property {string|null} [url] ComponentInstance url\n     */\n\n    /**\n     * Constructs a new ComponentInstance.\n     * @exports ComponentInstance\n     * @classdesc Represents a ComponentInstance.\n     * @implements IComponentInstance\n     * @constructor\n     * @param {IComponentInstance=} [properties] Properties to set\n     */\n    function ComponentInstance(properties) {\n        this.argsDataframe = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ComponentInstance id.\n     * @member {string} id\n     * @memberof ComponentInstance\n     * @instance\n     */\n    ComponentInstance.prototype.id = \"\";\n\n    /**\n     * ComponentInstance argsJson.\n     * @member {string} argsJson\n     * @memberof ComponentInstance\n     * @instance\n     */\n    ComponentInstance.prototype.argsJson = \"\";\n\n    /**\n     * ComponentInstance argsDataframe.\n     * @member {Array.<IArgsDataframe>} argsDataframe\n     * @memberof ComponentInstance\n     * @instance\n     */\n    ComponentInstance.prototype.argsDataframe = $util.emptyArray;\n\n    /**\n     * ComponentInstance componentName.\n     * @member {string} componentName\n     * @memberof ComponentInstance\n     * @instance\n     */\n    ComponentInstance.prototype.componentName = \"\";\n\n    /**\n     * ComponentInstance url.\n     * @member {string} url\n     * @memberof ComponentInstance\n     * @instance\n     */\n    ComponentInstance.prototype.url = \"\";\n\n    /**\n     * Creates a new ComponentInstance instance using the specified properties.\n     * @function create\n     * @memberof ComponentInstance\n     * @static\n     * @param {IComponentInstance=} [properties] Properties to set\n     * @returns {ComponentInstance} ComponentInstance instance\n     */\n    ComponentInstance.create = function create(properties) {\n        return new ComponentInstance(properties);\n    };\n\n    /**\n     * Encodes the specified ComponentInstance message. Does not implicitly {@link ComponentInstance.verify|verify} messages.\n     * @function encode\n     * @memberof ComponentInstance\n     * @static\n     * @param {IComponentInstance} message ComponentInstance message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ComponentInstance.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.argsJson != null && Object.hasOwnProperty.call(message, \"argsJson\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.argsJson);\n        if (message.argsDataframe != null && message.argsDataframe.length)\n            for (let i = 0; i < message.argsDataframe.length; ++i)\n                $root.ArgsDataframe.encode(message.argsDataframe[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.componentName != null && Object.hasOwnProperty.call(message, \"componentName\"))\n            writer.uint32(/* id 4, wireType 2 =*/34).string(message.componentName);\n        if (message.url != null && Object.hasOwnProperty.call(message, \"url\"))\n            writer.uint32(/* id 5, wireType 2 =*/42).string(message.url);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ComponentInstance message, length delimited. Does not implicitly {@link ComponentInstance.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ComponentInstance\n     * @static\n     * @param {IComponentInstance} message ComponentInstance message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ComponentInstance.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a ComponentInstance message from the specified reader or buffer.\n     * @function decode\n     * @memberof ComponentInstance\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ComponentInstance} ComponentInstance\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ComponentInstance.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ComponentInstance();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.argsJson = reader.string();\n                break;\n            case 3:\n                if (!(message.argsDataframe && message.argsDataframe.length))\n                    message.argsDataframe = [];\n                message.argsDataframe.push($root.ArgsDataframe.decode(reader, reader.uint32()));\n                break;\n            case 4:\n                message.componentName = reader.string();\n                break;\n            case 5:\n                message.url = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a ComponentInstance message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ComponentInstance\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ComponentInstance} ComponentInstance\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ComponentInstance.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a ComponentInstance message.\n     * @function verify\n     * @memberof ComponentInstance\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ComponentInstance.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.argsJson != null && message.hasOwnProperty(\"argsJson\"))\n            if (!$util.isString(message.argsJson))\n                return \"argsJson: string expected\";\n        if (message.argsDataframe != null && message.hasOwnProperty(\"argsDataframe\")) {\n            if (!Array.isArray(message.argsDataframe))\n                return \"argsDataframe: array expected\";\n            for (let i = 0; i < message.argsDataframe.length; ++i) {\n                let error = $root.ArgsDataframe.verify(message.argsDataframe[i]);\n                if (error)\n                    return \"argsDataframe.\" + error;\n            }\n        }\n        if (message.componentName != null && message.hasOwnProperty(\"componentName\"))\n            if (!$util.isString(message.componentName))\n                return \"componentName: string expected\";\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            if (!$util.isString(message.url))\n                return \"url: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a ComponentInstance message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ComponentInstance\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ComponentInstance} ComponentInstance\n     */\n    ComponentInstance.fromObject = function fromObject(object) {\n        if (object instanceof $root.ComponentInstance)\n            return object;\n        let message = new $root.ComponentInstance();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.argsJson != null)\n            message.argsJson = String(object.argsJson);\n        if (object.argsDataframe) {\n            if (!Array.isArray(object.argsDataframe))\n                throw TypeError(\".ComponentInstance.argsDataframe: array expected\");\n            message.argsDataframe = [];\n            for (let i = 0; i < object.argsDataframe.length; ++i) {\n                if (typeof object.argsDataframe[i] !== \"object\")\n                    throw TypeError(\".ComponentInstance.argsDataframe: object expected\");\n                message.argsDataframe[i] = $root.ArgsDataframe.fromObject(object.argsDataframe[i]);\n            }\n        }\n        if (object.componentName != null)\n            message.componentName = String(object.componentName);\n        if (object.url != null)\n            message.url = String(object.url);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a ComponentInstance message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ComponentInstance\n     * @static\n     * @param {ComponentInstance} message ComponentInstance\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ComponentInstance.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.argsDataframe = [];\n        if (options.defaults) {\n            object.id = \"\";\n            object.argsJson = \"\";\n            object.componentName = \"\";\n            object.url = \"\";\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.argsJson != null && message.hasOwnProperty(\"argsJson\"))\n            object.argsJson = message.argsJson;\n        if (message.argsDataframe && message.argsDataframe.length) {\n            object.argsDataframe = [];\n            for (let j = 0; j < message.argsDataframe.length; ++j)\n                object.argsDataframe[j] = $root.ArgsDataframe.toObject(message.argsDataframe[j], options);\n        }\n        if (message.componentName != null && message.hasOwnProperty(\"componentName\"))\n            object.componentName = message.componentName;\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            object.url = message.url;\n        return object;\n    };\n\n    /**\n     * Converts this ComponentInstance to JSON.\n     * @function toJSON\n     * @memberof ComponentInstance\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ComponentInstance.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ComponentInstance;\n})();\n\nexport const ArgsDataframe = $root.ArgsDataframe = (() => {\n\n    /**\n     * Properties of an ArgsDataframe.\n     * @exports IArgsDataframe\n     * @interface IArgsDataframe\n     * @property {string|null} [key] ArgsDataframe key\n     * @property {IArrowDataframe|null} [value] ArgsDataframe value\n     */\n\n    /**\n     * Constructs a new ArgsDataframe.\n     * @exports ArgsDataframe\n     * @classdesc Represents an ArgsDataframe.\n     * @implements IArgsDataframe\n     * @constructor\n     * @param {IArgsDataframe=} [properties] Properties to set\n     */\n    function ArgsDataframe(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ArgsDataframe key.\n     * @member {string} key\n     * @memberof ArgsDataframe\n     * @instance\n     */\n    ArgsDataframe.prototype.key = \"\";\n\n    /**\n     * ArgsDataframe value.\n     * @member {IArrowDataframe|null|undefined} value\n     * @memberof ArgsDataframe\n     * @instance\n     */\n    ArgsDataframe.prototype.value = null;\n\n    /**\n     * Creates a new ArgsDataframe instance using the specified properties.\n     * @function create\n     * @memberof ArgsDataframe\n     * @static\n     * @param {IArgsDataframe=} [properties] Properties to set\n     * @returns {ArgsDataframe} ArgsDataframe instance\n     */\n    ArgsDataframe.create = function create(properties) {\n        return new ArgsDataframe(properties);\n    };\n\n    /**\n     * Encodes the specified ArgsDataframe message. Does not implicitly {@link ArgsDataframe.verify|verify} messages.\n     * @function encode\n     * @memberof ArgsDataframe\n     * @static\n     * @param {IArgsDataframe} message ArgsDataframe message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ArgsDataframe.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.key != null && Object.hasOwnProperty.call(message, \"key\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.key);\n        if (message.value != null && Object.hasOwnProperty.call(message, \"value\"))\n            $root.ArrowDataframe.encode(message.value, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ArgsDataframe message, length delimited. Does not implicitly {@link ArgsDataframe.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ArgsDataframe\n     * @static\n     * @param {IArgsDataframe} message ArgsDataframe message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ArgsDataframe.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an ArgsDataframe message from the specified reader or buffer.\n     * @function decode\n     * @memberof ArgsDataframe\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ArgsDataframe} ArgsDataframe\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ArgsDataframe.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ArgsDataframe();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.key = reader.string();\n                break;\n            case 2:\n                message.value = $root.ArrowDataframe.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an ArgsDataframe message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ArgsDataframe\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ArgsDataframe} ArgsDataframe\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ArgsDataframe.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an ArgsDataframe message.\n     * @function verify\n     * @memberof ArgsDataframe\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ArgsDataframe.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.key != null && message.hasOwnProperty(\"key\"))\n            if (!$util.isString(message.key))\n                return \"key: string expected\";\n        if (message.value != null && message.hasOwnProperty(\"value\")) {\n            let error = $root.ArrowDataframe.verify(message.value);\n            if (error)\n                return \"value.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates an ArgsDataframe message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ArgsDataframe\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ArgsDataframe} ArgsDataframe\n     */\n    ArgsDataframe.fromObject = function fromObject(object) {\n        if (object instanceof $root.ArgsDataframe)\n            return object;\n        let message = new $root.ArgsDataframe();\n        if (object.key != null)\n            message.key = String(object.key);\n        if (object.value != null) {\n            if (typeof object.value !== \"object\")\n                throw TypeError(\".ArgsDataframe.value: object expected\");\n            message.value = $root.ArrowDataframe.fromObject(object.value);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an ArgsDataframe message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ArgsDataframe\n     * @static\n     * @param {ArgsDataframe} message ArgsDataframe\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ArgsDataframe.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.key = \"\";\n            object.value = null;\n        }\n        if (message.key != null && message.hasOwnProperty(\"key\"))\n            object.key = message.key;\n        if (message.value != null && message.hasOwnProperty(\"value\"))\n            object.value = $root.ArrowDataframe.toObject(message.value, options);\n        return object;\n    };\n\n    /**\n     * Converts this ArgsDataframe to JSON.\n     * @function toJSON\n     * @memberof ArgsDataframe\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ArgsDataframe.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ArgsDataframe;\n})();\n\nexport const DataFrame = $root.DataFrame = (() => {\n\n    /**\n     * Properties of a DataFrame.\n     * @exports IDataFrame\n     * @interface IDataFrame\n     * @property {ITable|null} [data] DataFrame data\n     * @property {IIndex|null} [index] DataFrame index\n     * @property {IIndex|null} [columns] DataFrame columns\n     * @property {ITableStyle|null} [style] DataFrame style\n     */\n\n    /**\n     * Constructs a new DataFrame.\n     * @exports DataFrame\n     * @classdesc Represents a DataFrame.\n     * @implements IDataFrame\n     * @constructor\n     * @param {IDataFrame=} [properties] Properties to set\n     */\n    function DataFrame(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DataFrame data.\n     * @member {ITable|null|undefined} data\n     * @memberof DataFrame\n     * @instance\n     */\n    DataFrame.prototype.data = null;\n\n    /**\n     * DataFrame index.\n     * @member {IIndex|null|undefined} index\n     * @memberof DataFrame\n     * @instance\n     */\n    DataFrame.prototype.index = null;\n\n    /**\n     * DataFrame columns.\n     * @member {IIndex|null|undefined} columns\n     * @memberof DataFrame\n     * @instance\n     */\n    DataFrame.prototype.columns = null;\n\n    /**\n     * DataFrame style.\n     * @member {ITableStyle|null|undefined} style\n     * @memberof DataFrame\n     * @instance\n     */\n    DataFrame.prototype.style = null;\n\n    /**\n     * Creates a new DataFrame instance using the specified properties.\n     * @function create\n     * @memberof DataFrame\n     * @static\n     * @param {IDataFrame=} [properties] Properties to set\n     * @returns {DataFrame} DataFrame instance\n     */\n    DataFrame.create = function create(properties) {\n        return new DataFrame(properties);\n    };\n\n    /**\n     * Encodes the specified DataFrame message. Does not implicitly {@link DataFrame.verify|verify} messages.\n     * @function encode\n     * @memberof DataFrame\n     * @static\n     * @param {IDataFrame} message DataFrame message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DataFrame.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.Table.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.index != null && Object.hasOwnProperty.call(message, \"index\"))\n            $root.Index.encode(message.index, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.columns != null && Object.hasOwnProperty.call(message, \"columns\"))\n            $root.Index.encode(message.columns, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.style != null && Object.hasOwnProperty.call(message, \"style\"))\n            $root.TableStyle.encode(message.style, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DataFrame message, length delimited. Does not implicitly {@link DataFrame.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DataFrame\n     * @static\n     * @param {IDataFrame} message DataFrame message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DataFrame.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DataFrame message from the specified reader or buffer.\n     * @function decode\n     * @memberof DataFrame\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DataFrame} DataFrame\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DataFrame.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DataFrame();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.Table.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.index = $root.Index.decode(reader, reader.uint32());\n                break;\n            case 3:\n                message.columns = $root.Index.decode(reader, reader.uint32());\n                break;\n            case 4:\n                message.style = $root.TableStyle.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DataFrame message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DataFrame\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DataFrame} DataFrame\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DataFrame.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DataFrame message.\n     * @function verify\n     * @memberof DataFrame\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DataFrame.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.Table.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        if (message.index != null && message.hasOwnProperty(\"index\")) {\n            let error = $root.Index.verify(message.index);\n            if (error)\n                return \"index.\" + error;\n        }\n        if (message.columns != null && message.hasOwnProperty(\"columns\")) {\n            let error = $root.Index.verify(message.columns);\n            if (error)\n                return \"columns.\" + error;\n        }\n        if (message.style != null && message.hasOwnProperty(\"style\")) {\n            let error = $root.TableStyle.verify(message.style);\n            if (error)\n                return \"style.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates a DataFrame message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DataFrame\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DataFrame} DataFrame\n     */\n    DataFrame.fromObject = function fromObject(object) {\n        if (object instanceof $root.DataFrame)\n            return object;\n        let message = new $root.DataFrame();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".DataFrame.data: object expected\");\n            message.data = $root.Table.fromObject(object.data);\n        }\n        if (object.index != null) {\n            if (typeof object.index !== \"object\")\n                throw TypeError(\".DataFrame.index: object expected\");\n            message.index = $root.Index.fromObject(object.index);\n        }\n        if (object.columns != null) {\n            if (typeof object.columns !== \"object\")\n                throw TypeError(\".DataFrame.columns: object expected\");\n            message.columns = $root.Index.fromObject(object.columns);\n        }\n        if (object.style != null) {\n            if (typeof object.style !== \"object\")\n                throw TypeError(\".DataFrame.style: object expected\");\n            message.style = $root.TableStyle.fromObject(object.style);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DataFrame message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DataFrame\n     * @static\n     * @param {DataFrame} message DataFrame\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DataFrame.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.data = null;\n            object.index = null;\n            object.columns = null;\n            object.style = null;\n        }\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.Table.toObject(message.data, options);\n        if (message.index != null && message.hasOwnProperty(\"index\"))\n            object.index = $root.Index.toObject(message.index, options);\n        if (message.columns != null && message.hasOwnProperty(\"columns\"))\n            object.columns = $root.Index.toObject(message.columns, options);\n        if (message.style != null && message.hasOwnProperty(\"style\"))\n            object.style = $root.TableStyle.toObject(message.style, options);\n        return object;\n    };\n\n    /**\n     * Converts this DataFrame to JSON.\n     * @function toJSON\n     * @memberof DataFrame\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DataFrame.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DataFrame;\n})();\n\nexport const Index = $root.Index = (() => {\n\n    /**\n     * Properties of an Index.\n     * @exports IIndex\n     * @interface IIndex\n     * @property {IPlainIndex|null} [plainIndex] Index plainIndex\n     * @property {IRangeIndex|null} [rangeIndex] Index rangeIndex\n     * @property {IMultiIndex|null} [multiIndex] Index multiIndex\n     * @property {IDatetimeIndex|null} [datetimeIndex] Index datetimeIndex\n     * @property {ITimedeltaIndex|null} [timedeltaIndex] Index timedeltaIndex\n     * @property {IInt64Index|null} [int_64Index] Index int_64Index\n     * @property {IFloat64Index|null} [float_64Index] Index float_64Index\n     */\n\n    /**\n     * Constructs a new Index.\n     * @exports Index\n     * @classdesc Represents an Index.\n     * @implements IIndex\n     * @constructor\n     * @param {IIndex=} [properties] Properties to set\n     */\n    function Index(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Index plainIndex.\n     * @member {IPlainIndex|null|undefined} plainIndex\n     * @memberof Index\n     * @instance\n     */\n    Index.prototype.plainIndex = null;\n\n    /**\n     * Index rangeIndex.\n     * @member {IRangeIndex|null|undefined} rangeIndex\n     * @memberof Index\n     * @instance\n     */\n    Index.prototype.rangeIndex = null;\n\n    /**\n     * Index multiIndex.\n     * @member {IMultiIndex|null|undefined} multiIndex\n     * @memberof Index\n     * @instance\n     */\n    Index.prototype.multiIndex = null;\n\n    /**\n     * Index datetimeIndex.\n     * @member {IDatetimeIndex|null|undefined} datetimeIndex\n     * @memberof Index\n     * @instance\n     */\n    Index.prototype.datetimeIndex = null;\n\n    /**\n     * Index timedeltaIndex.\n     * @member {ITimedeltaIndex|null|undefined} timedeltaIndex\n     * @memberof Index\n     * @instance\n     */\n    Index.prototype.timedeltaIndex = null;\n\n    /**\n     * Index int_64Index.\n     * @member {IInt64Index|null|undefined} int_64Index\n     * @memberof Index\n     * @instance\n     */\n    Index.prototype.int_64Index = null;\n\n    /**\n     * Index float_64Index.\n     * @member {IFloat64Index|null|undefined} float_64Index\n     * @memberof Index\n     * @instance\n     */\n    Index.prototype.float_64Index = null;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * Index type.\n     * @member {\"plainIndex\"|\"rangeIndex\"|\"multiIndex\"|\"datetimeIndex\"|\"timedeltaIndex\"|\"int_64Index\"|\"float_64Index\"|undefined} type\n     * @memberof Index\n     * @instance\n     */\n    Object.defineProperty(Index.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"plainIndex\", \"rangeIndex\", \"multiIndex\", \"datetimeIndex\", \"timedeltaIndex\", \"int_64Index\", \"float_64Index\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new Index instance using the specified properties.\n     * @function create\n     * @memberof Index\n     * @static\n     * @param {IIndex=} [properties] Properties to set\n     * @returns {Index} Index instance\n     */\n    Index.create = function create(properties) {\n        return new Index(properties);\n    };\n\n    /**\n     * Encodes the specified Index message. Does not implicitly {@link Index.verify|verify} messages.\n     * @function encode\n     * @memberof Index\n     * @static\n     * @param {IIndex} message Index message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Index.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.plainIndex != null && Object.hasOwnProperty.call(message, \"plainIndex\"))\n            $root.PlainIndex.encode(message.plainIndex, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.rangeIndex != null && Object.hasOwnProperty.call(message, \"rangeIndex\"))\n            $root.RangeIndex.encode(message.rangeIndex, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.multiIndex != null && Object.hasOwnProperty.call(message, \"multiIndex\"))\n            $root.MultiIndex.encode(message.multiIndex, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n        if (message.datetimeIndex != null && Object.hasOwnProperty.call(message, \"datetimeIndex\"))\n            $root.DatetimeIndex.encode(message.datetimeIndex, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();\n        if (message.timedeltaIndex != null && Object.hasOwnProperty.call(message, \"timedeltaIndex\"))\n            $root.TimedeltaIndex.encode(message.timedeltaIndex, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();\n        if (message.int_64Index != null && Object.hasOwnProperty.call(message, \"int_64Index\"))\n            $root.Int64Index.encode(message.int_64Index, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();\n        if (message.float_64Index != null && Object.hasOwnProperty.call(message, \"float_64Index\"))\n            $root.Float64Index.encode(message.float_64Index, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Index message, length delimited. Does not implicitly {@link Index.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Index\n     * @static\n     * @param {IIndex} message Index message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Index.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Index message from the specified reader or buffer.\n     * @function decode\n     * @memberof Index\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Index} Index\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Index.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Index();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.plainIndex = $root.PlainIndex.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.rangeIndex = $root.RangeIndex.decode(reader, reader.uint32());\n                break;\n            case 4:\n                message.multiIndex = $root.MultiIndex.decode(reader, reader.uint32());\n                break;\n            case 6:\n                message.datetimeIndex = $root.DatetimeIndex.decode(reader, reader.uint32());\n                break;\n            case 7:\n                message.timedeltaIndex = $root.TimedeltaIndex.decode(reader, reader.uint32());\n                break;\n            case 9:\n                message.int_64Index = $root.Int64Index.decode(reader, reader.uint32());\n                break;\n            case 11:\n                message.float_64Index = $root.Float64Index.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Index message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Index\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Index} Index\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Index.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Index message.\n     * @function verify\n     * @memberof Index\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Index.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.plainIndex != null && message.hasOwnProperty(\"plainIndex\")) {\n            properties.type = 1;\n            {\n                let error = $root.PlainIndex.verify(message.plainIndex);\n                if (error)\n                    return \"plainIndex.\" + error;\n            }\n        }\n        if (message.rangeIndex != null && message.hasOwnProperty(\"rangeIndex\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.RangeIndex.verify(message.rangeIndex);\n                if (error)\n                    return \"rangeIndex.\" + error;\n            }\n        }\n        if (message.multiIndex != null && message.hasOwnProperty(\"multiIndex\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.MultiIndex.verify(message.multiIndex);\n                if (error)\n                    return \"multiIndex.\" + error;\n            }\n        }\n        if (message.datetimeIndex != null && message.hasOwnProperty(\"datetimeIndex\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DatetimeIndex.verify(message.datetimeIndex);\n                if (error)\n                    return \"datetimeIndex.\" + error;\n            }\n        }\n        if (message.timedeltaIndex != null && message.hasOwnProperty(\"timedeltaIndex\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.TimedeltaIndex.verify(message.timedeltaIndex);\n                if (error)\n                    return \"timedeltaIndex.\" + error;\n            }\n        }\n        if (message.int_64Index != null && message.hasOwnProperty(\"int_64Index\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Int64Index.verify(message.int_64Index);\n                if (error)\n                    return \"int_64Index.\" + error;\n            }\n        }\n        if (message.float_64Index != null && message.hasOwnProperty(\"float_64Index\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Float64Index.verify(message.float_64Index);\n                if (error)\n                    return \"float_64Index.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates an Index message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Index\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Index} Index\n     */\n    Index.fromObject = function fromObject(object) {\n        if (object instanceof $root.Index)\n            return object;\n        let message = new $root.Index();\n        if (object.plainIndex != null) {\n            if (typeof object.plainIndex !== \"object\")\n                throw TypeError(\".Index.plainIndex: object expected\");\n            message.plainIndex = $root.PlainIndex.fromObject(object.plainIndex);\n        }\n        if (object.rangeIndex != null) {\n            if (typeof object.rangeIndex !== \"object\")\n                throw TypeError(\".Index.rangeIndex: object expected\");\n            message.rangeIndex = $root.RangeIndex.fromObject(object.rangeIndex);\n        }\n        if (object.multiIndex != null) {\n            if (typeof object.multiIndex !== \"object\")\n                throw TypeError(\".Index.multiIndex: object expected\");\n            message.multiIndex = $root.MultiIndex.fromObject(object.multiIndex);\n        }\n        if (object.datetimeIndex != null) {\n            if (typeof object.datetimeIndex !== \"object\")\n                throw TypeError(\".Index.datetimeIndex: object expected\");\n            message.datetimeIndex = $root.DatetimeIndex.fromObject(object.datetimeIndex);\n        }\n        if (object.timedeltaIndex != null) {\n            if (typeof object.timedeltaIndex !== \"object\")\n                throw TypeError(\".Index.timedeltaIndex: object expected\");\n            message.timedeltaIndex = $root.TimedeltaIndex.fromObject(object.timedeltaIndex);\n        }\n        if (object.int_64Index != null) {\n            if (typeof object.int_64Index !== \"object\")\n                throw TypeError(\".Index.int_64Index: object expected\");\n            message.int_64Index = $root.Int64Index.fromObject(object.int_64Index);\n        }\n        if (object.float_64Index != null) {\n            if (typeof object.float_64Index !== \"object\")\n                throw TypeError(\".Index.float_64Index: object expected\");\n            message.float_64Index = $root.Float64Index.fromObject(object.float_64Index);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Index message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Index\n     * @static\n     * @param {Index} message Index\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Index.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (message.plainIndex != null && message.hasOwnProperty(\"plainIndex\")) {\n            object.plainIndex = $root.PlainIndex.toObject(message.plainIndex, options);\n            if (options.oneofs)\n                object.type = \"plainIndex\";\n        }\n        if (message.rangeIndex != null && message.hasOwnProperty(\"rangeIndex\")) {\n            object.rangeIndex = $root.RangeIndex.toObject(message.rangeIndex, options);\n            if (options.oneofs)\n                object.type = \"rangeIndex\";\n        }\n        if (message.multiIndex != null && message.hasOwnProperty(\"multiIndex\")) {\n            object.multiIndex = $root.MultiIndex.toObject(message.multiIndex, options);\n            if (options.oneofs)\n                object.type = \"multiIndex\";\n        }\n        if (message.datetimeIndex != null && message.hasOwnProperty(\"datetimeIndex\")) {\n            object.datetimeIndex = $root.DatetimeIndex.toObject(message.datetimeIndex, options);\n            if (options.oneofs)\n                object.type = \"datetimeIndex\";\n        }\n        if (message.timedeltaIndex != null && message.hasOwnProperty(\"timedeltaIndex\")) {\n            object.timedeltaIndex = $root.TimedeltaIndex.toObject(message.timedeltaIndex, options);\n            if (options.oneofs)\n                object.type = \"timedeltaIndex\";\n        }\n        if (message.int_64Index != null && message.hasOwnProperty(\"int_64Index\")) {\n            object.int_64Index = $root.Int64Index.toObject(message.int_64Index, options);\n            if (options.oneofs)\n                object.type = \"int_64Index\";\n        }\n        if (message.float_64Index != null && message.hasOwnProperty(\"float_64Index\")) {\n            object.float_64Index = $root.Float64Index.toObject(message.float_64Index, options);\n            if (options.oneofs)\n                object.type = \"float_64Index\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Index to JSON.\n     * @function toJSON\n     * @memberof Index\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Index.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Index;\n})();\n\nexport const PlainIndex = $root.PlainIndex = (() => {\n\n    /**\n     * Properties of a PlainIndex.\n     * @exports IPlainIndex\n     * @interface IPlainIndex\n     * @property {IAnyArray|null} [data] PlainIndex data\n     */\n\n    /**\n     * Constructs a new PlainIndex.\n     * @exports PlainIndex\n     * @classdesc Represents a PlainIndex.\n     * @implements IPlainIndex\n     * @constructor\n     * @param {IPlainIndex=} [properties] Properties to set\n     */\n    function PlainIndex(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * PlainIndex data.\n     * @member {IAnyArray|null|undefined} data\n     * @memberof PlainIndex\n     * @instance\n     */\n    PlainIndex.prototype.data = null;\n\n    /**\n     * Creates a new PlainIndex instance using the specified properties.\n     * @function create\n     * @memberof PlainIndex\n     * @static\n     * @param {IPlainIndex=} [properties] Properties to set\n     * @returns {PlainIndex} PlainIndex instance\n     */\n    PlainIndex.create = function create(properties) {\n        return new PlainIndex(properties);\n    };\n\n    /**\n     * Encodes the specified PlainIndex message. Does not implicitly {@link PlainIndex.verify|verify} messages.\n     * @function encode\n     * @memberof PlainIndex\n     * @static\n     * @param {IPlainIndex} message PlainIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    PlainIndex.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.AnyArray.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified PlainIndex message, length delimited. Does not implicitly {@link PlainIndex.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof PlainIndex\n     * @static\n     * @param {IPlainIndex} message PlainIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    PlainIndex.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a PlainIndex message from the specified reader or buffer.\n     * @function decode\n     * @memberof PlainIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {PlainIndex} PlainIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    PlainIndex.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.PlainIndex();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.AnyArray.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a PlainIndex message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof PlainIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {PlainIndex} PlainIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    PlainIndex.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a PlainIndex message.\n     * @function verify\n     * @memberof PlainIndex\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    PlainIndex.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.AnyArray.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates a PlainIndex message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof PlainIndex\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {PlainIndex} PlainIndex\n     */\n    PlainIndex.fromObject = function fromObject(object) {\n        if (object instanceof $root.PlainIndex)\n            return object;\n        let message = new $root.PlainIndex();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".PlainIndex.data: object expected\");\n            message.data = $root.AnyArray.fromObject(object.data);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a PlainIndex message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof PlainIndex\n     * @static\n     * @param {PlainIndex} message PlainIndex\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    PlainIndex.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.data = null;\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.AnyArray.toObject(message.data, options);\n        return object;\n    };\n\n    /**\n     * Converts this PlainIndex to JSON.\n     * @function toJSON\n     * @memberof PlainIndex\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    PlainIndex.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return PlainIndex;\n})();\n\nexport const RangeIndex = $root.RangeIndex = (() => {\n\n    /**\n     * Properties of a RangeIndex.\n     * @exports IRangeIndex\n     * @interface IRangeIndex\n     * @property {number|Long|null} [start] RangeIndex start\n     * @property {number|Long|null} [stop] RangeIndex stop\n     */\n\n    /**\n     * Constructs a new RangeIndex.\n     * @exports RangeIndex\n     * @classdesc Represents a RangeIndex.\n     * @implements IRangeIndex\n     * @constructor\n     * @param {IRangeIndex=} [properties] Properties to set\n     */\n    function RangeIndex(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * RangeIndex start.\n     * @member {number|Long} start\n     * @memberof RangeIndex\n     * @instance\n     */\n    RangeIndex.prototype.start = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n    /**\n     * RangeIndex stop.\n     * @member {number|Long} stop\n     * @memberof RangeIndex\n     * @instance\n     */\n    RangeIndex.prototype.stop = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n    /**\n     * Creates a new RangeIndex instance using the specified properties.\n     * @function create\n     * @memberof RangeIndex\n     * @static\n     * @param {IRangeIndex=} [properties] Properties to set\n     * @returns {RangeIndex} RangeIndex instance\n     */\n    RangeIndex.create = function create(properties) {\n        return new RangeIndex(properties);\n    };\n\n    /**\n     * Encodes the specified RangeIndex message. Does not implicitly {@link RangeIndex.verify|verify} messages.\n     * @function encode\n     * @memberof RangeIndex\n     * @static\n     * @param {IRangeIndex} message RangeIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    RangeIndex.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.start != null && Object.hasOwnProperty.call(message, \"start\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).int64(message.start);\n        if (message.stop != null && Object.hasOwnProperty.call(message, \"stop\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).int64(message.stop);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified RangeIndex message, length delimited. Does not implicitly {@link RangeIndex.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof RangeIndex\n     * @static\n     * @param {IRangeIndex} message RangeIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    RangeIndex.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a RangeIndex message from the specified reader or buffer.\n     * @function decode\n     * @memberof RangeIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {RangeIndex} RangeIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    RangeIndex.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.RangeIndex();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.start = reader.int64();\n                break;\n            case 2:\n                message.stop = reader.int64();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a RangeIndex message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof RangeIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {RangeIndex} RangeIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    RangeIndex.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a RangeIndex message.\n     * @function verify\n     * @memberof RangeIndex\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    RangeIndex.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.start != null && message.hasOwnProperty(\"start\"))\n            if (!$util.isInteger(message.start) && !(message.start && $util.isInteger(message.start.low) && $util.isInteger(message.start.high)))\n                return \"start: integer|Long expected\";\n        if (message.stop != null && message.hasOwnProperty(\"stop\"))\n            if (!$util.isInteger(message.stop) && !(message.stop && $util.isInteger(message.stop.low) && $util.isInteger(message.stop.high)))\n                return \"stop: integer|Long expected\";\n        return null;\n    };\n\n    /**\n     * Creates a RangeIndex message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof RangeIndex\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {RangeIndex} RangeIndex\n     */\n    RangeIndex.fromObject = function fromObject(object) {\n        if (object instanceof $root.RangeIndex)\n            return object;\n        let message = new $root.RangeIndex();\n        if (object.start != null)\n            if ($util.Long)\n                (message.start = $util.Long.fromValue(object.start)).unsigned = false;\n            else if (typeof object.start === \"string\")\n                message.start = parseInt(object.start, 10);\n            else if (typeof object.start === \"number\")\n                message.start = object.start;\n            else if (typeof object.start === \"object\")\n                message.start = new $util.LongBits(object.start.low >>> 0, object.start.high >>> 0).toNumber();\n        if (object.stop != null)\n            if ($util.Long)\n                (message.stop = $util.Long.fromValue(object.stop)).unsigned = false;\n            else if (typeof object.stop === \"string\")\n                message.stop = parseInt(object.stop, 10);\n            else if (typeof object.stop === \"number\")\n                message.stop = object.stop;\n            else if (typeof object.stop === \"object\")\n                message.stop = new $util.LongBits(object.stop.low >>> 0, object.stop.high >>> 0).toNumber();\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a RangeIndex message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof RangeIndex\n     * @static\n     * @param {RangeIndex} message RangeIndex\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    RangeIndex.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            if ($util.Long) {\n                let long = new $util.Long(0, 0, false);\n                object.start = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n            } else\n                object.start = options.longs === String ? \"0\" : 0;\n            if ($util.Long) {\n                let long = new $util.Long(0, 0, false);\n                object.stop = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n            } else\n                object.stop = options.longs === String ? \"0\" : 0;\n        }\n        if (message.start != null && message.hasOwnProperty(\"start\"))\n            if (typeof message.start === \"number\")\n                object.start = options.longs === String ? String(message.start) : message.start;\n            else\n                object.start = options.longs === String ? $util.Long.prototype.toString.call(message.start) : options.longs === Number ? new $util.LongBits(message.start.low >>> 0, message.start.high >>> 0).toNumber() : message.start;\n        if (message.stop != null && message.hasOwnProperty(\"stop\"))\n            if (typeof message.stop === \"number\")\n                object.stop = options.longs === String ? String(message.stop) : message.stop;\n            else\n                object.stop = options.longs === String ? $util.Long.prototype.toString.call(message.stop) : options.longs === Number ? new $util.LongBits(message.stop.low >>> 0, message.stop.high >>> 0).toNumber() : message.stop;\n        return object;\n    };\n\n    /**\n     * Converts this RangeIndex to JSON.\n     * @function toJSON\n     * @memberof RangeIndex\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    RangeIndex.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return RangeIndex;\n})();\n\nexport const MultiIndex = $root.MultiIndex = (() => {\n\n    /**\n     * Properties of a MultiIndex.\n     * @exports IMultiIndex\n     * @interface IMultiIndex\n     * @property {Array.<IIndex>|null} [levels] MultiIndex levels\n     * @property {Array.<IInt32Array>|null} [labels] MultiIndex labels\n     */\n\n    /**\n     * Constructs a new MultiIndex.\n     * @exports MultiIndex\n     * @classdesc Represents a MultiIndex.\n     * @implements IMultiIndex\n     * @constructor\n     * @param {IMultiIndex=} [properties] Properties to set\n     */\n    function MultiIndex(properties) {\n        this.levels = [];\n        this.labels = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * MultiIndex levels.\n     * @member {Array.<IIndex>} levels\n     * @memberof MultiIndex\n     * @instance\n     */\n    MultiIndex.prototype.levels = $util.emptyArray;\n\n    /**\n     * MultiIndex labels.\n     * @member {Array.<IInt32Array>} labels\n     * @memberof MultiIndex\n     * @instance\n     */\n    MultiIndex.prototype.labels = $util.emptyArray;\n\n    /**\n     * Creates a new MultiIndex instance using the specified properties.\n     * @function create\n     * @memberof MultiIndex\n     * @static\n     * @param {IMultiIndex=} [properties] Properties to set\n     * @returns {MultiIndex} MultiIndex instance\n     */\n    MultiIndex.create = function create(properties) {\n        return new MultiIndex(properties);\n    };\n\n    /**\n     * Encodes the specified MultiIndex message. Does not implicitly {@link MultiIndex.verify|verify} messages.\n     * @function encode\n     * @memberof MultiIndex\n     * @static\n     * @param {IMultiIndex} message MultiIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    MultiIndex.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.levels != null && message.levels.length)\n            for (let i = 0; i < message.levels.length; ++i)\n                $root.Index.encode(message.levels[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.labels != null && message.labels.length)\n            for (let i = 0; i < message.labels.length; ++i)\n                $root.Int32Array.encode(message.labels[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified MultiIndex message, length delimited. Does not implicitly {@link MultiIndex.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof MultiIndex\n     * @static\n     * @param {IMultiIndex} message MultiIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    MultiIndex.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a MultiIndex message from the specified reader or buffer.\n     * @function decode\n     * @memberof MultiIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {MultiIndex} MultiIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    MultiIndex.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.MultiIndex();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.levels && message.levels.length))\n                    message.levels = [];\n                message.levels.push($root.Index.decode(reader, reader.uint32()));\n                break;\n            case 2:\n                if (!(message.labels && message.labels.length))\n                    message.labels = [];\n                message.labels.push($root.Int32Array.decode(reader, reader.uint32()));\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a MultiIndex message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof MultiIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {MultiIndex} MultiIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    MultiIndex.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a MultiIndex message.\n     * @function verify\n     * @memberof MultiIndex\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    MultiIndex.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.levels != null && message.hasOwnProperty(\"levels\")) {\n            if (!Array.isArray(message.levels))\n                return \"levels: array expected\";\n            for (let i = 0; i < message.levels.length; ++i) {\n                let error = $root.Index.verify(message.levels[i]);\n                if (error)\n                    return \"levels.\" + error;\n            }\n        }\n        if (message.labels != null && message.hasOwnProperty(\"labels\")) {\n            if (!Array.isArray(message.labels))\n                return \"labels: array expected\";\n            for (let i = 0; i < message.labels.length; ++i) {\n                let error = $root.Int32Array.verify(message.labels[i]);\n                if (error)\n                    return \"labels.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates a MultiIndex message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof MultiIndex\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {MultiIndex} MultiIndex\n     */\n    MultiIndex.fromObject = function fromObject(object) {\n        if (object instanceof $root.MultiIndex)\n            return object;\n        let message = new $root.MultiIndex();\n        if (object.levels) {\n            if (!Array.isArray(object.levels))\n                throw TypeError(\".MultiIndex.levels: array expected\");\n            message.levels = [];\n            for (let i = 0; i < object.levels.length; ++i) {\n                if (typeof object.levels[i] !== \"object\")\n                    throw TypeError(\".MultiIndex.levels: object expected\");\n                message.levels[i] = $root.Index.fromObject(object.levels[i]);\n            }\n        }\n        if (object.labels) {\n            if (!Array.isArray(object.labels))\n                throw TypeError(\".MultiIndex.labels: array expected\");\n            message.labels = [];\n            for (let i = 0; i < object.labels.length; ++i) {\n                if (typeof object.labels[i] !== \"object\")\n                    throw TypeError(\".MultiIndex.labels: object expected\");\n                message.labels[i] = $root.Int32Array.fromObject(object.labels[i]);\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a MultiIndex message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof MultiIndex\n     * @static\n     * @param {MultiIndex} message MultiIndex\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    MultiIndex.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults) {\n            object.levels = [];\n            object.labels = [];\n        }\n        if (message.levels && message.levels.length) {\n            object.levels = [];\n            for (let j = 0; j < message.levels.length; ++j)\n                object.levels[j] = $root.Index.toObject(message.levels[j], options);\n        }\n        if (message.labels && message.labels.length) {\n            object.labels = [];\n            for (let j = 0; j < message.labels.length; ++j)\n                object.labels[j] = $root.Int32Array.toObject(message.labels[j], options);\n        }\n        return object;\n    };\n\n    /**\n     * Converts this MultiIndex to JSON.\n     * @function toJSON\n     * @memberof MultiIndex\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    MultiIndex.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return MultiIndex;\n})();\n\nexport const DatetimeIndex = $root.DatetimeIndex = (() => {\n\n    /**\n     * Properties of a DatetimeIndex.\n     * @exports IDatetimeIndex\n     * @interface IDatetimeIndex\n     * @property {IInt64Array|null} [data] DatetimeIndex data\n     */\n\n    /**\n     * Constructs a new DatetimeIndex.\n     * @exports DatetimeIndex\n     * @classdesc Represents a DatetimeIndex.\n     * @implements IDatetimeIndex\n     * @constructor\n     * @param {IDatetimeIndex=} [properties] Properties to set\n     */\n    function DatetimeIndex(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DatetimeIndex data.\n     * @member {IInt64Array|null|undefined} data\n     * @memberof DatetimeIndex\n     * @instance\n     */\n    DatetimeIndex.prototype.data = null;\n\n    /**\n     * Creates a new DatetimeIndex instance using the specified properties.\n     * @function create\n     * @memberof DatetimeIndex\n     * @static\n     * @param {IDatetimeIndex=} [properties] Properties to set\n     * @returns {DatetimeIndex} DatetimeIndex instance\n     */\n    DatetimeIndex.create = function create(properties) {\n        return new DatetimeIndex(properties);\n    };\n\n    /**\n     * Encodes the specified DatetimeIndex message. Does not implicitly {@link DatetimeIndex.verify|verify} messages.\n     * @function encode\n     * @memberof DatetimeIndex\n     * @static\n     * @param {IDatetimeIndex} message DatetimeIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DatetimeIndex.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.Int64Array.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DatetimeIndex message, length delimited. Does not implicitly {@link DatetimeIndex.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DatetimeIndex\n     * @static\n     * @param {IDatetimeIndex} message DatetimeIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DatetimeIndex.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DatetimeIndex message from the specified reader or buffer.\n     * @function decode\n     * @memberof DatetimeIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DatetimeIndex} DatetimeIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DatetimeIndex.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DatetimeIndex();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.Int64Array.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DatetimeIndex message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DatetimeIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DatetimeIndex} DatetimeIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DatetimeIndex.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DatetimeIndex message.\n     * @function verify\n     * @memberof DatetimeIndex\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DatetimeIndex.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.Int64Array.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates a DatetimeIndex message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DatetimeIndex\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DatetimeIndex} DatetimeIndex\n     */\n    DatetimeIndex.fromObject = function fromObject(object) {\n        if (object instanceof $root.DatetimeIndex)\n            return object;\n        let message = new $root.DatetimeIndex();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".DatetimeIndex.data: object expected\");\n            message.data = $root.Int64Array.fromObject(object.data);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DatetimeIndex message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DatetimeIndex\n     * @static\n     * @param {DatetimeIndex} message DatetimeIndex\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DatetimeIndex.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.data = null;\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.Int64Array.toObject(message.data, options);\n        return object;\n    };\n\n    /**\n     * Converts this DatetimeIndex to JSON.\n     * @function toJSON\n     * @memberof DatetimeIndex\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DatetimeIndex.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DatetimeIndex;\n})();\n\nexport const TimedeltaIndex = $root.TimedeltaIndex = (() => {\n\n    /**\n     * Properties of a TimedeltaIndex.\n     * @exports ITimedeltaIndex\n     * @interface ITimedeltaIndex\n     * @property {IInt64Array|null} [data] TimedeltaIndex data\n     */\n\n    /**\n     * Constructs a new TimedeltaIndex.\n     * @exports TimedeltaIndex\n     * @classdesc Represents a TimedeltaIndex.\n     * @implements ITimedeltaIndex\n     * @constructor\n     * @param {ITimedeltaIndex=} [properties] Properties to set\n     */\n    function TimedeltaIndex(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TimedeltaIndex data.\n     * @member {IInt64Array|null|undefined} data\n     * @memberof TimedeltaIndex\n     * @instance\n     */\n    TimedeltaIndex.prototype.data = null;\n\n    /**\n     * Creates a new TimedeltaIndex instance using the specified properties.\n     * @function create\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {ITimedeltaIndex=} [properties] Properties to set\n     * @returns {TimedeltaIndex} TimedeltaIndex instance\n     */\n    TimedeltaIndex.create = function create(properties) {\n        return new TimedeltaIndex(properties);\n    };\n\n    /**\n     * Encodes the specified TimedeltaIndex message. Does not implicitly {@link TimedeltaIndex.verify|verify} messages.\n     * @function encode\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {ITimedeltaIndex} message TimedeltaIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TimedeltaIndex.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.Int64Array.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified TimedeltaIndex message, length delimited. Does not implicitly {@link TimedeltaIndex.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {ITimedeltaIndex} message TimedeltaIndex message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TimedeltaIndex.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TimedeltaIndex message from the specified reader or buffer.\n     * @function decode\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {TimedeltaIndex} TimedeltaIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TimedeltaIndex.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TimedeltaIndex();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.Int64Array.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a TimedeltaIndex message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {TimedeltaIndex} TimedeltaIndex\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TimedeltaIndex.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TimedeltaIndex message.\n     * @function verify\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TimedeltaIndex.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.Int64Array.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates a TimedeltaIndex message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {TimedeltaIndex} TimedeltaIndex\n     */\n    TimedeltaIndex.fromObject = function fromObject(object) {\n        if (object instanceof $root.TimedeltaIndex)\n            return object;\n        let message = new $root.TimedeltaIndex();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".TimedeltaIndex.data: object expected\");\n            message.data = $root.Int64Array.fromObject(object.data);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a TimedeltaIndex message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof TimedeltaIndex\n     * @static\n     * @param {TimedeltaIndex} message TimedeltaIndex\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TimedeltaIndex.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.data = null;\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.Int64Array.toObject(message.data, options);\n        return object;\n    };\n\n    /**\n     * Converts this TimedeltaIndex to JSON.\n     * @function toJSON\n     * @memberof TimedeltaIndex\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TimedeltaIndex.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return TimedeltaIndex;\n})();\n\nexport const Int64Index = $root.Int64Index = (() => {\n\n    /**\n     * Properties of an Int64Index.\n     * @exports IInt64Index\n     * @interface IInt64Index\n     * @property {IInt64Array|null} [data] Int64Index data\n     */\n\n    /**\n     * Constructs a new Int64Index.\n     * @exports Int64Index\n     * @classdesc Represents an Int64Index.\n     * @implements IInt64Index\n     * @constructor\n     * @param {IInt64Index=} [properties] Properties to set\n     */\n    function Int64Index(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Int64Index data.\n     * @member {IInt64Array|null|undefined} data\n     * @memberof Int64Index\n     * @instance\n     */\n    Int64Index.prototype.data = null;\n\n    /**\n     * Creates a new Int64Index instance using the specified properties.\n     * @function create\n     * @memberof Int64Index\n     * @static\n     * @param {IInt64Index=} [properties] Properties to set\n     * @returns {Int64Index} Int64Index instance\n     */\n    Int64Index.create = function create(properties) {\n        return new Int64Index(properties);\n    };\n\n    /**\n     * Encodes the specified Int64Index message. Does not implicitly {@link Int64Index.verify|verify} messages.\n     * @function encode\n     * @memberof Int64Index\n     * @static\n     * @param {IInt64Index} message Int64Index message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Int64Index.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.Int64Array.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Int64Index message, length delimited. Does not implicitly {@link Int64Index.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Int64Index\n     * @static\n     * @param {IInt64Index} message Int64Index message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Int64Index.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Int64Index message from the specified reader or buffer.\n     * @function decode\n     * @memberof Int64Index\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Int64Index} Int64Index\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Int64Index.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Int64Index();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.Int64Array.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Int64Index message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Int64Index\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Int64Index} Int64Index\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Int64Index.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Int64Index message.\n     * @function verify\n     * @memberof Int64Index\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Int64Index.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.Int64Array.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates an Int64Index message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Int64Index\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Int64Index} Int64Index\n     */\n    Int64Index.fromObject = function fromObject(object) {\n        if (object instanceof $root.Int64Index)\n            return object;\n        let message = new $root.Int64Index();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".Int64Index.data: object expected\");\n            message.data = $root.Int64Array.fromObject(object.data);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Int64Index message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Int64Index\n     * @static\n     * @param {Int64Index} message Int64Index\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Int64Index.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.data = null;\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.Int64Array.toObject(message.data, options);\n        return object;\n    };\n\n    /**\n     * Converts this Int64Index to JSON.\n     * @function toJSON\n     * @memberof Int64Index\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Int64Index.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Int64Index;\n})();\n\nexport const Float64Index = $root.Float64Index = (() => {\n\n    /**\n     * Properties of a Float64Index.\n     * @exports IFloat64Index\n     * @interface IFloat64Index\n     * @property {IDoubleArray|null} [data] Float64Index data\n     */\n\n    /**\n     * Constructs a new Float64Index.\n     * @exports Float64Index\n     * @classdesc Represents a Float64Index.\n     * @implements IFloat64Index\n     * @constructor\n     * @param {IFloat64Index=} [properties] Properties to set\n     */\n    function Float64Index(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Float64Index data.\n     * @member {IDoubleArray|null|undefined} data\n     * @memberof Float64Index\n     * @instance\n     */\n    Float64Index.prototype.data = null;\n\n    /**\n     * Creates a new Float64Index instance using the specified properties.\n     * @function create\n     * @memberof Float64Index\n     * @static\n     * @param {IFloat64Index=} [properties] Properties to set\n     * @returns {Float64Index} Float64Index instance\n     */\n    Float64Index.create = function create(properties) {\n        return new Float64Index(properties);\n    };\n\n    /**\n     * Encodes the specified Float64Index message. Does not implicitly {@link Float64Index.verify|verify} messages.\n     * @function encode\n     * @memberof Float64Index\n     * @static\n     * @param {IFloat64Index} message Float64Index message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Float64Index.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.DoubleArray.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Float64Index message, length delimited. Does not implicitly {@link Float64Index.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Float64Index\n     * @static\n     * @param {IFloat64Index} message Float64Index message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Float64Index.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Float64Index message from the specified reader or buffer.\n     * @function decode\n     * @memberof Float64Index\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Float64Index} Float64Index\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Float64Index.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Float64Index();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.DoubleArray.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Float64Index message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Float64Index\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Float64Index} Float64Index\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Float64Index.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Float64Index message.\n     * @function verify\n     * @memberof Float64Index\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Float64Index.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.DoubleArray.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates a Float64Index message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Float64Index\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Float64Index} Float64Index\n     */\n    Float64Index.fromObject = function fromObject(object) {\n        if (object instanceof $root.Float64Index)\n            return object;\n        let message = new $root.Float64Index();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".Float64Index.data: object expected\");\n            message.data = $root.DoubleArray.fromObject(object.data);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Float64Index message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Float64Index\n     * @static\n     * @param {Float64Index} message Float64Index\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Float64Index.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.data = null;\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.DoubleArray.toObject(message.data, options);\n        return object;\n    };\n\n    /**\n     * Converts this Float64Index to JSON.\n     * @function toJSON\n     * @memberof Float64Index\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Float64Index.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Float64Index;\n})();\n\nexport const StringArray = $root.StringArray = (() => {\n\n    /**\n     * Properties of a StringArray.\n     * @exports IStringArray\n     * @interface IStringArray\n     * @property {Array.<string>|null} [data] StringArray data\n     */\n\n    /**\n     * Constructs a new StringArray.\n     * @exports StringArray\n     * @classdesc Represents a StringArray.\n     * @implements IStringArray\n     * @constructor\n     * @param {IStringArray=} [properties] Properties to set\n     */\n    function StringArray(properties) {\n        this.data = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * StringArray data.\n     * @member {Array.<string>} data\n     * @memberof StringArray\n     * @instance\n     */\n    StringArray.prototype.data = $util.emptyArray;\n\n    /**\n     * Creates a new StringArray instance using the specified properties.\n     * @function create\n     * @memberof StringArray\n     * @static\n     * @param {IStringArray=} [properties] Properties to set\n     * @returns {StringArray} StringArray instance\n     */\n    StringArray.create = function create(properties) {\n        return new StringArray(properties);\n    };\n\n    /**\n     * Encodes the specified StringArray message. Does not implicitly {@link StringArray.verify|verify} messages.\n     * @function encode\n     * @memberof StringArray\n     * @static\n     * @param {IStringArray} message StringArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    StringArray.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && message.data.length)\n            for (let i = 0; i < message.data.length; ++i)\n                writer.uint32(/* id 1, wireType 2 =*/10).string(message.data[i]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified StringArray message, length delimited. Does not implicitly {@link StringArray.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof StringArray\n     * @static\n     * @param {IStringArray} message StringArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    StringArray.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a StringArray message from the specified reader or buffer.\n     * @function decode\n     * @memberof StringArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {StringArray} StringArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    StringArray.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.StringArray();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.data && message.data.length))\n                    message.data = [];\n                message.data.push(reader.string());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a StringArray message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof StringArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {StringArray} StringArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    StringArray.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a StringArray message.\n     * @function verify\n     * @memberof StringArray\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    StringArray.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            if (!Array.isArray(message.data))\n                return \"data: array expected\";\n            for (let i = 0; i < message.data.length; ++i)\n                if (!$util.isString(message.data[i]))\n                    return \"data: string[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a StringArray message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof StringArray\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {StringArray} StringArray\n     */\n    StringArray.fromObject = function fromObject(object) {\n        if (object instanceof $root.StringArray)\n            return object;\n        let message = new $root.StringArray();\n        if (object.data) {\n            if (!Array.isArray(object.data))\n                throw TypeError(\".StringArray.data: array expected\");\n            message.data = [];\n            for (let i = 0; i < object.data.length; ++i)\n                message.data[i] = String(object.data[i]);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a StringArray message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof StringArray\n     * @static\n     * @param {StringArray} message StringArray\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    StringArray.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.data = [];\n        if (message.data && message.data.length) {\n            object.data = [];\n            for (let j = 0; j < message.data.length; ++j)\n                object.data[j] = message.data[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this StringArray to JSON.\n     * @function toJSON\n     * @memberof StringArray\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    StringArray.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return StringArray;\n})();\n\nexport const DoubleArray = $root.DoubleArray = (() => {\n\n    /**\n     * Properties of a DoubleArray.\n     * @exports IDoubleArray\n     * @interface IDoubleArray\n     * @property {Array.<number>|null} [data] DoubleArray data\n     */\n\n    /**\n     * Constructs a new DoubleArray.\n     * @exports DoubleArray\n     * @classdesc Represents a DoubleArray.\n     * @implements IDoubleArray\n     * @constructor\n     * @param {IDoubleArray=} [properties] Properties to set\n     */\n    function DoubleArray(properties) {\n        this.data = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DoubleArray data.\n     * @member {Array.<number>} data\n     * @memberof DoubleArray\n     * @instance\n     */\n    DoubleArray.prototype.data = $util.emptyArray;\n\n    /**\n     * Creates a new DoubleArray instance using the specified properties.\n     * @function create\n     * @memberof DoubleArray\n     * @static\n     * @param {IDoubleArray=} [properties] Properties to set\n     * @returns {DoubleArray} DoubleArray instance\n     */\n    DoubleArray.create = function create(properties) {\n        return new DoubleArray(properties);\n    };\n\n    /**\n     * Encodes the specified DoubleArray message. Does not implicitly {@link DoubleArray.verify|verify} messages.\n     * @function encode\n     * @memberof DoubleArray\n     * @static\n     * @param {IDoubleArray} message DoubleArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DoubleArray.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && message.data.length) {\n            writer.uint32(/* id 1, wireType 2 =*/10).fork();\n            for (let i = 0; i < message.data.length; ++i)\n                writer.double(message.data[i]);\n            writer.ldelim();\n        }\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DoubleArray message, length delimited. Does not implicitly {@link DoubleArray.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DoubleArray\n     * @static\n     * @param {IDoubleArray} message DoubleArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DoubleArray.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DoubleArray message from the specified reader or buffer.\n     * @function decode\n     * @memberof DoubleArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DoubleArray} DoubleArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DoubleArray.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DoubleArray();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.data && message.data.length))\n                    message.data = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message.data.push(reader.double());\n                } else\n                    message.data.push(reader.double());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DoubleArray message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DoubleArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DoubleArray} DoubleArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DoubleArray.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DoubleArray message.\n     * @function verify\n     * @memberof DoubleArray\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DoubleArray.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            if (!Array.isArray(message.data))\n                return \"data: array expected\";\n            for (let i = 0; i < message.data.length; ++i)\n                if (typeof message.data[i] !== \"number\")\n                    return \"data: number[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a DoubleArray message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DoubleArray\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DoubleArray} DoubleArray\n     */\n    DoubleArray.fromObject = function fromObject(object) {\n        if (object instanceof $root.DoubleArray)\n            return object;\n        let message = new $root.DoubleArray();\n        if (object.data) {\n            if (!Array.isArray(object.data))\n                throw TypeError(\".DoubleArray.data: array expected\");\n            message.data = [];\n            for (let i = 0; i < object.data.length; ++i)\n                message.data[i] = Number(object.data[i]);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DoubleArray message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DoubleArray\n     * @static\n     * @param {DoubleArray} message DoubleArray\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DoubleArray.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.data = [];\n        if (message.data && message.data.length) {\n            object.data = [];\n            for (let j = 0; j < message.data.length; ++j)\n                object.data[j] = options.json && !isFinite(message.data[j]) ? String(message.data[j]) : message.data[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this DoubleArray to JSON.\n     * @function toJSON\n     * @memberof DoubleArray\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DoubleArray.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DoubleArray;\n})();\n\nexport const Int32Array = $root.Int32Array = (() => {\n\n    /**\n     * Properties of an Int32Array.\n     * @exports IInt32Array\n     * @interface IInt32Array\n     * @property {Array.<number>|null} [data] Int32Array data\n     */\n\n    /**\n     * Constructs a new Int32Array.\n     * @exports Int32Array\n     * @classdesc Represents an Int32Array.\n     * @implements IInt32Array\n     * @constructor\n     * @param {IInt32Array=} [properties] Properties to set\n     */\n    function Int32Array(properties) {\n        this.data = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Int32Array data.\n     * @member {Array.<number>} data\n     * @memberof Int32Array\n     * @instance\n     */\n    Int32Array.prototype.data = $util.emptyArray;\n\n    /**\n     * Creates a new Int32Array instance using the specified properties.\n     * @function create\n     * @memberof Int32Array\n     * @static\n     * @param {IInt32Array=} [properties] Properties to set\n     * @returns {Int32Array} Int32Array instance\n     */\n    Int32Array.create = function create(properties) {\n        return new Int32Array(properties);\n    };\n\n    /**\n     * Encodes the specified Int32Array message. Does not implicitly {@link Int32Array.verify|verify} messages.\n     * @function encode\n     * @memberof Int32Array\n     * @static\n     * @param {IInt32Array} message Int32Array message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Int32Array.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && message.data.length) {\n            writer.uint32(/* id 1, wireType 2 =*/10).fork();\n            for (let i = 0; i < message.data.length; ++i)\n                writer.int32(message.data[i]);\n            writer.ldelim();\n        }\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Int32Array message, length delimited. Does not implicitly {@link Int32Array.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Int32Array\n     * @static\n     * @param {IInt32Array} message Int32Array message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Int32Array.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Int32Array message from the specified reader or buffer.\n     * @function decode\n     * @memberof Int32Array\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Int32Array} Int32Array\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Int32Array.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Int32Array();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.data && message.data.length))\n                    message.data = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message.data.push(reader.int32());\n                } else\n                    message.data.push(reader.int32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Int32Array message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Int32Array\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Int32Array} Int32Array\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Int32Array.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Int32Array message.\n     * @function verify\n     * @memberof Int32Array\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Int32Array.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            if (!Array.isArray(message.data))\n                return \"data: array expected\";\n            for (let i = 0; i < message.data.length; ++i)\n                if (!$util.isInteger(message.data[i]))\n                    return \"data: integer[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates an Int32Array message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Int32Array\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Int32Array} Int32Array\n     */\n    Int32Array.fromObject = function fromObject(object) {\n        if (object instanceof $root.Int32Array)\n            return object;\n        let message = new $root.Int32Array();\n        if (object.data) {\n            if (!Array.isArray(object.data))\n                throw TypeError(\".Int32Array.data: array expected\");\n            message.data = [];\n            for (let i = 0; i < object.data.length; ++i)\n                message.data[i] = object.data[i] | 0;\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Int32Array message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Int32Array\n     * @static\n     * @param {Int32Array} message Int32Array\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Int32Array.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.data = [];\n        if (message.data && message.data.length) {\n            object.data = [];\n            for (let j = 0; j < message.data.length; ++j)\n                object.data[j] = message.data[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Int32Array to JSON.\n     * @function toJSON\n     * @memberof Int32Array\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Int32Array.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Int32Array;\n})();\n\nexport const Int64Array = $root.Int64Array = (() => {\n\n    /**\n     * Properties of an Int64Array.\n     * @exports IInt64Array\n     * @interface IInt64Array\n     * @property {Array.<number|Long>|null} [data] Int64Array data\n     */\n\n    /**\n     * Constructs a new Int64Array.\n     * @exports Int64Array\n     * @classdesc Represents an Int64Array.\n     * @implements IInt64Array\n     * @constructor\n     * @param {IInt64Array=} [properties] Properties to set\n     */\n    function Int64Array(properties) {\n        this.data = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Int64Array data.\n     * @member {Array.<number|Long>} data\n     * @memberof Int64Array\n     * @instance\n     */\n    Int64Array.prototype.data = $util.emptyArray;\n\n    /**\n     * Creates a new Int64Array instance using the specified properties.\n     * @function create\n     * @memberof Int64Array\n     * @static\n     * @param {IInt64Array=} [properties] Properties to set\n     * @returns {Int64Array} Int64Array instance\n     */\n    Int64Array.create = function create(properties) {\n        return new Int64Array(properties);\n    };\n\n    /**\n     * Encodes the specified Int64Array message. Does not implicitly {@link Int64Array.verify|verify} messages.\n     * @function encode\n     * @memberof Int64Array\n     * @static\n     * @param {IInt64Array} message Int64Array message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Int64Array.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && message.data.length) {\n            writer.uint32(/* id 1, wireType 2 =*/10).fork();\n            for (let i = 0; i < message.data.length; ++i)\n                writer.int64(message.data[i]);\n            writer.ldelim();\n        }\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Int64Array message, length delimited. Does not implicitly {@link Int64Array.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Int64Array\n     * @static\n     * @param {IInt64Array} message Int64Array message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Int64Array.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Int64Array message from the specified reader or buffer.\n     * @function decode\n     * @memberof Int64Array\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Int64Array} Int64Array\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Int64Array.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Int64Array();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.data && message.data.length))\n                    message.data = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message.data.push(reader.int64());\n                } else\n                    message.data.push(reader.int64());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Int64Array message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Int64Array\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Int64Array} Int64Array\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Int64Array.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Int64Array message.\n     * @function verify\n     * @memberof Int64Array\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Int64Array.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            if (!Array.isArray(message.data))\n                return \"data: array expected\";\n            for (let i = 0; i < message.data.length; ++i)\n                if (!$util.isInteger(message.data[i]) && !(message.data[i] && $util.isInteger(message.data[i].low) && $util.isInteger(message.data[i].high)))\n                    return \"data: integer|Long[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates an Int64Array message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Int64Array\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Int64Array} Int64Array\n     */\n    Int64Array.fromObject = function fromObject(object) {\n        if (object instanceof $root.Int64Array)\n            return object;\n        let message = new $root.Int64Array();\n        if (object.data) {\n            if (!Array.isArray(object.data))\n                throw TypeError(\".Int64Array.data: array expected\");\n            message.data = [];\n            for (let i = 0; i < object.data.length; ++i)\n                if ($util.Long)\n                    (message.data[i] = $util.Long.fromValue(object.data[i])).unsigned = false;\n                else if (typeof object.data[i] === \"string\")\n                    message.data[i] = parseInt(object.data[i], 10);\n                else if (typeof object.data[i] === \"number\")\n                    message.data[i] = object.data[i];\n                else if (typeof object.data[i] === \"object\")\n                    message.data[i] = new $util.LongBits(object.data[i].low >>> 0, object.data[i].high >>> 0).toNumber();\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Int64Array message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Int64Array\n     * @static\n     * @param {Int64Array} message Int64Array\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Int64Array.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.data = [];\n        if (message.data && message.data.length) {\n            object.data = [];\n            for (let j = 0; j < message.data.length; ++j)\n                if (typeof message.data[j] === \"number\")\n                    object.data[j] = options.longs === String ? String(message.data[j]) : message.data[j];\n                else\n                    object.data[j] = options.longs === String ? $util.Long.prototype.toString.call(message.data[j]) : options.longs === Number ? new $util.LongBits(message.data[j].low >>> 0, message.data[j].high >>> 0).toNumber() : message.data[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Int64Array to JSON.\n     * @function toJSON\n     * @memberof Int64Array\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Int64Array.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Int64Array;\n})();\n\nexport const UInt32Array = $root.UInt32Array = (() => {\n\n    /**\n     * Properties of a UInt32Array.\n     * @exports IUInt32Array\n     * @interface IUInt32Array\n     * @property {Array.<number>|null} [data] UInt32Array data\n     */\n\n    /**\n     * Constructs a new UInt32Array.\n     * @exports UInt32Array\n     * @classdesc Represents a UInt32Array.\n     * @implements IUInt32Array\n     * @constructor\n     * @param {IUInt32Array=} [properties] Properties to set\n     */\n    function UInt32Array(properties) {\n        this.data = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * UInt32Array data.\n     * @member {Array.<number>} data\n     * @memberof UInt32Array\n     * @instance\n     */\n    UInt32Array.prototype.data = $util.emptyArray;\n\n    /**\n     * Creates a new UInt32Array instance using the specified properties.\n     * @function create\n     * @memberof UInt32Array\n     * @static\n     * @param {IUInt32Array=} [properties] Properties to set\n     * @returns {UInt32Array} UInt32Array instance\n     */\n    UInt32Array.create = function create(properties) {\n        return new UInt32Array(properties);\n    };\n\n    /**\n     * Encodes the specified UInt32Array message. Does not implicitly {@link UInt32Array.verify|verify} messages.\n     * @function encode\n     * @memberof UInt32Array\n     * @static\n     * @param {IUInt32Array} message UInt32Array message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    UInt32Array.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && message.data.length) {\n            writer.uint32(/* id 1, wireType 2 =*/10).fork();\n            for (let i = 0; i < message.data.length; ++i)\n                writer.uint32(message.data[i]);\n            writer.ldelim();\n        }\n        return writer;\n    };\n\n    /**\n     * Encodes the specified UInt32Array message, length delimited. Does not implicitly {@link UInt32Array.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof UInt32Array\n     * @static\n     * @param {IUInt32Array} message UInt32Array message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    UInt32Array.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a UInt32Array message from the specified reader or buffer.\n     * @function decode\n     * @memberof UInt32Array\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {UInt32Array} UInt32Array\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    UInt32Array.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.UInt32Array();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.data && message.data.length))\n                    message.data = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message.data.push(reader.uint32());\n                } else\n                    message.data.push(reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a UInt32Array message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof UInt32Array\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {UInt32Array} UInt32Array\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    UInt32Array.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a UInt32Array message.\n     * @function verify\n     * @memberof UInt32Array\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    UInt32Array.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            if (!Array.isArray(message.data))\n                return \"data: array expected\";\n            for (let i = 0; i < message.data.length; ++i)\n                if (!$util.isInteger(message.data[i]))\n                    return \"data: integer[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a UInt32Array message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof UInt32Array\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {UInt32Array} UInt32Array\n     */\n    UInt32Array.fromObject = function fromObject(object) {\n        if (object instanceof $root.UInt32Array)\n            return object;\n        let message = new $root.UInt32Array();\n        if (object.data) {\n            if (!Array.isArray(object.data))\n                throw TypeError(\".UInt32Array.data: array expected\");\n            message.data = [];\n            for (let i = 0; i < object.data.length; ++i)\n                message.data[i] = object.data[i] >>> 0;\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a UInt32Array message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof UInt32Array\n     * @static\n     * @param {UInt32Array} message UInt32Array\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    UInt32Array.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.data = [];\n        if (message.data && message.data.length) {\n            object.data = [];\n            for (let j = 0; j < message.data.length; ++j)\n                object.data[j] = message.data[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this UInt32Array to JSON.\n     * @function toJSON\n     * @memberof UInt32Array\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    UInt32Array.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return UInt32Array;\n})();\n\nexport const CSSStyle = $root.CSSStyle = (() => {\n\n    /**\n     * Properties of a CSSStyle.\n     * @exports ICSSStyle\n     * @interface ICSSStyle\n     * @property {string|null} [property] CSSStyle property\n     * @property {string|null} [value] CSSStyle value\n     */\n\n    /**\n     * Constructs a new CSSStyle.\n     * @exports CSSStyle\n     * @classdesc Represents a CSSStyle.\n     * @implements ICSSStyle\n     * @constructor\n     * @param {ICSSStyle=} [properties] Properties to set\n     */\n    function CSSStyle(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * CSSStyle property.\n     * @member {string} property\n     * @memberof CSSStyle\n     * @instance\n     */\n    CSSStyle.prototype.property = \"\";\n\n    /**\n     * CSSStyle value.\n     * @member {string} value\n     * @memberof CSSStyle\n     * @instance\n     */\n    CSSStyle.prototype.value = \"\";\n\n    /**\n     * Creates a new CSSStyle instance using the specified properties.\n     * @function create\n     * @memberof CSSStyle\n     * @static\n     * @param {ICSSStyle=} [properties] Properties to set\n     * @returns {CSSStyle} CSSStyle instance\n     */\n    CSSStyle.create = function create(properties) {\n        return new CSSStyle(properties);\n    };\n\n    /**\n     * Encodes the specified CSSStyle message. Does not implicitly {@link CSSStyle.verify|verify} messages.\n     * @function encode\n     * @memberof CSSStyle\n     * @static\n     * @param {ICSSStyle} message CSSStyle message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    CSSStyle.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.property != null && Object.hasOwnProperty.call(message, \"property\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.property);\n        if (message.value != null && Object.hasOwnProperty.call(message, \"value\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.value);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified CSSStyle message, length delimited. Does not implicitly {@link CSSStyle.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof CSSStyle\n     * @static\n     * @param {ICSSStyle} message CSSStyle message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    CSSStyle.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a CSSStyle message from the specified reader or buffer.\n     * @function decode\n     * @memberof CSSStyle\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {CSSStyle} CSSStyle\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    CSSStyle.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.CSSStyle();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.property = reader.string();\n                break;\n            case 2:\n                message.value = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a CSSStyle message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof CSSStyle\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {CSSStyle} CSSStyle\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    CSSStyle.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a CSSStyle message.\n     * @function verify\n     * @memberof CSSStyle\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    CSSStyle.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.property != null && message.hasOwnProperty(\"property\"))\n            if (!$util.isString(message.property))\n                return \"property: string expected\";\n        if (message.value != null && message.hasOwnProperty(\"value\"))\n            if (!$util.isString(message.value))\n                return \"value: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a CSSStyle message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof CSSStyle\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {CSSStyle} CSSStyle\n     */\n    CSSStyle.fromObject = function fromObject(object) {\n        if (object instanceof $root.CSSStyle)\n            return object;\n        let message = new $root.CSSStyle();\n        if (object.property != null)\n            message.property = String(object.property);\n        if (object.value != null)\n            message.value = String(object.value);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a CSSStyle message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof CSSStyle\n     * @static\n     * @param {CSSStyle} message CSSStyle\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    CSSStyle.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.property = \"\";\n            object.value = \"\";\n        }\n        if (message.property != null && message.hasOwnProperty(\"property\"))\n            object.property = message.property;\n        if (message.value != null && message.hasOwnProperty(\"value\"))\n            object.value = message.value;\n        return object;\n    };\n\n    /**\n     * Converts this CSSStyle to JSON.\n     * @function toJSON\n     * @memberof CSSStyle\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    CSSStyle.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return CSSStyle;\n})();\n\nexport const CellStyle = $root.CellStyle = (() => {\n\n    /**\n     * Properties of a CellStyle.\n     * @exports ICellStyle\n     * @interface ICellStyle\n     * @property {Array.<ICSSStyle>|null} [css] CellStyle css\n     * @property {string|null} [displayValue] CellStyle displayValue\n     * @property {boolean|null} [hasDisplayValue] CellStyle hasDisplayValue\n     */\n\n    /**\n     * Constructs a new CellStyle.\n     * @exports CellStyle\n     * @classdesc Represents a CellStyle.\n     * @implements ICellStyle\n     * @constructor\n     * @param {ICellStyle=} [properties] Properties to set\n     */\n    function CellStyle(properties) {\n        this.css = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * CellStyle css.\n     * @member {Array.<ICSSStyle>} css\n     * @memberof CellStyle\n     * @instance\n     */\n    CellStyle.prototype.css = $util.emptyArray;\n\n    /**\n     * CellStyle displayValue.\n     * @member {string} displayValue\n     * @memberof CellStyle\n     * @instance\n     */\n    CellStyle.prototype.displayValue = \"\";\n\n    /**\n     * CellStyle hasDisplayValue.\n     * @member {boolean} hasDisplayValue\n     * @memberof CellStyle\n     * @instance\n     */\n    CellStyle.prototype.hasDisplayValue = false;\n\n    /**\n     * Creates a new CellStyle instance using the specified properties.\n     * @function create\n     * @memberof CellStyle\n     * @static\n     * @param {ICellStyle=} [properties] Properties to set\n     * @returns {CellStyle} CellStyle instance\n     */\n    CellStyle.create = function create(properties) {\n        return new CellStyle(properties);\n    };\n\n    /**\n     * Encodes the specified CellStyle message. Does not implicitly {@link CellStyle.verify|verify} messages.\n     * @function encode\n     * @memberof CellStyle\n     * @static\n     * @param {ICellStyle} message CellStyle message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    CellStyle.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.css != null && message.css.length)\n            for (let i = 0; i < message.css.length; ++i)\n                $root.CSSStyle.encode(message.css[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.displayValue != null && Object.hasOwnProperty.call(message, \"displayValue\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.displayValue);\n        if (message.hasDisplayValue != null && Object.hasOwnProperty.call(message, \"hasDisplayValue\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.hasDisplayValue);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified CellStyle message, length delimited. Does not implicitly {@link CellStyle.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof CellStyle\n     * @static\n     * @param {ICellStyle} message CellStyle message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    CellStyle.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a CellStyle message from the specified reader or buffer.\n     * @function decode\n     * @memberof CellStyle\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {CellStyle} CellStyle\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    CellStyle.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.CellStyle();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.css && message.css.length))\n                    message.css = [];\n                message.css.push($root.CSSStyle.decode(reader, reader.uint32()));\n                break;\n            case 2:\n                message.displayValue = reader.string();\n                break;\n            case 3:\n                message.hasDisplayValue = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a CellStyle message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof CellStyle\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {CellStyle} CellStyle\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    CellStyle.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a CellStyle message.\n     * @function verify\n     * @memberof CellStyle\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    CellStyle.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.css != null && message.hasOwnProperty(\"css\")) {\n            if (!Array.isArray(message.css))\n                return \"css: array expected\";\n            for (let i = 0; i < message.css.length; ++i) {\n                let error = $root.CSSStyle.verify(message.css[i]);\n                if (error)\n                    return \"css.\" + error;\n            }\n        }\n        if (message.displayValue != null && message.hasOwnProperty(\"displayValue\"))\n            if (!$util.isString(message.displayValue))\n                return \"displayValue: string expected\";\n        if (message.hasDisplayValue != null && message.hasOwnProperty(\"hasDisplayValue\"))\n            if (typeof message.hasDisplayValue !== \"boolean\")\n                return \"hasDisplayValue: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a CellStyle message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof CellStyle\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {CellStyle} CellStyle\n     */\n    CellStyle.fromObject = function fromObject(object) {\n        if (object instanceof $root.CellStyle)\n            return object;\n        let message = new $root.CellStyle();\n        if (object.css) {\n            if (!Array.isArray(object.css))\n                throw TypeError(\".CellStyle.css: array expected\");\n            message.css = [];\n            for (let i = 0; i < object.css.length; ++i) {\n                if (typeof object.css[i] !== \"object\")\n                    throw TypeError(\".CellStyle.css: object expected\");\n                message.css[i] = $root.CSSStyle.fromObject(object.css[i]);\n            }\n        }\n        if (object.displayValue != null)\n            message.displayValue = String(object.displayValue);\n        if (object.hasDisplayValue != null)\n            message.hasDisplayValue = Boolean(object.hasDisplayValue);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a CellStyle message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof CellStyle\n     * @static\n     * @param {CellStyle} message CellStyle\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    CellStyle.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.css = [];\n        if (options.defaults) {\n            object.displayValue = \"\";\n            object.hasDisplayValue = false;\n        }\n        if (message.css && message.css.length) {\n            object.css = [];\n            for (let j = 0; j < message.css.length; ++j)\n                object.css[j] = $root.CSSStyle.toObject(message.css[j], options);\n        }\n        if (message.displayValue != null && message.hasOwnProperty(\"displayValue\"))\n            object.displayValue = message.displayValue;\n        if (message.hasDisplayValue != null && message.hasOwnProperty(\"hasDisplayValue\"))\n            object.hasDisplayValue = message.hasDisplayValue;\n        return object;\n    };\n\n    /**\n     * Converts this CellStyle to JSON.\n     * @function toJSON\n     * @memberof CellStyle\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    CellStyle.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return CellStyle;\n})();\n\nexport const CellStyleArray = $root.CellStyleArray = (() => {\n\n    /**\n     * Properties of a CellStyleArray.\n     * @exports ICellStyleArray\n     * @interface ICellStyleArray\n     * @property {Array.<ICellStyle>|null} [styles] CellStyleArray styles\n     */\n\n    /**\n     * Constructs a new CellStyleArray.\n     * @exports CellStyleArray\n     * @classdesc Represents a CellStyleArray.\n     * @implements ICellStyleArray\n     * @constructor\n     * @param {ICellStyleArray=} [properties] Properties to set\n     */\n    function CellStyleArray(properties) {\n        this.styles = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * CellStyleArray styles.\n     * @member {Array.<ICellStyle>} styles\n     * @memberof CellStyleArray\n     * @instance\n     */\n    CellStyleArray.prototype.styles = $util.emptyArray;\n\n    /**\n     * Creates a new CellStyleArray instance using the specified properties.\n     * @function create\n     * @memberof CellStyleArray\n     * @static\n     * @param {ICellStyleArray=} [properties] Properties to set\n     * @returns {CellStyleArray} CellStyleArray instance\n     */\n    CellStyleArray.create = function create(properties) {\n        return new CellStyleArray(properties);\n    };\n\n    /**\n     * Encodes the specified CellStyleArray message. Does not implicitly {@link CellStyleArray.verify|verify} messages.\n     * @function encode\n     * @memberof CellStyleArray\n     * @static\n     * @param {ICellStyleArray} message CellStyleArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    CellStyleArray.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.styles != null && message.styles.length)\n            for (let i = 0; i < message.styles.length; ++i)\n                $root.CellStyle.encode(message.styles[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified CellStyleArray message, length delimited. Does not implicitly {@link CellStyleArray.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof CellStyleArray\n     * @static\n     * @param {ICellStyleArray} message CellStyleArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    CellStyleArray.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a CellStyleArray message from the specified reader or buffer.\n     * @function decode\n     * @memberof CellStyleArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {CellStyleArray} CellStyleArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    CellStyleArray.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.CellStyleArray();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.styles && message.styles.length))\n                    message.styles = [];\n                message.styles.push($root.CellStyle.decode(reader, reader.uint32()));\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a CellStyleArray message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof CellStyleArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {CellStyleArray} CellStyleArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    CellStyleArray.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a CellStyleArray message.\n     * @function verify\n     * @memberof CellStyleArray\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    CellStyleArray.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.styles != null && message.hasOwnProperty(\"styles\")) {\n            if (!Array.isArray(message.styles))\n                return \"styles: array expected\";\n            for (let i = 0; i < message.styles.length; ++i) {\n                let error = $root.CellStyle.verify(message.styles[i]);\n                if (error)\n                    return \"styles.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates a CellStyleArray message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof CellStyleArray\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {CellStyleArray} CellStyleArray\n     */\n    CellStyleArray.fromObject = function fromObject(object) {\n        if (object instanceof $root.CellStyleArray)\n            return object;\n        let message = new $root.CellStyleArray();\n        if (object.styles) {\n            if (!Array.isArray(object.styles))\n                throw TypeError(\".CellStyleArray.styles: array expected\");\n            message.styles = [];\n            for (let i = 0; i < object.styles.length; ++i) {\n                if (typeof object.styles[i] !== \"object\")\n                    throw TypeError(\".CellStyleArray.styles: object expected\");\n                message.styles[i] = $root.CellStyle.fromObject(object.styles[i]);\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a CellStyleArray message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof CellStyleArray\n     * @static\n     * @param {CellStyleArray} message CellStyleArray\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    CellStyleArray.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.styles = [];\n        if (message.styles && message.styles.length) {\n            object.styles = [];\n            for (let j = 0; j < message.styles.length; ++j)\n                object.styles[j] = $root.CellStyle.toObject(message.styles[j], options);\n        }\n        return object;\n    };\n\n    /**\n     * Converts this CellStyleArray to JSON.\n     * @function toJSON\n     * @memberof CellStyleArray\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    CellStyleArray.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return CellStyleArray;\n})();\n\nexport const AnyArray = $root.AnyArray = (() => {\n\n    /**\n     * Properties of an AnyArray.\n     * @exports IAnyArray\n     * @interface IAnyArray\n     * @property {IStringArray|null} [strings] AnyArray strings\n     * @property {IDoubleArray|null} [doubles] AnyArray doubles\n     * @property {IInt64Array|null} [int64s] AnyArray int64s\n     * @property {IInt64Array|null} [datetimes] AnyArray datetimes\n     * @property {IInt64Array|null} [timedeltas] AnyArray timedeltas\n     */\n\n    /**\n     * Constructs a new AnyArray.\n     * @exports AnyArray\n     * @classdesc Represents an AnyArray.\n     * @implements IAnyArray\n     * @constructor\n     * @param {IAnyArray=} [properties] Properties to set\n     */\n    function AnyArray(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * AnyArray strings.\n     * @member {IStringArray|null|undefined} strings\n     * @memberof AnyArray\n     * @instance\n     */\n    AnyArray.prototype.strings = null;\n\n    /**\n     * AnyArray doubles.\n     * @member {IDoubleArray|null|undefined} doubles\n     * @memberof AnyArray\n     * @instance\n     */\n    AnyArray.prototype.doubles = null;\n\n    /**\n     * AnyArray int64s.\n     * @member {IInt64Array|null|undefined} int64s\n     * @memberof AnyArray\n     * @instance\n     */\n    AnyArray.prototype.int64s = null;\n\n    /**\n     * AnyArray datetimes.\n     * @member {IInt64Array|null|undefined} datetimes\n     * @memberof AnyArray\n     * @instance\n     */\n    AnyArray.prototype.datetimes = null;\n\n    /**\n     * AnyArray timedeltas.\n     * @member {IInt64Array|null|undefined} timedeltas\n     * @memberof AnyArray\n     * @instance\n     */\n    AnyArray.prototype.timedeltas = null;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * AnyArray type.\n     * @member {\"strings\"|\"doubles\"|\"int64s\"|\"datetimes\"|\"timedeltas\"|undefined} type\n     * @memberof AnyArray\n     * @instance\n     */\n    Object.defineProperty(AnyArray.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"strings\", \"doubles\", \"int64s\", \"datetimes\", \"timedeltas\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new AnyArray instance using the specified properties.\n     * @function create\n     * @memberof AnyArray\n     * @static\n     * @param {IAnyArray=} [properties] Properties to set\n     * @returns {AnyArray} AnyArray instance\n     */\n    AnyArray.create = function create(properties) {\n        return new AnyArray(properties);\n    };\n\n    /**\n     * Encodes the specified AnyArray message. Does not implicitly {@link AnyArray.verify|verify} messages.\n     * @function encode\n     * @memberof AnyArray\n     * @static\n     * @param {IAnyArray} message AnyArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    AnyArray.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.strings != null && Object.hasOwnProperty.call(message, \"strings\"))\n            $root.StringArray.encode(message.strings, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.doubles != null && Object.hasOwnProperty.call(message, \"doubles\"))\n            $root.DoubleArray.encode(message.doubles, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.int64s != null && Object.hasOwnProperty.call(message, \"int64s\"))\n            $root.Int64Array.encode(message.int64s, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.datetimes != null && Object.hasOwnProperty.call(message, \"datetimes\"))\n            $root.Int64Array.encode(message.datetimes, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n        if (message.timedeltas != null && Object.hasOwnProperty.call(message, \"timedeltas\"))\n            $root.Int64Array.encode(message.timedeltas, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified AnyArray message, length delimited. Does not implicitly {@link AnyArray.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof AnyArray\n     * @static\n     * @param {IAnyArray} message AnyArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    AnyArray.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an AnyArray message from the specified reader or buffer.\n     * @function decode\n     * @memberof AnyArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {AnyArray} AnyArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    AnyArray.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.AnyArray();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.strings = $root.StringArray.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.doubles = $root.DoubleArray.decode(reader, reader.uint32());\n                break;\n            case 3:\n                message.int64s = $root.Int64Array.decode(reader, reader.uint32());\n                break;\n            case 4:\n                message.datetimes = $root.Int64Array.decode(reader, reader.uint32());\n                break;\n            case 5:\n                message.timedeltas = $root.Int64Array.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an AnyArray message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof AnyArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {AnyArray} AnyArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    AnyArray.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an AnyArray message.\n     * @function verify\n     * @memberof AnyArray\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    AnyArray.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.strings != null && message.hasOwnProperty(\"strings\")) {\n            properties.type = 1;\n            {\n                let error = $root.StringArray.verify(message.strings);\n                if (error)\n                    return \"strings.\" + error;\n            }\n        }\n        if (message.doubles != null && message.hasOwnProperty(\"doubles\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DoubleArray.verify(message.doubles);\n                if (error)\n                    return \"doubles.\" + error;\n            }\n        }\n        if (message.int64s != null && message.hasOwnProperty(\"int64s\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Int64Array.verify(message.int64s);\n                if (error)\n                    return \"int64s.\" + error;\n            }\n        }\n        if (message.datetimes != null && message.hasOwnProperty(\"datetimes\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Int64Array.verify(message.datetimes);\n                if (error)\n                    return \"datetimes.\" + error;\n            }\n        }\n        if (message.timedeltas != null && message.hasOwnProperty(\"timedeltas\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Int64Array.verify(message.timedeltas);\n                if (error)\n                    return \"timedeltas.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates an AnyArray message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof AnyArray\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {AnyArray} AnyArray\n     */\n    AnyArray.fromObject = function fromObject(object) {\n        if (object instanceof $root.AnyArray)\n            return object;\n        let message = new $root.AnyArray();\n        if (object.strings != null) {\n            if (typeof object.strings !== \"object\")\n                throw TypeError(\".AnyArray.strings: object expected\");\n            message.strings = $root.StringArray.fromObject(object.strings);\n        }\n        if (object.doubles != null) {\n            if (typeof object.doubles !== \"object\")\n                throw TypeError(\".AnyArray.doubles: object expected\");\n            message.doubles = $root.DoubleArray.fromObject(object.doubles);\n        }\n        if (object.int64s != null) {\n            if (typeof object.int64s !== \"object\")\n                throw TypeError(\".AnyArray.int64s: object expected\");\n            message.int64s = $root.Int64Array.fromObject(object.int64s);\n        }\n        if (object.datetimes != null) {\n            if (typeof object.datetimes !== \"object\")\n                throw TypeError(\".AnyArray.datetimes: object expected\");\n            message.datetimes = $root.Int64Array.fromObject(object.datetimes);\n        }\n        if (object.timedeltas != null) {\n            if (typeof object.timedeltas !== \"object\")\n                throw TypeError(\".AnyArray.timedeltas: object expected\");\n            message.timedeltas = $root.Int64Array.fromObject(object.timedeltas);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an AnyArray message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof AnyArray\n     * @static\n     * @param {AnyArray} message AnyArray\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    AnyArray.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (message.strings != null && message.hasOwnProperty(\"strings\")) {\n            object.strings = $root.StringArray.toObject(message.strings, options);\n            if (options.oneofs)\n                object.type = \"strings\";\n        }\n        if (message.doubles != null && message.hasOwnProperty(\"doubles\")) {\n            object.doubles = $root.DoubleArray.toObject(message.doubles, options);\n            if (options.oneofs)\n                object.type = \"doubles\";\n        }\n        if (message.int64s != null && message.hasOwnProperty(\"int64s\")) {\n            object.int64s = $root.Int64Array.toObject(message.int64s, options);\n            if (options.oneofs)\n                object.type = \"int64s\";\n        }\n        if (message.datetimes != null && message.hasOwnProperty(\"datetimes\")) {\n            object.datetimes = $root.Int64Array.toObject(message.datetimes, options);\n            if (options.oneofs)\n                object.type = \"datetimes\";\n        }\n        if (message.timedeltas != null && message.hasOwnProperty(\"timedeltas\")) {\n            object.timedeltas = $root.Int64Array.toObject(message.timedeltas, options);\n            if (options.oneofs)\n                object.type = \"timedeltas\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this AnyArray to JSON.\n     * @function toJSON\n     * @memberof AnyArray\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    AnyArray.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return AnyArray;\n})();\n\nexport const Table = $root.Table = (() => {\n\n    /**\n     * Properties of a Table.\n     * @exports ITable\n     * @interface ITable\n     * @property {Array.<IAnyArray>|null} [cols] Table cols\n     */\n\n    /**\n     * Constructs a new Table.\n     * @exports Table\n     * @classdesc Represents a Table.\n     * @implements ITable\n     * @constructor\n     * @param {ITable=} [properties] Properties to set\n     */\n    function Table(properties) {\n        this.cols = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Table cols.\n     * @member {Array.<IAnyArray>} cols\n     * @memberof Table\n     * @instance\n     */\n    Table.prototype.cols = $util.emptyArray;\n\n    /**\n     * Creates a new Table instance using the specified properties.\n     * @function create\n     * @memberof Table\n     * @static\n     * @param {ITable=} [properties] Properties to set\n     * @returns {Table} Table instance\n     */\n    Table.create = function create(properties) {\n        return new Table(properties);\n    };\n\n    /**\n     * Encodes the specified Table message. Does not implicitly {@link Table.verify|verify} messages.\n     * @function encode\n     * @memberof Table\n     * @static\n     * @param {ITable} message Table message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Table.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.cols != null && message.cols.length)\n            for (let i = 0; i < message.cols.length; ++i)\n                $root.AnyArray.encode(message.cols[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Table message, length delimited. Does not implicitly {@link Table.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Table\n     * @static\n     * @param {ITable} message Table message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Table.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Table message from the specified reader or buffer.\n     * @function decode\n     * @memberof Table\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Table} Table\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Table.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Table();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.cols && message.cols.length))\n                    message.cols = [];\n                message.cols.push($root.AnyArray.decode(reader, reader.uint32()));\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Table message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Table\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Table} Table\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Table.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Table message.\n     * @function verify\n     * @memberof Table\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Table.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.cols != null && message.hasOwnProperty(\"cols\")) {\n            if (!Array.isArray(message.cols))\n                return \"cols: array expected\";\n            for (let i = 0; i < message.cols.length; ++i) {\n                let error = $root.AnyArray.verify(message.cols[i]);\n                if (error)\n                    return \"cols.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates a Table message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Table\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Table} Table\n     */\n    Table.fromObject = function fromObject(object) {\n        if (object instanceof $root.Table)\n            return object;\n        let message = new $root.Table();\n        if (object.cols) {\n            if (!Array.isArray(object.cols))\n                throw TypeError(\".Table.cols: array expected\");\n            message.cols = [];\n            for (let i = 0; i < object.cols.length; ++i) {\n                if (typeof object.cols[i] !== \"object\")\n                    throw TypeError(\".Table.cols: object expected\");\n                message.cols[i] = $root.AnyArray.fromObject(object.cols[i]);\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Table message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Table\n     * @static\n     * @param {Table} message Table\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Table.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.cols = [];\n        if (message.cols && message.cols.length) {\n            object.cols = [];\n            for (let j = 0; j < message.cols.length; ++j)\n                object.cols[j] = $root.AnyArray.toObject(message.cols[j], options);\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Table to JSON.\n     * @function toJSON\n     * @memberof Table\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Table.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Table;\n})();\n\nexport const TableStyle = $root.TableStyle = (() => {\n\n    /**\n     * Properties of a TableStyle.\n     * @exports ITableStyle\n     * @interface ITableStyle\n     * @property {Array.<ICellStyleArray>|null} [cols] TableStyle cols\n     */\n\n    /**\n     * Constructs a new TableStyle.\n     * @exports TableStyle\n     * @classdesc Represents a TableStyle.\n     * @implements ITableStyle\n     * @constructor\n     * @param {ITableStyle=} [properties] Properties to set\n     */\n    function TableStyle(properties) {\n        this.cols = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TableStyle cols.\n     * @member {Array.<ICellStyleArray>} cols\n     * @memberof TableStyle\n     * @instance\n     */\n    TableStyle.prototype.cols = $util.emptyArray;\n\n    /**\n     * Creates a new TableStyle instance using the specified properties.\n     * @function create\n     * @memberof TableStyle\n     * @static\n     * @param {ITableStyle=} [properties] Properties to set\n     * @returns {TableStyle} TableStyle instance\n     */\n    TableStyle.create = function create(properties) {\n        return new TableStyle(properties);\n    };\n\n    /**\n     * Encodes the specified TableStyle message. Does not implicitly {@link TableStyle.verify|verify} messages.\n     * @function encode\n     * @memberof TableStyle\n     * @static\n     * @param {ITableStyle} message TableStyle message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TableStyle.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.cols != null && message.cols.length)\n            for (let i = 0; i < message.cols.length; ++i)\n                $root.CellStyleArray.encode(message.cols[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified TableStyle message, length delimited. Does not implicitly {@link TableStyle.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof TableStyle\n     * @static\n     * @param {ITableStyle} message TableStyle message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TableStyle.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TableStyle message from the specified reader or buffer.\n     * @function decode\n     * @memberof TableStyle\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {TableStyle} TableStyle\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TableStyle.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TableStyle();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.cols && message.cols.length))\n                    message.cols = [];\n                message.cols.push($root.CellStyleArray.decode(reader, reader.uint32()));\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a TableStyle message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof TableStyle\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {TableStyle} TableStyle\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TableStyle.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TableStyle message.\n     * @function verify\n     * @memberof TableStyle\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TableStyle.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.cols != null && message.hasOwnProperty(\"cols\")) {\n            if (!Array.isArray(message.cols))\n                return \"cols: array expected\";\n            for (let i = 0; i < message.cols.length; ++i) {\n                let error = $root.CellStyleArray.verify(message.cols[i]);\n                if (error)\n                    return \"cols.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates a TableStyle message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof TableStyle\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {TableStyle} TableStyle\n     */\n    TableStyle.fromObject = function fromObject(object) {\n        if (object instanceof $root.TableStyle)\n            return object;\n        let message = new $root.TableStyle();\n        if (object.cols) {\n            if (!Array.isArray(object.cols))\n                throw TypeError(\".TableStyle.cols: array expected\");\n            message.cols = [];\n            for (let i = 0; i < object.cols.length; ++i) {\n                if (typeof object.cols[i] !== \"object\")\n                    throw TypeError(\".TableStyle.cols: object expected\");\n                message.cols[i] = $root.CellStyleArray.fromObject(object.cols[i]);\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a TableStyle message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof TableStyle\n     * @static\n     * @param {TableStyle} message TableStyle\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TableStyle.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.cols = [];\n        if (message.cols && message.cols.length) {\n            object.cols = [];\n            for (let j = 0; j < message.cols.length; ++j)\n                object.cols[j] = $root.CellStyleArray.toObject(message.cols[j], options);\n        }\n        return object;\n    };\n\n    /**\n     * Converts this TableStyle to JSON.\n     * @function toJSON\n     * @memberof TableStyle\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TableStyle.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return TableStyle;\n})();\n\nexport const DateInput = $root.DateInput = (() => {\n\n    /**\n     * Properties of a DateInput.\n     * @exports IDateInput\n     * @interface IDateInput\n     * @property {string|null} [id] DateInput id\n     * @property {string|null} [label] DateInput label\n     * @property {Array.<string>|null} [\"default\"] DateInput default\n     * @property {string|null} [min] DateInput min\n     * @property {string|null} [max] DateInput max\n     * @property {boolean|null} [isRange] DateInput isRange\n     */\n\n    /**\n     * Constructs a new DateInput.\n     * @exports DateInput\n     * @classdesc Represents a DateInput.\n     * @implements IDateInput\n     * @constructor\n     * @param {IDateInput=} [properties] Properties to set\n     */\n    function DateInput(properties) {\n        this[\"default\"] = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DateInput id.\n     * @member {string} id\n     * @memberof DateInput\n     * @instance\n     */\n    DateInput.prototype.id = \"\";\n\n    /**\n     * DateInput label.\n     * @member {string} label\n     * @memberof DateInput\n     * @instance\n     */\n    DateInput.prototype.label = \"\";\n\n    /**\n     * DateInput default.\n     * @member {Array.<string>} default\n     * @memberof DateInput\n     * @instance\n     */\n    DateInput.prototype[\"default\"] = $util.emptyArray;\n\n    /**\n     * DateInput min.\n     * @member {string} min\n     * @memberof DateInput\n     * @instance\n     */\n    DateInput.prototype.min = \"\";\n\n    /**\n     * DateInput max.\n     * @member {string} max\n     * @memberof DateInput\n     * @instance\n     */\n    DateInput.prototype.max = \"\";\n\n    /**\n     * DateInput isRange.\n     * @member {boolean} isRange\n     * @memberof DateInput\n     * @instance\n     */\n    DateInput.prototype.isRange = false;\n\n    /**\n     * Creates a new DateInput instance using the specified properties.\n     * @function create\n     * @memberof DateInput\n     * @static\n     * @param {IDateInput=} [properties] Properties to set\n     * @returns {DateInput} DateInput instance\n     */\n    DateInput.create = function create(properties) {\n        return new DateInput(properties);\n    };\n\n    /**\n     * Encodes the specified DateInput message. Does not implicitly {@link DateInput.verify|verify} messages.\n     * @function encode\n     * @memberof DateInput\n     * @static\n     * @param {IDateInput} message DateInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DateInput.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && message[\"default\"].length)\n            for (let i = 0; i < message[\"default\"].length; ++i)\n                writer.uint32(/* id 3, wireType 2 =*/26).string(message[\"default\"][i]);\n        if (message.min != null && Object.hasOwnProperty.call(message, \"min\"))\n            writer.uint32(/* id 4, wireType 2 =*/34).string(message.min);\n        if (message.max != null && Object.hasOwnProperty.call(message, \"max\"))\n            writer.uint32(/* id 5, wireType 2 =*/42).string(message.max);\n        if (message.isRange != null && Object.hasOwnProperty.call(message, \"isRange\"))\n            writer.uint32(/* id 6, wireType 0 =*/48).bool(message.isRange);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DateInput message, length delimited. Does not implicitly {@link DateInput.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DateInput\n     * @static\n     * @param {IDateInput} message DateInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DateInput.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DateInput message from the specified reader or buffer.\n     * @function decode\n     * @memberof DateInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DateInput} DateInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DateInput.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DateInput();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                if (!(message[\"default\"] && message[\"default\"].length))\n                    message[\"default\"] = [];\n                message[\"default\"].push(reader.string());\n                break;\n            case 4:\n                message.min = reader.string();\n                break;\n            case 5:\n                message.max = reader.string();\n                break;\n            case 6:\n                message.isRange = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DateInput message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DateInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DateInput} DateInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DateInput.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DateInput message.\n     * @function verify\n     * @memberof DateInput\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DateInput.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\")) {\n            if (!Array.isArray(message[\"default\"]))\n                return \"default: array expected\";\n            for (let i = 0; i < message[\"default\"].length; ++i)\n                if (!$util.isString(message[\"default\"][i]))\n                    return \"default: string[] expected\";\n        }\n        if (message.min != null && message.hasOwnProperty(\"min\"))\n            if (!$util.isString(message.min))\n                return \"min: string expected\";\n        if (message.max != null && message.hasOwnProperty(\"max\"))\n            if (!$util.isString(message.max))\n                return \"max: string expected\";\n        if (message.isRange != null && message.hasOwnProperty(\"isRange\"))\n            if (typeof message.isRange !== \"boolean\")\n                return \"isRange: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a DateInput message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DateInput\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DateInput} DateInput\n     */\n    DateInput.fromObject = function fromObject(object) {\n        if (object instanceof $root.DateInput)\n            return object;\n        let message = new $root.DateInput();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"]) {\n            if (!Array.isArray(object[\"default\"]))\n                throw TypeError(\".DateInput.default: array expected\");\n            message[\"default\"] = [];\n            for (let i = 0; i < object[\"default\"].length; ++i)\n                message[\"default\"][i] = String(object[\"default\"][i]);\n        }\n        if (object.min != null)\n            message.min = String(object.min);\n        if (object.max != null)\n            message.max = String(object.max);\n        if (object.isRange != null)\n            message.isRange = Boolean(object.isRange);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DateInput message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DateInput\n     * @static\n     * @param {DateInput} message DateInput\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DateInput.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object[\"default\"] = [];\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object.min = \"\";\n            object.max = \"\";\n            object.isRange = false;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] && message[\"default\"].length) {\n            object[\"default\"] = [];\n            for (let j = 0; j < message[\"default\"].length; ++j)\n                object[\"default\"][j] = message[\"default\"][j];\n        }\n        if (message.min != null && message.hasOwnProperty(\"min\"))\n            object.min = message.min;\n        if (message.max != null && message.hasOwnProperty(\"max\"))\n            object.max = message.max;\n        if (message.isRange != null && message.hasOwnProperty(\"isRange\"))\n            object.isRange = message.isRange;\n        return object;\n    };\n\n    /**\n     * Converts this DateInput to JSON.\n     * @function toJSON\n     * @memberof DateInput\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DateInput.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DateInput;\n})();\n\nexport const DeckGlChart = $root.DeckGlChart = (() => {\n\n    /**\n     * Properties of a DeckGlChart.\n     * @exports IDeckGlChart\n     * @interface IDeckGlChart\n     * @property {IDataFrame|null} [data] DeckGlChart data\n     * @property {string|null} [spec] DeckGlChart spec\n     * @property {Array.<IDeckGLLayer>|null} [layers] DeckGlChart layers\n     * @property {boolean|null} [useContainerWidth] DeckGlChart useContainerWidth\n     */\n\n    /**\n     * Constructs a new DeckGlChart.\n     * @exports DeckGlChart\n     * @classdesc Represents a DeckGlChart.\n     * @implements IDeckGlChart\n     * @constructor\n     * @param {IDeckGlChart=} [properties] Properties to set\n     */\n    function DeckGlChart(properties) {\n        this.layers = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DeckGlChart data.\n     * @member {IDataFrame|null|undefined} data\n     * @memberof DeckGlChart\n     * @instance\n     */\n    DeckGlChart.prototype.data = null;\n\n    /**\n     * DeckGlChart spec.\n     * @member {string} spec\n     * @memberof DeckGlChart\n     * @instance\n     */\n    DeckGlChart.prototype.spec = \"\";\n\n    /**\n     * DeckGlChart layers.\n     * @member {Array.<IDeckGLLayer>} layers\n     * @memberof DeckGlChart\n     * @instance\n     */\n    DeckGlChart.prototype.layers = $util.emptyArray;\n\n    /**\n     * DeckGlChart useContainerWidth.\n     * @member {boolean} useContainerWidth\n     * @memberof DeckGlChart\n     * @instance\n     */\n    DeckGlChart.prototype.useContainerWidth = false;\n\n    /**\n     * Creates a new DeckGlChart instance using the specified properties.\n     * @function create\n     * @memberof DeckGlChart\n     * @static\n     * @param {IDeckGlChart=} [properties] Properties to set\n     * @returns {DeckGlChart} DeckGlChart instance\n     */\n    DeckGlChart.create = function create(properties) {\n        return new DeckGlChart(properties);\n    };\n\n    /**\n     * Encodes the specified DeckGlChart message. Does not implicitly {@link DeckGlChart.verify|verify} messages.\n     * @function encode\n     * @memberof DeckGlChart\n     * @static\n     * @param {IDeckGlChart} message DeckGlChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DeckGlChart.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.DataFrame.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.spec != null && Object.hasOwnProperty.call(message, \"spec\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.spec);\n        if (message.layers != null && message.layers.length)\n            for (let i = 0; i < message.layers.length; ++i)\n                $root.DeckGLLayer.encode(message.layers[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.useContainerWidth != null && Object.hasOwnProperty.call(message, \"useContainerWidth\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).bool(message.useContainerWidth);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DeckGlChart message, length delimited. Does not implicitly {@link DeckGlChart.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DeckGlChart\n     * @static\n     * @param {IDeckGlChart} message DeckGlChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DeckGlChart.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DeckGlChart message from the specified reader or buffer.\n     * @function decode\n     * @memberof DeckGlChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DeckGlChart} DeckGlChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DeckGlChart.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DeckGlChart();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.DataFrame.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.spec = reader.string();\n                break;\n            case 3:\n                if (!(message.layers && message.layers.length))\n                    message.layers = [];\n                message.layers.push($root.DeckGLLayer.decode(reader, reader.uint32()));\n                break;\n            case 4:\n                message.useContainerWidth = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DeckGlChart message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DeckGlChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DeckGlChart} DeckGlChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DeckGlChart.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DeckGlChart message.\n     * @function verify\n     * @memberof DeckGlChart\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DeckGlChart.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.DataFrame.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            if (!$util.isString(message.spec))\n                return \"spec: string expected\";\n        if (message.layers != null && message.hasOwnProperty(\"layers\")) {\n            if (!Array.isArray(message.layers))\n                return \"layers: array expected\";\n            for (let i = 0; i < message.layers.length; ++i) {\n                let error = $root.DeckGLLayer.verify(message.layers[i]);\n                if (error)\n                    return \"layers.\" + error;\n            }\n        }\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            if (typeof message.useContainerWidth !== \"boolean\")\n                return \"useContainerWidth: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a DeckGlChart message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DeckGlChart\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DeckGlChart} DeckGlChart\n     */\n    DeckGlChart.fromObject = function fromObject(object) {\n        if (object instanceof $root.DeckGlChart)\n            return object;\n        let message = new $root.DeckGlChart();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".DeckGlChart.data: object expected\");\n            message.data = $root.DataFrame.fromObject(object.data);\n        }\n        if (object.spec != null)\n            message.spec = String(object.spec);\n        if (object.layers) {\n            if (!Array.isArray(object.layers))\n                throw TypeError(\".DeckGlChart.layers: array expected\");\n            message.layers = [];\n            for (let i = 0; i < object.layers.length; ++i) {\n                if (typeof object.layers[i] !== \"object\")\n                    throw TypeError(\".DeckGlChart.layers: object expected\");\n                message.layers[i] = $root.DeckGLLayer.fromObject(object.layers[i]);\n            }\n        }\n        if (object.useContainerWidth != null)\n            message.useContainerWidth = Boolean(object.useContainerWidth);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DeckGlChart message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DeckGlChart\n     * @static\n     * @param {DeckGlChart} message DeckGlChart\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DeckGlChart.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.layers = [];\n        if (options.defaults) {\n            object.data = null;\n            object.spec = \"\";\n            object.useContainerWidth = false;\n        }\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.DataFrame.toObject(message.data, options);\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            object.spec = message.spec;\n        if (message.layers && message.layers.length) {\n            object.layers = [];\n            for (let j = 0; j < message.layers.length; ++j)\n                object.layers[j] = $root.DeckGLLayer.toObject(message.layers[j], options);\n        }\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            object.useContainerWidth = message.useContainerWidth;\n        return object;\n    };\n\n    /**\n     * Converts this DeckGlChart to JSON.\n     * @function toJSON\n     * @memberof DeckGlChart\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DeckGlChart.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DeckGlChart;\n})();\n\nexport const DeckGLLayer = $root.DeckGLLayer = (() => {\n\n    /**\n     * Properties of a DeckGLLayer.\n     * @exports IDeckGLLayer\n     * @interface IDeckGLLayer\n     * @property {IDataFrame|null} [data] DeckGLLayer data\n     * @property {string|null} [spec] DeckGLLayer spec\n     */\n\n    /**\n     * Constructs a new DeckGLLayer.\n     * @exports DeckGLLayer\n     * @classdesc Represents a DeckGLLayer.\n     * @implements IDeckGLLayer\n     * @constructor\n     * @param {IDeckGLLayer=} [properties] Properties to set\n     */\n    function DeckGLLayer(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DeckGLLayer data.\n     * @member {IDataFrame|null|undefined} data\n     * @memberof DeckGLLayer\n     * @instance\n     */\n    DeckGLLayer.prototype.data = null;\n\n    /**\n     * DeckGLLayer spec.\n     * @member {string} spec\n     * @memberof DeckGLLayer\n     * @instance\n     */\n    DeckGLLayer.prototype.spec = \"\";\n\n    /**\n     * Creates a new DeckGLLayer instance using the specified properties.\n     * @function create\n     * @memberof DeckGLLayer\n     * @static\n     * @param {IDeckGLLayer=} [properties] Properties to set\n     * @returns {DeckGLLayer} DeckGLLayer instance\n     */\n    DeckGLLayer.create = function create(properties) {\n        return new DeckGLLayer(properties);\n    };\n\n    /**\n     * Encodes the specified DeckGLLayer message. Does not implicitly {@link DeckGLLayer.verify|verify} messages.\n     * @function encode\n     * @memberof DeckGLLayer\n     * @static\n     * @param {IDeckGLLayer} message DeckGLLayer message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DeckGLLayer.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.DataFrame.encode(message.data, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.spec != null && Object.hasOwnProperty.call(message, \"spec\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.spec);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DeckGLLayer message, length delimited. Does not implicitly {@link DeckGLLayer.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DeckGLLayer\n     * @static\n     * @param {IDeckGLLayer} message DeckGLLayer message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DeckGLLayer.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DeckGLLayer message from the specified reader or buffer.\n     * @function decode\n     * @memberof DeckGLLayer\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DeckGLLayer} DeckGLLayer\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DeckGLLayer.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DeckGLLayer();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.data = $root.DataFrame.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.spec = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DeckGLLayer message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DeckGLLayer\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DeckGLLayer} DeckGLLayer\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DeckGLLayer.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DeckGLLayer message.\n     * @function verify\n     * @memberof DeckGLLayer\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DeckGLLayer.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.DataFrame.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            if (!$util.isString(message.spec))\n                return \"spec: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a DeckGLLayer message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DeckGLLayer\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DeckGLLayer} DeckGLLayer\n     */\n    DeckGLLayer.fromObject = function fromObject(object) {\n        if (object instanceof $root.DeckGLLayer)\n            return object;\n        let message = new $root.DeckGLLayer();\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".DeckGLLayer.data: object expected\");\n            message.data = $root.DataFrame.fromObject(object.data);\n        }\n        if (object.spec != null)\n            message.spec = String(object.spec);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DeckGLLayer message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DeckGLLayer\n     * @static\n     * @param {DeckGLLayer} message DeckGLLayer\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DeckGLLayer.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.data = null;\n            object.spec = \"\";\n        }\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.DataFrame.toObject(message.data, options);\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            object.spec = message.spec;\n        return object;\n    };\n\n    /**\n     * Converts this DeckGLLayer to JSON.\n     * @function toJSON\n     * @memberof DeckGLLayer\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DeckGLLayer.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DeckGLLayer;\n})();\n\nexport const DeckGlJsonChart = $root.DeckGlJsonChart = (() => {\n\n    /**\n     * Properties of a DeckGlJsonChart.\n     * @exports IDeckGlJsonChart\n     * @interface IDeckGlJsonChart\n     * @property {string|null} [json] DeckGlJsonChart json\n     * @property {string|null} [tooltip] DeckGlJsonChart tooltip\n     * @property {boolean|null} [useContainerWidth] DeckGlJsonChart useContainerWidth\n     */\n\n    /**\n     * Constructs a new DeckGlJsonChart.\n     * @exports DeckGlJsonChart\n     * @classdesc Represents a DeckGlJsonChart.\n     * @implements IDeckGlJsonChart\n     * @constructor\n     * @param {IDeckGlJsonChart=} [properties] Properties to set\n     */\n    function DeckGlJsonChart(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DeckGlJsonChart json.\n     * @member {string} json\n     * @memberof DeckGlJsonChart\n     * @instance\n     */\n    DeckGlJsonChart.prototype.json = \"\";\n\n    /**\n     * DeckGlJsonChart tooltip.\n     * @member {string} tooltip\n     * @memberof DeckGlJsonChart\n     * @instance\n     */\n    DeckGlJsonChart.prototype.tooltip = \"\";\n\n    /**\n     * DeckGlJsonChart useContainerWidth.\n     * @member {boolean} useContainerWidth\n     * @memberof DeckGlJsonChart\n     * @instance\n     */\n    DeckGlJsonChart.prototype.useContainerWidth = false;\n\n    /**\n     * Creates a new DeckGlJsonChart instance using the specified properties.\n     * @function create\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {IDeckGlJsonChart=} [properties] Properties to set\n     * @returns {DeckGlJsonChart} DeckGlJsonChart instance\n     */\n    DeckGlJsonChart.create = function create(properties) {\n        return new DeckGlJsonChart(properties);\n    };\n\n    /**\n     * Encodes the specified DeckGlJsonChart message. Does not implicitly {@link DeckGlJsonChart.verify|verify} messages.\n     * @function encode\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {IDeckGlJsonChart} message DeckGlJsonChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DeckGlJsonChart.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.json != null && Object.hasOwnProperty.call(message, \"json\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.json);\n        if (message.tooltip != null && Object.hasOwnProperty.call(message, \"tooltip\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.tooltip);\n        if (message.useContainerWidth != null && Object.hasOwnProperty.call(message, \"useContainerWidth\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).bool(message.useContainerWidth);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DeckGlJsonChart message, length delimited. Does not implicitly {@link DeckGlJsonChart.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {IDeckGlJsonChart} message DeckGlJsonChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DeckGlJsonChart.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DeckGlJsonChart message from the specified reader or buffer.\n     * @function decode\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DeckGlJsonChart} DeckGlJsonChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DeckGlJsonChart.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DeckGlJsonChart();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.json = reader.string();\n                break;\n            case 2:\n                message.tooltip = reader.string();\n                break;\n            case 4:\n                message.useContainerWidth = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DeckGlJsonChart message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DeckGlJsonChart} DeckGlJsonChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DeckGlJsonChart.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DeckGlJsonChart message.\n     * @function verify\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DeckGlJsonChart.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.json != null && message.hasOwnProperty(\"json\"))\n            if (!$util.isString(message.json))\n                return \"json: string expected\";\n        if (message.tooltip != null && message.hasOwnProperty(\"tooltip\"))\n            if (!$util.isString(message.tooltip))\n                return \"tooltip: string expected\";\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            if (typeof message.useContainerWidth !== \"boolean\")\n                return \"useContainerWidth: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a DeckGlJsonChart message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DeckGlJsonChart} DeckGlJsonChart\n     */\n    DeckGlJsonChart.fromObject = function fromObject(object) {\n        if (object instanceof $root.DeckGlJsonChart)\n            return object;\n        let message = new $root.DeckGlJsonChart();\n        if (object.json != null)\n            message.json = String(object.json);\n        if (object.tooltip != null)\n            message.tooltip = String(object.tooltip);\n        if (object.useContainerWidth != null)\n            message.useContainerWidth = Boolean(object.useContainerWidth);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DeckGlJsonChart message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DeckGlJsonChart\n     * @static\n     * @param {DeckGlJsonChart} message DeckGlJsonChart\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DeckGlJsonChart.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.json = \"\";\n            object.tooltip = \"\";\n            object.useContainerWidth = false;\n        }\n        if (message.json != null && message.hasOwnProperty(\"json\"))\n            object.json = message.json;\n        if (message.tooltip != null && message.hasOwnProperty(\"tooltip\"))\n            object.tooltip = message.tooltip;\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            object.useContainerWidth = message.useContainerWidth;\n        return object;\n    };\n\n    /**\n     * Converts this DeckGlJsonChart to JSON.\n     * @function toJSON\n     * @memberof DeckGlJsonChart\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DeckGlJsonChart.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DeckGlJsonChart;\n})();\n\nexport const Delta = $root.Delta = (() => {\n\n    /**\n     * Properties of a Delta.\n     * @exports IDelta\n     * @interface IDelta\n     * @property {IElement|null} [newElement] Delta newElement\n     * @property {boolean|null} [newBlock] Delta newBlock\n     * @property {INamedDataSet|null} [addRows] Delta addRows\n     */\n\n    /**\n     * Constructs a new Delta.\n     * @exports Delta\n     * @classdesc Represents a Delta.\n     * @implements IDelta\n     * @constructor\n     * @param {IDelta=} [properties] Properties to set\n     */\n    function Delta(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Delta newElement.\n     * @member {IElement|null|undefined} newElement\n     * @memberof Delta\n     * @instance\n     */\n    Delta.prototype.newElement = null;\n\n    /**\n     * Delta newBlock.\n     * @member {boolean} newBlock\n     * @memberof Delta\n     * @instance\n     */\n    Delta.prototype.newBlock = false;\n\n    /**\n     * Delta addRows.\n     * @member {INamedDataSet|null|undefined} addRows\n     * @memberof Delta\n     * @instance\n     */\n    Delta.prototype.addRows = null;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * Delta type.\n     * @member {\"newElement\"|\"newBlock\"|\"addRows\"|undefined} type\n     * @memberof Delta\n     * @instance\n     */\n    Object.defineProperty(Delta.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"newElement\", \"newBlock\", \"addRows\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new Delta instance using the specified properties.\n     * @function create\n     * @memberof Delta\n     * @static\n     * @param {IDelta=} [properties] Properties to set\n     * @returns {Delta} Delta instance\n     */\n    Delta.create = function create(properties) {\n        return new Delta(properties);\n    };\n\n    /**\n     * Encodes the specified Delta message. Does not implicitly {@link Delta.verify|verify} messages.\n     * @function encode\n     * @memberof Delta\n     * @static\n     * @param {IDelta} message Delta message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Delta.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.newElement != null && Object.hasOwnProperty.call(message, \"newElement\"))\n            $root.Element.encode(message.newElement, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.newBlock != null && Object.hasOwnProperty.call(message, \"newBlock\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).bool(message.newBlock);\n        if (message.addRows != null && Object.hasOwnProperty.call(message, \"addRows\"))\n            $root.NamedDataSet.encode(message.addRows, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Delta message, length delimited. Does not implicitly {@link Delta.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Delta\n     * @static\n     * @param {IDelta} message Delta message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Delta.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Delta message from the specified reader or buffer.\n     * @function decode\n     * @memberof Delta\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Delta} Delta\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Delta.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Delta();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 3:\n                message.newElement = $root.Element.decode(reader, reader.uint32());\n                break;\n            case 4:\n                message.newBlock = reader.bool();\n                break;\n            case 5:\n                message.addRows = $root.NamedDataSet.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Delta message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Delta\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Delta} Delta\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Delta.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Delta message.\n     * @function verify\n     * @memberof Delta\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Delta.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.newElement != null && message.hasOwnProperty(\"newElement\")) {\n            properties.type = 1;\n            {\n                let error = $root.Element.verify(message.newElement);\n                if (error)\n                    return \"newElement.\" + error;\n            }\n        }\n        if (message.newBlock != null && message.hasOwnProperty(\"newBlock\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (typeof message.newBlock !== \"boolean\")\n                return \"newBlock: boolean expected\";\n        }\n        if (message.addRows != null && message.hasOwnProperty(\"addRows\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.NamedDataSet.verify(message.addRows);\n                if (error)\n                    return \"addRows.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates a Delta message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Delta\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Delta} Delta\n     */\n    Delta.fromObject = function fromObject(object) {\n        if (object instanceof $root.Delta)\n            return object;\n        let message = new $root.Delta();\n        if (object.newElement != null) {\n            if (typeof object.newElement !== \"object\")\n                throw TypeError(\".Delta.newElement: object expected\");\n            message.newElement = $root.Element.fromObject(object.newElement);\n        }\n        if (object.newBlock != null)\n            message.newBlock = Boolean(object.newBlock);\n        if (object.addRows != null) {\n            if (typeof object.addRows !== \"object\")\n                throw TypeError(\".Delta.addRows: object expected\");\n            message.addRows = $root.NamedDataSet.fromObject(object.addRows);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Delta message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Delta\n     * @static\n     * @param {Delta} message Delta\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Delta.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (message.newElement != null && message.hasOwnProperty(\"newElement\")) {\n            object.newElement = $root.Element.toObject(message.newElement, options);\n            if (options.oneofs)\n                object.type = \"newElement\";\n        }\n        if (message.newBlock != null && message.hasOwnProperty(\"newBlock\")) {\n            object.newBlock = message.newBlock;\n            if (options.oneofs)\n                object.type = \"newBlock\";\n        }\n        if (message.addRows != null && message.hasOwnProperty(\"addRows\")) {\n            object.addRows = $root.NamedDataSet.toObject(message.addRows, options);\n            if (options.oneofs)\n                object.type = \"addRows\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Delta to JSON.\n     * @function toJSON\n     * @memberof Delta\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Delta.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Delta;\n})();\n\nexport const DocString = $root.DocString = (() => {\n\n    /**\n     * Properties of a DocString.\n     * @exports IDocString\n     * @interface IDocString\n     * @property {string|null} [name] DocString name\n     * @property {string|null} [module] DocString module\n     * @property {string|null} [docString] DocString docString\n     * @property {string|null} [type] DocString type\n     * @property {string|null} [signature] DocString signature\n     */\n\n    /**\n     * Constructs a new DocString.\n     * @exports DocString\n     * @classdesc Represents a DocString.\n     * @implements IDocString\n     * @constructor\n     * @param {IDocString=} [properties] Properties to set\n     */\n    function DocString(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * DocString name.\n     * @member {string} name\n     * @memberof DocString\n     * @instance\n     */\n    DocString.prototype.name = \"\";\n\n    /**\n     * DocString module.\n     * @member {string} module\n     * @memberof DocString\n     * @instance\n     */\n    DocString.prototype.module = \"\";\n\n    /**\n     * DocString docString.\n     * @member {string} docString\n     * @memberof DocString\n     * @instance\n     */\n    DocString.prototype.docString = \"\";\n\n    /**\n     * DocString type.\n     * @member {string} type\n     * @memberof DocString\n     * @instance\n     */\n    DocString.prototype.type = \"\";\n\n    /**\n     * DocString signature.\n     * @member {string} signature\n     * @memberof DocString\n     * @instance\n     */\n    DocString.prototype.signature = \"\";\n\n    /**\n     * Creates a new DocString instance using the specified properties.\n     * @function create\n     * @memberof DocString\n     * @static\n     * @param {IDocString=} [properties] Properties to set\n     * @returns {DocString} DocString instance\n     */\n    DocString.create = function create(properties) {\n        return new DocString(properties);\n    };\n\n    /**\n     * Encodes the specified DocString message. Does not implicitly {@link DocString.verify|verify} messages.\n     * @function encode\n     * @memberof DocString\n     * @static\n     * @param {IDocString} message DocString message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DocString.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.name != null && Object.hasOwnProperty.call(message, \"name\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);\n        if (message.module != null && Object.hasOwnProperty.call(message, \"module\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.module);\n        if (message.docString != null && Object.hasOwnProperty.call(message, \"docString\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message.docString);\n        if (message.type != null && Object.hasOwnProperty.call(message, \"type\"))\n            writer.uint32(/* id 4, wireType 2 =*/34).string(message.type);\n        if (message.signature != null && Object.hasOwnProperty.call(message, \"signature\"))\n            writer.uint32(/* id 5, wireType 2 =*/42).string(message.signature);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified DocString message, length delimited. Does not implicitly {@link DocString.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof DocString\n     * @static\n     * @param {IDocString} message DocString message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    DocString.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a DocString message from the specified reader or buffer.\n     * @function decode\n     * @memberof DocString\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {DocString} DocString\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DocString.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.DocString();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.name = reader.string();\n                break;\n            case 2:\n                message.module = reader.string();\n                break;\n            case 3:\n                message.docString = reader.string();\n                break;\n            case 4:\n                message.type = reader.string();\n                break;\n            case 5:\n                message.signature = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a DocString message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof DocString\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {DocString} DocString\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    DocString.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a DocString message.\n     * @function verify\n     * @memberof DocString\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    DocString.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            if (!$util.isString(message.name))\n                return \"name: string expected\";\n        if (message.module != null && message.hasOwnProperty(\"module\"))\n            if (!$util.isString(message.module))\n                return \"module: string expected\";\n        if (message.docString != null && message.hasOwnProperty(\"docString\"))\n            if (!$util.isString(message.docString))\n                return \"docString: string expected\";\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            if (!$util.isString(message.type))\n                return \"type: string expected\";\n        if (message.signature != null && message.hasOwnProperty(\"signature\"))\n            if (!$util.isString(message.signature))\n                return \"signature: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a DocString message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof DocString\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {DocString} DocString\n     */\n    DocString.fromObject = function fromObject(object) {\n        if (object instanceof $root.DocString)\n            return object;\n        let message = new $root.DocString();\n        if (object.name != null)\n            message.name = String(object.name);\n        if (object.module != null)\n            message.module = String(object.module);\n        if (object.docString != null)\n            message.docString = String(object.docString);\n        if (object.type != null)\n            message.type = String(object.type);\n        if (object.signature != null)\n            message.signature = String(object.signature);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a DocString message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof DocString\n     * @static\n     * @param {DocString} message DocString\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    DocString.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.name = \"\";\n            object.module = \"\";\n            object.docString = \"\";\n            object.type = \"\";\n            object.signature = \"\";\n        }\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            object.name = message.name;\n        if (message.module != null && message.hasOwnProperty(\"module\"))\n            object.module = message.module;\n        if (message.docString != null && message.hasOwnProperty(\"docString\"))\n            object.docString = message.docString;\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            object.type = message.type;\n        if (message.signature != null && message.hasOwnProperty(\"signature\"))\n            object.signature = message.signature;\n        return object;\n    };\n\n    /**\n     * Converts this DocString to JSON.\n     * @function toJSON\n     * @memberof DocString\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    DocString.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return DocString;\n})();\n\nexport const Element = $root.Element = (() => {\n\n    /**\n     * Properties of an Element.\n     * @exports IElement\n     * @interface IElement\n     * @property {IAlert|null} [alert] Element alert\n     * @property {IAudio|null} [audio] Element audio\n     * @property {IBalloons|null} [balloons] Element balloons\n     * @property {IBokehChart|null} [bokehChart] Element bokehChart\n     * @property {IButton|null} [button] Element button\n     * @property {ICheckbox|null} [checkbox] Element checkbox\n     * @property {IColorPicker|null} [colorPicker] Element colorPicker\n     * @property {IComponentInstance|null} [componentInstance] Element componentInstance\n     * @property {IDataFrame|null} [dataFrame] Element dataFrame\n     * @property {IDataFrame|null} [table] Element table\n     * @property {IDateInput|null} [dateInput] Element dateInput\n     * @property {IDeckGlChart|null} [deckGlChart] Element deckGlChart\n     * @property {IDeckGlJsonChart|null} [deckGlJsonChart] Element deckGlJsonChart\n     * @property {IDocString|null} [docString] Element docString\n     * @property {IEmpty|null} [empty] Element empty\n     * @property {IException|null} [exception] Element exception\n     * @property {IFavicon|null} [favicon] Element favicon\n     * @property {IFileUploader|null} [fileUploader] Element fileUploader\n     * @property {IGraphVizChart|null} [graphvizChart] Element graphvizChart\n     * @property {IIFrame|null} [iframe] Element iframe\n     * @property {IImageList|null} [imgs] Element imgs\n     * @property {IJson|null} [json] Element json\n     * @property {IMarkdown|null} [markdown] Element markdown\n     * @property {IMultiSelect|null} [multiselect] Element multiselect\n     * @property {INumberInput|null} [numberInput] Element numberInput\n     * @property {IPlotlyChart|null} [plotlyChart] Element plotlyChart\n     * @property {IProgress|null} [progress] Element progress\n     * @property {IRadio|null} [radio] Element radio\n     * @property {ISelectbox|null} [selectbox] Element selectbox\n     * @property {ISlider|null} [slider] Element slider\n     * @property {IText|null} [text] Element text\n     * @property {ITextArea|null} [textArea] Element textArea\n     * @property {ITextInput|null} [textInput] Element textInput\n     * @property {ITimeInput|null} [timeInput] Element timeInput\n     * @property {IVegaLiteChart|null} [vegaLiteChart] Element vegaLiteChart\n     * @property {IVideo|null} [video] Element video\n     */\n\n    /**\n     * Constructs a new Element.\n     * @exports Element\n     * @classdesc Represents an Element.\n     * @implements IElement\n     * @constructor\n     * @param {IElement=} [properties] Properties to set\n     */\n    function Element(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Element alert.\n     * @member {IAlert|null|undefined} alert\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.alert = null;\n\n    /**\n     * Element audio.\n     * @member {IAudio|null|undefined} audio\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.audio = null;\n\n    /**\n     * Element balloons.\n     * @member {IBalloons|null|undefined} balloons\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.balloons = null;\n\n    /**\n     * Element bokehChart.\n     * @member {IBokehChart|null|undefined} bokehChart\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.bokehChart = null;\n\n    /**\n     * Element button.\n     * @member {IButton|null|undefined} button\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.button = null;\n\n    /**\n     * Element checkbox.\n     * @member {ICheckbox|null|undefined} checkbox\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.checkbox = null;\n\n    /**\n     * Element colorPicker.\n     * @member {IColorPicker|null|undefined} colorPicker\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.colorPicker = null;\n\n    /**\n     * Element componentInstance.\n     * @member {IComponentInstance|null|undefined} componentInstance\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.componentInstance = null;\n\n    /**\n     * Element dataFrame.\n     * @member {IDataFrame|null|undefined} dataFrame\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.dataFrame = null;\n\n    /**\n     * Element table.\n     * @member {IDataFrame|null|undefined} table\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.table = null;\n\n    /**\n     * Element dateInput.\n     * @member {IDateInput|null|undefined} dateInput\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.dateInput = null;\n\n    /**\n     * Element deckGlChart.\n     * @member {IDeckGlChart|null|undefined} deckGlChart\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.deckGlChart = null;\n\n    /**\n     * Element deckGlJsonChart.\n     * @member {IDeckGlJsonChart|null|undefined} deckGlJsonChart\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.deckGlJsonChart = null;\n\n    /**\n     * Element docString.\n     * @member {IDocString|null|undefined} docString\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.docString = null;\n\n    /**\n     * Element empty.\n     * @member {IEmpty|null|undefined} empty\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.empty = null;\n\n    /**\n     * Element exception.\n     * @member {IException|null|undefined} exception\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.exception = null;\n\n    /**\n     * Element favicon.\n     * @member {IFavicon|null|undefined} favicon\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.favicon = null;\n\n    /**\n     * Element fileUploader.\n     * @member {IFileUploader|null|undefined} fileUploader\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.fileUploader = null;\n\n    /**\n     * Element graphvizChart.\n     * @member {IGraphVizChart|null|undefined} graphvizChart\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.graphvizChart = null;\n\n    /**\n     * Element iframe.\n     * @member {IIFrame|null|undefined} iframe\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.iframe = null;\n\n    /**\n     * Element imgs.\n     * @member {IImageList|null|undefined} imgs\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.imgs = null;\n\n    /**\n     * Element json.\n     * @member {IJson|null|undefined} json\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.json = null;\n\n    /**\n     * Element markdown.\n     * @member {IMarkdown|null|undefined} markdown\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.markdown = null;\n\n    /**\n     * Element multiselect.\n     * @member {IMultiSelect|null|undefined} multiselect\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.multiselect = null;\n\n    /**\n     * Element numberInput.\n     * @member {INumberInput|null|undefined} numberInput\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.numberInput = null;\n\n    /**\n     * Element plotlyChart.\n     * @member {IPlotlyChart|null|undefined} plotlyChart\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.plotlyChart = null;\n\n    /**\n     * Element progress.\n     * @member {IProgress|null|undefined} progress\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.progress = null;\n\n    /**\n     * Element radio.\n     * @member {IRadio|null|undefined} radio\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.radio = null;\n\n    /**\n     * Element selectbox.\n     * @member {ISelectbox|null|undefined} selectbox\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.selectbox = null;\n\n    /**\n     * Element slider.\n     * @member {ISlider|null|undefined} slider\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.slider = null;\n\n    /**\n     * Element text.\n     * @member {IText|null|undefined} text\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.text = null;\n\n    /**\n     * Element textArea.\n     * @member {ITextArea|null|undefined} textArea\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.textArea = null;\n\n    /**\n     * Element textInput.\n     * @member {ITextInput|null|undefined} textInput\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.textInput = null;\n\n    /**\n     * Element timeInput.\n     * @member {ITimeInput|null|undefined} timeInput\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.timeInput = null;\n\n    /**\n     * Element vegaLiteChart.\n     * @member {IVegaLiteChart|null|undefined} vegaLiteChart\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.vegaLiteChart = null;\n\n    /**\n     * Element video.\n     * @member {IVideo|null|undefined} video\n     * @memberof Element\n     * @instance\n     */\n    Element.prototype.video = null;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * Element type.\n     * @member {\"alert\"|\"audio\"|\"balloons\"|\"bokehChart\"|\"button\"|\"checkbox\"|\"colorPicker\"|\"componentInstance\"|\"dataFrame\"|\"table\"|\"dateInput\"|\"deckGlChart\"|\"deckGlJsonChart\"|\"docString\"|\"empty\"|\"exception\"|\"favicon\"|\"fileUploader\"|\"graphvizChart\"|\"iframe\"|\"imgs\"|\"json\"|\"markdown\"|\"multiselect\"|\"numberInput\"|\"plotlyChart\"|\"progress\"|\"radio\"|\"selectbox\"|\"slider\"|\"text\"|\"textArea\"|\"textInput\"|\"timeInput\"|\"vegaLiteChart\"|\"video\"|undefined} type\n     * @memberof Element\n     * @instance\n     */\n    Object.defineProperty(Element.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"alert\", \"audio\", \"balloons\", \"bokehChart\", \"button\", \"checkbox\", \"colorPicker\", \"componentInstance\", \"dataFrame\", \"table\", \"dateInput\", \"deckGlChart\", \"deckGlJsonChart\", \"docString\", \"empty\", \"exception\", \"favicon\", \"fileUploader\", \"graphvizChart\", \"iframe\", \"imgs\", \"json\", \"markdown\", \"multiselect\", \"numberInput\", \"plotlyChart\", \"progress\", \"radio\", \"selectbox\", \"slider\", \"text\", \"textArea\", \"textInput\", \"timeInput\", \"vegaLiteChart\", \"video\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new Element instance using the specified properties.\n     * @function create\n     * @memberof Element\n     * @static\n     * @param {IElement=} [properties] Properties to set\n     * @returns {Element} Element instance\n     */\n    Element.create = function create(properties) {\n        return new Element(properties);\n    };\n\n    /**\n     * Encodes the specified Element message. Does not implicitly {@link Element.verify|verify} messages.\n     * @function encode\n     * @memberof Element\n     * @static\n     * @param {IElement} message Element message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Element.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.text != null && Object.hasOwnProperty.call(message, \"text\"))\n            $root.Text.encode(message.text, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.empty != null && Object.hasOwnProperty.call(message, \"empty\"))\n            $root.Empty.encode(message.empty, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.dataFrame != null && Object.hasOwnProperty.call(message, \"dataFrame\"))\n            $root.DataFrame.encode(message.dataFrame, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.progress != null && Object.hasOwnProperty.call(message, \"progress\"))\n            $root.Progress.encode(message.progress, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();\n        if (message.imgs != null && Object.hasOwnProperty.call(message, \"imgs\"))\n            $root.ImageList.encode(message.imgs, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();\n        if (message.docString != null && Object.hasOwnProperty.call(message, \"docString\"))\n            $root.DocString.encode(message.docString, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();\n        if (message.exception != null && Object.hasOwnProperty.call(message, \"exception\"))\n            $root.Exception.encode(message.exception, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();\n        if (message.vegaLiteChart != null && Object.hasOwnProperty.call(message, \"vegaLiteChart\"))\n            $root.VegaLiteChart.encode(message.vegaLiteChart, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();\n        if (message.table != null && Object.hasOwnProperty.call(message, \"table\"))\n            $root.DataFrame.encode(message.table, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();\n        if (message.balloons != null && Object.hasOwnProperty.call(message, \"balloons\"))\n            $root.Balloons.encode(message.balloons, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();\n        if (message.audio != null && Object.hasOwnProperty.call(message, \"audio\"))\n            $root.Audio.encode(message.audio, writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();\n        if (message.video != null && Object.hasOwnProperty.call(message, \"video\"))\n            $root.Video.encode(message.video, writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();\n        if (message.deckGlChart != null && Object.hasOwnProperty.call(message, \"deckGlChart\"))\n            $root.DeckGlChart.encode(message.deckGlChart, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();\n        if (message.plotlyChart != null && Object.hasOwnProperty.call(message, \"plotlyChart\"))\n            $root.PlotlyChart.encode(message.plotlyChart, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();\n        if (message.bokehChart != null && Object.hasOwnProperty.call(message, \"bokehChart\"))\n            $root.BokehChart.encode(message.bokehChart, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();\n        if (message.graphvizChart != null && Object.hasOwnProperty.call(message, \"graphvizChart\"))\n            $root.GraphVizChart.encode(message.graphvizChart, writer.uint32(/* id 18, wireType 2 =*/146).fork()).ldelim();\n        if (message.button != null && Object.hasOwnProperty.call(message, \"button\"))\n            $root.Button.encode(message.button, writer.uint32(/* id 19, wireType 2 =*/154).fork()).ldelim();\n        if (message.checkbox != null && Object.hasOwnProperty.call(message, \"checkbox\"))\n            $root.Checkbox.encode(message.checkbox, writer.uint32(/* id 20, wireType 2 =*/162).fork()).ldelim();\n        if (message.slider != null && Object.hasOwnProperty.call(message, \"slider\"))\n            $root.Slider.encode(message.slider, writer.uint32(/* id 21, wireType 2 =*/170).fork()).ldelim();\n        if (message.textArea != null && Object.hasOwnProperty.call(message, \"textArea\"))\n            $root.TextArea.encode(message.textArea, writer.uint32(/* id 22, wireType 2 =*/178).fork()).ldelim();\n        if (message.radio != null && Object.hasOwnProperty.call(message, \"radio\"))\n            $root.Radio.encode(message.radio, writer.uint32(/* id 23, wireType 2 =*/186).fork()).ldelim();\n        if (message.textInput != null && Object.hasOwnProperty.call(message, \"textInput\"))\n            $root.TextInput.encode(message.textInput, writer.uint32(/* id 24, wireType 2 =*/194).fork()).ldelim();\n        if (message.selectbox != null && Object.hasOwnProperty.call(message, \"selectbox\"))\n            $root.Selectbox.encode(message.selectbox, writer.uint32(/* id 25, wireType 2 =*/202).fork()).ldelim();\n        if (message.timeInput != null && Object.hasOwnProperty.call(message, \"timeInput\"))\n            $root.TimeInput.encode(message.timeInput, writer.uint32(/* id 26, wireType 2 =*/210).fork()).ldelim();\n        if (message.dateInput != null && Object.hasOwnProperty.call(message, \"dateInput\"))\n            $root.DateInput.encode(message.dateInput, writer.uint32(/* id 27, wireType 2 =*/218).fork()).ldelim();\n        if (message.multiselect != null && Object.hasOwnProperty.call(message, \"multiselect\"))\n            $root.MultiSelect.encode(message.multiselect, writer.uint32(/* id 28, wireType 2 =*/226).fork()).ldelim();\n        if (message.markdown != null && Object.hasOwnProperty.call(message, \"markdown\"))\n            $root.Markdown.encode(message.markdown, writer.uint32(/* id 29, wireType 2 =*/234).fork()).ldelim();\n        if (message.alert != null && Object.hasOwnProperty.call(message, \"alert\"))\n            $root.Alert.encode(message.alert, writer.uint32(/* id 30, wireType 2 =*/242).fork()).ldelim();\n        if (message.json != null && Object.hasOwnProperty.call(message, \"json\"))\n            $root.Json.encode(message.json, writer.uint32(/* id 31, wireType 2 =*/250).fork()).ldelim();\n        if (message.numberInput != null && Object.hasOwnProperty.call(message, \"numberInput\"))\n            $root.NumberInput.encode(message.numberInput, writer.uint32(/* id 32, wireType 2 =*/258).fork()).ldelim();\n        if (message.fileUploader != null && Object.hasOwnProperty.call(message, \"fileUploader\"))\n            $root.FileUploader.encode(message.fileUploader, writer.uint32(/* id 33, wireType 2 =*/266).fork()).ldelim();\n        if (message.deckGlJsonChart != null && Object.hasOwnProperty.call(message, \"deckGlJsonChart\"))\n            $root.DeckGlJsonChart.encode(message.deckGlJsonChart, writer.uint32(/* id 34, wireType 2 =*/274).fork()).ldelim();\n        if (message.colorPicker != null && Object.hasOwnProperty.call(message, \"colorPicker\"))\n            $root.ColorPicker.encode(message.colorPicker, writer.uint32(/* id 35, wireType 2 =*/282).fork()).ldelim();\n        if (message.favicon != null && Object.hasOwnProperty.call(message, \"favicon\"))\n            $root.Favicon.encode(message.favicon, writer.uint32(/* id 36, wireType 2 =*/290).fork()).ldelim();\n        if (message.componentInstance != null && Object.hasOwnProperty.call(message, \"componentInstance\"))\n            $root.ComponentInstance.encode(message.componentInstance, writer.uint32(/* id 37, wireType 2 =*/298).fork()).ldelim();\n        if (message.iframe != null && Object.hasOwnProperty.call(message, \"iframe\"))\n            $root.IFrame.encode(message.iframe, writer.uint32(/* id 38, wireType 2 =*/306).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Element message, length delimited. Does not implicitly {@link Element.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Element\n     * @static\n     * @param {IElement} message Element message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Element.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Element message from the specified reader or buffer.\n     * @function decode\n     * @memberof Element\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Element} Element\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Element.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Element();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 30:\n                message.alert = $root.Alert.decode(reader, reader.uint32());\n                break;\n            case 13:\n                message.audio = $root.Audio.decode(reader, reader.uint32());\n                break;\n            case 12:\n                message.balloons = $root.Balloons.decode(reader, reader.uint32());\n                break;\n            case 17:\n                message.bokehChart = $root.BokehChart.decode(reader, reader.uint32());\n                break;\n            case 19:\n                message.button = $root.Button.decode(reader, reader.uint32());\n                break;\n            case 20:\n                message.checkbox = $root.Checkbox.decode(reader, reader.uint32());\n                break;\n            case 35:\n                message.colorPicker = $root.ColorPicker.decode(reader, reader.uint32());\n                break;\n            case 37:\n                message.componentInstance = $root.ComponentInstance.decode(reader, reader.uint32());\n                break;\n            case 3:\n                message.dataFrame = $root.DataFrame.decode(reader, reader.uint32());\n                break;\n            case 11:\n                message.table = $root.DataFrame.decode(reader, reader.uint32());\n                break;\n            case 27:\n                message.dateInput = $root.DateInput.decode(reader, reader.uint32());\n                break;\n            case 15:\n                message.deckGlChart = $root.DeckGlChart.decode(reader, reader.uint32());\n                break;\n            case 34:\n                message.deckGlJsonChart = $root.DeckGlJsonChart.decode(reader, reader.uint32());\n                break;\n            case 7:\n                message.docString = $root.DocString.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.empty = $root.Empty.decode(reader, reader.uint32());\n                break;\n            case 8:\n                message.exception = $root.Exception.decode(reader, reader.uint32());\n                break;\n            case 36:\n                message.favicon = $root.Favicon.decode(reader, reader.uint32());\n                break;\n            case 33:\n                message.fileUploader = $root.FileUploader.decode(reader, reader.uint32());\n                break;\n            case 18:\n                message.graphvizChart = $root.GraphVizChart.decode(reader, reader.uint32());\n                break;\n            case 38:\n                message.iframe = $root.IFrame.decode(reader, reader.uint32());\n                break;\n            case 6:\n                message.imgs = $root.ImageList.decode(reader, reader.uint32());\n                break;\n            case 31:\n                message.json = $root.Json.decode(reader, reader.uint32());\n                break;\n            case 29:\n                message.markdown = $root.Markdown.decode(reader, reader.uint32());\n                break;\n            case 28:\n                message.multiselect = $root.MultiSelect.decode(reader, reader.uint32());\n                break;\n            case 32:\n                message.numberInput = $root.NumberInput.decode(reader, reader.uint32());\n                break;\n            case 16:\n                message.plotlyChart = $root.PlotlyChart.decode(reader, reader.uint32());\n                break;\n            case 5:\n                message.progress = $root.Progress.decode(reader, reader.uint32());\n                break;\n            case 23:\n                message.radio = $root.Radio.decode(reader, reader.uint32());\n                break;\n            case 25:\n                message.selectbox = $root.Selectbox.decode(reader, reader.uint32());\n                break;\n            case 21:\n                message.slider = $root.Slider.decode(reader, reader.uint32());\n                break;\n            case 1:\n                message.text = $root.Text.decode(reader, reader.uint32());\n                break;\n            case 22:\n                message.textArea = $root.TextArea.decode(reader, reader.uint32());\n                break;\n            case 24:\n                message.textInput = $root.TextInput.decode(reader, reader.uint32());\n                break;\n            case 26:\n                message.timeInput = $root.TimeInput.decode(reader, reader.uint32());\n                break;\n            case 10:\n                message.vegaLiteChart = $root.VegaLiteChart.decode(reader, reader.uint32());\n                break;\n            case 14:\n                message.video = $root.Video.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Element message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Element\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Element} Element\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Element.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Element message.\n     * @function verify\n     * @memberof Element\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Element.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.alert != null && message.hasOwnProperty(\"alert\")) {\n            properties.type = 1;\n            {\n                let error = $root.Alert.verify(message.alert);\n                if (error)\n                    return \"alert.\" + error;\n            }\n        }\n        if (message.audio != null && message.hasOwnProperty(\"audio\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Audio.verify(message.audio);\n                if (error)\n                    return \"audio.\" + error;\n            }\n        }\n        if (message.balloons != null && message.hasOwnProperty(\"balloons\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Balloons.verify(message.balloons);\n                if (error)\n                    return \"balloons.\" + error;\n            }\n        }\n        if (message.bokehChart != null && message.hasOwnProperty(\"bokehChart\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.BokehChart.verify(message.bokehChart);\n                if (error)\n                    return \"bokehChart.\" + error;\n            }\n        }\n        if (message.button != null && message.hasOwnProperty(\"button\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Button.verify(message.button);\n                if (error)\n                    return \"button.\" + error;\n            }\n        }\n        if (message.checkbox != null && message.hasOwnProperty(\"checkbox\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Checkbox.verify(message.checkbox);\n                if (error)\n                    return \"checkbox.\" + error;\n            }\n        }\n        if (message.colorPicker != null && message.hasOwnProperty(\"colorPicker\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.ColorPicker.verify(message.colorPicker);\n                if (error)\n                    return \"colorPicker.\" + error;\n            }\n        }\n        if (message.componentInstance != null && message.hasOwnProperty(\"componentInstance\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.ComponentInstance.verify(message.componentInstance);\n                if (error)\n                    return \"componentInstance.\" + error;\n            }\n        }\n        if (message.dataFrame != null && message.hasOwnProperty(\"dataFrame\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DataFrame.verify(message.dataFrame);\n                if (error)\n                    return \"dataFrame.\" + error;\n            }\n        }\n        if (message.table != null && message.hasOwnProperty(\"table\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DataFrame.verify(message.table);\n                if (error)\n                    return \"table.\" + error;\n            }\n        }\n        if (message.dateInput != null && message.hasOwnProperty(\"dateInput\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DateInput.verify(message.dateInput);\n                if (error)\n                    return \"dateInput.\" + error;\n            }\n        }\n        if (message.deckGlChart != null && message.hasOwnProperty(\"deckGlChart\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DeckGlChart.verify(message.deckGlChart);\n                if (error)\n                    return \"deckGlChart.\" + error;\n            }\n        }\n        if (message.deckGlJsonChart != null && message.hasOwnProperty(\"deckGlJsonChart\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DeckGlJsonChart.verify(message.deckGlJsonChart);\n                if (error)\n                    return \"deckGlJsonChart.\" + error;\n            }\n        }\n        if (message.docString != null && message.hasOwnProperty(\"docString\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.DocString.verify(message.docString);\n                if (error)\n                    return \"docString.\" + error;\n            }\n        }\n        if (message.empty != null && message.hasOwnProperty(\"empty\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Empty.verify(message.empty);\n                if (error)\n                    return \"empty.\" + error;\n            }\n        }\n        if (message.exception != null && message.hasOwnProperty(\"exception\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Exception.verify(message.exception);\n                if (error)\n                    return \"exception.\" + error;\n            }\n        }\n        if (message.favicon != null && message.hasOwnProperty(\"favicon\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Favicon.verify(message.favicon);\n                if (error)\n                    return \"favicon.\" + error;\n            }\n        }\n        if (message.fileUploader != null && message.hasOwnProperty(\"fileUploader\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.FileUploader.verify(message.fileUploader);\n                if (error)\n                    return \"fileUploader.\" + error;\n            }\n        }\n        if (message.graphvizChart != null && message.hasOwnProperty(\"graphvizChart\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.GraphVizChart.verify(message.graphvizChart);\n                if (error)\n                    return \"graphvizChart.\" + error;\n            }\n        }\n        if (message.iframe != null && message.hasOwnProperty(\"iframe\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.IFrame.verify(message.iframe);\n                if (error)\n                    return \"iframe.\" + error;\n            }\n        }\n        if (message.imgs != null && message.hasOwnProperty(\"imgs\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.ImageList.verify(message.imgs);\n                if (error)\n                    return \"imgs.\" + error;\n            }\n        }\n        if (message.json != null && message.hasOwnProperty(\"json\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Json.verify(message.json);\n                if (error)\n                    return \"json.\" + error;\n            }\n        }\n        if (message.markdown != null && message.hasOwnProperty(\"markdown\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Markdown.verify(message.markdown);\n                if (error)\n                    return \"markdown.\" + error;\n            }\n        }\n        if (message.multiselect != null && message.hasOwnProperty(\"multiselect\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.MultiSelect.verify(message.multiselect);\n                if (error)\n                    return \"multiselect.\" + error;\n            }\n        }\n        if (message.numberInput != null && message.hasOwnProperty(\"numberInput\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.NumberInput.verify(message.numberInput);\n                if (error)\n                    return \"numberInput.\" + error;\n            }\n        }\n        if (message.plotlyChart != null && message.hasOwnProperty(\"plotlyChart\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.PlotlyChart.verify(message.plotlyChart);\n                if (error)\n                    return \"plotlyChart.\" + error;\n            }\n        }\n        if (message.progress != null && message.hasOwnProperty(\"progress\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Progress.verify(message.progress);\n                if (error)\n                    return \"progress.\" + error;\n            }\n        }\n        if (message.radio != null && message.hasOwnProperty(\"radio\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Radio.verify(message.radio);\n                if (error)\n                    return \"radio.\" + error;\n            }\n        }\n        if (message.selectbox != null && message.hasOwnProperty(\"selectbox\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Selectbox.verify(message.selectbox);\n                if (error)\n                    return \"selectbox.\" + error;\n            }\n        }\n        if (message.slider != null && message.hasOwnProperty(\"slider\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Slider.verify(message.slider);\n                if (error)\n                    return \"slider.\" + error;\n            }\n        }\n        if (message.text != null && message.hasOwnProperty(\"text\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Text.verify(message.text);\n                if (error)\n                    return \"text.\" + error;\n            }\n        }\n        if (message.textArea != null && message.hasOwnProperty(\"textArea\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.TextArea.verify(message.textArea);\n                if (error)\n                    return \"textArea.\" + error;\n            }\n        }\n        if (message.textInput != null && message.hasOwnProperty(\"textInput\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.TextInput.verify(message.textInput);\n                if (error)\n                    return \"textInput.\" + error;\n            }\n        }\n        if (message.timeInput != null && message.hasOwnProperty(\"timeInput\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.TimeInput.verify(message.timeInput);\n                if (error)\n                    return \"timeInput.\" + error;\n            }\n        }\n        if (message.vegaLiteChart != null && message.hasOwnProperty(\"vegaLiteChart\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.VegaLiteChart.verify(message.vegaLiteChart);\n                if (error)\n                    return \"vegaLiteChart.\" + error;\n            }\n        }\n        if (message.video != null && message.hasOwnProperty(\"video\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Video.verify(message.video);\n                if (error)\n                    return \"video.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates an Element message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Element\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Element} Element\n     */\n    Element.fromObject = function fromObject(object) {\n        if (object instanceof $root.Element)\n            return object;\n        let message = new $root.Element();\n        if (object.alert != null) {\n            if (typeof object.alert !== \"object\")\n                throw TypeError(\".Element.alert: object expected\");\n            message.alert = $root.Alert.fromObject(object.alert);\n        }\n        if (object.audio != null) {\n            if (typeof object.audio !== \"object\")\n                throw TypeError(\".Element.audio: object expected\");\n            message.audio = $root.Audio.fromObject(object.audio);\n        }\n        if (object.balloons != null) {\n            if (typeof object.balloons !== \"object\")\n                throw TypeError(\".Element.balloons: object expected\");\n            message.balloons = $root.Balloons.fromObject(object.balloons);\n        }\n        if (object.bokehChart != null) {\n            if (typeof object.bokehChart !== \"object\")\n                throw TypeError(\".Element.bokehChart: object expected\");\n            message.bokehChart = $root.BokehChart.fromObject(object.bokehChart);\n        }\n        if (object.button != null) {\n            if (typeof object.button !== \"object\")\n                throw TypeError(\".Element.button: object expected\");\n            message.button = $root.Button.fromObject(object.button);\n        }\n        if (object.checkbox != null) {\n            if (typeof object.checkbox !== \"object\")\n                throw TypeError(\".Element.checkbox: object expected\");\n            message.checkbox = $root.Checkbox.fromObject(object.checkbox);\n        }\n        if (object.colorPicker != null) {\n            if (typeof object.colorPicker !== \"object\")\n                throw TypeError(\".Element.colorPicker: object expected\");\n            message.colorPicker = $root.ColorPicker.fromObject(object.colorPicker);\n        }\n        if (object.componentInstance != null) {\n            if (typeof object.componentInstance !== \"object\")\n                throw TypeError(\".Element.componentInstance: object expected\");\n            message.componentInstance = $root.ComponentInstance.fromObject(object.componentInstance);\n        }\n        if (object.dataFrame != null) {\n            if (typeof object.dataFrame !== \"object\")\n                throw TypeError(\".Element.dataFrame: object expected\");\n            message.dataFrame = $root.DataFrame.fromObject(object.dataFrame);\n        }\n        if (object.table != null) {\n            if (typeof object.table !== \"object\")\n                throw TypeError(\".Element.table: object expected\");\n            message.table = $root.DataFrame.fromObject(object.table);\n        }\n        if (object.dateInput != null) {\n            if (typeof object.dateInput !== \"object\")\n                throw TypeError(\".Element.dateInput: object expected\");\n            message.dateInput = $root.DateInput.fromObject(object.dateInput);\n        }\n        if (object.deckGlChart != null) {\n            if (typeof object.deckGlChart !== \"object\")\n                throw TypeError(\".Element.deckGlChart: object expected\");\n            message.deckGlChart = $root.DeckGlChart.fromObject(object.deckGlChart);\n        }\n        if (object.deckGlJsonChart != null) {\n            if (typeof object.deckGlJsonChart !== \"object\")\n                throw TypeError(\".Element.deckGlJsonChart: object expected\");\n            message.deckGlJsonChart = $root.DeckGlJsonChart.fromObject(object.deckGlJsonChart);\n        }\n        if (object.docString != null) {\n            if (typeof object.docString !== \"object\")\n                throw TypeError(\".Element.docString: object expected\");\n            message.docString = $root.DocString.fromObject(object.docString);\n        }\n        if (object.empty != null) {\n            if (typeof object.empty !== \"object\")\n                throw TypeError(\".Element.empty: object expected\");\n            message.empty = $root.Empty.fromObject(object.empty);\n        }\n        if (object.exception != null) {\n            if (typeof object.exception !== \"object\")\n                throw TypeError(\".Element.exception: object expected\");\n            message.exception = $root.Exception.fromObject(object.exception);\n        }\n        if (object.favicon != null) {\n            if (typeof object.favicon !== \"object\")\n                throw TypeError(\".Element.favicon: object expected\");\n            message.favicon = $root.Favicon.fromObject(object.favicon);\n        }\n        if (object.fileUploader != null) {\n            if (typeof object.fileUploader !== \"object\")\n                throw TypeError(\".Element.fileUploader: object expected\");\n            message.fileUploader = $root.FileUploader.fromObject(object.fileUploader);\n        }\n        if (object.graphvizChart != null) {\n            if (typeof object.graphvizChart !== \"object\")\n                throw TypeError(\".Element.graphvizChart: object expected\");\n            message.graphvizChart = $root.GraphVizChart.fromObject(object.graphvizChart);\n        }\n        if (object.iframe != null) {\n            if (typeof object.iframe !== \"object\")\n                throw TypeError(\".Element.iframe: object expected\");\n            message.iframe = $root.IFrame.fromObject(object.iframe);\n        }\n        if (object.imgs != null) {\n            if (typeof object.imgs !== \"object\")\n                throw TypeError(\".Element.imgs: object expected\");\n            message.imgs = $root.ImageList.fromObject(object.imgs);\n        }\n        if (object.json != null) {\n            if (typeof object.json !== \"object\")\n                throw TypeError(\".Element.json: object expected\");\n            message.json = $root.Json.fromObject(object.json);\n        }\n        if (object.markdown != null) {\n            if (typeof object.markdown !== \"object\")\n                throw TypeError(\".Element.markdown: object expected\");\n            message.markdown = $root.Markdown.fromObject(object.markdown);\n        }\n        if (object.multiselect != null) {\n            if (typeof object.multiselect !== \"object\")\n                throw TypeError(\".Element.multiselect: object expected\");\n            message.multiselect = $root.MultiSelect.fromObject(object.multiselect);\n        }\n        if (object.numberInput != null) {\n            if (typeof object.numberInput !== \"object\")\n                throw TypeError(\".Element.numberInput: object expected\");\n            message.numberInput = $root.NumberInput.fromObject(object.numberInput);\n        }\n        if (object.plotlyChart != null) {\n            if (typeof object.plotlyChart !== \"object\")\n                throw TypeError(\".Element.plotlyChart: object expected\");\n            message.plotlyChart = $root.PlotlyChart.fromObject(object.plotlyChart);\n        }\n        if (object.progress != null) {\n            if (typeof object.progress !== \"object\")\n                throw TypeError(\".Element.progress: object expected\");\n            message.progress = $root.Progress.fromObject(object.progress);\n        }\n        if (object.radio != null) {\n            if (typeof object.radio !== \"object\")\n                throw TypeError(\".Element.radio: object expected\");\n            message.radio = $root.Radio.fromObject(object.radio);\n        }\n        if (object.selectbox != null) {\n            if (typeof object.selectbox !== \"object\")\n                throw TypeError(\".Element.selectbox: object expected\");\n            message.selectbox = $root.Selectbox.fromObject(object.selectbox);\n        }\n        if (object.slider != null) {\n            if (typeof object.slider !== \"object\")\n                throw TypeError(\".Element.slider: object expected\");\n            message.slider = $root.Slider.fromObject(object.slider);\n        }\n        if (object.text != null) {\n            if (typeof object.text !== \"object\")\n                throw TypeError(\".Element.text: object expected\");\n            message.text = $root.Text.fromObject(object.text);\n        }\n        if (object.textArea != null) {\n            if (typeof object.textArea !== \"object\")\n                throw TypeError(\".Element.textArea: object expected\");\n            message.textArea = $root.TextArea.fromObject(object.textArea);\n        }\n        if (object.textInput != null) {\n            if (typeof object.textInput !== \"object\")\n                throw TypeError(\".Element.textInput: object expected\");\n            message.textInput = $root.TextInput.fromObject(object.textInput);\n        }\n        if (object.timeInput != null) {\n            if (typeof object.timeInput !== \"object\")\n                throw TypeError(\".Element.timeInput: object expected\");\n            message.timeInput = $root.TimeInput.fromObject(object.timeInput);\n        }\n        if (object.vegaLiteChart != null) {\n            if (typeof object.vegaLiteChart !== \"object\")\n                throw TypeError(\".Element.vegaLiteChart: object expected\");\n            message.vegaLiteChart = $root.VegaLiteChart.fromObject(object.vegaLiteChart);\n        }\n        if (object.video != null) {\n            if (typeof object.video !== \"object\")\n                throw TypeError(\".Element.video: object expected\");\n            message.video = $root.Video.fromObject(object.video);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Element message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Element\n     * @static\n     * @param {Element} message Element\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Element.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (message.text != null && message.hasOwnProperty(\"text\")) {\n            object.text = $root.Text.toObject(message.text, options);\n            if (options.oneofs)\n                object.type = \"text\";\n        }\n        if (message.empty != null && message.hasOwnProperty(\"empty\")) {\n            object.empty = $root.Empty.toObject(message.empty, options);\n            if (options.oneofs)\n                object.type = \"empty\";\n        }\n        if (message.dataFrame != null && message.hasOwnProperty(\"dataFrame\")) {\n            object.dataFrame = $root.DataFrame.toObject(message.dataFrame, options);\n            if (options.oneofs)\n                object.type = \"dataFrame\";\n        }\n        if (message.progress != null && message.hasOwnProperty(\"progress\")) {\n            object.progress = $root.Progress.toObject(message.progress, options);\n            if (options.oneofs)\n                object.type = \"progress\";\n        }\n        if (message.imgs != null && message.hasOwnProperty(\"imgs\")) {\n            object.imgs = $root.ImageList.toObject(message.imgs, options);\n            if (options.oneofs)\n                object.type = \"imgs\";\n        }\n        if (message.docString != null && message.hasOwnProperty(\"docString\")) {\n            object.docString = $root.DocString.toObject(message.docString, options);\n            if (options.oneofs)\n                object.type = \"docString\";\n        }\n        if (message.exception != null && message.hasOwnProperty(\"exception\")) {\n            object.exception = $root.Exception.toObject(message.exception, options);\n            if (options.oneofs)\n                object.type = \"exception\";\n        }\n        if (message.vegaLiteChart != null && message.hasOwnProperty(\"vegaLiteChart\")) {\n            object.vegaLiteChart = $root.VegaLiteChart.toObject(message.vegaLiteChart, options);\n            if (options.oneofs)\n                object.type = \"vegaLiteChart\";\n        }\n        if (message.table != null && message.hasOwnProperty(\"table\")) {\n            object.table = $root.DataFrame.toObject(message.table, options);\n            if (options.oneofs)\n                object.type = \"table\";\n        }\n        if (message.balloons != null && message.hasOwnProperty(\"balloons\")) {\n            object.balloons = $root.Balloons.toObject(message.balloons, options);\n            if (options.oneofs)\n                object.type = \"balloons\";\n        }\n        if (message.audio != null && message.hasOwnProperty(\"audio\")) {\n            object.audio = $root.Audio.toObject(message.audio, options);\n            if (options.oneofs)\n                object.type = \"audio\";\n        }\n        if (message.video != null && message.hasOwnProperty(\"video\")) {\n            object.video = $root.Video.toObject(message.video, options);\n            if (options.oneofs)\n                object.type = \"video\";\n        }\n        if (message.deckGlChart != null && message.hasOwnProperty(\"deckGlChart\")) {\n            object.deckGlChart = $root.DeckGlChart.toObject(message.deckGlChart, options);\n            if (options.oneofs)\n                object.type = \"deckGlChart\";\n        }\n        if (message.plotlyChart != null && message.hasOwnProperty(\"plotlyChart\")) {\n            object.plotlyChart = $root.PlotlyChart.toObject(message.plotlyChart, options);\n            if (options.oneofs)\n                object.type = \"plotlyChart\";\n        }\n        if (message.bokehChart != null && message.hasOwnProperty(\"bokehChart\")) {\n            object.bokehChart = $root.BokehChart.toObject(message.bokehChart, options);\n            if (options.oneofs)\n                object.type = \"bokehChart\";\n        }\n        if (message.graphvizChart != null && message.hasOwnProperty(\"graphvizChart\")) {\n            object.graphvizChart = $root.GraphVizChart.toObject(message.graphvizChart, options);\n            if (options.oneofs)\n                object.type = \"graphvizChart\";\n        }\n        if (message.button != null && message.hasOwnProperty(\"button\")) {\n            object.button = $root.Button.toObject(message.button, options);\n            if (options.oneofs)\n                object.type = \"button\";\n        }\n        if (message.checkbox != null && message.hasOwnProperty(\"checkbox\")) {\n            object.checkbox = $root.Checkbox.toObject(message.checkbox, options);\n            if (options.oneofs)\n                object.type = \"checkbox\";\n        }\n        if (message.slider != null && message.hasOwnProperty(\"slider\")) {\n            object.slider = $root.Slider.toObject(message.slider, options);\n            if (options.oneofs)\n                object.type = \"slider\";\n        }\n        if (message.textArea != null && message.hasOwnProperty(\"textArea\")) {\n            object.textArea = $root.TextArea.toObject(message.textArea, options);\n            if (options.oneofs)\n                object.type = \"textArea\";\n        }\n        if (message.radio != null && message.hasOwnProperty(\"radio\")) {\n            object.radio = $root.Radio.toObject(message.radio, options);\n            if (options.oneofs)\n                object.type = \"radio\";\n        }\n        if (message.textInput != null && message.hasOwnProperty(\"textInput\")) {\n            object.textInput = $root.TextInput.toObject(message.textInput, options);\n            if (options.oneofs)\n                object.type = \"textInput\";\n        }\n        if (message.selectbox != null && message.hasOwnProperty(\"selectbox\")) {\n            object.selectbox = $root.Selectbox.toObject(message.selectbox, options);\n            if (options.oneofs)\n                object.type = \"selectbox\";\n        }\n        if (message.timeInput != null && message.hasOwnProperty(\"timeInput\")) {\n            object.timeInput = $root.TimeInput.toObject(message.timeInput, options);\n            if (options.oneofs)\n                object.type = \"timeInput\";\n        }\n        if (message.dateInput != null && message.hasOwnProperty(\"dateInput\")) {\n            object.dateInput = $root.DateInput.toObject(message.dateInput, options);\n            if (options.oneofs)\n                object.type = \"dateInput\";\n        }\n        if (message.multiselect != null && message.hasOwnProperty(\"multiselect\")) {\n            object.multiselect = $root.MultiSelect.toObject(message.multiselect, options);\n            if (options.oneofs)\n                object.type = \"multiselect\";\n        }\n        if (message.markdown != null && message.hasOwnProperty(\"markdown\")) {\n            object.markdown = $root.Markdown.toObject(message.markdown, options);\n            if (options.oneofs)\n                object.type = \"markdown\";\n        }\n        if (message.alert != null && message.hasOwnProperty(\"alert\")) {\n            object.alert = $root.Alert.toObject(message.alert, options);\n            if (options.oneofs)\n                object.type = \"alert\";\n        }\n        if (message.json != null && message.hasOwnProperty(\"json\")) {\n            object.json = $root.Json.toObject(message.json, options);\n            if (options.oneofs)\n                object.type = \"json\";\n        }\n        if (message.numberInput != null && message.hasOwnProperty(\"numberInput\")) {\n            object.numberInput = $root.NumberInput.toObject(message.numberInput, options);\n            if (options.oneofs)\n                object.type = \"numberInput\";\n        }\n        if (message.fileUploader != null && message.hasOwnProperty(\"fileUploader\")) {\n            object.fileUploader = $root.FileUploader.toObject(message.fileUploader, options);\n            if (options.oneofs)\n                object.type = \"fileUploader\";\n        }\n        if (message.deckGlJsonChart != null && message.hasOwnProperty(\"deckGlJsonChart\")) {\n            object.deckGlJsonChart = $root.DeckGlJsonChart.toObject(message.deckGlJsonChart, options);\n            if (options.oneofs)\n                object.type = \"deckGlJsonChart\";\n        }\n        if (message.colorPicker != null && message.hasOwnProperty(\"colorPicker\")) {\n            object.colorPicker = $root.ColorPicker.toObject(message.colorPicker, options);\n            if (options.oneofs)\n                object.type = \"colorPicker\";\n        }\n        if (message.favicon != null && message.hasOwnProperty(\"favicon\")) {\n            object.favicon = $root.Favicon.toObject(message.favicon, options);\n            if (options.oneofs)\n                object.type = \"favicon\";\n        }\n        if (message.componentInstance != null && message.hasOwnProperty(\"componentInstance\")) {\n            object.componentInstance = $root.ComponentInstance.toObject(message.componentInstance, options);\n            if (options.oneofs)\n                object.type = \"componentInstance\";\n        }\n        if (message.iframe != null && message.hasOwnProperty(\"iframe\")) {\n            object.iframe = $root.IFrame.toObject(message.iframe, options);\n            if (options.oneofs)\n                object.type = \"iframe\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Element to JSON.\n     * @function toJSON\n     * @memberof Element\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Element.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Element;\n})();\n\nexport const Empty = $root.Empty = (() => {\n\n    /**\n     * Properties of an Empty.\n     * @exports IEmpty\n     * @interface IEmpty\n     * @property {boolean|null} [unused] Empty unused\n     */\n\n    /**\n     * Constructs a new Empty.\n     * @exports Empty\n     * @classdesc Represents an Empty.\n     * @implements IEmpty\n     * @constructor\n     * @param {IEmpty=} [properties] Properties to set\n     */\n    function Empty(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Empty unused.\n     * @member {boolean} unused\n     * @memberof Empty\n     * @instance\n     */\n    Empty.prototype.unused = false;\n\n    /**\n     * Creates a new Empty instance using the specified properties.\n     * @function create\n     * @memberof Empty\n     * @static\n     * @param {IEmpty=} [properties] Properties to set\n     * @returns {Empty} Empty instance\n     */\n    Empty.create = function create(properties) {\n        return new Empty(properties);\n    };\n\n    /**\n     * Encodes the specified Empty message. Does not implicitly {@link Empty.verify|verify} messages.\n     * @function encode\n     * @memberof Empty\n     * @static\n     * @param {IEmpty} message Empty message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Empty.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.unused != null && Object.hasOwnProperty.call(message, \"unused\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).bool(message.unused);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Empty message, length delimited. Does not implicitly {@link Empty.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Empty\n     * @static\n     * @param {IEmpty} message Empty message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Empty.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Empty message from the specified reader or buffer.\n     * @function decode\n     * @memberof Empty\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Empty} Empty\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Empty.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Empty();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.unused = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Empty message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Empty\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Empty} Empty\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Empty.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Empty message.\n     * @function verify\n     * @memberof Empty\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Empty.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.unused != null && message.hasOwnProperty(\"unused\"))\n            if (typeof message.unused !== \"boolean\")\n                return \"unused: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates an Empty message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Empty\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Empty} Empty\n     */\n    Empty.fromObject = function fromObject(object) {\n        if (object instanceof $root.Empty)\n            return object;\n        let message = new $root.Empty();\n        if (object.unused != null)\n            message.unused = Boolean(object.unused);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Empty message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Empty\n     * @static\n     * @param {Empty} message Empty\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Empty.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.unused = false;\n        if (message.unused != null && message.hasOwnProperty(\"unused\"))\n            object.unused = message.unused;\n        return object;\n    };\n\n    /**\n     * Converts this Empty to JSON.\n     * @function toJSON\n     * @memberof Empty\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Empty.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Empty;\n})();\n\nexport const Exception = $root.Exception = (() => {\n\n    /**\n     * Properties of an Exception.\n     * @exports IException\n     * @interface IException\n     * @property {string|null} [type] Exception type\n     * @property {string|null} [message] Exception message\n     * @property {boolean|null} [messageIsMarkdown] Exception messageIsMarkdown\n     * @property {Array.<string>|null} [stackTrace] Exception stackTrace\n     * @property {boolean|null} [isWarning] Exception isWarning\n     */\n\n    /**\n     * Constructs a new Exception.\n     * @exports Exception\n     * @classdesc Represents an Exception.\n     * @implements IException\n     * @constructor\n     * @param {IException=} [properties] Properties to set\n     */\n    function Exception(properties) {\n        this.stackTrace = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Exception type.\n     * @member {string} type\n     * @memberof Exception\n     * @instance\n     */\n    Exception.prototype.type = \"\";\n\n    /**\n     * Exception message.\n     * @member {string} message\n     * @memberof Exception\n     * @instance\n     */\n    Exception.prototype.message = \"\";\n\n    /**\n     * Exception messageIsMarkdown.\n     * @member {boolean} messageIsMarkdown\n     * @memberof Exception\n     * @instance\n     */\n    Exception.prototype.messageIsMarkdown = false;\n\n    /**\n     * Exception stackTrace.\n     * @member {Array.<string>} stackTrace\n     * @memberof Exception\n     * @instance\n     */\n    Exception.prototype.stackTrace = $util.emptyArray;\n\n    /**\n     * Exception isWarning.\n     * @member {boolean} isWarning\n     * @memberof Exception\n     * @instance\n     */\n    Exception.prototype.isWarning = false;\n\n    /**\n     * Creates a new Exception instance using the specified properties.\n     * @function create\n     * @memberof Exception\n     * @static\n     * @param {IException=} [properties] Properties to set\n     * @returns {Exception} Exception instance\n     */\n    Exception.create = function create(properties) {\n        return new Exception(properties);\n    };\n\n    /**\n     * Encodes the specified Exception message. Does not implicitly {@link Exception.verify|verify} messages.\n     * @function encode\n     * @memberof Exception\n     * @static\n     * @param {IException} message Exception message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Exception.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.type != null && Object.hasOwnProperty.call(message, \"type\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.type);\n        if (message.message != null && Object.hasOwnProperty.call(message, \"message\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.message);\n        if (message.stackTrace != null && message.stackTrace.length)\n            for (let i = 0; i < message.stackTrace.length; ++i)\n                writer.uint32(/* id 3, wireType 2 =*/26).string(message.stackTrace[i]);\n        if (message.messageIsMarkdown != null && Object.hasOwnProperty.call(message, \"messageIsMarkdown\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).bool(message.messageIsMarkdown);\n        if (message.isWarning != null && Object.hasOwnProperty.call(message, \"isWarning\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).bool(message.isWarning);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Exception message, length delimited. Does not implicitly {@link Exception.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Exception\n     * @static\n     * @param {IException} message Exception message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Exception.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Exception message from the specified reader or buffer.\n     * @function decode\n     * @memberof Exception\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Exception} Exception\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Exception.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Exception();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.type = reader.string();\n                break;\n            case 2:\n                message.message = reader.string();\n                break;\n            case 4:\n                message.messageIsMarkdown = reader.bool();\n                break;\n            case 3:\n                if (!(message.stackTrace && message.stackTrace.length))\n                    message.stackTrace = [];\n                message.stackTrace.push(reader.string());\n                break;\n            case 5:\n                message.isWarning = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Exception message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Exception\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Exception} Exception\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Exception.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Exception message.\n     * @function verify\n     * @memberof Exception\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Exception.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            if (!$util.isString(message.type))\n                return \"type: string expected\";\n        if (message.message != null && message.hasOwnProperty(\"message\"))\n            if (!$util.isString(message.message))\n                return \"message: string expected\";\n        if (message.messageIsMarkdown != null && message.hasOwnProperty(\"messageIsMarkdown\"))\n            if (typeof message.messageIsMarkdown !== \"boolean\")\n                return \"messageIsMarkdown: boolean expected\";\n        if (message.stackTrace != null && message.hasOwnProperty(\"stackTrace\")) {\n            if (!Array.isArray(message.stackTrace))\n                return \"stackTrace: array expected\";\n            for (let i = 0; i < message.stackTrace.length; ++i)\n                if (!$util.isString(message.stackTrace[i]))\n                    return \"stackTrace: string[] expected\";\n        }\n        if (message.isWarning != null && message.hasOwnProperty(\"isWarning\"))\n            if (typeof message.isWarning !== \"boolean\")\n                return \"isWarning: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates an Exception message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Exception\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Exception} Exception\n     */\n    Exception.fromObject = function fromObject(object) {\n        if (object instanceof $root.Exception)\n            return object;\n        let message = new $root.Exception();\n        if (object.type != null)\n            message.type = String(object.type);\n        if (object.message != null)\n            message.message = String(object.message);\n        if (object.messageIsMarkdown != null)\n            message.messageIsMarkdown = Boolean(object.messageIsMarkdown);\n        if (object.stackTrace) {\n            if (!Array.isArray(object.stackTrace))\n                throw TypeError(\".Exception.stackTrace: array expected\");\n            message.stackTrace = [];\n            for (let i = 0; i < object.stackTrace.length; ++i)\n                message.stackTrace[i] = String(object.stackTrace[i]);\n        }\n        if (object.isWarning != null)\n            message.isWarning = Boolean(object.isWarning);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Exception message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Exception\n     * @static\n     * @param {Exception} message Exception\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Exception.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.stackTrace = [];\n        if (options.defaults) {\n            object.type = \"\";\n            object.message = \"\";\n            object.messageIsMarkdown = false;\n            object.isWarning = false;\n        }\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            object.type = message.type;\n        if (message.message != null && message.hasOwnProperty(\"message\"))\n            object.message = message.message;\n        if (message.stackTrace && message.stackTrace.length) {\n            object.stackTrace = [];\n            for (let j = 0; j < message.stackTrace.length; ++j)\n                object.stackTrace[j] = message.stackTrace[j];\n        }\n        if (message.messageIsMarkdown != null && message.hasOwnProperty(\"messageIsMarkdown\"))\n            object.messageIsMarkdown = message.messageIsMarkdown;\n        if (message.isWarning != null && message.hasOwnProperty(\"isWarning\"))\n            object.isWarning = message.isWarning;\n        return object;\n    };\n\n    /**\n     * Converts this Exception to JSON.\n     * @function toJSON\n     * @memberof Exception\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Exception.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Exception;\n})();\n\nexport const Favicon = $root.Favicon = (() => {\n\n    /**\n     * Properties of a Favicon.\n     * @exports IFavicon\n     * @interface IFavicon\n     * @property {string|null} [url] Favicon url\n     */\n\n    /**\n     * Constructs a new Favicon.\n     * @exports Favicon\n     * @classdesc Represents a Favicon.\n     * @implements IFavicon\n     * @constructor\n     * @param {IFavicon=} [properties] Properties to set\n     */\n    function Favicon(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Favicon url.\n     * @member {string} url\n     * @memberof Favicon\n     * @instance\n     */\n    Favicon.prototype.url = \"\";\n\n    /**\n     * Creates a new Favicon instance using the specified properties.\n     * @function create\n     * @memberof Favicon\n     * @static\n     * @param {IFavicon=} [properties] Properties to set\n     * @returns {Favicon} Favicon instance\n     */\n    Favicon.create = function create(properties) {\n        return new Favicon(properties);\n    };\n\n    /**\n     * Encodes the specified Favicon message. Does not implicitly {@link Favicon.verify|verify} messages.\n     * @function encode\n     * @memberof Favicon\n     * @static\n     * @param {IFavicon} message Favicon message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Favicon.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.url != null && Object.hasOwnProperty.call(message, \"url\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.url);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Favicon message, length delimited. Does not implicitly {@link Favicon.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Favicon\n     * @static\n     * @param {IFavicon} message Favicon message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Favicon.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Favicon message from the specified reader or buffer.\n     * @function decode\n     * @memberof Favicon\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Favicon} Favicon\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Favicon.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Favicon();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.url = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Favicon message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Favicon\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Favicon} Favicon\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Favicon.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Favicon message.\n     * @function verify\n     * @memberof Favicon\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Favicon.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            if (!$util.isString(message.url))\n                return \"url: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Favicon message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Favicon\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Favicon} Favicon\n     */\n    Favicon.fromObject = function fromObject(object) {\n        if (object instanceof $root.Favicon)\n            return object;\n        let message = new $root.Favicon();\n        if (object.url != null)\n            message.url = String(object.url);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Favicon message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Favicon\n     * @static\n     * @param {Favicon} message Favicon\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Favicon.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.url = \"\";\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            object.url = message.url;\n        return object;\n    };\n\n    /**\n     * Converts this Favicon to JSON.\n     * @function toJSON\n     * @memberof Favicon\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Favicon.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Favicon;\n})();\n\nexport const FileUploader = $root.FileUploader = (() => {\n\n    /**\n     * Properties of a FileUploader.\n     * @exports IFileUploader\n     * @interface IFileUploader\n     * @property {string|null} [id] FileUploader id\n     * @property {string|null} [label] FileUploader label\n     * @property {Array.<string>|null} [type] FileUploader type\n     * @property {number|null} [maxUploadSizeMb] FileUploader maxUploadSizeMb\n     * @property {boolean|null} [multipleFiles] FileUploader multipleFiles\n     */\n\n    /**\n     * Constructs a new FileUploader.\n     * @exports FileUploader\n     * @classdesc Represents a FileUploader.\n     * @implements IFileUploader\n     * @constructor\n     * @param {IFileUploader=} [properties] Properties to set\n     */\n    function FileUploader(properties) {\n        this.type = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * FileUploader id.\n     * @member {string} id\n     * @memberof FileUploader\n     * @instance\n     */\n    FileUploader.prototype.id = \"\";\n\n    /**\n     * FileUploader label.\n     * @member {string} label\n     * @memberof FileUploader\n     * @instance\n     */\n    FileUploader.prototype.label = \"\";\n\n    /**\n     * FileUploader type.\n     * @member {Array.<string>} type\n     * @memberof FileUploader\n     * @instance\n     */\n    FileUploader.prototype.type = $util.emptyArray;\n\n    /**\n     * FileUploader maxUploadSizeMb.\n     * @member {number} maxUploadSizeMb\n     * @memberof FileUploader\n     * @instance\n     */\n    FileUploader.prototype.maxUploadSizeMb = 0;\n\n    /**\n     * FileUploader multipleFiles.\n     * @member {boolean} multipleFiles\n     * @memberof FileUploader\n     * @instance\n     */\n    FileUploader.prototype.multipleFiles = false;\n\n    /**\n     * Creates a new FileUploader instance using the specified properties.\n     * @function create\n     * @memberof FileUploader\n     * @static\n     * @param {IFileUploader=} [properties] Properties to set\n     * @returns {FileUploader} FileUploader instance\n     */\n    FileUploader.create = function create(properties) {\n        return new FileUploader(properties);\n    };\n\n    /**\n     * Encodes the specified FileUploader message. Does not implicitly {@link FileUploader.verify|verify} messages.\n     * @function encode\n     * @memberof FileUploader\n     * @static\n     * @param {IFileUploader} message FileUploader message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    FileUploader.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message.type != null && message.type.length)\n            for (let i = 0; i < message.type.length; ++i)\n                writer.uint32(/* id 3, wireType 2 =*/26).string(message.type[i]);\n        if (message.maxUploadSizeMb != null && Object.hasOwnProperty.call(message, \"maxUploadSizeMb\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.maxUploadSizeMb);\n        if (message.multipleFiles != null && Object.hasOwnProperty.call(message, \"multipleFiles\"))\n            writer.uint32(/* id 6, wireType 0 =*/48).bool(message.multipleFiles);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified FileUploader message, length delimited. Does not implicitly {@link FileUploader.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof FileUploader\n     * @static\n     * @param {IFileUploader} message FileUploader message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    FileUploader.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a FileUploader message from the specified reader or buffer.\n     * @function decode\n     * @memberof FileUploader\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {FileUploader} FileUploader\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    FileUploader.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.FileUploader();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                if (!(message.type && message.type.length))\n                    message.type = [];\n                message.type.push(reader.string());\n                break;\n            case 4:\n                message.maxUploadSizeMb = reader.int32();\n                break;\n            case 6:\n                message.multipleFiles = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a FileUploader message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof FileUploader\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {FileUploader} FileUploader\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    FileUploader.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a FileUploader message.\n     * @function verify\n     * @memberof FileUploader\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    FileUploader.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message.type != null && message.hasOwnProperty(\"type\")) {\n            if (!Array.isArray(message.type))\n                return \"type: array expected\";\n            for (let i = 0; i < message.type.length; ++i)\n                if (!$util.isString(message.type[i]))\n                    return \"type: string[] expected\";\n        }\n        if (message.maxUploadSizeMb != null && message.hasOwnProperty(\"maxUploadSizeMb\"))\n            if (!$util.isInteger(message.maxUploadSizeMb))\n                return \"maxUploadSizeMb: integer expected\";\n        if (message.multipleFiles != null && message.hasOwnProperty(\"multipleFiles\"))\n            if (typeof message.multipleFiles !== \"boolean\")\n                return \"multipleFiles: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a FileUploader message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof FileUploader\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {FileUploader} FileUploader\n     */\n    FileUploader.fromObject = function fromObject(object) {\n        if (object instanceof $root.FileUploader)\n            return object;\n        let message = new $root.FileUploader();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object.type) {\n            if (!Array.isArray(object.type))\n                throw TypeError(\".FileUploader.type: array expected\");\n            message.type = [];\n            for (let i = 0; i < object.type.length; ++i)\n                message.type[i] = String(object.type[i]);\n        }\n        if (object.maxUploadSizeMb != null)\n            message.maxUploadSizeMb = object.maxUploadSizeMb | 0;\n        if (object.multipleFiles != null)\n            message.multipleFiles = Boolean(object.multipleFiles);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a FileUploader message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof FileUploader\n     * @static\n     * @param {FileUploader} message FileUploader\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    FileUploader.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.type = [];\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object.maxUploadSizeMb = 0;\n            object.multipleFiles = false;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message.type && message.type.length) {\n            object.type = [];\n            for (let j = 0; j < message.type.length; ++j)\n                object.type[j] = message.type[j];\n        }\n        if (message.maxUploadSizeMb != null && message.hasOwnProperty(\"maxUploadSizeMb\"))\n            object.maxUploadSizeMb = message.maxUploadSizeMb;\n        if (message.multipleFiles != null && message.hasOwnProperty(\"multipleFiles\"))\n            object.multipleFiles = message.multipleFiles;\n        return object;\n    };\n\n    /**\n     * Converts this FileUploader to JSON.\n     * @function toJSON\n     * @memberof FileUploader\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    FileUploader.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return FileUploader;\n})();\n\nexport const ForwardMsg = $root.ForwardMsg = (() => {\n\n    /**\n     * Properties of a ForwardMsg.\n     * @exports IForwardMsg\n     * @interface IForwardMsg\n     * @property {string|null} [hash] ForwardMsg hash\n     * @property {IForwardMsgMetadata|null} [metadata] ForwardMsg metadata\n     * @property {IInitialize|null} [initialize] ForwardMsg initialize\n     * @property {INewReport|null} [newReport] ForwardMsg newReport\n     * @property {IDelta|null} [delta] ForwardMsg delta\n     * @property {IReportProperties|null} [updateReportProperties] ForwardMsg updateReportProperties\n     * @property {ForwardMsg.ReportFinishedStatus|null} [reportFinished] ForwardMsg reportFinished\n     * @property {number|null} [uploadReportProgress] ForwardMsg uploadReportProgress\n     * @property {string|null} [reportUploaded] ForwardMsg reportUploaded\n     * @property {ISessionState|null} [sessionStateChanged] ForwardMsg sessionStateChanged\n     * @property {ISessionEvent|null} [sessionEvent] ForwardMsg sessionEvent\n     * @property {string|null} [refHash] ForwardMsg refHash\n     */\n\n    /**\n     * Constructs a new ForwardMsg.\n     * @exports ForwardMsg\n     * @classdesc Represents a ForwardMsg.\n     * @implements IForwardMsg\n     * @constructor\n     * @param {IForwardMsg=} [properties] Properties to set\n     */\n    function ForwardMsg(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ForwardMsg hash.\n     * @member {string} hash\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.hash = \"\";\n\n    /**\n     * ForwardMsg metadata.\n     * @member {IForwardMsgMetadata|null|undefined} metadata\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.metadata = null;\n\n    /**\n     * ForwardMsg initialize.\n     * @member {IInitialize|null|undefined} initialize\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.initialize = null;\n\n    /**\n     * ForwardMsg newReport.\n     * @member {INewReport|null|undefined} newReport\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.newReport = null;\n\n    /**\n     * ForwardMsg delta.\n     * @member {IDelta|null|undefined} delta\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.delta = null;\n\n    /**\n     * ForwardMsg updateReportProperties.\n     * @member {IReportProperties|null|undefined} updateReportProperties\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.updateReportProperties = null;\n\n    /**\n     * ForwardMsg reportFinished.\n     * @member {ForwardMsg.ReportFinishedStatus} reportFinished\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.reportFinished = 0;\n\n    /**\n     * ForwardMsg uploadReportProgress.\n     * @member {number} uploadReportProgress\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.uploadReportProgress = 0;\n\n    /**\n     * ForwardMsg reportUploaded.\n     * @member {string} reportUploaded\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.reportUploaded = \"\";\n\n    /**\n     * ForwardMsg sessionStateChanged.\n     * @member {ISessionState|null|undefined} sessionStateChanged\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.sessionStateChanged = null;\n\n    /**\n     * ForwardMsg sessionEvent.\n     * @member {ISessionEvent|null|undefined} sessionEvent\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.sessionEvent = null;\n\n    /**\n     * ForwardMsg refHash.\n     * @member {string} refHash\n     * @memberof ForwardMsg\n     * @instance\n     */\n    ForwardMsg.prototype.refHash = \"\";\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * ForwardMsg type.\n     * @member {\"initialize\"|\"newReport\"|\"delta\"|\"updateReportProperties\"|\"reportFinished\"|\"uploadReportProgress\"|\"reportUploaded\"|\"sessionStateChanged\"|\"sessionEvent\"|\"refHash\"|undefined} type\n     * @memberof ForwardMsg\n     * @instance\n     */\n    Object.defineProperty(ForwardMsg.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"initialize\", \"newReport\", \"delta\", \"updateReportProperties\", \"reportFinished\", \"uploadReportProgress\", \"reportUploaded\", \"sessionStateChanged\", \"sessionEvent\", \"refHash\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new ForwardMsg instance using the specified properties.\n     * @function create\n     * @memberof ForwardMsg\n     * @static\n     * @param {IForwardMsg=} [properties] Properties to set\n     * @returns {ForwardMsg} ForwardMsg instance\n     */\n    ForwardMsg.create = function create(properties) {\n        return new ForwardMsg(properties);\n    };\n\n    /**\n     * Encodes the specified ForwardMsg message. Does not implicitly {@link ForwardMsg.verify|verify} messages.\n     * @function encode\n     * @memberof ForwardMsg\n     * @static\n     * @param {IForwardMsg} message ForwardMsg message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ForwardMsg.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.hash != null && Object.hasOwnProperty.call(message, \"hash\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.hash);\n        if (message.metadata != null && Object.hasOwnProperty.call(message, \"metadata\"))\n            $root.ForwardMsgMetadata.encode(message.metadata, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.initialize != null && Object.hasOwnProperty.call(message, \"initialize\"))\n            $root.Initialize.encode(message.initialize, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.newReport != null && Object.hasOwnProperty.call(message, \"newReport\"))\n            $root.NewReport.encode(message.newReport, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n        if (message.delta != null && Object.hasOwnProperty.call(message, \"delta\"))\n            $root.Delta.encode(message.delta, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();\n        if (message.reportFinished != null && Object.hasOwnProperty.call(message, \"reportFinished\"))\n            writer.uint32(/* id 6, wireType 0 =*/48).int32(message.reportFinished);\n        if (message.uploadReportProgress != null && Object.hasOwnProperty.call(message, \"uploadReportProgress\"))\n            writer.uint32(/* id 7, wireType 0 =*/56).uint32(message.uploadReportProgress);\n        if (message.reportUploaded != null && Object.hasOwnProperty.call(message, \"reportUploaded\"))\n            writer.uint32(/* id 8, wireType 2 =*/66).string(message.reportUploaded);\n        if (message.sessionStateChanged != null && Object.hasOwnProperty.call(message, \"sessionStateChanged\"))\n            $root.SessionState.encode(message.sessionStateChanged, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();\n        if (message.sessionEvent != null && Object.hasOwnProperty.call(message, \"sessionEvent\"))\n            $root.SessionEvent.encode(message.sessionEvent, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();\n        if (message.refHash != null && Object.hasOwnProperty.call(message, \"refHash\"))\n            writer.uint32(/* id 11, wireType 2 =*/90).string(message.refHash);\n        if (message.updateReportProperties != null && Object.hasOwnProperty.call(message, \"updateReportProperties\"))\n            $root.ReportProperties.encode(message.updateReportProperties, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ForwardMsg message, length delimited. Does not implicitly {@link ForwardMsg.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ForwardMsg\n     * @static\n     * @param {IForwardMsg} message ForwardMsg message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ForwardMsg.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a ForwardMsg message from the specified reader or buffer.\n     * @function decode\n     * @memberof ForwardMsg\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ForwardMsg} ForwardMsg\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ForwardMsg.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ForwardMsg();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.hash = reader.string();\n                break;\n            case 2:\n                message.metadata = $root.ForwardMsgMetadata.decode(reader, reader.uint32());\n                break;\n            case 3:\n                message.initialize = $root.Initialize.decode(reader, reader.uint32());\n                break;\n            case 4:\n                message.newReport = $root.NewReport.decode(reader, reader.uint32());\n                break;\n            case 5:\n                message.delta = $root.Delta.decode(reader, reader.uint32());\n                break;\n            case 12:\n                message.updateReportProperties = $root.ReportProperties.decode(reader, reader.uint32());\n                break;\n            case 6:\n                message.reportFinished = reader.int32();\n                break;\n            case 7:\n                message.uploadReportProgress = reader.uint32();\n                break;\n            case 8:\n                message.reportUploaded = reader.string();\n                break;\n            case 9:\n                message.sessionStateChanged = $root.SessionState.decode(reader, reader.uint32());\n                break;\n            case 10:\n                message.sessionEvent = $root.SessionEvent.decode(reader, reader.uint32());\n                break;\n            case 11:\n                message.refHash = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a ForwardMsg message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ForwardMsg\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ForwardMsg} ForwardMsg\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ForwardMsg.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a ForwardMsg message.\n     * @function verify\n     * @memberof ForwardMsg\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ForwardMsg.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.hash != null && message.hasOwnProperty(\"hash\"))\n            if (!$util.isString(message.hash))\n                return \"hash: string expected\";\n        if (message.metadata != null && message.hasOwnProperty(\"metadata\")) {\n            let error = $root.ForwardMsgMetadata.verify(message.metadata);\n            if (error)\n                return \"metadata.\" + error;\n        }\n        if (message.initialize != null && message.hasOwnProperty(\"initialize\")) {\n            properties.type = 1;\n            {\n                let error = $root.Initialize.verify(message.initialize);\n                if (error)\n                    return \"initialize.\" + error;\n            }\n        }\n        if (message.newReport != null && message.hasOwnProperty(\"newReport\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.NewReport.verify(message.newReport);\n                if (error)\n                    return \"newReport.\" + error;\n            }\n        }\n        if (message.delta != null && message.hasOwnProperty(\"delta\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Delta.verify(message.delta);\n                if (error)\n                    return \"delta.\" + error;\n            }\n        }\n        if (message.updateReportProperties != null && message.hasOwnProperty(\"updateReportProperties\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.ReportProperties.verify(message.updateReportProperties);\n                if (error)\n                    return \"updateReportProperties.\" + error;\n            }\n        }\n        if (message.reportFinished != null && message.hasOwnProperty(\"reportFinished\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            switch (message.reportFinished) {\n            default:\n                return \"reportFinished: enum value expected\";\n            case 0:\n            case 1:\n                break;\n            }\n        }\n        if (message.uploadReportProgress != null && message.hasOwnProperty(\"uploadReportProgress\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (!$util.isInteger(message.uploadReportProgress))\n                return \"uploadReportProgress: integer expected\";\n        }\n        if (message.reportUploaded != null && message.hasOwnProperty(\"reportUploaded\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (!$util.isString(message.reportUploaded))\n                return \"reportUploaded: string expected\";\n        }\n        if (message.sessionStateChanged != null && message.hasOwnProperty(\"sessionStateChanged\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.SessionState.verify(message.sessionStateChanged);\n                if (error)\n                    return \"sessionStateChanged.\" + error;\n            }\n        }\n        if (message.sessionEvent != null && message.hasOwnProperty(\"sessionEvent\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.SessionEvent.verify(message.sessionEvent);\n                if (error)\n                    return \"sessionEvent.\" + error;\n            }\n        }\n        if (message.refHash != null && message.hasOwnProperty(\"refHash\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (!$util.isString(message.refHash))\n                return \"refHash: string expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a ForwardMsg message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ForwardMsg\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ForwardMsg} ForwardMsg\n     */\n    ForwardMsg.fromObject = function fromObject(object) {\n        if (object instanceof $root.ForwardMsg)\n            return object;\n        let message = new $root.ForwardMsg();\n        if (object.hash != null)\n            message.hash = String(object.hash);\n        if (object.metadata != null) {\n            if (typeof object.metadata !== \"object\")\n                throw TypeError(\".ForwardMsg.metadata: object expected\");\n            message.metadata = $root.ForwardMsgMetadata.fromObject(object.metadata);\n        }\n        if (object.initialize != null) {\n            if (typeof object.initialize !== \"object\")\n                throw TypeError(\".ForwardMsg.initialize: object expected\");\n            message.initialize = $root.Initialize.fromObject(object.initialize);\n        }\n        if (object.newReport != null) {\n            if (typeof object.newReport !== \"object\")\n                throw TypeError(\".ForwardMsg.newReport: object expected\");\n            message.newReport = $root.NewReport.fromObject(object.newReport);\n        }\n        if (object.delta != null) {\n            if (typeof object.delta !== \"object\")\n                throw TypeError(\".ForwardMsg.delta: object expected\");\n            message.delta = $root.Delta.fromObject(object.delta);\n        }\n        if (object.updateReportProperties != null) {\n            if (typeof object.updateReportProperties !== \"object\")\n                throw TypeError(\".ForwardMsg.updateReportProperties: object expected\");\n            message.updateReportProperties = $root.ReportProperties.fromObject(object.updateReportProperties);\n        }\n        switch (object.reportFinished) {\n        case \"FINISHED_SUCCESSFULLY\":\n        case 0:\n            message.reportFinished = 0;\n            break;\n        case \"FINISHED_WITH_COMPILE_ERROR\":\n        case 1:\n            message.reportFinished = 1;\n            break;\n        }\n        if (object.uploadReportProgress != null)\n            message.uploadReportProgress = object.uploadReportProgress >>> 0;\n        if (object.reportUploaded != null)\n            message.reportUploaded = String(object.reportUploaded);\n        if (object.sessionStateChanged != null) {\n            if (typeof object.sessionStateChanged !== \"object\")\n                throw TypeError(\".ForwardMsg.sessionStateChanged: object expected\");\n            message.sessionStateChanged = $root.SessionState.fromObject(object.sessionStateChanged);\n        }\n        if (object.sessionEvent != null) {\n            if (typeof object.sessionEvent !== \"object\")\n                throw TypeError(\".ForwardMsg.sessionEvent: object expected\");\n            message.sessionEvent = $root.SessionEvent.fromObject(object.sessionEvent);\n        }\n        if (object.refHash != null)\n            message.refHash = String(object.refHash);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a ForwardMsg message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ForwardMsg\n     * @static\n     * @param {ForwardMsg} message ForwardMsg\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ForwardMsg.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.hash = \"\";\n            object.metadata = null;\n        }\n        if (message.hash != null && message.hasOwnProperty(\"hash\"))\n            object.hash = message.hash;\n        if (message.metadata != null && message.hasOwnProperty(\"metadata\"))\n            object.metadata = $root.ForwardMsgMetadata.toObject(message.metadata, options);\n        if (message.initialize != null && message.hasOwnProperty(\"initialize\")) {\n            object.initialize = $root.Initialize.toObject(message.initialize, options);\n            if (options.oneofs)\n                object.type = \"initialize\";\n        }\n        if (message.newReport != null && message.hasOwnProperty(\"newReport\")) {\n            object.newReport = $root.NewReport.toObject(message.newReport, options);\n            if (options.oneofs)\n                object.type = \"newReport\";\n        }\n        if (message.delta != null && message.hasOwnProperty(\"delta\")) {\n            object.delta = $root.Delta.toObject(message.delta, options);\n            if (options.oneofs)\n                object.type = \"delta\";\n        }\n        if (message.reportFinished != null && message.hasOwnProperty(\"reportFinished\")) {\n            object.reportFinished = options.enums === String ? $root.ForwardMsg.ReportFinishedStatus[message.reportFinished] : message.reportFinished;\n            if (options.oneofs)\n                object.type = \"reportFinished\";\n        }\n        if (message.uploadReportProgress != null && message.hasOwnProperty(\"uploadReportProgress\")) {\n            object.uploadReportProgress = message.uploadReportProgress;\n            if (options.oneofs)\n                object.type = \"uploadReportProgress\";\n        }\n        if (message.reportUploaded != null && message.hasOwnProperty(\"reportUploaded\")) {\n            object.reportUploaded = message.reportUploaded;\n            if (options.oneofs)\n                object.type = \"reportUploaded\";\n        }\n        if (message.sessionStateChanged != null && message.hasOwnProperty(\"sessionStateChanged\")) {\n            object.sessionStateChanged = $root.SessionState.toObject(message.sessionStateChanged, options);\n            if (options.oneofs)\n                object.type = \"sessionStateChanged\";\n        }\n        if (message.sessionEvent != null && message.hasOwnProperty(\"sessionEvent\")) {\n            object.sessionEvent = $root.SessionEvent.toObject(message.sessionEvent, options);\n            if (options.oneofs)\n                object.type = \"sessionEvent\";\n        }\n        if (message.refHash != null && message.hasOwnProperty(\"refHash\")) {\n            object.refHash = message.refHash;\n            if (options.oneofs)\n                object.type = \"refHash\";\n        }\n        if (message.updateReportProperties != null && message.hasOwnProperty(\"updateReportProperties\")) {\n            object.updateReportProperties = $root.ReportProperties.toObject(message.updateReportProperties, options);\n            if (options.oneofs)\n                object.type = \"updateReportProperties\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this ForwardMsg to JSON.\n     * @function toJSON\n     * @memberof ForwardMsg\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ForwardMsg.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * ReportFinishedStatus enum.\n     * @name ForwardMsg.ReportFinishedStatus\n     * @enum {number}\n     * @property {number} FINISHED_SUCCESSFULLY=0 FINISHED_SUCCESSFULLY value\n     * @property {number} FINISHED_WITH_COMPILE_ERROR=1 FINISHED_WITH_COMPILE_ERROR value\n     */\n    ForwardMsg.ReportFinishedStatus = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"FINISHED_SUCCESSFULLY\"] = 0;\n        values[valuesById[1] = \"FINISHED_WITH_COMPILE_ERROR\"] = 1;\n        return values;\n    })();\n\n    return ForwardMsg;\n})();\n\nexport const ForwardMsgMetadata = $root.ForwardMsgMetadata = (() => {\n\n    /**\n     * Properties of a ForwardMsgMetadata.\n     * @exports IForwardMsgMetadata\n     * @interface IForwardMsgMetadata\n     * @property {boolean|null} [cacheable] ForwardMsgMetadata cacheable\n     * @property {number|null} [deltaId] ForwardMsgMetadata deltaId\n     * @property {IBlockPath|null} [parentBlock] ForwardMsgMetadata parentBlock\n     * @property {IElementDimensionSpec|null} [elementDimensionSpec] ForwardMsgMetadata elementDimensionSpec\n     */\n\n    /**\n     * Constructs a new ForwardMsgMetadata.\n     * @exports ForwardMsgMetadata\n     * @classdesc Represents a ForwardMsgMetadata.\n     * @implements IForwardMsgMetadata\n     * @constructor\n     * @param {IForwardMsgMetadata=} [properties] Properties to set\n     */\n    function ForwardMsgMetadata(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ForwardMsgMetadata cacheable.\n     * @member {boolean} cacheable\n     * @memberof ForwardMsgMetadata\n     * @instance\n     */\n    ForwardMsgMetadata.prototype.cacheable = false;\n\n    /**\n     * ForwardMsgMetadata deltaId.\n     * @member {number} deltaId\n     * @memberof ForwardMsgMetadata\n     * @instance\n     */\n    ForwardMsgMetadata.prototype.deltaId = 0;\n\n    /**\n     * ForwardMsgMetadata parentBlock.\n     * @member {IBlockPath|null|undefined} parentBlock\n     * @memberof ForwardMsgMetadata\n     * @instance\n     */\n    ForwardMsgMetadata.prototype.parentBlock = null;\n\n    /**\n     * ForwardMsgMetadata elementDimensionSpec.\n     * @member {IElementDimensionSpec|null|undefined} elementDimensionSpec\n     * @memberof ForwardMsgMetadata\n     * @instance\n     */\n    ForwardMsgMetadata.prototype.elementDimensionSpec = null;\n\n    /**\n     * Creates a new ForwardMsgMetadata instance using the specified properties.\n     * @function create\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {IForwardMsgMetadata=} [properties] Properties to set\n     * @returns {ForwardMsgMetadata} ForwardMsgMetadata instance\n     */\n    ForwardMsgMetadata.create = function create(properties) {\n        return new ForwardMsgMetadata(properties);\n    };\n\n    /**\n     * Encodes the specified ForwardMsgMetadata message. Does not implicitly {@link ForwardMsgMetadata.verify|verify} messages.\n     * @function encode\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {IForwardMsgMetadata} message ForwardMsgMetadata message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ForwardMsgMetadata.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.cacheable != null && Object.hasOwnProperty.call(message, \"cacheable\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).bool(message.cacheable);\n        if (message.deltaId != null && Object.hasOwnProperty.call(message, \"deltaId\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.deltaId);\n        if (message.parentBlock != null && Object.hasOwnProperty.call(message, \"parentBlock\"))\n            $root.BlockPath.encode(message.parentBlock, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.elementDimensionSpec != null && Object.hasOwnProperty.call(message, \"elementDimensionSpec\"))\n            $root.ElementDimensionSpec.encode(message.elementDimensionSpec, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ForwardMsgMetadata message, length delimited. Does not implicitly {@link ForwardMsgMetadata.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {IForwardMsgMetadata} message ForwardMsgMetadata message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ForwardMsgMetadata.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a ForwardMsgMetadata message from the specified reader or buffer.\n     * @function decode\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ForwardMsgMetadata} ForwardMsgMetadata\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ForwardMsgMetadata.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ForwardMsgMetadata();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.cacheable = reader.bool();\n                break;\n            case 2:\n                message.deltaId = reader.uint32();\n                break;\n            case 3:\n                message.parentBlock = $root.BlockPath.decode(reader, reader.uint32());\n                break;\n            case 4:\n                message.elementDimensionSpec = $root.ElementDimensionSpec.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a ForwardMsgMetadata message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ForwardMsgMetadata} ForwardMsgMetadata\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ForwardMsgMetadata.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a ForwardMsgMetadata message.\n     * @function verify\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ForwardMsgMetadata.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.cacheable != null && message.hasOwnProperty(\"cacheable\"))\n            if (typeof message.cacheable !== \"boolean\")\n                return \"cacheable: boolean expected\";\n        if (message.deltaId != null && message.hasOwnProperty(\"deltaId\"))\n            if (!$util.isInteger(message.deltaId))\n                return \"deltaId: integer expected\";\n        if (message.parentBlock != null && message.hasOwnProperty(\"parentBlock\")) {\n            let error = $root.BlockPath.verify(message.parentBlock);\n            if (error)\n                return \"parentBlock.\" + error;\n        }\n        if (message.elementDimensionSpec != null && message.hasOwnProperty(\"elementDimensionSpec\")) {\n            let error = $root.ElementDimensionSpec.verify(message.elementDimensionSpec);\n            if (error)\n                return \"elementDimensionSpec.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates a ForwardMsgMetadata message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ForwardMsgMetadata} ForwardMsgMetadata\n     */\n    ForwardMsgMetadata.fromObject = function fromObject(object) {\n        if (object instanceof $root.ForwardMsgMetadata)\n            return object;\n        let message = new $root.ForwardMsgMetadata();\n        if (object.cacheable != null)\n            message.cacheable = Boolean(object.cacheable);\n        if (object.deltaId != null)\n            message.deltaId = object.deltaId >>> 0;\n        if (object.parentBlock != null) {\n            if (typeof object.parentBlock !== \"object\")\n                throw TypeError(\".ForwardMsgMetadata.parentBlock: object expected\");\n            message.parentBlock = $root.BlockPath.fromObject(object.parentBlock);\n        }\n        if (object.elementDimensionSpec != null) {\n            if (typeof object.elementDimensionSpec !== \"object\")\n                throw TypeError(\".ForwardMsgMetadata.elementDimensionSpec: object expected\");\n            message.elementDimensionSpec = $root.ElementDimensionSpec.fromObject(object.elementDimensionSpec);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a ForwardMsgMetadata message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ForwardMsgMetadata\n     * @static\n     * @param {ForwardMsgMetadata} message ForwardMsgMetadata\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ForwardMsgMetadata.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.cacheable = false;\n            object.deltaId = 0;\n            object.parentBlock = null;\n            object.elementDimensionSpec = null;\n        }\n        if (message.cacheable != null && message.hasOwnProperty(\"cacheable\"))\n            object.cacheable = message.cacheable;\n        if (message.deltaId != null && message.hasOwnProperty(\"deltaId\"))\n            object.deltaId = message.deltaId;\n        if (message.parentBlock != null && message.hasOwnProperty(\"parentBlock\"))\n            object.parentBlock = $root.BlockPath.toObject(message.parentBlock, options);\n        if (message.elementDimensionSpec != null && message.hasOwnProperty(\"elementDimensionSpec\"))\n            object.elementDimensionSpec = $root.ElementDimensionSpec.toObject(message.elementDimensionSpec, options);\n        return object;\n    };\n\n    /**\n     * Converts this ForwardMsgMetadata to JSON.\n     * @function toJSON\n     * @memberof ForwardMsgMetadata\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ForwardMsgMetadata.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ForwardMsgMetadata;\n})();\n\nexport const ElementDimensionSpec = $root.ElementDimensionSpec = (() => {\n\n    /**\n     * Properties of an ElementDimensionSpec.\n     * @exports IElementDimensionSpec\n     * @interface IElementDimensionSpec\n     * @property {number|null} [width] ElementDimensionSpec width\n     * @property {number|null} [height] ElementDimensionSpec height\n     */\n\n    /**\n     * Constructs a new ElementDimensionSpec.\n     * @exports ElementDimensionSpec\n     * @classdesc Represents an ElementDimensionSpec.\n     * @implements IElementDimensionSpec\n     * @constructor\n     * @param {IElementDimensionSpec=} [properties] Properties to set\n     */\n    function ElementDimensionSpec(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ElementDimensionSpec width.\n     * @member {number} width\n     * @memberof ElementDimensionSpec\n     * @instance\n     */\n    ElementDimensionSpec.prototype.width = 0;\n\n    /**\n     * ElementDimensionSpec height.\n     * @member {number} height\n     * @memberof ElementDimensionSpec\n     * @instance\n     */\n    ElementDimensionSpec.prototype.height = 0;\n\n    /**\n     * Creates a new ElementDimensionSpec instance using the specified properties.\n     * @function create\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {IElementDimensionSpec=} [properties] Properties to set\n     * @returns {ElementDimensionSpec} ElementDimensionSpec instance\n     */\n    ElementDimensionSpec.create = function create(properties) {\n        return new ElementDimensionSpec(properties);\n    };\n\n    /**\n     * Encodes the specified ElementDimensionSpec message. Does not implicitly {@link ElementDimensionSpec.verify|verify} messages.\n     * @function encode\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {IElementDimensionSpec} message ElementDimensionSpec message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ElementDimensionSpec.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.width != null && Object.hasOwnProperty.call(message, \"width\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.width);\n        if (message.height != null && Object.hasOwnProperty.call(message, \"height\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.height);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ElementDimensionSpec message, length delimited. Does not implicitly {@link ElementDimensionSpec.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {IElementDimensionSpec} message ElementDimensionSpec message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ElementDimensionSpec.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an ElementDimensionSpec message from the specified reader or buffer.\n     * @function decode\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ElementDimensionSpec} ElementDimensionSpec\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ElementDimensionSpec.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ElementDimensionSpec();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.width = reader.uint32();\n                break;\n            case 2:\n                message.height = reader.uint32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an ElementDimensionSpec message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ElementDimensionSpec} ElementDimensionSpec\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ElementDimensionSpec.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an ElementDimensionSpec message.\n     * @function verify\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ElementDimensionSpec.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            if (!$util.isInteger(message.width))\n                return \"width: integer expected\";\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            if (!$util.isInteger(message.height))\n                return \"height: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates an ElementDimensionSpec message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ElementDimensionSpec} ElementDimensionSpec\n     */\n    ElementDimensionSpec.fromObject = function fromObject(object) {\n        if (object instanceof $root.ElementDimensionSpec)\n            return object;\n        let message = new $root.ElementDimensionSpec();\n        if (object.width != null)\n            message.width = object.width >>> 0;\n        if (object.height != null)\n            message.height = object.height >>> 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an ElementDimensionSpec message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ElementDimensionSpec\n     * @static\n     * @param {ElementDimensionSpec} message ElementDimensionSpec\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ElementDimensionSpec.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.width = 0;\n            object.height = 0;\n        }\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            object.width = message.width;\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            object.height = message.height;\n        return object;\n    };\n\n    /**\n     * Converts this ElementDimensionSpec to JSON.\n     * @function toJSON\n     * @memberof ElementDimensionSpec\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ElementDimensionSpec.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ElementDimensionSpec;\n})();\n\nexport const GraphVizChart = $root.GraphVizChart = (() => {\n\n    /**\n     * Properties of a GraphVizChart.\n     * @exports IGraphVizChart\n     * @interface IGraphVizChart\n     * @property {string|null} [spec] GraphVizChart spec\n     * @property {boolean|null} [useContainerWidth] GraphVizChart useContainerWidth\n     */\n\n    /**\n     * Constructs a new GraphVizChart.\n     * @exports GraphVizChart\n     * @classdesc Represents a GraphVizChart.\n     * @implements IGraphVizChart\n     * @constructor\n     * @param {IGraphVizChart=} [properties] Properties to set\n     */\n    function GraphVizChart(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * GraphVizChart spec.\n     * @member {string} spec\n     * @memberof GraphVizChart\n     * @instance\n     */\n    GraphVizChart.prototype.spec = \"\";\n\n    /**\n     * GraphVizChart useContainerWidth.\n     * @member {boolean} useContainerWidth\n     * @memberof GraphVizChart\n     * @instance\n     */\n    GraphVizChart.prototype.useContainerWidth = false;\n\n    /**\n     * Creates a new GraphVizChart instance using the specified properties.\n     * @function create\n     * @memberof GraphVizChart\n     * @static\n     * @param {IGraphVizChart=} [properties] Properties to set\n     * @returns {GraphVizChart} GraphVizChart instance\n     */\n    GraphVizChart.create = function create(properties) {\n        return new GraphVizChart(properties);\n    };\n\n    /**\n     * Encodes the specified GraphVizChart message. Does not implicitly {@link GraphVizChart.verify|verify} messages.\n     * @function encode\n     * @memberof GraphVizChart\n     * @static\n     * @param {IGraphVizChart} message GraphVizChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    GraphVizChart.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.spec != null && Object.hasOwnProperty.call(message, \"spec\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.spec);\n        if (message.useContainerWidth != null && Object.hasOwnProperty.call(message, \"useContainerWidth\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).bool(message.useContainerWidth);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified GraphVizChart message, length delimited. Does not implicitly {@link GraphVizChart.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof GraphVizChart\n     * @static\n     * @param {IGraphVizChart} message GraphVizChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    GraphVizChart.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a GraphVizChart message from the specified reader or buffer.\n     * @function decode\n     * @memberof GraphVizChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {GraphVizChart} GraphVizChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    GraphVizChart.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.GraphVizChart();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.spec = reader.string();\n                break;\n            case 4:\n                message.useContainerWidth = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a GraphVizChart message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof GraphVizChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {GraphVizChart} GraphVizChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    GraphVizChart.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a GraphVizChart message.\n     * @function verify\n     * @memberof GraphVizChart\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    GraphVizChart.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            if (!$util.isString(message.spec))\n                return \"spec: string expected\";\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            if (typeof message.useContainerWidth !== \"boolean\")\n                return \"useContainerWidth: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a GraphVizChart message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof GraphVizChart\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {GraphVizChart} GraphVizChart\n     */\n    GraphVizChart.fromObject = function fromObject(object) {\n        if (object instanceof $root.GraphVizChart)\n            return object;\n        let message = new $root.GraphVizChart();\n        if (object.spec != null)\n            message.spec = String(object.spec);\n        if (object.useContainerWidth != null)\n            message.useContainerWidth = Boolean(object.useContainerWidth);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a GraphVizChart message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof GraphVizChart\n     * @static\n     * @param {GraphVizChart} message GraphVizChart\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    GraphVizChart.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.spec = \"\";\n            object.useContainerWidth = false;\n        }\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            object.spec = message.spec;\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            object.useContainerWidth = message.useContainerWidth;\n        return object;\n    };\n\n    /**\n     * Converts this GraphVizChart to JSON.\n     * @function toJSON\n     * @memberof GraphVizChart\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    GraphVizChart.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return GraphVizChart;\n})();\n\nexport const IFrame = $root.IFrame = (() => {\n\n    /**\n     * Properties of a IFrame.\n     * @exports IIFrame\n     * @interface IIFrame\n     * @property {string|null} [src] IFrame src\n     * @property {string|null} [srcdoc] IFrame srcdoc\n     * @property {number|null} [width] IFrame width\n     * @property {boolean|null} [hasWidth] IFrame hasWidth\n     * @property {number|null} [height] IFrame height\n     * @property {boolean|null} [scrolling] IFrame scrolling\n     */\n\n    /**\n     * Constructs a new IFrame.\n     * @exports IFrame\n     * @classdesc Represents a IFrame.\n     * @implements IIFrame\n     * @constructor\n     * @param {IIFrame=} [properties] Properties to set\n     */\n    function IFrame(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * IFrame src.\n     * @member {string} src\n     * @memberof IFrame\n     * @instance\n     */\n    IFrame.prototype.src = \"\";\n\n    /**\n     * IFrame srcdoc.\n     * @member {string} srcdoc\n     * @memberof IFrame\n     * @instance\n     */\n    IFrame.prototype.srcdoc = \"\";\n\n    /**\n     * IFrame width.\n     * @member {number} width\n     * @memberof IFrame\n     * @instance\n     */\n    IFrame.prototype.width = 0;\n\n    /**\n     * IFrame hasWidth.\n     * @member {boolean} hasWidth\n     * @memberof IFrame\n     * @instance\n     */\n    IFrame.prototype.hasWidth = false;\n\n    /**\n     * IFrame height.\n     * @member {number} height\n     * @memberof IFrame\n     * @instance\n     */\n    IFrame.prototype.height = 0;\n\n    /**\n     * IFrame scrolling.\n     * @member {boolean} scrolling\n     * @memberof IFrame\n     * @instance\n     */\n    IFrame.prototype.scrolling = false;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * IFrame type.\n     * @member {\"src\"|\"srcdoc\"|undefined} type\n     * @memberof IFrame\n     * @instance\n     */\n    Object.defineProperty(IFrame.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"src\", \"srcdoc\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new IFrame instance using the specified properties.\n     * @function create\n     * @memberof IFrame\n     * @static\n     * @param {IIFrame=} [properties] Properties to set\n     * @returns {IFrame} IFrame instance\n     */\n    IFrame.create = function create(properties) {\n        return new IFrame(properties);\n    };\n\n    /**\n     * Encodes the specified IFrame message. Does not implicitly {@link IFrame.verify|verify} messages.\n     * @function encode\n     * @memberof IFrame\n     * @static\n     * @param {IIFrame} message IFrame message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    IFrame.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.src != null && Object.hasOwnProperty.call(message, \"src\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.src);\n        if (message.srcdoc != null && Object.hasOwnProperty.call(message, \"srcdoc\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.srcdoc);\n        if (message.width != null && Object.hasOwnProperty.call(message, \"width\"))\n            writer.uint32(/* id 3, wireType 5 =*/29).float(message.width);\n        if (message.hasWidth != null && Object.hasOwnProperty.call(message, \"hasWidth\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).bool(message.hasWidth);\n        if (message.height != null && Object.hasOwnProperty.call(message, \"height\"))\n            writer.uint32(/* id 5, wireType 5 =*/45).float(message.height);\n        if (message.scrolling != null && Object.hasOwnProperty.call(message, \"scrolling\"))\n            writer.uint32(/* id 7, wireType 0 =*/56).bool(message.scrolling);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified IFrame message, length delimited. Does not implicitly {@link IFrame.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof IFrame\n     * @static\n     * @param {IIFrame} message IFrame message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    IFrame.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a IFrame message from the specified reader or buffer.\n     * @function decode\n     * @memberof IFrame\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {IFrame} IFrame\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    IFrame.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.IFrame();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.src = reader.string();\n                break;\n            case 2:\n                message.srcdoc = reader.string();\n                break;\n            case 3:\n                message.width = reader.float();\n                break;\n            case 4:\n                message.hasWidth = reader.bool();\n                break;\n            case 5:\n                message.height = reader.float();\n                break;\n            case 7:\n                message.scrolling = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a IFrame message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof IFrame\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {IFrame} IFrame\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    IFrame.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a IFrame message.\n     * @function verify\n     * @memberof IFrame\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    IFrame.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.src != null && message.hasOwnProperty(\"src\")) {\n            properties.type = 1;\n            if (!$util.isString(message.src))\n                return \"src: string expected\";\n        }\n        if (message.srcdoc != null && message.hasOwnProperty(\"srcdoc\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (!$util.isString(message.srcdoc))\n                return \"srcdoc: string expected\";\n        }\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            if (typeof message.width !== \"number\")\n                return \"width: number expected\";\n        if (message.hasWidth != null && message.hasOwnProperty(\"hasWidth\"))\n            if (typeof message.hasWidth !== \"boolean\")\n                return \"hasWidth: boolean expected\";\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            if (typeof message.height !== \"number\")\n                return \"height: number expected\";\n        if (message.scrolling != null && message.hasOwnProperty(\"scrolling\"))\n            if (typeof message.scrolling !== \"boolean\")\n                return \"scrolling: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a IFrame message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof IFrame\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {IFrame} IFrame\n     */\n    IFrame.fromObject = function fromObject(object) {\n        if (object instanceof $root.IFrame)\n            return object;\n        let message = new $root.IFrame();\n        if (object.src != null)\n            message.src = String(object.src);\n        if (object.srcdoc != null)\n            message.srcdoc = String(object.srcdoc);\n        if (object.width != null)\n            message.width = Number(object.width);\n        if (object.hasWidth != null)\n            message.hasWidth = Boolean(object.hasWidth);\n        if (object.height != null)\n            message.height = Number(object.height);\n        if (object.scrolling != null)\n            message.scrolling = Boolean(object.scrolling);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a IFrame message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof IFrame\n     * @static\n     * @param {IFrame} message IFrame\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    IFrame.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.width = 0;\n            object.hasWidth = false;\n            object.height = 0;\n            object.scrolling = false;\n        }\n        if (message.src != null && message.hasOwnProperty(\"src\")) {\n            object.src = message.src;\n            if (options.oneofs)\n                object.type = \"src\";\n        }\n        if (message.srcdoc != null && message.hasOwnProperty(\"srcdoc\")) {\n            object.srcdoc = message.srcdoc;\n            if (options.oneofs)\n                object.type = \"srcdoc\";\n        }\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            object.width = options.json && !isFinite(message.width) ? String(message.width) : message.width;\n        if (message.hasWidth != null && message.hasOwnProperty(\"hasWidth\"))\n            object.hasWidth = message.hasWidth;\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            object.height = options.json && !isFinite(message.height) ? String(message.height) : message.height;\n        if (message.scrolling != null && message.hasOwnProperty(\"scrolling\"))\n            object.scrolling = message.scrolling;\n        return object;\n    };\n\n    /**\n     * Converts this IFrame to JSON.\n     * @function toJSON\n     * @memberof IFrame\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    IFrame.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return IFrame;\n})();\n\nexport const Image = $root.Image = (() => {\n\n    /**\n     * Properties of an Image.\n     * @exports IImage\n     * @interface IImage\n     * @property {string|null} [url] Image url\n     * @property {string|null} [caption] Image caption\n     */\n\n    /**\n     * Constructs a new Image.\n     * @exports Image\n     * @classdesc Represents an Image.\n     * @implements IImage\n     * @constructor\n     * @param {IImage=} [properties] Properties to set\n     */\n    function Image(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Image url.\n     * @member {string} url\n     * @memberof Image\n     * @instance\n     */\n    Image.prototype.url = \"\";\n\n    /**\n     * Image caption.\n     * @member {string} caption\n     * @memberof Image\n     * @instance\n     */\n    Image.prototype.caption = \"\";\n\n    /**\n     * Creates a new Image instance using the specified properties.\n     * @function create\n     * @memberof Image\n     * @static\n     * @param {IImage=} [properties] Properties to set\n     * @returns {Image} Image instance\n     */\n    Image.create = function create(properties) {\n        return new Image(properties);\n    };\n\n    /**\n     * Encodes the specified Image message. Does not implicitly {@link Image.verify|verify} messages.\n     * @function encode\n     * @memberof Image\n     * @static\n     * @param {IImage} message Image message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Image.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.caption != null && Object.hasOwnProperty.call(message, \"caption\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.caption);\n        if (message.url != null && Object.hasOwnProperty.call(message, \"url\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message.url);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Image message, length delimited. Does not implicitly {@link Image.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Image\n     * @static\n     * @param {IImage} message Image message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Image.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Image message from the specified reader or buffer.\n     * @function decode\n     * @memberof Image\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Image} Image\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Image.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Image();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 3:\n                message.url = reader.string();\n                break;\n            case 2:\n                message.caption = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Image message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Image\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Image} Image\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Image.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Image message.\n     * @function verify\n     * @memberof Image\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Image.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            if (!$util.isString(message.url))\n                return \"url: string expected\";\n        if (message.caption != null && message.hasOwnProperty(\"caption\"))\n            if (!$util.isString(message.caption))\n                return \"caption: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates an Image message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Image\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Image} Image\n     */\n    Image.fromObject = function fromObject(object) {\n        if (object instanceof $root.Image)\n            return object;\n        let message = new $root.Image();\n        if (object.url != null)\n            message.url = String(object.url);\n        if (object.caption != null)\n            message.caption = String(object.caption);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Image message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Image\n     * @static\n     * @param {Image} message Image\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Image.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.caption = \"\";\n            object.url = \"\";\n        }\n        if (message.caption != null && message.hasOwnProperty(\"caption\"))\n            object.caption = message.caption;\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            object.url = message.url;\n        return object;\n    };\n\n    /**\n     * Converts this Image to JSON.\n     * @function toJSON\n     * @memberof Image\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Image.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Image;\n})();\n\nexport const ImageList = $root.ImageList = (() => {\n\n    /**\n     * Properties of an ImageList.\n     * @exports IImageList\n     * @interface IImageList\n     * @property {Array.<IImage>|null} [imgs] ImageList imgs\n     * @property {number|null} [width] ImageList width\n     */\n\n    /**\n     * Constructs a new ImageList.\n     * @exports ImageList\n     * @classdesc Represents an ImageList.\n     * @implements IImageList\n     * @constructor\n     * @param {IImageList=} [properties] Properties to set\n     */\n    function ImageList(properties) {\n        this.imgs = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ImageList imgs.\n     * @member {Array.<IImage>} imgs\n     * @memberof ImageList\n     * @instance\n     */\n    ImageList.prototype.imgs = $util.emptyArray;\n\n    /**\n     * ImageList width.\n     * @member {number} width\n     * @memberof ImageList\n     * @instance\n     */\n    ImageList.prototype.width = 0;\n\n    /**\n     * Creates a new ImageList instance using the specified properties.\n     * @function create\n     * @memberof ImageList\n     * @static\n     * @param {IImageList=} [properties] Properties to set\n     * @returns {ImageList} ImageList instance\n     */\n    ImageList.create = function create(properties) {\n        return new ImageList(properties);\n    };\n\n    /**\n     * Encodes the specified ImageList message. Does not implicitly {@link ImageList.verify|verify} messages.\n     * @function encode\n     * @memberof ImageList\n     * @static\n     * @param {IImageList} message ImageList message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ImageList.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.imgs != null && message.imgs.length)\n            for (let i = 0; i < message.imgs.length; ++i)\n                $root.Image.encode(message.imgs[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.width != null && Object.hasOwnProperty.call(message, \"width\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.width);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ImageList message, length delimited. Does not implicitly {@link ImageList.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ImageList\n     * @static\n     * @param {IImageList} message ImageList message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ImageList.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an ImageList message from the specified reader or buffer.\n     * @function decode\n     * @memberof ImageList\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ImageList} ImageList\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ImageList.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ImageList();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.imgs && message.imgs.length))\n                    message.imgs = [];\n                message.imgs.push($root.Image.decode(reader, reader.uint32()));\n                break;\n            case 2:\n                message.width = reader.int32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an ImageList message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ImageList\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ImageList} ImageList\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ImageList.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an ImageList message.\n     * @function verify\n     * @memberof ImageList\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ImageList.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.imgs != null && message.hasOwnProperty(\"imgs\")) {\n            if (!Array.isArray(message.imgs))\n                return \"imgs: array expected\";\n            for (let i = 0; i < message.imgs.length; ++i) {\n                let error = $root.Image.verify(message.imgs[i]);\n                if (error)\n                    return \"imgs.\" + error;\n            }\n        }\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            if (!$util.isInteger(message.width))\n                return \"width: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates an ImageList message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ImageList\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ImageList} ImageList\n     */\n    ImageList.fromObject = function fromObject(object) {\n        if (object instanceof $root.ImageList)\n            return object;\n        let message = new $root.ImageList();\n        if (object.imgs) {\n            if (!Array.isArray(object.imgs))\n                throw TypeError(\".ImageList.imgs: array expected\");\n            message.imgs = [];\n            for (let i = 0; i < object.imgs.length; ++i) {\n                if (typeof object.imgs[i] !== \"object\")\n                    throw TypeError(\".ImageList.imgs: object expected\");\n                message.imgs[i] = $root.Image.fromObject(object.imgs[i]);\n            }\n        }\n        if (object.width != null)\n            message.width = object.width | 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an ImageList message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ImageList\n     * @static\n     * @param {ImageList} message ImageList\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ImageList.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.imgs = [];\n        if (options.defaults)\n            object.width = 0;\n        if (message.imgs && message.imgs.length) {\n            object.imgs = [];\n            for (let j = 0; j < message.imgs.length; ++j)\n                object.imgs[j] = $root.Image.toObject(message.imgs[j], options);\n        }\n        if (message.width != null && message.hasOwnProperty(\"width\"))\n            object.width = message.width;\n        return object;\n    };\n\n    /**\n     * Converts this ImageList to JSON.\n     * @function toJSON\n     * @memberof ImageList\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ImageList.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ImageList;\n})();\n\nexport const Initialize = $root.Initialize = (() => {\n\n    /**\n     * Properties of an Initialize.\n     * @exports IInitialize\n     * @interface IInitialize\n     * @property {IUserInfo|null} [userInfo] Initialize userInfo\n     * @property {IConfig|null} [config] Initialize config\n     * @property {IEnvironmentInfo|null} [environmentInfo] Initialize environmentInfo\n     * @property {ISessionState|null} [sessionState] Initialize sessionState\n     * @property {string|null} [commandLine] Initialize commandLine\n     * @property {string|null} [sessionId] Initialize sessionId\n     */\n\n    /**\n     * Constructs a new Initialize.\n     * @exports Initialize\n     * @classdesc Represents an Initialize.\n     * @implements IInitialize\n     * @constructor\n     * @param {IInitialize=} [properties] Properties to set\n     */\n    function Initialize(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Initialize userInfo.\n     * @member {IUserInfo|null|undefined} userInfo\n     * @memberof Initialize\n     * @instance\n     */\n    Initialize.prototype.userInfo = null;\n\n    /**\n     * Initialize config.\n     * @member {IConfig|null|undefined} config\n     * @memberof Initialize\n     * @instance\n     */\n    Initialize.prototype.config = null;\n\n    /**\n     * Initialize environmentInfo.\n     * @member {IEnvironmentInfo|null|undefined} environmentInfo\n     * @memberof Initialize\n     * @instance\n     */\n    Initialize.prototype.environmentInfo = null;\n\n    /**\n     * Initialize sessionState.\n     * @member {ISessionState|null|undefined} sessionState\n     * @memberof Initialize\n     * @instance\n     */\n    Initialize.prototype.sessionState = null;\n\n    /**\n     * Initialize commandLine.\n     * @member {string} commandLine\n     * @memberof Initialize\n     * @instance\n     */\n    Initialize.prototype.commandLine = \"\";\n\n    /**\n     * Initialize sessionId.\n     * @member {string} sessionId\n     * @memberof Initialize\n     * @instance\n     */\n    Initialize.prototype.sessionId = \"\";\n\n    /**\n     * Creates a new Initialize instance using the specified properties.\n     * @function create\n     * @memberof Initialize\n     * @static\n     * @param {IInitialize=} [properties] Properties to set\n     * @returns {Initialize} Initialize instance\n     */\n    Initialize.create = function create(properties) {\n        return new Initialize(properties);\n    };\n\n    /**\n     * Encodes the specified Initialize message. Does not implicitly {@link Initialize.verify|verify} messages.\n     * @function encode\n     * @memberof Initialize\n     * @static\n     * @param {IInitialize} message Initialize message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Initialize.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.userInfo != null && Object.hasOwnProperty.call(message, \"userInfo\"))\n            $root.UserInfo.encode(message.userInfo, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        if (message.config != null && Object.hasOwnProperty.call(message, \"config\"))\n            $root.Config.encode(message.config, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.environmentInfo != null && Object.hasOwnProperty.call(message, \"environmentInfo\"))\n            $root.EnvironmentInfo.encode(message.environmentInfo, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        if (message.sessionState != null && Object.hasOwnProperty.call(message, \"sessionState\"))\n            $root.SessionState.encode(message.sessionState, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n        if (message.commandLine != null && Object.hasOwnProperty.call(message, \"commandLine\"))\n            writer.uint32(/* id 5, wireType 2 =*/42).string(message.commandLine);\n        if (message.sessionId != null && Object.hasOwnProperty.call(message, \"sessionId\"))\n            writer.uint32(/* id 6, wireType 2 =*/50).string(message.sessionId);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Initialize message, length delimited. Does not implicitly {@link Initialize.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Initialize\n     * @static\n     * @param {IInitialize} message Initialize message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Initialize.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an Initialize message from the specified reader or buffer.\n     * @function decode\n     * @memberof Initialize\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Initialize} Initialize\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Initialize.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Initialize();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.userInfo = $root.UserInfo.decode(reader, reader.uint32());\n                break;\n            case 2:\n                message.config = $root.Config.decode(reader, reader.uint32());\n                break;\n            case 3:\n                message.environmentInfo = $root.EnvironmentInfo.decode(reader, reader.uint32());\n                break;\n            case 4:\n                message.sessionState = $root.SessionState.decode(reader, reader.uint32());\n                break;\n            case 5:\n                message.commandLine = reader.string();\n                break;\n            case 6:\n                message.sessionId = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an Initialize message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Initialize\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Initialize} Initialize\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Initialize.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an Initialize message.\n     * @function verify\n     * @memberof Initialize\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Initialize.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.userInfo != null && message.hasOwnProperty(\"userInfo\")) {\n            let error = $root.UserInfo.verify(message.userInfo);\n            if (error)\n                return \"userInfo.\" + error;\n        }\n        if (message.config != null && message.hasOwnProperty(\"config\")) {\n            let error = $root.Config.verify(message.config);\n            if (error)\n                return \"config.\" + error;\n        }\n        if (message.environmentInfo != null && message.hasOwnProperty(\"environmentInfo\")) {\n            let error = $root.EnvironmentInfo.verify(message.environmentInfo);\n            if (error)\n                return \"environmentInfo.\" + error;\n        }\n        if (message.sessionState != null && message.hasOwnProperty(\"sessionState\")) {\n            let error = $root.SessionState.verify(message.sessionState);\n            if (error)\n                return \"sessionState.\" + error;\n        }\n        if (message.commandLine != null && message.hasOwnProperty(\"commandLine\"))\n            if (!$util.isString(message.commandLine))\n                return \"commandLine: string expected\";\n        if (message.sessionId != null && message.hasOwnProperty(\"sessionId\"))\n            if (!$util.isString(message.sessionId))\n                return \"sessionId: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates an Initialize message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Initialize\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Initialize} Initialize\n     */\n    Initialize.fromObject = function fromObject(object) {\n        if (object instanceof $root.Initialize)\n            return object;\n        let message = new $root.Initialize();\n        if (object.userInfo != null) {\n            if (typeof object.userInfo !== \"object\")\n                throw TypeError(\".Initialize.userInfo: object expected\");\n            message.userInfo = $root.UserInfo.fromObject(object.userInfo);\n        }\n        if (object.config != null) {\n            if (typeof object.config !== \"object\")\n                throw TypeError(\".Initialize.config: object expected\");\n            message.config = $root.Config.fromObject(object.config);\n        }\n        if (object.environmentInfo != null) {\n            if (typeof object.environmentInfo !== \"object\")\n                throw TypeError(\".Initialize.environmentInfo: object expected\");\n            message.environmentInfo = $root.EnvironmentInfo.fromObject(object.environmentInfo);\n        }\n        if (object.sessionState != null) {\n            if (typeof object.sessionState !== \"object\")\n                throw TypeError(\".Initialize.sessionState: object expected\");\n            message.sessionState = $root.SessionState.fromObject(object.sessionState);\n        }\n        if (object.commandLine != null)\n            message.commandLine = String(object.commandLine);\n        if (object.sessionId != null)\n            message.sessionId = String(object.sessionId);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an Initialize message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Initialize\n     * @static\n     * @param {Initialize} message Initialize\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Initialize.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.userInfo = null;\n            object.config = null;\n            object.environmentInfo = null;\n            object.sessionState = null;\n            object.commandLine = \"\";\n            object.sessionId = \"\";\n        }\n        if (message.userInfo != null && message.hasOwnProperty(\"userInfo\"))\n            object.userInfo = $root.UserInfo.toObject(message.userInfo, options);\n        if (message.config != null && message.hasOwnProperty(\"config\"))\n            object.config = $root.Config.toObject(message.config, options);\n        if (message.environmentInfo != null && message.hasOwnProperty(\"environmentInfo\"))\n            object.environmentInfo = $root.EnvironmentInfo.toObject(message.environmentInfo, options);\n        if (message.sessionState != null && message.hasOwnProperty(\"sessionState\"))\n            object.sessionState = $root.SessionState.toObject(message.sessionState, options);\n        if (message.commandLine != null && message.hasOwnProperty(\"commandLine\"))\n            object.commandLine = message.commandLine;\n        if (message.sessionId != null && message.hasOwnProperty(\"sessionId\"))\n            object.sessionId = message.sessionId;\n        return object;\n    };\n\n    /**\n     * Converts this Initialize to JSON.\n     * @function toJSON\n     * @memberof Initialize\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Initialize.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Initialize;\n})();\n\nexport const Config = $root.Config = (() => {\n\n    /**\n     * Properties of a Config.\n     * @exports IConfig\n     * @interface IConfig\n     * @property {boolean|null} [sharingEnabled] Config sharingEnabled\n     * @property {boolean|null} [gatherUsageStats] Config gatherUsageStats\n     * @property {number|null} [maxCachedMessageAge] Config maxCachedMessageAge\n     * @property {string|null} [mapboxToken] Config mapboxToken\n     */\n\n    /**\n     * Constructs a new Config.\n     * @exports Config\n     * @classdesc Represents a Config.\n     * @implements IConfig\n     * @constructor\n     * @param {IConfig=} [properties] Properties to set\n     */\n    function Config(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Config sharingEnabled.\n     * @member {boolean} sharingEnabled\n     * @memberof Config\n     * @instance\n     */\n    Config.prototype.sharingEnabled = false;\n\n    /**\n     * Config gatherUsageStats.\n     * @member {boolean} gatherUsageStats\n     * @memberof Config\n     * @instance\n     */\n    Config.prototype.gatherUsageStats = false;\n\n    /**\n     * Config maxCachedMessageAge.\n     * @member {number} maxCachedMessageAge\n     * @memberof Config\n     * @instance\n     */\n    Config.prototype.maxCachedMessageAge = 0;\n\n    /**\n     * Config mapboxToken.\n     * @member {string} mapboxToken\n     * @memberof Config\n     * @instance\n     */\n    Config.prototype.mapboxToken = \"\";\n\n    /**\n     * Creates a new Config instance using the specified properties.\n     * @function create\n     * @memberof Config\n     * @static\n     * @param {IConfig=} [properties] Properties to set\n     * @returns {Config} Config instance\n     */\n    Config.create = function create(properties) {\n        return new Config(properties);\n    };\n\n    /**\n     * Encodes the specified Config message. Does not implicitly {@link Config.verify|verify} messages.\n     * @function encode\n     * @memberof Config\n     * @static\n     * @param {IConfig} message Config message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Config.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.sharingEnabled != null && Object.hasOwnProperty.call(message, \"sharingEnabled\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).bool(message.sharingEnabled);\n        if (message.gatherUsageStats != null && Object.hasOwnProperty.call(message, \"gatherUsageStats\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.gatherUsageStats);\n        if (message.maxCachedMessageAge != null && Object.hasOwnProperty.call(message, \"maxCachedMessageAge\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.maxCachedMessageAge);\n        if (message.mapboxToken != null && Object.hasOwnProperty.call(message, \"mapboxToken\"))\n            writer.uint32(/* id 4, wireType 2 =*/34).string(message.mapboxToken);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Config message, length delimited. Does not implicitly {@link Config.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Config\n     * @static\n     * @param {IConfig} message Config message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Config.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Config message from the specified reader or buffer.\n     * @function decode\n     * @memberof Config\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Config} Config\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Config.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Config();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.sharingEnabled = reader.bool();\n                break;\n            case 2:\n                message.gatherUsageStats = reader.bool();\n                break;\n            case 3:\n                message.maxCachedMessageAge = reader.int32();\n                break;\n            case 4:\n                message.mapboxToken = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Config message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Config\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Config} Config\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Config.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Config message.\n     * @function verify\n     * @memberof Config\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Config.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.sharingEnabled != null && message.hasOwnProperty(\"sharingEnabled\"))\n            if (typeof message.sharingEnabled !== \"boolean\")\n                return \"sharingEnabled: boolean expected\";\n        if (message.gatherUsageStats != null && message.hasOwnProperty(\"gatherUsageStats\"))\n            if (typeof message.gatherUsageStats !== \"boolean\")\n                return \"gatherUsageStats: boolean expected\";\n        if (message.maxCachedMessageAge != null && message.hasOwnProperty(\"maxCachedMessageAge\"))\n            if (!$util.isInteger(message.maxCachedMessageAge))\n                return \"maxCachedMessageAge: integer expected\";\n        if (message.mapboxToken != null && message.hasOwnProperty(\"mapboxToken\"))\n            if (!$util.isString(message.mapboxToken))\n                return \"mapboxToken: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Config message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Config\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Config} Config\n     */\n    Config.fromObject = function fromObject(object) {\n        if (object instanceof $root.Config)\n            return object;\n        let message = new $root.Config();\n        if (object.sharingEnabled != null)\n            message.sharingEnabled = Boolean(object.sharingEnabled);\n        if (object.gatherUsageStats != null)\n            message.gatherUsageStats = Boolean(object.gatherUsageStats);\n        if (object.maxCachedMessageAge != null)\n            message.maxCachedMessageAge = object.maxCachedMessageAge | 0;\n        if (object.mapboxToken != null)\n            message.mapboxToken = String(object.mapboxToken);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Config message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Config\n     * @static\n     * @param {Config} message Config\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Config.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.sharingEnabled = false;\n            object.gatherUsageStats = false;\n            object.maxCachedMessageAge = 0;\n            object.mapboxToken = \"\";\n        }\n        if (message.sharingEnabled != null && message.hasOwnProperty(\"sharingEnabled\"))\n            object.sharingEnabled = message.sharingEnabled;\n        if (message.gatherUsageStats != null && message.hasOwnProperty(\"gatherUsageStats\"))\n            object.gatherUsageStats = message.gatherUsageStats;\n        if (message.maxCachedMessageAge != null && message.hasOwnProperty(\"maxCachedMessageAge\"))\n            object.maxCachedMessageAge = message.maxCachedMessageAge;\n        if (message.mapboxToken != null && message.hasOwnProperty(\"mapboxToken\"))\n            object.mapboxToken = message.mapboxToken;\n        return object;\n    };\n\n    /**\n     * Converts this Config to JSON.\n     * @function toJSON\n     * @memberof Config\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Config.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Config;\n})();\n\nexport const UserInfo = $root.UserInfo = (() => {\n\n    /**\n     * Properties of a UserInfo.\n     * @exports IUserInfo\n     * @interface IUserInfo\n     * @property {string|null} [installationId] UserInfo installationId\n     * @property {string|null} [email] UserInfo email\n     */\n\n    /**\n     * Constructs a new UserInfo.\n     * @exports UserInfo\n     * @classdesc Represents a UserInfo.\n     * @implements IUserInfo\n     * @constructor\n     * @param {IUserInfo=} [properties] Properties to set\n     */\n    function UserInfo(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * UserInfo installationId.\n     * @member {string} installationId\n     * @memberof UserInfo\n     * @instance\n     */\n    UserInfo.prototype.installationId = \"\";\n\n    /**\n     * UserInfo email.\n     * @member {string} email\n     * @memberof UserInfo\n     * @instance\n     */\n    UserInfo.prototype.email = \"\";\n\n    /**\n     * Creates a new UserInfo instance using the specified properties.\n     * @function create\n     * @memberof UserInfo\n     * @static\n     * @param {IUserInfo=} [properties] Properties to set\n     * @returns {UserInfo} UserInfo instance\n     */\n    UserInfo.create = function create(properties) {\n        return new UserInfo(properties);\n    };\n\n    /**\n     * Encodes the specified UserInfo message. Does not implicitly {@link UserInfo.verify|verify} messages.\n     * @function encode\n     * @memberof UserInfo\n     * @static\n     * @param {IUserInfo} message UserInfo message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    UserInfo.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.installationId != null && Object.hasOwnProperty.call(message, \"installationId\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.installationId);\n        if (message.email != null && Object.hasOwnProperty.call(message, \"email\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.email);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified UserInfo message, length delimited. Does not implicitly {@link UserInfo.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof UserInfo\n     * @static\n     * @param {IUserInfo} message UserInfo message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    UserInfo.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a UserInfo message from the specified reader or buffer.\n     * @function decode\n     * @memberof UserInfo\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {UserInfo} UserInfo\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    UserInfo.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.UserInfo();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.installationId = reader.string();\n                break;\n            case 2:\n                message.email = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a UserInfo message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof UserInfo\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {UserInfo} UserInfo\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    UserInfo.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a UserInfo message.\n     * @function verify\n     * @memberof UserInfo\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    UserInfo.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.installationId != null && message.hasOwnProperty(\"installationId\"))\n            if (!$util.isString(message.installationId))\n                return \"installationId: string expected\";\n        if (message.email != null && message.hasOwnProperty(\"email\"))\n            if (!$util.isString(message.email))\n                return \"email: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a UserInfo message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof UserInfo\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {UserInfo} UserInfo\n     */\n    UserInfo.fromObject = function fromObject(object) {\n        if (object instanceof $root.UserInfo)\n            return object;\n        let message = new $root.UserInfo();\n        if (object.installationId != null)\n            message.installationId = String(object.installationId);\n        if (object.email != null)\n            message.email = String(object.email);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a UserInfo message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof UserInfo\n     * @static\n     * @param {UserInfo} message UserInfo\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    UserInfo.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.installationId = \"\";\n            object.email = \"\";\n        }\n        if (message.installationId != null && message.hasOwnProperty(\"installationId\"))\n            object.installationId = message.installationId;\n        if (message.email != null && message.hasOwnProperty(\"email\"))\n            object.email = message.email;\n        return object;\n    };\n\n    /**\n     * Converts this UserInfo to JSON.\n     * @function toJSON\n     * @memberof UserInfo\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    UserInfo.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return UserInfo;\n})();\n\nexport const EnvironmentInfo = $root.EnvironmentInfo = (() => {\n\n    /**\n     * Properties of an EnvironmentInfo.\n     * @exports IEnvironmentInfo\n     * @interface IEnvironmentInfo\n     * @property {string|null} [streamlitVersion] EnvironmentInfo streamlitVersion\n     * @property {string|null} [pythonVersion] EnvironmentInfo pythonVersion\n     */\n\n    /**\n     * Constructs a new EnvironmentInfo.\n     * @exports EnvironmentInfo\n     * @classdesc Represents an EnvironmentInfo.\n     * @implements IEnvironmentInfo\n     * @constructor\n     * @param {IEnvironmentInfo=} [properties] Properties to set\n     */\n    function EnvironmentInfo(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * EnvironmentInfo streamlitVersion.\n     * @member {string} streamlitVersion\n     * @memberof EnvironmentInfo\n     * @instance\n     */\n    EnvironmentInfo.prototype.streamlitVersion = \"\";\n\n    /**\n     * EnvironmentInfo pythonVersion.\n     * @member {string} pythonVersion\n     * @memberof EnvironmentInfo\n     * @instance\n     */\n    EnvironmentInfo.prototype.pythonVersion = \"\";\n\n    /**\n     * Creates a new EnvironmentInfo instance using the specified properties.\n     * @function create\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {IEnvironmentInfo=} [properties] Properties to set\n     * @returns {EnvironmentInfo} EnvironmentInfo instance\n     */\n    EnvironmentInfo.create = function create(properties) {\n        return new EnvironmentInfo(properties);\n    };\n\n    /**\n     * Encodes the specified EnvironmentInfo message. Does not implicitly {@link EnvironmentInfo.verify|verify} messages.\n     * @function encode\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {IEnvironmentInfo} message EnvironmentInfo message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    EnvironmentInfo.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.streamlitVersion != null && Object.hasOwnProperty.call(message, \"streamlitVersion\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.streamlitVersion);\n        if (message.pythonVersion != null && Object.hasOwnProperty.call(message, \"pythonVersion\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.pythonVersion);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified EnvironmentInfo message, length delimited. Does not implicitly {@link EnvironmentInfo.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {IEnvironmentInfo} message EnvironmentInfo message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    EnvironmentInfo.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an EnvironmentInfo message from the specified reader or buffer.\n     * @function decode\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {EnvironmentInfo} EnvironmentInfo\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    EnvironmentInfo.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.EnvironmentInfo();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.streamlitVersion = reader.string();\n                break;\n            case 2:\n                message.pythonVersion = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an EnvironmentInfo message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {EnvironmentInfo} EnvironmentInfo\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    EnvironmentInfo.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an EnvironmentInfo message.\n     * @function verify\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    EnvironmentInfo.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.streamlitVersion != null && message.hasOwnProperty(\"streamlitVersion\"))\n            if (!$util.isString(message.streamlitVersion))\n                return \"streamlitVersion: string expected\";\n        if (message.pythonVersion != null && message.hasOwnProperty(\"pythonVersion\"))\n            if (!$util.isString(message.pythonVersion))\n                return \"pythonVersion: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates an EnvironmentInfo message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {EnvironmentInfo} EnvironmentInfo\n     */\n    EnvironmentInfo.fromObject = function fromObject(object) {\n        if (object instanceof $root.EnvironmentInfo)\n            return object;\n        let message = new $root.EnvironmentInfo();\n        if (object.streamlitVersion != null)\n            message.streamlitVersion = String(object.streamlitVersion);\n        if (object.pythonVersion != null)\n            message.pythonVersion = String(object.pythonVersion);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an EnvironmentInfo message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof EnvironmentInfo\n     * @static\n     * @param {EnvironmentInfo} message EnvironmentInfo\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    EnvironmentInfo.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.streamlitVersion = \"\";\n            object.pythonVersion = \"\";\n        }\n        if (message.streamlitVersion != null && message.hasOwnProperty(\"streamlitVersion\"))\n            object.streamlitVersion = message.streamlitVersion;\n        if (message.pythonVersion != null && message.hasOwnProperty(\"pythonVersion\"))\n            object.pythonVersion = message.pythonVersion;\n        return object;\n    };\n\n    /**\n     * Converts this EnvironmentInfo to JSON.\n     * @function toJSON\n     * @memberof EnvironmentInfo\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    EnvironmentInfo.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return EnvironmentInfo;\n})();\n\nexport const Json = $root.Json = (() => {\n\n    /**\n     * Properties of a Json.\n     * @exports IJson\n     * @interface IJson\n     * @property {string|null} [body] Json body\n     */\n\n    /**\n     * Constructs a new Json.\n     * @exports Json\n     * @classdesc Represents a Json.\n     * @implements IJson\n     * @constructor\n     * @param {IJson=} [properties] Properties to set\n     */\n    function Json(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Json body.\n     * @member {string} body\n     * @memberof Json\n     * @instance\n     */\n    Json.prototype.body = \"\";\n\n    /**\n     * Creates a new Json instance using the specified properties.\n     * @function create\n     * @memberof Json\n     * @static\n     * @param {IJson=} [properties] Properties to set\n     * @returns {Json} Json instance\n     */\n    Json.create = function create(properties) {\n        return new Json(properties);\n    };\n\n    /**\n     * Encodes the specified Json message. Does not implicitly {@link Json.verify|verify} messages.\n     * @function encode\n     * @memberof Json\n     * @static\n     * @param {IJson} message Json message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Json.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.body != null && Object.hasOwnProperty.call(message, \"body\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.body);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Json message, length delimited. Does not implicitly {@link Json.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Json\n     * @static\n     * @param {IJson} message Json message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Json.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Json message from the specified reader or buffer.\n     * @function decode\n     * @memberof Json\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Json} Json\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Json.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Json();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.body = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Json message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Json\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Json} Json\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Json.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Json message.\n     * @function verify\n     * @memberof Json\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Json.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            if (!$util.isString(message.body))\n                return \"body: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Json message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Json\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Json} Json\n     */\n    Json.fromObject = function fromObject(object) {\n        if (object instanceof $root.Json)\n            return object;\n        let message = new $root.Json();\n        if (object.body != null)\n            message.body = String(object.body);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Json message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Json\n     * @static\n     * @param {Json} message Json\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Json.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.body = \"\";\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            object.body = message.body;\n        return object;\n    };\n\n    /**\n     * Converts this Json to JSON.\n     * @function toJSON\n     * @memberof Json\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Json.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Json;\n})();\n\nexport const Markdown = $root.Markdown = (() => {\n\n    /**\n     * Properties of a Markdown.\n     * @exports IMarkdown\n     * @interface IMarkdown\n     * @property {string|null} [body] Markdown body\n     * @property {boolean|null} [allowHtml] Markdown allowHtml\n     */\n\n    /**\n     * Constructs a new Markdown.\n     * @exports Markdown\n     * @classdesc Represents a Markdown.\n     * @implements IMarkdown\n     * @constructor\n     * @param {IMarkdown=} [properties] Properties to set\n     */\n    function Markdown(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Markdown body.\n     * @member {string} body\n     * @memberof Markdown\n     * @instance\n     */\n    Markdown.prototype.body = \"\";\n\n    /**\n     * Markdown allowHtml.\n     * @member {boolean} allowHtml\n     * @memberof Markdown\n     * @instance\n     */\n    Markdown.prototype.allowHtml = false;\n\n    /**\n     * Creates a new Markdown instance using the specified properties.\n     * @function create\n     * @memberof Markdown\n     * @static\n     * @param {IMarkdown=} [properties] Properties to set\n     * @returns {Markdown} Markdown instance\n     */\n    Markdown.create = function create(properties) {\n        return new Markdown(properties);\n    };\n\n    /**\n     * Encodes the specified Markdown message. Does not implicitly {@link Markdown.verify|verify} messages.\n     * @function encode\n     * @memberof Markdown\n     * @static\n     * @param {IMarkdown} message Markdown message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Markdown.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.body != null && Object.hasOwnProperty.call(message, \"body\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.body);\n        if (message.allowHtml != null && Object.hasOwnProperty.call(message, \"allowHtml\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.allowHtml);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Markdown message, length delimited. Does not implicitly {@link Markdown.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Markdown\n     * @static\n     * @param {IMarkdown} message Markdown message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Markdown.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Markdown message from the specified reader or buffer.\n     * @function decode\n     * @memberof Markdown\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Markdown} Markdown\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Markdown.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Markdown();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.body = reader.string();\n                break;\n            case 2:\n                message.allowHtml = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Markdown message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Markdown\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Markdown} Markdown\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Markdown.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Markdown message.\n     * @function verify\n     * @memberof Markdown\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Markdown.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            if (!$util.isString(message.body))\n                return \"body: string expected\";\n        if (message.allowHtml != null && message.hasOwnProperty(\"allowHtml\"))\n            if (typeof message.allowHtml !== \"boolean\")\n                return \"allowHtml: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Markdown message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Markdown\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Markdown} Markdown\n     */\n    Markdown.fromObject = function fromObject(object) {\n        if (object instanceof $root.Markdown)\n            return object;\n        let message = new $root.Markdown();\n        if (object.body != null)\n            message.body = String(object.body);\n        if (object.allowHtml != null)\n            message.allowHtml = Boolean(object.allowHtml);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Markdown message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Markdown\n     * @static\n     * @param {Markdown} message Markdown\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Markdown.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.body = \"\";\n            object.allowHtml = false;\n        }\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            object.body = message.body;\n        if (message.allowHtml != null && message.hasOwnProperty(\"allowHtml\"))\n            object.allowHtml = message.allowHtml;\n        return object;\n    };\n\n    /**\n     * Converts this Markdown to JSON.\n     * @function toJSON\n     * @memberof Markdown\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Markdown.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Markdown;\n})();\n\nexport const MultiSelect = $root.MultiSelect = (() => {\n\n    /**\n     * Properties of a MultiSelect.\n     * @exports IMultiSelect\n     * @interface IMultiSelect\n     * @property {string|null} [id] MultiSelect id\n     * @property {string|null} [label] MultiSelect label\n     * @property {Array.<number>|null} [\"default\"] MultiSelect default\n     * @property {Array.<string>|null} [options] MultiSelect options\n     */\n\n    /**\n     * Constructs a new MultiSelect.\n     * @exports MultiSelect\n     * @classdesc Represents a MultiSelect.\n     * @implements IMultiSelect\n     * @constructor\n     * @param {IMultiSelect=} [properties] Properties to set\n     */\n    function MultiSelect(properties) {\n        this[\"default\"] = [];\n        this.options = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * MultiSelect id.\n     * @member {string} id\n     * @memberof MultiSelect\n     * @instance\n     */\n    MultiSelect.prototype.id = \"\";\n\n    /**\n     * MultiSelect label.\n     * @member {string} label\n     * @memberof MultiSelect\n     * @instance\n     */\n    MultiSelect.prototype.label = \"\";\n\n    /**\n     * MultiSelect default.\n     * @member {Array.<number>} default\n     * @memberof MultiSelect\n     * @instance\n     */\n    MultiSelect.prototype[\"default\"] = $util.emptyArray;\n\n    /**\n     * MultiSelect options.\n     * @member {Array.<string>} options\n     * @memberof MultiSelect\n     * @instance\n     */\n    MultiSelect.prototype.options = $util.emptyArray;\n\n    /**\n     * Creates a new MultiSelect instance using the specified properties.\n     * @function create\n     * @memberof MultiSelect\n     * @static\n     * @param {IMultiSelect=} [properties] Properties to set\n     * @returns {MultiSelect} MultiSelect instance\n     */\n    MultiSelect.create = function create(properties) {\n        return new MultiSelect(properties);\n    };\n\n    /**\n     * Encodes the specified MultiSelect message. Does not implicitly {@link MultiSelect.verify|verify} messages.\n     * @function encode\n     * @memberof MultiSelect\n     * @static\n     * @param {IMultiSelect} message MultiSelect message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    MultiSelect.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && message[\"default\"].length) {\n            writer.uint32(/* id 3, wireType 2 =*/26).fork();\n            for (let i = 0; i < message[\"default\"].length; ++i)\n                writer.int32(message[\"default\"][i]);\n            writer.ldelim();\n        }\n        if (message.options != null && message.options.length)\n            for (let i = 0; i < message.options.length; ++i)\n                writer.uint32(/* id 4, wireType 2 =*/34).string(message.options[i]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified MultiSelect message, length delimited. Does not implicitly {@link MultiSelect.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof MultiSelect\n     * @static\n     * @param {IMultiSelect} message MultiSelect message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    MultiSelect.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a MultiSelect message from the specified reader or buffer.\n     * @function decode\n     * @memberof MultiSelect\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {MultiSelect} MultiSelect\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    MultiSelect.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.MultiSelect();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                if (!(message[\"default\"] && message[\"default\"].length))\n                    message[\"default\"] = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message[\"default\"].push(reader.int32());\n                } else\n                    message[\"default\"].push(reader.int32());\n                break;\n            case 4:\n                if (!(message.options && message.options.length))\n                    message.options = [];\n                message.options.push(reader.string());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a MultiSelect message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof MultiSelect\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {MultiSelect} MultiSelect\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    MultiSelect.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a MultiSelect message.\n     * @function verify\n     * @memberof MultiSelect\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    MultiSelect.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\")) {\n            if (!Array.isArray(message[\"default\"]))\n                return \"default: array expected\";\n            for (let i = 0; i < message[\"default\"].length; ++i)\n                if (!$util.isInteger(message[\"default\"][i]))\n                    return \"default: integer[] expected\";\n        }\n        if (message.options != null && message.hasOwnProperty(\"options\")) {\n            if (!Array.isArray(message.options))\n                return \"options: array expected\";\n            for (let i = 0; i < message.options.length; ++i)\n                if (!$util.isString(message.options[i]))\n                    return \"options: string[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a MultiSelect message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof MultiSelect\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {MultiSelect} MultiSelect\n     */\n    MultiSelect.fromObject = function fromObject(object) {\n        if (object instanceof $root.MultiSelect)\n            return object;\n        let message = new $root.MultiSelect();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"]) {\n            if (!Array.isArray(object[\"default\"]))\n                throw TypeError(\".MultiSelect.default: array expected\");\n            message[\"default\"] = [];\n            for (let i = 0; i < object[\"default\"].length; ++i)\n                message[\"default\"][i] = object[\"default\"][i] | 0;\n        }\n        if (object.options) {\n            if (!Array.isArray(object.options))\n                throw TypeError(\".MultiSelect.options: array expected\");\n            message.options = [];\n            for (let i = 0; i < object.options.length; ++i)\n                message.options[i] = String(object.options[i]);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a MultiSelect message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof MultiSelect\n     * @static\n     * @param {MultiSelect} message MultiSelect\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    MultiSelect.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults) {\n            object[\"default\"] = [];\n            object.options = [];\n        }\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] && message[\"default\"].length) {\n            object[\"default\"] = [];\n            for (let j = 0; j < message[\"default\"].length; ++j)\n                object[\"default\"][j] = message[\"default\"][j];\n        }\n        if (message.options && message.options.length) {\n            object.options = [];\n            for (let j = 0; j < message.options.length; ++j)\n                object.options[j] = message.options[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this MultiSelect to JSON.\n     * @function toJSON\n     * @memberof MultiSelect\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    MultiSelect.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return MultiSelect;\n})();\n\nexport const NamedDataSet = $root.NamedDataSet = (() => {\n\n    /**\n     * Properties of a NamedDataSet.\n     * @exports INamedDataSet\n     * @interface INamedDataSet\n     * @property {string|null} [name] NamedDataSet name\n     * @property {boolean|null} [hasName] NamedDataSet hasName\n     * @property {IDataFrame|null} [data] NamedDataSet data\n     */\n\n    /**\n     * Constructs a new NamedDataSet.\n     * @exports NamedDataSet\n     * @classdesc Represents a NamedDataSet.\n     * @implements INamedDataSet\n     * @constructor\n     * @param {INamedDataSet=} [properties] Properties to set\n     */\n    function NamedDataSet(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * NamedDataSet name.\n     * @member {string} name\n     * @memberof NamedDataSet\n     * @instance\n     */\n    NamedDataSet.prototype.name = \"\";\n\n    /**\n     * NamedDataSet hasName.\n     * @member {boolean} hasName\n     * @memberof NamedDataSet\n     * @instance\n     */\n    NamedDataSet.prototype.hasName = false;\n\n    /**\n     * NamedDataSet data.\n     * @member {IDataFrame|null|undefined} data\n     * @memberof NamedDataSet\n     * @instance\n     */\n    NamedDataSet.prototype.data = null;\n\n    /**\n     * Creates a new NamedDataSet instance using the specified properties.\n     * @function create\n     * @memberof NamedDataSet\n     * @static\n     * @param {INamedDataSet=} [properties] Properties to set\n     * @returns {NamedDataSet} NamedDataSet instance\n     */\n    NamedDataSet.create = function create(properties) {\n        return new NamedDataSet(properties);\n    };\n\n    /**\n     * Encodes the specified NamedDataSet message. Does not implicitly {@link NamedDataSet.verify|verify} messages.\n     * @function encode\n     * @memberof NamedDataSet\n     * @static\n     * @param {INamedDataSet} message NamedDataSet message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NamedDataSet.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.name != null && Object.hasOwnProperty.call(message, \"name\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.DataFrame.encode(message.data, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.hasName != null && Object.hasOwnProperty.call(message, \"hasName\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.hasName);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified NamedDataSet message, length delimited. Does not implicitly {@link NamedDataSet.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof NamedDataSet\n     * @static\n     * @param {INamedDataSet} message NamedDataSet message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NamedDataSet.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a NamedDataSet message from the specified reader or buffer.\n     * @function decode\n     * @memberof NamedDataSet\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {NamedDataSet} NamedDataSet\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NamedDataSet.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.NamedDataSet();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.name = reader.string();\n                break;\n            case 3:\n                message.hasName = reader.bool();\n                break;\n            case 2:\n                message.data = $root.DataFrame.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a NamedDataSet message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof NamedDataSet\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {NamedDataSet} NamedDataSet\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NamedDataSet.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a NamedDataSet message.\n     * @function verify\n     * @memberof NamedDataSet\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    NamedDataSet.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            if (!$util.isString(message.name))\n                return \"name: string expected\";\n        if (message.hasName != null && message.hasOwnProperty(\"hasName\"))\n            if (typeof message.hasName !== \"boolean\")\n                return \"hasName: boolean expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.DataFrame.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        return null;\n    };\n\n    /**\n     * Creates a NamedDataSet message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof NamedDataSet\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {NamedDataSet} NamedDataSet\n     */\n    NamedDataSet.fromObject = function fromObject(object) {\n        if (object instanceof $root.NamedDataSet)\n            return object;\n        let message = new $root.NamedDataSet();\n        if (object.name != null)\n            message.name = String(object.name);\n        if (object.hasName != null)\n            message.hasName = Boolean(object.hasName);\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".NamedDataSet.data: object expected\");\n            message.data = $root.DataFrame.fromObject(object.data);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a NamedDataSet message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof NamedDataSet\n     * @static\n     * @param {NamedDataSet} message NamedDataSet\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    NamedDataSet.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.name = \"\";\n            object.data = null;\n            object.hasName = false;\n        }\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            object.name = message.name;\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.DataFrame.toObject(message.data, options);\n        if (message.hasName != null && message.hasOwnProperty(\"hasName\"))\n            object.hasName = message.hasName;\n        return object;\n    };\n\n    /**\n     * Converts this NamedDataSet to JSON.\n     * @function toJSON\n     * @memberof NamedDataSet\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    NamedDataSet.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return NamedDataSet;\n})();\n\nexport const NewReport = $root.NewReport = (() => {\n\n    /**\n     * Properties of a NewReport.\n     * @exports INewReport\n     * @interface INewReport\n     * @property {string|null} [id] NewReport id\n     * @property {string|null} [name] NewReport name\n     * @property {string|null} [scriptPath] NewReport scriptPath\n     */\n\n    /**\n     * Constructs a new NewReport.\n     * @exports NewReport\n     * @classdesc Represents a NewReport.\n     * @implements INewReport\n     * @constructor\n     * @param {INewReport=} [properties] Properties to set\n     */\n    function NewReport(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * NewReport id.\n     * @member {string} id\n     * @memberof NewReport\n     * @instance\n     */\n    NewReport.prototype.id = \"\";\n\n    /**\n     * NewReport name.\n     * @member {string} name\n     * @memberof NewReport\n     * @instance\n     */\n    NewReport.prototype.name = \"\";\n\n    /**\n     * NewReport scriptPath.\n     * @member {string} scriptPath\n     * @memberof NewReport\n     * @instance\n     */\n    NewReport.prototype.scriptPath = \"\";\n\n    /**\n     * Creates a new NewReport instance using the specified properties.\n     * @function create\n     * @memberof NewReport\n     * @static\n     * @param {INewReport=} [properties] Properties to set\n     * @returns {NewReport} NewReport instance\n     */\n    NewReport.create = function create(properties) {\n        return new NewReport(properties);\n    };\n\n    /**\n     * Encodes the specified NewReport message. Does not implicitly {@link NewReport.verify|verify} messages.\n     * @function encode\n     * @memberof NewReport\n     * @static\n     * @param {INewReport} message NewReport message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NewReport.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.name != null && Object.hasOwnProperty.call(message, \"name\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.name);\n        if (message.scriptPath != null && Object.hasOwnProperty.call(message, \"scriptPath\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message.scriptPath);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified NewReport message, length delimited. Does not implicitly {@link NewReport.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof NewReport\n     * @static\n     * @param {INewReport} message NewReport message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NewReport.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a NewReport message from the specified reader or buffer.\n     * @function decode\n     * @memberof NewReport\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {NewReport} NewReport\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NewReport.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.NewReport();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.name = reader.string();\n                break;\n            case 3:\n                message.scriptPath = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a NewReport message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof NewReport\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {NewReport} NewReport\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NewReport.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a NewReport message.\n     * @function verify\n     * @memberof NewReport\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    NewReport.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            if (!$util.isString(message.name))\n                return \"name: string expected\";\n        if (message.scriptPath != null && message.hasOwnProperty(\"scriptPath\"))\n            if (!$util.isString(message.scriptPath))\n                return \"scriptPath: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a NewReport message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof NewReport\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {NewReport} NewReport\n     */\n    NewReport.fromObject = function fromObject(object) {\n        if (object instanceof $root.NewReport)\n            return object;\n        let message = new $root.NewReport();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.name != null)\n            message.name = String(object.name);\n        if (object.scriptPath != null)\n            message.scriptPath = String(object.scriptPath);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a NewReport message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof NewReport\n     * @static\n     * @param {NewReport} message NewReport\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    NewReport.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.name = \"\";\n            object.scriptPath = \"\";\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            object.name = message.name;\n        if (message.scriptPath != null && message.hasOwnProperty(\"scriptPath\"))\n            object.scriptPath = message.scriptPath;\n        return object;\n    };\n\n    /**\n     * Converts this NewReport to JSON.\n     * @function toJSON\n     * @memberof NewReport\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    NewReport.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return NewReport;\n})();\n\nexport const NumberInput = $root.NumberInput = (() => {\n\n    /**\n     * Properties of a NumberInput.\n     * @exports INumberInput\n     * @interface INumberInput\n     * @property {string|null} [id] NumberInput id\n     * @property {string|null} [label] NumberInput label\n     * @property {string|null} [format] NumberInput format\n     * @property {boolean|null} [hasMin] NumberInput hasMin\n     * @property {boolean|null} [hasMax] NumberInput hasMax\n     * @property {NumberInput.DataType|null} [dataType] NumberInput dataType\n     * @property {number|null} [\"default\"] NumberInput default\n     * @property {number|null} [step] NumberInput step\n     * @property {number|null} [min] NumberInput min\n     * @property {number|null} [max] NumberInput max\n     */\n\n    /**\n     * Constructs a new NumberInput.\n     * @exports NumberInput\n     * @classdesc Represents a NumberInput.\n     * @implements INumberInput\n     * @constructor\n     * @param {INumberInput=} [properties] Properties to set\n     */\n    function NumberInput(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * NumberInput id.\n     * @member {string} id\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.id = \"\";\n\n    /**\n     * NumberInput label.\n     * @member {string} label\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.label = \"\";\n\n    /**\n     * NumberInput format.\n     * @member {string} format\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.format = \"\";\n\n    /**\n     * NumberInput hasMin.\n     * @member {boolean} hasMin\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.hasMin = false;\n\n    /**\n     * NumberInput hasMax.\n     * @member {boolean} hasMax\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.hasMax = false;\n\n    /**\n     * NumberInput dataType.\n     * @member {NumberInput.DataType} dataType\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.dataType = 0;\n\n    /**\n     * NumberInput default.\n     * @member {number} default\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype[\"default\"] = 0;\n\n    /**\n     * NumberInput step.\n     * @member {number} step\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.step = 0;\n\n    /**\n     * NumberInput min.\n     * @member {number} min\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.min = 0;\n\n    /**\n     * NumberInput max.\n     * @member {number} max\n     * @memberof NumberInput\n     * @instance\n     */\n    NumberInput.prototype.max = 0;\n\n    /**\n     * Creates a new NumberInput instance using the specified properties.\n     * @function create\n     * @memberof NumberInput\n     * @static\n     * @param {INumberInput=} [properties] Properties to set\n     * @returns {NumberInput} NumberInput instance\n     */\n    NumberInput.create = function create(properties) {\n        return new NumberInput(properties);\n    };\n\n    /**\n     * Encodes the specified NumberInput message. Does not implicitly {@link NumberInput.verify|verify} messages.\n     * @function encode\n     * @memberof NumberInput\n     * @static\n     * @param {INumberInput} message NumberInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NumberInput.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message.format != null && Object.hasOwnProperty.call(message, \"format\"))\n            writer.uint32(/* id 8, wireType 2 =*/66).string(message.format);\n        if (message.hasMin != null && Object.hasOwnProperty.call(message, \"hasMin\"))\n            writer.uint32(/* id 11, wireType 0 =*/88).bool(message.hasMin);\n        if (message.hasMax != null && Object.hasOwnProperty.call(message, \"hasMax\"))\n            writer.uint32(/* id 12, wireType 0 =*/96).bool(message.hasMax);\n        if (message.dataType != null && Object.hasOwnProperty.call(message, \"dataType\"))\n            writer.uint32(/* id 13, wireType 0 =*/104).int32(message.dataType);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 14, wireType 1 =*/113).double(message[\"default\"]);\n        if (message.step != null && Object.hasOwnProperty.call(message, \"step\"))\n            writer.uint32(/* id 15, wireType 1 =*/121).double(message.step);\n        if (message.min != null && Object.hasOwnProperty.call(message, \"min\"))\n            writer.uint32(/* id 16, wireType 1 =*/129).double(message.min);\n        if (message.max != null && Object.hasOwnProperty.call(message, \"max\"))\n            writer.uint32(/* id 17, wireType 1 =*/137).double(message.max);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified NumberInput message, length delimited. Does not implicitly {@link NumberInput.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof NumberInput\n     * @static\n     * @param {INumberInput} message NumberInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NumberInput.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a NumberInput message from the specified reader or buffer.\n     * @function decode\n     * @memberof NumberInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {NumberInput} NumberInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NumberInput.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.NumberInput();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 8:\n                message.format = reader.string();\n                break;\n            case 11:\n                message.hasMin = reader.bool();\n                break;\n            case 12:\n                message.hasMax = reader.bool();\n                break;\n            case 13:\n                message.dataType = reader.int32();\n                break;\n            case 14:\n                message[\"default\"] = reader.double();\n                break;\n            case 15:\n                message.step = reader.double();\n                break;\n            case 16:\n                message.min = reader.double();\n                break;\n            case 17:\n                message.max = reader.double();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a NumberInput message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof NumberInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {NumberInput} NumberInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NumberInput.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a NumberInput message.\n     * @function verify\n     * @memberof NumberInput\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    NumberInput.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message.format != null && message.hasOwnProperty(\"format\"))\n            if (!$util.isString(message.format))\n                return \"format: string expected\";\n        if (message.hasMin != null && message.hasOwnProperty(\"hasMin\"))\n            if (typeof message.hasMin !== \"boolean\")\n                return \"hasMin: boolean expected\";\n        if (message.hasMax != null && message.hasOwnProperty(\"hasMax\"))\n            if (typeof message.hasMax !== \"boolean\")\n                return \"hasMax: boolean expected\";\n        if (message.dataType != null && message.hasOwnProperty(\"dataType\"))\n            switch (message.dataType) {\n            default:\n                return \"dataType: enum value expected\";\n            case 0:\n            case 1:\n                break;\n            }\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (typeof message[\"default\"] !== \"number\")\n                return \"default: number expected\";\n        if (message.step != null && message.hasOwnProperty(\"step\"))\n            if (typeof message.step !== \"number\")\n                return \"step: number expected\";\n        if (message.min != null && message.hasOwnProperty(\"min\"))\n            if (typeof message.min !== \"number\")\n                return \"min: number expected\";\n        if (message.max != null && message.hasOwnProperty(\"max\"))\n            if (typeof message.max !== \"number\")\n                return \"max: number expected\";\n        return null;\n    };\n\n    /**\n     * Creates a NumberInput message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof NumberInput\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {NumberInput} NumberInput\n     */\n    NumberInput.fromObject = function fromObject(object) {\n        if (object instanceof $root.NumberInput)\n            return object;\n        let message = new $root.NumberInput();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object.format != null)\n            message.format = String(object.format);\n        if (object.hasMin != null)\n            message.hasMin = Boolean(object.hasMin);\n        if (object.hasMax != null)\n            message.hasMax = Boolean(object.hasMax);\n        switch (object.dataType) {\n        case \"INT\":\n        case 0:\n            message.dataType = 0;\n            break;\n        case \"FLOAT\":\n        case 1:\n            message.dataType = 1;\n            break;\n        }\n        if (object[\"default\"] != null)\n            message[\"default\"] = Number(object[\"default\"]);\n        if (object.step != null)\n            message.step = Number(object.step);\n        if (object.min != null)\n            message.min = Number(object.min);\n        if (object.max != null)\n            message.max = Number(object.max);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a NumberInput message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof NumberInput\n     * @static\n     * @param {NumberInput} message NumberInput\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    NumberInput.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object.format = \"\";\n            object.hasMin = false;\n            object.hasMax = false;\n            object.dataType = options.enums === String ? \"INT\" : 0;\n            object[\"default\"] = 0;\n            object.step = 0;\n            object.min = 0;\n            object.max = 0;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message.format != null && message.hasOwnProperty(\"format\"))\n            object.format = message.format;\n        if (message.hasMin != null && message.hasOwnProperty(\"hasMin\"))\n            object.hasMin = message.hasMin;\n        if (message.hasMax != null && message.hasOwnProperty(\"hasMax\"))\n            object.hasMax = message.hasMax;\n        if (message.dataType != null && message.hasOwnProperty(\"dataType\"))\n            object.dataType = options.enums === String ? $root.NumberInput.DataType[message.dataType] : message.dataType;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = options.json && !isFinite(message[\"default\"]) ? String(message[\"default\"]) : message[\"default\"];\n        if (message.step != null && message.hasOwnProperty(\"step\"))\n            object.step = options.json && !isFinite(message.step) ? String(message.step) : message.step;\n        if (message.min != null && message.hasOwnProperty(\"min\"))\n            object.min = options.json && !isFinite(message.min) ? String(message.min) : message.min;\n        if (message.max != null && message.hasOwnProperty(\"max\"))\n            object.max = options.json && !isFinite(message.max) ? String(message.max) : message.max;\n        return object;\n    };\n\n    /**\n     * Converts this NumberInput to JSON.\n     * @function toJSON\n     * @memberof NumberInput\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    NumberInput.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * DataType enum.\n     * @name NumberInput.DataType\n     * @enum {number}\n     * @property {number} INT=0 INT value\n     * @property {number} FLOAT=1 FLOAT value\n     */\n    NumberInput.DataType = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"INT\"] = 0;\n        values[valuesById[1] = \"FLOAT\"] = 1;\n        return values;\n    })();\n\n    return NumberInput;\n})();\n\nexport const PlotlyChart = $root.PlotlyChart = (() => {\n\n    /**\n     * Properties of a PlotlyChart.\n     * @exports IPlotlyChart\n     * @interface IPlotlyChart\n     * @property {string|null} [url] PlotlyChart url\n     * @property {IFigure|null} [figure] PlotlyChart figure\n     * @property {boolean|null} [useContainerWidth] PlotlyChart useContainerWidth\n     */\n\n    /**\n     * Constructs a new PlotlyChart.\n     * @exports PlotlyChart\n     * @classdesc Represents a PlotlyChart.\n     * @implements IPlotlyChart\n     * @constructor\n     * @param {IPlotlyChart=} [properties] Properties to set\n     */\n    function PlotlyChart(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * PlotlyChart url.\n     * @member {string} url\n     * @memberof PlotlyChart\n     * @instance\n     */\n    PlotlyChart.prototype.url = \"\";\n\n    /**\n     * PlotlyChart figure.\n     * @member {IFigure|null|undefined} figure\n     * @memberof PlotlyChart\n     * @instance\n     */\n    PlotlyChart.prototype.figure = null;\n\n    /**\n     * PlotlyChart useContainerWidth.\n     * @member {boolean} useContainerWidth\n     * @memberof PlotlyChart\n     * @instance\n     */\n    PlotlyChart.prototype.useContainerWidth = false;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * PlotlyChart chart.\n     * @member {\"url\"|\"figure\"|undefined} chart\n     * @memberof PlotlyChart\n     * @instance\n     */\n    Object.defineProperty(PlotlyChart.prototype, \"chart\", {\n        get: $util.oneOfGetter($oneOfFields = [\"url\", \"figure\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new PlotlyChart instance using the specified properties.\n     * @function create\n     * @memberof PlotlyChart\n     * @static\n     * @param {IPlotlyChart=} [properties] Properties to set\n     * @returns {PlotlyChart} PlotlyChart instance\n     */\n    PlotlyChart.create = function create(properties) {\n        return new PlotlyChart(properties);\n    };\n\n    /**\n     * Encodes the specified PlotlyChart message. Does not implicitly {@link PlotlyChart.verify|verify} messages.\n     * @function encode\n     * @memberof PlotlyChart\n     * @static\n     * @param {IPlotlyChart} message PlotlyChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    PlotlyChart.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.url != null && Object.hasOwnProperty.call(message, \"url\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.url);\n        if (message.figure != null && Object.hasOwnProperty.call(message, \"figure\"))\n            $root.Figure.encode(message.figure, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.useContainerWidth != null && Object.hasOwnProperty.call(message, \"useContainerWidth\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).bool(message.useContainerWidth);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified PlotlyChart message, length delimited. Does not implicitly {@link PlotlyChart.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof PlotlyChart\n     * @static\n     * @param {IPlotlyChart} message PlotlyChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    PlotlyChart.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a PlotlyChart message from the specified reader or buffer.\n     * @function decode\n     * @memberof PlotlyChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {PlotlyChart} PlotlyChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    PlotlyChart.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.PlotlyChart();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.url = reader.string();\n                break;\n            case 2:\n                message.figure = $root.Figure.decode(reader, reader.uint32());\n                break;\n            case 5:\n                message.useContainerWidth = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a PlotlyChart message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof PlotlyChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {PlotlyChart} PlotlyChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    PlotlyChart.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a PlotlyChart message.\n     * @function verify\n     * @memberof PlotlyChart\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    PlotlyChart.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.url != null && message.hasOwnProperty(\"url\")) {\n            properties.chart = 1;\n            if (!$util.isString(message.url))\n                return \"url: string expected\";\n        }\n        if (message.figure != null && message.hasOwnProperty(\"figure\")) {\n            if (properties.chart === 1)\n                return \"chart: multiple values\";\n            properties.chart = 1;\n            {\n                let error = $root.Figure.verify(message.figure);\n                if (error)\n                    return \"figure.\" + error;\n            }\n        }\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            if (typeof message.useContainerWidth !== \"boolean\")\n                return \"useContainerWidth: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a PlotlyChart message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof PlotlyChart\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {PlotlyChart} PlotlyChart\n     */\n    PlotlyChart.fromObject = function fromObject(object) {\n        if (object instanceof $root.PlotlyChart)\n            return object;\n        let message = new $root.PlotlyChart();\n        if (object.url != null)\n            message.url = String(object.url);\n        if (object.figure != null) {\n            if (typeof object.figure !== \"object\")\n                throw TypeError(\".PlotlyChart.figure: object expected\");\n            message.figure = $root.Figure.fromObject(object.figure);\n        }\n        if (object.useContainerWidth != null)\n            message.useContainerWidth = Boolean(object.useContainerWidth);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a PlotlyChart message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof PlotlyChart\n     * @static\n     * @param {PlotlyChart} message PlotlyChart\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    PlotlyChart.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.useContainerWidth = false;\n        if (message.url != null && message.hasOwnProperty(\"url\")) {\n            object.url = message.url;\n            if (options.oneofs)\n                object.chart = \"url\";\n        }\n        if (message.figure != null && message.hasOwnProperty(\"figure\")) {\n            object.figure = $root.Figure.toObject(message.figure, options);\n            if (options.oneofs)\n                object.chart = \"figure\";\n        }\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            object.useContainerWidth = message.useContainerWidth;\n        return object;\n    };\n\n    /**\n     * Converts this PlotlyChart to JSON.\n     * @function toJSON\n     * @memberof PlotlyChart\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    PlotlyChart.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return PlotlyChart;\n})();\n\nexport const Figure = $root.Figure = (() => {\n\n    /**\n     * Properties of a Figure.\n     * @exports IFigure\n     * @interface IFigure\n     * @property {string|null} [spec] Figure spec\n     * @property {string|null} [config] Figure config\n     */\n\n    /**\n     * Constructs a new Figure.\n     * @exports Figure\n     * @classdesc Represents a Figure.\n     * @implements IFigure\n     * @constructor\n     * @param {IFigure=} [properties] Properties to set\n     */\n    function Figure(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Figure spec.\n     * @member {string} spec\n     * @memberof Figure\n     * @instance\n     */\n    Figure.prototype.spec = \"\";\n\n    /**\n     * Figure config.\n     * @member {string} config\n     * @memberof Figure\n     * @instance\n     */\n    Figure.prototype.config = \"\";\n\n    /**\n     * Creates a new Figure instance using the specified properties.\n     * @function create\n     * @memberof Figure\n     * @static\n     * @param {IFigure=} [properties] Properties to set\n     * @returns {Figure} Figure instance\n     */\n    Figure.create = function create(properties) {\n        return new Figure(properties);\n    };\n\n    /**\n     * Encodes the specified Figure message. Does not implicitly {@link Figure.verify|verify} messages.\n     * @function encode\n     * @memberof Figure\n     * @static\n     * @param {IFigure} message Figure message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Figure.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.spec != null && Object.hasOwnProperty.call(message, \"spec\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.spec);\n        if (message.config != null && Object.hasOwnProperty.call(message, \"config\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.config);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Figure message, length delimited. Does not implicitly {@link Figure.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Figure\n     * @static\n     * @param {IFigure} message Figure message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Figure.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Figure message from the specified reader or buffer.\n     * @function decode\n     * @memberof Figure\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Figure} Figure\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Figure.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Figure();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.spec = reader.string();\n                break;\n            case 2:\n                message.config = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Figure message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Figure\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Figure} Figure\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Figure.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Figure message.\n     * @function verify\n     * @memberof Figure\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Figure.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            if (!$util.isString(message.spec))\n                return \"spec: string expected\";\n        if (message.config != null && message.hasOwnProperty(\"config\"))\n            if (!$util.isString(message.config))\n                return \"config: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Figure message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Figure\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Figure} Figure\n     */\n    Figure.fromObject = function fromObject(object) {\n        if (object instanceof $root.Figure)\n            return object;\n        let message = new $root.Figure();\n        if (object.spec != null)\n            message.spec = String(object.spec);\n        if (object.config != null)\n            message.config = String(object.config);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Figure message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Figure\n     * @static\n     * @param {Figure} message Figure\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Figure.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.spec = \"\";\n            object.config = \"\";\n        }\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            object.spec = message.spec;\n        if (message.config != null && message.hasOwnProperty(\"config\"))\n            object.config = message.config;\n        return object;\n    };\n\n    /**\n     * Converts this Figure to JSON.\n     * @function toJSON\n     * @memberof Figure\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Figure.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Figure;\n})();\n\nexport const Progress = $root.Progress = (() => {\n\n    /**\n     * Properties of a Progress.\n     * @exports IProgress\n     * @interface IProgress\n     * @property {number|null} [value] Progress value\n     */\n\n    /**\n     * Constructs a new Progress.\n     * @exports Progress\n     * @classdesc Represents a Progress.\n     * @implements IProgress\n     * @constructor\n     * @param {IProgress=} [properties] Properties to set\n     */\n    function Progress(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Progress value.\n     * @member {number} value\n     * @memberof Progress\n     * @instance\n     */\n    Progress.prototype.value = 0;\n\n    /**\n     * Creates a new Progress instance using the specified properties.\n     * @function create\n     * @memberof Progress\n     * @static\n     * @param {IProgress=} [properties] Properties to set\n     * @returns {Progress} Progress instance\n     */\n    Progress.create = function create(properties) {\n        return new Progress(properties);\n    };\n\n    /**\n     * Encodes the specified Progress message. Does not implicitly {@link Progress.verify|verify} messages.\n     * @function encode\n     * @memberof Progress\n     * @static\n     * @param {IProgress} message Progress message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Progress.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.value != null && Object.hasOwnProperty.call(message, \"value\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.value);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Progress message, length delimited. Does not implicitly {@link Progress.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Progress\n     * @static\n     * @param {IProgress} message Progress message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Progress.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Progress message from the specified reader or buffer.\n     * @function decode\n     * @memberof Progress\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Progress} Progress\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Progress.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Progress();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.value = reader.uint32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Progress message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Progress\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Progress} Progress\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Progress.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Progress message.\n     * @function verify\n     * @memberof Progress\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Progress.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.value != null && message.hasOwnProperty(\"value\"))\n            if (!$util.isInteger(message.value))\n                return \"value: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Progress message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Progress\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Progress} Progress\n     */\n    Progress.fromObject = function fromObject(object) {\n        if (object instanceof $root.Progress)\n            return object;\n        let message = new $root.Progress();\n        if (object.value != null)\n            message.value = object.value >>> 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Progress message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Progress\n     * @static\n     * @param {Progress} message Progress\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Progress.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.value = 0;\n        if (message.value != null && message.hasOwnProperty(\"value\"))\n            object.value = message.value;\n        return object;\n    };\n\n    /**\n     * Converts this Progress to JSON.\n     * @function toJSON\n     * @memberof Progress\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Progress.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Progress;\n})();\n\nexport const Radio = $root.Radio = (() => {\n\n    /**\n     * Properties of a Radio.\n     * @exports IRadio\n     * @interface IRadio\n     * @property {string|null} [id] Radio id\n     * @property {string|null} [label] Radio label\n     * @property {number|null} [\"default\"] Radio default\n     * @property {Array.<string>|null} [options] Radio options\n     */\n\n    /**\n     * Constructs a new Radio.\n     * @exports Radio\n     * @classdesc Represents a Radio.\n     * @implements IRadio\n     * @constructor\n     * @param {IRadio=} [properties] Properties to set\n     */\n    function Radio(properties) {\n        this.options = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Radio id.\n     * @member {string} id\n     * @memberof Radio\n     * @instance\n     */\n    Radio.prototype.id = \"\";\n\n    /**\n     * Radio label.\n     * @member {string} label\n     * @memberof Radio\n     * @instance\n     */\n    Radio.prototype.label = \"\";\n\n    /**\n     * Radio default.\n     * @member {number} default\n     * @memberof Radio\n     * @instance\n     */\n    Radio.prototype[\"default\"] = 0;\n\n    /**\n     * Radio options.\n     * @member {Array.<string>} options\n     * @memberof Radio\n     * @instance\n     */\n    Radio.prototype.options = $util.emptyArray;\n\n    /**\n     * Creates a new Radio instance using the specified properties.\n     * @function create\n     * @memberof Radio\n     * @static\n     * @param {IRadio=} [properties] Properties to set\n     * @returns {Radio} Radio instance\n     */\n    Radio.create = function create(properties) {\n        return new Radio(properties);\n    };\n\n    /**\n     * Encodes the specified Radio message. Does not implicitly {@link Radio.verify|verify} messages.\n     * @function encode\n     * @memberof Radio\n     * @static\n     * @param {IRadio} message Radio message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Radio.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).int32(message[\"default\"]);\n        if (message.options != null && message.options.length)\n            for (let i = 0; i < message.options.length; ++i)\n                writer.uint32(/* id 4, wireType 2 =*/34).string(message.options[i]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Radio message, length delimited. Does not implicitly {@link Radio.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Radio\n     * @static\n     * @param {IRadio} message Radio message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Radio.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Radio message from the specified reader or buffer.\n     * @function decode\n     * @memberof Radio\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Radio} Radio\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Radio.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Radio();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.int32();\n                break;\n            case 4:\n                if (!(message.options && message.options.length))\n                    message.options = [];\n                message.options.push(reader.string());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Radio message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Radio\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Radio} Radio\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Radio.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Radio message.\n     * @function verify\n     * @memberof Radio\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Radio.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (!$util.isInteger(message[\"default\"]))\n                return \"default: integer expected\";\n        if (message.options != null && message.hasOwnProperty(\"options\")) {\n            if (!Array.isArray(message.options))\n                return \"options: array expected\";\n            for (let i = 0; i < message.options.length; ++i)\n                if (!$util.isString(message.options[i]))\n                    return \"options: string[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a Radio message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Radio\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Radio} Radio\n     */\n    Radio.fromObject = function fromObject(object) {\n        if (object instanceof $root.Radio)\n            return object;\n        let message = new $root.Radio();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = object[\"default\"] | 0;\n        if (object.options) {\n            if (!Array.isArray(object.options))\n                throw TypeError(\".Radio.options: array expected\");\n            message.options = [];\n            for (let i = 0; i < object.options.length; ++i)\n                message.options[i] = String(object.options[i]);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Radio message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Radio\n     * @static\n     * @param {Radio} message Radio\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Radio.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.options = [];\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = 0;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        if (message.options && message.options.length) {\n            object.options = [];\n            for (let j = 0; j < message.options.length; ++j)\n                object.options[j] = message.options[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Radio to JSON.\n     * @function toJSON\n     * @memberof Radio\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Radio.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Radio;\n})();\n\nexport const ReportProperties = $root.ReportProperties = (() => {\n\n    /**\n     * Properties of a ReportProperties.\n     * @exports IReportProperties\n     * @interface IReportProperties\n     * @property {string|null} [title] ReportProperties title\n     * @property {string|null} [favicon] ReportProperties favicon\n     */\n\n    /**\n     * Constructs a new ReportProperties.\n     * @exports ReportProperties\n     * @classdesc Represents a ReportProperties.\n     * @implements IReportProperties\n     * @constructor\n     * @param {IReportProperties=} [properties] Properties to set\n     */\n    function ReportProperties(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ReportProperties title.\n     * @member {string} title\n     * @memberof ReportProperties\n     * @instance\n     */\n    ReportProperties.prototype.title = \"\";\n\n    /**\n     * ReportProperties favicon.\n     * @member {string} favicon\n     * @memberof ReportProperties\n     * @instance\n     */\n    ReportProperties.prototype.favicon = \"\";\n\n    /**\n     * Creates a new ReportProperties instance using the specified properties.\n     * @function create\n     * @memberof ReportProperties\n     * @static\n     * @param {IReportProperties=} [properties] Properties to set\n     * @returns {ReportProperties} ReportProperties instance\n     */\n    ReportProperties.create = function create(properties) {\n        return new ReportProperties(properties);\n    };\n\n    /**\n     * Encodes the specified ReportProperties message. Does not implicitly {@link ReportProperties.verify|verify} messages.\n     * @function encode\n     * @memberof ReportProperties\n     * @static\n     * @param {IReportProperties} message ReportProperties message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ReportProperties.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.title != null && Object.hasOwnProperty.call(message, \"title\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.title);\n        if (message.favicon != null && Object.hasOwnProperty.call(message, \"favicon\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.favicon);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified ReportProperties message, length delimited. Does not implicitly {@link ReportProperties.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof ReportProperties\n     * @static\n     * @param {IReportProperties} message ReportProperties message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ReportProperties.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a ReportProperties message from the specified reader or buffer.\n     * @function decode\n     * @memberof ReportProperties\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {ReportProperties} ReportProperties\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ReportProperties.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ReportProperties();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.title = reader.string();\n                break;\n            case 2:\n                message.favicon = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a ReportProperties message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof ReportProperties\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {ReportProperties} ReportProperties\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ReportProperties.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a ReportProperties message.\n     * @function verify\n     * @memberof ReportProperties\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ReportProperties.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.title != null && message.hasOwnProperty(\"title\"))\n            if (!$util.isString(message.title))\n                return \"title: string expected\";\n        if (message.favicon != null && message.hasOwnProperty(\"favicon\"))\n            if (!$util.isString(message.favicon))\n                return \"favicon: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a ReportProperties message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof ReportProperties\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {ReportProperties} ReportProperties\n     */\n    ReportProperties.fromObject = function fromObject(object) {\n        if (object instanceof $root.ReportProperties)\n            return object;\n        let message = new $root.ReportProperties();\n        if (object.title != null)\n            message.title = String(object.title);\n        if (object.favicon != null)\n            message.favicon = String(object.favicon);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a ReportProperties message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof ReportProperties\n     * @static\n     * @param {ReportProperties} message ReportProperties\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ReportProperties.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.title = \"\";\n            object.favicon = \"\";\n        }\n        if (message.title != null && message.hasOwnProperty(\"title\"))\n            object.title = message.title;\n        if (message.favicon != null && message.hasOwnProperty(\"favicon\"))\n            object.favicon = message.favicon;\n        return object;\n    };\n\n    /**\n     * Converts this ReportProperties to JSON.\n     * @function toJSON\n     * @memberof ReportProperties\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ReportProperties.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return ReportProperties;\n})();\n\nexport const Selectbox = $root.Selectbox = (() => {\n\n    /**\n     * Properties of a Selectbox.\n     * @exports ISelectbox\n     * @interface ISelectbox\n     * @property {string|null} [id] Selectbox id\n     * @property {string|null} [label] Selectbox label\n     * @property {number|null} [\"default\"] Selectbox default\n     * @property {Array.<string>|null} [options] Selectbox options\n     */\n\n    /**\n     * Constructs a new Selectbox.\n     * @exports Selectbox\n     * @classdesc Represents a Selectbox.\n     * @implements ISelectbox\n     * @constructor\n     * @param {ISelectbox=} [properties] Properties to set\n     */\n    function Selectbox(properties) {\n        this.options = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Selectbox id.\n     * @member {string} id\n     * @memberof Selectbox\n     * @instance\n     */\n    Selectbox.prototype.id = \"\";\n\n    /**\n     * Selectbox label.\n     * @member {string} label\n     * @memberof Selectbox\n     * @instance\n     */\n    Selectbox.prototype.label = \"\";\n\n    /**\n     * Selectbox default.\n     * @member {number} default\n     * @memberof Selectbox\n     * @instance\n     */\n    Selectbox.prototype[\"default\"] = 0;\n\n    /**\n     * Selectbox options.\n     * @member {Array.<string>} options\n     * @memberof Selectbox\n     * @instance\n     */\n    Selectbox.prototype.options = $util.emptyArray;\n\n    /**\n     * Creates a new Selectbox instance using the specified properties.\n     * @function create\n     * @memberof Selectbox\n     * @static\n     * @param {ISelectbox=} [properties] Properties to set\n     * @returns {Selectbox} Selectbox instance\n     */\n    Selectbox.create = function create(properties) {\n        return new Selectbox(properties);\n    };\n\n    /**\n     * Encodes the specified Selectbox message. Does not implicitly {@link Selectbox.verify|verify} messages.\n     * @function encode\n     * @memberof Selectbox\n     * @static\n     * @param {ISelectbox} message Selectbox message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Selectbox.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).int32(message[\"default\"]);\n        if (message.options != null && message.options.length)\n            for (let i = 0; i < message.options.length; ++i)\n                writer.uint32(/* id 4, wireType 2 =*/34).string(message.options[i]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Selectbox message, length delimited. Does not implicitly {@link Selectbox.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Selectbox\n     * @static\n     * @param {ISelectbox} message Selectbox message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Selectbox.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Selectbox message from the specified reader or buffer.\n     * @function decode\n     * @memberof Selectbox\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Selectbox} Selectbox\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Selectbox.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Selectbox();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.int32();\n                break;\n            case 4:\n                if (!(message.options && message.options.length))\n                    message.options = [];\n                message.options.push(reader.string());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Selectbox message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Selectbox\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Selectbox} Selectbox\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Selectbox.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Selectbox message.\n     * @function verify\n     * @memberof Selectbox\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Selectbox.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (!$util.isInteger(message[\"default\"]))\n                return \"default: integer expected\";\n        if (message.options != null && message.hasOwnProperty(\"options\")) {\n            if (!Array.isArray(message.options))\n                return \"options: array expected\";\n            for (let i = 0; i < message.options.length; ++i)\n                if (!$util.isString(message.options[i]))\n                    return \"options: string[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a Selectbox message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Selectbox\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Selectbox} Selectbox\n     */\n    Selectbox.fromObject = function fromObject(object) {\n        if (object instanceof $root.Selectbox)\n            return object;\n        let message = new $root.Selectbox();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = object[\"default\"] | 0;\n        if (object.options) {\n            if (!Array.isArray(object.options))\n                throw TypeError(\".Selectbox.options: array expected\");\n            message.options = [];\n            for (let i = 0; i < object.options.length; ++i)\n                message.options[i] = String(object.options[i]);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Selectbox message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Selectbox\n     * @static\n     * @param {Selectbox} message Selectbox\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Selectbox.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.options = [];\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = 0;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        if (message.options && message.options.length) {\n            object.options = [];\n            for (let j = 0; j < message.options.length; ++j)\n                object.options[j] = message.options[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this Selectbox to JSON.\n     * @function toJSON\n     * @memberof Selectbox\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Selectbox.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Selectbox;\n})();\n\nexport const SessionEvent = $root.SessionEvent = (() => {\n\n    /**\n     * Properties of a SessionEvent.\n     * @exports ISessionEvent\n     * @interface ISessionEvent\n     * @property {boolean|null} [reportChangedOnDisk] SessionEvent reportChangedOnDisk\n     * @property {boolean|null} [reportWasManuallyStopped] SessionEvent reportWasManuallyStopped\n     * @property {IException|null} [scriptCompilationException] SessionEvent scriptCompilationException\n     */\n\n    /**\n     * Constructs a new SessionEvent.\n     * @exports SessionEvent\n     * @classdesc Represents a SessionEvent.\n     * @implements ISessionEvent\n     * @constructor\n     * @param {ISessionEvent=} [properties] Properties to set\n     */\n    function SessionEvent(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * SessionEvent reportChangedOnDisk.\n     * @member {boolean} reportChangedOnDisk\n     * @memberof SessionEvent\n     * @instance\n     */\n    SessionEvent.prototype.reportChangedOnDisk = false;\n\n    /**\n     * SessionEvent reportWasManuallyStopped.\n     * @member {boolean} reportWasManuallyStopped\n     * @memberof SessionEvent\n     * @instance\n     */\n    SessionEvent.prototype.reportWasManuallyStopped = false;\n\n    /**\n     * SessionEvent scriptCompilationException.\n     * @member {IException|null|undefined} scriptCompilationException\n     * @memberof SessionEvent\n     * @instance\n     */\n    SessionEvent.prototype.scriptCompilationException = null;\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * SessionEvent type.\n     * @member {\"reportChangedOnDisk\"|\"reportWasManuallyStopped\"|\"scriptCompilationException\"|undefined} type\n     * @memberof SessionEvent\n     * @instance\n     */\n    Object.defineProperty(SessionEvent.prototype, \"type\", {\n        get: $util.oneOfGetter($oneOfFields = [\"reportChangedOnDisk\", \"reportWasManuallyStopped\", \"scriptCompilationException\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new SessionEvent instance using the specified properties.\n     * @function create\n     * @memberof SessionEvent\n     * @static\n     * @param {ISessionEvent=} [properties] Properties to set\n     * @returns {SessionEvent} SessionEvent instance\n     */\n    SessionEvent.create = function create(properties) {\n        return new SessionEvent(properties);\n    };\n\n    /**\n     * Encodes the specified SessionEvent message. Does not implicitly {@link SessionEvent.verify|verify} messages.\n     * @function encode\n     * @memberof SessionEvent\n     * @static\n     * @param {ISessionEvent} message SessionEvent message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    SessionEvent.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.reportChangedOnDisk != null && Object.hasOwnProperty.call(message, \"reportChangedOnDisk\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).bool(message.reportChangedOnDisk);\n        if (message.reportWasManuallyStopped != null && Object.hasOwnProperty.call(message, \"reportWasManuallyStopped\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.reportWasManuallyStopped);\n        if (message.scriptCompilationException != null && Object.hasOwnProperty.call(message, \"scriptCompilationException\"))\n            $root.Exception.encode(message.scriptCompilationException, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified SessionEvent message, length delimited. Does not implicitly {@link SessionEvent.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof SessionEvent\n     * @static\n     * @param {ISessionEvent} message SessionEvent message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    SessionEvent.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a SessionEvent message from the specified reader or buffer.\n     * @function decode\n     * @memberof SessionEvent\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {SessionEvent} SessionEvent\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    SessionEvent.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.SessionEvent();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.reportChangedOnDisk = reader.bool();\n                break;\n            case 2:\n                message.reportWasManuallyStopped = reader.bool();\n                break;\n            case 3:\n                message.scriptCompilationException = $root.Exception.decode(reader, reader.uint32());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a SessionEvent message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof SessionEvent\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {SessionEvent} SessionEvent\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    SessionEvent.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a SessionEvent message.\n     * @function verify\n     * @memberof SessionEvent\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    SessionEvent.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.reportChangedOnDisk != null && message.hasOwnProperty(\"reportChangedOnDisk\")) {\n            properties.type = 1;\n            if (typeof message.reportChangedOnDisk !== \"boolean\")\n                return \"reportChangedOnDisk: boolean expected\";\n        }\n        if (message.reportWasManuallyStopped != null && message.hasOwnProperty(\"reportWasManuallyStopped\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            if (typeof message.reportWasManuallyStopped !== \"boolean\")\n                return \"reportWasManuallyStopped: boolean expected\";\n        }\n        if (message.scriptCompilationException != null && message.hasOwnProperty(\"scriptCompilationException\")) {\n            if (properties.type === 1)\n                return \"type: multiple values\";\n            properties.type = 1;\n            {\n                let error = $root.Exception.verify(message.scriptCompilationException);\n                if (error)\n                    return \"scriptCompilationException.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates a SessionEvent message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof SessionEvent\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {SessionEvent} SessionEvent\n     */\n    SessionEvent.fromObject = function fromObject(object) {\n        if (object instanceof $root.SessionEvent)\n            return object;\n        let message = new $root.SessionEvent();\n        if (object.reportChangedOnDisk != null)\n            message.reportChangedOnDisk = Boolean(object.reportChangedOnDisk);\n        if (object.reportWasManuallyStopped != null)\n            message.reportWasManuallyStopped = Boolean(object.reportWasManuallyStopped);\n        if (object.scriptCompilationException != null) {\n            if (typeof object.scriptCompilationException !== \"object\")\n                throw TypeError(\".SessionEvent.scriptCompilationException: object expected\");\n            message.scriptCompilationException = $root.Exception.fromObject(object.scriptCompilationException);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a SessionEvent message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof SessionEvent\n     * @static\n     * @param {SessionEvent} message SessionEvent\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    SessionEvent.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (message.reportChangedOnDisk != null && message.hasOwnProperty(\"reportChangedOnDisk\")) {\n            object.reportChangedOnDisk = message.reportChangedOnDisk;\n            if (options.oneofs)\n                object.type = \"reportChangedOnDisk\";\n        }\n        if (message.reportWasManuallyStopped != null && message.hasOwnProperty(\"reportWasManuallyStopped\")) {\n            object.reportWasManuallyStopped = message.reportWasManuallyStopped;\n            if (options.oneofs)\n                object.type = \"reportWasManuallyStopped\";\n        }\n        if (message.scriptCompilationException != null && message.hasOwnProperty(\"scriptCompilationException\")) {\n            object.scriptCompilationException = $root.Exception.toObject(message.scriptCompilationException, options);\n            if (options.oneofs)\n                object.type = \"scriptCompilationException\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this SessionEvent to JSON.\n     * @function toJSON\n     * @memberof SessionEvent\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    SessionEvent.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return SessionEvent;\n})();\n\nexport const SessionState = $root.SessionState = (() => {\n\n    /**\n     * Properties of a SessionState.\n     * @exports ISessionState\n     * @interface ISessionState\n     * @property {boolean|null} [runOnSave] SessionState runOnSave\n     * @property {boolean|null} [reportIsRunning] SessionState reportIsRunning\n     */\n\n    /**\n     * Constructs a new SessionState.\n     * @exports SessionState\n     * @classdesc Represents a SessionState.\n     * @implements ISessionState\n     * @constructor\n     * @param {ISessionState=} [properties] Properties to set\n     */\n    function SessionState(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * SessionState runOnSave.\n     * @member {boolean} runOnSave\n     * @memberof SessionState\n     * @instance\n     */\n    SessionState.prototype.runOnSave = false;\n\n    /**\n     * SessionState reportIsRunning.\n     * @member {boolean} reportIsRunning\n     * @memberof SessionState\n     * @instance\n     */\n    SessionState.prototype.reportIsRunning = false;\n\n    /**\n     * Creates a new SessionState instance using the specified properties.\n     * @function create\n     * @memberof SessionState\n     * @static\n     * @param {ISessionState=} [properties] Properties to set\n     * @returns {SessionState} SessionState instance\n     */\n    SessionState.create = function create(properties) {\n        return new SessionState(properties);\n    };\n\n    /**\n     * Encodes the specified SessionState message. Does not implicitly {@link SessionState.verify|verify} messages.\n     * @function encode\n     * @memberof SessionState\n     * @static\n     * @param {ISessionState} message SessionState message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    SessionState.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.runOnSave != null && Object.hasOwnProperty.call(message, \"runOnSave\"))\n            writer.uint32(/* id 1, wireType 0 =*/8).bool(message.runOnSave);\n        if (message.reportIsRunning != null && Object.hasOwnProperty.call(message, \"reportIsRunning\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.reportIsRunning);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified SessionState message, length delimited. Does not implicitly {@link SessionState.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof SessionState\n     * @static\n     * @param {ISessionState} message SessionState message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    SessionState.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a SessionState message from the specified reader or buffer.\n     * @function decode\n     * @memberof SessionState\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {SessionState} SessionState\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    SessionState.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.SessionState();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.runOnSave = reader.bool();\n                break;\n            case 2:\n                message.reportIsRunning = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a SessionState message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof SessionState\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {SessionState} SessionState\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    SessionState.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a SessionState message.\n     * @function verify\n     * @memberof SessionState\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    SessionState.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.runOnSave != null && message.hasOwnProperty(\"runOnSave\"))\n            if (typeof message.runOnSave !== \"boolean\")\n                return \"runOnSave: boolean expected\";\n        if (message.reportIsRunning != null && message.hasOwnProperty(\"reportIsRunning\"))\n            if (typeof message.reportIsRunning !== \"boolean\")\n                return \"reportIsRunning: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a SessionState message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof SessionState\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {SessionState} SessionState\n     */\n    SessionState.fromObject = function fromObject(object) {\n        if (object instanceof $root.SessionState)\n            return object;\n        let message = new $root.SessionState();\n        if (object.runOnSave != null)\n            message.runOnSave = Boolean(object.runOnSave);\n        if (object.reportIsRunning != null)\n            message.reportIsRunning = Boolean(object.reportIsRunning);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a SessionState message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof SessionState\n     * @static\n     * @param {SessionState} message SessionState\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    SessionState.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.runOnSave = false;\n            object.reportIsRunning = false;\n        }\n        if (message.runOnSave != null && message.hasOwnProperty(\"runOnSave\"))\n            object.runOnSave = message.runOnSave;\n        if (message.reportIsRunning != null && message.hasOwnProperty(\"reportIsRunning\"))\n            object.reportIsRunning = message.reportIsRunning;\n        return object;\n    };\n\n    /**\n     * Converts this SessionState to JSON.\n     * @function toJSON\n     * @memberof SessionState\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    SessionState.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return SessionState;\n})();\n\nexport const Slider = $root.Slider = (() => {\n\n    /**\n     * Properties of a Slider.\n     * @exports ISlider\n     * @interface ISlider\n     * @property {string|null} [id] Slider id\n     * @property {string|null} [label] Slider label\n     * @property {string|null} [format] Slider format\n     * @property {Slider.DataType|null} [dataType] Slider dataType\n     * @property {Array.<number>|null} [\"default\"] Slider default\n     * @property {number|null} [min] Slider min\n     * @property {number|null} [max] Slider max\n     * @property {number|null} [step] Slider step\n     */\n\n    /**\n     * Constructs a new Slider.\n     * @exports Slider\n     * @classdesc Represents a Slider.\n     * @implements ISlider\n     * @constructor\n     * @param {ISlider=} [properties] Properties to set\n     */\n    function Slider(properties) {\n        this[\"default\"] = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Slider id.\n     * @member {string} id\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype.id = \"\";\n\n    /**\n     * Slider label.\n     * @member {string} label\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype.label = \"\";\n\n    /**\n     * Slider format.\n     * @member {string} format\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype.format = \"\";\n\n    /**\n     * Slider dataType.\n     * @member {Slider.DataType} dataType\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype.dataType = 0;\n\n    /**\n     * Slider default.\n     * @member {Array.<number>} default\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype[\"default\"] = $util.emptyArray;\n\n    /**\n     * Slider min.\n     * @member {number} min\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype.min = 0;\n\n    /**\n     * Slider max.\n     * @member {number} max\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype.max = 0;\n\n    /**\n     * Slider step.\n     * @member {number} step\n     * @memberof Slider\n     * @instance\n     */\n    Slider.prototype.step = 0;\n\n    /**\n     * Creates a new Slider instance using the specified properties.\n     * @function create\n     * @memberof Slider\n     * @static\n     * @param {ISlider=} [properties] Properties to set\n     * @returns {Slider} Slider instance\n     */\n    Slider.create = function create(properties) {\n        return new Slider(properties);\n    };\n\n    /**\n     * Encodes the specified Slider message. Does not implicitly {@link Slider.verify|verify} messages.\n     * @function encode\n     * @memberof Slider\n     * @static\n     * @param {ISlider} message Slider message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Slider.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message.format != null && Object.hasOwnProperty.call(message, \"format\"))\n            writer.uint32(/* id 7, wireType 2 =*/58).string(message.format);\n        if (message[\"default\"] != null && message[\"default\"].length) {\n            writer.uint32(/* id 8, wireType 2 =*/66).fork();\n            for (let i = 0; i < message[\"default\"].length; ++i)\n                writer.double(message[\"default\"][i]);\n            writer.ldelim();\n        }\n        if (message.min != null && Object.hasOwnProperty.call(message, \"min\"))\n            writer.uint32(/* id 9, wireType 1 =*/73).double(message.min);\n        if (message.max != null && Object.hasOwnProperty.call(message, \"max\"))\n            writer.uint32(/* id 10, wireType 1 =*/81).double(message.max);\n        if (message.step != null && Object.hasOwnProperty.call(message, \"step\"))\n            writer.uint32(/* id 11, wireType 1 =*/89).double(message.step);\n        if (message.dataType != null && Object.hasOwnProperty.call(message, \"dataType\"))\n            writer.uint32(/* id 12, wireType 0 =*/96).int32(message.dataType);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Slider message, length delimited. Does not implicitly {@link Slider.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Slider\n     * @static\n     * @param {ISlider} message Slider message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Slider.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Slider message from the specified reader or buffer.\n     * @function decode\n     * @memberof Slider\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Slider} Slider\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Slider.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Slider();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 7:\n                message.format = reader.string();\n                break;\n            case 12:\n                message.dataType = reader.int32();\n                break;\n            case 8:\n                if (!(message[\"default\"] && message[\"default\"].length))\n                    message[\"default\"] = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message[\"default\"].push(reader.double());\n                } else\n                    message[\"default\"].push(reader.double());\n                break;\n            case 9:\n                message.min = reader.double();\n                break;\n            case 10:\n                message.max = reader.double();\n                break;\n            case 11:\n                message.step = reader.double();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Slider message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Slider\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Slider} Slider\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Slider.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Slider message.\n     * @function verify\n     * @memberof Slider\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Slider.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message.format != null && message.hasOwnProperty(\"format\"))\n            if (!$util.isString(message.format))\n                return \"format: string expected\";\n        if (message.dataType != null && message.hasOwnProperty(\"dataType\"))\n            switch (message.dataType) {\n            default:\n                return \"dataType: enum value expected\";\n            case 0:\n            case 1:\n            case 2:\n            case 3:\n            case 4:\n                break;\n            }\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\")) {\n            if (!Array.isArray(message[\"default\"]))\n                return \"default: array expected\";\n            for (let i = 0; i < message[\"default\"].length; ++i)\n                if (typeof message[\"default\"][i] !== \"number\")\n                    return \"default: number[] expected\";\n        }\n        if (message.min != null && message.hasOwnProperty(\"min\"))\n            if (typeof message.min !== \"number\")\n                return \"min: number expected\";\n        if (message.max != null && message.hasOwnProperty(\"max\"))\n            if (typeof message.max !== \"number\")\n                return \"max: number expected\";\n        if (message.step != null && message.hasOwnProperty(\"step\"))\n            if (typeof message.step !== \"number\")\n                return \"step: number expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Slider message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Slider\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Slider} Slider\n     */\n    Slider.fromObject = function fromObject(object) {\n        if (object instanceof $root.Slider)\n            return object;\n        let message = new $root.Slider();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object.format != null)\n            message.format = String(object.format);\n        switch (object.dataType) {\n        case \"INT\":\n        case 0:\n            message.dataType = 0;\n            break;\n        case \"FLOAT\":\n        case 1:\n            message.dataType = 1;\n            break;\n        case \"DATETIME\":\n        case 2:\n            message.dataType = 2;\n            break;\n        case \"DATE\":\n        case 3:\n            message.dataType = 3;\n            break;\n        case \"TIME\":\n        case 4:\n            message.dataType = 4;\n            break;\n        }\n        if (object[\"default\"]) {\n            if (!Array.isArray(object[\"default\"]))\n                throw TypeError(\".Slider.default: array expected\");\n            message[\"default\"] = [];\n            for (let i = 0; i < object[\"default\"].length; ++i)\n                message[\"default\"][i] = Number(object[\"default\"][i]);\n        }\n        if (object.min != null)\n            message.min = Number(object.min);\n        if (object.max != null)\n            message.max = Number(object.max);\n        if (object.step != null)\n            message.step = Number(object.step);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Slider message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Slider\n     * @static\n     * @param {Slider} message Slider\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Slider.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object[\"default\"] = [];\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object.format = \"\";\n            object.min = 0;\n            object.max = 0;\n            object.step = 0;\n            object.dataType = options.enums === String ? \"INT\" : 0;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message.format != null && message.hasOwnProperty(\"format\"))\n            object.format = message.format;\n        if (message[\"default\"] && message[\"default\"].length) {\n            object[\"default\"] = [];\n            for (let j = 0; j < message[\"default\"].length; ++j)\n                object[\"default\"][j] = options.json && !isFinite(message[\"default\"][j]) ? String(message[\"default\"][j]) : message[\"default\"][j];\n        }\n        if (message.min != null && message.hasOwnProperty(\"min\"))\n            object.min = options.json && !isFinite(message.min) ? String(message.min) : message.min;\n        if (message.max != null && message.hasOwnProperty(\"max\"))\n            object.max = options.json && !isFinite(message.max) ? String(message.max) : message.max;\n        if (message.step != null && message.hasOwnProperty(\"step\"))\n            object.step = options.json && !isFinite(message.step) ? String(message.step) : message.step;\n        if (message.dataType != null && message.hasOwnProperty(\"dataType\"))\n            object.dataType = options.enums === String ? $root.Slider.DataType[message.dataType] : message.dataType;\n        return object;\n    };\n\n    /**\n     * Converts this Slider to JSON.\n     * @function toJSON\n     * @memberof Slider\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Slider.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * DataType enum.\n     * @name Slider.DataType\n     * @enum {number}\n     * @property {number} INT=0 INT value\n     * @property {number} FLOAT=1 FLOAT value\n     * @property {number} DATETIME=2 DATETIME value\n     * @property {number} DATE=3 DATE value\n     * @property {number} TIME=4 TIME value\n     */\n    Slider.DataType = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"INT\"] = 0;\n        values[valuesById[1] = \"FLOAT\"] = 1;\n        values[valuesById[2] = \"DATETIME\"] = 2;\n        values[valuesById[3] = \"DATE\"] = 3;\n        values[valuesById[4] = \"TIME\"] = 4;\n        return values;\n    })();\n\n    return Slider;\n})();\n\nexport const StaticManifest = $root.StaticManifest = (() => {\n\n    /**\n     * Properties of a StaticManifest.\n     * @exports IStaticManifest\n     * @interface IStaticManifest\n     * @property {string|null} [name] StaticManifest name\n     * @property {number|null} [numMessages] StaticManifest numMessages\n     * @property {StaticManifest.ServerStatus|null} [serverStatus] StaticManifest serverStatus\n     * @property {string|null} [configuredServerAddress] StaticManifest configuredServerAddress\n     * @property {string|null} [externalServerIp] StaticManifest externalServerIp\n     * @property {string|null} [internalServerIp] StaticManifest internalServerIp\n     * @property {number|null} [serverPort] StaticManifest serverPort\n     * @property {string|null} [serverBasePath] StaticManifest serverBasePath\n     */\n\n    /**\n     * Constructs a new StaticManifest.\n     * @exports StaticManifest\n     * @classdesc Represents a StaticManifest.\n     * @implements IStaticManifest\n     * @constructor\n     * @param {IStaticManifest=} [properties] Properties to set\n     */\n    function StaticManifest(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * StaticManifest name.\n     * @member {string} name\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.name = \"\";\n\n    /**\n     * StaticManifest numMessages.\n     * @member {number} numMessages\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.numMessages = 0;\n\n    /**\n     * StaticManifest serverStatus.\n     * @member {StaticManifest.ServerStatus} serverStatus\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.serverStatus = 0;\n\n    /**\n     * StaticManifest configuredServerAddress.\n     * @member {string} configuredServerAddress\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.configuredServerAddress = \"\";\n\n    /**\n     * StaticManifest externalServerIp.\n     * @member {string} externalServerIp\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.externalServerIp = \"\";\n\n    /**\n     * StaticManifest internalServerIp.\n     * @member {string} internalServerIp\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.internalServerIp = \"\";\n\n    /**\n     * StaticManifest serverPort.\n     * @member {number} serverPort\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.serverPort = 0;\n\n    /**\n     * StaticManifest serverBasePath.\n     * @member {string} serverBasePath\n     * @memberof StaticManifest\n     * @instance\n     */\n    StaticManifest.prototype.serverBasePath = \"\";\n\n    /**\n     * Creates a new StaticManifest instance using the specified properties.\n     * @function create\n     * @memberof StaticManifest\n     * @static\n     * @param {IStaticManifest=} [properties] Properties to set\n     * @returns {StaticManifest} StaticManifest instance\n     */\n    StaticManifest.create = function create(properties) {\n        return new StaticManifest(properties);\n    };\n\n    /**\n     * Encodes the specified StaticManifest message. Does not implicitly {@link StaticManifest.verify|verify} messages.\n     * @function encode\n     * @memberof StaticManifest\n     * @static\n     * @param {IStaticManifest} message StaticManifest message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    StaticManifest.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.name != null && Object.hasOwnProperty.call(message, \"name\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);\n        if (message.numMessages != null && Object.hasOwnProperty.call(message, \"numMessages\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.numMessages);\n        if (message.serverStatus != null && Object.hasOwnProperty.call(message, \"serverStatus\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.serverStatus);\n        if (message.configuredServerAddress != null && Object.hasOwnProperty.call(message, \"configuredServerAddress\"))\n            writer.uint32(/* id 4, wireType 2 =*/34).string(message.configuredServerAddress);\n        if (message.externalServerIp != null && Object.hasOwnProperty.call(message, \"externalServerIp\"))\n            writer.uint32(/* id 5, wireType 2 =*/42).string(message.externalServerIp);\n        if (message.internalServerIp != null && Object.hasOwnProperty.call(message, \"internalServerIp\"))\n            writer.uint32(/* id 6, wireType 2 =*/50).string(message.internalServerIp);\n        if (message.serverPort != null && Object.hasOwnProperty.call(message, \"serverPort\"))\n            writer.uint32(/* id 7, wireType 0 =*/56).uint32(message.serverPort);\n        if (message.serverBasePath != null && Object.hasOwnProperty.call(message, \"serverBasePath\"))\n            writer.uint32(/* id 8, wireType 2 =*/66).string(message.serverBasePath);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified StaticManifest message, length delimited. Does not implicitly {@link StaticManifest.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof StaticManifest\n     * @static\n     * @param {IStaticManifest} message StaticManifest message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    StaticManifest.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a StaticManifest message from the specified reader or buffer.\n     * @function decode\n     * @memberof StaticManifest\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {StaticManifest} StaticManifest\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    StaticManifest.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.StaticManifest();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.name = reader.string();\n                break;\n            case 2:\n                message.numMessages = reader.uint32();\n                break;\n            case 3:\n                message.serverStatus = reader.int32();\n                break;\n            case 4:\n                message.configuredServerAddress = reader.string();\n                break;\n            case 5:\n                message.externalServerIp = reader.string();\n                break;\n            case 6:\n                message.internalServerIp = reader.string();\n                break;\n            case 7:\n                message.serverPort = reader.uint32();\n                break;\n            case 8:\n                message.serverBasePath = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a StaticManifest message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof StaticManifest\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {StaticManifest} StaticManifest\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    StaticManifest.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a StaticManifest message.\n     * @function verify\n     * @memberof StaticManifest\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    StaticManifest.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            if (!$util.isString(message.name))\n                return \"name: string expected\";\n        if (message.numMessages != null && message.hasOwnProperty(\"numMessages\"))\n            if (!$util.isInteger(message.numMessages))\n                return \"numMessages: integer expected\";\n        if (message.serverStatus != null && message.hasOwnProperty(\"serverStatus\"))\n            switch (message.serverStatus) {\n            default:\n                return \"serverStatus: enum value expected\";\n            case 0:\n            case 1:\n                break;\n            }\n        if (message.configuredServerAddress != null && message.hasOwnProperty(\"configuredServerAddress\"))\n            if (!$util.isString(message.configuredServerAddress))\n                return \"configuredServerAddress: string expected\";\n        if (message.externalServerIp != null && message.hasOwnProperty(\"externalServerIp\"))\n            if (!$util.isString(message.externalServerIp))\n                return \"externalServerIp: string expected\";\n        if (message.internalServerIp != null && message.hasOwnProperty(\"internalServerIp\"))\n            if (!$util.isString(message.internalServerIp))\n                return \"internalServerIp: string expected\";\n        if (message.serverPort != null && message.hasOwnProperty(\"serverPort\"))\n            if (!$util.isInteger(message.serverPort))\n                return \"serverPort: integer expected\";\n        if (message.serverBasePath != null && message.hasOwnProperty(\"serverBasePath\"))\n            if (!$util.isString(message.serverBasePath))\n                return \"serverBasePath: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a StaticManifest message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof StaticManifest\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {StaticManifest} StaticManifest\n     */\n    StaticManifest.fromObject = function fromObject(object) {\n        if (object instanceof $root.StaticManifest)\n            return object;\n        let message = new $root.StaticManifest();\n        if (object.name != null)\n            message.name = String(object.name);\n        if (object.numMessages != null)\n            message.numMessages = object.numMessages >>> 0;\n        switch (object.serverStatus) {\n        case \"RUNNING\":\n        case 0:\n            message.serverStatus = 0;\n            break;\n        case \"DONE\":\n        case 1:\n            message.serverStatus = 1;\n            break;\n        }\n        if (object.configuredServerAddress != null)\n            message.configuredServerAddress = String(object.configuredServerAddress);\n        if (object.externalServerIp != null)\n            message.externalServerIp = String(object.externalServerIp);\n        if (object.internalServerIp != null)\n            message.internalServerIp = String(object.internalServerIp);\n        if (object.serverPort != null)\n            message.serverPort = object.serverPort >>> 0;\n        if (object.serverBasePath != null)\n            message.serverBasePath = String(object.serverBasePath);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a StaticManifest message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof StaticManifest\n     * @static\n     * @param {StaticManifest} message StaticManifest\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    StaticManifest.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.name = \"\";\n            object.numMessages = 0;\n            object.serverStatus = options.enums === String ? \"RUNNING\" : 0;\n            object.configuredServerAddress = \"\";\n            object.externalServerIp = \"\";\n            object.internalServerIp = \"\";\n            object.serverPort = 0;\n            object.serverBasePath = \"\";\n        }\n        if (message.name != null && message.hasOwnProperty(\"name\"))\n            object.name = message.name;\n        if (message.numMessages != null && message.hasOwnProperty(\"numMessages\"))\n            object.numMessages = message.numMessages;\n        if (message.serverStatus != null && message.hasOwnProperty(\"serverStatus\"))\n            object.serverStatus = options.enums === String ? $root.StaticManifest.ServerStatus[message.serverStatus] : message.serverStatus;\n        if (message.configuredServerAddress != null && message.hasOwnProperty(\"configuredServerAddress\"))\n            object.configuredServerAddress = message.configuredServerAddress;\n        if (message.externalServerIp != null && message.hasOwnProperty(\"externalServerIp\"))\n            object.externalServerIp = message.externalServerIp;\n        if (message.internalServerIp != null && message.hasOwnProperty(\"internalServerIp\"))\n            object.internalServerIp = message.internalServerIp;\n        if (message.serverPort != null && message.hasOwnProperty(\"serverPort\"))\n            object.serverPort = message.serverPort;\n        if (message.serverBasePath != null && message.hasOwnProperty(\"serverBasePath\"))\n            object.serverBasePath = message.serverBasePath;\n        return object;\n    };\n\n    /**\n     * Converts this StaticManifest to JSON.\n     * @function toJSON\n     * @memberof StaticManifest\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    StaticManifest.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * ServerStatus enum.\n     * @name StaticManifest.ServerStatus\n     * @enum {number}\n     * @property {number} RUNNING=0 RUNNING value\n     * @property {number} DONE=1 DONE value\n     */\n    StaticManifest.ServerStatus = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"RUNNING\"] = 0;\n        values[valuesById[1] = \"DONE\"] = 1;\n        return values;\n    })();\n\n    return StaticManifest;\n})();\n\nexport const Text = $root.Text = (() => {\n\n    /**\n     * Properties of a Text.\n     * @exports IText\n     * @interface IText\n     * @property {string|null} [body] Text body\n     */\n\n    /**\n     * Constructs a new Text.\n     * @exports Text\n     * @classdesc Represents a Text.\n     * @implements IText\n     * @constructor\n     * @param {IText=} [properties] Properties to set\n     */\n    function Text(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Text body.\n     * @member {string} body\n     * @memberof Text\n     * @instance\n     */\n    Text.prototype.body = \"\";\n\n    /**\n     * Creates a new Text instance using the specified properties.\n     * @function create\n     * @memberof Text\n     * @static\n     * @param {IText=} [properties] Properties to set\n     * @returns {Text} Text instance\n     */\n    Text.create = function create(properties) {\n        return new Text(properties);\n    };\n\n    /**\n     * Encodes the specified Text message. Does not implicitly {@link Text.verify|verify} messages.\n     * @function encode\n     * @memberof Text\n     * @static\n     * @param {IText} message Text message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Text.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.body != null && Object.hasOwnProperty.call(message, \"body\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.body);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Text message, length delimited. Does not implicitly {@link Text.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Text\n     * @static\n     * @param {IText} message Text message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Text.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Text message from the specified reader or buffer.\n     * @function decode\n     * @memberof Text\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Text} Text\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Text.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Text();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.body = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Text message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Text\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Text} Text\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Text.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Text message.\n     * @function verify\n     * @memberof Text\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Text.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            if (!$util.isString(message.body))\n                return \"body: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a Text message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Text\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Text} Text\n     */\n    Text.fromObject = function fromObject(object) {\n        if (object instanceof $root.Text)\n            return object;\n        let message = new $root.Text();\n        if (object.body != null)\n            message.body = String(object.body);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Text message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Text\n     * @static\n     * @param {Text} message Text\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Text.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.body = \"\";\n        if (message.body != null && message.hasOwnProperty(\"body\"))\n            object.body = message.body;\n        return object;\n    };\n\n    /**\n     * Converts this Text to JSON.\n     * @function toJSON\n     * @memberof Text\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Text.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Text;\n})();\n\nexport const TextArea = $root.TextArea = (() => {\n\n    /**\n     * Properties of a TextArea.\n     * @exports ITextArea\n     * @interface ITextArea\n     * @property {string|null} [id] TextArea id\n     * @property {string|null} [label] TextArea label\n     * @property {string|null} [\"default\"] TextArea default\n     * @property {number|null} [height] TextArea height\n     * @property {number|null} [maxChars] TextArea maxChars\n     */\n\n    /**\n     * Constructs a new TextArea.\n     * @exports TextArea\n     * @classdesc Represents a TextArea.\n     * @implements ITextArea\n     * @constructor\n     * @param {ITextArea=} [properties] Properties to set\n     */\n    function TextArea(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TextArea id.\n     * @member {string} id\n     * @memberof TextArea\n     * @instance\n     */\n    TextArea.prototype.id = \"\";\n\n    /**\n     * TextArea label.\n     * @member {string} label\n     * @memberof TextArea\n     * @instance\n     */\n    TextArea.prototype.label = \"\";\n\n    /**\n     * TextArea default.\n     * @member {string} default\n     * @memberof TextArea\n     * @instance\n     */\n    TextArea.prototype[\"default\"] = \"\";\n\n    /**\n     * TextArea height.\n     * @member {number} height\n     * @memberof TextArea\n     * @instance\n     */\n    TextArea.prototype.height = 0;\n\n    /**\n     * TextArea maxChars.\n     * @member {number} maxChars\n     * @memberof TextArea\n     * @instance\n     */\n    TextArea.prototype.maxChars = 0;\n\n    /**\n     * Creates a new TextArea instance using the specified properties.\n     * @function create\n     * @memberof TextArea\n     * @static\n     * @param {ITextArea=} [properties] Properties to set\n     * @returns {TextArea} TextArea instance\n     */\n    TextArea.create = function create(properties) {\n        return new TextArea(properties);\n    };\n\n    /**\n     * Encodes the specified TextArea message. Does not implicitly {@link TextArea.verify|verify} messages.\n     * @function encode\n     * @memberof TextArea\n     * @static\n     * @param {ITextArea} message TextArea message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TextArea.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message[\"default\"]);\n        if (message.height != null && Object.hasOwnProperty.call(message, \"height\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.height);\n        if (message.maxChars != null && Object.hasOwnProperty.call(message, \"maxChars\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.maxChars);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified TextArea message, length delimited. Does not implicitly {@link TextArea.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof TextArea\n     * @static\n     * @param {ITextArea} message TextArea message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TextArea.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TextArea message from the specified reader or buffer.\n     * @function decode\n     * @memberof TextArea\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {TextArea} TextArea\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TextArea.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TextArea();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.string();\n                break;\n            case 4:\n                message.height = reader.uint32();\n                break;\n            case 5:\n                message.maxChars = reader.uint32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a TextArea message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof TextArea\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {TextArea} TextArea\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TextArea.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TextArea message.\n     * @function verify\n     * @memberof TextArea\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TextArea.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (!$util.isString(message[\"default\"]))\n                return \"default: string expected\";\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            if (!$util.isInteger(message.height))\n                return \"height: integer expected\";\n        if (message.maxChars != null && message.hasOwnProperty(\"maxChars\"))\n            if (!$util.isInteger(message.maxChars))\n                return \"maxChars: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates a TextArea message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof TextArea\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {TextArea} TextArea\n     */\n    TextArea.fromObject = function fromObject(object) {\n        if (object instanceof $root.TextArea)\n            return object;\n        let message = new $root.TextArea();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = String(object[\"default\"]);\n        if (object.height != null)\n            message.height = object.height >>> 0;\n        if (object.maxChars != null)\n            message.maxChars = object.maxChars >>> 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a TextArea message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof TextArea\n     * @static\n     * @param {TextArea} message TextArea\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TextArea.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = \"\";\n            object.height = 0;\n            object.maxChars = 0;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        if (message.height != null && message.hasOwnProperty(\"height\"))\n            object.height = message.height;\n        if (message.maxChars != null && message.hasOwnProperty(\"maxChars\"))\n            object.maxChars = message.maxChars;\n        return object;\n    };\n\n    /**\n     * Converts this TextArea to JSON.\n     * @function toJSON\n     * @memberof TextArea\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TextArea.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return TextArea;\n})();\n\nexport const TextInput = $root.TextInput = (() => {\n\n    /**\n     * Properties of a TextInput.\n     * @exports ITextInput\n     * @interface ITextInput\n     * @property {string|null} [id] TextInput id\n     * @property {string|null} [label] TextInput label\n     * @property {string|null} [\"default\"] TextInput default\n     * @property {TextInput.Type|null} [type] TextInput type\n     * @property {number|null} [maxChars] TextInput maxChars\n     */\n\n    /**\n     * Constructs a new TextInput.\n     * @exports TextInput\n     * @classdesc Represents a TextInput.\n     * @implements ITextInput\n     * @constructor\n     * @param {ITextInput=} [properties] Properties to set\n     */\n    function TextInput(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TextInput id.\n     * @member {string} id\n     * @memberof TextInput\n     * @instance\n     */\n    TextInput.prototype.id = \"\";\n\n    /**\n     * TextInput label.\n     * @member {string} label\n     * @memberof TextInput\n     * @instance\n     */\n    TextInput.prototype.label = \"\";\n\n    /**\n     * TextInput default.\n     * @member {string} default\n     * @memberof TextInput\n     * @instance\n     */\n    TextInput.prototype[\"default\"] = \"\";\n\n    /**\n     * TextInput type.\n     * @member {TextInput.Type} type\n     * @memberof TextInput\n     * @instance\n     */\n    TextInput.prototype.type = 0;\n\n    /**\n     * TextInput maxChars.\n     * @member {number} maxChars\n     * @memberof TextInput\n     * @instance\n     */\n    TextInput.prototype.maxChars = 0;\n\n    /**\n     * Creates a new TextInput instance using the specified properties.\n     * @function create\n     * @memberof TextInput\n     * @static\n     * @param {ITextInput=} [properties] Properties to set\n     * @returns {TextInput} TextInput instance\n     */\n    TextInput.create = function create(properties) {\n        return new TextInput(properties);\n    };\n\n    /**\n     * Encodes the specified TextInput message. Does not implicitly {@link TextInput.verify|verify} messages.\n     * @function encode\n     * @memberof TextInput\n     * @static\n     * @param {ITextInput} message TextInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TextInput.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message[\"default\"]);\n        if (message.type != null && Object.hasOwnProperty.call(message, \"type\"))\n            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.type);\n        if (message.maxChars != null && Object.hasOwnProperty.call(message, \"maxChars\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.maxChars);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified TextInput message, length delimited. Does not implicitly {@link TextInput.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof TextInput\n     * @static\n     * @param {ITextInput} message TextInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TextInput.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TextInput message from the specified reader or buffer.\n     * @function decode\n     * @memberof TextInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {TextInput} TextInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TextInput.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TextInput();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.string();\n                break;\n            case 4:\n                message.type = reader.int32();\n                break;\n            case 5:\n                message.maxChars = reader.uint32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a TextInput message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof TextInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {TextInput} TextInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TextInput.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TextInput message.\n     * @function verify\n     * @memberof TextInput\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TextInput.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (!$util.isString(message[\"default\"]))\n                return \"default: string expected\";\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            switch (message.type) {\n            default:\n                return \"type: enum value expected\";\n            case 0:\n            case 1:\n                break;\n            }\n        if (message.maxChars != null && message.hasOwnProperty(\"maxChars\"))\n            if (!$util.isInteger(message.maxChars))\n                return \"maxChars: integer expected\";\n        return null;\n    };\n\n    /**\n     * Creates a TextInput message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof TextInput\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {TextInput} TextInput\n     */\n    TextInput.fromObject = function fromObject(object) {\n        if (object instanceof $root.TextInput)\n            return object;\n        let message = new $root.TextInput();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = String(object[\"default\"]);\n        switch (object.type) {\n        case \"DEFAULT\":\n        case 0:\n            message.type = 0;\n            break;\n        case \"PASSWORD\":\n        case 1:\n            message.type = 1;\n            break;\n        }\n        if (object.maxChars != null)\n            message.maxChars = object.maxChars >>> 0;\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a TextInput message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof TextInput\n     * @static\n     * @param {TextInput} message TextInput\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TextInput.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = \"\";\n            object.type = options.enums === String ? \"DEFAULT\" : 0;\n            object.maxChars = 0;\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            object.type = options.enums === String ? $root.TextInput.Type[message.type] : message.type;\n        if (message.maxChars != null && message.hasOwnProperty(\"maxChars\"))\n            object.maxChars = message.maxChars;\n        return object;\n    };\n\n    /**\n     * Converts this TextInput to JSON.\n     * @function toJSON\n     * @memberof TextInput\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TextInput.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Type enum.\n     * @name TextInput.Type\n     * @enum {number}\n     * @property {number} DEFAULT=0 DEFAULT value\n     * @property {number} PASSWORD=1 PASSWORD value\n     */\n    TextInput.Type = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"DEFAULT\"] = 0;\n        values[valuesById[1] = \"PASSWORD\"] = 1;\n        return values;\n    })();\n\n    return TextInput;\n})();\n\nexport const TimeInput = $root.TimeInput = (() => {\n\n    /**\n     * Properties of a TimeInput.\n     * @exports ITimeInput\n     * @interface ITimeInput\n     * @property {string|null} [id] TimeInput id\n     * @property {string|null} [label] TimeInput label\n     * @property {string|null} [\"default\"] TimeInput default\n     */\n\n    /**\n     * Constructs a new TimeInput.\n     * @exports TimeInput\n     * @classdesc Represents a TimeInput.\n     * @implements ITimeInput\n     * @constructor\n     * @param {ITimeInput=} [properties] Properties to set\n     */\n    function TimeInput(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TimeInput id.\n     * @member {string} id\n     * @memberof TimeInput\n     * @instance\n     */\n    TimeInput.prototype.id = \"\";\n\n    /**\n     * TimeInput label.\n     * @member {string} label\n     * @memberof TimeInput\n     * @instance\n     */\n    TimeInput.prototype.label = \"\";\n\n    /**\n     * TimeInput default.\n     * @member {string} default\n     * @memberof TimeInput\n     * @instance\n     */\n    TimeInput.prototype[\"default\"] = \"\";\n\n    /**\n     * Creates a new TimeInput instance using the specified properties.\n     * @function create\n     * @memberof TimeInput\n     * @static\n     * @param {ITimeInput=} [properties] Properties to set\n     * @returns {TimeInput} TimeInput instance\n     */\n    TimeInput.create = function create(properties) {\n        return new TimeInput(properties);\n    };\n\n    /**\n     * Encodes the specified TimeInput message. Does not implicitly {@link TimeInput.verify|verify} messages.\n     * @function encode\n     * @memberof TimeInput\n     * @static\n     * @param {ITimeInput} message TimeInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TimeInput.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.label != null && Object.hasOwnProperty.call(message, \"label\"))\n            writer.uint32(/* id 2, wireType 2 =*/18).string(message.label);\n        if (message[\"default\"] != null && Object.hasOwnProperty.call(message, \"default\"))\n            writer.uint32(/* id 3, wireType 2 =*/26).string(message[\"default\"]);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified TimeInput message, length delimited. Does not implicitly {@link TimeInput.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof TimeInput\n     * @static\n     * @param {ITimeInput} message TimeInput message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TimeInput.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TimeInput message from the specified reader or buffer.\n     * @function decode\n     * @memberof TimeInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {TimeInput} TimeInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TimeInput.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.TimeInput();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.label = reader.string();\n                break;\n            case 3:\n                message[\"default\"] = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a TimeInput message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof TimeInput\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {TimeInput} TimeInput\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TimeInput.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TimeInput message.\n     * @function verify\n     * @memberof TimeInput\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TimeInput.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            if (!$util.isString(message.label))\n                return \"label: string expected\";\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            if (!$util.isString(message[\"default\"]))\n                return \"default: string expected\";\n        return null;\n    };\n\n    /**\n     * Creates a TimeInput message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof TimeInput\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {TimeInput} TimeInput\n     */\n    TimeInput.fromObject = function fromObject(object) {\n        if (object instanceof $root.TimeInput)\n            return object;\n        let message = new $root.TimeInput();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.label != null)\n            message.label = String(object.label);\n        if (object[\"default\"] != null)\n            message[\"default\"] = String(object[\"default\"]);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a TimeInput message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof TimeInput\n     * @static\n     * @param {TimeInput} message TimeInput\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TimeInput.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.id = \"\";\n            object.label = \"\";\n            object[\"default\"] = \"\";\n        }\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.label != null && message.hasOwnProperty(\"label\"))\n            object.label = message.label;\n        if (message[\"default\"] != null && message.hasOwnProperty(\"default\"))\n            object[\"default\"] = message[\"default\"];\n        return object;\n    };\n\n    /**\n     * Converts this TimeInput to JSON.\n     * @function toJSON\n     * @memberof TimeInput\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TimeInput.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return TimeInput;\n})();\n\nexport const VegaLiteChart = $root.VegaLiteChart = (() => {\n\n    /**\n     * Properties of a VegaLiteChart.\n     * @exports IVegaLiteChart\n     * @interface IVegaLiteChart\n     * @property {string|null} [spec] VegaLiteChart spec\n     * @property {IDataFrame|null} [data] VegaLiteChart data\n     * @property {Array.<INamedDataSet>|null} [datasets] VegaLiteChart datasets\n     * @property {boolean|null} [useContainerWidth] VegaLiteChart useContainerWidth\n     */\n\n    /**\n     * Constructs a new VegaLiteChart.\n     * @exports VegaLiteChart\n     * @classdesc Represents a VegaLiteChart.\n     * @implements IVegaLiteChart\n     * @constructor\n     * @param {IVegaLiteChart=} [properties] Properties to set\n     */\n    function VegaLiteChart(properties) {\n        this.datasets = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * VegaLiteChart spec.\n     * @member {string} spec\n     * @memberof VegaLiteChart\n     * @instance\n     */\n    VegaLiteChart.prototype.spec = \"\";\n\n    /**\n     * VegaLiteChart data.\n     * @member {IDataFrame|null|undefined} data\n     * @memberof VegaLiteChart\n     * @instance\n     */\n    VegaLiteChart.prototype.data = null;\n\n    /**\n     * VegaLiteChart datasets.\n     * @member {Array.<INamedDataSet>} datasets\n     * @memberof VegaLiteChart\n     * @instance\n     */\n    VegaLiteChart.prototype.datasets = $util.emptyArray;\n\n    /**\n     * VegaLiteChart useContainerWidth.\n     * @member {boolean} useContainerWidth\n     * @memberof VegaLiteChart\n     * @instance\n     */\n    VegaLiteChart.prototype.useContainerWidth = false;\n\n    /**\n     * Creates a new VegaLiteChart instance using the specified properties.\n     * @function create\n     * @memberof VegaLiteChart\n     * @static\n     * @param {IVegaLiteChart=} [properties] Properties to set\n     * @returns {VegaLiteChart} VegaLiteChart instance\n     */\n    VegaLiteChart.create = function create(properties) {\n        return new VegaLiteChart(properties);\n    };\n\n    /**\n     * Encodes the specified VegaLiteChart message. Does not implicitly {@link VegaLiteChart.verify|verify} messages.\n     * @function encode\n     * @memberof VegaLiteChart\n     * @static\n     * @param {IVegaLiteChart} message VegaLiteChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    VegaLiteChart.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.spec != null && Object.hasOwnProperty.call(message, \"spec\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.spec);\n        if (message.data != null && Object.hasOwnProperty.call(message, \"data\"))\n            $root.DataFrame.encode(message.data, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n        if (message.datasets != null && message.datasets.length)\n            for (let i = 0; i < message.datasets.length; ++i)\n                $root.NamedDataSet.encode(message.datasets[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n        if (message.useContainerWidth != null && Object.hasOwnProperty.call(message, \"useContainerWidth\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).bool(message.useContainerWidth);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified VegaLiteChart message, length delimited. Does not implicitly {@link VegaLiteChart.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof VegaLiteChart\n     * @static\n     * @param {IVegaLiteChart} message VegaLiteChart message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    VegaLiteChart.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a VegaLiteChart message from the specified reader or buffer.\n     * @function decode\n     * @memberof VegaLiteChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {VegaLiteChart} VegaLiteChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    VegaLiteChart.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.VegaLiteChart();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.spec = reader.string();\n                break;\n            case 2:\n                message.data = $root.DataFrame.decode(reader, reader.uint32());\n                break;\n            case 4:\n                if (!(message.datasets && message.datasets.length))\n                    message.datasets = [];\n                message.datasets.push($root.NamedDataSet.decode(reader, reader.uint32()));\n                break;\n            case 5:\n                message.useContainerWidth = reader.bool();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a VegaLiteChart message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof VegaLiteChart\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {VegaLiteChart} VegaLiteChart\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    VegaLiteChart.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a VegaLiteChart message.\n     * @function verify\n     * @memberof VegaLiteChart\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    VegaLiteChart.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            if (!$util.isString(message.spec))\n                return \"spec: string expected\";\n        if (message.data != null && message.hasOwnProperty(\"data\")) {\n            let error = $root.DataFrame.verify(message.data);\n            if (error)\n                return \"data.\" + error;\n        }\n        if (message.datasets != null && message.hasOwnProperty(\"datasets\")) {\n            if (!Array.isArray(message.datasets))\n                return \"datasets: array expected\";\n            for (let i = 0; i < message.datasets.length; ++i) {\n                let error = $root.NamedDataSet.verify(message.datasets[i]);\n                if (error)\n                    return \"datasets.\" + error;\n            }\n        }\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            if (typeof message.useContainerWidth !== \"boolean\")\n                return \"useContainerWidth: boolean expected\";\n        return null;\n    };\n\n    /**\n     * Creates a VegaLiteChart message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof VegaLiteChart\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {VegaLiteChart} VegaLiteChart\n     */\n    VegaLiteChart.fromObject = function fromObject(object) {\n        if (object instanceof $root.VegaLiteChart)\n            return object;\n        let message = new $root.VegaLiteChart();\n        if (object.spec != null)\n            message.spec = String(object.spec);\n        if (object.data != null) {\n            if (typeof object.data !== \"object\")\n                throw TypeError(\".VegaLiteChart.data: object expected\");\n            message.data = $root.DataFrame.fromObject(object.data);\n        }\n        if (object.datasets) {\n            if (!Array.isArray(object.datasets))\n                throw TypeError(\".VegaLiteChart.datasets: array expected\");\n            message.datasets = [];\n            for (let i = 0; i < object.datasets.length; ++i) {\n                if (typeof object.datasets[i] !== \"object\")\n                    throw TypeError(\".VegaLiteChart.datasets: object expected\");\n                message.datasets[i] = $root.NamedDataSet.fromObject(object.datasets[i]);\n            }\n        }\n        if (object.useContainerWidth != null)\n            message.useContainerWidth = Boolean(object.useContainerWidth);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a VegaLiteChart message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof VegaLiteChart\n     * @static\n     * @param {VegaLiteChart} message VegaLiteChart\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    VegaLiteChart.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.datasets = [];\n        if (options.defaults) {\n            object.spec = \"\";\n            object.data = null;\n            object.useContainerWidth = false;\n        }\n        if (message.spec != null && message.hasOwnProperty(\"spec\"))\n            object.spec = message.spec;\n        if (message.data != null && message.hasOwnProperty(\"data\"))\n            object.data = $root.DataFrame.toObject(message.data, options);\n        if (message.datasets && message.datasets.length) {\n            object.datasets = [];\n            for (let j = 0; j < message.datasets.length; ++j)\n                object.datasets[j] = $root.NamedDataSet.toObject(message.datasets[j], options);\n        }\n        if (message.useContainerWidth != null && message.hasOwnProperty(\"useContainerWidth\"))\n            object.useContainerWidth = message.useContainerWidth;\n        return object;\n    };\n\n    /**\n     * Converts this VegaLiteChart to JSON.\n     * @function toJSON\n     * @memberof VegaLiteChart\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    VegaLiteChart.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return VegaLiteChart;\n})();\n\nexport const Video = $root.Video = (() => {\n\n    /**\n     * Properties of a Video.\n     * @exports IVideo\n     * @interface IVideo\n     * @property {string|null} [url] Video url\n     * @property {number|null} [startTime] Video startTime\n     * @property {Video.Type|null} [type] Video type\n     */\n\n    /**\n     * Constructs a new Video.\n     * @exports Video\n     * @classdesc Represents a Video.\n     * @implements IVideo\n     * @constructor\n     * @param {IVideo=} [properties] Properties to set\n     */\n    function Video(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * Video url.\n     * @member {string} url\n     * @memberof Video\n     * @instance\n     */\n    Video.prototype.url = \"\";\n\n    /**\n     * Video startTime.\n     * @member {number} startTime\n     * @memberof Video\n     * @instance\n     */\n    Video.prototype.startTime = 0;\n\n    /**\n     * Video type.\n     * @member {Video.Type} type\n     * @memberof Video\n     * @instance\n     */\n    Video.prototype.type = 0;\n\n    /**\n     * Creates a new Video instance using the specified properties.\n     * @function create\n     * @memberof Video\n     * @static\n     * @param {IVideo=} [properties] Properties to set\n     * @returns {Video} Video instance\n     */\n    Video.create = function create(properties) {\n        return new Video(properties);\n    };\n\n    /**\n     * Encodes the specified Video message. Does not implicitly {@link Video.verify|verify} messages.\n     * @function encode\n     * @memberof Video\n     * @static\n     * @param {IVideo} message Video message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Video.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.startTime != null && Object.hasOwnProperty.call(message, \"startTime\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.startTime);\n        if (message.type != null && Object.hasOwnProperty.call(message, \"type\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).int32(message.type);\n        if (message.url != null && Object.hasOwnProperty.call(message, \"url\"))\n            writer.uint32(/* id 6, wireType 2 =*/50).string(message.url);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified Video message, length delimited. Does not implicitly {@link Video.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof Video\n     * @static\n     * @param {IVideo} message Video message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Video.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a Video message from the specified reader or buffer.\n     * @function decode\n     * @memberof Video\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {Video} Video\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Video.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Video();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 6:\n                message.url = reader.string();\n                break;\n            case 3:\n                message.startTime = reader.int32();\n                break;\n            case 5:\n                message.type = reader.int32();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a Video message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof Video\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {Video} Video\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Video.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a Video message.\n     * @function verify\n     * @memberof Video\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    Video.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            if (!$util.isString(message.url))\n                return \"url: string expected\";\n        if (message.startTime != null && message.hasOwnProperty(\"startTime\"))\n            if (!$util.isInteger(message.startTime))\n                return \"startTime: integer expected\";\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            switch (message.type) {\n            default:\n                return \"type: enum value expected\";\n            case 0:\n            case 1:\n            case 2:\n                break;\n            }\n        return null;\n    };\n\n    /**\n     * Creates a Video message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Video\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {Video} Video\n     */\n    Video.fromObject = function fromObject(object) {\n        if (object instanceof $root.Video)\n            return object;\n        let message = new $root.Video();\n        if (object.url != null)\n            message.url = String(object.url);\n        if (object.startTime != null)\n            message.startTime = object.startTime | 0;\n        switch (object.type) {\n        case \"UNUSED\":\n        case 0:\n            message.type = 0;\n            break;\n        case \"NATIVE\":\n        case 1:\n            message.type = 1;\n            break;\n        case \"YOUTUBE_IFRAME\":\n        case 2:\n            message.type = 2;\n            break;\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a Video message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Video\n     * @static\n     * @param {Video} message Video\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Video.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults) {\n            object.startTime = 0;\n            object.type = options.enums === String ? \"UNUSED\" : 0;\n            object.url = \"\";\n        }\n        if (message.startTime != null && message.hasOwnProperty(\"startTime\"))\n            object.startTime = message.startTime;\n        if (message.type != null && message.hasOwnProperty(\"type\"))\n            object.type = options.enums === String ? $root.Video.Type[message.type] : message.type;\n        if (message.url != null && message.hasOwnProperty(\"url\"))\n            object.url = message.url;\n        return object;\n    };\n\n    /**\n     * Converts this Video to JSON.\n     * @function toJSON\n     * @memberof Video\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Video.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Type enum.\n     * @name Video.Type\n     * @enum {number}\n     * @property {number} UNUSED=0 UNUSED value\n     * @property {number} NATIVE=1 NATIVE value\n     * @property {number} YOUTUBE_IFRAME=2 YOUTUBE_IFRAME value\n     */\n    Video.Type = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"UNUSED\"] = 0;\n        values[valuesById[1] = \"NATIVE\"] = 1;\n        values[valuesById[2] = \"YOUTUBE_IFRAME\"] = 2;\n        return values;\n    })();\n\n    return Video;\n})();\n\nexport const WidgetStates = $root.WidgetStates = (() => {\n\n    /**\n     * Properties of a WidgetStates.\n     * @exports IWidgetStates\n     * @interface IWidgetStates\n     * @property {Array.<IWidgetState>|null} [widgets] WidgetStates widgets\n     */\n\n    /**\n     * Constructs a new WidgetStates.\n     * @exports WidgetStates\n     * @classdesc Represents a WidgetStates.\n     * @implements IWidgetStates\n     * @constructor\n     * @param {IWidgetStates=} [properties] Properties to set\n     */\n    function WidgetStates(properties) {\n        this.widgets = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * WidgetStates widgets.\n     * @member {Array.<IWidgetState>} widgets\n     * @memberof WidgetStates\n     * @instance\n     */\n    WidgetStates.prototype.widgets = $util.emptyArray;\n\n    /**\n     * Creates a new WidgetStates instance using the specified properties.\n     * @function create\n     * @memberof WidgetStates\n     * @static\n     * @param {IWidgetStates=} [properties] Properties to set\n     * @returns {WidgetStates} WidgetStates instance\n     */\n    WidgetStates.create = function create(properties) {\n        return new WidgetStates(properties);\n    };\n\n    /**\n     * Encodes the specified WidgetStates message. Does not implicitly {@link WidgetStates.verify|verify} messages.\n     * @function encode\n     * @memberof WidgetStates\n     * @static\n     * @param {IWidgetStates} message WidgetStates message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    WidgetStates.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.widgets != null && message.widgets.length)\n            for (let i = 0; i < message.widgets.length; ++i)\n                $root.WidgetState.encode(message.widgets[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n        return writer;\n    };\n\n    /**\n     * Encodes the specified WidgetStates message, length delimited. Does not implicitly {@link WidgetStates.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof WidgetStates\n     * @static\n     * @param {IWidgetStates} message WidgetStates message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    WidgetStates.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a WidgetStates message from the specified reader or buffer.\n     * @function decode\n     * @memberof WidgetStates\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {WidgetStates} WidgetStates\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    WidgetStates.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.WidgetStates();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.widgets && message.widgets.length))\n                    message.widgets = [];\n                message.widgets.push($root.WidgetState.decode(reader, reader.uint32()));\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a WidgetStates message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof WidgetStates\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {WidgetStates} WidgetStates\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    WidgetStates.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a WidgetStates message.\n     * @function verify\n     * @memberof WidgetStates\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    WidgetStates.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.widgets != null && message.hasOwnProperty(\"widgets\")) {\n            if (!Array.isArray(message.widgets))\n                return \"widgets: array expected\";\n            for (let i = 0; i < message.widgets.length; ++i) {\n                let error = $root.WidgetState.verify(message.widgets[i]);\n                if (error)\n                    return \"widgets.\" + error;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Creates a WidgetStates message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof WidgetStates\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {WidgetStates} WidgetStates\n     */\n    WidgetStates.fromObject = function fromObject(object) {\n        if (object instanceof $root.WidgetStates)\n            return object;\n        let message = new $root.WidgetStates();\n        if (object.widgets) {\n            if (!Array.isArray(object.widgets))\n                throw TypeError(\".WidgetStates.widgets: array expected\");\n            message.widgets = [];\n            for (let i = 0; i < object.widgets.length; ++i) {\n                if (typeof object.widgets[i] !== \"object\")\n                    throw TypeError(\".WidgetStates.widgets: object expected\");\n                message.widgets[i] = $root.WidgetState.fromObject(object.widgets[i]);\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a WidgetStates message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof WidgetStates\n     * @static\n     * @param {WidgetStates} message WidgetStates\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    WidgetStates.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.widgets = [];\n        if (message.widgets && message.widgets.length) {\n            object.widgets = [];\n            for (let j = 0; j < message.widgets.length; ++j)\n                object.widgets[j] = $root.WidgetState.toObject(message.widgets[j], options);\n        }\n        return object;\n    };\n\n    /**\n     * Converts this WidgetStates to JSON.\n     * @function toJSON\n     * @memberof WidgetStates\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    WidgetStates.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return WidgetStates;\n})();\n\nexport const WidgetState = $root.WidgetState = (() => {\n\n    /**\n     * Properties of a WidgetState.\n     * @exports IWidgetState\n     * @interface IWidgetState\n     * @property {string|null} [id] WidgetState id\n     * @property {boolean|null} [triggerValue] WidgetState triggerValue\n     * @property {boolean|null} [boolValue] WidgetState boolValue\n     * @property {number|null} [floatValue] WidgetState floatValue\n     * @property {number|Long|null} [intValue] WidgetState intValue\n     * @property {string|null} [stringValue] WidgetState stringValue\n     * @property {IFloatArray|null} [floatArrayValue] WidgetState floatArrayValue\n     * @property {IIntArray|null} [intArrayValue] WidgetState intArrayValue\n     * @property {IStringArray|null} [stringArrayValue] WidgetState stringArrayValue\n     * @property {string|null} [jsonValue] WidgetState jsonValue\n     */\n\n    /**\n     * Constructs a new WidgetState.\n     * @exports WidgetState\n     * @classdesc Represents a WidgetState.\n     * @implements IWidgetState\n     * @constructor\n     * @param {IWidgetState=} [properties] Properties to set\n     */\n    function WidgetState(properties) {\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * WidgetState id.\n     * @member {string} id\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.id = \"\";\n\n    /**\n     * WidgetState triggerValue.\n     * @member {boolean} triggerValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.triggerValue = false;\n\n    /**\n     * WidgetState boolValue.\n     * @member {boolean} boolValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.boolValue = false;\n\n    /**\n     * WidgetState floatValue.\n     * @member {number} floatValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.floatValue = 0;\n\n    /**\n     * WidgetState intValue.\n     * @member {number|Long} intValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.intValue = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n    /**\n     * WidgetState stringValue.\n     * @member {string} stringValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.stringValue = \"\";\n\n    /**\n     * WidgetState floatArrayValue.\n     * @member {IFloatArray|null|undefined} floatArrayValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.floatArrayValue = null;\n\n    /**\n     * WidgetState intArrayValue.\n     * @member {IIntArray|null|undefined} intArrayValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.intArrayValue = null;\n\n    /**\n     * WidgetState stringArrayValue.\n     * @member {IStringArray|null|undefined} stringArrayValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.stringArrayValue = null;\n\n    /**\n     * WidgetState jsonValue.\n     * @member {string} jsonValue\n     * @memberof WidgetState\n     * @instance\n     */\n    WidgetState.prototype.jsonValue = \"\";\n\n    // OneOf field names bound to virtual getters and setters\n    let $oneOfFields;\n\n    /**\n     * WidgetState value.\n     * @member {\"triggerValue\"|\"boolValue\"|\"floatValue\"|\"intValue\"|\"stringValue\"|\"floatArrayValue\"|\"intArrayValue\"|\"stringArrayValue\"|\"jsonValue\"|undefined} value\n     * @memberof WidgetState\n     * @instance\n     */\n    Object.defineProperty(WidgetState.prototype, \"value\", {\n        get: $util.oneOfGetter($oneOfFields = [\"triggerValue\", \"boolValue\", \"floatValue\", \"intValue\", \"stringValue\", \"floatArrayValue\", \"intArrayValue\", \"stringArrayValue\", \"jsonValue\"]),\n        set: $util.oneOfSetter($oneOfFields)\n    });\n\n    /**\n     * Creates a new WidgetState instance using the specified properties.\n     * @function create\n     * @memberof WidgetState\n     * @static\n     * @param {IWidgetState=} [properties] Properties to set\n     * @returns {WidgetState} WidgetState instance\n     */\n    WidgetState.create = function create(properties) {\n        return new WidgetState(properties);\n    };\n\n    /**\n     * Encodes the specified WidgetState message. Does not implicitly {@link WidgetState.verify|verify} messages.\n     * @function encode\n     * @memberof WidgetState\n     * @static\n     * @param {IWidgetState} message WidgetState message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    WidgetState.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.id != null && Object.hasOwnProperty.call(message, \"id\"))\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);\n        if (message.triggerValue != null && Object.hasOwnProperty.call(message, \"triggerValue\"))\n            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.triggerValue);\n        if (message.boolValue != null && Object.hasOwnProperty.call(message, \"boolValue\"))\n            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.boolValue);\n        if (message.floatValue != null && Object.hasOwnProperty.call(message, \"floatValue\"))\n            writer.uint32(/* id 4, wireType 1 =*/33).double(message.floatValue);\n        if (message.intValue != null && Object.hasOwnProperty.call(message, \"intValue\"))\n            writer.uint32(/* id 5, wireType 0 =*/40).sint64(message.intValue);\n        if (message.stringValue != null && Object.hasOwnProperty.call(message, \"stringValue\"))\n            writer.uint32(/* id 6, wireType 2 =*/50).string(message.stringValue);\n        if (message.floatArrayValue != null && Object.hasOwnProperty.call(message, \"floatArrayValue\"))\n            $root.FloatArray.encode(message.floatArrayValue, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();\n        if (message.intArrayValue != null && Object.hasOwnProperty.call(message, \"intArrayValue\"))\n            $root.IntArray.encode(message.intArrayValue, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();\n        if (message.stringArrayValue != null && Object.hasOwnProperty.call(message, \"stringArrayValue\"))\n            $root.StringArray.encode(message.stringArrayValue, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();\n        if (message.jsonValue != null && Object.hasOwnProperty.call(message, \"jsonValue\"))\n            writer.uint32(/* id 10, wireType 2 =*/82).string(message.jsonValue);\n        return writer;\n    };\n\n    /**\n     * Encodes the specified WidgetState message, length delimited. Does not implicitly {@link WidgetState.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof WidgetState\n     * @static\n     * @param {IWidgetState} message WidgetState message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    WidgetState.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a WidgetState message from the specified reader or buffer.\n     * @function decode\n     * @memberof WidgetState\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {WidgetState} WidgetState\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    WidgetState.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.WidgetState();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                message.id = reader.string();\n                break;\n            case 2:\n                message.triggerValue = reader.bool();\n                break;\n            case 3:\n                message.boolValue = reader.bool();\n                break;\n            case 4:\n                message.floatValue = reader.double();\n                break;\n            case 5:\n                message.intValue = reader.sint64();\n                break;\n            case 6:\n                message.stringValue = reader.string();\n                break;\n            case 7:\n                message.floatArrayValue = $root.FloatArray.decode(reader, reader.uint32());\n                break;\n            case 8:\n                message.intArrayValue = $root.IntArray.decode(reader, reader.uint32());\n                break;\n            case 9:\n                message.stringArrayValue = $root.StringArray.decode(reader, reader.uint32());\n                break;\n            case 10:\n                message.jsonValue = reader.string();\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a WidgetState message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof WidgetState\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {WidgetState} WidgetState\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    WidgetState.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a WidgetState message.\n     * @function verify\n     * @memberof WidgetState\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    WidgetState.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        let properties = {};\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            if (!$util.isString(message.id))\n                return \"id: string expected\";\n        if (message.triggerValue != null && message.hasOwnProperty(\"triggerValue\")) {\n            properties.value = 1;\n            if (typeof message.triggerValue !== \"boolean\")\n                return \"triggerValue: boolean expected\";\n        }\n        if (message.boolValue != null && message.hasOwnProperty(\"boolValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            if (typeof message.boolValue !== \"boolean\")\n                return \"boolValue: boolean expected\";\n        }\n        if (message.floatValue != null && message.hasOwnProperty(\"floatValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            if (typeof message.floatValue !== \"number\")\n                return \"floatValue: number expected\";\n        }\n        if (message.intValue != null && message.hasOwnProperty(\"intValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            if (!$util.isInteger(message.intValue) && !(message.intValue && $util.isInteger(message.intValue.low) && $util.isInteger(message.intValue.high)))\n                return \"intValue: integer|Long expected\";\n        }\n        if (message.stringValue != null && message.hasOwnProperty(\"stringValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            if (!$util.isString(message.stringValue))\n                return \"stringValue: string expected\";\n        }\n        if (message.floatArrayValue != null && message.hasOwnProperty(\"floatArrayValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            {\n                let error = $root.FloatArray.verify(message.floatArrayValue);\n                if (error)\n                    return \"floatArrayValue.\" + error;\n            }\n        }\n        if (message.intArrayValue != null && message.hasOwnProperty(\"intArrayValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            {\n                let error = $root.IntArray.verify(message.intArrayValue);\n                if (error)\n                    return \"intArrayValue.\" + error;\n            }\n        }\n        if (message.stringArrayValue != null && message.hasOwnProperty(\"stringArrayValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            {\n                let error = $root.StringArray.verify(message.stringArrayValue);\n                if (error)\n                    return \"stringArrayValue.\" + error;\n            }\n        }\n        if (message.jsonValue != null && message.hasOwnProperty(\"jsonValue\")) {\n            if (properties.value === 1)\n                return \"value: multiple values\";\n            properties.value = 1;\n            if (!$util.isString(message.jsonValue))\n                return \"jsonValue: string expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a WidgetState message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof WidgetState\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {WidgetState} WidgetState\n     */\n    WidgetState.fromObject = function fromObject(object) {\n        if (object instanceof $root.WidgetState)\n            return object;\n        let message = new $root.WidgetState();\n        if (object.id != null)\n            message.id = String(object.id);\n        if (object.triggerValue != null)\n            message.triggerValue = Boolean(object.triggerValue);\n        if (object.boolValue != null)\n            message.boolValue = Boolean(object.boolValue);\n        if (object.floatValue != null)\n            message.floatValue = Number(object.floatValue);\n        if (object.intValue != null)\n            if ($util.Long)\n                (message.intValue = $util.Long.fromValue(object.intValue)).unsigned = false;\n            else if (typeof object.intValue === \"string\")\n                message.intValue = parseInt(object.intValue, 10);\n            else if (typeof object.intValue === \"number\")\n                message.intValue = object.intValue;\n            else if (typeof object.intValue === \"object\")\n                message.intValue = new $util.LongBits(object.intValue.low >>> 0, object.intValue.high >>> 0).toNumber();\n        if (object.stringValue != null)\n            message.stringValue = String(object.stringValue);\n        if (object.floatArrayValue != null) {\n            if (typeof object.floatArrayValue !== \"object\")\n                throw TypeError(\".WidgetState.floatArrayValue: object expected\");\n            message.floatArrayValue = $root.FloatArray.fromObject(object.floatArrayValue);\n        }\n        if (object.intArrayValue != null) {\n            if (typeof object.intArrayValue !== \"object\")\n                throw TypeError(\".WidgetState.intArrayValue: object expected\");\n            message.intArrayValue = $root.IntArray.fromObject(object.intArrayValue);\n        }\n        if (object.stringArrayValue != null) {\n            if (typeof object.stringArrayValue !== \"object\")\n                throw TypeError(\".WidgetState.stringArrayValue: object expected\");\n            message.stringArrayValue = $root.StringArray.fromObject(object.stringArrayValue);\n        }\n        if (object.jsonValue != null)\n            message.jsonValue = String(object.jsonValue);\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a WidgetState message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof WidgetState\n     * @static\n     * @param {WidgetState} message WidgetState\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    WidgetState.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.defaults)\n            object.id = \"\";\n        if (message.id != null && message.hasOwnProperty(\"id\"))\n            object.id = message.id;\n        if (message.triggerValue != null && message.hasOwnProperty(\"triggerValue\")) {\n            object.triggerValue = message.triggerValue;\n            if (options.oneofs)\n                object.value = \"triggerValue\";\n        }\n        if (message.boolValue != null && message.hasOwnProperty(\"boolValue\")) {\n            object.boolValue = message.boolValue;\n            if (options.oneofs)\n                object.value = \"boolValue\";\n        }\n        if (message.floatValue != null && message.hasOwnProperty(\"floatValue\")) {\n            object.floatValue = options.json && !isFinite(message.floatValue) ? String(message.floatValue) : message.floatValue;\n            if (options.oneofs)\n                object.value = \"floatValue\";\n        }\n        if (message.intValue != null && message.hasOwnProperty(\"intValue\")) {\n            if (typeof message.intValue === \"number\")\n                object.intValue = options.longs === String ? String(message.intValue) : message.intValue;\n            else\n                object.intValue = options.longs === String ? $util.Long.prototype.toString.call(message.intValue) : options.longs === Number ? new $util.LongBits(message.intValue.low >>> 0, message.intValue.high >>> 0).toNumber() : message.intValue;\n            if (options.oneofs)\n                object.value = \"intValue\";\n        }\n        if (message.stringValue != null && message.hasOwnProperty(\"stringValue\")) {\n            object.stringValue = message.stringValue;\n            if (options.oneofs)\n                object.value = \"stringValue\";\n        }\n        if (message.floatArrayValue != null && message.hasOwnProperty(\"floatArrayValue\")) {\n            object.floatArrayValue = $root.FloatArray.toObject(message.floatArrayValue, options);\n            if (options.oneofs)\n                object.value = \"floatArrayValue\";\n        }\n        if (message.intArrayValue != null && message.hasOwnProperty(\"intArrayValue\")) {\n            object.intArrayValue = $root.IntArray.toObject(message.intArrayValue, options);\n            if (options.oneofs)\n                object.value = \"intArrayValue\";\n        }\n        if (message.stringArrayValue != null && message.hasOwnProperty(\"stringArrayValue\")) {\n            object.stringArrayValue = $root.StringArray.toObject(message.stringArrayValue, options);\n            if (options.oneofs)\n                object.value = \"stringArrayValue\";\n        }\n        if (message.jsonValue != null && message.hasOwnProperty(\"jsonValue\")) {\n            object.jsonValue = message.jsonValue;\n            if (options.oneofs)\n                object.value = \"jsonValue\";\n        }\n        return object;\n    };\n\n    /**\n     * Converts this WidgetState to JSON.\n     * @function toJSON\n     * @memberof WidgetState\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    WidgetState.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return WidgetState;\n})();\n\nexport const FloatArray = $root.FloatArray = (() => {\n\n    /**\n     * Properties of a FloatArray.\n     * @exports IFloatArray\n     * @interface IFloatArray\n     * @property {Array.<number>|null} [value] FloatArray value\n     */\n\n    /**\n     * Constructs a new FloatArray.\n     * @exports FloatArray\n     * @classdesc Represents a FloatArray.\n     * @implements IFloatArray\n     * @constructor\n     * @param {IFloatArray=} [properties] Properties to set\n     */\n    function FloatArray(properties) {\n        this.value = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * FloatArray value.\n     * @member {Array.<number>} value\n     * @memberof FloatArray\n     * @instance\n     */\n    FloatArray.prototype.value = $util.emptyArray;\n\n    /**\n     * Creates a new FloatArray instance using the specified properties.\n     * @function create\n     * @memberof FloatArray\n     * @static\n     * @param {IFloatArray=} [properties] Properties to set\n     * @returns {FloatArray} FloatArray instance\n     */\n    FloatArray.create = function create(properties) {\n        return new FloatArray(properties);\n    };\n\n    /**\n     * Encodes the specified FloatArray message. Does not implicitly {@link FloatArray.verify|verify} messages.\n     * @function encode\n     * @memberof FloatArray\n     * @static\n     * @param {IFloatArray} message FloatArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    FloatArray.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.value != null && message.value.length) {\n            writer.uint32(/* id 1, wireType 2 =*/10).fork();\n            for (let i = 0; i < message.value.length; ++i)\n                writer.double(message.value[i]);\n            writer.ldelim();\n        }\n        return writer;\n    };\n\n    /**\n     * Encodes the specified FloatArray message, length delimited. Does not implicitly {@link FloatArray.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof FloatArray\n     * @static\n     * @param {IFloatArray} message FloatArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    FloatArray.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a FloatArray message from the specified reader or buffer.\n     * @function decode\n     * @memberof FloatArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {FloatArray} FloatArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    FloatArray.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.FloatArray();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.value && message.value.length))\n                    message.value = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message.value.push(reader.double());\n                } else\n                    message.value.push(reader.double());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes a FloatArray message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof FloatArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {FloatArray} FloatArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    FloatArray.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a FloatArray message.\n     * @function verify\n     * @memberof FloatArray\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    FloatArray.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.value != null && message.hasOwnProperty(\"value\")) {\n            if (!Array.isArray(message.value))\n                return \"value: array expected\";\n            for (let i = 0; i < message.value.length; ++i)\n                if (typeof message.value[i] !== \"number\")\n                    return \"value: number[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates a FloatArray message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof FloatArray\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {FloatArray} FloatArray\n     */\n    FloatArray.fromObject = function fromObject(object) {\n        if (object instanceof $root.FloatArray)\n            return object;\n        let message = new $root.FloatArray();\n        if (object.value) {\n            if (!Array.isArray(object.value))\n                throw TypeError(\".FloatArray.value: array expected\");\n            message.value = [];\n            for (let i = 0; i < object.value.length; ++i)\n                message.value[i] = Number(object.value[i]);\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from a FloatArray message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof FloatArray\n     * @static\n     * @param {FloatArray} message FloatArray\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    FloatArray.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.value = [];\n        if (message.value && message.value.length) {\n            object.value = [];\n            for (let j = 0; j < message.value.length; ++j)\n                object.value[j] = options.json && !isFinite(message.value[j]) ? String(message.value[j]) : message.value[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this FloatArray to JSON.\n     * @function toJSON\n     * @memberof FloatArray\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    FloatArray.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return FloatArray;\n})();\n\nexport const IntArray = $root.IntArray = (() => {\n\n    /**\n     * Properties of an IntArray.\n     * @exports IIntArray\n     * @interface IIntArray\n     * @property {Array.<number|Long>|null} [value] IntArray value\n     */\n\n    /**\n     * Constructs a new IntArray.\n     * @exports IntArray\n     * @classdesc Represents an IntArray.\n     * @implements IIntArray\n     * @constructor\n     * @param {IIntArray=} [properties] Properties to set\n     */\n    function IntArray(properties) {\n        this.value = [];\n        if (properties)\n            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                if (properties[keys[i]] != null)\n                    this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * IntArray value.\n     * @member {Array.<number|Long>} value\n     * @memberof IntArray\n     * @instance\n     */\n    IntArray.prototype.value = $util.emptyArray;\n\n    /**\n     * Creates a new IntArray instance using the specified properties.\n     * @function create\n     * @memberof IntArray\n     * @static\n     * @param {IIntArray=} [properties] Properties to set\n     * @returns {IntArray} IntArray instance\n     */\n    IntArray.create = function create(properties) {\n        return new IntArray(properties);\n    };\n\n    /**\n     * Encodes the specified IntArray message. Does not implicitly {@link IntArray.verify|verify} messages.\n     * @function encode\n     * @memberof IntArray\n     * @static\n     * @param {IIntArray} message IntArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    IntArray.encode = function encode(message, writer) {\n        if (!writer)\n            writer = $Writer.create();\n        if (message.value != null && message.value.length) {\n            writer.uint32(/* id 1, wireType 2 =*/10).fork();\n            for (let i = 0; i < message.value.length; ++i)\n                writer.sint64(message.value[i]);\n            writer.ldelim();\n        }\n        return writer;\n    };\n\n    /**\n     * Encodes the specified IntArray message, length delimited. Does not implicitly {@link IntArray.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof IntArray\n     * @static\n     * @param {IIntArray} message IntArray message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    IntArray.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an IntArray message from the specified reader or buffer.\n     * @function decode\n     * @memberof IntArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {IntArray} IntArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    IntArray.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader))\n            reader = $Reader.create(reader);\n        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.IntArray();\n        while (reader.pos < end) {\n            let tag = reader.uint32();\n            switch (tag >>> 3) {\n            case 1:\n                if (!(message.value && message.value.length))\n                    message.value = [];\n                if ((tag & 7) === 2) {\n                    let end2 = reader.uint32() + reader.pos;\n                    while (reader.pos < end2)\n                        message.value.push(reader.sint64());\n                } else\n                    message.value.push(reader.sint64());\n                break;\n            default:\n                reader.skipType(tag & 7);\n                break;\n            }\n        }\n        return message;\n    };\n\n    /**\n     * Decodes an IntArray message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof IntArray\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {IntArray} IntArray\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    IntArray.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader))\n            reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an IntArray message.\n     * @function verify\n     * @memberof IntArray\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    IntArray.verify = function verify(message) {\n        if (typeof message !== \"object\" || message === null)\n            return \"object expected\";\n        if (message.value != null && message.hasOwnProperty(\"value\")) {\n            if (!Array.isArray(message.value))\n                return \"value: array expected\";\n            for (let i = 0; i < message.value.length; ++i)\n                if (!$util.isInteger(message.value[i]) && !(message.value[i] && $util.isInteger(message.value[i].low) && $util.isInteger(message.value[i].high)))\n                    return \"value: integer|Long[] expected\";\n        }\n        return null;\n    };\n\n    /**\n     * Creates an IntArray message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof IntArray\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {IntArray} IntArray\n     */\n    IntArray.fromObject = function fromObject(object) {\n        if (object instanceof $root.IntArray)\n            return object;\n        let message = new $root.IntArray();\n        if (object.value) {\n            if (!Array.isArray(object.value))\n                throw TypeError(\".IntArray.value: array expected\");\n            message.value = [];\n            for (let i = 0; i < object.value.length; ++i)\n                if ($util.Long)\n                    (message.value[i] = $util.Long.fromValue(object.value[i])).unsigned = false;\n                else if (typeof object.value[i] === \"string\")\n                    message.value[i] = parseInt(object.value[i], 10);\n                else if (typeof object.value[i] === \"number\")\n                    message.value[i] = object.value[i];\n                else if (typeof object.value[i] === \"object\")\n                    message.value[i] = new $util.LongBits(object.value[i].low >>> 0, object.value[i].high >>> 0).toNumber();\n        }\n        return message;\n    };\n\n    /**\n     * Creates a plain object from an IntArray message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof IntArray\n     * @static\n     * @param {IntArray} message IntArray\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    IntArray.toObject = function toObject(message, options) {\n        if (!options)\n            options = {};\n        let object = {};\n        if (options.arrays || options.defaults)\n            object.value = [];\n        if (message.value && message.value.length) {\n            object.value = [];\n            for (let j = 0; j < message.value.length; ++j)\n                if (typeof message.value[j] === \"number\")\n                    object.value[j] = options.longs === String ? String(message.value[j]) : message.value[j];\n                else\n                    object.value[j] = options.longs === String ? $util.Long.prototype.toString.call(message.value[j]) : options.longs === Number ? new $util.LongBits(message.value[j].low >>> 0, message.value[j].high >>> 0).toNumber() : message.value[j];\n        }\n        return object;\n    };\n\n    /**\n     * Converts this IntArray to JSON.\n     * @function toJSON\n     * @memberof IntArray\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    IntArray.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return IntArray;\n})();\n\nexport { $root as default };\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { ReactNode } from \"react\"\r\n\r\nimport classNames from \"classnames\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\nimport { Alert as AlertProto } from \"autogen/proto\"\r\nimport { StreamlitMarkdown } from \"components/shared/StreamlitMarkdown\"\r\n\r\nimport \"./Alert.scss\"\r\nimport \"assets/css/write.scss\"\r\n\r\n// classes defined in assets/css/theme.scss\r\nconst ALERT_CSS_CLASS = ImmutableMap({\r\n  [AlertProto.Format.SUCCESS]: \"alert-success\",\r\n  [AlertProto.Format.INFO]: \"alert-info\",\r\n  [AlertProto.Format.WARNING]: \"alert-warning\",\r\n  [AlertProto.Format.ERROR]: \"alert-danger\",\r\n})\r\n\r\nexport function getAlertCSSClass(format: number): string {\r\n  const cname = ALERT_CSS_CLASS.get(format.toString())\r\n  if (cname) {\r\n    return cname\r\n  } else {\r\n    throw new Error(`Unexpected alert type: ${format}`)\r\n  }\r\n}\r\n\r\nexport interface Props {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n}\r\n\r\n/**\r\n * Functional element representing error/warning/info/success boxes\r\n * which may be formatted in Markdown.\r\n */\r\nclass Alert extends React.PureComponent<Props> {\r\n  public render(): ReactNode {\r\n    const { element, width } = this.props\r\n    const body = element.get(\"body\")\r\n    const format = element.get(\"format\")\r\n\r\n    return (\r\n      <div\r\n        className={classNames(\"alert\", getAlertCSSClass(format), \"stAlert\")}\r\n        style={{ width }}\r\n      >\r\n        <div className=\"markdown-text-container\">\r\n          <StreamlitMarkdown source={body} allowHTML={false} />\r\n        </div>\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default Alert\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport { default } from \"./Alert\"\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\n/**\r\n * Our default iframe sandbox options.\r\n * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#Attributes\r\n *\r\n * From that page:\r\n * \"When the embedded document has the same origin as the embedding page, it is\r\n * strongly discouraged to use both allow-scripts and allow-same-origin, as\r\n * that lets the embedded document remove the sandbox attribute — making it no\r\n * more secure than not using the sandbox attribute at all.\"\r\n */\r\nexport const DEFAULT_IFRAME_SANDBOX_POLICY = [\r\n  // Allows for downloads to occur without a gesture from the user.\r\n  // Experimental; limited browser support.\r\n  // \"allow-downloads-without-user-activation\",\r\n\r\n  // Allows the resource to submit forms. If this keyword is not used, form submission is blocked.\r\n  \"allow-forms\",\r\n\r\n  // Lets the resource open modal windows.\r\n  \"allow-modals\",\r\n\r\n  // Lets the resource lock the screen orientation.\r\n  // \"allow-orientation-lock\",\r\n\r\n  // Lets the resource use the Pointer Lock API.\r\n  // \"allow-pointer-lock\",\r\n\r\n  // Allows popups (such as window.open(), target=\"_blank\", or showModalDialog()). If this keyword is not used, the popup will silently fail to open.\r\n  \"allow-popups\",\r\n\r\n  // Lets the sandboxed document open new windows without those windows inheriting the sandboxing. For example, this can safely sandbox an advertisement without forcing the same restrictions upon the page the ad links to.\r\n  \"allow-popups-to-escape-sandbox\",\r\n\r\n  // Lets the resource start a presentation session.\r\n  // \"allow-presentation\",\r\n\r\n  // If this token is not used, the resource is treated as being from a special origin that always fails the same-origin policy.\r\n  // (This token is conditionally set - the element must opt into it.)\r\n  // \"allow-same-origin\",\r\n\r\n  // Lets the resource run scripts (but not create popup windows).\r\n  \"allow-scripts\",\r\n\r\n  // Lets the resource request access to the parent's storage capabilities with the Storage Access API.\r\n  // Experimental; limited browser support.\r\n  // \"allow-storage-access-by-user-activation\",\r\n\r\n  // Lets the resource navigate the top-level browsing context (the one named _top).\r\n  // \"allow-top-navigation\",\r\n\r\n  // Lets the resource navigate the top-level browsing context, but only if initiated by a user gesture.\r\n  // \"allow-top-navigation-by-user-activation\",\r\n].join(\" \")\r\n\r\n/**\r\n * Our default iframe `allow` policy options.\r\n * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#Attributes\r\n */\r\nexport const DEFAULT_IFRAME_FEATURE_POLICY = [\r\n  // Controls whether the current document is allowed to gather information about the acceleration of the device through the Accelerometer interface.\r\n  \"accelerometer\",\r\n\r\n  // Controls whether the current document is allowed to gather information about the amount of light in the environment around the device through the AmbientLightSensor interface.\r\n  \"ambient-light-sensor\",\r\n\r\n  // Controls whether the current document is allowed to autoplay media requested through the HTMLMediaElement interface. When this policy is disabled and there were no user gestures, the Promise returned by HTMLMediaElement.play() will reject with a DOMException. The autoplay attribute on <audio> and <video> elements will be ignored.\r\n  \"autoplay\",\r\n\r\n  // Controls whether the use of the Battery Status API is allowed. When this policy is disabled, the Promise returned by Navigator.getBattery() will reject with a NotAllowedError DOMException.\r\n  \"battery\",\r\n\r\n  // Controls whether the current document is allowed to use video input devices. When this policy is disabled, the Promise returned by getUserMedia() will reject with a NotAllowedError DOMException.\r\n  \"camera\",\r\n\r\n  // Controls whether or not the current document is permitted to use the getDisplayMedia() method to capture screen contents. When this policy is disabled, the promise returned by getDisplayMedia() will reject with a NotAllowedError if permission is not obtained to capture the display's contents.\r\n  // \"display-capture\",\r\n\r\n  // Controls whether the current document is allowed to set document.domain. When this policy is disabled, attempting to set document.domain will fail and cause a SecurityError DOMException to be be thrown.\r\n  \"document-domain\",\r\n\r\n  // Controls whether the current document is allowed to use the Encrypted Media Extensions API (EME). When this policy is disabled, the Promise returned by Navigator.requestMediaKeySystemAccess() will reject with a DOMException.\r\n  \"encrypted-media\",\r\n\r\n  // Controls whether tasks should execute in frames while they're not being rendered (e.g. if an iframe is hidden or display: none).\r\n  //\"execution-while-not-rendered\",\r\n\r\n  // Controls whether tasks should execute in frames while they're outside of the visible viewport.\r\n  //\"execution-while-out-of-viewport\",\r\n\r\n  // Controls whether the current document is allowed to use Element.requestFullScreen(). When this policy is disabled, the returned Promise rejects with a TypeError DOMException.\r\n  \"fullscreen\",\r\n\r\n  // Controls whether the current document is allowed to use the Geolocation Interface. When this policy is disabled, calls to getCurrentPosition() and watchPosition() will cause those functions' callbacks to be invoked with a PositionError code of PERMISSION_DENIED.\r\n  \"geolocation\",\r\n\r\n  // Controls whether the current document is allowed to gather information about the orientation of the device through the Gyroscope interface.\r\n  \"gyroscope\",\r\n\r\n  // Controls whether the current document is allowed to show layout animations.\r\n  \"layout-animations\",\r\n\r\n  // Controls whether the current document is allowed to display images in legacy formats.\r\n  \"legacy-image-formats\",\r\n\r\n  // Controls whether the current document is allowed to gather information about the orientation of the device through the Magnetometer interface.\r\n  \"magnetometer\",\r\n\r\n  // Controls whether the current document is allowed to use audio input devices. When this policy is disabled, the Promise returned by MediaDevices.getUserMedia() will reject with a NotAllowedError.\r\n  \"microphone\",\r\n\r\n  // Controls whether the current document is allowed to use the Web MIDI API. When this policy is disabled, the Promise returned by Navigator.requestMIDIAccess() will reject with a DOMException.\r\n  \"midi\",\r\n\r\n  // Controls the availability of mechanisms that enables the page author to take control over the behavior of spatial navigation, or to cancel it outright.\r\n  // \"navigation-override\",\r\n\r\n  // Controls whether the current document is allowed to download and display large images.\r\n  \"oversized-images\",\r\n\r\n  // Controls whether the current document is allowed to use the Payment Request API. When this policy is enabled, the PaymentRequest() constructor will throw a SecurityError DOMException.\r\n  \"payment\",\r\n\r\n  // Controls whether the current document is allowed to play a video in a Picture-in-Picture mode via the corresponding API.\r\n  \"picture-in-picture\",\r\n\r\n  // Controls whether the current document is allowed to use the Web Authentication API to retreive already stored public-key credentials, i.e. via navigator.credentials.get({publicKey: ..., ...}).\r\n  \"publickey-credentials-get\",\r\n\r\n  // Controls whether the current document is allowed to make synchronous XMLHttpRequest requests.\r\n  \"sync-xhr\",\r\n\r\n  // Controls whether the current document is allowed to use the WebUSB API.\r\n  \"usb\",\r\n\r\n  // Controls whether the current document is allowed to use the WebVR API. When this policy is disabled, the Promise returned by Navigator.getVRDisplays() will reject with a DOMException. Keep in mind that the WebVR standard is in the process of being replaced with WebXR.\r\n  \"vr \",\r\n\r\n  // Controls whether the current document is allowed to use Wake Lock API to indicate that device should not enter power-saving mode.\r\n  \"wake-lock\",\r\n\r\n  // Controls whether or not the current document is allowed to use the WebXR Device API to interact with a WebXR session.\r\n  \"xr-spatial-tracking\",\r\n].join(\"; \")\r\n\r\n/**\r\n * Return an iFrame sandbox policy with the `allow-same-origin` token\r\n * optionally set.\r\n */\r\nexport function getIFrameSandboxPolicy(allowSameOrigin: boolean): string {\r\n  let sandboxPolicy = DEFAULT_IFRAME_SANDBOX_POLICY\r\n  if (allowSameOrigin) {\r\n    sandboxPolicy += \" allow-same-origin\"\r\n  }\r\n  return sandboxPolicy\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { PureComponent, ComponentType, ReactNode } from \"react\"\r\nimport hoistNonReactStatics from \"hoist-non-react-statics\"\r\nimport { Map as ImmutableMap } from \"immutable\"\r\n\r\nimport FullScreenWrapper from \"components/shared/FullScreenWrapper\"\r\n\r\nexport interface ReportElementProps {\r\n  width: number\r\n  element: ImmutableMap<string, any>\r\n  height?: number\r\n  index?: number\r\n}\r\n\r\nfunction withFullScreenWrapper(\r\n  WrappedComponent: ComponentType<any>\r\n): ComponentType<any> {\r\n  class ComponentWithFullScreenWrapper extends PureComponent<\r\n    ReportElementProps\r\n  > {\r\n    static readonly displayName = `withFullScreenWrapper(${WrappedComponent.displayName ||\r\n      WrappedComponent.name})`\r\n\r\n    render(): ReactNode {\r\n      const { width, height, ...passThroughProps } = this.props\r\n\r\n      return (\r\n        <FullScreenWrapper width={width} height={height}>\r\n          {({ width, height, expanded }) => (\r\n            <WrappedComponent\r\n              width={width}\r\n              height={height}\r\n              isFullScreen={expanded}\r\n              {...passThroughProps}\r\n            />\r\n          )}\r\n        </FullScreenWrapper>\r\n      )\r\n    }\r\n  }\r\n\r\n  // Static methods must be copied over\r\n  // https://en.reactjs.org/docs/higher-order-components.html#static-methods-must-be-copied-over\r\n  return hoistNonReactStatics(ComponentWithFullScreenWrapper, WrappedComponent)\r\n}\r\n\r\nexport default withFullScreenWrapper\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport { default } from \"./withFullScreenWrapper\"\r\n","export const SCSS_VARS = \n{\n  \"$white\": \"#fff\",\n  \"$gray-050\": \"#fafafa\",\n  \"$gray-100\": \"#fafafa\",\n  \"$gray-200\": \"#f0f2f6\",\n  \"$gray-300\": \"#e6eaf1\",\n  \"$gray-400\": \"#d5dae5\",\n  \"$gray-500\": \"#bfc5d3\",\n  \"$gray-600\": \"#a3a8b4\",\n  \"$gray-700\": \"#808495\",\n  \"$gray-800\": \"#555867\",\n  \"$gray-900\": \"#262730\",\n  \"$gray-1000\": \"#0e1117\",\n  \"$black\": \"#262730\",\n  \"$red\": \"#ff2b2b\",\n  \"$yellow\": \"#faca2b\",\n  \"$blue\": \"#0068c9\",\n  \"$green\": \"#09ab3b\",\n  \"$gray-faint\": \"#fafafa\",\n  \"$gray-lightest\": \"#f0f2f6\",\n  \"$gray-lighter\": \"#e6eaf1\",\n  \"$gray-light\": \"#d5dae5\",\n  \"$gray\": \"#a3a8b4\",\n  \"$gray-dark\": \"#808495\",\n  \"$gray-darker\": \"#262730\",\n  \"$yellow-light\": \"#fffd80\",\n  \"$primary\": \"#f63366\",\n  \"$secondary\": \"#a3a8b4\",\n  \"$light\": \"#fafafa\",\n  \"$dark\": \"#a3a8b4\",\n  \"$primary-a50\": \"rgba(246,51,102,0.5)\",\n  \"$white-a50\": \"#fff88\",\n  \"$white-a25\": \"#fff44\",\n  \"$font-family-sans-serif\": \"\\\"IBM Plex Sans\\\",sans-serif\",\n  \"$font-family-monospace\": \"\\\"IBM Plex Mono\\\",monospace\",\n  \"$font-size-base\": \"1rem\",\n  \"$font-size-sm\": \".8rem\",\n  \"$line-height-base\": \"1.6\",\n  \"$line-height-tight\": \"1.25\",\n  \"$border-radius\": \".25rem\",\n  \"$border-radius-sm\": \".25rem\",\n  \"$border-radius-large\": \".75rem\",\n  \"$btn-border-radius\": \".75rem\",\n  \"$z-index-popup-menu\": \"140\",\n  \"$z-index-sidebar-mobile\": \"130\",\n  \"$z-index-header\": \"120\",\n  \"$z-index-menu-button\": \"110\",\n  \"$z-index-sidebar\": \"100\",\n  \"$m1-2-font-size-sm\": \".8rem / 2\",\n  \"$m2-3-font-size-sm\": \".53333rem\",\n  \"$m1-2-font-size-base\": \"1rem / 2\",\n  \"$sidebar-width\": \"21rem\",\n  \"$content-max-width\": \"730px\",\n  \"$header-height\": \"3.5rem\",\n  \"$top-margin\": \"5rem\",\n  \"$bottom-margin\": \"10rem\",\n  \"$fullscreen-button\": \"2rem\",\n  \"$fullscreen-padding\": \".75rem\",\n  \"$fullscreen-padding-top\": \"3.5rem\",\n  \"$overlayBtn-height\": \"2.5rem\",\n  \"$overlayBtn-width\": \"2.5rem\",\n  \"$overlayBtn-opacity-visible\": \".25\",\n  \"$overlayBtn-opacity-active\": \".75\",\n  \"$normal-animation-duration\": \"300ms\",\n  \"$code-color\": \"#09ab3b\",\n  \"$kbd-color\": \"#09ab3b\",\n  \"$kbd-bg\": \"#fafafa\",\n  \"$pre-color\": \"#262730\"\n}\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport url from \"url\"\r\n\r\n/**\r\n * When in dev mode, this is the port used to connect to the web server that is\r\n * serving the current page (i.e. the actual web page server, not the API\r\n * server, which in dev are actually different servers.)\r\n */\r\nexport const WWW_PORT_DEV = 3000\r\n\r\n/**\r\n * This is the port used to connect to the server web socket when in dev.\r\n * IMPORTANT: If changed, also change config.py\r\n */\r\nexport const WEBSOCKET_PORT_DEV = 8501\r\n\r\n/**\r\n * True when in development mode.\r\n */\r\nexport const IS_DEV_ENV = +window.location.port === WWW_PORT_DEV\r\n\r\n/**\r\n * True when viewing a shared report.\r\n */\r\nexport const IS_SHARED_REPORT =\r\n  url.parse(window.location.href, true).query.id != null\r\n\r\n/**\r\n * Parameters for our fetch() requests.\r\n */\r\nexport const FETCH_PARAMS: RequestInit = {\r\n  redirect: \"follow\",\r\n  credentials: \"same-origin\",\r\n  mode: \"cors\",\r\n}\r\n\r\n/**\r\n * Feature flag for https://github.com/streamlit/streamlit/issues/678.\r\n * If this is true, we show a modal dialog to prompt the user to rerun\r\n * when their script changes. If false, we show a less intrusive UI in\r\n * StatusWidget.\r\n */\r\nexport const RERUN_PROMPT_MODAL_DIALOG = false\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport interface Args {\r\n  sessionId: string\r\n  streamlitVersion?: string | null\r\n  pythonVersion?: string | null\r\n  installationId?: string | null\r\n  authorEmail?: string | null\r\n  maxCachedMessageAge?: number | null\r\n  commandLine?: string | null\r\n  userMapboxToken?: string | null\r\n}\r\n\r\nexport class SessionInfo {\r\n  // Fields that don't change during the lifetime of a session (i.e. a browser tab).\r\n  public readonly sessionId: string\r\n  public readonly streamlitVersion: string\r\n  public readonly pythonVersion: string\r\n  public readonly installationId: string\r\n  public readonly authorEmail: string\r\n  public readonly maxCachedMessageAge: number\r\n  public readonly commandLine: string\r\n\r\n  /**\r\n   * The user-supplied mapbox token. By default, this will be the empty string,\r\n   * which indicates that we should fetch Streamlit's mapbox token and use\r\n   * that instead. Do not use this value directly; use `MapboxToken.get()`\r\n   * instead.\r\n   */\r\n  public readonly userMapboxToken: string\r\n\r\n  /**\r\n   * Singleton SessionInfo object. The reasons we're using a singleton here\r\n   * instead of just exporting a module-level instance are:\r\n   * - So we can easily override it in tests.\r\n   * - So we throw a loud error when some code tries to use it before it's\r\n   *   initialized.\r\n   */\r\n  private static singleton?: SessionInfo\r\n\r\n  public static get current(): SessionInfo {\r\n    if (!SessionInfo.singleton) {\r\n      throw new Error(\"Tried to use SessionInfo before it was initialized\")\r\n    }\r\n    return SessionInfo.singleton\r\n  }\r\n\r\n  public static set current(sm: SessionInfo) {\r\n    SessionInfo.singleton = sm\r\n  }\r\n\r\n  public static isSet(): boolean {\r\n    return SessionInfo.singleton != null\r\n  }\r\n\r\n  public static get isHello(): boolean {\r\n    return this.current.commandLine === \"streamlit hello\"\r\n  }\r\n\r\n  constructor({\r\n    sessionId,\r\n    streamlitVersion,\r\n    pythonVersion,\r\n    installationId,\r\n    authorEmail,\r\n    maxCachedMessageAge,\r\n    commandLine,\r\n    userMapboxToken,\r\n  }: Args) {\r\n    if (\r\n      sessionId == null ||\r\n      streamlitVersion == null ||\r\n      pythonVersion == null ||\r\n      installationId == null ||\r\n      authorEmail == null ||\r\n      maxCachedMessageAge == null ||\r\n      commandLine == null ||\r\n      userMapboxToken == null\r\n    ) {\r\n      throw new Error(\"SessionInfo arguments must be non-null\")\r\n    }\r\n\r\n    this.sessionId = sessionId\r\n    this.streamlitVersion = streamlitVersion\r\n    this.pythonVersion = pythonVersion\r\n    this.installationId = installationId\r\n    this.authorEmail = authorEmail\r\n    this.maxCachedMessageAge = maxCachedMessageAge\r\n    this.commandLine = commandLine\r\n    this.userMapboxToken = userMapboxToken\r\n  }\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { fromJS, Map } from \"immutable\"\r\nimport { IS_DEV_ENV } from \"./baseconsts\"\r\nimport { logMessage } from \"./log\"\r\n\r\n/**\r\n * Converts a protobuf JS object into its immutable counterpart.\r\n */\r\nexport function toImmutableProto(messageType: any, message: any): any {\r\n  const x = messageType.toObject(message, {\r\n    defaults: true,\r\n    oneofs: true,\r\n  })\r\n  if (IS_DEV_ENV) {\r\n    logMessage(\"Protobuf: \", x)\r\n  }\r\n  return fromJS(x)\r\n}\r\n\r\n/**\r\n * Applies a function based on the type of a protobuf oneof field.\r\n *\r\n * obj   - The immutable protobuf object we're applying this to.\r\n * name  - The name of the oneof field.\r\n * funcs - Dictionary of functions, one for each oneof field. Optionally, you\r\n * may pass a key-value pair {'_else': errorFunc} to hanle the case where there\r\n * is no match. If such a function is not passed, we throw an error if there's\r\n * no match.\r\n */\r\n\r\nexport function dispatchOneOf(\r\n  obj: Map<string, any>,\r\n  name: string,\r\n  funcs: any\r\n): any {\r\n  const whichOne = obj.get(name)\r\n  if (whichOne in funcs) {\r\n    return funcs[whichOne](obj.get(whichOne))\r\n  } else if (funcs._else) {\r\n    return funcs._else()\r\n  } else {\r\n    throw new Error(`Cannot handle ${name} \"${whichOne}\".`)\r\n  }\r\n}\r\n\r\n/**\r\n * Updates a oneof field of an immutable protobuf based on its type.\r\n *\r\n * obj   - The immutable protobuf object we're applying this to.\r\n * name  - The name of the oneof field.\r\n * funcs - Dictionary of update functions, one for each oneof field.\r\n */\r\nexport function updateOneOf(\r\n  obj: Map<string, any>,\r\n  name: string,\r\n  funcs: any\r\n): any {\r\n  const whichOne = obj.get(name)\r\n  if (whichOne in funcs) {\r\n    return obj.update(whichOne, funcs[whichOne])\r\n  } else {\r\n    throw new Error(`Cannot handle ${name} \"${whichOne}\".`)\r\n  }\r\n}\r\n\r\n/**\r\n * Returns a value based on the type of a protobuf oneof field.\r\n *\r\n * obj   - The immutable protobuf object we're applying this to.\r\n * name  - The name of the oneof field.\r\n * funcs - Dictionary of values, one for each oneof field.\r\n */\r\nexport function mapOneOf(\r\n  obj: Map<string, any>,\r\n  name: string,\r\n  values: any\r\n): any {\r\n  const whichOne = obj.get(name)\r\n  if (whichOne in values) {\r\n    return values[whichOne]\r\n  }\r\n\r\n  throw new Error(`Cannot handle ${name} \"${whichOne}\".`)\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport url from \"url\"\r\nimport xxhash from \"xxhashjs\"\r\nimport {\r\n  fromJS,\r\n  List,\r\n  Map as ImmutableMap,\r\n  Set as ImmutableSet,\r\n} from \"immutable\"\r\nimport { Alert as AlertProto } from \"autogen/proto\"\r\nimport { BlockElement, ReportElement, SimpleElement } from \"./DeltaParser\"\r\n\r\n/**\r\n * Wraps a function to allow it to be called, at most, once per interval\r\n * (specified in milliseconds). If the wrapper function is called N times\r\n * within that interval, only the Nth call will go through. The function\r\n * will only be called after the full interval has elapsed since the last\r\n * call.\r\n */\r\nexport function debounce(delay: number, fn: any): any {\r\n  let timerId: any\r\n\r\n  return function(...args: any[]) {\r\n    if (timerId) {\r\n      clearTimeout(timerId)\r\n    }\r\n\r\n    timerId = setTimeout(() => {\r\n      fn(...args)\r\n      timerId = null\r\n    }, delay)\r\n  }\r\n}\r\n\r\n/**\r\n * Returns true if the URL parameters indicated that we're embedded in an\r\n * iframe.\r\n */\r\nexport function isEmbeddedInIFrame(): boolean {\r\n  return url.parse(window.location.href, true).query.embed === \"true\"\r\n}\r\n\r\n/**\r\n * A helper function to make an ImmutableJS\r\n * info element from the given text.\r\n */\r\nexport function makeElementWithInfoText(\r\n  text: string\r\n): ImmutableMap<string, any> {\r\n  return fromJS({\r\n    type: \"alert\",\r\n    alert: {\r\n      body: text,\r\n      format: AlertProto.Format.INFO,\r\n    },\r\n  })\r\n}\r\n\r\n/**\r\n * A helper function to hash a string using xxHash32 algorithm.\r\n * Seed used: 0xDEADBEEF\r\n */\r\nexport function hashString(s: string): string {\r\n  return xxhash.h32(s, 0xdeadbeef).toString(16)\r\n}\r\n\r\n/**\r\n * Coerces a possibly-null value into a non-null value, throwing an error\r\n * if the value is null or undefined.\r\n */\r\nexport function requireNonNull<T>(obj: T | null | undefined): T {\r\n  if (obj == null) {\r\n    throw new Error(\"value is null\")\r\n  }\r\n  return obj\r\n}\r\n\r\n/**\r\n * Provide an ImmutableSet of SimpleElements by walking a BlockElement to\r\n * its leaves.\r\n */\r\nexport function flattenElements(\r\n  elements: BlockElement\r\n): ImmutableSet<SimpleElement> {\r\n  return elements.reduce(\r\n    (acc: ImmutableSet<SimpleElement>, reportElement: ReportElement) => {\r\n      const element = reportElement.get(\"element\")\r\n\r\n      if (element instanceof List) {\r\n        return flattenElements(element as BlockElement)\r\n      }\r\n      return acc.union(ImmutableSet.of(element as SimpleElement))\r\n    },\r\n    ImmutableSet.of<SimpleElement>()\r\n  )\r\n}\r\n\r\n/**\r\n * A promise that would be resolved after certain time\r\n * @param ms number\r\n */\r\nexport function timeout(ms: number): Promise<void> {\r\n  return new Promise(resolve => setTimeout(resolve, ms))\r\n}\r\n\r\n/**\r\n * Tests if the app is running from a Mac\r\n */\r\nexport function isFromMac(): boolean {\r\n  return /Mac/i.test(navigator.platform)\r\n}\r\n\r\n/**\r\n * Returns cookie value\r\n */\r\nexport function getCookie(name: string): string | undefined {\r\n  const r = document.cookie.match(\"\\\\b\" + name + \"=([^;]*)\\\\b\")\r\n  return r ? r[1] : undefined\r\n}\r\n\r\n/**\r\n * Sets cookie value\r\n */\r\nexport function setCookie(\r\n  name: string,\r\n  value?: string,\r\n  expiration?: Date\r\n): void {\r\n  const expirationDate = value ? expiration : new Date()\r\n  const expirationStr: string = expirationDate\r\n    ? `expires=${expirationDate.toUTCString()};`\r\n    : \"\"\r\n  document.cookie = `${name}=${value};${expirationStr}path=/`\r\n}\r\n","module.exports = \"data:image/gif;base64,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\"","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { IS_DEV_ENV, WEBSOCKET_PORT_DEV } from \"lib/baseconsts\"\r\n\r\n/**\r\n * host:port tuple\r\n */\r\nexport interface BaseUriParts {\r\n  host: string\r\n  port: number\r\n  basePath: string\r\n}\r\n\r\nconst FINAL_SLASH_RE = /\\/+$/\r\nconst INITIAL_SLASH_RE = /^\\/+/\r\n\r\n/**\r\n * Return the BaseUriParts for the global window\r\n */\r\nexport function getWindowBaseUriParts(): BaseUriParts {\r\n  // If dev, always connect to 8501, since window.location.port is the Node\r\n  // server's port 3000.\r\n  // If changed, also change config.py\r\n  const host = window.location.hostname\r\n\r\n  // prettier-ignore\r\n  const port = IS_DEV_ENV\r\n    ? WEBSOCKET_PORT_DEV\r\n    : window.location.port\r\n      ? Number(window.location.port)\r\n      : isHttps()\r\n        ? 443\r\n        : 80\r\n\r\n  const basePath = window.location.pathname\r\n    .replace(FINAL_SLASH_RE, \"\")\r\n    .replace(INITIAL_SLASH_RE, \"\")\r\n\r\n  return { host, port, basePath }\r\n}\r\n\r\n/**\r\n * Create a ws:// or wss:// URI for the given path.\r\n */\r\nexport function buildWsUri(\r\n  { host, port, basePath }: BaseUriParts,\r\n  path: string\r\n): string {\r\n  const protocol = isHttps() ? \"wss\" : \"ws\"\r\n  const fullPath = makePath(basePath, path)\r\n  return `${protocol}://${host}:${port}/${fullPath}`\r\n}\r\n\r\n/**\r\n * Create an HTTP URI for the given path.\r\n */\r\nexport function buildHttpUri(\r\n  { host, port, basePath }: BaseUriParts,\r\n  path: string\r\n): string {\r\n  const protocol = isHttps() ? \"https\" : \"http\"\r\n  const fullPath = makePath(basePath, path)\r\n  return `${protocol}://${host}:${port}/${fullPath}`\r\n}\r\n\r\nfunction makePath(basePath: string, subPath: string): string {\r\n  basePath = basePath.replace(FINAL_SLASH_RE, \"\").replace(INITIAL_SLASH_RE, \"\")\r\n  subPath = subPath.replace(FINAL_SLASH_RE, \"\").replace(INITIAL_SLASH_RE, \"\")\r\n\r\n  if (basePath.length === 0) {\r\n    return subPath\r\n  }\r\n\r\n  return `${basePath}/${subPath}`\r\n}\r\n\r\n/**\r\n * True if we're connected to the host via HTTPS.\r\n */\r\nfunction isHttps(): boolean {\r\n  return window.location.href.startsWith(\"https://\")\r\n}\r\n\r\n/**\r\n * If this is a relative URI, assume it's being served from streamlit and\r\n * construct it appropriately.  Otherwise leave it alone.\r\n */\r\nexport function buildMediaUri(uri: string): string {\r\n  return uri.startsWith(\"/media\")\r\n    ? buildHttpUri(getWindowBaseUriParts(), uri)\r\n    : uri\r\n}\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { ReactElement } from \"react\"\r\nimport classNames from \"classnames\"\r\nimport \"./Icon.scss\"\r\n\r\ninterface Props {\r\n  type: string\r\n  className?: string\r\n}\r\nconst Icon = ({ type, className }: Props): ReactElement => (\r\n  <span\r\n    className={classNames(\"open-iconic\", className)}\r\n    data-glyph={type}\r\n    title={type}\r\n    aria-hidden=\"true\"\r\n  ></span>\r\n)\r\n\r\nexport default Icon\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nexport { default } from \"./Icon\"\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\n/**\r\n * Text formatting utilities\r\n */\r\nimport moment from \"moment\"\r\nimport \"moment-duration-format\"\r\nimport numbro from \"numbro\"\r\n\r\nclass Duration {\r\n  private readonly millis: number\r\n\r\n  constructor(millis: number) {\r\n    this.millis = millis\r\n  }\r\n\r\n  getTime(): number {\r\n    return this.millis\r\n  }\r\n}\r\n\r\nclass Format {\r\n  nanosToDate(nanos: number): Date {\r\n    return new Date(nanos / 1e6)\r\n  }\r\n\r\n  nanosToDuration(nanos: number): Duration {\r\n    return new Duration(nanos / 1e6)\r\n  }\r\n\r\n  dateToString(date: Date): string {\r\n    const m = moment(date)\r\n    let format = \"lll\"\r\n    if (m.hour() === 0 && m.minute() === 0 && m.second() === 0) {\r\n      format = \"ll\"\r\n    }\r\n    return m.format(format)\r\n  }\r\n\r\n  durationToString(duration: Duration): string {\r\n    return moment.duration(duration.getTime()).format()\r\n  }\r\n}\r\n\r\nconst format = new Format()\r\n\r\n/**\r\n * Formats the string nicely if it's a floating point, number, date or duration.\r\n */\r\nfunction toFormattedString(x: any): string {\r\n  if (isFloat(x)) {\r\n    return numbro(x).format(\"0,0.0000\")\r\n  } else if (x instanceof Date) {\r\n    return format.dateToString(x)\r\n  } else if (x instanceof Duration) {\r\n    return format.durationToString(x)\r\n  } else {\r\n    return x.toString()\r\n  }\r\n}\r\n\r\n/**\r\n * Returns true if this number is a float.\r\n */\r\nfunction isFloat(n: any): boolean {\r\n  return Number(n) === n && n % 1 !== 0\r\n}\r\n\r\nexport { Duration, format, toFormattedString }\r\n","var map = {\n\t\"./models-android\": 325,\n\t\"./models-android.js\": 325,\n\t\"./models-asha\": 326,\n\t\"./models-asha.js\": 326,\n\t\"./models-bada\": 327,\n\t\"./models-bada.js\": 327,\n\t\"./models-blackberry\": 328,\n\t\"./models-blackberry.js\": 328,\n\t\"./models-brew\": 329,\n\t\"./models-brew.js\": 329,\n\t\"./models-feature\": 205,\n\t\"./models-feature.js\": 205,\n\t\"./models-firefoxos\": 330,\n\t\"./models-firefoxos.js\": 330,\n\t\"./models-ios\": 331,\n\t\"./models-ios.js\": 331,\n\t\"./models-kddi\": 332,\n\t\"./models-kddi.js\": 332,\n\t\"./models-palmos\": 333,\n\t\"./models-palmos.js\": 333,\n\t\"./models-s30plus\": 334,\n\t\"./models-s30plus.js\": 334,\n\t\"./models-s40\": 335,\n\t\"./models-s40.js\": 335,\n\t\"./models-symbian\": 336,\n\t\"./models-symbian.js\": 336,\n\t\"./models-tizen\": 337,\n\t\"./models-tizen.js\": 337,\n\t\"./models-touchwiz\": 338,\n\t\"./models-touchwiz.js\": 338,\n\t\"./models-wm\": 339,\n\t\"./models-wm.js\": 339,\n\t\"./models-wp\": 340,\n\t\"./models-wp.js\": 340\n};\n\n\nfunction webpackContext(req) {\n\tvar id = webpackContextResolve(req);\n\treturn __webpack_require__(id);\n}\nfunction webpackContextResolve(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\n\treturn map[req];\n}\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = 860;","var map = {\n\t\"./models-android\": 341,\n\t\"./models-android.js\": 341,\n\t\"./models-asha\": 342,\n\t\"./models-asha.js\": 342,\n\t\"./models-bada\": 343,\n\t\"./models-bada.js\": 343,\n\t\"./models-brew\": 344,\n\t\"./models-brew.js\": 344,\n\t\"./models-feature\": 206,\n\t\"./models-feature.js\": 206,\n\t\"./models-firefoxos\": 345,\n\t\"./models-firefoxos.js\": 345,\n\t\"./models-kddi\": 346,\n\t\"./models-kddi.js\": 346,\n\t\"./models-palmos\": 347,\n\t\"./models-palmos.js\": 347,\n\t\"./models-s30plus\": 348,\n\t\"./models-s30plus.js\": 348,\n\t\"./models-s40\": 349,\n\t\"./models-s40.js\": 349,\n\t\"./models-symbian\": 350,\n\t\"./models-symbian.js\": 350,\n\t\"./models-tizen\": 351,\n\t\"./models-tizen.js\": 351,\n\t\"./models-touchwiz\": 352,\n\t\"./models-touchwiz.js\": 352,\n\t\"./models-wm\": 353,\n\t\"./models-wm.js\": 353,\n\t\"./models-wp\": 354,\n\t\"./models-wp.js\": 354\n};\n\n\nfunction webpackContext(req) {\n\tvar id = webpackContextResolve(req);\n\treturn __webpack_require__(id);\n}\nfunction webpackContextResolve(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\n\treturn map[req];\n}\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = 861;","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport Clipboard from \"clipboard\"\r\nimport React, { PureComponent, ReactNode, createRef } from \"react\"\r\nimport { Copy as CopyIcon } from \"react-feather\"\r\n\r\ninterface Props {\r\n  text: string\r\n}\r\n\r\nclass CopyButton extends PureComponent<Props> {\r\n  private button = createRef<HTMLButtonElement>()\r\n  private clipboard: ClipboardJS | null = null\r\n\r\n  public componentDidMount = (): void => {\r\n    const node = this.button.current\r\n\r\n    if (node !== null) {\r\n      this.clipboard = new Clipboard(node)\r\n    }\r\n  }\r\n\r\n  public componentWillUnmount = (): void => {\r\n    if (this.clipboard !== null) {\r\n      this.clipboard.destroy()\r\n    }\r\n  }\r\n\r\n  public render = (): ReactNode => (\r\n    <button\r\n      className=\"overlayBtn\"\r\n      title=\"Copy to clipboard\"\r\n      ref={this.button}\r\n      data-clipboard-text={this.props.text}\r\n    >\r\n      <CopyIcon size=\"16\" />\r\n    </button>\r\n  )\r\n}\r\n\r\nexport default CopyButton\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport Prism from \"prismjs\"\r\nimport React, { PureComponent, ReactNode } from \"react\"\r\n\r\n// Prism language definition files.\r\n// These must come after the prismjs import because they modify Prism.languages\r\nimport \"prismjs/components/prism-jsx\"\r\nimport \"prismjs/components/prism-python\"\r\nimport \"prismjs/components/prism-typescript\"\r\nimport \"prismjs/components/prism-sql\"\r\nimport \"prismjs/components/prism-bash\"\r\nimport \"prismjs/components/prism-json\"\r\nimport \"prismjs/components/prism-yaml\"\r\nimport \"prismjs/components/prism-css\"\r\nimport \"prismjs/components/prism-c\"\r\nimport CopyButton from \"./CopyButton\"\r\nimport \"./CodeBlock.scss\"\r\n\r\nexport interface Props {\r\n  width: number\r\n  language?: string\r\n  value: string\r\n}\r\n\r\n/**\r\n * Renders a code block with syntax highlighting, via Prismjs\r\n */\r\nclass CodeBlock extends PureComponent<Props> {\r\n  public render(): ReactNode {\r\n    if (this.props.language == null) {\r\n      return (\r\n        <div className=\"stCodeBlock\">\r\n          <CopyButton text={this.props.value} />\r\n          <pre>\r\n            <code>{this.props.value}</code>\r\n          </pre>\r\n        </div>\r\n      )\r\n    }\r\n\r\n    // Language definition keys are lowercase\r\n    let lang = Prism.languages[this.props.language.toLowerCase()]\r\n    let languageClassName = `language-${this.props.language}`\r\n\r\n    if (lang === undefined) {\r\n      console.warn(\r\n        `No syntax highlighting for ${this.props.language}; defaulting to Python`\r\n      )\r\n      lang = Prism.languages.python\r\n      languageClassName = \"language-python\"\r\n    }\r\n\r\n    const safeHtml = this.props.value\r\n      ? Prism.highlight(this.props.value, lang, \"\")\r\n      : \"\"\r\n\r\n    return (\r\n      <div className=\"stCodeBlock\">\r\n        <CopyButton text={this.props.value} />\r\n        <pre>\r\n          <code\r\n            className={languageClassName}\r\n            dangerouslySetInnerHTML={{ __html: safeHtml }}\r\n          />\r\n        </pre>\r\n      </div>\r\n    )\r\n  }\r\n}\r\n\r\nexport default CodeBlock\r\n","/**\r\n * @license\r\n * Copyright 2018-2020 Streamlit Inc.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport React, { ReactElement, ReactNode, Fragment, PureComponent } from \"react\"\r\nimport ReactMarkdown from \"react-markdown\"\r\n// @ts-ignore\r\nimport htmlParser from \"react-markdown/plugins/html-parser\"\r\n// @ts-ignore\r\nimport { BlockMath, InlineMath } from \"react-katex\"\r\n// @ts-ignore\r\nimport RemarkMathPlugin from \"remark-math\"\r\n// @ts-ignore\r\nimport RemarkEmoji from \"remark-emoji\"\r\nimport CodeBlock from \"components/elements/CodeBlock/\"\r\n\r\nimport \"katex/dist/katex.min.css\"\r\n\r\nexport interface Props {\r\n  /**\r\n   * The Markdown formatted text to render.\r\n   */\r\n  source: string\r\n\r\n  /**\r\n   * True if HTML is allowed in the source string. If this is false,\r\n   * any HTML will be escaped in the output.\r\n   */\r\n  allowHTML: boolean\r\n}\r\n\r\n/**\r\n * Wraps the <ReactMarkdown> component to include our standard\r\n * renderers and AST plugins (for syntax highlighting, HTML support, etc).\r\n */\r\nexport class StreamlitMarkdown extends PureComponent<Props> {\r\n  public componentDidCatch = (): void => {\r\n    const { source } = this.props\r\n\r\n    throw Object.assign(new Error(), {\r\n      name: \"Error parsing Markdown or HTML in this string\",\r\n      message: <p>{source}</p>,\r\n      stack: null,\r\n    })\r\n  }\r\n\r\n  public render = (): ReactNode => {\r\n    const { source, allowHTML } = this.props\r\n\r\n    const renderers = {\r\n      code: CodeBlock,\r\n      link: linkWithTargetBlank,\r\n      linkReference: linkReferenceHasParens,\r\n      inlineMath: (props: { value: string }): ReactElement => (\r\n        <InlineMath>{props.value}</InlineMath>\r\n      ),\r\n      math: (props: { value: string }): ReactElement => (\r\n        <BlockMath>{props.value}</BlockMath>\r\n      ),\r\n    }\r\n\r\n    const plugins = [RemarkMathPlugin, RemarkEmoji]\r\n    const astPlugins = allowHTML ? [htmlParser()] : []\r\n\r\n    return (\r\n      <ReactMarkdown\r\n        source={source}\r\n        escapeHtml={!allowHTML}\r\n        astPlugins={astPlugins}\r\n        plugins={plugins}\r\n        renderers={renderers}\r\n      />\r\n    )\r\n  }\r\n}\r\n\r\ninterface LinkProps {\r\n  children: ReactElement\r\n  href: string\r\n}\r\n\r\ninterface LinkReferenceProps {\r\n  children: [ReactElement]\r\n  href: string\r\n}\r\n\r\n// Using target=\"_blank\" without rel=\"noopener noreferrer\" is a security risk:\r\n// see https://mathiasbynens.github.io/rel-noopener\r\nexport function linkWithTargetBlank(props: LinkProps): ReactElement {\r\n  return (\r\n    <a href={props.href} target=\"_blank\" rel=\"noopener noreferrer\">\r\n      {props.children}\r\n    </a>\r\n  )\r\n}\r\n\r\n// Handle rendering a link through a reference, ex [text](href)\r\n// Don't convert to a link if only `[text]` and missing `(href)`\r\nexport function linkReferenceHasParens(\r\n  props: LinkReferenceProps\r\n): ReactElement | null {\r\n  const { href, children } = props\r\n\r\n  if (!href) {\r\n    return children.length ? (\r\n      <Fragment>[{children[0].props.children}]</Fragment>\r\n    ) : null\r\n  }\r\n\r\n  return (\r\n    <a href={href} target=\"_blank\" rel=\"noopener noreferrer\">\r\n      {children}\r\n    </a>\r\n  )\r\n}\r\n"],"sourceRoot":""}