{"version":3,"sources":["../../src/index.ts","../../src/RestAPI.ts","../../src/API.ts","../../src/Signer.ts","../../Providers/PubSubProvider.ts","../../Providers/MqttOverWSProvider.ts","../../Providers/AWSAppSyncRealTimeProvider.ts","../../Providers/AWSAppSyncProvider.ts","../../src/PubSub.ts","../../I18n/I18n.ts","../../I18n/index.ts","../node_modules/graphql/language/visitor.mjs","../node_modules/graphql/language/printer.mjs","../node_modules/graphql/jsutils/inspect.mjs","../node_modules/graphql/jsutils/invariant.mjs","../node_modules/graphql/language/source.mjs","../node_modules/graphql/jsutils/defineToStringTag.mjs","../node_modules/graphql/error/syntaxError.mjs","../node_modules/graphql/language/blockStringValue.mjs","../node_modules/graphql/language/lexer.mjs","../node_modules/graphql/language/kinds.mjs","../node_modules/graphql/language/directiveLocation.mjs","../node_modules/graphql/language/parser.mjs","../../src/GraphQLAPI.ts","../../src/zenObservable.ts","../../src/constants.ts","../node_modules/@aws-amplify/pubsub/node_modules/uuid/index.js","../node_modules/@aws-amplify/pubsub/node_modules/uuid/lib/rng-browser.js","../node_modules/@aws-amplify/pubsub/node_modules/uuid/lib/bytesToUuid.js","../node_modules/graphql/language/location.mjs","../node_modules/graphql/error/printError.mjs","../node_modules/graphql/error/GraphQLError.mjs","../../src/RestClient.ts","../../src/jsSha256.ts","../../src/RawSha256.ts","../node_modules/zen-observable/index.js","../node_modules/zen-observable/lib/Observable.js","../node_modules/paho-mqtt/paho-mqtt.js","../node_modules/@aws-amplify/pubsub/node_modules/uuid/v1.js","../node_modules/@aws-amplify/pubsub/node_modules/uuid/v4.js","../../index.ts","../../whatwgEncodingApi.ts","../../pureJs.ts","../../Util/DateUtils.ts"],"names":["Constants","userAgent","Platform","Amplify","Auth","logger","Logger","options","Credentials","_options","debug","RestAPIClass","_a","_b","API","otherOptions","opt","custom","endpoints","JSON","parse","Object","assign","region","header","Array","isArray","forEach","endpoint","custom_header","warn","name","undefined","createInstance","_api","RestClient","apiName","path","init","apiInfo","getEndpointInfo","cancellableToken","getCancellableToken","initParams","responsePromise","get","updateRequestToBeCancellable","err","Promise","reject","message","post","put","patch","del","head","error","isCancel","request","cancel","cloud_logic_array","Error","apiConfig","find","response","service","RestAPI","register","Cache","_restApi","_graphqlApi","GraphQLAPIClass","APIClass","restAPIConfig","configure","graphQLAPIConfig","operation","getGraphqlOperationType","additionalHeaders","graphql","encrypt","key","src","hash","jsSha256","update","digestSync","arg","toHex","signed_headers","headers","keys","map","toLowerCase","sort","join","canonical_request","query","url_info","url","method","encodeURIComponent","pathname","replace","length","split","key_val","e","reencoded_val","c","charCodeAt","toString","toUpperCase","a","b","key_a","key_b","value","trim","item","data","parse_service_info","parsed","host","match","slice","reverse","credential_scope","d_str","string_to_sign","algorithm","dt_str","scope","get_signing_key","secret_key","service_info","k_date","k_region","k_service","get_signature","signing_key","str_to_sign","Signer","access_info","DateUtils","getDateWithClockOffset","toISOString","substr","session_token","request_str","serviceInfo","signature","authorization_header","access_key","get_authorization_header","urlOrRequest","accessInfo","expiration","urlToSign","body","now","today","parsedUrl","search","signedHeaders","credentialScope","sessionTokenRequired","queryParams","canonicalRequest","format","stringToSign","additionalQueryParams","protocol","slashes","hostname","port","CONTROL_MSG","PubSub","_config","AbstractPubSubProvider","config","getProviderName","MESSAGE_TYPES","SUBSCRIPTION_STATUS","SOCKET_STATUS","Map","ClientsQueue","clientId","clientFactory","promise","promises","set","from","delete","topicSymbol","Symbol","_super","uuid","_this","__extends","MqttOverWSProvider","aws_pubsub_endpoint","_clientsQueue","aws_appsync_dangerously_connect_to_http_endpoint_for_testing","errorCode","args","stringify","topicsToDelete_1","clientIdObservers","_clientIdObservers","observer","_topicObservers","observerForTopic","observerTopic","size","push","topic","client","Paho","onMessageArrived","msg","_onMessage","onConnectionLost","onDisconnect","resolve","connect","useSSL","isSSLEnabled","mqttVersion","onSuccess","onFailure","clientsQueue","newClient","isConnected","disconnect","remove","topics","targetTopics","concat","send","matchedTopicObservers_1","filter","filterArray","topicArray","i","left","right","mqttTopicMatch","parsedMessage_1","observersForTopic","next","Observable","Set","add","observersForClientId","_c","subscribe","e_1","unsubscribe","AWSAppSyncProvider","_topicClient","entries","t","_cleanUpForTopic","_topicAlias","has","obs","closed","_cleanUp","result","mqttConnections","newSubscriptions","newAliases","alias","v","reduce","acc","elem","connectionInfoForTopic","indexOf","all","_d","err_1","complete","values","some","getTopicForValue","obj","origKey","val","AMPLIFY_SYMBOL","for","NON_RETRYABLE_CODES","AWS_APPSYNC_REALTIME_HEADERS","accept","CLOSED","AWSAppSyncRealTimeProvider","_topics","_msg","appSyncGraphqlEndpoint","subscriptionId_1","_startSubscriptionWithAWSAppSyncRealTime","subscriptionId","_waitForSubscriptionToBeConnected","subscriptionState","subscriptionObserverMap","CONNECTED","_sendUnsubscriptionMessage","_removeSubscriptionObserver","errors","GraphQLError","authenticationType","variables","apiKey","graphql_headers","PENDING","startAckTimeoutId","dataString","_awsRealTimeHeaderBasedAuth","payload","canonicalUri","_j","headerObj","USER_AGENT_HEADER","subscriptionMessage","id","extensions","authorization","type","GQL_START","stringToAWSRealTime","_initializeWebSocketConnection","_f","err_2","subscriptionFailedCallback_1","_g","subscriptionFailedCallback","subscriptionReadyCallback","setTimeout","_timeoutStartSubscriptionAck","call","awsRealTimeSocket","res","rej","readyState","WebSocket","OPEN","socketStatus","READY","unsubscribeMessage","GQL_STOP","_closeSocketIfRequired","bind","bufferedAmount","clearTimeout","keepAliveTimeoutId","tempSocket","onclose","onerror","close","_e","GQL_DATA","GQL_START_ACK","GQL_CONNECTION_KEEP_ALIVE","_errorDisconnect","TIMEOUT_DISCONNECT","keepAliveTimeout","GQL_ERROR","FAILED","event","Hub","dispatch","dispatchApiEvent","SUBSCRIPTION_ACK","clear","promiseArray","CONNECTING","discoverableEndpoint","payloadString","headerString","headerQs","Buffer","payloadQs","awsRealTimeUrl","_initializeRetryableHandshake","err_3","jitteredExponentialRetry","_initializeHandshake","newSocket","onopen","ackOk","reason","onmessage","connectionTimeoutMs","GQL_CONNECTION_ACK","_handleIncomingSubscriptionMessage","CONNECTION_CLOSED","GQL_CONNECTION_ERROR","_h","errorType","gqlInit","GQL_CONNECTION_INIT","err_4","includes","NonRetryableError","headerHandler","API_KEY","_awsRealTimeApiKeyHeader","AWS_IAM","_awsRealTimeIAMHeader","OPENID_CONNECT","_awsRealTimeOPENIDHeader","AMAZON_COGNITO_USER_POOLS","_awsRealTimeCUPHeader","handler","currentSession","Authorization","getAccessToken","getJwtToken","getItem","federatedInfo","token","currentAuthenticatedUser","currentUser","dt","Date","dtStr","endpointInfo","_ensureCredentials","then","credentials","secretAccessKey","accessKeyId","sessionToken","creds","sign","cred","shear","catch","_pluggables","PubSubClass","_awsAppSyncProvider","_awsAppSyncRealTimeProvider","pluggable","getCategory","providerName","INTERNAL_AWS_APPSYNC_PUBSUB_PROVIDER","awsAppSyncProvider","INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER","awsAppSyncRealTimeProvider","provider","getProviderByName","getProviders","publish","isNode","ssr","providers","subscriptions","observable","start","console","_lang","language","window","navigator","I18n","lang","defVal","getByLanguage","lang_dict","_dict","vocabularies","putVocabulariesForLanguage","_i18n","I18nClass","checkConfig","setLanguage","putVocabularies","QueryDocumentKeys","Name","Document","OperationDefinition","VariableDefinition","Variable","SelectionSet","Field","Argument","FragmentSpread","InlineFragment","FragmentDefinition","IntValue","FloatValue","StringValue","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","Directive","NamedType","ListType","NonNullType","SchemaDefinition","OperationTypeDefinition","ScalarTypeDefinition","ObjectTypeDefinition","FieldDefinition","InputValueDefinition","InterfaceTypeDefinition","UnionTypeDefinition","EnumTypeDefinition","EnumValueDefinition","InputObjectTypeDefinition","DirectiveDefinition","SchemaExtension","ScalarTypeExtension","ObjectTypeExtension","InterfaceTypeExtension","UnionTypeExtension","EnumTypeExtension","InputObjectTypeExtension","BREAK","maybeNode","Boolean","kind","getVisitFn","visitor","isLeaving","kindVisitor","kindSpecificVisitor","leave","enter","specificVisitor","specificKindVisitor","print","ast","root","visitorKeys","arguments","stack","inArray","index","edits","node","parent","ancestors","newRoot","isEdited","pop","clone","k","hasOwnProperty","editOffset","ii","editKey","editValue","splice","prev","visitFn","visit","printDocASTReducer","definitions","op","varDefs","wrap","variableDefinitions","directives","selectionSet","_ref","variable","defaultValue","_ref2","block","selections","_ref3","_ref4","_ref5","_ref6","typeCondition","_ref7","_ref8","_ref9","_ref10","isDescription","escaped","indent","printBlockString","_ref11","_ref12","_ref13","_ref14","fields","_ref15","_ref16","_ref17","_ref18","_ref19","_ref20","operationTypes","_ref21","addDescription","_ref22","_ref23","interfaces","_ref24","every","_ref25","_ref26","_ref27","types","_ref28","_ref29","_ref30","_ref31","locations","_ref32","_ref33","_ref34","_ref35","_ref36","_ref37","_ref38","cb","description","maybeArray","separator","x","array","maybeString","end","_typeof","iterator","constructor","prototype","inspect","String","invariant","condition","_defineProperty","defineProperty","enumerable","configurable","writable","classObject","Source","locationOffset","this","line","column","syntaxError","source","position","blockStringValue","rawString","lines","commonIndent","leadingWhitespace","_i","isBlank","shift","str","createLexer","startOfFileToken","Tok","TokenKind","SOF","lastToken","lineStart","advance","advanceLexer","lookahead","EOF","readToken","COMMENT","toStringTag","freeze","BANG","DOLLAR","AMP","PAREN_L","PAREN_R","SPREAD","COLON","EQUALS","AT","BRACKET_L","BRACKET_R","BRACE_L","PIPE","BRACE_R","NAME","INT","FLOAT","STRING","BLOCK_STRING","getTokenDesc","printCharCode","code","isNaN","fromCharCode","lexer","bodyLength","pos","startPosition","positionAfterWhitespace","col","readComment","readName","firstCode","isFloat","readDigits","readNumber","chunkStart","rawValue","readBlockString","charCode","d","char2hex","readString","unexpectedCharacterMessage","toJSON","Kind","DOCUMENT","OPERATION_DEFINITION","VARIABLE_DEFINITION","SELECTION_SET","FIELD","ARGUMENT","FRAGMENT_SPREAD","INLINE_FRAGMENT","FRAGMENT_DEFINITION","VARIABLE","BOOLEAN","NULL","ENUM","LIST","OBJECT","OBJECT_FIELD","DIRECTIVE","NAMED_TYPE","LIST_TYPE","NON_NULL_TYPE","SCHEMA_DEFINITION","OPERATION_TYPE_DEFINITION","SCALAR_TYPE_DEFINITION","OBJECT_TYPE_DEFINITION","FIELD_DEFINITION","INPUT_VALUE_DEFINITION","INTERFACE_TYPE_DEFINITION","UNION_TYPE_DEFINITION","ENUM_TYPE_DEFINITION","ENUM_VALUE_DEFINITION","INPUT_OBJECT_TYPE_DEFINITION","DIRECTIVE_DEFINITION","SCHEMA_EXTENSION","SCALAR_TYPE_EXTENSION","OBJECT_TYPE_EXTENSION","INTERFACE_TYPE_EXTENSION","UNION_TYPE_EXTENSION","ENUM_TYPE_EXTENSION","INPUT_OBJECT_TYPE_EXTENSION","DirectiveLocation","QUERY","MUTATION","SUBSCRIPTION","SCHEMA","SCALAR","ARGUMENT_DEFINITION","INTERFACE","UNION","ENUM_VALUE","INPUT_OBJECT","INPUT_FIELD_DEFINITION","sourceObj","TypeError","many","parseDefinition","loc","parseDocument","parseName","expect","peek","parseExecutableDefinition","parseTypeSystemDefinition","keywordToken","expectKeyword","parseDirectives","parseOperationTypeDefinition","unexpected","parseSchemaExtension","parseScalarTypeExtension","parseImplementsInterfaces","parseFieldsDefinition","parseObjectTypeExtension","parseInterfaceTypeExtension","parseUnionMemberTypes","parseUnionTypeExtension","parseEnumValuesDefinition","parseEnumTypeExtension","parseInputFieldsDefinition","parseInputObjectTypeExtension","parseTypeSystemExtension","peekDescription","parseOperationDefinition","experimentalFragmentVariables","parseFragmentName","parseVariableDefinitions","parseNamedType","parseSelectionSet","parseFragmentDefinition","parseOperationType","operationToken","parseVariableDefinition","experimentalVariableDefinitionDirectives","parseVariable","parseTypeReference","skip","parseValueLiteral","parseSelection","parseFragment","nameOrAlias","parseArguments","parseField","isConst","parseConstArgument","parseArgument","parseConstValue","parseValueValue","any","parseList","parseObjectField","parseObject","parseStringLiteral","parseDirective","parseSchemaDefinition","parseDescription","parseScalarTypeDefinition","parseObjectTypeDefinition","parseInterfaceTypeDefinition","parseUnionTypeDefinition","parseEnumTypeDefinition","parseInputObjectTypeDefinition","parseArgumentDefs","parseDirectiveLocation","parseDirectiveLocations","parseDirectiveDefinition","allowLegacySDLImplementsInterfaces","allowLegacySDLEmptyFields","parseFieldDefinition","parseInputValueDef","parseEnumValueDefinition","startToken","noLocation","Loc","endToken","atToken","openKind","parseFn","closeKind","nodes","graphqlOperation","defaultAuthenticationType","aws_appsync_authenticationType","session","doc","operationType","paramQuery","authMode","operationDef","_graphql","_graphqlSubscribe","_l","customGraphqlEndpoint","customEndpointRegion","_headerBasedAuth","_k","signerServiceInfo","GraphQLAPI","zenObservable","hasSymbol","exports","Uint32Array","Math","v1","require","v4","module","getRandomValues","crypto","msCrypto","rnds8","Uint8Array","rnds","r","random","byteToHex","buf","offset","bth","getLocation","lineRegexp","exec","highlightSourceAtLocation","location","firstLineColumnOffset","whitespace","lineIndex","lineOffset","lineNum","columnOffset","columnNum","existingLines","padLen","_iteratorNormalCompletion3","_didIteratorError3","_iteratorError3","_step3","_iterator3","done","prefix","max","return","printPrefixedLines","len","positions","originalError","_nodes","_source","_locations","_positions","list","_extensions","defineProperties","captureStackTrace","create","printedLocations","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_step2","_iterator2","printError","_cancelTokenMap","WeakMap","urlOrApiInfo","parsed_url","_parseUrl","params","responseType","timeout","cancelToken","libraryHeaders","isReactNative","isAllResponse","FormData","withCredentials","custom_header_obj","queryStringParameters","_request","_signed","isClockSkewError","dateHeader","date","responseDate","requestDate","getDateFromHeaderString","isClockSkewed","setClockOffset","getTime","ajax","axios","CancelToken","cancelTokenSource","_region","_service","_custom_header","otherParams","endpoint_region","endpoint_service","signerServiceInfoParams","signed_params","parts","tslib_1","secret","RawSha256_1","outer","inner","input","convertToBuffer","byteLength","constants_1","bufferHash","digest","buffer","bufferFromSecret","Sha256","toHash","isEmptyData","finished","util_utf8_browser_1","ArrayBuffer","isView","byteOffset","BYTES_PER_ELEMENT","Int32Array","RawSha256","bytesHashed","bufferLength","hashBuffer","bitsHashed","bufferView","DataView","undecoratedLength","setUint8","setUint32","floor","out","state","state0","state1","state2","state3","state4","state5","state6","state7","temp","u","t1_1","t2_1","t1","t2","_classCallCheck","instance","Constructor","_defineProperties","target","props","descriptor","_createClass","protoProps","staticProps","hasSymbols","getSymbol","SymbolIterator","SymbolObservable","SymbolSpecies","getMethod","getSpecies","ctor","isObservable","hostReportError","log","enqueue","fn","cleanupSubscription","subscription","cleanup","_cleanup","closeSubscription","_observer","_queue","_state","notifySubscription","m","onNotify","queue","flushSubscription","Subscription","subscriber","subscriptionObserver","SubscriptionObserver","_subscription","_subscriber","_this2","_this3","_this4","C","hasSeed","hasValue","seed","first","_this5","_len","sources","_key","startNext","_this6","completeIfDone","s","_item","_len2","items","_key2","symbol","factory","global","localStorage","setItem","removeItem","MESSAGE_TYPE","validate","errorStr","validKey","ERROR","INVALID_TYPE","f","apply","OK","text","CONNECT_TIMEOUT","SUBSCRIBE_TIMEOUT","UNSUBSCRIBE_TIMEOUT","PING_TIMEOUT","INTERNAL_ERROR","CONNACK_RETURNCODE","SOCKET_ERROR","SOCKET_CLOSE","MALFORMED_UTF","UNSUPPORTED","INVALID_STATE","INVALID_ARGUMENT","UNSUPPORTED_OPERATION","INVALID_STORED_DATA","INVALID_MQTT_MESSAGE_TYPE","MALFORMED_UNICODE","BUFFER_FULL","CONNACK_RC","0","1","2","3","4","5","substitutions","field","part1","substring","part2","MqttProtoIdentifierv3","MqttProtoIdentifierv4","WireMessage","decodeMessage","digit","startingPos","messageInfo","remLength","multiplier","endPos","wireMessage","sessionPresent","returnCode","qos","readUint16","topicName","parseUTF8","messageIdentifier","Message","subarray","retained","duplicate","destinationName","payloadMessage","writeUint16","writeString","utf8Length","stringToUTF8","UTF8Length","output","lowCharCode","utf16","byte1","byte2","byte3","byte4","encode","willMessagePayloadBytes","topicStrLength","destinationNameLength","willMessage","payloadBytes","userName","password","requestedQos","mbi","number","numBytes","encodeMBI","byteStream","connectFlags","cleanSession","keepAliveInterval","Pinger","_client","_keepAliveInterval","isReset","pingReq","doTimeout","pinger","doPing","_trace","socket","_disconnected","reset","Timeout","timeoutSeconds","action","ClientImpl","uri","_wsuri","_localKey","_msg_queue","_buffered_msg_queue","_sentMessages","_receivedMessages","_notify_msg_sent","_message_identifier","_sequence","restore","connected","maxMessageIdentifier","connectOptions","hostIndex","onConnected","onMessageDelivered","traceFunction","_connectTimeout","sendPinger","receivePinger","_reconnectInterval","_reconnecting","_reconnectTimeout","disconnectedPublishing","disconnectedBufferSize","receiveBuffer","_traceBuffer","_MAX_TRACE_ENTRIES","connectOptionsMasked","_traceMask","uris","_doConnect","subscribeOptions","grantedQos","invocationContext","errorMessage","timeOut","_requires_ack","_schedule_message","unsubscribeOptions","callback","sequence","unshift","getTraceLog","startTrace","stopTrace","wsurl","uriParts","binaryType","_on_socket_open","_on_socket_message","_on_socket_error","_on_socket_close","_process_queue","store","storedMessage","version","pubRecReceived","hex","messageBytes","payloadHex","parseInt","_socket_send","messageCount","messages","_deframeMessages","_handleMessage","byteArray","newData","errorStack","sentMessage","receivedMessage","sequencedMessages","msgId","pubRelMessage","reconnected","_connected","_receivePublish","_receiveMessage","pubCompMessage","wireMessageMasked","pubAckMessage","pubRecMessage","reconnect","_reconnect","errorText","mqttVersionExplicit","record","severity","traceObject","masked","traceObjectMasked","attr","newPayload","newDestinationName","newQos","newRetained","newTopic","newDuplicate","Client","ipv6AddSBracket","clientIdLength","newOnConnected","newDisconnectedPublishing","newDisconnectedBufferSize","newOnConnectionLost","newOnMessageDelivered","newOnMessageArrived","trace","hosts","ports","stringPayload","usingURIs","test","ipv6","self","_nodeId","_clockseq","rng","bytesToUuid","_lastMSecs","_lastNSecs","clockseq","seedBytes","msecs","nsecs","tl","tmh","n","fromUtf8","TextEncoder","textEncoderFromUtf8","bytes","surrogatePair","jsFromUtf8","toUtf8","TextDecoder","decode","textEncoderToUtf8","decoded","byte","nextByte","encoded","byteValue","decodeURIComponent","jsToUtf8","clockOffset","getClockOffset","getHeaderStringFromDate","year","month","day","hour","minute","second","UTC","Number","serverDate","abs"],"mappings":"iGAAA,sDAmCaA,GAnCb,cAmCyB,CACxBC,UAAWC,IAASD,YAUNE,EAAO,G,iCA9CtB,kBAyBeC,MAAI,G,m+DCLbC,EAAS,IAAIC,IAAO,WAK1B,aAaC,WAAYC,GARJ,UAAmB,KAE3B,iBAAcC,IAOb,KAAKC,SAAWF,EAChBF,EAAOK,MAAM,cAAe,KAAKD,UAuSnC,OApSQE,0BAAP,WACC,MAAO,WAQRA,sBAAA,SAAUJ,GACT,IAAMK,QAAEC,QAAAC,kBAAUC,eACdC,EAAG,OAAQD,GAAiBD,GAGhC,GAFAT,EAAOK,MAAM,qBAAsB,CAAEM,IAAG,IAEpCA,EAAwB,mBAAG,CAC9B,GAAIA,EAA4B,uBAAG,CAClC,IAAMC,EAASD,EAA4B,uBAC3CA,EAAIE,UACe,kBAAXD,EAAsBE,KAAKC,MAAMH,GAAUA,EAGpDD,EAAMK,OAAOC,OAAO,GAAIN,EAAK,CAC5BO,OAAQP,EAAwB,mBAChCQ,OAAQ,KA2BV,OAvBIC,MAAMC,QAAQV,EAAIE,WAErBF,EAAIE,UAAUS,SAAQ,YAEc,qBAA3BC,EAASC,eACkB,oBAA3BD,EAASC,gBAEhBxB,EAAOyB,KACN,YAAcF,EAASG,KAAO,wCAE/BH,EAASC,mBAAgBG,MAGjB,KAAKvB,UAAYgB,MAAMC,QAAQ,KAAKjB,SAASS,WACvDF,EAAIE,UAAY,KAAKT,SAASS,UAE9BF,EAAIE,UAAY,GAGjB,KAAKT,SAAWY,OAAOC,OAAO,GAAI,KAAKb,SAAUO,GAEjD,KAAKiB,iBAEE,KAAKxB,UAObE,2BAAA,WAMC,OALAN,EAAOK,MAAM,4BACb,KAAKwB,KAAO,IAAIC,IAAW,KAAK1B,UAGhC,KAAKyB,KAAK1B,YAAc,KAAKA,aACtB,GAURG,gBAAA,SAAIyB,EAASC,EAAMC,GAClB,IACC,IAAMC,EAAU,KAAKC,gBAAgBJ,EAASC,GAExCI,EAAmB,KAAKP,KAAKQ,sBAE7BC,EAAatB,OAAOC,OAAO,GAAIgB,GACrCK,EAAWF,iBAAmBA,EAE9B,IAAMG,EAAkB,KAAKV,KAAKW,IAAIN,EAASI,GAI/C,OAFA,KAAKT,KAAKY,6BAA6BF,EAAiBH,GAEjDG,EACN,MAAOG,GACR,OAAOC,QAAQC,OAAOF,EAAIG,WAW5BvC,iBAAA,SAAKyB,EAASC,EAAMC,GACnB,IACC,IAAMC,EAAU,KAAKC,gBAAgBJ,EAASC,GAExCI,EAAmB,KAAKP,KAAKQ,sBAE7BC,EAAatB,OAAOC,OAAO,GAAIgB,GACrCK,EAAWF,iBAAmBA,EAE9B,IAAMG,EAAkB,KAAKV,KAAKiB,KAAKZ,EAASI,GAIhD,OAFA,KAAKT,KAAKY,6BAA6BF,EAAiBH,GAEjDG,EACN,MAAOG,GACR,OAAOC,QAAQC,OAAOF,EAAIG,WAW5BvC,gBAAA,SAAIyB,EAASC,EAAMC,GAClB,IACC,IAAMC,EAAU,KAAKC,gBAAgBJ,EAASC,GAExCI,EAAmB,KAAKP,KAAKQ,sBAE7BC,EAAatB,OAAOC,OAAO,GAAIgB,GACrCK,EAAWF,iBAAmBA,EAE9B,IAAMG,EAAkB,KAAKV,KAAKkB,IAAIb,EAASI,GAI/C,OAFA,KAAKT,KAAKY,6BAA6BF,EAAiBH,GAEjDG,EACN,MAAOG,GACR,OAAOC,QAAQC,OAAOF,EAAIG,WAW5BvC,kBAAA,SAAMyB,EAASC,EAAMC,GACpB,IACC,IAAMC,EAAU,KAAKC,gBAAgBJ,EAASC,GAExCI,EAAmB,KAAKP,KAAKQ,sBAE7BC,EAAatB,OAAOC,OAAO,GAAIgB,GACrCK,EAAWF,iBAAmBA,EAE9B,IAAMG,EAAkB,KAAKV,KAAKmB,MAAMd,EAASI,GAIjD,OAFA,KAAKT,KAAKY,6BAA6BF,EAAiBH,GAEjDG,EACN,MAAOG,GACR,OAAOC,QAAQC,OAAOF,EAAIG,WAW5BvC,gBAAA,SAAIyB,EAASC,EAAMC,GAClB,IACC,IAAMC,EAAU,KAAKC,gBAAgBJ,EAASC,GAExCI,EAAmB,KAAKP,KAAKQ,sBAE7BC,EAAatB,OAAOC,OAAO,GAAIgB,GACrCK,EAAWF,iBAAmBA,EAE9B,IAAMG,EAAkB,KAAKV,KAAKoB,IAAIf,EAASI,GAI/C,OAFA,KAAKT,KAAKY,6BAA6BF,EAAiBH,GAEjDG,EACN,MAAOG,GACR,OAAOC,QAAQC,OAAOF,EAAIG,WAW5BvC,iBAAA,SAAKyB,EAASC,EAAMC,GACnB,IACC,IAAMC,EAAU,KAAKC,gBAAgBJ,EAASC,GAExCI,EAAmB,KAAKP,KAAKQ,sBAE7BC,EAAatB,OAAOC,OAAO,GAAIgB,GACrCK,EAAWF,iBAAmBA,EAE9B,IAAMG,EAAkB,KAAKV,KAAKqB,KAAKhB,EAASI,GAIhD,OAFA,KAAKT,KAAKY,6BAA6BF,EAAiBH,GAEjDG,EACN,MAAOG,GACR,OAAOC,QAAQC,OAAOF,EAAIG,WAS5BvC,qBAAA,SAAS6C,GACR,OAAO,KAAKtB,KAAKuB,SAASD,IAQ3B7C,mBAAA,SAAO+C,EAAuBR,GAC7B,OAAO,KAAKhB,KAAKyB,OAAOD,EAASR,IAQ5BvC,qBAAN,SAAeyB,G,mEACd,SAAO,KAAKF,KAAKN,SAASQ,WASnBzB,4BAAR,SAAwByB,EAAiBC,GACxC,IAAMuB,EAAoB,KAAKnD,SAASS,UAExC,IAAKO,MAAMC,QAAQkC,GAClB,MAAM,IAAIC,MAAM,+BAGjB,IAAMC,EAAYF,EAAkBG,MAAK,YAAO,SAAIhC,OAASK,KAE7D,IAAK0B,EACJ,MAAM,IAAID,MAAM,OAAOzB,EAAO,mBAG/B,IAAM4B,EAAoB,CACzBpC,SAAUkC,EAAUlC,SAAWS,GAqBhC,MAlBgC,kBAArByB,EAAUvC,OACpByC,EAASzC,OAASuC,EAAUvC,OACc,kBAAzB,KAAKd,SAASc,SAC/ByC,EAASzC,OAAS,KAAKd,SAASc,QAGA,kBAAtBuC,EAAUG,QACpBD,EAASC,QAAUH,EAAUG,SAAW,cAExCD,EAASC,QAAU,cAGmB,oBAA5BH,EAAUjC,cACpBmC,EAASnC,cAAgBiC,EAAUjC,cAEnCmC,EAASnC,mBAAgBG,EAGnBgC,GAET,EAtTA,GAwTaE,EAAU,IAAIvD,EAAa,MACxCR,IAAQgE,SAASD,G,0iDCvTX7D,EAAS,IAAIC,IAAO,OA0KbQ,EAAM,IApKnB,WAiBC,WAAYP,GARZ,UAAOH,IACP,WAAQgE,IACR,iBAAc5D,IAOb,KAAKC,SAAWF,EAChB,KAAK8D,SAAW,IAAI1D,EAAaJ,GACjC,KAAK+D,YAAc,IAAIC,IAAgBhE,GACvCF,EAAOK,MAAM,cAAe,KAAKD,UA6InC,OA1IQ+D,0BAAP,WACC,MAAO,OAQRA,sBAAA,SAAUjE,GACT,KAAKE,SAAWY,OAAOC,OAAO,GAAI,KAAKb,SAAUF,GAGjD,KAAK8D,SAAS7D,YAAc,KAAKA,YAEjC,KAAK8D,YAAYlE,KAAO,KAAKA,KAC7B,KAAKkE,YAAYF,MAAQ,KAAKA,MAC9B,KAAKE,YAAY9D,YAAc,KAAKA,YAEpC,IAAMiE,EAAgB,KAAKJ,SAASK,UAAU,KAAKjE,UAC7CkE,EAAmB,KAAKL,YAAYI,UAAU,KAAKjE,UAEzD,cAAYgE,GAAkBE,IAU/BH,gBAAA,SAAIpC,EAASC,EAAMC,GAClB,OAAO,KAAK+B,SAASxB,IAAIT,EAASC,EAAMC,IAUzCkC,iBAAA,SAAKpC,EAASC,EAAMC,GACnB,OAAO,KAAK+B,SAASlB,KAAKf,EAASC,EAAMC,IAU1CkC,gBAAA,SAAIpC,EAASC,EAAMC,GAClB,OAAO,KAAK+B,SAASjB,IAAIhB,EAASC,EAAMC,IAUzCkC,kBAAA,SAAMpC,EAASC,EAAMC,GACpB,OAAO,KAAK+B,SAAShB,MAAMjB,EAASC,EAAMC,IAU3CkC,gBAAA,SAAIpC,EAASC,EAAMC,GAClB,OAAO,KAAK+B,SAASf,IAAIlB,EAASC,EAAMC,IAUzCkC,iBAAA,SAAKpC,EAASC,EAAMC,GACnB,OAAO,KAAK+B,SAASd,KAAKnB,EAASC,EAAMC,IAQ1CkC,qBAAA,SAAShB,GACR,OAAO,KAAKa,SAASZ,SAASD,IAO/BgB,mBAAA,SAAOd,EAAuBR,GAC7B,OAAO,KAAKmB,SAASV,OAAOD,EAASR,IAQhCsB,qBAAN,SAAepC,G,mEACd,SAAO,KAAKiC,SAASzC,SAASQ,WAO/BoC,oCAAA,SAAwBI,GACvB,OAAO,KAAKN,YAAYO,wBAAwBD,IAUjDJ,oBAAA,SACCjE,EACAuE,GAEA,OAAO,KAAKR,YAAYS,QAAQxE,EAASuE,IAE3C,EAlKA,GAoKmB,CAAa,MAChC3E,IAAQgE,SAASrD,I,iCCtMjB,+E,4hBAmBMT,EAAS,IAAIC,IAAO,UAKpB0E,EAAU,SAASC,EAAKC,GAC7B,IAAMC,EAAO,IAAIC,SAASH,GAE1B,OADAE,EAAKE,OAAOH,GACLC,EAAKG,cAGPH,EAAO,SAASD,GACrB,IAAMK,EAAML,GAAO,GACbC,EAAO,IAAIC,SAEjB,OADAD,EAAKE,OAAOE,GACLC,YAAML,EAAKG,eA2FbG,EAAiB,SAASC,GAC/B,OAAOrE,OAAOsE,KAAKD,GACjBE,KAAI,SAASX,GACb,OAAOA,EAAIY,iBAEXC,OACAC,KAAK,MAmBFC,EAAoB,SAAStC,GAClC,IArDkCgC,EAxCFO,EA6F1BC,EAAW9E,gBAAMsC,EAAQyC,KAE/B,MAAO,CACNzC,EAAQ0C,QAAU,IAClBC,mBAAmBH,EAASI,UAAUC,QAAQ,QAAS,MAjGxBN,EAkGfC,EAASD,MAjGrBA,GAA0B,IAAjBA,EAAMO,OAIbP,EACLQ,MAAM,KACNb,KAAI,YACJ,IAAMc,EAAUC,EAAEF,MAAM,KAExB,GAAuB,IAAnBC,EAAQF,OACX,OAAOG,EAEP,IAAMC,EAA+BF,EAAQ,GA7B/BH,QAAQ,YAAY,SAASM,GAC7C,MACC,IACAA,EACEC,WAAW,GACXC,SAAS,IACTC,iBAwBD,OAAON,EAAQ,GAAK,IAAME,KAG3Bd,MAAK,SAACmB,EAAGC,GACT,IAAMC,EAAQF,EAAER,MAAM,KAAK,GACrBW,EAAQF,EAAET,MAAM,KAAK,GAC3B,OAAIU,IAAUC,EACNH,EAAIC,GAAK,EAAI,EAEbC,EAAQC,GAAS,EAAI,KAG7BrB,KAAK,KAxBC,KAsC0BL,EA2DfhC,EAAQgC,QA1DtBA,GAA2C,IAAhCrE,OAAOsE,KAAKD,GAASc,OAKpCnF,OAAOsE,KAAKD,GACVE,KAAI,SAASX,GACb,MAAO,CACNA,IAAKA,EAAIY,cACTwB,MAAO3B,EAAQT,GAAOS,EAAQT,GAAKqC,OAAOf,QAAQ,OAAQ,KAAO,OAGlET,MAAK,SAASmB,EAAGC,GACjB,OAAOD,EAAEhC,IAAMiC,EAAEjC,KAAO,EAAI,KAE5BW,KAAI,SAAS2B,GACb,OAAOA,EAAKtC,IAAM,IAAMsC,EAAKF,SAE7BtB,KAAK,MAAQ,KAjBR,IA0DPN,EAAe/B,EAAQgC,SACvBP,EAAKzB,EAAQ8D,OACZzB,KAAK,OAGF0B,EAAqB,SAAS/D,GACnC,IAIIgE,GAJatG,gBAAMsC,EAAQyC,KACdwB,KAEIC,MAAM,6CACF,IAAIC,MAAM,EAAG,GAOtC,MALkB,OAAdH,EAAO,KAEVA,EAASA,EAAOI,WAGV,CACN7D,QAASP,EAAQO,SAAWyD,EAAO,GACnCnG,OAAQmC,EAAQnC,QAAUmG,EAAO,KAI7BK,EAAmB,SAASC,EAAOzG,EAAQ0C,GAChD,MAAO,CAAC+D,EAAOzG,EAAQ0C,EAAS,gBAAgB8B,KAAK,MAiBhDkC,EAAiB,SAASC,EAAWlC,EAAmBmC,EAAQC,GACrE,MAAO,CAACF,EAAWC,EAAQC,EAAOjD,EAAKa,IAAoBD,KAAK,OAiB3DsC,EAAkB,SAASC,EAAYN,EAAOO,GACnDlI,EAAOK,MAAM6H,GACb,IACCC,EAASxD,EADA,OAASsD,EACEN,GACpBS,EAAWzD,EAAQwD,EAAQD,EAAahH,QACxCmH,EAAY1D,EAAQyD,EAAUF,EAAatE,SAG5C,OAFae,EAAQ0D,EAAW,iBAK3BC,EAAgB,SAASC,EAAaC,GAC3C,OAAOrD,YAAMR,EAAQ4D,EAAaC,KAuBnC,2BA4LA,OAvJQC,OAAP,SAAYpF,EAASqF,EAAaR,QAAA,QAAAA,QACjC7E,EAAQgC,QAAUhC,EAAQgC,SAAW,GAGrC,IACCyC,EADUa,IAAUC,yBACRC,cAAc3C,QAAQ,iBAAkB,IACpDyB,EAAQG,EAAOgB,OAAO,EAAG,GAEpBjD,EAAW9E,gBAAMsC,EAAQyC,KAC/BzC,EAAQgC,QAAc,KAAIQ,EAASyB,KACnCjE,EAAQgC,QAAQ,cAAgByC,EAC5BY,EAAYK,gBACf1F,EAAQgC,QAAQ,wBAA0BqD,EAAYK,eAIvD,IAAMC,EAAcrD,EAAkBtC,GACtCrD,EAAOK,MAAM2I,GAGb,IAAMC,EAAcf,GAAgBd,EAAmB/D,GACtD0E,EAAQL,EAAiBC,EAAOsB,EAAY/H,OAAQ+H,EAAYrF,SAChE4E,EAAcZ,EAlSS,mBAoStBoB,EACAlB,EACAC,GAIIQ,EAAcP,EAClBU,EAAYT,WACZN,EACAsB,GAEDC,EAAYZ,EAAcC,EAAaC,GAGlCW,EAzFyB,SAChCtB,EACAuB,EACArB,EACA3C,EACA8D,GAEA,MAAO,CACNrB,iBAAkCuB,EAAa,IAAMrB,EACrD,iBAAmB3C,EACnB,aAAe8D,GACdxD,KAAK,MA8EuB2D,CAlTL,mBAoTvBX,EAAYU,WACZrB,EACA3C,EAAe/B,EAAQgC,SACvB6D,GAID,OAFA7F,EAAQgC,QAAuB,cAAI8D,EAE5B9F,GAeDoF,UAAP,SACCa,EACAC,EACAN,EACAO,GAEA,IAAMC,EACmB,kBAAjBH,EAA4BA,EAAaxD,IAAMwD,EACjDvD,EACmB,kBAAjBuD,EAA4BA,EAAavD,OAAS,MACpD2D,EACmB,kBAAjBJ,EAA4BA,EAAaI,UAAO/H,EAElDgI,EAAMhB,IAAUC,yBACpBC,cACA3C,QAAQ,iBAAkB,IACtB0D,EAAQD,EAAIb,OAAO,EAAG,GAEtBvI,2BAAUsJ,GAARC,SAAQD,iBAEVE,EAAgB,CAAEzC,KADhB,QAGF,QAAAxB,0BAAE5E,WAAQ0C,YAEVoG,EAAkBtC,EAAiBkC,EAAO1I,EAAQ0C,GAIlDqG,EACLV,EAAWR,eAtWW,qBAsWMnF,EACvBsG,EAAW,OAChB,kBAzWuB,mBA0WvB,mBAAoB,CAACX,EAAWH,WAAYY,GAAiBtE,KAAK,KAClE,aAAciE,EAAIb,OAAO,EAAG,KACxBmB,EACD,CAAE,uBAAwB,GAAGV,EAAWR,eACxC,IACCS,EAAa,CAAE,gBAAiB,GAAGA,GAAiB,IAAG,CAC3D,sBAAuBxI,OAAOsE,KAAKyE,GAAerE,KAAK,OAGlDyE,EAAmBxE,EAAkB,CAC1CI,OAAM,EACND,IAAKsE,iBAAM,OACPP,GAAS,CACZjE,MAAK,OACDiE,EAAUjE,OACVsE,MAGL7E,QAAS0E,EACT5C,KAAMuC,IAGDW,EAAezC,EAhYG,mBAkYvBuC,EACAR,EACAK,GAGKzB,EAAcP,EAAgBuB,EAAWtB,WAAY2B,EAAO,CACjE1I,OAAM,EACN0C,QAAO,IAEFsF,EAAYZ,EAAcC,EAAa8B,GAEvCC,EAAqB,GAC1B,kBAAmBpB,GACfK,EAAWR,eAAiB,CAC/B,uBAAwBQ,EAAWR,gBAiBrC,OAbeqB,iBAAO,CACrBG,SAAUV,EAAUU,SACpBC,SAAS,EACTC,SAAUZ,EAAUY,SACpBC,KAAMb,EAAUa,KAChBzE,SAAU4D,EAAU5D,SACpBL,MAAK,SACDiE,EAAUjE,OACVsE,GACAI,MAMP,EA5LA,I,iCH5PA,sCAgBKK,EAhBL,UAgBA,SAAKA,GACJA,wCACAA,0CACAA,sCAHD,CAAKA,MAAW,KAWDC,MAAM,G,mVIXf5K,EAAS,IAAIC,IAAO,0BAE1B,aAGC,WAAYC,QAAA,QAAAA,MACX,KAAK2K,QAAU3K,EAiCjB,OA9BC4K,sBAAA,SAAUC,GAKT,YALS,QAAAA,MACT,KAAKF,QAAO,OAAQE,GAAW,KAAKF,SAEpC7K,EAAOK,MAAM,aAAa,KAAK2K,kBAAqB,KAAKH,SAElD,KAAK3K,SAGb4K,wBAAA,WACC,MAAO,UAKR9J,sBAAc8J,sBAAO,C,IAArB,WACC,YAAY,KAAKD,U,gCAenB,EArCA,G,qrECEM7K,EAAS,IAAIC,IAAO,sBAqB1B,ICiBKgL,EAqDAC,EAMAC,ED5EL,0BACS,cAAsC,IAAIC,IAsBnD,OApBOC,gBAAN,SAAUC,EAAkBC,G,yEAE3B,OADIC,EAAU,KAAKC,SAASjJ,IAAI8I,MAKhCE,EAAUD,EAAcD,GAExB,KAAKG,SAASC,IAAIJ,EAAUE,IAL3B,GAAOA,UAUTxK,sBAAIqK,yBAAU,C,IAAd,WACC,OAAOjK,MAAMuK,KAAK,KAAKF,SAASnG,S,gCAGjC+F,mBAAA,SAAOC,GACN,KAAKG,SAASG,OAAON,IAEvB,EAvBA,GAyBMO,EAAgC,qBAAXC,OAAyBA,OAAO,SAAW,UAEtE,cAGC,WAAY5L,QAAA,QAAAA,MAAZ,MACC6L,mBAAW7L,GAAO,CAAEoL,SAAUpL,EAAQoL,UAAYU,mBAAS,K,OAHpDC,gBAAgB,IAAIZ,EA0HlBY,kBAGN,IAAIb,IAEEa,qBAGN,IAAIb,I,EAsGT,OAzOwCc,OAOvClL,sBAAcmL,uBAAQ,C,IAAtB,WACC,OAAO,KAAKjM,QAAQoL,U,gCAGrBtK,sBAAcmL,uBAAQ,C,IAAtB,WACC,OAAO,KAAKjM,QAAQkM,qB,gCAGrBpL,sBAAcmL,2BAAY,C,IAA1B,WACC,OAAO,KAAKE,e,gCAGbrL,sBAAcmL,2BAAY,C,IAA1B,WACC,OAAQ,KAAKjM,QACXoM,8D,gCAGOH,6BAAV,SAA2BnF,GAC1B,MAAwB,kBAAVA,GAAsBA,EAAM6E,IAG3CM,4BAAA,WACC,MAAO,sBAGDA,yBAAP,SAAoB5L,GAApB,WAAsB,aAAUgM,cAAWC,gCAC1C,GAAkB,IAAdD,EAAiB,CACpBvM,EAAOyB,KAAK6J,EAAUxK,KAAK2L,UAAS,GAAGF,UAAS,GAAKC,GAAQ,KAAM,IAEnE,IAAME,EAAiB,GACjBC,EAAoB,KAAKC,mBAAmBpK,IAAI8I,GACtD,IAAKqB,EACJ,OAEDA,EAAkBrL,SAAQ,YACzBuL,EAAS1J,MAAM,6BAA+BoJ,GAE9CN,EAAKa,gBAAgBxL,SAAQ,SAACyL,EAAkBC,GAC/CD,EAAiBnB,OAAOiB,GACM,IAA1BE,EAAiBE,MACpBP,EAAeQ,KAAKF,SAMvB,KAAKJ,mBAAmBhB,OAAON,GAG/BoB,EAAepL,SAAQ,YACtB2K,EAAKa,gBAAgBlB,OAAOuB,QAKlBhB,sBAAb,SAAuB5L,G,IACtBuF,QACAwF,a,uGAiBA,OAfAtL,EAAOK,MAAM,2BAA4BiL,IAGnC8B,EAAS,IAAIC,SAAYvH,EAAKwF,IAE7BgC,iBAAmB,SAAC/M,G,IAC1B4M,oBACAI,kBAEAtB,EAAKuB,WAAWL,EAAOI,IAExBH,EAAOK,iBAAmB,SAAClN,GAAE,kBAAWiM,qBACvCP,EAAKyB,aAAY,GAAGpC,SAAQ,EAAEiB,UAAS,GAAKC,KAG7C,GAAM,IAAI7J,SAAQ,SAACgL,EAAS/K,GAC3BwK,EAAOQ,QAAQ,CACdC,OAAQ5B,EAAK6B,aACbC,YAAa,EACbC,UAAW,WAAM,SAAQZ,IACzBa,UAAWrL,Q,OAIb,OATApC,SASA,GAAO4M,WAGQjB,oBAAhB,SACCb,EACApL,G,YAAA,QAAAA,M,8FAEO,SAAM,KAAKgO,aAAa1L,IAAI8I,GAAU,YAC5C,SAAK6C,UAAS,OAAMjO,GAAO,CAAEoL,SAAQ,S,OADtC,SAAO/K,kBAKQ4L,uBAAhB,SAA2Bb,G,gGACX,SAAM,KAAK4C,aAAa1L,IAAI8I,GAAU,WAAM,gB,cAArD8B,EAAS7M,WAED6M,EAAOgB,eACpBhB,EAAOiB,aAER,KAAKH,aAAaI,OAAOhD,G,YAGpBa,oBAAN,SAAcoC,EAA2BhB,G,sGAI5B,OAHNiB,EAAgB,GAAgBC,OAAOF,GACvC1L,EAAU/B,KAAK2L,UAAUc,GAEnB,GAAM,KAAKhM,U,OAER,OAFTuE,EAAMvF,SAEG,GAAM,KAAKqN,QAAQ,KAAKtC,SAAU,CAAExF,IAAG,K,cAAhDsH,EAAS7M,SAEfP,EAAOK,MAAM,yBAA0BmO,EAAa9I,KAAK,KAAM7C,GAC/D2L,EAAalN,SAAQ,YAAS,SAAOoN,KAAKvB,EAAOtK,M,YAa1CsJ,uBAAR,SAAmBgB,EAAeI,GACjC,IACC,IAAMoB,EAAwB,GAC9B,KAAK7B,gBAAgBxL,SAAQ,SAACyL,EAAkBC,IAtL7C,SAAyB4B,EAAgBzB,GAK9C,IAJA,IAAM0B,EAAcD,EAAOxI,MAAM,KAC3BD,EAAS0I,EAAY1I,OACrB2I,EAAa3B,EAAM/G,MAAM,KAEtB2I,EAAI,EAAGA,EAAI5I,IAAU4I,EAAG,CAChC,IAAMC,EAAOH,EAAYE,GACnBE,EAAQH,EAAWC,GACzB,GAAa,MAATC,EAAc,OAAOF,EAAW3I,QAAUA,EAC9C,GAAa,MAAT6I,GAAgBA,IAASC,EAAO,OAAO,EAE5C,OAAO9I,IAAW2I,EAAW3I,QA4KtB+I,CAAelC,EAAeG,IACjCwB,EAAsBzB,KAAKH,MAG7B,IAAMoC,EAAgBrO,KAAKC,MAAMwM,GAEJ,kBAAlB4B,IACVA,EAActD,GAAesB,GAG9BwB,EAAsBrN,SAAQ,YAC7B8N,EAAkB9N,SAAQ,YAAY,SAAS+N,KAAKF,SAEpD,MAAOhM,GACRnD,EAAOyB,KAAK,yBAA0B0B,EAAOoK,KAI/CpB,sBAAA,SACCoC,EACArO,GAFD,gBAEC,QAAAA,MAEA,IAAMsO,EAAgB,GAAgBC,OAAOF,GAG7C,OAFAvO,EAAOK,MAAM,0BAA2BmO,EAAa9I,KAAK,MAEnD,IAAI4J,KAAW,YAerB,IAAIlC,EAdJoB,EAAalN,SAAQ,YAEpB,IAAI8N,EAAoBnD,EAAKa,gBAAgBtK,IAAI2K,GAE5CiC,IACJA,EAAoB,IAAIG,IAExBtD,EAAKa,gBAAgBpB,IAAIyB,EAAOiC,IAGjCA,EAAkBI,IAAI3C,MAKf,iBAAAvB,0BAGJmE,EAAuBxD,EAAKW,mBAAmBpK,IAAI8I,GAoBvD,OAnBKmE,IACJA,EAAuB,IAAIF,KAE5BE,EAAqBD,IAAI3C,GACzBZ,EAAKW,mBAAmBlB,IAAIJ,EAAUmE,GAErC,8B,+EACQlP,EAA8BL,EAAO,K,MAA/B,GAAM,KAAKqB,U,cAAXf,W,kCAANsF,EAAG,E,iBAGD,O,sBAAA,GAAM,KAAK8H,QAAQtC,EAAU,CAAExF,IAAG,K,cAA3CsH,EAASsC,SACTlB,EAAalN,SAAQ,YACpB8L,EAAOuC,UAAUxC,M,+BAGlBN,EAAS1J,MAAMyM,G,8BAIV,WA4BN,OA3BA5P,EAAOK,MAAM,8BAA+BmO,EAAa9I,KAAK,MAE1D0H,IACHnB,EAAKW,mBAAmBpK,IAAI8I,GAAUM,OAAOiB,GAEM,IAA/CZ,EAAKW,mBAAmBpK,IAAI8I,GAAU2B,OACzChB,EAAKoC,WAAW/C,GAChBW,EAAKW,mBAAmBhB,OAAON,IAGhCkD,EAAalN,SAAQ,YACpB,IAAM8N,EACLnD,EAAKa,gBAAgBtK,IAAI2K,IACxB,IAAIoC,IAENH,EAAkBxD,OAAOiB,GAGM,IAA3BuC,EAAkBnC,OACrBhB,EAAKa,gBAAgBlB,OAAOuB,GACxBC,EAAOgB,eACVhB,EAAOyC,YAAY1C,QAMhB,UAIX,EAzOA,CAAwCrC,G,41EElDlC9K,EAAS,IAAIC,IAAO,sBAE1B,yE,OAgDSgM,eAAoC,IAAIb,IAExCa,cAAmC,IAAIb,I,EAoIhD,OAtLwCc,OACvClL,sBAAc8O,uBAAQ,C,IAAtB,WACC,MAAM,IAAItM,MAAM,kB,gCAGjBsM,4BAAA,WACC,MAAO,sBAGKA,oBAAb,SAAqBvB,EAA2BhB,EAAUrN,G,mEACzD,MAAM,IAAIsD,MAAM,kCAGTsM,qBAAR,SAAiBxE,GAAjB,WACyBlK,MAAMuK,KAAK,KAAKoE,aAAaC,WACnDpB,QAAO,SAACrO,GAAU,OAAVC,OAAGgG,GAAS8E,WAAaA,KACjC/F,KAAI,SAAChF,GAAQ,OAARC,OAACyP,MAEQ3O,SAAQ,YAAK,SAAK4O,iBAAiBD,OAG5CH,6BAAR,SAAyB3C,GACxB,KAAK4C,aAAanE,OAAOuB,GACzB,KAAKgD,YAAYvE,OAAOuB,IAGlB2C,yBAAP,SAAoBvP,GAApB,WAAsB,aAAUgM,cAAWC,gCACxB,IAAdD,IACqBnL,MAAMuK,KAAK,KAAKoE,aAAaC,WACnDpB,QAAO,SAACrO,GAAU,OAAVC,OAAGgG,GAAS8E,WAAaA,KACjC/F,KAAI,SAAChF,GAAQ,OAARC,OAACyP,MAEQ3O,SAAQ,YACnB2K,EAAKa,gBAAgBsD,IAAIjD,KAC5BlB,EAAKa,gBAAgBtK,IAAI2K,GAAO7L,SAAQ,YAClC+O,EAAIC,QACRD,EAAIlN,MAAMqJ,MAIZP,EAAKa,gBAAgBlB,OAAOuB,OAI9B,KAAKoD,SAASjF,KAQAwE,uBAAhB,SAA2BxE,G,0FACX,SAAM,KAAK4C,aAAa1L,IAAI8I,GAAU,WAAM,gB,OAE3D,OAFe/K,SAEf,GAAMwL,YAAMsC,WAAU,UAAC/C,I,cAAvB/K,SAEA,KAAKgQ,SAASjF,G,YAGfwE,sBAAA,SAAUvB,EAA2BrO,GAArC,gBAAqC,QAAAA,MACpC,IAAMsQ,EAAS,IAAIlB,KAAgB,YAClC,IAAMd,EAAgB,GAAgBC,OAAOF,GAoF7C,OAnFAvO,EAAOK,MAAM,0BAA2BmO,EAAa9I,KAAK,MAEzD,8B,uEAmDA,OAjDA8I,EAAalN,SAAQ,YACf2K,EAAKa,gBAAgBsD,IAAIH,IAC7BhE,EAAKa,gBAAgBpB,IAAIuE,EAAG,IAAIV,KAGjCtD,EAAKa,gBAAgBtK,IAAIyN,GAAGT,IAAI3C,MAGzBtM,EAA2CL,EAAO,gBAAlDuQ,OAAe,MAAG,GAAE,EAAEC,EAAqBxQ,EAAO,iBAGpDyQ,EAAa3P,OAAOgP,QACzBU,GACCnL,KAAI,SAAChF,G,IAAAC,SAACoQ,OAA2C,OAApCC,KAAuC1D,MAAOyD,MAG7D,KAAKT,YAAc,IAAI/E,IAAG,EACtBhK,MAAMuK,KAAK,KAAKwE,YAAYH,WAC3BW,IAICpL,EAGAvE,OAAOgP,QACZxB,EAAasC,QAAO,SAACC,EAAKC,GACzB,IAAMC,EAAyBR,EAAgB/M,MAC9C,YAAK,SAAE6K,OAAO2C,QAAQF,IAAS,KAGhC,GAAIC,EAAwB,CACnB,eAAkBnL,QAErBiL,EAAIzF,KACRyF,EAAIzF,GAAY,CACfxF,IAAG,EACHyI,OAAQ,IAAIgB,MAIdwB,EAAIzF,GAAUiD,OAAOiB,IAAIwB,GAG1B,OAAOD,IACL,KAIJ,GAAMpO,QAAQwO,IACb5L,EAAIA,KAAI,SAAOhF,G,IAAAC,SAAC8K,OAAUoE,OAAE5J,QAAKyI,W,sGAE5BnB,EAAS,K,iBAEH,O,sBAAA,GAAM,KAAKQ,QAAQtC,EAAU,CACrCA,SAAQ,EACRxF,IAAG,K,cAFJsH,EAASgE,S,aAOT,O,WAFAvE,EAAS1J,MAAM,CAAEN,QAAS,oBAAqBM,MAAOkO,IACtDxE,EAASyE,WACT,QAAO3P,G,OAaR,OARA4M,EAAOjN,SAAQ,YACV8L,EAAOgB,gBACVhB,EAAOuC,UAAUxC,GAEjBlB,EAAK8D,aAAarE,IAAIyB,EAAOC,OAI/B,GAAOA,e,cAzBT5M,S,WA8BM,WACNR,EAAOK,MAAM,8BAA+BmO,EAAa9I,KAAK,MAE9D8I,EAAalN,SAAQ,YACpB,IAAM8L,EAASnB,EAAK8D,aAAavN,IAAIyN,GAEjC7C,GAAUA,EAAOgB,gBACpBhB,EAAOyC,YAAYI,GACnBhE,EAAK8D,aAAanE,OAAOqE,GAGvB7O,MAAMuK,KAAKM,EAAK8D,aAAawB,UAAUC,MAAK,YAAK,WAAMpE,MAExDnB,EAAKoC,WAAWjB,EAAO9B,WAIzBW,EAAKa,gBAAgBlB,OAAOqE,UAK/B,OAAOX,IAAW3D,KAAK6E,GAAQjL,KAAI,YAClC,IAAM4H,EAAQlB,EAAKwF,iBAAiBzK,GAC9B4J,EAAQ3E,EAAKkE,YAAY3N,IAAI2K,GASnC,OAPAnG,EAAMG,KAAOnG,OAAOgP,QAAQhJ,EAAMG,MAAM2J,QACvC,SAACY,EAAKnR,G,IAAAC,SAACmR,OAASC,OAAS,OACvBF,EAAKd,GAASe,GAAsBC,EAAMF,IAE5C,IAGM1K,MAGV,EAtLA,CAAwCmF,G,iuEDalCnM,EAAS,IAAIC,IAAO,8BAEpB4R,EAAoC,qBAAX/F,QACT,oBAAfA,OAAOgG,IACXhG,OAAOgG,IAAI,mBACX,oBAQGC,EAAsB,CAAC,IAAK,IAAK,MAYvC,SAAK9G,GAKJA,wCAKAA,0CAKAA,sCAKAA,oBAKAA,4BAKAA,kBAKAA,iCAKAA,kBAKAA,0BAKAA,oBAlDD,CAAKA,MAAa,KAqDlB,SAAKC,GACJA,yBACAA,6BACAA,uBAHD,CAAKA,MAAmB,KAMxB,SAAKC,GACJA,uBACAA,qBACAA,+BAHD,CAAKA,MAAa,KAMlB,IAAM6G,EAA+B,CACpCC,OAAQ,oCACR,mBAAoB,UACpB,eAAgB,mCAkBjB,yE,OAEShG,eAA8Bd,EAAc+G,OAE5CjG,mBAN0B,IAO1BA,0BAAsD,IAAIb,IAC1Da,eAAwD,G,EAwsBjE,OA9sBgDC,OAQ/CiG,4BAAA,WACC,MAAO,8BAGRA,sBAAA,WACC,MAAM,IAAI3O,MAAM,kBAGJ2O,oBAAb,SAAqBC,EAA4BC,EAAWjS,G,mEAC3D,MAAM,IAAIoD,MAAM,kCAGjB2O,sBAAA,SACCC,EACAlS,GAFD,WAIS,2BAER,OAAO,IAAIoP,KAAW,YACrB,GAAKgD,EAWE,CACN,IAAMC,EAAiBvG,eAOvB,OANAC,EAAKuG,yCAAyC,CAC7CtS,QAAO,EACP2M,SAAQ,EACR4F,eAAc,IAGR,gD,0DAIL,O,uBAAA,GAAM,KAAKC,kCAAkCH,I,OAK7C,GALAhS,WAEQoS,GACP,KAAKC,wBAAwBpQ,IAAI+P,IAAmB,IAAE,mBAItD,UAGD,GAAII,IAAsBzH,EAAoB2H,UAG7C,MAAM,IAAIrP,MAAM,gC,OAFhB,KAAKsP,2BAA2BP,G,+BAKjCvS,EAAOK,MAAM,6BAA6BgR,G,oBAE1C,KAAK0B,4BAA4BR,G,6BAxCnC1F,EAAS1J,MAAM,CACd6P,OAAQ,MAEH,IAAIC,IACN,yDAKJpG,EAASyE,eAsCZtQ,sBAAcmR,2BAAY,C,IAA1B,WACC,OAAQ,KAAKjS,QACXoM,8D,gCAEW6F,qDAAd,SAAuD5R,G,IACtDL,YACA2M,aACA4F,mB,yJA+BK,OA5BJH,EAQGpS,EAAO,uBAPVgT,EAOGhT,EAAO,mBANV0F,EAMG1F,EAAO,MALViT,EAKGjT,EAAO,UAJVkT,EAIGlT,EAAO,OAHVgB,EAGGhB,EAAO,OAFVM,EAEGN,EAAO,gBAFVmT,OAAe,MAAG,WAAM,MAAC,IAAG,EAC5B3D,EACGxP,EAAO,kBADVuE,OAAiB,MAAG,GAAE,EAGjBkO,EAAyCzH,EAAoBoI,QAC7DnM,EAAO,CACZvB,MAAK,EACLuN,UAAS,GAGV,KAAKP,wBAAwBlH,IAAI+G,EAAgB,CAChD5F,SAAQ,EACRjH,MAAK,EACLuN,UAAS,EACTR,kBAAiB,EACjBY,kBAAmB,OAKdC,EAAa1S,KAAK2L,UAAUtF,G,OAE7B,GAAM,KAAKsM,4BAA4B,CAC1CL,OAAM,EACNd,uBAAsB,EACtBY,mBAAkB,EAClBQ,QAASF,EACTG,aAAc,GACdzS,OAAM,K,OAEH,O,4BARA0S,aAQA,GAAMP,K,OATLQ,EAAS,yDASVD,YACDnP,KAAiB,OACnBqP,KAAoBnU,IAAUC,UAAS,KAGnCmU,EAAsB,CAC3BC,GAAIvB,EACJiB,QAAS,CACRvM,KAAMqM,EACNS,WAAY,CACXC,cAAa,KACTL,KAINM,KAAMlJ,EAAcmJ,WAGfC,EAAsBvT,KAAK2L,UAAUsH,G,iBAG1C,O,sBAAA,GAAM,KAAKO,+BAA+B,CACzClB,OAAM,EACNd,uBAAsB,EACtBY,mBAAkB,EAClBhS,OAAM,K,cAJP0S,S,aAyBA,O,WAlBA5T,EAAOK,MAAM,CAAEqC,IAAG,IACV6R,EAAiBC,EAAG,QAApB3R,OAAO,MAAG,GAAE,EACpBgK,EAAS1J,MAAM,CACd6P,OAAQ,MAEH,IAAIC,IAAa,sBAAsBpQ,OAI7CgK,EAASyE,WAMiC,oBAJlCmD,GACP,KAAK7B,wBAAwBpQ,IAAIiQ,IAAmB,IAAE,6BAItDgC,IAED,I,cAOKC,EAGF,KAAK9B,wBAAwBpQ,IAAIiQ,GAFpCkC,EAA0B,6BAC1BC,EAAyB,4BAI1B,KAAKhC,wBAAwBlH,IAAI+G,EAAgB,CAChD5F,SAAQ,EACR8F,kBAAiB,EACjBQ,UAAS,EACTvN,MAAK,EACLgP,0BAAyB,EACzBD,2BAA0B,EAC1BpB,kBAAmBsB,YAAW,WAC7B5I,EAAK6I,6BAA6BC,KAAK9I,EAAMwG,KAnMvB,QAsMpB,KAAKuC,mBACR,KAAKA,kBAAkBtG,KAAK2F,G,YAKhBlC,8CAAd,SAAgDM,G,8EAK/C,OAJ8B,KAAKG,wBAAwBpQ,IAC1DiQ,GACA,oBAEyBvH,EAAoBoI,QAC7C,GAAO,IAAI3Q,SAAQ,SAACsS,EAAKC,GAClB,uCACLrI,aACA8F,sBACAQ,cACAvN,UAEDqG,EAAK2G,wBAAwBlH,IAAI+G,EAAgB,CAChD5F,SAAQ,EACR8F,kBAAiB,EACjBQ,UAAS,EACTvN,MAAK,EACLgP,0BAA2BK,EAC3BN,2BAA4BO,Q,WAMxB/C,uCAAR,SAAmCM,GAClC,IACC,GACC,KAAKuC,mBACL,KAAKA,kBAAkBG,aAAeC,UAAUC,MAChD,KAAKC,eAAiBnK,EAAcoK,MACnC,CAED,IAAMC,EAAqB,CAC1BxB,GAAIvB,EACJ0B,KAAMlJ,EAAcwK,UAEfpB,EAAsBvT,KAAK2L,UAAU+I,GAC3C,KAAKR,kBAAkBtG,KAAK2F,IAE5B,MAAO3R,GAER1C,EAAOK,MAAM,CAAEqC,IAAG,MAIZyP,wCAAR,SAAoCM,GACnC,KAAKG,wBAAwBhH,OAAO6G,GAGpCoC,WAAW,KAAKa,uBAAuBC,KAAK,MAAO,MAG5CxD,mCAAR,WACC,KAAI,KAAKS,wBAAwB3F,KAAO,GAKxC,GAAK,KAAK+H,kBAIV,GAAI,KAAKA,kBAAkBY,eAAiB,EAE3Cf,WAAW,KAAKa,uBAAuBC,KAAK,MAAO,SAC7C,CACN3V,EAAOK,MAAM,wBACbwV,aAAa,KAAKC,oBAClB,IAAMC,EAAa,KAAKf,kBAExBe,EAAWC,aAAUrU,EACrBoU,EAAWE,aAAUtU,EACrBoU,EAAWG,MAAM,KACjB,KAAKlB,kBAAoB,KACzB,KAAKM,aAAenK,EAAc+G,YAflC,KAAKoD,aAAenK,EAAc+G,QAmB5BC,+CAAR,SAA2CtP,GAC1C7C,EAAOK,MACN,mDAAmDwC,EAAQsE,MAEtD,yBAAE3G,OAAAwT,kBAASN,YAASS,SACpB,0CACL/C,aAAAvE,oBACAsJ,UAAAvQ,kBACA2O,cAAApB,kBACAI,sBACAqB,8BACAD,+BAKD,GAFA3U,EAAOK,MAAM,CAAE2T,GAAE,EAAEnH,SAAQ,EAAEjH,MAAK,EAAEuN,UAAS,IAEzCgB,IAASlJ,EAAcmL,UAAY1C,GAAWA,EAAQvM,KACrD0F,EACHA,EAASwC,KAAKqE,GAEd1T,EAAOK,MAAM,8BAA8B2T,QAK7C,GAAIG,IAASlJ,EAAcoL,cAA3B,CA4BA,GAAIlC,IAASlJ,EAAcqL,0BAM1B,OALAT,aAAa,KAAKC,yBAClB,KAAKA,mBAAqBjB,WACzB,KAAK0B,iBAAiBZ,KAAK,KAAMhL,IAAY6L,oBAC7C,KAAKC,mBAKP,GAAItC,IAASlJ,EAAcyL,UAAW,CAC/B/D,EAAoBzH,EAAoByL,OAC9C,KAAK/D,wBAAwBlH,IAAIsI,EAAI,CACpCnH,SAAQ,EACRjH,MAAK,EACLuN,UAAS,EACTI,kBAAiB,EACjBqB,0BAAyB,EACzBD,2BAA0B,EAC1BhC,kBAAiB,IAGlB9F,EAAS1J,MAAM,CACd6P,OAAQ,MAEH,IAAIC,IACN,sBAAsBnS,KAAK2L,UAAUiH,QAKzCmC,aAAatC,GAEb1G,EAASyE,WACiC,oBAA/BqD,GACVA,SA9DF,CACC3U,EAAOK,MACN,0BAA0BS,KAAK2L,UAAU,CAAE7G,MAAK,EAAEuN,UAAS,KAEnB,oBAA9ByB,GACVA,IAEDiB,aAAatC,GA5ZS,SAACqD,EAAezP,EAAWtE,GACnDgU,IAAIC,SAAS,MAAO,CAAEF,MAAK,EAAEzP,KAAI,EAAEtE,QAAO,GAAI,SAAUgP,GA4ZtDkF,CACCpM,IAAYqM,iBACZ,CAAEpR,MAAK,EAAEuN,UAAS,GAClB,2CAED,IAAMR,EAAoBzH,EAAoB2H,UAC9C,KAAKD,wBAAwBlH,IAAIsI,EAAI,CACpCnH,SAAQ,EACRjH,MAAK,EACLuN,UAAS,EACTI,kBAAmB,KACnBZ,kBAAiB,EACjBiC,0BAAyB,EACzBD,2BAA0B,MA8CrBxC,6BAAR,SAAyB5E,GACxBvN,EAAOK,MAAM,qBAAqBkN,GAClC,KAAKqF,wBAAwBtR,SAAQ,SAACf,G,IAAEsM,aACnCA,IAAaA,EAASyD,QACzBzD,EAAS1J,MAAM,CACd6P,OAAQ,MAAM,IAAIC,IAAa1F,UAIlC,KAAKqF,wBAAwBqE,QACzB,KAAKjC,mBACR,KAAKA,kBAAkBkB,QAGxB,KAAKZ,aAAenK,EAAc+G,QAG3BC,yCAAR,SAAqCM,GAC9B,8CAAE5F,aAAUjH,UAAOuN,cAEpBtG,IAGL,KAAK+F,wBAAwBlH,IAAI+G,EAAgB,CAChD5F,SAAQ,EACRjH,MAAK,EACLuN,UAAS,EACTR,kBAAmBzH,EAAoByL,SAGpC9J,IAAaA,EAASyD,SACzBzD,EAAS1J,MAAM,CACd6P,OAAQ,MAEH,IAAIC,IACN,wBAAwBnS,KAAK2L,UAAU,CAAE7G,MAAK,EAAEuN,UAAS,SAM7DtG,EAASyE,YAEVtR,EAAOK,MACN,2BACAS,KAAK2L,UAAU,CAAE7G,MAAK,EAAEuN,UAAS,OAI3BhB,2CAAR,SAAuC5R,GAAvC,WACC+R,2BACAY,uBACAE,WACAlS,WAEA,GAAI,KAAKoU,eAAiBnK,EAAcoK,MAGxC,OAAO,IAAI5S,SAAQ,SAAOsS,EAAKC,GAAG,qC,6EACjC,KAAKgC,aAAahK,KAAK,CAAE+H,IAAG,EAAEC,IAAG,IAE7B,KAAKI,eAAiBnK,EAAc+G,OAApC,Y,iBAaD,O,sBAXD,KAAKoD,aAAenK,EAAcgM,WAE5B5M,EAAW,KAAKuD,aAAe,SAAW,QAC1CsJ,EAAuB9E,EAC3BpM,QAAQ,WAAYqE,GACpBrE,QAAQ,UAAWqE,GACnBrE,QAAQ,cAAe,wBACvBA,QAAQ,YAAa,YAEjBmR,EAAgB,KACD7W,WAAKiM,UACzB,GAAM,KAAKgH,4BAA4B,CACtCP,mBAAkB,EAClBQ,QAAS2D,EACT1D,aAAc,WACdP,OAAM,EACNd,uBAAsB,EACtBpR,OAAM,K,OAQR,OAfMoW,EAAe9W,WACpBkP,WASK6H,EAAWC,SAAO7L,KAAK2L,GAAc5Q,SAAS,UAE9C+Q,EAAYD,SAAO7L,KAAK0L,GAAe3Q,SAAS,UAChDgR,EAAoBN,EAAoB,WAAWG,EAAQ,YAAYE,EAE7E,GAAM,KAAKE,8BAA8B,CAAED,eAAc,K,cAAzDhI,SAEA,KAAKwH,aAAa5V,SAAQ,SAACf,G,IAAE0U,QAC5BjV,EAAOK,MAAM,mCACb4U,OAED,KAAKK,aAAenK,EAAcoK,MAClC,KAAK2B,aAAe,G,+BAEpB,KAAKA,aAAa5V,SAAQ,SAACf,GAAY,SAAV2U,OAAc0C,MAC3C,KAAKV,aAAe,GAEnB,KAAKlC,mBACL,KAAKA,kBAAkBG,aAAeC,UAAUC,MAEhD,KAAKL,kBAAkBkB,MAAM,MAE9B,KAAKlB,kBAAoB,KACzB,KAAKM,aAAenK,EAAc+G,O,kCAMxBC,0CAAd,SAA4C5R,G,IAAEmX,mB,0FAE7C,OADA1X,EAAOK,MAAM,sCACb,GAAMwX,YACL,KAAKC,qBAAqBnC,KAAK,MAC/B,CAAC,CAAE+B,eAAc,IAxkBC,M,cAskBnBlX,S,YAOa2R,iCAAd,SAAmC5R,G,IAAEmX,mB,2GACpC1X,EAAOK,MAAM,0BAA0BqX,G,iBAItC,O,sBAAA,GACQ,IAAI/U,SAAQ,SAACsS,EAAKC,GACxB,IAAM6C,EAAY,IAAI3C,UAAUsC,EAAgB,cAChDK,EAAU9B,QAAU,WACnBjW,EAAOK,MAAM,+BAEd0X,EAAU/B,QAAU,WACnBd,EAAI,IAAI1R,MAAM,gCAEfuU,EAAUC,OAAS,WAElB,OADA/L,EAAK+I,kBAAoB+C,EAClB9C,S,OAMV,OAjBAzU,SAiBA,GACQ,IAAImC,SAAQ,SAACsS,EAAKC,GACxB,IAAI+C,GAAQ,EACZhM,EAAK+I,kBAAkBiB,QAAU,YAChCjW,EAAOK,MAAM,mBAAmBS,KAAK2L,UAAUtJ,KAEhD8I,EAAK+I,kBAAkBgB,QAAU,YAChChW,EAAOK,MAAM,oBAAoBuW,EAAMsB,QACvChD,EAAI,IAAI1R,MAAM1C,KAAK2L,UAAUmK,MAG9B3K,EAAK+I,kBAAkBmD,UAAY,SAACtV,GACnC7C,EAAOK,MACN,kDAAkDwC,EAAQsE,KAAI,KAE/D,IAAMA,EAAOrG,KAAKC,MAAM8B,EAAQsE,MAE/B,SACA5G,YACCC,wCAAA4X,aAphB2B,IAohB3BA,EAGF,GAAIjE,IAASlJ,EAAcoN,mBAe1B,OAdAJ,GAAQ,EACRhM,EAAKwK,iBAAmB2B,EACxBnM,EAAK+I,kBAAkBmD,UAAYlM,EAAKqM,mCAAmC3C,KAC1E1J,GAEDA,EAAK+I,kBAAkBiB,QAAU,YAChCjW,EAAOK,MAAMqC,GACbuJ,EAAKsK,iBAAiB5L,IAAY4N,oBAEnCtM,EAAK+I,kBAAkBgB,QAAU,YAChChW,EAAOK,MAAM,oBAAoBuW,EAAMsB,QACvCjM,EAAKsK,iBAAiB5L,IAAY4N,yBAEnCtD,EAAI,0CAIL,GAAId,IAASlJ,EAAcuN,qBAAsB,CAE/C,gBACCpH,2BAASmD,EAAT4B,qBAAS5B,GAAAG,kBAAE+D,cAAAC,kBAAgB9E,cAI7BsB,EAAI,CAAEwD,UAAS,EAAEnM,eAJYA,cAQ/B,IAAMoM,EAAU,CACfxE,KAAMlJ,EAAc2N,qBAErB3M,EAAK+I,kBAAkBtG,KAAK5N,KAAK2L,UAAUkM,IAY3C9D,WAVA,WACMoD,GACJ/C,EACC,IAAI1R,MACH,2EAMkBmS,KAAK1J,GA7kBA,U,cA2gB7BzL,S,aAwEA,M,WAFQkY,EAAyBG,EAAG,UAAjBtM,EAAcsM,EAAG,UAEhC9G,EAAoB+G,SAASvM,GAC1B,IAAIwM,IAAkBL,GAClBA,EACJ,IAAIlV,MAAMkV,GAEVG,E,yBAKK1G,wCAAd,SAA0C5R,G,IACzC2S,uBACAQ,YACAC,iBACArB,2BACAc,WACAlS,W,oGAWA,OATM8X,EAAgB,CACrBC,QAAS,KAAKC,yBAAyBvD,KAAK,MAC5CwD,QAAS,KAAKC,sBAAsBzD,KAAK,MACzC0D,eAAgB,KAAKC,yBAAyB3D,KAAK,MACnD4D,0BAA2B,KAAKC,sBAAsB7D,KAAK,OAKrC,oBAFjB8D,EAAUT,EAAc9F,KAG7BlT,EAAOK,MAAM,uBAAuB6S,EAAkB,kBACtD,GAAO,MAGA5L,EAASxB,QAAUwM,GAAuB,KAEnC,GAAMmH,EAAQ,CAC5B/F,QAAO,EACPC,aAAY,EACZrB,uBAAsB,EACtBc,OAAM,EACNlS,OAAM,EACNoG,KAAI,M,OAGL,SATe9G,kBAYF2R,kCAAd,SAAoC5R,G,IAAE+G,S,0FACrB,SAAMvH,IAAK2Z,kB,OAC3B,SAAO,CACNC,cAFenZ,SAEQoZ,iBAAiBC,cACxCvS,KAAI,YAIQ6K,qCAAd,SAAuC5R,G,IAAE+G,S,oGAGlB,SAAMvD,IAAM+V,QAAQ,kB,cAApCC,EAAgBvZ,WAErBwZ,EAAQD,EAAcC,M,OADnB,M,OAGiB,SAAMja,IAAKka,4B,QAAzBC,EAAc1Z,YAEnBwZ,EAAQE,EAAYF,O,iBAGtB,IAAKA,EACJ,MAAM,IAAIxW,MAAM,oBAEjB,SAAO,CACNmW,cAAeK,EACf1S,KAAI,YAIQ6K,qCAAd,SAAuC5R,G,IAAE6S,WAAQ9L,S,2EAIhD,OAHM6S,EAAK,IAAIC,KACTC,EAAQF,EAAGtR,cAAc3C,QAAQ,iBAAkB,IAEzD,GAAO,CACNoB,KAAI,EACJ,aAAc+S,EACd,YAAajH,WAIDjB,kCAAd,SAAoC5R,G,IACnCmT,YACAC,iBACArB,2BACApR,W,oGAOsB,OALhBoZ,EAAe,CACpBpZ,OAAM,EACN0C,QAAS,WAGY,GAAM,KAAK2W,sB,OACjC,IADsB/Z,SAErB,MAAM,IAAIgD,MAAM,kBAEH,SAAMrD,IAAYqC,MAAMgY,MAAK,YAAe,MAAC,CAC1DvS,WAAYwS,EAAYC,gBACxBtR,WAAYqR,EAAYE,YACxB5R,cAAe0R,EAAYG,kB,OAW5B,OAdMC,EAAQra,SAMR6C,EAAU,CACfyC,IAAK,GAAGwM,EAAyBqB,EACjCxM,KAAMuM,EACN3N,OAAQ,OACRV,QAAO,KAAO2M,IAIf,GADsBvJ,IAAOqS,KAAKzX,EAASwX,EAAOP,GAC7BjV,iBAMtB8M,+BAAA,WACC,OAAOhS,IAAYqC,MACjBgY,MAAK,YACL,IAAKC,EAAa,OAAO,EACzB,IAAMM,EAAO5a,IAAY6a,MAAMP,GAG/B,OAFAza,EAAOK,MAAM,iDAAkD0a,IAExD,KAEPE,OAAM,YAEN,OADAjb,EAAOyB,KAAK,2BAA4BiB,IACjC,MAGX,EA9sBA,CAAgDoI,G,g1CEvHxC,wBACF9K,GAAS,IAAIC,IAAO,UAgKb2K,GAAS,IA9JtB,WA0CC,WAAY1K,GACX,KAAKE,SAAWF,EAChBF,GAAOK,MAAM,iBAAkB,KAAKD,UACpC,KAAK8a,YAAc,GACnB,KAAKvL,UAAY,KAAKA,UAAUgG,KAAK,MA8GvC,OA1IC3U,sBAAYma,iCAAkB,C,IAA9B,WAIC,OAHK,KAAKC,sBACT,KAAKA,oBAAsB,IAAItL,EAAmB,KAAK1P,WAEjD,KAAKgb,qB,gCAMbpa,sBAAYma,yCAA0B,C,IAAtC,WAMC,OALK,KAAKE,8BACT,KAAKA,4BAA8B,IAAIlJ,EACtC,KAAK/R,WAGA,KAAKib,6B,gCAeNF,0BAAP,WACC,MAAO,UASRA,sBAAA,SAAUjb,GAAV,WACOS,EAAMT,EAAUA,EAAQ0K,QAAU1K,EAAU,GAOlD,OANAF,GAAOK,MAAM,mBAAoB,CAAEM,IAAG,IAEtC,KAAKP,SAAWY,OAAOC,OAAO,GAAI,KAAKb,SAAUO,GAEjD,KAAKua,YAAY3V,KAAI,YAAa,SAAUlB,UAAU4H,EAAK7L,aAEpD,KAAKA,UAOA+a,yBAAb,SAA0BG,G,qEACzB,OAAIA,GAAyC,WAA5BA,EAAUC,eAC1B,KAAKL,YAAYhO,KAAKoO,GAItB,GAFeA,EAAUjX,UAAU,KAAKjE,Y,WAMlC+a,8BAAR,SAA0BK,GACzB,OAAIA,IAAiBC,IACb,KAAKC,mBAETF,IAAiBG,IACb,KAAKC,2BAGN,KAAKV,YAAYxX,MACvB,YAAa,SAAUsH,oBAAsBwQ,MAIvCL,yBAAR,SAAqBjb,QAAA,QAAAA,MACZ,iBACR,IAAKsb,EACJ,OAAO,KAAKN,YAGb,IAAMW,EAAW,KAAKC,kBAAkBN,GACxC,IAAKK,EACJ,MAAM,IAAIrY,MAAM,iCAAiCgY,GAGlD,MAAO,CAACK,IAGHV,oBAAN,SACC5M,EACAhB,EACArN,G,qEAEA,SAAOyC,QAAQwO,IACd,KAAK4K,aAAa7b,GAASqF,KAAI,YAC9B,SAASyW,QAAQzN,EAAQhB,EAAKrN,eAKjCib,sBAAA,SACC5M,EACArO,GAEA,GAAI+b,IAAU,KAAK7b,UAAY,KAAKA,SAAS8b,IAC5C,MAAM,IAAI1Y,MACT,mEAIFxD,GAAOK,MAAM,oBAAqBH,GAElC,IAAMic,EAAY,KAAKJ,aAAa7b,GAEpC,OAAO,IAAIoP,KAAW,YACrB,IAKM8M,EALcD,EAAU5W,KAAI,YAAY,MAAC,CAC9CsW,SAAQ,EACRQ,WAAYR,EAASlM,UAAUpB,EAAQrO,OAGNqF,KAAI,SAAChF,G,IAAEsb,aACxC,OADkDQ,aACvC1M,UAAU,CACpB2M,MAAOC,QAAQpZ,MACfkM,KAAM,YAAS,SAASA,KAAK,CAAEwM,SAAQ,EAAE7U,MAAK,KAC9C7D,MAAO,YAAS,SAASA,MAAM,CAAE0Y,SAAQ,EAAE1Y,MAAK,UAKlD,OAAO,WACN,SAAc7B,SAAQ,YAAgB,SAAauO,sBAGvD,EA5JA,GA8JsB,CAAgB,MACtC/P,IAAQgE,SAAS8G,K,6CC3KX5K,EAAS,IAAIC,IAAO,QAK1B,aAqBC,WAAYC,GAjBZ,cAAwB,KAKxB,WAAQ,KAKR,WAAQ,GAQP,KAAKE,SAAWY,OAAOC,OAAO,GAAIf,GAClC,KAAKsc,MAAQ,KAAKpc,SAASqc,UAGzB,KAAKD,OACY,qBAAXE,QACPA,QACAA,OAAOC,YAEP,KAAKH,MAAQE,OAAOC,UAAUF,UAG/Bzc,EAAOK,MAAM,KAAKmc,OAoFpB,OA5ECI,wBAAA,SAAYC,GACX,KAAKL,MAAQK,GASdD,gBAAA,SAAIhY,EAAKkY,GACR,QADQ,QAAAA,WACH,KAAKN,MACT,MAAyB,qBAAXM,EAAyBA,EAASlY,EAGjD,IAAMiY,EAAO,KAAKL,MACd5K,EAAM,KAAKmL,cAAcnY,EAAKiY,GAClC,OAAIjL,IAIAiL,EAAK3L,QAAQ,KAAO,IACvBU,EAAM,KAAKmL,cAAcnY,EAAKiY,EAAKzW,MAAM,KAAK,KAE3CwL,IAIqB,qBAAXkL,EAAyBA,EAASlY,KAUjDgY,0BAAA,SAAchY,EAAK6X,EAAUK,GAC5B,QAD4B,QAAAA,SACvBL,EACJ,OAAOK,EAGR,IAAME,EAAY,KAAKC,MAAMR,GAC7B,OAAKO,EAIEA,EAAUpY,GAHTkY,GAYTF,uCAAA,SAA2BH,EAAUS,GACpC,IAAIF,EAAY,KAAKC,MAAMR,GACtBO,IACJA,EAAY,KAAKC,MAAMR,GAAY,IAEpCzb,OAAOC,OAAO+b,EAAWE,IAS1BN,4BAAA,SAAgBM,GAAhB,WACClc,OAAOsE,KAAK4X,GAAc3X,KAAI,YAC7B0G,EAAKkR,2BAA2BvY,EAAKsY,EAAatY,QAGrD,EAtHA,G,QCHM5E,EAAS,IAAIC,IAAO,QAEtB4K,EAAU,KACVuS,EAAQ,KAKZ,2BA+FA,OAxFQR,YAAP,SAAiB7R,GAEhB,OADA/K,EAAOK,MAAM,kBACR0K,GAILF,EAAU7J,OAAOC,OAAO,GAAI4J,EAASE,EAAO6R,MAAQ7R,GAEpD6R,EAAKhb,iBAEEiJ,GAPCA,GAUF+R,gBAAP,WACC,MAAO,QAQDA,iBAAP,WACC5c,EAAOK,MAAM,wBACT+c,IAGJA,EAAQ,IAAIC,EAAUxS,KAQhB+R,cAAP,SAAmBC,GAGlB,OAFAD,EAAKU,cAEEF,EAAMG,YAAYV,IASnBD,MAAP,SAAWhY,EAAKkY,GACf,OAAKF,EAAKU,cAIHF,EAAM5a,IAAIoC,EAAKkY,GAHI,qBAAXA,EAAyBlY,EAAMkY,GAaxCF,6BAAP,SAAkCH,EAAUS,GAG3C,OAFAN,EAAKU,cAEEF,EAAMD,2BAA2BV,EAAUS,IAU5CN,kBAAP,SAAuBM,GAGtB,OAFAN,EAAKU,cAEEF,EAAMI,gBAAgBN,IAGhBN,cAAd,WAKC,OAJKQ,IACJA,EAAQ,IAAIC,EAAUxS,KAGhB,GAET,EA/FA,GAiGA/K,IAAQgE,SAAS8Y,I,oHCrGNa,EAAoB,CAC7BC,KAAM,GACNC,SAAU,CAAC,eACXC,oBAAqB,CAAC,OAAQ,sBAAuB,aAAc,gBACnEC,mBAAoB,CAAC,WAAY,OAAQ,eAAgB,cACzDC,SAAU,CAAC,QACXC,aAAc,CAAC,cACfC,MAAO,CAAC,QAAS,OAAQ,YAAa,aAAc,gBACpDC,SAAU,CAAC,OAAQ,SACnBC,eAAgB,CAAC,OAAQ,cACzBC,eAAgB,CAAC,gBAAiB,aAAc,gBAChDC,mBAAoB,CAAC,OAErB,sBAAuB,gBAAiB,aAAc,gBACtDC,SAAU,GACVC,WAAY,GACZC,YAAa,GACbC,aAAc,GACdC,UAAW,GACXC,UAAW,GACXC,UAAW,CAAC,UACZC,YAAa,CAAC,UACdC,YAAa,CAAC,OAAQ,SACtBC,UAAW,CAAC,OAAQ,aACpBC,UAAW,CAAC,QACZC,SAAU,CAAC,QACXC,YAAa,CAAC,QACdC,iBAAkB,CAAC,aAAc,kBACjCC,wBAAyB,CAAC,QAC1BC,qBAAsB,CAAC,cAAe,OAAQ,cAC9CC,qBAAsB,CAAC,cAAe,OAAQ,aAAc,aAAc,UAC1EC,gBAAiB,CAAC,cAAe,OAAQ,YAAa,OAAQ,cAC9DC,qBAAsB,CAAC,cAAe,OAAQ,OAAQ,eAAgB,cACtEC,wBAAyB,CAAC,cAAe,OAAQ,aAAc,UAC/DC,oBAAqB,CAAC,cAAe,OAAQ,aAAc,SAC3DC,mBAAoB,CAAC,cAAe,OAAQ,aAAc,UAC1DC,oBAAqB,CAAC,cAAe,OAAQ,cAC7CC,0BAA2B,CAAC,cAAe,OAAQ,aAAc,UACjEC,oBAAqB,CAAC,cAAe,OAAQ,YAAa,aAC1DC,gBAAiB,CAAC,aAAc,kBAChCC,oBAAqB,CAAC,OAAQ,cAC9BC,oBAAqB,CAAC,OAAQ,aAAc,aAAc,UAC1DC,uBAAwB,CAAC,OAAQ,aAAc,UAC/CC,mBAAoB,CAAC,OAAQ,aAAc,SAC3CC,kBAAmB,CAAC,OAAQ,aAAc,UAC1CC,yBAA0B,CAAC,OAAQ,aAAc,WAExCC,EAAQ,GA6OnB,SAASpE,EAAOqE,GACd,OAAOC,QAAQD,GAAuC,kBAAnBA,EAAUE,MAwGxC,SAASC,EAAWC,EAASF,EAAMG,GACxC,IAAIC,EAAcF,EAAQF,GAE1B,GAAII,EAAa,CACf,IAAKD,GAAoC,oBAAhBC,EAEvB,OAAOA,EAGT,IAAIC,EAAsBF,EAAYC,EAAYE,MAAQF,EAAYG,MAEtE,GAAmC,oBAAxBF,EAET,OAAOA,MAEJ,CACL,IAAIG,EAAkBL,EAAYD,EAAQI,MAAQJ,EAAQK,MAE1D,GAAIC,EAAiB,CACnB,GAA+B,oBAApBA,EAET,OAAOA,EAGT,IAAIC,EAAsBD,EAAgBR,GAE1C,GAAmC,oBAAxBS,EAET,OAAOA,IC3aR,SAASC,EAAMC,GACpB,ODgJK,SAAeC,EAAMV,GAC1B,IAAIW,EAAcC,UAAUnb,OAAS,QAAsBxE,IAAjB2f,UAAU,GAAmBA,UAAU,GAAK7D,EAGlF8D,OAAQ5f,EACR6f,EAAUpgB,MAAMC,QAAQ+f,GACxB9b,EAAO,CAAC8b,GACRK,GAAS,EACTC,EAAQ,GACRC,OAAOhgB,EACPiD,OAAMjD,EACNigB,OAASjgB,EACTK,EAAO,GACP6f,EAAY,GACZC,EAAUV,EAGd,EAAG,CAED,IAAIT,IADJc,IAC0Bnc,EAAKa,OAC3B4b,EAAWpB,GAA8B,IAAjBe,EAAMvb,OAElC,GAAIwa,EAAW,CAKb,GAJA/b,EAA2B,IAArBid,EAAU1b,YAAexE,EAAYK,EAAKA,EAAKmE,OAAS,GAC9Dwb,EAAOC,EACPA,EAASC,EAAUG,MAEfD,EAAU,CACZ,GAAIP,EACFG,EAAOA,EAAKna,YACP,CACL,IAAIya,EAAQ,GAEZ,IAAK,IAAIC,KAAKP,EACRA,EAAKQ,eAAeD,KACtBD,EAAMC,GAAKP,EAAKO,IAIpBP,EAAOM,EAKT,IAFA,IAAIG,EAAa,EAERC,EAAK,EAAGA,EAAKX,EAAMvb,OAAQkc,IAAM,CACxC,IAAIC,EAAUZ,EAAMW,GAAI,GACpBE,EAAYb,EAAMW,GAAI,GAEtBb,IACFc,GAAWF,GAGTZ,GAAyB,OAAde,GACbZ,EAAKa,OAAOF,EAAS,GACrBF,KAEAT,EAAKW,GAAWC,GAKtBd,EAAQF,EAAME,MACdnc,EAAOic,EAAMjc,KACboc,EAAQH,EAAMG,MACdF,EAAUD,EAAMC,QAChBD,EAAQA,EAAMkB,SACT,CAIL,GAHA7d,EAAMgd,EAASJ,EAAUC,EAAQnc,EAAKmc,QAAS9f,EAGlC,QAFbggB,EAAOC,EAASA,EAAOhd,GAAOkd,SAEAngB,IAATggB,EACnB,SAGEC,GACF5f,EAAKkL,KAAKtI,GAId,IAAI4L,OAAS,EAEb,IAAKpP,MAAMC,QAAQsgB,GAAO,CACxB,IAAK1F,EAAO0F,GACV,MAAM,IAAIne,MAAM,qBAAuB1C,KAAK2L,UAAUkV,IAGxD,IAAIe,EAAUjC,EAAWC,EAASiB,EAAKnB,KAAMG,GAE7C,GAAI+B,EAAS,CAGX,IAFAlS,EAASkS,EAAQ3N,KAAK2L,EAASiB,EAAM/c,EAAKgd,EAAQ5f,EAAM6f,MAEzCxB,EACb,MAGF,IAAe,IAAX7P,GACF,IAAKmQ,EAAW,CACd3e,EAAKggB,MACL,eAEG,QAAergB,IAAX6O,IACTkR,EAAMxU,KAAK,CAACtI,EAAK4L,KAEZmQ,GAAW,CACd,IAAI1E,EAAOzL,GAEJ,CACLxO,EAAKggB,MACL,SAHAL,EAAOnR,SAUF7O,IAAX6O,GAAwBuR,GAC1BL,EAAMxU,KAAK,CAACtI,EAAK+c,IAGfhB,EACF3e,EAAKggB,OAELT,EAAQ,CACNC,QAASA,EACTC,MAAOA,EACPnc,KAAMA,EACNoc,MAAOA,EACPe,KAAMlB,GAGRjc,GADAkc,EAAUpgB,MAAMC,QAAQsgB,IACPA,EAAON,EAAYM,EAAKnB,OAAS,GAClDiB,GAAS,EACTC,EAAQ,GAEJE,GACFC,EAAU3U,KAAK0U,GAGjBA,EAASD,cAEMhgB,IAAV4f,GAMT,OAJqB,IAAjBG,EAAMvb,SACR2b,EAAUJ,EAAMA,EAAMvb,OAAS,GAAG,IAG7B2b,EClSAa,CAAMxB,EAAK,CAChBL,MAAO8B,IAGX,IAAIA,EAAqB,CACvBlF,KAAM,SAAciE,GAClB,OAAOA,EAAK3a,OAEd8W,SAAU,SAAkB6D,GAC1B,MAAO,IAAMA,EAAKjgB,MAGpBic,SAAU,SAAkBgE,GAC1B,OAAOjc,EAAKic,EAAKkB,YAAa,QAAU,MAE1CjF,oBAAqB,SAA6B+D,GAChD,IAAImB,EAAKnB,EAAKpd,UACV7C,EAAOigB,EAAKjgB,KACZqhB,EAAUC,EAAK,IAAKtd,EAAKic,EAAKsB,oBAAqB,MAAO,KAC1DC,EAAaxd,EAAKic,EAAKuB,WAAY,KACnCC,EAAexB,EAAKwB,aAGxB,OAAQzhB,GAASwhB,GAAeH,GAAkB,UAAPD,EAAgCpd,EAAK,CAACod,EAAIpd,EAAK,CAAChE,EAAMqhB,IAAWG,EAAYC,GAAe,KAA3EA,GAE9DtF,mBAAoB,SAA4BuF,GAC9C,IAAIC,EAAWD,EAAKC,SAChBlP,EAAOiP,EAAKjP,KACZmP,EAAeF,EAAKE,aACpBJ,EAAaE,EAAKF,WACtB,OAAOG,EAAW,KAAOlP,EAAO6O,EAAK,MAAOM,GAAgBN,EAAK,IAAKtd,EAAKwd,EAAY,OAEzFnF,aAAc,SAAsBwF,GAElC,OAAOC,EADUD,EAAME,aAGzBzF,MAAO,SAAe0F,GACpB,IAAI9S,EAAQ8S,EAAM9S,MACdlP,EAAOgiB,EAAMhiB,KACb8K,EAAOkX,EAAMpC,UACb4B,EAAaQ,EAAMR,WACnBC,EAAeO,EAAMP,aACzB,OAAOzd,EAAK,CAACsd,EAAK,GAAIpS,EAAO,MAAQlP,EAAOshB,EAAK,IAAKtd,EAAK8G,EAAM,MAAO,KAAM9G,EAAKwd,EAAY,KAAMC,GAAe,MAEtHlF,SAAU,SAAkB0F,GAG1B,OAFWA,EAAMjiB,KAEH,KADFiiB,EAAM3c,OAIpBkX,eAAgB,SAAwB0F,GAGtC,MAAO,MAFIA,EAAMliB,KAEKshB,EAAK,IAAKtd,EADfke,EAAMV,WAC0B,OAEnD/E,eAAgB,SAAwB0F,GACtC,IAAIC,EAAgBD,EAAMC,cACtBZ,EAAaW,EAAMX,WACnBC,EAAeU,EAAMV,aACzB,OAAOzd,EAAK,CAAC,MAAOsd,EAAK,MAAOc,GAAgBpe,EAAKwd,EAAY,KAAMC,GAAe,MAExF/E,mBAAoB,SAA4B2F,GAC9C,IAAIriB,EAAOqiB,EAAMriB,KACboiB,EAAgBC,EAAMD,cACtBb,EAAsBc,EAAMd,oBAC5BC,EAAaa,EAAMb,WACnBC,EAAeY,EAAMZ,aACzB,MAEE,YAAY1U,OAAO/M,GAAM+M,OAAOuU,EAAK,IAAKtd,EAAKud,EAAqB,MAAO,KAAM,KAAO,MAAMxU,OAAOqV,EAAe,KAAKrV,OAAOuU,EAAK,GAAItd,EAAKwd,EAAY,KAAM,MAAQC,GAI5K9E,SAAU,SAAkB2F,GAE1B,OADYA,EAAMhd,OAGpBsX,WAAY,SAAoB2F,GAE9B,OADYA,EAAMjd,OAGpBuX,YAAa,SAAqB2F,EAAQtf,GACxC,IAAIoC,EAAQkd,EAAOld,MAEnB,OADoBkd,EAAOV,MAkN/B,SAA0Bxc,EAAOmd,GAC/B,IAAIC,EAAUpd,EAAMd,QAAQ,OAAQ,SACpC,MAAqB,MAAbc,EAAM,IAA2B,OAAbA,EAAM,KAAyC,IAAzBA,EAAMkK,QAAQ,MAAyE,QAAWzC,OAAO0V,EAAgBC,EAAUC,EAAOD,GAAU,SAAvH,MAAS3V,OAAO2V,EAAQle,QAAQ,KAAM,OAAQ,OAnNpGoe,CAAiBtd,EAAe,gBAARpC,GAAyB9D,KAAK2L,UAAUzF,IAEzFwX,aAAc,SAAsB+F,GAElC,OADYA,EAAOvd,MACJ,OAAS,SAE1ByX,UAAW,WACT,MAAO,QAETC,UAAW,SAAmB8F,GAE5B,OADYA,EAAOxd,OAGrB2X,UAAW,SAAmB8F,GAE5B,MAAO,IAAM/e,EADA+e,EAAOlT,OACM,MAAQ,KAEpCqN,YAAa,SAAqB8F,GAEhC,MAAO,IAAMhf,EADAgf,EAAOC,OACM,MAAQ,KAEpC9F,YAAa,SAAqB+F,GAGhC,OAFWA,EAAOljB,KAEJ,KADFkjB,EAAO5d,OAIrB8X,UAAW,SAAmB+F,GAG5B,MAAO,IAFIA,EAAOnjB,KAEEshB,EAAK,IAAKtd,EADnBmf,EAAOvD,UACuB,MAAO,MAGlDvC,UAAW,SAAmB+F,GAE5B,OADWA,EAAOpjB,MAGpBsd,SAAU,SAAkB+F,GAE1B,MAAO,IADIA,EAAO5Q,KACE,KAEtB8K,YAAa,SAAqB+F,GAEhC,OADWA,EAAO7Q,KACJ,KAGhB+K,iBAAkB,SAA0B+F,GAC1C,IAAI/B,EAAa+B,EAAO/B,WACpBgC,EAAiBD,EAAOC,eAC5B,OAAOxf,EAAK,CAAC,SAAUA,EAAKwd,EAAY,KAAMM,EAAM0B,IAAkB,MAExE/F,wBAAyB,SAAiCgG,GAGxD,OAFgBA,EAAO5gB,UAEJ,KADR4gB,EAAOhR,MAGpBiL,qBAAsBgG,GAAe,SAAUC,GAG7C,OAAO3f,EAAK,CAAC,SAFF2f,EAAO3jB,KAEWgE,EADZ2f,EAAOnC,WACsB,MAAO,QAEvD7D,qBAAsB+F,GAAe,SAAUE,GAC7C,IAAI5jB,EAAO4jB,EAAO5jB,KACd6jB,EAAaD,EAAOC,WACpBrC,EAAaoC,EAAOpC,WACpByB,EAASW,EAAOX,OACpB,OAAOjf,EAAK,CAAC,OAAQhE,EAAMshB,EAAK,cAAetd,EAAK6f,EAAY,QAAS7f,EAAKwd,EAAY,KAAMM,EAAMmB,IAAU,QAElHrF,gBAAiB8F,GAAe,SAAUI,GACxC,IAAI9jB,EAAO8jB,EAAO9jB,KACd8K,EAAOgZ,EAAOlE,UACdnN,EAAOqR,EAAOrR,KACd+O,EAAasC,EAAOtC,WACxB,OAAOxhB,GAAQ8K,EAAKiZ,OAAM,SAAUvgB,GAClC,OAA8B,IAAvBA,EAAIgM,QAAQ,SAChB8R,EAAK,IAAKtd,EAAK8G,EAAM,MAAO,KAAOwW,EAAK,MAAOqB,EAAO3e,EAAK8G,EAAM,OAAQ,QAAU,KAAO2H,EAAO6O,EAAK,IAAKtd,EAAKwd,EAAY,SAEnI3D,qBAAsB6F,GAAe,SAAUM,GAC7C,IAAIhkB,EAAOgkB,EAAOhkB,KACdyS,EAAOuR,EAAOvR,KACdmP,EAAeoC,EAAOpC,aACtBJ,EAAawC,EAAOxC,WACxB,OAAOxd,EAAK,CAAChE,EAAO,KAAOyS,EAAM6O,EAAK,KAAMM,GAAe5d,EAAKwd,EAAY,MAAO,QAErF1D,wBAAyB4F,GAAe,SAAUO,GAChD,IAAIjkB,EAAOikB,EAAOjkB,KACdwhB,EAAayC,EAAOzC,WACpByB,EAASgB,EAAOhB,OACpB,OAAOjf,EAAK,CAAC,YAAahE,EAAMgE,EAAKwd,EAAY,KAAMM,EAAMmB,IAAU,QAEzElF,oBAAqB2F,GAAe,SAAUQ,GAC5C,IAAIlkB,EAAOkkB,EAAOlkB,KACdwhB,EAAa0C,EAAO1C,WACpB2C,EAAQD,EAAOC,MACnB,OAAOngB,EAAK,CAAC,QAAShE,EAAMgE,EAAKwd,EAAY,KAAM2C,GAA0B,IAAjBA,EAAM1f,OAAe,KAAOT,EAAKmgB,EAAO,OAAS,IAAK,QAEpHnG,mBAAoB0F,GAAe,SAAUU,GAC3C,IAAIpkB,EAAOokB,EAAOpkB,KACdwhB,EAAa4C,EAAO5C,WACpB3R,EAASuU,EAAOvU,OACpB,OAAO7L,EAAK,CAAC,OAAQhE,EAAMgE,EAAKwd,EAAY,KAAMM,EAAMjS,IAAU,QAEpEoO,oBAAqByF,GAAe,SAAUW,GAG5C,OAAOrgB,EAAK,CAFDqgB,EAAOrkB,KAECgE,EADFqgB,EAAO7C,WACY,MAAO,QAE7CtD,0BAA2BwF,GAAe,SAAUY,GAClD,IAAItkB,EAAOskB,EAAOtkB,KACdwhB,EAAa8C,EAAO9C,WACpByB,EAASqB,EAAOrB,OACpB,OAAOjf,EAAK,CAAC,QAAShE,EAAMgE,EAAKwd,EAAY,KAAMM,EAAMmB,IAAU,QAErE9E,oBAAqBuF,GAAe,SAAUa,GAC5C,IAAIvkB,EAAOukB,EAAOvkB,KACd8K,EAAOyZ,EAAO3E,UACd4E,EAAYD,EAAOC,UACvB,MAAO,cAAgBxkB,GAAQ8K,EAAKiZ,OAAM,SAAUvgB,GAClD,OAA8B,IAAvBA,EAAIgM,QAAQ,SAChB8R,EAAK,IAAKtd,EAAK8G,EAAM,MAAO,KAAOwW,EAAK,MAAOqB,EAAO3e,EAAK8G,EAAM,OAAQ,QAAU,OAAS9G,EAAKwgB,EAAW,UAEnHpG,gBAAiB,SAAyBqG,GACxC,IAAIjD,EAAaiD,EAAOjD,WACpBgC,EAAiBiB,EAAOjB,eAC5B,OAAOxf,EAAK,CAAC,gBAAiBA,EAAKwd,EAAY,KAAMM,EAAM0B,IAAkB,MAE/EnF,oBAAqB,SAA6BqG,GAGhD,OAAO1gB,EAAK,CAAC,gBAFF0gB,EAAO1kB,KAEkBgE,EADnB0gB,EAAOlD,WAC6B,MAAO,MAE9DlD,oBAAqB,SAA6BqG,GAChD,IAAI3kB,EAAO2kB,EAAO3kB,KACd6jB,EAAac,EAAOd,WACpBrC,EAAamD,EAAOnD,WACpByB,EAAS0B,EAAO1B,OACpB,OAAOjf,EAAK,CAAC,cAAehE,EAAMshB,EAAK,cAAetd,EAAK6f,EAAY,QAAS7f,EAAKwd,EAAY,KAAMM,EAAMmB,IAAU,MAEzH1E,uBAAwB,SAAgCqG,GACtD,IAAI5kB,EAAO4kB,EAAO5kB,KACdwhB,EAAaoD,EAAOpD,WACpByB,EAAS2B,EAAO3B,OACpB,OAAOjf,EAAK,CAAC,mBAAoBhE,EAAMgE,EAAKwd,EAAY,KAAMM,EAAMmB,IAAU,MAEhFzE,mBAAoB,SAA4BqG,GAC9C,IAAI7kB,EAAO6kB,EAAO7kB,KACdwhB,EAAaqD,EAAOrD,WACpB2C,EAAQU,EAAOV,MACnB,OAAOngB,EAAK,CAAC,eAAgBhE,EAAMgE,EAAKwd,EAAY,KAAM2C,GAA0B,IAAjBA,EAAM1f,OAAe,KAAOT,EAAKmgB,EAAO,OAAS,IAAK,MAE3H1F,kBAAmB,SAA2BqG,GAC5C,IAAI9kB,EAAO8kB,EAAO9kB,KACdwhB,EAAasD,EAAOtD,WACpB3R,EAASiV,EAAOjV,OACpB,OAAO7L,EAAK,CAAC,cAAehE,EAAMgE,EAAKwd,EAAY,KAAMM,EAAMjS,IAAU,MAE3E6O,yBAA0B,SAAkCqG,GAC1D,IAAI/kB,EAAO+kB,EAAO/kB,KACdwhB,EAAauD,EAAOvD,WACpByB,EAAS8B,EAAO9B,OACpB,OAAOjf,EAAK,CAAC,eAAgBhE,EAAMgE,EAAKwd,EAAY,KAAMM,EAAMmB,IAAU,OAI9E,SAASS,EAAesB,GACtB,OAAO,SAAU/E,GACf,OAAOjc,EAAK,CAACic,EAAKgF,YAAaD,EAAG/E,IAAQ,OAS9C,SAASjc,EAAKkhB,EAAYC,GACxB,OAAOD,EAAaA,EAAWhY,QAAO,SAAUkY,GAC9C,OAAOA,KACNphB,KAAKmhB,GAAa,IAAM,GAQ7B,SAASrD,EAAMuD,GACb,OAAOA,GAA0B,IAAjBA,EAAM5gB,OAAe,MAAQke,EAAO3e,EAAKqhB,EAAO,OAAS,MAAQ,GAQnF,SAAS/D,EAAK1G,EAAO0K,EAAaC,GAChC,OAAOD,EAAc1K,EAAQ0K,GAAeC,GAAO,IAAM,GAG3D,SAAS5C,EAAO2C,GACd,OAAOA,GAAe,KAAOA,EAAY9gB,QAAQ,MAAO,QCzS1D,SAASghB,EAAQxV,GAAwT,OAAtOwV,EAArD,oBAAXpb,QAAoD,kBAApBA,OAAOqb,SAAmC,SAAiBzV,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAX5F,QAAyB4F,EAAI0V,cAAgBtb,QAAU4F,IAAQ5F,OAAOub,UAAY,gBAAkB3V,IAAyBA,GAczU,SAAS4V,EAAQtgB,GAC9B,OAAOA,GAA4B,WAAnBkgB,EAAQlgB,GAA+C,oBAAlBA,EAAMsgB,QAAyBtgB,EAAMsgB,UAAYlmB,MAAMC,QAAQ2F,GAAS,IAAMA,EAAMzB,IAAI+hB,GAAS5hB,KAAK,MAAQ,IAAM,IAAM1E,OAAOsE,KAAK0B,GAAOzB,KAAI,SAAU2c,GAC9M,MAAO,GAAGzT,OAAOyT,EAAG,MAAMzT,OAAO6Y,EAAQtgB,EAAMkb,QAC9Cxc,KAAK,MAAQ,IAAuB,kBAAVsB,EAAqB,IAAMA,EAAQ,IAAuB,oBAAVA,EAAuB,aAAayH,OAAOzH,EAAMtF,KAAM,KAAO6lB,OAAOvgB,GCTrI,SAASwgB,EAAUC,EAAW5kB,GAE3C,IAAK4kB,EACH,MAAM,IAAIjkB,MAAMX,GCXpB,SAAS6kB,EAAgBhW,EAAK9M,EAAKoC,GAAiK,OAApJpC,KAAO8M,EAAO1Q,OAAO2mB,eAAejW,EAAK9M,EAAK,CAAEoC,MAAOA,EAAO4gB,YAAY,EAAMC,cAAc,EAAMC,UAAU,IAAkBpW,EAAI9M,GAAOoC,EAAgB0K,EAqBpM,ICCkCqW,EDD9BC,EAAS,SAAgBte,EAAMhI,EAAMumB,GAC9CP,EAAgBQ,KAAM,YAAQ,GAE9BR,EAAgBQ,KAAM,YAAQ,GAE9BR,EAAgBQ,KAAM,sBAAkB,GAExCA,KAAKxe,KAAOA,EACZwe,KAAKxmB,KAAOA,GAAQ,kBACpBwmB,KAAKD,eAAiBA,GAAkB,CACtCE,KAAM,EACNC,OAAQ,GAERF,KAAKD,eAAeE,KAAO,GAAKX,EAAU,EAAG,4DAC7CU,KAAKD,eAAeG,OAAS,GAAKZ,EAAU,EAAG,+DErB5C,SAASa,EAAYC,EAAQC,EAAU5B,GAC5C,OAAO,IAAI1T,IAAa,iBAAiBxE,OAAOkY,QAAchlB,EAAW2mB,EAAQ,CAACC,ICArE,SAASC,EAAiBC,GAMvC,IAJA,IAAIC,EAAQD,EAAUriB,MAAM,gBAExBuiB,EAAe,KAEV5Z,EAAI,EAAGA,EAAI2Z,EAAMviB,OAAQ4I,IAAK,CACrC,IAAIoZ,EAAOO,EAAM3Z,GACbsV,EAASuE,EAAkBT,GAE/B,GAAI9D,EAAS8D,EAAKhiB,SAA4B,OAAjBwiB,GAAyBtE,EAASsE,IAGxC,KAFrBA,EAAetE,GAGb,MAKN,GAAIsE,EACF,IAAK,IAAIE,EAAK,EAAGA,EAAKH,EAAMviB,OAAQ0iB,IAClCH,EAAMG,GAAMH,EAAMG,GAAIrhB,MAAMmhB,GAKhC,KAAOD,EAAMviB,OAAS,GAAK2iB,EAAQJ,EAAM,KACvCA,EAAMK,QAGR,KAAOL,EAAMviB,OAAS,GAAK2iB,EAAQJ,EAAMA,EAAMviB,OAAS,KACtDuiB,EAAM1G,MAIR,OAAO0G,EAAMhjB,KAAK,MAGpB,SAASkjB,EAAkBI,GAGzB,IAFA,IAAIja,EAAI,EAEDA,EAAIia,EAAI7iB,SAAsB,MAAX6iB,EAAIja,IAAyB,OAAXia,EAAIja,KAC9CA,IAGF,OAAOA,EAGT,SAAS+Z,EAAQE,GACf,OAAOJ,EAAkBI,KAASA,EAAI7iB,OC7CjC,SAAS8iB,EAAYX,EAAQpoB,GAClC,IAAIgpB,EAAmB,IAAIC,EAAIC,EAAUC,IAAK,EAAG,EAAG,EAAG,EAAG,MAW1D,MAVY,CACVf,OAAQA,EACRpoB,QAASA,EACTopB,UAAWJ,EACXlP,MAAOkP,EACPf,KAAM,EACNoB,UAAW,EACXC,QAASC,EACTC,UAAWA,GAKf,SAASD,IAGP,OAFAvB,KAAKoB,UAAYpB,KAAKlO,MACVkO,KAAKlO,MAAQkO,KAAKwB,YAIhC,SAASA,IACP,IAAI1P,EAAQkO,KAAKlO,MAEjB,GAAIA,EAAMwG,OAAS4I,EAAUO,IAC3B,GAEE3P,EAAQA,EAAM3K,OAAS2K,EAAM3K,KAAOua,EAAU1B,KAAMlO,UAC7CA,EAAMwG,OAAS4I,EAAUS,SAGpC,OAAO7P,EH5BgC+N,EDgBvBC,ECfM,oBAAXlc,QAAyBA,OAAOge,aACzC9oB,OAAO2mB,eAAeI,EAAYV,UAAWvb,OAAOge,YAAa,CAC/DtnB,IAAK,WACH,OAAO0lB,KAAKd,YAAY1lB,QGmCzB,IAAI0nB,EAAYpoB,OAAO+oB,OAAO,CACnCV,IAAK,QACLM,IAAK,QACLK,KAAM,IACNC,OAAQ,IACRC,IAAK,IACLC,QAAS,IACTC,QAAS,IACTC,OAAQ,MACRC,MAAO,IACPC,OAAQ,IACRC,GAAI,IACJC,UAAW,IACXC,UAAW,IACXC,QAAS,IACTC,KAAM,IACNC,QAAS,IACTC,KAAM,OACNC,IAAK,MACLC,MAAO,QACPC,OAAQ,SACRC,aAAc,cACdrB,QAAS,YASJ,SAASsB,EAAanR,GAC3B,IAAIhT,EAAQgT,EAAMhT,MAClB,OAAOA,EAAQ,GAAGyH,OAAOuL,EAAMwG,KAAM,MAAO/R,OAAOzH,EAAO,KAAQgT,EAAMwG,KAE1E,IAAI/Z,EAAa8gB,OAAOF,UAAU5gB,WAC9Be,EAAQ+f,OAAOF,UAAU7f,MAK7B,SAAS2hB,EAAI3I,EAAMlE,EAAO2K,EAAKkB,EAAMC,EAAQ3F,EAAMzb,GACjDkhB,KAAK1H,KAAOA,EACZ0H,KAAK5L,MAAQA,EACb4L,KAAKjB,IAAMA,EACXiB,KAAKC,KAAOA,EACZD,KAAKE,OAASA,EACdF,KAAKlhB,MAAQA,EACbkhB,KAAKzF,KAAOA,EACZyF,KAAK7Y,KAAO,KAad,SAAS+b,EAAcC,GACrB,OACEC,MAAMD,GAAQjC,EAAUO,IACxB0B,EAAO,IAASvqB,KAAK2L,UAAU8a,OAAOgE,aAAaF,IACnD,OAAQ5c,QAAQ,KAAO4c,EAAK3kB,SAAS,IAAIC,eAAea,OAAO,GAAI,KAYvE,SAASoiB,EAAU4B,EAAO/I,GACxB,IAAI6F,EAASkD,EAAMlD,OACf5e,EAAO4e,EAAO5e,KACd+hB,EAAa/hB,EAAKvD,OAClBulB,EAoLN,SAAiChiB,EAAMiiB,EAAeH,GACpD,IAAIC,EAAa/hB,EAAKvD,OAClBoiB,EAAWoD,EAEf,KAAOpD,EAAWkD,GAAY,CAC5B,IAAIJ,EAAO5kB,EAAWsO,KAAKrL,EAAM6e,GAEjC,GAAa,IAAT8C,GAAuB,KAATA,GAAwB,KAATA,GAAwB,QAATA,IAC5C9C,OACG,GAAa,KAAT8C,IAEP9C,IACAiD,EAAMrD,KACRqD,EAAMjC,UAAYhB,MACb,IAAa,KAAT8C,EAWT,MAT4C,KAAxC5kB,EAAWsO,KAAKrL,EAAM6e,EAAW,GACnCA,GAAY,IAEVA,IAGFiD,EAAMrD,KACRqD,EAAMjC,UAAYhB,GAMtB,OAAOA,EAjNGqD,CAAwBliB,EAAM+Y,EAAKwE,IAAKuE,GAC9CrD,EAAOqD,EAAMrD,KACb0D,EAAM,EAAIH,EAAMF,EAAMjC,UAE1B,GAAImC,GAAOD,EACT,OAAO,IAAItC,EAAIC,EAAUO,IAAK8B,EAAYA,EAAYtD,EAAM0D,EAAKpJ,GAGnE,IAAI4I,EAAO5kB,EAAWsO,KAAKrL,EAAMgiB,GAEjC,OAAQL,GAEN,KAAK,GACH,OAAO,IAAIlC,EAAIC,EAAUY,KAAM0B,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG1D,KAAK,GACH,OAyMN,SAAqB6F,EAAQhM,EAAO6L,EAAM0D,EAAKpJ,GAC7C,IACI4I,EADA3hB,EAAO4e,EAAO5e,KAEd6e,EAAWjM,EAEf,GACE+O,EAAO5kB,EAAWsO,KAAKrL,IAAQ6e,SACf,OAAT8C,IACTA,EAAO,IAAmB,IAATA,IAEjB,OAAO,IAAIlC,EAAIC,EAAUS,QAASvN,EAAOiM,EAAUJ,EAAM0D,EAAKpJ,EAAMjb,EAAMuN,KAAKrL,EAAM4S,EAAQ,EAAGiM,IAnNrFuD,CAAYxD,EAAQoD,EAAKvD,EAAM0D,EAAKpJ,GAG7C,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUa,OAAQyB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG5D,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUc,IAAKwB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAGzD,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUe,QAASuB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG7D,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUgB,QAASsB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG7D,KAAK,GACH,GAAuC,KAAnChc,EAAWsO,KAAKrL,EAAMgiB,EAAM,IAAgD,KAAnCjlB,EAAWsO,KAAKrL,EAAMgiB,EAAM,GACvE,OAAO,IAAIvC,EAAIC,EAAUiB,OAAQqB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG5D,MAGF,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUkB,MAAOoB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG3D,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUmB,OAAQmB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG5D,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUoB,GAAIkB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAGxD,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUqB,UAAWiB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG/D,KAAK,GACH,OAAO,IAAI0G,EAAIC,EAAUsB,UAAWgB,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG/D,KAAK,IACH,OAAO,IAAI0G,EAAIC,EAAUuB,QAASe,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG7D,KAAK,IACH,OAAO,IAAI0G,EAAIC,EAAUwB,KAAMc,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG1D,KAAK,IACH,OAAO,IAAI0G,EAAIC,EAAUyB,QAASa,EAAKA,EAAM,EAAGvD,EAAM0D,EAAKpJ,GAG7D,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACL,KAAK,IACH,OAwVN,SAAkB6F,EAAQhM,EAAO6L,EAAM0D,EAAKpJ,GAC1C,IAAI/Y,EAAO4e,EAAO5e,KACd+hB,EAAa/hB,EAAKvD,OAClBoiB,EAAWjM,EAAQ,EACnB+O,EAAO,EAEX,KAAO9C,IAAakD,GAA2D,QAA5CJ,EAAO5kB,EAAWsO,KAAKrL,EAAM6e,MAAiC,KAAT8C,GACxFA,GAAQ,IAAMA,GAAQ,IACtBA,GAAQ,IAAMA,GAAQ,IACtBA,GAAQ,IAAMA,GAAQ,QAElB9C,EAGJ,OAAO,IAAIY,EAAIC,EAAU0B,KAAMxO,EAAOiM,EAAUJ,EAAM0D,EAAKpJ,EAAMjb,EAAMuN,KAAKrL,EAAM4S,EAAOiM,IAtW9EwD,CAASzD,EAAQoD,EAAKvD,EAAM0D,EAAKpJ,GAG1C,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACH,OAgGN,SAAoB6F,EAAQhM,EAAO0P,EAAW7D,EAAM0D,EAAKpJ,GACvD,IAAI/Y,EAAO4e,EAAO5e,KACd2hB,EAAOW,EACPzD,EAAWjM,EACX2P,GAAU,EAED,KAATZ,IAEFA,EAAO5kB,EAAWsO,KAAKrL,IAAQ6e,IAGjC,GAAa,KAAT8C,GAIF,IAFAA,EAAO5kB,EAAWsO,KAAKrL,IAAQ6e,KAEnB,IAAM8C,GAAQ,GACxB,MAAMhD,EAAYC,EAAQC,EAAU,6CAA6C9Z,OAAO2c,EAAcC,GAAO,WAG/G9C,EAAW2D,EAAW5D,EAAQC,EAAU8C,GACxCA,EAAO5kB,EAAWsO,KAAKrL,EAAM6e,GAGlB,KAAT8C,IAEFY,GAAU,EACVZ,EAAO5kB,EAAWsO,KAAKrL,IAAQ6e,GAC/BA,EAAW2D,EAAW5D,EAAQC,EAAU8C,GACxCA,EAAO5kB,EAAWsO,KAAKrL,EAAM6e,IAGlB,KAAT8C,GAAwB,MAATA,IAEjBY,GAAU,EAGG,MAFbZ,EAAO5kB,EAAWsO,KAAKrL,IAAQ6e,KAEH,KAAT8C,IAEjBA,EAAO5kB,EAAWsO,KAAKrL,IAAQ6e,IAGjCA,EAAW2D,EAAW5D,EAAQC,EAAU8C,IAG1C,OAAO,IAAIlC,EAAI8C,EAAU7C,EAAU4B,MAAQ5B,EAAU2B,IAAKzO,EAAOiM,EAAUJ,EAAM0D,EAAKpJ,EAAMjb,EAAMuN,KAAKrL,EAAM4S,EAAOiM,IA5IzG4D,CAAW7D,EAAQoD,EAAKL,EAAMlD,EAAM0D,EAAKpJ,GAGlD,KAAK,GACH,OAAuC,KAAnChc,EAAWsO,KAAKrL,EAAMgiB,EAAM,IAAgD,KAAnCjlB,EAAWsO,KAAKrL,EAAMgiB,EAAM,GAiQ/E,SAAyBpD,EAAQhM,EAAO6L,EAAM0D,EAAKpJ,GACjD,IAAI/Y,EAAO4e,EAAO5e,KACd6e,EAAWjM,EAAQ,EACnB8P,EAAa7D,EACb8C,EAAO,EACPgB,EAAW,GAEf,KAAO9D,EAAW7e,EAAKvD,QAAuD,QAA5CklB,EAAO5kB,EAAWsO,KAAKrL,EAAM6e,KAAqB,CAElF,GAAa,KAAT8C,GAAuD,KAAxC5kB,EAAWsO,KAAKrL,EAAM6e,EAAW,IAAqD,KAAxC9hB,EAAWsO,KAAKrL,EAAM6e,EAAW,GAEhG,OADA8D,GAAY7kB,EAAMuN,KAAKrL,EAAM0iB,EAAY7D,GAClC,IAAIY,EAAIC,EAAU8B,aAAc5O,EAAOiM,EAAW,EAAGJ,EAAM0D,EAAKpJ,EAAM+F,EAAiB6D,IAIhG,GAAIhB,EAAO,IAAmB,IAATA,GAA4B,KAATA,GAA4B,KAATA,EACzD,MAAMhD,EAAYC,EAAQC,EAAU,oCAAoC9Z,OAAO2c,EAAcC,GAAO,MAIzF,KAATA,GAAuD,KAAxC5kB,EAAWsO,KAAKrL,EAAM6e,EAAW,IAAqD,KAAxC9hB,EAAWsO,KAAKrL,EAAM6e,EAAW,IAAqD,KAAxC9hB,EAAWsO,KAAKrL,EAAM6e,EAAW,IAC9I8D,GAAY7kB,EAAMuN,KAAKrL,EAAM0iB,EAAY7D,GAAY,MAErD6D,EADA7D,GAAY,KAGVA,EAIN,MAAMF,EAAYC,EAAQC,EAAU,wBA7RvB+D,CAAgBhE,EAAQoD,EAAKvD,EAAM0D,EAAKpJ,GAsKvD,SAAoB6F,EAAQhM,EAAO6L,EAAM0D,EAAKpJ,GAC5C,IAAI/Y,EAAO4e,EAAO5e,KACd6e,EAAWjM,EAAQ,EACnB8P,EAAa7D,EACb8C,EAAO,EACPrkB,EAAQ,GAEZ,KAAOuhB,EAAW7e,EAAKvD,QAAuD,QAA5CklB,EAAO5kB,EAAWsO,KAAKrL,EAAM6e,KACtD,KAAT8C,GAA4B,KAATA,GAAiB,CAElC,GAAa,KAATA,EAEF,OADArkB,GAASQ,EAAMuN,KAAKrL,EAAM0iB,EAAY7D,GAC/B,IAAIY,EAAIC,EAAU6B,OAAQ3O,EAAOiM,EAAW,EAAGJ,EAAM0D,EAAKpJ,EAAMzb,GAIzE,GAAIqkB,EAAO,IAAmB,IAATA,EACnB,MAAMhD,EAAYC,EAAQC,EAAU,oCAAoC9Z,OAAO2c,EAAcC,GAAO,MAKtG,KAFE9C,EAEW,KAAT8C,EAAa,CAKf,OAHArkB,GAASQ,EAAMuN,KAAKrL,EAAM0iB,EAAY7D,EAAW,GACjD8C,EAAO5kB,EAAWsO,KAAKrL,EAAM6e,IAG3B,KAAK,GACHvhB,GAAS,IACT,MAEF,KAAK,GACHA,GAAS,IACT,MAEF,KAAK,GACHA,GAAS,KACT,MAEF,KAAK,GACHA,GAAS,KACT,MAEF,KAAK,IACHA,GAAS,KACT,MAEF,KAAK,IACHA,GAAS,KACT,MAEF,KAAK,IACHA,GAAS,KACT,MAEF,KAAK,IACHA,GAAS,KACT,MAEF,KAAK,IAEH,IAAIulB,GAuEO3lB,EAvEgBH,EAAWsO,KAAKrL,EAAM6e,EAAW,GAuE9C1hB,EAvEkDJ,EAAWsO,KAAKrL,EAAM6e,EAAW,GAuEhF/hB,EAvEoFC,EAAWsO,KAAKrL,EAAM6e,EAAW,GAuElHiE,EAvEsH/lB,EAAWsO,KAAKrL,EAAM6e,EAAW,GAwE5KkE,EAAS7lB,IAAM,GAAK6lB,EAAS5lB,IAAM,EAAI4lB,EAASjmB,IAAM,EAAIimB,EAASD,IAtElE,GAAID,EAAW,EACb,MAAMlE,EAAYC,EAAQC,EAAU,sCAAwC,MAAM9Z,OAAO/E,EAAKlC,MAAM+gB,EAAW,EAAGA,EAAW,GAAI,MAGnIvhB,GAASugB,OAAOgE,aAAagB,GAC7BhE,GAAY,EACZ,MAEF,QACE,MAAMF,EAAYC,EAAQC,EAAU,wCAAwC9Z,OAAO8Y,OAAOgE,aAAaF,GAAO,QAGhH9C,EACF6D,EAAa7D,GAwDnB,IAAqB3hB,EAAGC,EAAGL,EAAGgmB,EApD5B,MAAMnE,EAAYC,EAAQC,EAAU,wBApPzBmE,CAAWpE,EAAQoD,EAAKvD,EAAM0D,EAAKpJ,GAG9C,MAAM4F,EAAYC,EAAQoD,EAO5B,SAAoCL,GAClC,GAAIA,EAAO,IAAmB,IAATA,GAA4B,KAATA,GAA4B,KAATA,EACzD,MAAO,wCAAwC5c,OAAO2c,EAAcC,GAAO,KAG7E,GAAa,KAATA,EAEF,MAAO,kFAGT,MAAO,yCAAyC5c,OAAO2c,EAAcC,GAAO,KAjB7CsB,CAA2BtB,IAwI5D,SAASa,EAAW5D,EAAQhM,EAAO0P,GACjC,IAAItiB,EAAO4e,EAAO5e,KACd6e,EAAWjM,EACX+O,EAAOW,EAEX,GAAIX,GAAQ,IAAMA,GAAQ,GAAI,CAE5B,GACEA,EAAO5kB,EAAWsO,KAAKrL,IAAQ6e,SACxB8C,GAAQ,IAAMA,GAAQ,IAG/B,OAAO9C,EAGT,MAAMF,EAAYC,EAAQC,EAAU,2CAA2C9Z,OAAO2c,EAAcC,GAAO,MA2J7G,SAASoB,EAAS7lB,GAChB,OAAOA,GAAK,IAAMA,GAAK,GAAKA,EAAI,GAC9BA,GAAK,IAAMA,GAAK,GAAKA,EAAI,GACzBA,GAAK,IAAMA,GAAK,IAAMA,EAAI,IACzB,EA7eLuiB,EAAI9B,UAAUuF,OAASzD,EAAI9B,UAAUC,QAAU,WAC7C,MAAO,CACL9G,KAAM0H,KAAK1H,KACXxZ,MAAOkhB,KAAKlhB,MACZmhB,KAAMD,KAAKC,KACXC,OAAQF,KAAKE,SC3GV,IAAIyE,EAAO7rB,OAAO+oB,OAAO,CAE9Be,KAAM,OAENgC,SAAU,WACVC,qBAAsB,sBACtBC,oBAAqB,qBACrBC,cAAe,eACfC,MAAO,QACPC,SAAU,WAEVC,gBAAiB,iBACjBC,gBAAiB,iBACjBC,oBAAqB,qBAErBC,SAAU,WACVxC,IAAK,WACLC,MAAO,aACPC,OAAQ,cACRuC,QAAS,eACTC,KAAM,YACNC,KAAM,YACNC,KAAM,YACNC,OAAQ,cACRC,aAAc,cAEdC,UAAW,YAEXC,WAAY,YACZC,UAAW,WACXC,cAAe,cAEfC,kBAAmB,mBACnBC,0BAA2B,0BAE3BC,uBAAwB,uBACxBC,uBAAwB,uBACxBC,iBAAkB,kBAClBC,uBAAwB,uBACxBC,0BAA2B,0BAC3BC,sBAAuB,sBACvBC,qBAAsB,qBACtBC,sBAAuB,sBACvBC,6BAA8B,4BAE9BC,qBAAsB,sBAEtBC,iBAAkB,kBAElBC,sBAAuB,sBACvBC,sBAAuB,sBACvBC,yBAA0B,yBAC1BC,qBAAsB,qBACtBC,oBAAqB,oBACrBC,4BAA6B,6BCtDpBC,EAAoBruB,OAAO+oB,OAAO,CAE3CuF,MAAO,QACPC,SAAU,WACVC,aAAc,eACdtC,MAAO,QACPI,oBAAqB,sBACrBF,gBAAiB,kBACjBC,gBAAiB,kBACjBL,oBAAqB,sBAErByC,OAAQ,SACRC,OAAQ,SACR9B,OAAQ,SACRU,iBAAkB,mBAClBqB,oBAAqB,sBACrBC,UAAW,YACXC,MAAO,QACPnC,KAAM,OACNoC,WAAY,aACZC,aAAc,eACdC,uBAAwB,2BCXnB,SAASjvB,EAAMunB,EAAQpoB,GAC5B,IAAI+vB,EAA8B,kBAAX3H,EAAsB,IAAIN,EAAOM,GAAUA,EAElE,KAAM2H,aAAqBjI,GACzB,MAAM,IAAIkI,UAAU,kCAAkCzhB,OAAO6Y,EAAQ2I,KAIvE,OA0DF,SAAuBzE,GACrB,IAAIlP,EAAQkP,EAAMxR,MAClB,MAAO,CACLwG,KAAMqM,EAAKC,SACXjK,YAAasN,GAAK3E,EAAOpC,EAAUC,IAAK+G,EAAiBhH,EAAUO,KACnE0G,IAAKA,GAAI7E,EAAOlP,IA/DXgU,CADKrH,EAAYgH,EAAW/vB,GAAW,KA6ChD,SAASqwB,EAAU/E,GACjB,IAAIxR,EAAQwW,GAAOhF,EAAOpC,EAAU0B,MACpC,MAAO,CACLtK,KAAMqM,EAAK/B,KACX9jB,MAAOgT,EAAMhT,MACbqpB,IAAKA,GAAI7E,EAAOxR,IAyBpB,SAASoW,EAAgB5E,GACvB,GAAIiF,GAAKjF,EAAOpC,EAAU0B,MACxB,OAAQU,EAAMxR,MAAMhT,OAClB,IAAK,QACL,IAAK,WACL,IAAK,eACL,IAAK,WACH,OAAO0pB,EAA0BlF,GAEnC,IAAK,SACL,IAAK,SACL,IAAK,OACL,IAAK,YACL,IAAK,QACL,IAAK,OACL,IAAK,QACL,IAAK,YACH,OAAOmF,GAA0BnF,GAEnC,IAAK,SACH,OAy7BR,SAAkCA,GAChC,IAAIoF,EAAepF,EAAM9B,YAEzB,GAAIkH,EAAapQ,OAAS4I,EAAU0B,KAClC,OAAQ8F,EAAa5pB,OACnB,IAAK,SACH,OA+BR,SAA8BwkB,GAC5B,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrBqF,GAAcrF,EAAO,UACrB,IAAItI,EAAa4N,GAAgBtF,GAAO,GACpCtG,EAAiBuL,GAAKjF,EAAOpC,EAAUuB,SAAWwF,GAAK3E,EAAOpC,EAAUuB,QAASoG,GAA8B3H,EAAUyB,SAAW,GAExI,GAA0B,IAAtB3H,EAAW/c,QAA0C,IAA1B+e,EAAe/e,OAC5C,MAAM6qB,GAAWxF,GAGnB,MAAO,CACLhL,KAAMqM,EAAKiC,iBACX5L,WAAYA,EACZgC,eAAgBA,EAChBmL,IAAKA,GAAI7E,EAAOlP,IA9CL2U,CAAqBzF,GAE9B,IAAK,SACH,OAoDR,SAAkCA,GAChC,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrBqF,GAAcrF,EAAO,UACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GAExC,GAA0B,IAAtBtI,EAAW/c,OACb,MAAM6qB,GAAWxF,GAGnB,MAAO,CACLhL,KAAMqM,EAAKkC,sBACXrtB,KAAMA,EACNwhB,WAAYA,EACZmN,IAAKA,GAAI7E,EAAOlP,IAnEL4U,CAAyB1F,GAElC,IAAK,OACH,OA2ER,SAAkCA,GAChC,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrBqF,GAAcrF,EAAO,QACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBjG,EAAa4L,GAA0B3F,GACvCtI,EAAa4N,GAAgBtF,GAAO,GACpC7G,EAASyM,GAAsB5F,GAEnC,GAA0B,IAAtBjG,EAAWpf,QAAsC,IAAtB+c,EAAW/c,QAAkC,IAAlBwe,EAAOxe,OAC/D,MAAM6qB,GAAWxF,GAGnB,MAAO,CACLhL,KAAMqM,EAAKmC,sBACXttB,KAAMA,EACN6jB,WAAYA,EACZrC,WAAYA,EACZyB,OAAQA,EACR0L,IAAKA,GAAI7E,EAAOlP,IA9FL+U,CAAyB7F,GAElC,IAAK,YACH,OAqGR,SAAqCA,GACnC,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrBqF,GAAcrF,EAAO,aACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpC7G,EAASyM,GAAsB5F,GAEnC,GAA0B,IAAtBtI,EAAW/c,QAAkC,IAAlBwe,EAAOxe,OACpC,MAAM6qB,GAAWxF,GAGnB,MAAO,CACLhL,KAAMqM,EAAKoC,yBACXvtB,KAAMA,EACNwhB,WAAYA,EACZyB,OAAQA,EACR0L,IAAKA,GAAI7E,EAAOlP,IAtHLgV,CAA4B9F,GAErC,IAAK,QACH,OA6HR,SAAiCA,GAC/B,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrBqF,GAAcrF,EAAO,SACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpC3F,EAAQ0L,GAAsB/F,GAElC,GAA0B,IAAtBtI,EAAW/c,QAAiC,IAAjB0f,EAAM1f,OACnC,MAAM6qB,GAAWxF,GAGnB,MAAO,CACLhL,KAAMqM,EAAKqC,qBACXxtB,KAAMA,EACNwhB,WAAYA,EACZ2C,MAAOA,EACPwK,IAAKA,GAAI7E,EAAOlP,IA9ILkV,CAAwBhG,GAEjC,IAAK,OACH,OAqJR,SAAgCA,GAC9B,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrBqF,GAAcrF,EAAO,QACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpCja,EAASkgB,GAA0BjG,GAEvC,GAA0B,IAAtBtI,EAAW/c,QAAkC,IAAlBoL,EAAOpL,OACpC,MAAM6qB,GAAWxF,GAGnB,MAAO,CACLhL,KAAMqM,EAAKsC,oBACXztB,KAAMA,EACNwhB,WAAYA,EACZ3R,OAAQA,EACR8e,IAAKA,GAAI7E,EAAOlP,IAtKLoV,CAAuBlG,GAEhC,IAAK,QACH,OA6KR,SAAuCA,GACrC,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrBqF,GAAcrF,EAAO,SACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpC7G,EAASgN,GAA2BnG,GAExC,GAA0B,IAAtBtI,EAAW/c,QAAkC,IAAlBwe,EAAOxe,OACpC,MAAM6qB,GAAWxF,GAGnB,MAAO,CACLhL,KAAMqM,EAAKuC,4BACX1tB,KAAMA,EACNwhB,WAAYA,EACZyB,OAAQA,EACR0L,IAAKA,GAAI7E,EAAOlP,IA9LLsV,CAA8BpG,GAI3C,MAAMwF,GAAWxF,EAAOoF,GAr9BXiB,CAAyBrG,OAE/B,IAAIiF,GAAKjF,EAAOpC,EAAUuB,SAC/B,OAAO+F,EAA0BlF,GAC5B,GAAIsG,GAAgBtG,GACzB,OAAOmF,GAA0BnF,GAGnC,MAAMwF,GAAWxF,GASnB,SAASkF,EAA0BlF,GACjC,GAAIiF,GAAKjF,EAAOpC,EAAU0B,MACxB,OAAQU,EAAMxR,MAAMhT,OAClB,IAAK,QACL,IAAK,WACL,IAAK,eACH,OAAO+qB,EAAyBvG,GAElC,IAAK,WACH,OA2PR,SAAiCA,GAC/B,IAAIlP,EAAQkP,EAAMxR,MAKlB,GAJA6W,GAAcrF,EAAO,YAIjBA,EAAMtrB,QAAQ8xB,8BAChB,MAAO,CACLxR,KAAMqM,EAAKS,oBACX5rB,KAAMuwB,EAAkBzG,GACxBvI,oBAAqBiP,EAAyB1G,GAC9C1H,eAAgB+M,GAAcrF,EAAO,MAAO2G,GAAe3G,IAC3DtI,WAAY4N,GAAgBtF,GAAO,GACnCrI,aAAciP,EAAkB5G,GAChC6E,IAAKA,GAAI7E,EAAOlP,IAIpB,MAAO,CACLkE,KAAMqM,EAAKS,oBACX5rB,KAAMuwB,EAAkBzG,GACxB1H,eAAgB+M,GAAcrF,EAAO,MAAO2G,GAAe3G,IAC3DtI,WAAY4N,GAAgBtF,GAAO,GACnCrI,aAAciP,EAAkB5G,GAChC6E,IAAKA,GAAI7E,EAAOlP,IAnRL+V,CAAwB7G,QAE9B,GAAIiF,GAAKjF,EAAOpC,EAAUuB,SAC/B,OAAOoH,EAAyBvG,GAGlC,MAAMwF,GAAWxF,GAUnB,SAASuG,EAAyBvG,GAChC,IAAIlP,EAAQkP,EAAMxR,MAElB,GAAIyW,GAAKjF,EAAOpC,EAAUuB,SACxB,MAAO,CACLnK,KAAMqM,EAAKE,qBACXxoB,UAAW,QACX7C,UAAMC,EACNshB,oBAAqB,GACrBC,WAAY,GACZC,aAAciP,EAAkB5G,GAChC6E,IAAKA,GAAI7E,EAAOlP,IAIpB,IACI5a,EADA6C,EAAY+tB,EAAmB9G,GAOnC,OAJIiF,GAAKjF,EAAOpC,EAAU0B,QACxBppB,EAAO6uB,EAAU/E,IAGZ,CACLhL,KAAMqM,EAAKE,qBACXxoB,UAAWA,EACX7C,KAAMA,EACNuhB,oBAAqBiP,EAAyB1G,GAC9CtI,WAAY4N,GAAgBtF,GAAO,GACnCrI,aAAciP,EAAkB5G,GAChC6E,IAAKA,GAAI7E,EAAOlP,IAQpB,SAASgW,EAAmB9G,GAC1B,IAAI+G,EAAiB/B,GAAOhF,EAAOpC,EAAU0B,MAE7C,OAAQyH,EAAevrB,OACrB,IAAK,QACH,MAAO,QAET,IAAK,WACH,MAAO,WAET,IAAK,eACH,MAAO,eAGX,MAAMgqB,GAAWxF,EAAO+G,GAO1B,SAASL,EAAyB1G,GAChC,OAAOiF,GAAKjF,EAAOpC,EAAUe,SAAWgG,GAAK3E,EAAOpC,EAAUe,QAASqI,EAAyBpJ,EAAUgB,SAAW,GAOvH,SAASoI,EAAwBhH,GAC/B,IAAIlP,EAAQkP,EAAMxR,MAElB,OAAIwR,EAAMtrB,QAAQuyB,yCACT,CACLjS,KAAMqM,EAAKG,oBACX3J,SAAUqP,EAAclH,GACxBrX,MAAOqc,GAAOhF,EAAOpC,EAAUkB,OAAQqI,GAAmBnH,IAC1DlI,aAAcsP,GAAKpH,EAAOpC,EAAUmB,QAAUsI,GAAkBrH,GAAO,QAAQ7pB,EAC/EuhB,WAAY4N,GAAgBtF,GAAO,GACnC6E,IAAKA,GAAI7E,EAAOlP,IAIb,CACLkE,KAAMqM,EAAKG,oBACX3J,SAAUqP,EAAclH,GACxBrX,MAAOqc,GAAOhF,EAAOpC,EAAUkB,OAAQqI,GAAmBnH,IAC1DlI,aAAcsP,GAAKpH,EAAOpC,EAAUmB,QAAUsI,GAAkBrH,GAAO,QAAQ7pB,EAC/E0uB,IAAKA,GAAI7E,EAAOlP,IAQpB,SAASoW,EAAclH,GACrB,IAAIlP,EAAQkP,EAAMxR,MAElB,OADAwW,GAAOhF,EAAOpC,EAAUa,QACjB,CACLzJ,KAAMqM,EAAKU,SACX7rB,KAAM6uB,EAAU/E,GAChB6E,IAAKA,GAAI7E,EAAOlP,IAQpB,SAAS8V,EAAkB5G,GACzB,IAAIlP,EAAQkP,EAAMxR,MAClB,MAAO,CACLwG,KAAMqM,EAAKI,cACXxJ,WAAY0M,GAAK3E,EAAOpC,EAAUuB,QAASmI,EAAgB1J,EAAUyB,SACrEwF,IAAKA,GAAI7E,EAAOlP,IAWpB,SAASwW,EAAetH,GACtB,OAAOiF,GAAKjF,EAAOpC,EAAUiB,QA2E/B,SAAuBmB,GACrB,IAYI1H,EAZAxH,EAAQkP,EAAMxR,MAGlB,GAFAwW,GAAOhF,EAAOpC,EAAUiB,QAEpBoG,GAAKjF,EAAOpC,EAAU0B,OAA+B,OAAtBU,EAAMxR,MAAMhT,MAC7C,MAAO,CACLwZ,KAAMqM,EAAKO,gBACX1rB,KAAMuwB,EAAkBzG,GACxBtI,WAAY4N,GAAgBtF,GAAO,GACnC6E,IAAKA,GAAI7E,EAAOlP,IAMM,OAAtBkP,EAAMxR,MAAMhT,QACdwkB,EAAMhC,UACN1F,EAAgBqO,GAAe3G,IAGjC,MAAO,CACLhL,KAAMqM,EAAKQ,gBACXvJ,cAAeA,EACfZ,WAAY4N,GAAgBtF,GAAO,GACnCrI,aAAciP,EAAkB5G,GAChC6E,IAAKA,GAAI7E,EAAOlP,IApGqByW,CAAcvH,GASvD,SAAoBA,GAClB,IAEI5a,EACAlP,EAHA4a,EAAQkP,EAAMxR,MACdgZ,EAAczC,EAAU/E,GAIxBoH,GAAKpH,EAAOpC,EAAUkB,QACxB1Z,EAAQoiB,EACRtxB,EAAO6uB,EAAU/E,IAEjB9pB,EAAOsxB,EAGT,MAAO,CACLxS,KAAMqM,EAAKK,MACXtc,MAAOA,EACPlP,KAAMA,EACN4f,UAAW2R,EAAezH,GAAO,GACjCtI,WAAY4N,GAAgBtF,GAAO,GACnCrI,aAAcsN,GAAKjF,EAAOpC,EAAUuB,SAAWyH,EAAkB5G,QAAS7pB,EAC1E0uB,IAAKA,GAAI7E,EAAOlP,IA7B4C4W,CAAW1H,GAqC3E,SAASyH,EAAezH,EAAO2H,GAC7B,IAAIjsB,EAAOisB,EAAUC,EAAqBC,EAC1C,OAAO5C,GAAKjF,EAAOpC,EAAUe,SAAWgG,GAAK3E,EAAOpC,EAAUe,QAASjjB,EAAMkiB,EAAUgB,SAAW,GAOpG,SAASiJ,EAAc7H,GACrB,IAAIlP,EAAQkP,EAAMxR,MAClB,MAAO,CACLwG,KAAMqM,EAAKM,SACXzrB,KAAM6uB,EAAU/E,GAChBxkB,OAAQwpB,GAAOhF,EAAOpC,EAAUkB,OAAQuI,GAAkBrH,GAAO,IACjE6E,IAAKA,GAAI7E,EAAOlP,IAIpB,SAAS8W,EAAmB5H,GAC1B,IAAIlP,EAAQkP,EAAMxR,MAClB,MAAO,CACLwG,KAAMqM,EAAKM,SACXzrB,KAAM6uB,EAAU/E,GAChBxkB,OAAQwpB,GAAOhF,EAAOpC,EAAUkB,OAAQgJ,GAAgB9H,IACxD6E,IAAKA,GAAI7E,EAAOlP,IAiFpB,SAAS2V,EAAkBzG,GACzB,GAA0B,OAAtBA,EAAMxR,MAAMhT,MACd,MAAMgqB,GAAWxF,GAGnB,OAAO+E,EAAU/E,GAuBnB,SAASqH,GAAkBrH,EAAO2H,GAChC,IAAInZ,EAAQwR,EAAMxR,MAElB,OAAQA,EAAMwG,MACZ,KAAK4I,EAAUqB,UACb,OAoFN,SAAmBe,EAAO2H,GACxB,IAAI7W,EAAQkP,EAAMxR,MACd9S,EAAOisB,EAAUG,GAAkBC,GACvC,MAAO,CACL/S,KAAMqM,EAAKc,KACXpc,OAAQiiB,GAAIhI,EAAOpC,EAAUqB,UAAWvjB,EAAMkiB,EAAUsB,WACxD2F,IAAKA,GAAI7E,EAAOlP,IA1FPmX,CAAUjI,EAAO2H,GAE1B,KAAK/J,EAAUuB,QACb,OAiGN,SAAqBa,EAAO2H,GAC1B,IAAI7W,EAAQkP,EAAMxR,MAClBwW,GAAOhF,EAAOpC,EAAUuB,SACxB,IAAIhG,EAAS,GAEb,MAAQiO,GAAKpH,EAAOpC,EAAUyB,UAC5BlG,EAAOzX,KAAKwmB,GAAiBlI,EAAO2H,IAGtC,MAAO,CACL3S,KAAMqM,EAAKe,OACXjJ,OAAQA,EACR0L,IAAKA,GAAI7E,EAAOlP,IA7GPqX,CAAYnI,EAAO2H,GAE5B,KAAK/J,EAAU2B,IAEb,OADAS,EAAMhC,UACC,CACLhJ,KAAMqM,EAAK9B,IACX/jB,MAAOgT,EAAMhT,MACbqpB,IAAKA,GAAI7E,EAAOxR,IAGpB,KAAKoP,EAAU4B,MAEb,OADAQ,EAAMhC,UACC,CACLhJ,KAAMqM,EAAK7B,MACXhkB,MAAOgT,EAAMhT,MACbqpB,IAAKA,GAAI7E,EAAOxR,IAGpB,KAAKoP,EAAU6B,OACf,KAAK7B,EAAU8B,aACb,OAAO0I,GAAmBpI,GAE5B,KAAKpC,EAAU0B,KACb,MAAoB,SAAhB9Q,EAAMhT,OAAoC,UAAhBgT,EAAMhT,OAClCwkB,EAAMhC,UACC,CACLhJ,KAAMqM,EAAKW,QACXxmB,MAAuB,SAAhBgT,EAAMhT,MACbqpB,IAAKA,GAAI7E,EAAOxR,KAEO,SAAhBA,EAAMhT,OACfwkB,EAAMhC,UACC,CACLhJ,KAAMqM,EAAKY,KACX4C,IAAKA,GAAI7E,EAAOxR,MAIpBwR,EAAMhC,UACC,CACLhJ,KAAMqM,EAAKa,KACX1mB,MAAOgT,EAAMhT,MACbqpB,IAAKA,GAAI7E,EAAOxR,KAGpB,KAAKoP,EAAUa,OACb,IAAKkJ,EACH,OAAOT,EAAclH,GAM3B,MAAMwF,GAAWxF,GAGnB,SAASoI,GAAmBpI,GAC1B,IAAIxR,EAAQwR,EAAMxR,MAElB,OADAwR,EAAMhC,UACC,CACLhJ,KAAMqM,EAAK5B,OACXjkB,MAAOgT,EAAMhT,MACbwc,MAAOxJ,EAAMwG,OAAS4I,EAAU8B,aAChCmF,IAAKA,GAAI7E,EAAOxR,IAIb,SAASsZ,GAAgB9H,GAC9B,OAAOqH,GAAkBrH,GAAO,GAGlC,SAAS+H,GAAgB/H,GACvB,OAAOqH,GAAkBrH,GAAO,GA6ClC,SAASkI,GAAiBlI,EAAO2H,GAC/B,IAAI7W,EAAQkP,EAAMxR,MAClB,MAAO,CACLwG,KAAMqM,EAAKgB,aACXnsB,KAAM6uB,EAAU/E,GAChBxkB,OAAQwpB,GAAOhF,EAAOpC,EAAUkB,OAAQuI,GAAkBrH,EAAO2H,IACjE9C,IAAKA,GAAI7E,EAAOlP,IASpB,SAASwU,GAAgBtF,EAAO2H,GAG9B,IAFA,IAAIjQ,EAAa,GAEVuN,GAAKjF,EAAOpC,EAAUoB,KAC3BtH,EAAWhW,KAAK2mB,GAAerI,EAAO2H,IAGxC,OAAOjQ,EAOT,SAAS2Q,GAAerI,EAAO2H,GAC7B,IAAI7W,EAAQkP,EAAMxR,MAElB,OADAwW,GAAOhF,EAAOpC,EAAUoB,IACjB,CACLhK,KAAMqM,EAAKiB,UACXpsB,KAAM6uB,EAAU/E,GAChBlK,UAAW2R,EAAezH,EAAO2H,GACjC9C,IAAKA,GAAI7E,EAAOlP,IAYb,SAASqW,GAAmBnH,GACjC,IACIrX,EADAmI,EAAQkP,EAAMxR,MAelB,OAZI4Y,GAAKpH,EAAOpC,EAAUqB,YACxBtW,EAAOwe,GAAmBnH,GAC1BgF,GAAOhF,EAAOpC,EAAUsB,WACxBvW,EAAO,CACLqM,KAAMqM,EAAKmB,UACX7Z,KAAMA,EACNkc,IAAKA,GAAI7E,EAAOlP,KAGlBnI,EAAOge,GAAe3G,GAGpBoH,GAAKpH,EAAOpC,EAAUY,MACjB,CACLxJ,KAAMqM,EAAKoB,cACX9Z,KAAMA,EACNkc,IAAKA,GAAI7E,EAAOlP,IAIbnI,EAMF,SAASge,GAAe3G,GAC7B,IAAIlP,EAAQkP,EAAMxR,MAClB,MAAO,CACLwG,KAAMqM,EAAKkB,WACXrsB,KAAM6uB,EAAU/E,GAChB6E,IAAKA,GAAI7E,EAAOlP,IAmBpB,SAASqU,GAA0BnF,GAEjC,IAAIoF,EAAekB,GAAgBtG,GAASA,EAAM9B,YAAc8B,EAAMxR,MAEtE,GAAI4W,EAAapQ,OAAS4I,EAAU0B,KAClC,OAAQ8F,EAAa5pB,OACnB,IAAK,SACH,OA8CR,SAA+BwkB,GAC7B,IAAIlP,EAAQkP,EAAMxR,MAClB6W,GAAcrF,EAAO,UACrB,IAAItI,EAAa4N,GAAgBtF,GAAO,GACpCtG,EAAiBiL,GAAK3E,EAAOpC,EAAUuB,QAASoG,GAA8B3H,EAAUyB,SAC5F,MAAO,CACLrK,KAAMqM,EAAKqB,kBACXhL,WAAYA,EACZgC,eAAgBA,EAChBmL,IAAKA,GAAI7E,EAAOlP,IAvDLwX,CAAsBtI,GAE/B,IAAK,SACH,OA6ER,SAAmCA,GACjC,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GACnCqF,GAAcrF,EAAO,UACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACxC,MAAO,CACLhL,KAAMqM,EAAKuB,uBACXzH,YAAaA,EACbjlB,KAAMA,EACNwhB,WAAYA,EACZmN,IAAKA,GAAI7E,EAAOlP,IAxFL0X,CAA0BxI,GAEnC,IAAK,OACH,OA+FR,SAAmCA,GACjC,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GACnCqF,GAAcrF,EAAO,QACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBjG,EAAa4L,GAA0B3F,GACvCtI,EAAa4N,GAAgBtF,GAAO,GACpC7G,EAASyM,GAAsB5F,GACnC,MAAO,CACLhL,KAAMqM,EAAKwB,uBACX1H,YAAaA,EACbjlB,KAAMA,EACN6jB,WAAYA,EACZrC,WAAYA,EACZyB,OAAQA,EACR0L,IAAKA,GAAI7E,EAAOlP,IA9GL2X,CAA0BzI,GAEnC,IAAK,YACH,OA2NR,SAAsCA,GACpC,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GACnCqF,GAAcrF,EAAO,aACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpC7G,EAASyM,GAAsB5F,GACnC,MAAO,CACLhL,KAAMqM,EAAK2B,0BACX7H,YAAaA,EACbjlB,KAAMA,EACNwhB,WAAYA,EACZyB,OAAQA,EACR0L,IAAKA,GAAI7E,EAAOlP,IAxOL4X,CAA6B1I,GAEtC,IAAK,QACH,OA8OR,SAAkCA,GAChC,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GACnCqF,GAAcrF,EAAO,SACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpC3F,EAAQ0L,GAAsB/F,GAClC,MAAO,CACLhL,KAAMqM,EAAK4B,sBACX9H,YAAaA,EACbjlB,KAAMA,EACNwhB,WAAYA,EACZ2C,MAAOA,EACPwK,IAAKA,GAAI7E,EAAOlP,IA3PL6X,CAAyB3I,GAElC,IAAK,OACH,OAsRR,SAAiCA,GAC/B,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GACnCqF,GAAcrF,EAAO,QACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpCja,EAASkgB,GAA0BjG,GACvC,MAAO,CACLhL,KAAMqM,EAAK6B,qBACX/H,YAAaA,EACbjlB,KAAMA,EACNwhB,WAAYA,EACZ3R,OAAQA,EACR8e,IAAKA,GAAI7E,EAAOlP,IAnSL8X,CAAwB5I,GAEjC,IAAK,QACH,OAqUR,SAAwCA,GACtC,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GACnCqF,GAAcrF,EAAO,SACrB,IAAI9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACpC7G,EAASgN,GAA2BnG,GACxC,MAAO,CACLhL,KAAMqM,EAAK+B,6BACXjI,YAAaA,EACbjlB,KAAMA,EACNwhB,WAAYA,EACZyB,OAAQA,EACR0L,IAAKA,GAAI7E,EAAOlP,IAlVL+X,CAA+B7I,GAExC,IAAK,YACH,OAwkBR,SAAkCA,GAChC,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GACnCqF,GAAcrF,EAAO,aACrBgF,GAAOhF,EAAOpC,EAAUoB,IACxB,IAAI9oB,EAAO6uB,EAAU/E,GACjBhf,EAAO8nB,GAAkB9I,GAC7BqF,GAAcrF,EAAO,MACrB,IAAItF,EAiBN,SAAiCsF,GAE/BoH,GAAKpH,EAAOpC,EAAUwB,MACtB,IAAI1E,EAAY,GAEhB,GACEA,EAAUhZ,KAAKqnB,GAAuB/I,UAC/BoH,GAAKpH,EAAOpC,EAAUwB,OAE/B,OAAO1E,EA1BSsO,CAAwBhJ,GACxC,MAAO,CACLhL,KAAMqM,EAAKgC,qBACXlI,YAAaA,EACbjlB,KAAMA,EACN4f,UAAW9U,EACX0Z,UAAWA,EACXmK,IAAKA,GAAI7E,EAAOlP,IAvlBLmY,CAAyBjJ,GAItC,MAAMwF,GAAWxF,EAAOoF,GAG1B,SAASkB,GAAgBtG,GACvB,OAAOiF,GAAKjF,EAAOpC,EAAU6B,SAAWwF,GAAKjF,EAAOpC,EAAU8B,cAOhE,SAAS6I,GAAiBvI,GACxB,GAAIsG,GAAgBtG,GAClB,OAAOoI,GAAmBpI,GAyB9B,SAASuF,GAA6BvF,GACpC,IAAIlP,EAAQkP,EAAMxR,MACdzV,EAAY+tB,EAAmB9G,GACnCgF,GAAOhF,EAAOpC,EAAUkB,OACxB,IAAInW,EAAOge,GAAe3G,GAC1B,MAAO,CACLhL,KAAMqM,EAAKsB,0BACX5pB,UAAWA,EACX4P,KAAMA,EACNkc,IAAKA,GAAI7E,EAAOlP,IAsDpB,SAAS6U,GAA0B3F,GACjC,IAAI3F,EAAQ,GAEZ,GAA0B,eAAtB2F,EAAMxR,MAAMhT,MAAwB,CACtCwkB,EAAMhC,UAENoJ,GAAKpH,EAAOpC,EAAUc,KAEtB,GACErE,EAAM3Y,KAAKilB,GAAe3G,UACnBoH,GAAKpH,EAAOpC,EAAUc,MAC/BsB,EAAMtrB,QAAQw0B,oCAAsCjE,GAAKjF,EAAOpC,EAAU0B,OAG5E,OAAOjF,EAOT,SAASuL,GAAsB5F,GAE7B,OAAIA,EAAMtrB,QAAQy0B,2BAA6BlE,GAAKjF,EAAOpC,EAAUuB,UAAYa,EAAM9B,YAAYlJ,OAAS4I,EAAUyB,SACpHW,EAAMhC,UACNgC,EAAMhC,UACC,IAGFiH,GAAKjF,EAAOpC,EAAUuB,SAAWwF,GAAK3E,EAAOpC,EAAUuB,QAASiK,GAAsBxL,EAAUyB,SAAW,GAQpH,SAAS+J,GAAqBpJ,GAC5B,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GAC/B9pB,EAAO6uB,EAAU/E,GACjBhf,EAAO8nB,GAAkB9I,GAC7BgF,GAAOhF,EAAOpC,EAAUkB,OACxB,IAAInW,EAAOwe,GAAmBnH,GAC1BtI,EAAa4N,GAAgBtF,GAAO,GACxC,MAAO,CACLhL,KAAMqM,EAAKyB,iBACX3H,YAAaA,EACbjlB,KAAMA,EACN4f,UAAW9U,EACX2H,KAAMA,EACN+O,WAAYA,EACZmN,IAAKA,GAAI7E,EAAOlP,IAQpB,SAASgY,GAAkB9I,GACzB,OAAKiF,GAAKjF,EAAOpC,EAAUe,SAIpBgG,GAAK3E,EAAOpC,EAAUe,QAAS0K,GAAoBzL,EAAUgB,SAH3D,GAWX,SAASyK,GAAmBrJ,GAC1B,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GAC/B9pB,EAAO6uB,EAAU/E,GACrBgF,GAAOhF,EAAOpC,EAAUkB,OACxB,IACIhH,EADAnP,EAAOwe,GAAmBnH,GAG1BoH,GAAKpH,EAAOpC,EAAUmB,UACxBjH,EAAegQ,GAAgB9H,IAGjC,IAAItI,EAAa4N,GAAgBtF,GAAO,GACxC,MAAO,CACLhL,KAAMqM,EAAK0B,uBACX5H,YAAaA,EACbjlB,KAAMA,EACNyS,KAAMA,EACNmP,aAAcA,EACdJ,WAAYA,EACZmN,IAAKA,GAAI7E,EAAOlP,IAsDpB,SAASiV,GAAsB/F,GAC7B,IAAI3F,EAAQ,GAEZ,GAAI+M,GAAKpH,EAAOpC,EAAUmB,QAAS,CAEjCqI,GAAKpH,EAAOpC,EAAUwB,MAEtB,GACE/E,EAAM3Y,KAAKilB,GAAe3G,UACnBoH,GAAKpH,EAAOpC,EAAUwB,OAGjC,OAAO/E,EA6BT,SAAS4L,GAA0BjG,GACjC,OAAOiF,GAAKjF,EAAOpC,EAAUuB,SAAWwF,GAAK3E,EAAOpC,EAAUuB,QAASmK,GAA0B1L,EAAUyB,SAAW,GASxH,SAASiK,GAAyBtJ,GAChC,IAAIlP,EAAQkP,EAAMxR,MACd2M,EAAcoN,GAAiBvI,GAC/B9pB,EAAO6uB,EAAU/E,GACjBtI,EAAa4N,GAAgBtF,GAAO,GACxC,MAAO,CACLhL,KAAMqM,EAAK8B,sBACXhI,YAAaA,EACbjlB,KAAMA,EACNwhB,WAAYA,EACZmN,IAAKA,GAAI7E,EAAOlP,IA8BpB,SAASqV,GAA2BnG,GAClC,OAAOiF,GAAKjF,EAAOpC,EAAUuB,SAAWwF,GAAK3E,EAAOpC,EAAUuB,QAASkK,GAAoBzL,EAAUyB,SAAW,GAiTlH,SAAS0J,GAAuB/I,GAC9B,IAAIlP,EAAQkP,EAAMxR,MACdtY,EAAO6uB,EAAU/E,GAErB,GAAI6D,EAAkBlN,eAAezgB,EAAKsF,OACxC,OAAOtF,EAGT,MAAMsvB,GAAWxF,EAAOlP,GAS1B,SAAS+T,GAAI7E,EAAOuJ,GAClB,IAAKvJ,EAAMtrB,QAAQ80B,WACjB,OAAO,IAAIC,GAAIF,EAAYvJ,EAAMlC,UAAWkC,EAAMlD,QAItD,SAAS2M,GAAIF,EAAYG,EAAU5M,GACjCJ,KAAK5L,MAAQyY,EAAWzY,MACxB4L,KAAKjB,IAAMiO,EAASjO,IACpBiB,KAAK6M,WAAaA,EAClB7M,KAAKgN,SAAWA,EAChBhN,KAAKI,OAASA,EAehB,SAASmI,GAAKjF,EAAOhL,GACnB,OAAOgL,EAAMxR,MAAMwG,OAASA,EAQ9B,SAASoS,GAAKpH,EAAOhL,GACnB,IAAIjZ,EAAQikB,EAAMxR,MAAMwG,OAASA,EAMjC,OAJIjZ,GACFikB,EAAMhC,UAGDjiB,EAQT,SAASipB,GAAOhF,EAAOhL,GACrB,IAAIxG,EAAQwR,EAAMxR,MAElB,GAAIA,EAAMwG,OAASA,EAEjB,OADAgL,EAAMhC,UACCxP,EAGT,MAAMqO,EAAYmD,EAAMlD,OAAQtO,EAAMsC,MAAO,YAAY7N,OAAO+R,EAAM,YAAY/R,OAAO0c,EAAanR,KASxG,SAAS6W,GAAcrF,EAAOxkB,GAC5B,IAAIgT,EAAQwR,EAAMxR,MAElB,GAAIA,EAAMwG,OAAS4I,EAAU0B,MAAQ9Q,EAAMhT,QAAUA,EAEnD,OADAwkB,EAAMhC,UACCxP,EAGT,MAAMqO,EAAYmD,EAAMlD,OAAQtO,EAAMsC,MAAO,aAAc7N,OAAOzH,EAAO,aAAcyH,OAAO0c,EAAanR,KAQ7G,SAASgX,GAAWxF,EAAO2J,GACzB,IAAInb,EAAQmb,GAAW3J,EAAMxR,MAC7B,OAAOqO,EAAYmD,EAAMlD,OAAQtO,EAAMsC,MAAO,cAAc7N,OAAO0c,EAAanR,KAUlF,SAASwZ,GAAIhI,EAAO4J,EAAUC,EAASC,GACrC9E,GAAOhF,EAAO4J,GAGd,IAFA,IAAIG,EAAQ,IAEJ3C,GAAKpH,EAAO8J,IAClBC,EAAMroB,KAAKmoB,EAAQ7J,IAGrB,OAAO+J,EAUT,SAASpF,GAAK3E,EAAO4J,EAAUC,EAASC,GACtC9E,GAAOhF,EAAO4J,GAGd,IAFA,IAAIG,EAAQ,CAACF,EAAQ7J,KAEboH,GAAKpH,EAAO8J,IAClBC,EAAMroB,KAAKmoB,EAAQ7J,IAGrB,OAAO+J,EA1GTN,GAAI5N,UAAUuF,OAASqI,GAAI5N,UAAUC,QAAU,WAC7C,MAAO,CACLhL,MAAO4L,KAAK5L,MACZ2K,IAAKiB,KAAKjB,M,quECx1CRjnB,GAAS,IAAIC,KAAO,cAEbu1B,GAAmB,SAAC5vB,EAAOuN,GAAmB,YAAnB,QAAAA,MAAoB,CAC3DvN,MAAK,EACLuN,UAAS,IAMV,cAeC,WAAYjT,GAVJ,UAAO,KAEf,UAAOH,KACP,WAAQgE,KACR,iBAAc5D,KAOb,KAAKC,SAAWF,EAChBF,GAAOK,MAAM,cAAe,KAAKD,UAuUnC,OApUQ8D,0BAAP,WACC,MAAO,cAQRA,sBAAA,SAAUhE,GACT,IAAMK,QAAEC,QAAAC,kBAAUC,gBACdC,EAAG,SAAQD,GAAiBD,GAsBhC,OArBAT,GAAOK,MAAM,wBAAyB,CAAEM,IAAG,IAEvCA,EAAwB,qBAC3BA,EAAMK,OAAOC,OAAO,GAAIN,EAAK,CAC5BO,OAAQP,EAAwB,mBAChCQ,OAAQ,MAKsB,qBAAxBR,EAAI0S,iBACoB,oBAAxB1S,EAAI0S,kBAEXrT,GAAOyB,KAAK,wCACZd,EAAI0S,qBAAkB1R,GAGvB,KAAKvB,SAAWY,OAAOC,OAAO,GAAI,KAAKb,SAAUO,GAEjD,KAAKiB,iBAEE,KAAKxB,UAOb8D,2BAAA,WAEC,OADAlE,GAAOK,MAAM,wBACT,KAAKD,UACR,KAAKyB,KAAO,IAAIC,KAAW,KAAK1B,UAEhC,KAAKyB,KAAK1B,YAAc,KAAKA,aAEtB,GAEAwC,QAAQC,OAAO,uBAIVsB,6BAAd,SAA+BuxB,G,uHACxBl1B,EAGF,KAAKH,SAFRs1B,EAA8B,iCACVtiB,EAAM,qBAIvB/N,EAAU,GADbowB,GAA6BC,GAAkC,W,IAI1D,sB,IASA,sB,IAMA,6B,IAmBA,wC,oBAjCJ,IAAKtiB,EACJ,MAAM,IAAI5P,MAAM,yBAMjB,OAJA6B,EAAU,CACTsU,cAAe,KACf,YAAavG,GAEd,O,OAEsB,SAAM,KAAKmH,sB,OACjC,IADsB7K,SAErB,MAAM,IAAIlM,MAAM,kBAEjB,a,OAIsB,OAFlBwW,OAAK,EAEa,GAAMjW,KAAM+V,QAAQ,kB,cAApCC,EAAgBrK,WAErBsK,EAAQD,EAAcC,M,OADnB,M,OAGiB,SAAMja,KAAKka,4B,QAAzBC,EAAcxK,YAEnBsK,EAAQE,EAAYF,O,iBAGtB,IAAKA,EACJ,MAAM,IAAIxW,MAAM,oBAKjB,OAHA6B,EAAU,CACTsU,cAAeK,GAEhB,O,OAEgB,SAAM,KAAKja,KAAK2Z,kB,QAIhC,OAJMic,EAAUjmB,SAChBrK,EAAU,CACTsU,cAAegc,EAAQ/b,iBAAiBC,eAEzC,O,QAKA,OAHAxU,EAAU,CACTsU,cAAe,MAEhB,O,QAGF,SAAOtU,WAORnB,oCAAA,SAAwBK,GACvB,IAAMqxB,EAAM70B,EAAMwD,GAKlB,OAHC,oBAAgBsxB,cAalB3xB,oBAAA,SACC3D,EACAkE,G,IADEqxB,UAAmBt1B,cAAA2S,kBAAgB4iB,aAG/BnwB,EAEF7E,EADmB,kBAAf+0B,EACEA,EACA5U,EAAM4U,IAET1kB,EAAD,gFAACA,GAIN,QAJM4kB,YAIN,UAGD,OAAQH,GACP,IAAK,QACL,IAAK,WACJ,IAAMzzB,EAAmB,KAAKP,KAAKQ,sBAC7BC,EAAa,CAAEF,iBAAgB,GAC/BG,EAAkB,KAAK0zB,SAC5B,CAAErwB,MAAK,EAAEuN,UAAS,EAAE4iB,SAAQ,GAC5BtxB,EACAnC,GAMD,OAJA,KAAKT,KAAKY,6BACTF,EACAH,GAEMG,EACR,IAAK,eACJ,OAAO,KAAK2zB,kBACX,CAAEtwB,MAAK,EAAEuN,UAAS,EAAE4iB,SAAQ,GAC5BtxB,GAIH,MAAM,IAAIjB,MAAM,2BAA2BqyB,IAG9B3xB,qBAAd,SACC3D,EACAkE,EACAnC,G,IAFEsD,UAAOuN,cAAW4iB,a,YACpB,QAAAtxB,WACA,QAAAnC,M,0IAEK,KAAKT,KAAN,MACH,GAAM,KAAKD,kB,OAAXu0B,S,wBAGK31B,EAMF,KAAKJ,SALYc,EAAM,qBACGoR,EAAsB,8BACnD5C,oBAAA2D,OAAe,MAAG,WAAM,MAAC,IAAG,EACV+iB,EAAqB,mBACVC,EAAoB,8B,QAI7ClgB,GAACigB,GAA0B,GAAM,KAAKE,iBAAiBP,IAAvD,M,OAA0B5f,EAACggB,S,qDAA5BhgB,OACCzB,KACF2hB,EACE,GAAM,KAAKC,iBAAiBP,IAD9B,MADE,M,cAEAtd,W,aACAA,GAAEkB,cAAe,M,iBAFpBjF,I,iBAGG,O,6BAJDA,MAIC,GAAMrB,EAAgB,CAAEzN,MAAK,EAAEuN,UAAS,K,OA0B7C,GAhCM9N,EAAO,4DAMR8wB,YACD1xB,KACE2xB,IAAqB,KACzBG,EAxOsB,oBAwOD52B,KAAUC,UAAS,KAIpC8J,EAAO,CACZ9D,MAAOsb,EAAMtb,GACbuN,UAAS,GAGJlR,EAAOjB,OAAOC,OACnB,CACCoE,QAAO,EACPqE,KAAI,EACJ8sB,kBAAmB,CAClB5yB,QAAUwyB,EAAoC,cAAZ,UAClCl1B,OAASk1B,EAAiCC,EAATn1B,IAGnCoB,KAGKf,EAAW60B,GAAyB9jB,GAKzC,KAAM,CACLnL,KAAM,GACN6L,OAAQ,CAJK,IAAIC,IAAa,mC,mBAUpB,O,yBAAA,GAAM,KAAKpR,KAAKiB,KAAKvB,EAAUU,I,eAA1C0B,EAAWwyB,S,eAKX,G,WAAI,KAAKt0B,KAAKuB,SAASiO,GACtB,MAAMA,E,OAEP1N,EAAW,CACVwD,KAAM,GACN6L,OAAQ,CAAC,IAAIC,IAAa5B,EAAIxO,W,eAMhC,IAFQmQ,EAAWrP,EAAQ,SAEbqP,EAAO7M,OACpB,MAAMxC,EAGP,SAAOA,WAQRO,qBAAA,SAASf,GACR,OAAO,KAAKtB,KAAKuB,SAASD,IAQ3Be,mBAAA,SAAOb,EAAuBR,GAC7B,OAAO,KAAKhB,KAAKyB,OAAOD,EAASR,IAG1BqB,8BAAR,SACC3D,EACAkE,G,IADEmB,UAAOuN,cAAWsiB,kBACpB,QAAAhxB,MAEM,oBACLvD,uBACAoR,gCACAojB,mCACAtiB,uBACA1D,oBAAA2D,wBAAA,YAEKH,EACLuiB,GAA6BC,GAAkC,UAEhE,GAAI9qB,MAAsC,oBAArBA,KAAO+E,UAC3B,OAAO/E,KAAO+E,UAAU,GAAI,CAC3BkM,SAAUF,KACVrJ,uBAAsB,EACtBY,mBAAkB,EAClBE,OAAM,EACNxN,MAAOsb,EAAMtb,GACb1E,OAAM,EACNiS,UAAS,EACTE,gBAAe,EACf5O,kBAAiB,IAIlB,MADAzE,GAAOK,MAAM,6CACP,IAAImD,MAAM,8CAOlBU,+BAAA,sBACC,OAAO,KAAK/D,YAAYqC,MACtBgY,MAAK,YACL,IAAKC,EAAa,OAAO,EACzB,IAAMM,EAAO9O,EAAK9L,YAAY6a,MAAMP,GAGpC,OAFAza,GAAOK,MAAM,0BAA2B0a,IAEjC,KAEPE,OAAM,YAEN,OADAjb,GAAOyB,KAAK,2BAA4BiB,IACjC,MAGX,EAxVA,GA0Va+zB,GAAa,IAAIvyB,GAAgB,MAC9CpE,KAAQgE,SAAS2yB,K,8CCrXJnnB,E,OAMJonB,E,wCCtBT,sGAiBA,IAAMC,EACa,qBAAX7qB,QAAgD,oBAAfA,OAAOgG,IAEnC2J,EAAuCkb,EACjD7qB,OAAOgG,IAAI,wCACX,yCAEU6J,EAAgDgb,EAC1D7qB,OAAOgG,IAAI,iDACX,kDAEUgC,EAAoB,oB,kFAzBpB8iB,aAAqB,GAKrBA,gBAAwB,GAKxBA,MAAM,IAAIC,YAAY,CACjC,WACA,WACA,WACA,WACA,UACA,WACA,WACA,WACA,WACA,UACA,UACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,UACA,UACA,UACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,UACA,UACA,UACA,UACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,UACA,UACA,UACA,UACA,UACA,UACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,WACA,aAMWD,OAAO,CAClB,WACA,WACA,WACA,WACA,WACA,WACA,UACA,YAMWA,sBAAsBE,WAAK,IAAK,G,oBCjG7C,IAAIC,EAAKC,EAAQ,KACbC,EAAKD,EAAQ,KAEbhrB,EAAOirB,EACXjrB,EAAK+qB,GAAKA,EACV/qB,EAAKirB,GAAKA,EAEVC,EAAON,QAAU5qB,G,kBCAjB,IAAImrB,EAAqC,oBAAXC,QAA0BA,OAAOD,iBAAmBC,OAAOD,gBAAgBxhB,KAAKyhB,SACnE,oBAAbC,UAAsE,mBAAnC3a,OAAO2a,SAASF,iBAAiCE,SAASF,gBAAgBxhB,KAAK0hB,UAEhJ,GAAIF,EAAiB,CAEnB,IAAIG,EAAQ,IAAIC,WAAW,IAE3BL,EAAON,QAAU,WAEf,OADAO,EAAgBG,GACTA,OAEJ,CAKL,IAAIE,EAAO,IAAIp2B,MAAM,IAErB81B,EAAON,QAAU,WACf,IAAK,IAAWa,EAAP1oB,EAAI,EAAMA,EAAI,GAAIA,IACN,KAAV,EAAJA,KAAiB0oB,EAAoB,WAAhBX,KAAKY,UAC/BF,EAAKzoB,GAAK0oB,MAAY,EAAJ1oB,IAAa,GAAK,IAGtC,OAAOyoB,K,kBC1BX,IADA,IAAIG,EAAY,GACP5oB,EAAI,EAAGA,EAAI,MAAOA,EACzB4oB,EAAU5oB,IAAMA,EAAI,KAAOrI,SAAS,IAAIoC,OAAO,GAmBjDouB,EAAON,QAhBP,SAAqBgB,EAAKC,GACxB,IAAI9oB,EAAI8oB,GAAU,EACdC,EAAMH,EAEV,MAAQ,CACNG,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,MACvB+oB,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,MAAO,IAC9B+oB,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,MAAO,IAC9B+oB,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,MAAO,IAC9B+oB,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,MAAO,IAC9B+oB,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,MACvB+oB,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,MACvB+oB,EAAIF,EAAI7oB,MAAO+oB,EAAIF,EAAI7oB,OACtBrJ,KAAK,M,iCCLH,SAASqyB,EAAYzP,EAAQC,GAMlC,IALA,IAGIhhB,EAHAywB,EAAa,eACb7P,EAAO,EACPC,EAASG,EAAW,GAGhBhhB,EAAQywB,EAAWC,KAAK3P,EAAO5e,QAAUnC,EAAMka,MAAQ8G,GAC7DJ,GAAQ,EACRC,EAASG,EAAW,GAAKhhB,EAAMka,MAAQla,EAAM,GAAGpB,QAGlD,MAAO,CACLgiB,KAAMA,EACNC,OAAQA,GCgDZ,SAAS8P,EAA0B5P,EAAQ6P,GACzC,IAAIC,EAAwB9P,EAAOL,eAAeG,OAAS,EACvD1e,EAAO2uB,EAAWD,GAAyB9P,EAAO5e,KAClD4uB,EAAYH,EAAShQ,KAAO,EAC5BoQ,EAAajQ,EAAOL,eAAeE,KAAO,EAC1CqQ,EAAUL,EAAShQ,KAAOoQ,EAC1BE,EAAiC,IAAlBN,EAAShQ,KAAaiQ,EAAwB,EAC7DM,EAAYP,EAAS/P,OAASqQ,EAC9B/P,EAAQhf,EAAKtD,MAAM,gBACvB,MAAO,GAAGqI,OAAO6Z,EAAO5mB,KAAM,MAAM+M,OAAO+pB,EAAS,KAAK/pB,OAAOiqB,EAAW,OAI7E,SAA4BhQ,GAC1B,IAAIiQ,EAAgBjQ,EAAM9Z,QAAO,SAAUwU,GACjCA,EAAK,GAEb,YAAgBzhB,IADLyhB,EAAK,MAGdwV,EAAS,EACTC,GAA6B,EAC7BC,GAAqB,EACrBC,OAAkBp3B,EAEtB,IACE,IAAK,IAAmDq3B,EAA/CC,EAAaN,EAAc7sB,OAAOqb,cAAuB0R,GAA8BG,EAASC,EAAW5pB,QAAQ6pB,MAAOL,GAA6B,EAAM,CACpK,IACIM,EADQH,EAAOhyB,MACA,GACnB4xB,EAAS9B,KAAKsC,IAAIR,EAAQO,EAAOhzB,SAEnC,MAAOzD,GACPo2B,GAAqB,EACrBC,EAAkBr2B,EAClB,QACA,IACOm2B,GAAmD,MAArBI,EAAWI,QAC5CJ,EAAWI,SAEb,QACA,GAAIP,EACF,MAAMC,GAKZ,OAAOJ,EAAcpzB,KAAI,SAAUme,GACjC,IAUesF,EAVXmQ,EAASzV,EAAM,GACfyE,EAAOzE,EAAM,GACjB,OASK2U,EATOO,GAQG5P,EARKmQ,GASMhzB,QAAU6iB,EATNb,KAC7BziB,KAAK,MAxC4E4zB,CAAmB,CACvG,CAAC,GAAG7qB,OAAO+pB,EAAU,EAAG,MAAO9P,EAAM4P,EAAY,IAAK,CAAC,GAAG7pB,OAAO+pB,EAAS,MAAO9P,EAAM4P,IAAa,CAAC,GAAID,EAAWK,EAAY,GAAK,KAAM,CAAC,GAAGjqB,OAAO+pB,EAAU,EAAG,MAAO9P,EAAM4P,EAAY,MA0C9L,SAASD,EAAWkB,GAClB,OAAOn4B,MAAMm4B,EAAM,GAAG7zB,KAAK,KCzHtB,SAASuN,EAChBpQ,EAAS0yB,EAAOjN,EAAQkR,EAAWx3B,EAAMy3B,EAAexlB,GAEtD,IAAIylB,EAASt4B,MAAMC,QAAQk0B,GAA0B,IAAjBA,EAAMpvB,OAAeovB,OAAQ5zB,EAAY4zB,EAAQ,CAACA,QAAS5zB,EAG3Fg4B,EAAUrR,EAEd,IAAKqR,GAAWD,EAAQ,CACtB,IAAI/X,EAAO+X,EAAO,GAClBC,EAAUhY,GAAQA,EAAK0O,KAAO1O,EAAK0O,IAAI/H,OAGzC,IAgBIsR,EAhBAC,EAAaL,GAEZK,GAAcH,IACjBG,EAAaH,EAAO5oB,QAAO,SAAUgpB,EAAMnY,GAKzC,OAJIA,EAAK0O,KACPyJ,EAAK5sB,KAAKyU,EAAK0O,IAAI/T,OAGdwd,IACN,KAGDD,GAAoC,IAAtBA,EAAW1zB,SAC3B0zB,OAAal4B,GAKX63B,GAAalR,EACfsR,EAAaJ,EAAUj0B,KAAI,SAAUmmB,GACnC,OAAOqM,EAAYzP,EAAQoD,MAEpBgO,IACTE,EAAaF,EAAO5oB,QAAO,SAAUgpB,EAAMnY,GAKzC,OAJIA,EAAK0O,KACPyJ,EAAK5sB,KAAK6qB,EAAYpW,EAAK0O,IAAI/H,OAAQ3G,EAAK0O,IAAI/T,QAG3Cwd,IACN,KAGL,IAAIC,EAAc9lB,GAAcwlB,GAAiBA,EAAcxlB,WAE/DjT,OAAOg5B,iBAAiB9R,KAAM,CAC5BrlB,QAAS,CACPmE,MAAOnE,EAIP+kB,YAAY,EACZE,UAAU,GAEZ5B,UAAW,CAGTlf,MAAO4yB,QAAcj4B,EAIrBimB,WAAYrH,QAAQqZ,IAEtB53B,KAAM,CAGJgF,MAAOhF,QAAQL,EAIfimB,WAAYrH,QAAQve,IAEtBuzB,MAAO,CACLvuB,MAAO0yB,QAAU/3B,GAEnB2mB,OAAQ,CACNthB,MAAO2yB,QAAWh4B,GAEpB63B,UAAW,CACTxyB,MAAO6yB,QAAcl4B,GAEvB83B,cAAe,CACbzyB,MAAOyyB,GAETxlB,WAAY,CAGVjN,MAAO+yB,QAAep4B,EAItBimB,WAAYrH,QAAQwZ,MAIpBN,GAAiBA,EAAclY,MACjCvgB,OAAO2mB,eAAeO,KAAM,QAAS,CACnClhB,MAAOyyB,EAAclY,MACrBuG,UAAU,EACVD,cAAc,IAEPrkB,MAAMy2B,kBACfz2B,MAAMy2B,kBAAkB/R,KAAMjV,GAE9BjS,OAAO2mB,eAAeO,KAAM,QAAS,CACnClhB,MAAOxD,QAAQ+d,MACfuG,UAAU,EACVD,cAAc,I,kCAIpB5U,EAAaoU,UAAYrmB,OAAOk5B,OAAO12B,MAAM6jB,UAAW,CACtDD,YAAa,CACXpgB,MAAOiM,GAETvR,KAAM,CACJsF,MAAO,gBAETN,SAAU,CACRM,MAAO,WACL,ODtHC,SAAoB7D,GACzB,IAAIg3B,EAAmB,GAEvB,GAAIh3B,EAAMoyB,MAAO,CACf,IAAI6E,GAA4B,EAC5BC,GAAoB,EACpBC,OAAiB34B,EAErB,IACE,IAAK,IAAgD44B,EAA5CC,EAAYr3B,EAAMoyB,MAAMzpB,OAAOqb,cAAsBiT,GAA6BG,EAAQC,EAAUnrB,QAAQ6pB,MAAOkB,GAA4B,EAAM,CAC5J,IAAIzY,EAAO4Y,EAAMvzB,MAEb2a,EAAK0O,KACP8J,EAAiBjtB,KAAKgrB,EAA0BvW,EAAK0O,IAAI/H,OAAQyP,EAAYpW,EAAK0O,IAAI/H,OAAQ3G,EAAK0O,IAAI/T,UAG3G,MAAO5Z,GACP23B,GAAoB,EACpBC,EAAiB53B,EACjB,QACA,IACO03B,GAAiD,MAApBI,EAAUnB,QAC1CmB,EAAUnB,SAEZ,QACA,GAAIgB,EACF,MAAMC,SAIP,GAAIn3B,EAAMmlB,QAAUnlB,EAAM+iB,UAAW,CAC1C,IAAIoC,EAASnlB,EAAMmlB,OACfmS,GAA6B,EAC7BC,GAAqB,EACrBC,OAAkBh5B,EAEtB,IACE,IAAK,IAAqDi5B,EAAjDC,EAAa13B,EAAM+iB,UAAUpa,OAAOqb,cAAuBsT,GAA8BG,EAASC,EAAWxrB,QAAQ6pB,MAAOuB,GAA6B,EAAM,CACtK,IAAItC,EAAWyC,EAAO5zB,MACtBmzB,EAAiBjtB,KAAKgrB,EAA0B5P,EAAQ6P,KAE1D,MAAOz1B,GACPg4B,GAAqB,EACrBC,EAAkBj4B,EAClB,QACA,IACO+3B,GAAmD,MAArBI,EAAWxB,QAC5CwB,EAAWxB,SAEb,QACA,GAAIqB,EACF,MAAMC,IAMd,OAAmC,IAA5BR,EAAiBh0B,OAAehD,EAAMN,QAAU,CAACM,EAAMN,SAAS4L,OAAO0rB,GAAkBz0B,KAAK,QAAU,KC6DpGo1B,CAAW5S,W,iCCpIxB,0G,02DAyBMloB,EAAS,IAAIC,IAAO,cAe1B,aA2BC,WAAYC,GAzBJ,aAAkB,YAClB,cAAmB,cACnB,yBAAiByB,EAgBjB,qBAAmD,KAE3D,iBAAcxB,IAMb,KAAKC,SAAWF,EAChBF,EAAOK,MAAM,cAAe,KAAKD,UACL,MAAxB,KAAK26B,kBACR,KAAKA,gBAAkB,IAAIC,SAqW9B,OAlVOl5B,iBAAN,SAAWm5B,EAAgCl1B,EAAgB9D,G,wIAC1DjC,EAAOK,MAAM0F,EAAQk1B,GAIjB/5B,EAAiB,YACjB0C,EAAkB,cAClBpC,OAEAG,EAEwB,kBAAjBs5B,GACVC,EAAa,KAAKC,UAAUF,GAC5Bn1B,EAAMm1B,IAEHn1B,aAAetE,kBAAeN,WAAQ0C,YACzCs3B,EAAa,KAAKC,UAAUF,EAAa15B,WAGpC65B,EAAS,CACdr1B,OAAM,EACND,IAAG,EACHwB,KAAM4zB,EAAW5zB,KACjBtF,KAAMk5B,EAAWl5B,KACjBqD,QAAS,GACT8B,KAAM,KACNk0B,aAAc,OACdC,QAAS,EACTC,YAAa,MAGVC,EAAiB,GAEjB37B,IAAS47B,gBACN77B,EAAYC,IAASD,WAAa,oBACxC47B,EAAiB,CAChB,aAAc57B,IAIV0C,EAAatB,OAAOC,OAAO,GAAIgB,GAC/By5B,EAAgBp5B,EAAWqB,SAC7BrB,EAAWoH,OAEO,oBAAbiyB,UACPr5B,EAAWoH,gBAAgBiyB,UAE3BH,EAAe,gBAAkB,sBACjCJ,EAAOj0B,KAAO7E,EAAWoH,OAEzB8xB,EAAe,gBAAkB,kCACjCJ,EAAOj0B,KAAOrG,KAAK2L,UAAUnK,EAAWoH,QAGtCpH,EAAW+4B,eACdD,EAAOC,aAAe/4B,EAAW+4B,cAE9B/4B,EAAWs5B,kBACdR,EAAwB,gBAAI94B,EAAWs5B,iBAEpCt5B,EAAWg5B,UACdF,EAAOE,QAAUh5B,EAAWg5B,SAEzBh5B,EAAWF,mBACdg5B,EAAOG,YAAcj5B,EAAWF,iBAAiB4X,OAGlDohB,EAA0B,kBAAI94B,EAAWk0B,kBAIf,oBAAlBh1B,EAAP,MAAsC,GAAMA,K,cAANjB,W,aAAwBA,S,iBAoB/D,OArBMs7B,EAAiB,EAGvBT,EAAO/1B,QAAO,SACVm2B,GACAK,GACAv5B,EAAW+C,SAIT7E,EAA2BO,gBAAM+E,GAAK,GAAM,GAApC,SAAK+D,EAAS,IAAtB,YACNuxB,EAAOt1B,IAAMsE,iBAAM,OACfP,GAAS,CACZjE,MAAK,OACDiE,EAAUjE,OACTtD,EAAWw5B,uBAAyB,OAMK,qBAApCV,EAAO/1B,QAAuB,eACxC+1B,EAAO/1B,QAAUrE,OAAOsE,KAAK81B,EAAO/1B,SAASyL,QAAO,SAACC,EAAKmR,GAIzD,OAHIkZ,EAAO/1B,QAAQ6c,KAClBnR,EAAImR,GAAKkZ,EAAO/1B,QAAQ6c,IAElBnR,IAEL,IACH,GAAO,KAAKgrB,SAASX,EAAQM,KAI9B,GAAO,KAAKv7B,YAAYqC,MAAMgY,MAC7B,YACC,OAAOvO,EAAK+vB,QAAO,KAAMZ,GAAU3gB,EAAaihB,EAAe,CAC9Dx6B,OAAM,EACN0C,QAAO,IACLqX,OAAM,YACR,GAAItS,IAAUszB,iBAAiB94B,GAAQ,CAC9B,yBACF+4B,EAAa72B,IAAYA,EAAQ82B,MAAQ92B,EAAQ+U,MACjDgiB,EAAe,IAAIhiB,KAAK8hB,GACxBG,EAAc1zB,IAAU2zB,wBAC7BlB,EAAO/1B,QAAQ,eAGhB,GAAIsD,IAAU4zB,cAAcF,EAAaD,GAKxC,OAJAzzB,IAAU6zB,eACTJ,EAAaK,UAAYJ,EAAYI,WAG/BxwB,EAAKywB,KAAKzB,EAAcl1B,EAAQ9D,GAIzC,MAAMkB,QAGR,YAEC,OADAnD,EAAOK,MAAM,0DACN4L,EAAK8vB,SAASX,EAAQM,eAWhC55B,gBAAA,SAAIm5B,EAAgCh5B,GACnC,OAAO,KAAKy6B,KAAKzB,EAAc,MAAOh5B,IASvCH,gBAAA,SAAIm5B,EAAgCh5B,GACnC,OAAO,KAAKy6B,KAAKzB,EAAc,MAAOh5B,IASvCH,kBAAA,SAAMm5B,EAAgCh5B,GACrC,OAAO,KAAKy6B,KAAKzB,EAAc,QAASh5B,IASzCH,iBAAA,SAAKm5B,EAAgCh5B,GACpC,OAAO,KAAKy6B,KAAKzB,EAAc,OAAQh5B,IASxCH,gBAAA,SAAIm5B,EAAgCh5B,GACnC,OAAO,KAAKy6B,KAAKzB,EAAc,SAAUh5B,IAS1CH,iBAAA,SAAKm5B,EAAgCh5B,GACpC,OAAO,KAAKy6B,KAAKzB,EAAc,OAAQh5B,IAQxCH,mBAAA,SAAOuB,EAAuBR,GAC7B,IAAMylB,EAAS,KAAKyS,gBAAgBv4B,IAAIa,GAIxC,OAHIilB,GACHA,EAAOhlB,OAAOT,IAER,GAQRf,qBAAA,SAASqB,GACR,OAAOw5B,IAAMv5B,SAASD,IAOvBrB,gCAAA,WACC,OAAO66B,IAAMC,YAAYtU,UAQ1BxmB,yCAAA,SACC0J,EACAqxB,GAEA,KAAK9B,gBAAgBrvB,IAAIF,EAASqxB,IAQnC/6B,qBAAA,SAASC,GAAT,WACOwB,EAAoB,KAAKnD,SAASS,UACpC8C,EAAW,GAEf,OAAKvC,MAAMC,QAAQkC,IAInBA,EAAkBjC,SAAQ,YACrBuP,EAAEnP,OAASK,IACd4B,EAAWkN,EAAEtP,SACW,kBAAbsP,EAAE3P,OACZ+K,EAAK6wB,QAAUjsB,EAAE3P,OACyB,kBAAzB+K,EAAK7L,SAASc,SAC/B+K,EAAK6wB,QAAU7wB,EAAK7L,SAASc,QAEL,kBAAd2P,EAAEjN,QACZqI,EAAK8wB,SAAWlsB,EAAEjN,SAAW,cAE7BqI,EAAK8wB,SAAW,cAEc,oBAApBlsB,EAAErP,cACZyK,EAAK+wB,eAAiBnsB,EAAErP,cAExByK,EAAK+wB,oBAAiBr7B,MAIlBgC,GAvBCA,GA4BD7B,oBAAR,SAAgBs5B,EAAQ3gB,EAAaihB,EAAen7B,G,IAAEqD,YAAS1C,WAE7D,sBACA+7B,6BAGKC,EACLh8B,GAAU,KAAK47B,SAAW,KAAK18B,SAASc,OACnCi8B,EACLv5B,GAAW,KAAKm5B,UAAY,KAAK38B,SAASwD,QAErCiX,EAAQ,CACb5S,WAAYwS,EAAYC,gBACxBtR,WAAYqR,EAAYE,YACxB5R,cAAe0R,EAAYG,cAGtBN,EAAe,CACpBpZ,OAAQg8B,EACRt5B,QAASu5B,GAGJ3G,EAAoBx1B,OAAOC,OAChCqZ,EACA8iB,GAGKC,EAAgB50B,IAAOqS,KAAKmiB,EAAapiB,EAAO2b,GAUtD,OARI6G,EAAcl2B,OACjBk2B,EAAc3zB,KAAO2zB,EAAcl2B,MAGpCnH,EAAOK,MAAM,mBAAoBg9B,UAE1BA,EAAch4B,QAAc,KAE5Bs3B,IAAMU,GACX7iB,MAAK,YAAY,OAACkhB,EAAgB/3B,EAAWA,EAASwD,QACtD8T,OAAM,YAEN,MADAjb,EAAOK,MAAM8C,GACPA,MAIDrB,qBAAR,SAAiBs5B,EAAQM,GACxB,YADwB,QAAAA,MACjBiB,IAAMvB,GACX5gB,MAAK,YAAY,OAACkhB,EAAgB/3B,EAAWA,EAASwD,QACtD8T,OAAM,YAEN,MADAjb,EAAOK,MAAM8C,GACPA,MAIDrB,sBAAR,SAAkBgE,GACjB,IAAMw3B,EAAQx3B,EAAIM,MAAM,KAExB,MAAO,CACNkB,KAAMg2B,EAAM,GACZt7B,KAAM,IAAMs7B,EAAM91B,MAAM,GAAG9B,KAAK,OAGnC,EApYA,I,uFhCxCA63B,wB,6FiCAA,SACA,SAEA,SAEA,aAKE,WAAYC,GACV,GALe,UAAO,IAAIC,YAKtBD,EAAQ,CACV,KAAKE,MAAQ,IAAID,YACjB,IAAME,EA4DZ,SAA0BH,GACxB,IAAII,EAAQC,EAAgBL,GAE5B,GAAII,EAAME,WAAaC,aAAY,CACjC,IAAMC,EAAa,IAAIP,YACvBO,EAAWh5B,OAAO44B,GAClBA,EAAQI,EAAWC,SAGrB,IAAMC,EAAS,IAAI3G,WAAWwG,cAE9B,OADAG,EAAOxyB,IAAIkyB,GACJM,EAvEWC,CAAiBX,GACzBE,EAAQ,IAAInG,WAAWwG,cAC7BL,EAAMhyB,IAAIiyB,GAEV,IAAK,IAAI5uB,EAAI,EAAGA,EAAIgvB,aAAYhvB,IAC9B4uB,EAAM5uB,IAAM,GACZ2uB,EAAM3uB,IAAM,GAGd,KAAKjK,KAAKE,OAAO24B,GACjB,KAAKD,MAAM14B,OAAO04B,GAGlB,IAAS3uB,EAAI,EAAGA,EAAI4uB,EAAMG,WAAY/uB,IACpC4uB,EAAM5uB,GAAK,GA4CnB,OAvCEqvB,mBAAA,SAAOC,GACL,IAsDJ,SAAqBl3B,GACnB,GAAoB,kBAATA,EACT,OAAuB,IAAhBA,EAAKhB,OAGd,OAA2B,IAApBgB,EAAK22B,WA3DNQ,CAAYD,KAAW,KAAKl7B,MAIhC,IACE,KAAK2B,KAAKE,OAAO64B,EAAgBQ,IACjC,MAAO/3B,GACP,KAAKnD,MAAQmD,IAOjB83B,uBAAA,WACE,GAAI,KAAKj7B,MACP,MAAM,KAAKA,MAGb,OAAI,KAAKu6B,OACF,KAAKA,MAAMa,UACd,KAAKb,MAAM14B,OAAO,KAAKF,KAAKm5B,UAGvB,KAAKP,MAAMO,UAGb,KAAKn5B,KAAKm5B,UAQbG,mBAAN,W,yFACE,SAAO,KAAKn5B,qBAEhB,EAlEA,GA0FA,SAAS44B,EAAgB12B,GACvB,MAAoB,kBAATA,EACFq3B,WAASr3B,GAGds3B,YAAYC,OAAOv3B,GACd,IAAIowB,WACTpwB,EAAK+2B,OACL/2B,EAAKw3B,WACLx3B,EAAK22B,WAAavG,WAAWqH,mBAI1B,IAAIrH,WAAWpwB,GAvGXyvB,Y,kFCLb,aAWA,0BACU,WAAoBiI,WAAWlzB,KAAKoyB,QACpC,UAAmB,IAAIc,WAAW,IAClC,YAAqB,IAAItH,WAAW,IACpC,kBAAuB,EACvB,iBAAsB,EAK9B,eAAoB,EA8ItB,OA5IEuH,mBAAA,SAAO33B,GACL,GAAI,KAAKo3B,SACP,MAAM,IAAI/6B,MAAM,iDAGlB,IAAI+kB,EAAW,EACT,eAGN,GAFA,KAAKwW,aAAejB,EAEG,EAAnB,KAAKiB,YAAkBhB,sBACzB,MAAM,IAAIv6B,MAAM,uCAGlB,KAAOs6B,EAAa,GAClB,KAAKI,OAAO,KAAKc,gBAAkB73B,EAAKohB,KACxCuV,IAEI,KAAKkB,eAAiBjB,eACxB,KAAKkB,aACL,KAAKD,aAAe,IAK1BF,mBAAA,WACE,IAAK,KAAKP,SAAU,CAClB,IAAMW,EAAgC,EAAnB,KAAKH,YAClBI,EAAa,IAAIC,SACrB,KAAKlB,OAAOA,OACZ,KAAKA,OAAOS,WACZ,KAAKT,OAAOJ,YAGRuB,EAAoB,KAAKL,aAI/B,GAHAG,EAAWG,SAAS,KAAKN,eAAgB,KAGrCK,EAAoBtB,cAAcA,aAAa,EAAG,CACpD,IAAK,IAAIhvB,EAAI,KAAKiwB,aAAcjwB,EAAIgvB,aAAYhvB,IAC9CowB,EAAWG,SAASvwB,EAAG,GAEzB,KAAKkwB,aACL,KAAKD,aAAe,EAGtB,IAASjwB,EAAI,KAAKiwB,aAAcjwB,EAAIgvB,aAAa,EAAGhvB,IAClDowB,EAAWG,SAASvwB,EAAG,GAEzBowB,EAAWI,UACTxB,aAAa,EACbjH,KAAK0I,MAAMN,EAAa,aACxB,GAEFC,EAAWI,UAAUxB,aAAa,EAAGmB,GAErC,KAAKD,aAEL,KAAKV,UAAW,EAKlB,IAAMkB,EAAM,IAAIlI,WAAWwG,iBAC3B,IAAShvB,EAAI,EAAGA,EAAI,EAAGA,IACrB0wB,EAAQ,EAAJ1wB,GAAU,KAAK2wB,MAAM3wB,KAAO,GAAM,IACtC0wB,EAAQ,EAAJ1wB,EAAQ,GAAM,KAAK2wB,MAAM3wB,KAAO,GAAM,IAC1C0wB,EAAQ,EAAJ1wB,EAAQ,GAAM,KAAK2wB,MAAM3wB,KAAO,EAAK,IACzC0wB,EAAQ,EAAJ1wB,EAAQ,GAAM,KAAK2wB,MAAM3wB,KAAO,EAAK,IAG3C,OAAO0wB,GAGDX,uBAAR,WAYE,IAXM,IAAEZ,EAAF,KAAEA,OAAQwB,EAAV,KAAUA,MAEZC,EAASD,EAAM,GACjBE,EAASF,EAAM,GACfG,EAASH,EAAM,GACfI,EAASJ,EAAM,GACfK,EAASL,EAAM,GACfM,EAASN,EAAM,GACfO,EAASP,EAAM,GACfQ,EAASR,EAAM,GAER3wB,EAAI,EAAGA,EAAIgvB,aAAYhvB,IAAK,CACnC,GAAIA,EAAI,GACN,KAAKoxB,KAAKpxB,IACU,IAAhBmvB,EAAW,EAAJnvB,KAAkB,IACL,IAApBmvB,EAAW,EAAJnvB,EAAQ,KAAc,IACT,IAApBmvB,EAAW,EAAJnvB,EAAQ,KAAc,EACV,IAApBmvB,EAAW,EAAJnvB,EAAQ,OACb,CACL,IAAIqxB,EAAI,KAAKD,KAAKpxB,EAAI,GAChBsxB,GACFD,IAAM,GAAOA,GAAK,KAASA,IAAM,GAAOA,GAAK,IAAQA,IAAM,GAGzDE,IADNF,EAAI,KAAKD,KAAKpxB,EAAI,OAER,EAAMqxB,GAAK,KAASA,IAAM,GAAOA,GAAK,IAAQA,IAAM,EAE9D,KAAKD,KAAKpxB,IACNsxB,EAAK,KAAKF,KAAKpxB,EAAI,GAAM,IAAOuxB,EAAK,KAAKH,KAAKpxB,EAAI,IAAO,GAGhE,IAAMwxB,KACER,IAAW,EAAMA,GAAU,KAC7BA,IAAW,GAAOA,GAAU,KAC5BA,IAAW,GAAOA,GAAU,KAC5BA,EAASC,GAAYD,EAASE,GAChC,IACEC,GAAWnC,MAAIhvB,GAAK,KAAKoxB,KAAKpxB,GAAM,GAAM,GAC9C,EAEIyxB,IACAb,IAAW,EAAMA,GAAU,KAC3BA,IAAW,GAAOA,GAAU,KAC5BA,IAAW,GAAOA,GAAU,MAC5BA,EAASC,EAAWD,EAASE,EAAWD,EAASC,GACrD,EAEFK,EAASD,EACTA,EAASD,EACTA,EAASD,EACTA,EAAUD,EAASS,EAAM,EACzBT,EAASD,EACTA,EAASD,EACTA,EAASD,EACTA,EAAUY,EAAKC,EAAM,EAGvBd,EAAM,IAAMC,EACZD,EAAM,IAAME,EACZF,EAAM,IAAMG,EACZH,EAAM,IAAMI,EACZJ,EAAM,IAAMK,EACZL,EAAM,IAAMM,EACZN,EAAM,IAAMO,EACZP,EAAM,IAAMQ,GAEhB,EAxJA,GAAatJ,e,oBCXbM,EAAON,QAAUI,EAAQ,KAAuB1nB,Y,iCCOhD,SAASmxB,EAAgBC,EAAUC,GAAe,KAAMD,aAAoBC,GAAgB,MAAM,IAAIzQ,UAAU,qCAEhH,SAAS0Q,EAAkBC,EAAQC,GAAS,IAAK,IAAI/xB,EAAI,EAAGA,EAAI+xB,EAAM36B,OAAQ4I,IAAK,CAAE,IAAIgyB,EAAaD,EAAM/xB,GAAIgyB,EAAWnZ,WAAamZ,EAAWnZ,aAAc,EAAOmZ,EAAWlZ,cAAe,EAAU,UAAWkZ,IAAYA,EAAWjZ,UAAW,GAAM9mB,OAAO2mB,eAAekZ,EAAQE,EAAWn8B,IAAKm8B,IAE7S,SAASC,EAAaL,EAAaM,EAAYC,GAAmJ,OAAhID,GAAYL,EAAkBD,EAAYtZ,UAAW4Z,GAAiBC,GAAaN,EAAkBD,EAAaO,GAAqBP,EATzM3/B,OAAO2mB,eAAeiP,EAAS,aAAc,CAC3C5vB,OAAO,IAET4vB,EAAQtnB,gBAAa,EASrB,IAAI6xB,EAAa,WACf,MAAyB,oBAAXr1B,QAGZ6qB,EAAY,SAAUj1B,GACxB,OAAOy/B,KAAgB5gB,QAAQzU,OAAOpK,KAGpC0/B,EAAY,SAAU1/B,GACxB,OAAOi1B,EAAUj1B,GAAQoK,OAAOpK,GAAQ,KAAOA,GAG7Cy/B,MAAiBxK,EAAU,gBAC7B7qB,OAAOuQ,WAAavQ,OAAO,eAG7B,IAAIu1B,EAAiBD,EAAU,YAC3BE,EAAmBF,EAAU,cAC7BG,EAAgBH,EAAU,WAE9B,SAASI,EAAU9vB,EAAK9M,GACtB,IAAIoC,EAAQ0K,EAAI9M,GAChB,GAAa,MAAToC,EAAJ,CACA,GAAqB,oBAAVA,EAAsB,MAAM,IAAIkpB,UAAUlpB,EAAQ,sBAC7D,OAAOA,GAGT,SAASy6B,EAAW/vB,GAClB,IAAIgwB,EAAOhwB,EAAI0V,YAUf,YARazlB,IAAT+/B,GAGW,QAFbA,EAAOA,EAAKH,MAGVG,OAAO//B,QAIKA,IAAT+/B,EAAqBA,EAAOpyB,EAGrC,SAASqyB,EAAa7a,GACpB,OAAOA,aAAaxX,EAGtB,SAASsyB,EAAgBt7B,GACnBs7B,EAAgBC,IAClBD,EAAgBC,IAAIv7B,GAEpBuO,YAAW,WACT,MAAMvO,KAKZ,SAASw7B,EAAQC,GACfp/B,QAAQgL,UAAU6M,MAAK,WACrB,IACEunB,IACA,MAAOz7B,GACPs7B,EAAgBt7B,OAKtB,SAAS07B,EAAoBC,GAC3B,IAAIC,EAAUD,EAAaE,SAC3B,QAAgBxgC,IAAZugC,IACJD,EAAaE,cAAWxgC,EAEnBugC,GAIL,IACE,GAAuB,oBAAZA,EACTA,QACK,CACL,IAAIryB,EAAc2xB,EAAUU,EAAS,eAEjCryB,GACFA,EAAYkF,KAAKmtB,IAGrB,MAAO57B,GACPs7B,EAAgBt7B,IAIpB,SAAS87B,EAAkBH,GACzBA,EAAaI,eAAY1gC,EACzBsgC,EAAaK,YAAS3gC,EACtBsgC,EAAaM,OAAS,SAmBxB,SAASC,EAAmBP,EAAc9tB,EAAMnN,GAC9Ci7B,EAAaM,OAAS,UACtB,IAAI11B,EAAWo1B,EAAaI,UAE5B,IACE,IAAII,EAAIjB,EAAU30B,EAAUsH,GAE5B,OAAQA,GACN,IAAK,OACCsuB,GAAGA,EAAE1tB,KAAKlI,EAAU7F,GACxB,MAEF,IAAK,QAEH,GADAo7B,EAAkBH,IACdQ,EAAgC,MAAMz7B,EAAnCy7B,EAAE1tB,KAAKlI,EAAU7F,GACxB,MAEF,IAAK,WACHo7B,EAAkBH,GACdQ,GAAGA,EAAE1tB,KAAKlI,IAGlB,MAAOvG,GACPs7B,EAAgBt7B,GAGU,WAAxB27B,EAAaM,OAAqBP,EAAoBC,GAA+C,YAAxBA,EAAaM,SAAsBN,EAAaM,OAAS,SAG5I,SAASG,EAAST,EAAc9tB,EAAMnN,GACpC,GAA4B,WAAxBi7B,EAAaM,OAAjB,CAEA,GAA4B,cAAxBN,EAAaM,OASjB,MAA4B,UAAxBN,EAAaM,QACfN,EAAaM,OAAS,YACtBN,EAAaK,OAAS,CAAC,CACrBnuB,KAAMA,EACNnN,MAAOA,SAET86B,GAAQ,WACN,OAhEN,SAA2BG,GACzB,IAAIU,EAAQV,EAAaK,OAEzB,GAAKK,EAAL,CAIAV,EAAaK,YAAS3gC,EACtBsgC,EAAaM,OAAS,QAEtB,IAAK,IAAIxzB,EAAI,EAAGA,EAAI4zB,EAAMx8B,SACxBq8B,EAAmBP,EAAcU,EAAM5zB,GAAGoF,KAAMwuB,EAAM5zB,GAAG/H,OAC7B,WAAxBi7B,EAAaM,UAFiBxzB,KAsDzB6zB,CAAkBX,YAK7BO,EAAmBP,EAAc9tB,EAAMnN,GApBrCi7B,EAAaK,OAAOp1B,KAAK,CACvBiH,KAAMA,EACNnN,MAAOA,KAqBb,IAAI67B,EAEJ,WACE,SAASA,EAAah2B,EAAUi2B,GAC9BrC,EAAgBvY,KAAM2a,GAItB3a,KAAKia,cAAWxgC,EAChBumB,KAAKma,UAAYx1B,EACjBqb,KAAKoa,YAAS3gC,EACdumB,KAAKqa,OAAS,eACd,IAAIQ,EAAuB,IAAIC,EAAqB9a,MAEpD,IACEA,KAAKia,SAAWW,EAAW/tB,UAAKpT,EAAWohC,GAC3C,MAAOz8B,GACPy8B,EAAqB5/B,MAAMmD,GAGT,iBAAhB4hB,KAAKqa,SAA2Bra,KAAKqa,OAAS,SAkBpD,OAfAvB,EAAa6B,EAAc,CAAC,CAC1Bj+B,IAAK,cACLoC,MAAO,WACe,WAAhBkhB,KAAKqa,SACPH,EAAkBla,MAClB8Z,EAAoB9Z,SAGvB,CACDtjB,IAAK,SACLpC,IAAK,WACH,MAAuB,WAAhB0lB,KAAKqa,WAITM,EApCT,GAuCIG,EAEJ,WACE,SAASA,EAAqBf,GAC5BxB,EAAgBvY,KAAM8a,GAEtB9a,KAAK+a,cAAgBhB,EAyBvB,OAtBAjB,EAAagC,EAAsB,CAAC,CAClCp+B,IAAK,OACLoC,MAAO,SAAcA,GACnB07B,EAASxa,KAAK+a,cAAe,OAAQj8B,KAEtC,CACDpC,IAAK,QACLoC,MAAO,SAAeA,GACpB07B,EAASxa,KAAK+a,cAAe,QAASj8B,KAEvC,CACDpC,IAAK,WACLoC,MAAO,WACL07B,EAASxa,KAAK+a,cAAe,cAE9B,CACDr+B,IAAK,SACLpC,IAAK,WACH,MAAqC,WAA9B0lB,KAAK+a,cAAcV,WAIvBS,EA7BT,GAgCI1zB,EAEJ,WACE,SAASA,EAAWwzB,GAGlB,GAFArC,EAAgBvY,KAAM5Y,KAEhB4Y,gBAAgB5Y,GAAa,MAAM,IAAI4gB,UAAU,6CACvD,GAA0B,oBAAf4S,EAA2B,MAAM,IAAI5S,UAAU,6CAC1DhI,KAAKgb,YAAcJ,EAmVrB,OAhVA9B,EAAa1xB,EAAY,CAAC,CACxB1K,IAAK,YACLoC,MAAO,SAAmB6F,GASxB,MARwB,kBAAbA,GAAsC,OAAbA,IAClCA,EAAW,CACTwC,KAAMxC,EACN1J,MAAOme,UAAU,GACjBhQ,SAAUgQ,UAAU,KAIjB,IAAIuhB,EAAah2B,EAAUqb,KAAKgb,eAExC,CACDt+B,IAAK,UACLoC,MAAO,SAAiB+6B,GACtB,IAAI91B,EAAQic,KAEZ,OAAO,IAAIvlB,SAAQ,SAAUgL,EAAS/K,GACpC,GAAkB,oBAAPm/B,EAUX,IAAIE,EAAeh2B,EAAM0D,UAAU,CACjCN,KAAM,SAAUrI,GACd,IACE+6B,EAAG/6B,EAAOkyB,GACV,MAAO5yB,GACP1D,EAAO0D,GACP27B,EAAapyB,gBAGjB1M,MAAOP,EACP0O,SAAU3D,SAnBV/K,EAAO,IAAIstB,UAAU6R,EAAK,uBAI5B,SAAS7I,IACP+I,EAAapyB,cACblC,UAiBL,CACD/I,IAAK,MACLoC,MAAO,SAAa+6B,GAClB,IAAIoB,EAASjb,KAEb,GAAkB,oBAAP6Z,EAAmB,MAAM,IAAI7R,UAAU6R,EAAK,sBAEvD,OAAO,IADCN,EAAWvZ,MACZ,EAAM,SAAUrb,GACrB,OAAOs2B,EAAOxzB,UAAU,CACtBN,KAAM,SAAUrI,GACd,IACEA,EAAQ+6B,EAAG/6B,GACX,MAAOV,GACP,OAAOuG,EAAS1J,MAAMmD,GAGxBuG,EAASwC,KAAKrI,IAEhB7D,MAAO,SAAUmD,GACfuG,EAAS1J,MAAMmD,IAEjBgL,SAAU,WACRzE,EAASyE,mBAKhB,CACD1M,IAAK,SACLoC,MAAO,SAAgB+6B,GACrB,IAAIqB,EAASlb,KAEb,GAAkB,oBAAP6Z,EAAmB,MAAM,IAAI7R,UAAU6R,EAAK,sBAEvD,OAAO,IADCN,EAAWvZ,MACZ,EAAM,SAAUrb,GACrB,OAAOu2B,EAAOzzB,UAAU,CACtBN,KAAM,SAAUrI,GACd,IACE,IAAK+6B,EAAG/6B,GAAQ,OAChB,MAAOV,GACP,OAAOuG,EAAS1J,MAAMmD,GAGxBuG,EAASwC,KAAKrI,IAEhB7D,MAAO,SAAUmD,GACfuG,EAAS1J,MAAMmD,IAEjBgL,SAAU,WACRzE,EAASyE,mBAKhB,CACD1M,IAAK,SACLoC,MAAO,SAAgB+6B,GACrB,IAAIsB,EAASnb,KAEb,GAAkB,oBAAP6Z,EAAmB,MAAM,IAAI7R,UAAU6R,EAAK,sBACvD,IAAIuB,EAAI7B,EAAWvZ,MACfqb,EAAUjiB,UAAUnb,OAAS,EAC7Bq9B,GAAW,EACXC,EAAOniB,UAAU,GACjBvQ,EAAM0yB,EACV,OAAO,IAAIH,GAAE,SAAUz2B,GACrB,OAAOw2B,EAAO1zB,UAAU,CACtBN,KAAM,SAAUrI,GACd,IAAI08B,GAASF,EAGb,GAFAA,GAAW,GAENE,GAASH,EACZ,IACExyB,EAAMgxB,EAAGhxB,EAAK/J,GACd,MAAOV,GACP,OAAOuG,EAAS1J,MAAMmD,QAGxByK,EAAM/J,GAGV7D,MAAO,SAAUmD,GACfuG,EAAS1J,MAAMmD,IAEjBgL,SAAU,WACR,IAAKkyB,IAAaD,EAAS,OAAO12B,EAAS1J,MAAM,IAAI+sB,UAAU,oCAC/DrjB,EAASwC,KAAK0B,GACdlE,EAASyE,mBAKhB,CACD1M,IAAK,SACLoC,MAAO,WAGL,IAFA,IAAI28B,EAASzb,KAEJ0b,EAAOtiB,UAAUnb,OAAQ09B,EAAU,IAAIziC,MAAMwiC,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IAClFD,EAAQC,GAAQxiB,UAAUwiB,GAG5B,IAAIR,EAAI7B,EAAWvZ,MACnB,OAAO,IAAIob,GAAE,SAAUz2B,GACrB,IAAIo1B,EACAxgB,EAAQ,EAsBZ,OApBA,SAASsiB,EAAU10B,GACjB4yB,EAAe5yB,EAAKM,UAAU,CAC5BN,KAAM,SAAUwB,GACdhE,EAASwC,KAAKwB,IAEhB1N,MAAO,SAAUmD,GACfuG,EAAS1J,MAAMmD,IAEjBgL,SAAU,WACJmQ,IAAUoiB,EAAQ19B,QACpB87B,OAAetgC,EACfkL,EAASyE,YAETyyB,EAAUT,EAAE33B,KAAKk4B,EAAQpiB,UAMjCsiB,CAAUJ,GACH,WACD1B,IACFA,EAAapyB,cACboyB,OAAetgC,SAKtB,CACDiD,IAAK,UACLoC,MAAO,SAAiB+6B,GACtB,IAAIiC,EAAS9b,KAEb,GAAkB,oBAAP6Z,EAAmB,MAAM,IAAI7R,UAAU6R,EAAK,sBACvD,IAAIuB,EAAI7B,EAAWvZ,MACnB,OAAO,IAAIob,GAAE,SAAUz2B,GACrB,IAAIuP,EAAgB,GAEhBshB,EAAQsG,EAAOr0B,UAAU,CAC3BN,KAAM,SAAUrI,GACd,GAAI+6B,EACF,IACE/6B,EAAQ+6B,EAAG/6B,GACX,MAAOV,GACP,OAAOuG,EAAS1J,MAAMmD,GAI1B,IAAIq3B,EAAQ2F,EAAE33B,KAAK3E,GAAO2I,UAAU,CAClCN,KAAM,SAAUrI,GACd6F,EAASwC,KAAKrI,IAEhB7D,MAAO,SAAUmD,GACfuG,EAAS1J,MAAMmD,IAEjBgL,SAAU,WACR,IAAIvC,EAAIqN,EAAclL,QAAQysB,GAC1B5uB,GAAK,GAAGqN,EAAcoG,OAAOzT,EAAG,GACpCk1B,OAGJ7nB,EAAclP,KAAKywB,IAErBx6B,MAAO,SAAUmD,GACfuG,EAAS1J,MAAMmD,IAEjBgL,SAAU,WACR2yB,OAIJ,SAASA,IACHvG,EAAMptB,QAAmC,IAAzB8L,EAAcjW,QAAc0G,EAASyE,WAG3D,OAAO,WACL8K,EAAc9a,SAAQ,SAAU4iC,GAC9B,OAAOA,EAAEr0B,iBAEX6tB,EAAM7tB,oBAIX,CACDjL,IAAK08B,EACLt6B,MAAO,WACL,OAAOkhB,QAEP,CAAC,CACHtjB,IAAK,OACLoC,MAAO,SAAc8f,GACnB,IAAIwc,EAAoB,oBAATpb,KAAsBA,KAAO5Y,EAC5C,GAAS,MAALwX,EAAW,MAAM,IAAIoJ,UAAUpJ,EAAI,qBACvC,IAAI/gB,EAASy7B,EAAU1a,EAAGwa,GAE1B,GAAIv7B,EAAQ,CACV,IAAIsW,EAAatW,EAAOgP,KAAK+R,GAC7B,GAAI9lB,OAAOqb,KAAgBA,EAAY,MAAM,IAAI6T,UAAU7T,EAAa,qBACxE,OAAIslB,EAAatlB,IAAeA,EAAW+K,cAAgBkc,EAAUjnB,EAC9D,IAAIinB,GAAE,SAAUz2B,GACrB,OAAOwP,EAAW1M,UAAU9C,MAIhC,GAAI8pB,EAAU,cACZ5wB,EAASy7B,EAAU1a,EAAGua,IAGpB,OAAO,IAAIiC,GAAE,SAAUz2B,GACrBi1B,GAAQ,WACN,IAAIj1B,EAASyD,OAAb,CACA,IAAI8pB,GAA4B,EAC5BC,GAAoB,EACpBC,OAAiB34B,EAErB,IACE,IAAK,IAAmD44B,EAA/CC,EAAYz0B,EAAOgP,KAAK+R,GAAGhb,OAAOqb,cAAsBiT,GAA6BG,EAAQC,EAAUnrB,QAAQ6pB,MAAOkB,GAA4B,EAAM,CAC/J,IAAI+J,EAAQ5J,EAAMvzB,MAElB,GADA6F,EAASwC,KAAK80B,GACVt3B,EAASyD,OAAQ,QAEvB,MAAO5N,GACP23B,GAAoB,EACpBC,EAAiB53B,EACjB,QACA,IACO03B,GAAiD,MAApBI,EAAUnB,QAC1CmB,EAAUnB,SAEZ,QACA,GAAIgB,EACF,MAAMC,GAKZztB,EAASyE,kBAMjB,GAAIlQ,MAAMC,QAAQylB,GAChB,OAAO,IAAIwc,GAAE,SAAUz2B,GACrBi1B,GAAQ,WACN,IAAIj1B,EAASyD,OAAb,CAEA,IAAK,IAAIvB,EAAI,EAAGA,EAAI+X,EAAE3gB,SAAU4I,EAE9B,GADAlC,EAASwC,KAAKyX,EAAE/X,IACZlC,EAASyD,OAAQ,OAGvBzD,EAASyE,kBAKf,MAAM,IAAI4e,UAAUpJ,EAAI,wBAEzB,CACDliB,IAAK,KACLoC,MAAO,WACL,IAAK,IAAIo9B,EAAQ9iB,UAAUnb,OAAQk+B,EAAQ,IAAIjjC,MAAMgjC,GAAQE,EAAQ,EAAGA,EAAQF,EAAOE,IACrFD,EAAMC,GAAShjB,UAAUgjB,GAG3B,IAAIhB,EAAoB,oBAATpb,KAAsBA,KAAO5Y,EAC5C,OAAO,IAAIg0B,GAAE,SAAUz2B,GACrBi1B,GAAQ,WACN,IAAIj1B,EAASyD,OAAb,CAEA,IAAK,IAAIvB,EAAI,EAAGA,EAAIs1B,EAAMl+B,SAAU4I,EAElC,GADAlC,EAASwC,KAAKg1B,EAAMt1B,IAChBlC,EAASyD,OAAQ,OAGvBzD,EAASyE,oBAId,CACD1M,IAAK28B,EACL/+B,IAAK,WACH,OAAO0lB,SAIJ5Y,EAzVT,GA4VAsnB,EAAQtnB,WAAaA,EAEjB6xB,KACFngC,OAAO2mB,eAAerY,EAAYxD,OAAO,cAAe,CACtD9E,MAAO,CACLu9B,OAAQjD,EACRM,gBAAiBA,GAEnB/Z,cAAc,K,qBCtmBlB,YAmFA,IAA8B2c,IAarB,WAyvER,OAtvEgB,SAAUC,GAI1B,IAKIC,EAAeD,EAAOC,cAAiB,WAC1C,IAAIv9B,EAAO,GAEX,MAAO,CACNw9B,QAAS,SAAU//B,EAAKsC,GAAQC,EAAKvC,GAAOsC,GAC5C4S,QAAS,SAAUlV,GAAO,OAAOuC,EAAKvC,IACtCggC,WAAY,SAAUhgC,UAAcuC,EAAKvC,KANA,GAetCigC,EACM,EADNA,EAEM,EAFNA,EAGM,EAHNA,EAIK,EAJLA,EAKK,EALLA,EAMK,EANLA,EAOM,EAPNA,EAQQ,EARRA,EASK,EATLA,EAUU,GAVVA,EAWO,GAXPA,EAYM,GAZNA,EAaO,GAbPA,EAcS,GAgBTC,EAAW,SAASpzB,EAAKpM,GAC5B,IAAK,IAAIV,KAAO8M,EACf,GAAIA,EAAIyQ,eAAevd,GAAM,CAC5B,IAAIU,EAAK6c,eAAevd,GAGjB,CACN,IAAImgC,EAAW,qBAAuBngC,EAAM,0BAC5C,IAAK,IAAIogC,KAAY1/B,EAChBA,EAAK6c,eAAe6iB,KACvBD,EAAWA,EAAS,IAAIC,GAC1B,MAAM,IAAIxhC,MAAMuhC,GAPhB,UAAWrzB,EAAI9M,KAASU,EAAKV,GAC5B,MAAM,IAAIpB,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQxzB,EAAI9M,GAAMA,OAoB9DmD,EAAQ,SAAUo9B,EAAGp9B,GACxB,OAAO,WACN,OAAOo9B,EAAEC,MAAMr9B,EAAOuZ,aASpB2jB,EAAQ,CACXI,GAAI,CAACha,KAAK,EAAGia,KAAK,mBAClBC,gBAAiB,CAACla,KAAK,EAAGia,KAAK,kCAC/BE,kBAAmB,CAACna,KAAK,EAAGia,KAAK,mCACjCG,oBAAqB,CAACpa,KAAK,EAAGia,KAAK,qCACnCI,aAAc,CAACra,KAAK,EAAGia,KAAK,8BAC5BK,eAAgB,CAACta,KAAK,EAAGia,KAAK,mEAC9BM,mBAAoB,CAACva,KAAK,EAAGia,KAAK,+CAClCO,aAAc,CAACxa,KAAK,EAAGia,KAAK,gCAC5BQ,aAAc,CAACza,KAAK,EAAGia,KAAK,6BAC5BS,cAAe,CAAC1a,KAAK,EAAGia,KAAK,8CAC7BU,YAAa,CAAC3a,KAAK,GAAIia,KAAK,oDAC5BW,cAAe,CAAC5a,KAAK,GAAIia,KAAK,iCAC9BJ,aAAc,CAAC7Z,KAAK,GAAIia,KAAK,wCAC7BY,iBAAkB,CAAC7a,KAAK,GAAIia,KAAK,4CACjCa,sBAAuB,CAAC9a,KAAK,GAAIia,KAAK,qCACtCc,oBAAqB,CAAC/a,KAAK,GAAIia,KAAK,+DACpCe,0BAA2B,CAAChb,KAAK,GAAIia,KAAK,6CAC1CgB,kBAAmB,CAACjb,KAAK,GAAIia,KAAK,gDAClCiB,YAAa,CAAClb,KAAK,GAAIia,KAAK,iEAIzBkB,EAAa,CAChBC,EAAE,sBACFC,EAAE,oDACFC,EAAE,0CACFC,EAAE,yCACFC,EAAE,gDACFC,EAAE,sCAUC18B,EAAS,SAASjH,EAAO4jC,GAC5B,IAAIzB,EAAOniC,EAAMmiC,KACjB,GAAIyB,EAEH,IADA,IAAIC,EAAM1qB,EACDvN,EAAE,EAAGA,EAAEg4B,EAAc5gC,OAAQ4I,IAGrC,GAFAi4B,EAAQ,IAAIj4B,EAAE,KACduN,EAAQgpB,EAAKp0B,QAAQ81B,IACV,EAAG,CACb,IAAIC,EAAQ3B,EAAK4B,UAAU,EAAE5qB,GACzB6qB,EAAQ7B,EAAK4B,UAAU5qB,EAAM0qB,EAAM7gC,QACvCm/B,EAAO2B,EAAMF,EAAch4B,GAAGo4B,EAIjC,OAAO7B,GAIJ8B,EAAwB,CAAC,EAAK,EAAK,GAAK,GAAK,GAAK,IAAK,IAAK,IAAK,GAEjEC,EAAwB,CAAC,EAAK,EAAK,GAAK,GAAK,GAAK,GAAK,GA0BvDC,EAAc,SAAUnzB,EAAMjU,GAEjC,IAAK,IAAIwB,KADTwmB,KAAK/T,KAAOA,EACKjU,EACZA,EAAQiiB,eAAezgB,KAC1BwmB,KAAKxmB,GAAQxB,EAAQwB,KA+LxB,SAAS6lC,EAAc3J,EAAMlS,GAC5B,IASI8b,EATAC,EAAc/b,EACdgY,EAAQ9F,EAAMlS,GACdvX,EAAOuvB,GAAS,EAChBgE,EAAchE,GAAS,GAC3BhY,GAAO,EAMP,IAAIic,EAAY,EACZC,EAAa,EACjB,EAAG,CACF,GAAIlc,GAAOkS,EAAMz3B,OAChB,MAAO,CAAC,KAAKshC,GAGdE,IAAuB,KADvBH,EAAQ5J,EAAMlS,OACiBkc,EAC/BA,GAAc,UACa,KAAV,IAARJ,IAEV,IAAIK,EAASnc,EAAIic,EACjB,GAAIE,EAASjK,EAAMz3B,OAClB,MAAO,CAAC,KAAKshC,GAGd,IAAIK,EAAc,IAAIR,EAAYnzB,GAClC,OAAOA,GACP,KAAK0wB,EAE0B,EADAjH,EAAMlS,OAEnCoc,EAAYC,gBAAiB,GAC9BD,EAAYE,WAAapK,EAAMlS,KAC/B,MAED,KAAKmZ,EACJ,IAAIoD,EAAOP,GAAe,EAAK,EAE3BnO,EAAM2O,EAAWtK,EAAOlS,GAExByc,EAAYC,EAAUxK,EAD1BlS,GAAO,EAC+B6N,GACtC7N,GAAO6N,EAEH0O,EAAM,IACTH,EAAYO,kBAAoBH,EAAWtK,EAAOlS,GAClDA,GAAO,GAGR,IAAI7oB,EAAU,IAAIylC,EAAQ1K,EAAM2K,SAAS7c,EAAKmc,IAClB,IAAT,EAAdH,KACJ7kC,EAAQ2lC,UAAW,GACQ,IAAT,EAAdd,KACJ7kC,EAAQ4lC,WAAa,GACtB5lC,EAAQolC,IAAMA,EACdplC,EAAQ6lC,gBAAkBP,EAC1BL,EAAYa,eAAiB9lC,EAC7B,MAED,KAAMgiC,EACN,KAAMA,EACN,KAAMA,EACN,KAAMA,EACN,KAAMA,EACLiD,EAAYO,kBAAoBH,EAAWtK,EAAOlS,GAClD,MAED,KAAMmZ,EACLiD,EAAYO,kBAAoBH,EAAWtK,EAAOlS,GAClDA,GAAO,EACPoc,EAAYE,WAAapK,EAAM2K,SAAS7c,EAAKmc,GAO9C,MAAO,CAACC,EAAYD,GAGrB,SAASe,EAAYhL,EAAOM,EAAQrG,GAGnC,OAFAqG,EAAOrG,KAAY+F,GAAS,EAC5BM,EAAOrG,KAAY+F,EAAQ,IACpB/F,EAGR,SAASgR,EAAYjL,EAAOkL,EAAY5K,EAAQrG,GAG/C,OADAkR,EAAanL,EAAOM,EADpBrG,EAAS+Q,EAAYE,EAAY5K,EAAQrG,IAElCA,EAASiR,EAGjB,SAASZ,EAAWhK,EAAQrG,GAC3B,OAAO,IAAIqG,EAAOrG,GAAUqG,EAAOrG,EAAO,GA2B3C,SAASmR,EAAWpL,GAEnB,IADA,IAAIqL,EAAS,EACJl6B,EAAI,EAAGA,EAAE6uB,EAAMz3B,OAAQ4I,IAChC,CACC,IAAIwd,EAAWqR,EAAMn3B,WAAWsI,GAC5Bwd,EAAW,MAGV,OAAUA,GAAYA,GAAY,QAErCxd,IACAk6B,KAEDA,GAAS,GAED1c,EAAW,IACnB0c,GAAS,EAETA,IAEF,OAAOA,EAOR,SAASF,EAAanL,EAAOqL,EAAQ3sB,GAEpC,IADA,IAAIoP,EAAMpP,EACDvN,EAAI,EAAGA,EAAE6uB,EAAMz3B,OAAQ4I,IAAK,CACpC,IAAIwd,EAAWqR,EAAMn3B,WAAWsI,GAGhC,GAAI,OAAUwd,GAAYA,GAAY,MAAQ,CAC7C,IAAI2c,EAActL,EAAMn3B,aAAasI,GACrC,GAAIuc,MAAM4d,GACT,MAAM,IAAI1lC,MAAM4G,EAAO66B,EAAMqB,kBAAmB,CAAC/Z,EAAU2c,KAE5D3c,EAAwC2c,EAAc,OAAzC3c,EAAW,OAAS,IAA+B,MAI7DA,GAAY,IACf0c,EAAOvd,KAASa,EACNA,GAAY,MACtB0c,EAAOvd,KAASa,GAAU,EAAK,GAAO,IACtC0c,EAAOvd,KAAwB,GAAfa,EAAsB,KAC5BA,GAAY,OACtB0c,EAAOvd,KAASa,GAAU,GAAK,GAAO,IACtC0c,EAAOvd,KAASa,GAAU,EAAK,GAAO,IACtC0c,EAAOvd,KAAwB,GAAfa,EAAsB,MAEtC0c,EAAOvd,KAASa,GAAU,GAAK,EAAO,IACtC0c,EAAOvd,KAASa,GAAU,GAAK,GAAO,IACtC0c,EAAOvd,KAASa,GAAU,EAAK,GAAO,IACtC0c,EAAOvd,KAAwB,GAAfa,EAAsB,KAGxC,OAAO0c,EAGR,SAASb,EAAUxK,EAAO/F,EAAQ1xB,GAKjC,IAJA,IACIgjC,EADAF,EAAS,GAETvd,EAAMmM,EAEHnM,EAAMmM,EAAO1xB,GACpB,CACC,IAAIijC,EAAQxL,EAAMlS,KAClB,GAAI0d,EAAQ,IACXD,EAAQC,MAET,CACC,IAAIC,EAAQzL,EAAMlS,KAAO,IACzB,GAAI2d,EAAQ,EACX,MAAM,IAAI7lC,MAAM4G,EAAO66B,EAAMc,cAAe,CAACqD,EAAM1iC,SAAS,IAAK2iC,EAAM3iC,SAAS,IAAI,MACrF,GAAI0iC,EAAQ,IACXD,EAAQ,IAAIC,EAAM,KAAQC,MAE3B,CACC,IAAIC,EAAQ1L,EAAMlS,KAAO,IACzB,GAAI4d,EAAQ,EACX,MAAM,IAAI9lC,MAAM4G,EAAO66B,EAAMc,cAAe,CAACqD,EAAM1iC,SAAS,IAAK2iC,EAAM3iC,SAAS,IAAK4iC,EAAM5iC,SAAS,OACrG,GAAI0iC,EAAQ,IACXD,EAAQ,MAAMC,EAAM,KAAQ,GAAGC,EAAQC,MAExC,CACC,IAAIC,EAAQ3L,EAAMlS,KAAO,IACzB,GAAI6d,EAAQ,EACX,MAAM,IAAI/lC,MAAM4G,EAAO66B,EAAMc,cAAe,CAACqD,EAAM1iC,SAAS,IAAK2iC,EAAM3iC,SAAS,IAAK4iC,EAAM5iC,SAAS,IAAK6iC,EAAM7iC,SAAS,OACzH,KAAI0iC,EAAQ,KAGX,MAAM,IAAI5lC,MAAM4G,EAAO66B,EAAMc,cAAe,CAACqD,EAAM1iC,SAAS,IAAK2iC,EAAM3iC,SAAS,IAAK4iC,EAAM5iC,SAAS,IAAK6iC,EAAM7iC,SAAS,OAFxHyiC,EAAQ,QAAQC,EAAM,KAAQ,KAAKC,EAAQ,GAAGC,EAAQC,IAOtDJ,EAAQ,QAEXA,GAAS,MACTF,GAAU1hB,OAAOgE,aAAa,OAAU4d,GAAS,KACjDA,EAAQ,OAAkB,KAARA,IAEnBF,GAAU1hB,OAAOgE,aAAa4d,GAE/B,OAAOF,EA5ZR3B,EAAYjgB,UAAUmiB,OAAS,WAE9B,IAUIC,EAVA/F,GAAsB,GAAZxb,KAAK/T,OAAgB,EAO/BwzB,EAAY,EACZ+B,EAAiB,GACjBC,EAAwB,EAO5B,YAH+BhoC,IAA3BumB,KAAKmgB,oBACRV,GAAa,GAEPzf,KAAK/T,MAEZ,KAAK0wB,EACJ,OAAO3c,KAAKna,aACZ,KAAK,EACJ45B,GAAaP,EAAsBjhC,OAAS,EAC5C,MACD,KAAK,EACJwhC,GAAaN,EAAsBlhC,OAAS,EAI7CwhC,GAAaqB,EAAW9gB,KAAK5c,UAAY,OAChB3J,IAArBumB,KAAK0hB,cACRjC,GAAaqB,EAAW9gB,KAAK0hB,YAAYlB,iBAAmB,GAE5De,EAA0BvhB,KAAK0hB,YAAYC,wBACFtS,aACxCkS,EAA0B,IAAIlS,WAAWsS,IAC1ClC,GAAa8B,EAAwB3L,WAAY,QAE5Bn8B,IAAlBumB,KAAK4hB,WACRnC,GAAaqB,EAAW9gB,KAAK4hB,UAAY,QACpBnoC,IAAlBumB,KAAK6hB,WACRpC,GAAaqB,EAAW9gB,KAAK6hB,UAAY,GAC1C,MAGD,KAAKlF,EACJnB,GAAS,EACT,IAAM,IAAI30B,EAAI,EAAGA,EAAImZ,KAAK3Z,OAAOpI,OAAQ4I,IACxC26B,EAAe36B,GAAKi6B,EAAW9gB,KAAK3Z,OAAOQ,IAC3C44B,GAAa+B,EAAe36B,GAAK,EAElC44B,GAAazf,KAAK8hB,aAAa7jC,OAE/B,MAED,KAAK0+B,EAEJ,IADAnB,GAAS,EACC30B,EAAI,EAAGA,EAAImZ,KAAK3Z,OAAOpI,OAAQ4I,IACxC26B,EAAe36B,GAAKi6B,EAAW9gB,KAAK3Z,OAAOQ,IAC3C44B,GAAa+B,EAAe36B,GAAK,EAElC,MAED,KAAK81B,EACJnB,GAAS,EACT,MAED,KAAKmB,EACA3c,KAAKygB,eAAeF,YAAW/E,GAAS,GAC5CA,EAASA,GAAUxb,KAAKygB,eAAeV,KAAO,EAC1C/f,KAAKygB,eAAeH,WAAU9E,GAAS,GAE3CiE,IADAgC,EAAwBX,EAAW9gB,KAAKygB,eAAeD,kBAClB,EACrC,IAAImB,EAAe3hB,KAAKygB,eAAekB,aACvClC,GAAakC,EAAa/L,WACtB+L,aAAwBpL,YAC3BoL,EAAe,IAAItS,WAAWsS,GACpBA,aAAwBtS,aAClCsS,EAAe,IAAItS,WAAWsS,EAAa3L,SAY7C,IAAI+L,EAmML,SAAmBC,GAClB,IAAIjB,EAAS,IAAI7nC,MAAM,GACnB+oC,EAAW,EAEf,EAAG,CACF,IAAI3C,EAAQ0C,EAAS,KACrBA,IAAmB,GACN,IACZ1C,GAAS,KAEVyB,EAAOkB,KAAc3C,QACX0C,EAAS,GAAOC,EAAS,GAEpC,OAAOlB,EAhNGmB,CAAUzC,GAChBjc,EAAMue,EAAI9jC,OAAS,EACnB+3B,EAAS,IAAIO,YAAYkJ,EAAYjc,GACrC2e,EAAa,IAAI9S,WAAW2G,GAOhC,GAJAmM,EAAW,GAAK3G,EAChB2G,EAAW3+B,IAAIu+B,EAAI,GAGf/hB,KAAK/T,MAAQ0wB,EAChBnZ,EAAMmd,EAAY3gB,KAAKygB,eAAeD,gBAAiBiB,EAAuBU,EAAY3e,QAGtF,GAAIxD,KAAK/T,MAAQ0wB,EAAsB,CAC3C,OAAQ3c,KAAKna,aACb,KAAK,EACJs8B,EAAW3+B,IAAI07B,EAAuB1b,GACtCA,GAAO0b,EAAsBjhC,OAC7B,MACD,KAAK,EACJkkC,EAAW3+B,IAAI27B,EAAuB3b,GACtCA,GAAO2b,EAAsBlhC,OAG9B,IAAImkC,EAAe,EACfpiB,KAAKqiB,eACRD,EAAe,QACS3oC,IAArBumB,KAAK0hB,cACRU,GAAgB,EAChBA,GAAiBpiB,KAAK0hB,YAAY3B,KAAK,EACnC/f,KAAK0hB,YAAYpB,WACpB8B,GAAgB,UAGI3oC,IAAlBumB,KAAK4hB,WACRQ,GAAgB,UACK3oC,IAAlBumB,KAAK6hB,WACRO,GAAgB,IACjBD,EAAW3e,KAAS4e,EACpB5e,EAAMkd,EAAa1gB,KAAKsiB,kBAAmBH,EAAY3e,GAOxD,YAH+B/pB,IAA3BumB,KAAKmgB,oBACR3c,EAAMkd,EAAa1gB,KAAKmgB,kBAAmBgC,EAAY3e,IAEjDxD,KAAK/T,MACZ,KAAK0wB,EACJnZ,EAAMmd,EAAY3gB,KAAK5c,SAAU09B,EAAW9gB,KAAK5c,UAAW++B,EAAY3e,QAC/C/pB,IAArBumB,KAAK0hB,cACRle,EAAMmd,EAAY3gB,KAAK0hB,YAAYlB,gBAAiBM,EAAW9gB,KAAK0hB,YAAYlB,iBAAkB2B,EAAY3e,GAC9GA,EAAMkd,EAAYa,EAAwB3L,WAAYuM,EAAY3e,GAClE2e,EAAW3+B,IAAI+9B,EAAyB/d,GACxCA,GAAO+d,EAAwB3L,iBAGVn8B,IAAlBumB,KAAK4hB,WACRpe,EAAMmd,EAAY3gB,KAAK4hB,SAAUd,EAAW9gB,KAAK4hB,UAAWO,EAAY3e,SACnD/pB,IAAlBumB,KAAK6hB,WACRre,EAAMmd,EAAY3gB,KAAK6hB,SAAUf,EAAW9gB,KAAK6hB,UAAWM,EAAY3e,IACzE,MAED,KAAKmZ,EAEJwF,EAAW3+B,IAAIm+B,EAAcne,GAE7B,MAOD,KAAKmZ,EAEJ,IAAS91B,EAAE,EAAGA,EAAEmZ,KAAK3Z,OAAOpI,OAAQ4I,IACnC2c,EAAMmd,EAAY3gB,KAAK3Z,OAAOQ,GAAI26B,EAAe36B,GAAIs7B,EAAY3e,GACjE2e,EAAW3e,KAASxD,KAAK8hB,aAAaj7B,GAEvC,MAED,KAAK81B,EAEJ,IAAS91B,EAAE,EAAGA,EAAEmZ,KAAK3Z,OAAOpI,OAAQ4I,IACnC2c,EAAMmd,EAAY3gB,KAAK3Z,OAAOQ,GAAI26B,EAAe36B,GAAIs7B,EAAY3e,GAOnE,OAAOwS,GA4OR,IAAIuM,EAAS,SAASr9B,EAAQo9B,GAC7BtiB,KAAKwiB,QAAUt9B,EACf8a,KAAKyiB,mBAAuC,IAAlBH,EAC1BtiB,KAAK0iB,SAAU,EAEf,IAAIC,EAAU,IAAIvD,EAAYzC,GAAsB2E,SAEhDsB,EAAY,SAAUC,GACzB,OAAO,WACN,OAAOC,EAAO5F,MAAM2F,KAKlBC,EAAS,WACP9iB,KAAK0iB,SAIT1iB,KAAK0iB,SAAU,EACf1iB,KAAKwiB,QAAQO,OAAO,gBAAiB,gBACrC/iB,KAAKwiB,QAAQQ,OAAOx8B,KAAKm8B,GACzB3iB,KAAKoT,QAAUzmB,WAAWi2B,EAAU5iB,MAAOA,KAAKyiB,sBANhDziB,KAAKwiB,QAAQO,OAAO,gBAAiB,aACrC/iB,KAAKwiB,QAAQS,cAAelG,EAAMS,aAAara,KAAOjhB,EAAO66B,EAAMS,iBASrExd,KAAKkjB,MAAQ,WACZljB,KAAK0iB,SAAU,EACf/0B,aAAaqS,KAAKoT,SACdpT,KAAKyiB,mBAAqB,IAC7BziB,KAAKoT,QAAUzmB,WAAWi2B,EAAU5iB,MAAOA,KAAKyiB,sBAGlDziB,KAAK5kB,OAAS,WACbuS,aAAaqS,KAAKoT,WAQhB+P,EAAU,SAASj+B,EAAQk+B,EAAgBC,EAAQ/+B,GACjD8+B,IACJA,EAAiB,IAOlBpjB,KAAKoT,QAAUzmB,WALC,SAAU02B,EAAQn+B,EAAQZ,GACzC,OAAO,WACN,OAAO++B,EAAOnG,MAAMh4B,EAAQZ,IAGJs+B,CAAUS,EAAQn+B,EAAQZ,GAAwB,IAAjB8+B,GAE3DpjB,KAAK5kB,OAAS,WACbuS,aAAaqS,KAAKoT,WAYhBkQ,EAAa,SAAUC,EAAKnkC,EAAMoD,EAAM1I,EAAMsJ,GAEjD,KAAM,cAAem5B,IAA+B,OAArBA,EAAOrvB,UACrC,MAAM,IAAI5R,MAAM4G,EAAO66B,EAAMe,YAAa,CAAC,eAE5C,KAAM,gBAAiBvB,IAAiC,OAAvBA,EAAOhG,YACvC,MAAM,IAAIj7B,MAAM4G,EAAO66B,EAAMe,YAAa,CAAC,iBA2C5C,IAAK,IAAIphC,KAzCTsjB,KAAK+iB,OAAO,cAAeQ,EAAKnkC,EAAMoD,EAAM1I,EAAMsJ,GAElD4c,KAAK5gB,KAAOA,EACZ4gB,KAAKxd,KAAOA,EACZwd,KAAKlmB,KAAOA,EACZkmB,KAAKujB,IAAMA,EACXvjB,KAAK5c,SAAWA,EAChB4c,KAAKwjB,OAAS,KAMdxjB,KAAKyjB,UAAUrkC,EAAK,IAAIoD,GAAY,SAAN1I,EAAc,IAAIA,EAAK,IAAI,IAAIsJ,EAAS,IAItE4c,KAAK0jB,WAAa,GAClB1jB,KAAK2jB,oBAAsB,GAG3B3jB,KAAK4jB,cAAgB,GAIrB5jB,KAAK6jB,kBAAoB,GAKzB7jB,KAAK8jB,iBAAmB,GAIxB9jB,KAAK+jB,oBAAsB,EAG3B/jB,KAAKgkB,UAAY,EAIDxH,EACgC,IAAxC9/B,EAAIsM,QAAQ,QAAQgX,KAAKyjB,YAAgE,IAA5C/mC,EAAIsM,QAAQ,YAAYgX,KAAKyjB,YAChFzjB,KAAKikB,QAAQvnC,IAIhB4mC,EAAWnkB,UAAU/f,KAAO,KAC5BkkC,EAAWnkB,UAAU3c,KAAO,KAC5B8gC,EAAWnkB,UAAUrlB,KAAO,KAC5BwpC,EAAWnkB,UAAUokB,IAAM,KAC3BD,EAAWnkB,UAAU/b,SAAW,KAGhCkgC,EAAWnkB,UAAU6jB,OAAS,KAE9BM,EAAWnkB,UAAU+kB,WAAY,EAIjCZ,EAAWnkB,UAAUglB,qBAAuB,MAC5Cb,EAAWnkB,UAAUilB,eAAiB,KACtCd,EAAWnkB,UAAUklB,UAAY,KACjCf,EAAWnkB,UAAUmlB,YAAc,KACnChB,EAAWnkB,UAAU5Z,iBAAmB,KACxC+9B,EAAWnkB,UAAUolB,mBAAqB,KAC1CjB,EAAWnkB,UAAU/Z,iBAAmB,KACxCk+B,EAAWnkB,UAAUqlB,cAAgB,KACrClB,EAAWnkB,UAAUukB,WAAa,KAClCJ,EAAWnkB,UAAUwkB,oBAAsB,KAC3CL,EAAWnkB,UAAUslB,gBAAkB,KAEvCnB,EAAWnkB,UAAUulB,WAAa,KAElCpB,EAAWnkB,UAAUwlB,cAAgB,KACrCrB,EAAWnkB,UAAUylB,mBAAqB,EAC1CtB,EAAWnkB,UAAU0lB,eAAgB,EACrCvB,EAAWnkB,UAAU2lB,kBAAoB,KACzCxB,EAAWnkB,UAAU4lB,wBAAyB,EAC9CzB,EAAWnkB,UAAU6lB,uBAAyB,IAE9C1B,EAAWnkB,UAAU8lB,cAAgB,KAErC3B,EAAWnkB,UAAU+lB,aAAe,KACpC5B,EAAWnkB,UAAUgmB,mBAAqB,IAE1C7B,EAAWnkB,UAAUzZ,QAAU,SAAU0+B,GACxC,IAAIgB,EAAuBplB,KAAKqlB,WAAWjB,EAAgB,YAG3D,GAFApkB,KAAK+iB,OAAO,iBAAkBqC,EAAsBplB,KAAKgjB,OAAQhjB,KAAKkkB,WAElElkB,KAAKkkB,UACR,MAAM,IAAI5oC,MAAM4G,EAAO66B,EAAMgB,cAAe,CAAC,uBAC9C,GAAI/d,KAAKgjB,OACR,MAAM,IAAI1nC,MAAM4G,EAAO66B,EAAMgB,cAAe,CAAC,uBAE1C/d,KAAK6kB,gBAGR7kB,KAAK8kB,kBAAkB1pC,SACvB4kB,KAAK8kB,kBAAoB,KACzB9kB,KAAK6kB,eAAgB,GAGtB7kB,KAAKokB,eAAiBA,EACtBpkB,KAAK4kB,mBAAqB,EAC1B5kB,KAAK6kB,eAAgB,EACjBT,EAAekB,MAClBtlB,KAAKqkB,UAAY,EACjBrkB,KAAKulB,WAAWnB,EAAekB,KAAK,KAEpCtlB,KAAKulB,WAAWvlB,KAAKujB,MAKvBD,EAAWnkB,UAAU1X,UAAY,SAAUf,EAAQ8+B,GAGlD,GAFAxlB,KAAK+iB,OAAO,mBAAoBr8B,EAAQ8+B,IAEnCxlB,KAAKkkB,UACT,MAAM,IAAI5oC,MAAM4G,EAAO66B,EAAMgB,cAAe,CAAC,mBAErC,IAAI6B,EAAc,IAAIR,EAAYzC,GAClCiD,EAAYv5B,OAASK,EAAOwY,cAAgBhmB,MAAQwN,EAAS,CAACA,QACjCjN,IAAzB+rC,EAAiBzF,MACjByF,EAAiBzF,IAAM,GAC3BH,EAAYkC,aAAe,GAC3B,IAAK,IAAIj7B,EAAI,EAAGA,EAAI+4B,EAAYv5B,OAAOpI,OAAQ4I,IAC3C+4B,EAAYkC,aAAaj7B,GAAK2+B,EAAiBzF,IAExDyF,EAAiB1/B,YACpB85B,EAAY95B,UAAY,SAAS2/B,GAAaD,EAAiB1/B,UAAU,CAAC4/B,kBAAkBF,EAAiBE,kBAAkBD,WAAWA,MAGvID,EAAiBz/B,YACpB65B,EAAY75B,UAAY,SAAS1B,GAAYmhC,EAAiBz/B,UAAU,CAAC2/B,kBAAkBF,EAAiBE,kBAAkBrhC,UAAUA,EAAWshC,aAAazjC,EAAOmC,OAGpKmhC,EAAiBpS,UACpBwM,EAAYgG,QAAU,IAAIzC,EAAQnjB,KAAMwlB,EAAiBpS,QAASoS,EAAiBz/B,UAClF,CAAC,CAAC2/B,kBAAkBF,EAAiBE,kBACpCrhC,UAAU04B,EAAMO,kBAAkBna,KAClCwiB,aAAazjC,EAAO66B,EAAMO,uBAI7Btd,KAAK6lB,cAAcjG,GACnB5f,KAAK8lB,kBAAkBlG,IAIxB0D,EAAWnkB,UAAUxX,YAAc,SAASjB,EAAQq/B,GAGnD,GAFA/lB,KAAK+iB,OAAO,qBAAsBr8B,EAAQq/B,IAErC/lB,KAAKkkB,UACT,MAAM,IAAI5oC,MAAM4G,EAAO66B,EAAMgB,cAAe,CAAC,mBAErC,IAAI6B,EAAc,IAAIR,EAAYzC,GAClCiD,EAAYv5B,OAASK,EAAOwY,cAAgBhmB,MAAQwN,EAAS,CAACA,GAEnEq/B,EAAmBjgC,YACtB85B,EAAYoG,SAAW,WAAYD,EAAmBjgC,UAAU,CAAC4/B,kBAAkBK,EAAmBL,sBAEnGK,EAAmB3S,UACtBwM,EAAYgG,QAAU,IAAIzC,EAAQnjB,KAAM+lB,EAAmB3S,QAAS2S,EAAmBhgC,UACtF,CAAC,CAAC2/B,kBAAkBK,EAAmBL,kBACtCrhC,UAAU04B,EAAMQ,oBAAoBpa,KACpCwiB,aAAazjC,EAAO66B,EAAMQ,yBAI7Bvd,KAAK6lB,cAAcjG,GACnB5f,KAAK8lB,kBAAkBlG,IAGxB0D,EAAWnkB,UAAU3Y,KAAO,SAAU7L,GACrCqlB,KAAK+iB,OAAO,cAAepoC,GAE3B,IAAIilC,EAAc,IAAIR,EAAYzC,GAGlC,GAFAiD,EAAYa,eAAiB9lC,EAEzBqlB,KAAKkkB,UAIJvpC,EAAQolC,IAAM,EACjB/f,KAAK6lB,cAAcjG,GACT5f,KAAKukB,qBACfvkB,KAAK8jB,iBAAiBlE,GAAe5f,KAAKukB,mBAAmB3E,EAAYa,iBAE1EzgB,KAAK8lB,kBAAkBlG,OACjB,CAGN,IAAI5f,KAAK6kB,gBAAiB7kB,KAAK+kB,uBAgB9B,MAAM,IAAIzpC,MAAM4G,EAAO66B,EAAMgB,cAAe,CAAC,mBAb7C,GADmBjlC,OAAOsE,KAAK4iB,KAAK4jB,eAAe3lC,OAAS+hB,KAAK2jB,oBAAoB1lC,OAClE+hB,KAAKglB,uBACvB,MAAM,IAAI1pC,MAAM4G,EAAO66B,EAAMsB,YAAa,CAACre,KAAKglB,0BAE5CrqC,EAAQolC,IAAM,EAEjB/f,KAAK6lB,cAAcjG,IAEnBA,EAAYqG,WAAajmB,KAAKgkB,UAE9BhkB,KAAK2jB,oBAAoBuC,QAAQtG,MAStC0D,EAAWnkB,UAAUhZ,WAAa,WAWjC,GAVA6Z,KAAK+iB,OAAO,qBAER/iB,KAAK6kB,gBAGR7kB,KAAK8kB,kBAAkB1pC,SACvB4kB,KAAK8kB,kBAAoB,KACzB9kB,KAAK6kB,eAAgB,IAGjB7kB,KAAKgjB,OACT,MAAM,IAAI1nC,MAAM4G,EAAO66B,EAAMgB,cAAe,CAAC,iCAE9C,IAAI6B,EAAc,IAAIR,EAAYzC,GAKlC3c,KAAK8jB,iBAAiBlE,GAAe//B,EAAMmgB,KAAKijB,cAAejjB,MAE/DA,KAAK8lB,kBAAkBlG,IAGxB0D,EAAWnkB,UAAUgnB,YAAc,WAClC,GAA2B,OAAtBnmB,KAAKklB,aAAwB,CAGjC,IAAK,IAAIxoC,KAFTsjB,KAAK+iB,OAAO,qBAAsB,IAAI7wB,MACtC8N,KAAK+iB,OAAO,wCAAyC/iB,KAAK4jB,cAAc3lC,QACxD+hB,KAAK4jB,cACpB5jB,KAAK+iB,OAAO,iBAAiBrmC,EAAKsjB,KAAK4jB,cAAclnC,IACtD,IAAK,IAAIA,KAAOsjB,KAAK6jB,kBACpB7jB,KAAK+iB,OAAO,qBAAqBrmC,EAAKsjB,KAAK6jB,kBAAkBnnC,IAE9D,OAAOsjB,KAAKklB,eAId5B,EAAWnkB,UAAUinB,WAAa,WACN,OAAtBpmB,KAAKklB,eACTllB,KAAKklB,aAAe,IAErBllB,KAAK+iB,OAAO,oBAAqB,IAAI7wB,KAh6BzB,2BAm6BboxB,EAAWnkB,UAAUknB,UAAY,kBACzBrmB,KAAKklB,cAGb5B,EAAWnkB,UAAUomB,WAAa,SAAUe,GAE3C,GAAItmB,KAAKokB,eAAez+B,OAAQ,CAC/B,IAAI4gC,EAAWD,EAAMpoC,MAAM,KAC3BqoC,EAAS,GAAK,MACdD,EAAQC,EAAS/oC,KAAK,KAEvBwiB,KAAKwjB,OAAS8C,EACdtmB,KAAKkkB,WAAY,EAIblkB,KAAKokB,eAAev+B,YAAc,EACrCma,KAAKgjB,OAAS,IAAI91B,UAAUo5B,EAAO,CAAC,aAEpCtmB,KAAKgjB,OAAS,IAAI91B,UAAUo5B,EAAO,CAAC,SAErCtmB,KAAKgjB,OAAOwD,WAAa,cACzBxmB,KAAKgjB,OAAOlzB,OAASjQ,EAAMmgB,KAAKymB,gBAAiBzmB,MACjDA,KAAKgjB,OAAO/yB,UAAYpQ,EAAMmgB,KAAK0mB,mBAAoB1mB,MACvDA,KAAKgjB,OAAOj1B,QAAUlO,EAAMmgB,KAAK2mB,iBAAkB3mB,MACnDA,KAAKgjB,OAAOl1B,QAAUjO,EAAMmgB,KAAK4mB,iBAAkB5mB,MAEnDA,KAAK0kB,WAAa,IAAInC,EAAOviB,KAAMA,KAAKokB,eAAe9B,mBACvDtiB,KAAK2kB,cAAgB,IAAIpC,EAAOviB,KAAMA,KAAKokB,eAAe9B,mBACtDtiB,KAAKykB,kBACRzkB,KAAKykB,gBAAgBrpC,SACrB4kB,KAAKykB,gBAAkB,MAExBzkB,KAAKykB,gBAAkB,IAAItB,EAAQnjB,KAAMA,KAAKokB,eAAehR,QAASpT,KAAKijB,cAAgB,CAAClG,EAAMM,gBAAgBla,KAAMjhB,EAAO66B,EAAMM,oBAStIiG,EAAWnkB,UAAU2mB,kBAAoB,SAAUnrC,GAElDqlB,KAAK0jB,WAAWwC,QAAQvrC,GAEpBqlB,KAAKkkB,WACRlkB,KAAK6mB,kBAIPvD,EAAWnkB,UAAU2nB,MAAQ,SAAS7V,EAAQ2O,GAC7C,IAAImH,EAAgB,CAAC96B,KAAK2zB,EAAY3zB,KAAMk0B,kBAAkBP,EAAYO,kBAAmB6G,QAAQ,GAErG,OAAOpH,EAAY3zB,MACnB,KAAK0wB,EACDiD,EAAYqH,iBACdF,EAAcE,gBAAiB,GAGhCF,EAActG,eAAiB,GAG/B,IAFA,IAAIyG,EAAM,GACNC,EAAevH,EAAYa,eAAekB,aACrC96B,EAAE,EAAGA,EAAEsgC,EAAalpC,OAAQ4I,IAChCsgC,EAAatgC,IAAM,GACtBqgC,EAAMA,EAAI,IAAIC,EAAatgC,GAAGrI,SAAS,IAEvC0oC,GAAUC,EAAatgC,GAAGrI,SAAS,IAErCuoC,EAActG,eAAe2G,WAAaF,EAE1CH,EAActG,eAAeV,IAAMH,EAAYa,eAAeV,IAC9DgH,EAActG,eAAeD,gBAAkBZ,EAAYa,eAAeD,gBACtEZ,EAAYa,eAAeF,YAC9BwG,EAActG,eAAeF,WAAY,GACtCX,EAAYa,eAAeH,WAC9ByG,EAActG,eAAeH,UAAW,GAGR,IAA5BrP,EAAOjoB,QAAQ,gBACWvP,IAAzBmmC,EAAYqG,WAChBrG,EAAYqG,WAAajmB,KAAKgkB,WAC/B+C,EAAcd,SAAWrG,EAAYqG,UAEtC,MAED,QACC,MAAM3qC,MAAM4G,EAAO66B,EAAMmB,oBAAqB,CAACjN,EAAOjR,KAAKyjB,UAAU7D,EAAYO,kBAAmB4G,KAErGvK,EAAaC,QAAQxL,EAAOjR,KAAKyjB,UAAU7D,EAAYO,kBAAmBvnC,KAAK2L,UAAUwiC,KAG1FzD,EAAWnkB,UAAU8kB,QAAU,SAASvnC,GACvC,IAAIoC,EAAQ09B,EAAa5qB,QAAQlV,GAC7BqqC,EAAgBnuC,KAAKC,MAAMiG,GAE3B8gC,EAAc,IAAIR,EAAY2H,EAAc96B,KAAM86B,GAEtD,OAAOA,EAAc96B,MACrB,KAAK0wB,EAMJ,IAJA,IAAIuK,EAAMH,EAActG,eAAe2G,WACnCpR,EAAS,IAAIO,YAAa2Q,EAAIjpC,OAAQ,GACtCkkC,EAAa,IAAI9S,WAAW2G,GAC5BnvB,EAAI,EACDqgC,EAAIjpC,QAAU,GAAG,CACvB,IAAI2gB,EAAIyoB,SAASH,EAAIlI,UAAU,EAAG,GAAI,IACtCkI,EAAMA,EAAIlI,UAAU,EAAGkI,EAAIjpC,QAC3BkkC,EAAWt7B,KAAO+X,EAEnB,IAAI6hB,EAAiB,IAAIL,EAAQ+B,GAEjC1B,EAAeV,IAAMgH,EAActG,eAAeV,IAClDU,EAAeD,gBAAkBuG,EAActG,eAAeD,gBAC1DuG,EAActG,eAAeF,YAChCE,EAAeF,WAAY,GACxBwG,EAActG,eAAeH,WAChCG,EAAeH,UAAW,GAC3BV,EAAYa,eAAiBA,EAE7B,MAED,QACC,MAAMnlC,MAAM4G,EAAO66B,EAAMmB,oBAAqB,CAACxhC,EAAKoC,KAGT,IAAxCpC,EAAIsM,QAAQ,QAAQgX,KAAKyjB,YAC5B7D,EAAYa,eAAeF,WAAY,EACvCvgB,KAAK4jB,cAAchE,EAAYO,mBAAqBP,GACE,IAA5CljC,EAAIsM,QAAQ,YAAYgX,KAAKyjB,aACvCzjB,KAAK6jB,kBAAkBjE,EAAYO,mBAAqBP,IAI1D0D,EAAWnkB,UAAU0nB,eAAiB,WAIrC,IAHA,IAAIlsC,EAAU,KAGNA,EAAUqlB,KAAK0jB,WAAW5pB,OACjCkG,KAAKsnB,aAAa3sC,GAEdqlB,KAAK8jB,iBAAiBnpC,KACzBqlB,KAAK8jB,iBAAiBnpC,YACfqlB,KAAK8jB,iBAAiBnpC,KAUhC2oC,EAAWnkB,UAAU0mB,cAAgB,SAAUjG,GAC9C,IAAI2H,EAAezuC,OAAOsE,KAAK4iB,KAAK4jB,eAAe3lC,OACnD,GAAIspC,EAAevnB,KAAKmkB,qBACvB,MAAM7oC,MAAO,qBAAqBisC,GAEnC,UAAuD9tC,IAAjDumB,KAAK4jB,cAAc5jB,KAAK+jB,sBAC7B/jB,KAAK+jB,sBAENnE,EAAYO,kBAAoBngB,KAAK+jB,oBACrC/jB,KAAK4jB,cAAchE,EAAYO,mBAAqBP,EAChDA,EAAY3zB,OAAS0wB,GACxB3c,KAAK8mB,MAAM,QAASlH,GAEjB5f,KAAK+jB,sBAAwB/jB,KAAKmkB,uBACrCnkB,KAAK+jB,oBAAsB,IAQ7BT,EAAWnkB,UAAUsnB,gBAAkB,WAEtC,IAAI7G,EAAc,IAAIR,EAAYzC,EAAsB3c,KAAKokB,gBAC7DxE,EAAYx8B,SAAW4c,KAAK5c,SAC5B4c,KAAKsnB,aAAa1H,IAOnB0D,EAAWnkB,UAAUunB,mBAAqB,SAAUh4B,GACnDsR,KAAK+iB,OAAO,4BAA6Br0B,EAAMzP,MAE/C,IADA,IAAIuoC,EAAWxnB,KAAKynB,iBAAiB/4B,EAAMzP,MAClC4H,EAAI,EAAGA,EAAI2gC,EAASvpC,OAAQ4I,GAAG,EACvCmZ,KAAK0nB,eAAeF,EAAS3gC,KAI/By8B,EAAWnkB,UAAUsoB,iBAAmB,SAASxoC,GAChD,IAAI0oC,EAAY,IAAItY,WAAWpwB,GAC3BuoC,EAAW,GACf,GAAIxnB,KAAKilB,cAAe,CACvB,IAAI2C,EAAU,IAAIvY,WAAWrP,KAAKilB,cAAchnC,OAAO0pC,EAAU1pC,QACjE2pC,EAAQpkC,IAAIwc,KAAKilB,eACjB2C,EAAQpkC,IAAImkC,EAAU3nB,KAAKilB,cAAchnC,QACzC0pC,EAAYC,SACL5nB,KAAKilB,cAEb,IAEC,IADA,IAAItV,EAAS,EACPA,EAASgY,EAAU1pC,QAAQ,CAChC,IAAIqK,EAAS+2B,EAAcsI,EAAUhY,GACjCiQ,EAAct3B,EAAO,GAEzB,GADAqnB,EAASrnB,EAAO,GACI,OAAhBs3B,EAGH,MAFA4H,EAASxiC,KAAK46B,GAKZjQ,EAASgY,EAAU1pC,SACtB+hB,KAAKilB,cAAgB0C,EAAUtH,SAAS1Q,IAExC,MAAO10B,GACR,IAAI4sC,EAAgD,aAAjC5sC,EAAMgf,eAAe,SAA2Bhf,EAAMoe,MAAM7a,WAAa,2BAE5F,YADAwhB,KAAKijB,cAAclG,EAAMU,eAAeta,KAAOjhB,EAAO66B,EAAMU,eAAgB,CAACxiC,EAAMN,QAAQktC,KAG5F,OAAOL,GAGRlE,EAAWnkB,UAAUuoB,eAAiB,SAAS9H,GAE9C5f,KAAK+iB,OAAO,wBAAyBnD,GAErC,IACC,OAAOA,EAAY3zB,MACnB,KAAK0wB,EAMJ,GALA3c,KAAKykB,gBAAgBrpC,SACjB4kB,KAAK8kB,mBACR9kB,KAAK8kB,kBAAkB1pC,SAGpB4kB,KAAKokB,eAAe/B,aAAc,CACrC,IAAK,IAAI3lC,KAAOsjB,KAAK4jB,cAAe,CACnC,IAAIkE,EAAc9nB,KAAK4jB,cAAclnC,GACrC8/B,EAAaE,WAAW,QAAQ1c,KAAKyjB,UAAUqE,EAAY3H,mBAI5D,IAAK,IAAIzjC,KAFTsjB,KAAK4jB,cAAgB,GAEL5jB,KAAK6jB,kBAAmB,CACvC,IAAIkE,EAAkB/nB,KAAK6jB,kBAAkBnnC,GAC7C8/B,EAAaE,WAAW,YAAY1c,KAAKyjB,UAAUsE,EAAgB5H,mBAEpEngB,KAAK6jB,kBAAoB,GAG1B,GAA+B,IAA3BjE,EAAYE,WAQT,CACN9f,KAAKijB,cAAclG,EAAMW,mBAAmBva,KAAOjhB,EAAO66B,EAAMW,mBAAoB,CAACkC,EAAYE,WAAYxB,EAAWsB,EAAYE,eACpI,MARA9f,KAAKkkB,WAAY,EAGblkB,KAAKokB,eAAekB,OACvBtlB,KAAKqkB,UAAYrkB,KAAKokB,eAAekB,KAAKrnC,QAQ5C,IAAI+pC,EAAoB,GACxB,IAAK,IAAIC,KAASjoB,KAAK4jB,cAClB5jB,KAAK4jB,cAAc3pB,eAAeguB,IACrCD,EAAkBhjC,KAAKgb,KAAK4jB,cAAcqE,IAI5C,GAAIjoB,KAAK2jB,oBAAoB1lC,OAAS,EAErC,IADA,IAAIoH,EAAM,KACFA,EAAM2a,KAAK2jB,oBAAoB7pB,OACtCkuB,EAAkBhjC,KAAKK,GACnB2a,KAAKukB,qBACRvkB,KAAK8jB,iBAAiBz+B,GAAO2a,KAAKukB,mBAAmBl/B,EAAIo7B,iBAKxDuH,EAAoBA,EAAkBzqC,MAAK,SAASmB,EAAEC,GAAI,OAAOD,EAAEunC,SAAWtnC,EAAEsnC,YACpF,IADA,IACSp/B,EAAE,EAAGwqB,EAAI2W,EAAkB/pC,OAAQ4I,EAAEwqB,EAAKxqB,IAElD,IADIihC,EAAcE,EAAkBnhC,IACpBoF,MAAQ0wB,GAAwBmL,EAAYb,eAAgB,CAC3E,IAAIiB,EAAgB,IAAI9I,EAAYzC,EAAqB,CAACwD,kBAAkB2H,EAAY3H,oBACxFngB,KAAK8lB,kBAAkBoC,QAEvBloB,KAAK8lB,kBAAkBgC,GAOrB9nB,KAAKokB,eAAet+B,WACvBka,KAAKokB,eAAet+B,UAAU,CAAC4/B,kBAAkB1lB,KAAKokB,eAAesB,oBAGtE,IAAIyC,GAAc,EACdnoB,KAAK6kB,gBACRsD,GAAc,EACdnoB,KAAK4kB,mBAAqB,EAC1B5kB,KAAK6kB,eAAgB,GAItB7kB,KAAKooB,WAAWD,EAAanoB,KAAKwjB,QAGlCxjB,KAAK6mB,iBACL,MAED,KAAKlK,EACJ3c,KAAKqoB,gBAAgBzI,GACrB,MAED,KAAKjD,GACAmL,EAAc9nB,KAAK4jB,cAAchE,EAAYO,6BAGzCngB,KAAK4jB,cAAchE,EAAYO,mBACtC3D,EAAaE,WAAW,QAAQ1c,KAAKyjB,UAAU7D,EAAYO,mBACvDngB,KAAKukB,oBACRvkB,KAAKukB,mBAAmBuD,EAAYrH,iBAEtC,MAED,KAAK9D,GACAmL,EAAc9nB,KAAK4jB,cAAchE,EAAYO,sBAGhD2H,EAAYb,gBAAiB,EACzBiB,EAAgB,IAAI9I,EAAYzC,EAAqB,CAACwD,kBAAkBP,EAAYO,oBACxFngB,KAAK8mB,MAAM,QAASgB,GACpB9nB,KAAK8lB,kBAAkBoC,IAExB,MAED,KAAKvL,EACAoL,EAAkB/nB,KAAK6jB,kBAAkBjE,EAAYO,mBACzD3D,EAAaE,WAAW,YAAY1c,KAAKyjB,UAAU7D,EAAYO,mBAE3D4H,IACH/nB,KAAKsoB,gBAAgBP,UACd/nB,KAAK6jB,kBAAkBjE,EAAYO,oBAG3C,IAAIoI,EAAiB,IAAInJ,EAAYzC,EAAsB,CAACwD,kBAAkBP,EAAYO,oBAC1FngB,KAAK8lB,kBAAkByC,GAGvB,MAED,KAAK5L,EACAmL,EAAc9nB,KAAK4jB,cAAchE,EAAYO,0BAC1CngB,KAAK4jB,cAAchE,EAAYO,mBACtC3D,EAAaE,WAAW,QAAQ1c,KAAKyjB,UAAU7D,EAAYO,mBACvDngB,KAAKukB,oBACRvkB,KAAKukB,mBAAmBuD,EAAYrH,gBACrC,MAED,KAAK9D,GACAmL,EAAc9nB,KAAK4jB,cAAchE,EAAYO,sBAE7C2H,EAAYlC,SACdkC,EAAYlC,QAAQxqC,SAEa,MAA9BwkC,EAAYE,WAAW,GACtBgI,EAAY/hC,WACf+hC,EAAY/hC,UAAU65B,EAAYE,YAEzBgI,EAAYhiC,WACtBgiC,EAAYhiC,UAAU85B,EAAYE,mBAE5B9f,KAAK4jB,cAAchE,EAAYO,oBAEvC,MAED,KAAKxD,GACAmL,EAAc9nB,KAAK4jB,cAAchE,EAAYO,sBAE5C2H,EAAYlC,SACfkC,EAAYlC,QAAQxqC,SACjB0sC,EAAY9B,UACf8B,EAAY9B,kBAENhmB,KAAK4jB,cAAchE,EAAYO,oBAGvC,MAED,KAAKxD,EAEJ3c,KAAK0kB,WAAWxB,QAChB,MAED,KAAKvG,EAEJ3c,KAAKijB,cAAclG,EAAMoB,0BAA0Bhb,KAAOjhB,EAAO66B,EAAMoB,0BAA2B,CAACyB,EAAY3zB,QAC/G,MAED,QACC+T,KAAKijB,cAAclG,EAAMoB,0BAA0Bhb,KAAOjhB,EAAO66B,EAAMoB,0BAA2B,CAACyB,EAAY3zB,SAE/G,MAAOhR,GACR,IAAI4sC,EAAgD,aAAjC5sC,EAAMgf,eAAe,SAA2Bhf,EAAMoe,MAAM7a,WAAa,2BAE5F,YADAwhB,KAAKijB,cAAclG,EAAMU,eAAeta,KAAOjhB,EAAO66B,EAAMU,eAAgB,CAACxiC,EAAMN,QAAQktC,OAM7FvE,EAAWnkB,UAAUwnB,iBAAmB,SAAU1rC,GAC5C+kB,KAAK6kB,eACT7kB,KAAKijB,cAAclG,EAAMY,aAAaxa,KAAOjhB,EAAO66B,EAAMY,aAAc,CAAC1iC,EAAMgE,SAKjFqkC,EAAWnkB,UAAUynB,iBAAmB,WAClC5mB,KAAK6kB,eACT7kB,KAAKijB,cAAclG,EAAMa,aAAaza,KAAOjhB,EAAO66B,EAAMa,gBAK5D0F,EAAWnkB,UAAUmoB,aAAe,SAAU1H,GAE7C,GAAwB,GAApBA,EAAY3zB,KAAW,CAC1B,IAAIu8B,EAAoBxoB,KAAKqlB,WAAWzF,EAAa,YACrD5f,KAAK+iB,OAAO,sBAAuByF,QAE/BxoB,KAAK+iB,OAAO,sBAAuBnD,GAExC5f,KAAKgjB,OAAOx8B,KAAKo5B,EAAY0B,UAE7BthB,KAAK0kB,WAAWxB,SAIjBI,EAAWnkB,UAAUkpB,gBAAkB,SAAUzI,GAChD,OAAOA,EAAYa,eAAeV,KAClC,IAAK,YACL,KAAK,EACJ/f,KAAKsoB,gBAAgB1I,GACrB,MAED,KAAK,EACJ,IAAI6I,EAAgB,IAAIrJ,EAAYzC,EAAqB,CAACwD,kBAAkBP,EAAYO,oBACxFngB,KAAK8lB,kBAAkB2C,GACvBzoB,KAAKsoB,gBAAgB1I,GACrB,MAED,KAAK,EACJ5f,KAAK6jB,kBAAkBjE,EAAYO,mBAAqBP,EACxD5f,KAAK8mB,MAAM,YAAalH,GACxB,IAAI8I,EAAgB,IAAItJ,EAAYzC,EAAqB,CAACwD,kBAAkBP,EAAYO,oBACxFngB,KAAK8lB,kBAAkB4C,GAEvB,MAED,QACC,MAAMptC,MAAM,eAAiBskC,EAAYa,eAAeV,OAK1DuD,EAAWnkB,UAAUmpB,gBAAkB,SAAU1I,GAC5C5f,KAAK5a,kBACR4a,KAAK5a,iBAAiBw6B,EAAYa,iBASpC6C,EAAWnkB,UAAUipB,WAAa,SAAUO,EAAWpF,GAElDvjB,KAAKskB,aACRtkB,KAAKskB,YAAYqE,EAAWpF,IAQ9BD,EAAWnkB,UAAUypB,WAAa,WACjC5oB,KAAK+iB,OAAO,qBACP/iB,KAAKkkB,YACTlkB,KAAK6kB,eAAgB,EACrB7kB,KAAK0kB,WAAWtpC,SAChB4kB,KAAK2kB,cAAcvpC,SACf4kB,KAAK4kB,mBAAqB,MAC7B5kB,KAAK4kB,mBAA+C,EAA1B5kB,KAAK4kB,oBAC5B5kB,KAAKokB,eAAekB,MACvBtlB,KAAKqkB,UAAY,EACjBrkB,KAAKulB,WAAWvlB,KAAKokB,eAAekB,KAAK,KAEzCtlB,KAAKulB,WAAWvlB,KAAKujB,OAYxBD,EAAWnkB,UAAU8jB,cAAgB,SAAU5+B,EAAWwkC,GAGzD,GAFA7oB,KAAK+iB,OAAO,uBAAwB1+B,EAAWwkC,QAE7BpvC,IAAd4K,GAA2B2b,KAAK6kB,cAEnC7kB,KAAK8kB,kBAAoB,IAAI3B,EAAQnjB,KAAMA,KAAK4kB,mBAAoB5kB,KAAK4oB,iBA2B1E,GAvBA5oB,KAAK0kB,WAAWtpC,SAChB4kB,KAAK2kB,cAAcvpC,SACf4kB,KAAKykB,kBACRzkB,KAAKykB,gBAAgBrpC,SACrB4kB,KAAKykB,gBAAkB,MAIxBzkB,KAAK0jB,WAAa,GAClB1jB,KAAK2jB,oBAAsB,GAC3B3jB,KAAK8jB,iBAAmB,GAEpB9jB,KAAKgjB,SAERhjB,KAAKgjB,OAAOlzB,OAAS,KACrBkQ,KAAKgjB,OAAO/yB,UAAY,KACxB+P,KAAKgjB,OAAOj1B,QAAU,KACtBiS,KAAKgjB,OAAOl1B,QAAU,KACS,IAA3BkS,KAAKgjB,OAAO/1B,YACf+S,KAAKgjB,OAAOh1B,eACNgS,KAAKgjB,QAGThjB,KAAKokB,eAAekB,MAAQtlB,KAAKqkB,UAAYrkB,KAAKokB,eAAekB,KAAKrnC,OAAO,EAEhF+hB,KAAKqkB,YACLrkB,KAAKulB,WAAWvlB,KAAKokB,eAAekB,KAAKtlB,KAAKqkB,iBAS9C,QANkB5qC,IAAd4K,IACHA,EAAY04B,EAAMI,GAAGha,KACrB0lB,EAAY3mC,EAAO66B,EAAMI,KAItBnd,KAAKkkB,WAMR,GALAlkB,KAAKkkB,WAAY,EAEblkB,KAAKza,kBACRya,KAAKza,iBAAiB,CAAClB,UAAUA,EAAWshC,aAAakD,EAAWF,UAAU3oB,KAAKokB,eAAeuE,UAAWpF,IAAIvjB,KAAKwjB,SAEnHn/B,IAAc04B,EAAMI,GAAGha,MAAQnD,KAAKokB,eAAeuE,UAItD,OAFA3oB,KAAK4kB,mBAAqB,OAC1B5kB,KAAK4oB,kBAKkC,IAApC5oB,KAAKokB,eAAev+B,cAAiE,IAA5Cma,KAAKokB,eAAe0E,qBAChE9oB,KAAK+iB,OAAO,6CACZ/iB,KAAKokB,eAAev+B,YAAc,EAC9Bma,KAAKokB,eAAekB,MACvBtlB,KAAKqkB,UAAY,EACjBrkB,KAAKulB,WAAWvlB,KAAKokB,eAAekB,KAAK,KAEzCtlB,KAAKulB,WAAWvlB,KAAKujB,MAEbvjB,KAAKokB,eAAer+B,WAC7Bia,KAAKokB,eAAer+B,UAAU,CAAC2/B,kBAAkB1lB,KAAKokB,eAAesB,kBAAmBrhC,UAAUA,EAAWshC,aAAakD,KAO9HvF,EAAWnkB,UAAU4jB,OAAS,WAE7B,GAAI/iB,KAAKwkB,cAAe,CACvB,IAAIlgC,EAAOpL,MAAMimB,UAAU7f,MAAMuN,KAAKuM,WACtC,IAAK,IAAIvS,KAAKvC,EAEU,qBAAZA,EAAKuC,IACfvC,EAAKgW,OAAOzT,EAAG,EAAGjO,KAAK2L,UAAUD,EAAKuC,KAExC,IAAIkiC,EAASzkC,EAAK9G,KAAK,IACvBwiB,KAAKwkB,cAAe,CAACwE,SAAU,QAASruC,QAASouC,IAIlD,GAA2B,OAAtB/oB,KAAKklB,aACJ,CAAIr+B,EAAI,EAAb,IAAK,IAAWqqB,EAAM9X,UAAUnb,OAAQ4I,EAAIqqB,EAAKrqB,IAC3CmZ,KAAKklB,aAAajnC,QAAU+hB,KAAKmlB,oBACrCnlB,KAAKklB,aAAarkB,QAET,IAANha,GAC6B,qBAAjBuS,UAAUvS,GADbmZ,KAAKklB,aAAalgC,KAAKoU,UAAUvS,IAEzCmZ,KAAKklB,aAAalgC,KAAK,KAAKpM,KAAK2L,UAAU6U,UAAUvS,OAM7Dy8B,EAAWnkB,UAAUkmB,WAAa,SAAU4D,EAAaC,GACxD,IAAIC,EAAoB,GACxB,IAAK,IAAIC,KAAQH,EACZA,EAAYhvB,eAAemvB,KAE7BD,EAAkBC,GADfA,GAAQF,EACe,SAEAD,EAAYG,IAGzC,OAAOD,GA4ER,IAojBI/I,EAAU,SAAUiJ,GACvB,IAAI79B,EAUAg1B,EATJ,KAA6B,kBAAf6I,GACfA,aAAsB9S,aACrBA,YAAYC,OAAO6S,MAAiBA,aAAsBnS,WAIzD,MAAOh1B,EAAO66B,EAAMiB,iBAAkB,CAACqL,EAAY,eAFnD79B,EAAU69B,EAMX,IAAItJ,EAAM,EACNO,GAAW,EACXC,GAAY,EAEhBznC,OAAOg5B,iBAAiB9R,KAAK,CAC5B,cAAgB,CACfN,YAAa,EACbplB,IAAM,WACL,MAAuB,kBAAZkR,EACHA,EAEA00B,EAAU10B,EAAS,EAAGA,EAAQvN,UAGxC,aAAe,CACdyhB,YAAY,EACZplB,IAAK,WACJ,GAAuB,kBAAZkR,EAAsB,CAChC,IAAIwqB,EAAS,IAAIO,YAAYuK,EAAWt1B,IACpC22B,EAAa,IAAI9S,WAAW2G,GAGhC,OAFA6K,EAAar1B,EAAS22B,EAAY,GAE3BA,EAEP,OAAO32B,IAIV,gBAAkB,CACjBkU,YAAY,EACZplB,IAAK,WAAa,OAAOkmC,GACzBh9B,IAAK,SAAS8lC,GACb,GAAkC,kBAAvBA,EAGV,MAAM,IAAIhuC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACsL,EAAoB,wBAFpE9I,EAAkB8I,IAKrB,IAAM,CACL5pB,YAAY,EACZplB,IAAK,WAAa,OAAOylC,GACzBv8B,IAAK,SAAS+lC,GACb,GAAe,IAAXA,GAA2B,IAAXA,GAA2B,IAAXA,EAGnC,MAAM,IAAIjuC,MAAM,oBAAoBiuC,GAFpCxJ,EAAMwJ,IAKT,SAAW,CACV7pB,YAAY,EACZplB,IAAK,WAAa,OAAOgmC,GACzB98B,IAAK,SAASgmC,GACb,GAA2B,mBAAhBA,EAGV,MAAM,IAAIluC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACwL,EAAa,iBAF7DlJ,EAAWkJ,IAKd,MAAQ,CACP9pB,YAAY,EACZplB,IAAK,WAAa,OAAOkmC,GACzBh9B,IAAK,SAASimC,GAAWjJ,EAAgBiJ,IAE1C,UAAY,CACX/pB,YAAY,EACZplB,IAAK,WAAa,OAAOimC,GACzB/8B,IAAK,SAASkmC,GAAenJ,EAAUmJ,OAM1C,MAAO,CACNC,OAzoBY,SAAUvqC,EAAMoD,EAAM1I,EAAMsJ,GAExC,IAAImgC,EAEJ,GAAoB,kBAATnkC,EACV,MAAM,IAAI9D,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQ59B,EAAM,UAE1D,GAAwB,GAApBga,UAAUnb,OAAa,CAG1BmF,EAAWZ,EAEX,IAAInD,GADJkkC,EAAMnkC,GACUC,MAAM,sDACtB,IAAIA,EAKH,MAAM,IAAI/D,MAAM4G,EAAO66B,EAAMiB,iBAAiB,CAAC5+B,EAAK,UAJpDA,EAAOC,EAAM,IAAIA,EAAM,GACvBmD,EAAO6kC,SAAShoC,EAAM,IACtBvF,EAAOuF,EAAM,OAIR,CAKN,GAJwB,GAApB+Z,UAAUnb,SACbmF,EAAWtJ,EACXA,EAAO,SAEY,kBAAT0I,GAAqBA,EAAO,EACtC,MAAM,IAAIlH,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQx6B,EAAM,UAC1D,GAAoB,kBAAT1I,EACV,MAAM,IAAIwB,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQljC,EAAM,UAE1D,IAAI8vC,GAA0C,IAAvBxqC,EAAK4J,QAAQ,MAAmC,MAApB5J,EAAKE,MAAM,EAAE,IAAiC,MAAnBF,EAAKE,OAAO,GAC1FikC,EAAM,SAASqG,EAAgB,IAAIxqC,EAAK,IAAIA,GAAM,IAAIoD,EAAK1I,EAI5D,IADA,IAAI+vC,EAAiB,EACZhjC,EAAI,EAAGA,EAAEzD,EAASnF,OAAQ4I,IAAK,CACvC,IAAIwd,EAAWjhB,EAAS7E,WAAWsI,GAC/B,OAAUwd,GAAYA,GAAY,OACrCxd,IAEDgjC,IAED,GAAwB,kBAAbzmC,GAAyBymC,EAAiB,MACpD,MAAM,IAAIvuC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAAC56B,EAAU,cAE3D,IAAI8B,EAAS,IAAIo+B,EAAWC,EAAKnkC,EAAMoD,EAAM1I,EAAMsJ,GAGnDtK,OAAOg5B,iBAAiB9R,KAAK,CAC5B,KAAO,CACN1lB,IAAK,WAAa,OAAO8E,GACzBoE,IAAK,WAAa,MAAM,IAAIlI,MAAM4G,EAAO66B,EAAMkB,0BAEhD,KAAO,CACN3jC,IAAK,WAAa,OAAOkI,GACzBgB,IAAK,WAAa,MAAM,IAAIlI,MAAM4G,EAAO66B,EAAMkB,0BAEhD,KAAO,CACN3jC,IAAK,WAAa,OAAOR,GACzB0J,IAAK,WAAa,MAAM,IAAIlI,MAAM4G,EAAO66B,EAAMkB,0BAEhD,IAAM,CACL3jC,IAAK,WAAa,OAAOipC,GACzB//B,IAAK,WAAa,MAAM,IAAIlI,MAAM4G,EAAO66B,EAAMkB,0BAEhD,SAAW,CACV3jC,IAAK,WAAa,OAAO4K,EAAO9B,UAChCI,IAAK,WAAa,MAAM,IAAIlI,MAAM4G,EAAO66B,EAAMkB,0BAEhD,YAAc,CACb3jC,IAAK,WAAa,OAAO4K,EAAOo/B,aAChC9gC,IAAK,SAASsmC,GACb,GAA8B,oBAAnBA,EAGV,MAAM,IAAIxuC,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQ8M,EAAgB,iBAFnE5kC,EAAOo/B,YAAcwF,IAKxB,uBAAyB,CACxBxvC,IAAK,WAAa,OAAO4K,EAAO6/B,wBAChCvhC,IAAK,SAASumC,GACb7kC,EAAO6/B,uBAAyBgF,IAGlC,uBAAyB,CACxBzvC,IAAK,WAAa,OAAO4K,EAAO8/B,wBAChCxhC,IAAK,SAASwmC,GACb9kC,EAAO8/B,uBAAyBgF,IAGlC,iBAAmB,CAClB1vC,IAAK,WAAa,OAAO4K,EAAOK,kBAChC/B,IAAK,SAASymC,GACb,GAAmC,oBAAxBA,EAGV,MAAM,IAAI3uC,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQiN,EAAqB,sBAFxE/kC,EAAOK,iBAAmB0kC,IAK7B,mBAAqB,CACpB3vC,IAAK,WAAa,OAAO4K,EAAOq/B,oBAChC/gC,IAAK,SAAS0mC,GACb,GAAqC,oBAA1BA,EAGV,MAAM,IAAI5uC,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQkN,EAAuB,wBAF1EhlC,EAAOq/B,mBAAqB2F,IAK/B,iBAAmB,CAClB5vC,IAAK,WAAa,OAAO4K,EAAOE,kBAChC5B,IAAK,SAAS2mC,GACb,GAAmC,oBAAxBA,EAGV,MAAM,IAAI7uC,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQmN,EAAqB,sBAFxEjlC,EAAOE,iBAAmB+kC,IAK7B,MAAQ,CACP7vC,IAAK,WAAa,OAAO4K,EAAOs/B,eAChChhC,IAAK,SAAS4mC,GACb,GAAoB,oBAAVA,EAGT,MAAM,IAAI9uC,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQoN,EAAO,aAF1DllC,EAAOs/B,cAAgB4F,MAsE3BpqB,KAAKta,QAAU,SAAU0+B,GAuBxB,GArBAxH,EADAwH,EAAiBA,GAAkB,GACT,CAAChR,QAAQ,SAClCwO,SAAS,SACTC,SAAS,SACTH,YAAY,SACZY,kBAAkB,SAClBD,aAAa,UACb18B,OAAO,UACP+/B,kBAAkB,SAClB5/B,UAAU,WACVC,UAAU,WACVskC,MAAM,SACNC,MAAM,SACN3B,UAAU,UACV9iC,YAAY,SACZijC,oBAAoB,UACpBxD,KAAM,gBAGkC7rC,IAArC2qC,EAAe9B,oBAClB8B,EAAe9B,kBAAoB,IAEhC8B,EAAev+B,YAAc,GAAKu+B,EAAev+B,YAAc,EAClE,MAAM,IAAIvK,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAev+B,YAAa,gCAW7E,QARmCpM,IAA/B2qC,EAAev+B,aAClBu+B,EAAe0E,qBAAsB,EACrC1E,EAAev+B,YAAc,GAE7Bu+B,EAAe0E,qBAAsB,OAINrvC,IAA5B2qC,EAAevC,eAAsDpoC,IAA5B2qC,EAAexC,SAC3D,MAAM,IAAItmC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAevC,SAAU,6BAE1E,GAAIuC,EAAe1C,YAAa,CAC/B,KAAM0C,EAAe1C,uBAAuBtB,GAC3C,MAAM,IAAI9kC,MAAM4G,EAAO66B,EAAMC,aAAc,CAACoH,EAAe1C,YAAa,gCAKzE,GAFA0C,EAAe1C,YAAY6I,cAAgB,KAEe,qBAA/CnG,EAAe1C,YAAYlB,gBACrC,MAAM,IAAIllC,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQoH,EAAe1C,YAAYlB,gBAAiB,gDAIjG,GAF2C,qBAAhC4D,EAAe/B,eACzB+B,EAAe/B,cAAe,GAC3B+B,EAAeiG,MAAO,CAEzB,KAAMjG,EAAeiG,iBAAiBnxC,OACrC,MAAM,IAAIoC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAeiG,MAAO,0BACvE,GAAIjG,EAAeiG,MAAMpsC,OAAQ,EAChC,MAAM,IAAI3C,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAeiG,MAAO,0BAGvE,IADA,IAAIG,GAAY,EACP3jC,EAAI,EAAGA,EAAEu9B,EAAeiG,MAAMpsC,OAAQ4I,IAAK,CACnD,GAAuC,kBAA5Bu9B,EAAeiG,MAAMxjC,GAC/B,MAAM,IAAIvL,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQoH,EAAeiG,MAAMxjC,GAAI,wBAAwBA,EAAE,OACvG,GAAI,qDAAqD4jC,KAAKrG,EAAeiG,MAAMxjC,KAClF,GAAU,IAANA,EACH2jC,GAAY,OACN,IAAKA,EACX,MAAM,IAAIlvC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAeiG,MAAMxjC,GAAI,wBAAwBA,EAAE,YAE9F,GAAI2jC,EACV,MAAM,IAAIlvC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAeiG,MAAMxjC,GAAI,wBAAwBA,EAAE,OAIrG,GAAK2jC,EAqBJpG,EAAekB,KAAOlB,EAAeiG,UArBtB,CACf,IAAKjG,EAAekG,MACnB,MAAM,IAAIhvC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAekG,MAAO,0BACvE,KAAMlG,EAAekG,iBAAiBpxC,OACrC,MAAM,IAAIoC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAekG,MAAO,0BACvE,GAAIlG,EAAeiG,MAAMpsC,SAAWmmC,EAAekG,MAAMrsC,OACxD,MAAM,IAAI3C,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACoG,EAAekG,MAAO,0BAIvE,IAFAlG,EAAekB,KAAO,GAEbz+B,EAAI,EAAGA,EAAEu9B,EAAeiG,MAAMpsC,OAAQ4I,IAAK,CACnD,GAAuC,kBAA5Bu9B,EAAekG,MAAMzjC,IAAmBu9B,EAAekG,MAAMzjC,GAAK,EAC5E,MAAM,IAAIvL,MAAM4G,EAAO66B,EAAMC,aAAc,QAAQoH,EAAekG,MAAMzjC,GAAI,wBAAwBA,EAAE,OACvG,IAAIzH,EAAOglC,EAAeiG,MAAMxjC,GAC5BrE,EAAO4hC,EAAekG,MAAMzjC,GAE5B6jC,GAA+B,IAAvBtrC,EAAK4J,QAAQ,KACzBu6B,EAAM,SAASmH,EAAK,IAAItrC,EAAK,IAAIA,GAAM,IAAIoD,EAAK1I,EAChDsqC,EAAekB,KAAKtgC,KAAKu+B,KAO5Br+B,EAAOQ,QAAQ0+B,IAmChBpkB,KAAKvY,UAAY,SAAUf,EAAQ8+B,GAClC,GAAsB,kBAAX9+B,GAAuBA,EAAOwY,cAAgBhmB,MACxD,MAAM,IAAIoC,MAAM,oBAAoBoL,GAQrC,GANAk2B,EADA4I,EAAmBA,GAAoB,GACX,CAACzF,IAAI,SAChC2F,kBAAkB,SAClB5/B,UAAU,WACVC,UAAU,WACVqtB,QAAQ,WAELoS,EAAiBpS,UAAYoS,EAAiBz/B,UACjD,MAAM,IAAIzK,MAAM,kEACjB,GAAoC,qBAAzBkqC,EAAiBzF,KAAkD,IAAzByF,EAAiBzF,KAAsC,IAAzByF,EAAiBzF,KAAsC,IAAzByF,EAAiBzF,IACjI,MAAM,IAAIzkC,MAAM4G,EAAO66B,EAAMiB,iBAAkB,CAACwH,EAAiBzF,IAAK,0BACvE76B,EAAOuC,UAAUf,EAAQ8+B,IA+B1BxlB,KAAKrY,YAAc,SAAUjB,EAAQq/B,GACpC,GAAsB,kBAAXr/B,GAAuBA,EAAOwY,cAAgBhmB,MACxD,MAAM,IAAIoC,MAAM,oBAAoBoL,GAOrC,GALAk2B,EADAmJ,EAAqBA,GAAsB,GACb,CAACL,kBAAkB,SAChD5/B,UAAU,WACVC,UAAU,WACVqtB,QAAQ,WAEL2S,EAAmB3S,UAAY2S,EAAmBhgC,UACrD,MAAM,IAAIzK,MAAM,oEACjB4J,EAAOyC,YAAYjB,EAAQq/B,IAyB5B/lB,KAAKxZ,KAAO,SAAUvB,EAAMuG,EAAQu0B,EAAIO,GACvC,IAAI3lC,EAEJ,GAAwB,IAArBye,UAAUnb,OACZ,MAAM,IAAI3C,MAAM,2BAEX,GAAuB,GAApB8d,UAAUnb,OAAa,CAE/B,KAAMgH,aAAiBm7B,IAA8B,kBAAVn7B,EAC1C,MAAM,IAAI3J,MAAM,2BAA4B2J,GAG7C,GAAuC,qBADvCtK,EAAUsK,GACSu7B,gBAClB,MAAM,IAAIllC,MAAM4G,EAAO66B,EAAMiB,iBAAiB,CAACrjC,EAAQ6lC,gBAAgB,6BACxEt7B,EAAOsB,KAAK7L,QAIZA,EAAU,IAAIylC,EAAQ50B,IACdg1B,gBAAkBv7B,EACvBmU,UAAUnb,QAAU,IACtBtD,EAAQolC,IAAMA,GACZ3mB,UAAUnb,QAAU,IACtBtD,EAAQ2lC,SAAWA,GACpBp7B,EAAOsB,KAAK7L,IA2BdqlB,KAAKlM,QAAU,SAAS7O,EAAMuG,EAAQu0B,EAAIO,GACzC,IAAI3lC,EAEJ,GAAwB,IAArBye,UAAUnb,OACZ,MAAM,IAAI3C,MAAM,2BAEX,GAAuB,GAApB8d,UAAUnb,OAAa,CAE/B,KAAMgH,aAAiBm7B,IAA8B,kBAAVn7B,EAC1C,MAAM,IAAI3J,MAAM,2BAA4B2J,GAG7C,GAAuC,qBADvCtK,EAAUsK,GACSu7B,gBAClB,MAAM,IAAIllC,MAAM4G,EAAO66B,EAAMiB,iBAAiB,CAACrjC,EAAQ6lC,gBAAgB,6BACxEt7B,EAAOsB,KAAK7L,QAIZA,EAAU,IAAIylC,EAAQ50B,IACdg1B,gBAAkBv7B,EACvBmU,UAAUnb,QAAU,IACtBtD,EAAQolC,IAAMA,GACZ3mB,UAAUnb,QAAU,IACtBtD,EAAQ2lC,SAAWA,GACpBp7B,EAAOsB,KAAK7L,IAWdqlB,KAAK7Z,WAAa,WACjBjB,EAAOiB,cAUR6Z,KAAKmmB,YAAc,WAClB,OAAOjhC,EAAOihC,eASfnmB,KAAKomB,WAAa,WACjBlhC,EAAOkhC,cASRpmB,KAAKqmB,UAAY,WAChBnhC,EAAOmhC,aAGRrmB,KAAK9Z,YAAc,WAClB,OAAOhB,EAAOg/B,YA4Hf9D,QAASA,GAlvEK,CAqvEK,qBAAX7D,EAAyBA,EAAyB,qBAAToO,KAAuBA,KAAyB,qBAAXn2B,OAAyBA,OAAS,KAnwEzHwa,EAAON,QAAU4N,M,sCCrFnB,IAQIsO,EACAC,EATAC,EAAMhc,EAAQ,KACdic,EAAcjc,EAAQ,KAWtBkc,EAAa,EACbC,EAAa,EA+FjBjc,EAAON,QA5FP,SAAY12B,EAAS03B,EAAKC,GACxB,IAAI9oB,EAAI6oB,GAAOC,GAAU,EACrBhxB,EAAI+wB,GAAO,GAGXjW,GADJzhB,EAAUA,GAAW,IACFyhB,MAAQmxB,EACvBM,OAAgCzxC,IAArBzB,EAAQkzC,SAAyBlzC,EAAQkzC,SAAWL,EAKnE,GAAY,MAARpxB,GAA4B,MAAZyxB,EAAkB,CACpC,IAAIC,EAAYL,IACJ,MAARrxB,IAEFA,EAAOmxB,EAAU,CACA,EAAfO,EAAU,GACVA,EAAU,GAAIA,EAAU,GAAIA,EAAU,GAAIA,EAAU,GAAIA,EAAU,KAGtD,MAAZD,IAEFA,EAAWL,EAAiD,OAApCM,EAAU,IAAM,EAAIA,EAAU,KAQ1D,IAAIC,OAA0B3xC,IAAlBzB,EAAQozC,MAAsBpzC,EAAQozC,OAAQ,IAAIl5B,MAAOqiB,UAIjE8W,OAA0B5xC,IAAlBzB,EAAQqzC,MAAsBrzC,EAAQqzC,MAAQJ,EAAa,EAGnEh5B,EAAMm5B,EAAQJ,GAAeK,EAAQJ,GAAY,IAcrD,GAXIh5B,EAAK,QAA0BxY,IAArBzB,EAAQkzC,WACpBA,EAAWA,EAAW,EAAI,QAKvBj5B,EAAK,GAAKm5B,EAAQJ,SAAiCvxC,IAAlBzB,EAAQqzC,QAC5CA,EAAQ,GAINA,GAAS,IACX,MAAM,IAAI/vC,MAAM,mDAGlB0vC,EAAaI,EACbH,EAAaI,EACbR,EAAYK,EAMZ,IAAII,GAA4B,KAAb,WAHnBF,GAAS,cAG+BC,GAAS,WACjD1sC,EAAEkI,KAAOykC,IAAO,GAAK,IACrB3sC,EAAEkI,KAAOykC,IAAO,GAAK,IACrB3sC,EAAEkI,KAAOykC,IAAO,EAAI,IACpB3sC,EAAEkI,KAAY,IAALykC,EAGT,IAAIC,EAAOH,EAAQ,WAAc,IAAS,UAC1CzsC,EAAEkI,KAAO0kC,IAAQ,EAAI,IACrB5sC,EAAEkI,KAAa,IAAN0kC,EAGT5sC,EAAEkI,KAAO0kC,IAAQ,GAAK,GAAM,GAC5B5sC,EAAEkI,KAAO0kC,IAAQ,GAAK,IAGtB5sC,EAAEkI,KAAOqkC,IAAa,EAAI,IAG1BvsC,EAAEkI,KAAkB,IAAXqkC,EAGT,IAAK,IAAIM,EAAI,EAAGA,EAAI,IAAKA,EACvB7sC,EAAEkI,EAAI2kC,GAAK/xB,EAAK+xB,GAGlB,OAAO9b,GAAYqb,EAAYpsC,K,oBCzGjC,IAAImsC,EAAMhc,EAAQ,KACdic,EAAcjc,EAAQ,KA2B1BE,EAAON,QAzBP,SAAY12B,EAAS03B,EAAKC,GACxB,IAAI9oB,EAAI6oB,GAAOC,GAAU,EAEF,iBAAZ33B,IACT03B,EAAkB,WAAZ13B,EAAuB,IAAIkB,MAAM,IAAM,KAC7ClB,EAAU,MAIZ,IAAIs3B,GAFJt3B,EAAUA,GAAW,IAEFw3B,SAAWx3B,EAAQ8yC,KAAOA,KAO7C,GAJAxb,EAAK,GAAgB,GAAVA,EAAK,GAAa,GAC7BA,EAAK,GAAgB,GAAVA,EAAK,GAAa,IAGzBI,EACF,IAAK,IAAIvV,EAAK,EAAGA,EAAK,KAAMA,EAC1BuV,EAAI7oB,EAAIsT,GAAMmV,EAAKnV,GAIvB,OAAOuV,GAAOqb,EAAYzb,K,wHCnBrB,IAAMmc,EAAW,SAAC/V,GACvB,MAAuB,oBAAhBgW,YCkCH,SAAmBhW,GACvB,OAAO,IAAIgW,aAAcpK,OAAO5L,GDnCIiW,CAAoBjW,GEAlC,SAACA,GAEvB,IADA,IAAMkW,EAAuB,GACpB/kC,EAAI,EAAGwqB,EAAMqE,EAAMz3B,OAAQ4I,EAAIwqB,EAAKxqB,IAAK,CAChD,IAAM/H,EAAQ42B,EAAMn3B,WAAWsI,GAC/B,GAAI/H,EAAQ,IACV8sC,EAAM5mC,KAAKlG,QACN,GAAIA,EAAQ,KACjB8sC,EAAM5mC,KAAMlG,GAAS,EAAK,IAAqB,GAARA,EAAoB,UACtD,GAAI+H,EAAI,EAAI6uB,EAAMz3B,QAA+B,SAAZ,MAARa,IAAqE,SAAZ,MAA1B42B,EAAMn3B,WAAWsI,EAAI,IAAyB,CAC/G,IAAMglC,EAAgB,QAAoB,KAAR/sC,IAAyB,KAA+B,KAAxB42B,EAAMn3B,aAAasI,IACrF+kC,EAAM5mC,KACH6mC,GAAiB,GAAM,IACtBA,GAAiB,GAAM,GAAY,IACnCA,GAAiB,EAAK,GAAY,IACnB,GAAhBA,EAA4B,UAG/BD,EAAM5mC,KAAMlG,GAAS,GAAM,IAAcA,GAAS,EAAK,GAAY,IAAqB,GAARA,EAAoB,KAIxG,OAAOuwB,WAAW5rB,KAAKmoC,GFrB0CE,CAAWpW,IAEjEqW,EAAS,SAACrW,GACrB,MAAuB,oBAAhBsW,YCmCH,SAAiBtW,GACrB,OAAO,IAAIsW,YAAY,SAASC,OAAOvW,GDpCHwW,CAAkBxW,GE6BlC,SAACA,GAErB,IADA,IAAIyW,EAAU,GACLtlC,EAAI,EAAGwqB,EAAMqE,EAAMz3B,OAAQ4I,EAAIwqB,EAAKxqB,IAAK,CAChD,IAAMulC,EAAO1W,EAAM7uB,GACnB,GAAIulC,EAAO,IACTD,GAAW9sB,OAAOgE,aAAa+oB,QAC1B,GAAI,KAAcA,GAAQA,EAAO,IAAY,CAClD,IAAMC,EAAW3W,IAAQ7uB,GACzBslC,GAAW9sB,OAAOgE,cAAsB,GAAP+oB,IAAmB,EAAiB,GAAXC,QACrD,GAAI,KAAcD,GAAQA,EAAO,IAAa,CACnD,IACME,EAAU,IADM,CAACF,EAAM1W,IAAQ7uB,GAAI6uB,IAAQ7uB,GAAI6uB,IAAQ7uB,IACzBxJ,KAAI,SAACkvC,GAAc,OAAAA,EAAU/tC,SAAS,OAAKhB,KAAK,KACpF2uC,GAAWK,mBAAmBF,QAE9BH,GAAW9sB,OAAOgE,cACP,GAAP+oB,IAAkB,IAAqB,GAAb1W,IAAQ7uB,KAAkB,EAAmB,GAAb6uB,IAAQ7uB,IAK1E,OAAOslC,EFjDwDM,CAAS/W,K,iCGV1E,kC,+RASaj1B,EAAY,CAIxBisC,YAAa,EAEbhsC,uBAAsB,WACrB,OAAID,EAAUisC,YACN,IAAIx6B,MAAK,IAAIA,MAAOqiB,UAAY9zB,EAAUisC,aAE1C,IAAIx6B,MAOby6B,eAAc,WACb,OAAOlsC,EAAUisC,aAGlBE,wBAAA,SAAwB3Y,GACvB,YADuB,QAAAA,EAAaxzB,EAAUC,0BACvCuzB,EAAKtzB,cAAc3C,QAAQ,iBAAkB,KAGrDo2B,wBAAA,SAAwBn7B,GACjB,qEAAG4zC,OAAMC,OAAOC,OAAKC,OAAMC,OAAQC,OAIzC,OAAO,IAAIh7B,KACVA,KAAKi7B,IACJC,OAAOP,GACPO,OAAON,GAAS,EAChBM,OAAOL,GACPK,OAAOJ,GACPI,OAAOH,GACPG,OAAOF,MAKV7Y,cAAA,SAAcgZ,GAEb,OACCze,KAAK0e,IACJD,EAAW9Y,UAAY9zB,EAAUC,yBAAyB6zB,YAhDnC,KAqD1BR,iBAAA,SAAiB94B,GAChB,IAAKA,EAAMQ,WAAaR,EAAMQ,SAAS0B,QACtC,OAAO,EAGA,yBAER,OAAOkb,QAC0B,wBAAhClb,EAAQ,sBACNA,EAAQ82B,MAAQ92B,EAAQ+U,QAO5BoiB,eAAA,SAAe3E,GACdlvB,EAAUisC,YAAc/c","file":"static/js/5.cef8c3f3.chunk.js","sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,"/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\n\n/**\n * A visitor is provided to visit, it contains the collection of\n * relevant functions to be called during the visitor's traversal.\n */\n\n/**\n * A visitor is comprised of visit functions, which are called on each node\n * during the visitor's traversal.\n */\n\n/**\n * A KeyMap describes each the traversable properties of each kind of node.\n */\nexport var QueryDocumentKeys = {\n  Name: [],\n  Document: ['definitions'],\n  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],\n  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],\n  Variable: ['name'],\n  SelectionSet: ['selections'],\n  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],\n  Argument: ['name', 'value'],\n  FragmentSpread: ['name', 'directives'],\n  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],\n  FragmentDefinition: ['name', // Note: fragment variable definitions are experimental and may be changed\n  // or removed in the future.\n  'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],\n  IntValue: [],\n  FloatValue: [],\n  StringValue: [],\n  BooleanValue: [],\n  NullValue: [],\n  EnumValue: [],\n  ListValue: ['values'],\n  ObjectValue: ['fields'],\n  ObjectField: ['name', 'value'],\n  Directive: ['name', 'arguments'],\n  NamedType: ['name'],\n  ListType: ['type'],\n  NonNullType: ['type'],\n  SchemaDefinition: ['directives', 'operationTypes'],\n  OperationTypeDefinition: ['type'],\n  ScalarTypeDefinition: ['description', 'name', 'directives'],\n  ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],\n  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],\n  InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],\n  InterfaceTypeDefinition: ['description', 'name', 'directives', 'fields'],\n  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],\n  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],\n  EnumValueDefinition: ['description', 'name', 'directives'],\n  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],\n  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],\n  SchemaExtension: ['directives', 'operationTypes'],\n  ScalarTypeExtension: ['name', 'directives'],\n  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],\n  InterfaceTypeExtension: ['name', 'directives', 'fields'],\n  UnionTypeExtension: ['name', 'directives', 'types'],\n  EnumTypeExtension: ['name', 'directives', 'values'],\n  InputObjectTypeExtension: ['name', 'directives', 'fields']\n};\nexport var BREAK = {};\n/**\n * visit() will walk through an AST using a depth first traversal, calling\n * the visitor's enter function at each node in the traversal, and calling the\n * leave function after visiting that node and all of its child nodes.\n *\n * By returning different values from the enter and leave functions, the\n * behavior of the visitor can be altered, including skipping over a sub-tree of\n * the AST (by returning false), editing the AST by returning a value or null\n * to remove the value, or to stop the whole traversal by returning BREAK.\n *\n * When using visit() to edit an AST, the original AST will not be modified, and\n * a new version of the AST with the changes applied will be returned from the\n * visit function.\n *\n *     const editedAST = visit(ast, {\n *       enter(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: skip visiting this node\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       },\n *       leave(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: no action\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       }\n *     });\n *\n * Alternatively to providing enter() and leave() functions, a visitor can\n * instead provide functions named the same as the kinds of AST nodes, or\n * enter/leave visitors at a named key, leading to four permutations of\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node a specific kind.\n *\n *     visit(ast, {\n *       Kind(node) {\n *         // enter the \"Kind\" node\n *       }\n *     })\n *\n * 2) Named visitors that trigger upon entering and leaving a node of\n *    a specific kind.\n *\n *     visit(ast, {\n *       Kind: {\n *         enter(node) {\n *           // enter the \"Kind\" node\n *         }\n *         leave(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n *\n * 3) Generic visitors that trigger upon entering and leaving any node.\n *\n *     visit(ast, {\n *       enter(node) {\n *         // enter any node\n *       },\n *       leave(node) {\n *         // leave any node\n *       }\n *     })\n *\n * 4) Parallel visitors for entering and leaving nodes of a specific kind.\n *\n *     visit(ast, {\n *       enter: {\n *         Kind(node) {\n *           // enter the \"Kind\" node\n *         }\n *       },\n *       leave: {\n *         Kind(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n */\n\nexport function visit(root, visitor) {\n  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;\n\n  /* eslint-disable no-undef-init */\n  var stack = undefined;\n  var inArray = Array.isArray(root);\n  var keys = [root];\n  var index = -1;\n  var edits = [];\n  var node = undefined;\n  var key = undefined;\n  var parent = undefined;\n  var path = [];\n  var ancestors = [];\n  var newRoot = root;\n  /* eslint-enable no-undef-init */\n\n  do {\n    index++;\n    var isLeaving = index === keys.length;\n    var isEdited = isLeaving && edits.length !== 0;\n\n    if (isLeaving) {\n      key = ancestors.length === 0 ? undefined : path[path.length - 1];\n      node = parent;\n      parent = ancestors.pop();\n\n      if (isEdited) {\n        if (inArray) {\n          node = node.slice();\n        } else {\n          var clone = {};\n\n          for (var k in node) {\n            if (node.hasOwnProperty(k)) {\n              clone[k] = node[k];\n            }\n          }\n\n          node = clone;\n        }\n\n        var editOffset = 0;\n\n        for (var ii = 0; ii < edits.length; ii++) {\n          var editKey = edits[ii][0];\n          var editValue = edits[ii][1];\n\n          if (inArray) {\n            editKey -= editOffset;\n          }\n\n          if (inArray && editValue === null) {\n            node.splice(editKey, 1);\n            editOffset++;\n          } else {\n            node[editKey] = editValue;\n          }\n        }\n      }\n\n      index = stack.index;\n      keys = stack.keys;\n      edits = stack.edits;\n      inArray = stack.inArray;\n      stack = stack.prev;\n    } else {\n      key = parent ? inArray ? index : keys[index] : undefined;\n      node = parent ? parent[key] : newRoot;\n\n      if (node === null || node === undefined) {\n        continue;\n      }\n\n      if (parent) {\n        path.push(key);\n      }\n    }\n\n    var result = void 0;\n\n    if (!Array.isArray(node)) {\n      if (!isNode(node)) {\n        throw new Error('Invalid AST Node: ' + JSON.stringify(node));\n      }\n\n      var visitFn = getVisitFn(visitor, node.kind, isLeaving);\n\n      if (visitFn) {\n        result = visitFn.call(visitor, node, key, parent, path, ancestors);\n\n        if (result === BREAK) {\n          break;\n        }\n\n        if (result === false) {\n          if (!isLeaving) {\n            path.pop();\n            continue;\n          }\n        } else if (result !== undefined) {\n          edits.push([key, result]);\n\n          if (!isLeaving) {\n            if (isNode(result)) {\n              node = result;\n            } else {\n              path.pop();\n              continue;\n            }\n          }\n        }\n      }\n    }\n\n    if (result === undefined && isEdited) {\n      edits.push([key, node]);\n    }\n\n    if (isLeaving) {\n      path.pop();\n    } else {\n      stack = {\n        inArray: inArray,\n        index: index,\n        keys: keys,\n        edits: edits,\n        prev: stack\n      };\n      inArray = Array.isArray(node);\n      keys = inArray ? node : visitorKeys[node.kind] || [];\n      index = -1;\n      edits = [];\n\n      if (parent) {\n        ancestors.push(parent);\n      }\n\n      parent = node;\n    }\n  } while (stack !== undefined);\n\n  if (edits.length !== 0) {\n    newRoot = edits[edits.length - 1][1];\n  }\n\n  return newRoot;\n}\n\nfunction isNode(maybeNode) {\n  return Boolean(maybeNode && typeof maybeNode.kind === 'string');\n}\n/**\n * Creates a new visitor instance which delegates to many visitors to run in\n * parallel. Each visitor will be visited for each node before moving on.\n *\n * If a prior visitor edits a node, no following visitors will see that node.\n */\n\n\nexport function visitInParallel(visitors) {\n  var skipping = new Array(visitors.length);\n  return {\n    enter: function enter(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (!skipping[i]) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          false);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === false) {\n              skipping[i] = node;\n            } else if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined) {\n              return result;\n            }\n          }\n        }\n      }\n    },\n    leave: function leave(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (!skipping[i]) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          true);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined && result !== false) {\n              return result;\n            }\n          }\n        } else if (skipping[i] === node) {\n          skipping[i] = null;\n        }\n      }\n    }\n  };\n}\n/**\n * Creates a new visitor instance which maintains a provided TypeInfo instance\n * along with visiting visitor.\n */\n\nexport function visitWithTypeInfo(typeInfo, visitor) {\n  return {\n    enter: function enter(node) {\n      typeInfo.enter(node);\n      var fn = getVisitFn(visitor, node.kind,\n      /* isLeaving */\n      false);\n\n      if (fn) {\n        var result = fn.apply(visitor, arguments);\n\n        if (result !== undefined) {\n          typeInfo.leave(node);\n\n          if (isNode(result)) {\n            typeInfo.enter(result);\n          }\n        }\n\n        return result;\n      }\n    },\n    leave: function leave(node) {\n      var fn = getVisitFn(visitor, node.kind,\n      /* isLeaving */\n      true);\n      var result;\n\n      if (fn) {\n        result = fn.apply(visitor, arguments);\n      }\n\n      typeInfo.leave(node);\n      return result;\n    }\n  };\n}\n/**\n * Given a visitor instance, if it is leaving or not, and a node kind, return\n * the function the visitor runtime should call.\n */\n\nexport function getVisitFn(visitor, kind, isLeaving) {\n  var kindVisitor = visitor[kind];\n\n  if (kindVisitor) {\n    if (!isLeaving && typeof kindVisitor === 'function') {\n      // { Kind() {} }\n      return kindVisitor;\n    }\n\n    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;\n\n    if (typeof kindSpecificVisitor === 'function') {\n      // { Kind: { enter() {}, leave() {} } }\n      return kindSpecificVisitor;\n    }\n  } else {\n    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;\n\n    if (specificVisitor) {\n      if (typeof specificVisitor === 'function') {\n        // { enter() {}, leave() {} }\n        return specificVisitor;\n      }\n\n      var specificKindVisitor = specificVisitor[kind];\n\n      if (typeof specificKindVisitor === 'function') {\n        // { enter: { Kind() {} }, leave: { Kind() {} } }\n        return specificKindVisitor;\n      }\n    }\n  }\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\nimport { visit } from './visitor';\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\n\nexport function print(ast) {\n  return visit(ast, {\n    leave: printDocASTReducer\n  });\n}\nvar printDocASTReducer = {\n  Name: function Name(node) {\n    return node.value;\n  },\n  Variable: function Variable(node) {\n    return '$' + node.name;\n  },\n  // Document\n  Document: function Document(node) {\n    return join(node.definitions, '\\n\\n') + '\\n';\n  },\n  OperationDefinition: function OperationDefinition(node) {\n    var op = node.operation;\n    var name = node.name;\n    var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');\n    var directives = join(node.directives, ' ');\n    var selectionSet = node.selectionSet; // Anonymous queries with no directives or variable definitions can use\n    // the query short form.\n\n    return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');\n  },\n  VariableDefinition: function VariableDefinition(_ref) {\n    var variable = _ref.variable,\n        type = _ref.type,\n        defaultValue = _ref.defaultValue,\n        directives = _ref.directives;\n    return variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' '));\n  },\n  SelectionSet: function SelectionSet(_ref2) {\n    var selections = _ref2.selections;\n    return block(selections);\n  },\n  Field: function Field(_ref3) {\n    var alias = _ref3.alias,\n        name = _ref3.name,\n        args = _ref3.arguments,\n        directives = _ref3.directives,\n        selectionSet = _ref3.selectionSet;\n    return join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], ' ');\n  },\n  Argument: function Argument(_ref4) {\n    var name = _ref4.name,\n        value = _ref4.value;\n    return name + ': ' + value;\n  },\n  // Fragments\n  FragmentSpread: function FragmentSpread(_ref5) {\n    var name = _ref5.name,\n        directives = _ref5.directives;\n    return '...' + name + wrap(' ', join(directives, ' '));\n  },\n  InlineFragment: function InlineFragment(_ref6) {\n    var typeCondition = _ref6.typeCondition,\n        directives = _ref6.directives,\n        selectionSet = _ref6.selectionSet;\n    return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');\n  },\n  FragmentDefinition: function FragmentDefinition(_ref7) {\n    var name = _ref7.name,\n        typeCondition = _ref7.typeCondition,\n        variableDefinitions = _ref7.variableDefinitions,\n        directives = _ref7.directives,\n        selectionSet = _ref7.selectionSet;\n    return (// Note: fragment variable definitions are experimental and may be changed\n      // or removed in the future.\n      \"fragment \".concat(name).concat(wrap('(', join(variableDefinitions, ', '), ')'), \" \") + \"on \".concat(typeCondition, \" \").concat(wrap('', join(directives, ' '), ' ')) + selectionSet\n    );\n  },\n  // Value\n  IntValue: function IntValue(_ref8) {\n    var value = _ref8.value;\n    return value;\n  },\n  FloatValue: function FloatValue(_ref9) {\n    var value = _ref9.value;\n    return value;\n  },\n  StringValue: function StringValue(_ref10, key) {\n    var value = _ref10.value,\n        isBlockString = _ref10.block;\n    return isBlockString ? printBlockString(value, key === 'description') : JSON.stringify(value);\n  },\n  BooleanValue: function BooleanValue(_ref11) {\n    var value = _ref11.value;\n    return value ? 'true' : 'false';\n  },\n  NullValue: function NullValue() {\n    return 'null';\n  },\n  EnumValue: function EnumValue(_ref12) {\n    var value = _ref12.value;\n    return value;\n  },\n  ListValue: function ListValue(_ref13) {\n    var values = _ref13.values;\n    return '[' + join(values, ', ') + ']';\n  },\n  ObjectValue: function ObjectValue(_ref14) {\n    var fields = _ref14.fields;\n    return '{' + join(fields, ', ') + '}';\n  },\n  ObjectField: function ObjectField(_ref15) {\n    var name = _ref15.name,\n        value = _ref15.value;\n    return name + ': ' + value;\n  },\n  // Directive\n  Directive: function Directive(_ref16) {\n    var name = _ref16.name,\n        args = _ref16.arguments;\n    return '@' + name + wrap('(', join(args, ', '), ')');\n  },\n  // Type\n  NamedType: function NamedType(_ref17) {\n    var name = _ref17.name;\n    return name;\n  },\n  ListType: function ListType(_ref18) {\n    var type = _ref18.type;\n    return '[' + type + ']';\n  },\n  NonNullType: function NonNullType(_ref19) {\n    var type = _ref19.type;\n    return type + '!';\n  },\n  // Type System Definitions\n  SchemaDefinition: function SchemaDefinition(_ref20) {\n    var directives = _ref20.directives,\n        operationTypes = _ref20.operationTypes;\n    return join(['schema', join(directives, ' '), block(operationTypes)], ' ');\n  },\n  OperationTypeDefinition: function OperationTypeDefinition(_ref21) {\n    var operation = _ref21.operation,\n        type = _ref21.type;\n    return operation + ': ' + type;\n  },\n  ScalarTypeDefinition: addDescription(function (_ref22) {\n    var name = _ref22.name,\n        directives = _ref22.directives;\n    return join(['scalar', name, join(directives, ' ')], ' ');\n  }),\n  ObjectTypeDefinition: addDescription(function (_ref23) {\n    var name = _ref23.name,\n        interfaces = _ref23.interfaces,\n        directives = _ref23.directives,\n        fields = _ref23.fields;\n    return join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');\n  }),\n  FieldDefinition: addDescription(function (_ref24) {\n    var name = _ref24.name,\n        args = _ref24.arguments,\n        type = _ref24.type,\n        directives = _ref24.directives;\n    return name + (args.every(function (arg) {\n      return arg.indexOf('\\n') === -1;\n    }) ? wrap('(', join(args, ', '), ')') : wrap('(\\n', indent(join(args, '\\n')), '\\n)')) + ': ' + type + wrap(' ', join(directives, ' '));\n  }),\n  InputValueDefinition: addDescription(function (_ref25) {\n    var name = _ref25.name,\n        type = _ref25.type,\n        defaultValue = _ref25.defaultValue,\n        directives = _ref25.directives;\n    return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');\n  }),\n  InterfaceTypeDefinition: addDescription(function (_ref26) {\n    var name = _ref26.name,\n        directives = _ref26.directives,\n        fields = _ref26.fields;\n    return join(['interface', name, join(directives, ' '), block(fields)], ' ');\n  }),\n  UnionTypeDefinition: addDescription(function (_ref27) {\n    var name = _ref27.name,\n        directives = _ref27.directives,\n        types = _ref27.types;\n    return join(['union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');\n  }),\n  EnumTypeDefinition: addDescription(function (_ref28) {\n    var name = _ref28.name,\n        directives = _ref28.directives,\n        values = _ref28.values;\n    return join(['enum', name, join(directives, ' '), block(values)], ' ');\n  }),\n  EnumValueDefinition: addDescription(function (_ref29) {\n    var name = _ref29.name,\n        directives = _ref29.directives;\n    return join([name, join(directives, ' ')], ' ');\n  }),\n  InputObjectTypeDefinition: addDescription(function (_ref30) {\n    var name = _ref30.name,\n        directives = _ref30.directives,\n        fields = _ref30.fields;\n    return join(['input', name, join(directives, ' '), block(fields)], ' ');\n  }),\n  DirectiveDefinition: addDescription(function (_ref31) {\n    var name = _ref31.name,\n        args = _ref31.arguments,\n        locations = _ref31.locations;\n    return 'directive @' + name + (args.every(function (arg) {\n      return arg.indexOf('\\n') === -1;\n    }) ? wrap('(', join(args, ', '), ')') : wrap('(\\n', indent(join(args, '\\n')), '\\n)')) + ' on ' + join(locations, ' | ');\n  }),\n  SchemaExtension: function SchemaExtension(_ref32) {\n    var directives = _ref32.directives,\n        operationTypes = _ref32.operationTypes;\n    return join(['extend schema', join(directives, ' '), block(operationTypes)], ' ');\n  },\n  ScalarTypeExtension: function ScalarTypeExtension(_ref33) {\n    var name = _ref33.name,\n        directives = _ref33.directives;\n    return join(['extend scalar', name, join(directives, ' ')], ' ');\n  },\n  ObjectTypeExtension: function ObjectTypeExtension(_ref34) {\n    var name = _ref34.name,\n        interfaces = _ref34.interfaces,\n        directives = _ref34.directives,\n        fields = _ref34.fields;\n    return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');\n  },\n  InterfaceTypeExtension: function InterfaceTypeExtension(_ref35) {\n    var name = _ref35.name,\n        directives = _ref35.directives,\n        fields = _ref35.fields;\n    return join(['extend interface', name, join(directives, ' '), block(fields)], ' ');\n  },\n  UnionTypeExtension: function UnionTypeExtension(_ref36) {\n    var name = _ref36.name,\n        directives = _ref36.directives,\n        types = _ref36.types;\n    return join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');\n  },\n  EnumTypeExtension: function EnumTypeExtension(_ref37) {\n    var name = _ref37.name,\n        directives = _ref37.directives,\n        values = _ref37.values;\n    return join(['extend enum', name, join(directives, ' '), block(values)], ' ');\n  },\n  InputObjectTypeExtension: function InputObjectTypeExtension(_ref38) {\n    var name = _ref38.name,\n        directives = _ref38.directives,\n        fields = _ref38.fields;\n    return join(['extend input', name, join(directives, ' '), block(fields)], ' ');\n  }\n};\n\nfunction addDescription(cb) {\n  return function (node) {\n    return join([node.description, cb(node)], '\\n');\n  };\n}\n/**\n * Given maybeArray, print an empty string if it is null or empty, otherwise\n * print all items together separated by separator if provided\n */\n\n\nfunction join(maybeArray, separator) {\n  return maybeArray ? maybeArray.filter(function (x) {\n    return x;\n  }).join(separator || '') : '';\n}\n/**\n * Given array, print each item on its own line, wrapped in an\n * indented \"{ }\" block.\n */\n\n\nfunction block(array) {\n  return array && array.length !== 0 ? '{\\n' + indent(join(array, '\\n')) + '\\n}' : '';\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise\n * print an empty string.\n */\n\n\nfunction wrap(start, maybeString, end) {\n  return maybeString ? start + maybeString + (end || '') : '';\n}\n\nfunction indent(maybeString) {\n  return maybeString && '  ' + maybeString.replace(/\\n/g, '\\n  ');\n}\n/**\n * Print a block string in the indented block form by adding a leading and\n * trailing blank line. However, if a block string starts with whitespace and is\n * a single-line, adding a leading blank line would strip that whitespace.\n */\n\n\nfunction printBlockString(value, isDescription) {\n  var escaped = value.replace(/\"\"\"/g, '\\\\\"\"\"');\n  return (value[0] === ' ' || value[0] === '\\t') && value.indexOf('\\n') === -1 ? \"\\\"\\\"\\\"\".concat(escaped.replace(/\"$/, '\"\\n'), \"\\\"\\\"\\\"\") : \"\\\"\\\"\\\"\\n\".concat(isDescription ? escaped : indent(escaped), \"\\n\\\"\\\"\\\"\");\n}","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\n\n/**\n * Used to print values in error messages.\n */\nexport default function inspect(value) {\n  return value && _typeof(value) === 'object' ? typeof value.inspect === 'function' ? value.inspect() : Array.isArray(value) ? '[' + value.map(inspect).join(', ') + ']' : '{' + Object.keys(value).map(function (k) {\n    return \"\".concat(k, \": \").concat(inspect(value[k]));\n  }).join(', ') + '}' : typeof value === 'string' ? '\"' + value + '\"' : typeof value === 'function' ? \"[function \".concat(value.name, \"]\") : String(value);\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\nexport default function invariant(condition, message) {\n  /* istanbul ignore else */\n  if (!condition) {\n    throw new Error(message);\n  }\n}","function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\nimport invariant from '../jsutils/invariant';\nimport defineToStringTag from '../jsutils/defineToStringTag';\n\n/**\n * A representation of source input to GraphQL.\n * `name` and `locationOffset` are optional. They are useful for clients who\n * store GraphQL documents in source files; for example, if the GraphQL input\n * starts at line 40 in a file named Foo.graphql, it might be useful for name to\n * be \"Foo.graphql\" and location to be `{ line: 40, column: 0 }`.\n * line and column in locationOffset are 1-indexed\n */\nexport var Source = function Source(body, name, locationOffset) {\n  _defineProperty(this, \"body\", void 0);\n\n  _defineProperty(this, \"name\", void 0);\n\n  _defineProperty(this, \"locationOffset\", void 0);\n\n  this.body = body;\n  this.name = name || 'GraphQL request';\n  this.locationOffset = locationOffset || {\n    line: 1,\n    column: 1\n  };\n  !(this.locationOffset.line > 0) ? invariant(0, 'line in locationOffset is 1-indexed and must be positive') : void 0;\n  !(this.locationOffset.column > 0) ? invariant(0, 'column in locationOffset is 1-indexed and must be positive') : void 0;\n}; // Conditionally apply `[Symbol.toStringTag]` if `Symbol`s are supported\n\ndefineToStringTag(Source);","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\n\n/**\n * The `applyToStringTag()` function checks first to see if the runtime\n * supports the `Symbol` class and then if the `Symbol.toStringTag` constant\n * is defined as a `Symbol` instance. If both conditions are met, the\n * Symbol.toStringTag property is defined as a getter that returns the\n * supplied class constructor's name.\n *\n * @method applyToStringTag\n *\n * @param {Class<any>} classObject a class such as Object, String, Number but\n * typically one of your own creation through the class keyword; `class A {}`,\n * for example.\n */\nexport default function applyToStringTag(classObject) {\n  if (typeof Symbol === 'function' && Symbol.toStringTag) {\n    Object.defineProperty(classObject.prototype, Symbol.toStringTag, {\n      get: function get() {\n        return this.constructor.name;\n      }\n    });\n  }\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\nimport { GraphQLError } from './GraphQLError';\n/**\n * Produces a GraphQLError representing a syntax error, containing useful\n * descriptive information about the syntax error's position in the source.\n */\n\nexport function syntaxError(source, position, description) {\n  return new GraphQLError(\"Syntax Error: \".concat(description), undefined, source, [position]);\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\n\n/**\n * Produces the value of a block string from its parsed raw value, similar to\n * Coffeescript's block string, Python's docstring trim or Ruby's strip_heredoc.\n *\n * This implements the GraphQL spec's BlockStringValue() static algorithm.\n */\nexport default function blockStringValue(rawString) {\n  // Expand a block string's raw value into independent lines.\n  var lines = rawString.split(/\\r\\n|[\\n\\r]/g); // Remove common indentation from all lines but first.\n\n  var commonIndent = null;\n\n  for (var i = 1; i < lines.length; i++) {\n    var line = lines[i];\n    var indent = leadingWhitespace(line);\n\n    if (indent < line.length && (commonIndent === null || indent < commonIndent)) {\n      commonIndent = indent;\n\n      if (commonIndent === 0) {\n        break;\n      }\n    }\n  }\n\n  if (commonIndent) {\n    for (var _i = 1; _i < lines.length; _i++) {\n      lines[_i] = lines[_i].slice(commonIndent);\n    }\n  } // Remove leading and trailing blank lines.\n\n\n  while (lines.length > 0 && isBlank(lines[0])) {\n    lines.shift();\n  }\n\n  while (lines.length > 0 && isBlank(lines[lines.length - 1])) {\n    lines.pop();\n  } // Return a string of the lines joined with U+000A.\n\n\n  return lines.join('\\n');\n}\n\nfunction leadingWhitespace(str) {\n  var i = 0;\n\n  while (i < str.length && (str[i] === ' ' || str[i] === '\\t')) {\n    i++;\n  }\n\n  return i;\n}\n\nfunction isBlank(str) {\n  return leadingWhitespace(str) === str.length;\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\nimport { syntaxError } from '../error';\nimport blockStringValue from './blockStringValue';\n/**\n * Given a Source object, this returns a Lexer for that source.\n * A Lexer is a stateful stream generator in that every time\n * it is advanced, it returns the next token in the Source. Assuming the\n * source lexes, the final Token emitted by the lexer will be of kind\n * EOF, after which the lexer will repeatedly return the same EOF token\n * whenever called.\n */\n\nexport function createLexer(source, options) {\n  var startOfFileToken = new Tok(TokenKind.SOF, 0, 0, 0, 0, null);\n  var lexer = {\n    source: source,\n    options: options,\n    lastToken: startOfFileToken,\n    token: startOfFileToken,\n    line: 1,\n    lineStart: 0,\n    advance: advanceLexer,\n    lookahead: lookahead\n  };\n  return lexer;\n}\n\nfunction advanceLexer() {\n  this.lastToken = this.token;\n  var token = this.token = this.lookahead();\n  return token;\n}\n\nfunction lookahead() {\n  var token = this.token;\n\n  if (token.kind !== TokenKind.EOF) {\n    do {\n      // Note: next is only mutable during parsing, so we cast to allow this.\n      token = token.next || (token.next = readToken(this, token));\n    } while (token.kind === TokenKind.COMMENT);\n  }\n\n  return token;\n}\n/**\n * The return type of createLexer.\n */\n\n\n/**\n * An exported enum describing the different kinds of tokens that the\n * lexer emits.\n */\nexport var TokenKind = Object.freeze({\n  SOF: '<SOF>',\n  EOF: '<EOF>',\n  BANG: '!',\n  DOLLAR: '$',\n  AMP: '&',\n  PAREN_L: '(',\n  PAREN_R: ')',\n  SPREAD: '...',\n  COLON: ':',\n  EQUALS: '=',\n  AT: '@',\n  BRACKET_L: '[',\n  BRACKET_R: ']',\n  BRACE_L: '{',\n  PIPE: '|',\n  BRACE_R: '}',\n  NAME: 'Name',\n  INT: 'Int',\n  FLOAT: 'Float',\n  STRING: 'String',\n  BLOCK_STRING: 'BlockString',\n  COMMENT: 'Comment'\n});\n/**\n * The enum type representing the token kinds values.\n */\n\n/**\n * A helper function to describe a token as a string for debugging\n */\nexport function getTokenDesc(token) {\n  var value = token.value;\n  return value ? \"\".concat(token.kind, \" \\\"\").concat(value, \"\\\"\") : token.kind;\n}\nvar charCodeAt = String.prototype.charCodeAt;\nvar slice = String.prototype.slice;\n/**\n * Helper function for constructing the Token object.\n */\n\nfunction Tok(kind, start, end, line, column, prev, value) {\n  this.kind = kind;\n  this.start = start;\n  this.end = end;\n  this.line = line;\n  this.column = column;\n  this.value = value;\n  this.prev = prev;\n  this.next = null;\n} // Print a simplified form when appearing in JSON/util.inspect.\n\n\nTok.prototype.toJSON = Tok.prototype.inspect = function toJSON() {\n  return {\n    kind: this.kind,\n    value: this.value,\n    line: this.line,\n    column: this.column\n  };\n};\n\nfunction printCharCode(code) {\n  return (// NaN/undefined represents access beyond the end of the file.\n    isNaN(code) ? TokenKind.EOF : // Trust JSON for ASCII.\n    code < 0x007f ? JSON.stringify(String.fromCharCode(code)) : // Otherwise print the escaped form.\n    \"\\\"\\\\u\".concat(('00' + code.toString(16).toUpperCase()).slice(-4), \"\\\"\")\n  );\n}\n/**\n * Gets the next token from the source starting at the given position.\n *\n * This skips over whitespace and comments until it finds the next lexable\n * token, then lexes punctuators immediately or calls the appropriate helper\n * function for more complicated tokens.\n */\n\n\nfunction readToken(lexer, prev) {\n  var source = lexer.source;\n  var body = source.body;\n  var bodyLength = body.length;\n  var pos = positionAfterWhitespace(body, prev.end, lexer);\n  var line = lexer.line;\n  var col = 1 + pos - lexer.lineStart;\n\n  if (pos >= bodyLength) {\n    return new Tok(TokenKind.EOF, bodyLength, bodyLength, line, col, prev);\n  }\n\n  var code = charCodeAt.call(body, pos); // SourceCharacter\n\n  switch (code) {\n    // !\n    case 33:\n      return new Tok(TokenKind.BANG, pos, pos + 1, line, col, prev);\n    // #\n\n    case 35:\n      return readComment(source, pos, line, col, prev);\n    // $\n\n    case 36:\n      return new Tok(TokenKind.DOLLAR, pos, pos + 1, line, col, prev);\n    // &\n\n    case 38:\n      return new Tok(TokenKind.AMP, pos, pos + 1, line, col, prev);\n    // (\n\n    case 40:\n      return new Tok(TokenKind.PAREN_L, pos, pos + 1, line, col, prev);\n    // )\n\n    case 41:\n      return new Tok(TokenKind.PAREN_R, pos, pos + 1, line, col, prev);\n    // .\n\n    case 46:\n      if (charCodeAt.call(body, pos + 1) === 46 && charCodeAt.call(body, pos + 2) === 46) {\n        return new Tok(TokenKind.SPREAD, pos, pos + 3, line, col, prev);\n      }\n\n      break;\n    // :\n\n    case 58:\n      return new Tok(TokenKind.COLON, pos, pos + 1, line, col, prev);\n    // =\n\n    case 61:\n      return new Tok(TokenKind.EQUALS, pos, pos + 1, line, col, prev);\n    // @\n\n    case 64:\n      return new Tok(TokenKind.AT, pos, pos + 1, line, col, prev);\n    // [\n\n    case 91:\n      return new Tok(TokenKind.BRACKET_L, pos, pos + 1, line, col, prev);\n    // ]\n\n    case 93:\n      return new Tok(TokenKind.BRACKET_R, pos, pos + 1, line, col, prev);\n    // {\n\n    case 123:\n      return new Tok(TokenKind.BRACE_L, pos, pos + 1, line, col, prev);\n    // |\n\n    case 124:\n      return new Tok(TokenKind.PIPE, pos, pos + 1, line, col, prev);\n    // }\n\n    case 125:\n      return new Tok(TokenKind.BRACE_R, pos, pos + 1, line, col, prev);\n    // A-Z _ a-z\n\n    case 65:\n    case 66:\n    case 67:\n    case 68:\n    case 69:\n    case 70:\n    case 71:\n    case 72:\n    case 73:\n    case 74:\n    case 75:\n    case 76:\n    case 77:\n    case 78:\n    case 79:\n    case 80:\n    case 81:\n    case 82:\n    case 83:\n    case 84:\n    case 85:\n    case 86:\n    case 87:\n    case 88:\n    case 89:\n    case 90:\n    case 95:\n    case 97:\n    case 98:\n    case 99:\n    case 100:\n    case 101:\n    case 102:\n    case 103:\n    case 104:\n    case 105:\n    case 106:\n    case 107:\n    case 108:\n    case 109:\n    case 110:\n    case 111:\n    case 112:\n    case 113:\n    case 114:\n    case 115:\n    case 116:\n    case 117:\n    case 118:\n    case 119:\n    case 120:\n    case 121:\n    case 122:\n      return readName(source, pos, line, col, prev);\n    // - 0-9\n\n    case 45:\n    case 48:\n    case 49:\n    case 50:\n    case 51:\n    case 52:\n    case 53:\n    case 54:\n    case 55:\n    case 56:\n    case 57:\n      return readNumber(source, pos, code, line, col, prev);\n    // \"\n\n    case 34:\n      if (charCodeAt.call(body, pos + 1) === 34 && charCodeAt.call(body, pos + 2) === 34) {\n        return readBlockString(source, pos, line, col, prev);\n      }\n\n      return readString(source, pos, line, col, prev);\n  }\n\n  throw syntaxError(source, pos, unexpectedCharacterMessage(code));\n}\n/**\n * Report a message that an unexpected character was encountered.\n */\n\n\nfunction unexpectedCharacterMessage(code) {\n  if (code < 0x0020 && code !== 0x0009 && code !== 0x000a && code !== 0x000d) {\n    return \"Cannot contain the invalid character \".concat(printCharCode(code), \".\");\n  }\n\n  if (code === 39) {\n    // '\n    return \"Unexpected single quote character ('), did you mean to use \" + 'a double quote (\")?';\n  }\n\n  return \"Cannot parse the unexpected character \".concat(printCharCode(code), \".\");\n}\n/**\n * Reads from body starting at startPosition until it finds a non-whitespace\n * or commented character, then returns the position of that character for\n * lexing.\n */\n\n\nfunction positionAfterWhitespace(body, startPosition, lexer) {\n  var bodyLength = body.length;\n  var position = startPosition;\n\n  while (position < bodyLength) {\n    var code = charCodeAt.call(body, position); // tab | space | comma | BOM\n\n    if (code === 9 || code === 32 || code === 44 || code === 0xfeff) {\n      ++position;\n    } else if (code === 10) {\n      // new line\n      ++position;\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else if (code === 13) {\n      // carriage return\n      if (charCodeAt.call(body, position + 1) === 10) {\n        position += 2;\n      } else {\n        ++position;\n      }\n\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else {\n      break;\n    }\n  }\n\n  return position;\n}\n/**\n * Reads a comment token from the source file.\n *\n * #[\\u0009\\u0020-\\uFFFF]*\n */\n\n\nfunction readComment(source, start, line, col, prev) {\n  var body = source.body;\n  var code;\n  var position = start;\n\n  do {\n    code = charCodeAt.call(body, ++position);\n  } while (code !== null && ( // SourceCharacter but not LineTerminator\n  code > 0x001f || code === 0x0009));\n\n  return new Tok(TokenKind.COMMENT, start, position, line, col, prev, slice.call(body, start + 1, position));\n}\n/**\n * Reads a number token from the source file, either a float\n * or an int depending on whether a decimal point appears.\n *\n * Int:   -?(0|[1-9][0-9]*)\n * Float: -?(0|[1-9][0-9]*)(\\.[0-9]+)?((E|e)(+|-)?[0-9]+)?\n */\n\n\nfunction readNumber(source, start, firstCode, line, col, prev) {\n  var body = source.body;\n  var code = firstCode;\n  var position = start;\n  var isFloat = false;\n\n  if (code === 45) {\n    // -\n    code = charCodeAt.call(body, ++position);\n  }\n\n  if (code === 48) {\n    // 0\n    code = charCodeAt.call(body, ++position);\n\n    if (code >= 48 && code <= 57) {\n      throw syntaxError(source, position, \"Invalid number, unexpected digit after 0: \".concat(printCharCode(code), \".\"));\n    }\n  } else {\n    position = readDigits(source, position, code);\n    code = charCodeAt.call(body, position);\n  }\n\n  if (code === 46) {\n    // .\n    isFloat = true;\n    code = charCodeAt.call(body, ++position);\n    position = readDigits(source, position, code);\n    code = charCodeAt.call(body, position);\n  }\n\n  if (code === 69 || code === 101) {\n    // E e\n    isFloat = true;\n    code = charCodeAt.call(body, ++position);\n\n    if (code === 43 || code === 45) {\n      // + -\n      code = charCodeAt.call(body, ++position);\n    }\n\n    position = readDigits(source, position, code);\n  }\n\n  return new Tok(isFloat ? TokenKind.FLOAT : TokenKind.INT, start, position, line, col, prev, slice.call(body, start, position));\n}\n/**\n * Returns the new position in the source after reading digits.\n */\n\n\nfunction readDigits(source, start, firstCode) {\n  var body = source.body;\n  var position = start;\n  var code = firstCode;\n\n  if (code >= 48 && code <= 57) {\n    // 0 - 9\n    do {\n      code = charCodeAt.call(body, ++position);\n    } while (code >= 48 && code <= 57); // 0 - 9\n\n\n    return position;\n  }\n\n  throw syntaxError(source, position, \"Invalid number, expected digit but got: \".concat(printCharCode(code), \".\"));\n}\n/**\n * Reads a string token from the source file.\n *\n * \"([^\"\\\\\\u000A\\u000D]|(\\\\(u[0-9a-fA-F]{4}|[\"\\\\/bfnrt])))*\"\n */\n\n\nfunction readString(source, start, line, col, prev) {\n  var body = source.body;\n  var position = start + 1;\n  var chunkStart = position;\n  var code = 0;\n  var value = '';\n\n  while (position < body.length && (code = charCodeAt.call(body, position)) !== null && // not LineTerminator\n  code !== 0x000a && code !== 0x000d) {\n    // Closing Quote (\")\n    if (code === 34) {\n      value += slice.call(body, chunkStart, position);\n      return new Tok(TokenKind.STRING, start, position + 1, line, col, prev, value);\n    } // SourceCharacter\n\n\n    if (code < 0x0020 && code !== 0x0009) {\n      throw syntaxError(source, position, \"Invalid character within String: \".concat(printCharCode(code), \".\"));\n    }\n\n    ++position;\n\n    if (code === 92) {\n      // \\\n      value += slice.call(body, chunkStart, position - 1);\n      code = charCodeAt.call(body, position);\n\n      switch (code) {\n        case 34:\n          value += '\"';\n          break;\n\n        case 47:\n          value += '/';\n          break;\n\n        case 92:\n          value += '\\\\';\n          break;\n\n        case 98:\n          value += '\\b';\n          break;\n\n        case 102:\n          value += '\\f';\n          break;\n\n        case 110:\n          value += '\\n';\n          break;\n\n        case 114:\n          value += '\\r';\n          break;\n\n        case 116:\n          value += '\\t';\n          break;\n\n        case 117:\n          // u\n          var charCode = uniCharCode(charCodeAt.call(body, position + 1), charCodeAt.call(body, position + 2), charCodeAt.call(body, position + 3), charCodeAt.call(body, position + 4));\n\n          if (charCode < 0) {\n            throw syntaxError(source, position, 'Invalid character escape sequence: ' + \"\\\\u\".concat(body.slice(position + 1, position + 5), \".\"));\n          }\n\n          value += String.fromCharCode(charCode);\n          position += 4;\n          break;\n\n        default:\n          throw syntaxError(source, position, \"Invalid character escape sequence: \\\\\".concat(String.fromCharCode(code), \".\"));\n      }\n\n      ++position;\n      chunkStart = position;\n    }\n  }\n\n  throw syntaxError(source, position, 'Unterminated string.');\n}\n/**\n * Reads a block string token from the source file.\n *\n * \"\"\"(\"?\"?(\\\\\"\"\"|\\\\(?!=\"\"\")|[^\"\\\\]))*\"\"\"\n */\n\n\nfunction readBlockString(source, start, line, col, prev) {\n  var body = source.body;\n  var position = start + 3;\n  var chunkStart = position;\n  var code = 0;\n  var rawValue = '';\n\n  while (position < body.length && (code = charCodeAt.call(body, position)) !== null) {\n    // Closing Triple-Quote (\"\"\")\n    if (code === 34 && charCodeAt.call(body, position + 1) === 34 && charCodeAt.call(body, position + 2) === 34) {\n      rawValue += slice.call(body, chunkStart, position);\n      return new Tok(TokenKind.BLOCK_STRING, start, position + 3, line, col, prev, blockStringValue(rawValue));\n    } // SourceCharacter\n\n\n    if (code < 0x0020 && code !== 0x0009 && code !== 0x000a && code !== 0x000d) {\n      throw syntaxError(source, position, \"Invalid character within String: \".concat(printCharCode(code), \".\"));\n    } // Escape Triple-Quote (\\\"\"\")\n\n\n    if (code === 92 && charCodeAt.call(body, position + 1) === 34 && charCodeAt.call(body, position + 2) === 34 && charCodeAt.call(body, position + 3) === 34) {\n      rawValue += slice.call(body, chunkStart, position) + '\"\"\"';\n      position += 4;\n      chunkStart = position;\n    } else {\n      ++position;\n    }\n  }\n\n  throw syntaxError(source, position, 'Unterminated string.');\n}\n/**\n * Converts four hexidecimal chars to the integer that the\n * string represents. For example, uniCharCode('0','0','0','f')\n * will return 15, and uniCharCode('0','0','f','f') returns 255.\n *\n * Returns a negative number on error, if a char was invalid.\n *\n * This is implemented by noting that char2hex() returns -1 on error,\n * which means the result of ORing the char2hex() will also be negative.\n */\n\n\nfunction uniCharCode(a, b, c, d) {\n  return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d);\n}\n/**\n * Converts a hex character to its integer value.\n * '0' becomes 0, '9' becomes 9\n * 'A' becomes 10, 'F' becomes 15\n * 'a' becomes 10, 'f' becomes 15\n *\n * Returns -1 on error.\n */\n\n\nfunction char2hex(a) {\n  return a >= 48 && a <= 57 ? a - 48 // 0-9\n  : a >= 65 && a <= 70 ? a - 55 // A-F\n  : a >= 97 && a <= 102 ? a - 87 // a-f\n  : -1;\n}\n/**\n * Reads an alphanumeric + underscore name from the source.\n *\n * [_A-Za-z][_0-9A-Za-z]*\n */\n\n\nfunction readName(source, start, line, col, prev) {\n  var body = source.body;\n  var bodyLength = body.length;\n  var position = start + 1;\n  var code = 0;\n\n  while (position !== bodyLength && (code = charCodeAt.call(body, position)) !== null && (code === 95 || // _\n  code >= 48 && code <= 57 || // 0-9\n  code >= 65 && code <= 90 || // A-Z\n  code >= 97 && code <= 122) // a-z\n  ) {\n    ++position;\n  }\n\n  return new Tok(TokenKind.NAME, start, position, line, col, prev, slice.call(body, start, position));\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\n\n/**\n * The set of allowed kind values for AST nodes.\n */\nexport var Kind = Object.freeze({\n  // Name\n  NAME: 'Name',\n  // Document\n  DOCUMENT: 'Document',\n  OPERATION_DEFINITION: 'OperationDefinition',\n  VARIABLE_DEFINITION: 'VariableDefinition',\n  SELECTION_SET: 'SelectionSet',\n  FIELD: 'Field',\n  ARGUMENT: 'Argument',\n  // Fragments\n  FRAGMENT_SPREAD: 'FragmentSpread',\n  INLINE_FRAGMENT: 'InlineFragment',\n  FRAGMENT_DEFINITION: 'FragmentDefinition',\n  // Values\n  VARIABLE: 'Variable',\n  INT: 'IntValue',\n  FLOAT: 'FloatValue',\n  STRING: 'StringValue',\n  BOOLEAN: 'BooleanValue',\n  NULL: 'NullValue',\n  ENUM: 'EnumValue',\n  LIST: 'ListValue',\n  OBJECT: 'ObjectValue',\n  OBJECT_FIELD: 'ObjectField',\n  // Directives\n  DIRECTIVE: 'Directive',\n  // Types\n  NAMED_TYPE: 'NamedType',\n  LIST_TYPE: 'ListType',\n  NON_NULL_TYPE: 'NonNullType',\n  // Type System Definitions\n  SCHEMA_DEFINITION: 'SchemaDefinition',\n  OPERATION_TYPE_DEFINITION: 'OperationTypeDefinition',\n  // Type Definitions\n  SCALAR_TYPE_DEFINITION: 'ScalarTypeDefinition',\n  OBJECT_TYPE_DEFINITION: 'ObjectTypeDefinition',\n  FIELD_DEFINITION: 'FieldDefinition',\n  INPUT_VALUE_DEFINITION: 'InputValueDefinition',\n  INTERFACE_TYPE_DEFINITION: 'InterfaceTypeDefinition',\n  UNION_TYPE_DEFINITION: 'UnionTypeDefinition',\n  ENUM_TYPE_DEFINITION: 'EnumTypeDefinition',\n  ENUM_VALUE_DEFINITION: 'EnumValueDefinition',\n  INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',\n  // Directive Definitions\n  DIRECTIVE_DEFINITION: 'DirectiveDefinition',\n  // Type System Extensions\n  SCHEMA_EXTENSION: 'SchemaExtension',\n  // Type Extensions\n  SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',\n  OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',\n  INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',\n  UNION_TYPE_EXTENSION: 'UnionTypeExtension',\n  ENUM_TYPE_EXTENSION: 'EnumTypeExtension',\n  INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension'\n});\n/**\n * The enum type representing the possible kind values of AST nodes.\n */","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\n\n/**\n * The set of allowed directive location values.\n */\nexport var DirectiveLocation = Object.freeze({\n  // Request Definitions\n  QUERY: 'QUERY',\n  MUTATION: 'MUTATION',\n  SUBSCRIPTION: 'SUBSCRIPTION',\n  FIELD: 'FIELD',\n  FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION',\n  FRAGMENT_SPREAD: 'FRAGMENT_SPREAD',\n  INLINE_FRAGMENT: 'INLINE_FRAGMENT',\n  VARIABLE_DEFINITION: 'VARIABLE_DEFINITION',\n  // Type System Definitions\n  SCHEMA: 'SCHEMA',\n  SCALAR: 'SCALAR',\n  OBJECT: 'OBJECT',\n  FIELD_DEFINITION: 'FIELD_DEFINITION',\n  ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION',\n  INTERFACE: 'INTERFACE',\n  UNION: 'UNION',\n  ENUM: 'ENUM',\n  ENUM_VALUE: 'ENUM_VALUE',\n  INPUT_OBJECT: 'INPUT_OBJECT',\n  INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'\n});\n/**\n * The enum type representing the directive location values.\n */","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\nimport inspect from '../jsutils/inspect';\nimport { Source } from './source';\nimport { syntaxError } from '../error';\nimport { createLexer, TokenKind, getTokenDesc } from './lexer';\nimport { Kind } from './kinds';\nimport { DirectiveLocation } from './directiveLocation';\n/**\n * Configuration options to control parser behavior\n */\n\n/**\n * Given a GraphQL source, parses it into a Document.\n * Throws GraphQLError if a syntax error is encountered.\n */\nexport function parse(source, options) {\n  var sourceObj = typeof source === 'string' ? new Source(source) : source;\n\n  if (!(sourceObj instanceof Source)) {\n    throw new TypeError(\"Must provide Source. Received: \".concat(inspect(sourceObj)));\n  }\n\n  var lexer = createLexer(sourceObj, options || {});\n  return parseDocument(lexer);\n}\n/**\n * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for\n * that value.\n * Throws GraphQLError if a syntax error is encountered.\n *\n * This is useful within tools that operate upon GraphQL Values directly and\n * in isolation of complete GraphQL documents.\n *\n * Consider providing the results to the utility function: valueFromAST().\n */\n\nexport function parseValue(source, options) {\n  var sourceObj = typeof source === 'string' ? new Source(source) : source;\n  var lexer = createLexer(sourceObj, options || {});\n  expect(lexer, TokenKind.SOF);\n  var value = parseValueLiteral(lexer, false);\n  expect(lexer, TokenKind.EOF);\n  return value;\n}\n/**\n * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for\n * that type.\n * Throws GraphQLError if a syntax error is encountered.\n *\n * This is useful within tools that operate upon GraphQL Types directly and\n * in isolation of complete GraphQL documents.\n *\n * Consider providing the results to the utility function: typeFromAST().\n */\n\nexport function parseType(source, options) {\n  var sourceObj = typeof source === 'string' ? new Source(source) : source;\n  var lexer = createLexer(sourceObj, options || {});\n  expect(lexer, TokenKind.SOF);\n  var type = parseTypeReference(lexer);\n  expect(lexer, TokenKind.EOF);\n  return type;\n}\n/**\n * Converts a name lex token into a name parse node.\n */\n\nfunction parseName(lexer) {\n  var token = expect(lexer, TokenKind.NAME);\n  return {\n    kind: Kind.NAME,\n    value: token.value,\n    loc: loc(lexer, token)\n  };\n} // Implements the parsing rules in the Document section.\n\n/**\n * Document : Definition+\n */\n\n\nfunction parseDocument(lexer) {\n  var start = lexer.token;\n  return {\n    kind: Kind.DOCUMENT,\n    definitions: many(lexer, TokenKind.SOF, parseDefinition, TokenKind.EOF),\n    loc: loc(lexer, start)\n  };\n}\n/**\n * Definition :\n *   - ExecutableDefinition\n *   - TypeSystemDefinition\n *   - TypeSystemExtension\n */\n\n\nfunction parseDefinition(lexer) {\n  if (peek(lexer, TokenKind.NAME)) {\n    switch (lexer.token.value) {\n      case 'query':\n      case 'mutation':\n      case 'subscription':\n      case 'fragment':\n        return parseExecutableDefinition(lexer);\n\n      case 'schema':\n      case 'scalar':\n      case 'type':\n      case 'interface':\n      case 'union':\n      case 'enum':\n      case 'input':\n      case 'directive':\n        return parseTypeSystemDefinition(lexer);\n\n      case 'extend':\n        return parseTypeSystemExtension(lexer);\n    }\n  } else if (peek(lexer, TokenKind.BRACE_L)) {\n    return parseExecutableDefinition(lexer);\n  } else if (peekDescription(lexer)) {\n    return parseTypeSystemDefinition(lexer);\n  }\n\n  throw unexpected(lexer);\n}\n/**\n * ExecutableDefinition :\n *   - OperationDefinition\n *   - FragmentDefinition\n */\n\n\nfunction parseExecutableDefinition(lexer) {\n  if (peek(lexer, TokenKind.NAME)) {\n    switch (lexer.token.value) {\n      case 'query':\n      case 'mutation':\n      case 'subscription':\n        return parseOperationDefinition(lexer);\n\n      case 'fragment':\n        return parseFragmentDefinition(lexer);\n    }\n  } else if (peek(lexer, TokenKind.BRACE_L)) {\n    return parseOperationDefinition(lexer);\n  }\n\n  throw unexpected(lexer);\n} // Implements the parsing rules in the Operations section.\n\n/**\n * OperationDefinition :\n *  - SelectionSet\n *  - OperationType Name? VariableDefinitions? Directives? SelectionSet\n */\n\n\nfunction parseOperationDefinition(lexer) {\n  var start = lexer.token;\n\n  if (peek(lexer, TokenKind.BRACE_L)) {\n    return {\n      kind: Kind.OPERATION_DEFINITION,\n      operation: 'query',\n      name: undefined,\n      variableDefinitions: [],\n      directives: [],\n      selectionSet: parseSelectionSet(lexer),\n      loc: loc(lexer, start)\n    };\n  }\n\n  var operation = parseOperationType(lexer);\n  var name;\n\n  if (peek(lexer, TokenKind.NAME)) {\n    name = parseName(lexer);\n  }\n\n  return {\n    kind: Kind.OPERATION_DEFINITION,\n    operation: operation,\n    name: name,\n    variableDefinitions: parseVariableDefinitions(lexer),\n    directives: parseDirectives(lexer, false),\n    selectionSet: parseSelectionSet(lexer),\n    loc: loc(lexer, start)\n  };\n}\n/**\n * OperationType : one of query mutation subscription\n */\n\n\nfunction parseOperationType(lexer) {\n  var operationToken = expect(lexer, TokenKind.NAME);\n\n  switch (operationToken.value) {\n    case 'query':\n      return 'query';\n\n    case 'mutation':\n      return 'mutation';\n\n    case 'subscription':\n      return 'subscription';\n  }\n\n  throw unexpected(lexer, operationToken);\n}\n/**\n * VariableDefinitions : ( VariableDefinition+ )\n */\n\n\nfunction parseVariableDefinitions(lexer) {\n  return peek(lexer, TokenKind.PAREN_L) ? many(lexer, TokenKind.PAREN_L, parseVariableDefinition, TokenKind.PAREN_R) : [];\n}\n/**\n * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?\n */\n\n\nfunction parseVariableDefinition(lexer) {\n  var start = lexer.token;\n\n  if (lexer.options.experimentalVariableDefinitionDirectives) {\n    return {\n      kind: Kind.VARIABLE_DEFINITION,\n      variable: parseVariable(lexer),\n      type: (expect(lexer, TokenKind.COLON), parseTypeReference(lexer)),\n      defaultValue: skip(lexer, TokenKind.EQUALS) ? parseValueLiteral(lexer, true) : undefined,\n      directives: parseDirectives(lexer, true),\n      loc: loc(lexer, start)\n    };\n  }\n\n  return {\n    kind: Kind.VARIABLE_DEFINITION,\n    variable: parseVariable(lexer),\n    type: (expect(lexer, TokenKind.COLON), parseTypeReference(lexer)),\n    defaultValue: skip(lexer, TokenKind.EQUALS) ? parseValueLiteral(lexer, true) : undefined,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * Variable : $ Name\n */\n\n\nfunction parseVariable(lexer) {\n  var start = lexer.token;\n  expect(lexer, TokenKind.DOLLAR);\n  return {\n    kind: Kind.VARIABLE,\n    name: parseName(lexer),\n    loc: loc(lexer, start)\n  };\n}\n/**\n * SelectionSet : { Selection+ }\n */\n\n\nfunction parseSelectionSet(lexer) {\n  var start = lexer.token;\n  return {\n    kind: Kind.SELECTION_SET,\n    selections: many(lexer, TokenKind.BRACE_L, parseSelection, TokenKind.BRACE_R),\n    loc: loc(lexer, start)\n  };\n}\n/**\n * Selection :\n *   - Field\n *   - FragmentSpread\n *   - InlineFragment\n */\n\n\nfunction parseSelection(lexer) {\n  return peek(lexer, TokenKind.SPREAD) ? parseFragment(lexer) : parseField(lexer);\n}\n/**\n * Field : Alias? Name Arguments? Directives? SelectionSet?\n *\n * Alias : Name :\n */\n\n\nfunction parseField(lexer) {\n  var start = lexer.token;\n  var nameOrAlias = parseName(lexer);\n  var alias;\n  var name;\n\n  if (skip(lexer, TokenKind.COLON)) {\n    alias = nameOrAlias;\n    name = parseName(lexer);\n  } else {\n    name = nameOrAlias;\n  }\n\n  return {\n    kind: Kind.FIELD,\n    alias: alias,\n    name: name,\n    arguments: parseArguments(lexer, false),\n    directives: parseDirectives(lexer, false),\n    selectionSet: peek(lexer, TokenKind.BRACE_L) ? parseSelectionSet(lexer) : undefined,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * Arguments[Const] : ( Argument[?Const]+ )\n */\n\n\nfunction parseArguments(lexer, isConst) {\n  var item = isConst ? parseConstArgument : parseArgument;\n  return peek(lexer, TokenKind.PAREN_L) ? many(lexer, TokenKind.PAREN_L, item, TokenKind.PAREN_R) : [];\n}\n/**\n * Argument[Const] : Name : Value[?Const]\n */\n\n\nfunction parseArgument(lexer) {\n  var start = lexer.token;\n  return {\n    kind: Kind.ARGUMENT,\n    name: parseName(lexer),\n    value: (expect(lexer, TokenKind.COLON), parseValueLiteral(lexer, false)),\n    loc: loc(lexer, start)\n  };\n}\n\nfunction parseConstArgument(lexer) {\n  var start = lexer.token;\n  return {\n    kind: Kind.ARGUMENT,\n    name: parseName(lexer),\n    value: (expect(lexer, TokenKind.COLON), parseConstValue(lexer)),\n    loc: loc(lexer, start)\n  };\n} // Implements the parsing rules in the Fragments section.\n\n/**\n * Corresponds to both FragmentSpread and InlineFragment in the spec.\n *\n * FragmentSpread : ... FragmentName Directives?\n *\n * InlineFragment : ... TypeCondition? Directives? SelectionSet\n */\n\n\nfunction parseFragment(lexer) {\n  var start = lexer.token;\n  expect(lexer, TokenKind.SPREAD);\n\n  if (peek(lexer, TokenKind.NAME) && lexer.token.value !== 'on') {\n    return {\n      kind: Kind.FRAGMENT_SPREAD,\n      name: parseFragmentName(lexer),\n      directives: parseDirectives(lexer, false),\n      loc: loc(lexer, start)\n    };\n  }\n\n  var typeCondition;\n\n  if (lexer.token.value === 'on') {\n    lexer.advance();\n    typeCondition = parseNamedType(lexer);\n  }\n\n  return {\n    kind: Kind.INLINE_FRAGMENT,\n    typeCondition: typeCondition,\n    directives: parseDirectives(lexer, false),\n    selectionSet: parseSelectionSet(lexer),\n    loc: loc(lexer, start)\n  };\n}\n/**\n * FragmentDefinition :\n *   - fragment FragmentName on TypeCondition Directives? SelectionSet\n *\n * TypeCondition : NamedType\n */\n\n\nfunction parseFragmentDefinition(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'fragment'); // Experimental support for defining variables within fragments changes\n  // the grammar of FragmentDefinition:\n  //   - fragment FragmentName VariableDefinitions? on TypeCondition Directives? SelectionSet\n\n  if (lexer.options.experimentalFragmentVariables) {\n    return {\n      kind: Kind.FRAGMENT_DEFINITION,\n      name: parseFragmentName(lexer),\n      variableDefinitions: parseVariableDefinitions(lexer),\n      typeCondition: (expectKeyword(lexer, 'on'), parseNamedType(lexer)),\n      directives: parseDirectives(lexer, false),\n      selectionSet: parseSelectionSet(lexer),\n      loc: loc(lexer, start)\n    };\n  }\n\n  return {\n    kind: Kind.FRAGMENT_DEFINITION,\n    name: parseFragmentName(lexer),\n    typeCondition: (expectKeyword(lexer, 'on'), parseNamedType(lexer)),\n    directives: parseDirectives(lexer, false),\n    selectionSet: parseSelectionSet(lexer),\n    loc: loc(lexer, start)\n  };\n}\n/**\n * FragmentName : Name but not `on`\n */\n\n\nfunction parseFragmentName(lexer) {\n  if (lexer.token.value === 'on') {\n    throw unexpected(lexer);\n  }\n\n  return parseName(lexer);\n} // Implements the parsing rules in the Values section.\n\n/**\n * Value[Const] :\n *   - [~Const] Variable\n *   - IntValue\n *   - FloatValue\n *   - StringValue\n *   - BooleanValue\n *   - NullValue\n *   - EnumValue\n *   - ListValue[?Const]\n *   - ObjectValue[?Const]\n *\n * BooleanValue : one of `true` `false`\n *\n * NullValue : `null`\n *\n * EnumValue : Name but not `true`, `false` or `null`\n */\n\n\nfunction parseValueLiteral(lexer, isConst) {\n  var token = lexer.token;\n\n  switch (token.kind) {\n    case TokenKind.BRACKET_L:\n      return parseList(lexer, isConst);\n\n    case TokenKind.BRACE_L:\n      return parseObject(lexer, isConst);\n\n    case TokenKind.INT:\n      lexer.advance();\n      return {\n        kind: Kind.INT,\n        value: token.value,\n        loc: loc(lexer, token)\n      };\n\n    case TokenKind.FLOAT:\n      lexer.advance();\n      return {\n        kind: Kind.FLOAT,\n        value: token.value,\n        loc: loc(lexer, token)\n      };\n\n    case TokenKind.STRING:\n    case TokenKind.BLOCK_STRING:\n      return parseStringLiteral(lexer);\n\n    case TokenKind.NAME:\n      if (token.value === 'true' || token.value === 'false') {\n        lexer.advance();\n        return {\n          kind: Kind.BOOLEAN,\n          value: token.value === 'true',\n          loc: loc(lexer, token)\n        };\n      } else if (token.value === 'null') {\n        lexer.advance();\n        return {\n          kind: Kind.NULL,\n          loc: loc(lexer, token)\n        };\n      }\n\n      lexer.advance();\n      return {\n        kind: Kind.ENUM,\n        value: token.value,\n        loc: loc(lexer, token)\n      };\n\n    case TokenKind.DOLLAR:\n      if (!isConst) {\n        return parseVariable(lexer);\n      }\n\n      break;\n  }\n\n  throw unexpected(lexer);\n}\n\nfunction parseStringLiteral(lexer) {\n  var token = lexer.token;\n  lexer.advance();\n  return {\n    kind: Kind.STRING,\n    value: token.value,\n    block: token.kind === TokenKind.BLOCK_STRING,\n    loc: loc(lexer, token)\n  };\n}\n\nexport function parseConstValue(lexer) {\n  return parseValueLiteral(lexer, true);\n}\n\nfunction parseValueValue(lexer) {\n  return parseValueLiteral(lexer, false);\n}\n/**\n * ListValue[Const] :\n *   - [ ]\n *   - [ Value[?Const]+ ]\n */\n\n\nfunction parseList(lexer, isConst) {\n  var start = lexer.token;\n  var item = isConst ? parseConstValue : parseValueValue;\n  return {\n    kind: Kind.LIST,\n    values: any(lexer, TokenKind.BRACKET_L, item, TokenKind.BRACKET_R),\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ObjectValue[Const] :\n *   - { }\n *   - { ObjectField[?Const]+ }\n */\n\n\nfunction parseObject(lexer, isConst) {\n  var start = lexer.token;\n  expect(lexer, TokenKind.BRACE_L);\n  var fields = [];\n\n  while (!skip(lexer, TokenKind.BRACE_R)) {\n    fields.push(parseObjectField(lexer, isConst));\n  }\n\n  return {\n    kind: Kind.OBJECT,\n    fields: fields,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ObjectField[Const] : Name : Value[?Const]\n */\n\n\nfunction parseObjectField(lexer, isConst) {\n  var start = lexer.token;\n  return {\n    kind: Kind.OBJECT_FIELD,\n    name: parseName(lexer),\n    value: (expect(lexer, TokenKind.COLON), parseValueLiteral(lexer, isConst)),\n    loc: loc(lexer, start)\n  };\n} // Implements the parsing rules in the Directives section.\n\n/**\n * Directives[Const] : Directive[?Const]+\n */\n\n\nfunction parseDirectives(lexer, isConst) {\n  var directives = [];\n\n  while (peek(lexer, TokenKind.AT)) {\n    directives.push(parseDirective(lexer, isConst));\n  }\n\n  return directives;\n}\n/**\n * Directive[Const] : @ Name Arguments[?Const]?\n */\n\n\nfunction parseDirective(lexer, isConst) {\n  var start = lexer.token;\n  expect(lexer, TokenKind.AT);\n  return {\n    kind: Kind.DIRECTIVE,\n    name: parseName(lexer),\n    arguments: parseArguments(lexer, isConst),\n    loc: loc(lexer, start)\n  };\n} // Implements the parsing rules in the Types section.\n\n/**\n * Type :\n *   - NamedType\n *   - ListType\n *   - NonNullType\n */\n\n\nexport function parseTypeReference(lexer) {\n  var start = lexer.token;\n  var type;\n\n  if (skip(lexer, TokenKind.BRACKET_L)) {\n    type = parseTypeReference(lexer);\n    expect(lexer, TokenKind.BRACKET_R);\n    type = {\n      kind: Kind.LIST_TYPE,\n      type: type,\n      loc: loc(lexer, start)\n    };\n  } else {\n    type = parseNamedType(lexer);\n  }\n\n  if (skip(lexer, TokenKind.BANG)) {\n    return {\n      kind: Kind.NON_NULL_TYPE,\n      type: type,\n      loc: loc(lexer, start)\n    };\n  }\n\n  return type;\n}\n/**\n * NamedType : Name\n */\n\nexport function parseNamedType(lexer) {\n  var start = lexer.token;\n  return {\n    kind: Kind.NAMED_TYPE,\n    name: parseName(lexer),\n    loc: loc(lexer, start)\n  };\n} // Implements the parsing rules in the Type Definition section.\n\n/**\n * TypeSystemDefinition :\n *   - SchemaDefinition\n *   - TypeDefinition\n *   - DirectiveDefinition\n *\n * TypeDefinition :\n *   - ScalarTypeDefinition\n *   - ObjectTypeDefinition\n *   - InterfaceTypeDefinition\n *   - UnionTypeDefinition\n *   - EnumTypeDefinition\n *   - InputObjectTypeDefinition\n */\n\nfunction parseTypeSystemDefinition(lexer) {\n  // Many definitions begin with a description and require a lookahead.\n  var keywordToken = peekDescription(lexer) ? lexer.lookahead() : lexer.token;\n\n  if (keywordToken.kind === TokenKind.NAME) {\n    switch (keywordToken.value) {\n      case 'schema':\n        return parseSchemaDefinition(lexer);\n\n      case 'scalar':\n        return parseScalarTypeDefinition(lexer);\n\n      case 'type':\n        return parseObjectTypeDefinition(lexer);\n\n      case 'interface':\n        return parseInterfaceTypeDefinition(lexer);\n\n      case 'union':\n        return parseUnionTypeDefinition(lexer);\n\n      case 'enum':\n        return parseEnumTypeDefinition(lexer);\n\n      case 'input':\n        return parseInputObjectTypeDefinition(lexer);\n\n      case 'directive':\n        return parseDirectiveDefinition(lexer);\n    }\n  }\n\n  throw unexpected(lexer, keywordToken);\n}\n\nfunction peekDescription(lexer) {\n  return peek(lexer, TokenKind.STRING) || peek(lexer, TokenKind.BLOCK_STRING);\n}\n/**\n * Description : StringValue\n */\n\n\nfunction parseDescription(lexer) {\n  if (peekDescription(lexer)) {\n    return parseStringLiteral(lexer);\n  }\n}\n/**\n * SchemaDefinition : schema Directives[Const]? { OperationTypeDefinition+ }\n */\n\n\nfunction parseSchemaDefinition(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'schema');\n  var directives = parseDirectives(lexer, true);\n  var operationTypes = many(lexer, TokenKind.BRACE_L, parseOperationTypeDefinition, TokenKind.BRACE_R);\n  return {\n    kind: Kind.SCHEMA_DEFINITION,\n    directives: directives,\n    operationTypes: operationTypes,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * OperationTypeDefinition : OperationType : NamedType\n */\n\n\nfunction parseOperationTypeDefinition(lexer) {\n  var start = lexer.token;\n  var operation = parseOperationType(lexer);\n  expect(lexer, TokenKind.COLON);\n  var type = parseNamedType(lexer);\n  return {\n    kind: Kind.OPERATION_TYPE_DEFINITION,\n    operation: operation,\n    type: type,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ScalarTypeDefinition : Description? scalar Name Directives[Const]?\n */\n\n\nfunction parseScalarTypeDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  expectKeyword(lexer, 'scalar');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  return {\n    kind: Kind.SCALAR_TYPE_DEFINITION,\n    description: description,\n    name: name,\n    directives: directives,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ObjectTypeDefinition :\n *   Description?\n *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?\n */\n\n\nfunction parseObjectTypeDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  expectKeyword(lexer, 'type');\n  var name = parseName(lexer);\n  var interfaces = parseImplementsInterfaces(lexer);\n  var directives = parseDirectives(lexer, true);\n  var fields = parseFieldsDefinition(lexer);\n  return {\n    kind: Kind.OBJECT_TYPE_DEFINITION,\n    description: description,\n    name: name,\n    interfaces: interfaces,\n    directives: directives,\n    fields: fields,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ImplementsInterfaces :\n *   - implements `&`? NamedType\n *   - ImplementsInterfaces & NamedType\n */\n\n\nfunction parseImplementsInterfaces(lexer) {\n  var types = [];\n\n  if (lexer.token.value === 'implements') {\n    lexer.advance(); // Optional leading ampersand\n\n    skip(lexer, TokenKind.AMP);\n\n    do {\n      types.push(parseNamedType(lexer));\n    } while (skip(lexer, TokenKind.AMP) || // Legacy support for the SDL?\n    lexer.options.allowLegacySDLImplementsInterfaces && peek(lexer, TokenKind.NAME));\n  }\n\n  return types;\n}\n/**\n * FieldsDefinition : { FieldDefinition+ }\n */\n\n\nfunction parseFieldsDefinition(lexer) {\n  // Legacy support for the SDL?\n  if (lexer.options.allowLegacySDLEmptyFields && peek(lexer, TokenKind.BRACE_L) && lexer.lookahead().kind === TokenKind.BRACE_R) {\n    lexer.advance();\n    lexer.advance();\n    return [];\n  }\n\n  return peek(lexer, TokenKind.BRACE_L) ? many(lexer, TokenKind.BRACE_L, parseFieldDefinition, TokenKind.BRACE_R) : [];\n}\n/**\n * FieldDefinition :\n *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?\n */\n\n\nfunction parseFieldDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  var name = parseName(lexer);\n  var args = parseArgumentDefs(lexer);\n  expect(lexer, TokenKind.COLON);\n  var type = parseTypeReference(lexer);\n  var directives = parseDirectives(lexer, true);\n  return {\n    kind: Kind.FIELD_DEFINITION,\n    description: description,\n    name: name,\n    arguments: args,\n    type: type,\n    directives: directives,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ArgumentsDefinition : ( InputValueDefinition+ )\n */\n\n\nfunction parseArgumentDefs(lexer) {\n  if (!peek(lexer, TokenKind.PAREN_L)) {\n    return [];\n  }\n\n  return many(lexer, TokenKind.PAREN_L, parseInputValueDef, TokenKind.PAREN_R);\n}\n/**\n * InputValueDefinition :\n *   - Description? Name : Type DefaultValue? Directives[Const]?\n */\n\n\nfunction parseInputValueDef(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  var name = parseName(lexer);\n  expect(lexer, TokenKind.COLON);\n  var type = parseTypeReference(lexer);\n  var defaultValue;\n\n  if (skip(lexer, TokenKind.EQUALS)) {\n    defaultValue = parseConstValue(lexer);\n  }\n\n  var directives = parseDirectives(lexer, true);\n  return {\n    kind: Kind.INPUT_VALUE_DEFINITION,\n    description: description,\n    name: name,\n    type: type,\n    defaultValue: defaultValue,\n    directives: directives,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * InterfaceTypeDefinition :\n *   - Description? interface Name Directives[Const]? FieldsDefinition?\n */\n\n\nfunction parseInterfaceTypeDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  expectKeyword(lexer, 'interface');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var fields = parseFieldsDefinition(lexer);\n  return {\n    kind: Kind.INTERFACE_TYPE_DEFINITION,\n    description: description,\n    name: name,\n    directives: directives,\n    fields: fields,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * UnionTypeDefinition :\n *   - Description? union Name Directives[Const]? UnionMemberTypes?\n */\n\n\nfunction parseUnionTypeDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  expectKeyword(lexer, 'union');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var types = parseUnionMemberTypes(lexer);\n  return {\n    kind: Kind.UNION_TYPE_DEFINITION,\n    description: description,\n    name: name,\n    directives: directives,\n    types: types,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * UnionMemberTypes :\n *   - = `|`? NamedType\n *   - UnionMemberTypes | NamedType\n */\n\n\nfunction parseUnionMemberTypes(lexer) {\n  var types = [];\n\n  if (skip(lexer, TokenKind.EQUALS)) {\n    // Optional leading pipe\n    skip(lexer, TokenKind.PIPE);\n\n    do {\n      types.push(parseNamedType(lexer));\n    } while (skip(lexer, TokenKind.PIPE));\n  }\n\n  return types;\n}\n/**\n * EnumTypeDefinition :\n *   - Description? enum Name Directives[Const]? EnumValuesDefinition?\n */\n\n\nfunction parseEnumTypeDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  expectKeyword(lexer, 'enum');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var values = parseEnumValuesDefinition(lexer);\n  return {\n    kind: Kind.ENUM_TYPE_DEFINITION,\n    description: description,\n    name: name,\n    directives: directives,\n    values: values,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * EnumValuesDefinition : { EnumValueDefinition+ }\n */\n\n\nfunction parseEnumValuesDefinition(lexer) {\n  return peek(lexer, TokenKind.BRACE_L) ? many(lexer, TokenKind.BRACE_L, parseEnumValueDefinition, TokenKind.BRACE_R) : [];\n}\n/**\n * EnumValueDefinition : Description? EnumValue Directives[Const]?\n *\n * EnumValue : Name\n */\n\n\nfunction parseEnumValueDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  return {\n    kind: Kind.ENUM_VALUE_DEFINITION,\n    description: description,\n    name: name,\n    directives: directives,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * InputObjectTypeDefinition :\n *   - Description? input Name Directives[Const]? InputFieldsDefinition?\n */\n\n\nfunction parseInputObjectTypeDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  expectKeyword(lexer, 'input');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var fields = parseInputFieldsDefinition(lexer);\n  return {\n    kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,\n    description: description,\n    name: name,\n    directives: directives,\n    fields: fields,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * InputFieldsDefinition : { InputValueDefinition+ }\n */\n\n\nfunction parseInputFieldsDefinition(lexer) {\n  return peek(lexer, TokenKind.BRACE_L) ? many(lexer, TokenKind.BRACE_L, parseInputValueDef, TokenKind.BRACE_R) : [];\n}\n/**\n * TypeSystemExtension :\n *   - SchemaExtension\n *   - TypeExtension\n *\n * TypeExtension :\n *   - ScalarTypeExtension\n *   - ObjectTypeExtension\n *   - InterfaceTypeExtension\n *   - UnionTypeExtension\n *   - EnumTypeExtension\n *   - InputObjectTypeDefinition\n */\n\n\nfunction parseTypeSystemExtension(lexer) {\n  var keywordToken = lexer.lookahead();\n\n  if (keywordToken.kind === TokenKind.NAME) {\n    switch (keywordToken.value) {\n      case 'schema':\n        return parseSchemaExtension(lexer);\n\n      case 'scalar':\n        return parseScalarTypeExtension(lexer);\n\n      case 'type':\n        return parseObjectTypeExtension(lexer);\n\n      case 'interface':\n        return parseInterfaceTypeExtension(lexer);\n\n      case 'union':\n        return parseUnionTypeExtension(lexer);\n\n      case 'enum':\n        return parseEnumTypeExtension(lexer);\n\n      case 'input':\n        return parseInputObjectTypeExtension(lexer);\n    }\n  }\n\n  throw unexpected(lexer, keywordToken);\n}\n/**\n * SchemaExtension :\n *  - extend schema Directives[Const]? { OperationTypeDefinition+ }\n *  - extend schema Directives[Const]\n */\n\n\nfunction parseSchemaExtension(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'extend');\n  expectKeyword(lexer, 'schema');\n  var directives = parseDirectives(lexer, true);\n  var operationTypes = peek(lexer, TokenKind.BRACE_L) ? many(lexer, TokenKind.BRACE_L, parseOperationTypeDefinition, TokenKind.BRACE_R) : [];\n\n  if (directives.length === 0 && operationTypes.length === 0) {\n    throw unexpected(lexer);\n  }\n\n  return {\n    kind: Kind.SCHEMA_EXTENSION,\n    directives: directives,\n    operationTypes: operationTypes,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ScalarTypeExtension :\n *   - extend scalar Name Directives[Const]\n */\n\n\nfunction parseScalarTypeExtension(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'extend');\n  expectKeyword(lexer, 'scalar');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n\n  if (directives.length === 0) {\n    throw unexpected(lexer);\n  }\n\n  return {\n    kind: Kind.SCALAR_TYPE_EXTENSION,\n    name: name,\n    directives: directives,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * ObjectTypeExtension :\n *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition\n *  - extend type Name ImplementsInterfaces? Directives[Const]\n *  - extend type Name ImplementsInterfaces\n */\n\n\nfunction parseObjectTypeExtension(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'extend');\n  expectKeyword(lexer, 'type');\n  var name = parseName(lexer);\n  var interfaces = parseImplementsInterfaces(lexer);\n  var directives = parseDirectives(lexer, true);\n  var fields = parseFieldsDefinition(lexer);\n\n  if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {\n    throw unexpected(lexer);\n  }\n\n  return {\n    kind: Kind.OBJECT_TYPE_EXTENSION,\n    name: name,\n    interfaces: interfaces,\n    directives: directives,\n    fields: fields,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * InterfaceTypeExtension :\n *   - extend interface Name Directives[Const]? FieldsDefinition\n *   - extend interface Name Directives[Const]\n */\n\n\nfunction parseInterfaceTypeExtension(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'extend');\n  expectKeyword(lexer, 'interface');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var fields = parseFieldsDefinition(lexer);\n\n  if (directives.length === 0 && fields.length === 0) {\n    throw unexpected(lexer);\n  }\n\n  return {\n    kind: Kind.INTERFACE_TYPE_EXTENSION,\n    name: name,\n    directives: directives,\n    fields: fields,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * UnionTypeExtension :\n *   - extend union Name Directives[Const]? UnionMemberTypes\n *   - extend union Name Directives[Const]\n */\n\n\nfunction parseUnionTypeExtension(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'extend');\n  expectKeyword(lexer, 'union');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var types = parseUnionMemberTypes(lexer);\n\n  if (directives.length === 0 && types.length === 0) {\n    throw unexpected(lexer);\n  }\n\n  return {\n    kind: Kind.UNION_TYPE_EXTENSION,\n    name: name,\n    directives: directives,\n    types: types,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * EnumTypeExtension :\n *   - extend enum Name Directives[Const]? EnumValuesDefinition\n *   - extend enum Name Directives[Const]\n */\n\n\nfunction parseEnumTypeExtension(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'extend');\n  expectKeyword(lexer, 'enum');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var values = parseEnumValuesDefinition(lexer);\n\n  if (directives.length === 0 && values.length === 0) {\n    throw unexpected(lexer);\n  }\n\n  return {\n    kind: Kind.ENUM_TYPE_EXTENSION,\n    name: name,\n    directives: directives,\n    values: values,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * InputObjectTypeExtension :\n *   - extend input Name Directives[Const]? InputFieldsDefinition\n *   - extend input Name Directives[Const]\n */\n\n\nfunction parseInputObjectTypeExtension(lexer) {\n  var start = lexer.token;\n  expectKeyword(lexer, 'extend');\n  expectKeyword(lexer, 'input');\n  var name = parseName(lexer);\n  var directives = parseDirectives(lexer, true);\n  var fields = parseInputFieldsDefinition(lexer);\n\n  if (directives.length === 0 && fields.length === 0) {\n    throw unexpected(lexer);\n  }\n\n  return {\n    kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,\n    name: name,\n    directives: directives,\n    fields: fields,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * DirectiveDefinition :\n *   - Description? directive @ Name ArgumentsDefinition? on DirectiveLocations\n */\n\n\nfunction parseDirectiveDefinition(lexer) {\n  var start = lexer.token;\n  var description = parseDescription(lexer);\n  expectKeyword(lexer, 'directive');\n  expect(lexer, TokenKind.AT);\n  var name = parseName(lexer);\n  var args = parseArgumentDefs(lexer);\n  expectKeyword(lexer, 'on');\n  var locations = parseDirectiveLocations(lexer);\n  return {\n    kind: Kind.DIRECTIVE_DEFINITION,\n    description: description,\n    name: name,\n    arguments: args,\n    locations: locations,\n    loc: loc(lexer, start)\n  };\n}\n/**\n * DirectiveLocations :\n *   - `|`? DirectiveLocation\n *   - DirectiveLocations | DirectiveLocation\n */\n\n\nfunction parseDirectiveLocations(lexer) {\n  // Optional leading pipe\n  skip(lexer, TokenKind.PIPE);\n  var locations = [];\n\n  do {\n    locations.push(parseDirectiveLocation(lexer));\n  } while (skip(lexer, TokenKind.PIPE));\n\n  return locations;\n}\n/*\n * DirectiveLocation :\n *   - ExecutableDirectiveLocation\n *   - TypeSystemDirectiveLocation\n *\n * ExecutableDirectiveLocation : one of\n *   `QUERY`\n *   `MUTATION`\n *   `SUBSCRIPTION`\n *   `FIELD`\n *   `FRAGMENT_DEFINITION`\n *   `FRAGMENT_SPREAD`\n *   `INLINE_FRAGMENT`\n *\n * TypeSystemDirectiveLocation : one of\n *   `SCHEMA`\n *   `SCALAR`\n *   `OBJECT`\n *   `FIELD_DEFINITION`\n *   `ARGUMENT_DEFINITION`\n *   `INTERFACE`\n *   `UNION`\n *   `ENUM`\n *   `ENUM_VALUE`\n *   `INPUT_OBJECT`\n *   `INPUT_FIELD_DEFINITION`\n */\n\n\nfunction parseDirectiveLocation(lexer) {\n  var start = lexer.token;\n  var name = parseName(lexer);\n\n  if (DirectiveLocation.hasOwnProperty(name.value)) {\n    return name;\n  }\n\n  throw unexpected(lexer, start);\n} // Core parsing utility functions\n\n/**\n * Returns a location object, used to identify the place in\n * the source that created a given parsed object.\n */\n\n\nfunction loc(lexer, startToken) {\n  if (!lexer.options.noLocation) {\n    return new Loc(startToken, lexer.lastToken, lexer.source);\n  }\n}\n\nfunction Loc(startToken, endToken, source) {\n  this.start = startToken.start;\n  this.end = endToken.end;\n  this.startToken = startToken;\n  this.endToken = endToken;\n  this.source = source;\n} // Print a simplified form when appearing in JSON/util.inspect.\n\n\nLoc.prototype.toJSON = Loc.prototype.inspect = function toJSON() {\n  return {\n    start: this.start,\n    end: this.end\n  };\n};\n/**\n * Determines if the next token is of a given kind\n */\n\n\nfunction peek(lexer, kind) {\n  return lexer.token.kind === kind;\n}\n/**\n * If the next token is of the given kind, return true after advancing\n * the lexer. Otherwise, do not change the parser state and return false.\n */\n\n\nfunction skip(lexer, kind) {\n  var match = lexer.token.kind === kind;\n\n  if (match) {\n    lexer.advance();\n  }\n\n  return match;\n}\n/**\n * If the next token is of the given kind, return that token after advancing\n * the lexer. Otherwise, do not change the parser state and throw an error.\n */\n\n\nfunction expect(lexer, kind) {\n  var token = lexer.token;\n\n  if (token.kind === kind) {\n    lexer.advance();\n    return token;\n  }\n\n  throw syntaxError(lexer.source, token.start, \"Expected \".concat(kind, \", found \").concat(getTokenDesc(token)));\n}\n/**\n * If the next token is a keyword with the given value, return that token after\n * advancing the lexer. Otherwise, do not change the parser state and return\n * false.\n */\n\n\nfunction expectKeyword(lexer, value) {\n  var token = lexer.token;\n\n  if (token.kind === TokenKind.NAME && token.value === value) {\n    lexer.advance();\n    return token;\n  }\n\n  throw syntaxError(lexer.source, token.start, \"Expected \\\"\".concat(value, \"\\\", found \").concat(getTokenDesc(token)));\n}\n/**\n * Helper function for creating an error when an unexpected lexed token\n * is encountered.\n */\n\n\nfunction unexpected(lexer, atToken) {\n  var token = atToken || lexer.token;\n  return syntaxError(lexer.source, token.start, \"Unexpected \".concat(getTokenDesc(token)));\n}\n/**\n * Returns a possibly empty list of parse nodes, determined by\n * the parseFn. This list begins with a lex token of openKind\n * and ends with a lex token of closeKind. Advances the parser\n * to the next lex token after the closing token.\n */\n\n\nfunction any(lexer, openKind, parseFn, closeKind) {\n  expect(lexer, openKind);\n  var nodes = [];\n\n  while (!skip(lexer, closeKind)) {\n    nodes.push(parseFn(lexer));\n  }\n\n  return nodes;\n}\n/**\n * Returns a non-empty list of parse nodes, determined by\n * the parseFn. This list begins with a lex token of openKind\n * and ends with a lex token of closeKind. Advances the parser\n * to the next lex token after the closing token.\n */\n\n\nfunction many(lexer, openKind, parseFn, closeKind) {\n  expect(lexer, openKind);\n  var nodes = [parseFn(lexer)];\n\n  while (!skip(lexer, closeKind)) {\n    nodes.push(parseFn(lexer));\n  }\n\n  return nodes;\n}",null,"/* tslint:disable */\n\nimport zenObservable from 'zen-observable';\n\nnamespace Observable {\n\n}\n\nimport { ZenObservable } from './types';\n\nexport { ZenObservable };\n\nexport type Observer<T> = ZenObservable.Observer<T>;\nexport type Subscriber<T> = ZenObservable.Subscriber<T>;\nexport type ObservableLike<T> = ZenObservable.ObservableLike<T>;\n\nexport const Observable: {\n  new <T>(subscriber: Subscriber<T>): Observable<T>;\n  from<R>(\n    observable: Observable<R> | ZenObservable.ObservableLike<R> | ArrayLike<R>,\n  ): Observable<R>;\n  of<R>(...args: Array<R>): Observable<R>;\n} = <any>zenObservable;\n\nexport interface Observable<T> {\n  subscribe(\n    observerOrNext: ((value: T) => void) | ZenObservable.Observer<T>,\n    error?: (error: any) => void,\n    complete?: () => void,\n  ): ZenObservable.Subscription;\n\n  forEach(fn: (value: T) => void): Promise<void>;\n\n  map<R>(fn: (value: T) => R): Observable<R>;\n\n  filter(fn: (value: T) => boolean): Observable<T>;\n\n  reduce<R = T>(\n    fn: (previousValue: R | T, currentValue: T) => R | T,\n    initialValue?: R | T,\n  ): Observable<R | T>;\n\n  flatMap<R>(fn: (value: T) => ZenObservable.ObservableLike<R>): Observable<R>;\n\n  from<R>(\n    observable: Observable<R> | ZenObservable.ObservableLike<R> | ArrayLike<R>,\n  ): Observable<R>;\n  of<R>(...args: Array<R>): Observable<R>;\n}\n",null,"var v1 = require('./v1');\nvar v4 = require('./v4');\n\nvar uuid = v4;\nuuid.v1 = v1;\nuuid.v4 = v4;\n\nmodule.exports = uuid;\n","// Unique ID creation requires a high quality random # generator.  In the\n// browser this is a little complicated due to unknown quality of Math.random()\n// and inconsistent support for the `crypto` API.  We do the best we can via\n// feature-detection\n\n// getRandomValues needs to be invoked in a context where \"this\" is a Crypto\n// implementation. Also, find the complete implementation of crypto on IE11.\nvar getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||\n                      (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));\n\nif (getRandomValues) {\n  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef\n\n  module.exports = function whatwgRNG() {\n    getRandomValues(rnds8);\n    return rnds8;\n  };\n} else {\n  // Math.random()-based (RNG)\n  //\n  // If all else fails, use Math.random().  It's fast, but is of unspecified\n  // quality.\n  var rnds = new Array(16);\n\n  module.exports = function mathRNG() {\n    for (var i = 0, r; i < 16; i++) {\n      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;\n      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;\n    }\n\n    return rnds;\n  };\n}\n","/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\nvar byteToHex = [];\nfor (var i = 0; i < 256; ++i) {\n  byteToHex[i] = (i + 0x100).toString(16).substr(1);\n}\n\nfunction bytesToUuid(buf, offset) {\n  var i = offset || 0;\n  var bth = byteToHex;\n  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n  return ([\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]]\n  ]).join('');\n}\n\nmodule.exports = bytesToUuid;\n","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\n\n/**\n * Represents a location in a Source.\n */\n\n/**\n * Takes a Source and a UTF-8 character offset, and returns the corresponding\n * line and column as a SourceLocation.\n */\nexport function getLocation(source, position) {\n  var lineRegexp = /\\r\\n|[\\n\\r]/g;\n  var line = 1;\n  var column = position + 1;\n  var match;\n\n  while ((match = lineRegexp.exec(source.body)) && match.index < position) {\n    line += 1;\n    column = position + 1 - (match.index + match[0].length);\n  }\n\n  return {\n    line: line,\n    column: column\n  };\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\nimport { getLocation } from '../language/location';\n\n/**\n * Prints a GraphQLError to a string, representing useful location information\n * about the error's position in the source.\n */\nexport function printError(error) {\n  var printedLocations = [];\n\n  if (error.nodes) {\n    var _iteratorNormalCompletion = true;\n    var _didIteratorError = false;\n    var _iteratorError = undefined;\n\n    try {\n      for (var _iterator = error.nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n        var node = _step.value;\n\n        if (node.loc) {\n          printedLocations.push(highlightSourceAtLocation(node.loc.source, getLocation(node.loc.source, node.loc.start)));\n        }\n      }\n    } catch (err) {\n      _didIteratorError = true;\n      _iteratorError = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion && _iterator.return != null) {\n          _iterator.return();\n        }\n      } finally {\n        if (_didIteratorError) {\n          throw _iteratorError;\n        }\n      }\n    }\n  } else if (error.source && error.locations) {\n    var source = error.source;\n    var _iteratorNormalCompletion2 = true;\n    var _didIteratorError2 = false;\n    var _iteratorError2 = undefined;\n\n    try {\n      for (var _iterator2 = error.locations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n        var location = _step2.value;\n        printedLocations.push(highlightSourceAtLocation(source, location));\n      }\n    } catch (err) {\n      _didIteratorError2 = true;\n      _iteratorError2 = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {\n          _iterator2.return();\n        }\n      } finally {\n        if (_didIteratorError2) {\n          throw _iteratorError2;\n        }\n      }\n    }\n  }\n\n  return printedLocations.length === 0 ? error.message : [error.message].concat(printedLocations).join('\\n\\n') + '\\n';\n}\n/**\n * Render a helpful description of the location of the error in the GraphQL\n * Source document.\n */\n\nfunction highlightSourceAtLocation(source, location) {\n  var firstLineColumnOffset = source.locationOffset.column - 1;\n  var body = whitespace(firstLineColumnOffset) + source.body;\n  var lineIndex = location.line - 1;\n  var lineOffset = source.locationOffset.line - 1;\n  var lineNum = location.line + lineOffset;\n  var columnOffset = location.line === 1 ? firstLineColumnOffset : 0;\n  var columnNum = location.column + columnOffset;\n  var lines = body.split(/\\r\\n|[\\n\\r]/g);\n  return \"\".concat(source.name, \" (\").concat(lineNum, \":\").concat(columnNum, \")\\n\") + printPrefixedLines([// Lines specified like this: [\"prefix\", \"string\"],\n  [\"\".concat(lineNum - 1, \": \"), lines[lineIndex - 1]], [\"\".concat(lineNum, \": \"), lines[lineIndex]], ['', whitespace(columnNum - 1) + '^'], [\"\".concat(lineNum + 1, \": \"), lines[lineIndex + 1]]]);\n}\n\nfunction printPrefixedLines(lines) {\n  var existingLines = lines.filter(function (_ref) {\n    var _ = _ref[0],\n        line = _ref[1];\n    return line !== undefined;\n  });\n  var padLen = 0;\n  var _iteratorNormalCompletion3 = true;\n  var _didIteratorError3 = false;\n  var _iteratorError3 = undefined;\n\n  try {\n    for (var _iterator3 = existingLines[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n      var _ref4 = _step3.value;\n      var prefix = _ref4[0];\n      padLen = Math.max(padLen, prefix.length);\n    }\n  } catch (err) {\n    _didIteratorError3 = true;\n    _iteratorError3 = err;\n  } finally {\n    try {\n      if (!_iteratorNormalCompletion3 && _iterator3.return != null) {\n        _iterator3.return();\n      }\n    } finally {\n      if (_didIteratorError3) {\n        throw _iteratorError3;\n      }\n    }\n  }\n\n  return existingLines.map(function (_ref3) {\n    var prefix = _ref3[0],\n        line = _ref3[1];\n    return lpad(padLen, prefix) + line;\n  }).join('\\n');\n}\n\nfunction whitespace(len) {\n  return Array(len + 1).join(' ');\n}\n\nfunction lpad(len, str) {\n  return whitespace(len - str.length) + str;\n}","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n *  strict\n */\nimport { printError } from './printError';\nimport { getLocation } from '../language/location';\nexport function GraphQLError( // eslint-disable-line no-redeclare\nmessage, nodes, source, positions, path, originalError, extensions) {\n  // Compute list of blame nodes.\n  var _nodes = Array.isArray(nodes) ? nodes.length !== 0 ? nodes : undefined : nodes ? [nodes] : undefined; // Compute locations in the source for the given nodes/positions.\n\n\n  var _source = source;\n\n  if (!_source && _nodes) {\n    var node = _nodes[0];\n    _source = node && node.loc && node.loc.source;\n  }\n\n  var _positions = positions;\n\n  if (!_positions && _nodes) {\n    _positions = _nodes.reduce(function (list, node) {\n      if (node.loc) {\n        list.push(node.loc.start);\n      }\n\n      return list;\n    }, []);\n  }\n\n  if (_positions && _positions.length === 0) {\n    _positions = undefined;\n  }\n\n  var _locations;\n\n  if (positions && source) {\n    _locations = positions.map(function (pos) {\n      return getLocation(source, pos);\n    });\n  } else if (_nodes) {\n    _locations = _nodes.reduce(function (list, node) {\n      if (node.loc) {\n        list.push(getLocation(node.loc.source, node.loc.start));\n      }\n\n      return list;\n    }, []);\n  }\n\n  var _extensions = extensions || originalError && originalError.extensions;\n\n  Object.defineProperties(this, {\n    message: {\n      value: message,\n      // By being enumerable, JSON.stringify will include `message` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: true,\n      writable: true\n    },\n    locations: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: _locations || undefined,\n      // By being enumerable, JSON.stringify will include `locations` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(_locations)\n    },\n    path: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: path || undefined,\n      // By being enumerable, JSON.stringify will include `path` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(path)\n    },\n    nodes: {\n      value: _nodes || undefined\n    },\n    source: {\n      value: _source || undefined\n    },\n    positions: {\n      value: _positions || undefined\n    },\n    originalError: {\n      value: originalError\n    },\n    extensions: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: _extensions || undefined,\n      // By being enumerable, JSON.stringify will include `path` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(_extensions)\n    }\n  }); // Include (non-enumerable) stack trace.\n\n  if (originalError && originalError.stack) {\n    Object.defineProperty(this, 'stack', {\n      value: originalError.stack,\n      writable: true,\n      configurable: true\n    });\n  } else if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, GraphQLError);\n  } else {\n    Object.defineProperty(this, 'stack', {\n      value: Error().stack,\n      writable: true,\n      configurable: true\n    });\n  }\n}\nGraphQLError.prototype = Object.create(Error.prototype, {\n  constructor: {\n    value: GraphQLError\n  },\n  name: {\n    value: 'GraphQLError'\n  },\n  toString: {\n    value: function toString() {\n      return printError(this);\n    }\n  }\n});",null,null,null,"module.exports = require('./lib/Observable.js').Observable;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Observable = void 0;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n// === Symbol Support ===\nvar hasSymbols = function () {\n  return typeof Symbol === 'function';\n};\n\nvar hasSymbol = function (name) {\n  return hasSymbols() && Boolean(Symbol[name]);\n};\n\nvar getSymbol = function (name) {\n  return hasSymbol(name) ? Symbol[name] : '@@' + name;\n};\n\nif (hasSymbols() && !hasSymbol('observable')) {\n  Symbol.observable = Symbol('observable');\n}\n\nvar SymbolIterator = getSymbol('iterator');\nvar SymbolObservable = getSymbol('observable');\nvar SymbolSpecies = getSymbol('species'); // === Abstract Operations ===\n\nfunction getMethod(obj, key) {\n  var value = obj[key];\n  if (value == null) return undefined;\n  if (typeof value !== 'function') throw new TypeError(value + ' is not a function');\n  return value;\n}\n\nfunction getSpecies(obj) {\n  var ctor = obj.constructor;\n\n  if (ctor !== undefined) {\n    ctor = ctor[SymbolSpecies];\n\n    if (ctor === null) {\n      ctor = undefined;\n    }\n  }\n\n  return ctor !== undefined ? ctor : Observable;\n}\n\nfunction isObservable(x) {\n  return x instanceof Observable; // SPEC: Brand check\n}\n\nfunction hostReportError(e) {\n  if (hostReportError.log) {\n    hostReportError.log(e);\n  } else {\n    setTimeout(function () {\n      throw e;\n    });\n  }\n}\n\nfunction enqueue(fn) {\n  Promise.resolve().then(function () {\n    try {\n      fn();\n    } catch (e) {\n      hostReportError(e);\n    }\n  });\n}\n\nfunction cleanupSubscription(subscription) {\n  var cleanup = subscription._cleanup;\n  if (cleanup === undefined) return;\n  subscription._cleanup = undefined;\n\n  if (!cleanup) {\n    return;\n  }\n\n  try {\n    if (typeof cleanup === 'function') {\n      cleanup();\n    } else {\n      var unsubscribe = getMethod(cleanup, 'unsubscribe');\n\n      if (unsubscribe) {\n        unsubscribe.call(cleanup);\n      }\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n}\n\nfunction closeSubscription(subscription) {\n  subscription._observer = undefined;\n  subscription._queue = undefined;\n  subscription._state = 'closed';\n}\n\nfunction flushSubscription(subscription) {\n  var queue = subscription._queue;\n\n  if (!queue) {\n    return;\n  }\n\n  subscription._queue = undefined;\n  subscription._state = 'ready';\n\n  for (var i = 0; i < queue.length; ++i) {\n    notifySubscription(subscription, queue[i].type, queue[i].value);\n    if (subscription._state === 'closed') break;\n  }\n}\n\nfunction notifySubscription(subscription, type, value) {\n  subscription._state = 'running';\n  var observer = subscription._observer;\n\n  try {\n    var m = getMethod(observer, type);\n\n    switch (type) {\n      case 'next':\n        if (m) m.call(observer, value);\n        break;\n\n      case 'error':\n        closeSubscription(subscription);\n        if (m) m.call(observer, value);else throw value;\n        break;\n\n      case 'complete':\n        closeSubscription(subscription);\n        if (m) m.call(observer);\n        break;\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n\n  if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';\n}\n\nfunction onNotify(subscription, type, value) {\n  if (subscription._state === 'closed') return;\n\n  if (subscription._state === 'buffering') {\n    subscription._queue.push({\n      type: type,\n      value: value\n    });\n\n    return;\n  }\n\n  if (subscription._state !== 'ready') {\n    subscription._state = 'buffering';\n    subscription._queue = [{\n      type: type,\n      value: value\n    }];\n    enqueue(function () {\n      return flushSubscription(subscription);\n    });\n    return;\n  }\n\n  notifySubscription(subscription, type, value);\n}\n\nvar Subscription =\n/*#__PURE__*/\nfunction () {\n  function Subscription(observer, subscriber) {\n    _classCallCheck(this, Subscription);\n\n    // ASSERT: observer is an object\n    // ASSERT: subscriber is callable\n    this._cleanup = undefined;\n    this._observer = observer;\n    this._queue = undefined;\n    this._state = 'initializing';\n    var subscriptionObserver = new SubscriptionObserver(this);\n\n    try {\n      this._cleanup = subscriber.call(undefined, subscriptionObserver);\n    } catch (e) {\n      subscriptionObserver.error(e);\n    }\n\n    if (this._state === 'initializing') this._state = 'ready';\n  }\n\n  _createClass(Subscription, [{\n    key: \"unsubscribe\",\n    value: function unsubscribe() {\n      if (this._state !== 'closed') {\n        closeSubscription(this);\n        cleanupSubscription(this);\n      }\n    }\n  }, {\n    key: \"closed\",\n    get: function () {\n      return this._state === 'closed';\n    }\n  }]);\n\n  return Subscription;\n}();\n\nvar SubscriptionObserver =\n/*#__PURE__*/\nfunction () {\n  function SubscriptionObserver(subscription) {\n    _classCallCheck(this, SubscriptionObserver);\n\n    this._subscription = subscription;\n  }\n\n  _createClass(SubscriptionObserver, [{\n    key: \"next\",\n    value: function next(value) {\n      onNotify(this._subscription, 'next', value);\n    }\n  }, {\n    key: \"error\",\n    value: function error(value) {\n      onNotify(this._subscription, 'error', value);\n    }\n  }, {\n    key: \"complete\",\n    value: function complete() {\n      onNotify(this._subscription, 'complete');\n    }\n  }, {\n    key: \"closed\",\n    get: function () {\n      return this._subscription._state === 'closed';\n    }\n  }]);\n\n  return SubscriptionObserver;\n}();\n\nvar Observable =\n/*#__PURE__*/\nfunction () {\n  function Observable(subscriber) {\n    _classCallCheck(this, Observable);\n\n    if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');\n    if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');\n    this._subscriber = subscriber;\n  }\n\n  _createClass(Observable, [{\n    key: \"subscribe\",\n    value: function subscribe(observer) {\n      if (typeof observer !== 'object' || observer === null) {\n        observer = {\n          next: observer,\n          error: arguments[1],\n          complete: arguments[2]\n        };\n      }\n\n      return new Subscription(observer, this._subscriber);\n    }\n  }, {\n    key: \"forEach\",\n    value: function forEach(fn) {\n      var _this = this;\n\n      return new Promise(function (resolve, reject) {\n        if (typeof fn !== 'function') {\n          reject(new TypeError(fn + ' is not a function'));\n          return;\n        }\n\n        function done() {\n          subscription.unsubscribe();\n          resolve();\n        }\n\n        var subscription = _this.subscribe({\n          next: function (value) {\n            try {\n              fn(value, done);\n            } catch (e) {\n              reject(e);\n              subscription.unsubscribe();\n            }\n          },\n          error: reject,\n          complete: resolve\n        });\n      });\n    }\n  }, {\n    key: \"map\",\n    value: function map(fn) {\n      var _this2 = this;\n\n      if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n      var C = getSpecies(this);\n      return new C(function (observer) {\n        return _this2.subscribe({\n          next: function (value) {\n            try {\n              value = fn(value);\n            } catch (e) {\n              return observer.error(e);\n            }\n\n            observer.next(value);\n          },\n          error: function (e) {\n            observer.error(e);\n          },\n          complete: function () {\n            observer.complete();\n          }\n        });\n      });\n    }\n  }, {\n    key: \"filter\",\n    value: function filter(fn) {\n      var _this3 = this;\n\n      if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n      var C = getSpecies(this);\n      return new C(function (observer) {\n        return _this3.subscribe({\n          next: function (value) {\n            try {\n              if (!fn(value)) return;\n            } catch (e) {\n              return observer.error(e);\n            }\n\n            observer.next(value);\n          },\n          error: function (e) {\n            observer.error(e);\n          },\n          complete: function () {\n            observer.complete();\n          }\n        });\n      });\n    }\n  }, {\n    key: \"reduce\",\n    value: function reduce(fn) {\n      var _this4 = this;\n\n      if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n      var C = getSpecies(this);\n      var hasSeed = arguments.length > 1;\n      var hasValue = false;\n      var seed = arguments[1];\n      var acc = seed;\n      return new C(function (observer) {\n        return _this4.subscribe({\n          next: function (value) {\n            var first = !hasValue;\n            hasValue = true;\n\n            if (!first || hasSeed) {\n              try {\n                acc = fn(acc, value);\n              } catch (e) {\n                return observer.error(e);\n              }\n            } else {\n              acc = value;\n            }\n          },\n          error: function (e) {\n            observer.error(e);\n          },\n          complete: function () {\n            if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));\n            observer.next(acc);\n            observer.complete();\n          }\n        });\n      });\n    }\n  }, {\n    key: \"concat\",\n    value: function concat() {\n      var _this5 = this;\n\n      for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n        sources[_key] = arguments[_key];\n      }\n\n      var C = getSpecies(this);\n      return new C(function (observer) {\n        var subscription;\n        var index = 0;\n\n        function startNext(next) {\n          subscription = next.subscribe({\n            next: function (v) {\n              observer.next(v);\n            },\n            error: function (e) {\n              observer.error(e);\n            },\n            complete: function () {\n              if (index === sources.length) {\n                subscription = undefined;\n                observer.complete();\n              } else {\n                startNext(C.from(sources[index++]));\n              }\n            }\n          });\n        }\n\n        startNext(_this5);\n        return function () {\n          if (subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n          }\n        };\n      });\n    }\n  }, {\n    key: \"flatMap\",\n    value: function flatMap(fn) {\n      var _this6 = this;\n\n      if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n      var C = getSpecies(this);\n      return new C(function (observer) {\n        var subscriptions = [];\n\n        var outer = _this6.subscribe({\n          next: function (value) {\n            if (fn) {\n              try {\n                value = fn(value);\n              } catch (e) {\n                return observer.error(e);\n              }\n            }\n\n            var inner = C.from(value).subscribe({\n              next: function (value) {\n                observer.next(value);\n              },\n              error: function (e) {\n                observer.error(e);\n              },\n              complete: function () {\n                var i = subscriptions.indexOf(inner);\n                if (i >= 0) subscriptions.splice(i, 1);\n                completeIfDone();\n              }\n            });\n            subscriptions.push(inner);\n          },\n          error: function (e) {\n            observer.error(e);\n          },\n          complete: function () {\n            completeIfDone();\n          }\n        });\n\n        function completeIfDone() {\n          if (outer.closed && subscriptions.length === 0) observer.complete();\n        }\n\n        return function () {\n          subscriptions.forEach(function (s) {\n            return s.unsubscribe();\n          });\n          outer.unsubscribe();\n        };\n      });\n    }\n  }, {\n    key: SymbolObservable,\n    value: function () {\n      return this;\n    }\n  }], [{\n    key: \"from\",\n    value: function from(x) {\n      var C = typeof this === 'function' ? this : Observable;\n      if (x == null) throw new TypeError(x + ' is not an object');\n      var method = getMethod(x, SymbolObservable);\n\n      if (method) {\n        var observable = method.call(x);\n        if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');\n        if (isObservable(observable) && observable.constructor === C) return observable;\n        return new C(function (observer) {\n          return observable.subscribe(observer);\n        });\n      }\n\n      if (hasSymbol('iterator')) {\n        method = getMethod(x, SymbolIterator);\n\n        if (method) {\n          return new C(function (observer) {\n            enqueue(function () {\n              if (observer.closed) return;\n              var _iteratorNormalCompletion = true;\n              var _didIteratorError = false;\n              var _iteratorError = undefined;\n\n              try {\n                for (var _iterator = method.call(x)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                  var _item = _step.value;\n                  observer.next(_item);\n                  if (observer.closed) return;\n                }\n              } catch (err) {\n                _didIteratorError = true;\n                _iteratorError = err;\n              } finally {\n                try {\n                  if (!_iteratorNormalCompletion && _iterator.return != null) {\n                    _iterator.return();\n                  }\n                } finally {\n                  if (_didIteratorError) {\n                    throw _iteratorError;\n                  }\n                }\n              }\n\n              observer.complete();\n            });\n          });\n        }\n      }\n\n      if (Array.isArray(x)) {\n        return new C(function (observer) {\n          enqueue(function () {\n            if (observer.closed) return;\n\n            for (var i = 0; i < x.length; ++i) {\n              observer.next(x[i]);\n              if (observer.closed) return;\n            }\n\n            observer.complete();\n          });\n        });\n      }\n\n      throw new TypeError(x + ' is not observable');\n    }\n  }, {\n    key: \"of\",\n    value: function of() {\n      for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        items[_key2] = arguments[_key2];\n      }\n\n      var C = typeof this === 'function' ? this : Observable;\n      return new C(function (observer) {\n        enqueue(function () {\n          if (observer.closed) return;\n\n          for (var i = 0; i < items.length; ++i) {\n            observer.next(items[i]);\n            if (observer.closed) return;\n          }\n\n          observer.complete();\n        });\n      });\n    }\n  }, {\n    key: SymbolSpecies,\n    get: function () {\n      return this;\n    }\n  }]);\n\n  return Observable;\n}();\n\nexports.Observable = Observable;\n\nif (hasSymbols()) {\n  Object.defineProperty(Observable, Symbol('extensions'), {\n    value: {\n      symbol: SymbolObservable,\n      hostReportError: hostReportError\n    },\n    configurable: true\n  });\n}","/*******************************************************************************\n * Copyright (c) 2013 IBM Corp.\n *\n * All rights reserved. This program and the accompanying materials\n * are made available under the terms of the Eclipse Public License v1.0\n * and Eclipse Distribution License v1.0 which accompany this distribution.\n *\n * The Eclipse Public License is available at\n *    http://www.eclipse.org/legal/epl-v10.html\n * and the Eclipse Distribution License is available at\n *   http://www.eclipse.org/org/documents/edl-v10.php.\n *\n * Contributors:\n *    Andrew Banks - initial API and implementation and initial documentation\n *******************************************************************************/\n\n\n// Only expose a single object name in the global namespace.\n// Everything must go through this module. Global Paho module\n// only has a single public function, client, which returns\n// a Paho client object given connection details.\n\n/**\n * Send and receive messages using web browsers.\n * <p>\n * This programming interface lets a JavaScript client application use the MQTT V3.1 or\n * V3.1.1 protocol to connect to an MQTT-supporting messaging server.\n *\n * The function supported includes:\n * <ol>\n * <li>Connecting to and disconnecting from a server. The server is identified by its host name and port number.\n * <li>Specifying options that relate to the communications link with the server,\n * for example the frequency of keep-alive heartbeats, and whether SSL/TLS is required.\n * <li>Subscribing to and receiving messages from MQTT Topics.\n * <li>Publishing messages to MQTT Topics.\n * </ol>\n * <p>\n * The API consists of two main objects:\n * <dl>\n * <dt><b>{@link Paho.Client}</b></dt>\n * <dd>This contains methods that provide the functionality of the API,\n * including provision of callbacks that notify the application when a message\n * arrives from or is delivered to the messaging server,\n * or when the status of its connection to the messaging server changes.</dd>\n * <dt><b>{@link Paho.Message}</b></dt>\n * <dd>This encapsulates the payload of the message along with various attributes\n * associated with its delivery, in particular the destination to which it has\n * been (or is about to be) sent.</dd>\n * </dl>\n * <p>\n * The programming interface validates parameters passed to it, and will throw\n * an Error containing an error message intended for developer use, if it detects\n * an error with any parameter.\n * <p>\n * Example:\n *\n * <code><pre>\nvar client = new Paho.MQTT.Client(location.hostname, Number(location.port), \"clientId\");\nclient.onConnectionLost = onConnectionLost;\nclient.onMessageArrived = onMessageArrived;\nclient.connect({onSuccess:onConnect});\n\nfunction onConnect() {\n  // Once a connection has been made, make a subscription and send a message.\n  console.log(\"onConnect\");\n  client.subscribe(\"/World\");\n  var message = new Paho.MQTT.Message(\"Hello\");\n  message.destinationName = \"/World\";\n  client.send(message);\n};\nfunction onConnectionLost(responseObject) {\n  if (responseObject.errorCode !== 0)\n\tconsole.log(\"onConnectionLost:\"+responseObject.errorMessage);\n};\nfunction onMessageArrived(message) {\n  console.log(\"onMessageArrived:\"+message.payloadString);\n  client.disconnect();\n};\n * </pre></code>\n * @namespace Paho\n */\n\n/* jshint shadow:true */\n(function ExportLibrary(root, factory) {\n\tif(typeof exports === \"object\" && typeof module === \"object\"){\n\t\tmodule.exports = factory();\n\t} else if (typeof define === \"function\" && define.amd){\n\t\tdefine(factory);\n\t} else if (typeof exports === \"object\"){\n\t\texports = factory();\n\t} else {\n\t\t//if (typeof root.Paho === \"undefined\"){\n\t\t//\troot.Paho = {};\n\t\t//}\n\t\troot.Paho = factory();\n\t}\n})(this, function LibraryFactory(){\n\n\n\tvar PahoMQTT = (function (global) {\n\n\t// Private variables below, these are only visible inside the function closure\n\t// which is used to define the module.\n\tvar version = \"@VERSION@-@BUILDLEVEL@\";\n\n\t/**\n\t * @private\n\t */\n\tvar localStorage = global.localStorage || (function () {\n\t\tvar data = {};\n\n\t\treturn {\n\t\t\tsetItem: function (key, item) { data[key] = item; },\n\t\t\tgetItem: function (key) { return data[key]; },\n\t\t\tremoveItem: function (key) { delete data[key]; },\n\t\t};\n\t})();\n\n\t\t/**\n\t * Unique message type identifiers, with associated\n\t * associated integer values.\n\t * @private\n\t */\n\t\tvar MESSAGE_TYPE = {\n\t\t\tCONNECT: 1,\n\t\t\tCONNACK: 2,\n\t\t\tPUBLISH: 3,\n\t\t\tPUBACK: 4,\n\t\t\tPUBREC: 5,\n\t\t\tPUBREL: 6,\n\t\t\tPUBCOMP: 7,\n\t\t\tSUBSCRIBE: 8,\n\t\t\tSUBACK: 9,\n\t\t\tUNSUBSCRIBE: 10,\n\t\t\tUNSUBACK: 11,\n\t\t\tPINGREQ: 12,\n\t\t\tPINGRESP: 13,\n\t\t\tDISCONNECT: 14\n\t\t};\n\n\t\t// Collection of utility methods used to simplify module code\n\t\t// and promote the DRY pattern.\n\n\t\t/**\n\t * Validate an object's parameter names to ensure they\n\t * match a list of expected variables name for this option\n\t * type. Used to ensure option object passed into the API don't\n\t * contain erroneous parameters.\n\t * @param {Object} obj - User options object\n\t * @param {Object} keys - valid keys and types that may exist in obj.\n\t * @throws {Error} Invalid option parameter found.\n\t * @private\n\t */\n\t\tvar validate = function(obj, keys) {\n\t\t\tfor (var key in obj) {\n\t\t\t\tif (obj.hasOwnProperty(key)) {\n\t\t\t\t\tif (keys.hasOwnProperty(key)) {\n\t\t\t\t\t\tif (typeof obj[key] !== keys[key])\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof obj[key], key]));\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvar errorStr = \"Unknown property, \" + key + \". Valid properties are:\";\n\t\t\t\t\t\tfor (var validKey in keys)\n\t\t\t\t\t\t\tif (keys.hasOwnProperty(validKey))\n\t\t\t\t\t\t\t\terrorStr = errorStr+\" \"+validKey;\n\t\t\t\t\t\tthrow new Error(errorStr);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t * Return a new function which runs the user function bound\n\t * to a fixed scope.\n\t * @param {function} User function\n\t * @param {object} Function scope\n\t * @return {function} User function bound to another scope\n\t * @private\n\t */\n\t\tvar scope = function (f, scope) {\n\t\t\treturn function () {\n\t\t\t\treturn f.apply(scope, arguments);\n\t\t\t};\n\t\t};\n\n\t\t/**\n\t * Unique message type identifiers, with associated\n\t * associated integer values.\n\t * @private\n\t */\n\t\tvar ERROR = {\n\t\t\tOK: {code:0, text:\"AMQJSC0000I OK.\"},\n\t\t\tCONNECT_TIMEOUT: {code:1, text:\"AMQJSC0001E Connect timed out.\"},\n\t\t\tSUBSCRIBE_TIMEOUT: {code:2, text:\"AMQJS0002E Subscribe timed out.\"},\n\t\t\tUNSUBSCRIBE_TIMEOUT: {code:3, text:\"AMQJS0003E Unsubscribe timed out.\"},\n\t\t\tPING_TIMEOUT: {code:4, text:\"AMQJS0004E Ping timed out.\"},\n\t\t\tINTERNAL_ERROR: {code:5, text:\"AMQJS0005E Internal error. Error Message: {0}, Stack trace: {1}\"},\n\t\t\tCONNACK_RETURNCODE: {code:6, text:\"AMQJS0006E Bad Connack return code:{0} {1}.\"},\n\t\t\tSOCKET_ERROR: {code:7, text:\"AMQJS0007E Socket error:{0}.\"},\n\t\t\tSOCKET_CLOSE: {code:8, text:\"AMQJS0008I Socket closed.\"},\n\t\t\tMALFORMED_UTF: {code:9, text:\"AMQJS0009E Malformed UTF data:{0} {1} {2}.\"},\n\t\t\tUNSUPPORTED: {code:10, text:\"AMQJS0010E {0} is not supported by this browser.\"},\n\t\t\tINVALID_STATE: {code:11, text:\"AMQJS0011E Invalid state {0}.\"},\n\t\t\tINVALID_TYPE: {code:12, text:\"AMQJS0012E Invalid type {0} for {1}.\"},\n\t\t\tINVALID_ARGUMENT: {code:13, text:\"AMQJS0013E Invalid argument {0} for {1}.\"},\n\t\t\tUNSUPPORTED_OPERATION: {code:14, text:\"AMQJS0014E Unsupported operation.\"},\n\t\t\tINVALID_STORED_DATA: {code:15, text:\"AMQJS0015E Invalid data in local storage key={0} value={1}.\"},\n\t\t\tINVALID_MQTT_MESSAGE_TYPE: {code:16, text:\"AMQJS0016E Invalid MQTT message type {0}.\"},\n\t\t\tMALFORMED_UNICODE: {code:17, text:\"AMQJS0017E Malformed Unicode string:{0} {1}.\"},\n\t\t\tBUFFER_FULL: {code:18, text:\"AMQJS0018E Message buffer is full, maximum buffer size: {0}.\"},\n\t\t};\n\n\t\t/** CONNACK RC Meaning. */\n\t\tvar CONNACK_RC = {\n\t\t\t0:\"Connection Accepted\",\n\t\t\t1:\"Connection Refused: unacceptable protocol version\",\n\t\t\t2:\"Connection Refused: identifier rejected\",\n\t\t\t3:\"Connection Refused: server unavailable\",\n\t\t\t4:\"Connection Refused: bad user name or password\",\n\t\t\t5:\"Connection Refused: not authorized\"\n\t\t};\n\n\t/**\n\t * Format an error message text.\n\t * @private\n\t * @param {error} ERROR value above.\n\t * @param {substitutions} [array] substituted into the text.\n\t * @return the text with the substitutions made.\n\t */\n\t\tvar format = function(error, substitutions) {\n\t\t\tvar text = error.text;\n\t\t\tif (substitutions) {\n\t\t\t\tvar field,start;\n\t\t\t\tfor (var i=0; i<substitutions.length; i++) {\n\t\t\t\t\tfield = \"{\"+i+\"}\";\n\t\t\t\t\tstart = text.indexOf(field);\n\t\t\t\t\tif(start > 0) {\n\t\t\t\t\t\tvar part1 = text.substring(0,start);\n\t\t\t\t\t\tvar part2 = text.substring(start+field.length);\n\t\t\t\t\t\ttext = part1+substitutions[i]+part2;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn text;\n\t\t};\n\n\t\t//MQTT protocol and version          6    M    Q    I    s    d    p    3\n\t\tvar MqttProtoIdentifierv3 = [0x00,0x06,0x4d,0x51,0x49,0x73,0x64,0x70,0x03];\n\t\t//MQTT proto/version for 311         4    M    Q    T    T    4\n\t\tvar MqttProtoIdentifierv4 = [0x00,0x04,0x4d,0x51,0x54,0x54,0x04];\n\n\t\t/**\n\t * Construct an MQTT wire protocol message.\n\t * @param type MQTT packet type.\n\t * @param options optional wire message attributes.\n\t *\n\t * Optional properties\n\t *\n\t * messageIdentifier: message ID in the range [0..65535]\n\t * payloadMessage:\tApplication Message - PUBLISH only\n\t * connectStrings:\tarray of 0 or more Strings to be put into the CONNECT payload\n\t * topics:\t\t\tarray of strings (SUBSCRIBE, UNSUBSCRIBE)\n\t * requestQoS:\t\tarray of QoS values [0..2]\n\t *\n\t * \"Flag\" properties\n\t * cleanSession:\ttrue if present / false if absent (CONNECT)\n\t * willMessage:  \ttrue if present / false if absent (CONNECT)\n\t * isRetained:\t\ttrue if present / false if absent (CONNECT)\n\t * userName:\t\ttrue if present / false if absent (CONNECT)\n\t * password:\t\ttrue if present / false if absent (CONNECT)\n\t * keepAliveInterval:\tinteger [0..65535]  (CONNECT)\n\t *\n\t * @private\n\t * @ignore\n\t */\n\t\tvar WireMessage = function (type, options) {\n\t\t\tthis.type = type;\n\t\t\tfor (var name in options) {\n\t\t\t\tif (options.hasOwnProperty(name)) {\n\t\t\t\t\tthis[name] = options[name];\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tWireMessage.prototype.encode = function() {\n\t\t// Compute the first byte of the fixed header\n\t\t\tvar first = ((this.type & 0x0f) << 4);\n\n\t\t\t/*\n\t\t * Now calculate the length of the variable header + payload by adding up the lengths\n\t\t * of all the component parts\n\t\t */\n\n\t\t\tvar remLength = 0;\n\t\t\tvar topicStrLength = [];\n\t\t\tvar destinationNameLength = 0;\n\t\t\tvar willMessagePayloadBytes;\n\n\t\t\t// if the message contains a messageIdentifier then we need two bytes for that\n\t\t\tif (this.messageIdentifier !== undefined)\n\t\t\t\tremLength += 2;\n\n\t\t\tswitch(this.type) {\n\t\t\t// If this a Connect then we need to include 12 bytes for its header\n\t\t\tcase MESSAGE_TYPE.CONNECT:\n\t\t\t\tswitch(this.mqttVersion) {\n\t\t\t\tcase 3:\n\t\t\t\t\tremLength += MqttProtoIdentifierv3.length + 3;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 4:\n\t\t\t\t\tremLength += MqttProtoIdentifierv4.length + 3;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tremLength += UTF8Length(this.clientId) + 2;\n\t\t\t\tif (this.willMessage !== undefined) {\n\t\t\t\t\tremLength += UTF8Length(this.willMessage.destinationName) + 2;\n\t\t\t\t\t// Will message is always a string, sent as UTF-8 characters with a preceding length.\n\t\t\t\t\twillMessagePayloadBytes = this.willMessage.payloadBytes;\n\t\t\t\t\tif (!(willMessagePayloadBytes instanceof Uint8Array))\n\t\t\t\t\t\twillMessagePayloadBytes = new Uint8Array(payloadBytes);\n\t\t\t\t\tremLength += willMessagePayloadBytes.byteLength +2;\n\t\t\t\t}\n\t\t\t\tif (this.userName !== undefined)\n\t\t\t\t\tremLength += UTF8Length(this.userName) + 2;\n\t\t\t\tif (this.password !== undefined)\n\t\t\t\t\tremLength += UTF8Length(this.password) + 2;\n\t\t\t\tbreak;\n\n\t\t\t// Subscribe, Unsubscribe can both contain topic strings\n\t\t\tcase MESSAGE_TYPE.SUBSCRIBE:\n\t\t\t\tfirst |= 0x02; // Qos = 1;\n\t\t\t\tfor ( var i = 0; i < this.topics.length; i++) {\n\t\t\t\t\ttopicStrLength[i] = UTF8Length(this.topics[i]);\n\t\t\t\t\tremLength += topicStrLength[i] + 2;\n\t\t\t\t}\n\t\t\t\tremLength += this.requestedQos.length; // 1 byte for each topic's Qos\n\t\t\t\t// QoS on Subscribe only\n\t\t\t\tbreak;\n\n\t\t\tcase MESSAGE_TYPE.UNSUBSCRIBE:\n\t\t\t\tfirst |= 0x02; // Qos = 1;\n\t\t\t\tfor ( var i = 0; i < this.topics.length; i++) {\n\t\t\t\t\ttopicStrLength[i] = UTF8Length(this.topics[i]);\n\t\t\t\t\tremLength += topicStrLength[i] + 2;\n\t\t\t\t}\n\t\t\t\tbreak;\n\n\t\t\tcase MESSAGE_TYPE.PUBREL:\n\t\t\t\tfirst |= 0x02; // Qos = 1;\n\t\t\t\tbreak;\n\n\t\t\tcase MESSAGE_TYPE.PUBLISH:\n\t\t\t\tif (this.payloadMessage.duplicate) first |= 0x08;\n\t\t\t\tfirst  = first |= (this.payloadMessage.qos << 1);\n\t\t\t\tif (this.payloadMessage.retained) first |= 0x01;\n\t\t\t\tdestinationNameLength = UTF8Length(this.payloadMessage.destinationName);\n\t\t\t\tremLength += destinationNameLength + 2;\n\t\t\t\tvar payloadBytes = this.payloadMessage.payloadBytes;\n\t\t\t\tremLength += payloadBytes.byteLength;\n\t\t\t\tif (payloadBytes instanceof ArrayBuffer)\n\t\t\t\t\tpayloadBytes = new Uint8Array(payloadBytes);\n\t\t\t\telse if (!(payloadBytes instanceof Uint8Array))\n\t\t\t\t\tpayloadBytes = new Uint8Array(payloadBytes.buffer);\n\t\t\t\tbreak;\n\n\t\t\tcase MESSAGE_TYPE.DISCONNECT:\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\t// Now we can allocate a buffer for the message\n\n\t\t\tvar mbi = encodeMBI(remLength);  // Convert the length to MQTT MBI format\n\t\t\tvar pos = mbi.length + 1;        // Offset of start of variable header\n\t\t\tvar buffer = new ArrayBuffer(remLength + pos);\n\t\t\tvar byteStream = new Uint8Array(buffer);    // view it as a sequence of bytes\n\n\t\t\t//Write the fixed header into the buffer\n\t\t\tbyteStream[0] = first;\n\t\t\tbyteStream.set(mbi,1);\n\n\t\t\t// If this is a PUBLISH then the variable header starts with a topic\n\t\t\tif (this.type == MESSAGE_TYPE.PUBLISH)\n\t\t\t\tpos = writeString(this.payloadMessage.destinationName, destinationNameLength, byteStream, pos);\n\t\t\t// If this is a CONNECT then the variable header contains the protocol name/version, flags and keepalive time\n\n\t\t\telse if (this.type == MESSAGE_TYPE.CONNECT) {\n\t\t\t\tswitch (this.mqttVersion) {\n\t\t\t\tcase 3:\n\t\t\t\t\tbyteStream.set(MqttProtoIdentifierv3, pos);\n\t\t\t\t\tpos += MqttProtoIdentifierv3.length;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 4:\n\t\t\t\t\tbyteStream.set(MqttProtoIdentifierv4, pos);\n\t\t\t\t\tpos += MqttProtoIdentifierv4.length;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tvar connectFlags = 0;\n\t\t\t\tif (this.cleanSession)\n\t\t\t\t\tconnectFlags = 0x02;\n\t\t\t\tif (this.willMessage !== undefined ) {\n\t\t\t\t\tconnectFlags |= 0x04;\n\t\t\t\t\tconnectFlags |= (this.willMessage.qos<<3);\n\t\t\t\t\tif (this.willMessage.retained) {\n\t\t\t\t\t\tconnectFlags |= 0x20;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (this.userName !== undefined)\n\t\t\t\t\tconnectFlags |= 0x80;\n\t\t\t\tif (this.password !== undefined)\n\t\t\t\t\tconnectFlags |= 0x40;\n\t\t\t\tbyteStream[pos++] = connectFlags;\n\t\t\t\tpos = writeUint16 (this.keepAliveInterval, byteStream, pos);\n\t\t\t}\n\n\t\t\t// Output the messageIdentifier - if there is one\n\t\t\tif (this.messageIdentifier !== undefined)\n\t\t\t\tpos = writeUint16 (this.messageIdentifier, byteStream, pos);\n\n\t\t\tswitch(this.type) {\n\t\t\tcase MESSAGE_TYPE.CONNECT:\n\t\t\t\tpos = writeString(this.clientId, UTF8Length(this.clientId), byteStream, pos);\n\t\t\t\tif (this.willMessage !== undefined) {\n\t\t\t\t\tpos = writeString(this.willMessage.destinationName, UTF8Length(this.willMessage.destinationName), byteStream, pos);\n\t\t\t\t\tpos = writeUint16(willMessagePayloadBytes.byteLength, byteStream, pos);\n\t\t\t\t\tbyteStream.set(willMessagePayloadBytes, pos);\n\t\t\t\t\tpos += willMessagePayloadBytes.byteLength;\n\n\t\t\t\t}\n\t\t\t\tif (this.userName !== undefined)\n\t\t\t\t\tpos = writeString(this.userName, UTF8Length(this.userName), byteStream, pos);\n\t\t\t\tif (this.password !== undefined)\n\t\t\t\t\tpos = writeString(this.password, UTF8Length(this.password), byteStream, pos);\n\t\t\t\tbreak;\n\n\t\t\tcase MESSAGE_TYPE.PUBLISH:\n\t\t\t\t// PUBLISH has a text or binary payload, if text do not add a 2 byte length field, just the UTF characters.\n\t\t\t\tbyteStream.set(payloadBytes, pos);\n\n\t\t\t\tbreak;\n\n\t\t\t\t//    \t    case MESSAGE_TYPE.PUBREC:\n\t\t\t\t//    \t    case MESSAGE_TYPE.PUBREL:\n\t\t\t\t//    \t    case MESSAGE_TYPE.PUBCOMP:\n\t\t\t\t//    \t    \tbreak;\n\n\t\t\tcase MESSAGE_TYPE.SUBSCRIBE:\n\t\t\t\t// SUBSCRIBE has a list of topic strings and request QoS\n\t\t\t\tfor (var i=0; i<this.topics.length; i++) {\n\t\t\t\t\tpos = writeString(this.topics[i], topicStrLength[i], byteStream, pos);\n\t\t\t\t\tbyteStream[pos++] = this.requestedQos[i];\n\t\t\t\t}\n\t\t\t\tbreak;\n\n\t\t\tcase MESSAGE_TYPE.UNSUBSCRIBE:\n\t\t\t\t// UNSUBSCRIBE has a list of topic strings\n\t\t\t\tfor (var i=0; i<this.topics.length; i++)\n\t\t\t\t\tpos = writeString(this.topics[i], topicStrLength[i], byteStream, pos);\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\t// Do nothing.\n\t\t\t}\n\n\t\t\treturn buffer;\n\t\t};\n\n\t\tfunction decodeMessage(input,pos) {\n\t\t\tvar startingPos = pos;\n\t\t\tvar first = input[pos];\n\t\t\tvar type = first >> 4;\n\t\t\tvar messageInfo = first &= 0x0f;\n\t\t\tpos += 1;\n\n\n\t\t\t// Decode the remaining length (MBI format)\n\n\t\t\tvar digit;\n\t\t\tvar remLength = 0;\n\t\t\tvar multiplier = 1;\n\t\t\tdo {\n\t\t\t\tif (pos == input.length) {\n\t\t\t\t\treturn [null,startingPos];\n\t\t\t\t}\n\t\t\t\tdigit = input[pos++];\n\t\t\t\tremLength += ((digit & 0x7F) * multiplier);\n\t\t\t\tmultiplier *= 128;\n\t\t\t} while ((digit & 0x80) !== 0);\n\n\t\t\tvar endPos = pos+remLength;\n\t\t\tif (endPos > input.length) {\n\t\t\t\treturn [null,startingPos];\n\t\t\t}\n\n\t\t\tvar wireMessage = new WireMessage(type);\n\t\t\tswitch(type) {\n\t\t\tcase MESSAGE_TYPE.CONNACK:\n\t\t\t\tvar connectAcknowledgeFlags = input[pos++];\n\t\t\t\tif (connectAcknowledgeFlags & 0x01)\n\t\t\t\t\twireMessage.sessionPresent = true;\n\t\t\t\twireMessage.returnCode = input[pos++];\n\t\t\t\tbreak;\n\n\t\t\tcase MESSAGE_TYPE.PUBLISH:\n\t\t\t\tvar qos = (messageInfo >> 1) & 0x03;\n\n\t\t\t\tvar len = readUint16(input, pos);\n\t\t\t\tpos += 2;\n\t\t\t\tvar topicName = parseUTF8(input, pos, len);\n\t\t\t\tpos += len;\n\t\t\t\t// If QoS 1 or 2 there will be a messageIdentifier\n\t\t\t\tif (qos > 0) {\n\t\t\t\t\twireMessage.messageIdentifier = readUint16(input, pos);\n\t\t\t\t\tpos += 2;\n\t\t\t\t}\n\n\t\t\t\tvar message = new Message(input.subarray(pos, endPos));\n\t\t\t\tif ((messageInfo & 0x01) == 0x01)\n\t\t\t\t\tmessage.retained = true;\n\t\t\t\tif ((messageInfo & 0x08) == 0x08)\n\t\t\t\t\tmessage.duplicate =  true;\n\t\t\t\tmessage.qos = qos;\n\t\t\t\tmessage.destinationName = topicName;\n\t\t\t\twireMessage.payloadMessage = message;\n\t\t\t\tbreak;\n\n\t\t\tcase  MESSAGE_TYPE.PUBACK:\n\t\t\tcase  MESSAGE_TYPE.PUBREC:\n\t\t\tcase  MESSAGE_TYPE.PUBREL:\n\t\t\tcase  MESSAGE_TYPE.PUBCOMP:\n\t\t\tcase  MESSAGE_TYPE.UNSUBACK:\n\t\t\t\twireMessage.messageIdentifier = readUint16(input, pos);\n\t\t\t\tbreak;\n\n\t\t\tcase  MESSAGE_TYPE.SUBACK:\n\t\t\t\twireMessage.messageIdentifier = readUint16(input, pos);\n\t\t\t\tpos += 2;\n\t\t\t\twireMessage.returnCode = input.subarray(pos, endPos);\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\treturn [wireMessage,endPos];\n\t\t}\n\n\t\tfunction writeUint16(input, buffer, offset) {\n\t\t\tbuffer[offset++] = input >> 8;      //MSB\n\t\t\tbuffer[offset++] = input % 256;     //LSB\n\t\t\treturn offset;\n\t\t}\n\n\t\tfunction writeString(input, utf8Length, buffer, offset) {\n\t\t\toffset = writeUint16(utf8Length, buffer, offset);\n\t\t\tstringToUTF8(input, buffer, offset);\n\t\t\treturn offset + utf8Length;\n\t\t}\n\n\t\tfunction readUint16(buffer, offset) {\n\t\t\treturn 256*buffer[offset] + buffer[offset+1];\n\t\t}\n\n\t\t/**\n\t * Encodes an MQTT Multi-Byte Integer\n\t * @private\n\t */\n\t\tfunction encodeMBI(number) {\n\t\t\tvar output = new Array(1);\n\t\t\tvar numBytes = 0;\n\n\t\t\tdo {\n\t\t\t\tvar digit = number % 128;\n\t\t\t\tnumber = number >> 7;\n\t\t\t\tif (number > 0) {\n\t\t\t\t\tdigit |= 0x80;\n\t\t\t\t}\n\t\t\t\toutput[numBytes++] = digit;\n\t\t\t} while ( (number > 0) && (numBytes<4) );\n\n\t\t\treturn output;\n\t\t}\n\n\t\t/**\n\t * Takes a String and calculates its length in bytes when encoded in UTF8.\n\t * @private\n\t */\n\t\tfunction UTF8Length(input) {\n\t\t\tvar output = 0;\n\t\t\tfor (var i = 0; i<input.length; i++)\n\t\t\t{\n\t\t\t\tvar charCode = input.charCodeAt(i);\n\t\t\t\tif (charCode > 0x7FF)\n\t\t\t\t{\n\t\t\t\t\t// Surrogate pair means its a 4 byte character\n\t\t\t\t\tif (0xD800 <= charCode && charCode <= 0xDBFF)\n\t\t\t\t\t{\n\t\t\t\t\t\ti++;\n\t\t\t\t\t\toutput++;\n\t\t\t\t\t}\n\t\t\t\t\toutput +=3;\n\t\t\t\t}\n\t\t\t\telse if (charCode > 0x7F)\n\t\t\t\t\toutput +=2;\n\t\t\t\telse\n\t\t\t\t\toutput++;\n\t\t\t}\n\t\t\treturn output;\n\t\t}\n\n\t\t/**\n\t * Takes a String and writes it into an array as UTF8 encoded bytes.\n\t * @private\n\t */\n\t\tfunction stringToUTF8(input, output, start) {\n\t\t\tvar pos = start;\n\t\t\tfor (var i = 0; i<input.length; i++) {\n\t\t\t\tvar charCode = input.charCodeAt(i);\n\n\t\t\t\t// Check for a surrogate pair.\n\t\t\t\tif (0xD800 <= charCode && charCode <= 0xDBFF) {\n\t\t\t\t\tvar lowCharCode = input.charCodeAt(++i);\n\t\t\t\t\tif (isNaN(lowCharCode)) {\n\t\t\t\t\t\tthrow new Error(format(ERROR.MALFORMED_UNICODE, [charCode, lowCharCode]));\n\t\t\t\t\t}\n\t\t\t\t\tcharCode = ((charCode - 0xD800)<<10) + (lowCharCode - 0xDC00) + 0x10000;\n\n\t\t\t\t}\n\n\t\t\t\tif (charCode <= 0x7F) {\n\t\t\t\t\toutput[pos++] = charCode;\n\t\t\t\t} else if (charCode <= 0x7FF) {\n\t\t\t\t\toutput[pos++] = charCode>>6  & 0x1F | 0xC0;\n\t\t\t\t\toutput[pos++] = charCode     & 0x3F | 0x80;\n\t\t\t\t} else if (charCode <= 0xFFFF) {\n\t\t\t\t\toutput[pos++] = charCode>>12 & 0x0F | 0xE0;\n\t\t\t\t\toutput[pos++] = charCode>>6  & 0x3F | 0x80;\n\t\t\t\t\toutput[pos++] = charCode     & 0x3F | 0x80;\n\t\t\t\t} else {\n\t\t\t\t\toutput[pos++] = charCode>>18 & 0x07 | 0xF0;\n\t\t\t\t\toutput[pos++] = charCode>>12 & 0x3F | 0x80;\n\t\t\t\t\toutput[pos++] = charCode>>6  & 0x3F | 0x80;\n\t\t\t\t\toutput[pos++] = charCode     & 0x3F | 0x80;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn output;\n\t\t}\n\n\t\tfunction parseUTF8(input, offset, length) {\n\t\t\tvar output = \"\";\n\t\t\tvar utf16;\n\t\t\tvar pos = offset;\n\n\t\t\twhile (pos < offset+length)\n\t\t\t{\n\t\t\t\tvar byte1 = input[pos++];\n\t\t\t\tif (byte1 < 128)\n\t\t\t\t\tutf16 = byte1;\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tvar byte2 = input[pos++]-128;\n\t\t\t\t\tif (byte2 < 0)\n\t\t\t\t\t\tthrow new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16),\"\"]));\n\t\t\t\t\tif (byte1 < 0xE0)             // 2 byte character\n\t\t\t\t\t\tutf16 = 64*(byte1-0xC0) + byte2;\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\tvar byte3 = input[pos++]-128;\n\t\t\t\t\t\tif (byte3 < 0)\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16), byte3.toString(16)]));\n\t\t\t\t\t\tif (byte1 < 0xF0)        // 3 byte character\n\t\t\t\t\t\t\tutf16 = 4096*(byte1-0xE0) + 64*byte2 + byte3;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tvar byte4 = input[pos++]-128;\n\t\t\t\t\t\t\tif (byte4 < 0)\n\t\t\t\t\t\t\t\tthrow new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16), byte3.toString(16), byte4.toString(16)]));\n\t\t\t\t\t\t\tif (byte1 < 0xF8)        // 4 byte character\n\t\t\t\t\t\t\t\tutf16 = 262144*(byte1-0xF0) + 4096*byte2 + 64*byte3 + byte4;\n\t\t\t\t\t\t\telse                     // longer encodings are not supported\n\t\t\t\t\t\t\t\tthrow new Error(format(ERROR.MALFORMED_UTF, [byte1.toString(16), byte2.toString(16), byte3.toString(16), byte4.toString(16)]));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (utf16 > 0xFFFF)   // 4 byte character - express as a surrogate pair\n\t\t\t\t{\n\t\t\t\t\tutf16 -= 0x10000;\n\t\t\t\t\toutput += String.fromCharCode(0xD800 + (utf16 >> 10)); // lead character\n\t\t\t\t\tutf16 = 0xDC00 + (utf16 & 0x3FF);  // trail character\n\t\t\t\t}\n\t\t\t\toutput += String.fromCharCode(utf16);\n\t\t\t}\n\t\t\treturn output;\n\t\t}\n\n\t\t/**\n\t * Repeat keepalive requests, monitor responses.\n\t * @ignore\n\t */\n\t\tvar Pinger = function(client, keepAliveInterval) {\n\t\t\tthis._client = client;\n\t\t\tthis._keepAliveInterval = keepAliveInterval*1000;\n\t\t\tthis.isReset = false;\n\n\t\t\tvar pingReq = new WireMessage(MESSAGE_TYPE.PINGREQ).encode();\n\n\t\t\tvar doTimeout = function (pinger) {\n\t\t\t\treturn function () {\n\t\t\t\t\treturn doPing.apply(pinger);\n\t\t\t\t};\n\t\t\t};\n\n\t\t\t/** @ignore */\n\t\t\tvar doPing = function() {\n\t\t\t\tif (!this.isReset) {\n\t\t\t\t\tthis._client._trace(\"Pinger.doPing\", \"Timed out\");\n\t\t\t\t\tthis._client._disconnected( ERROR.PING_TIMEOUT.code , format(ERROR.PING_TIMEOUT));\n\t\t\t\t} else {\n\t\t\t\t\tthis.isReset = false;\n\t\t\t\t\tthis._client._trace(\"Pinger.doPing\", \"send PINGREQ\");\n\t\t\t\t\tthis._client.socket.send(pingReq);\n\t\t\t\t\tthis.timeout = setTimeout(doTimeout(this), this._keepAliveInterval);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tthis.reset = function() {\n\t\t\t\tthis.isReset = true;\n\t\t\t\tclearTimeout(this.timeout);\n\t\t\t\tif (this._keepAliveInterval > 0)\n\t\t\t\t\tthis.timeout = setTimeout(doTimeout(this), this._keepAliveInterval);\n\t\t\t};\n\n\t\t\tthis.cancel = function() {\n\t\t\t\tclearTimeout(this.timeout);\n\t\t\t};\n\t\t};\n\n\t\t/**\n\t * Monitor request completion.\n\t * @ignore\n\t */\n\t\tvar Timeout = function(client, timeoutSeconds, action, args) {\n\t\t\tif (!timeoutSeconds)\n\t\t\t\ttimeoutSeconds = 30;\n\n\t\t\tvar doTimeout = function (action, client, args) {\n\t\t\t\treturn function () {\n\t\t\t\t\treturn action.apply(client, args);\n\t\t\t\t};\n\t\t\t};\n\t\t\tthis.timeout = setTimeout(doTimeout(action, client, args), timeoutSeconds * 1000);\n\n\t\t\tthis.cancel = function() {\n\t\t\t\tclearTimeout(this.timeout);\n\t\t\t};\n\t\t};\n\n\t/**\n\t * Internal implementation of the Websockets MQTT V3.1 client.\n\t *\n\t * @name Paho.ClientImpl @constructor\n\t * @param {String} host the DNS nameof the webSocket host.\n\t * @param {Number} port the port number for that host.\n\t * @param {String} clientId the MQ client identifier.\n\t */\n\t\tvar ClientImpl = function (uri, host, port, path, clientId) {\n\t\t// Check dependencies are satisfied in this browser.\n\t\t\tif (!(\"WebSocket\" in global && global.WebSocket !== null)) {\n\t\t\t\tthrow new Error(format(ERROR.UNSUPPORTED, [\"WebSocket\"]));\n\t\t\t}\n\t\t\tif (!(\"ArrayBuffer\" in global && global.ArrayBuffer !== null)) {\n\t\t\t\tthrow new Error(format(ERROR.UNSUPPORTED, [\"ArrayBuffer\"]));\n\t\t\t}\n\t\t\tthis._trace(\"Paho.Client\", uri, host, port, path, clientId);\n\n\t\t\tthis.host = host;\n\t\t\tthis.port = port;\n\t\t\tthis.path = path;\n\t\t\tthis.uri = uri;\n\t\t\tthis.clientId = clientId;\n\t\t\tthis._wsuri = null;\n\n\t\t\t// Local storagekeys are qualified with the following string.\n\t\t\t// The conditional inclusion of path in the key is for backward\n\t\t\t// compatibility to when the path was not configurable and assumed to\n\t\t\t// be /mqtt\n\t\t\tthis._localKey=host+\":\"+port+(path!=\"/mqtt\"?\":\"+path:\"\")+\":\"+clientId+\":\";\n\n\t\t\t// Create private instance-only message queue\n\t\t\t// Internal queue of messages to be sent, in sending order.\n\t\t\tthis._msg_queue = [];\n\t\t\tthis._buffered_msg_queue = [];\n\n\t\t\t// Messages we have sent and are expecting a response for, indexed by their respective message ids.\n\t\t\tthis._sentMessages = {};\n\n\t\t\t// Messages we have received and acknowleged and are expecting a confirm message for\n\t\t\t// indexed by their respective message ids.\n\t\t\tthis._receivedMessages = {};\n\n\t\t\t// Internal list of callbacks to be executed when messages\n\t\t\t// have been successfully sent over web socket, e.g. disconnect\n\t\t\t// when it doesn't have to wait for ACK, just message is dispatched.\n\t\t\tthis._notify_msg_sent = {};\n\n\t\t\t// Unique identifier for SEND messages, incrementing\n\t\t\t// counter as messages are sent.\n\t\t\tthis._message_identifier = 1;\n\n\t\t\t// Used to determine the transmission sequence of stored sent messages.\n\t\t\tthis._sequence = 0;\n\n\n\t\t\t// Load the local state, if any, from the saved version, only restore state relevant to this client.\n\t\t\tfor (var key in localStorage)\n\t\t\t\tif (   key.indexOf(\"Sent:\"+this._localKey) === 0 || key.indexOf(\"Received:\"+this._localKey) === 0)\n\t\t\t\t\tthis.restore(key);\n\t\t};\n\n\t\t// Messaging Client public instance members.\n\t\tClientImpl.prototype.host = null;\n\t\tClientImpl.prototype.port = null;\n\t\tClientImpl.prototype.path = null;\n\t\tClientImpl.prototype.uri = null;\n\t\tClientImpl.prototype.clientId = null;\n\n\t\t// Messaging Client private instance members.\n\t\tClientImpl.prototype.socket = null;\n\t\t/* true once we have received an acknowledgement to a CONNECT packet. */\n\t\tClientImpl.prototype.connected = false;\n\t\t/* The largest message identifier allowed, may not be larger than 2**16 but\n\t\t * if set smaller reduces the maximum number of outbound messages allowed.\n\t\t */\n\t\tClientImpl.prototype.maxMessageIdentifier = 65536;\n\t\tClientImpl.prototype.connectOptions = null;\n\t\tClientImpl.prototype.hostIndex = null;\n\t\tClientImpl.prototype.onConnected = null;\n\t\tClientImpl.prototype.onConnectionLost = null;\n\t\tClientImpl.prototype.onMessageDelivered = null;\n\t\tClientImpl.prototype.onMessageArrived = null;\n\t\tClientImpl.prototype.traceFunction = null;\n\t\tClientImpl.prototype._msg_queue = null;\n\t\tClientImpl.prototype._buffered_msg_queue = null;\n\t\tClientImpl.prototype._connectTimeout = null;\n\t\t/* The sendPinger monitors how long we allow before we send data to prove to the server that we are alive. */\n\t\tClientImpl.prototype.sendPinger = null;\n\t\t/* The receivePinger monitors how long we allow before we require evidence that the server is alive. */\n\t\tClientImpl.prototype.receivePinger = null;\n\t\tClientImpl.prototype._reconnectInterval = 1; // Reconnect Delay, starts at 1 second\n\t\tClientImpl.prototype._reconnecting = false;\n\t\tClientImpl.prototype._reconnectTimeout = null;\n\t\tClientImpl.prototype.disconnectedPublishing = false;\n\t\tClientImpl.prototype.disconnectedBufferSize = 5000;\n\n\t\tClientImpl.prototype.receiveBuffer = null;\n\n\t\tClientImpl.prototype._traceBuffer = null;\n\t\tClientImpl.prototype._MAX_TRACE_ENTRIES = 100;\n\n\t\tClientImpl.prototype.connect = function (connectOptions) {\n\t\t\tvar connectOptionsMasked = this._traceMask(connectOptions, \"password\");\n\t\t\tthis._trace(\"Client.connect\", connectOptionsMasked, this.socket, this.connected);\n\n\t\t\tif (this.connected)\n\t\t\t\tthrow new Error(format(ERROR.INVALID_STATE, [\"already connected\"]));\n\t\t\tif (this.socket)\n\t\t\t\tthrow new Error(format(ERROR.INVALID_STATE, [\"already connected\"]));\n\n\t\t\tif (this._reconnecting) {\n\t\t\t// connect() function is called while reconnect is in progress.\n\t\t\t// Terminate the auto reconnect process to use new connect options.\n\t\t\t\tthis._reconnectTimeout.cancel();\n\t\t\t\tthis._reconnectTimeout = null;\n\t\t\t\tthis._reconnecting = false;\n\t\t\t}\n\n\t\t\tthis.connectOptions = connectOptions;\n\t\t\tthis._reconnectInterval = 1;\n\t\t\tthis._reconnecting = false;\n\t\t\tif (connectOptions.uris) {\n\t\t\t\tthis.hostIndex = 0;\n\t\t\t\tthis._doConnect(connectOptions.uris[0]);\n\t\t\t} else {\n\t\t\t\tthis._doConnect(this.uri);\n\t\t\t}\n\n\t\t};\n\n\t\tClientImpl.prototype.subscribe = function (filter, subscribeOptions) {\n\t\t\tthis._trace(\"Client.subscribe\", filter, subscribeOptions);\n\n\t\t\tif (!this.connected)\n\t\t\t\tthrow new Error(format(ERROR.INVALID_STATE, [\"not connected\"]));\n\n            var wireMessage = new WireMessage(MESSAGE_TYPE.SUBSCRIBE);\n            wireMessage.topics = filter.constructor === Array ? filter : [filter];\n            if (subscribeOptions.qos === undefined)\n                subscribeOptions.qos = 0;\n            wireMessage.requestedQos = [];\n            for (var i = 0; i < wireMessage.topics.length; i++)\n                wireMessage.requestedQos[i] = subscribeOptions.qos;\n\n\t\t\tif (subscribeOptions.onSuccess) {\n\t\t\t\twireMessage.onSuccess = function(grantedQos) {subscribeOptions.onSuccess({invocationContext:subscribeOptions.invocationContext,grantedQos:grantedQos});};\n\t\t\t}\n\n\t\t\tif (subscribeOptions.onFailure) {\n\t\t\t\twireMessage.onFailure = function(errorCode) {subscribeOptions.onFailure({invocationContext:subscribeOptions.invocationContext,errorCode:errorCode, errorMessage:format(errorCode)});};\n\t\t\t}\n\n\t\t\tif (subscribeOptions.timeout) {\n\t\t\t\twireMessage.timeOut = new Timeout(this, subscribeOptions.timeout, subscribeOptions.onFailure,\n\t\t\t\t\t[{invocationContext:subscribeOptions.invocationContext,\n\t\t\t\t\t\terrorCode:ERROR.SUBSCRIBE_TIMEOUT.code,\n\t\t\t\t\t\terrorMessage:format(ERROR.SUBSCRIBE_TIMEOUT)}]);\n\t\t\t}\n\n\t\t\t// All subscriptions return a SUBACK.\n\t\t\tthis._requires_ack(wireMessage);\n\t\t\tthis._schedule_message(wireMessage);\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype.unsubscribe = function(filter, unsubscribeOptions) {\n\t\t\tthis._trace(\"Client.unsubscribe\", filter, unsubscribeOptions);\n\n\t\t\tif (!this.connected)\n\t\t\t\tthrow new Error(format(ERROR.INVALID_STATE, [\"not connected\"]));\n\n            var wireMessage = new WireMessage(MESSAGE_TYPE.UNSUBSCRIBE);\n            wireMessage.topics = filter.constructor === Array ? filter : [filter];\n\n\t\t\tif (unsubscribeOptions.onSuccess) {\n\t\t\t\twireMessage.callback = function() {unsubscribeOptions.onSuccess({invocationContext:unsubscribeOptions.invocationContext});};\n\t\t\t}\n\t\t\tif (unsubscribeOptions.timeout) {\n\t\t\t\twireMessage.timeOut = new Timeout(this, unsubscribeOptions.timeout, unsubscribeOptions.onFailure,\n\t\t\t\t\t[{invocationContext:unsubscribeOptions.invocationContext,\n\t\t\t\t\t\terrorCode:ERROR.UNSUBSCRIBE_TIMEOUT.code,\n\t\t\t\t\t\terrorMessage:format(ERROR.UNSUBSCRIBE_TIMEOUT)}]);\n\t\t\t}\n\n\t\t\t// All unsubscribes return a SUBACK.\n\t\t\tthis._requires_ack(wireMessage);\n\t\t\tthis._schedule_message(wireMessage);\n\t\t};\n\n\t\tClientImpl.prototype.send = function (message) {\n\t\t\tthis._trace(\"Client.send\", message);\n\n\t\t\tvar wireMessage = new WireMessage(MESSAGE_TYPE.PUBLISH);\n\t\t\twireMessage.payloadMessage = message;\n\n\t\t\tif (this.connected) {\n\t\t\t// Mark qos 1 & 2 message as \"ACK required\"\n\t\t\t// For qos 0 message, invoke onMessageDelivered callback if there is one.\n\t\t\t// Then schedule the message.\n\t\t\t\tif (message.qos > 0) {\n\t\t\t\t\tthis._requires_ack(wireMessage);\n\t\t\t\t} else if (this.onMessageDelivered) {\n\t\t\t\t\tthis._notify_msg_sent[wireMessage] = this.onMessageDelivered(wireMessage.payloadMessage);\n\t\t\t\t}\n\t\t\t\tthis._schedule_message(wireMessage);\n\t\t\t} else {\n\t\t\t// Currently disconnected, will not schedule this message\n\t\t\t// Check if reconnecting is in progress and disconnected publish is enabled.\n\t\t\t\tif (this._reconnecting && this.disconnectedPublishing) {\n\t\t\t\t// Check the limit which include the \"required ACK\" messages\n\t\t\t\t\tvar messageCount = Object.keys(this._sentMessages).length + this._buffered_msg_queue.length;\n\t\t\t\t\tif (messageCount > this.disconnectedBufferSize) {\n\t\t\t\t\t\tthrow new Error(format(ERROR.BUFFER_FULL, [this.disconnectedBufferSize]));\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (message.qos > 0) {\n\t\t\t\t\t\t// Mark this message as \"ACK required\"\n\t\t\t\t\t\t\tthis._requires_ack(wireMessage);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\twireMessage.sequence = ++this._sequence;\n\t\t\t\t\t\t\t// Add messages in fifo order to array, by adding to start\n\t\t\t\t\t\t\tthis._buffered_msg_queue.unshift(wireMessage);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error(format(ERROR.INVALID_STATE, [\"not connected\"]));\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tClientImpl.prototype.disconnect = function () {\n\t\t\tthis._trace(\"Client.disconnect\");\n\n\t\t\tif (this._reconnecting) {\n\t\t\t// disconnect() function is called while reconnect is in progress.\n\t\t\t// Terminate the auto reconnect process.\n\t\t\t\tthis._reconnectTimeout.cancel();\n\t\t\t\tthis._reconnectTimeout = null;\n\t\t\t\tthis._reconnecting = false;\n\t\t\t}\n\n\t\t\tif (!this.socket)\n\t\t\t\tthrow new Error(format(ERROR.INVALID_STATE, [\"not connecting or connected\"]));\n\n\t\t\tvar wireMessage = new WireMessage(MESSAGE_TYPE.DISCONNECT);\n\n\t\t\t// Run the disconnected call back as soon as the message has been sent,\n\t\t\t// in case of a failure later on in the disconnect processing.\n\t\t\t// as a consequence, the _disconected call back may be run several times.\n\t\t\tthis._notify_msg_sent[wireMessage] = scope(this._disconnected, this);\n\n\t\t\tthis._schedule_message(wireMessage);\n\t\t};\n\n\t\tClientImpl.prototype.getTraceLog = function () {\n\t\t\tif ( this._traceBuffer !== null ) {\n\t\t\t\tthis._trace(\"Client.getTraceLog\", new Date());\n\t\t\t\tthis._trace(\"Client.getTraceLog in flight messages\", this._sentMessages.length);\n\t\t\t\tfor (var key in this._sentMessages)\n\t\t\t\t\tthis._trace(\"_sentMessages \",key, this._sentMessages[key]);\n\t\t\t\tfor (var key in this._receivedMessages)\n\t\t\t\t\tthis._trace(\"_receivedMessages \",key, this._receivedMessages[key]);\n\n\t\t\t\treturn this._traceBuffer;\n\t\t\t}\n\t\t};\n\n\t\tClientImpl.prototype.startTrace = function () {\n\t\t\tif ( this._traceBuffer === null ) {\n\t\t\t\tthis._traceBuffer = [];\n\t\t\t}\n\t\t\tthis._trace(\"Client.startTrace\", new Date(), version);\n\t\t};\n\n\t\tClientImpl.prototype.stopTrace = function () {\n\t\t\tdelete this._traceBuffer;\n\t\t};\n\n\t\tClientImpl.prototype._doConnect = function (wsurl) {\n\t\t// When the socket is open, this client will send the CONNECT WireMessage using the saved parameters.\n\t\t\tif (this.connectOptions.useSSL) {\n\t\t\t\tvar uriParts = wsurl.split(\":\");\n\t\t\t\turiParts[0] = \"wss\";\n\t\t\t\twsurl = uriParts.join(\":\");\n\t\t\t}\n\t\t\tthis._wsuri = wsurl;\n\t\t\tthis.connected = false;\n\n\n\n\t\t\tif (this.connectOptions.mqttVersion < 4) {\n\t\t\t\tthis.socket = new WebSocket(wsurl, [\"mqttv3.1\"]);\n\t\t\t} else {\n\t\t\t\tthis.socket = new WebSocket(wsurl, [\"mqtt\"]);\n\t\t\t}\n\t\t\tthis.socket.binaryType = \"arraybuffer\";\n\t\t\tthis.socket.onopen = scope(this._on_socket_open, this);\n\t\t\tthis.socket.onmessage = scope(this._on_socket_message, this);\n\t\t\tthis.socket.onerror = scope(this._on_socket_error, this);\n\t\t\tthis.socket.onclose = scope(this._on_socket_close, this);\n\n\t\t\tthis.sendPinger = new Pinger(this, this.connectOptions.keepAliveInterval);\n\t\t\tthis.receivePinger = new Pinger(this, this.connectOptions.keepAliveInterval);\n\t\t\tif (this._connectTimeout) {\n\t\t\t\tthis._connectTimeout.cancel();\n\t\t\t\tthis._connectTimeout = null;\n\t\t\t}\n\t\t\tthis._connectTimeout = new Timeout(this, this.connectOptions.timeout, this._disconnected,  [ERROR.CONNECT_TIMEOUT.code, format(ERROR.CONNECT_TIMEOUT)]);\n\t\t};\n\n\n\t\t// Schedule a new message to be sent over the WebSockets\n\t\t// connection. CONNECT messages cause WebSocket connection\n\t\t// to be started. All other messages are queued internally\n\t\t// until this has happened. When WS connection starts, process\n\t\t// all outstanding messages.\n\t\tClientImpl.prototype._schedule_message = function (message) {\n\t\t\t// Add messages in fifo order to array, by adding to start\n\t\t\tthis._msg_queue.unshift(message);\n\t\t\t// Process outstanding messages in the queue if we have an  open socket, and have received CONNACK.\n\t\t\tif (this.connected) {\n\t\t\t\tthis._process_queue();\n\t\t\t}\n\t\t};\n\n\t\tClientImpl.prototype.store = function(prefix, wireMessage) {\n\t\t\tvar storedMessage = {type:wireMessage.type, messageIdentifier:wireMessage.messageIdentifier, version:1};\n\n\t\t\tswitch(wireMessage.type) {\n\t\t\tcase MESSAGE_TYPE.PUBLISH:\n\t\t\t\tif(wireMessage.pubRecReceived)\n\t\t\t\t\tstoredMessage.pubRecReceived = true;\n\n\t\t\t\t// Convert the payload to a hex string.\n\t\t\t\tstoredMessage.payloadMessage = {};\n\t\t\t\tvar hex = \"\";\n\t\t\t\tvar messageBytes = wireMessage.payloadMessage.payloadBytes;\n\t\t\t\tfor (var i=0; i<messageBytes.length; i++) {\n\t\t\t\t\tif (messageBytes[i] <= 0xF)\n\t\t\t\t\t\thex = hex+\"0\"+messageBytes[i].toString(16);\n\t\t\t\t\telse\n\t\t\t\t\t\thex = hex+messageBytes[i].toString(16);\n\t\t\t\t}\n\t\t\t\tstoredMessage.payloadMessage.payloadHex = hex;\n\n\t\t\t\tstoredMessage.payloadMessage.qos = wireMessage.payloadMessage.qos;\n\t\t\t\tstoredMessage.payloadMessage.destinationName = wireMessage.payloadMessage.destinationName;\n\t\t\t\tif (wireMessage.payloadMessage.duplicate)\n\t\t\t\t\tstoredMessage.payloadMessage.duplicate = true;\n\t\t\t\tif (wireMessage.payloadMessage.retained)\n\t\t\t\t\tstoredMessage.payloadMessage.retained = true;\n\n\t\t\t\t// Add a sequence number to sent messages.\n\t\t\t\tif ( prefix.indexOf(\"Sent:\") === 0 ) {\n\t\t\t\t\tif ( wireMessage.sequence === undefined )\n\t\t\t\t\t\twireMessage.sequence = ++this._sequence;\n\t\t\t\t\tstoredMessage.sequence = wireMessage.sequence;\n\t\t\t\t}\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tthrow Error(format(ERROR.INVALID_STORED_DATA, [prefix+this._localKey+wireMessage.messageIdentifier, storedMessage]));\n\t\t\t}\n\t\t\tlocalStorage.setItem(prefix+this._localKey+wireMessage.messageIdentifier, JSON.stringify(storedMessage));\n\t\t};\n\n\t\tClientImpl.prototype.restore = function(key) {\n\t\t\tvar value = localStorage.getItem(key);\n\t\t\tvar storedMessage = JSON.parse(value);\n\n\t\t\tvar wireMessage = new WireMessage(storedMessage.type, storedMessage);\n\n\t\t\tswitch(storedMessage.type) {\n\t\t\tcase MESSAGE_TYPE.PUBLISH:\n\t\t\t\t// Replace the payload message with a Message object.\n\t\t\t\tvar hex = storedMessage.payloadMessage.payloadHex;\n\t\t\t\tvar buffer = new ArrayBuffer((hex.length)/2);\n\t\t\t\tvar byteStream = new Uint8Array(buffer);\n\t\t\t\tvar i = 0;\n\t\t\t\twhile (hex.length >= 2) {\n\t\t\t\t\tvar x = parseInt(hex.substring(0, 2), 16);\n\t\t\t\t\thex = hex.substring(2, hex.length);\n\t\t\t\t\tbyteStream[i++] = x;\n\t\t\t\t}\n\t\t\t\tvar payloadMessage = new Message(byteStream);\n\n\t\t\t\tpayloadMessage.qos = storedMessage.payloadMessage.qos;\n\t\t\t\tpayloadMessage.destinationName = storedMessage.payloadMessage.destinationName;\n\t\t\t\tif (storedMessage.payloadMessage.duplicate)\n\t\t\t\t\tpayloadMessage.duplicate = true;\n\t\t\t\tif (storedMessage.payloadMessage.retained)\n\t\t\t\t\tpayloadMessage.retained = true;\n\t\t\t\twireMessage.payloadMessage = payloadMessage;\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tthrow Error(format(ERROR.INVALID_STORED_DATA, [key, value]));\n\t\t\t}\n\n\t\t\tif (key.indexOf(\"Sent:\"+this._localKey) === 0) {\n\t\t\t\twireMessage.payloadMessage.duplicate = true;\n\t\t\t\tthis._sentMessages[wireMessage.messageIdentifier] = wireMessage;\n\t\t\t} else if (key.indexOf(\"Received:\"+this._localKey) === 0) {\n\t\t\t\tthis._receivedMessages[wireMessage.messageIdentifier] = wireMessage;\n\t\t\t}\n\t\t};\n\n\t\tClientImpl.prototype._process_queue = function () {\n\t\t\tvar message = null;\n\n\t\t\t// Send all queued messages down socket connection\n\t\t\twhile ((message = this._msg_queue.pop())) {\n\t\t\t\tthis._socket_send(message);\n\t\t\t\t// Notify listeners that message was successfully sent\n\t\t\t\tif (this._notify_msg_sent[message]) {\n\t\t\t\t\tthis._notify_msg_sent[message]();\n\t\t\t\t\tdelete this._notify_msg_sent[message];\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t * Expect an ACK response for this message. Add message to the set of in progress\n\t * messages and set an unused identifier in this message.\n\t * @ignore\n\t */\n\t\tClientImpl.prototype._requires_ack = function (wireMessage) {\n\t\t\tvar messageCount = Object.keys(this._sentMessages).length;\n\t\t\tif (messageCount > this.maxMessageIdentifier)\n\t\t\t\tthrow Error (\"Too many messages:\"+messageCount);\n\n\t\t\twhile(this._sentMessages[this._message_identifier] !== undefined) {\n\t\t\t\tthis._message_identifier++;\n\t\t\t}\n\t\t\twireMessage.messageIdentifier = this._message_identifier;\n\t\t\tthis._sentMessages[wireMessage.messageIdentifier] = wireMessage;\n\t\t\tif (wireMessage.type === MESSAGE_TYPE.PUBLISH) {\n\t\t\t\tthis.store(\"Sent:\", wireMessage);\n\t\t\t}\n\t\t\tif (this._message_identifier === this.maxMessageIdentifier) {\n\t\t\t\tthis._message_identifier = 1;\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t * Called when the underlying websocket has been opened.\n\t * @ignore\n\t */\n\t\tClientImpl.prototype._on_socket_open = function () {\n\t\t// Create the CONNECT message object.\n\t\t\tvar wireMessage = new WireMessage(MESSAGE_TYPE.CONNECT, this.connectOptions);\n\t\t\twireMessage.clientId = this.clientId;\n\t\t\tthis._socket_send(wireMessage);\n\t\t};\n\n\t\t/**\n\t * Called when the underlying websocket has received a complete packet.\n\t * @ignore\n\t */\n\t\tClientImpl.prototype._on_socket_message = function (event) {\n\t\t\tthis._trace(\"Client._on_socket_message\", event.data);\n\t\t\tvar messages = this._deframeMessages(event.data);\n\t\t\tfor (var i = 0; i < messages.length; i+=1) {\n\t\t\t\tthis._handleMessage(messages[i]);\n\t\t\t}\n\t\t};\n\n\t\tClientImpl.prototype._deframeMessages = function(data) {\n\t\t\tvar byteArray = new Uint8Array(data);\n\t\t\tvar messages = [];\n\t\t\tif (this.receiveBuffer) {\n\t\t\t\tvar newData = new Uint8Array(this.receiveBuffer.length+byteArray.length);\n\t\t\t\tnewData.set(this.receiveBuffer);\n\t\t\t\tnewData.set(byteArray,this.receiveBuffer.length);\n\t\t\t\tbyteArray = newData;\n\t\t\t\tdelete this.receiveBuffer;\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tvar offset = 0;\n\t\t\t\twhile(offset < byteArray.length) {\n\t\t\t\t\tvar result = decodeMessage(byteArray,offset);\n\t\t\t\t\tvar wireMessage = result[0];\n\t\t\t\t\toffset = result[1];\n\t\t\t\t\tif (wireMessage !== null) {\n\t\t\t\t\t\tmessages.push(wireMessage);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (offset < byteArray.length) {\n\t\t\t\t\tthis.receiveBuffer = byteArray.subarray(offset);\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tvar errorStack = ((error.hasOwnProperty(\"stack\") == \"undefined\") ? error.stack.toString() : \"No Error Stack Available\");\n\t\t\t\tthis._disconnected(ERROR.INTERNAL_ERROR.code , format(ERROR.INTERNAL_ERROR, [error.message,errorStack]));\n\t\t\t\treturn;\n\t\t\t}\n\t\t\treturn messages;\n\t\t};\n\n\t\tClientImpl.prototype._handleMessage = function(wireMessage) {\n\n\t\t\tthis._trace(\"Client._handleMessage\", wireMessage);\n\n\t\t\ttry {\n\t\t\t\tswitch(wireMessage.type) {\n\t\t\t\tcase MESSAGE_TYPE.CONNACK:\n\t\t\t\t\tthis._connectTimeout.cancel();\n\t\t\t\t\tif (this._reconnectTimeout)\n\t\t\t\t\t\tthis._reconnectTimeout.cancel();\n\n\t\t\t\t\t// If we have started using clean session then clear up the local state.\n\t\t\t\t\tif (this.connectOptions.cleanSession) {\n\t\t\t\t\t\tfor (var key in this._sentMessages) {\n\t\t\t\t\t\t\tvar sentMessage = this._sentMessages[key];\n\t\t\t\t\t\t\tlocalStorage.removeItem(\"Sent:\"+this._localKey+sentMessage.messageIdentifier);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthis._sentMessages = {};\n\n\t\t\t\t\t\tfor (var key in this._receivedMessages) {\n\t\t\t\t\t\t\tvar receivedMessage = this._receivedMessages[key];\n\t\t\t\t\t\t\tlocalStorage.removeItem(\"Received:\"+this._localKey+receivedMessage.messageIdentifier);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthis._receivedMessages = {};\n\t\t\t\t\t}\n\t\t\t\t\t// Client connected and ready for business.\n\t\t\t\t\tif (wireMessage.returnCode === 0) {\n\n\t\t\t\t\t\tthis.connected = true;\n\t\t\t\t\t\t// Jump to the end of the list of uris and stop looking for a good host.\n\n\t\t\t\t\t\tif (this.connectOptions.uris)\n\t\t\t\t\t\t\tthis.hostIndex = this.connectOptions.uris.length;\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis._disconnected(ERROR.CONNACK_RETURNCODE.code , format(ERROR.CONNACK_RETURNCODE, [wireMessage.returnCode, CONNACK_RC[wireMessage.returnCode]]));\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Resend messages.\n\t\t\t\t\tvar sequencedMessages = [];\n\t\t\t\t\tfor (var msgId in this._sentMessages) {\n\t\t\t\t\t\tif (this._sentMessages.hasOwnProperty(msgId))\n\t\t\t\t\t\t\tsequencedMessages.push(this._sentMessages[msgId]);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Also schedule qos 0 buffered messages if any\n\t\t\t\t\tif (this._buffered_msg_queue.length > 0) {\n\t\t\t\t\t\tvar msg = null;\n\t\t\t\t\t\twhile ((msg = this._buffered_msg_queue.pop())) {\n\t\t\t\t\t\t\tsequencedMessages.push(msg);\n\t\t\t\t\t\t\tif (this.onMessageDelivered)\n\t\t\t\t\t\t\t\tthis._notify_msg_sent[msg] = this.onMessageDelivered(msg.payloadMessage);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Sort sentMessages into the original sent order.\n\t\t\t\t\tvar sequencedMessages = sequencedMessages.sort(function(a,b) {return a.sequence - b.sequence;} );\n\t\t\t\t\tfor (var i=0, len=sequencedMessages.length; i<len; i++) {\n\t\t\t\t\t\tvar sentMessage = sequencedMessages[i];\n\t\t\t\t\t\tif (sentMessage.type == MESSAGE_TYPE.PUBLISH && sentMessage.pubRecReceived) {\n\t\t\t\t\t\t\tvar pubRelMessage = new WireMessage(MESSAGE_TYPE.PUBREL, {messageIdentifier:sentMessage.messageIdentifier});\n\t\t\t\t\t\t\tthis._schedule_message(pubRelMessage);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis._schedule_message(sentMessage);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Execute the connectOptions.onSuccess callback if there is one.\n\t\t\t\t\t// Will also now return if this connection was the result of an automatic\n\t\t\t\t\t// reconnect and which URI was successfully connected to.\n\t\t\t\t\tif (this.connectOptions.onSuccess) {\n\t\t\t\t\t\tthis.connectOptions.onSuccess({invocationContext:this.connectOptions.invocationContext});\n\t\t\t\t\t}\n\n\t\t\t\t\tvar reconnected = false;\n\t\t\t\t\tif (this._reconnecting) {\n\t\t\t\t\t\treconnected = true;\n\t\t\t\t\t\tthis._reconnectInterval = 1;\n\t\t\t\t\t\tthis._reconnecting = false;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Execute the onConnected callback if there is one.\n\t\t\t\t\tthis._connected(reconnected, this._wsuri);\n\n\t\t\t\t\t// Process all queued messages now that the connection is established.\n\t\t\t\t\tthis._process_queue();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.PUBLISH:\n\t\t\t\t\tthis._receivePublish(wireMessage);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.PUBACK:\n\t\t\t\t\tvar sentMessage = this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\t// If this is a re flow of a PUBACK after we have restarted receivedMessage will not exist.\n\t\t\t\t\tif (sentMessage) {\n\t\t\t\t\t\tdelete this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\t\tlocalStorage.removeItem(\"Sent:\"+this._localKey+wireMessage.messageIdentifier);\n\t\t\t\t\t\tif (this.onMessageDelivered)\n\t\t\t\t\t\t\tthis.onMessageDelivered(sentMessage.payloadMessage);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.PUBREC:\n\t\t\t\t\tvar sentMessage = this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\t// If this is a re flow of a PUBREC after we have restarted receivedMessage will not exist.\n\t\t\t\t\tif (sentMessage) {\n\t\t\t\t\t\tsentMessage.pubRecReceived = true;\n\t\t\t\t\t\tvar pubRelMessage = new WireMessage(MESSAGE_TYPE.PUBREL, {messageIdentifier:wireMessage.messageIdentifier});\n\t\t\t\t\t\tthis.store(\"Sent:\", sentMessage);\n\t\t\t\t\t\tthis._schedule_message(pubRelMessage);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.PUBREL:\n\t\t\t\t\tvar receivedMessage = this._receivedMessages[wireMessage.messageIdentifier];\n\t\t\t\t\tlocalStorage.removeItem(\"Received:\"+this._localKey+wireMessage.messageIdentifier);\n\t\t\t\t\t// If this is a re flow of a PUBREL after we have restarted receivedMessage will not exist.\n\t\t\t\t\tif (receivedMessage) {\n\t\t\t\t\t\tthis._receiveMessage(receivedMessage);\n\t\t\t\t\t\tdelete this._receivedMessages[wireMessage.messageIdentifier];\n\t\t\t\t\t}\n\t\t\t\t\t// Always flow PubComp, we may have previously flowed PubComp but the server lost it and restarted.\n\t\t\t\t\tvar pubCompMessage = new WireMessage(MESSAGE_TYPE.PUBCOMP, {messageIdentifier:wireMessage.messageIdentifier});\n\t\t\t\t\tthis._schedule_message(pubCompMessage);\n\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.PUBCOMP:\n\t\t\t\t\tvar sentMessage = this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\tdelete this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\tlocalStorage.removeItem(\"Sent:\"+this._localKey+wireMessage.messageIdentifier);\n\t\t\t\t\tif (this.onMessageDelivered)\n\t\t\t\t\t\tthis.onMessageDelivered(sentMessage.payloadMessage);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.SUBACK:\n\t\t\t\t\tvar sentMessage = this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\tif (sentMessage) {\n\t\t\t\t\t\tif(sentMessage.timeOut)\n\t\t\t\t\t\t\tsentMessage.timeOut.cancel();\n\t\t\t\t\t\t// This will need to be fixed when we add multiple topic support\n\t\t\t\t\t\tif (wireMessage.returnCode[0] === 0x80) {\n\t\t\t\t\t\t\tif (sentMessage.onFailure) {\n\t\t\t\t\t\t\t\tsentMessage.onFailure(wireMessage.returnCode);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else if (sentMessage.onSuccess) {\n\t\t\t\t\t\t\tsentMessage.onSuccess(wireMessage.returnCode);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdelete this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.UNSUBACK:\n\t\t\t\t\tvar sentMessage = this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\tif (sentMessage) {\n\t\t\t\t\t\tif (sentMessage.timeOut)\n\t\t\t\t\t\t\tsentMessage.timeOut.cancel();\n\t\t\t\t\t\tif (sentMessage.callback) {\n\t\t\t\t\t\t\tsentMessage.callback();\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdelete this._sentMessages[wireMessage.messageIdentifier];\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.PINGRESP:\n\t\t\t\t/* The sendPinger or receivePinger may have sent a ping, the receivePinger has already been reset. */\n\t\t\t\t\tthis.sendPinger.reset();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MESSAGE_TYPE.DISCONNECT:\n\t\t\t\t// Clients do not expect to receive disconnect packets.\n\t\t\t\t\tthis._disconnected(ERROR.INVALID_MQTT_MESSAGE_TYPE.code , format(ERROR.INVALID_MQTT_MESSAGE_TYPE, [wireMessage.type]));\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\tthis._disconnected(ERROR.INVALID_MQTT_MESSAGE_TYPE.code , format(ERROR.INVALID_MQTT_MESSAGE_TYPE, [wireMessage.type]));\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tvar errorStack = ((error.hasOwnProperty(\"stack\") == \"undefined\") ? error.stack.toString() : \"No Error Stack Available\");\n\t\t\t\tthis._disconnected(ERROR.INTERNAL_ERROR.code , format(ERROR.INTERNAL_ERROR, [error.message,errorStack]));\n\t\t\t\treturn;\n\t\t\t}\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype._on_socket_error = function (error) {\n\t\t\tif (!this._reconnecting) {\n\t\t\t\tthis._disconnected(ERROR.SOCKET_ERROR.code , format(ERROR.SOCKET_ERROR, [error.data]));\n\t\t\t}\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype._on_socket_close = function () {\n\t\t\tif (!this._reconnecting) {\n\t\t\t\tthis._disconnected(ERROR.SOCKET_CLOSE.code , format(ERROR.SOCKET_CLOSE));\n\t\t\t}\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype._socket_send = function (wireMessage) {\n\n\t\t\tif (wireMessage.type == 1) {\n\t\t\t\tvar wireMessageMasked = this._traceMask(wireMessage, \"password\");\n\t\t\t\tthis._trace(\"Client._socket_send\", wireMessageMasked);\n\t\t\t}\n\t\t\telse this._trace(\"Client._socket_send\", wireMessage);\n\n\t\t\tthis.socket.send(wireMessage.encode());\n\t\t\t/* We have proved to the server we are alive. */\n\t\t\tthis.sendPinger.reset();\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype._receivePublish = function (wireMessage) {\n\t\t\tswitch(wireMessage.payloadMessage.qos) {\n\t\t\tcase \"undefined\":\n\t\t\tcase 0:\n\t\t\t\tthis._receiveMessage(wireMessage);\n\t\t\t\tbreak;\n\n\t\t\tcase 1:\n\t\t\t\tvar pubAckMessage = new WireMessage(MESSAGE_TYPE.PUBACK, {messageIdentifier:wireMessage.messageIdentifier});\n\t\t\t\tthis._schedule_message(pubAckMessage);\n\t\t\t\tthis._receiveMessage(wireMessage);\n\t\t\t\tbreak;\n\n\t\t\tcase 2:\n\t\t\t\tthis._receivedMessages[wireMessage.messageIdentifier] = wireMessage;\n\t\t\t\tthis.store(\"Received:\", wireMessage);\n\t\t\t\tvar pubRecMessage = new WireMessage(MESSAGE_TYPE.PUBREC, {messageIdentifier:wireMessage.messageIdentifier});\n\t\t\t\tthis._schedule_message(pubRecMessage);\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tthrow Error(\"Invaild qos=\" + wireMessage.payloadMessage.qos);\n\t\t\t}\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype._receiveMessage = function (wireMessage) {\n\t\t\tif (this.onMessageArrived) {\n\t\t\t\tthis.onMessageArrived(wireMessage.payloadMessage);\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t * Client has connected.\n\t * @param {reconnect} [boolean] indicate if this was a result of reconnect operation.\n\t * @param {uri} [string] fully qualified WebSocket URI of the server.\n\t */\n\t\tClientImpl.prototype._connected = function (reconnect, uri) {\n\t\t// Execute the onConnected callback if there is one.\n\t\t\tif (this.onConnected)\n\t\t\t\tthis.onConnected(reconnect, uri);\n\t\t};\n\n\t\t/**\n\t * Attempts to reconnect the client to the server.\n   * For each reconnect attempt, will double the reconnect interval\n   * up to 128 seconds.\n\t */\n\t\tClientImpl.prototype._reconnect = function () {\n\t\t\tthis._trace(\"Client._reconnect\");\n\t\t\tif (!this.connected) {\n\t\t\t\tthis._reconnecting = true;\n\t\t\t\tthis.sendPinger.cancel();\n\t\t\t\tthis.receivePinger.cancel();\n\t\t\t\tif (this._reconnectInterval < 128)\n\t\t\t\t\tthis._reconnectInterval = this._reconnectInterval * 2;\n\t\t\t\tif (this.connectOptions.uris) {\n\t\t\t\t\tthis.hostIndex = 0;\n\t\t\t\t\tthis._doConnect(this.connectOptions.uris[0]);\n\t\t\t\t} else {\n\t\t\t\t\tthis._doConnect(this.uri);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\t/**\n\t * Client has disconnected either at its own request or because the server\n\t * or network disconnected it. Remove all non-durable state.\n\t * @param {errorCode} [number] the error number.\n\t * @param {errorText} [string] the error text.\n\t * @ignore\n\t */\n\t\tClientImpl.prototype._disconnected = function (errorCode, errorText) {\n\t\t\tthis._trace(\"Client._disconnected\", errorCode, errorText);\n\n\t\t\tif (errorCode !== undefined && this._reconnecting) {\n\t\t\t\t//Continue automatic reconnect process\n\t\t\t\tthis._reconnectTimeout = new Timeout(this, this._reconnectInterval, this._reconnect);\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.sendPinger.cancel();\n\t\t\tthis.receivePinger.cancel();\n\t\t\tif (this._connectTimeout) {\n\t\t\t\tthis._connectTimeout.cancel();\n\t\t\t\tthis._connectTimeout = null;\n\t\t\t}\n\n\t\t\t// Clear message buffers.\n\t\t\tthis._msg_queue = [];\n\t\t\tthis._buffered_msg_queue = [];\n\t\t\tthis._notify_msg_sent = {};\n\n\t\t\tif (this.socket) {\n\t\t\t// Cancel all socket callbacks so that they cannot be driven again by this socket.\n\t\t\t\tthis.socket.onopen = null;\n\t\t\t\tthis.socket.onmessage = null;\n\t\t\t\tthis.socket.onerror = null;\n\t\t\t\tthis.socket.onclose = null;\n\t\t\t\tif (this.socket.readyState === 1)\n\t\t\t\t\tthis.socket.close();\n\t\t\t\tdelete this.socket;\n\t\t\t}\n\n\t\t\tif (this.connectOptions.uris && this.hostIndex < this.connectOptions.uris.length-1) {\n\t\t\t// Try the next host.\n\t\t\t\tthis.hostIndex++;\n\t\t\t\tthis._doConnect(this.connectOptions.uris[this.hostIndex]);\n\t\t\t} else {\n\n\t\t\t\tif (errorCode === undefined) {\n\t\t\t\t\terrorCode = ERROR.OK.code;\n\t\t\t\t\terrorText = format(ERROR.OK);\n\t\t\t\t}\n\n\t\t\t\t// Run any application callbacks last as they may attempt to reconnect and hence create a new socket.\n\t\t\t\tif (this.connected) {\n\t\t\t\t\tthis.connected = false;\n\t\t\t\t\t// Execute the connectionLostCallback if there is one, and we were connected.\n\t\t\t\t\tif (this.onConnectionLost) {\n\t\t\t\t\t\tthis.onConnectionLost({errorCode:errorCode, errorMessage:errorText, reconnect:this.connectOptions.reconnect, uri:this._wsuri});\n\t\t\t\t\t}\n\t\t\t\t\tif (errorCode !== ERROR.OK.code && this.connectOptions.reconnect) {\n\t\t\t\t\t// Start automatic reconnect process for the very first time since last successful connect.\n\t\t\t\t\t\tthis._reconnectInterval = 1;\n\t\t\t\t\t\tthis._reconnect();\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t// Otherwise we never had a connection, so indicate that the connect has failed.\n\t\t\t\t\tif (this.connectOptions.mqttVersion === 4 && this.connectOptions.mqttVersionExplicit === false) {\n\t\t\t\t\t\tthis._trace(\"Failed to connect V4, dropping back to V3\");\n\t\t\t\t\t\tthis.connectOptions.mqttVersion = 3;\n\t\t\t\t\t\tif (this.connectOptions.uris) {\n\t\t\t\t\t\t\tthis.hostIndex = 0;\n\t\t\t\t\t\t\tthis._doConnect(this.connectOptions.uris[0]);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis._doConnect(this.uri);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if(this.connectOptions.onFailure) {\n\t\t\t\t\t\tthis.connectOptions.onFailure({invocationContext:this.connectOptions.invocationContext, errorCode:errorCode, errorMessage:errorText});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype._trace = function () {\n\t\t// Pass trace message back to client's callback function\n\t\t\tif (this.traceFunction) {\n\t\t\t\tvar args = Array.prototype.slice.call(arguments);\n\t\t\t\tfor (var i in args)\n\t\t\t\t{\n\t\t\t\t\tif (typeof args[i] !== \"undefined\")\n\t\t\t\t\t\targs.splice(i, 1, JSON.stringify(args[i]));\n\t\t\t\t}\n\t\t\t\tvar record = args.join(\"\");\n\t\t\t\tthis.traceFunction ({severity: \"Debug\", message: record\t});\n\t\t\t}\n\n\t\t\t//buffer style trace\n\t\t\tif ( this._traceBuffer !== null ) {\n\t\t\t\tfor (var i = 0, max = arguments.length; i < max; i++) {\n\t\t\t\t\tif ( this._traceBuffer.length == this._MAX_TRACE_ENTRIES ) {\n\t\t\t\t\t\tthis._traceBuffer.shift();\n\t\t\t\t\t}\n\t\t\t\t\tif (i === 0) this._traceBuffer.push(arguments[i]);\n\t\t\t\t\telse if (typeof arguments[i] === \"undefined\" ) this._traceBuffer.push(arguments[i]);\n\t\t\t\t\telse this._traceBuffer.push(\"  \"+JSON.stringify(arguments[i]));\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\t/** @ignore */\n\t\tClientImpl.prototype._traceMask = function (traceObject, masked) {\n\t\t\tvar traceObjectMasked = {};\n\t\t\tfor (var attr in traceObject) {\n\t\t\t\tif (traceObject.hasOwnProperty(attr)) {\n\t\t\t\t\tif (attr == masked)\n\t\t\t\t\t\ttraceObjectMasked[attr] = \"******\";\n\t\t\t\t\telse\n\t\t\t\t\t\ttraceObjectMasked[attr] = traceObject[attr];\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn traceObjectMasked;\n\t\t};\n\n\t\t// ------------------------------------------------------------------------\n\t\t// Public Programming interface.\n\t\t// ------------------------------------------------------------------------\n\n\t\t/**\n\t * The JavaScript application communicates to the server using a {@link Paho.Client} object.\n\t * <p>\n\t * Most applications will create just one Client object and then call its connect() method,\n\t * however applications can create more than one Client object if they wish.\n\t * In this case the combination of host, port and clientId attributes must be different for each Client object.\n\t * <p>\n\t * The send, subscribe and unsubscribe methods are implemented as asynchronous JavaScript methods\n\t * (even though the underlying protocol exchange might be synchronous in nature).\n\t * This means they signal their completion by calling back to the application,\n\t * via Success or Failure callback functions provided by the application on the method in question.\n\t * Such callbacks are called at most once per method invocation and do not persist beyond the lifetime\n\t * of the script that made the invocation.\n\t * <p>\n\t * In contrast there are some callback functions, most notably <i>onMessageArrived</i>,\n\t * that are defined on the {@link Paho.Client} object.\n\t * These may get called multiple times, and aren't directly related to specific method invocations made by the client.\n\t *\n\t * @name Paho.Client\n\t *\n\t * @constructor\n\t *\n\t * @param {string} host - the address of the messaging server, as a fully qualified WebSocket URI, as a DNS name or dotted decimal IP address.\n\t * @param {number} port - the port number to connect to - only required if host is not a URI\n\t * @param {string} path - the path on the host to connect to - only used if host is not a URI. Default: '/mqtt'.\n\t * @param {string} clientId - the Messaging client identifier, between 1 and 23 characters in length.\n\t *\n\t * @property {string} host - <i>read only</i> the server's DNS hostname or dotted decimal IP address.\n\t * @property {number} port - <i>read only</i> the server's port.\n\t * @property {string} path - <i>read only</i> the server's path.\n\t * @property {string} clientId - <i>read only</i> used when connecting to the server.\n\t * @property {function} onConnectionLost - called when a connection has been lost.\n\t *                            after a connect() method has succeeded.\n\t *                            Establish the call back used when a connection has been lost. The connection may be\n\t *                            lost because the client initiates a disconnect or because the server or network\n\t *                            cause the client to be disconnected. The disconnect call back may be called without\n\t *                            the connectionComplete call back being invoked if, for example the client fails to\n\t *                            connect.\n\t *                            A single response object parameter is passed to the onConnectionLost callback containing the following fields:\n\t *                            <ol>\n\t *                            <li>errorCode\n\t *                            <li>errorMessage\n\t *                            </ol>\n\t * @property {function} onMessageDelivered - called when a message has been delivered.\n\t *                            All processing that this Client will ever do has been completed. So, for example,\n\t *                            in the case of a Qos=2 message sent by this client, the PubComp flow has been received from the server\n\t *                            and the message has been removed from persistent storage before this callback is invoked.\n\t *                            Parameters passed to the onMessageDelivered callback are:\n\t *                            <ol>\n\t *                            <li>{@link Paho.Message} that was delivered.\n\t *                            </ol>\n\t * @property {function} onMessageArrived - called when a message has arrived in this Paho.client.\n\t *                            Parameters passed to the onMessageArrived callback are:\n\t *                            <ol>\n\t *                            <li>{@link Paho.Message} that has arrived.\n\t *                            </ol>\n\t * @property {function} onConnected - called when a connection is successfully made to the server.\n\t *                                  after a connect() method.\n\t *                                  Parameters passed to the onConnected callback are:\n\t *                                  <ol>\n\t *                                  <li>reconnect (boolean) - If true, the connection was the result of a reconnect.</li>\n\t *                                  <li>URI (string) - The URI used to connect to the server.</li>\n\t *                                  </ol>\n\t * @property {boolean} disconnectedPublishing - if set, will enable disconnected publishing in\n\t *                                            in the event that the connection to the server is lost.\n\t * @property {number} disconnectedBufferSize - Used to set the maximum number of messages that the disconnected\n\t *                                             buffer will hold before rejecting new messages. Default size: 5000 messages\n\t * @property {function} trace - called whenever trace is called. TODO\n\t */\n\t\tvar Client = function (host, port, path, clientId) {\n\n\t\t\tvar uri;\n\n\t\t\tif (typeof host !== \"string\")\n\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof host, \"host\"]));\n\n\t\t\tif (arguments.length == 2) {\n\t\t\t// host: must be full ws:// uri\n\t\t\t// port: clientId\n\t\t\t\tclientId = port;\n\t\t\t\turi = host;\n\t\t\t\tvar match = uri.match(/^(wss?):\\/\\/((\\[(.+)\\])|([^\\/]+?))(:(\\d+))?(\\/.*)$/);\n\t\t\t\tif (match) {\n\t\t\t\t\thost = match[4]||match[2];\n\t\t\t\t\tport = parseInt(match[7]);\n\t\t\t\t\tpath = match[8];\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT,[host,\"host\"]));\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (arguments.length == 3) {\n\t\t\t\t\tclientId = path;\n\t\t\t\t\tpath = \"/mqtt\";\n\t\t\t\t}\n\t\t\t\tif (typeof port !== \"number\" || port < 0)\n\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof port, \"port\"]));\n\t\t\t\tif (typeof path !== \"string\")\n\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof path, \"path\"]));\n\n\t\t\t\tvar ipv6AddSBracket = (host.indexOf(\":\") !== -1 && host.slice(0,1) !== \"[\" && host.slice(-1) !== \"]\");\n\t\t\t\turi = \"ws://\"+(ipv6AddSBracket?\"[\"+host+\"]\":host)+\":\"+port+path;\n\t\t\t}\n\n\t\t\tvar clientIdLength = 0;\n\t\t\tfor (var i = 0; i<clientId.length; i++) {\n\t\t\t\tvar charCode = clientId.charCodeAt(i);\n\t\t\t\tif (0xD800 <= charCode && charCode <= 0xDBFF)  {\n\t\t\t\t\ti++; // Surrogate pair.\n\t\t\t\t}\n\t\t\t\tclientIdLength++;\n\t\t\t}\n\t\t\tif (typeof clientId !== \"string\" || clientIdLength > 65535)\n\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [clientId, \"clientId\"]));\n\n\t\t\tvar client = new ClientImpl(uri, host, port, path, clientId);\n\n\t\t\t//Public Properties\n\t\t\tObject.defineProperties(this,{\n\t\t\t\t\"host\":{\n\t\t\t\t\tget: function() { return host; },\n\t\t\t\t\tset: function() { throw new Error(format(ERROR.UNSUPPORTED_OPERATION)); }\n\t\t\t\t},\n\t\t\t\t\"port\":{\n\t\t\t\t\tget: function() { return port; },\n\t\t\t\t\tset: function() { throw new Error(format(ERROR.UNSUPPORTED_OPERATION)); }\n\t\t\t\t},\n\t\t\t\t\"path\":{\n\t\t\t\t\tget: function() { return path; },\n\t\t\t\t\tset: function() { throw new Error(format(ERROR.UNSUPPORTED_OPERATION)); }\n\t\t\t\t},\n\t\t\t\t\"uri\":{\n\t\t\t\t\tget: function() { return uri; },\n\t\t\t\t\tset: function() { throw new Error(format(ERROR.UNSUPPORTED_OPERATION)); }\n\t\t\t\t},\n\t\t\t\t\"clientId\":{\n\t\t\t\t\tget: function() { return client.clientId; },\n\t\t\t\t\tset: function() { throw new Error(format(ERROR.UNSUPPORTED_OPERATION)); }\n\t\t\t\t},\n\t\t\t\t\"onConnected\":{\n\t\t\t\t\tget: function() { return client.onConnected; },\n\t\t\t\t\tset: function(newOnConnected) {\n\t\t\t\t\t\tif (typeof newOnConnected === \"function\")\n\t\t\t\t\t\t\tclient.onConnected = newOnConnected;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof newOnConnected, \"onConnected\"]));\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"disconnectedPublishing\":{\n\t\t\t\t\tget: function() { return client.disconnectedPublishing; },\n\t\t\t\t\tset: function(newDisconnectedPublishing) {\n\t\t\t\t\t\tclient.disconnectedPublishing = newDisconnectedPublishing;\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"disconnectedBufferSize\":{\n\t\t\t\t\tget: function() { return client.disconnectedBufferSize; },\n\t\t\t\t\tset: function(newDisconnectedBufferSize) {\n\t\t\t\t\t\tclient.disconnectedBufferSize = newDisconnectedBufferSize;\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"onConnectionLost\":{\n\t\t\t\t\tget: function() { return client.onConnectionLost; },\n\t\t\t\t\tset: function(newOnConnectionLost) {\n\t\t\t\t\t\tif (typeof newOnConnectionLost === \"function\")\n\t\t\t\t\t\t\tclient.onConnectionLost = newOnConnectionLost;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof newOnConnectionLost, \"onConnectionLost\"]));\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"onMessageDelivered\":{\n\t\t\t\t\tget: function() { return client.onMessageDelivered; },\n\t\t\t\t\tset: function(newOnMessageDelivered) {\n\t\t\t\t\t\tif (typeof newOnMessageDelivered === \"function\")\n\t\t\t\t\t\t\tclient.onMessageDelivered = newOnMessageDelivered;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof newOnMessageDelivered, \"onMessageDelivered\"]));\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"onMessageArrived\":{\n\t\t\t\t\tget: function() { return client.onMessageArrived; },\n\t\t\t\t\tset: function(newOnMessageArrived) {\n\t\t\t\t\t\tif (typeof newOnMessageArrived === \"function\")\n\t\t\t\t\t\t\tclient.onMessageArrived = newOnMessageArrived;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof newOnMessageArrived, \"onMessageArrived\"]));\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"trace\":{\n\t\t\t\t\tget: function() { return client.traceFunction; },\n\t\t\t\t\tset: function(trace) {\n\t\t\t\t\t\tif(typeof trace === \"function\"){\n\t\t\t\t\t\t\tclient.traceFunction = trace;\n\t\t\t\t\t\t}else{\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof trace, \"onTrace\"]));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t});\n\n\t\t\t/**\n\t\t * Connect this Messaging client to its server.\n\t\t *\n\t\t * @name Paho.Client#connect\n\t\t * @function\n\t\t * @param {object} connectOptions - Attributes used with the connection.\n\t\t * @param {number} connectOptions.timeout - If the connect has not succeeded within this\n\t\t *                    number of seconds, it is deemed to have failed.\n\t\t *                    The default is 30 seconds.\n\t\t * @param {string} connectOptions.userName - Authentication username for this connection.\n\t\t * @param {string} connectOptions.password - Authentication password for this connection.\n\t\t * @param {Paho.Message} connectOptions.willMessage - sent by the server when the client\n\t\t *                    disconnects abnormally.\n\t\t * @param {number} connectOptions.keepAliveInterval - the server disconnects this client if\n\t\t *                    there is no activity for this number of seconds.\n\t\t *                    The default value of 60 seconds is assumed if not set.\n\t\t * @param {boolean} connectOptions.cleanSession - if true(default) the client and server\n\t\t *                    persistent state is deleted on successful connect.\n\t\t * @param {boolean} connectOptions.useSSL - if present and true, use an SSL Websocket connection.\n\t\t * @param {object} connectOptions.invocationContext - passed to the onSuccess callback or onFailure callback.\n\t\t * @param {function} connectOptions.onSuccess - called when the connect acknowledgement\n\t\t *                    has been received from the server.\n\t\t * A single response object parameter is passed to the onSuccess callback containing the following fields:\n\t\t * <ol>\n\t\t * <li>invocationContext as passed in to the onSuccess method in the connectOptions.\n\t\t * </ol>\n\t * @param {function} connectOptions.onFailure - called when the connect request has failed or timed out.\n\t\t * A single response object parameter is passed to the onFailure callback containing the following fields:\n\t\t * <ol>\n\t\t * <li>invocationContext as passed in to the onFailure method in the connectOptions.\n\t\t * <li>errorCode a number indicating the nature of the error.\n\t\t * <li>errorMessage text describing the error.\n\t\t * </ol>\n\t * @param {array} connectOptions.hosts - If present this contains either a set of hostnames or fully qualified\n\t\t * WebSocket URIs (ws://iot.eclipse.org:80/ws), that are tried in order in place\n\t\t * of the host and port paramater on the construtor. The hosts are tried one at at time in order until\n\t\t * one of then succeeds.\n\t * @param {array} connectOptions.ports - If present the set of ports matching the hosts. If hosts contains URIs, this property\n\t\t * is not used.\n\t * @param {boolean} connectOptions.reconnect - Sets whether the client will automatically attempt to reconnect\n\t * to the server if the connection is lost.\n\t *<ul>\n\t *<li>If set to false, the client will not attempt to automatically reconnect to the server in the event that the\n\t * connection is lost.</li>\n\t *<li>If set to true, in the event that the connection is lost, the client will attempt to reconnect to the server.\n\t * It will initially wait 1 second before it attempts to reconnect, for every failed reconnect attempt, the delay\n\t * will double until it is at 2 minutes at which point the delay will stay at 2 minutes.</li>\n\t *</ul>\n\t * @param {number} connectOptions.mqttVersion - The version of MQTT to use to connect to the MQTT Broker.\n\t *<ul>\n\t *<li>3 - MQTT V3.1</li>\n\t *<li>4 - MQTT V3.1.1</li>\n\t *</ul>\n\t * @param {boolean} connectOptions.mqttVersionExplicit - If set to true, will force the connection to use the\n\t * selected MQTT Version or will fail to connect.\n\t * @param {array} connectOptions.uris - If present, should contain a list of fully qualified WebSocket uris\n\t * (e.g. ws://iot.eclipse.org:80/ws), that are tried in order in place of the host and port parameter of the construtor.\n\t * The uris are tried one at a time in order until one of them succeeds. Do not use this in conjunction with hosts as\n\t * the hosts array will be converted to uris and will overwrite this property.\n\t\t * @throws {InvalidState} If the client is not in disconnected state. The client must have received connectionLost\n\t\t * or disconnected before calling connect for a second or subsequent time.\n\t\t */\n\t\t\tthis.connect = function (connectOptions) {\n\t\t\t\tconnectOptions = connectOptions || {} ;\n\t\t\t\tvalidate(connectOptions,  {timeout:\"number\",\n\t\t\t\t\tuserName:\"string\",\n\t\t\t\t\tpassword:\"string\",\n\t\t\t\t\twillMessage:\"object\",\n\t\t\t\t\tkeepAliveInterval:\"number\",\n\t\t\t\t\tcleanSession:\"boolean\",\n\t\t\t\t\tuseSSL:\"boolean\",\n\t\t\t\t\tinvocationContext:\"object\",\n\t\t\t\t\tonSuccess:\"function\",\n\t\t\t\t\tonFailure:\"function\",\n\t\t\t\t\thosts:\"object\",\n\t\t\t\t\tports:\"object\",\n\t\t\t\t\treconnect:\"boolean\",\n\t\t\t\t\tmqttVersion:\"number\",\n\t\t\t\t\tmqttVersionExplicit:\"boolean\",\n\t\t\t\t\turis: \"object\"});\n\n\t\t\t\t// If no keep alive interval is set, assume 60 seconds.\n\t\t\t\tif (connectOptions.keepAliveInterval === undefined)\n\t\t\t\t\tconnectOptions.keepAliveInterval = 60;\n\n\t\t\t\tif (connectOptions.mqttVersion > 4 || connectOptions.mqttVersion < 3) {\n\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.mqttVersion, \"connectOptions.mqttVersion\"]));\n\t\t\t\t}\n\n\t\t\t\tif (connectOptions.mqttVersion === undefined) {\n\t\t\t\t\tconnectOptions.mqttVersionExplicit = false;\n\t\t\t\t\tconnectOptions.mqttVersion = 4;\n\t\t\t\t} else {\n\t\t\t\t\tconnectOptions.mqttVersionExplicit = true;\n\t\t\t\t}\n\n\t\t\t\t//Check that if password is set, so is username\n\t\t\t\tif (connectOptions.password !== undefined && connectOptions.userName === undefined)\n\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.password, \"connectOptions.password\"]));\n\n\t\t\t\tif (connectOptions.willMessage) {\n\t\t\t\t\tif (!(connectOptions.willMessage instanceof Message))\n\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [connectOptions.willMessage, \"connectOptions.willMessage\"]));\n\t\t\t\t\t// The will message must have a payload that can be represented as a string.\n\t\t\t\t\t// Cause the willMessage to throw an exception if this is not the case.\n\t\t\t\t\tconnectOptions.willMessage.stringPayload = null;\n\n\t\t\t\t\tif (typeof connectOptions.willMessage.destinationName === \"undefined\")\n\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof connectOptions.willMessage.destinationName, \"connectOptions.willMessage.destinationName\"]));\n\t\t\t\t}\n\t\t\t\tif (typeof connectOptions.cleanSession === \"undefined\")\n\t\t\t\t\tconnectOptions.cleanSession = true;\n\t\t\t\tif (connectOptions.hosts) {\n\n\t\t\t\t\tif (!(connectOptions.hosts instanceof Array) )\n\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.hosts, \"connectOptions.hosts\"]));\n\t\t\t\t\tif (connectOptions.hosts.length <1 )\n\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.hosts, \"connectOptions.hosts\"]));\n\n\t\t\t\t\tvar usingURIs = false;\n\t\t\t\t\tfor (var i = 0; i<connectOptions.hosts.length; i++) {\n\t\t\t\t\t\tif (typeof connectOptions.hosts[i] !== \"string\")\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof connectOptions.hosts[i], \"connectOptions.hosts[\"+i+\"]\"]));\n\t\t\t\t\t\tif (/^(wss?):\\/\\/((\\[(.+)\\])|([^\\/]+?))(:(\\d+))?(\\/.*)$/.test(connectOptions.hosts[i])) {\n\t\t\t\t\t\t\tif (i === 0) {\n\t\t\t\t\t\t\t\tusingURIs = true;\n\t\t\t\t\t\t\t} else if (!usingURIs) {\n\t\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.hosts[i], \"connectOptions.hosts[\"+i+\"]\"]));\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else if (usingURIs) {\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.hosts[i], \"connectOptions.hosts[\"+i+\"]\"]));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!usingURIs) {\n\t\t\t\t\t\tif (!connectOptions.ports)\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.ports, \"connectOptions.ports\"]));\n\t\t\t\t\t\tif (!(connectOptions.ports instanceof Array) )\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.ports, \"connectOptions.ports\"]));\n\t\t\t\t\t\tif (connectOptions.hosts.length !== connectOptions.ports.length)\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [connectOptions.ports, \"connectOptions.ports\"]));\n\n\t\t\t\t\t\tconnectOptions.uris = [];\n\n\t\t\t\t\t\tfor (var i = 0; i<connectOptions.hosts.length; i++) {\n\t\t\t\t\t\t\tif (typeof connectOptions.ports[i] !== \"number\" || connectOptions.ports[i] < 0)\n\t\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_TYPE, [typeof connectOptions.ports[i], \"connectOptions.ports[\"+i+\"]\"]));\n\t\t\t\t\t\t\tvar host = connectOptions.hosts[i];\n\t\t\t\t\t\t\tvar port = connectOptions.ports[i];\n\n\t\t\t\t\t\t\tvar ipv6 = (host.indexOf(\":\") !== -1);\n\t\t\t\t\t\t\turi = \"ws://\"+(ipv6?\"[\"+host+\"]\":host)+\":\"+port+path;\n\t\t\t\t\t\t\tconnectOptions.uris.push(uri);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconnectOptions.uris = connectOptions.hosts;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tclient.connect(connectOptions);\n\t\t\t};\n\n\t\t\t/**\n\t\t * Subscribe for messages, request receipt of a copy of messages sent to the destinations described by the filter.\n\t\t *\n\t\t * @name Paho.Client#subscribe\n\t\t * @function\n\t\t * @param {string} filter describing the destinations to receive messages from.\n\t\t * <br>\n\t\t * @param {object} subscribeOptions - used to control the subscription\n\t\t *\n\t\t * @param {number} subscribeOptions.qos - the maximum qos of any publications sent\n\t\t *                                  as a result of making this subscription.\n\t\t * @param {object} subscribeOptions.invocationContext - passed to the onSuccess callback\n\t\t *                                  or onFailure callback.\n\t\t * @param {function} subscribeOptions.onSuccess - called when the subscribe acknowledgement\n\t\t *                                  has been received from the server.\n\t\t *                                  A single response object parameter is passed to the onSuccess callback containing the following fields:\n\t\t *                                  <ol>\n\t\t *                                  <li>invocationContext if set in the subscribeOptions.\n\t\t *                                  </ol>\n\t\t * @param {function} subscribeOptions.onFailure - called when the subscribe request has failed or timed out.\n\t\t *                                  A single response object parameter is passed to the onFailure callback containing the following fields:\n\t\t *                                  <ol>\n\t\t *                                  <li>invocationContext - if set in the subscribeOptions.\n\t\t *                                  <li>errorCode - a number indicating the nature of the error.\n\t\t *                                  <li>errorMessage - text describing the error.\n\t\t *                                  </ol>\n\t\t * @param {number} subscribeOptions.timeout - which, if present, determines the number of\n\t\t *                                  seconds after which the onFailure calback is called.\n\t\t *                                  The presence of a timeout does not prevent the onSuccess\n\t\t *                                  callback from being called when the subscribe completes.\n\t\t * @throws {InvalidState} if the client is not in connected state.\n\t\t */\n\t\t\tthis.subscribe = function (filter, subscribeOptions) {\n\t\t\t\tif (typeof filter !== \"string\" && filter.constructor !== Array)\n\t\t\t\t\tthrow new Error(\"Invalid argument:\"+filter);\n\t\t\t\tsubscribeOptions = subscribeOptions || {} ;\n\t\t\t\tvalidate(subscribeOptions,  {qos:\"number\",\n\t\t\t\t\tinvocationContext:\"object\",\n\t\t\t\t\tonSuccess:\"function\",\n\t\t\t\t\tonFailure:\"function\",\n\t\t\t\t\ttimeout:\"number\"\n\t\t\t\t});\n\t\t\t\tif (subscribeOptions.timeout && !subscribeOptions.onFailure)\n\t\t\t\t\tthrow new Error(\"subscribeOptions.timeout specified with no onFailure callback.\");\n\t\t\t\tif (typeof subscribeOptions.qos !== \"undefined\" && !(subscribeOptions.qos === 0 || subscribeOptions.qos === 1 || subscribeOptions.qos === 2 ))\n\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [subscribeOptions.qos, \"subscribeOptions.qos\"]));\n\t\t\t\tclient.subscribe(filter, subscribeOptions);\n\t\t\t};\n\n\t\t/**\n\t\t * Unsubscribe for messages, stop receiving messages sent to destinations described by the filter.\n\t\t *\n\t\t * @name Paho.Client#unsubscribe\n\t\t * @function\n\t\t * @param {string} filter - describing the destinations to receive messages from.\n\t\t * @param {object} unsubscribeOptions - used to control the subscription\n\t\t * @param {object} unsubscribeOptions.invocationContext - passed to the onSuccess callback\n\t\t\t\t\t\t\t\t\t\t\t  or onFailure callback.\n\t\t * @param {function} unsubscribeOptions.onSuccess - called when the unsubscribe acknowledgement has been received from the server.\n\t\t *                                    A single response object parameter is passed to the\n\t\t *                                    onSuccess callback containing the following fields:\n\t\t *                                    <ol>\n\t\t *                                    <li>invocationContext - if set in the unsubscribeOptions.\n\t\t *                                    </ol>\n\t\t * @param {function} unsubscribeOptions.onFailure called when the unsubscribe request has failed or timed out.\n\t\t *                                    A single response object parameter is passed to the onFailure callback containing the following fields:\n\t\t *                                    <ol>\n\t\t *                                    <li>invocationContext - if set in the unsubscribeOptions.\n\t\t *                                    <li>errorCode - a number indicating the nature of the error.\n\t\t *                                    <li>errorMessage - text describing the error.\n\t\t *                                    </ol>\n\t\t * @param {number} unsubscribeOptions.timeout - which, if present, determines the number of seconds\n\t\t *                                    after which the onFailure callback is called. The presence of\n\t\t *                                    a timeout does not prevent the onSuccess callback from being\n\t\t *                                    called when the unsubscribe completes\n\t\t * @throws {InvalidState} if the client is not in connected state.\n\t\t */\n\t\t\tthis.unsubscribe = function (filter, unsubscribeOptions) {\n\t\t\t\tif (typeof filter !== \"string\" && filter.constructor !== Array)\n\t\t\t\t\tthrow new Error(\"Invalid argument:\"+filter);\n\t\t\t\tunsubscribeOptions = unsubscribeOptions || {} ;\n\t\t\t\tvalidate(unsubscribeOptions,  {invocationContext:\"object\",\n\t\t\t\t\tonSuccess:\"function\",\n\t\t\t\t\tonFailure:\"function\",\n\t\t\t\t\ttimeout:\"number\"\n\t\t\t\t});\n\t\t\t\tif (unsubscribeOptions.timeout && !unsubscribeOptions.onFailure)\n\t\t\t\t\tthrow new Error(\"unsubscribeOptions.timeout specified with no onFailure callback.\");\n\t\t\t\tclient.unsubscribe(filter, unsubscribeOptions);\n\t\t\t};\n\n\t\t\t/**\n\t\t * Send a message to the consumers of the destination in the Message.\n\t\t *\n\t\t * @name Paho.Client#send\n\t\t * @function\n\t\t * @param {string|Paho.Message} topic - <b>mandatory</b> The name of the destination to which the message is to be sent.\n\t\t * \t\t\t\t\t   - If it is the only parameter, used as Paho.Message object.\n\t\t * @param {String|ArrayBuffer} payload - The message data to be sent.\n\t\t * @param {number} qos The Quality of Service used to deliver the message.\n\t\t * \t\t<dl>\n\t\t * \t\t\t<dt>0 Best effort (default).\n\t\t *     \t\t\t<dt>1 At least once.\n\t\t *     \t\t\t<dt>2 Exactly once.\n\t\t * \t\t</dl>\n\t\t * @param {Boolean} retained If true, the message is to be retained by the server and delivered\n\t\t *                     to both current and future subscriptions.\n\t\t *                     If false the server only delivers the message to current subscribers, this is the default for new Messages.\n\t\t *                     A received message has the retained boolean set to true if the message was published\n\t\t *                     with the retained boolean set to true\n\t\t *                     and the subscrption was made after the message has been published.\n\t\t * @throws {InvalidState} if the client is not connected.\n\t\t */\n\t\t\tthis.send = function (topic,payload,qos,retained) {\n\t\t\t\tvar message ;\n\n\t\t\t\tif(arguments.length === 0){\n\t\t\t\t\tthrow new Error(\"Invalid argument.\"+\"length\");\n\n\t\t\t\t}else if(arguments.length == 1) {\n\n\t\t\t\t\tif (!(topic instanceof Message) && (typeof topic !== \"string\"))\n\t\t\t\t\t\tthrow new Error(\"Invalid argument:\"+ typeof topic);\n\n\t\t\t\t\tmessage = topic;\n\t\t\t\t\tif (typeof message.destinationName === \"undefined\")\n\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT,[message.destinationName,\"Message.destinationName\"]));\n\t\t\t\t\tclient.send(message);\n\n\t\t\t\t}else {\n\t\t\t\t//parameter checking in Message object\n\t\t\t\t\tmessage = new Message(payload);\n\t\t\t\t\tmessage.destinationName = topic;\n\t\t\t\t\tif(arguments.length >= 3)\n\t\t\t\t\t\tmessage.qos = qos;\n\t\t\t\t\tif(arguments.length >= 4)\n\t\t\t\t\t\tmessage.retained = retained;\n\t\t\t\t\tclient.send(message);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t\t * Publish a message to the consumers of the destination in the Message.\n\t\t * Synonym for Paho.Mqtt.Client#send\n\t\t *\n\t\t * @name Paho.Client#publish\n\t\t * @function\n\t\t * @param {string|Paho.Message} topic - <b>mandatory</b> The name of the topic to which the message is to be published.\n\t\t * \t\t\t\t\t   - If it is the only parameter, used as Paho.Message object.\n\t\t * @param {String|ArrayBuffer} payload - The message data to be published.\n\t\t * @param {number} qos The Quality of Service used to deliver the message.\n\t\t * \t\t<dl>\n\t\t * \t\t\t<dt>0 Best effort (default).\n\t\t *     \t\t\t<dt>1 At least once.\n\t\t *     \t\t\t<dt>2 Exactly once.\n\t\t * \t\t</dl>\n\t\t * @param {Boolean} retained If true, the message is to be retained by the server and delivered\n\t\t *                     to both current and future subscriptions.\n\t\t *                     If false the server only delivers the message to current subscribers, this is the default for new Messages.\n\t\t *                     A received message has the retained boolean set to true if the message was published\n\t\t *                     with the retained boolean set to true\n\t\t *                     and the subscrption was made after the message has been published.\n\t\t * @throws {InvalidState} if the client is not connected.\n\t\t */\n\t\t\tthis.publish = function(topic,payload,qos,retained) {\n\t\t\t\tvar message ;\n\n\t\t\t\tif(arguments.length === 0){\n\t\t\t\t\tthrow new Error(\"Invalid argument.\"+\"length\");\n\n\t\t\t\t}else if(arguments.length == 1) {\n\n\t\t\t\t\tif (!(topic instanceof Message) && (typeof topic !== \"string\"))\n\t\t\t\t\t\tthrow new Error(\"Invalid argument:\"+ typeof topic);\n\n\t\t\t\t\tmessage = topic;\n\t\t\t\t\tif (typeof message.destinationName === \"undefined\")\n\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT,[message.destinationName,\"Message.destinationName\"]));\n\t\t\t\t\tclient.send(message);\n\n\t\t\t\t}else {\n\t\t\t\t\t//parameter checking in Message object\n\t\t\t\t\tmessage = new Message(payload);\n\t\t\t\t\tmessage.destinationName = topic;\n\t\t\t\t\tif(arguments.length >= 3)\n\t\t\t\t\t\tmessage.qos = qos;\n\t\t\t\t\tif(arguments.length >= 4)\n\t\t\t\t\t\tmessage.retained = retained;\n\t\t\t\t\tclient.send(message);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t/**\n\t\t * Normal disconnect of this Messaging client from its server.\n\t\t *\n\t\t * @name Paho.Client#disconnect\n\t\t * @function\n\t\t * @throws {InvalidState} if the client is already disconnected.\n\t\t */\n\t\t\tthis.disconnect = function () {\n\t\t\t\tclient.disconnect();\n\t\t\t};\n\n\t\t\t/**\n\t\t * Get the contents of the trace log.\n\t\t *\n\t\t * @name Paho.Client#getTraceLog\n\t\t * @function\n\t\t * @return {Object[]} tracebuffer containing the time ordered trace records.\n\t\t */\n\t\t\tthis.getTraceLog = function () {\n\t\t\t\treturn client.getTraceLog();\n\t\t\t};\n\n\t\t\t/**\n\t\t * Start tracing.\n\t\t *\n\t\t * @name Paho.Client#startTrace\n\t\t * @function\n\t\t */\n\t\t\tthis.startTrace = function () {\n\t\t\t\tclient.startTrace();\n\t\t\t};\n\n\t\t\t/**\n\t\t * Stop tracing.\n\t\t *\n\t\t * @name Paho.Client#stopTrace\n\t\t * @function\n\t\t */\n\t\t\tthis.stopTrace = function () {\n\t\t\t\tclient.stopTrace();\n\t\t\t};\n\n\t\t\tthis.isConnected = function() {\n\t\t\t\treturn client.connected;\n\t\t\t};\n\t\t};\n\n\t\t/**\n\t * An application message, sent or received.\n\t * <p>\n\t * All attributes may be null, which implies the default values.\n\t *\n\t * @name Paho.Message\n\t * @constructor\n\t * @param {String|ArrayBuffer} payload The message data to be sent.\n\t * <p>\n\t * @property {string} payloadString <i>read only</i> The payload as a string if the payload consists of valid UTF-8 characters.\n\t * @property {ArrayBuffer} payloadBytes <i>read only</i> The payload as an ArrayBuffer.\n\t * <p>\n\t * @property {string} destinationName <b>mandatory</b> The name of the destination to which the message is to be sent\n\t *                    (for messages about to be sent) or the name of the destination from which the message has been received.\n\t *                    (for messages received by the onMessage function).\n\t * <p>\n\t * @property {number} qos The Quality of Service used to deliver the message.\n\t * <dl>\n\t *     <dt>0 Best effort (default).\n\t *     <dt>1 At least once.\n\t *     <dt>2 Exactly once.\n\t * </dl>\n\t * <p>\n\t * @property {Boolean} retained If true, the message is to be retained by the server and delivered\n\t *                     to both current and future subscriptions.\n\t *                     If false the server only delivers the message to current subscribers, this is the default for new Messages.\n\t *                     A received message has the retained boolean set to true if the message was published\n\t *                     with the retained boolean set to true\n\t *                     and the subscrption was made after the message has been published.\n\t * <p>\n\t * @property {Boolean} duplicate <i>read only</i> If true, this message might be a duplicate of one which has already been received.\n\t *                     This is only set on messages received from the server.\n\t *\n\t */\n\t\tvar Message = function (newPayload) {\n\t\t\tvar payload;\n\t\t\tif (   typeof newPayload === \"string\" ||\n\t\tnewPayload instanceof ArrayBuffer ||\n\t\t(ArrayBuffer.isView(newPayload) && !(newPayload instanceof DataView))\n\t\t\t) {\n\t\t\t\tpayload = newPayload;\n\t\t\t} else {\n\t\t\t\tthrow (format(ERROR.INVALID_ARGUMENT, [newPayload, \"newPayload\"]));\n\t\t\t}\n\n\t\t\tvar destinationName;\n\t\t\tvar qos = 0;\n\t\t\tvar retained = false;\n\t\t\tvar duplicate = false;\n\n\t\t\tObject.defineProperties(this,{\n\t\t\t\t\"payloadString\":{\n\t\t\t\t\tenumerable : true,\n\t\t\t\t\tget : function () {\n\t\t\t\t\t\tif (typeof payload === \"string\")\n\t\t\t\t\t\t\treturn payload;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\treturn parseUTF8(payload, 0, payload.length);\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"payloadBytes\":{\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function() {\n\t\t\t\t\t\tif (typeof payload === \"string\") {\n\t\t\t\t\t\t\tvar buffer = new ArrayBuffer(UTF8Length(payload));\n\t\t\t\t\t\t\tvar byteStream = new Uint8Array(buffer);\n\t\t\t\t\t\t\tstringToUTF8(payload, byteStream, 0);\n\n\t\t\t\t\t\t\treturn byteStream;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn payload;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"destinationName\":{\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function() { return destinationName; },\n\t\t\t\t\tset: function(newDestinationName) {\n\t\t\t\t\t\tif (typeof newDestinationName === \"string\")\n\t\t\t\t\t\t\tdestinationName = newDestinationName;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [newDestinationName, \"newDestinationName\"]));\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"qos\":{\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function() { return qos; },\n\t\t\t\t\tset: function(newQos) {\n\t\t\t\t\t\tif (newQos === 0 || newQos === 1 || newQos === 2 )\n\t\t\t\t\t\t\tqos = newQos;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthrow new Error(\"Invalid argument:\"+newQos);\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"retained\":{\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function() { return retained; },\n\t\t\t\t\tset: function(newRetained) {\n\t\t\t\t\t\tif (typeof newRetained === \"boolean\")\n\t\t\t\t\t\t\tretained = newRetained;\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthrow new Error(format(ERROR.INVALID_ARGUMENT, [newRetained, \"newRetained\"]));\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"topic\":{\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function() { return destinationName; },\n\t\t\t\t\tset: function(newTopic) {destinationName=newTopic;}\n\t\t\t\t},\n\t\t\t\t\"duplicate\":{\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function() { return duplicate; },\n\t\t\t\t\tset: function(newDuplicate) {duplicate=newDuplicate;}\n\t\t\t\t}\n\t\t\t});\n\t\t};\n\n\t\t// Module contents.\n\t\treturn {\n\t\t\tClient: Client,\n\t\t\tMessage: Message\n\t\t};\n\t// eslint-disable-next-line no-nested-ternary\n\t})(typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {});\n\treturn PahoMQTT;\n});\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\n// **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\nvar _clockseq;\n\n// Previous uuid creation time\nvar _lastMSecs = 0;\nvar _lastNSecs = 0;\n\n// See https://github.com/uuidjs/uuid for API details\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || [];\n\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;\n\n  // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n  if (node == null || clockseq == null) {\n    var seedBytes = rng();\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [\n        seedBytes[0] | 0x01,\n        seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]\n      ];\n    }\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  }\n\n  // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n  var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();\n\n  // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;\n\n  // Time since last uuid creation (in msecs)\n  var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;\n\n  // Per 4.2.1.2, Bump clockseq on clock regression\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  }\n\n  // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  }\n\n  // Per 4.2.1.2 Throw error if too many uuids are requested\n  if (nsecs >= 10000) {\n    throw new Error('uuid.v1(): Can\\'t create more than 10M uuids/sec');\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq;\n\n  // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n  msecs += 12219292800000;\n\n  // `time_low`\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff;\n\n  // `time_mid`\n  var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff;\n\n  // `time_high_and_version`\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n  b[i++] = tmh >>> 16 & 0xff;\n\n  // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n  b[i++] = clockseq >>> 8 | 0x80;\n\n  // `clock_seq_low`\n  b[i++] = clockseq & 0xff;\n\n  // `node`\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf ? buf : bytesToUuid(b);\n}\n\nmodule.exports = v1;\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\nfunction v4(options, buf, offset) {\n  var i = buf && offset || 0;\n\n  if (typeof(options) == 'string') {\n    buf = options === 'binary' ? new Array(16) : null;\n    options = null;\n  }\n  options = options || {};\n\n  var rnds = options.random || (options.rng || rng)();\n\n  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n  rnds[6] = (rnds[6] & 0x0f) | 0x40;\n  rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n  // Copy bytes to buffer, if provided\n  if (buf) {\n    for (var ii = 0; ii < 16; ++ii) {\n      buf[i + ii] = rnds[ii];\n    }\n  }\n\n  return buf || bytesToUuid(rnds);\n}\n\nmodule.exports = v4;\n","import { fromUtf8 as jsFromUtf8, toUtf8 as jsToUtf8 } from \"./pureJs\";\nimport { fromUtf8 as textEncoderFromUtf8, toUtf8 as textEncoderToUtf8 } from \"./whatwgEncodingApi\";\n\ndeclare const TextDecoder: Function | undefined;\ndeclare const TextEncoder: Function | undefined;\n\nexport const fromUtf8 = (input: string): Uint8Array =>\n  typeof TextEncoder === \"function\" ? textEncoderFromUtf8(input) : jsFromUtf8(input);\n\nexport const toUtf8 = (input: Uint8Array): string =>\n  typeof TextDecoder === \"function\" ? textEncoderToUtf8(input) : jsToUtf8(input);\n","/**\n * A declaration of the global TextEncoder and TextDecoder constructors.\n *\n * @see https://encoding.spec.whatwg.org/\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nnamespace Encoding {\n  interface TextDecoderOptions {\n    fatal?: boolean;\n    ignoreBOM?: boolean;\n  }\n\n  interface TextDecodeOptions {\n    stream?: boolean;\n  }\n\n  interface TextDecoder {\n    readonly encoding: string;\n    readonly fatal: boolean;\n    readonly ignoreBOM: boolean;\n    decode(input?: ArrayBuffer | ArrayBufferView, options?: TextDecodeOptions): string;\n  }\n\n  export interface TextDecoderConstructor {\n    new (label?: string, options?: TextDecoderOptions): TextDecoder;\n  }\n\n  interface TextEncoder {\n    readonly encoding: \"utf-8\";\n    encode(input?: string): Uint8Array;\n  }\n\n  export interface TextEncoderConstructor {\n    new (): TextEncoder;\n  }\n}\n\ndeclare const TextDecoder: Encoding.TextDecoderConstructor;\n\ndeclare const TextEncoder: Encoding.TextEncoderConstructor;\n\nexport function fromUtf8(input: string): Uint8Array {\n  return new TextEncoder().encode(input);\n}\n\nexport function toUtf8(input: Uint8Array): string {\n  return new TextDecoder(\"utf-8\").decode(input);\n}\n","/**\n * Converts a JS string from its native UCS-2/UTF-16 representation into a\n * Uint8Array of the bytes used to represent the equivalent characters in UTF-8.\n *\n * Cribbed from the `goog.crypt.stringToUtf8ByteArray` function in the Google\n * Closure library, though updated to use typed arrays.\n */\nexport const fromUtf8 = (input: string): Uint8Array => {\n  const bytes: Array<number> = [];\n  for (let i = 0, len = input.length; i < len; i++) {\n    const value = input.charCodeAt(i);\n    if (value < 0x80) {\n      bytes.push(value);\n    } else if (value < 0x800) {\n      bytes.push((value >> 6) | 0b11000000, (value & 0b111111) | 0b10000000);\n    } else if (i + 1 < input.length && (value & 0xfc00) === 0xd800 && (input.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {\n      const surrogatePair = 0x10000 + ((value & 0b1111111111) << 10) + (input.charCodeAt(++i) & 0b1111111111);\n      bytes.push(\n        (surrogatePair >> 18) | 0b11110000,\n        ((surrogatePair >> 12) & 0b111111) | 0b10000000,\n        ((surrogatePair >> 6) & 0b111111) | 0b10000000,\n        (surrogatePair & 0b111111) | 0b10000000\n      );\n    } else {\n      bytes.push((value >> 12) | 0b11100000, ((value >> 6) & 0b111111) | 0b10000000, (value & 0b111111) | 0b10000000);\n    }\n  }\n\n  return Uint8Array.from(bytes);\n};\n\n/**\n * Converts a typed array of bytes containing UTF-8 data into a native JS\n * string.\n *\n * Partly cribbed from the `goog.crypt.utf8ByteArrayToString` function in the\n * Google Closure library, though updated to use typed arrays and to better\n * handle astral plane code points.\n */\nexport const toUtf8 = (input: Uint8Array): string => {\n  let decoded = \"\";\n  for (let i = 0, len = input.length; i < len; i++) {\n    const byte = input[i];\n    if (byte < 0x80) {\n      decoded += String.fromCharCode(byte);\n    } else if (0b11000000 <= byte && byte < 0b11100000) {\n      const nextByte = input[++i];\n      decoded += String.fromCharCode(((byte & 0b11111) << 6) | (nextByte & 0b111111));\n    } else if (0b11110000 <= byte && byte < 0b101101101) {\n      const surrogatePair = [byte, input[++i], input[++i], input[++i]];\n      const encoded = \"%\" + surrogatePair.map((byteValue) => byteValue.toString(16)).join(\"%\");\n      decoded += decodeURIComponent(encoded);\n    } else {\n      decoded += String.fromCharCode(\n        ((byte & 0b1111) << 12) | ((input[++i] & 0b111111) << 6) | (input[++i] & 0b111111)\n      );\n    }\n  }\n\n  return decoded;\n};\n",null],"sourceRoot":""}