{"version":3,"sources":["?","../client/js/util.js","../client/js/export.js","../client/js/error/error.js","../client/js/version.js","../client/js/features.js","../client/js/promise.js","../client/js/blob-proxy.js","../client/js/button.js","../client/js/upload-data.js","../client/js/uploader.basic.api.js","../client/js/uploader.basic.js","../client/js/ajax.requester.js","../client/js/upload-handler/upload.handler.js","../client/js/upload-handler/upload.handler.controller.js","../client/js/window.receive.message.js","../client/js/upload-handler/form.upload.handler.js","../client/js/upload-handler/xhr.upload.handler.js","../client/js/deletefile.ajax.requester.js","../client/js/image-support/megapix-image.js","../client/js/image-support/image.js","../client/js/image-support/exif.js","../client/js/identify.js","../client/js/image-support/validation.image.js","../client/js/session.js","../client/js/session.ajax.requester.js","../client/js/image-support/scaler.js","../client/js/third-party/ExifRestorer.js","../client/js/total-progress.js","../client/js/paste.js","../client/js/form-support.js","../client/js/traditional/traditional.form.upload.handler.js","../client/js/traditional/traditional.xhr.upload.handler.js","../client/js/traditional/all-chunks-done.ajax.requester.js"],"names":["global","qq","element","hide","style","display","this","attach","type","fn","addEventListener","attachEvent","detach","removeEventListener","detachEvent","contains","descendant","compareDocumentPosition","insertBefore","elementB","parentNode","remove","removeChild","css","styles","Error","opacity","filter","Math","round","extend","hasClass","name","considerParent","re","RegExp","test","className","addClass","removeClass","replace","getByClass","first","candidates","result","querySelector","querySelectorAll","getElementsByTagName","each","idx","val","push","getFirstByClass","children","child","firstChild","nodeType","nextSibling","setText","text","innerText","textContent","clearText","hasAttribute","attrName","attrVal","exec","getAttribute","undefined","canvasToBlob","canvas","mime","quality","dataUriToBlob","toDataURL","dataUri","arrayBuffer","byteString","createBlob","data","BlobBuilder","window","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","blobBuilder","append","getBlob","Blob","intArray","mimeString","split","indexOf","atob","decodeURI","ArrayBuffer","length","Uint8Array","character","charCodeAt","log","message","level","console","isObject","variable","Object","prototype","toString","call","isFunction","isArray","value","buffer","constructor","isItemList","maybeItemList","isNodeList","maybeNodeList","item","namedItem","isString","maybeString","trimStr","string","String","trim","format","str","args","Array","slice","arguments","newStr","nextIdxToReplace","strBefore","substring","strAfter","isFile","maybeFile","File","isFileList","maybeFileList","FileList","isFileOrInput","maybeFileOrInput","isInput","maybeInput","notFile","evaluateType","normalizedType","toLowerCase","HTMLInputElement","tagName","isBlob","maybeBlob","isXhrUploadSupported","input","document","createElement","multiple","FormData","createXhrInstance","upload","XMLHttpRequest","ActiveXObject","error","isFolderDropSupported","dataTransfer","items","webkitGetAsEntry","isFileChunkingSupported","androidStock","webkitSlice","mozSlice","sliceBlob","fileOrBlob","start","end","slicer","arrayBufferToHex","bytesAsHex","bytes","byt","byteAsHexStr","readBlobToHex","blob","startOffset","initialBlob","fileReader","FileReader","promise","Promise","onload","success","onerror","failure","readAsArrayBuffer","second","extendNested","prop","override","target","sourceFn","super_","source","srcPropName","srcPropVal","arr","elt","from","len","hasOwnProperty","getUniqueId","c","r","random","v","ie","navigator","userAgent","ie7","ie8","ie10","ie11","edge","safari","vendor","chrome","opera","firefox","windows","platform","android","ios6","ios","ios7","ios8","ios800","iosChrome","iosSafari","iosSafariWebView","preventDefault","e","returnValue","toElement","div","html","innerHTML","iterableItem","callback","keyOrIndex","retVal","Storage","key","getItem","charAt","bind","oldFunc","context","newArgs","concat","apply","obj2url","obj","temp","prefixDone","uristrings","prefix","add","nextObj","i","nextTemp","encodeURIComponent","join","obj2FormData","formData","arrayKeyName","obj2Inputs","form","setAttribute","appendChild","parseJson","json","JSON","parse","eval","getExtension","filename","extIdx","lastIndexOf","substr","getFilename","blobOrFileInput","fileName","DisposeSupport","disposers","dispose","disposer","shift","addDisposer","disposeFunction","define","amd","module","exports","version","supportedFeatures","supportsUploading","supportsUploadingBlobs","supportsFileDrop","supportsAjaxFileUploading","supportsFolderDrop","supportsChunking","supportsResume","supportsUploadViaPaste","supportsUploadCors","supportsDeleteFileXdr","supportsDeleteFileCorsXhr","supportsDeleteFileCors","supportsFolderSelection","supportsImagePreviews","supportsUploadProgress","testSupportsFileInputElement","supported","tempInput","disabled","ex","isChrome21OrHigher","match","isChrome14OrHigher","isCrossOriginXhrSupported","xhr","withCredentials","isXdrSupported","XDomainRequest","isCrossOriginAjaxSupported","isFolderSelectionSupported","webkitdirectory","isLocalStorageSupported","localStorage","setItem","isDragAndDropSupported","span","postMessage","ajaxUploading","blobUploading","canDetermineSize","chunking","deleteFileCors","deleteFileCorsXdr","deleteFileCorsXhr","dialogElement","HTMLDialogElement","fileDrop","folderDrop","folderSelection","imagePreviews","imageValidation","itemSizeValidation","pause","progressBar","resume","scaling","tiffPreviews","unlimitedScaledImageSize","uploading","uploadCors","uploadCustomHeaders","uploadNonMultipart","uploadViaPaste","isGenericPromise","maybePromise","then","successArgs","failureArgs","successCallbacks","failureCallbacks","doneCallbacks","state","onSuccess","onFailure","done","BlobProxy","referenceBlob","onCreate","create","UploadButton","o","self","disposeSupport","options","acceptFiles","focusClass","folders","hoverClass","ios8BrowserCrashWorkaround","onChange","title","buttonId","createInput","BUTTON_ID_ATTR_NAME","setMultiple","position","right","top","fontFamily","fontSize","margin","padding","cursor","height","overflow","direction","getInput","getButtonId","isMultiple","optInput","removeAttribute","setAcceptFiles","reset","UploadData","uploaderProxy","byUuid","byStatus","byProxyGroupId","byBatchId","getDataByIds","idOrIds","entries","id","getDataByUuids","uuids","uuid","getDataByStatus","status","statusResults","statuses","index","statusEnum","statusResultIndexes","dataIndex","addFile","spec","SUBMITTING","originalName","size","batchId","proxyGroupId","onStatusChange","retrieve","optionalFilter","setStatus","newStatus","oldStatus","byStatusOldStatusIndex","splice","uuidChanged","newUuid","oldUuid","updateName","newName","updateSize","newSize","setParentId","targetId","parentId","getIdsInProxyGroup","getIdsInBatch","SUBMITTED","REJECTED","QUEUED","CANCELED","PAUSED","UPLOADING","UPLOAD_RETRYING","UPLOAD_SUCCESSFUL","UPLOAD_FAILED","DELETE_FAILED","DELETING","DELETED","basePublicApi","addBlobs","blobDataOrArray","params","endpoint","addFiles","addInitialFiles","cannedFileList","cannedFile","_addCannedFile","_maybeHandleIos8SafariWorkaround","_storedIds","_currentBatchId","processBlob","_handleNewFile","_options","blobs","defaultName","verifiedFiles","processBlobData","blobData","processCanvas","processCanvasData","canvasData","normalizedQuality","processFileOrInput","fileOrInput","files","file","normalizeData","fileContainer","_prepareItemsForUpload","cancel","_handler","cancelAll","storedIdsCopy","storedFileId","clearStoredFiles","continueUpload","uploadData","_uploadData","enabled","getName","_uploadFile","deleteFile","_onSubmitDelete","doesExist","fileOrBlobId","isValid","drawThumbnail","fileId","imgOrCanvas","maxSize","fromServer","customResizeFunction","promiseToReturn","fileOrUrl","_imageGenerator","_thumbnailUrls","scale","getFile","container","generate","modifiedContainer","reason","getButton","_getButton","_buttonIdsForFileIds","getEndpoint","_endpointStore","get","getInProgress","getParentId","uploadDataEntry","getUploads","getResumableFilesData","getSize","getNetUploads","_netUploaded","getRemainingAllowedItems","allowedItems","_currentItemLimit","_netUploadedOrQueued","getUuid","debug","pauseUpload","removeFileRef","expunge","_autoRetries","_retryTimeouts","_preventRetries","_buttons","button","_paramsStore","_pasteHandler","session","refreshOnReset","_refreshSessionData","_succeededSinceLastAllComplete","_failedSinceLastAllComplete","_totalProgress","retry","_manualRetry","scaleImage","specs","Scaler","setCustomHeaders","headers","_customHeadersStore","set","setDeleteFileCustomHeaders","_deleteFileCustomHeadersStore","setDeleteFileEndpoint","_deleteFileEndpointStore","setDeleteFileParams","_deleteFileParamsStore","setEndpoint","setForm","elementOrId","_updateFormSupportAndParams","setItemLimit","newItemLimit","setName","setParams","setUuid","fileRecord","_onDeleteComplete","errorMessage","uploadStoredFiles","_itemError","_uploadStoredFiles","basePrivateApi","sessionData","deleteFileEndpoint","deleteFileParams","thumbnailUrl","_annotateWithButtonId","associatedInput","qqButtonId","_getButtonId","_batchError","callbacks","onError","_createDeleteHandler","DeleteFileAjaxRequester","method","toUpperCase","maxConnections","uuidParamName","request","uuidName","customHeaders","paramsStore","endpointStore","cors","onDelete","_onDelete","onDeleteComplete","xhrOrXdr","isError","_createPasteHandler","PasteSupport","targetElement","paste","pasteReceived","_handleCheckedCallback","onPasteReceived","_handlePasteSuccess","identifier","_createStore","initialValue","_readOnlyValues_","store","catchall","perIdReadOnlyValues","readOnlyValues","copy","orig","getReadOnlyValues","includeReadOnlyValues","existing","values","addReadOnly","_createUploadDataTracker","_onUploadStatusChange","_maybeAllComplete","setTimeout","_createUploadButton","accept","validation","allowedExtensions","allowMultiple","workarounds","iosEmptyVideos","_isAllowedExtension","classes","buttonFocus","buttonHover","ios8BrowserCrash","inputName","_onInputChange","fileInputTitle","_disposeSupport","_createUploadHandler","additionalOptions","namespace","lastOnProgress","preventRetryParam","preventRetryResponseProperty","onProgress","loaded","total","_onProgress","onComplete","_onComplete","onCancel","cancelFinalizationEffort","_onCancel","onUploadPrep","_onUploadPrep","onUpload","_onUpload","onUploadChunk","chunkData","_onUploadChunk","onUploadChunkSuccess","onResume","onAutoRetry","responseJSON","_onAutoRetry","onUuidChanged","setSize","_setSize","getDataByUuid","isQueued","UploadHandlerController","_fileOrBlobRejected","_formatSize","sizeSymbols","max","toFixed","_generateExtraButtonSpecs","_extraButtonSpecs","extraButtons","extraButtonOptionEntry","extraButtonSpec","_initExtraButton","extraButtonsSpec","_defaultButtonId","buttonOrFileInputOrFile","inputs","fileInput","fileBlobOrInput","_getNotFinished","_getValidationBase","_getValidationDescriptor","fileWrapper","_getValidationDescriptors","fileWrappers","fileDescriptors","_handleCameraAccess","camera","acceptIosCamera","optionRoot","details","callbackRetVal","successParam","newFileWrapperList","actualFile","handler","_customNewFileHandler","_handleNewFileGeneric","addFileToHandler","_trackButton","fileList","extSuppliedName","extension","_handleDeleteSuccess","_handleDeleteFailed","_initFormSupportAndParams","_formSupport","FormSupport","attachedToForm","getFormInputsAsObject","autoUpload","newAutoUpload","newEndpoint","_isDeletePossible","expected","allowXdr","allowed","valid","allowedExt","extRegex","code","maybeNameOrNames","messages","names","validationBase","extensionsForMessage","placeholderMatch","replacement","allowedExtension","formatFileName","sizeLimit","minSizeLimit","placeholder","_onBeforeManualRetry","notFinished","_onAllComplete","ios8SafariUploads","alert","unsupportedBrowserIos8Safari","_maybeParseAndSendUploadError","response","errorReason","defaultResponseError","_maybeProcessNextItemAfterOnValidateCallback","validItem","stopOnFirstInvalidFile","validationDescriptor","onValidate","_onValidateCallbackSuccess","_onValidateCallbackFailure","successful","failed","onAllComplete","_shouldAutoRetry","retryWaitPeriod","autoAttemptDelay","_onBeforeAutoRetry","itemLimit","onManualRetry","clearTimeout","storedItemIndex","fileIndex","onIndividualProgress","_onSubmit","_onSubmitCallbackSuccess","_onSubmitted","onSubmitted","_storeForLater","onSuccessCallback","additionalMandatedParams","adjustedOnSuccessCallback","onSubmitDelete","_deleteHandler","sendDelete","_onTotalProgress","onTotalProgress","_onValidateBatchCallbackFailure","_onValidateBatchCallbackSuccess","validationDescriptors","proposedNetFilesUploadedOrQueued","tooManyItemsError","nextIndex","_validateFileOrBlobData","_upload","onValidateBatch","_preventLeaveInProgress","event","onLeave","Session","_session","addFileRecord","refresh","_sessionRequestComplete","onSessionRequestComplete","onNewSize","enableAuto","maxAutoAttempts","formElementOrId","onSubmit","idToUpload","stillSubmitting","validityChecker","allowEmpty","ImageValidation","validate","image","errorCode","_wrapCallbacks","safeCallback","errorMsg","exception","callbackName","callbackFunc","FineUploaderBasic","disableCancelForFormUploads","filenameParam","forceMultipart","paramsInBody","totalFileSizeName","maxHeight","maxWidth","minHeight","minWidth","maybeXhr","maybeXhrOrXdr","attemptNumber","fileOrBlobData","typeError","sizeError","minSizeError","emptyError","noFilesError","maxHeightImageError","maxWidthImageError","minHeightImageError","minWidthImageError","retryFailTooManyItems","concurrent","mandatory","paramNames","partIndex","partByteOffset","chunkSize","totalFileSize","totalParts","partSize","recordsExpireIn","resuming","fileOrBlobName","sendCredentials","interceptSubmit","customResizer","sendOriginal","orient","defaultType","defaultQuality","failureText","includeExif","sizes","ImageGenerator","_scaler","handleNewFile","TotalProgress","entry","AjaxRequester","shouldParamsBeInQueryString","queue","requestData","acceptHeader","validMethods","contentType","mandatedParams","allowXRequestedWithAndCacheControl","successfulResponseCodes","DELETE","PATCH","POST","PUT","GET","onSend","isSimpleMethod","containsNonSimpleHeaders","containsNonSimple","header","isXdr","getCorsAjaxTransport","ontimeout","onprogress","getXhrOrXdr","suppliedXhr","dequeue","nextId","sendRequest","xdrError","isResponseSuccessful","getParams","onDemandParams","additionalParams","optXhr","payload","url","createUrl","additionalQueryParams","getXdrLoadHandler","getXdrErrorHandler","onreadystatechange","getXhrReadyStateChangeHandler","registerForUploadProgress","open","setHeaders","send","stringify","addToPath","readyState","lengthComputable","onDemandHeaders","additionalHeaders","allHeaders","setRequestHeader","responseCode","prepareToSend","initTransport","path","cacheBuster","withPath","appendToPath","withParams","withQueryParams","_additionalQueryParams_","withHeaders","withPayload","thePayload","withCacheBuster","qqtimestamp","Date","getTime","canceled","UploadHandler","proxy","fileState","fileItem","onCancelRetVal","getThirdPartyFileId","_getFileState","_setThirdPartyFileId","thirdPartyFileId","_wasCanceled","controller","chunkingPossible","concurrentChunkingPossible","preventRetryResponse","chunked","chunkIdx","_getChunkData","attemptingResume","chunkProgress","_getChunkDataForCallback","finalize","finalizeChunks","normaizedResponse","normalizeResponse","_maybeDeletePersistedChunkData","cleanup","handleFailure","clearCachedChunk","responseToReport","inProgressIdx","inProgress","remaining","unshift","ignoreFailure","keys","_getXhrs","ckid","ckXhr","abort","_cancelled","moveInProgressToRemaining","connectionManager","free","hasMoreParts","nextPart","nextIdx","_getTotalChunks","reevaluateChunking","sendNext","inProgressChunks","available","uploadChunk","inProgressChunkIdx","_maybePersistChunkedState","clearXhr","_open","_openChunks","_waiting","openChunkEntriesCount","openChunksCount","openChunkIndexes","dontAllowNext","allowNext","waitingIndex","connectionsIndex","getProxyOrBlob","getWaitingOrConnected","waitingOrConnected","chunks","parseInt","isUsingConnection","pop","openChunksEntry","simple","uploadFile","maybeNewUuid","_clearXhrs","getProxy","initHandler","handlerType","traditional","handlerModuleSubtype","_removeExpiredChunkingRecords","isDeferredEligibleForUpload","maybeDefer","generatedBlob","updateBlob","maybeSendDeferredFiles","errorResponse","idsInGroup","uploadedThisId","idInGroup","now","originalResponse","_shouldChunkThisFile","blobToUpload","cancelRetVal","isProxied","isResumable","WindowReceiveMessage","callbackWrapperDetachers","receiveMessage","onMessageCallbackWrapper","stopReceivingMessages","detacher","FormUploadHandler","formHandlerInstanceId","onloadCallbacks","detachLoadEvents","postMessageCallbackTimers","isCors","corsMessageReceiver","expungeFile","iframe","getElementById","_getIframeName","getFileIdForIframeName","iframeName","initIframeForUpload","body","registerPostMessageCallback","_parseJsonResponse","onloadCallback","_detachLoadEvent","_attachLoadEvent","responseDescriptor","contentDocument","_createIframe","_initFormForUpload","targetName","innerHtmlOrMessage","XhrUploadHandler","chunkFiles","resumeEnabled","xhrId","ajaxRequester","_getAjaxRequester","blobOrProxy","_initTempState","_maybePrepareForResume","cachedChunks","tempState","xhrs","ajaxRequesters","responseParser","lastChunkIdx","_getXhr","resumableFilesData","_iterateResumeRecords","notResumable","optInProgress","optRemaining","reverse","paused","totalChunks","parts","newBlob","chunkId","_createXhr","optChunkIdx","_registerXhr","chunkIndex","fileSize","startBytes","endBytes","part","count","startByte","endByte","_getLocalStorageId","formatVersion","_getMimeType","_getPersistableData","ceil","_markNotResumable","localStorageId","removeItem","persistedData","lastUpdated","_registerProgressHandler","progressCalculator","totalSuccessfullyLoadedForFile","loadedForRequest","totalForRequest","estActualChunkLoaded","totalLoadedForFile","chunkLoaded","optAjaxRequester","xhrsId","expirationDays","expirationDate","setDate","getDate","requester","getMandatedParams","_method","detectSubsampling","img","iw","naturalWidth","ih","naturalHeight","ctx","width","getContext","drawImage","getImageData","detectVerticalSquash","sy","ey","py","alpha","ratio","renderImageToDataURL","doSquash","renderImageToCanvas","maybeCalculateDownsampledDimensions","maxPixels","origHeight","origWidth","newHeight","sqrt","newWidth","modifiedDimensions","save","resize","renderImageToCanvasWithCustomResizer","imageHeight","imageWidth","orientation","targetHeight","targetWidth","transformCoordinate","d","tmpCanvas","vertSquashRatio","dw","dh","dy","tmpCtx","sx","dx","clearRect","restore","qqImageRendered","resizeInfo","sourceCanvas","sourceCanvasContext","targetCanvas","translate","rotate","PI","MegaPixImage","srcImage","errorCallback","Image","URL","createObjectURL","webkitURL","src","listeners","imageLoadListeners","render","imgWidth","imgHeight","opt","optionsKey","optionsValue","oldTargetSrc","onrender","isImg","el","isCanvas","isImgCorsSupported","crossOrigin","isCanvasSupported","determineMimeOfFileName","nameWithPath","pathSegments","isCrossOrigin","targetAnchor","targetProtocol","targetHostname","targetPort","href","protocol","port","hostname","location","registerImgLoadListeners","registerCanvasDrawImageListener","registerThumbnailRenderedListener","registered","draw","drawPreview","Identify","megapixErrorHandler","isPreviewable","dummyExif","exif","Exif","mpImg","Orientation","failureMsg","drawOnCanvasOrImgFromUrl","canvasOrImg","tempImg","tempImgRender","rendered","drawOnImgFromUrlWithCssScaling","drawFromUrl","fileBlobOrUrl","_testing","TAG_IDS","TAG_INFO","274","parseLittleEndian","hex","pow","seekToApp1","offset","theOffset","thePromise","segmentLength","getApp1Offset","isLittleEndian","app1Start","getDirEntryCount","littleEndian","getIfd","dirEntries","getDirEntries","ifdHex","getTagValues","TAG_VAL_OFFSET","tagsToFind","vals","idHex","tagsToFindIdx","tagValHex","tagValLength","parser","onParseFailure","app1Offset","dirEntryCount","tagValues","isIdentifiable","magicBytes","questionableBytes","identifiable","magicBytesEntries","magicBytesArrayEntry","previewable","isPreviewableSync","PREVIEWABLE_MIME_TYPES","fileMime","isRecognizedImage","image/jpeg","image/gif","image/png","image/bmp","image/tiff","hasNonZeroLimits","limits","atLeastOne","limit","getWidthHeight","sizeDetermination","getFailingLimit","dimensions","failingLimit","limitName","limitValue","limitMatcher","dimensionPropName","actualValue","validationEffort","isJsonResponseValid","handleFileItems","fileItems","someItemsIgnored","err","refreshEffort","refreshCompleteCallback","requesterOptions","SessionAjaxRequester","queryServer","responseText","includeOriginal","failedToScaleText","_getSortedSizes","getFileRecords","originalFileUuid","originalFileName","originalBlobOrBlobData","records","originalBlob","sizeRecord","outputType","_determineOutputType","requestedType","refType","_getName","_generateScaledImage","failedText","api","scaledIds","originalId","record","blobSize","scaledId","qqparentuuid","qqparentsize","param","scalingEffort","scalingOptions","scaler","referenceType","scaledVersionProperties","startOfExt","versionType","scaledName","scaledExt","nameAppendage","sort","a","b","sourceFile","imageGenerator","scaledImageDataUri","signalSuccess","_insertExifHeader","scaledImageDataUriWithExif","originalImage","reader","insertionEffort","originalImageDataUri","ExifRestorer","readAsDataURL","_dataUriToBlob","_createBlob","KEY_STR","encode64","output","chr1","chr2","chr3","enc1","enc2","enc3","enc4","isNaN","origFileBase64","resizedFileBase64","expectedBase64Header","rawImage","decode64","segments","slice2Segments","exifManipulation","exifArray","getExifArray","newImageArray","insertExif","aBuffer","seg","x","imageData","buf","separatePoint","mae","ato","array","rawImageArray","head","endPoint","base64test","perFileProgress","totalLoaded","totalSize","lastLoadedSent","lastTotalSent","callbackProxy","noRetryableFiles","retryable","none","failedId","updateTotalProgress","onNew","newLoaded","newTotal","oldLoaded","oldTotal","detachPasteHandler","isImage","registerPasteHandler","clipboardData","getAsFile","unregisterPasteHandler","startUpload","formEl","_form2Obj","determineNewEndpoint","validateForm","nativeSubmit","checkValidity","maybeUploadOnSubmit","submit","determineFormEl","notIrrelevantType","irrelevantTypes","radioOrCheckbox","ignoreValue","checked","selectValue","select","selected","elements","getIframeContentJson","doc","innerHtml","contentWindow","nodeValue","createForm","responseFromMessage","multipart","addChunkingSpecificParams","allChunksDoneRequester","AllChunksDoneAjaxRequester","createReadyStateChangedHandler","onUploadOrChunkComplete","getChunksCompleteParams","isErrorUploadResponse","parseResponse","sendChunksCompleteRequest","complete","setParamsAndGetEntityToSend","setUploadHeaders","extraHeaders","toSend","promises","endpointHandler"],"mappings":";CAAA,SAAUA;ICEV,IAAIC,KAAK,SAASC;QACd;QAEA;YACIC,MAAM;gBACFD,QAAQE,MAAMC,UAAU;gBACxB,OAAOC;;YAIXC,QAAQ,SAASC,MAAMC;gBACnB,IAAIP,QAAQQ,kBAAkB;oBAC1BR,QAAQQ,iBAAiBF,MAAMC,IAAI;uBAChC,IAAIP,QAAQS,aAAa;oBAC5BT,QAAQS,YAAY,OAAOH,MAAMC;;gBAErC,OAAO;oBACHR,GAAGC,SAASU,OAAOJ,MAAMC;;;YAIjCG,QAAQ,SAASJ,MAAMC;gBACnB,IAAIP,QAAQW,qBAAqB;oBAC7BX,QAAQW,oBAAoBL,MAAMC,IAAI;uBACnC,IAAIP,QAAQS,aAAa;oBAC5BT,QAAQY,YAAY,OAAON,MAAMC;;gBAErC,OAAOH;;YAGXS,UAAU,SAASC;gBAKf,KAAKA,YAAY;oBACb,OAAO;;gBAIX,IAAId,YAAYc,YAAY;oBACxB,OAAO;;gBAGX,IAAId,QAAQa,UAAU;oBAClB,OAAOb,QAAQa,SAASC;uBACrB;oBAEH,UAAUA,WAAWC,wBAAwBf,WAAW;;;YAOhEgB,cAAc,SAASC;gBACnBA,SAASC,WAAWF,aAAahB,SAASiB;gBAC1C,OAAOb;;YAGXe,QAAQ;gBACJnB,QAAQkB,WAAWE,YAAYpB;gBAC/B,OAAOI;;YAOXiB,KAAK,SAASC;gBAEV,IAAItB,QAAQE,SAAS,MAAM;oBACvB,MAAM,IAAIH,GAAGwB,MAAM;;gBAIvB,IAAID,OAAOE,WAAW,MAAM;oBACxB,WAAWxB,QAAQE,MAAMsB,YAAY,mBAAoBxB,QAAe,YAAM,aAAa;wBACvFsB,OAAOG,SAAS,mBAAmBC,KAAKC,MAAM,MAAML,OAAOE,WAAW;;;gBAG9EzB,GAAG6B,OAAO5B,QAAQE,OAAOoB;gBAEzB,OAAOlB;;YAGXyB,UAAU,SAASC,MAAMC;gBACrB,IAAIC,KAAK,IAAIC,OAAO,UAAUH,OAAO;gBACrC,OAAOE,GAAGE,KAAKlC,QAAQmC,iBAAiBJ,kBAAkBC,GAAGE,KAAKlC,QAAQkB,WAAWiB;;YAGzFC,UAAU,SAASN;gBACf,KAAK/B,GAAGC,SAAS6B,SAASC,OAAO;oBAC7B9B,QAAQmC,aAAa,MAAML;;gBAE/B,OAAO1B;;YAGXiC,aAAa,SAASP;gBAClB,IAAIE,KAAK,IAAIC,OAAO,UAAUH,OAAO;gBACrC9B,QAAQmC,YAAYnC,QAAQmC,UAAUG,QAAQN,IAAI,KAAKM,QAAQ,cAAc;gBAC7E,OAAOlC;;YAGXmC,YAAY,SAASJ,WAAWK;gBAC5B,IAAIC,YACAC;gBAEJ,IAAIF,SAASxC,QAAQ2C,eAAe;oBAChC,OAAO3C,QAAQ2C,cAAc,MAAMR;uBAElC,IAAInC,QAAQ4C,kBAAkB;oBAC/B,OAAO5C,QAAQ4C,iBAAiB,MAAMT;;gBAG1CM,aAAazC,QAAQ6C,qBAAqB;gBAE1C9C,GAAG+C,KAAKL,YAAY,SAASM,KAAKC;oBAC9B,IAAIjD,GAAGiD,KAAKnB,SAASM,YAAY;wBAC7BO,OAAOO,KAAKD;;;gBAGpB,OAAOR,QAAQE,OAAO,KAAKA;;YAG/BQ,iBAAiB,SAASf;gBACtB,OAAOpC,GAAGC,SAASuC,WAAWJ,WAAW;;YAG7CgB,UAAU;gBACN,IAAIA,eACAC,QAAQpD,QAAQqD;gBAEpB,OAAOD,OAAO;oBACV,IAAIA,MAAME,aAAa,GAAG;wBACtBH,SAASF,KAAKG;;oBAElBA,QAAQA,MAAMG;;gBAGlB,OAAOJ;;YAGXK,SAAS,SAASC;gBACdzD,QAAQ0D,YAAYD;gBACpBzD,QAAQ2D,cAAcF;gBACtB,OAAOrD;;YAGXwD,WAAW;gBACP,OAAO7D,GAAGC,SAASwD,QAAQ;;YAK/BK,cAAc,SAASC;gBACnB,IAAIC;gBAEJ,IAAI/D,QAAQ6D,cAAc;oBAEtB,KAAK7D,QAAQ6D,aAAaC,WAAW;wBACjC,OAAO;;oBAIX,OAAO,WAAaE,KAAKhE,QAAQiE,aAAaH,cAAc;uBAE3D;oBACDC,UAAU/D,QAAQ8D;oBAElB,IAAIC,YAAYG,WAAW;wBACvB,OAAO;;oBAIX,OAAO,WAAaF,KAAKD,YAAY;;;;;KAMpD;QACG;QAEAhE,GAAGoE,eAAe,SAASC,QAAQC,MAAMC;YACrC,OAAOvE,GAAGwE,cAAcH,OAAOI,UAAUH,MAAMC;;QAGnDvE,GAAGwE,gBAAgB,SAASE;YACxB,IAAIC,aAAaC,YACbC,aAAa,SAASC,MAAMR;gBACxB,IAAIS,cAAcC,OAAOD,eACjBC,OAAOC,qBACPD,OAAOE,kBACPF,OAAOG,eACXC,cAAcL,eAAe,IAAIA;gBAErC,IAAIK,aAAa;oBACbA,YAAYC,OAAOP;oBACnB,OAAOM,YAAYE,QAAQhB;uBAE1B;oBACD,OAAO,IAAIiB,OAAMT;wBAAQvE,MAAM+D;;;eAGvCkB,UAAUC;YAGd,IAAIf,QAAQgB,MAAM,KAAK,GAAGC,QAAQ,aAAa,GAAG;gBAC9Cf,aAAagB,KAAKlB,QAAQgB,MAAM,KAAK;mBAEpC;gBACDd,aAAaiB,UAAUnB,QAAQgB,MAAM,KAAK;;YAI9CD,aAAaf,QAAQgB,MAAM,KAAK,GAC3BA,MAAM,KAAK,GACXA,MAAM,KAAK;YAGhBf,cAAc,IAAImB,YAAYlB,WAAWmB;YACzCP,WAAW,IAAIQ,WAAWrB;YAC1B3E,GAAG+C,KAAK6B,YAAY,SAAS5B,KAAKiD;gBAC9BT,SAASxC,OAAOiD,UAAUC,WAAW;;YAGzC,OAAOrB,WAAWF,aAAac;;QAGnCzF,GAAGmG,MAAM,SAASC,SAASC;YACvB,IAAIrB,OAAOsB,SAAS;gBAChB,KAAKD,SAASA,UAAU,QAAQ;oBAC5BrB,OAAOsB,QAAQH,IAAIC;uBAGvB;oBACI,IAAIpB,OAAOsB,QAAQD,QAAQ;wBACvBrB,OAAOsB,QAAQD,OAAOD;2BAErB;wBACDpB,OAAOsB,QAAQH,IAAI,MAAME,QAAQ,OAAOD;;;;;QAMxDpG,GAAGuG,WAAW,SAASC;YACnB,OAAOA,aAAaA,SAASjD,YAAYkD,OAAOC,UAAUC,SAASC,KAAKJ,cAAc;;QAG1FxG,GAAG6G,aAAa,SAASL;YACrB,cAAc,aAAe;;QASjCxG,GAAG8G,UAAU,SAASC;YAClB,OAAON,OAAOC,UAAUC,SAASC,KAAKG,WAAW,oBAC5CA,SAAS/B,OAAOc,eAAeiB,MAAMC,UAAUD,MAAMC,OAAOC,gBAAgBnB;;QAIrF9F,GAAGkH,aAAa,SAASC;YACrB,OAAOV,OAAOC,UAAUC,SAASC,KAAKO,mBAAmB;;QAK7DnH,GAAGoH,aAAa,SAASC;YACrB,OAAOZ,OAAOC,UAAUC,SAASC,KAAKS,mBAAmB,uBAGpDA,cAAcC,QAAQD,cAAcE;;QAG7CvH,GAAGwH,WAAW,SAASC;YACnB,OAAOhB,OAAOC,UAAUC,SAASC,KAAKa,iBAAiB;;QAG3DzH,GAAG0H,UAAU,SAASC;YAClB,IAAIC,OAAOlB,UAAUmB,MAAM;gBACvB,OAAOF,OAAOE;;YAGlB,OAAOF,OAAOpF,QAAQ,cAAc;;QAOxCvC,GAAG8H,SAAS,SAASC;YAEjB,IAAIC,OAAQC,MAAMvB,UAAUwB,MAAMtB,KAAKuB,WAAW,IAC9CC,SAASL,KACTM,mBAAmBD,OAAOzC,QAAQ;YAEtC3F,GAAG+C,KAAKiF,MAAM,SAAShF,KAAKC;gBACxB,IAAIqF,YAAYF,OAAOG,UAAU,GAAGF,mBAChCG,WAAWJ,OAAOG,UAAUF,mBAAmB;gBAEnDD,SAASE,YAAYrF,MAAMuF;gBAC3BH,mBAAmBD,OAAOzC,QAAQ,MAAM0C,mBAAmBpF,IAAI8C;gBAG/D,IAAIsC,mBAAmB,GAAG;oBACtB,OAAO;;;YAIf,OAAOD;;QAGXpI,GAAGyI,SAAS,SAASC;YACjB,OAAO1D,OAAO2D,QAAQlC,OAAOC,UAAUC,SAASC,KAAK8B,eAAe;;QAGxE1I,GAAG4I,aAAa,SAASC;YACrB,OAAO7D,OAAO8D,YAAYrC,OAAOC,UAAUC,SAASC,KAAKiC,mBAAmB;;QAGhF7I,GAAG+I,gBAAgB,SAASC;YACxB,OAAOhJ,GAAGyI,OAAOO,qBAAqBhJ,GAAGiJ,QAAQD;;QAGrDhJ,GAAGiJ,UAAU,SAASC,YAAYC;YAC9B,IAAIC,eAAe,SAAS7I;gBACxB,IAAI8I,iBAAiB9I,KAAK+I;gBAE1B,IAAIH,SAAS;oBACT,OAAOE,mBAAmB;;gBAG9B,OAAOA,mBAAmB;;YAG9B,IAAIrE,OAAOuE,kBAAkB;gBACzB,IAAI9C,OAAOC,UAAUC,SAASC,KAAKsC,gBAAgB,6BAA6B;oBAC5E,IAAIA,WAAW3I,QAAQ6I,aAAaF,WAAW3I,OAAO;wBAClD,OAAO;;;;YAInB,IAAI2I,WAAWM,SAAS;gBACpB,IAAIN,WAAWM,QAAQF,kBAAkB,SAAS;oBAC9C,IAAIJ,WAAW3I,QAAQ6I,aAAaF,WAAW3I,OAAO;wBAClD,OAAO;;;;YAKnB,OAAO;;QAGXP,GAAGyJ,SAAS,SAASC;YACjB,IAAI1E,OAAOO,QAAQkB,OAAOC,UAAUC,SAASC,KAAK8C,eAAe,iBAAiB;gBAC9E,OAAO;;;QAIf1J,GAAG2J,uBAAuB;YACtB,IAAIC,QAAQC,SAASC,cAAc;YACnCF,MAAMrJ,OAAO;YAEb,OACIqJ,MAAMG,aAAa5F,oBACRwE,SAAS,sBACTqB,aAAa,sBACZhK,GAAGiK,oBAAqBC,WAAW;;QAIvDlK,GAAGiK,oBAAoB;YACnB,IAAIjF,OAAOmF,gBAAgB;gBACvB,OAAO,IAAIA;;YAGf;gBACI,OAAO,IAAIC,cAAc;cAE7B,OAAOC;gBACHrK,GAAGmG,IAAI,yCAAyC;gBAChD,OAAO;;;QAIfnG,GAAGsK,wBAAwB,SAASC;YAChC,OAAOA,aAAaC,SAChBD,aAAaC,MAAMzE,SAAS,KAC5BwE,aAAaC,MAAM,GAAGC;;QAG9BzK,GAAG0K,0BAA0B;YACzB,QAAQ1K,GAAG2K,kBACP3K,GAAG2J,2BACFhB,KAAKjC,UAAUwB,UAAU/D,aAAawE,KAAKjC,UAAUkE,gBAAgBzG,aAAawE,KAAKjC,UAAUmE,aAAa1G;;QAGvHnE,GAAG8K,YAAY,SAASC,YAAYC,OAAOC;YACvC,IAAIC,SAASH,WAAW7C,SAAS6C,WAAWF,YAAYE,WAAWH;YAEnE,OAAOM,OAAOtE,KAAKmE,YAAYC,OAAOC;;QAG1CjL,GAAGmL,mBAAmB,SAASnE;YAC3B,IAAIoE,aAAa,IACbC,QAAQ,IAAIrF,WAAWgB;YAE3BhH,GAAG+C,KAAKsI,OAAO,SAASrI,KAAKsI;gBACzB,IAAIC,eAAeD,IAAI3E,SAAS;gBAEhC,IAAI4E,aAAaxF,SAAS,GAAG;oBACzBwF,eAAe,MAAMA;;gBAGzBH,cAAcG;;YAGlB,OAAOH;;QAGXpL,GAAGwL,gBAAgB,SAASC,MAAMC,aAAa3F;YAC3C,IAAI4F,cAAc3L,GAAG8K,UAAUW,MAAMC,aAAaA,cAAc3F,SAC5D6F,aAAa,IAAIC,cACjBC,UAAU,IAAI9L,GAAG+L;YAErBH,WAAWI,SAAS;gBAChBF,QAAQG,QAAQjM,GAAGmL,iBAAiBS,WAAWjJ;;YAGnDiJ,WAAWM,UAAUJ,QAAQK;YAE7BP,WAAWQ,kBAAkBT;YAE7B,OAAOG;;QAGX9L,GAAG6B,SAAS,SAASY,OAAO4J,QAAQC;YAChCtM,GAAG+C,KAAKsJ,QAAQ,SAASE,MAAMtJ;gBAC3B,IAAIqJ,gBAAgBtM,GAAGuG,SAAStD,MAAM;oBAClC,IAAIR,MAAM8J,UAAUpI,WAAW;wBAC3B1B,MAAM8J;;oBAEVvM,GAAG6B,OAAOY,MAAM8J,OAAOtJ,KAAK;uBAE3B;oBACDR,MAAM8J,QAAQtJ;;;YAItB,OAAOR;;QAaXzC,GAAGwM,WAAW,SAASC,QAAQC;YAC3B,IAAIC,aACAC,SAASF,SAASC;YAEtB3M,GAAG+C,KAAK6J,QAAQ,SAASC,aAAaC;gBAClC,IAAIL,OAAOI,iBAAiB1I,WAAW;oBACnCwI,OAAOE,eAAeJ,OAAOI;;gBAGjCJ,OAAOI,eAAeC;;YAG1B,OAAOL;;QAMXzM,GAAG2F,UAAU,SAASoH,KAAKC,KAAKC;YAC5B,IAAIF,IAAIpH,SAAS;gBACb,OAAOoH,IAAIpH,QAAQqH,KAAKC;;YAG5BA,OAAOA,QAAQ;YACf,IAAIC,MAAMH,IAAIhH;YAEd,IAAIkH,OAAO,GAAG;gBACVA,QAAQC;;YAGZ,MAAOD,OAAOC,KAAKD,QAAQ,GAAG;gBAC1B,IAAIF,IAAII,eAAeF,SAASF,IAAIE,UAAUD,KAAK;oBAC/C,OAAOC;;;YAGf,QAAQ;;QAIZjN,GAAGoN,cAAc;YACb,OAAO,uCAAuC7K,QAAQ,SAAS,SAAS8K;gBAEpE,IAAIC,IAAI3L,KAAK4L,WAAW,KAAK,GAAGC,IAAIH,KAAK,MAAMC,IAAKA,IAAI,IAAM;gBAC9D,OAAOE,EAAE7G,SAAS;;;QAM1B3G,GAAGyN,KAAK;YACJ,OAAOC,UAAUC,UAAUhI,QAAQ,aAAa,KAC5C+H,UAAUC,UAAUhI,QAAQ,gBAAgB;;QAGpD3F,GAAG4N,MAAM;YACL,OAAOF,UAAUC,UAAUhI,QAAQ,eAAe;;QAGtD3F,GAAG6N,MAAM;YACL,OAAOH,UAAUC,UAAUhI,QAAQ,eAAe;;QAGtD3F,GAAG8N,OAAO;YACN,OAAOJ,UAAUC,UAAUhI,QAAQ,gBAAgB;;QAGvD3F,GAAG+N,OAAO;YACN,OAAO/N,GAAGyN,QAAQC,UAAUC,UAAUhI,QAAQ,cAAc;;QAGhE3F,GAAGgO,OAAO;YACN,OAAON,UAAUC,UAAUhI,QAAQ,WAAW;;QAGlD3F,GAAGiO,SAAS;YACR,OAAOP,UAAUQ,WAAW/J,aAAauJ,UAAUQ,OAAOvI,QAAQ,cAAc;;QAGpF3F,GAAGmO,SAAS;YACR,OAAOT,UAAUQ,WAAW/J,aAAauJ,UAAUQ,OAAOvI,QAAQ,eAAe;;QAGrF3F,GAAGoO,QAAQ;YACP,OAAOV,UAAUQ,WAAW/J,aAAauJ,UAAUQ,OAAOvI,QAAQ,cAAc;;QAGpF3F,GAAGqO,UAAU;YACT,QAASrO,GAAGgO,WAAWhO,GAAG+N,UAAUL,UAAUC,UAAUhI,QAAQ,gBAAgB,KAAK+H,UAAUQ,WAAW/J,aAAauJ,UAAUQ,WAAW;;QAGhJlO,GAAGsO,UAAU;YACT,OAAOZ,UAAUa,aAAa;;QAGlCvO,GAAGwO,UAAU;YACT,OAAOd,UAAUC,UAAUrE,cAAc3D,QAAQ,gBAAgB;;QAKrE3F,GAAG2K,eAAe;YACd,OAAO3K,GAAGwO,aAAad,UAAUC,UAAUrE,cAAc3D,QAAQ,YAAY;;QAGjF3F,GAAGyO,OAAO;YACN,OAAOzO,GAAG0O,SAAShB,UAAUC,UAAUhI,QAAQ,eAAe;;QAGlE3F,GAAG2O,OAAO;YACN,OAAO3O,GAAG0O,SAAShB,UAAUC,UAAUhI,QAAQ,eAAe;;QAGlE3F,GAAG4O,OAAO;YACN,OAAO5O,GAAG0O,SAAShB,UAAUC,UAAUhI,QAAQ,eAAe;;QAIlE3F,GAAG6O,SAAS;YACR,OAAO7O,GAAG0O,SAAShB,UAAUC,UAAUhI,QAAQ,iBAAiB;;QAGpE3F,GAAG0O,MAAM;YAEL,OAAOhB,UAAUC,UAAUhI,QAAQ,aAAa,KACzC+H,UAAUC,UAAUhI,QAAQ,aAAa,KACzC+H,UAAUC,UAAUhI,QAAQ,eAAe;;QAGtD3F,GAAG8O,YAAY;YACX,OAAO9O,GAAG0O,SAAShB,UAAUC,UAAUhI,QAAQ,cAAc;;QAGjE3F,GAAG+O,YAAY;YACX,OAAO/O,GAAG0O,UAAU1O,GAAG8O,eAAepB,UAAUC,UAAUhI,QAAQ,eAAe;;QAGrF3F,GAAGgP,mBAAmB;YAClB,OAAOhP,GAAG0O,UAAU1O,GAAG8O,gBAAgB9O,GAAG+O;;QAM9C/O,GAAGiP,iBAAiB,SAASC;YACzB,IAAIA,EAAED,gBAAgB;gBAClBC,EAAED;mBACC;gBACHC,EAAEC,cAAc;;;QAQxBnP,GAAGoP,YAAa;YACZ,IAAIC,MAAMxF,SAASC,cAAc;YACjC,OAAO,SAASwF;gBACZD,IAAIE,YAAYD;gBAChB,IAAIrP,UAAUoP,IAAI/L;gBAClB+L,IAAIhO,YAAYpB;gBAChB,OAAOA;;;QAKfD,GAAG+C,OAAO,SAASyM,cAAcC;YAC7B,IAAIC,YAAYC;YAEhB,IAAIH,cAAc;gBAEd,IAAIxK,OAAO4K,WAAWJ,aAAavI,gBAAgBjC,OAAO4K,SAAS;oBAC/D,KAAKF,aAAa,GAAGA,aAAaF,aAAazJ,QAAQ2J,cAAc;wBACjEC,SAASF,SAASD,aAAaK,IAAIH,aAAaF,aAAaM,QAAQN,aAAaK,IAAIH;wBACtF,IAAIC,WAAW,OAAO;4BAClB;;;uBAMP,IAAI3P,GAAG8G,QAAQ0I,iBAAiBxP,GAAGkH,WAAWsI,iBAAiBxP,GAAGoH,WAAWoI,eAAe;oBAC7F,KAAKE,aAAa,GAAGA,aAAaF,aAAazJ,QAAQ2J,cAAc;wBACjEC,SAASF,SAASC,YAAYF,aAAaE;wBAC3C,IAAIC,WAAW,OAAO;4BAClB;;;uBAIP,IAAI3P,GAAGwH,SAASgI,eAAe;oBAChC,KAAKE,aAAa,GAAGA,aAAaF,aAAazJ,QAAQ2J,cAAc;wBACjEC,SAASF,SAASC,YAAYF,aAAaO,OAAOL;wBAClD,IAAIC,WAAW,OAAO;4BAClB;;;uBAIP;oBACD,KAAKD,cAAcF,cAAc;wBAC7B,IAAI/I,OAAOC,UAAUyG,eAAevG,KAAK4I,cAAcE,aAAa;4BAChEC,SAASF,SAASC,YAAYF,aAAaE;4BAC3C,IAAIC,WAAW,OAAO;gCAClB;;;;;;;QASxB3P,GAAGgQ,OAAO,SAASC,SAASC;YACxB,IAAIlQ,GAAG6G,WAAWoJ,UAAU;gBACxB,IAAIjI,OAAQC,MAAMvB,UAAUwB,MAAMtB,KAAKuB,WAAW;gBAElD,OAAO;oBACH,IAAIgI,UAAUnQ,GAAG6B,WAAWmG;oBAC5B,IAAIG,UAAUpC,QAAQ;wBAClBoK,UAAUA,QAAQC,OAAOnI,MAAMvB,UAAUwB,MAAMtB,KAAKuB;;oBAExD,OAAO8H,QAAQI,MAAMH,SAASC;;;YAItC,MAAM,IAAI3O,MAAM;;QAmBpBxB,GAAGsQ,UAAU,SAASC,KAAKC,MAAMC;YAE7B,IAAIC,iBACAC,SAAS,KACTC,MAAM,SAASC,SAASC;gBACpB,IAAIC,WAAWP,OACR,QAAQrO,KAAKqO,QACdA,OACAA,OAAO,MAAMM,IAAI,MACjBA;gBACN,IAAKC,aAAa,eAAiBD,MAAM,aAAc;oBACnDJ,WAAWxN,YACC2N,YAAY,WACd7Q,GAAGsQ,QAAQO,SAASE,UAAU,QAC7BtK,OAAOC,UAAUC,SAASC,KAAKiK,aAAa,sBAC7CG,mBAAmBD,YAAY,MAAMC,mBAAmBH,aACxDG,mBAAmBD,YAAY,MAAMC,mBAAmBH;;;YAK9E,KAAKJ,cAAcD,MAAM;gBACrBG,SAAU,KAAKxO,KAAKqO,QAAU,MAAMrO,KAAKqO,QAAS,KAAK,MAAM;gBAC7DE,WAAWxN,KAAKsN;gBAChBE,WAAWxN,KAAKlD,GAAGsQ,QAAQC;mBACxB,IAAK9J,OAAOC,UAAUC,SAASC,KAAK2J,SAAS,2BAA6BA,QAAQ,aAAc;gBACnGvQ,GAAG+C,KAAKwN,KAAK,SAASvN,KAAKC;oBACvB2N,IAAI3N,KAAKD;;mBAEV,WAAYuN,QAAQ,eAAiBA,QAAQ,eAAiBA,QAAQ,UAAW;gBACpFvQ,GAAG+C,KAAKwN,KAAK,SAAShE,MAAMtJ;oBACxB2N,IAAI3N,KAAKsJ;;mBAEV;gBACHmE,WAAWxN,KAAK8N,mBAAmBR,QAAQ,MAAMQ,mBAAmBT;;YAGxE,IAAIC,MAAM;gBACN,OAAOE,WAAWO,KAAKN;mBACpB;gBACH,OAAOD,WAAWO,KAAKN,QAClBpO,QAAQ,MAAM,IACdA,QAAQ,QAAQ;;;QAI7BvC,GAAGkR,eAAe,SAASX,KAAKY,UAAUC;YACtC,KAAKD,UAAU;gBACXA,WAAW,IAAInH;;YAGnBhK,GAAG+C,KAAKwN,KAAK,SAASV,KAAK5M;gBACvB4M,MAAMuB,eAAeA,eAAe,MAAMvB,MAAM,MAAMA;gBAEtD,IAAI7P,GAAGuG,SAAStD,MAAM;oBAClBjD,GAAGkR,aAAajO,KAAKkO,UAAUtB;uBAE9B,IAAI7P,GAAG6G,WAAW5D,MAAM;oBACzBkO,SAAS9L,OAAOwK,KAAK5M;uBAEpB;oBACDkO,SAAS9L,OAAOwK,KAAK5M;;;YAI7B,OAAOkO;;QAGXnR,GAAGqR,aAAa,SAASd,KAAKe;YAC1B,IAAI1H;YAEJ,KAAK0H,MAAM;gBACPA,OAAOzH,SAASC,cAAc;;YAGlC9J,GAAGkR,aAAaX;gBACZlL,QAAQ,SAASwK,KAAK5M;oBAClB2G,QAAQC,SAASC,cAAc;oBAC/BF,MAAM2H,aAAa,QAAQ1B;oBAC3BjG,MAAM2H,aAAa,SAAStO;oBAC5BqO,KAAKE,YAAY5H;;;YAIzB,OAAO0H;;QAOXtR,GAAGyR,YAAY,SAASC;YAEpB,IAAI1M,OAAO2M,QAAQ3R,GAAG6G,WAAW8K,KAAKC,QAAQ;gBAC1C,OAAOD,KAAKC,MAAMF;mBACf;gBACH,OAAOG,KAAK,MAAMH,OAAO;;;QAUjC1R,GAAG8R,eAAe,SAASC;YACvB,IAAIC,SAASD,SAASE,YAAY,OAAO;YAEzC,IAAID,SAAS,GAAG;gBACZ,OAAOD,SAASG,OAAOF,QAAQD,SAAShM,SAASiM;;;QAIzDhS,GAAGmS,cAAc,SAASC;YAGtB,IAAIpS,GAAGiJ,QAAQmJ,kBAAkB;gBAE7B,OAAOA,gBAAgBrL,MAAMxE,QAAQ,aAAa;mBAEjD,IAAIvC,GAAGyI,OAAO2J,kBAAkB;gBACjC,IAAIA,gBAAgBC,aAAa,QAAQD,gBAAgBC,aAAalO,WAAW;oBAC7E,OAAOiO,gBAAgBC;;;YAI/B,OAAOD,gBAAgBrQ;;QAM3B/B,GAAGsS,iBAAiB;YAChB,IAAIC;YAEJ;gBAEIC,SAAS;oBACL,IAAIC;oBACJ,GAAG;wBACCA,WAAWF,UAAUG;wBACrB,IAAID,UAAU;4BACVA;;6BAGDA;;gBAIXnS,QAAQ;oBACJ,IAAI0H,OAAOG;oBAEX9H,KAAKsS,YAAY3S,GAAGgI,KAAK,IAAI1H,OAAO+P,MAAMhQ,MAAM4H,MAAMvB,UAAUwB,MAAMtB,KAAKuB,WAAW;;gBAI1FwK,aAAa,SAASC;oBAClBL,UAAUrP,KAAK0P;;;;;KCt2B9B;QACG;QACA,WAAWC,WAAW,cAAcA,OAAOC,KAAK;YAC5CD,OAAO;gBACH,OAAO7S;;eAGV,WAAW+S,WAAW,eAAeA,OAAOC,SAAS;YACtDD,OAAOC,UAAUhT;eAEhB;YACDD,OAAOC,KAAKA;;;KCRnB;QACG;QAEAA,GAAGwB,QAAQ,SAAS4E;YAChB/F,KAAK+F,UAAU,oBAAoBpG,GAAGiT,UAAU,OAAO7M;;QAG3DpG,GAAGwB,MAAMkF,YAAY,IAAIlF;;ICV7BxB,GAAGiT,UAAU;ICAbjT,GAAGkT,oBAAqB;QACpB;QAEA,IAAIC,mBACAC,wBACAC,kBACAC,2BACAC,oBACAC,kBACAC,gBACAC,wBACAC,oBACAC,uBACAC,2BACAC,wBACAC,yBACAC,uBACAC;QAEJ,SAASC;YACL,IAAIC,YAAY,MACZC;YAEJ;gBACIA,YAAYvK,SAASC,cAAc;gBACnCsK,UAAU7T,OAAO;gBACjBP,GAAGoU,WAAWlU;gBAEd,IAAIkU,UAAUC,UAAU;oBACpBF,YAAY;;cAGpB,OAAOG;gBACHH,YAAY;;YAGhB,OAAOA;;QAIX,SAASI;YACL,QAAQvU,GAAGmO,YAAYnO,GAAGoO,YACtBV,UAAUC,UAAU6G,MAAM,2CAA2CrQ;;QAI7E,SAASsQ;YACL,QAAQzU,GAAGmO,YAAYnO,GAAGoO,YACtBV,UAAUC,UAAU6G,MAAM,2CAA2CrQ;;QAI7E,SAASuQ;YACL,IAAI1P,OAAOmF,gBAAgB;gBACvB,IAAIwK,MAAM3U,GAAGiK;gBAGb,OAAO0K,IAAIC,oBAAoBzQ;;YAGnC,OAAO;;QAIX,SAAS0Q;YACL,OAAO7P,OAAO8P,mBAAmB3Q;;QAKrC,SAAS4Q;YACL,IAAIL,6BAA6B;gBAC7B,OAAO;;YAGX,OAAOG;;QAGX,SAASG;YAEL,OAAOnL,SAASC,cAAc,SAASmL,oBAAoB9Q;;QAG/D,SAAS+Q;YACL;gBACI,SAASlQ,OAAOmQ,gBAEZnV,GAAG6G,WAAW7B,OAAOmQ,aAAaC;cAE1C,OAAO/K;gBAEH,OAAO;;;QAIf,SAASgL;YACL,IAAIC,OAAOzL,SAASC,cAAc;YAElC,QAAQ,eAAewL,QAAS,iBAAiBA,QAAQ,YAAYA,UAChEtV,GAAGwO,cAAcxO,GAAG0O;;QAG7ByE,oBAAoBe;QAEpBZ,4BAA4BH,qBAAqBnT,GAAG2J;QAEpDyJ,yBAAyBE,8BAA8BtT,GAAG2K;QAE1D0I,mBAAmBC,6BAA6B+B;QAEhD9B,qBAAqBF,oBAAoBkB;QAEzCf,mBAAmBF,6BAA6BtT,GAAG0K;QAEnD+I,iBAAiBH,6BAA6BE,oBAAoB0B;QAElExB,yBAAyBJ,6BAA6BmB;QAEtDd,qBAAqBR,sBAAsBnO,OAAOuQ,gBAAgBpR,aAAamP;QAE/EO,4BAA4Ba;QAE5Bd,wBAAwBiB;QAExBf,yBAAyBiB;QAEzBhB,0BAA0BiB;QAE1BhB,wBAAwBV,6BAA6BtO,OAAO6G,eAAe1H;QAE3E8P,yBAA0B;YACtB,IAAIX,2BAA2B;gBAC3B,QAAQtT,GAAG2K,mBAAmB3K,GAAG8O;;YAErC,OAAO;;QAGX;YACI0G,eAAelC;YACfmC,eAAerC;YACfsC,kBAAkBpC;YAClBqC,UAAUnC;YACVoC,gBAAgB9B;YAChB+B,mBAAmBjC;YACnBkC,mBAAmBjC;YACnBkC,iBAAiB/Q,OAAOgR;YACxBC,UAAU5C;YACV6C,YAAY3C;YACZ4C,iBAAiBpC;YACjBqC,eAAepC;YACfqC,iBAAiBrC;YACjBsC,oBAAoBhD;YACpBiD,OAAO/C;YACPgD,aAAavC;YACbwC,QAAQhD;YACRiD,SAAS1C,yBAAyBZ;YAClCuD,cAAc3W,GAAGiO;YACjB2I,2BAA2B5W,GAAG0O;YAC9BmI,WAAW1D;YACX2D,YAAYnD;YACZoD,qBAAqBzD;YACrB0D,oBAAoB1D;YACpB2D,gBAAgBvD;;;IChKxB1T,GAAGkX,mBAAmB,SAASC;QAC3B;QACA,UAAUA,gBAAgBA,aAAaC,QAAQpX,GAAG6G,WAAWsQ,aAAaC;;IAG9EpX,GAAG+L,UAAU;QACT;QAEA,IAAIsL,aAAaC,aACbC,uBACAC,uBACAC,oBACAC,QAAQ;QAEZ1X,GAAG6B,OAAOxB;YACN+W,MAAM,SAASO,WAAWC;gBACtB,IAAIF,UAAU,GAAG;oBACb,IAAIC,WAAW;wBACXJ,iBAAiBrU,KAAKyU;;oBAE1B,IAAIC,WAAW;wBACXJ,iBAAiBtU,KAAK0U;;uBAGzB,IAAIF,WAAW,GAAG;oBACnBE,aAAaA,UAAUvH,MAAM,MAAMiH;uBAElC,IAAIK,WAAW;oBAChBA,UAAUtH,MAAM,MAAMgH;;gBAG1B,OAAOhX;;YAGXwX,MAAM,SAASpI;gBACX,IAAIiI,UAAU,GAAG;oBACbD,cAAcvU,KAAKuM;uBAElB;oBACDA,SAASY,MAAM,MAAMiH,gBAAgBnT,YAAYkT,cAAcC;;gBAGnE,OAAOjX;;YAGX4L,SAAS;gBACLyL,QAAQ;gBACRL,cAAclP;gBAEd,IAAIoP,iBAAiBxR,QAAQ;oBACzB/F,GAAG+C,KAAKwU,kBAAkB,SAASvU,KAAKyM;wBACpCA,SAASY,MAAM,MAAMgH;;;gBAI7B,IAAII,cAAc1R,QAAQ;oBACtB/F,GAAG+C,KAAK0U,eAAe,SAASzU,KAAKyM;wBACjCA,SAASY,MAAM,MAAMgH;;;gBAI7B,OAAOhX;;YAGX8L,SAAS;gBACLuL,SAAS;gBACTJ,cAAcnP;gBAEd,IAAIqP,iBAAiBzR,QAAQ;oBACzB/F,GAAG+C,KAAKyU,kBAAkB,SAASxU,KAAKyM;wBACpCA,SAASY,MAAM,MAAMiH;;;gBAI7B,IAAIG,cAAc1R,QAAQ;oBACtB/F,GAAG+C,KAAK0U,eAAe,SAASzU,KAAKyM;wBACjCA,SAASY,MAAM,MAAMiH;;;gBAI7B,OAAOjX;;;;IC3EnBL,GAAG8X,YAAY,SAASC,eAAeC;QACnC;QAEAhY,GAAG6B,OAAOxB;YACN0X,eAAeA;YAEfE,QAAQ;gBACJ,OAAOD,SAASD;;;;ICF5B/X,GAAGkY,eAAe,SAASC;QACvB;QAEA,IAAIC,OAAO/X,MAEPgY,iBAAiB,IAAIrY,GAAGsS,kBAExBgG;YAEIC,aAAa;YAGbtY,SAAS;YAETuY,YAAY;YAGZC,SAAS;YAGTC,YAAY;YAEZC,4BAA4B;YAG5B5O,UAAU;YAGVhI,MAAM;YAGN6W,UAAU,SAAShP;YAEnBiP,OAAO;WAEXjP,OAAOkP;QAGX9Y,GAAG6B,OAAOyW,SAASH;QAEnBW,WAAW9Y,GAAGoN;QAGd,SAAS2L;YACL,IAAInP,QAAQC,SAASC,cAAc;YAEnCF,MAAM2H,aAAavR,GAAGkY,aAAac,qBAAqBF;YACxDlP,MAAM2H,aAAa,SAAS+G,QAAQO;YAEpCT,KAAKa,YAAYX,QAAQvO,UAAUH;YAEnC,IAAI0O,QAAQG,WAAWzY,GAAGkT,kBAAkBiD,iBAAiB;gBAEzDvM,MAAM2H,aAAa,mBAAmB;;YAG1C,IAAI+G,QAAQC,aAAa;gBACrB3O,MAAM2H,aAAa,UAAU+G,QAAQC;;YAGzC3O,MAAM2H,aAAa,QAAQ;YAC3B3H,MAAM2H,aAAa,QAAQ+G,QAAQvW;YAEnC/B,GAAG4J,OAAOtI;gBACN4X,UAAU;gBAIVC,OAAO;gBACPC,KAAK;gBACLC,YAAY;gBASZC,UAAUtZ,GAAGyN,SAASzN,GAAG6N,QAAQ,WAAW;gBAC5C0L,QAAQ;gBACRC,SAAS;gBACTC,QAAQ;gBACRhY,SAAS;;aAKZzB,GAAG4N,SAAS5N,GAAG4J,OAAOtI;gBAAKoY,QAAQ;;YAEpCpB,QAAQrY,QAAQuR,YAAY5H;YAE5ByO,eAAe/X,OAAOsJ,OAAO,UAAU;gBACnC0O,QAAQM,SAAShP;;YAIrByO,eAAe/X,OAAOsJ,OAAO,aAAa;gBACtC5J,GAAGsY,QAAQrY,SAASoC,SAASiW,QAAQI;;YAEzCL,eAAe/X,OAAOsJ,OAAO,YAAY;gBACrC5J,GAAGsY,QAAQrY,SAASqC,YAAYgW,QAAQI;;YAG5CL,eAAe/X,OAAOsJ,OAAO,SAAS;gBAClC5J,GAAGsY,QAAQrY,SAASoC,SAASiW,QAAQE;;YAEzCH,eAAe/X,OAAOsJ,OAAO,QAAQ;gBACjC5J,GAAGsY,QAAQrY,SAASqC,YAAYgW,QAAQE;;YAG5C,OAAO5O;;QAIX5J,GAAGsY,QAAQrY,SAASqB;YAChB4X,UAAU;YACVS,UAAU;YAEVC,WAAW;;QAIf5Z,GAAG6B,OAAOxB;YACNwZ,UAAU;gBACN,OAAOjQ;;YAGXkQ,aAAa;gBACT,OAAOhB;;YAGXG,aAAa,SAASc,YAAYC;gBAC9B,IAAIpQ,QAAQoQ,YAAY3Z,KAAKwZ;gBAK7B,IAAIvB,QAAQK,8BAA8B3Y,GAAG4O,WAAW5O,GAAG8O,eAAe9O,GAAGgP,qBAAqB;oBAC9FpF,MAAM2H,aAAa,YAAY;uBAG9B;oBACD,IAAIwI,YAAY;wBACZnQ,MAAM2H,aAAa,YAAY;2BAE9B;wBACD3H,MAAMqQ,gBAAgB;;;;YAKlCC,gBAAgB,SAAS3B;gBACrB,IAAIA,gBAAgBD,QAAQC,aAAa;oBACrC3O,MAAM2H,aAAa,UAAUgH;;;YAIrC4B,OAAO;gBACH,IAAIvQ,MAAMzI,YAAY;oBAClBnB,GAAG4J,OAAOxI;;gBAGdpB,GAAGsY,QAAQrY,SAASqC,YAAYgW,QAAQE;gBACxC5O,QAAQ;gBACRA,QAAQmP;;;QAIhBnP,QAAQmP;;IAGZ/Y,GAAGkY,aAAac,sBAAsB;ICxLtChZ,GAAGoa,aAAa,SAASC;QACrB;QAEA,IAAIvV,WACAwV,aACAC,eACAC,qBACAC;QAEJ,SAASC,aAAaC;YAClB,IAAI3a,GAAG8G,QAAQ6T,UAAU;gBACrB,IAAIC;gBAEJ5a,GAAG+C,KAAK4X,SAAS,SAAS3X,KAAK6X;oBAC3BD,QAAQ1X,KAAK4B,KAAK+V;;gBAGtB,OAAOD;;YAGX,OAAO9V,KAAK6V;;QAGhB,SAASG,eAAeC;YACpB,IAAI/a,GAAG8G,QAAQiU,QAAQ;gBACnB,IAAIH;gBAEJ5a,GAAG+C,KAAKgY,OAAO,SAAS/X,KAAKgY;oBACzBJ,QAAQ1X,KAAK4B,KAAKwV,OAAOU;;gBAG7B,OAAOJ;;YAGX,OAAO9V,KAAKwV,OAAOS;;QAGvB,SAASE,gBAAgBC;YACrB,IAAIC,oBACAC,cAAchL,OAAO8K;YAEzBlb,GAAG+C,KAAKqY,UAAU,SAASC,OAAOC;gBAC9B,IAAIC,sBAAsBhB,SAASe;gBAEnC,IAAIC,wBAAwBpX,WAAW;oBACnCnE,GAAG+C,KAAKwY,qBAAqB,SAASzK,GAAG0K;wBACrCL,cAAcjY,KAAK4B,KAAK0W;;;;YAKpC,OAAOL;;QAGXnb,GAAG6B,OAAOxB;YAeNob,SAAS,SAASC;gBACd,IAAIR,SAASQ,KAAKR,UAAUlb,GAAGkb,OAAOS,YAClCd,KAAK/V,KAAK5B;oBACNnB,MAAM2Z,KAAK3Z;oBACX6Z,cAAcF,KAAK3Z;oBACnBiZ,MAAMU,KAAKV;oBACXa,MAAMH,KAAKG,QAAQ,QAAQ,IAAIH,KAAKG;oBACpCX,QAAQA;qBACP;gBAET,IAAIQ,KAAKI,SAAS;oBACdhX,KAAK+V,IAAIiB,UAAUJ,KAAKI;oBAExB,IAAIrB,UAAUiB,KAAKI,aAAa3X,WAAW;wBACvCsW,UAAUiB,KAAKI;;oBAEnBrB,UAAUiB,KAAKI,SAAS5Y,KAAK2X;;gBAGjC,IAAIa,KAAKK,cAAc;oBACnBjX,KAAK+V,IAAIkB,eAAeL,KAAKK;oBAE7B,IAAIvB,eAAekB,KAAKK,kBAAkB5X,WAAW;wBACjDqW,eAAekB,KAAKK;;oBAExBvB,eAAekB,KAAKK,cAAc7Y,KAAK2X;;gBAG3C/V,KAAK+V,IAAIA,KAAKA;gBACdP,OAAOoB,KAAKV,QAAQH;gBAEpB,IAAIN,SAASW,YAAY/W,WAAW;oBAChCoW,SAASW;;gBAEbX,SAASW,QAAQhY,KAAK2X;gBAEtBR,cAAc2B,eAAenB,IAAI,MAAMK;gBAEvC,OAAOL;;YAGXoB,UAAU,SAASC;gBACf,IAAIlc,GAAGuG,SAAS2V,mBAAmBpX,KAAKiB,QAAS;oBAC7C,IAAImW,eAAerB,OAAO1W,WAAW;wBACjC,OAAOuW,aAAawB,eAAerB;2BAGlC,IAAIqB,eAAelB,SAAS7W,WAAW;wBACxC,OAAO2W,eAAeoB,eAAelB;2BAGpC,IAAIkB,eAAehB,QAAQ;wBAC5B,OAAOD,gBAAgBiB,eAAehB;;uBAGzC;oBACD,OAAOlb,GAAG6B,WAAWiD,MAAM;;;YAInCqV,OAAO;gBACHrV;gBACAwV;gBACAC;gBACAE;;YAGJ0B,WAAW,SAAStB,IAAIuB;gBACpB,IAAIC,YAAYvX,KAAK+V,IAAIK,QACrBoB,yBAAyBtc,GAAG2F,QAAQ4U,SAAS8B,YAAYxB;gBAE7DN,SAAS8B,WAAWE,OAAOD,wBAAwB;gBAEnDxX,KAAK+V,IAAIK,SAASkB;gBAElB,IAAI7B,SAAS6B,eAAejY,WAAW;oBACnCoW,SAAS6B;;gBAEb7B,SAAS6B,WAAWlZ,KAAK2X;gBAEzBR,cAAc2B,eAAenB,IAAIwB,WAAWD;;YAGhDI,aAAa,SAAS3B,IAAI4B;gBACtB,IAAIC,UAAU5X,KAAK+V,IAAIG;gBAEvBlW,KAAK+V,IAAIG,OAAOyB;gBAChBnC,OAAOmC,WAAW5B;uBACXP,OAAOoC;;YAGlBC,YAAY,SAAS9B,IAAI+B;gBACrB9X,KAAK+V,IAAI9Y,OAAO6a;;YAGpBC,YAAY,SAAShC,IAAIiC;gBACrBhY,KAAK+V,IAAIgB,OAAOiB;;YAIpBC,aAAa,SAASC,UAAUC;gBAC5BnY,KAAKkY,UAAUC,WAAWA;;YAG9BC,oBAAoB,SAASrC;gBACzB,IAAIkB,eAAejX,KAAK+V,IAAIkB;gBAE5B,IAAIA,cAAc;oBACd,OAAOvB,eAAeuB;;gBAE1B;;YAGJoB,eAAe,SAAStC;gBACpB,IAAIiB,UAAUhX,KAAK+V,IAAIiB;gBAEvB,OAAOrB,UAAUqB;;;;IAK7B9b,GAAGkb;QACCS,YAAY;QACZyB,WAAW;QACXC,UAAU;QACVC,QAAQ;QACRC,UAAU;QACVC,QAAQ;QACRC,WAAW;QACXC,iBAAiB;QACjBC,mBAAmB;QACnBC,eAAe;QACfC,eAAe;QACfC,UAAU;QACVC,SAAS;;KCxMZ;QACG;QAEA/d,GAAGge;YAECC,UAAU,SAASC,iBAAiBC,QAAQC;gBACxC/d,KAAKge,SAASH,iBAAiBC,QAAQC;;YAG3CE,iBAAiB,SAASC;gBACtB,IAAInG,OAAO/X;gBAEXL,GAAG+C,KAAKwb,gBAAgB,SAASlD,OAAOmD;oBACpCpG,KAAKqG,eAAeD;;;YAI5BH,UAAU,SAASvZ,MAAMqZ,QAAQC;gBAC7B/d,KAAKqe;gBAEL,IAAI5C,UAAUzb,KAAKse,WAAW5Y,WAAW,IAAI/F,GAAGoN,gBAAgB/M,KAAKue,iBAEjEC,cAAc7e,GAAGgQ,KAAK,SAASvE;oBAC3BpL,KAAKye;wBACDrT,MAAMA;wBACN1J,MAAM1B,KAAK0e,SAASC,MAAMC;uBAC3BnD,SAASoD;mBACb7e,OAEH8e,kBAAkBnf,GAAGgQ,KAAK,SAASoP;oBAC/B/e,KAAKye,eAAeM,UAAUtD,SAASoD;mBACxC7e,OAEHgf,gBAAgBrf,GAAGgQ,KAAK,SAAS3L;oBAC7B,IAAIoH,OAAOzL,GAAGoE,aAAaC;oBAE3BhE,KAAKye;wBACDrT,MAAMA;wBACN1J,MAAM1B,KAAK0e,SAASC,MAAMC,cAAc;uBACzCnD,SAASoD;mBACb7e,OAEHif,oBAAoBtf,GAAGgQ,KAAK,SAASuP;oBACjC,IAAIC,oBAAoBD,WAAWhb,WAAWgb,WAAWhb,UAAU,KAC/DkH,OAAOzL,GAAGoE,aAAamb,WAAWlb,QAAQkb,WAAWhf,MAAMif;oBAE/Dnf,KAAKye;wBACDrT,MAAMA;wBACN1J,MAAMwd,WAAWxd;uBAClB+Z,SAASoD;mBACb7e,OAEHof,qBAAqBzf,GAAGgQ,KAAK,SAAS0P;oBAClC,IAAI1f,GAAGiJ,QAAQyW,gBAAgB1f,GAAGkT,kBAAkBsC,eAAe;wBAC/D,IAAImK,QAAQ1X,MAAMvB,UAAUwB,MAAMtB,KAAK8Y,YAAYC,QAC/CvH,OAAO/X;wBAEXL,GAAG+C,KAAK4c,OAAO,SAAS3c,KAAK4c;4BACzBxH,KAAK0G,eAAec,MAAM9D,SAASoD;;2BAGtC;wBACD7e,KAAKye,eAAeY,aAAa5D,SAASoD;;mBAE/C7e,OAEHwf,gBAAgB;oBACZ,IAAI7f,GAAG4I,WAAW9D,OAAO;wBACrBA,OAAOmD,MAAMvB,UAAUwB,MAAMtB,KAAK9B;;oBAEtCA,UAAUsL,OAAOtL;mBAGrBsT,OAAO/X,MACP6e;gBAEJ7e,KAAKue,kBAAkB9C;gBAEvB,IAAIhX,MAAM;oBACN+a;oBAEA7f,GAAG+C,KAAK+B,MAAM,SAAS9B,KAAK8c;wBACxB,IAAI9f,GAAG+I,cAAc+W,gBAAgB;4BACjCL,mBAAmBK;+BAElB,IAAI9f,GAAGyJ,OAAOqW,gBAAgB;4BAC/BjB,YAAYiB;+BAEX,IAAI9f,GAAGuG,SAASuZ,gBAAgB;4BACjC,IAAIA,cAAcrU,QAAQqU,cAAc/d,MAAM;gCAC1Cod,gBAAgBW;mCAEf,IAAIA,cAAczb,UAAUyb,cAAc/d,MAAM;gCACjDud,kBAAkBQ;;+BAGrB,IAAIA,cAActW,WAAWsW,cAActW,QAAQF,kBAAkB,UAAU;4BAChF+V,cAAcS;+BAEb;4BACD1H,KAAKjS,IAAI2Z,gBAAgB,8CAA8C;;;oBAI/Ezf,KAAK8F,IAAI,cAAc+Y,cAAcnZ,SAAS;oBAC9C1F,KAAK0f,uBAAuBb,eAAef,QAAQC;;;YAI3D4B,QAAQ,SAASnF;gBACbxa,KAAK4f,SAASD,OAAOnF;;YAGzBqF,WAAW;gBACP,IAAIC,oBACA/H,OAAO/X;gBAEXL,GAAG6B,OAAOse,eAAe9f,KAAKse;gBAC9B3e,GAAG+C,KAAKod,eAAe,SAASnd,KAAKod;oBACjChI,KAAK4H,OAAOI;;gBAGhB/f,KAAK4f,SAASC;;YAGlBG,kBAAkB;gBACdhgB,KAAKse;;YAGT2B,gBAAgB,SAASzF;gBACrB,IAAI0F,aAAalgB,KAAKmgB,YAAYvE;oBAAUpB,IAAIA;;gBAEhD,KAAK7a,GAAGkT,kBAAkBqD,UAAUlW,KAAK0e,SAASpJ,SAAS8K,SAAS;oBAChE,OAAO;;gBAGX,IAAIF,WAAWrF,WAAWlb,GAAGkb,OAAOsC,QAAQ;oBACxCnd,KAAK8F,IAAInG,GAAG8H,OAAO,0DAA0D+S,IAAIxa,KAAKqgB,QAAQ7F;oBAC9Fxa,KAAKsgB,YAAY9F;oBACjB,OAAO;uBAEN;oBACDxa,KAAK8F,IAAInG,GAAG8H,OAAO,uDAAuD+S,IAAIxa,KAAKqgB,QAAQ7F,MAAM;;gBAGrG,OAAO;;YAGX+F,YAAY,SAAS/F;gBACjB,OAAOxa,KAAKwgB,gBAAgBhG;;YAIhCiG,WAAW,SAASC;gBAChB,OAAO1gB,KAAK4f,SAASe,QAAQD;;YAOjCE,eAAe,SAASC,QAAQC,aAAaC,SAASC,YAAYC;gBAC9D,IAAIC,kBAAkB,IAAIvhB,GAAG+L,WACzByV,WAAWlJ;gBAEf,IAAIjY,KAAKohB,iBAAiB;oBACtBD,YAAYnhB,KAAKqhB,eAAeR;oBAChC5I;wBACIgJ,sBAAsBA;wBACtBF,SAASA,UAAU,IAAIA,UAAU;wBACjCO,OAAOP,UAAU;;oBAKrB,KAAKC,cAAcrhB,GAAGkT,kBAAkBkD,eAAe;wBACnDoL,YAAYnhB,KAAKuhB,QAAQV;;oBAI7B,IAAIM,aAAa,MAAM;wBACnBD,gBAAgBpV;4BAAS0V,WAAWV;4BAAa9W,OAAO;;2BAEvD;wBACDhK,KAAKohB,gBAAgBK,SAASN,WAAWL,aAAa7I,SAASlB,KAC3D,SAASnL,QAAQ8V;4BACbR,gBAAgBtV,QAAQ8V;2BAG5B,SAAS5V,QAAQ0V,WAAWG;4BACxBT,gBAAgBpV;gCAAS0V,WAAWA;gCAAWxX,OAAO2X,UAAU;;;;uBAK3E;oBACDT,gBAAgBpV;wBAAS0V,WAAWV;wBAAa9W,OAAO;;;gBAG5D,OAAOkX;;YAGXU,WAAW,SAASf;gBAChB,OAAO7gB,KAAK6hB,WAAW7hB,KAAK8hB,qBAAqBjB;;YAGrDkB,aAAa,SAASlB;gBAClB,OAAO7gB,KAAKgiB,eAAeC,IAAIpB;;YAGnCU,SAAS,SAASb;gBACd,OAAO1gB,KAAK4f,SAAS2B,QAAQb,iBAAiB;;YAGlDwB,eAAe;gBACX,OAAOliB,KAAKmgB,YAAYvE;oBACpBf,UACIlb,GAAGkb,OAAOuC,WACVzd,GAAGkb,OAAOwC,iBACV1d,GAAGkb,OAAOoC;mBAEfvX;;YAGP2a,SAAS,SAAS7F;gBACd,OAAOxa,KAAKmgB,YAAYvE;oBAAUpB,IAAIA;mBAAK9Y;;YAI/CygB,aAAa,SAAS3H;gBAClB,IAAI4H,kBAAkBpiB,KAAKqiB;oBAAY7H,IAAIA;oBACvCoC,WAAW;gBAEf,IAAIwF,iBAAiB;oBACjB,IAAIA,gBAAgBxF,aAAa9Y,WAAW;wBACxC8Y,WAAWwF,gBAAgBxF;;;gBAInC,OAAOA;;YAGX0F,uBAAuB;gBACnB,OAAOtiB,KAAK4f,SAAS0C;;YAGzBC,SAAS,SAAS/H;gBACd,OAAOxa,KAAKmgB,YAAYvE;oBAAUpB,IAAIA;mBAAKgB;;YAG/CgH,eAAe;gBACX,OAAOxiB,KAAKyiB;;YAGhBC,0BAA0B;gBACtB,IAAIC,eAAe3iB,KAAK4iB;gBAExB,IAAID,eAAe,GAAG;oBAClB,OAAOA,eAAe3iB,KAAK6iB;;gBAG/B,OAAO;;YAGXR,YAAY,SAASxG;gBACjB,OAAO7b,KAAKmgB,YAAYvE,SAASC;;YAGrCiH,SAAS,SAAStI;gBACd,OAAOxa,KAAKmgB,YAAYvE;oBAAUpB,IAAIA;mBAAKG;;YAG/C7U,KAAK,SAAS4B,KAAK1B;gBACf,IAAIhG,KAAK0e,SAASqE,WAAW/c,SAASA,UAAU,SAAS;oBACrDrG,GAAGmG,IAAI,oBAAoBnG,GAAGiT,UAAU,OAAOlL;uBAE9C,IAAI1B,SAASA,UAAU,QAAQ;oBAChCrG,GAAGmG,IAAI,oBAAoBnG,GAAGiT,UAAU,OAAOlL,KAAK1B;;;YAK5Dgd,aAAa,SAASxI;gBAClB,IAAI0F,aAAalgB,KAAKmgB,YAAYvE;oBAAUpB,IAAIA;;gBAEhD,KAAK7a,GAAGkT,kBAAkBqD,UAAUlW,KAAK0e,SAASpJ,SAAS8K,SAAS;oBAChE,OAAO;;gBAIX,IAAIzgB,GAAG2F,UAAS3F,GAAGkb,OAAOuC,WAAWzd,GAAGkb,OAAOwC,mBAAkB6C,WAAWrF,WAAW,GAAG;oBACtF,IAAI7a,KAAK4f,SAAS1J,MAAMsE,KAAK;wBACzBxa,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOsC;wBACzC,OAAO;2BAEN;wBACDnd,KAAK8F,IAAInG,GAAG8H,OAAO,oCAAoC+S,IAAIxa,KAAKqgB,QAAQ7F,MAAM;;uBAGjF;oBACDxa,KAAK8F,IAAInG,GAAG8H,OAAO,yDAAyD+S,IAAIxa,KAAKqgB,QAAQ7F,MAAM;;gBAGvG,OAAO;;YAGXyI,eAAe,SAASzI;gBACpBxa,KAAK4f,SAASsD,QAAQ1I;;YAG1BV,OAAO;gBACH9Z,KAAK8F,IAAI;gBAET9F,KAAK4f,SAAS9F;gBACd9Z,KAAKse;gBACLte,KAAKmjB;gBACLnjB,KAAKojB;gBACLpjB,KAAKqjB;gBACLrjB,KAAKqhB;gBAEL1hB,GAAG+C,KAAK1C,KAAKsjB,UAAU,SAAS3gB,KAAK4gB;oBACjCA,OAAOzJ;;gBAGX9Z,KAAKwjB,aAAa1J;gBAClB9Z,KAAKgiB,eAAelI;gBACpB9Z,KAAK6iB,uBAAuB;gBAC5B7iB,KAAKyiB,eAAe;gBACpBziB,KAAKmgB,YAAYrG;gBACjB9Z,KAAK8hB;gBAEL9hB,KAAKyjB,iBAAiBzjB,KAAKyjB,cAAc3J;gBACzC9Z,KAAK0e,SAASgF,QAAQC,kBAAkB3jB,KAAK4jB;gBAE7C5jB,KAAK6jB;gBACL7jB,KAAK8jB;gBAEL9jB,KAAK+jB,kBAAkB/jB,KAAK+jB,eAAejK;;YAG/CkK,OAAO,SAASxJ;gBACZ,OAAOxa,KAAKikB,aAAazJ;;YAG7B0J,YAAY,SAAS1J,IAAI2J;gBACrB,IAAIpM,OAAO/X;gBAEX,OAAOL,GAAGykB,OAAO/d,UAAU6d,WAAW1J,IAAI2J;oBACtCre,KAAKnG,GAAGgQ,KAAKoI,KAAKjS,KAAKiS;oBACvBwJ,SAAS5hB,GAAGgQ,KAAKoI,KAAKwJ,SAASxJ;oBAC/BmI,YAAYnI,KAAKoI;;;YAIzBkE,kBAAkB,SAASC,SAAS9J;gBAChCxa,KAAKukB,oBAAoBC,IAAIF,SAAS9J;;YAG1CiK,4BAA4B,SAASH,SAAS9J;gBAC1Cxa,KAAK0kB,8BAA8BF,IAAIF,SAAS9J;;YAGpDmK,uBAAuB,SAAS5G,UAAUvD;gBACtCxa,KAAK4kB,yBAAyBJ,IAAIzG,UAAUvD;;YAGhDqK,qBAAqB,SAAS/G,QAAQtD;gBAClCxa,KAAK8kB,uBAAuBN,IAAI1G,QAAQtD;;YAI5CuK,aAAa,SAAShH,UAAUvD;gBAC5Bxa,KAAKgiB,eAAewC,IAAIzG,UAAUvD;;YAGtCwK,SAAS,SAASC;gBACdjlB,KAAKklB,4BAA4BD;;YAGrCE,cAAc,SAASC;gBACnBplB,KAAK4iB,oBAAoBwC;;YAG7BC,SAAS,SAAS7K,IAAI+B;gBAClBvc,KAAKmgB,YAAY7D,WAAW9B,IAAI+B;;YAGpC+I,WAAW,SAASxH,QAAQtD;gBACxBxa,KAAKwjB,aAAagB,IAAI1G,QAAQtD;;YAGlC+K,SAAS,SAAS/K,IAAI4B;gBAClB,OAAOpc,KAAKmgB,YAAYhE,YAAY3B,IAAI4B;;YAY5CN,WAAW,SAAStB,IAAIuB;gBACpB,IAAIyJ,aAAaxlB,KAAKqiB;oBAAY7H,IAAIA;;gBACtC,KAAKgL,YAAY;oBACb,MAAM,IAAI7lB,GAAGwB,MAAMqZ,KAAK;;gBAG5B,QAAQuB;kBACJ,KAAKpc,GAAGkb,OAAO6C;oBACX1d,KAAKylB,kBAAkBjL,IAAI,MAAM;oBACjC;;kBACJ,KAAK7a,GAAGkb,OAAO2C;oBACXxd,KAAKylB,kBAAkBjL,IAAI,MAAM;oBACjC;;kBACJ;oBACI,IAAIkL,eAAe,iCAAiChkB,OAAO,+BAA+Bqa;oBAC1F/b,KAAK8F,IAAI4f;oBACT,MAAM,IAAI/lB,GAAGwB,MAAMukB;;;YAI/BC,mBAAmB;gBACf,IAAI3lB,KAAKse,WAAW5Y,WAAW,GAAG;oBAC9B1F,KAAK4lB,WAAW;uBAEf;oBACD5lB,KAAK6lB;;;;QAQjBlmB,GAAGmmB;YAEC1H,gBAAgB,SAAS2H;gBACrB,IAAIvL,KAAKxa,KAAKmgB,YAAY/E;oBACtBT,MAAMoL,YAAYpL;oBAClBjZ,MAAMqkB,YAAYrkB;oBAClB8Z,MAAMuK,YAAYvK;oBAClBX,QAAQlb,GAAGkb,OAAOyC;;gBAGtByI,YAAYC,sBAAsBhmB,KAAK2kB,sBAAsBoB,YAAYC,oBAAoBxL;gBAC7FuL,YAAYE,oBAAoBjmB,KAAK6kB,oBAAoBkB,YAAYE,kBAAkBzL;gBAEvF,IAAIuL,YAAYG,cAAc;oBAC1BlmB,KAAKqhB,eAAe7G,MAAMuL,YAAYG;;gBAG1ClmB,KAAKyiB;gBACLziB,KAAK6iB;gBAEL,OAAOrI;;YAGX2L,uBAAuB,SAAS5G,MAAM6G;gBAClC,IAAIzmB,GAAGyI,OAAOmX,OAAO;oBACjBA,KAAK8G,aAAarmB,KAAKsmB,aAAaF;;;YAI5CG,aAAa,SAASxgB;gBAClB/F,KAAK0e,SAAS8H,UAAUC,QAAQ,MAAM,MAAM1gB,SAASjC;;YAGzD4iB,sBAAsB;gBAClB,IAAI3O,OAAO/X;gBAEX,OAAO,IAAIL,GAAGgnB;oBACVC,QAAQ5mB,KAAK0e,SAAS6B,WAAWqG,OAAOC;oBACxCC,gBAAgB9mB,KAAK0e,SAASoI;oBAC9BC,eAAe/mB,KAAK0e,SAASsI,QAAQC;oBACrCC,eAAelnB,KAAK0kB;oBACpByC,aAAannB,KAAK8kB;oBAClBsC,eAAepnB,KAAK4kB;oBACpByC,MAAMrnB,KAAK0e,SAAS2I;oBACpBvhB,KAAKnG,GAAGgQ,KAAKoI,KAAKjS,KAAKiS;oBACvBuP,UAAU,SAAS9M;wBACfzC,KAAKwP,UAAU/M;wBACfzC,KAAK2G,SAAS8H,UAAUc,SAAS9M;;oBAErCgN,kBAAkB,SAAShN,IAAIiN,UAAUC;wBACrC3P,KAAK0N,kBAAkBjL,IAAIiN,UAAUC;wBACrC3P,KAAK2G,SAAS8H,UAAUgB,iBAAiBhN,IAAIiN,UAAUC;;;;YAMnEC,qBAAqB;gBACjB,IAAI5P,OAAO/X;gBAEX,OAAO,IAAIL,GAAGioB;oBACVC,eAAe7nB,KAAK0e,SAASoJ,MAAMD;oBACnCrB;wBACI1gB,KAAKnG,GAAGgQ,KAAKoI,KAAKjS,KAAKiS;wBACvBgQ,eAAe,SAAS3c;4BACpB2M,KAAKiQ;gCACDtmB,MAAM;gCACN0N,UAAUzP,GAAGgQ,KAAKoI,KAAK2G,SAAS8H,UAAUyB,iBAAiBlQ,MAAM3M;gCACjEkM,WAAW3X,GAAGgQ,KAAKoI,KAAKmQ,qBAAqBnQ,MAAM3M;gCACnD+c,YAAY;;;;;;YAOhCC,cAAc,SAASC,cAAcC;gBACjC,IAAIC,YACAC,WAAWH,cACXI,0BACAC,iBAAiBJ,kBACjBK,OAAO,SAASC;oBACZ,IAAIjpB,GAAGuG,SAAS0iB,OAAO;wBACnB,OAAOjpB,GAAG6B,WAAWonB;;oBAEzB,OAAOA;mBAEXC,oBAAoB;oBAChB,IAAIlpB,GAAG6G,WAAWkiB,iBAAiB;wBAC/B,OAAOA;;oBAEX,OAAOA;mBAEXI,wBAAwB,SAAStO,IAAIuO;oBACjC,IAAIL,kBAAkB/oB,GAAGuG,SAAS6iB,WAAW;wBACzCppB,GAAG6B,OAAOunB,UAAUF;;oBAGxB,IAAIJ,oBAAoBjO,KAAK;wBACzB7a,GAAG6B,OAAOunB,UAAUN,oBAAoBjO;;;gBAIpD;oBACIgK,KAAK,SAAS5hB,KAAK4X;wBAEf,IAAIA,MAAM,MAAM;4BACZ+N;4BACAC,WAAWG,KAAK/lB;+BAEf;4BACD2lB,MAAM/N,MAAMmO,KAAK/lB;;;oBAIzBqf,KAAK,SAASzH;wBACV,IAAIwO;wBAGJ,IAAIxO,MAAM,QAAQ+N,MAAM/N,KAAK;4BACzBwO,SAAST,MAAM/N;+BAEd;4BACDwO,SAASL,KAAKH;;wBAGlBM,sBAAsBtO,IAAIwO;wBAE1B,OAAOL,KAAKK;;oBAGhBC,aAAa,SAASzO,IAAIwO;wBAEtB,IAAIrpB,GAAGuG,SAASqiB,QAAQ;4BAEpB,IAAI/N,OAAO,MAAM;gCACb,IAAI7a,GAAG6G,WAAWwiB,SAAS;oCACvBN,iBAAiBM;uCAEhB;oCACDN,iBAAiBA;oCACjB/oB,GAAG6B,OAAOknB,gBAAgBM;;mCAG7B;gCACDP,oBAAoBjO,MAAMiO,oBAAoBjO;gCAC9C7a,GAAG6B,OAAOinB,oBAAoBjO,KAAKwO;;;;oBAK/CjoB,QAAQ,SAAS8f;wBACb,cAAc0H,MAAM1H;;oBAGxB/G,OAAO;wBACHyO;wBACAE;wBACAD,WAAWH;;;;YAKvBa,0BAA0B;gBACtB,IAAInR,OAAO/X;gBAEX,OAAO,IAAIL,GAAGoa;oBACVsG,SAAS,SAAS7F;wBACd,OAAOzC,KAAKsI,QAAQ7F;;oBAExBsI,SAAS,SAAStI;wBACd,OAAOzC,KAAK+K,QAAQtI;;oBAExB+H,SAAS,SAAS/H;wBACd,OAAOzC,KAAKwK,QAAQ/H;;oBAExBmB,gBAAgB,SAASnB,IAAIwB,WAAWD;wBACpChE,KAAKoR,sBAAsB3O,IAAIwB,WAAWD;wBAC1ChE,KAAK2G,SAAS8H,UAAU7K,eAAenB,IAAIwB,WAAWD;wBACtDhE,KAAKqR,kBAAkB5O,IAAIuB;wBAE3B,IAAIhE,KAAKgM,gBAAgB;4BACrBsF,WAAW;gCACPtR,KAAKgM,eAAepI,eAAenB,IAAIwB,WAAWD;+BACnD;;;;;YAcnBuN,qBAAqB,SAASjO;gBAC1B,IAAItD,OAAO/X,MACPkY,cAAcmD,KAAKkO,UAAUvpB,KAAK0e,SAAS8K,WAAWtR,aACtDuR,oBAAoBpO,KAAKoO,qBAAqBzpB,KAAK0e,SAAS8K,WAAWC,mBACvElG;gBAEJ,SAASmG;oBACL,IAAI/pB,GAAGkT,kBAAkBsC,eAAe;wBAEpC,IAAI4C,KAAK2G,SAASiL,YAAYC,kBAC1BjqB,GAAG0O,UACF1O,GAAGyO,UACJ2J,KAAK8R,oBAAoBJ,mBAAmB,SAAS;4BAErD,OAAO;;wBAGX,IAAIpO,KAAK3R,aAAa5F,WAAW;4BAC7B,OAAOiU,KAAK2G,SAAShV;;wBAGzB,OAAO2R,KAAK3R;;oBAGhB,OAAO;;gBAGX6Z,SAAS,IAAI5jB,GAAGkY;oBACZK,aAAaA;oBACbtY,SAASyb,KAAKzb;oBACduY,YAAYnY,KAAK0e,SAASoL,QAAQC;oBAClC3R,SAASiD,KAAKjD;oBACdC,YAAYrY,KAAK0e,SAASoL,QAAQE;oBAClC1R,4BAA4BtY,KAAK0e,SAASiL,YAAYM;oBACtDvgB,UAAUggB;oBACVhoB,MAAM1B,KAAK0e,SAASsI,QAAQkD;oBAC5B3R,UAAU,SAAShP;wBACfwO,KAAKoS,eAAe5gB;;oBAExBiP,OAAO6C,KAAK7C,SAAS,OAAOxY,KAAK0e,SAASrb,KAAK+mB,iBAAiB/O,KAAK7C;;gBAGzExY,KAAKqqB,gBAAgB/X,YAAY;oBAC7BiR,OAAOpR;;gBAGX4F,KAAKuL,SAASzgB,KAAK0gB;gBAEnB,OAAOA;;YAGX+G,sBAAsB,SAASC,mBAAmBC;gBAC9C,IAAIzS,OAAO/X,MACPyqB,qBACAxS;oBACI8K,OAAO/iB,KAAK0e,SAASqE;oBACrB+D,gBAAgB9mB,KAAK0e,SAASoI;oBAC9BO,MAAMrnB,KAAK0e,SAAS2I;oBACpBF,aAAannB,KAAKwjB;oBAClB4D,eAAepnB,KAAKgiB;oBACpB1M,UAAUtV,KAAK0e,SAASpJ;oBACxBc,QAAQpW,KAAK0e,SAAStI;oBACtBuI,OAAO3e,KAAK0e,SAASC;oBACrB7Y,KAAKnG,GAAGgQ,KAAKoI,KAAKjS,KAAKiS;oBACvB2S,mBAAmB1qB,KAAK0e,SAASsF,MAAM2G;oBACvCC,YAAY,SAASpQ,IAAI9Y,MAAMmpB,QAAQC;wBACnC,IAAID,SAAS,KAAKC,QAAQ,GAAG;4BACzB;;wBAGJ,IAAIL,eAAejQ,KAAK;4BACpB,IAAIiQ,eAAejQ,IAAIqQ,WAAWA,UAAUJ,eAAejQ,IAAIsQ,UAAUA,OAAO;gCAC5E/S,KAAKgT,YAAYvQ,IAAI9Y,MAAMmpB,QAAQC;gCACnC/S,KAAK2G,SAAS8H,UAAUoE,WAAWpQ,IAAI9Y,MAAMmpB,QAAQC;;+BAGxD;4BACD/S,KAAKgT,YAAYvQ,IAAI9Y,MAAMmpB,QAAQC;4BACnC/S,KAAK2G,SAAS8H,UAAUoE,WAAWpQ,IAAI9Y,MAAMmpB,QAAQC;;wBAGzDL,eAAejQ;4BAAOqQ,QAAQA;4BAAQC,OAAOA;;;oBAGjDE,YAAY,SAASxQ,IAAI9Y,MAAMY,QAAQgS;+BAC5BmW,eAAejQ;wBAEtB,IAAIK,SAAS9C,KAAKsK;4BAAY7H,IAAIA;2BAAKK,QACnCvL;wBAMJ,IAAIuL,WAAWlb,GAAGkb,OAAOyC,qBAAqBzC,WAAWlb,GAAGkb,OAAO0C,eAAe;4BAC9E;;wBAGJjO,SAASyI,KAAKkT,YAAYzQ,IAAI9Y,MAAMY,QAAQgS;wBAI5C,IAAIhF,kBAAmB3P,GAAG+L,SAAS;4BAC/B4D,OAAOkI,KAAK;gCACRO,KAAK2G,SAAS8H,UAAUwE,WAAWxQ,IAAI9Y,MAAMY,QAAQgS;;+BAGxD;4BACDyD,KAAK2G,SAAS8H,UAAUwE,WAAWxQ,IAAI9Y,MAAMY,QAAQgS;;;oBAG7D4W,UAAU,SAAS1Q,IAAI9Y,MAAMypB;wBACzB,IAAI1f,UAAU,IAAI9L,GAAG+L;wBAErBqM,KAAKiQ;4BACDtmB,MAAM;4BACN0N,UAAUzP,GAAGgQ,KAAKoI,KAAK2G,SAAS8H,UAAU0E,UAAUnT,MAAMyC,IAAI9Y;4BAC9D6V,WAAW9L,QAAQK;4BACnBwL,WAAW;gCACP6T,yBAAyBpU,KAAK;oCAC1BgB,KAAKqT,UAAU5Q,IAAI9Y;;gCAGvB+J,QAAQG;;4BAEZuc,YAAY3N;;wBAGhB,OAAO/O;;oBAEX4f,cAAc1rB,GAAGgQ,KAAK3P,KAAKsrB,eAAetrB;oBAC1CurB,UAAU,SAAS/Q,IAAI9Y;wBACnBqW,KAAKyT,UAAUhR,IAAI9Y;wBACnBqW,KAAK2G,SAAS8H,UAAU+E,SAAS/Q,IAAI9Y;;oBAEzC+pB,eAAe,SAASjR,IAAI9Y,MAAMgqB;wBAC9B3T,KAAK4T,eAAenR,IAAIkR;wBACxB3T,KAAK2G,SAAS8H,UAAUiF,cAAcjR,IAAI9Y,MAAMgqB;;oBAEpDE,sBAAsB,SAASpR,IAAIkR,WAAWppB,QAAQgS;wBAClDyD,KAAK2G,SAAS8H,UAAUoF,qBAAqB5b,MAAM+H,MAAMjQ;;oBAE7D+jB,UAAU,SAASrR,IAAI9Y,MAAMgqB;wBACzB,OAAO3T,KAAK2G,SAAS8H,UAAUqF,SAASrR,IAAI9Y,MAAMgqB;;oBAEtDI,aAAa,SAAStR,IAAI9Y,MAAMqqB,cAAczX;wBAC1C,OAAOyD,KAAKiU,aAAahc,MAAM+H,MAAMjQ;;oBAEzCmkB,eAAe,SAASzR,IAAI4B;wBACxBrE,KAAKjS,IAAI,wCAAwCiS,KAAK+K,QAAQtI,MAAM,WAAW4B,UAAU;wBACzFrE,KAAKwN,QAAQ/K,IAAI4B;;oBAErBiE,SAAS1gB,GAAGgQ,KAAKoI,KAAKsI,SAAStI;oBAC/B+K,SAASnjB,GAAGgQ,KAAKoI,KAAK+K,SAAS/K;oBAC/BwK,SAAS5iB,GAAGgQ,KAAKoI,KAAKwK,SAASxK;oBAC/BmU,SAASvsB,GAAGgQ,KAAKoI,KAAKoU,UAAUpU;oBAChCqU,eAAe,SAASzR;wBACpB,OAAO5C,KAAKsK;4BAAY1H,MAAMA;;;oBAElC0R,UAAU,SAAS7R;wBACf,IAAIK,SAAS9C,KAAKsK;4BAAY7H,IAAIA;2BAAKK;wBACvC,OAAOA,WAAWlb,GAAGkb,OAAOoC,UACxBpC,WAAWlb,GAAGkb,OAAOkC,aACrBlC,WAAWlb,GAAGkb,OAAOwC,mBACrBxC,WAAWlb,GAAGkb,OAAOsC;;oBAE7BN,oBAAoB9E,KAAKoI,YAAYtD;oBACrCC,eAAe/E,KAAKoI,YAAYrD;;gBAGxCnd,GAAG+C,KAAK1C,KAAK0e,SAASsI,SAAS,SAAS9a,MAAMtJ;oBAC1CqV,QAAQ/L,QAAQtJ;;gBAGpBqV,QAAQiP,gBAAgBlnB,KAAKukB;gBAE7B,IAAIgG,mBAAmB;oBACnB5qB,GAAG+C,KAAK6nB,mBAAmB,SAAS/a,KAAK5M;wBACrCqV,QAAQzI,OAAO5M;;;gBAIvB,OAAO,IAAIjD,GAAG2sB,wBAAwBrU,SAASuS;;YAGnD+B,qBAAqB,SAAS/R;gBAC1Bxa,KAAK6iB;gBACL7iB,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOmC;;YAG7CwP,aAAa,SAASxhB;gBAClB,IAAIA,UAAU,GAAG;oBACb,OAAOA,QAAQhL,KAAK0e,SAASrb,KAAKopB,YAAY;;gBAElD,IAAIhc,KAAK;gBACT,GAAG;oBACCzF,QAAQA,QAAQ;oBAChByF;yBACKzF,QAAQ;gBAEjB,OAAO1J,KAAKorB,IAAI1hB,OAAO,IAAK2hB,QAAQ,KAAK3sB,KAAK0e,SAASrb,KAAKopB,YAAYhc;;YAK5Emc,2BAA2B;gBACvB,IAAI7U,OAAO/X;gBAEXA,KAAK6sB;gBAELltB,GAAG+C,KAAK1C,KAAK0e,SAASoO,cAAc,SAASnqB,KAAKoqB;oBAC9C,IAAIrjB,WAAWqjB,uBAAuBrjB,UAClC8f,aAAa7pB,GAAG6B,WAAWuW,KAAK2G,SAAS8K,YAAY,OACrDwD,kBAAkBrtB,GAAG6B,WAAWurB;oBAEpC,IAAIrjB,aAAa5F,WAAW;wBACxB4F,WAAWqO,KAAK2G,SAAShV;;oBAG7B,IAAIsjB,gBAAgBxD,YAAY;wBAC5B7pB,GAAG6B,OAAOgoB,YAAYuD,uBAAuBvD,YAAY;;oBAG7D7pB,GAAG6B,OAAOwrB;wBACNtjB,UAAUA;wBACV8f,YAAYA;uBACb;oBAEHzR,KAAKkV,iBAAiBD;;;YAI9BnL,YAAY,SAASpJ;gBACjB,IAAIyU,mBAAmBltB,KAAK6sB,kBAAkBpU;gBAE9C,IAAIyU,kBAAkB;oBAClB,OAAOA,iBAAiBttB;uBAEvB,IAAI6Y,aAAazY,KAAKmtB,kBAAkB;oBACzC,OAAOntB,KAAK0e,SAAS6E;;;YAW7B+C,cAAc,SAAS8G;gBACnB,IAAIC,QAAQC,WACRC,kBAAkBH;gBAGtB,IAAIG,2BAA2B5tB,GAAG8X,WAAW;oBACzC8V,kBAAkBA,gBAAgB7V;;gBAItC,IAAI6V,oBAAoB5tB,GAAGyJ,OAAOmkB,kBAAkB;oBAChD,IAAI5tB,GAAGyI,OAAOmlB,kBAAkB;wBAC5B,OAAOA,gBAAgBlH;2BAEtB,IAAIkH,gBAAgBpkB,QAAQF,kBAAkB,WAC/CskB,gBAAgBrtB,KAAK+I,kBAAkB,QAAQ;wBAE/C,OAAOskB,gBAAgB1pB,aAAalE,GAAGkY,aAAac;;oBAGxD0U,SAASE,gBAAgB9qB,qBAAqB;oBAE9C9C,GAAG+C,KAAK2qB,QAAQ,SAAS1qB,KAAK4G;wBAC1B,IAAIA,MAAM1F,aAAa,YAAY,QAAQ;4BACvCypB,YAAY/jB;4BACZ,OAAO;;;oBAIf,IAAI+jB,WAAW;wBACX,OAAOA,UAAUzpB,aAAalE,GAAGkY,aAAac;;;;YAK1D6U,iBAAiB;gBACb,OAAOxtB,KAAKmgB,YAAYvE;oBACpBf,UACIlb,GAAGkb,OAAOuC,WACVzd,GAAGkb,OAAOwC,iBACV1d,GAAGkb,OAAOoC,QACVtd,GAAGkb,OAAOS,YACV3b,GAAGkb,OAAOkC,WACVpd,GAAGkb,OAAOsC;mBAEfzX;;YAKP+nB,oBAAoB,SAAShV;gBACzB,IAAIuU,kBAAkBhtB,KAAK6sB,kBAAkBpU;gBAE7C,OAAOuU,kBAAkBA,gBAAgBxD,aAAaxpB,KAAK0e,SAAS8K;;YAGxEkE,0BAA0B,SAASC;gBAC/B,IAAIA,YAAYpO,gBAAgB5f,GAAG8X,WAAW;oBAC1C;wBACI/V,MAAM/B,GAAGmS,YAAY6b,YAAYpO,KAAK7H;wBACtC8D,MAAMmS,YAAYpO,KAAK7H,cAAc8D;;;gBAI7C;oBACI9Z,MAAM1B,KAAKqiB;wBAAY7H,IAAImT,YAAYnT;uBAAK9Y;oBAC5C8Z,MAAMxb,KAAKqiB;wBAAY7H,IAAImT,YAAYnT;uBAAKgB;;;YAIpDoS,2BAA2B,SAASC;gBAChC,IAAI9V,OAAO/X,MACP8tB;gBAEJnuB,GAAG+C,KAAKmrB,cAAc,SAASlrB,KAAKgrB;oBAChCG,gBAAgBjrB,KAAKkV,KAAK2V,yBAAyBC;;gBAGvD,OAAOG;;YAIXC,qBAAqB;gBACjB,IAAI/tB,KAAK0e,SAASsP,OAAO3f,OAAO1O,GAAG0O,OAAO;oBACtC,IAAI4f,kBAAkB,0BAClB1K,SAASvjB,KAAK0e,SAASsP,OAAOzK,QAC9B9K,WAAW8K,SAASvjB,KAAKsmB,aAAa/C,UAAUvjB,KAAKmtB,kBACrDe,aAAaluB,KAAK0e;oBAGtB,IAAIjG,YAAYA,aAAazY,KAAKmtB,kBAAkB;wBAChDe,aAAaluB,KAAK6sB,kBAAkBpU;;oBAIxCyV,WAAWxkB,WAAW;oBAGtB,IAAIwkB,WAAW1E,WAAWtR,gBAAgB,MAAM;wBAC5CgW,WAAW1E,WAAWtR,cAAc+V;2BAEnC;wBACDC,WAAW1E,WAAWtR,eAAe,MAAM+V;;oBAI/CtuB,GAAG+C,KAAK1C,KAAKsjB,UAAU,SAAS3gB,KAAK4gB;wBACjC,IAAIA,OAAO9J,kBAAkBhB,UAAU;4BACnC8K,OAAO3K,YAAYsV,WAAWxkB;4BAC9B6Z,OAAO1J,eAAeqU,WAAWhW;4BAEjC,OAAO;;;;;YAMvB8P,wBAAwB,SAASmG;gBAC7B,IAAIpW,OAAO/X,MACPouB,iBAAiBD,QAAQ/e;gBAE7B,IAAIzP,GAAGkX,iBAAiBuX,iBAAiB;oBACrCpuB,KAAK8F,IAAIqoB,QAAQzsB,OAAO,oBAAoBysB,QAAQzsB,OAAO,kCAAkCysB,QAAQhG;oBACrG,OAAOiG,eAAerX,KAClB,SAASsX;wBACLtW,KAAKjS,IAAIqoB,QAAQzsB,OAAO,0BAA0BysB,QAAQhG;wBAC1DgG,QAAQ7W,UAAU+W;uBAEtB;wBACI,IAAIF,QAAQ5W,WAAW;4BACnBQ,KAAKjS,IAAIqoB,QAAQzsB,OAAO,0BAA0BysB,QAAQhG;4BAC1DgG,QAAQ5W;+BAEP;4BACDQ,KAAKjS,IAAIqoB,QAAQzsB,OAAO,0BAA0BysB,QAAQhG;;;;gBAK1E,IAAIiG,mBAAmB,OAAO;oBAC1BD,QAAQ7W,UAAU8W;uBAEjB;oBACD,IAAID,QAAQ5W,WAAW;wBACnBvX,KAAK8F,IAAIqoB,QAAQzsB,OAAO,qCAAqCysB,QAAQhG,aAAa;wBAClFgG,QAAQ5W;2BAEP;wBACDvX,KAAK8F,IAAIqoB,QAAQzsB,OAAO,qCAAqCysB,QAAQhG,aAAa;;;gBAI1F,OAAOiG;;YAIX3P,gBAAgB,SAASc,MAAM9D,SAAS6S;gBACpC,IAAIvW,OAAO/X,MACP2a,OAAOhb,GAAGoN,eACVyO,QAAQ,GACR9Z,OAAO/B,GAAGmS,YAAYyN,OACtBgP,aAAahP,KAAKnU,QAAQmU,MAC1BiP,UAAUxuB,KAAKyuB,wBACXzuB,KAAKyuB,wBACL9uB,GAAGgQ,KAAKoI,KAAK2W,uBAAuB3W;gBAE5C,KAAKpY,GAAGiJ,QAAQ2lB,eAAeA,WAAW/S,QAAQ,GAAG;oBACjDA,OAAO+S,WAAW/S;;gBAGtBgT,QAAQD,YAAY7sB,MAAMiZ,MAAMa,MAAM8S,oBAAoB7S,SAASzb,KAAK0e,SAASsI,QAAQC;oBACrF/G,YAAYnI,KAAKoI;oBACjBgH,aAAapP,KAAKyL;oBAClBmL,kBAAkB,SAASnU,IAAI+E;wBAC3BxH,KAAK6H,SAASrP,IAAIiK,IAAI+E;wBACtBxH,KAAK8K;wBACL9K,KAAK6W,aAAapU;;;;YAK9BkU,uBAAuB,SAASnP,MAAM7d,MAAMiZ,MAAMa,MAAMqT,UAAUpT;gBAC9D,IAAIjB,KAAKxa,KAAKmgB,YAAY/E;oBAAST,MAAMA;oBAAMjZ,MAAMA;oBAAM8Z,MAAMA;oBAAMC,SAASA;;gBAEhFzb,KAAK4f,SAASrP,IAAIiK,IAAI+E;gBACtBvf,KAAK4uB,aAAapU;gBAElBxa,KAAK6iB;gBAELgM,SAAShsB;oBAAM2X,IAAIA;oBAAI+E,MAAMA;;;YAGjC2I,qBAAqB,SAAS9c,MAAM0jB;gBAChC,IAAIC,YAAY3jB,KAAKlL,KAAKmF,MAAM,KAAK,IACjC3D,OAAOotB;gBAGX,IAAIptB,QAAQ,MAAM;oBACdA,OAAO1B,KAAK0e,SAASoJ,MAAMlJ;;gBAG/Bld,QAAQ,MAAMqtB;gBAEd/uB,KAAKge;oBACDtc,MAAMA;oBACN0J,MAAMA;;;YAId4jB,sBAAsB,SAASxU;gBAC3B,IAAIxa,KAAKqiB;oBAAY7H,IAAIA;mBAAKK,WAAWlb,GAAGkb,OAAO6C,SAAS;oBACxD,IAAIhc,OAAO1B,KAAKqgB,QAAQ7F;oBAExBxa,KAAK6iB;oBACL7iB,KAAKyiB;oBACLziB,KAAK4f,SAASsD,QAAQ1I;oBACtBxa,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAO6C;oBACzC1d,KAAK8F,IAAI,yBAAyBpE,OAAO;;;YAIjDutB,qBAAqB,SAASzU,IAAIiN;gBAC9B,IAAI/lB,OAAO1B,KAAKqgB,QAAQ7F;gBAExBxa,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAO2C;gBACzCxd,KAAK8F,IAAI,yBAAyBpE,OAAO,iBAAiB;gBAK1D,KAAK+lB,YAAYA,SAASlT,oBAAoBzQ,WAAW;oBACrD9D,KAAK0e,SAAS8H,UAAUC,QAAQjM,IAAI9Y,MAAM,yBAAyB+lB;uBAElE;oBACDznB,KAAK0e,SAAS8H,UAAUC,QAAQjM,IAAI9Y,MAAM,8CAA8C+lB,SAAS5M,QAAQ4M;;;YAKjHwF,kBAAkB,SAAS5R;gBACvB,IAAIkI,SAASvjB,KAAKspB;oBACdC,QAAQlO,KAAKmO,WAAWtR;oBACxBuR,mBAAmBpO,KAAKmO,WAAWC;oBACnC7pB,SAASyb,KAAKzb;oBACdwY,SAASiD,KAAKjD;oBACd1O,UAAU2R,KAAK3R;oBACf8O,OAAO6C,KAAK+O;;gBAGhBpqB,KAAK6sB,kBAAkBtJ,OAAO9J,iBAAiB4B;;YAGnD6T,2BAA2B;gBACvBlvB,KAAKmvB,eAAexvB,GAAGyvB,eAAe,IAAIzvB,GAAGyvB,YACzCpvB,KAAK0e,SAASzN,MAAMtR,GAAGgQ,KAAK3P,KAAK2lB,mBAAmB3lB,OAAOL,GAAGgQ,KAAK3P,KAAK8F,KAAK9F;gBAGjF,IAAIA,KAAKmvB,gBAAgBnvB,KAAKmvB,aAAaE,gBAAgB;oBACvDrvB,KAAKwjB,eAAexjB,KAAKooB,aACrBpoB,KAAK0e,SAASsI,QAAQlJ,QAAS9d,KAAKmvB,aAAaG;oBAGrDtvB,KAAK0e,SAAS6Q,aAAavvB,KAAKmvB,aAAaK;oBAC7C,IAAIxvB,KAAKmvB,aAAaM,aAAa;wBAC/BzvB,KAAK0e,SAASsI,QAAQjJ,WAAW/d,KAAKmvB,aAAaM;;uBAGtD;oBACDzvB,KAAKwjB,eAAexjB,KAAKooB,aAAapoB,KAAK0e,SAASsI,QAAQlJ;;;YAIpE4R,mBAAmB;gBACf,KAAK/vB,GAAGgnB,4BAA4B3mB,KAAK0e,SAAS6B,WAAWH,SAAS;oBAClE,OAAO;;gBAGX,IAAIpgB,KAAK0e,SAAS2I,KAAKsI,UAAU;oBAC7B,IAAIhwB,GAAGkT,kBAAkB4C,mBAAmB;wBACxC,OAAO;;oBAGX,IAAI9V,GAAGkT,kBAAkB2C,qBAAqBxV,KAAK0e,SAAS2I,KAAKuI,UAAU;wBACvE,OAAO;;oBAGX,OAAO;;gBAGX,OAAO;;YAGX/F,qBAAqB,SAASgG,SAAS7d;gBACnC,IAAI8d,QAAQ;gBAEZ,KAAKD,QAAQnqB,QAAQ;oBACjB,OAAO;;gBAGX/F,GAAG+C,KAAKmtB,SAAS,SAASltB,KAAKotB;oBAK3B,IAAIpwB,GAAGwH,SAAS4oB,aAAa;wBAEzB,IAAIC,WAAW,IAAInuB,OAAO,QAAQkuB,aAAa,KAAK;wBAEpD,IAAI/d,SAASmC,MAAM6b,aAAa,MAAM;4BAClCF,QAAQ;4BACR,OAAO;;;;gBAKnB,OAAOA;;YAWXlK,YAAY,SAASqK,MAAMC,kBAAkBjpB;gBACzC,IAAIlB,UAAU/F,KAAK0e,SAASyR,SAASF,OACjCxG,wBACA2G,WAAWrgB,OAAOmgB,mBAClBxuB,OAAO0uB,MAAM,IACb3X,WAAWzY,KAAKsmB,aAAarf,OAC7BopB,iBAAiBrwB,KAAKytB,mBAAmBhV,WACzC6X,sBAAsBC;gBAE1B,SAAStjB,EAAEvL,MAAM8uB;oBAAezqB,UAAUA,QAAQ7D,QAAQR,MAAM8uB;;gBAEhE7wB,GAAG+C,KAAK2tB,eAAe5G,mBAAmB,SAAS9mB,KAAK8tB;oBAKpD,IAAI9wB,GAAGwH,SAASspB,mBAAmB;wBAC/BhH,kBAAkB5mB,KAAK4tB;;;gBAI/BH,uBAAuB7G,kBAAkB7Y,KAAK,MAAM3H;gBAEpDgE,EAAE,UAAUjN,KAAK0e,SAASgS,eAAehvB;gBACzCuL,EAAE,gBAAgBqjB;gBAClBrjB,EAAE,eAAejN,KAAKwsB,YAAY6D,eAAeM;gBACjD1jB,EAAE,kBAAkBjN,KAAKwsB,YAAY6D,eAAeO;gBAEpDL,mBAAmBxqB,QAAQoO,MAAM;gBACjC,IAAIoc,qBAAqB,MAAM;oBAC3B5wB,GAAG+C,KAAK6tB,kBAAkB,SAAS5tB,KAAKkuB;wBACpC5jB,EAAE4jB,aAAaT,MAAMztB;;;gBAI7B3C,KAAK0e,SAAS8H,UAAUC,QAAQ,MAAM/kB,MAAMqE,SAASjC;gBAErD,OAAOiC;;YAYXke,cAAc,SAASzJ,IAAIpL;gBACvB,IAAIpP,KAAK8wB,qBAAqBtW,KAAK;oBAC/Bxa,KAAK6iB;oBACL7iB,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOwC;oBAEzC,IAAIjO,UAAU;wBACVA,SAASoL;2BAER;wBACDxa,KAAK4f,SAASoE,MAAMxJ;;oBAGxB,OAAO;;;YAIf4O,mBAAmB,SAAS5O,IAAIK;gBAC5B,IAAI9C,OAAO/X,MACP+wB,cAAc/wB,KAAKwtB;gBAEvB,IAAI3S,WAAWlb,GAAGkb,OAAOyC,mBAAmB;oBACxCtd,KAAK6jB,+BAA+BhhB,KAAK2X;uBAExC,IAAIK,WAAWlb,GAAGkb,OAAO0C,eAAe;oBACzCvd,KAAK8jB,4BAA4BjhB,KAAK2X;;gBAG1C,IAAIuW,gBAAgB,MACf/wB,KAAK6jB,+BAA+Bne,UAAU1F,KAAK8jB,4BAA4Bpe,SAAS;oBAEzF2jB,WAAW;wBACPtR,KAAKiZ,eAAejZ,KAAK8L,gCAAgC9L,KAAK+L;uBAC/D;;;YAIXzF,kCAAkC;gBAC9B,IAAItG,OAAO/X;gBAEX,IAAIA,KAAK0e,SAASiL,YAAYsH,qBAAqBtxB,GAAG6O,YAAY7O,GAAG+O,aAAa;oBAC9E2a,WAAW;wBACP1kB,OAAOusB,MAAMnZ,KAAK2G,SAASyR,SAASgB;uBACrC;oBACH,MAAM,IAAIxxB,GAAGwB,MAAMnB,KAAK0e,SAASyR,SAASgB;;;YAIlDC,+BAA+B,SAAS5W,IAAI9Y,MAAM2vB,UAAU/c;gBAGxD,KAAK+c,SAASzlB,SAAS;oBACnB,IAAI0I,OAAOA,IAAIuG,WAAW,QAAQwW,SAASrnB,OAAO;wBAC9ChK,KAAK0e,SAAS8H,UAAUC,QAAQjM,IAAI9Y,MAAM,gCAAgC4S,IAAIuG,QAAQvG;2BAErF;wBACD,IAAIgd,cAAcD,SAASrnB,QAAQqnB,SAASrnB,QAAQhK,KAAK0e,SAASrb,KAAKkuB;wBACvEvxB,KAAK0e,SAAS8H,UAAUC,QAAQjM,IAAI9Y,MAAM4vB,aAAahd;;;;YAKnEkd,8CAA8C,SAASC,WAAWtnB,OAAO6Q,OAAO8C,QAAQC;gBACpF,IAAIhG,OAAO/X;gBAEX,IAAImK,MAAMzE,SAASsV,OAAO;oBACtB,IAAIyW,cAAczxB,KAAK0e,SAAS8K,WAAWkI,wBAAwB;wBAE/DrI,WAAW;4BACP,IAAIsI,uBAAuB5Z,KAAK2V,yBAAyBvjB,MAAM6Q,SAC3DvC,WAAWV,KAAKuO,aAAanc,MAAM6Q,OAAOuE,OAC1CgE,SAASxL,KAAK8J,WAAWpJ;4BAE7BV,KAAKiQ;gCACDtmB,MAAM;gCACN0N,UAAUzP,GAAGgQ,KAAKoI,KAAK2G,SAAS8H,UAAUoL,YAAY7Z,MAAM4Z,sBAAsBpO;gCAClFjM,WAAW3X,GAAGgQ,KAAKoI,KAAK8Z,4BAA4B9Z,MAAM5N,OAAO6Q,OAAO8C,QAAQC;gCAChFxG,WAAW5X,GAAGgQ,KAAKoI,KAAK+Z,4BAA4B/Z,MAAM5N,OAAO6Q,OAAO8C,QAAQC;gCAChFoK,YAAY,WAAWwJ,qBAAqBjwB,OAAO,cAAciwB,qBAAqBnW;;2BAE3F;2BAEF,KAAKiW,WAAW;wBACjB,MAAOzW,QAAQ7Q,MAAMzE,QAAQsV,SAAS;4BAClCjD,KAAKwU,oBAAoBpiB,MAAM6Q,OAAOR;;;;;YAMtDwW,gBAAgB,SAASe,YAAYC;gBACjChyB,KAAK+jB,kBAAkB/jB,KAAK+jB,eAAekO,cAAcF,YAAYC,QAAQhyB,KAAKqjB;gBAElFrjB,KAAK0e,SAAS8H,UAAUyL,cAActyB,GAAG6B,WAAWuwB,aAAapyB,GAAG6B,WAAWwwB;gBAE/EhyB,KAAK6jB;gBACL7jB,KAAK8jB;;YAeTkI,cAAc,SAASxR,IAAI9Y,MAAMqqB,cAAczX,KAAKlF;gBAChD,IAAI2I,OAAO/X;gBAEX+X,KAAKsL,gBAAgB7I,MAAMuR,aAAahU,KAAK2G,SAASsF,MAAM2G;gBAE5D,IAAI5S,KAAKma,iBAAiB1X,IAAI9Y,MAAMqqB,eAAe;oBAC/C,IAAIoG,kBAAkBpa,KAAK2G,SAASsF,MAAMoO,mBAAmB;oBAE7Dra,KAAKqZ,8BAA8BphB,MAAM+H,MAAMjQ;oBAC/CiQ,KAAK2G,SAAS8H,UAAUsF,YAAYtR,IAAI9Y,MAAMqW,KAAKoL,aAAa3I;oBAChEzC,KAAKsa,mBAAmB7X,IAAI9Y;oBAE5BqW,KAAKoI,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOwC;oBACzCtF,KAAKqL,eAAe5I,MAAM6O,WAAW;wBACjCtR,KAAKjS,IAAI,wBAAwBpE,OAAO;wBAExC,IAAI0N,UAAU;4BACVA,SAASoL;+BAER;4BACDzC,KAAK6H,SAASoE,MAAMxJ;;uBAEzB2X;oBAEH,OAAO;;;YAIfE,oBAAoB,SAAS7X,IAAI9Y;gBAC7B1B,KAAK8F,IAAI,aAAa9F,KAAK0e,SAASsF,MAAMoO,mBAAmB,8BAA8B1wB,OAAO;;YAItGovB,sBAAsB,SAAStW;gBAC3B,IAAI8X,YAAYtyB,KAAK4iB,mBACjB5Q;gBAEJ,IAAIhS,KAAKqjB,gBAAgB7I,KAAK;oBAC1Bxa,KAAK8F,IAAI,kCAAkC0U,IAAI;oBAC/C,OAAO;uBAEN,IAAIxa,KAAK4f,SAASe,QAAQnG,KAAK;oBAChCxI,WAAWhS,KAAKqgB,QAAQ7F;oBAExB,IAAIxa,KAAK0e,SAAS8H,UAAU+L,cAAc/X,IAAIxI,cAAc,OAAO;wBAC/D,OAAO;;oBAGX,IAAIsgB,YAAY,KAAKtyB,KAAK6iB,uBAAuB,IAAIyP,WAAW;wBAC5DtyB,KAAK4lB,WAAW;wBAChB,OAAO;;oBAGX5lB,KAAK8F,IAAI,0BAA0BkM,WAAW,YAAYwI,KAAK;oBAC/D,OAAO;uBAEN;oBACDxa,KAAK8F,IAAI,MAAM0U,KAAK,4BAA4B;oBAChD,OAAO;;;YAIf4Q,WAAW,SAAS5Q,IAAI9Y;gBACpB1B,KAAK6iB;gBAEL2P,aAAaxyB,KAAKojB,eAAe5I;gBAEjC,IAAIiY,kBAAkB9yB,GAAG2F,QAAQtF,KAAKse,YAAY9D;gBAClD,KAAKxa,KAAK0e,SAAS6Q,cAAckD,mBAAmB,GAAG;oBACnDzyB,KAAKse,WAAWpC,OAAOuW,iBAAiB;;gBAG5CzyB,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOqC;;YAG7C+N,aAAa,SAASzQ,IAAI9Y,MAAMY,QAAQgS;gBACpC,KAAKhS,OAAOsJ,SAAS;oBACjB5L,KAAK6iB;oBACL7iB,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAO0C;oBAEzC,IAAIjb,OAAOtC,KAAK0e,SAASsF,MAAM2G,kCAAkC,MAAM;wBACnE3qB,KAAKqjB,gBAAgB7I,MAAM;;uBAG9B;oBACD,IAAIlY,OAAO4jB,cAAc;wBACrBlmB,KAAKqhB,eAAe7G,MAAMlY,OAAO4jB;;oBAGrClmB,KAAKyiB;oBACLziB,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOyC;;gBAG7Ctd,KAAKoxB,8BAA8B5W,IAAI9Y,MAAMY,QAAQgS;gBAErD,OAAOhS,OAAOsJ,UAAU,OAAO;;YAGnC2b,WAAW,SAAS/M;gBAChBxa,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAO4C;;YAG7CgI,mBAAmB,SAASjL,IAAIiN,UAAUC;gBACtC,IAAIhmB,OAAO1B,KAAKqgB,QAAQ7F;gBAExB,IAAIkN,SAAS;oBACT1nB,KAAKivB,oBAAoBzU,IAAIiN;uBAE5B;oBACDznB,KAAKgvB,qBAAqBxU;;;YAIlC2P,gBAAgB,SAAS5gB;gBACrB,IAAImpB;gBAEJ,IAAI/yB,GAAGkT,kBAAkBsC,eAAe;oBACpC,KAAKud,YAAY,GAAGA,YAAYnpB,MAAM+V,MAAM5Z,QAAQgtB,aAAa;wBAC7D1yB,KAAKmmB,sBAAsB5c,MAAM+V,MAAMoT,YAAYnpB;;oBAGvDvJ,KAAKge,SAASzU,MAAM+V;uBAGnB,IAAI/V,MAAM7C,MAAMhB,SAAS,GAAG;oBAC7B1F,KAAKge,SAASzU;;gBAGlB5J,GAAG+C,KAAK1C,KAAKsjB,UAAU,SAAS3gB,KAAK4gB;oBACjCA,OAAOzJ;;;YAIfiR,aAAa,SAASvQ,IAAI9Y,MAAMmpB,QAAQC;gBACpC9qB,KAAK+jB,kBAAkB/jB,KAAK+jB,eAAe4O,qBAAqBnY,IAAIqQ,QAAQC;;YAGhF8H,WAAW,SAASpY,IAAI9Y;YAIxBmxB,0BAA0B,SAASrY,IAAI9Y;gBACnC1B,KAAK4yB,UAAU5iB,MAAMhQ,MAAM8H;gBAC3B9H,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOkC;gBACzC/c,KAAK8yB,aAAa9iB,MAAMhQ,MAAM8H;gBAE9B,IAAI9H,KAAK0e,SAAS6Q,YAAY;oBAC1BvvB,KAAK0e,SAAS8H,UAAUuM,YAAY/iB,MAAMhQ,MAAM8H;oBAChD9H,KAAKsgB,YAAY9F;uBAEhB;oBACDxa,KAAKgzB,eAAexY;oBACpBxa,KAAK0e,SAAS8H,UAAUuM,YAAY/iB,MAAMhQ,MAAM8H;;;YAIxD0Y,iBAAiB,SAAShG,IAAIyY,mBAAmBC;gBAC7C,IAAIvY,OAAO3a,KAAK8iB,QAAQtI,KACpB2Y;gBAEJ,IAAIF,mBAAmB;oBACnBE,4BAA4BxzB,GAAGgQ,KAAKsjB,mBAAmBjzB,MAAMwa,IAAIG,MAAMuY;;gBAG3E,IAAIlzB,KAAK0vB,qBAAqB;oBAC1B1vB,KAAKgoB;wBACDtmB,MAAM;wBACN0N,UAAUzP,GAAGgQ,KAAK3P,KAAK0e,SAAS8H,UAAU4M,gBAAgBpzB,MAAMwa;wBAChElD,WAAW6b,6BACPxzB,GAAGgQ,KAAK3P,KAAKqzB,eAAeC,YAAYtzB,MAAMwa,IAAIG,MAAMuY;wBAC5D/K,YAAY3N;;oBAEhB,OAAO;uBAEN;oBACDxa,KAAK8F,IAAI,mCAAmC0U,KAAK,0DAC7C,oEAAoE;oBACxE,OAAO;;;YAIfsY,cAAc,SAAStY;YAIvB+Y,kBAAkB,SAAS1I,QAAQC;gBAC/B9qB,KAAK0e,SAAS8H,UAAUgN,gBAAgB3I,QAAQC;;YAGpDQ,eAAe,SAAS9Q;YAIxBgR,WAAW,SAAShR,IAAI9Y;gBACpB1B,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOuC;;YAG7CuO,gBAAgB,SAASnR,IAAIkR;YAI7BvC,uBAAuB,SAAS3O,IAAIwB,WAAWD;gBAE3C,IAAIA,cAAcpc,GAAGkb,OAAOsC,QAAQ;oBAChCqV,aAAaxyB,KAAKojB,eAAe5I;;;YAIzCiZ,iCAAiC,SAAS5F;gBACtC,IAAI9V,OAAO/X;gBAEXL,GAAG+C,KAAKmrB,cAAc,SAASlrB,KAAKgrB;oBAChC5V,KAAKwU,oBAAoBoB,YAAYnT;;;YAI7CkZ,iCAAiC,SAASC,uBAAuBxpB,OAAO2T,QAAQC,UAAUwF;gBACtF,IAAImC,cACA4M,YAAYtyB,KAAK4iB,mBACjBgR,mCAAmC5zB,KAAK6iB;gBAE5C,IAAIyP,cAAc,KAAKsB,oCAAoCtB,WAAW;oBAClE,IAAInoB,MAAMzE,SAAS,GAAG;wBAClB1F,KAAKgoB;4BACDtmB,MAAM;4BACN0N,UAAUzP,GAAGgQ,KAAK3P,KAAK0e,SAAS8H,UAAUoL,YAAY5xB,MAAM2zB,sBAAsB,IAAIpQ;4BACtFjM,WAAW3X,GAAGgQ,KAAK3P,KAAK6xB,4BAA4B7xB,MAAMmK,OAAO,GAAG2T,QAAQC;4BAC5ExG,WAAW5X,GAAGgQ,KAAK3P,KAAK8xB,4BAA4B9xB,MAAMmK,OAAO,GAAG2T,QAAQC;4BAC5EoK,YAAY,WAAWhe,MAAM,GAAGoV,KAAK7d,OAAO,cAAcyI,MAAM,GAAGoV,KAAK/D;;2BAG3E;wBACDxb,KAAK4lB,WAAW;;uBAGnB;oBACD5lB,KAAKyzB,gCAAgCtpB;oBACrCub,eAAe1lB,KAAK0e,SAASyR,SAAS0D,kBACjC3xB,QAAQ,iBAAiB0xB,kCACzB1xB,QAAQ,kBAAkBowB;oBAC/BtyB,KAAKumB,YAAYb;;;YAIzBoM,4BAA4B,SAAS3nB,OAAO6Q,OAAO8C,QAAQC;gBACvD,IAAI+V,YAAY9Y,QAAQ;gBAExBhb,KAAKusB,oBAAoBpiB,MAAM6Q,OAAOR,IAAIrQ,MAAM6Q,OAAOuE,KAAK7d;gBAE5D1B,KAAKwxB,6CAA6C,OAAOrnB,OAAO2pB,WAAWhW,QAAQC;;YAGvF8T,4BAA4B,SAAS1nB,OAAO6Q,OAAO8C,QAAQC;gBACvD,IAAIhG,OAAO/X,MACP8zB,YAAY9Y,QAAQ,GACpB2W,uBAAuB3xB,KAAK0tB,yBAAyBvjB,MAAM6Q;gBAE/Dhb,KAAK+zB,wBAAwB5pB,MAAM6Q,QAAQ2W,sBACtC5a,KACD;oBACIgB,KAAKic,QAAQ7pB,MAAM6Q,OAAOR,IAAIsD,QAAQC;oBACtChG,KAAKyZ,6CAA6C,MAAMrnB,OAAO2pB,WAAWhW,QAAQC;mBAEtF;oBACIhG,KAAKyZ,6CAA6C,OAAOrnB,OAAO2pB,WAAWhW,QAAQC;;;YAK/F2B,wBAAwB,SAASvV,OAAO2T,QAAQC;gBAC5C,IAAI5T,MAAMzE,WAAW,GAAG;oBACpB1F,KAAK4lB,WAAW;oBAChB;;gBAGJ,IAAI+N,wBAAwB3zB,KAAK4tB,0BAA0BzjB,QACvDsO,WAAWzY,KAAKsmB,aAAanc,MAAM,GAAGoV,OACtCgE,SAASvjB,KAAK6hB,WAAWpJ;gBAE7BzY,KAAKgoB;oBACDtmB,MAAM;oBACN0N,UAAUzP,GAAGgQ,KAAK3P,KAAK0e,SAAS8H,UAAUyN,iBAAiBj0B,MAAM2zB,uBAAuBpQ;oBACxFjM,WAAW3X,GAAGgQ,KAAK3P,KAAK0zB,iCAAiC1zB,MAAM2zB,uBAAuBxpB,OAAO2T,QAAQC,UAAUwF;oBAC/GhM,WAAW5X,GAAGgQ,KAAK3P,KAAKyzB,iCAAiCzzB,MAAMmK;oBAC/Dge,YAAY;;;YAIpB+L,yBAAyB;gBACrB,IAAInc,OAAO/X;gBAEXA,KAAKqqB,gBAAgBpqB,OAAO0E,QAAQ,gBAAgB,SAASkK;oBACzD,IAAIkJ,KAAKmK,iBAAiB;wBACtBrT,IAAIA,KAAKlK,OAAOwvB;wBAEhBtlB,EAAEC,cAAciJ,KAAK2G,SAASyR,SAASiE;wBAEvC,OAAOrc,KAAK2G,SAASyR,SAASiE;;;;YAQ1CxQ,qBAAqB;gBACjB,IAAI7L,OAAO/X,MACPiY,UAAUjY,KAAK0e,SAASgF;gBAG5B,IAAI/jB,GAAG00B,WAAWr0B,KAAK0e,SAASgF,QAAQ3F,YAAY,MAAM;oBACtD,KAAK/d,KAAKs0B,UAAU;wBAChB30B,GAAG6B,OAAOyW;4BAAUoP,MAAMrnB,KAAK0e,SAAS2I;;wBAExCpP,QAAQnS,MAAMnG,GAAGgQ,KAAK3P,KAAK8F,KAAK9F;wBAChCiY,QAAQsc,gBAAgB50B,GAAGgQ,KAAK3P,KAAKoe,gBAAgBpe;wBAErDA,KAAKs0B,WAAW,IAAI30B,GAAG00B,QAAQpc;;oBAGnCoR,WAAW;wBACPtR,KAAKuc,SAASE,UAAUzd,KAAK,SAASsa,UAAU5J;4BAC5C1P,KAAK0c;4BACL1c,KAAK2G,SAAS8H,UAAUkO,yBAAyBrD,UAAU,MAAM5J;2BAElE,SAAS4J,UAAU5J;4BAElB1P,KAAK2G,SAAS8H,UAAUkO,yBAAyBrD,UAAU,OAAO5J;;uBAEvE;;;YAIXgN,yBAAyB;YAEzBtI,UAAU,SAAS3R,IAAIiC;gBACnBzc,KAAKmgB,YAAY3D,WAAWhC,IAAIiC;gBAChCzc,KAAK+jB,kBAAkB/jB,KAAK+jB,eAAe4Q,UAAUna;;YAGzD0X,kBAAkB,SAAS1X,IAAI9Y,MAAMqqB;gBACjC,IAAI7L,aAAalgB,KAAKmgB,YAAYvE;oBAAUpB,IAAIA;;gBAGhD,KAAKxa,KAAKqjB,gBAAgB7I,OACnBxa,KAAK0e,SAASsF,MAAM4Q,cACpB1U,WAAWrF,WAAWlb,GAAGkb,OAAOsC,QAAQ;oBAE3C,IAAInd,KAAKmjB,aAAa3I,QAAQ1W,WAAW;wBACrC9D,KAAKmjB,aAAa3I,MAAM;;oBAG5B,IAAIxa,KAAKmjB,aAAa3I,MAAMxa,KAAK0e,SAASsF,MAAM6Q,iBAAiB;wBAC7D70B,KAAKmjB,aAAa3I,OAAO;wBACzB,OAAO;;;gBAIf,OAAO;;YAGXwY,gBAAgB,SAASxY;gBACrBxa,KAAKse,WAAWzb,KAAK2X;;YAIzBoU,cAAc,SAASpU;gBACnB,IAAI/B;gBAEJ,IAAI9Y,GAAGkT,kBAAkBsC,eAAe;oBACpCsD,WAAWzY,KAAK4f,SAAS2B,QAAQ/G,IAAI6L;uBAEpC;oBACD5N,WAAWzY,KAAKsmB,aAAatmB,KAAK4f,SAASpG,SAASgB;;gBAGxD,IAAI/B,UAAU;oBACVzY,KAAK8hB,qBAAqBtH,MAAM/B;;;YAIxCyM,6BAA6B,SAAS4P;gBAClC90B,KAAK0e,SAASzN,KAAKrR,UAAUk1B;gBAE7B90B,KAAKmvB,eAAexvB,GAAGyvB,eAAe,IAAIzvB,GAAGyvB,YACrCpvB,KAAK0e,SAASzN,MAAMtR,GAAGgQ,KAAK3P,KAAK2lB,mBAAmB3lB,OAAOL,GAAGgQ,KAAK3P,KAAK8F,KAAK9F;gBAGrF,IAAIA,KAAKmvB,gBAAgBnvB,KAAKmvB,aAAaE,gBAAgB;oBACvDrvB,KAAKwjB,aAAayF,YAAY,MAAMjpB,KAAKmvB,aAAaG;oBAEtDtvB,KAAK0e,SAAS6Q,aAAavvB,KAAKmvB,aAAaK;oBAC7C,IAAIxvB,KAAKmvB,aAAaM,aAAa;wBAC/BzvB,KAAK+kB,YAAY/kB,KAAKmvB,aAAaM;;;;YAK/CuE,SAAS,SAASxZ,IAAIsD,QAAQC;gBAC1B,IAAIrc,OAAO1B,KAAKqgB,QAAQ7F;gBAExB,IAAIsD,QAAQ;oBACR9d,KAAKslB,UAAUxH,QAAQtD;;gBAG3B,IAAIuD,UAAU;oBACV/d,KAAK+kB,YAAYhH,UAAUvD;;gBAG/Bxa,KAAKgoB;oBACDtmB,MAAM;oBACN0N,UAAUzP,GAAGgQ,KAAK3P,KAAK0e,SAAS8H,UAAUuO,UAAU/0B,MAAMwa,IAAI9Y;oBAC9D4V,WAAW3X,GAAGgQ,KAAK3P,KAAK6yB,0BAA0B7yB,MAAMwa,IAAI9Y;oBAC5D6V,WAAW5X,GAAGgQ,KAAK3P,KAAKusB,qBAAqBvsB,MAAMwa,IAAI9Y;oBACvDymB,YAAY3N;;;YAIpB8F,aAAa,SAAS9F;gBAClB,KAAKxa,KAAK4f,SAAS/V,OAAO2Q,KAAK;oBAC3Bxa,KAAKmgB,YAAYrE,UAAUtB,IAAI7a,GAAGkb,OAAOoC;;;YAIjD4I,oBAAoB;gBAChB,IAAImP,YAAYC,iBACZld,OAAO/X;gBAEX,OAAOA,KAAKse,WAAW5Y,QAAQ;oBAC3BsvB,aAAah1B,KAAKse,WAAWjM;oBAC7BrS,KAAKsgB,YAAY0U;;gBAIrBC,kBAAkBj1B,KAAKqiB;oBAAYxH,QAAQlb,GAAGkb,OAAOS;mBAAa5V;gBAClE,IAAIuvB,iBAAiB;oBACjBt1B,GAAGmG,IAAI,uBAAuBmvB,kBAAkB;oBAChD5L,WAAW;wBACPtR,KAAK8N;uBACN;;;YAYXkO,yBAAyB,SAASpG,aAAagE;gBAC3C,IAAI5Z,OAAO/X,MACPuf,OAAQ;oBACJ,IAAIoO,YAAYpO,gBAAgB5f,GAAG8X,WAAW;wBAC1C,OAAOkW,YAAYpO,KAAK7H;;oBAE5B,OAAOiW,YAAYpO;qBAEvB7d,OAAOiwB,qBAAqBjwB,MAC5B8Z,OAAOmW,qBAAqBnW,MAC5B/C,WAAWzY,KAAKsmB,aAAaqH,YAAYpO,OACzC8Q,iBAAiBrwB,KAAKytB,mBAAmBhV,WACzCyc,kBAAkB,IAAIv1B,GAAG+L;gBAE7BwpB,gBAAgBne,KACZ,eACA;oBACIgB,KAAKwU,oBAAoBoB,YAAYnT,IAAI9Y;;gBAGjD,IAAI/B,GAAG+I,cAAc6W,UAAUvf,KAAK6pB,oBAAoBwG,eAAe5G,mBAAmB/nB,OAAO;oBAC7F1B,KAAK4lB,WAAW,aAAalkB,MAAM6d;oBACnC,OAAO2V,gBAAgBppB;;gBAG3B,KAAK9L,KAAK0e,SAAS8K,WAAW2L,cAAc3Z,SAAS,GAAG;oBACpDxb,KAAK4lB,WAAW,cAAclkB,MAAM6d;oBACpC,OAAO2V,gBAAgBppB;;gBAG3B,IAAI0P,OAAO,KAAK6U,eAAeM,aAAanV,OAAO6U,eAAeM,WAAW;oBACzE3wB,KAAK4lB,WAAW,aAAalkB,MAAM6d;oBACnC,OAAO2V,gBAAgBppB;;gBAG3B,IAAI0P,OAAO,KAAKA,OAAO6U,eAAeO,cAAc;oBAChD5wB,KAAK4lB,WAAW,gBAAgBlkB,MAAM6d;oBACtC,OAAO2V,gBAAgBppB;;gBAG3B,IAAInM,GAAGy1B,mBAAmBz1B,GAAGkT,kBAAkBkD,iBAAiBpW,GAAGyI,OAAOmX,OAAO;oBAC7E,IAAI5f,GAAGy1B,gBAAgB7V,MAAM5f,GAAGgQ,KAAKoI,KAAKjS,KAAKiS,OAAOsd,SAAShF,eAAeiF,OAAOve,KACjFme,gBAAgBtpB,SAChB,SAAS2pB;wBACLxd,KAAK6N,WAAW2P,YAAY,cAAc7zB,MAAM6d;wBAChD2V,gBAAgBppB;;uBAIvB;oBACDopB,gBAAgBtpB;;gBAGpB,OAAOspB;;YAGXM,gBAAgB;gBACZ,IAAIzd,MAAM0d,cAAcvpB;gBAExB6L,OAAO/X;gBAEPy1B,eAAe,SAAS/zB,MAAM0N,UAAUzH;oBACpC,IAAI+tB;oBAEJ;wBACI,OAAOtmB,SAASY,MAAM+H,MAAMpQ;sBAEhC,OAAOguB;wBACHD,WAAWC,UAAU5vB,WAAW4vB,UAAUrvB;wBAC1CyR,KAAKjS,IAAI,0BAA0BpE,OAAO,kBAAkBg0B,UAAU;;;gBAK9E,KAAKxpB,QAAQlM,KAAK0e,SAAS8H,WAAW;qBACjC;wBACG,IAAIoP,cAAcC;wBAClBD,eAAe1pB;wBACf2pB,eAAe9d,KAAK2G,SAAS8H,UAAUoP;wBACvC7d,KAAK2G,SAAS8H,UAAUoP,gBAAgB;4BACpC,OAAOH,aAAaG,cAAcC,cAAc/tB;;;;;;;KCh3DvE;QACG;QAEAnI,GAAGm2B,oBAAoB,SAAShe;YAC5B,IAAIC,OAAO/X;YAGXA,KAAK0e;gBACDqE,OAAO;gBACPQ,QAAQ;gBACR7Z,UAAU;gBACVod,gBAAgB;gBAChBiP,6BAA6B;gBAC7BxG,YAAY;gBAEZvI;oBACIE;oBACAnJ,UAAU;oBACViY,eAAe;oBACfC,gBAAgB;oBAChB/L,WAAW;oBACXtD,QAAQ;oBACR9I;oBACAoY,cAAc;oBACdC,mBAAmB;oBACnBlP,UAAU;;gBAGduC;oBACIC;oBACAkH,WAAW;oBACXC,cAAc;oBACd0B,WAAW;oBACXZ,wBAAwB;oBACxBxZ,aAAa;oBACbod;wBACIc,WAAW;wBACXC,UAAU;wBACVC,WAAW;wBACXC,UAAU;;oBAEdpB,YAAY;;gBAGhB3O;oBACIuO,UAAU,SAASva,IAAI9Y;oBACvBqxB,aAAa,SAASvY,IAAI9Y;oBAC1BspB,YAAY,SAASxQ,IAAI9Y,MAAMqqB,cAAcyK;oBAC7CvE,eAAe,SAASF,YAAYC;oBACpC9G,UAAU,SAAS1Q,IAAI9Y;oBACvB6pB,UAAU,SAAS/Q,IAAI9Y;oBACvB+pB,eAAe,SAASjR,IAAI9Y,MAAMgqB;oBAClCE,sBAAsB,SAASpR,IAAIkR,WAAWK,cAAczX;oBAC5DuX,UAAU,SAASrR,IAAIxI,UAAU0Z;oBACjCd,YAAY,SAASpQ,IAAI9Y,MAAMmpB,QAAQC;oBACvC0I,iBAAiB,SAAS3I,QAAQC;oBAClCrE,SAAS,SAASjM,IAAI9Y,MAAMigB,QAAQ8U;oBACpC3K,aAAa,SAAStR,IAAI9Y,MAAMg1B;oBAChCnE,eAAe,SAAS/X,IAAI9Y;oBAC5BuyB,iBAAiB,SAAS0C;oBAC1B/E,YAAY,SAAS+E;oBACrBvD,gBAAgB,SAAS5Y;oBACzB8M,UAAU,SAAS9M;oBACnBgN,kBAAkB,SAAShN,IAAIiN,UAAUC;oBACzCO,iBAAiB,SAAS7c;oBAC1BuQ,gBAAgB,SAASnB,IAAIwB,WAAWD;oBACxC2Y,0BAA0B,SAASrD,UAAUzlB,SAAS6b;;gBAG1D0I;oBACIyG,WAAW;oBACXC,WAAW;oBACXC,cAAc;oBACdC,YAAY;oBACZC,cAAc;oBACdnD,mBAAmB;oBACnBoD,qBAAqB;oBACrBC,oBAAoB;oBACpBC,qBAAqB;oBACrBC,oBAAoB;oBACpBC,uBAAuB;oBACvBjD,SAAS;oBACTjD,8BAA8B;;gBAGlCnN;oBACI4Q,YAAY;oBACZC,iBAAiB;oBACjBzC,kBAAkB;oBAClBzH,8BAA8B;;gBAGlCb;oBACIE,aAAa;oBACbD,aAAa;;gBAGjBzU;oBACI8K,SAAS;oBACTkX;wBACIlX,SAAS;;oBAEbmX,WAAW;oBACXC;wBACIC,WAAW;wBACXC,gBAAgB;wBAChBC,WAAW;wBACXC,eAAe;wBACfC,YAAY;;oBAEhBC,UAAU;oBAEVlsB;wBACImS,UAAU;;;gBAIlB3H;oBACIgK,SAAS;oBACT2X,iBAAiB;oBACjBP;wBACIQ,UAAU;;;gBAIlBtH,gBAAgB,SAASuH;oBACrB,OAAOA;;gBAGX50B;oBACIkuB,sBAAsB;oBACtBnH,gBAAgB;oBAChBqC,eAAc,MAAM,MAAM,MAAM,MAAM,MAAM;;gBAGhDlM;oBACIH,SAAS;oBACTwG,QAAQ;oBACR7I,UAAU;oBACVmJ;oBACApJ;;gBAGJuJ;oBACIsI,UAAU;oBACVuI,iBAAiB;oBACjBtI,UAAU;;gBAGdjR;oBACIC,aAAa;;gBAGjBkJ;oBACID,eAAe;oBACfjJ,aAAa;;gBAGjBoP;oBACI3f,KAAK;oBAGLkV,QAAQ;;gBASZuJ;gBAIApJ;oBACI3F,UAAU;oBACVD;oBACAoJ;oBACAvD,gBAAgB;;gBAIpB1S;oBAEIrR,SAAS;oBAGT2vB,YAAY;oBAGZ4I,iBAAiB;;gBAIrB9hB;oBACI+hB,eAAe;oBAGfC,cAAc;oBAGdC,QAAQ;oBAIRC,aAAa;oBAEbC,gBAAgB;oBAEhBC,aAAa;oBAEbC,aAAa;oBAGbC;;gBAGJhP;oBACIC,gBAAgB;oBAChBqH,mBAAmB;oBACnBhH,kBAAkB;;;YAK1BtqB,GAAG6B,OAAOxB,KAAK0e,UAAU5G,GAAG;YAE5B9X,KAAKsjB;YACLtjB,KAAK6sB;YACL7sB,KAAK8hB;YAEL9hB,KAAKw1B;YACLx1B,KAAKqqB,kBAAmB,IAAI1qB,GAAGsS;YAE/BjS,KAAKse;YACLte,KAAKmjB;YACLnjB,KAAKojB;YACLpjB,KAAKqjB;YACLrjB,KAAKqhB;YAELrhB,KAAK6iB,uBAAuB;YAC5B7iB,KAAKyiB,eAAe;YACpBziB,KAAKmgB,cAAcngB,KAAKkpB;YAExBlpB,KAAKkvB;YAELlvB,KAAKukB,sBAAsBvkB,KAAKooB,aAAapoB,KAAK0e,SAASsI,QAAQE;YACnElnB,KAAK0kB,gCAAgC1kB,KAAKooB,aAAapoB,KAAK0e,SAAS6B,WAAW2G;YAEhFlnB,KAAK8kB,yBAAyB9kB,KAAKooB,aAAapoB,KAAK0e,SAAS6B,WAAWzC;YAEzE9d,KAAKgiB,iBAAiBhiB,KAAKooB,aAAapoB,KAAK0e,SAASsI,QAAQjJ;YAC9D/d,KAAK4kB,2BAA2B5kB,KAAKooB,aAAapoB,KAAK0e,SAAS6B,WAAWxC;YAE3E/d,KAAK4f,WAAW5f,KAAKsqB;YAErBtqB,KAAKqzB,iBAAiB1zB,GAAGgnB,2BAA2B3mB,KAAK0mB;YAEzD,IAAI1mB,KAAK0e,SAAS6E,QAAQ;gBACtBvjB,KAAKmtB,mBAAmBntB,KAAKspB;oBACzB1pB,SAASI,KAAK0e,SAAS6E;oBACvB/K,OAAOxY,KAAK0e,SAASrb,KAAK+mB;mBAC3B3Q;;YAGPzZ,KAAK4sB;YAEL5sB,KAAK+tB;YAEL,IAAI/tB,KAAK0e,SAASoJ,MAAMD,eAAe;gBACnC,IAAIloB,GAAGioB,cAAc;oBACjB5nB,KAAKyjB,gBAAgBzjB,KAAK2nB;uBAEzB;oBACD3nB,KAAK8F,IAAI,kCAAkC;;;YAInD9F,KAAKk0B;YAELl0B,KAAKohB,kBAAkBzhB,GAAGi5B,kBAAkB,IAAIj5B,GAAGi5B,eAAej5B,GAAGgQ,KAAK3P,KAAK8F,KAAK9F;YACpFA,KAAK4jB;YAEL5jB,KAAK6jB;YACL7jB,KAAK8jB;YAEL9jB,KAAK64B,UAAWl5B,GAAGykB,UAAU,IAAIzkB,GAAGykB,OAAOpkB,KAAK0e,SAASrI,SAAS1W,GAAGgQ,KAAK3P,KAAK8F,KAAK9F;YACpF,IAAIA,KAAK64B,QAAQzY,SAAS;gBACtBpgB,KAAKyuB,wBAAwB9uB,GAAGgQ,KAAK3P,KAAK64B,QAAQC,eAAe94B,KAAK64B;;YAG1E,IAAIl5B,GAAGo5B,iBAAiBp5B,GAAGkT,kBAAkBsD,aAAa;gBACtDnW,KAAK+jB,iBAAiB,IAAIpkB,GAAGo5B,cACzBp5B,GAAGgQ,KAAK3P,KAAKuzB,kBAAkBvzB,OAE/B,SAASwa;oBACL,IAAIwe,QAAQjhB,KAAKoI,YAAYvE;wBAAUpB,IAAIA;;oBAC3C,OAAQwe,SAASA,MAAMxd,QAAS;;;YAK5Cxb,KAAK4iB,oBAAoB5iB,KAAK0e,SAAS8K,WAAW8I;;QAItD3yB,GAAGm2B,kBAAkBzvB,YAAY1G,GAAGge;QACpChe,GAAG6B,OAAO7B,GAAGm2B,kBAAkBzvB,WAAW1G,GAAGmmB;;ICnTjDnmB,GAAGs5B,gBAAgB,SAASnhB;QACxB;QAEA,IAAIhS,KAAKozB,6BACLC,YACAC,kBACAnhB;YACIohB,cAAc;YACdC,gBAAe,SAAS,QAAQ;YAChC1S,QAAQ;YACR2S,aAAa;YACbzS,gBAAgB;YAChBI;YACAE;YACAD;YACAqS;YACAC,oCAAoC;YACpCC;gBACIC,UAAS,KAAK,KAAK;gBACnBC,SAAQ,KAAK,KAAK,KAAK,KAAK;gBAC5BC,QAAO,KAAK,KAAK,KAAK,KAAK;gBAC3BC,OAAM,KAAK,KAAK,KAAK,KAAK;gBAC1BC,OAAM;;YAEV1S;gBACIsI,UAAU;gBACVuI,iBAAiB;;YAErBpyB,KAAK,SAAS4B,KAAK1B;YACnBg0B,QAAQ,SAASxf;YACjBwQ,YAAY,SAASxQ,IAAIiN,UAAUC;YACnCkD,YAAY;;QAGpBjrB,GAAG6B,OAAOyW,SAASH;QACnBhS,MAAMmS,QAAQnS;QAEd,IAAInG,GAAG2F,QAAQ2S,QAAQqhB,cAAcrhB,QAAQ2O,UAAU,GAAG;YACtD,MAAM,IAAIzlB,MAAM,MAAM8W,QAAQ2O,SAAS;;QAM3C,SAASqT;YACL,OAAOt6B,GAAG2F,UAAS,OAAO,QAAQ,UAAS2S,QAAQ2O,WAAW;;QAMlE,SAASsT,yBAAyB5V;YAC9B,IAAI6V,oBAAoB;YAExBx6B,GAAG+C,KAAKy3B,mBAAmB,SAASx3B,KAAKy3B;gBACrC,IAAIz6B,GAAG2F,UAAS,UAAU,mBAAmB,oBAAoB,kBAAiB80B,UAAU,GAAG;oBAC3FD,oBAAoB;oBACpB,OAAO;;;YAIf,OAAOA;;QAGX,SAASE,MAAM/lB;YAEX,OAAO2D,QAAQoP,KAAKsI,YAAYrb,IAAIC,oBAAoBzQ;;QAI5D,SAASw2B;YACL,IAAI7S;YAEJ,IAAI9iB,OAAOmF,kBAAkBnF,OAAOoF,eAAe;gBAC/C0d,WAAW9nB,GAAGiK;gBAEd,IAAI6d,SAASlT,oBAAoBzQ,WAAW;oBACxC2jB,WAAW,IAAIhT;oBAEfgT,SAAS9b,SAAS;oBAClB8b,SAAS5b,UAAU;oBACnB4b,SAAS8S,YAAY;oBACrB9S,SAAS+S,aAAa;;;YAI9B,OAAO/S;;QAIX,SAASgT,YAAYjgB,IAAIkgB;YACrB,IAAIjT,WAAW2R,YAAY5e,IAAIlG;YAE/B,KAAKmT,UAAU;gBACX,IAAIiT,aAAa;oBACbjT,WAAWiT;uBAEV;oBACD,IAAIziB,QAAQoP,KAAKsI,UAAU;wBACvBlI,WAAW6S;2BAEV;wBACD7S,WAAW9nB,GAAGiK;;;gBAItBwvB,YAAY5e,IAAIlG,MAAMmT;;YAG1B,OAAOA;;QAIX,SAASkT,QAAQngB;YACb,IAAI/J,IAAI9Q,GAAG2F,QAAQ6zB,OAAO3e,KACtBkS,MAAMzU,QAAQ6O,gBACd8T;mBAEGxB,YAAY5e;YACnB2e,MAAMjd,OAAOzL,GAAG;YAEhB,IAAI0oB,MAAMzzB,UAAUgnB,OAAOjc,IAAIic,KAAK;gBAChCkO,SAASzB,MAAMzM,MAAM;gBACrBmO,YAAYD;;;QAIpB,SAAS5P,WAAWxQ,IAAIsgB;YACpB,IAAIxmB,MAAMmmB,YAAYjgB,KAClBoM,SAAS3O,QAAQ2O,QACjBc,UAAUoT,aAAa;YAE3BH,QAAQngB;YAER,IAAIkN,SAAS;gBACT5hB,IAAI8gB,SAAS,kBAAkBpM,KAAK,eAAe;mBAElD,KAAK6f,MAAM/lB,SAASymB,qBAAqBzmB,IAAIuG,SAAS;gBACvD6M,UAAU;gBACV5hB,IAAI8gB,SAAS,kBAAkBpM,KAAK,iCAAiClG,IAAIuG,QAAQ;;YAGrF5C,QAAQ+S,WAAWxQ,IAAIlG,KAAKoT;;QAGhC,SAASsT,UAAUxgB;YACf,IAAIygB,iBAAiB7B,YAAY5e,IAAI0gB,kBACjC1B,iBAAiBvhB,QAAQuhB,gBACzB1b;YAEJ,IAAI7F,QAAQkP,YAAYlF,KAAK;gBACzBnE,SAAS7F,QAAQkP,YAAYlF,IAAIzH;;YAGrC,IAAIygB,gBAAgB;gBAChBt7B,GAAG+C,KAAKu4B,gBAAgB,SAASv5B,MAAMkB;oBACnCkb,SAASA;oBACTA,OAAOpc,QAAQkB;;;YAIvB,IAAI42B,gBAAgB;gBAChB75B,GAAG+C,KAAK82B,gBAAgB,SAAS93B,MAAMkB;oBACnCkb,SAASA;oBACTA,OAAOpc,QAAQkB;;;YAIvB,OAAOkb;;QAGX,SAAS+c,YAAYrgB,IAAI2gB;YACrB,IAAI7mB,MAAMmmB,YAAYjgB,IAAI2gB,SACtBvU,SAAS3O,QAAQ2O,QACjB9I,SAASkd,UAAUxgB,KACnB4gB,UAAUhC,YAAY5e,IAAI4gB,SAC1BC;YAEJpjB,QAAQ+hB,OAAOxf;YAEf6gB,MAAMC,UAAU9gB,IAAIsD,QAAQsb,YAAY5e,IAAI+gB;YAG5C,IAAIlB,MAAM/lB,MAAM;gBACZA,IAAI3I,SAAS6vB,kBAAkBhhB;gBAC/BlG,IAAIzI,UAAU4vB,mBAAmBjhB;mBAEhC;gBACDlG,IAAIonB,qBAAqBC,8BAA8BnhB;;YAG3DohB,0BAA0BphB;YAG1BlG,IAAIunB,KAAKjV,QAAQyU,KAAK;YAItB,IAAIpjB,QAAQoP,KAAKsI,YAAY1X,QAAQoP,KAAK6Q,oBAAoBmC,MAAM/lB,MAAM;gBACtEA,IAAIC,kBAAkB;;YAG1BunB,WAAWthB;YAEX1U,IAAI,aAAa8gB,SAAS,kBAAkBpM;YAE5C,IAAI4gB,SAAS;gBACT9mB,IAAIynB,KAAKX;mBAER,IAAIlC,gCAAgCpb,QAAQ;gBAC7CxJ,IAAIynB;mBAEH,IAAIje,UAAU7F,QAAQshB,eAAethB,QAAQshB,YAAYtwB,cAAc3D,QAAQ,wCAAwC,GAAG;gBAC3HgP,IAAIynB,KAAKp8B,GAAGsQ,QAAQ6N,QAAQ;mBAE3B,IAAIA,UAAU7F,QAAQshB,eAAethB,QAAQshB,YAAYtwB,cAAc3D,QAAQ,uBAAuB,GAAG;gBAC1GgP,IAAIynB,KAAKzqB,KAAK0qB,UAAUle;mBAEvB;gBACDxJ,IAAIynB,KAAKje;;YAGb,OAAOxJ;;QAGX,SAASgnB,UAAU9gB,IAAIsD,QAAQyd;YAC3B,IAAIxd,WAAW9F,QAAQmP,cAAcnF,IAAIzH,KACrCyhB,YAAY7C,YAAY5e,IAAIyhB;YAGhC,IAAIA,aAAan4B,WAAW;gBACxBia,YAAY,MAAMke;;YAGtB,IAAI/C,+BAA+Bpb,QAAQ;gBACvCC,WAAWpe,GAAGsQ,QAAQ6N,QAAQC;;YAGlC,IAAIwd,uBAAuB;gBACvBxd,WAAWpe,GAAGsQ,QAAQsrB,uBAAuBxd;;YAGjD,OAAOA;;QAKX,SAAS4d,8BAA8BnhB;YACnC,OAAO;gBACH,IAAIigB,YAAYjgB,IAAI0hB,eAAe,GAAG;oBAClClR,WAAWxQ;;;;QAKvB,SAASohB,0BAA0BphB;YAC/B,IAAIoQ,aAAa3S,QAAQ2S;YAEzB,IAAIA,YAAY;gBACZ6P,YAAYjgB,IAAI3Q,OAAO2wB,aAAa,SAAS3rB;oBACzC,IAAIA,EAAEstB,kBAAkB;wBACpBvR,WAAWpQ,IAAI3L,EAAEgc,QAAQhc,EAAEic;;;;;QAQ3C,SAAS0Q,kBAAkBhhB;YACvB,OAAO;gBACHwQ,WAAWxQ;;;QAMnB,SAASihB,mBAAmBjhB;YACxB,OAAO;gBACHwQ,WAAWxQ,IAAI;;;QAIvB,SAASshB,WAAWthB;YAChB,IAAIlG,MAAMmmB,YAAYjgB,KAClB0M,gBAAgBjP,QAAQiP,eACxBkV,kBAAkBhD,YAAY5e,IAAI6hB,yBAClCzV,SAAS3O,QAAQ2O,QACjB0V;YAGJ,KAAKjC,MAAM/lB,MAAM;gBACb2D,QAAQohB,gBAAgB/kB,IAAIioB,iBAAiB,UAAUtkB,QAAQohB;gBAG/D,IAAIphB,QAAQwhB,oCAAoC;oBAK5C,KAAKxhB,QAAQoP,KAAKsI,cAAcsK,oBAAoBC,yBAAyBhT,iBAAiB;wBAC1F5S,IAAIioB,iBAAiB,oBAAoB;wBACzCjoB,IAAIioB,iBAAiB,iBAAiB;;;gBAI9C,IAAItkB,QAAQshB,gBAAgB3S,WAAW,UAAUA,WAAW,QAAQ;oBAChEtS,IAAIioB,iBAAiB,gBAAgBtkB,QAAQshB;;gBAGjD55B,GAAG6B,OAAO86B,YAAY38B,GAAG6G,WAAW0gB,iBAAiBA,cAAc1M,MAAM0M;gBACzEvnB,GAAG6B,OAAO86B,YAAYF;gBAEtBz8B,GAAG+C,KAAK45B,YAAY,SAAS56B,MAAMkB;oBAC/B0R,IAAIioB,iBAAiB76B,MAAMkB;;;;QAKvC,SAASm4B,qBAAqByB;YAC1B,OAAO78B,GAAG2F,QAAQ2S,QAAQyhB,wBAAwBzhB,QAAQ2O,SAAS4V,iBAAiB;;QAGxF,SAASC,cAAcjiB,IAAI2gB,QAAQc,WAAWf,kBAAkBK,uBAAuBc,mBAAmBjB;YACtGhC,YAAY5e;gBACRyhB,WAAWA;gBACXf,kBAAkBA;gBAClBK,uBAAuBA;gBACvBc,mBAAmBA;gBACnBjB,SAASA;;YAGb,IAAIvuB,MAAMssB,MAAMt2B,KAAK2X;YAGrB,IAAI3N,OAAOoL,QAAQ6O,gBAAgB;gBAC/B,OAAO+T,YAAYrgB,IAAI2gB;;;QAI/BjC,8BAA8BjhB,QAAQ2O,WAAW,SAAS3O,QAAQ2O,WAAW;QAE7EjnB,GAAG6B,OAAOxB;YAEN08B,eAAe,SAASliB;gBACpB,IAAImiB,MAAM7e,QAAQwG,SAAS8W,SAASwB,aAAarB;gBAEjD;oBAEIsB,UAAU,SAASC;wBACfH,OAAOG;wBACP,OAAO98B;;oBAOX+8B,YAAY,SAAS7B;wBACjBpd,SAASod;wBACT,OAAOl7B;;oBAGXg9B,iBAAiB,SAASC;wBACtB1B,wBAAwB0B;wBACxB,OAAOj9B;;oBAIXk9B,aAAa,SAASb;wBAClB/X,UAAU+X;wBACV,OAAOr8B;;oBAIXm9B,aAAa,SAASC;wBAClBhC,UAAUgC;wBACV,OAAOp9B;;oBAIXq9B,iBAAiB;wBACbT,cAAc;wBACd,OAAO58B;;oBAIX+7B,MAAM,SAASZ;wBACX,IAAIyB,eAAej9B,GAAG2F,UAAS,OAAO,YAAW2S,QAAQ2O,WAAW,GAAG;4BACnE9I,OAAOwf,cAAc,IAAIC,OAAOC;;wBAGpC,OAAOf,cAAcjiB,IAAI2gB,QAAQwB,MAAM7e,QAAQyd,uBAAuBjX,SAAS8W;;;;YAK3FqC,UAAU,SAASjjB;gBACfmgB,QAAQngB;;;;IC1YpB7a,GAAG+9B,gBAAgB,SAASriB;QACxB;QAEA,IAAIsiB,QAAQtiB,KAAKsiB,OACbC,gBACA1S,WAAWyS,MAAMzS,UACjB7K,UAAUsd,MAAMtd;QAEpB1gB,GAAG6B,OAAOxB;YACNuQ,KAAK,SAASiK,IAAIqjB;gBACdD,UAAUpjB,MAAMqjB;gBAChBD,UAAUpjB,IAAIrK;;YAGlBwP,QAAQ,SAASnF;gBACb,IAAIzC,OAAO/X,MACPmrB,2BAA2B,IAAIxrB,GAAG+L,WAClCoyB,iBAAiB5S,SAAS1Q,IAAI6F,QAAQ7F,KAAK2Q;gBAE/C2S,eAAe/mB,KAAK;oBAChB,IAAIgB,KAAK4I,QAAQnG,KAAK;wBAClBojB,UAAUpjB,IAAIijB,WAAW;wBACzB1lB,KAAKmL,QAAQ1I;;oBAEjB2Q,yBAAyBvf;;;YAIjCsX,SAAS,SAAS1I;uBACPojB,UAAUpjB;;YAGrBujB,qBAAqB,SAASvjB;gBAC1B,OAAOojB,UAAUpjB,IAAIhL;;YAGzBmR,SAAS,SAASnG;gBACd,OAAOojB,UAAUpjB,QAAQ1W;;YAG7BgW,OAAO;gBACH8jB;;YAGJI,eAAe,SAASxjB;gBACpB,OAAOojB,UAAUpjB;;YAGrByjB,sBAAsB,SAASzjB,IAAI0jB;gBAC/BN,UAAUpjB,IAAIhL,MAAM0uB;;YAGxBC,cAAc,SAAS3jB;gBACnB,SAASojB,UAAUpjB,IAAIijB;;;;ICpDnC99B,GAAG2sB,0BAA0B,SAASxU,GAAG0S;QACrC;QAEA,IAAI4T,aAAap+B,MACbq+B,mBAAmB,OACnBC,6BAA6B,OAC7BhpB,UAAUipB,sBAAsBz4B,KAAK0oB,SAEzCvW;YACIkP;YACAL,gBAAgB;YAChBxR;gBACI8K,SAAS;gBACT1W;oBACI0W,SAAS;;;YAGjBta,KAAK,SAAS4B,KAAK1B;YACnB4kB,YAAY,SAASpQ,IAAIxI,UAAU6Y,QAAQC;YAC3CE,YAAY,SAASxQ,IAAIxI,UAAUqf,UAAU/c;YAC7C4W,UAAU,SAAS1Q,IAAIxI;YACvBqZ,cAAc,SAAS7Q;YACvB+Q,UAAU,SAAS/Q,IAAIxI;YACvByZ,eAAe,SAASjR,IAAIxI,UAAU0Z;YACtCE,sBAAsB,SAASpR,IAAIkR,WAAW2F,UAAU/c;YACxDwX,aAAa,SAAStR,IAAIxI,UAAUqf,UAAU/c;YAC9CuX,UAAU,SAASrR,IAAIxI,UAAU0Z;YACjCO,eAAe,SAASzR,IAAI4B;YAC5BiE,SAAS,SAAS7F;YAClB0R,SAAS,SAAS1R,IAAIiC;YACtB4P,UAAU,SAAS7R;YACnBqC,oBAAoB,SAASrC;YAC7BsC,eAAe,SAAStC;WAG5BgkB;YAEIhnB,MAAM,SAASgD,IAAIikB,UAAUpN,UAAU/c;gBACnC,IAAIoX,YAAY8C,QAAQkQ,cAAclkB,IAAIikB;gBAE1CjQ,QAAQwP,cAAcxjB,IAAImkB,mBAAmB;uBAEtCnQ,QAAQwP,cAAcxjB,IAAIrK,KAAKyuB,cAAcH;gBACpDjQ,QAAQwP,cAAcxjB,IAAIqQ,UAAUa,UAAUlQ;gBAE9CvD,QAAQ2T,qBAAqBpR,IAAIgU,QAAQqQ,yBAAyBnT,YAAY2F,UAAU/c;;YAK5FwqB,UAAU,SAAStkB;gBACf,IAAIgB,OAAOvD,QAAQsK,QAAQ/H,KACvB9Y,OAAOuW,QAAQoI,QAAQ7F;gBAE3B1U,IAAI,uCAAuC0U,KAAK;gBAChDgU,QAAQuQ,eAAevkB,IAAIzD,KACvB,SAASsa,UAAU/c;oBACfxO,IAAI,6BAA6B0U;oBAEjC,IAAIwkB,oBAAoBn1B,OAAOo1B,kBAAkB5N,UAAU;oBAE3DpZ,QAAQ2S,WAAWpQ,IAAI9Y,MAAM8Z,MAAMA;oBACnCgT,QAAQ0Q,+BAA+B1kB;oBACvC3Q,OAAOs1B,QAAQ3kB,IAAIwkB,mBAAmB1qB;mBAE1C,SAAS+c,UAAU/c;oBACf,IAAI0qB,oBAAoBn1B,OAAOo1B,kBAAkB5N,UAAU;oBAE3DvrB,IAAI,2CAA2C0U,KAAK,QAAQwkB,kBAAkBh1B,OAAO;oBAErF,IAAIg1B,kBAAkBllB,OAAO;wBACzB0kB,QAAQ1kB,MAAMU;;oBAGlB,KAAKvC,QAAQ6T,YAAYtR,IAAI9Y,MAAMs9B,mBAAmB1qB,MAAM;wBACxDzK,OAAOs1B,QAAQ3kB,IAAIwkB,mBAAmB1qB;;;;YAMtD8qB,eAAe,SAASX,UAAUjkB,IAAI6W,UAAU/c;gBAC5C,IAAI5S,OAAOuW,QAAQoI,QAAQ7F;gBAE3B1U,IAAI,uCAAuC0U,KAAK,aAAaikB;gBAE7DjQ,QAAQ6Q,iBAAiB7kB,IAAIikB;gBAE7B,IAAIa,mBAAmBz1B,OAAOo1B,kBAAkB5N,UAAU,QACtDkO;gBAEJ,IAAID,iBAAiBxlB,OAAO;oBACxB0kB,QAAQ1kB,MAAMU;uBAEb;oBACD+kB,gBAAgB5/B,GAAG2F,QAAQkpB,QAAQwP,cAAcxjB,IAAIlF,SAASkqB,YAAYf;oBAC1E,IAAIc,iBAAiB,GAAG;wBACpB/Q,QAAQwP,cAAcxjB,IAAIlF,SAASkqB,WAAWtjB,OAAOqjB,eAAe;wBACpE/Q,QAAQwP,cAAcxjB,IAAIlF,SAASmqB,UAAUC,QAAQjB;;;gBAM7D,KAAKjQ,QAAQwP,cAAcxjB,IAAIrK,KAAKwvB,eAAe;oBAG/C,IAAIrB,4BAA4B;wBAC5B9P,QAAQwP,cAAcxjB,IAAIrK,KAAKwvB,gBAAgB;wBAE/C75B,IAAInG,GAAG8H,OAAO,oFAAoF6J,KAAK0qB,UAAU51B,OAAOw5B,KAAKpR,QAAQqR,SAASrlB,OAAOlJ,KAAK0qB,UAAUxN,QAAQwP,cAAcxjB,IAAIlF,SAASkqB;wBACvM7/B,GAAG+C,KAAK8rB,QAAQqR,SAASrlB,KAAK,SAASslB,MAAMC;4BACzCj6B,IAAInG,GAAG8H,OAAO,uDAAuD+S,IAAIslB,MAAMC,MAAM7D;4BACrF6D,MAAMC;4BAGND,MAAME,aAAa;;wBAIvBzR,QAAQ0R,0BAA0B1lB;wBAIlC2lB,kBAAkBC,KAAK5lB,IAAI;;oBAG/B,KAAKvC,QAAQ6T,YAAYtR,IAAI9Y,MAAM49B,kBAAkBhrB,MAAM;wBAIvDzK,OAAOs1B,QAAQ3kB,IAAI8kB,kBAAkBhrB;;;;YAKjD+rB,cAAc,SAAS7lB;gBACnB,SAASgU,QAAQwP,cAAcxjB,IAAIlF,SAASmqB,UAAU/5B;;YAG1D46B,UAAU,SAAS9lB;gBACf,IAAI+lB,UAAU/R,QAAQwP,cAAcxjB,IAAIlF,SAASmqB,UAAUptB;gBAE3D,IAAIkuB,WAAW/R,QAAQgS,gBAAgBhmB,KAAK;oBACxC+lB,UAAU;;gBAGd,OAAOA;;YAGXzmB,OAAO,SAASU;gBACZ1U,IAAI,gGAAgG0U,IAAI;gBAExGgU,QAAQ0Q,+BAA+B1kB;gBACvCgU,QAAQiS,mBAAmBjmB;gBAC3BgU,QAAQwP,cAAcxjB,IAAIqQ,SAAS;;YAGvC6V,UAAU,SAASlmB;gBACf,IAAIgB,OAAOvD,QAAQsK,QAAQ/H,KACvB9Y,OAAOuW,QAAQoI,QAAQ7F,KACvBikB,WAAWD,QAAQ8B,SAAS9lB,KAC5BkR,YAAY8C,QAAQkQ,cAAclkB,IAAIikB,WACtCzG,WAAWxJ,QAAQwP,cAAcxjB,IAAImkB,kBACrCgC,mBAAmBnS,QAAQwP,cAAcxjB,IAAIlF,SAASkqB;gBAE1D,IAAIhR,QAAQwP,cAAcxjB,IAAIqQ,UAAU,MAAM;oBAC1C2D,QAAQwP,cAAcxjB,IAAIqQ,SAAS;;gBAIvC,IAAImN,YAAY/f,QAAQ4T,SAASrR,IAAI9Y,MAAMgqB,eAAe,OAAO;oBAC7D8S,QAAQ1kB,MAAMU;oBACdikB,WAAWD,QAAQ8B,SAAS9lB;oBAC5BkR,YAAY8C,QAAQkQ,cAAclkB,IAAIikB;oBACtCzG,WAAW;;gBAIf,IAAIyG,YAAY,QAAQkC,iBAAiBj7B,WAAW,GAAG;oBACnD84B,QAAQM,SAAStkB;uBAIhB;oBACD1U,IAAInG,GAAG8H,OAAO,qEAAqE+S,IAAIikB,UAAU/S,UAAU/gB,QAAQ,GAAG+gB,UAAU9gB,KAAK4Q;oBACrIvD,QAAQwT,cAAcjR,IAAI9Y,MAAM8sB,QAAQqQ,yBAAyBnT;oBACjEiV,iBAAiB99B,KAAK47B;oBACtBjQ,QAAQwP,cAAcxjB,IAAIlF,SAASkqB,aAAamB;oBAEhD,IAAIrC,4BAA4B;wBAC5B6B,kBAAkBtE,KAAKrhB,IAAIikB;;oBAG/B,IAAIH,8BAA8B6B,kBAAkBS,eAAepS,QAAQwP,cAAcxjB,IAAIlF,SAASmqB,UAAU/5B,QAAQ;wBACpH84B,QAAQkC,SAASlmB;;oBAGrB,IAAIkR,UAAUtgB,KAAKoQ,SAAS,GAAG;wBAC3B1V,IAAInG,GAAG8H,OAAO,gEAAgEg3B,UAAUjkB,KAAK;wBAC7FgkB,QAAQY,cAAcX,UAAUjkB,IAAI,+BAA+B;2BAElE;wBACDgU,QAAQqS,YAAYrmB,IAAIikB,UAAUzG,UAAUjhB,KAExC,SAASnL,QAAQylB,UAAU/c;4BACvBxO,IAAI,0CAA0C0U,KAAK,aAAaikB;4BAEhEjQ,QAAQ6Q,iBAAiB7kB,IAAIikB;4BAE7B,IAAIkC,mBAAmBnS,QAAQwP,cAAcxjB,IAAIlF,SAASkqB,kBACtDF,mBAAmBz1B,OAAOo1B,kBAAkB5N,UAAU,OACtDyP,qBAAqBnhC,GAAG2F,QAAQq7B,kBAAkBlC;4BAEtD34B,IAAInG,GAAG8H,OAAO,+CAA+Cg3B,UAAUjkB;4BAEvEgkB,QAAQhnB,KAAKgD,IAAIikB,UAAUa,kBAAkBhrB;4BAE7C,IAAIwsB,sBAAsB,GAAG;gCACzBH,iBAAiBzkB,OAAO4kB,oBAAoB;;4BAGhDtS,QAAQuS,0BAA0BvmB;4BAElC,KAAKgkB,QAAQ6B,aAAa7lB,OAAOmmB,iBAAiBj7B,WAAW,GAAG;gCAC5D84B,QAAQM,SAAStkB;mCAEhB,IAAIgkB,QAAQ6B,aAAa7lB,KAAK;gCAC/BgkB,QAAQkC,SAASlmB;mCAEhB;gCACD1U,IAAInG,GAAG8H,OAAO,qGAAqG+S,IAAIlJ,KAAK0qB,UAAU2E;;2BAK9I,SAAS70B,QAAQulB,UAAU/c;4BACvBkqB,QAAQY,cAAcX,UAAUjkB,IAAI6W,UAAU/c;2BAGjDkD,KAAK;4BACFgX,QAAQwS,SAASxmB,IAAIikB;;;;;WAO7C0B;YACIc;YACAC;YACAC;YAEAP,WAAW;gBACP,IAAIlU,MAAMzU,QAAQ6O,gBACdsa,wBAAwB,GACxBC,kBAAkB;gBAEtB1hC,GAAG+C,KAAKy9B,kBAAkBe,aAAa,SAASrgB,QAAQygB;oBACpDF;oBACAC,mBAAmBC,iBAAiB57B;;gBAGxC,OAAOgnB,OAAOyT,kBAAkBc,MAAMv7B,SAAS07B,wBAAwBC;;YAM3EjB,MAAM,SAAS5lB,IAAI+mB;gBACf,IAAIC,aAAaD,eACbE,eAAe9hC,GAAG2F,QAAQ66B,kBAAkBgB,UAAU3mB,KACtDknB,mBAAmB/hC,GAAG2F,QAAQ66B,kBAAkBc,OAAOzmB,KACvDogB;uBAEGuF,kBAAkBe,YAAY1mB;gBAErC,IAAI3Q,OAAO83B,eAAennB,eAAe7a,GAAG8X,WAAW;oBACnD3R,IAAI,yCAAyC0U,KAAK;2BAC3CgU,QAAQwP,cAAcxjB,IAAI+E;;gBAIrC,IAAIkiB,gBAAgB,GAAG;oBACnBtB,kBAAkBgB,SAASjlB,OAAOulB,cAAc;uBAG/C,IAAID,aAAaE,oBAAoB,GAAG;oBACzCvB,kBAAkBc,MAAM/kB,OAAOwlB,kBAAkB;oBAEjD9G,SAASuF,kBAAkBgB,SAAS9uB;oBACpC,IAAIuoB,UAAU,GAAG;wBACbuF,kBAAkBc,MAAMp+B,KAAK+3B;wBAC7B/wB,OAAOc,MAAMiwB;;;;YAKzBgH,uBAAuB;gBACnB,IAAIC;gBAIJliC,GAAG+C,KAAKy9B,kBAAkBe,aAAa,SAASrgB,QAAQihB;oBACpD,IAAIA,UAAUA,OAAOp8B,QAAQ;wBACzBm8B,mBAAmBh/B,KAAKk/B,SAASlhB;;;gBAMzClhB,GAAG+C,KAAKy9B,kBAAkBc,OAAO,SAASt+B,KAAKke;oBAC3C,KAAKsf,kBAAkBe,YAAYrgB,SAAS;wBACxCghB,mBAAmBh/B,KAAKk/B,SAASlhB;;;gBAKzCghB,qBAAqBA,mBAAmB9xB,OAAOowB,kBAAkBgB;gBAEjE,OAAOU;;YAGXG,mBAAmB,SAASxnB;gBACxB,OAAO7a,GAAG2F,QAAQ66B,kBAAkBc,OAAOzmB,OAAO;;YAGtDqhB,MAAM,SAASrhB,IAAIikB;gBACf,IAAIA,YAAY,MAAM;oBAClB0B,kBAAkBgB,SAASt+B,KAAK2X;;gBAGpC,IAAI2lB,kBAAkBS,aAAa;oBAC/B,IAAInC,YAAY,MAAM;wBAClB0B,kBAAkBgB,SAASc;wBAC3B9B,kBAAkBc,MAAMp+B,KAAK2X;2BAE5B;yBACA;4BACG,IAAI0nB,kBAAkB/B,kBAAkBe,YAAY1mB;4BACpD0nB,gBAAgBr/B,KAAK47B;4BACrB0B,kBAAkBe,YAAY1mB,MAAM0nB;;;oBAI5C,OAAO;;gBAGX,OAAO;;YAGXpoB,OAAO;gBACHqmB,kBAAkBgB;gBAClBhB,kBAAkBc;;WAI1BkB;YACIpG,MAAM,SAASvhB,IAAI9Y;gBACf8sB,QAAQwP,cAAcxjB,IAAIqQ,SAAS;gBAEnC/kB,IAAI,uCAAuC0U;gBAC3CgU,QAAQ4T,WAAW5nB,IAAIzD,KACnB,SAASsa,UAAU8J;oBACfr1B,IAAI,yCAAyC0U;oBAE7C,IAAI8kB,mBAAmBz1B,OAAOo1B,kBAAkB5N,UAAU,OACtD7V,OAAOvD,QAAQsK,QAAQ/H;oBAE3BvC,QAAQ2S,WAAWpQ,IAAI9Y,MAAM8Z,MAAMA;oBACnC3R,OAAOw4B,aAAa7nB,IAAI8kB;oBACxBz1B,OAAOs1B,QAAQ3kB,IAAI8kB,kBAAkBnE;mBAGzC,SAAS9J,UAAU8J;oBACfr1B,IAAI,sCAAsC0U;oBAE1C,IAAI8kB,mBAAmBz1B,OAAOo1B,kBAAkB5N,UAAU;oBAE1D,KAAKpZ,QAAQ6T,YAAYtR,IAAI9Y,MAAM49B,kBAAkBnE,SAAS;wBAC1DtxB,OAAOs1B,QAAQ3kB,IAAI8kB,kBAAkBnE;;;;WAOzDtxB;YACI8V,QAAQ,SAASnF;gBACb1U,IAAI,gBAAgB0U;gBACpBvC,QAAQkP,YAAYpmB,OAAOyZ;gBAC3B2lB,kBAAkBC,KAAK5lB;;YAG3B2kB,SAAS,SAAS3kB,IAAI6W,UAAU8J;gBAC5B,IAAIz5B,OAAOuW,QAAQoI,QAAQ7F;gBAE3BvC,QAAQ+S,WAAWxQ,IAAI9Y,MAAM2vB,UAAU8J;gBAEvC,IAAI3M,QAAQwP,cAAcxjB,KAAK;oBAC3BgU,QAAQ8T,cAAc9T,QAAQ8T,WAAW9nB;;gBAG7C2lB,kBAAkBC,KAAK5lB;;YAK3BmnB,gBAAgB,SAASnnB;gBACrB,OAAQgU,QAAQ+T,YAAY/T,QAAQ+T,SAAS/nB,OACxCgU,QAAQjN,WAAWiN,QAAQjN,QAAQ/G;;YAG5CgoB,aAAa;gBACT,IAAIC,cAAcjY,YAAY7qB,GAAG6qB,aAAa7qB,GAAG+iC,aAC7CC,uBAAuBhjC,GAAGkT,kBAAkBsC,gBAAgB,QAAQ;gBAExEqZ,UAAU,IAAIiU,YAAYE,uBAAuB,iBAC7C1qB;oBAEImU,eAAenU,QAAQmU;oBACvB/L,SAASpI,QAAQoI;oBACjBkC,SAAStK,QAAQsK;oBACjBO,SAAS7K,QAAQ6K;oBACjBhd,KAAKA;oBACLolB,UAAUjT,QAAQiT;oBAClBN,YAAY3S,QAAQ2S;oBACpBqB,eAAehU,QAAQgU;;gBAI/B,IAAIuC,QAAQoU,+BAA+B;oBACvCpU,QAAQoU;;;YAIhBC,6BAA6B,SAASroB;gBAClC,OAAOvC,QAAQoU,SAAS7R;;YAM5BsoB,YAAY,SAAStoB,IAAIpP;gBAIrB,IAAIA,SAASojB,QAAQjN,QAAQ/G,OAAOpP,gBAAgBzL,GAAG8X,WAAW;oBAK9DQ,QAAQoT,aAAa7Q;oBAErB1U,IAAI,iDAAiD0U;oBACrDpP,KAAKwM,SAASb,KAAK,SAASgsB;wBACxBj9B,IAAI,qCAAqC0U;wBAGzCgU,QAAQwU,WAAWxoB,IAAIuoB;wBAGvB9qB,QAAQiU,QAAQ1R,IAAIuoB,cAAcvnB;wBAGlCgT,QAAQiS,mBAAmBjmB;wBAE3B3Q,OAAOo5B,uBAAuBzoB;uBAIlC,SAASkL;wBACL,IAAIwd;wBAEJ,IAAIxd,cAAc;4BACdwd,cAAcl5B,QAAQ0b;;wBAG1B5f,IAAInG,GAAG8H,OAAO,0DAA0D+S,IAAIkL,eAAe;wBAE3FzN,QAAQ+S,WAAWxQ,IAAIvC,QAAQoI,QAAQ7F,KAAK7a,GAAG6B,OAAO0hC,eAAe3E,uBAAuB;wBAC5F10B,OAAOo5B,uBAAuBzoB;wBAC9B2lB,kBAAkBC,KAAK5lB;;uBAG1B;oBACD,OAAO3Q,OAAOo5B,uBAAuBzoB;;gBAGzC,OAAO;;YAIXyoB,wBAAwB,SAASzoB;gBAC7B,IAAI2oB,aAAalrB,QAAQ4E,mBAAmBrC,KACxC4oB,iBAAiB;gBAErB,IAAID,cAAcA,WAAWz9B,QAAQ;oBACjCI,IAAI,4CAA4C0U;oBAEhD7a,GAAG+C,KAAKygC,YAAY,SAASxgC,KAAK0gC;wBAC9B,IAAIx5B,OAAOg5B,4BAA4BQ,gBAAgB7U,QAAQjN,QAAQ8hB,YAAY;4BAC/ED,iBAAiBC,cAAc7oB;4BAC/B3Q,OAAOy5B,IAAID;+BAEV,IAAIx5B,OAAOg5B,4BAA4BQ,YAAY;4BACpD,OAAO;;;uBAId;oBACDD,iBAAiB;oBACjBv5B,OAAOy5B,IAAI9oB;;gBAGf,OAAO4oB;;YAGXf,cAAc,SAAS7nB,IAAI6W;gBACvB,IAAIA,SAASjV,YAAYtY,WAAW;oBAChCmU,QAAQgU,cAAczR,IAAI6W,SAASjV;;;YAO3C6iB,mBAAmB,SAASsE,kBAAkBxR;gBAC1C,IAAIV,WAAWkS;gBAIf,KAAK5jC,GAAGuG,SAASq9B,mBAAmB;oBAChClS;oBAEA,IAAI1xB,GAAGwH,SAASo8B,sBAAsBxR,YAAY;wBAC9CV,SAASrnB,QAAQu5B;;;gBAIzBlS,SAASzlB,UAAUmmB;gBAEnB,OAAOV;;YAGXiS,KAAK,SAAS9oB;gBACV,IAAI9Y,OAAOuW,QAAQoI,QAAQ7F;gBAE3B,KAAK4jB,WAAWzd,QAAQnG,KAAK;oBACzB,MAAM,IAAI7a,GAAGwB,MAAMqZ,KAAK;;gBAG5BvC,QAAQsT,SAAS/Q,IAAI9Y;gBAErB,IAAI28B,oBAAoB7P,QAAQgV,qBAAqBhpB,KAAK;oBACtDgkB,QAAQkC,SAASlmB;uBAEhB;oBACD2nB,OAAOpG,KAAKvhB,IAAI9Y;;;YAIxBiJ,OAAO,SAAS6P;gBACZ,IAAIipB,eAAe55B,OAAO83B,eAAennB;gBAEzC,IAAIipB,cAAc;oBACd,OAAO55B,OAAOi5B,WAAWtoB,IAAIipB;uBAE5B;oBACD55B,OAAOy5B,IAAI9oB;oBACX,OAAO;;;;QAKnB7a,GAAG6B,OAAOxB;YAINuQ,KAAK,SAASiK,IAAI+E;gBACdiP,QAAQje,IAAIP,MAAMhQ,MAAM8H;;YAM5B+B,QAAQ,SAAS2Q;gBACb,IAAI2lB,kBAAkBtE,KAAKrhB,KAAK;oBAC5B,OAAO3Q,OAAOc,MAAM6P;;gBAExB,OAAO;;YAGXwJ,OAAO,SAASxJ;gBAKZ,IAAI8jB,4BAA4B;oBAC5B9P,QAAQwP,cAAcxjB,IAAIrK,KAAKwvB,gBAAgB;;gBAKnD,IAAIQ,kBAAkB6B,kBAAkBxnB,KAAK;oBACzC,OAAO3Q,OAAOc,MAAM6P;uBAMnB;oBACD,OAAO4jB,WAAWv0B,OAAO2Q;;;YAOjCmF,QAAQ,SAASnF;gBACb,IAAIkpB,eAAelV,QAAQ7O,OAAOnF;gBAElC,IAAI7a,GAAGkX,iBAAiB6sB,eAAe;oBACnCA,aAAa3sB,KAAK;wBACdlN,OAAO8V,OAAOnF;;uBAGjB,IAAIkpB,iBAAiB,OAAO;oBAC7B75B,OAAO8V,OAAOnF;;;YAOtBqF,WAAW;gBACP,IAAIgiB,qBAAqB1B,kBAAkByB,yBACvCnxB;gBAIJ,IAAIoxB,mBAAmBn8B,QAAQ;oBAC3B,KAAK+K,IAAIoxB,mBAAmBn8B,SAAS,GAAG+K,KAAK,GAAGA,KAAK;wBACjD2tB,WAAWze,OAAOkiB,mBAAmBpxB;;;gBAI7C0vB,kBAAkBrmB;;YAKtByH,SAAS,SAAS/G;gBACd,IAAIgU,QAAQ+T,YAAY/T,QAAQ+T,SAAS/nB,KAAK;oBAC1C,OAAOgU,QAAQ+T,SAAS/nB,IAAI9C;;gBAGhC,OAAO8W,QAAQjN,WAAWiN,QAAQjN,QAAQ/G;;YAI9CmpB,WAAW,SAASnpB;gBAChB,UAAUgU,QAAQ+T,YAAY/T,QAAQ+T,SAAS/nB;;YAGnDhB,UAAU,SAASgB;gBACf,IAAIgU,QAAQhV,UAAU;oBAClB,OAAOgV,QAAQhV,SAASgB;;;YAIhCV,OAAO;gBACHhU,IAAI;gBACJs4B,WAAWve;gBACXsgB,kBAAkBrmB;gBAClB0U,QAAQ1U;;YAGZoJ,SAAS,SAAS1I;gBACd,IAAI4jB,WAAWzd,QAAQnG,KAAK;oBACxB,OAAOgU,QAAQtL,QAAQ1I;;;YAO/BmG,SAAS,SAASnG;gBACd,OAAOgU,QAAQ7N,QAAQnG;;YAG3B8H,uBAAuB;gBACnB,IAAIkM,QAAQlM,uBAAuB;oBAC/B,OAAOkM,QAAQlM;;gBAEnB;;YAWJyb,qBAAqB,SAASvjB;gBAC1B,IAAI4jB,WAAWzd,QAAQnG,KAAK;oBACxB,OAAOgU,QAAQuP,oBAAoBvjB;;;YAS3CtE,OAAO,SAASsE;gBACZ,IAAI4jB,WAAWwF,YAAYppB,OAAOgU,QAAQtY,SAASkoB,WAAWzd,QAAQnG,OAAOgU,QAAQtY,MAAMsE,KAAK;oBAC5F2lB,kBAAkBC,KAAK5lB;oBACvBgU,QAAQ0R,0BAA0B1lB;oBAClC,OAAO;;gBAEX,OAAO;;YAIXopB,aAAa,SAASppB;gBAClB,SAASgU,QAAQoV,eAAepV,QAAQoV,YAAYppB;;;QAI5D7a,GAAG6B,OAAOyW,SAASH;QACnBhS,MAAMmS,QAAQnS;QACdu4B,mBAAmBpmB,QAAQ3C,SAAS8K,WAAWzgB,GAAGkT,kBAAkByC;QACpEgpB,6BAA6BD,oBAAoBpmB,QAAQ3C,SAASgiB,WAAWlX;QAE7Eme,uBAAwB;YACpB,IAAIlN;YAEJA,SAASpZ,QAAQyS,qBAAqB;YAEtC,OAAO2G;;QAGXxnB,OAAO24B;;IC9uBX7iC,GAAGkkC,uBAAuB,SAAS/rB;QAC/B;QAEA,IAAIG;YACInS,KAAK,SAASC,SAASC;WAE3B89B;QAEJnkC,GAAG6B,OAAOyW,SAASH;QAEnBnY,GAAG6B,OAAOxB;YACN+jC,gBAAgB,SAASvpB,IAAIpL;gBACzB,IAAI40B,2BAA2B,SAAS7P;oBAChC/kB,SAAS+kB,MAAM1vB;;gBAGvB,IAAIE,OAAOuQ,aAAa;oBACpB4uB,yBAAyBtpB,MAAM7a,GAAGgF,QAAQ1E,OAAO,WAAW+jC;uBAE3D;oBACDl+B,IAAI,yDAAyD;;;YAIrEm+B,uBAAuB,SAASzpB;gBAC5B,IAAI7V,OAAOuQ,aAAa;oBACpB,IAAIgvB,WAAWJ,yBAAyBtpB;oBACxC,IAAI0pB,UAAU;wBACVA;;;;;;ICvBpBvkC,GAAGwkC,oBAAoB,SAAS9oB;QAC5B;QAEA,IAAIpD,UAAUoD,KAAKpD,SACfuW,UAAUxuB,MACV29B,QAAQtiB,KAAKsiB,OACbyG,wBAAwBzkC,GAAGoN,eAC3Bs3B,sBACAC,uBACAC,gCACAC,SAASvsB,QAAQusB,QACjBta,YAAYjS,QAAQiS,WACpBpH,UAAU6a,MAAM7a,SAChBhd,MAAM63B,MAAM73B,KACZ2+B,sBAAsB,IAAI9kC,GAAGkkC;YAAsB/9B,KAAKA;;QAO5D,SAAS4+B,YAAYlqB;mBACV8pB,iBAAiB9pB;YAKxB,IAAIgqB,QAAQ;gBACRhS,aAAa+R,0BAA0B/pB;uBAChC+pB,0BAA0B/pB;gBACjCiqB,oBAAoBR,sBAAsBzpB;;YAG9C,IAAImqB,SAASn7B,SAASo7B,eAAepW,QAAQqW,eAAerqB;YAC5D,IAAImqB,QAAQ;gBAIRA,OAAOzzB,aAAa,OAAO;gBAE3BvR,GAAGglC,QAAQ5jC;;;QAQnB,SAAS+jC,uBAAuBC;YAC5B,OAAOA,WAAW1/B,MAAM,KAAK;;QAUjC,SAAS2/B,oBAAoBtjC;YACzB,IAAIijC,SAAShlC,GAAGoP,UAAU,2CAA2CrN,OAAO;YAE5EijC,OAAOzzB,aAAa,MAAMxP;YAE1BijC,OAAO7kC,MAAMC,UAAU;YACvByJ,SAASy7B,KAAK9zB,YAAYwzB;YAE1B,OAAOA;;QAUX,SAASO,4BAA4BP,QAAQv1B;YACzC,IAAI21B,aAAaJ,OAAOnqB,IACpBqG,SAASikB,uBAAuBC,aAChCpqB,OAAOmI,QAAQjC;YAEnBwjB,gBAAgB1pB,QAAQvL;YAIxBk1B,iBAAiBzjB,UAAUlhB,GAAGglC,QAAQ1kC,OAAO,QAAQ;gBACjD,IAAIuuB,QAAQhV,SAASqH,SAAS;oBAC1B/a,IAAI,qEAAqEi/B,aAAa;oBAEtFR,0BAA0BQ,cAAc1b,WAAW;wBAC/C,IAAI3D,eAAe,kEAAkEqf;wBACrFj/B,IAAI4f,cAAc;wBAClBtW;4BACIpF,OAAO0b;;uBAEZ;;;YAMX+e,oBAAoBV,eAAegB,YAAY,SAASh/B;gBACpDD,IAAI,6CAA6CC,UAAU;gBAC3D,IAAI8a,SAASikB,uBAAuBC,aAChC1T,WAAW7C,QAAQ2W,mBAAmBp/B,UACtC4U,OAAO0W,SAAS1W,MAChByqB;gBAEJ,IAAIzqB,QAAQ0pB,gBAAgB1pB,OAAO;oBAC/B7U,IAAI,uCAAuCi/B;oBAC3CvS,aAAa+R,0BAA0BQ;2BAChCR,0BAA0BQ;oBAEjCvW,QAAQ6W,iBAAiBN;oBAEzBK,iBAAiBf,gBAAgB1pB;2BAE1B0pB,gBAAgB1pB;oBACvB8pB,oBAAoBR,sBAAsBc;oBAC1CK,eAAe/T;uBAEd,KAAK1W,MAAM;oBACZ7U,IAAI,MAAMC,UAAU;;;;QAKhCpG,GAAG6B,OAAOxB,MAAM,IAAIL,GAAG+9B,cAAcriB;QAErC1b,GAAGwM,SAASnM,MAAM,SAASsM;YACvB;gBAIIiE,KAAK,SAASiK,IAAI8S;oBACdhhB,OAAOiE,IAAIiK;wBAAKjR,OAAO+jB;;oBAEvBA,UAAUpc,aAAa,QAAQgZ;oBAG/B,IAAIoD,UAAUxsB,YAAY;wBACtBnB,GAAG2tB,WAAWvsB;;;gBAItBmiB,SAAS,SAAS1I;oBACdkqB,YAAYlqB;oBACZlO,OAAO4W,QAAQ1I;;gBAGnBmG,SAAS,SAASnG;oBACd,OAAOlO,OAAOqU,QAAQnG,OAClBgU,QAAQwP,cAAcxjB,IAAIjR,UAAUzF;;;;QAKpDnE,GAAG6B,OAAOxB;YACNwZ,UAAU,SAASgB;gBACf,OAAOgU,QAAQwP,cAAcxjB,IAAIjR;;YAWrC+7B,kBAAkB,SAASX,QAAQv1B;gBAE/B,IAAIm2B;gBAEJ,IAAIf,QAAQ;oBACRU,4BAA4BP,QAAQv1B;uBAEnC;oBACDk1B,iBAAiBK,OAAOnqB,MAAM7a,GAAGglC,QAAQ1kC,OAAO,QAAQ;wBACpD6F,IAAI,2BAA2B6+B,OAAOnqB;wBAKtC,KAAKmqB,OAAO7jC,YAAY;4BACpB;;wBAGJ;4BAEI,IAAI6jC,OAAOa,mBACPb,OAAOa,gBAAgBP,QACvBN,OAAOa,gBAAgBP,KAAK/1B,aAAa,SAAS;gCAKlD;;0BAGR,OAAOlF;4BAEHlE,IAAI,gFAAgFkE,MAAMjE,UAAU,KAAK;4BACzGw/B;gCAAsB35B,SAAS;;;wBAGnCwD,SAASm2B;;;;YAWrBE,eAAe,SAASjrB;gBACpB,IAAIuqB,aAAavW,QAAQqW,eAAerqB;gBAExC,OAAOwqB,oBAAoBD;;YAQ/BM,kBAAkB,SAAS7qB;gBACvB,IAAI8pB,iBAAiB9pB,QAAQ1W,WAAW;oBACpCwgC,iBAAiB9pB;2BACV8pB,iBAAiB9pB;;;YAQhCqqB,gBAAgB,SAAShkB;gBACrB,OAAOA,SAAS,MAAMujB;;YAY1BsB,oBAAoB,SAASrqB;gBACzB,IAAIuL,SAASvL,KAAKuL,QACd7I,WAAW1C,KAAK0C,UAChBD,SAASzC,KAAKyC,QACdoY,eAAe7a,KAAK6a,cACpByP,aAAatqB,KAAKsqB,YAClB10B,OAAOtR,GAAGoP,UAAU,mBAAmB6X,SAAS,4CAChDyU,MAAMtd;gBAEV,IAAImY,cAAc;oBACdv2B,GAAGqR,WAAW8M,QAAQ7M;uBAErB;oBACDoqB,MAAM17B,GAAGsQ,QAAQ6N,QAAQC;;gBAG7B9M,KAAKC,aAAa,UAAUmqB;gBAC5BpqB,KAAKC,aAAa,UAAUy0B;gBAC5B10B,KAAKnR,MAAMC,UAAU;gBACrByJ,SAASy7B,KAAK9zB,YAAYF;gBAE1B,OAAOA;;YAOXk0B,oBAAoB,SAASS;gBACzB,IAAIvU;gBAEJ;oBACIA,WAAW1xB,GAAGyR,UAAUw0B;kBAE5B,OAAO57B;oBACHlE,IAAI,4DAA4DkE,MAAMjE,UAAU,KAAK;;gBAGzF,OAAOsrB;;;;ICnSnB1xB,GAAGkmC,mBAAmB,SAASxqB;QAC3B;QAEA,IAAImT,UAAUxuB,MACVwqB,YAAYnP,KAAKpD,QAAQuS,WACzBmT,QAAQtiB,KAAKsiB,OACbroB,WAAW+F,KAAKpD,QAAQ3C,UACxBc,SAASiF,KAAKpD,QAAQ7B,QACtB0vB,aAAaxwB,YAAY+F,KAAKpD,QAAQ3C,SAAS8K,WAAWzgB,GAAGkT,kBAAkByC,UAC/EywB,gBAAgB3vB,UAAUiF,KAAKpD,QAAQ7B,OAAOgK,WAAW0lB,cAAcnmC,GAAGkT,kBAAkBuD,QAC5FiK,UAAUsd,MAAMtd,SAChBkC,UAAUob,MAAMpb,SAChBO,UAAU6a,MAAM7a,SAChBf,cAAc4b,MAAM5b,aACpBqK,gBAAgBuR,MAAMvR,eACtBH,gBAAgB0R,MAAM1R,eACtBrB,aAAa+S,MAAM/S,YACnB9kB,MAAM63B,MAAM73B;QAEhB,SAASk6B,MAAMxlB;YACX7a,GAAG+C,KAAK8rB,QAAQqR,SAASrlB,KAAK,SAASwrB,OAAO1xB;gBAC1C,IAAI2xB,gBAAgBzX,QAAQ0X,kBAAkB1rB,IAAIwrB;gBAElD1xB,IAAIonB,qBAAqB;gBACzBpnB,IAAIzK,OAAO2wB,aAAa;gBACxBlmB,IAAI0rB;gBACJiG,iBAAiBA,cAAcxI,YAAYwI,cAAcxI,SAASjjB;;;QAI1E7a,GAAG6B,OAAOxB,MAAM,IAAIL,GAAG+9B,cAAcriB;QAErC1b,GAAGwM,SAASnM,MAAM,SAASsM;YACvB;gBAIIiE,KAAK,SAASiK,IAAI2rB;oBACd,IAAIxmC,GAAGyI,OAAO+9B,gBAAgBxmC,GAAGyJ,OAAO+8B,cAAc;wBAClD75B,OAAOiE,IAAIiK;4BAAK+E,MAAM4mB;;2BAErB,IAAIA,uBAAuBxmC,GAAG8X,WAAW;wBAC1CnL,OAAOiE,IAAIiK;4BAAKmjB,OAAOwI;;2BAEtB;wBACD,MAAM,IAAIhlC,MAAM;;oBAGpBqtB,QAAQ4X,eAAe5rB;oBACvBurB,iBAAiBvX,QAAQ6X,uBAAuB7rB;;gBAGpD0I,SAAS,SAAS1I;oBACdwlB,MAAMxlB;oBACNgU,QAAQ0Q,+BAA+B1kB;oBACvCgU,QAAQ8T,WAAW9nB;oBACnBlO,OAAO4W,QAAQ1I;;;;QAK3B7a,GAAG6B,OAAOxB;YAENq/B,kBAAkB,SAAS7kB,IAAIikB;uBACpBjQ,QAAQwP,cAAcxjB,IAAIrK,KAAKm2B,aAAa7H;;YAGvDuC,UAAU,SAASxmB,IAAIikB;gBACnB,IAAI8H,YAAY/X,QAAQwP,cAAcxjB,IAAIrK;gBAE1C,IAAIo2B,UAAUC,MAAM;2BACTD,UAAUC,KAAK/H;;gBAE1B,IAAI8H,UAAUE,gBAAgB;2BACnBF,UAAUE,eAAehI;;;YAMxCM,gBAAgB,SAASvkB,IAAIksB;gBACzB,IAAIC,eAAenY,QAAQgS,gBAAgBhmB,MAAM,GAC7ClG,MAAMka,QAAQoY,QAAQpsB,IAAImsB;gBAE9B,IAAID,gBAAgB;oBAChB,OAAO,IAAI/mC,GAAG+L,UAAUE,QAAQ86B,eAAepyB,MAAMA;;gBAGzD,OAAO,IAAI3U,GAAG+L,UAAUE,YAAY0I;;YAGxCiN,SAAS,SAAS/G;gBACd,OAAOgU,QAAQ7N,QAAQnG,OAAOgU,QAAQwP,cAAcxjB,IAAI+E;;YAG5DgjB,UAAU,SAAS/nB;gBACf,OAAOgU,QAAQ7N,QAAQnG,OAAOgU,QAAQwP,cAAcxjB,IAAImjB;;YAO5Drb,uBAAuB;gBACnB,IAAIukB;gBAEJrY,QAAQsY,sBAAsB,SAASt3B,KAAK0Q;oBACxCsO,QAAQ0R,0BAA0B,MAAMhgB,WAAW5K,SAASkqB,YAAatf,WAAW5K,SAASmqB;oBAE7F,IAAIh7B;wBACA/C,MAAMwe,WAAWxe;wBACjB+9B,WAAWvf,WAAW5K,SAASmqB;wBAC/BjkB,MAAM0E,WAAW1E;wBACjBb,MAAMuF,WAAWvF;;oBAGrB,IAAIuF,WAAW1Q,KAAK;wBAChB/K,KAAK+K,MAAM0Q,WAAW1Q;;oBAG1Bq3B,mBAAmBhkC,KAAK4B;;gBAG5B,OAAOoiC;;YAGXjD,aAAa,SAASppB;gBAClB,SAASlF,YAAYkZ,QAAQ7N,QAAQnG,QAAQgU,QAAQwP,cAAcxjB,IAAIusB;;YAG3E7G,2BAA2B,SAAS1lB,IAAIwsB,eAAeC;gBACnD,IAAIzH,aAAawH,iBAAiBxY,QAAQwP,cAAcxjB,IAAIlF,SAASkqB,YACjEC,YAAYwH,gBAAgBzY,QAAQwP,cAAcxjB,IAAIlF,SAASmqB;gBAEnE,IAAID,YAAY;oBACZ15B,IAAInG,GAAG8H,OAAO,0DAA0D6J,KAAK0qB,UAAUwD;oBACvFA,WAAW0H;oBACXvnC,GAAG+C,KAAK88B,YAAY,SAAS78B,KAAK87B;wBAC9BgB,UAAUC,QAAQjB;;oBAEtBe,WAAW95B,SAAS;;;YAI5BwQ,OAAO,SAASsE;gBACZ,IAAIgU,QAAQ7N,QAAQnG,KAAK;oBACrB1U,IAAInG,GAAG8H,OAAO,6DAA6D+S,IAAI6F,QAAQ7F;oBACvFgU,QAAQwP,cAAcxjB,IAAI2sB,SAAS;oBACnCnH,MAAMxlB;oBACN,OAAO;;;YAIfimB,oBAAoB,SAASjmB;gBACzB,IAAIlF,YAAYkZ,QAAQ7N,QAAQnG,KAAK;oBACjC,IAAInD,QAAQmX,QAAQwP,cAAcxjB,KAC9B4sB,aACA32B;2BAEG4G,MAAM/B;oBAEb+B,MAAM/B;oBACN8xB,cAAc5Y,QAAQgS,gBAAgBhmB;oBACtC,IAAI4sB,cAAc,KAAK9xB,SAASiiB,WAAW;wBACvClgB,MAAM/B,SAAS8K,UAAU;wBACzB/I,MAAM/B,SAAS+xB,QAAQD;wBACvB/vB,MAAM/B,SAASmqB;wBAEf,KAAKhvB,IAAI,GAAGA,IAAI22B,aAAa32B,KAAK;4BAC9B4G,MAAM/B,SAASmqB,UAAU58B,KAAK4N;;wBAGlC+d,QAAQ4X,eAAe5rB;2BAEtB;wBACDnD,MAAM/B,SAAS8K,UAAU;;;;YAKrC4iB,YAAY,SAASxoB,IAAI8sB;gBACrB,IAAI9Y,QAAQ7N,QAAQnG,KAAK;oBACrBgU,QAAQwP,cAAcxjB,IAAI+E,OAAO+nB;;;YAIzChF,YAAY,SAAS9nB;gBACjB,IAAI+rB,YAAY/X,QAAQwP,cAAcxjB,IAAIrK;gBAE1CxQ,GAAG+C,KAAK6jC,UAAUE,gBAAgB,SAASc;2BAChChB,UAAUE,eAAec;;gBAGpC5nC,GAAG+C,KAAK6jC,UAAUC,MAAM,SAASe;2BACtBhB,UAAUC,KAAKe;;;YAW9BC,YAAY,SAAShtB,IAAIitB;gBACrB,OAAOjZ,QAAQkZ,aAAaltB,IAAIitB,aAAa9nC,GAAGiK;;YAGpDs8B,mBAAmB,SAAS1rB,IAAIitB;gBAC5B,IAAIhJ,WAAWgJ,eAAe,QAAQ,IAAIA;gBAC1C,OAAOjZ,QAAQwP,cAAcxjB,IAAIrK,KAAKs2B,eAAehI;;YAGzDC,eAAe,SAASlkB,IAAImtB;gBACxB,IAAIhQ,YAAYriB,SAASwiB,UACrB8P,WAAWrlB,QAAQ/H,KACnB9P,aAAa8jB,QAAQjN,QAAQ/G,KAC7BqtB,aAAalQ,YAAYgQ,YACzBG,WAAWD,aAAalQ,aAAaiQ,WAAWA,WAAWC,aAAalQ,WACxEyP,cAAc5Y,QAAQgS,gBAAgBhmB,KACtC8rB,eAAetmC,KAAKg+B,cAAcxjB,IAAIrK,KAAKm2B,cAI3Cl7B,OAAOk7B,aAAaqB,eAAehoC,GAAG8K,UAAUC,YAAYm9B,YAAYC;gBAE5ExB,aAAaqB,cAAcv8B;gBAE3B;oBACI28B,MAAMJ;oBACNh9B,OAAOk9B;oBACPj9B,KAAKk9B;oBACLE,OAAOZ;oBACPh8B,MAAMA;oBACNoQ,MAAMssB,WAAWD;;;YAIzBhJ,0BAA0B,SAASnT;gBAC/B;oBACI+L,WAAW/L,UAAUqc;oBACrBE,WAAWvc,UAAU/gB,QAAQ;oBAC7Bu9B,SAASxc,UAAU9gB;oBACnBitB,YAAYnM,UAAUsc;;;YAQ9BG,oBAAoB,SAAS3tB;gBACzB,IAAI4tB,gBAAgB,OAChB1mC,OAAO2e,QAAQ7F,KACfgB,OAAO+G,QAAQ/H,KACfmd,YAAYriB,SAASwiB,UACrB/Z,WAAWgE,YAAYvH;gBAE3B,OAAO7a,GAAG8H,OAAO,4BAA4B+iB,WAAW4d,eAAe1mC,MAAM8Z,MAAMmc,WAAW5Z;;YAGlGsqB,cAAc,SAAS7tB;gBACnB,OAAOgU,QAAQjN,QAAQ/G,IAAIta;;YAG/BooC,qBAAqB,SAAS9tB;gBAC1B,OAAOgU,QAAQwP,cAAcxjB,IAAIlF;;YAOrCkrB,iBAAiB,SAAShmB;gBACtB,IAAIlF,UAAU;oBACV,IAAIsyB,WAAWrlB,QAAQ/H,KACnBmd,YAAYriB,SAASwiB;oBAEzB,OAAOx2B,KAAKinC,KAAKX,WAAWjQ;;;YAIpCiP,SAAS,SAASpsB,IAAIitB;gBAClB,IAAIhJ,WAAWgJ,eAAe,QAAQ,IAAIA;gBAC1C,OAAOjZ,QAAQwP,cAAcxjB,IAAIrK,KAAKq2B,KAAK/H;;YAG/CoB,UAAU,SAASrlB;gBACf,OAAOgU,QAAQwP,cAAcxjB,IAAIrK,KAAKq2B;;YAK1CM,uBAAuB,SAAS13B;gBAC5B,IAAI22B,eAAe;oBACfpmC,GAAG+C,KAAKoS,cAAc,SAAStF,KAAKvI;wBAChC,IAAIuI,IAAIlK,QAAQ3F,GAAG8H,OAAO,cAAc+iB,gBAAgB,GAAG;4BACvD,IAAItK,aAAa5O,KAAKC,MAAMtK;4BAC5BmI,SAASI,KAAK0Q;;;;;YAM9BkmB,gBAAgB,SAAS5rB;gBACrBgU,QAAQwP,cAAcxjB,IAAIrK;oBACtBs2B;oBACA7H;oBACA4H;oBACAF;;;YAIRkC,mBAAmB,SAAShuB;gBACxBgU,QAAQwP,cAAcxjB,IAAIusB,eAAe;;YAK7C7H,gCAAgC,SAAS1kB;gBACrC,IAAIiuB;gBAEJ,IAAI1C,iBAAiBvX,QAAQoV,YAAYppB,KAAK;oBAC1CiuB,iBAAiBja,QAAQ2Z,mBAAmB3tB;oBAE5C,IAAIiuB,kBAAkB3zB,aAAarF,QAAQg5B,iBAAiB;wBACxD3zB,aAAa4zB,WAAWD;wBACxB,OAAO;;;gBAIf,OAAO;;YAKXpC,wBAAwB,SAAS7rB;gBAC7B,IAAInD,QAAQmX,QAAQwP,cAAcxjB,KAC9BiuB,gBAAgBE;gBAIpB,IAAI5C,iBAAiB1uB,MAAM7H,QAAQ1L,WAAW;oBAC1C2kC,iBAAiBja,QAAQ2Z,mBAAmB3tB;oBAC5CmuB,gBAAgB7zB,aAAarF,QAAQg5B;oBAGrC,IAAIE,eAAe;wBACfA,gBAAgBr3B,KAAKC,MAAMo3B;wBAI3B,IAAIvc,cAAcuc,cAAchuB,OAAO;4BACnC6T,QAAQga,kBAAkBhuB;+BAEzB;4BACD1U,IAAInG,GAAG8H,OAAO,2DAA2D+S,IAAI6F,QAAQ7F;4BAErFyR,cAAczR,IAAImuB,cAAchuB;4BAEhCtD,MAAM7H,MAAMm5B,cAAcn5B;4BAC1B6H,MAAM/B,WAAWqzB,cAAcrzB;4BAC/B+B,MAAMwT,SAAS8d,cAAc9d;4BAC7BxT,MAAMsnB,mBAAmB;4BAEzBnQ,QAAQ0R,0BAA0B1lB;;;;;YAOlDumB,2BAA2B,SAASvmB;gBAChC,IAAInD,QAAQmX,QAAQwP,cAAcxjB,KAC9BiuB,gBAAgBE;gBAGpB,IAAI5C,iBAAiBvX,QAAQoV,YAAYppB,KAAK;oBAC1CiuB,iBAAiBja,QAAQ2Z,mBAAmB3tB;oBAE5CmuB;wBACIjnC,MAAM2e,QAAQ7F;wBACdgB,MAAM+G,QAAQ/H;wBACdG,MAAMmI,QAAQtI;wBACdhL,KAAK6H,MAAM7H;wBACX8F,UAAU+B,MAAM/B;wBAChBuV,QAAQxT,MAAMwT;wBACd+d,aAAarL,KAAK+F;;oBAGtB;wBACIxuB,aAAaC,QAAQ0zB,gBAAgBn3B,KAAK0qB,UAAU2M;sBAExD,OAAO3+B;wBACHlE,IAAInG,GAAG8H,OAAO,2DAA2D+S,IAAIxQ,MAAM1D,aAAa;;;;YAK5GuiC,0BAA0B,SAASruB,IAAIikB,UAAU9G;gBAC7C,IAAIrjB,MAAMka,QAAQoY,QAAQpsB,IAAIikB,WAC1B/8B,OAAO2e,QAAQ7F,KACfsuB;oBACI3G,QAAQ,SAAStX,QAAQC;wBACrB,IAAI8c,WAAWrlB,QAAQ/H;wBAEvB,IAAIqQ,WAAWC,OAAO;4BAClBF,WAAWpQ,IAAI9Y,MAAMkmC,UAAUA;+BAE9B;4BACDhd,WAAWpQ,IAAI9Y,MAAOmpB,UAAU+c,WAAWA,WAAW,IAAI/c,QAAS+c;;;oBAI3EpJ,SAAS,SAAS3T,QAAQC;wBACtB,IAAI8T,gBAAgBpQ,QAAQwP,cAAcxjB,IAAIrK,KAAKyuB,eAC/CmK,iCAAiCva,QAAQwP,cAAcxjB,IAAIqQ,QAC3Dme,mBAAmBne,QACnBoe,kBAAkBne,OAClB8M,gBAAgBrV,QAAQ/H,KACxB0uB,uBAAuBF,oBAAoBC,kBAAkBtR,YAC7DwR,qBAAqBJ;wBAEzBnK,cAAcH,YAAYyK;wBAE1BvpC,GAAG+C,KAAKk8B,eAAe,SAASH,UAAU2K;4BACtCD,sBAAsBC;;wBAG1Bxe,WAAWpQ,IAAI9Y,MAAMynC,oBAAoBvR;;;gBAIrDtjB,IAAIzK,OAAO2wB,aAAa,SAAS3rB;oBAC7B,IAAIA,EAAEstB,kBAAkB;wBAEpB,IAAIj8B,OAAOy3B,aAAa,OAAO,WAAW;wBAC1CmR,mBAAmB5oC,MAAM2O,EAAEgc,QAAQhc,EAAEic;;;;YAcjD4c,cAAc,SAASltB,IAAIitB,aAAanzB,KAAK+0B;gBACzC,IAAIC,SAAS7B,eAAe,QAAQ,IAAIA,aACpClB,YAAY/X,QAAQwP,cAAcxjB,IAAIrK;gBAE1Co2B,UAAUC,OAAOD,UAAUC;gBAC3BD,UAAUE,iBAAiBF,UAAUE;gBAErCF,UAAUC,KAAK8C,UAAUh1B;gBAEzB,IAAI+0B,kBAAkB;oBAClB9C,UAAUE,eAAe6C,UAAUD;;gBAGvC,OAAO/0B;;YAIXsuB,+BAA+B;gBAC3B,IAAI2G,iBAAiBnzB,OAAO2hB;gBAE5BvJ,QAAQsY,sBAAsB,SAASt3B,KAAK0Q;oBACxC,IAAIspB,iBAAiB,IAAIjM,KAAKrd,WAAW0oB;oBAGzCY,eAAeC,QAAQD,eAAeE,YAAYH;oBAElD,IAAIC,eAAehM,aAAaD,KAAK+F,OAAO;wBACxCx9B,IAAI,6CAA6C0J;wBACjDsF,aAAa4zB,WAAWl5B;;;;YAWpCg0B,sBAAsB,SAAShpB;gBAC3B,IAAInD,QAAQmX,QAAQwP,cAAcxjB;gBAElC,KAAKnD,MAAM/B,UAAU;oBACjBkZ,QAAQiS,mBAAmBjmB;;gBAG/B,OAAOnD,MAAM/B,SAAS8K;;;;ICxflCzgB,GAAGgnB,0BAA0B,SAAS7O;QAClC;QAEA,IAAI6xB,WACA1xB;YACI2O,QAAQ;YACRG,eAAe;YACfK;YACAN,gBAAgB;YAChBI,eAAe,SAAS1M;gBAAK;;YAC7B2M;YACAE;gBACIsI,UAAU;gBACVuI,iBAAiB;;YAErBpyB,KAAK,SAAS4B,KAAK1B;YACnBshB,UAAU,SAAS9M;YACnBgN,kBAAkB,SAAShN,IAAIiN,UAAUC;;QAGjD/nB,GAAG6B,OAAOyW,SAASH;QAEnB,SAAS8xB;YACL,IAAI3xB,QAAQ2O,OAAOC,kBAAkB,QAAQ;gBACzC;oBACIgjB,SAAS;;;YAIjB;;QAGJF,YAAYhqC,GAAG6B,OAAOxB,MAAM,IAAIL,GAAGs5B;YAC/BI,cAAc;YACdC,gBAAe,QAAQ;YACvB1S,QAAQ3O,QAAQ2O;YAChBQ,eAAenP,QAAQmP;YACvBD,aAAalP,QAAQkP;YACrBqS,gBAAgBoQ;YAChB9iB,gBAAgB7O,QAAQ6O;YACxBI,eAAe,SAAS1M;gBACpB,OAAOvC,QAAQiP,cAAcjF,IAAIzH;;YAErC1U,KAAKmS,QAAQnS;YACbk0B,QAAQ/hB,QAAQqP;YAChB0D,YAAY/S,QAAQuP;YACpBH,MAAMpP,QAAQoP;;QAGlB1nB,GAAG6B,OAAOxB;YACNszB,YAAY,SAAS9Y,IAAIG,MAAMuY;gBAC3B,IAAI3I,oBAAoB2I;gBAExBjb,QAAQnS,IAAI,wCAAwC0U;gBAEpD,IAAIvC,QAAQ2O,WAAW,UAAU;oBAC7B+iB,UAAUjN,cAAcliB,IACnBqiB,SAASliB,MACToiB,WAAWxS,mBACXwR;uBAEJ;oBACDxR,kBAAkBtS,QAAQ8O,iBAAiBpM;oBAC3CgvB,UAAUjN,cAAcliB,IACnBuiB,WAAWxS,mBACXwR;;;;;KCpDrB;QAMI,SAAS+N,kBAAkBC;YACvB,IAAIC,KAAKD,IAAIE,cACTC,KAAKH,IAAII,eACTnmC,SAASwF,SAASC,cAAc,WAChC2gC;YAEJ,IAAIJ,KAAKE,KAAK,OAAO,MAAM;gBACvBlmC,OAAOqmC,QAAQrmC,OAAOqV,SAAS;gBAC/B+wB,MAAMpmC,OAAOsmC,WAAW;gBACxBF,IAAIG,UAAUR,MAAMC,KAAK,GAAG;gBAI5B,OAAOI,IAAII,aAAa,GAAG,GAAG,GAAG,GAAG/lC,KAAK,OAAO;mBAC7C;gBACH,OAAO;;;QAQf,SAASgmC,qBAAqBV,KAAKC,IAAIE;YACnC,IAAIlmC,SAASwF,SAASC,cAAc,WAChCihC,KAAK,GACLC,KAAKT,IACLU,KAAKV,IACLE,KAAK3lC,MAAMomC,OAAOC;YAEtB9mC,OAAOqmC,QAAQ;YACfrmC,OAAOqV,SAAS6wB;YAChBE,MAAMpmC,OAAOsmC,WAAW;YACxBF,IAAIG,UAAUR,KAAK,GAAG;YACtBtlC,OAAO2lC,IAAII,aAAa,GAAG,GAAG,GAAGN,IAAIzlC;YAGrC,OAAOmmC,KAAKF,IAAI;gBACZG,QAAQpmC,MAAMmmC,KAAK,KAAK,IAAI;gBAC5B,IAAIC,UAAU,GAAG;oBACbF,KAAKC;uBACF;oBACHF,KAAKE;;gBAETA,KAAMD,KAAKD,MAAO;;YAGtBI,QAASF,KAAKV;YACd,OAAQY,UAAU,IAAK,IAAIA;;QAM/B,SAASC,qBAAqBhB,KAAK3+B,MAAM6M,SAAS+yB;YAC9C,IAAIhnC,SAASwF,SAASC,cAAc,WAChCxF,OAAOgU,QAAQhU,QAAQ,cACvBwH,UAAU,IAAI9L,GAAG+L;YAErBu/B,oBAAoBlB,KAAK3+B,MAAMpH,QAAQiU,SAAS+yB,UAC3Cj0B,KAAK;gBACFtL,QAAQG,QACJ5H,OAAOI,UAAUH,MAAMgU,QAAQ/T,WAAW;;YAItD,OAAOuH;;QAGX,SAASy/B,oCAAoC7vB;YACzC,IAAI8vB,YAAY;YAEhB,KAAKxrC,GAAG0O,OAAO;gBACX,MAAM,IAAI1O,GAAGwB,MAAM;;YAGvB,IAAIka,KAAK+vB,aAAa/vB,KAAKgwB,YAAYF,WAAW;gBAC9C;oBACIG,WAAWhqC,KAAKC,MAAMD,KAAKiqC,KAAKJ,aAAa9vB,KAAK+vB,aAAa/vB,KAAKgwB;oBACpEG,UAAUlqC,KAAKC,MAAMD,KAAKiqC,KAAKJ,aAAa9vB,KAAKgwB,YAAYhwB,KAAK+vB;;;;QAQ9E,SAASH,oBAAoBlB,KAAK3+B,MAAMpH,QAAQiU,SAAS+yB;YACrD,IAAIhB,KAAKD,IAAIE,cACTC,KAAKH,IAAII,eACTE,QAAQpyB,QAAQoyB,OAChBhxB,SAASpB,QAAQoB,QACjB+wB,MAAMpmC,OAAOsmC,WAAW,OACxB7+B,UAAU,IAAI9L,GAAG+L,WACjB+/B;YAEJrB,IAAIsB;YAEJ,IAAIzzB,QAAQ0zB,QAAQ;gBAChB,OAAOC;oBACHxgC,MAAMA;oBACNpH,QAAQA;oBACRsxB,OAAOyU;oBACP8B,aAAa3B;oBACb4B,YAAY9B;oBACZ+B,aAAa9zB,QAAQ8zB;oBACrBJ,QAAQ1zB,QAAQ0zB;oBAChBK,cAAc3yB;oBACd4yB,aAAa5B;;;YAIrB,KAAK1qC,GAAGkT,kBAAkB0D,0BAA0B;gBAChDk1B,qBAAqBP;oBACjBG,WAAWhB;oBACXe,YAAY/xB;;gBAGhB,IAAIoyB,oBAAoB;oBACpB9rC,GAAGmG,IAAInG,GAAG8H,OAAO,kFACb4iC,OAAOhxB,QAAQoyB,mBAAmBD,UAAUC,mBAAmBH,YAC/D;oBAEJjB,QAAQoB,mBAAmBD;oBAC3BnyB,SAASoyB,mBAAmBH;;;YAIpCY,oBAAoBloC,QAAQqmC,OAAOhxB,QAAQpB,QAAQ8zB;YAInD,IAAIpsC,GAAG0O,OAAO;iBACT;oBACG,IAAIy7B,kBAAkBC,MAAM;wBACxBC,MAAM;wBACNE,MAAM;;oBAGV,IAAIiC,IAAI,MACJC,YAAY5iC,SAASC,cAAc,WACnC4iC,kBAAkBrB,WAAWP,qBAAqBV,KAAKC,IAAIE,MAAM,GACjEoC,KAAKhrC,KAAKinC,KAAK4D,IAAI9B,QAAQL,KAC3BuC,KAAKjrC,KAAKinC,KAAK4D,IAAI9yB,SAAS6wB,KAAKmC,kBACjC3B,KAAK,GACL8B,KAAK,GACLC,QAAQC,IAAIC;oBAEhBP,UAAU/B,QAAQ+B,UAAU/yB,SAAS8yB;oBACrCM,SAASL,UAAU9B,WAAW;oBAE9B,OAAOI,KAAKR,IAAI;wBACZwC,KAAK;wBACLC,KAAK;wBACL,OAAOD,KAAK1C,IAAI;4BACZyC,OAAOG,UAAU,GAAG,GAAGT,GAAGA;4BAC1BM,OAAOlC,UAAUR,MAAM2C,KAAKhC;4BAC5BN,IAAIG,UAAU6B,WAAW,GAAG,GAAGD,GAAGA,GAAGQ,IAAIH,IAAIF,IAAIC;4BACjDG,MAAMP;4BACNQ,MAAML;;wBAEV5B,MAAMyB;wBACNK,MAAMD;;oBAEVnC,IAAIyC;oBACJT,YAAYK,SAAS;;mBAGxB;gBACDrC,IAAIG,UAAUR,KAAK,GAAG,GAAGM,OAAOhxB;;YAGpCrV,OAAO8oC,mBAAmB9oC,OAAO8oC;YACjCrhC,QAAQG;YAER,OAAOH;;QAGX,SAASmgC,qCAAqCmB;YAC1C,IAAI3hC,OAAO2hC,WAAW3hC,MAClBkqB,QAAQyX,WAAWzX,OACnBuW,cAAckB,WAAWlB,aACzBC,aAAaiB,WAAWjB,YACxBC,cAAcgB,WAAWhB,aACzBtgC,UAAU,IAAI9L,GAAG+L,WACjBigC,SAASoB,WAAWpB,QACpBqB,eAAexjC,SAASC,cAAc,WACtCwjC,sBAAsBD,aAAa1C,WAAW,OAC9C4C,eAAeH,WAAW/oC,QAC1BgoC,eAAee,WAAWf,cAC1BC,cAAcc,WAAWd;YAE7BC,oBAAoBc,cAAclB,YAAYD,aAAaE;YAE3DmB,aAAa7zB,SAAS2yB;YACtBkB,aAAa7C,QAAQ4B;YAErBgB,oBAAoB1C,UAAUjV,OAAO,GAAG;YAExCqW;gBACIvgC,MAAMA;gBACNiO,QAAQ2yB;gBACR1W,OAAOA;gBACP0X,cAAcA;gBACdE,cAAcA;gBACd7C,OAAO4B;eAENl1B,KACG,SAASnL;gBACLshC,aAAaJ,mBAAmBI,aAAaJ;gBAC7CrhC,QAAQG;eAEZH,QAAQK;YAGhB,OAAOL;;QAOX,SAASygC,oBAAoBloC,QAAQqmC,OAAOhxB,QAAQ0yB;YAChD,QAAQA;cACJ,KAAK;cACL,KAAK;cACL,KAAK;cACL,KAAK;gBACD/nC,OAAOqmC,QAAQhxB;gBACfrV,OAAOqV,SAASgxB;gBAChB;;cACJ;gBACIrmC,OAAOqmC,QAAQA;gBACfrmC,OAAOqV,SAASA;;YAExB,IAAI+wB,MAAMpmC,OAAOsmC,WAAW;YAC5B,QAAQyB;cACJ,KAAK;gBAED3B,IAAI+C,UAAU9C,OAAO;gBACrBD,IAAI9oB,OAAO,GAAG;gBACd;;cACJ,KAAK;gBAED8oB,IAAI+C,UAAU9C,OAAOhxB;gBACrB+wB,IAAIgD,OAAO9rC,KAAK+rC;gBAChB;;cACJ,KAAK;gBAEDjD,IAAI+C,UAAU,GAAG9zB;gBACjB+wB,IAAI9oB,MAAM,IAAI;gBACd;;cACJ,KAAK;gBAED8oB,IAAIgD,OAAO,KAAM9rC,KAAK+rC;gBACtBjD,IAAI9oB,MAAM,IAAI;gBACd;;cACJ,KAAK;gBAED8oB,IAAIgD,OAAO,KAAM9rC,KAAK+rC;gBACtBjD,IAAI+C,UAAU,IAAI9zB;gBAClB;;cACJ,KAAK;gBAED+wB,IAAIgD,OAAO,KAAM9rC,KAAK+rC;gBACtBjD,IAAI+C,UAAU9C,QAAQhxB;gBACtB+wB,IAAI9oB,OAAO,GAAG;gBACd;;cACJ,KAAK;gBAED8oB,IAAIgD,QAAQ,KAAM9rC,KAAK+rC;gBACvBjD,IAAI+C,WAAW9C,OAAO;gBACtB;;cACJ;gBACI;;;QAOZ,SAASiD,aAAaC,UAAUC;YAC5B,IAAIz1B,OAAO/X;YAEX,IAAI2E,OAAOO,QAAQqoC,oBAAoBroC,MAAM;iBACxC;oBACG,IAAI6kC,MAAM,IAAI0D,SACVC,MAAM/oC,OAAO+oC,OAAO/oC,OAAO+oC,IAAIC,kBAAkBhpC,OAAO+oC,MACpD/oC,OAAOipC,aAAajpC,OAAOipC,UAAUD,kBAAkBhpC,OAAOipC,YAAY;oBAClF,KAAKF,KAAK;wBAAE,MAAMvsC,MAAM;;oBACxB4oC,IAAI8D,MAAMH,IAAIC,gBAAgBJ;oBAC9Bx1B,KAAK3M,OAAOmiC;oBACZA,WAAWxD;;;YAGnB,KAAKwD,SAAStD,iBAAiBsD,SAASpD,eAAe;gBACnDoD,SAAS5hC,SAAS;oBACd,IAAImiC,YAAY/1B,KAAKg2B;oBACrB,IAAID,WAAW;wBACX/1B,KAAKg2B,qBAAqB;wBAG1B1kB,WAAW;4BACP,KAAK,IAAI5Y,IAAI,GAAG5D,MAAMihC,UAAUpoC,QAAQ+K,IAAI5D,KAAK4D,KAAK;gCAClDq9B,UAAUr9B;;2BAEf;;;gBAGX88B,SAAS1hC,UAAU2hC;gBACnBxtC,KAAK+tC;;YAET/tC,KAAKutC,WAAWA;;QAMpBD,aAAajnC,UAAU2nC,SAAS,SAAS5hC,QAAQ6L;YAC7CA,UAAUA;YAEV,IAAIF,OAAO/X,MACPiuC,WAAWjuC,KAAKutC,SAAStD,cACzBiE,YAAYluC,KAAKutC,SAASpD,eAC1BE,QAAQpyB,QAAQoyB,OAChBhxB,SAASpB,QAAQoB,QACjBgd,WAAWpe,QAAQoe,UACnBD,YAAYne,QAAQme,WACpB4U,YAAYhrC,KAAKoL,QAAQpL,KAAKoL,KAAKlL,SAAS,cAC5CiJ,UAAUiD,OAAOjD,QAAQF,eACzBklC;YAEJ,IAAInuC,KAAK+tC,oBAAoB;gBACzB/tC,KAAK+tC,mBAAmBlrC,KAAK;oBAAakV,KAAKi2B,OAAO5hC,QAAQ6L;;gBAC9D;;YAGJ,IAAIoyB,UAAUhxB,QAAQ;gBAClBA,SAAU60B,YAAY7D,QAAQ4D,YAAa;mBACxC,IAAI50B,WAAWgxB,OAAO;gBACzBA,QAAS4D,WAAW50B,SAAS60B,aAAc;mBACxC;gBACH7D,QAAQ4D;gBACR50B,SAAS60B;;YAEb,IAAI7X,YAAYgU,QAAQhU,UAAU;gBAC9BgU,QAAQhU;gBACRhd,SAAU60B,YAAY7D,QAAQ4D,YAAa;;YAE/C,IAAI7X,aAAa/c,SAAS+c,WAAW;gBACjC/c,SAAS+c;gBACTiU,QAAS4D,WAAW50B,SAAS60B,aAAc;;YAG/CC;gBAAQ9D,OAAOA;gBAAOhxB,QAAQA;eAC9B1Z,GAAG+C,KAAKuV,SAAS,SAASm2B,YAAYC;gBAClCF,IAAIC,cAAcC;;YAGtB,IAAIllC,YAAY,OAAO;iBAClB;oBACG,IAAImlC,eAAeliC,OAAOyhC;oBAC1B9C,qBAAqBhzB,KAAKw1B,UAAUx1B,KAAK3M,MAAM+iC,KAAKnD,UAC/Cj0B,KAAK,SAAS1S;wBACX+H,OAAOyhC,MAAMxpC;wBACbiqC,iBAAiBliC,OAAOyhC,OAAOzhC,OAAOT;;;mBAG/C,IAAIxC,YAAY,UAAU;gBAC7B8hC,oBAAoBjrC,KAAKutC,UAAUvtC,KAAKoL,MAAMgB,QAAQ+hC,KAAKnD;;YAE/D,WAAWhrC,KAAKuuC,aAAa,YAAY;gBACrCvuC,KAAKuuC,SAASniC;;;QAItBzM,GAAG2tC,eAAeA;;ICtYtB3tC,GAAGi5B,iBAAiB,SAAS9yB;QACzB;QAEA,SAAS0oC,MAAMC;YACX,OAAOA,GAAGtlC,QAAQF,kBAAkB;;QAGxC,SAASylC,SAASD;YACd,OAAOA,GAAGtlC,QAAQF,kBAAkB;;QAGxC,SAAS0lC;YACL,OAAO,IAAIlB,QAAQmB,gBAAgB9qC;;QAGvC,SAAS+qC;YACL,IAAI7qC,SAASwF,SAASC,cAAc;YAEpC,OAAOzF,OAAOsmC,cAActmC,OAAOsmC,WAAW;;QAMlD,SAASwE,wBAAwBC;YAE7B,IAAIC,eAAeD,aAAa1pC,MAAM,MAClC3D,OAAOstC,aAAaA,aAAatpC,SAAS,GAAGL,MAAM,KAAK,IACxD0pB,YAAYpvB,GAAG8R,aAAa/P;YAEhCqtB,YAAYA,aAAaA,UAAU9lB;YAEnC,QAAQ8lB;cACJ,KAAK;cACL,KAAK;gBACD,OAAO;;cACX,KAAK;gBACD,OAAO;;cACX,KAAK;gBACD,OAAO;;cACX,KAAK;gBACD,OAAO;;cACX,KAAK;cACL,KAAK;gBACD,OAAO;;;QASnB,SAASkgB,cAAc5T;YACnB,IAAI6T,eAAe1lC,SAASC,cAAc,MACtC0lC,gBAAgBC,gBAAgBC;YAEpCH,aAAaI,OAAOjU;YAEpB8T,iBAAiBD,aAAaK;YAC9BF,aAAaH,aAAaM;YAC1BJ,iBAAiBF,aAAaO;YAE9B,IAAIN,eAAelmC,kBAAkBtE,OAAO+qC,SAASH,SAAStmC,eAAe;gBACzE,OAAO;;YAGX,IAAImmC,eAAenmC,kBAAkBtE,OAAO+qC,SAASD,SAASxmC,eAAe;gBACzE,OAAO;;YAIX,IAAIomC,eAAe1qC,OAAO+qC,SAASF,SAAS7vC,GAAGyN,MAAM;gBACjD,OAAO;;YAGX,OAAO;;QAGX,SAASuiC,yBAAyB5F,KAAKt+B;YACnCs+B,IAAIp+B,SAAS;gBACTo+B,IAAIp+B,SAAS;gBACbo+B,IAAIl+B,UAAU;gBACdJ,QAAQG,QAAQm+B;;YAGpBA,IAAIl+B,UAAU;gBACVk+B,IAAIp+B,SAAS;gBACbo+B,IAAIl+B,UAAU;gBACd/F,IAAI,8BAA8B;gBAClC2F,QAAQK,QAAQi+B,KAAK;;;QAI7B,SAAS6F,gCAAgC5rC,QAAQyH;YAO7CzH,OAAO8oC,kBAAkB;gBACrBrhC,QAAQG,QAAQ5H;;;QAQxB,SAAS6rC,kCAAkC/uB,aAAarV;YACpD,IAAIqkC,aAAatB,MAAM1tB,gBAAgB4tB,SAAS5tB;YAEhD,IAAI0tB,MAAM1tB,cAAc;gBACpB6uB,yBAAyB7uB,aAAarV;mBAErC,IAAIijC,SAAS5tB,cAAc;gBAC5B8uB,gCAAgC9uB,aAAarV;mBAE5C;gBACDA,QAAQK,QAAQgV;gBAChBhb,IAAInG,GAAG8H,OAAO,kDAAkDqZ,YAAY3X,UAAU;;YAG1F,OAAO2mC;;QAKX,SAASC,KAAKrlC,YAAY8W,WAAWvJ;YACjC,IAAI+3B,cAAc,IAAIrwC,GAAG+L,WACrByc,aAAa,IAAIxoB,GAAGswC,SAASvlC,YAAY5E,MACzCib,UAAU9I,QAAQ8I,SAElBuX,SAASrgB,QAAQqgB,UAAU,OAAO,OAAOrgB,QAAQqgB,QACjD4X,sBAAsB;gBAClB1uB,UAAU3V,UAAU;gBACpB2V,UAAU7V,SAAS;gBACnB7F,IAAI,oDAAoD;gBACxDkqC,YAAYlkC,QAAQ0V,WAAW;;YAGvC2G,WAAWgoB,gBAAgBp5B,KACvB,SAAS9S;gBAGL,IAAImsC;oBACI7+B,OAAO;wBACH,OAAO,IAAI5R,GAAG+L,UAAUE;;mBAGhCykC,OAAO/X,SAAS,IAAI34B,GAAG2wC,KAAK5lC,YAAY5E,OAAOsqC,WAC/CG,QAAQ,IAAI5wC,GAAG2tC,aAAa5iC,YAAYwlC;gBAE5C,IAAIL,kCAAkCruB,WAAWwuB,cAAc;oBAC3DK,KAAK9+B,QAAQwF,KACT,SAASs5B;wBACL,IAAItE,cAAcsE,QAAQA,KAAKG;wBAE/BD,MAAMvC,OAAOxsB;4BACT6U,UAAUtV;4BACVqV,WAAWrV;4BACXgrB,aAAaA;4BACb9nC,MAAMA;4BACN0nC,QAAQ1zB,QAAQgJ;;uBAIxB,SAASwvB;wBACL3qC,IAAInG,GAAG8H,OAAO,kEAAkEgpC;wBAEhFF,MAAMvC,OAAOxsB;4BACT6U,UAAUtV;4BACVqV,WAAWrV;4BACX9c,MAAMA;4BACN0nC,QAAQ1zB,QAAQgJ;;;;eAOpC;gBACInb,IAAI;gBACJkqC,YAAYlkC,QAAQ0V,WAAW;;YAIvC,OAAOwuB;;QAGX,SAASU,yBAAyBrV,KAAKsV,aAAaZ,MAAMhvB,SAASE;YAC/D,IAAI2vB,UAAU,IAAInD,SACdoD,gBAAgB,IAAIlxC,GAAG+L;YAE3BmkC,kCAAkCe,SAASC;YAE3C,IAAI5B,cAAc5T,MAAM;gBACpBuV,QAAQhC,cAAc;;YAG1BgC,QAAQ/C,MAAMxS;YAEdwV,cAAc95B,KACV,SAAS+5B;gBACLjB,kCAAkCc,aAAaZ;gBAE/C,IAAIQ,QAAQ,IAAI5wC,GAAG2tC,aAAasD;gBAChCL,MAAMvC,OAAO2C;oBACTta,UAAUtV;oBACVqV,WAAWrV;oBACX9c,MAAM6qC,wBAAwBzT;oBAC9BsQ,QAAQ1qB;;eAIhB8uB,KAAKjkC;;QAIb,SAASilC,+BAA+B1V,KAAK0O,KAAKgG,MAAMhvB;YACpD8uB,kCAAkC9F,KAAKgG;YAKvCpwC,GAAGoqC,KAAK9oC;gBACJo1B,UAAUtV,UAAU;gBACpBqV,WAAWrV,UAAU;;YAGzBgpB,IAAI8D,MAAMxS;;QAWd,SAAS2V,YAAY3V,KAAK7Z,WAAWvJ;YACjC,IAAI83B,OAAO,IAAIpwC,GAAG+L,WACd4V,QAAQrJ,QAAQqJ,OAChBP,UAAUO,QAAQrJ,QAAQ8I,UAAU;YAGxC,IAAIO,SAASktB,MAAMhtB,YAAY;gBAG3B,IAAIqtB,qBAAqB;oBAIrB,IAAII,cAAc5T,SAASsT,sBAAsB;wBAC7CoC,+BAA+B1V,KAAK7Z,WAAWuuB,MAAMhvB;2BAEpD;wBACD2vB,yBAAyBrV,KAAK7Z,WAAWuuB,MAAMhvB;;uBAGlD;oBACDgwB,+BAA+B1V,KAAK7Z,WAAWuuB,MAAMhvB;;mBAIxD,IAAI2tB,SAASltB,YAAY;gBAC1BkvB,yBAAyBrV,KAAK7Z,WAAWuuB,MAAMhvB;mBAG9C,IAAI8uB,kCAAkCruB,WAAWuuB,OAAO;gBACzDvuB,UAAUqsB,MAAMxS;;YAGpB,OAAO0U;;QAGXpwC,GAAG6B,OAAOxB;YAWNyhB,UAAU,SAASwvB,eAAezvB,WAAWvJ;gBACzC,IAAItY,GAAGwH,SAAS8pC,gBAAgB;oBAC5BnrC,IAAI;oBACJ,OAAOkrC,YAAYC,eAAezvB,WAAWvJ;uBAE5C;oBACDnS,IAAI;oBACJ,OAAOiqC,KAAKkB,eAAezvB,WAAWvJ;;;;QAMlDjY,KAAKkxC;QACLlxC,KAAKkxC,SAAS1C,QAAQA;QACtBxuC,KAAKkxC,SAASxC,WAAWA;QACzB1uC,KAAKkxC,SAASjC,gBAAgBA;QAC9BjvC,KAAKkxC,SAASpC,0BAA0BA;;IChT5CnvC,GAAG2wC,OAAO,SAAS5lC,YAAY5E;QAC3B;QAGA,IAAIqrC,YAAW,OACXC;YACIC;gBACI3vC,MAAM;gBACNsJ,OAAO;;;QAKnB,SAASsmC,kBAAkBC;YACvB,IAAIjvC,SAAS,GACTkvC,MAAM;YAEV,OAAOD,IAAI7rC,SAAS,GAAG;gBACnBpD,UAAUy/B,SAASwP,IAAIrpC,UAAU,GAAG,IAAI,MAAM5G,KAAKkwC,IAAI,GAAGA;gBAC1DD,MAAMA,IAAIrpC,UAAU,GAAGqpC,IAAI7rC;gBAC3B8rC,OAAO;;YAGX,OAAOlvC;;QAKX,SAASmvC,WAAWC,QAAQjmC;YACxB,IAAIkmC,YAAYD,QACZE,aAAanmC;YACjB,IAAIkmC,cAAc7tC,WAAW;gBACzB6tC,YAAY;gBACZC,aAAa,IAAIjyC,GAAG+L;;YAGxB/L,GAAGwL,cAAcT,YAAYinC,WAAW,GAAG56B,KAAK,SAASw6B;gBACrD,IAAIp9B,QAAQ,cAAcvQ,KAAK2tC,MAC3BM;gBAEJ,IAAI19B,OAAO;oBACP,IAAIA,MAAM,OAAO,KAAK;wBAClB09B,gBAAgB9P,SAASwP,IAAI1pC,MAAM,GAAG,IAAI;wBAC1C4pC,WAAWE,YAAYE,gBAAgB,GAAGD;2BAEzC;wBACDA,WAAWhmC,QAAQ+lC;;uBAGtB;oBACDC,WAAW9lC,QAAQ;;;YAI3B,OAAO8lC;;QAIX,SAASE;YACL,IAAIrmC,UAAU,IAAI9L,GAAG+L;YAErB/L,GAAGwL,cAAcT,YAAY,GAAG,GAAGqM,KAAK,SAASw6B;gBAC7C,IAAIA,IAAIjsC,QAAQ,YAAY,GAAG;oBAC3BmG,QAAQK,QAAQ;uBAEf;oBACD2lC,aAAa16B,KAAK,SAAS26B;wBACvBjmC,QAAQG,QAAQ8lC;uBAEpB,SAAS1nC;wBACLyB,QAAQK,QAAQ9B;;;;YAK5B,OAAOyB;;QAIX,SAASsmC,eAAeC;YACpB,IAAIvmC,UAAU,IAAI9L,GAAG+L;YAErB/L,GAAGwL,cAAcT,YAAYsnC,YAAY,IAAI,GAAGj7B,KAAK,SAASw6B;gBAC1D9lC,QAAQG,QAAQ2lC,QAAQ;;YAG5B,OAAO9lC;;QAIX,SAASwmC,iBAAiBD,WAAWE;YACjC,IAAIzmC,UAAU,IAAI9L,GAAG+L;YAErB/L,GAAGwL,cAAcT,YAAYsnC,YAAY,IAAI,GAAGj7B,KAAK,SAASw6B;gBAC1D,IAAIW,cAAc;oBACd,OAAOzmC,QAAQG,QAAQ0lC,kBAAkBC;uBAExC;oBACD9lC,QAAQG,QAAQm2B,SAASwP,KAAK;;;YAItC,OAAO9lC;;QAIX,SAAS0mC,OAAOH,WAAWI;YACvB,IAAIV,SAASM,YAAY,IACrBhnC,QAAQonC,aAAa;YAEzB,OAAOzyC,GAAGwL,cAAcT,YAAYgnC,QAAQ1mC;;QAIhD,SAASqnC,cAAcC;YACnB,IAAI/3B,cACAm3B,SAAS;YAEb,OAAOA,SAAS,MAAMY,OAAO5sC,QAAQ;gBACjC6U,QAAQ1X,KAAKyvC,OAAOzqC,MAAM6pC,QAAQA,SAAS;gBAC3CA,UAAU;;YAGd,OAAOn3B;;QAIX,SAASg4B,aAAaL,cAAcE;YAChC,IAAII,iBAAiB,IACjBC,aAAa9yC,GAAG6B,WAAW2vC,UAC3BuB;YAEJ/yC,GAAG+C,KAAK0vC,YAAY,SAASzvC,KAAKq2B;gBAC9B,IAAI2Z,QAAQ3Z,MAAMnxB,MAAM,GAAG,IACvB2S,KAAK03B,eAAeZ,kBAAkBqB,SAAS5Q,SAAS4Q,OAAO,KAC/DC,gBAAgBH,WAAWntC,QAAQkV,KACnCq4B,WAAW1pC,SAAS2pC;gBAExB,IAAIF,iBAAiB,GAAG;oBACpBzpC,UAAUioC,SAAS52B,IAAI9Y;oBACvBoxC,eAAe1B,SAAS52B,IAAIxP;oBAC5B6nC,YAAY7Z,MAAMnxB,MAAM2qC,gBAAgBA,iBAAkBM,eAAe;oBACzEJ,KAAKvpC,WAAW+oC,eAAeZ,kBAAkBuB,aAAa9Q,SAAS8Q,WAAW;oBAElFJ,WAAWv2B,OAAO02B,eAAe;;gBAGrC,IAAIH,WAAW/sC,WAAW,GAAG;oBACzB,OAAO;;;YAIf,OAAOgtC;;QAGX/yC,GAAG6B,OAAOxB;YAONuR,OAAO;gBACH,IAAIwhC,SAAS,IAAIpzC,GAAG+L,WAChBsnC,iBAAiB,SAASjtC;oBACtBD,IAAInG,GAAG8H,OAAO,mCAAmC1B;oBACjDgtC,OAAOjnC,QAAQ/F;;gBAGvB+rC,gBAAgB/6B,KAAK,SAASk8B;oBAC1BntC,IAAInG,GAAG8H,OAAO,oDAAoDiD,WAAWhJ,SAASoC,YAAY,SAAS4G,WAAWhJ;oBAEtHqwC,eAAekB,YAAYl8B,KAAK,SAASm7B;wBAErCpsC,IAAInG,GAAG8H,OAAO,gCAAgCyqC,eAAe,WAAW;wBAExED,iBAAiBgB,YAAYf,cAAcn7B,KAAK,SAASm8B;4BAErDptC,IAAInG,GAAG8H,OAAO,mCAAmCyrC;4BAEjDf,OAAOc,YAAYC,eAAen8B,KAAK,SAASu7B;gCAC5C,IAAIF,aAAaC,cAAcC,SAC3Ba,YAAYZ,aAAaL,cAAcE;gCAE3CtsC,IAAI;gCAEJitC,OAAOnnC,QAAQunC;+BAChBH;2BACJA;uBACJA;mBACJA;gBAEH,OAAOD;;;QAKf/yC,KAAKkxC;QACLlxC,KAAKkxC,SAASI,oBAAoBA;;IC7MtC3xC,GAAGswC,WAAW,SAASvlC,YAAY5E;QAC/B;QAEA,SAASstC,eAAeC,YAAYC;YAChC,IAAIC,eAAe,OACfC,uBAAuBzjC,OAAOsjC;YAElC1zC,GAAG+C,KAAK8wC,mBAAmB,SAAS7wC,KAAK8wC;gBACrC,IAAIH,kBAAkBhuC,QAAQmuC,0BAA0B,GAAG;oBACvDF,eAAe;oBACf,OAAO;;;YAIf,OAAOA;;QAGX5zC,GAAG6B,OAAOxB;YASNmwC,eAAe;gBACX,IAAIp4B,OAAO/X,MACPmoB,aAAa,IAAIxoB,GAAG+L,WACpBgoC,cAAc,OACdhyC,OAAOgJ,WAAWhJ,SAASoC,YAAY,SAAS4G,WAAWhJ;gBAE/DoE,IAAInG,GAAG8H,OAAO,iEAAiE/F;gBAE/EoE,IAAI;gBAEJ,IAAI9F,KAAK2zC,qBAAqB;oBAC1B7tC,IAAI;oBAEJnG,GAAGwL,cAAcT,YAAY,GAAG,GAAGqM,KAAK,SAASw6B;wBAC7C5xC,GAAG+C,KAAKqV,KAAK67B,wBAAwB,SAAS3vC,MAAM+G;4BAChD,IAAIooC,eAAepoC,OAAOumC,MAAM;gCAG5B,IAAIttC,SAAS,gBAAgBtE,GAAGkT,kBAAkByD,cAAc;oCAC5Do9B,cAAc;oCACdvrB,WAAWvc,QAAQ3H;;gCAGvB,OAAO;;;wBAIf6B,IAAInG,GAAG8H,OAAO,kDAAkD/F,MAAMgyC,cAAc,KAAK;wBAEzF,KAAKA,aAAa;4BACdvrB,WAAWrc;;uBAGnB;wBACIhG,IAAI,iCAAiCpE,OAAO;wBAC5CymB,WAAWrc;;uBAGd;oBACDqc,WAAWrc;;gBAGf,OAAOqc;;YAWXwrB,mBAAmB;gBACf,IAAIE,WAAWnpC,WAAWxK,MAEtB4zC,oBAAoBn0C,GAAG2F,QAAQc,OAAOw5B,KAAK5/B,KAAK4zC,yBAAyBC,aAAa,GACtFH,cAAc,OACdhyC,OAAOgJ,WAAWhJ,SAASoC,YAAY,SAAS4G,WAAWhJ;gBAE/D,IAAIoyC,mBAAmB;oBACnB,IAAID,aAAa,cAAc;wBAC3BH,cAAc/zC,GAAGkT,kBAAkByD;2BAElC;wBACDo9B,cAAc;;;iBAIrBA,eAAe5tC,IAAIpE,OAAO;gBAE3B,OAAOgyC;;;;IAKnB/zC,GAAGswC,SAAS5pC,UAAUutC;QAClBG,cAAc;QACdC,aAAa;QACbC,aAAa;QACbC,aAAa;QACbC,gBAAe,YAAY;;ICpG/Bx0C,GAAGy1B,kBAAkB,SAAShqB,MAAMtF;QAChC;QAMA,SAASsuC,iBAAiBC;YACtB,IAAIC,aAAa;YAEjB30C,GAAG+C,KAAK2xC,QAAQ,SAASE,OAAO7tC;gBAC5B,IAAIA,QAAQ,GAAG;oBACX4tC,aAAa;oBACb,OAAO;;;YAIf,OAAOA;;QAQX,SAASE;YACL,IAAIC,oBAAoB,IAAI90C,GAAG+L;YAE/B,IAAI/L,GAAGswC,SAAS7kC,MAAMtF,KAAKqqC,gBAAgBp5B,KAAK;gBAC5C,IAAIue,QAAQ,IAAImY,SACZpS,MAAM12B,OAAO+oC,OAAO/oC,OAAO+oC,IAAIC,kBAAkBhpC,OAAO+oC,MAClD/oC,OAAOipC,aAAajpC,OAAOipC,UAAUD,kBAAkBhpC,OAAOipC,YAC9D;gBAEV,IAAIvS,KAAK;oBACL/F,MAAMzpB,UAAU;wBACZ/F,IAAI,6DAA6D;wBACjE2uC,kBAAkB3oC;;oBAGtBwpB,MAAM3pB,SAAS;wBACX8oC,kBAAkB7oC;4BACdy+B,OAAOrqC,KAAKqqC;4BACZhxB,QAAQrZ,KAAKqZ;;;oBAIrBic,MAAMuY,MAAMxS,IAAIsS,gBAAgBviC;uBAE/B;oBACDtF,IAAI,gEAAgE;oBACpE2uC,kBAAkB3oC;;eAEvB2oC,kBAAkB3oC;YAErB,OAAO2oC;;QASX,SAASC,gBAAgBL,QAAQM;YAC7B,IAAIC;YAEJj1C,GAAG+C,KAAK2xC,QAAQ,SAASQ,WAAWC;gBAChC,IAAIA,aAAa,GAAG;oBAChB,IAAIC,eAAe,0BAA0BnxC,KAAKixC,YAC9CG,oBAAoBD,aAAa,GAAGrlC,OAAO,GAAGzG,gBAAgB8rC,aAAa,GAAGltC,MAAM,IACpFotC,cAAcN,WAAWK;oBAG7B,QAAQD,aAAa;sBACjB,KAAK;wBACD,IAAIE,cAAcH,YAAY;4BAC1BF,eAAeC;4BACf,OAAO;;wBAEX;;sBACJ,KAAK;wBACD,IAAII,cAAcH,YAAY;4BAC1BF,eAAeC;4BACf,OAAO;;wBAEX;;;;YAKhB,OAAOD;;QAWX50C,KAAKq1B,WAAW,SAASgf;YACrB,IAAIa,mBAAmB,IAAIv1C,GAAG+L;YAE9B5F,IAAI;YAEJ,IAAIsuC,iBAAiBC,SAAS;gBAC1BG,iBAAiBz9B,KAAK,SAAS49B;oBAC3B,IAAIC,eAAeF,gBAAgBL,QAAQM;oBAE3C,IAAIC,cAAc;wBACdM,iBAAiBppC,QAAQ8oC;2BAExB;wBACDM,iBAAiBtpC;;mBAEtBspC,iBAAiBtpC;mBAEnB;gBACDspC,iBAAiBtpC;;YAGrB,OAAOspC;;;IC7Hfv1C,GAAG00B,UAAU,SAAShZ;QAClB;QAEA,IAAIpD;YACA8F,UAAU;YACVD;YACAoJ;YACAG;YACAkN,eAAe,SAASxO;YACxBjgB,KAAK,SAASC,SAASC;;QAG3BrG,GAAG6B,OAAOyW,SAASoD,MAAM;QAEzB,SAAS85B,oBAAoB9jB;YACzB,IAAI1xB,GAAG8G,QAAQ4qB,WAAW;gBACtB,OAAO;;YAGXpZ,QAAQnS,IAAI,qCAAqC;;QAGrD,SAASsvC,gBAAgBC,WAAWzpC,SAAS6b,UAAUhc;YACnD,IAAI6pC,mBAAmB;YAEvB1pC,UAAUA,WAAWupC,oBAAoBE;YAEzC,IAAIzpC,SAAS;gBACTjM,GAAG+C,KAAK2yC,WAAW,SAAS1yC,KAAKk7B;oBAE7B,IAAIA,SAASljB,QAAQ,MAAM;wBACvB26B,mBAAmB;wBACnBr9B,QAAQnS,IAAInG,GAAG8H,OAAO,qEAAqE9E,MAAM;2BAEhG,IAAIk7B,SAASn8B,QAAQ,MAAM;wBAC5B4zC,mBAAmB;wBACnBr9B,QAAQnS,IAAInG,GAAG8H,OAAO,qEAAqE9E,MAAM;2BAEhG;wBACD;4BACIsV,QAAQsc,cAAcsJ;4BACtB,OAAO;0BAEX,OAAO0X;4BACHD,mBAAmB;4BACnBr9B,QAAQnS,IAAIyvC,IAAIxvC,SAAS;;;oBAIjC,OAAO;;;YAIf0F,QAAQG,YAAY0pC,mBAAmB,YAAY,WAAWD,WAAW5tB;;QAK7EznB,KAAKw0B,UAAU;YAEX,IAAIghB,gBAAgB,IAAI71C,GAAG+L,WACvB+pC,0BAA0B,SAASpkB,UAAUzlB,SAAS6b;gBAClD2tB,gBAAgB/jB,UAAUzlB,SAAS6b,UAAU+tB;eAEjDE,mBAAmB/1C,GAAG6B,WAAWyW,UACjC0xB,YAAY,IAAIhqC,GAAGg2C,qBACfh2C,GAAG6B,OAAOk0C;gBAAmB1qB,YAAYyqB;;YAGjD9L,UAAUiM;YAEV,OAAOJ;;;ICrEf71C,GAAGg2C,uBAAuB,SAASt6B;QAC/B;QAEA,IAAIsuB,WACA1xB;YACI8F,UAAU;YACVmJ;YACApJ;YACAuJ;gBACIsI,UAAU;gBACVuI,iBAAiB;;YAErBlN,YAAY,SAASqG,UAAUzlB,SAAS6b;YACxC3hB,KAAK,SAAS4B,KAAK1B;;QAG3BrG,GAAG6B,OAAOyW,SAASoD;QAEnB,SAAS2P,WAAWxQ,IAAIiN,UAAUC;YAC9B,IAAI2J,WAAW;YAGf,IAAI5J,SAASouB,gBAAgB,MAAM;gBAC/B;oBACIxkB,WAAW1xB,GAAGyR,UAAUqW,SAASouB;kBAErC,OAAON;oBACHt9B,QAAQnS,IAAI,uCAAuCyvC,IAAIxvC,SAAS;oBAChE2hB,UAAU;;;YAIlBzP,QAAQ+S,WAAWqG,WAAW3J,SAASD;;QAG3CkiB,YAAYhqC,GAAG6B,OAAOxB,MAAM,IAAIL,GAAGs5B;YAC/BI,cAAc;YACdC,gBAAe;YACf1S,QAAQ;YACRQ;gBACInF,KAAK;oBACD,OAAOhK,QAAQ8F;;;YAGvBmJ,eAAejP,QAAQiP;YACvBphB,KAAKmS,QAAQnS;YACbklB,YAAYA;YACZ3D,MAAMpP,QAAQoP;;QAGlB1nB,GAAG6B,OAAOxB;YACN41C,aAAa;gBACT,IAAI93B,SAASne,GAAG6B,WAAWyW,QAAQ6F;gBAEnC7F,QAAQnS,IAAI;gBAEZ6jC,UAAUjN,cAAc,kBACnBK,WAAWjf,QACXuf,kBACAtB;;;;ICzDjBp8B,GAAGykB,SAAS,SAAS/I,MAAMvV;QACvB;QAEA,IAAIiS,OAAO/X,MACPihB,uBAAuB5F,KAAK+c,eAC5B0d,kBAAkBz6B,KAAKgd,cACvBC,SAASjd,KAAKid,QACdC,cAAcld,KAAKkd,aACnBC,iBAAiBnd,KAAKmd,iBAAiB,KACvCud,oBAAoB16B,KAAKod,aACzBC,cAAcrd,KAAKqd,aACnBC,QAAQ34B,KAAKg2C,gBAAgB36B,KAAKsd;QAGtCh5B,GAAG6B,OAAOxB;YAGNogB,SAASzgB,GAAGkT,kBAAkBwD,WAAWsiB,MAAMjzB,SAAS;YAExDuwC,gBAAgB,SAASC,kBAAkBC,kBAAkBC;gBACzD,IAAIr+B,OAAO/X,MACPq2C,cACAC,eAAeF,uBAAuBhrC,OAAOgrC,uBAAuBhrC,OAAOgrC,wBAC3EjuB,aAAa,IAAIxoB,GAAGswC,SAASqG,cAAcxwC;gBAG/C,IAAIqiB,WAAWwrB,qBAAqB;oBAEhCh0C,GAAG+C,KAAKi2B,OAAO,SAASh2B,KAAK4zC;wBACzB,IAAIC,aAAaz+B,KAAK0+B;4BAClBle,aAAaA;4BACbme,eAAeH,WAAWr2C;4BAC1By2C,SAASL,aAAap2C;;wBAG1Bm2C,QAAQxzC;4BACJ8X,MAAMhb,GAAGoN;4BACTrL,MAAMqW,KAAK6+B,SAAST;gCAChBz0C,MAAM60C,WAAW70C;gCACjBxB,MAAMs2C;gCACNG,SAASL,aAAap2C;;4BAE1BkL,MAAM,IAAIzL,GAAG8X,UAAU6+B,cACvB32C,GAAGgQ,KAAKoI,KAAK8+B,sBAAsB9+B;gCAC/BkJ,sBAAsBA;gCACtBF,SAASw1B,WAAWx1B;gCACpBuX,QAAQA;gCACRp4B,MAAMs2C;gCACNtyC,SAASs0B;gCACTse,YAAYf;gCACZrd,aAAaA;gCACb5yB,KAAKA;;;;oBAKjBuwC,QAAQxzC;wBACJ8X,MAAMu7B;wBACNx0C,MAAMy0C;wBACN36B,MAAM86B,aAAa96B;wBACnBpQ,MAAM0qC,kBAAkBQ,eAAe;;uBAG1C;oBACDD,QAAQxzC;wBACJ8X,MAAMu7B;wBACNx0C,MAAMy0C;wBACN36B,MAAM86B,aAAa96B;wBACnBpQ,MAAMkrC;;;gBAId,OAAOD;;YAGXvd,eAAe,SAASvZ,MAAM7d,MAAMiZ,MAAMa,MAAMqT,UAAUpT,SAASsL,eAAegwB;gBAC9E,IAAIh/B,OAAO/X,MACPyY,WAAW8G,KAAK8G,cAAe9G,KAAKnU,QAAQmU,KAAKnU,KAAKib,YACtD2wB,gBACAC,aAAa,MACbtoB,mBAAmBooB,IAAIpoB,kBACvBzO,aAAa62B,IAAI72B,YACjBiH,cAAc4vB,IAAI5vB,aAClBzL,eAAe/b,GAAGoN;gBAEtBpN,GAAG+C,KAAKqV,KAAKk+B,eAAet7B,MAAMjZ,MAAM6d,OAAO,SAAS5c,KAAKu0C;oBACzD,IAAIC,WAAWD,OAAO17B,MAClBhB;oBAEJ,IAAI08B,OAAO9rC,gBAAgBzL,GAAG8X,WAAW;wBACrC0/B,YAAY;;oBAGhB38B,KAAK0F,WAAW9E;wBACZT,MAAMu8B,OAAOv8B;wBACbjZ,MAAMw1C,OAAOx1C;wBACb8Z,MAAM27B;wBACN17B,SAASA;wBACTC,cAAcA;;oBAGlB,IAAIw7B,OAAO9rC,gBAAgBzL,GAAG8X,WAAW;wBACrCu/B,UAAUn0C,KAAK2X;2BAEd;wBACDy8B,aAAaz8B;;oBAGjB,IAAI08B,OAAO9rC,MAAM;wBACbujB,iBAAiBnU,IAAI08B,OAAO9rC;wBAC5ByjB,SAAShsB;4BAAM2X,IAAIA;4BAAI+E,MAAM23B,OAAO9rC;;2BAEnC;wBACD8U,WAAWpE,UAAUtB,IAAI7a,GAAGkb,OAAOmC;;;gBAO3C,IAAIi6B,eAAe,MAAM;oBACrBt3C,GAAG+C,KAAKs0C,WAAW,SAASr0C,KAAKy0C;wBAC7B,IAAIt5B;4BACAu5B,cAAcn3B,WAAWtE;gCAAUpB,IAAIy8B;+BAAat8B;4BACpD28B,cAAcp3B,WAAWtE;gCAAUpB,IAAIy8B;+BAAaz7B;;wBAKxDsC,OAAOiJ,iBAAiB7G,WAAWtE;4BAAUpB,IAAI48B;2BAAWz8B;wBAE5DuF,WAAWxD,YAAY06B,UAAUH;wBACjC9vB,YAAY8B,YAAYmuB,UAAUt5B;;oBAKtC,IAAIk5B,UAAUtxC,QAAQ;yBACjB;4BACG,IAAI6xC;4BACJA,MAAMxwB,iBAAiB7G,WAAWtE;gCAAUpB,IAAIy8B;+BAAat8B;4BAC7DwM,YAAY8B,YAAYguB,YAAYM;;;;;;;IAQ5D53C,GAAG6B,OAAO7B,GAAGykB,OAAO/d;QAChB6d,YAAY,SAAS1J,IAAI2J,OAAO4yB;YAC5B;YAEA,KAAKp3C,GAAGkT,kBAAkBwD,SAAS;gBAC/B,MAAM,IAAI1W,GAAGwB,MAAM;;YAGvB,IAAIq2C,gBAAgB,IAAI73C,GAAG+L,WACvB5F,MAAMixC,IAAIjxC,KACVyZ,OAAOw3B,IAAIx1B,QAAQ/G,KACnB0F,aAAa62B,IAAI72B,WAAWtE;gBAAUpB,IAAIA;gBAC1C9Y,OAAOwe,cAAcA,WAAWxe,MAChCiZ,OAAOuF,cAAcA,WAAWvF,MAChC88B;gBACIrf,eAAejU,MAAMiU;gBACrBC,cAAc;gBACdC,QAAQnU,MAAMmU;gBACdC,aAAapU,MAAMjkB,QAAQ;gBAC3Bs4B,gBAAgBrU,MAAMjgB;gBACtB6xC,mBAAmB;gBACnBpd;oBAASj3B,MAAM;oBAAIqf,SAASoD,MAAMpD;;eAEtC22B,SAAS,IAAI/3C,GAAGykB,OAAOqzB,gBAAgB3xC;YAE3C,KAAKnG,GAAGykB,WAAWzkB,GAAGkT,kBAAkBkD,kBAAkBwJ,MAAM;gBAC5Di4B,cAAc1rC;gBAEdhG,IAAI,mDAAmD0U,KAAK,QACxD,qFAAqF;mBAExF;gBACA7a,GAAGgQ,KAAK;oBAEL,IAAIunC,SAASQ,OAAOzB,eAAet7B,MAAMjZ,MAAM6d,MAAM;oBAErD,IAAI23B,UAAUA,OAAO9rC,gBAAgBzL,GAAG8X,WAAW;wBAC/Cy/B,OAAO9rC,KAAKwM,SAASb,KAAKygC,cAAc5rC,SAAS4rC,cAAc1rC;2BAE9D;wBACDhG,IAAI0U,KAAK,6BAA6B;wBACtCg9B,cAAc1rC;;mBAEnB9L;;YAGP,OAAOw3C;;QAKXf,sBAAsB,SAASp7B;YAC3B;YAEA,IAAIq7B,gBAAgBr7B,KAAKq7B,eACrBne,cAAcld,KAAKkd,aACnBof,gBAAgBt8B,KAAKs7B;YAIzB,KAAKpe,gBAAgBme,eAAe;gBAChC,IAAIiB,kBAAkB,cAAc;oBAChC,OAAO;;gBAEX,OAAOA;;YAIX,KAAKjB,eAAe;gBAChB,OAAOne;;YAIX,IAAI54B,GAAG2F,QAAQc,OAAOw5B,KAAKjgC,GAAGswC,SAAS5pC,UAAUutC,yBAAyB8C,kBAAkB,GAAG;gBAC3F,IAAIA,kBAAkB,cAAc;oBAChC,OAAO/2C,GAAGkT,kBAAkByD,eAAeogC,gBAAgBne;;gBAG/D,OAAOme;;YAGX,OAAOne;;QAIXqe,UAAU,SAASr7B,cAAcq8B;YAC7B;YAEA,IAAIC,aAAat8B,aAAa3J,YAAY,MACtCkmC,cAAcF,wBAAwB13C,QAAQ,aAC9Cy3C,gBAAgBC,wBAAwBjB,SACxCoB,aAAa,IACbC,YAAYr4C,GAAG8R,aAAa8J,eAC5B08B,gBAAgB;YAEpB,IAAIL,wBAAwBl2C,QAAQk2C,wBAAwBl2C,KAAK8F,OAAO9B,QAAQ;gBAC5EuyC,gBAAgB,OAAOL,wBAAwBl2C,OAAO;;YAG1D,IAAIm2C,cAAc,GAAG;gBACjBE,aAAax8B,aAAa1J,OAAO,GAAGgmC;gBAEpC,IAAIF,kBAAkBG,aAAa;oBAC/BE,YAAYF,YAAYzyC,MAAM,KAAK;;gBAGvC0yC,cAAcE,gBAAgB,MAAMD;mBAEnC;gBACDD,aAAax8B,eAAe08B;;YAGhC,OAAOF;;QAIX/B,iBAAiB,SAASrd;YACtB;YAEAA,QAAQh5B,GAAG6B,WAAWm3B;YAEtB,OAAOA,MAAMuf,KAAK,SAASC,GAAGC;gBAC1B,IAAID,EAAEp3B,UAAUq3B,EAAEr3B,SAAS;oBACvB,OAAO;;gBAEX,IAAIo3B,EAAEp3B,UAAUq3B,EAAEr3B,SAAS;oBACvB,QAAQ;;gBAEZ,OAAO;;;QAIf81B,sBAAsB,SAASx7B,MAAMg9B;YACjC;YAEA,IAAItgC,OAAO/X,MACPihB,uBAAuB5F,KAAK4F,sBAC5Bnb,MAAMuV,KAAKvV,KACXib,UAAU1F,KAAK0F,SACfuX,SAASjd,KAAKid,QACdp4B,OAAOmb,KAAKnb,MACZgE,UAAUmX,KAAKnX,SACf4yC,aAAaz7B,KAAKy7B,YAClBpe,cAAcrd,KAAKqd,eAAe2f,WAAWn4C,SAAS,gBAAgBA,SAAS,cAC/Es3C,gBAAgB,IAAI73C,GAAG+L,WACvB4sC,iBAAiB,IAAI34C,GAAGi5B,eAAe9yB,MACvC9B,SAASwF,SAASC,cAAc;YAEpC3D,IAAI,+CAA+CuyC,WAAW32C;YAE9D42C,eAAe72B,SAAS42B,YAAYr0C;gBAAS+c,SAASA;gBAASuX,QAAQA;gBAAQrX,sBAAsBA;eAAuBlK,KAAK;gBAC7H,IAAIwhC,qBAAqBv0C,OAAOI,UAAUlE,MAAMgE,UAC5Cs0C,gBAAgB;oBACZ1yC,IAAI,2CAA2CuyC,WAAW32C;oBAC1D,IAAI0J,OAAOzL,GAAGwE,cAAco0C;oBAC5Bf,cAAc5rC,QAAQR;;gBAG9B,IAAIstB,aAAa;oBACb3gB,KAAK0gC,kBAAkBJ,YAAYE,oBAAoBzyC,KAAKiR,KAAK,SAAS2hC;wBACtEH,qBAAqBG;wBACrBF;uBAEJ;wBACI1yC,IAAI,yFAAyF;wBAC7F0yC;;uBAGH;oBACDA;;eAEL;gBACC1yC,IAAI,mDAAmDuyC,WAAW32C,MAAM;gBACxE81C,cAAc1rC,QAAQgrC;;YAG1B,OAAOU;;QAIXiB,mBAAmB,SAASE,eAAeJ,oBAAoBzyC;YAC3D;YAEA,IAAI8yC,SAAS,IAAIptC,cACbqtC,kBAAkB,IAAIl5C,GAAG+L,WACzBotC,uBAAuB;YAE3BF,OAAOjtC,SAAS;gBACZmtC,uBAAuBF,OAAOt2C;gBAC9Bu2C,gBAAgBjtC,QAAQjM,GAAGo5C,aAAalM,QAAQiM,sBAAsBP;;YAG1EK,OAAO/sC,UAAU;gBACb/F,IAAI,qBAAqB6yC,cAAcj3C,OAAO,4DAA4D;gBAC1Gm3C,gBAAgB/sC;;YAGpB8sC,OAAOI,cAAcL;YAErB,OAAOE;;QAGXI,gBAAgB,SAAS50C;YACrB;YAEA,IAAIE,YAAYa,YAAYd,aAAaa;YAGzC,IAAId,QAAQgB,MAAM,KAAK,GAAGC,QAAQ,aAAa,GAAG;gBAC9Cf,aAAagB,KAAKlB,QAAQgB,MAAM,KAAK;mBAEpC;gBACDd,aAAaiB,UAAUnB,QAAQgB,MAAM,KAAK;;YAI9CD,aAAaf,QAAQgB,MAAM,KAAK,GAC3BA,MAAM,KAAK,GACXA,MAAM,KAAK;YAGhBf,cAAc,IAAImB,YAAYlB,WAAWmB;YACzCP,WAAW,IAAIQ,WAAWrB;YAC1B3E,GAAG+C,KAAK6B,YAAY,SAAS5B,KAAKiD;gBAC9BT,SAASxC,OAAOiD,UAAUC,WAAW;;YAGzC,OAAO7F,KAAKk5C,YAAY50C,aAAac;;QAGzC8zC,aAAa,SAASz0C,MAAMR;YACxB;YAEA,IAAIS,cAAcC,OAAOD,eACjBC,OAAOC,qBACPD,OAAOE,kBACPF,OAAOG,eACXC,cAAcL,eAAe,IAAIA;YAErC,IAAIK,aAAa;gBACbA,YAAYC,OAAOP;gBACnB,OAAOM,YAAYE,QAAQhB;mBAE1B;gBACD,OAAO,IAAIiB,OAAMT;oBAAQvE,MAAM+D;;;;;IChZ3CtE,GAAGo5C,eAAe;QAGjB,IAAIA;QAEDA,aAAaI,UAAU,qBACF,qBACA,qBACA,qBACA;QAErBJ,aAAaK,WAAW,SAAS7vC;YAE7B,IAAI8vC,SAAS,IACTC,MAAMC,MAAMC,OAAO,IACnBC,MAAMC,MAAMC,MAAMC,OAAO,IACzBnpC,IAAI;YAER,GAAG;gBACC6oC,OAAO/vC,MAAMkH;gBACb8oC,OAAOhwC,MAAMkH;gBACb+oC,OAAOjwC,MAAMkH;gBAEbgpC,OAAOH,QAAQ;gBACfI,QAASJ,OAAO,MAAM,IAAMC,QAAQ;gBACpCI,QAASJ,OAAO,OAAO,IAAMC,QAAQ;gBACrCI,OAAOJ,OAAO;gBAEd,IAAIK,MAAMN,OAAO;oBACdI,OAAOC,OAAO;uBACV,IAAIC,MAAML,OAAO;oBACrBI,OAAO;;gBAGVP,SAASA,SACNr5C,KAAKm5C,QAAQzpC,OAAO+pC,QACpBz5C,KAAKm5C,QAAQzpC,OAAOgqC,QACpB15C,KAAKm5C,QAAQzpC,OAAOiqC,QACpB35C,KAAKm5C,QAAQzpC,OAAOkqC;gBACvBN,OAAOC,OAAOC,OAAO;gBACrBC,OAAOC,OAAOC,OAAOC,OAAO;qBACvBnpC,IAAIlH,MAAM7D;YAEnB,OAAO2zC;;QAGXN,aAAalM,UAAU,SAASiN,gBAAgBC;YAE5C,IAAIC,uBAAuB;YAE3B,KAAKF,eAAe3lC,MAAM6lC,uBAC1B;gBACC,OAAOD;;YAGR,IAAIE,WAAWj6C,KAAKk6C,SAASJ,eAAe53C,QAAQ83C,sBAAsB;YAC1E,IAAIG,WAAWn6C,KAAKo6C,eAAeH;YAEnC,IAAI3kB,QAAQt1B,KAAKq6C,iBAAiBN,mBAAmBI;YAErD,OAAOH,uBAAuBh6C,KAAKo5C,SAAS9jB;;QAKhDyjB,aAAasB,mBAAmB,SAASN,mBAAmBI;YAEpD,IAAIG,YAAYt6C,KAAKu6C,aAAaJ,WAC9BK,gBAAgBx6C,KAAKy6C,WAAWV,mBAAmBO,YACnDI,UAAU,IAAI/0C,WAAW60C;YAE7B,OAAOE;;QAIf3B,aAAawB,eAAe,SAASJ;YAE7B,IAAIQ;YACJ,KAAK,IAAIC,IAAI,GAAGA,IAAIT,SAASz0C,QAAQk1C,KACrC;gBACID,MAAMR,SAASS;gBACf,IAAID,IAAI,MAAM,MAAMA,IAAI,MAAM,KAC9B;oBACI,OAAOA;;;YAGf;;QAIR5B,aAAa0B,aAAa,SAASV,mBAAmBO;YAE9C,IAAIO,YAAYd,kBAAkB73C,QAAQ,2BAA2B,KACjE44C,MAAM96C,KAAKk6C,SAASW,YACpBE,gBAAgBD,IAAIx1C,QAAQ,KAAI,IAChC01C,MAAMF,IAAIjzC,MAAM,GAAGkzC,gBACnBE,MAAMH,IAAIjzC,MAAMkzC,gBAChBG,QAAQF;YAEZE,QAAQA,MAAMnrC,OAAOuqC;YACrBY,QAAQA,MAAMnrC,OAAOkrC;YACtB,OAAOC;;QAKdnC,aAAaqB,iBAAiB,SAASe;YAEnC,IAAIC,OAAO,GACPjB;YAEJ,OAAO,GACP;gBACI,IAAIgB,cAAcC,SAAS,MAAMD,cAAcC,OAAO,MAAM,KAAI;oBAAC;;gBACjE,IAAID,cAAcC,SAAS,MAAMD,cAAcC,OAAO,MAAM,KAC5D;oBACIA,QAAQ;uBAGZ;oBACI,IAAI11C,SAASy1C,cAAcC,OAAO,KAAK,MAAMD,cAAcC,OAAO,IAC9DC,WAAWD,OAAO11C,SAAS,GAC3Bi1C,MAAMQ,cAActzC,MAAMuzC,MAAMC;oBACpClB,SAASt3C,KAAK83C;oBACdS,OAAOC;;gBAEX,IAAID,OAAOD,cAAcz1C,QAAO;oBAAC;;;YAGrC,OAAOy0C;;QAKXpB,aAAamB,WAAW,SAAS3wC;YAE7B,IAAI8vC,SAAS,IACTC,MAAMC,MAAMC,OAAO,IACnBC,MAAMC,MAAMC,MAAMC,OAAO,IACzBnpC,IAAI,GACJqqC;YAGJ,IAAIQ,aAAa;YACjB,IAAIA,WAAW13C,KAAK2F,QAAQ;gBACxB,MAAM,IAAIpI,MAAM,8DACZ;;YAERoI,QAAQA,MAAMrH,QAAQ,uBAAuB;YAE7C,GAAG;gBACCu3C,OAAOz5C,KAAKm5C,QAAQ7zC,QAAQiE,MAAMmG,OAAOe;gBACzCipC,OAAO15C,KAAKm5C,QAAQ7zC,QAAQiE,MAAMmG,OAAOe;gBACzCkpC,OAAO35C,KAAKm5C,QAAQ7zC,QAAQiE,MAAMmG,OAAOe;gBACzCmpC,OAAO55C,KAAKm5C,QAAQ7zC,QAAQiE,MAAMmG,OAAOe;gBAEzC6oC,OAAQG,QAAQ,IAAMC,QAAQ;gBAC9BH,QAASG,OAAO,OAAO,IAAMC,QAAQ;gBACrCH,QAASG,OAAO,MAAM,IAAKC;gBAE3BkB,IAAIj4C,KAAKy2C;gBAET,IAAIK,QAAQ,IAAI;oBACbmB,IAAIj4C,KAAK02C;;gBAEZ,IAAIK,QAAQ,IAAI;oBACbkB,IAAIj4C,KAAK22C;;gBAGZF,OAAOC,OAAOC,OAAO;gBACrBC,OAAOC,OAAOC,OAAOC,OAAO;qBAEvBnpC,IAAIlH,MAAM7D;YAEnB,OAAOo1C;;QAIX,OAAO/B;;IC7KXp5C,GAAGo5B,gBAAgB,SAAS3pB,UAAUmT;QAClC;QAEA,IAAIg5B,sBACAC,cAAc,GACdC,YAAY,GAEZC,kBAAkB,GAClBC,iBAAiB,GACjBC,gBAAgB,SAAS/wB,QAAQC;YAC7B,IAAID,WAAW6wB,kBAAkB5wB,UAAU6wB,eAAe;gBACtDvsC,SAASyb,QAAQC;;YAGrB4wB,iBAAiB7wB;YACjB8wB,gBAAgB7wB;WAQpB+wB,mBAAmB,SAAS7pB,QAAQ8pB;YAChC,IAAIC,OAAO;YAEXp8C,GAAG+C,KAAKsvB,QAAQ,SAASrvB,KAAKq5C;gBAC1B,IAAIr8C,GAAG2F,QAAQw2C,WAAWE,aAAa,GAAG;oBACtCD,OAAO;oBACP,OAAO;;;YAIf,OAAOA;WAGX7wB,WAAW,SAAS1Q;YAChByhC,oBAAoBzhC,KAAK,IAAI;mBACtB+gC,gBAAgB/gC;WAG3ByX,gBAAgB,SAASF,YAAYC,QAAQ8pB;YACzC,IAAI9pB,OAAOtsB,WAAW,KAAKm2C,iBAAiB7pB,QAAQ8pB,YAAY;gBAC5DF,cAAcH,WAAWA;gBACzBz7C,KAAK8Z;;WAIboiC,QAAQ,SAAS1hC;YACb,IAAIgB,OAAO+G,QAAQ/H;YAGnB,IAAIgB,OAAO,GAAG;gBACVygC,oBAAoBzhC,IAAI,GAAGgB;gBAC3B+/B,gBAAgB/gC;oBAAOqQ,QAAQ;oBAAGC,OAAOtP;;;WAYjDygC,sBAAsB,SAASzhC,IAAI2hC,WAAWC;YAC1C,IAAIC,YAAYd,gBAAgB/gC,MAAM+gC,gBAAgB/gC,IAAIqQ,SAAS,GAC/DyxB,WAAWf,gBAAgB/gC,MAAM+gC,gBAAgB/gC,IAAIsQ,QAAQ;YAEjE,IAAIqxB,eAAe,KAAKC,cAAc,GAAG;gBACrCZ,eAAea;gBACfZ,aAAaa;mBAEZ;gBACD,IAAIH,WAAW;oBACXX,eAAeW,YAAYE;;gBAE/B,IAAID,UAAU;oBACVX,aAAaW,WAAWE;;;YAIhCV,cAAcJ,aAAaC;;QAGnC97C,GAAG6B,OAAOxB;YAENiyB,eAAeA;YAGftW,gBAAgB,SAASnB,IAAIwB,WAAWD;gBACpC,IAAIA,cAAcpc,GAAGkb,OAAOqC,YAAYnB,cAAcpc,GAAGkb,OAAOmC,UAAU;oBACtEkO,SAAS1Q;uBAER,IAAIuB,cAAcpc,GAAGkb,OAAOS,YAAY;oBACzC4gC,MAAM1hC;;;YAKdmY,sBAAsB,SAASnY,IAAIqQ,QAAQC;gBACvCmxB,oBAAoBzhC,IAAIqQ,QAAQC;gBAChCywB,gBAAgB/gC;oBAAOqQ,QAAQA;oBAAQC,OAAOA;;;YAIlD6J,WAAW,SAASna;gBAChB0hC,MAAM1hC;;YAGVV,OAAO;gBACHyhC;gBACAC,cAAc;gBACdC,YAAY;;;;ICzHxB97C,GAAGioB,eAAe,SAAS9P;QACvB;QAEA,IAAIG,SAASskC;QAEbtkC;YACI4P,eAAe;YACfrB;gBACI1gB,KAAK,SAASC,SAASC;gBACvB+hB,eAAe,SAAS3c;;;QAIhC,SAASoxC,QAAQv1C;YACb,OAAOA,KAAK/G,QACR+G,KAAK/G,KAAKoF,QAAQ,cAAc;;QAGxC,SAASm3C;YACLF,qBAAqB58C,GAAGsY,QAAQ4P,eAAe5nB,OAAO,SAAS,SAASk0B;gBACpE,IAAIuoB,gBAAgBvoB,MAAMuoB;gBAE1B,IAAIA,eAAe;oBACf/8C,GAAG+C,KAAKg6C,cAAcvyC,OAAO,SAASxH,KAAKsE;wBACvC,IAAIu1C,QAAQv1C,OAAO;4BACf,IAAImE,OAAOnE,KAAK01C;4BAChB1kC,QAAQuO,UAAUuB,cAAc3c;;;;;;QAOpD,SAASwxC;YACL,IAAIL,oBAAoB;gBACpBA;;;QAIR58C,GAAG6B,OAAOyW,SAASH;QACnB2kC;QAEA98C,GAAG6B,OAAOxB;YACN8Z,OAAO;gBACH8iC;;;;ICpCZj9C,GAAGyvB,cAAc,SAASnX,SAAS4kC,aAAa/2C;QAC5C;QACA,IAAIiS,OAAQ/X,MACRm4B,kBAAkBlgB,QAAQkgB,iBAC1B2kB,SAAS7kC,QAAQrY,SACjB2vB,aAAatX,QAAQsX;QAGzB5vB,GAAG6B,OAAOxB;YAINyvB,aAAa;YAIbD,eAAeD;YAGfF,gBAAgB;YAGhBC,uBAAuB;gBAEnB,IAAIwtB,UAAU,MAAM;oBAChB,OAAO;;gBAGX,OAAO/kC,KAAKglC,UAAUD;;;QAK9B,SAASE,qBAAqBF;YAC1B,IAAIA,OAAOj5C,aAAa,WAAW;gBAC/BkU,KAAK0X,cAAcqtB,OAAOj5C,aAAa;;;QAM/C,SAASo5C,aAAaH,QAAQI;YAC1B,IAAIJ,OAAOK,kBAAkBL,OAAOK,iBAAiB;gBACjDr3C,IAAI,0DAA0D;gBAC9Do3C;mBAEC;gBACD,OAAO;;;QAKf,SAASE,oBAAoBN;YACzB,IAAII,eAAeJ,OAAOO;YAG1B19C,GAAGm9C,QAAQ78C,OAAO,UAAU,SAASk0B;gBACjCA,QAAQA,SAASxvB,OAAOwvB;gBAExB,IAAIA,MAAMvlB,gBAAgB;oBACtBulB,MAAMvlB;uBAEL;oBACDulB,MAAMrlB,cAAc;;gBAGxBmuC,aAAaH,QAAQI,iBAAiBL;;YAK1CC,OAAOO,SAAS;gBACZJ,aAAaH,QAAQI,iBAAiBL;;;QAM9C,SAASS,gBAAgBR;YACrB,IAAIA,QAAQ;gBACR,IAAIn9C,GAAGwH,SAAS21C,SAAS;oBACrBA,SAAStzC,SAASo7B,eAAekY;;gBAGrC,IAAIA,QAAQ;oBACRh3C,IAAI;oBACJk3C,qBAAqBF;oBACrB3kB,mBAAmBilB,oBAAoBN;;;YAI/C,OAAOA;;QAGXA,SAASQ,gBAAgBR;QACzB98C,KAAKqvB,mBAAmBytB;;IAG5Bn9C,GAAG6B,OAAO7B,GAAGyvB,YAAY/oB;QAGrB02C,WAAW,SAAS9rC;YAChB;YACA,IAAIf,UACAqtC,oBAAoB,SAASr9C;gBACzB,IAAIs9C,oBACA,UACA,SACA,SACA;gBAGJ,OAAO79C,GAAG2F,QAAQk4C,iBAAiBt9C,KAAK+I,iBAAiB;eAE7Dw0C,kBAAkB,SAASv9C;gBACvB,OAAOP,GAAG2F,UAAS,YAAY,WAAUpF,KAAK+I,kBAAkB;eAEpEy0C,cAAc,SAASjP;gBACnB,IAAIgP,gBAAgBhP,GAAGvuC,UAAUuuC,GAAGkP,SAAS;oBACzC,OAAO;;gBAGX,OAAOlP,GAAGz6B,YAAYy6B,GAAGvuC,KAAK+I,kBAAkB;eAEpD20C,cAAc,SAASC;gBACnB,IAAIn3C,QAAQ;gBAEZ/G,GAAG+C,KAAK/C,GAAGk+C,QAAQ96C,YAAY,SAASJ,KAAKK;oBACzC,IAAIA,MAAMmG,QAAQF,kBAAkB,YAAYjG,MAAM86C,UAAU;wBAC5Dp3C,QAAQ1D,MAAM0D;wBACd,OAAO;;;gBAIf,OAAOA;;YAGf/G,GAAG+C,KAAKuO,KAAK8sC,UAAU,SAASp7C,KAAK8rC;gBACjC,KAAK9uC,GAAGiJ,QAAQ6lC,IAAI,SAASA,GAAGtlC,QAAQF,kBAAkB,eACtDs0C,kBAAkB9O,GAAGvuC,UACpBw9C,YAAYjP,KAAK;oBAElBv+B,IAAIu+B,GAAG/sC,QAAQ+sC,GAAG/nC;uBAEjB,IAAI+nC,GAAGtlC,QAAQF,kBAAkB,aAAay0C,YAAYjP,KAAK;oBAChE,IAAI/nC,QAAQk3C,YAAYnP;oBAExB,IAAI/nC,UAAU,MAAM;wBAChBwJ,IAAIu+B,GAAG/sC,QAAQgF;;;;YAK3B,OAAOwJ;;;ICzJfvQ,GAAG+iC,cAAc/iC,GAAG+iC;IACpB/iC,GAAG+iC,YAAYyB,oBAAoB,SAASlsB,SAAS0lB;QACjD;QAEA,IAAInP,UAAUxuB,MACVqgB,UAAUsd,MAAMtd,SAChByC,UAAU6a,MAAM7a,SAChBhd,MAAM63B,MAAM73B;QAKhB,SAASk4C,qBAAqBxjC,IAAImqB;YAG9B,IAAItT,UAAU4sB,KAAKC;YAGnB;gBAEID,MAAMtZ,OAAOa,mBAAmBb,OAAOwZ,cAAc30C;gBACrD00C,YAAYD,IAAIhZ,KAAK/1B;gBAErBpJ,IAAI;gBACJA,IAAI,iBAAiBo4C;gBAErB,IAAIA,aAAaA,UAAU/pC,MAAM,WAAW;oBACxC+pC,YAAYD,IAAIhZ,KAAKhiC,WAAWA,WAAWm7C;;gBAG/C/sB,WAAW7C,QAAQ2W,mBAAmB+Y;cAE1C,OAAOl0C;gBACHlE,IAAI,0DAA0DkE,MAAMjE,UAAU,KAAK;gBACnFsrB;oBAAYzlB,SAAS;;;YAGzB,OAAOylB;;QAMX,SAASgtB,WAAW7jC,IAAImqB;YACpB,IAAI7mB,SAAS7F,QAAQkP,YAAYlF,IAAIzH,KACjCoM,SAAS3O,QAAQ2O,OAAO3d,kBAAkB,QAAQ,QAAQ,QAC1D8U,WAAW9F,QAAQmP,cAAcnF,IAAIzH,KACrC9Y,OAAO2e,QAAQ7F;YAEnBsD,OAAO7F,QAAQgP,YAAYnE,QAAQtI;YACnCsD,OAAO7F,QAAQ+d,iBAAiBt0B;YAEhC,OAAO8sB,QAAQkX;gBACX9e,QAAQA;gBACR7I,UAAUA;gBACVD,QAAQA;gBACRoY,cAAcje,QAAQie;gBACtByP,YAAYhB,OAAOjjC;;;QAI3B1B,KAAKoiC,aAAa,SAAS5nB;YACvB,IAAIjR,QAAQilB,QAAQhV,SAASgB,KACzBmqB,SAASnW,QAAQiX,cAAcjrB,KAC/B/O,UAAU,IAAI9L,GAAG+L,WACjBuF;YAEJA,OAAOotC,WAAW7jC,IAAImqB;YACtB1zB,KAAKE,YAAY5H;YAEjBilB,QAAQ8W,iBAAiBX,QAAQ,SAAS2Z;gBACtCx4C,IAAI;gBAEJ,IAAIurB,WAAWitB,sBAAsBA,sBAAsBN,qBAAqBxjC,IAAImqB;gBAEpFnW,QAAQ6W,iBAAiB7qB;gBAGzB,KAAKvC,QAAQoP,KAAKsI,UAAU;oBACxBhwB,GAAGglC,QAAQ5jC;;gBAGf,IAAIswB,SAASzlB,SAAS;oBAClBH,QAAQG,QAAQylB;uBAEf;oBACD5lB,QAAQK,QAAQulB;;;YAIxBvrB,IAAI,gCAAgC0U;YACpCvJ,KAAKosC;YACL19C,GAAGsR,MAAMlQ;YAET,OAAO0K;;QAGX9L,GAAG6B,OAAOxB,MAAM,IAAIL,GAAGwkC;YACnBlsB;gBACIusB,QAAQvsB,QAAQoP,KAAKsI;gBACrBzF,WAAWjS,QAAQiS;;YAGvByT;gBACIzS,UAAUjT,QAAQiT;gBAClB7K,SAASA;gBACTyC,SAASA;gBACThd,KAAKA;;;;IC5GjBnG,GAAG+iC,cAAc/iC,GAAG+iC;IACpB/iC,GAAG+iC,YAAYmD,mBAAmB,SAASxqB,MAAMsiB;QAC7C;QAEA,IAAInP,UAAUxuB,MACVqgB,UAAUsd,MAAMtd,SAChBkC,UAAUob,MAAMpb,SAChBO,UAAU6a,MAAM7a,SAChBhd,MAAM63B,MAAM73B,KACZy4C,YAAYljC,KAAK4a,kBAAkB5a,KAAK6a,cAExCsoB,4BAA4B,SAAShkC,IAAIsD,QAAQ4N;YAC7C,IAAIlQ,OAAO+G,QAAQ/H,KACf9Y,OAAO2e,QAAQ7F;YAEnBsD,OAAOzC,KAAK/F,SAASkiB,WAAWC,aAAa/L,UAAUqc;YACvDjqB,OAAOzC,KAAK/F,SAASkiB,WAAWE,kBAAkBhM,UAAU/gB;YAC5DmT,OAAOzC,KAAK/F,SAASkiB,WAAWG,aAAajM,UAAUlQ;YACvDsC,OAAOzC,KAAK/F,SAASkiB,WAAWK,cAAcnM,UAAUsc;YACxDlqB,OAAOzC,KAAK8a,qBAAqB3a;YAMjC,IAAI+iC,WAAW;gBACXzgC,OAAOzC,KAAK2a,iBAAiBt0B;;WAIrC+8C,yBAAyB,IAAI9+C,GAAG+iC,YAAYgc;YACxCr3B,MAAMhM,KAAKgM;YACXtJ,UAAU1C,KAAK/F,SAAS1J,QAAQmS;YAChCjY,KAAKA;YAGT64C,iCAAiC,SAASnkC,IAAIlG;YAC1C,IAAI7I,UAAU,IAAI9L,GAAG+L;YAErB4I,IAAIonB,qBAAqB;gBACrB,IAAIpnB,IAAI4nB,eAAe,GAAG;oBACtB,IAAI55B,SAASs8C,wBAAwBpkC,IAAIlG;oBAEzC,IAAIhS,OAAOsJ,SAAS;wBAChBH,QAAQG,QAAQtJ,OAAO+uB,UAAU/c;2BAEhC;wBACD7I,QAAQK,QAAQxJ,OAAO+uB,UAAU/c;;;;YAK7C,OAAO7I;WAGXozC,0BAA0B,SAASrkC;YAC/B,IAAIsD,SAASzC,KAAK8L,YAAYlF,IAAIzH,KAC9B9Y,OAAO2e,QAAQ7F,KACfgB,OAAO+G,QAAQ/H;YAEnBsD,OAAOzC,KAAK4L,YAAYnE,QAAQtI;YAChCsD,OAAOzC,KAAK2a,iBAAiBt0B;YAC7Boc,OAAOzC,KAAK8a,qBAAqB3a;YACjCsC,OAAOzC,KAAK/F,SAASkiB,WAAWK,cAAcrJ,QAAQgS,gBAAgBhmB;YAEtE,OAAOsD;WAGXghC,wBAAwB,SAASxqC,KAAK+c;YAClC,OAAO1xB,GAAG2F,UAAS,KAAK,KAAK,KAAK,KAAK,OAAMgP,IAAIuG,UAAU,MACtDwW,SAASzlB,WACVylB,SAASvX;WAGjB8kC,0BAA0B,SAASpkC,IAAIlG;YACnC,IAAI+c;YAEJvrB,IAAI,wCAAwC0U;YAC5C1U,IAAI,oBAAoBwO,IAAIuhC;YAE5BxkB,WAAW0tB,cAAc,MAAMzqC;YAE/B;gBACI1I,UAAUkzC,sBAAsBxqC,KAAK+c;gBACrCA,UAAUA;;WAKlB0tB,gBAAgB,SAASl1C,QAAQyK;YAC7B,IAAI+c;YAEJ;gBACIvrB,IAAInG,GAAG8H,OAAO,6CAA6C6M,IAAIuG,QAAQvG,IAAIuhC;gBAC3ExkB,WAAW1xB,GAAGyR,UAAUkD,IAAIuhC;cAEhC,OAAO7rC;gBACHH,UAAU/D,IAAI,uDAAuDkE,MAAMjE,UAAU,KAAK;;YAG9F,OAAOsrB;WAGX2tB,4BAA4B,SAASxkC;YACjC,IAAI/O,UAAU,IAAI9L,GAAG+L;YAErB+yC,uBAAuBQ,SACfzkC,IACAgU,QAAQgZ,WAAWhtB,KACnBqkC,wBAAwBrkC,KACxBa,KAAK6L,cAAcjF,IAAIzH,KAE1BzD,KAAK,SAASzC;gBACX7I,QAAQG,QAAQmzC,cAAc,OAAOzqC,MAAMA;eAC5C,SAASA;gBACR7I,QAAQK,QAAQizC,cAAc,OAAOzqC,MAAMA;;YAGnD,OAAO7I;WAGXyzC,8BAA8B,SAASphC,QAAQxJ,KAAK5J,YAAY8P;YAC5D,IAAI1J,WAAW,IAAInH,YACfid,SAASvL,KAAKuL,QACd7I,WAAW1C,KAAK+L,cAAcnF,IAAIzH,KAClC9Y,OAAO2e,QAAQ7F,KACfgB,OAAO+G,QAAQ/H;YAEnBsD,OAAOzC,KAAK4L,YAAYnE,QAAQtI;YAChCsD,OAAOzC,KAAK2a,iBAAiBt0B;YAE7B,IAAI68C,WAAW;gBACXzgC,OAAOzC,KAAK8a,qBAAqB3a;;YAIrC,KAAKH,KAAK6a,cAAc;gBACpB,KAAKqoB,WAAW;oBACZzgC,OAAOzC,KAAK6O,aAAaxoB;;gBAE7Bqc,WAAWpe,GAAGsQ,QAAQ6N,QAAQC;;YAGlCzJ,IAAIunB,KAAKjV,QAAQ7I,UAAU;YAE3B,IAAI1C,KAAKgM,KAAKsI,YAAYtU,KAAKgM,KAAK6Q,iBAAiB;gBACjD5jB,IAAIC,kBAAkB;;YAG1B,IAAIgqC,WAAW;gBACX,IAAIljC,KAAK6a,cAAc;oBACnBv2B,GAAGkR,aAAaiN,QAAQhN;;gBAG5BA,SAAS9L,OAAOqW,KAAK6O,WAAWxf;gBAChC,OAAOoG;;YAGX,OAAOpG;WAGXy0C,mBAAmB,SAAS3kC,IAAIlG;YAC5B,IAAI8qC,eAAe/jC,KAAK6L,cAAcjF,IAAIzH,KACtC9P,aAAa8jB,QAAQjN,QAAQ/G;YAEjClG,IAAIioB,iBAAiB,UAAU;YAC/BjoB,IAAIioB,iBAAiB,oBAAoB;YACzCjoB,IAAIioB,iBAAiB,iBAAiB;YAEtC,KAAKgiB,WAAW;gBACZjqC,IAAIioB,iBAAiB,gBAAgB;gBAErCjoB,IAAIioB,iBAAiB,eAAe7xB,WAAWxK;;YAGnDP,GAAG+C,KAAK08C,cAAc,SAAS19C,MAAMkB;gBACjC0R,IAAIioB,iBAAiB76B,MAAMkB;;;QAIvCjD,GAAG6B,OAAOxB;YACN6gC,aAAa,SAASrmB,IAAIikB,UAAUzG;gBAChC,IAAItM,YAAY8C,QAAQkQ,cAAclkB,IAAIikB,WACtCnqB,MAAMka,QAAQgZ,WAAWhtB,IAAIikB,WAC7BjjB,OAAO+G,QAAQ/H,KACf/O,SAAS4zC,QAAQvhC;gBAErBrS,UAAUkzC,+BAA+BnkC,IAAIlG;gBAC7Cka,QAAQqa,yBAAyBruB,IAAIikB,UAAU/S,UAAUlQ;gBACzDsC,SAASzC,KAAK8L,YAAYlF,IAAIzH;gBAC9BgkC,0BAA0BhkC,IAAIsD,QAAQ4N;gBAEtC,IAAIsM,UAAU;oBACVla,OAAOzC,KAAKjF,OAAOohB,WAAWQ,YAAY;;gBAG9CqnB,SAASH,4BAA4BphC,QAAQxJ,KAAKoX,UAAUtgB,MAAMoP;gBAClE2kC,iBAAiB3kC,IAAIlG;gBACrBA,IAAIynB,KAAKsjB;gBAET,OAAO5zC;;YAGX22B,YAAY,SAAS5nB;gBACjB,IAAI9P,aAAa8jB,QAAQjN,QAAQ/G,KAC7B/O,SAAS6I,KAAKwJ,QAAQuhC;gBAE1B/qC,MAAMka,QAAQgZ,WAAWhtB;gBACzBgU,QAAQqa,yBAAyBruB;gBACjC/O,UAAUkzC,+BAA+BnkC,IAAIlG;gBAC7CwJ,SAASzC,KAAK8L,YAAYlF,IAAIzH;gBAC9B6kC,SAASH,4BAA4BphC,QAAQxJ,KAAK5J,YAAY8P;gBAC9D2kC,iBAAiB3kC,IAAIlG;gBACrBA,IAAIynB,KAAKsjB;gBAET,OAAO5zC;;;QAIf9L,GAAG6B,OAAOxB,MAAM,IAAIL,GAAGkmC;YACnB5tB,SAAStY,GAAG6B;gBAAQgpB,WAAW;eAAgBnP;YAC/CsiB,OAAOh+B,GAAG6B;gBAAQugB,aAAa1G,KAAK+L,cAAcnF;eAAM0b;;QAG5Dh+B,GAAGwM,SAASnM,MAAM,SAASsM;YACvB;gBACIyyB,gBAAgB,SAASvkB;oBACrB,IAAIa,KAAK/F,SAAS1J,QAAQmS,UAAU;wBAChC,OAAOihC,0BAA0BxkC;2BAEhC;wBACD,OAAOlO,OAAOyyB,eAAevkB,IAAI7a,GAAGgQ,KAAKovC,eAAe/+C,MAAM;;;;;;ICvOlFL,GAAG+iC,YAAYgc,6BAA6B,SAAS5mC;QACjD;QAEA,IAAI6xB,WACA/iB,SAAS,QACT3O;YACIoP;gBACIuI,UAAU;gBACVD,UAAU;gBACVuI,iBAAiB;;YAErBna,UAAU;YACVjY,KAAK,SAAS4B,KAAK1B;WAEvBs5C,eACAC;YACIt9B,KAAK,SAASzH;gBACV,OAAOvC,QAAQ8F;;;QAI3Bpe,GAAG6B,OAAOyW,SAASH;QAEnB6xB,YAAYhqC,GAAG6B,OAAOxB,MAAM,IAAIL,GAAGs5B;YAC/BI,cAAc;YACdC,gBAAe1S;YACfA,QAAQA;YACRQ,eAAem4B;YACf9lB,oCAAoC;YACpCpS,MAAMpP,QAAQoP;YACdvhB,KAAKmS,QAAQnS;YACbklB,YAAY,SAASxQ,IAAIlG,KAAKoT;gBAC1B,IAAIjc,UAAU6zC,SAAS9kC;uBAEhB8kC,SAAS9kC;gBAEhB,IAAIkN,SAAS;oBACTjc,QAAQK,QAAQwI;uBAEf;oBACD7I,QAAQG,QAAQ0I;;;;QAK5B3U,GAAG6B,OAAOxB;YACNi/C,UAAU,SAASzkC,IAAIlG,KAAKwJ,QAAQwG;gBAChC,IAAI7Y,UAAU,IAAI9L,GAAG+L;gBAErBuM,QAAQnS,IAAI,4CAA4C0U;gBAExD8kC,SAAS9kC,MAAM/O;gBAEfk+B,UAAUjN,cAAcliB,IACnBuiB,WAAWjf,QACXof,YAAY5Y,SACZyX,KAAKznB;gBAEV,OAAO7I;;;;GjClEY9G","file":"fine-uploader.core.js","sourcesContent":[null,"/*globals window, navigator, document, FormData, File, HTMLInputElement, XMLHttpRequest, Blob, Storage, ActiveXObject */\n/* jshint -W079 */\nvar qq = function(element) {\n    \"use strict\";\n\n    return {\n        hide: function() {\n            element.style.display = \"none\";\n            return this;\n        },\n\n        /** Returns the function which detaches attached event */\n        attach: function(type, fn) {\n            if (element.addEventListener) {\n                element.addEventListener(type, fn, false);\n            } else if (element.attachEvent) {\n                element.attachEvent(\"on\" + type, fn);\n            }\n            return function() {\n                qq(element).detach(type, fn);\n            };\n        },\n\n        detach: function(type, fn) {\n            if (element.removeEventListener) {\n                element.removeEventListener(type, fn, false);\n            } else if (element.attachEvent) {\n                element.detachEvent(\"on\" + type, fn);\n            }\n            return this;\n        },\n\n        contains: function(descendant) {\n            // The [W3C spec](http://www.w3.org/TR/domcore/#dom-node-contains)\n            // says a `null` (or ostensibly `undefined`) parameter\n            // passed into `Node.contains` should result in a false return value.\n            // IE7 throws an exception if the parameter is `undefined` though.\n            if (!descendant) {\n                return false;\n            }\n\n            // compareposition returns false in this case\n            if (element === descendant) {\n                return true;\n            }\n\n            if (element.contains) {\n                return element.contains(descendant);\n            } else {\n                /*jslint bitwise: true*/\n                return !!(descendant.compareDocumentPosition(element) & 8);\n            }\n        },\n\n        /**\n         * Insert this element before elementB.\n         */\n        insertBefore: function(elementB) {\n            elementB.parentNode.insertBefore(element, elementB);\n            return this;\n        },\n\n        remove: function() {\n            element.parentNode.removeChild(element);\n            return this;\n        },\n\n        /**\n         * Sets styles for an element.\n         * Fixes opacity in IE6-8.\n         */\n        css: function(styles) {\n            /*jshint eqnull: true*/\n            if (element.style == null) {\n                throw new qq.Error(\"Can't apply style to node as it is not on the HTMLElement prototype chain!\");\n            }\n\n            /*jshint -W116*/\n            if (styles.opacity != null) {\n                if (typeof element.style.opacity !== \"string\" && typeof (element.filters) !== \"undefined\") {\n                    styles.filter = \"alpha(opacity=\" + Math.round(100 * styles.opacity) + \")\";\n                }\n            }\n            qq.extend(element.style, styles);\n\n            return this;\n        },\n\n        hasClass: function(name, considerParent) {\n            var re = new RegExp(\"(^| )\" + name + \"( |$)\");\n            return re.test(element.className) || !!(considerParent && re.test(element.parentNode.className));\n        },\n\n        addClass: function(name) {\n            if (!qq(element).hasClass(name)) {\n                element.className += \" \" + name;\n            }\n            return this;\n        },\n\n        removeClass: function(name) {\n            var re = new RegExp(\"(^| )\" + name + \"( |$)\");\n            element.className = element.className.replace(re, \" \").replace(/^\\s+|\\s+$/g, \"\");\n            return this;\n        },\n\n        getByClass: function(className, first) {\n            var candidates,\n                result = [];\n\n            if (first && element.querySelector) {\n                return element.querySelector(\".\" + className);\n            }\n            else if (element.querySelectorAll) {\n                return element.querySelectorAll(\".\" + className);\n            }\n\n            candidates = element.getElementsByTagName(\"*\");\n\n            qq.each(candidates, function(idx, val) {\n                if (qq(val).hasClass(className)) {\n                    result.push(val);\n                }\n            });\n            return first ? result[0] : result;\n        },\n\n        getFirstByClass: function(className) {\n            return qq(element).getByClass(className, true);\n        },\n\n        children: function() {\n            var children = [],\n                child = element.firstChild;\n\n            while (child) {\n                if (child.nodeType === 1) {\n                    children.push(child);\n                }\n                child = child.nextSibling;\n            }\n\n            return children;\n        },\n\n        setText: function(text) {\n            element.innerText = text;\n            element.textContent = text;\n            return this;\n        },\n\n        clearText: function() {\n            return qq(element).setText(\"\");\n        },\n\n        // Returns true if the attribute exists on the element\n        // AND the value of the attribute is NOT \"false\" (case-insensitive)\n        hasAttribute: function(attrName) {\n            var attrVal;\n\n            if (element.hasAttribute) {\n\n                if (!element.hasAttribute(attrName)) {\n                    return false;\n                }\n\n                /*jshint -W116*/\n                return (/^false$/i).exec(element.getAttribute(attrName)) == null;\n            }\n            else {\n                attrVal = element[attrName];\n\n                if (attrVal === undefined) {\n                    return false;\n                }\n\n                /*jshint -W116*/\n                return (/^false$/i).exec(attrVal) == null;\n            }\n        }\n    };\n};\n\n(function() {\n    \"use strict\";\n\n    qq.canvasToBlob = function(canvas, mime, quality) {\n        return qq.dataUriToBlob(canvas.toDataURL(mime, quality));\n    };\n\n    qq.dataUriToBlob = function(dataUri) {\n        var arrayBuffer, byteString,\n            createBlob = function(data, mime) {\n                var BlobBuilder = window.BlobBuilder ||\n                        window.WebKitBlobBuilder ||\n                        window.MozBlobBuilder ||\n                        window.MSBlobBuilder,\n                    blobBuilder = BlobBuilder && new BlobBuilder();\n\n                if (blobBuilder) {\n                    blobBuilder.append(data);\n                    return blobBuilder.getBlob(mime);\n                }\n                else {\n                    return new Blob([data], {type: mime});\n                }\n            },\n            intArray, mimeString;\n\n        // convert base64 to raw binary data held in a string\n        if (dataUri.split(\",\")[0].indexOf(\"base64\") >= 0) {\n            byteString = atob(dataUri.split(\",\")[1]);\n        }\n        else {\n            byteString = decodeURI(dataUri.split(\",\")[1]);\n        }\n\n        // extract the MIME\n        mimeString = dataUri.split(\",\")[0]\n            .split(\":\")[1]\n            .split(\";\")[0];\n\n        // write the bytes of the binary string to an ArrayBuffer\n        arrayBuffer = new ArrayBuffer(byteString.length);\n        intArray = new Uint8Array(arrayBuffer);\n        qq.each(byteString, function(idx, character) {\n            intArray[idx] = character.charCodeAt(0);\n        });\n\n        return createBlob(arrayBuffer, mimeString);\n    };\n\n    qq.log = function(message, level) {\n        if (window.console) {\n            if (!level || level === \"info\") {\n                window.console.log(message);\n            }\n            else\n            {\n                if (window.console[level]) {\n                    window.console[level](message);\n                }\n                else {\n                    window.console.log(\"<\" + level + \"> \" + message);\n                }\n            }\n        }\n    };\n\n    qq.isObject = function(variable) {\n        return variable && !variable.nodeType && Object.prototype.toString.call(variable) === \"[object Object]\";\n    };\n\n    qq.isFunction = function(variable) {\n        return typeof (variable) === \"function\";\n    };\n\n    /**\n     * Check the type of a value.  Is it an \"array\"?\n     *\n     * @param value value to test.\n     * @returns true if the value is an array or associated with an `ArrayBuffer`\n     */\n    qq.isArray = function(value) {\n        return Object.prototype.toString.call(value) === \"[object Array]\" ||\n            (value && window.ArrayBuffer && value.buffer && value.buffer.constructor === ArrayBuffer);\n    };\n\n    // Looks for an object on a `DataTransfer` object that is associated with drop events when utilizing the Filesystem API.\n    qq.isItemList = function(maybeItemList) {\n        return Object.prototype.toString.call(maybeItemList) === \"[object DataTransferItemList]\";\n    };\n\n    // Looks for an object on a `NodeList` or an `HTMLCollection`|`HTMLFormElement`|`HTMLSelectElement`\n    // object that is associated with collections of Nodes.\n    qq.isNodeList = function(maybeNodeList) {\n        return Object.prototype.toString.call(maybeNodeList) === \"[object NodeList]\" ||\n            // If `HTMLCollection` is the actual type of the object, we must determine this\n            // by checking for expected properties/methods on the object\n            (maybeNodeList.item && maybeNodeList.namedItem);\n    };\n\n    qq.isString = function(maybeString) {\n        return Object.prototype.toString.call(maybeString) === \"[object String]\";\n    };\n\n    qq.trimStr = function(string) {\n        if (String.prototype.trim) {\n            return string.trim();\n        }\n\n        return string.replace(/^\\s+|\\s+$/g, \"\");\n    };\n\n    /**\n     * @param str String to format.\n     * @returns {string} A string, swapping argument values with the associated occurrence of {} in the passed string.\n     */\n    qq.format = function(str) {\n\n        var args =  Array.prototype.slice.call(arguments, 1),\n            newStr = str,\n            nextIdxToReplace = newStr.indexOf(\"{}\");\n\n        qq.each(args, function(idx, val) {\n            var strBefore = newStr.substring(0, nextIdxToReplace),\n                strAfter = newStr.substring(nextIdxToReplace + 2);\n\n            newStr = strBefore + val + strAfter;\n            nextIdxToReplace = newStr.indexOf(\"{}\", nextIdxToReplace + val.length);\n\n            // End the loop if we have run out of tokens (when the arguments exceed the # of tokens)\n            if (nextIdxToReplace < 0) {\n                return false;\n            }\n        });\n\n        return newStr;\n    };\n\n    qq.isFile = function(maybeFile) {\n        return window.File && Object.prototype.toString.call(maybeFile) === \"[object File]\";\n    };\n\n    qq.isFileList = function(maybeFileList) {\n        return window.FileList && Object.prototype.toString.call(maybeFileList) === \"[object FileList]\";\n    };\n\n    qq.isFileOrInput = function(maybeFileOrInput) {\n        return qq.isFile(maybeFileOrInput) || qq.isInput(maybeFileOrInput);\n    };\n\n    qq.isInput = function(maybeInput, notFile) {\n        var evaluateType = function(type) {\n            var normalizedType = type.toLowerCase();\n\n            if (notFile) {\n                return normalizedType !== \"file\";\n            }\n\n            return normalizedType === \"file\";\n        };\n\n        if (window.HTMLInputElement) {\n            if (Object.prototype.toString.call(maybeInput) === \"[object HTMLInputElement]\") {\n                if (maybeInput.type && evaluateType(maybeInput.type)) {\n                    return true;\n                }\n            }\n        }\n        if (maybeInput.tagName) {\n            if (maybeInput.tagName.toLowerCase() === \"input\") {\n                if (maybeInput.type && evaluateType(maybeInput.type)) {\n                    return true;\n                }\n            }\n        }\n\n        return false;\n    };\n\n    qq.isBlob = function(maybeBlob) {\n        if (window.Blob && Object.prototype.toString.call(maybeBlob) === \"[object Blob]\") {\n            return true;\n        }\n    };\n\n    qq.isXhrUploadSupported = function() {\n        var input = document.createElement(\"input\");\n        input.type = \"file\";\n\n        return (\n            input.multiple !== undefined &&\n                typeof File !== \"undefined\" &&\n                typeof FormData !== \"undefined\" &&\n                typeof (qq.createXhrInstance()).upload !== \"undefined\");\n    };\n\n    // Fall back to ActiveX is native XHR is disabled (possible in any version of IE).\n    qq.createXhrInstance = function() {\n        if (window.XMLHttpRequest) {\n            return new XMLHttpRequest();\n        }\n\n        try {\n            return new ActiveXObject(\"MSXML2.XMLHTTP.3.0\");\n        }\n        catch (error) {\n            qq.log(\"Neither XHR or ActiveX are supported!\", \"error\");\n            return null;\n        }\n    };\n\n    qq.isFolderDropSupported = function(dataTransfer) {\n        return dataTransfer.items &&\n            dataTransfer.items.length > 0 &&\n            dataTransfer.items[0].webkitGetAsEntry;\n    };\n\n    qq.isFileChunkingSupported = function() {\n        return !qq.androidStock() && //Android's stock browser cannot upload Blobs correctly\n            qq.isXhrUploadSupported() &&\n            (File.prototype.slice !== undefined || File.prototype.webkitSlice !== undefined || File.prototype.mozSlice !== undefined);\n    };\n\n    qq.sliceBlob = function(fileOrBlob, start, end) {\n        var slicer = fileOrBlob.slice || fileOrBlob.mozSlice || fileOrBlob.webkitSlice;\n\n        return slicer.call(fileOrBlob, start, end);\n    };\n\n    qq.arrayBufferToHex = function(buffer) {\n        var bytesAsHex = \"\",\n            bytes = new Uint8Array(buffer);\n\n        qq.each(bytes, function(idx, byt) {\n            var byteAsHexStr = byt.toString(16);\n\n            if (byteAsHexStr.length < 2) {\n                byteAsHexStr = \"0\" + byteAsHexStr;\n            }\n\n            bytesAsHex += byteAsHexStr;\n        });\n\n        return bytesAsHex;\n    };\n\n    qq.readBlobToHex = function(blob, startOffset, length) {\n        var initialBlob = qq.sliceBlob(blob, startOffset, startOffset + length),\n            fileReader = new FileReader(),\n            promise = new qq.Promise();\n\n        fileReader.onload = function() {\n            promise.success(qq.arrayBufferToHex(fileReader.result));\n        };\n\n        fileReader.onerror = promise.failure;\n\n        fileReader.readAsArrayBuffer(initialBlob);\n\n        return promise;\n    };\n\n    qq.extend = function(first, second, extendNested) {\n        qq.each(second, function(prop, val) {\n            if (extendNested && qq.isObject(val)) {\n                if (first[prop] === undefined) {\n                    first[prop] = {};\n                }\n                qq.extend(first[prop], val, true);\n            }\n            else {\n                first[prop] = val;\n            }\n        });\n\n        return first;\n    };\n\n    /**\n     * Allow properties in one object to override properties in another,\n     * keeping track of the original values from the target object.\n     *\n     * Note that the pre-overriden properties to be overriden by the source will be passed into the `sourceFn` when it is invoked.\n     *\n     * @param target Update properties in this object from some source\n     * @param sourceFn A function that, when invoked, will return properties that will replace properties with the same name in the target.\n     * @returns {object} The target object\n     */\n    qq.override = function(target, sourceFn) {\n        var super_ = {},\n            source = sourceFn(super_);\n\n        qq.each(source, function(srcPropName, srcPropVal) {\n            if (target[srcPropName] !== undefined) {\n                super_[srcPropName] = target[srcPropName];\n            }\n\n            target[srcPropName] = srcPropVal;\n        });\n\n        return target;\n    };\n\n    /**\n     * Searches for a given element (elt) in the array, returns -1 if it is not present.\n     */\n    qq.indexOf = function(arr, elt, from) {\n        if (arr.indexOf) {\n            return arr.indexOf(elt, from);\n        }\n\n        from = from || 0;\n        var len = arr.length;\n\n        if (from < 0) {\n            from += len;\n        }\n\n        for (; from < len; from += 1) {\n            if (arr.hasOwnProperty(from) && arr[from] === elt) {\n                return from;\n            }\n        }\n        return -1;\n    };\n\n    //this is a version 4 UUID\n    qq.getUniqueId = function() {\n        return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, function(c) {\n            /*jslint eqeq: true, bitwise: true*/\n            var r = Math.random() * 16 | 0, v = c == \"x\" ? r : (r & 0x3 | 0x8);\n            return v.toString(16);\n        });\n    };\n\n    //\n    // Browsers and platforms detection\n    qq.ie = function() {\n        return navigator.userAgent.indexOf(\"MSIE\") !== -1 ||\n            navigator.userAgent.indexOf(\"Trident\") !== -1;\n    };\n\n    qq.ie7 = function() {\n        return navigator.userAgent.indexOf(\"MSIE 7\") !== -1;\n    };\n\n    qq.ie8 = function() {\n        return navigator.userAgent.indexOf(\"MSIE 8\") !== -1;\n    };\n\n    qq.ie10 = function() {\n        return navigator.userAgent.indexOf(\"MSIE 10\") !== -1;\n    };\n\n    qq.ie11 = function() {\n        return qq.ie() && navigator.userAgent.indexOf(\"rv:11\") !== -1;\n    };\n\n    qq.edge = function() {\n        return navigator.userAgent.indexOf(\"Edge\") >= 0;\n    };\n\n    qq.safari = function() {\n        return navigator.vendor !== undefined && navigator.vendor.indexOf(\"Apple\") !== -1;\n    };\n\n    qq.chrome = function() {\n        return navigator.vendor !== undefined && navigator.vendor.indexOf(\"Google\") !== -1;\n    };\n\n    qq.opera = function() {\n        return navigator.vendor !== undefined && navigator.vendor.indexOf(\"Opera\") !== -1;\n    };\n\n    qq.firefox = function() {\n        return (!qq.edge() && !qq.ie11() && navigator.userAgent.indexOf(\"Mozilla\") !== -1 && navigator.vendor !== undefined && navigator.vendor === \"\");\n    };\n\n    qq.windows = function() {\n        return navigator.platform === \"Win32\";\n    };\n\n    qq.android = function() {\n        return navigator.userAgent.toLowerCase().indexOf(\"android\") !== -1;\n    };\n\n    // We need to identify the Android stock browser via the UA string to work around various bugs in this browser,\n    // such as the one that prevents a `Blob` from being uploaded.\n    qq.androidStock = function() {\n        return qq.android() && navigator.userAgent.toLowerCase().indexOf(\"chrome\") < 0;\n    };\n\n    qq.ios6 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 6_\") !== -1;\n    };\n\n    qq.ios7 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 7_\") !== -1;\n    };\n\n    qq.ios8 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 8_\") !== -1;\n    };\n\n    // iOS 8.0.0\n    qq.ios800 = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\" OS 8_0 \") !== -1;\n    };\n\n    qq.ios = function() {\n        /*jshint -W014 */\n        return navigator.userAgent.indexOf(\"iPad\") !== -1\n            || navigator.userAgent.indexOf(\"iPod\") !== -1\n            || navigator.userAgent.indexOf(\"iPhone\") !== -1;\n    };\n\n    qq.iosChrome = function() {\n        return qq.ios() && navigator.userAgent.indexOf(\"CriOS\") !== -1;\n    };\n\n    qq.iosSafari = function() {\n        return qq.ios() && !qq.iosChrome() && navigator.userAgent.indexOf(\"Safari\") !== -1;\n    };\n\n    qq.iosSafariWebView = function() {\n        return qq.ios() && !qq.iosChrome() && !qq.iosSafari();\n    };\n\n    //\n    // Events\n\n    qq.preventDefault = function(e) {\n        if (e.preventDefault) {\n            e.preventDefault();\n        } else {\n            e.returnValue = false;\n        }\n    };\n\n    /**\n     * Creates and returns element from html string\n     * Uses innerHTML to create an element\n     */\n    qq.toElement = (function() {\n        var div = document.createElement(\"div\");\n        return function(html) {\n            div.innerHTML = html;\n            var element = div.firstChild;\n            div.removeChild(element);\n            return element;\n        };\n    }());\n\n    //key and value are passed to callback for each entry in the iterable item\n    qq.each = function(iterableItem, callback) {\n        var keyOrIndex, retVal;\n\n        if (iterableItem) {\n            // Iterate through [`Storage`](http://www.w3.org/TR/webstorage/#the-storage-interface) items\n            if (window.Storage && iterableItem.constructor === window.Storage) {\n                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {\n                    retVal = callback(iterableItem.key(keyOrIndex), iterableItem.getItem(iterableItem.key(keyOrIndex)));\n                    if (retVal === false) {\n                        break;\n                    }\n                }\n            }\n            // `DataTransferItemList` & `NodeList` objects are array-like and should be treated as arrays\n            // when iterating over items inside the object.\n            else if (qq.isArray(iterableItem) || qq.isItemList(iterableItem) || qq.isNodeList(iterableItem)) {\n                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {\n                    retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);\n                    if (retVal === false) {\n                        break;\n                    }\n                }\n            }\n            else if (qq.isString(iterableItem)) {\n                for (keyOrIndex = 0; keyOrIndex < iterableItem.length; keyOrIndex++) {\n                    retVal = callback(keyOrIndex, iterableItem.charAt(keyOrIndex));\n                    if (retVal === false) {\n                        break;\n                    }\n                }\n            }\n            else {\n                for (keyOrIndex in iterableItem) {\n                    if (Object.prototype.hasOwnProperty.call(iterableItem, keyOrIndex)) {\n                        retVal = callback(keyOrIndex, iterableItem[keyOrIndex]);\n                        if (retVal === false) {\n                            break;\n                        }\n                    }\n                }\n            }\n        }\n    };\n\n    //include any args that should be passed to the new function after the context arg\n    qq.bind = function(oldFunc, context) {\n        if (qq.isFunction(oldFunc)) {\n            var args =  Array.prototype.slice.call(arguments, 2);\n\n            return function() {\n                var newArgs = qq.extend([], args);\n                if (arguments.length) {\n                    newArgs = newArgs.concat(Array.prototype.slice.call(arguments));\n                }\n                return oldFunc.apply(context, newArgs);\n            };\n        }\n\n        throw new Error(\"first parameter must be a function!\");\n    };\n\n    /**\n     * obj2url() takes a json-object as argument and generates\n     * a querystring. pretty much like jQuery.param()\n     *\n     * how to use:\n     *\n     *    `qq.obj2url({a:'b',c:'d'},'http://any.url/upload?otherParam=value');`\n     *\n     * will result in:\n     *\n     *    `http://any.url/upload?otherParam=value&a=b&c=d`\n     *\n     * @param  Object JSON-Object\n     * @param  String current querystring-part\n     * @return String encoded querystring\n     */\n    qq.obj2url = function(obj, temp, prefixDone) {\n        /*jshint laxbreak: true*/\n        var uristrings = [],\n            prefix = \"&\",\n            add = function(nextObj, i) {\n                var nextTemp = temp\n                    ? (/\\[\\]$/.test(temp)) // prevent double-encoding\n                    ? temp\n                    : temp + \"[\" + i + \"]\"\n                    : i;\n                if ((nextTemp !== \"undefined\") && (i !== \"undefined\")) {\n                    uristrings.push(\n                        (typeof nextObj === \"object\")\n                            ? qq.obj2url(nextObj, nextTemp, true)\n                            : (Object.prototype.toString.call(nextObj) === \"[object Function]\")\n                            ? encodeURIComponent(nextTemp) + \"=\" + encodeURIComponent(nextObj())\n                            : encodeURIComponent(nextTemp) + \"=\" + encodeURIComponent(nextObj)\n                    );\n                }\n            };\n\n        if (!prefixDone && temp) {\n            prefix = (/\\?/.test(temp)) ? (/\\?$/.test(temp)) ? \"\" : \"&\" : \"?\";\n            uristrings.push(temp);\n            uristrings.push(qq.obj2url(obj));\n        } else if ((Object.prototype.toString.call(obj) === \"[object Array]\") && (typeof obj !== \"undefined\")) {\n            qq.each(obj, function(idx, val) {\n                add(val, idx);\n            });\n        } else if ((typeof obj !== \"undefined\") && (obj !== null) && (typeof obj === \"object\")) {\n            qq.each(obj, function(prop, val) {\n                add(val, prop);\n            });\n        } else {\n            uristrings.push(encodeURIComponent(temp) + \"=\" + encodeURIComponent(obj));\n        }\n\n        if (temp) {\n            return uristrings.join(prefix);\n        } else {\n            return uristrings.join(prefix)\n                .replace(/^&/, \"\")\n                .replace(/%20/g, \"+\");\n        }\n    };\n\n    qq.obj2FormData = function(obj, formData, arrayKeyName) {\n        if (!formData) {\n            formData = new FormData();\n        }\n\n        qq.each(obj, function(key, val) {\n            key = arrayKeyName ? arrayKeyName + \"[\" + key + \"]\" : key;\n\n            if (qq.isObject(val)) {\n                qq.obj2FormData(val, formData, key);\n            }\n            else if (qq.isFunction(val)) {\n                formData.append(key, val());\n            }\n            else {\n                formData.append(key, val);\n            }\n        });\n\n        return formData;\n    };\n\n    qq.obj2Inputs = function(obj, form) {\n        var input;\n\n        if (!form) {\n            form = document.createElement(\"form\");\n        }\n\n        qq.obj2FormData(obj, {\n            append: function(key, val) {\n                input = document.createElement(\"input\");\n                input.setAttribute(\"name\", key);\n                input.setAttribute(\"value\", val);\n                form.appendChild(input);\n            }\n        });\n\n        return form;\n    };\n\n    /**\n     * Not recommended for use outside of Fine Uploader since this falls back to an unchecked eval if JSON.parse is not\n     * implemented.  For a more secure JSON.parse polyfill, use Douglas Crockford's json2.js.\n     */\n    qq.parseJson = function(json) {\n        /*jshint evil: true*/\n        if (window.JSON && qq.isFunction(JSON.parse)) {\n            return JSON.parse(json);\n        } else {\n            return eval(\"(\" + json + \")\");\n        }\n    };\n\n    /**\n     * Retrieve the extension of a file, if it exists.\n     *\n     * @param filename\n     * @returns {string || undefined}\n     */\n    qq.getExtension = function(filename) {\n        var extIdx = filename.lastIndexOf(\".\") + 1;\n\n        if (extIdx > 0) {\n            return filename.substr(extIdx, filename.length - extIdx);\n        }\n    };\n\n    qq.getFilename = function(blobOrFileInput) {\n        /*jslint regexp: true*/\n\n        if (qq.isInput(blobOrFileInput)) {\n            // get input value and remove path to normalize\n            return blobOrFileInput.value.replace(/.*(\\/|\\\\)/, \"\");\n        }\n        else if (qq.isFile(blobOrFileInput)) {\n            if (blobOrFileInput.fileName !== null && blobOrFileInput.fileName !== undefined) {\n                return blobOrFileInput.fileName;\n            }\n        }\n\n        return blobOrFileInput.name;\n    };\n\n    /**\n     * A generic module which supports object disposing in dispose() method.\n     * */\n    qq.DisposeSupport = function() {\n        var disposers = [];\n\n        return {\n            /** Run all registered disposers */\n            dispose: function() {\n                var disposer;\n                do {\n                    disposer = disposers.shift();\n                    if (disposer) {\n                        disposer();\n                    }\n                }\n                while (disposer);\n            },\n\n            /** Attach event handler and register de-attacher as a disposer */\n            attach: function() {\n                var args = arguments;\n                /*jslint undef:true*/\n                this.addDisposer(qq(args[0]).attach.apply(this, Array.prototype.slice.call(arguments, 1)));\n            },\n\n            /** Add disposer to the collection */\n            addDisposer: function(disposeFunction) {\n                disposers.push(disposeFunction);\n            }\n        };\n    };\n}());\n","/* globals define, module, global, qq */\n(function() {\n    \"use strict\";\n    if (typeof define === \"function\" && define.amd) {\n        define(function() {\n            return qq;\n        });\n    }\n    else if (typeof module !== \"undefined\" && module.exports) {\n        module.exports = qq;\n    }\n    else {\n        global.qq = qq;\n    }\n}());\n","/* globals qq */\n/**\n * Fine Uploader top-level Error container.  Inherits from `Error`.\n */\n(function() {\n    \"use strict\";\n\n    qq.Error = function(message) {\n        this.message = \"[Fine Uploader \" + qq.version + \"] \" + message;\n    };\n\n    qq.Error.prototype = new Error();\n}());\n","/*global qq */\nqq.version = \"5.14.1\";\n","/* globals qq */\nqq.supportedFeatures = (function() {\n    \"use strict\";\n\n    var supportsUploading,\n        supportsUploadingBlobs,\n        supportsFileDrop,\n        supportsAjaxFileUploading,\n        supportsFolderDrop,\n        supportsChunking,\n        supportsResume,\n        supportsUploadViaPaste,\n        supportsUploadCors,\n        supportsDeleteFileXdr,\n        supportsDeleteFileCorsXhr,\n        supportsDeleteFileCors,\n        supportsFolderSelection,\n        supportsImagePreviews,\n        supportsUploadProgress;\n\n    function testSupportsFileInputElement() {\n        var supported = true,\n            tempInput;\n\n        try {\n            tempInput = document.createElement(\"input\");\n            tempInput.type = \"file\";\n            qq(tempInput).hide();\n\n            if (tempInput.disabled) {\n                supported = false;\n            }\n        }\n        catch (ex) {\n            supported = false;\n        }\n\n        return supported;\n    }\n\n    //only way to test for Filesystem API support since webkit does not expose the DataTransfer interface\n    function isChrome21OrHigher() {\n        return (qq.chrome() || qq.opera()) &&\n            navigator.userAgent.match(/Chrome\\/[2][1-9]|Chrome\\/[3-9][0-9]/) !== undefined;\n    }\n\n    //only way to test for complete Clipboard API support at this time\n    function isChrome14OrHigher() {\n        return (qq.chrome() || qq.opera()) &&\n            navigator.userAgent.match(/Chrome\\/[1][4-9]|Chrome\\/[2-9][0-9]/) !== undefined;\n    }\n\n    //Ensure we can send cross-origin `XMLHttpRequest`s\n    function isCrossOriginXhrSupported() {\n        if (window.XMLHttpRequest) {\n            var xhr = qq.createXhrInstance();\n\n            //Commonly accepted test for XHR CORS support.\n            return xhr.withCredentials !== undefined;\n        }\n\n        return false;\n    }\n\n    //Test for (terrible) cross-origin ajax transport fallback for IE9 and IE8\n    function isXdrSupported() {\n        return window.XDomainRequest !== undefined;\n    }\n\n    // CORS Ajax requests are supported if it is either possible to send credentialed `XMLHttpRequest`s,\n    // or if `XDomainRequest` is an available alternative.\n    function isCrossOriginAjaxSupported() {\n        if (isCrossOriginXhrSupported()) {\n            return true;\n        }\n\n        return isXdrSupported();\n    }\n\n    function isFolderSelectionSupported() {\n        // We know that folder selection is only supported in Chrome via this proprietary attribute for now\n        return document.createElement(\"input\").webkitdirectory !== undefined;\n    }\n\n    function isLocalStorageSupported() {\n        try {\n            return !!window.localStorage &&\n                // unpatched versions of IE10/11 have buggy impls of localStorage where setItem is a string\n                qq.isFunction(window.localStorage.setItem);\n        }\n        catch (error) {\n            // probably caught a security exception, so no localStorage for you\n            return false;\n        }\n    }\n\n    function isDragAndDropSupported() {\n        var span = document.createElement(\"span\");\n\n        return (\"draggable\" in span || (\"ondragstart\" in span && \"ondrop\" in span)) &&\n            !qq.android() && !qq.ios();\n    }\n\n    supportsUploading = testSupportsFileInputElement();\n\n    supportsAjaxFileUploading = supportsUploading && qq.isXhrUploadSupported();\n\n    supportsUploadingBlobs = supportsAjaxFileUploading && !qq.androidStock();\n\n    supportsFileDrop = supportsAjaxFileUploading && isDragAndDropSupported();\n\n    supportsFolderDrop = supportsFileDrop && isChrome21OrHigher();\n\n    supportsChunking = supportsAjaxFileUploading && qq.isFileChunkingSupported();\n\n    supportsResume = supportsAjaxFileUploading && supportsChunking && isLocalStorageSupported();\n\n    supportsUploadViaPaste = supportsAjaxFileUploading && isChrome14OrHigher();\n\n    supportsUploadCors = supportsUploading && (window.postMessage !== undefined || supportsAjaxFileUploading);\n\n    supportsDeleteFileCorsXhr = isCrossOriginXhrSupported();\n\n    supportsDeleteFileXdr = isXdrSupported();\n\n    supportsDeleteFileCors = isCrossOriginAjaxSupported();\n\n    supportsFolderSelection = isFolderSelectionSupported();\n\n    supportsImagePreviews = supportsAjaxFileUploading && window.FileReader !== undefined;\n\n    supportsUploadProgress = (function() {\n        if (supportsAjaxFileUploading) {\n            return !qq.androidStock() && !qq.iosChrome();\n        }\n        return false;\n    }());\n\n    return {\n        ajaxUploading: supportsAjaxFileUploading,\n        blobUploading: supportsUploadingBlobs,\n        canDetermineSize: supportsAjaxFileUploading,\n        chunking: supportsChunking,\n        deleteFileCors: supportsDeleteFileCors,\n        deleteFileCorsXdr: supportsDeleteFileXdr, //NOTE: will also return true in IE10, where XDR is also supported\n        deleteFileCorsXhr: supportsDeleteFileCorsXhr,\n        dialogElement: !!window.HTMLDialogElement,\n        fileDrop: supportsFileDrop,\n        folderDrop: supportsFolderDrop,\n        folderSelection: supportsFolderSelection,\n        imagePreviews: supportsImagePreviews,\n        imageValidation: supportsImagePreviews,\n        itemSizeValidation: supportsAjaxFileUploading,\n        pause: supportsChunking,\n        progressBar: supportsUploadProgress,\n        resume: supportsResume,\n        scaling: supportsImagePreviews && supportsUploadingBlobs,\n        tiffPreviews: qq.safari(), // Not the best solution, but simple and probably accurate enough (for now)\n        unlimitedScaledImageSize: !qq.ios(), // false simply indicates that there is some known limit\n        uploading: supportsUploading,\n        uploadCors: supportsUploadCors,\n        uploadCustomHeaders: supportsAjaxFileUploading,\n        uploadNonMultipart: supportsAjaxFileUploading,\n        uploadViaPaste: supportsUploadViaPaste\n    };\n\n}());\n","/*globals qq*/\n\n// Is the passed object a promise instance?\nqq.isGenericPromise = function(maybePromise) {\n    \"use strict\";\n    return !!(maybePromise && maybePromise.then && qq.isFunction(maybePromise.then));\n};\n\nqq.Promise = function() {\n    \"use strict\";\n\n    var successArgs, failureArgs,\n        successCallbacks = [],\n        failureCallbacks = [],\n        doneCallbacks = [],\n        state = 0;\n\n    qq.extend(this, {\n        then: function(onSuccess, onFailure) {\n            if (state === 0) {\n                if (onSuccess) {\n                    successCallbacks.push(onSuccess);\n                }\n                if (onFailure) {\n                    failureCallbacks.push(onFailure);\n                }\n            }\n            else if (state === -1) {\n                onFailure && onFailure.apply(null, failureArgs);\n            }\n            else if (onSuccess) {\n                onSuccess.apply(null, successArgs);\n            }\n\n            return this;\n        },\n\n        done: function(callback) {\n            if (state === 0) {\n                doneCallbacks.push(callback);\n            }\n            else {\n                callback.apply(null, failureArgs === undefined ? successArgs : failureArgs);\n            }\n\n            return this;\n        },\n\n        success: function() {\n            state = 1;\n            successArgs = arguments;\n\n            if (successCallbacks.length) {\n                qq.each(successCallbacks, function(idx, callback) {\n                    callback.apply(null, successArgs);\n                });\n            }\n\n            if (doneCallbacks.length) {\n                qq.each(doneCallbacks, function(idx, callback) {\n                    callback.apply(null, successArgs);\n                });\n            }\n\n            return this;\n        },\n\n        failure: function() {\n            state = -1;\n            failureArgs = arguments;\n\n            if (failureCallbacks.length) {\n                qq.each(failureCallbacks, function(idx, callback) {\n                    callback.apply(null, failureArgs);\n                });\n            }\n\n            if (doneCallbacks.length) {\n                qq.each(doneCallbacks, function(idx, callback) {\n                    callback.apply(null, failureArgs);\n                });\n            }\n\n            return this;\n        }\n    });\n};\n","/* globals qq */\n/**\n * Placeholder for a Blob that will be generated on-demand.\n *\n * @param referenceBlob Parent of the generated blob\n * @param onCreate Function to invoke when the blob must be created.  Must be promissory.\n * @constructor\n */\nqq.BlobProxy = function(referenceBlob, onCreate) {\n    \"use strict\";\n\n    qq.extend(this, {\n        referenceBlob: referenceBlob,\n\n        create: function() {\n            return onCreate(referenceBlob);\n        }\n    });\n};\n","/*globals qq*/\n\n/**\n * This module represents an upload or \"Select File(s)\" button.  It's job is to embed an opaque `<input type=\"file\">`\n * element as a child of a provided \"container\" element.  This \"container\" element (`options.element`) is used to provide\n * a custom style for the `<input type=\"file\">` element.  The ability to change the style of the container element is also\n * provided here by adding CSS classes to the container on hover/focus.\n *\n * TODO Eliminate the mouseover and mouseout event handlers since the :hover CSS pseudo-class should now be\n * available on all supported browsers.\n *\n * @param o Options to override the default values\n */\nqq.UploadButton = function(o) {\n    \"use strict\";\n\n    var self = this,\n\n        disposeSupport = new qq.DisposeSupport(),\n\n        options = {\n            // Corresponds to the `accept` attribute on the associated `<input type=\"file\">`\n            acceptFiles: null,\n\n            // \"Container\" element\n            element: null,\n\n            focusClass: \"qq-upload-button-focus\",\n\n            // A true value allows folders to be selected, if supported by the UA\n            folders: false,\n\n            // **This option will be removed** in the future as the :hover CSS pseudo-class is available on all supported browsers\n            hoverClass: \"qq-upload-button-hover\",\n\n            ios8BrowserCrashWorkaround: false,\n\n            // If true adds `multiple` attribute to `<input type=\"file\">`\n            multiple: false,\n\n            // `name` attribute of `<input type=\"file\">`\n            name: \"qqfile\",\n\n            // Called when the browser invokes the onchange handler on the `<input type=\"file\">`\n            onChange: function(input) {},\n\n            title: null\n        },\n        input, buttonId;\n\n    // Overrides any of the default option values with any option values passed in during construction.\n    qq.extend(options, o);\n\n    buttonId = qq.getUniqueId();\n\n    // Embed an opaque `<input type=\"file\">` element as a child of `options.element`.\n    function createInput() {\n        var input = document.createElement(\"input\");\n\n        input.setAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME, buttonId);\n        input.setAttribute(\"title\", options.title);\n\n        self.setMultiple(options.multiple, input);\n\n        if (options.folders && qq.supportedFeatures.folderSelection) {\n            // selecting directories is only possible in Chrome now, via a vendor-specific prefixed attribute\n            input.setAttribute(\"webkitdirectory\", \"\");\n        }\n\n        if (options.acceptFiles) {\n            input.setAttribute(\"accept\", options.acceptFiles);\n        }\n\n        input.setAttribute(\"type\", \"file\");\n        input.setAttribute(\"name\", options.name);\n\n        qq(input).css({\n            position: \"absolute\",\n            // in Opera only 'browse' button\n            // is clickable and it is located at\n            // the right side of the input\n            right: 0,\n            top: 0,\n            fontFamily: \"Arial\",\n            // It's especially important to make this an arbitrarily large value\n            // to ensure the rendered input button in IE takes up the entire\n            // space of the container element.  Otherwise, the left side of the\n            // button will require a double-click to invoke the file chooser.\n            // In other browsers, this might cause other issues, so a large font-size\n            // is only used in IE.  There is a bug in IE8 where the opacity style is  ignored\n            // in some cases when the font-size is large.  So, this workaround is not applied\n            // to IE8.\n            fontSize: qq.ie() && !qq.ie8() ? \"3500px\" : \"118px\",\n            margin: 0,\n            padding: 0,\n            cursor: \"pointer\",\n            opacity: 0\n        });\n\n        // Setting the file input's height to 100% in IE7 causes\n        // most of the visible button to be unclickable.\n        !qq.ie7() && qq(input).css({height: \"100%\"});\n\n        options.element.appendChild(input);\n\n        disposeSupport.attach(input, \"change\", function() {\n            options.onChange(input);\n        });\n\n        // **These event handlers will be removed** in the future as the :hover CSS pseudo-class is available on all supported browsers\n        disposeSupport.attach(input, \"mouseover\", function() {\n            qq(options.element).addClass(options.hoverClass);\n        });\n        disposeSupport.attach(input, \"mouseout\", function() {\n            qq(options.element).removeClass(options.hoverClass);\n        });\n\n        disposeSupport.attach(input, \"focus\", function() {\n            qq(options.element).addClass(options.focusClass);\n        });\n        disposeSupport.attach(input, \"blur\", function() {\n            qq(options.element).removeClass(options.focusClass);\n        });\n\n        return input;\n    }\n\n    // Make button suitable container for input\n    qq(options.element).css({\n        position: \"relative\",\n        overflow: \"hidden\",\n        // Make sure browse button is in the right side in Internet Explorer\n        direction: \"ltr\"\n    });\n\n    // Exposed API\n    qq.extend(this, {\n        getInput: function() {\n            return input;\n        },\n\n        getButtonId: function() {\n            return buttonId;\n        },\n\n        setMultiple: function(isMultiple, optInput) {\n            var input = optInput || this.getInput();\n\n            // Temporary workaround for bug in in iOS8 UIWebView that causes the browser to crash\n            // before the file chooser appears if the file input doesn't contain a multiple attribute.\n            // See #1283.\n            if (options.ios8BrowserCrashWorkaround && qq.ios8() && (qq.iosChrome() || qq.iosSafariWebView())) {\n                input.setAttribute(\"multiple\", \"\");\n            }\n\n            else {\n                if (isMultiple) {\n                    input.setAttribute(\"multiple\", \"\");\n                }\n                else {\n                    input.removeAttribute(\"multiple\");\n                }\n            }\n        },\n\n        setAcceptFiles: function(acceptFiles) {\n            if (acceptFiles !== options.acceptFiles) {\n                input.setAttribute(\"accept\", acceptFiles);\n            }\n        },\n\n        reset: function() {\n            if (input.parentNode) {\n                qq(input).remove();\n            }\n\n            qq(options.element).removeClass(options.focusClass);\n            input = null;\n            input = createInput();\n        }\n    });\n\n    input = createInput();\n};\n\nqq.UploadButton.BUTTON_ID_ATTR_NAME = \"qq-button-id\";\n","/*globals qq */\nqq.UploadData = function(uploaderProxy) {\n    \"use strict\";\n\n    var data = [],\n        byUuid = {},\n        byStatus = {},\n        byProxyGroupId = {},\n        byBatchId = {};\n\n    function getDataByIds(idOrIds) {\n        if (qq.isArray(idOrIds)) {\n            var entries = [];\n\n            qq.each(idOrIds, function(idx, id) {\n                entries.push(data[id]);\n            });\n\n            return entries;\n        }\n\n        return data[idOrIds];\n    }\n\n    function getDataByUuids(uuids) {\n        if (qq.isArray(uuids)) {\n            var entries = [];\n\n            qq.each(uuids, function(idx, uuid) {\n                entries.push(data[byUuid[uuid]]);\n            });\n\n            return entries;\n        }\n\n        return data[byUuid[uuids]];\n    }\n\n    function getDataByStatus(status) {\n        var statusResults = [],\n            statuses = [].concat(status);\n\n        qq.each(statuses, function(index, statusEnum) {\n            var statusResultIndexes = byStatus[statusEnum];\n\n            if (statusResultIndexes !== undefined) {\n                qq.each(statusResultIndexes, function(i, dataIndex) {\n                    statusResults.push(data[dataIndex]);\n                });\n            }\n        });\n\n        return statusResults;\n    }\n\n    qq.extend(this, {\n        /**\n         * Adds a new file to the data cache for tracking purposes.\n         *\n         * @param spec Data that describes this file.  Possible properties are:\n         *\n         * - uuid: Initial UUID for this file.\n         * - name: Initial name of this file.\n         * - size: Size of this file, omit if this cannot be determined\n         * - status: Initial `qq.status` for this file.  Omit for `qq.status.SUBMITTING`.\n         * - batchId: ID of the batch this file belongs to\n         * - proxyGroupId: ID of the proxy group associated with this file\n         *\n         * @returns {number} Internal ID for this file.\n         */\n        addFile: function(spec) {\n            var status = spec.status || qq.status.SUBMITTING,\n                id = data.push({\n                    name: spec.name,\n                    originalName: spec.name,\n                    uuid: spec.uuid,\n                    size: spec.size == null ? -1 : spec.size,\n                    status: status\n                }) - 1;\n\n            if (spec.batchId) {\n                data[id].batchId = spec.batchId;\n\n                if (byBatchId[spec.batchId] === undefined) {\n                    byBatchId[spec.batchId] = [];\n                }\n                byBatchId[spec.batchId].push(id);\n            }\n\n            if (spec.proxyGroupId) {\n                data[id].proxyGroupId = spec.proxyGroupId;\n\n                if (byProxyGroupId[spec.proxyGroupId] === undefined) {\n                    byProxyGroupId[spec.proxyGroupId] = [];\n                }\n                byProxyGroupId[spec.proxyGroupId].push(id);\n            }\n\n            data[id].id = id;\n            byUuid[spec.uuid] = id;\n\n            if (byStatus[status] === undefined) {\n                byStatus[status] = [];\n            }\n            byStatus[status].push(id);\n\n            uploaderProxy.onStatusChange(id, null, status);\n\n            return id;\n        },\n\n        retrieve: function(optionalFilter) {\n            if (qq.isObject(optionalFilter) && data.length)  {\n                if (optionalFilter.id !== undefined) {\n                    return getDataByIds(optionalFilter.id);\n                }\n\n                else if (optionalFilter.uuid !== undefined) {\n                    return getDataByUuids(optionalFilter.uuid);\n                }\n\n                else if (optionalFilter.status) {\n                    return getDataByStatus(optionalFilter.status);\n                }\n            }\n            else {\n                return qq.extend([], data, true);\n            }\n        },\n\n        reset: function() {\n            data = [];\n            byUuid = {};\n            byStatus = {};\n            byBatchId = {};\n        },\n\n        setStatus: function(id, newStatus) {\n            var oldStatus = data[id].status,\n                byStatusOldStatusIndex = qq.indexOf(byStatus[oldStatus], id);\n\n            byStatus[oldStatus].splice(byStatusOldStatusIndex, 1);\n\n            data[id].status = newStatus;\n\n            if (byStatus[newStatus] === undefined) {\n                byStatus[newStatus] = [];\n            }\n            byStatus[newStatus].push(id);\n\n            uploaderProxy.onStatusChange(id, oldStatus, newStatus);\n        },\n\n        uuidChanged: function(id, newUuid) {\n            var oldUuid = data[id].uuid;\n\n            data[id].uuid = newUuid;\n            byUuid[newUuid] = id;\n            delete byUuid[oldUuid];\n        },\n\n        updateName: function(id, newName) {\n            data[id].name = newName;\n        },\n\n        updateSize: function(id, newSize) {\n            data[id].size = newSize;\n        },\n\n        // Only applicable if this file has a parent that we may want to reference later.\n        setParentId: function(targetId, parentId) {\n            data[targetId].parentId = parentId;\n        },\n\n        getIdsInProxyGroup: function(id) {\n            var proxyGroupId = data[id].proxyGroupId;\n\n            if (proxyGroupId) {\n                return byProxyGroupId[proxyGroupId];\n            }\n            return [];\n        },\n\n        getIdsInBatch: function(id) {\n            var batchId = data[id].batchId;\n\n            return byBatchId[batchId];\n        }\n    });\n};\n\nqq.status = {\n    SUBMITTING: \"submitting\",\n    SUBMITTED: \"submitted\",\n    REJECTED: \"rejected\",\n    QUEUED: \"queued\",\n    CANCELED: \"canceled\",\n    PAUSED: \"paused\",\n    UPLOADING: \"uploading\",\n    UPLOAD_RETRYING: \"retrying upload\",\n    UPLOAD_SUCCESSFUL: \"upload successful\",\n    UPLOAD_FAILED: \"upload failed\",\n    DELETE_FAILED: \"delete failed\",\n    DELETING: \"deleting\",\n    DELETED: \"deleted\"\n};\n","/*globals qq*/\n/**\n * Defines the public API for FineUploaderBasic mode.\n */\n(function() {\n    \"use strict\";\n\n    qq.basePublicApi = {\n        // DEPRECATED - TODO REMOVE IN NEXT MAJOR RELEASE (replaced by addFiles)\n        addBlobs: function(blobDataOrArray, params, endpoint) {\n            this.addFiles(blobDataOrArray, params, endpoint);\n        },\n\n        addInitialFiles: function(cannedFileList) {\n            var self = this;\n\n            qq.each(cannedFileList, function(index, cannedFile) {\n                self._addCannedFile(cannedFile);\n            });\n        },\n\n        addFiles: function(data, params, endpoint) {\n            this._maybeHandleIos8SafariWorkaround();\n\n            var batchId = this._storedIds.length === 0 ? qq.getUniqueId() : this._currentBatchId,\n\n                processBlob = qq.bind(function(blob) {\n                    this._handleNewFile({\n                        blob: blob,\n                        name: this._options.blobs.defaultName\n                    }, batchId, verifiedFiles);\n                }, this),\n\n                processBlobData = qq.bind(function(blobData) {\n                    this._handleNewFile(blobData, batchId, verifiedFiles);\n                }, this),\n\n                processCanvas = qq.bind(function(canvas) {\n                    var blob = qq.canvasToBlob(canvas);\n\n                    this._handleNewFile({\n                        blob: blob,\n                        name: this._options.blobs.defaultName + \".png\"\n                    }, batchId, verifiedFiles);\n                }, this),\n\n                processCanvasData = qq.bind(function(canvasData) {\n                    var normalizedQuality = canvasData.quality && canvasData.quality / 100,\n                        blob = qq.canvasToBlob(canvasData.canvas, canvasData.type, normalizedQuality);\n\n                    this._handleNewFile({\n                        blob: blob,\n                        name: canvasData.name\n                    }, batchId, verifiedFiles);\n                }, this),\n\n                processFileOrInput = qq.bind(function(fileOrInput) {\n                    if (qq.isInput(fileOrInput) && qq.supportedFeatures.ajaxUploading) {\n                        var files = Array.prototype.slice.call(fileOrInput.files),\n                            self = this;\n\n                        qq.each(files, function(idx, file) {\n                            self._handleNewFile(file, batchId, verifiedFiles);\n                        });\n                    }\n                    else {\n                        this._handleNewFile(fileOrInput, batchId, verifiedFiles);\n                    }\n                }, this),\n\n                normalizeData = function() {\n                    if (qq.isFileList(data)) {\n                        data = Array.prototype.slice.call(data);\n                    }\n                    data = [].concat(data);\n                },\n\n                self = this,\n                verifiedFiles = [];\n\n            this._currentBatchId = batchId;\n\n            if (data) {\n                normalizeData();\n\n                qq.each(data, function(idx, fileContainer) {\n                    if (qq.isFileOrInput(fileContainer)) {\n                        processFileOrInput(fileContainer);\n                    }\n                    else if (qq.isBlob(fileContainer)) {\n                        processBlob(fileContainer);\n                    }\n                    else if (qq.isObject(fileContainer)) {\n                        if (fileContainer.blob && fileContainer.name) {\n                            processBlobData(fileContainer);\n                        }\n                        else if (fileContainer.canvas && fileContainer.name) {\n                            processCanvasData(fileContainer);\n                        }\n                    }\n                    else if (fileContainer.tagName && fileContainer.tagName.toLowerCase() === \"canvas\") {\n                        processCanvas(fileContainer);\n                    }\n                    else {\n                        self.log(fileContainer + \" is not a valid file container!  Ignoring!\", \"warn\");\n                    }\n                });\n\n                this.log(\"Received \" + verifiedFiles.length + \" files.\");\n                this._prepareItemsForUpload(verifiedFiles, params, endpoint);\n            }\n        },\n\n        cancel: function(id) {\n            this._handler.cancel(id);\n        },\n\n        cancelAll: function() {\n            var storedIdsCopy = [],\n                self = this;\n\n            qq.extend(storedIdsCopy, this._storedIds);\n            qq.each(storedIdsCopy, function(idx, storedFileId) {\n                self.cancel(storedFileId);\n            });\n\n            this._handler.cancelAll();\n        },\n\n        clearStoredFiles: function() {\n            this._storedIds = [];\n        },\n\n        continueUpload: function(id) {\n            var uploadData = this._uploadData.retrieve({id: id});\n\n            if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {\n                return false;\n            }\n\n            if (uploadData.status === qq.status.PAUSED) {\n                this.log(qq.format(\"Paused file ID {} ({}) will be continued.  Not paused.\", id, this.getName(id)));\n                this._uploadFile(id);\n                return true;\n            }\n            else {\n                this.log(qq.format(\"Ignoring continue for file ID {} ({}).  Not paused.\", id, this.getName(id)), \"error\");\n            }\n\n            return false;\n        },\n\n        deleteFile: function(id) {\n            return this._onSubmitDelete(id);\n        },\n\n        // TODO document?\n        doesExist: function(fileOrBlobId) {\n            return this._handler.isValid(fileOrBlobId);\n        },\n\n        // Generate a variable size thumbnail on an img or canvas,\n        // returning a promise that is fulfilled when the attempt completes.\n        // Thumbnail can either be based off of a URL for an image returned\n        // by the server in the upload response, or the associated `Blob`.\n        drawThumbnail: function(fileId, imgOrCanvas, maxSize, fromServer, customResizeFunction) {\n            var promiseToReturn = new qq.Promise(),\n                fileOrUrl, options;\n\n            if (this._imageGenerator) {\n                fileOrUrl = this._thumbnailUrls[fileId];\n                options = {\n                    customResizeFunction: customResizeFunction,\n                    maxSize: maxSize > 0 ? maxSize : null,\n                    scale: maxSize > 0\n                };\n\n                // If client-side preview generation is possible\n                // and we are not specifically looking for the image URl returned by the server...\n                if (!fromServer && qq.supportedFeatures.imagePreviews) {\n                    fileOrUrl = this.getFile(fileId);\n                }\n\n                /* jshint eqeqeq:false,eqnull:true */\n                if (fileOrUrl == null) {\n                    promiseToReturn.failure({container: imgOrCanvas, error: \"File or URL not found.\"});\n                }\n                else {\n                    this._imageGenerator.generate(fileOrUrl, imgOrCanvas, options).then(\n                        function success(modifiedContainer) {\n                            promiseToReturn.success(modifiedContainer);\n                        },\n\n                        function failure(container, reason) {\n                            promiseToReturn.failure({container: container, error: reason || \"Problem generating thumbnail\"});\n                        }\n                    );\n                }\n            }\n            else {\n                promiseToReturn.failure({container: imgOrCanvas, error: \"Missing image generator module\"});\n            }\n\n            return promiseToReturn;\n        },\n\n        getButton: function(fileId) {\n            return this._getButton(this._buttonIdsForFileIds[fileId]);\n        },\n\n        getEndpoint: function(fileId) {\n            return this._endpointStore.get(fileId);\n        },\n\n        getFile: function(fileOrBlobId) {\n            return this._handler.getFile(fileOrBlobId) || null;\n        },\n\n        getInProgress: function() {\n            return this._uploadData.retrieve({\n                status: [\n                    qq.status.UPLOADING,\n                    qq.status.UPLOAD_RETRYING,\n                    qq.status.QUEUED\n                ]\n            }).length;\n        },\n\n        getName: function(id) {\n            return this._uploadData.retrieve({id: id}).name;\n        },\n\n        // Parent ID for a specific file, or null if this is the parent, or if it has no parent.\n        getParentId: function(id) {\n            var uploadDataEntry = this.getUploads({id: id}),\n                parentId = null;\n\n            if (uploadDataEntry) {\n                if (uploadDataEntry.parentId !== undefined) {\n                    parentId = uploadDataEntry.parentId;\n                }\n            }\n\n            return parentId;\n        },\n\n        getResumableFilesData: function() {\n            return this._handler.getResumableFilesData();\n        },\n\n        getSize: function(id) {\n            return this._uploadData.retrieve({id: id}).size;\n        },\n\n        getNetUploads: function() {\n            return this._netUploaded;\n        },\n\n        getRemainingAllowedItems: function() {\n            var allowedItems = this._currentItemLimit;\n\n            if (allowedItems > 0) {\n                return allowedItems - this._netUploadedOrQueued;\n            }\n\n            return null;\n        },\n\n        getUploads: function(optionalFilter) {\n            return this._uploadData.retrieve(optionalFilter);\n        },\n\n        getUuid: function(id) {\n            return this._uploadData.retrieve({id: id}).uuid;\n        },\n\n        log: function(str, level) {\n            if (this._options.debug && (!level || level === \"info\")) {\n                qq.log(\"[Fine Uploader \" + qq.version + \"] \" + str);\n            }\n            else if (level && level !== \"info\") {\n                qq.log(\"[Fine Uploader \" + qq.version + \"] \" + str, level);\n\n            }\n        },\n\n        pauseUpload: function(id) {\n            var uploadData = this._uploadData.retrieve({id: id});\n\n            if (!qq.supportedFeatures.pause || !this._options.chunking.enabled) {\n                return false;\n            }\n\n            // Pause only really makes sense if the file is uploading or retrying\n            if (qq.indexOf([qq.status.UPLOADING, qq.status.UPLOAD_RETRYING], uploadData.status) >= 0) {\n                if (this._handler.pause(id)) {\n                    this._uploadData.setStatus(id, qq.status.PAUSED);\n                    return true;\n                }\n                else {\n                    this.log(qq.format(\"Unable to pause file ID {} ({}).\", id, this.getName(id)), \"error\");\n                }\n            }\n            else {\n                this.log(qq.format(\"Ignoring pause for file ID {} ({}).  Not in progress.\", id, this.getName(id)), \"error\");\n            }\n\n            return false;\n        },\n\n        removeFileRef: function(id) {\n            this._handler.expunge(id);\n        },\n\n        reset: function() {\n            this.log(\"Resetting uploader...\");\n\n            this._handler.reset();\n            this._storedIds = [];\n            this._autoRetries = [];\n            this._retryTimeouts = [];\n            this._preventRetries = [];\n            this._thumbnailUrls = [];\n\n            qq.each(this._buttons, function(idx, button) {\n                button.reset();\n            });\n\n            this._paramsStore.reset();\n            this._endpointStore.reset();\n            this._netUploadedOrQueued = 0;\n            this._netUploaded = 0;\n            this._uploadData.reset();\n            this._buttonIdsForFileIds = [];\n\n            this._pasteHandler && this._pasteHandler.reset();\n            this._options.session.refreshOnReset && this._refreshSessionData();\n\n            this._succeededSinceLastAllComplete = [];\n            this._failedSinceLastAllComplete = [];\n\n            this._totalProgress && this._totalProgress.reset();\n        },\n\n        retry: function(id) {\n            return this._manualRetry(id);\n        },\n\n        scaleImage: function(id, specs) {\n            var self = this;\n\n            return qq.Scaler.prototype.scaleImage(id, specs, {\n                log: qq.bind(self.log, self),\n                getFile: qq.bind(self.getFile, self),\n                uploadData: self._uploadData\n            });\n        },\n\n        setCustomHeaders: function(headers, id) {\n            this._customHeadersStore.set(headers, id);\n        },\n\n        setDeleteFileCustomHeaders: function(headers, id) {\n            this._deleteFileCustomHeadersStore.set(headers, id);\n        },\n\n        setDeleteFileEndpoint: function(endpoint, id) {\n            this._deleteFileEndpointStore.set(endpoint, id);\n        },\n\n        setDeleteFileParams: function(params, id) {\n            this._deleteFileParamsStore.set(params, id);\n        },\n\n        // Re-sets the default endpoint, an endpoint for a specific file, or an endpoint for a specific button\n        setEndpoint: function(endpoint, id) {\n            this._endpointStore.set(endpoint, id);\n        },\n\n        setForm: function(elementOrId) {\n            this._updateFormSupportAndParams(elementOrId);\n        },\n\n        setItemLimit: function(newItemLimit) {\n            this._currentItemLimit = newItemLimit;\n        },\n\n        setName: function(id, newName) {\n            this._uploadData.updateName(id, newName);\n        },\n\n        setParams: function(params, id) {\n            this._paramsStore.set(params, id);\n        },\n\n        setUuid: function(id, newUuid) {\n            return this._uploadData.uuidChanged(id, newUuid);\n        },\n\n        /**\n         * Expose the internal status of a file id to the public api for manual state changes\n         * @public\n         *\n         * @param {Number} id,\n         * @param {String} newStatus\n         *\n         * @todo Implement the remaining methods\n         */\n        setStatus: function(id, newStatus) {\n            var fileRecord = this.getUploads({id: id});\n            if (!fileRecord) {\n                throw new qq.Error(id + \" is not a valid file ID.\");\n            }\n\n            switch (newStatus) {\n                case qq.status.DELETED:\n                    this._onDeleteComplete(id, null, false);\n                    break;\n                case qq.status.DELETE_FAILED:\n                    this._onDeleteComplete(id, null, true);\n                    break;\n                default:\n                    var errorMessage = \"Method setStatus called on '\" + name + \"' not implemented yet for \" + newStatus;\n                    this.log(errorMessage);\n                    throw new qq.Error(errorMessage);\n            }\n        },\n\n        uploadStoredFiles: function() {\n            if (this._storedIds.length === 0) {\n                this._itemError(\"noFilesError\");\n            }\n            else {\n                this._uploadStoredFiles();\n            }\n        }\n    };\n\n    /**\n     * Defines the private (internal) API for FineUploaderBasic mode.\n     */\n    qq.basePrivateApi = {\n        // Updates internal state with a file record (not backed by a live file).  Returns the assigned ID.\n        _addCannedFile: function(sessionData) {\n            var id = this._uploadData.addFile({\n                uuid: sessionData.uuid,\n                name: sessionData.name,\n                size: sessionData.size,\n                status: qq.status.UPLOAD_SUCCESSFUL\n            });\n\n            sessionData.deleteFileEndpoint && this.setDeleteFileEndpoint(sessionData.deleteFileEndpoint, id);\n            sessionData.deleteFileParams && this.setDeleteFileParams(sessionData.deleteFileParams, id);\n\n            if (sessionData.thumbnailUrl) {\n                this._thumbnailUrls[id] = sessionData.thumbnailUrl;\n            }\n\n            this._netUploaded++;\n            this._netUploadedOrQueued++;\n\n            return id;\n        },\n\n        _annotateWithButtonId: function(file, associatedInput) {\n            if (qq.isFile(file)) {\n                file.qqButtonId = this._getButtonId(associatedInput);\n            }\n        },\n\n        _batchError: function(message) {\n            this._options.callbacks.onError(null, null, message, undefined);\n        },\n\n        _createDeleteHandler: function() {\n            var self = this;\n\n            return new qq.DeleteFileAjaxRequester({\n                method: this._options.deleteFile.method.toUpperCase(),\n                maxConnections: this._options.maxConnections,\n                uuidParamName: this._options.request.uuidName,\n                customHeaders: this._deleteFileCustomHeadersStore,\n                paramsStore: this._deleteFileParamsStore,\n                endpointStore: this._deleteFileEndpointStore,\n                cors: this._options.cors,\n                log: qq.bind(self.log, self),\n                onDelete: function(id) {\n                    self._onDelete(id);\n                    self._options.callbacks.onDelete(id);\n                },\n                onDeleteComplete: function(id, xhrOrXdr, isError) {\n                    self._onDeleteComplete(id, xhrOrXdr, isError);\n                    self._options.callbacks.onDeleteComplete(id, xhrOrXdr, isError);\n                }\n\n            });\n        },\n\n        _createPasteHandler: function() {\n            var self = this;\n\n            return new qq.PasteSupport({\n                targetElement: this._options.paste.targetElement,\n                callbacks: {\n                    log: qq.bind(self.log, self),\n                    pasteReceived: function(blob) {\n                        self._handleCheckedCallback({\n                            name: \"onPasteReceived\",\n                            callback: qq.bind(self._options.callbacks.onPasteReceived, self, blob),\n                            onSuccess: qq.bind(self._handlePasteSuccess, self, blob),\n                            identifier: \"pasted image\"\n                        });\n                    }\n                }\n            });\n        },\n\n        _createStore: function(initialValue, _readOnlyValues_) {\n            var store = {},\n                catchall = initialValue,\n                perIdReadOnlyValues = {},\n                readOnlyValues = _readOnlyValues_,\n                copy = function(orig) {\n                    if (qq.isObject(orig)) {\n                        return qq.extend({}, orig);\n                    }\n                    return orig;\n                },\n                getReadOnlyValues = function() {\n                    if (qq.isFunction(readOnlyValues)) {\n                        return readOnlyValues();\n                    }\n                    return readOnlyValues;\n                },\n                includeReadOnlyValues = function(id, existing) {\n                    if (readOnlyValues && qq.isObject(existing)) {\n                        qq.extend(existing, getReadOnlyValues());\n                    }\n\n                    if (perIdReadOnlyValues[id]) {\n                        qq.extend(existing, perIdReadOnlyValues[id]);\n                    }\n                };\n\n            return {\n                set: function(val, id) {\n                    /*jshint eqeqeq: true, eqnull: true*/\n                    if (id == null) {\n                        store = {};\n                        catchall = copy(val);\n                    }\n                    else {\n                        store[id] = copy(val);\n                    }\n                },\n\n                get: function(id) {\n                    var values;\n\n                    /*jshint eqeqeq: true, eqnull: true*/\n                    if (id != null && store[id]) {\n                        values = store[id];\n                    }\n                    else {\n                        values = copy(catchall);\n                    }\n\n                    includeReadOnlyValues(id, values);\n\n                    return copy(values);\n                },\n\n                addReadOnly: function(id, values) {\n                    // Only applicable to Object stores\n                    if (qq.isObject(store)) {\n                        // If null ID, apply readonly values to all files\n                        if (id === null) {\n                            if (qq.isFunction(values)) {\n                                readOnlyValues = values;\n                            }\n                            else {\n                                readOnlyValues = readOnlyValues || {};\n                                qq.extend(readOnlyValues, values);\n                            }\n                        }\n                        else {\n                            perIdReadOnlyValues[id] = perIdReadOnlyValues[id] || {};\n                            qq.extend(perIdReadOnlyValues[id], values);\n                        }\n                    }\n                },\n\n                remove: function(fileId) {\n                    return delete store[fileId];\n                },\n\n                reset: function() {\n                    store = {};\n                    perIdReadOnlyValues = {};\n                    catchall = initialValue;\n                }\n            };\n        },\n\n        _createUploadDataTracker: function() {\n            var self = this;\n\n            return new qq.UploadData({\n                getName: function(id) {\n                    return self.getName(id);\n                },\n                getUuid: function(id) {\n                    return self.getUuid(id);\n                },\n                getSize: function(id) {\n                    return self.getSize(id);\n                },\n                onStatusChange: function(id, oldStatus, newStatus) {\n                    self._onUploadStatusChange(id, oldStatus, newStatus);\n                    self._options.callbacks.onStatusChange(id, oldStatus, newStatus);\n                    self._maybeAllComplete(id, newStatus);\n\n                    if (self._totalProgress) {\n                        setTimeout(function() {\n                            self._totalProgress.onStatusChange(id, oldStatus, newStatus);\n                        }, 0);\n                    }\n                }\n            });\n        },\n\n        /**\n         * Generate a tracked upload button.\n         *\n         * @param spec Object containing a required `element` property\n         * along with optional `multiple`, `accept`, and `folders`.\n         * @returns {qq.UploadButton}\n         * @private\n         */\n        _createUploadButton: function(spec) {\n            var self = this,\n                acceptFiles = spec.accept || this._options.validation.acceptFiles,\n                allowedExtensions = spec.allowedExtensions || this._options.validation.allowedExtensions,\n                button;\n\n            function allowMultiple() {\n                if (qq.supportedFeatures.ajaxUploading) {\n                    // Workaround for bug in iOS7+ (see #1039)\n                    if (self._options.workarounds.iosEmptyVideos &&\n                        qq.ios() &&\n                        !qq.ios6() &&\n                        self._isAllowedExtension(allowedExtensions, \".mov\")) {\n\n                        return false;\n                    }\n\n                    if (spec.multiple === undefined) {\n                        return self._options.multiple;\n                    }\n\n                    return spec.multiple;\n                }\n\n                return false;\n            }\n\n            button = new qq.UploadButton({\n                acceptFiles: acceptFiles,\n                element: spec.element,\n                focusClass: this._options.classes.buttonFocus,\n                folders: spec.folders,\n                hoverClass: this._options.classes.buttonHover,\n                ios8BrowserCrashWorkaround: this._options.workarounds.ios8BrowserCrash,\n                multiple: allowMultiple(),\n                name: this._options.request.inputName,\n                onChange: function(input) {\n                    self._onInputChange(input);\n                },\n                title: spec.title == null ? this._options.text.fileInputTitle : spec.title\n            });\n\n            this._disposeSupport.addDisposer(function() {\n                button.dispose();\n            });\n\n            self._buttons.push(button);\n\n            return button;\n        },\n\n        _createUploadHandler: function(additionalOptions, namespace) {\n            var self = this,\n                lastOnProgress = {},\n                options = {\n                    debug: this._options.debug,\n                    maxConnections: this._options.maxConnections,\n                    cors: this._options.cors,\n                    paramsStore: this._paramsStore,\n                    endpointStore: this._endpointStore,\n                    chunking: this._options.chunking,\n                    resume: this._options.resume,\n                    blobs: this._options.blobs,\n                    log: qq.bind(self.log, self),\n                    preventRetryParam: this._options.retry.preventRetryResponseProperty,\n                    onProgress: function(id, name, loaded, total) {\n                        if (loaded < 0 || total < 0) {\n                            return;\n                        }\n\n                        if (lastOnProgress[id]) {\n                            if (lastOnProgress[id].loaded !== loaded || lastOnProgress[id].total !== total) {\n                                self._onProgress(id, name, loaded, total);\n                                self._options.callbacks.onProgress(id, name, loaded, total);\n                            }\n                        }\n                        else {\n                            self._onProgress(id, name, loaded, total);\n                            self._options.callbacks.onProgress(id, name, loaded, total);\n                        }\n\n                        lastOnProgress[id] = {loaded: loaded, total: total};\n\n                    },\n                    onComplete: function(id, name, result, xhr) {\n                        delete lastOnProgress[id];\n\n                        var status = self.getUploads({id: id}).status,\n                            retVal;\n\n                        // This is to deal with some observed cases where the XHR readyStateChange handler is\n                        // invoked by the browser multiple times for the same XHR instance with the same state\n                        // readyState value.  Higher level: don't invoke complete-related code if we've already\n                        // done this.\n                        if (status === qq.status.UPLOAD_SUCCESSFUL || status === qq.status.UPLOAD_FAILED) {\n                            return;\n                        }\n\n                        retVal = self._onComplete(id, name, result, xhr);\n\n                        // If the internal `_onComplete` handler returns a promise, don't invoke the `onComplete` callback\n                        // until the promise has been fulfilled.\n                        if (retVal instanceof  qq.Promise) {\n                            retVal.done(function() {\n                                self._options.callbacks.onComplete(id, name, result, xhr);\n                            });\n                        }\n                        else {\n                            self._options.callbacks.onComplete(id, name, result, xhr);\n                        }\n                    },\n                    onCancel: function(id, name, cancelFinalizationEffort) {\n                        var promise = new qq.Promise();\n\n                        self._handleCheckedCallback({\n                            name: \"onCancel\",\n                            callback: qq.bind(self._options.callbacks.onCancel, self, id, name),\n                            onFailure: promise.failure,\n                            onSuccess: function() {\n                                cancelFinalizationEffort.then(function() {\n                                    self._onCancel(id, name);\n                                });\n\n                                promise.success();\n                            },\n                            identifier: id\n                        });\n\n                        return promise;\n                    },\n                    onUploadPrep: qq.bind(this._onUploadPrep, this),\n                    onUpload: function(id, name) {\n                        self._onUpload(id, name);\n                        self._options.callbacks.onUpload(id, name);\n                    },\n                    onUploadChunk: function(id, name, chunkData) {\n                        self._onUploadChunk(id, chunkData);\n                        self._options.callbacks.onUploadChunk(id, name, chunkData);\n                    },\n                    onUploadChunkSuccess: function(id, chunkData, result, xhr) {\n                        self._options.callbacks.onUploadChunkSuccess.apply(self, arguments);\n                    },\n                    onResume: function(id, name, chunkData) {\n                        return self._options.callbacks.onResume(id, name, chunkData);\n                    },\n                    onAutoRetry: function(id, name, responseJSON, xhr) {\n                        return self._onAutoRetry.apply(self, arguments);\n                    },\n                    onUuidChanged: function(id, newUuid) {\n                        self.log(\"Server requested UUID change from '\" + self.getUuid(id) + \"' to '\" + newUuid + \"'\");\n                        self.setUuid(id, newUuid);\n                    },\n                    getName: qq.bind(self.getName, self),\n                    getUuid: qq.bind(self.getUuid, self),\n                    getSize: qq.bind(self.getSize, self),\n                    setSize: qq.bind(self._setSize, self),\n                    getDataByUuid: function(uuid) {\n                        return self.getUploads({uuid: uuid});\n                    },\n                    isQueued: function(id) {\n                        var status = self.getUploads({id: id}).status;\n                        return status === qq.status.QUEUED ||\n                            status === qq.status.SUBMITTED ||\n                            status === qq.status.UPLOAD_RETRYING ||\n                            status === qq.status.PAUSED;\n                    },\n                    getIdsInProxyGroup: self._uploadData.getIdsInProxyGroup,\n                    getIdsInBatch: self._uploadData.getIdsInBatch\n                };\n\n            qq.each(this._options.request, function(prop, val) {\n                options[prop] = val;\n            });\n\n            options.customHeaders = this._customHeadersStore;\n\n            if (additionalOptions) {\n                qq.each(additionalOptions, function(key, val) {\n                    options[key] = val;\n                });\n            }\n\n            return new qq.UploadHandlerController(options, namespace);\n        },\n\n        _fileOrBlobRejected: function(id) {\n            this._netUploadedOrQueued--;\n            this._uploadData.setStatus(id, qq.status.REJECTED);\n        },\n\n        _formatSize: function(bytes) {\n            if (bytes === 0) {\n                return bytes + this._options.text.sizeSymbols[0];\n            }\n            var i = -1;\n            do {\n                bytes = bytes / 1000;\n                i++;\n            } while (bytes > 999);\n\n            return Math.max(bytes, 0.1).toFixed(1) + this._options.text.sizeSymbols[i];\n        },\n\n        // Creates an internal object that tracks various properties of each extra button,\n        // and then actually creates the extra button.\n        _generateExtraButtonSpecs: function() {\n            var self = this;\n\n            this._extraButtonSpecs = {};\n\n            qq.each(this._options.extraButtons, function(idx, extraButtonOptionEntry) {\n                var multiple = extraButtonOptionEntry.multiple,\n                    validation = qq.extend({}, self._options.validation, true),\n                    extraButtonSpec = qq.extend({}, extraButtonOptionEntry);\n\n                if (multiple === undefined) {\n                    multiple = self._options.multiple;\n                }\n\n                if (extraButtonSpec.validation) {\n                    qq.extend(validation, extraButtonOptionEntry.validation, true);\n                }\n\n                qq.extend(extraButtonSpec, {\n                    multiple: multiple,\n                    validation: validation\n                }, true);\n\n                self._initExtraButton(extraButtonSpec);\n            });\n        },\n\n        _getButton: function(buttonId) {\n            var extraButtonsSpec = this._extraButtonSpecs[buttonId];\n\n            if (extraButtonsSpec) {\n                return extraButtonsSpec.element;\n            }\n            else if (buttonId === this._defaultButtonId) {\n                return this._options.button;\n            }\n        },\n\n        /**\n         * Gets the internally used tracking ID for a button.\n         *\n         * @param buttonOrFileInputOrFile `File`, `<input type=\"file\">`, or a button container element\n         * @returns {*} The button's ID, or undefined if no ID is recoverable\n         * @private\n         */\n        _getButtonId: function(buttonOrFileInputOrFile) {\n            var inputs, fileInput,\n                fileBlobOrInput = buttonOrFileInputOrFile;\n\n            // We want the reference file/blob here if this is a proxy (a file that will be generated on-demand later)\n            if (fileBlobOrInput instanceof qq.BlobProxy) {\n                fileBlobOrInput = fileBlobOrInput.referenceBlob;\n            }\n\n            // If the item is a `Blob` it will never be associated with a button or drop zone.\n            if (fileBlobOrInput && !qq.isBlob(fileBlobOrInput)) {\n                if (qq.isFile(fileBlobOrInput)) {\n                    return fileBlobOrInput.qqButtonId;\n                }\n                else if (fileBlobOrInput.tagName.toLowerCase() === \"input\" &&\n                    fileBlobOrInput.type.toLowerCase() === \"file\") {\n\n                    return fileBlobOrInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);\n                }\n\n                inputs = fileBlobOrInput.getElementsByTagName(\"input\");\n\n                qq.each(inputs, function(idx, input) {\n                    if (input.getAttribute(\"type\") === \"file\") {\n                        fileInput = input;\n                        return false;\n                    }\n                });\n\n                if (fileInput) {\n                    return fileInput.getAttribute(qq.UploadButton.BUTTON_ID_ATTR_NAME);\n                }\n            }\n        },\n\n        _getNotFinished: function() {\n            return this._uploadData.retrieve({\n                status: [\n                    qq.status.UPLOADING,\n                    qq.status.UPLOAD_RETRYING,\n                    qq.status.QUEUED,\n                    qq.status.SUBMITTING,\n                    qq.status.SUBMITTED,\n                    qq.status.PAUSED\n                ]\n            }).length;\n        },\n\n        // Get the validation options for this button.  Could be the default validation option\n        // or a specific one assigned to this particular button.\n        _getValidationBase: function(buttonId) {\n            var extraButtonSpec = this._extraButtonSpecs[buttonId];\n\n            return extraButtonSpec ? extraButtonSpec.validation : this._options.validation;\n        },\n\n        _getValidationDescriptor: function(fileWrapper) {\n            if (fileWrapper.file instanceof qq.BlobProxy) {\n                return {\n                    name: qq.getFilename(fileWrapper.file.referenceBlob),\n                    size: fileWrapper.file.referenceBlob.size\n                };\n            }\n\n            return {\n                name: this.getUploads({id: fileWrapper.id}).name,\n                size: this.getUploads({id: fileWrapper.id}).size\n            };\n        },\n\n        _getValidationDescriptors: function(fileWrappers) {\n            var self = this,\n                fileDescriptors = [];\n\n            qq.each(fileWrappers, function(idx, fileWrapper) {\n                fileDescriptors.push(self._getValidationDescriptor(fileWrapper));\n            });\n\n            return fileDescriptors;\n        },\n\n        // Allows camera access on either the default or an extra button for iOS devices.\n        _handleCameraAccess: function() {\n            if (this._options.camera.ios && qq.ios()) {\n                var acceptIosCamera = \"image/*;capture=camera\",\n                    button = this._options.camera.button,\n                    buttonId = button ? this._getButtonId(button) : this._defaultButtonId,\n                    optionRoot = this._options;\n\n                // If we are not targeting the default button, it is an \"extra\" button\n                if (buttonId && buttonId !== this._defaultButtonId) {\n                    optionRoot = this._extraButtonSpecs[buttonId];\n                }\n\n                // Camera access won't work in iOS if the `multiple` attribute is present on the file input\n                optionRoot.multiple = false;\n\n                // update the options\n                if (optionRoot.validation.acceptFiles === null) {\n                    optionRoot.validation.acceptFiles = acceptIosCamera;\n                }\n                else {\n                    optionRoot.validation.acceptFiles += \",\" + acceptIosCamera;\n                }\n\n                // update the already-created button\n                qq.each(this._buttons, function(idx, button) {\n                    if (button.getButtonId() === buttonId) {\n                        button.setMultiple(optionRoot.multiple);\n                        button.setAcceptFiles(optionRoot.acceptFiles);\n\n                        return false;\n                    }\n                });\n            }\n        },\n\n        _handleCheckedCallback: function(details) {\n            var self = this,\n                callbackRetVal = details.callback();\n\n            if (qq.isGenericPromise(callbackRetVal)) {\n                this.log(details.name + \" - waiting for \" + details.name + \" promise to be fulfilled for \" + details.identifier);\n                return callbackRetVal.then(\n                    function(successParam) {\n                        self.log(details.name + \" promise success for \" + details.identifier);\n                        details.onSuccess(successParam);\n                    },\n                    function() {\n                        if (details.onFailure) {\n                            self.log(details.name + \" promise failure for \" + details.identifier);\n                            details.onFailure();\n                        }\n                        else {\n                            self.log(details.name + \" promise failure for \" + details.identifier);\n                        }\n                    });\n            }\n\n            if (callbackRetVal !== false) {\n                details.onSuccess(callbackRetVal);\n            }\n            else {\n                if (details.onFailure) {\n                    this.log(details.name + \" - return value was 'false' for \" + details.identifier + \".  Invoking failure callback.\");\n                    details.onFailure();\n                }\n                else {\n                    this.log(details.name + \" - return value was 'false' for \" + details.identifier + \".  Will not proceed.\");\n                }\n            }\n\n            return callbackRetVal;\n        },\n\n        // Updates internal state when a new file has been received, and adds it along with its ID to a passed array.\n        _handleNewFile: function(file, batchId, newFileWrapperList) {\n            var self = this,\n                uuid = qq.getUniqueId(),\n                size = -1,\n                name = qq.getFilename(file),\n                actualFile = file.blob || file,\n                handler = this._customNewFileHandler ?\n                    this._customNewFileHandler :\n                    qq.bind(self._handleNewFileGeneric, self);\n\n            if (!qq.isInput(actualFile) && actualFile.size >= 0) {\n                size = actualFile.size;\n            }\n\n            handler(actualFile, name, uuid, size, newFileWrapperList, batchId, this._options.request.uuidName, {\n                uploadData: self._uploadData,\n                paramsStore: self._paramsStore,\n                addFileToHandler: function(id, file) {\n                    self._handler.add(id, file);\n                    self._netUploadedOrQueued++;\n                    self._trackButton(id);\n                }\n            });\n        },\n\n        _handleNewFileGeneric: function(file, name, uuid, size, fileList, batchId) {\n            var id = this._uploadData.addFile({uuid: uuid, name: name, size: size, batchId: batchId});\n\n            this._handler.add(id, file);\n            this._trackButton(id);\n\n            this._netUploadedOrQueued++;\n\n            fileList.push({id: id, file: file});\n        },\n\n        _handlePasteSuccess: function(blob, extSuppliedName) {\n            var extension = blob.type.split(\"/\")[1],\n                name = extSuppliedName;\n\n            /*jshint eqeqeq: true, eqnull: true*/\n            if (name == null) {\n                name = this._options.paste.defaultName;\n            }\n\n            name += \".\" + extension;\n\n            this.addFiles({\n                name: name,\n                blob: blob\n            });\n        },\n\n        _handleDeleteSuccess: function(id) {\n            if (this.getUploads({id: id}).status !== qq.status.DELETED) {\n                var name = this.getName(id);\n\n                this._netUploadedOrQueued--;\n                this._netUploaded--;\n                this._handler.expunge(id);\n                this._uploadData.setStatus(id, qq.status.DELETED);\n                this.log(\"Delete request for '\" + name + \"' has succeeded.\");\n            }\n        },\n\n        _handleDeleteFailed: function(id, xhrOrXdr) {\n            var name = this.getName(id);\n\n            this._uploadData.setStatus(id, qq.status.DELETE_FAILED);\n            this.log(\"Delete request for '\" + name + \"' has failed.\", \"error\");\n\n            // Check first if xhrOrXdr is actually passed or valid\n            // For error reporting, we only have access to the response status if this is not\n            // an `XDomainRequest`.\n            if (!xhrOrXdr || xhrOrXdr.withCredentials === undefined) {\n                this._options.callbacks.onError(id, name, \"Delete request failed\", xhrOrXdr);\n            }\n            else {\n                this._options.callbacks.onError(id, name, \"Delete request failed with response code \" + xhrOrXdr.status, xhrOrXdr);\n            }\n        },\n\n        // Creates an extra button element\n        _initExtraButton: function(spec) {\n            var button = this._createUploadButton({\n                accept: spec.validation.acceptFiles,\n                allowedExtensions: spec.validation.allowedExtensions,\n                element: spec.element,\n                folders: spec.folders,\n                multiple: spec.multiple,\n                title: spec.fileInputTitle\n            });\n\n            this._extraButtonSpecs[button.getButtonId()] = spec;\n        },\n\n        _initFormSupportAndParams: function() {\n            this._formSupport = qq.FormSupport && new qq.FormSupport(\n                this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this)\n            );\n\n            if (this._formSupport && this._formSupport.attachedToForm) {\n                this._paramsStore = this._createStore(\n                    this._options.request.params,  this._formSupport.getFormInputsAsObject\n                );\n\n                this._options.autoUpload = this._formSupport.newAutoUpload;\n                if (this._formSupport.newEndpoint) {\n                    this._options.request.endpoint = this._formSupport.newEndpoint;\n                }\n            }\n            else {\n                this._paramsStore = this._createStore(this._options.request.params);\n            }\n        },\n\n        _isDeletePossible: function() {\n            if (!qq.DeleteFileAjaxRequester || !this._options.deleteFile.enabled) {\n                return false;\n            }\n\n            if (this._options.cors.expected) {\n                if (qq.supportedFeatures.deleteFileCorsXhr) {\n                    return true;\n                }\n\n                if (qq.supportedFeatures.deleteFileCorsXdr && this._options.cors.allowXdr) {\n                    return true;\n                }\n\n                return false;\n            }\n\n            return true;\n        },\n\n        _isAllowedExtension: function(allowed, fileName) {\n            var valid = false;\n\n            if (!allowed.length) {\n                return true;\n            }\n\n            qq.each(allowed, function(idx, allowedExt) {\n                /**\n                 * If an argument is not a string, ignore it.  Added when a possible issue with MooTools hijacking the\n                 * `allowedExtensions` array was discovered.  See case #735 in the issue tracker for more details.\n                 */\n                if (qq.isString(allowedExt)) {\n                    /*jshint eqeqeq: true, eqnull: true*/\n                    var extRegex = new RegExp(\"\\\\.\" + allowedExt + \"$\", \"i\");\n\n                    if (fileName.match(extRegex) != null) {\n                        valid = true;\n                        return false;\n                    }\n                }\n            });\n\n            return valid;\n        },\n\n        /**\n         * Constructs and returns a message that describes an item/file error.  Also calls `onError` callback.\n         *\n         * @param code REQUIRED - a code that corresponds to a stock message describing this type of error\n         * @param maybeNameOrNames names of the items that have failed, if applicable\n         * @param item `File`, `Blob`, or `<input type=\"file\">`\n         * @private\n         */\n        _itemError: function(code, maybeNameOrNames, item) {\n            var message = this._options.messages[code],\n                allowedExtensions = [],\n                names = [].concat(maybeNameOrNames),\n                name = names[0],\n                buttonId = this._getButtonId(item),\n                validationBase = this._getValidationBase(buttonId),\n                extensionsForMessage, placeholderMatch;\n\n            function r(name, replacement) { message = message.replace(name, replacement); }\n\n            qq.each(validationBase.allowedExtensions, function(idx, allowedExtension) {\n                /**\n                 * If an argument is not a string, ignore it.  Added when a possible issue with MooTools hijacking the\n                 * `allowedExtensions` array was discovered.  See case #735 in the issue tracker for more details.\n                 */\n                if (qq.isString(allowedExtension)) {\n                    allowedExtensions.push(allowedExtension);\n                }\n            });\n\n            extensionsForMessage = allowedExtensions.join(\", \").toLowerCase();\n\n            r(\"{file}\", this._options.formatFileName(name));\n            r(\"{extensions}\", extensionsForMessage);\n            r(\"{sizeLimit}\", this._formatSize(validationBase.sizeLimit));\n            r(\"{minSizeLimit}\", this._formatSize(validationBase.minSizeLimit));\n\n            placeholderMatch = message.match(/(\\{\\w+\\})/g);\n            if (placeholderMatch !== null) {\n                qq.each(placeholderMatch, function(idx, placeholder) {\n                    r(placeholder, names[idx]);\n                });\n            }\n\n            this._options.callbacks.onError(null, name, message, undefined);\n\n            return message;\n        },\n\n        /**\n         * Conditionally orders a manual retry of a failed upload.\n         *\n         * @param id File ID of the failed upload\n         * @param callback Optional callback to invoke if a retry is prudent.\n         * In lieu of asking the upload handler to retry.\n         * @returns {boolean} true if a manual retry will occur\n         * @private\n         */\n        _manualRetry: function(id, callback) {\n            if (this._onBeforeManualRetry(id)) {\n                this._netUploadedOrQueued++;\n                this._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);\n\n                if (callback) {\n                    callback(id);\n                }\n                else {\n                    this._handler.retry(id);\n                }\n\n                return true;\n            }\n        },\n\n        _maybeAllComplete: function(id, status) {\n            var self = this,\n                notFinished = this._getNotFinished();\n\n            if (status === qq.status.UPLOAD_SUCCESSFUL) {\n                this._succeededSinceLastAllComplete.push(id);\n            }\n            else if (status === qq.status.UPLOAD_FAILED) {\n                this._failedSinceLastAllComplete.push(id);\n            }\n\n            if (notFinished === 0 &&\n                (this._succeededSinceLastAllComplete.length || this._failedSinceLastAllComplete.length)) {\n                // Attempt to ensure onAllComplete is not invoked before other callbacks, such as onCancel & onComplete\n                setTimeout(function() {\n                    self._onAllComplete(self._succeededSinceLastAllComplete, self._failedSinceLastAllComplete);\n                }, 0);\n            }\n        },\n\n        _maybeHandleIos8SafariWorkaround: function() {\n            var self = this;\n\n            if (this._options.workarounds.ios8SafariUploads && qq.ios800() && qq.iosSafari()) {\n                setTimeout(function() {\n                    window.alert(self._options.messages.unsupportedBrowserIos8Safari);\n                }, 0);\n                throw new qq.Error(this._options.messages.unsupportedBrowserIos8Safari);\n            }\n        },\n\n        _maybeParseAndSendUploadError: function(id, name, response, xhr) {\n            // Assuming no one will actually set the response code to something other than 200\n            // and still set 'success' to true...\n            if (!response.success) {\n                if (xhr && xhr.status !== 200 && !response.error) {\n                    this._options.callbacks.onError(id, name, \"XHR returned response code \" + xhr.status, xhr);\n                }\n                else {\n                    var errorReason = response.error ? response.error : this._options.text.defaultResponseError;\n                    this._options.callbacks.onError(id, name, errorReason, xhr);\n                }\n            }\n        },\n\n        _maybeProcessNextItemAfterOnValidateCallback: function(validItem, items, index, params, endpoint) {\n            var self = this;\n\n            if (items.length > index) {\n                if (validItem || !this._options.validation.stopOnFirstInvalidFile) {\n                    //use setTimeout to prevent a stack overflow with a large number of files in the batch & non-promissory callbacks\n                    setTimeout(function() {\n                        var validationDescriptor = self._getValidationDescriptor(items[index]),\n                            buttonId = self._getButtonId(items[index].file),\n                            button = self._getButton(buttonId);\n\n                        self._handleCheckedCallback({\n                            name: \"onValidate\",\n                            callback: qq.bind(self._options.callbacks.onValidate, self, validationDescriptor, button),\n                            onSuccess: qq.bind(self._onValidateCallbackSuccess, self, items, index, params, endpoint),\n                            onFailure: qq.bind(self._onValidateCallbackFailure, self, items, index, params, endpoint),\n                            identifier: \"Item '\" + validationDescriptor.name + \"', size: \" + validationDescriptor.size\n                        });\n                    }, 0);\n                }\n                else if (!validItem) {\n                    for (; index < items.length; index++) {\n                        self._fileOrBlobRejected(items[index].id);\n                    }\n                }\n            }\n        },\n\n        _onAllComplete: function(successful, failed) {\n            this._totalProgress && this._totalProgress.onAllComplete(successful, failed, this._preventRetries);\n\n            this._options.callbacks.onAllComplete(qq.extend([], successful), qq.extend([], failed));\n\n            this._succeededSinceLastAllComplete = [];\n            this._failedSinceLastAllComplete = [];\n        },\n\n        /**\n         * Attempt to automatically retry a failed upload.\n         *\n         * @param id The file ID of the failed upload\n         * @param name The name of the file associated with the failed upload\n         * @param responseJSON Response from the server, parsed into a javascript object\n         * @param xhr Ajax transport used to send the failed request\n         * @param callback Optional callback to be invoked if a retry is prudent.\n         * Invoked in lieu of asking the upload handler to retry.\n         * @returns {boolean} true if an auto-retry will occur\n         * @private\n         */\n        _onAutoRetry: function(id, name, responseJSON, xhr, callback) {\n            var self = this;\n\n            self._preventRetries[id] = responseJSON[self._options.retry.preventRetryResponseProperty];\n\n            if (self._shouldAutoRetry(id, name, responseJSON)) {\n                var retryWaitPeriod = self._options.retry.autoAttemptDelay * 1000;\n\n                self._maybeParseAndSendUploadError.apply(self, arguments);\n                self._options.callbacks.onAutoRetry(id, name, self._autoRetries[id]);\n                self._onBeforeAutoRetry(id, name);\n\n                self._uploadData.setStatus(id, qq.status.UPLOAD_RETRYING);\n                self._retryTimeouts[id] = setTimeout(function() {\n                    self.log(\"Starting retry for \" + name + \"...\");\n\n                    if (callback) {\n                        callback(id);\n                    }\n                    else {\n                        self._handler.retry(id);\n                    }\n                }, retryWaitPeriod);\n\n                return true;\n            }\n        },\n\n        _onBeforeAutoRetry: function(id, name) {\n            this.log(\"Waiting \" + this._options.retry.autoAttemptDelay + \" seconds before retrying \" + name + \"...\");\n        },\n\n        //return false if we should not attempt the requested retry\n        _onBeforeManualRetry: function(id) {\n            var itemLimit = this._currentItemLimit,\n                fileName;\n\n            if (this._preventRetries[id]) {\n                this.log(\"Retries are forbidden for id \" + id, \"warn\");\n                return false;\n            }\n            else if (this._handler.isValid(id)) {\n                fileName = this.getName(id);\n\n                if (this._options.callbacks.onManualRetry(id, fileName) === false) {\n                    return false;\n                }\n\n                if (itemLimit > 0 && this._netUploadedOrQueued + 1 > itemLimit) {\n                    this._itemError(\"retryFailTooManyItems\");\n                    return false;\n                }\n\n                this.log(\"Retrying upload for '\" + fileName + \"' (id: \" + id + \")...\");\n                return true;\n            }\n            else {\n                this.log(\"'\" + id + \"' is not a valid file ID\", \"error\");\n                return false;\n            }\n        },\n\n        _onCancel: function(id, name) {\n            this._netUploadedOrQueued--;\n\n            clearTimeout(this._retryTimeouts[id]);\n\n            var storedItemIndex = qq.indexOf(this._storedIds, id);\n            if (!this._options.autoUpload && storedItemIndex >= 0) {\n                this._storedIds.splice(storedItemIndex, 1);\n            }\n\n            this._uploadData.setStatus(id, qq.status.CANCELED);\n        },\n\n        _onComplete: function(id, name, result, xhr) {\n            if (!result.success) {\n                this._netUploadedOrQueued--;\n                this._uploadData.setStatus(id, qq.status.UPLOAD_FAILED);\n\n                if (result[this._options.retry.preventRetryResponseProperty] === true) {\n                    this._preventRetries[id] = true;\n                }\n            }\n            else {\n                if (result.thumbnailUrl) {\n                    this._thumbnailUrls[id] = result.thumbnailUrl;\n                }\n\n                this._netUploaded++;\n                this._uploadData.setStatus(id, qq.status.UPLOAD_SUCCESSFUL);\n            }\n\n            this._maybeParseAndSendUploadError(id, name, result, xhr);\n\n            return result.success ? true : false;\n        },\n\n        _onDelete: function(id) {\n            this._uploadData.setStatus(id, qq.status.DELETING);\n        },\n\n        _onDeleteComplete: function(id, xhrOrXdr, isError) {\n            var name = this.getName(id);\n\n            if (isError) {\n                this._handleDeleteFailed(id, xhrOrXdr);\n            }\n            else {\n                this._handleDeleteSuccess(id);\n            }\n        },\n\n        _onInputChange: function(input) {\n            var fileIndex;\n\n            if (qq.supportedFeatures.ajaxUploading) {\n                for (fileIndex = 0; fileIndex < input.files.length; fileIndex++) {\n                    this._annotateWithButtonId(input.files[fileIndex], input);\n                }\n\n                this.addFiles(input.files);\n            }\n            // Android 2.3.x will fire `onchange` even if no file has been selected\n            else if (input.value.length > 0) {\n                this.addFiles(input);\n            }\n\n            qq.each(this._buttons, function(idx, button) {\n                button.reset();\n            });\n        },\n\n        _onProgress: function(id, name, loaded, total) {\n            this._totalProgress && this._totalProgress.onIndividualProgress(id, loaded, total);\n        },\n\n        _onSubmit: function(id, name) {\n            //nothing to do yet in core uploader\n        },\n\n        _onSubmitCallbackSuccess: function(id, name) {\n            this._onSubmit.apply(this, arguments);\n            this._uploadData.setStatus(id, qq.status.SUBMITTED);\n            this._onSubmitted.apply(this, arguments);\n\n            if (this._options.autoUpload) {\n                this._options.callbacks.onSubmitted.apply(this, arguments);\n                this._uploadFile(id);\n            }\n            else {\n                this._storeForLater(id);\n                this._options.callbacks.onSubmitted.apply(this, arguments);\n            }\n        },\n\n        _onSubmitDelete: function(id, onSuccessCallback, additionalMandatedParams) {\n            var uuid = this.getUuid(id),\n                adjustedOnSuccessCallback;\n\n            if (onSuccessCallback) {\n                adjustedOnSuccessCallback = qq.bind(onSuccessCallback, this, id, uuid, additionalMandatedParams);\n            }\n\n            if (this._isDeletePossible()) {\n                this._handleCheckedCallback({\n                    name: \"onSubmitDelete\",\n                    callback: qq.bind(this._options.callbacks.onSubmitDelete, this, id),\n                    onSuccess: adjustedOnSuccessCallback ||\n                        qq.bind(this._deleteHandler.sendDelete, this, id, uuid, additionalMandatedParams),\n                    identifier: id\n                });\n                return true;\n            }\n            else {\n                this.log(\"Delete request ignored for ID \" + id + \", delete feature is disabled or request not possible \" +\n                    \"due to CORS on a user agent that does not support pre-flighting.\", \"warn\");\n                return false;\n            }\n        },\n\n        _onSubmitted: function(id) {\n            //nothing to do in the base uploader\n        },\n\n        _onTotalProgress: function(loaded, total) {\n            this._options.callbacks.onTotalProgress(loaded, total);\n        },\n\n        _onUploadPrep: function(id) {\n            // nothing to do in the core uploader for now\n        },\n\n        _onUpload: function(id, name) {\n            this._uploadData.setStatus(id, qq.status.UPLOADING);\n        },\n\n        _onUploadChunk: function(id, chunkData) {\n            //nothing to do in the base uploader\n        },\n\n        _onUploadStatusChange: function(id, oldStatus, newStatus) {\n            // Make sure a \"queued\" retry attempt is canceled if the upload has been paused\n            if (newStatus === qq.status.PAUSED) {\n                clearTimeout(this._retryTimeouts[id]);\n            }\n        },\n\n        _onValidateBatchCallbackFailure: function(fileWrappers) {\n            var self = this;\n\n            qq.each(fileWrappers, function(idx, fileWrapper) {\n                self._fileOrBlobRejected(fileWrapper.id);\n            });\n        },\n\n        _onValidateBatchCallbackSuccess: function(validationDescriptors, items, params, endpoint, button) {\n            var errorMessage,\n                itemLimit = this._currentItemLimit,\n                proposedNetFilesUploadedOrQueued = this._netUploadedOrQueued;\n\n            if (itemLimit === 0 || proposedNetFilesUploadedOrQueued <= itemLimit) {\n                if (items.length > 0) {\n                    this._handleCheckedCallback({\n                        name: \"onValidate\",\n                        callback: qq.bind(this._options.callbacks.onValidate, this, validationDescriptors[0], button),\n                        onSuccess: qq.bind(this._onValidateCallbackSuccess, this, items, 0, params, endpoint),\n                        onFailure: qq.bind(this._onValidateCallbackFailure, this, items, 0, params, endpoint),\n                        identifier: \"Item '\" + items[0].file.name + \"', size: \" + items[0].file.size\n                    });\n                }\n                else {\n                    this._itemError(\"noFilesError\");\n                }\n            }\n            else {\n                this._onValidateBatchCallbackFailure(items);\n                errorMessage = this._options.messages.tooManyItemsError\n                    .replace(/\\{netItems\\}/g, proposedNetFilesUploadedOrQueued)\n                    .replace(/\\{itemLimit\\}/g, itemLimit);\n                this._batchError(errorMessage);\n            }\n        },\n\n        _onValidateCallbackFailure: function(items, index, params, endpoint) {\n            var nextIndex = index + 1;\n\n            this._fileOrBlobRejected(items[index].id, items[index].file.name);\n\n            this._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);\n        },\n\n        _onValidateCallbackSuccess: function(items, index, params, endpoint) {\n            var self = this,\n                nextIndex = index + 1,\n                validationDescriptor = this._getValidationDescriptor(items[index]);\n\n            this._validateFileOrBlobData(items[index], validationDescriptor)\n                .then(\n                function() {\n                    self._upload(items[index].id, params, endpoint);\n                    self._maybeProcessNextItemAfterOnValidateCallback(true, items, nextIndex, params, endpoint);\n                },\n                function() {\n                    self._maybeProcessNextItemAfterOnValidateCallback(false, items, nextIndex, params, endpoint);\n                }\n            );\n        },\n\n        _prepareItemsForUpload: function(items, params, endpoint) {\n            if (items.length === 0) {\n                this._itemError(\"noFilesError\");\n                return;\n            }\n\n            var validationDescriptors = this._getValidationDescriptors(items),\n                buttonId = this._getButtonId(items[0].file),\n                button = this._getButton(buttonId);\n\n            this._handleCheckedCallback({\n                name: \"onValidateBatch\",\n                callback: qq.bind(this._options.callbacks.onValidateBatch, this, validationDescriptors, button),\n                onSuccess: qq.bind(this._onValidateBatchCallbackSuccess, this, validationDescriptors, items, params, endpoint, button),\n                onFailure: qq.bind(this._onValidateBatchCallbackFailure, this, items),\n                identifier: \"batch validation\"\n            });\n        },\n\n        _preventLeaveInProgress: function() {\n            var self = this;\n\n            this._disposeSupport.attach(window, \"beforeunload\", function(e) {\n                if (self.getInProgress()) {\n                    e = e || window.event;\n                    // for ie, ff\n                    e.returnValue = self._options.messages.onLeave;\n                    // for webkit\n                    return self._options.messages.onLeave;\n                }\n            });\n        },\n\n        // Attempts to refresh session data only if the `qq.Session` module exists\n        // and a session endpoint has been specified.  The `onSessionRequestComplete`\n        // callback will be invoked once the refresh is complete.\n        _refreshSessionData: function() {\n            var self = this,\n                options = this._options.session;\n\n            /* jshint eqnull:true */\n            if (qq.Session && this._options.session.endpoint != null) {\n                if (!this._session) {\n                    qq.extend(options, {cors: this._options.cors});\n\n                    options.log = qq.bind(this.log, this);\n                    options.addFileRecord = qq.bind(this._addCannedFile, this);\n\n                    this._session = new qq.Session(options);\n                }\n\n                setTimeout(function() {\n                    self._session.refresh().then(function(response, xhrOrXdr) {\n                        self._sessionRequestComplete();\n                        self._options.callbacks.onSessionRequestComplete(response, true, xhrOrXdr);\n\n                    }, function(response, xhrOrXdr) {\n\n                        self._options.callbacks.onSessionRequestComplete(response, false, xhrOrXdr);\n                    });\n                }, 0);\n            }\n        },\n\n        _sessionRequestComplete: function() {},\n\n        _setSize: function(id, newSize) {\n            this._uploadData.updateSize(id, newSize);\n            this._totalProgress && this._totalProgress.onNewSize(id);\n        },\n\n        _shouldAutoRetry: function(id, name, responseJSON) {\n            var uploadData = this._uploadData.retrieve({id: id});\n\n            /*jshint laxbreak: true */\n            if (!this._preventRetries[id]\n                && this._options.retry.enableAuto\n                && uploadData.status !== qq.status.PAUSED) {\n\n                if (this._autoRetries[id] === undefined) {\n                    this._autoRetries[id] = 0;\n                }\n\n                if (this._autoRetries[id] < this._options.retry.maxAutoAttempts) {\n                    this._autoRetries[id] += 1;\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        _storeForLater: function(id) {\n            this._storedIds.push(id);\n        },\n\n        // Maps a file with the button that was used to select it.\n        _trackButton: function(id) {\n            var buttonId;\n\n            if (qq.supportedFeatures.ajaxUploading) {\n                buttonId = this._handler.getFile(id).qqButtonId;\n            }\n            else {\n                buttonId = this._getButtonId(this._handler.getInput(id));\n            }\n\n            if (buttonId) {\n                this._buttonIdsForFileIds[id] = buttonId;\n            }\n        },\n\n        _updateFormSupportAndParams: function(formElementOrId) {\n            this._options.form.element = formElementOrId;\n\n            this._formSupport = qq.FormSupport && new qq.FormSupport(\n                    this._options.form, qq.bind(this.uploadStoredFiles, this), qq.bind(this.log, this)\n                );\n\n            if (this._formSupport && this._formSupport.attachedToForm) {\n                this._paramsStore.addReadOnly(null, this._formSupport.getFormInputsAsObject);\n\n                this._options.autoUpload = this._formSupport.newAutoUpload;\n                if (this._formSupport.newEndpoint) {\n                    this.setEndpoint(this._formSupport.newEndpoint);\n                }\n            }\n        },\n\n        _upload: function(id, params, endpoint) {\n            var name = this.getName(id);\n\n            if (params) {\n                this.setParams(params, id);\n            }\n\n            if (endpoint) {\n                this.setEndpoint(endpoint, id);\n            }\n\n            this._handleCheckedCallback({\n                name: \"onSubmit\",\n                callback: qq.bind(this._options.callbacks.onSubmit, this, id, name),\n                onSuccess: qq.bind(this._onSubmitCallbackSuccess, this, id, name),\n                onFailure: qq.bind(this._fileOrBlobRejected, this, id, name),\n                identifier: id\n            });\n        },\n\n        _uploadFile: function(id) {\n            if (!this._handler.upload(id)) {\n                this._uploadData.setStatus(id, qq.status.QUEUED);\n            }\n        },\n\n        _uploadStoredFiles: function() {\n            var idToUpload, stillSubmitting,\n                self = this;\n\n            while (this._storedIds.length) {\n                idToUpload = this._storedIds.shift();\n                this._uploadFile(idToUpload);\n            }\n\n            // If we are still waiting for some files to clear validation, attempt to upload these again in a bit\n            stillSubmitting = this.getUploads({status: qq.status.SUBMITTING}).length;\n            if (stillSubmitting) {\n                qq.log(\"Still waiting for \" + stillSubmitting + \" files to clear submit queue. Will re-parse stored IDs array shortly.\");\n                setTimeout(function() {\n                    self._uploadStoredFiles();\n                }, 1000);\n            }\n        },\n\n        /**\n         * Performs some internal validation checks on an item, defined in the `validation` option.\n         *\n         * @param fileWrapper Wrapper containing a `file` along with an `id`\n         * @param validationDescriptor Normalized information about the item (`size`, `name`).\n         * @returns qq.Promise with appropriate callbacks invoked depending on the validity of the file\n         * @private\n         */\n        _validateFileOrBlobData: function(fileWrapper, validationDescriptor) {\n            var self = this,\n                file = (function() {\n                    if (fileWrapper.file instanceof qq.BlobProxy) {\n                        return fileWrapper.file.referenceBlob;\n                    }\n                    return fileWrapper.file;\n                }()),\n                name = validationDescriptor.name,\n                size = validationDescriptor.size,\n                buttonId = this._getButtonId(fileWrapper.file),\n                validationBase = this._getValidationBase(buttonId),\n                validityChecker = new qq.Promise();\n\n            validityChecker.then(\n                function() {},\n                function() {\n                    self._fileOrBlobRejected(fileWrapper.id, name);\n                });\n\n            if (qq.isFileOrInput(file) && !this._isAllowedExtension(validationBase.allowedExtensions, name)) {\n                this._itemError(\"typeError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (!this._options.validation.allowEmpty && size === 0) {\n                this._itemError(\"emptyError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (size > 0 && validationBase.sizeLimit && size > validationBase.sizeLimit) {\n                this._itemError(\"sizeError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (size > 0 && size < validationBase.minSizeLimit) {\n                this._itemError(\"minSizeError\", name, file);\n                return validityChecker.failure();\n            }\n\n            if (qq.ImageValidation && qq.supportedFeatures.imagePreviews && qq.isFile(file)) {\n                new qq.ImageValidation(file, qq.bind(self.log, self)).validate(validationBase.image).then(\n                    validityChecker.success,\n                    function(errorCode) {\n                        self._itemError(errorCode + \"ImageError\", name, file);\n                        validityChecker.failure();\n                    }\n                );\n            }\n            else {\n                validityChecker.success();\n            }\n\n            return validityChecker;\n        },\n\n        _wrapCallbacks: function() {\n            var self, safeCallback, prop;\n\n            self = this;\n\n            safeCallback = function(name, callback, args) {\n                var errorMsg;\n\n                try {\n                    return callback.apply(self, args);\n                }\n                catch (exception) {\n                    errorMsg = exception.message || exception.toString();\n                    self.log(\"Caught exception in '\" + name + \"' callback - \" + errorMsg, \"error\");\n                }\n            };\n\n            /* jshint forin: false, loopfunc: true */\n            for (prop in this._options.callbacks) {\n                (function() {\n                    var callbackName, callbackFunc;\n                    callbackName = prop;\n                    callbackFunc = self._options.callbacks[callbackName];\n                    self._options.callbacks[callbackName] = function() {\n                        return safeCallback(callbackName, callbackFunc, arguments);\n                    };\n                }());\n            }\n        }\n    };\n}());\n","/*globals qq*/\n(function() {\n    \"use strict\";\n\n    qq.FineUploaderBasic = function(o) {\n        var self = this;\n\n        // These options define FineUploaderBasic mode.\n        this._options = {\n            debug: false,\n            button: null,\n            multiple: true,\n            maxConnections: 3,\n            disableCancelForFormUploads: false,\n            autoUpload: true,\n\n            request: {\n                customHeaders: {},\n                endpoint: \"/server/upload\",\n                filenameParam: \"qqfilename\",\n                forceMultipart: true,\n                inputName: \"qqfile\",\n                method: \"POST\",\n                params: {},\n                paramsInBody: true,\n                totalFileSizeName: \"qqtotalfilesize\",\n                uuidName: \"qquuid\"\n            },\n\n            validation: {\n                allowedExtensions: [],\n                sizeLimit: 0,\n                minSizeLimit: 0,\n                itemLimit: 0,\n                stopOnFirstInvalidFile: true,\n                acceptFiles: null,\n                image: {\n                    maxHeight: 0,\n                    maxWidth: 0,\n                    minHeight: 0,\n                    minWidth: 0\n                },\n                allowEmpty: false\n            },\n\n            callbacks: {\n                onSubmit: function(id, name) {},\n                onSubmitted: function(id, name) {},\n                onComplete: function(id, name, responseJSON, maybeXhr) {},\n                onAllComplete: function(successful, failed) {},\n                onCancel: function(id, name) {},\n                onUpload: function(id, name) {},\n                onUploadChunk: function(id, name, chunkData) {},\n                onUploadChunkSuccess: function(id, chunkData, responseJSON, xhr) {},\n                onResume: function(id, fileName, chunkData) {},\n                onProgress: function(id, name, loaded, total) {},\n                onTotalProgress: function(loaded, total) {},\n                onError: function(id, name, reason, maybeXhrOrXdr) {},\n                onAutoRetry: function(id, name, attemptNumber) {},\n                onManualRetry: function(id, name) {},\n                onValidateBatch: function(fileOrBlobData) {},\n                onValidate: function(fileOrBlobData) {},\n                onSubmitDelete: function(id) {},\n                onDelete: function(id) {},\n                onDeleteComplete: function(id, xhrOrXdr, isError) {},\n                onPasteReceived: function(blob) {},\n                onStatusChange: function(id, oldStatus, newStatus) {},\n                onSessionRequestComplete: function(response, success, xhrOrXdr) {}\n            },\n\n            messages: {\n                typeError: \"{file} has an invalid extension. Valid extension(s): {extensions}.\",\n                sizeError: \"{file} is too large, maximum file size is {sizeLimit}.\",\n                minSizeError: \"{file} is too small, minimum file size is {minSizeLimit}.\",\n                emptyError: \"{file} is empty, please select files again without it.\",\n                noFilesError: \"No files to upload.\",\n                tooManyItemsError: \"Too many items ({netItems}) would be uploaded.  Item limit is {itemLimit}.\",\n                maxHeightImageError: \"Image is too tall.\",\n                maxWidthImageError: \"Image is too wide.\",\n                minHeightImageError: \"Image is not tall enough.\",\n                minWidthImageError: \"Image is not wide enough.\",\n                retryFailTooManyItems: \"Retry failed - you have reached your file limit.\",\n                onLeave: \"The files are being uploaded, if you leave now the upload will be canceled.\",\n                unsupportedBrowserIos8Safari: \"Unrecoverable error - this browser does not permit file uploading of any kind due to serious bugs in iOS8 Safari.  Please use iOS8 Chrome until Apple fixes these issues.\"\n            },\n\n            retry: {\n                enableAuto: false,\n                maxAutoAttempts: 3,\n                autoAttemptDelay: 5,\n                preventRetryResponseProperty: \"preventRetry\"\n            },\n\n            classes: {\n                buttonHover: \"qq-upload-button-hover\",\n                buttonFocus: \"qq-upload-button-focus\"\n            },\n\n            chunking: {\n                enabled: false,\n                concurrent: {\n                    enabled: false\n                },\n                mandatory: false,\n                paramNames: {\n                    partIndex: \"qqpartindex\",\n                    partByteOffset: \"qqpartbyteoffset\",\n                    chunkSize: \"qqchunksize\",\n                    totalFileSize: \"qqtotalfilesize\",\n                    totalParts: \"qqtotalparts\"\n                },\n                partSize: 2000000,\n                // only relevant for traditional endpoints, only required when concurrent.enabled === true\n                success: {\n                    endpoint: null\n                }\n            },\n\n            resume: {\n                enabled: false,\n                recordsExpireIn: 7, //days\n                paramNames: {\n                    resuming: \"qqresume\"\n                }\n            },\n\n            formatFileName: function(fileOrBlobName) {\n                return fileOrBlobName;\n            },\n\n            text: {\n                defaultResponseError: \"Upload failure reason unknown\",\n                fileInputTitle: \"file input\",\n                sizeSymbols: [\"kB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\"]\n            },\n\n            deleteFile: {\n                enabled: false,\n                method: \"DELETE\",\n                endpoint: \"/server/upload\",\n                customHeaders: {},\n                params: {}\n            },\n\n            cors: {\n                expected: false,\n                sendCredentials: false,\n                allowXdr: false\n            },\n\n            blobs: {\n                defaultName: \"misc_data\"\n            },\n\n            paste: {\n                targetElement: null,\n                defaultName: \"pasted_image\"\n            },\n\n            camera: {\n                ios: false,\n\n                // if ios is true: button is null means target the default button, otherwise target the button specified\n                button: null\n            },\n\n            // This refers to additional upload buttons to be handled by Fine Uploader.\n            // Each element is an object, containing `element` as the only required\n            // property.  The `element` must be a container that will ultimately\n            // contain an invisible `<input type=\"file\">` created by Fine Uploader.\n            // Optional properties of each object include `multiple`, `validation`,\n            // and `folders`.\n            extraButtons: [],\n\n            // Depends on the session module.  Used to query the server for an initial file list\n            // during initialization and optionally after a `reset`.\n            session: {\n                endpoint: null,\n                params: {},\n                customHeaders: {},\n                refreshOnReset: true\n            },\n\n            // Send parameters associated with an existing form along with the files\n            form: {\n                // Element ID, HTMLElement, or null\n                element: \"qq-form\",\n\n                // Overrides the base `autoUpload`, unless `element` is null.\n                autoUpload: false,\n\n                // true = upload files on form submission (and squelch submit event)\n                interceptSubmit: true\n            },\n\n            // scale images client side, upload a new file for each scaled version\n            scaling: {\n                customResizer: null,\n\n                // send the original file as well\n                sendOriginal: true,\n\n                // fox orientation for scaled images\n                orient: true,\n\n                // If null, scaled image type will match reference image type.  This value will be referred to\n                // for any size record that does not specific a type.\n                defaultType: null,\n\n                defaultQuality: 80,\n\n                failureText: \"Failed to scale\",\n\n                includeExif: false,\n\n                // metadata about each requested scaled version\n                sizes: []\n            },\n\n            workarounds: {\n                iosEmptyVideos: true,\n                ios8SafariUploads: true,\n                ios8BrowserCrash: false\n            }\n        };\n\n        // Replace any default options with user defined ones\n        qq.extend(this._options, o, true);\n\n        this._buttons = [];\n        this._extraButtonSpecs = {};\n        this._buttonIdsForFileIds = [];\n\n        this._wrapCallbacks();\n        this._disposeSupport =  new qq.DisposeSupport();\n\n        this._storedIds = [];\n        this._autoRetries = [];\n        this._retryTimeouts = [];\n        this._preventRetries = [];\n        this._thumbnailUrls = [];\n\n        this._netUploadedOrQueued = 0;\n        this._netUploaded = 0;\n        this._uploadData = this._createUploadDataTracker();\n\n        this._initFormSupportAndParams();\n\n        this._customHeadersStore = this._createStore(this._options.request.customHeaders);\n        this._deleteFileCustomHeadersStore = this._createStore(this._options.deleteFile.customHeaders);\n\n        this._deleteFileParamsStore = this._createStore(this._options.deleteFile.params);\n\n        this._endpointStore = this._createStore(this._options.request.endpoint);\n        this._deleteFileEndpointStore = this._createStore(this._options.deleteFile.endpoint);\n\n        this._handler = this._createUploadHandler();\n\n        this._deleteHandler = qq.DeleteFileAjaxRequester && this._createDeleteHandler();\n\n        if (this._options.button) {\n            this._defaultButtonId = this._createUploadButton({\n                element: this._options.button,\n                title: this._options.text.fileInputTitle\n            }).getButtonId();\n        }\n\n        this._generateExtraButtonSpecs();\n\n        this._handleCameraAccess();\n\n        if (this._options.paste.targetElement) {\n            if (qq.PasteSupport) {\n                this._pasteHandler = this._createPasteHandler();\n            }\n            else {\n                this.log(\"Paste support module not found\", \"error\");\n            }\n        }\n\n        this._preventLeaveInProgress();\n\n        this._imageGenerator = qq.ImageGenerator && new qq.ImageGenerator(qq.bind(this.log, this));\n        this._refreshSessionData();\n\n        this._succeededSinceLastAllComplete = [];\n        this._failedSinceLastAllComplete = [];\n\n        this._scaler = (qq.Scaler && new qq.Scaler(this._options.scaling, qq.bind(this.log, this))) || {};\n        if (this._scaler.enabled) {\n            this._customNewFileHandler = qq.bind(this._scaler.handleNewFile, this._scaler);\n        }\n\n        if (qq.TotalProgress && qq.supportedFeatures.progressBar) {\n            this._totalProgress = new qq.TotalProgress(\n                qq.bind(this._onTotalProgress, this),\n\n                function(id) {\n                    var entry = self._uploadData.retrieve({id: id});\n                    return (entry && entry.size) || 0;\n                }\n            );\n        }\n\n        this._currentItemLimit = this._options.validation.itemLimit;\n    };\n\n    // Define the private & public API methods.\n    qq.FineUploaderBasic.prototype = qq.basePublicApi;\n    qq.extend(qq.FineUploaderBasic.prototype, qq.basePrivateApi);\n}());\n","/*globals qq, XDomainRequest*/\n/** Generic class for sending non-upload ajax requests and handling the associated responses **/\nqq.AjaxRequester = function(o) {\n    \"use strict\";\n\n    var log, shouldParamsBeInQueryString,\n        queue = [],\n        requestData = {},\n        options = {\n            acceptHeader: null,\n            validMethods: [\"PATCH\", \"POST\", \"PUT\"],\n            method: \"POST\",\n            contentType: \"application/x-www-form-urlencoded\",\n            maxConnections: 3,\n            customHeaders: {},\n            endpointStore: {},\n            paramsStore: {},\n            mandatedParams: {},\n            allowXRequestedWithAndCacheControl: true,\n            successfulResponseCodes: {\n                DELETE: [200, 202, 204],\n                PATCH: [200, 201, 202, 203, 204],\n                POST: [200, 201, 202, 203, 204],\n                PUT: [200, 201, 202, 203, 204],\n                GET: [200]\n            },\n            cors: {\n                expected: false,\n                sendCredentials: false\n            },\n            log: function(str, level) {},\n            onSend: function(id) {},\n            onComplete: function(id, xhrOrXdr, isError) {},\n            onProgress: null\n        };\n\n    qq.extend(options, o);\n    log = options.log;\n\n    if (qq.indexOf(options.validMethods, options.method) < 0) {\n        throw new Error(\"'\" + options.method + \"' is not a supported method for this type of request!\");\n    }\n\n    // [Simple methods](http://www.w3.org/TR/cors/#simple-method)\n    // are defined by the W3C in the CORS spec as a list of methods that, in part,\n    // make a CORS request eligible to be exempt from preflighting.\n    function isSimpleMethod() {\n        return qq.indexOf([\"GET\", \"POST\", \"HEAD\"], options.method) >= 0;\n    }\n\n    // [Simple headers](http://www.w3.org/TR/cors/#simple-header)\n    // are defined by the W3C in the CORS spec as a list of headers that, in part,\n    // make a CORS request eligible to be exempt from preflighting.\n    function containsNonSimpleHeaders(headers) {\n        var containsNonSimple = false;\n\n        qq.each(containsNonSimple, function(idx, header) {\n            if (qq.indexOf([\"Accept\", \"Accept-Language\", \"Content-Language\", \"Content-Type\"], header) < 0) {\n                containsNonSimple = true;\n                return false;\n            }\n        });\n\n        return containsNonSimple;\n    }\n\n    function isXdr(xhr) {\n        //The `withCredentials` test is a commonly accepted way to determine if XHR supports CORS.\n        return options.cors.expected && xhr.withCredentials === undefined;\n    }\n\n    // Returns either a new `XMLHttpRequest` or `XDomainRequest` instance.\n    function getCorsAjaxTransport() {\n        var xhrOrXdr;\n\n        if (window.XMLHttpRequest || window.ActiveXObject) {\n            xhrOrXdr = qq.createXhrInstance();\n\n            if (xhrOrXdr.withCredentials === undefined) {\n                xhrOrXdr = new XDomainRequest();\n                // Workaround for XDR bug in IE9 - https://social.msdn.microsoft.com/Forums/ie/en-US/30ef3add-767c-4436-b8a9-f1ca19b4812e/ie9-rtm-xdomainrequest-issued-requests-may-abort-if-all-event-handlers-not-specified?forum=iewebdevelopment\n                xhrOrXdr.onload = function() {};\n                xhrOrXdr.onerror = function() {};\n                xhrOrXdr.ontimeout = function() {};\n                xhrOrXdr.onprogress = function() {};\n            }\n        }\n\n        return xhrOrXdr;\n    }\n\n    // Returns either a new XHR/XDR instance, or an existing one for the associated `File` or `Blob`.\n    function getXhrOrXdr(id, suppliedXhr) {\n        var xhrOrXdr = requestData[id].xhr;\n\n        if (!xhrOrXdr) {\n            if (suppliedXhr) {\n                xhrOrXdr = suppliedXhr;\n            }\n            else {\n                if (options.cors.expected) {\n                    xhrOrXdr = getCorsAjaxTransport();\n                }\n                else {\n                    xhrOrXdr = qq.createXhrInstance();\n                }\n            }\n\n            requestData[id].xhr = xhrOrXdr;\n        }\n\n        return xhrOrXdr;\n    }\n\n    // Removes element from queue, sends next request\n    function dequeue(id) {\n        var i = qq.indexOf(queue, id),\n            max = options.maxConnections,\n            nextId;\n\n        delete requestData[id];\n        queue.splice(i, 1);\n\n        if (queue.length >= max && i < max) {\n            nextId = queue[max - 1];\n            sendRequest(nextId);\n        }\n    }\n\n    function onComplete(id, xdrError) {\n        var xhr = getXhrOrXdr(id),\n            method = options.method,\n            isError = xdrError === true;\n\n        dequeue(id);\n\n        if (isError) {\n            log(method + \" request for \" + id + \" has failed\", \"error\");\n        }\n        else if (!isXdr(xhr) && !isResponseSuccessful(xhr.status)) {\n            isError = true;\n            log(method + \" request for \" + id + \" has failed - response code \" + xhr.status, \"error\");\n        }\n\n        options.onComplete(id, xhr, isError);\n    }\n\n    function getParams(id) {\n        var onDemandParams = requestData[id].additionalParams,\n            mandatedParams = options.mandatedParams,\n            params;\n\n        if (options.paramsStore.get) {\n            params = options.paramsStore.get(id);\n        }\n\n        if (onDemandParams) {\n            qq.each(onDemandParams, function(name, val) {\n                params = params || {};\n                params[name] = val;\n            });\n        }\n\n        if (mandatedParams) {\n            qq.each(mandatedParams, function(name, val) {\n                params = params || {};\n                params[name] = val;\n            });\n        }\n\n        return params;\n    }\n\n    function sendRequest(id, optXhr) {\n        var xhr = getXhrOrXdr(id, optXhr),\n            method = options.method,\n            params = getParams(id),\n            payload = requestData[id].payload,\n            url;\n\n        options.onSend(id);\n\n        url = createUrl(id, params, requestData[id].additionalQueryParams);\n\n        // XDR and XHR status detection APIs differ a bit.\n        if (isXdr(xhr)) {\n            xhr.onload = getXdrLoadHandler(id);\n            xhr.onerror = getXdrErrorHandler(id);\n        }\n        else {\n            xhr.onreadystatechange = getXhrReadyStateChangeHandler(id);\n        }\n\n        registerForUploadProgress(id);\n\n        // The last parameter is assumed to be ignored if we are actually using `XDomainRequest`.\n        xhr.open(method, url, true);\n\n        // Instruct the transport to send cookies along with the CORS request,\n        // unless we are using `XDomainRequest`, which is not capable of this.\n        if (options.cors.expected && options.cors.sendCredentials && !isXdr(xhr)) {\n            xhr.withCredentials = true;\n        }\n\n        setHeaders(id);\n\n        log(\"Sending \" + method + \" request for \" + id);\n\n        if (payload) {\n            xhr.send(payload);\n        }\n        else if (shouldParamsBeInQueryString || !params) {\n            xhr.send();\n        }\n        else if (params && options.contentType && options.contentType.toLowerCase().indexOf(\"application/x-www-form-urlencoded\") >= 0) {\n            xhr.send(qq.obj2url(params, \"\"));\n        }\n        else if (params && options.contentType && options.contentType.toLowerCase().indexOf(\"application/json\") >= 0) {\n            xhr.send(JSON.stringify(params));\n        }\n        else {\n            xhr.send(params);\n        }\n\n        return xhr;\n    }\n\n    function createUrl(id, params, additionalQueryParams) {\n        var endpoint = options.endpointStore.get(id),\n            addToPath = requestData[id].addToPath;\n\n        /*jshint -W116,-W041 */\n        if (addToPath != undefined) {\n            endpoint += \"/\" + addToPath;\n        }\n\n        if (shouldParamsBeInQueryString && params) {\n            endpoint = qq.obj2url(params, endpoint);\n        }\n\n        if (additionalQueryParams) {\n            endpoint = qq.obj2url(additionalQueryParams, endpoint);\n        }\n\n        return endpoint;\n    }\n\n    // Invoked by the UA to indicate a number of possible states that describe\n    // a live `XMLHttpRequest` transport.\n    function getXhrReadyStateChangeHandler(id) {\n        return function() {\n            if (getXhrOrXdr(id).readyState === 4) {\n                onComplete(id);\n            }\n        };\n    }\n\n    function registerForUploadProgress(id) {\n        var onProgress = options.onProgress;\n\n        if (onProgress) {\n            getXhrOrXdr(id).upload.onprogress = function(e) {\n                if (e.lengthComputable) {\n                    onProgress(id, e.loaded, e.total);\n                }\n            };\n        }\n    }\n\n    // This will be called by IE to indicate **success** for an associated\n    // `XDomainRequest` transported request.\n    function getXdrLoadHandler(id) {\n        return function() {\n            onComplete(id);\n        };\n    }\n\n    // This will be called by IE to indicate **failure** for an associated\n    // `XDomainRequest` transported request.\n    function getXdrErrorHandler(id) {\n        return function() {\n            onComplete(id, true);\n        };\n    }\n\n    function setHeaders(id) {\n        var xhr = getXhrOrXdr(id),\n            customHeaders = options.customHeaders,\n            onDemandHeaders = requestData[id].additionalHeaders || {},\n            method = options.method,\n            allHeaders = {};\n\n        // If XDomainRequest is being used, we can't set headers, so just ignore this block.\n        if (!isXdr(xhr)) {\n            options.acceptHeader && xhr.setRequestHeader(\"Accept\", options.acceptHeader);\n\n            // Only attempt to add X-Requested-With & Cache-Control if permitted\n            if (options.allowXRequestedWithAndCacheControl) {\n                // Do not add X-Requested-With & Cache-Control if this is a cross-origin request\n                // OR the cross-origin request contains a non-simple method or header.\n                // This is done to ensure a preflight is not triggered exclusively based on the\n                // addition of these 2 non-simple headers.\n                if (!options.cors.expected || (!isSimpleMethod() || containsNonSimpleHeaders(customHeaders))) {\n                    xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n                    xhr.setRequestHeader(\"Cache-Control\", \"no-cache\");\n                }\n            }\n\n            if (options.contentType && (method === \"POST\" || method === \"PUT\")) {\n                xhr.setRequestHeader(\"Content-Type\", options.contentType);\n            }\n\n            qq.extend(allHeaders, qq.isFunction(customHeaders) ? customHeaders(id) : customHeaders);\n            qq.extend(allHeaders, onDemandHeaders);\n\n            qq.each(allHeaders, function(name, val) {\n                xhr.setRequestHeader(name, val);\n            });\n        }\n    }\n\n    function isResponseSuccessful(responseCode) {\n        return qq.indexOf(options.successfulResponseCodes[options.method], responseCode) >= 0;\n    }\n\n    function prepareToSend(id, optXhr, addToPath, additionalParams, additionalQueryParams, additionalHeaders, payload) {\n        requestData[id] = {\n            addToPath: addToPath,\n            additionalParams: additionalParams,\n            additionalQueryParams: additionalQueryParams,\n            additionalHeaders: additionalHeaders,\n            payload: payload\n        };\n\n        var len = queue.push(id);\n\n        // if too many active connections, wait...\n        if (len <= options.maxConnections) {\n            return sendRequest(id, optXhr);\n        }\n    }\n\n    shouldParamsBeInQueryString = options.method === \"GET\" || options.method === \"DELETE\";\n\n    qq.extend(this, {\n        // Start the process of sending the request.  The ID refers to the file associated with the request.\n        initTransport: function(id) {\n            var path, params, headers, payload, cacheBuster, additionalQueryParams;\n\n            return {\n                // Optionally specify the end of the endpoint path for the request.\n                withPath: function(appendToPath) {\n                    path = appendToPath;\n                    return this;\n                },\n\n                // Optionally specify additional parameters to send along with the request.\n                // These will be added to the query string for GET/DELETE requests or the payload\n                // for POST/PUT requests.  The Content-Type of the request will be used to determine\n                // how these parameters should be formatted as well.\n                withParams: function(additionalParams) {\n                    params = additionalParams;\n                    return this;\n                },\n\n                withQueryParams: function(_additionalQueryParams_) {\n                    additionalQueryParams = _additionalQueryParams_;\n                    return this;\n                },\n\n                // Optionally specify additional headers to send along with the request.\n                withHeaders: function(additionalHeaders) {\n                    headers = additionalHeaders;\n                    return this;\n                },\n\n                // Optionally specify a payload/body for the request.\n                withPayload: function(thePayload) {\n                    payload = thePayload;\n                    return this;\n                },\n\n                // Appends a cache buster (timestamp) to the request URL as a query parameter (only if GET or DELETE)\n                withCacheBuster: function() {\n                    cacheBuster = true;\n                    return this;\n                },\n\n                // Send the constructed request.\n                send: function(optXhr) {\n                    if (cacheBuster && qq.indexOf([\"GET\", \"DELETE\"], options.method) >= 0) {\n                        params.qqtimestamp = new Date().getTime();\n                    }\n\n                    return prepareToSend(id, optXhr, path, params, additionalQueryParams, headers, payload);\n                }\n            };\n        },\n\n        canceled: function(id) {\n            dequeue(id);\n        }\n    });\n};\n","/* globals qq */\n/**\n * Common upload handler functions.\n *\n * @constructor\n */\nqq.UploadHandler = function(spec) {\n    \"use strict\";\n\n    var proxy = spec.proxy,\n        fileState = {},\n        onCancel = proxy.onCancel,\n        getName = proxy.getName;\n\n    qq.extend(this, {\n        add: function(id, fileItem) {\n            fileState[id] = fileItem;\n            fileState[id].temp = {};\n        },\n\n        cancel: function(id) {\n            var self = this,\n                cancelFinalizationEffort = new qq.Promise(),\n                onCancelRetVal = onCancel(id, getName(id), cancelFinalizationEffort);\n\n            onCancelRetVal.then(function() {\n                if (self.isValid(id)) {\n                    fileState[id].canceled = true;\n                    self.expunge(id);\n                }\n                cancelFinalizationEffort.success();\n            });\n        },\n\n        expunge: function(id) {\n            delete fileState[id];\n        },\n\n        getThirdPartyFileId: function(id) {\n            return fileState[id].key;\n        },\n\n        isValid: function(id) {\n            return fileState[id] !== undefined;\n        },\n\n        reset: function() {\n            fileState = {};\n        },\n\n        _getFileState: function(id) {\n            return fileState[id];\n        },\n\n        _setThirdPartyFileId: function(id, thirdPartyFileId) {\n            fileState[id].key = thirdPartyFileId;\n        },\n\n        _wasCanceled: function(id) {\n            return !!fileState[id].canceled;\n        }\n    });\n};\n","/*globals qq*/\n/**\n * Base upload handler module.  Controls more specific handlers.\n *\n * @param o Options.  Passed along to the specific handler submodule as well.\n * @param namespace [optional] Namespace for the specific handler.\n */\nqq.UploadHandlerController = function(o, namespace) {\n    \"use strict\";\n\n    var controller = this,\n        chunkingPossible = false,\n        concurrentChunkingPossible = false,\n        chunking, preventRetryResponse, log, handler,\n\n    options = {\n        paramsStore: {},\n        maxConnections: 3, // maximum number of concurrent uploads\n        chunking: {\n            enabled: false,\n            multiple: {\n                enabled: false\n            }\n        },\n        log: function(str, level) {},\n        onProgress: function(id, fileName, loaded, total) {},\n        onComplete: function(id, fileName, response, xhr) {},\n        onCancel: function(id, fileName) {},\n        onUploadPrep: function(id) {}, // Called if non-trivial operations will be performed before onUpload\n        onUpload: function(id, fileName) {},\n        onUploadChunk: function(id, fileName, chunkData) {},\n        onUploadChunkSuccess: function(id, chunkData, response, xhr) {},\n        onAutoRetry: function(id, fileName, response, xhr) {},\n        onResume: function(id, fileName, chunkData) {},\n        onUuidChanged: function(id, newUuid) {},\n        getName: function(id) {},\n        setSize: function(id, newSize) {},\n        isQueued: function(id) {},\n        getIdsInProxyGroup: function(id) {},\n        getIdsInBatch: function(id) {}\n    },\n\n    chunked = {\n        // Called when each chunk has uploaded successfully\n        done: function(id, chunkIdx, response, xhr) {\n            var chunkData = handler._getChunkData(id, chunkIdx);\n\n            handler._getFileState(id).attemptingResume = false;\n\n            delete handler._getFileState(id).temp.chunkProgress[chunkIdx];\n            handler._getFileState(id).loaded += chunkData.size;\n\n            options.onUploadChunkSuccess(id, handler._getChunkDataForCallback(chunkData), response, xhr);\n        },\n\n        // Called when all chunks have been successfully uploaded and we want to ask the handler to perform any\n        // logic associated with closing out the file, such as combining the chunks.\n        finalize: function(id) {\n            var size = options.getSize(id),\n                name = options.getName(id);\n\n            log(\"All chunks have been uploaded for \" + id + \" - finalizing....\");\n            handler.finalizeChunks(id).then(\n                function(response, xhr) {\n                    log(\"Finalize successful for \" + id);\n\n                    var normaizedResponse = upload.normalizeResponse(response, true);\n\n                    options.onProgress(id, name, size, size);\n                    handler._maybeDeletePersistedChunkData(id);\n                    upload.cleanup(id, normaizedResponse, xhr);\n                },\n                function(response, xhr) {\n                    var normaizedResponse = upload.normalizeResponse(response, false);\n\n                    log(\"Problem finalizing chunks for file ID \" + id + \" - \" + normaizedResponse.error, \"error\");\n\n                    if (normaizedResponse.reset) {\n                        chunked.reset(id);\n                    }\n\n                    if (!options.onAutoRetry(id, name, normaizedResponse, xhr)) {\n                        upload.cleanup(id, normaizedResponse, xhr);\n                    }\n                }\n            );\n        },\n\n        handleFailure: function(chunkIdx, id, response, xhr) {\n            var name = options.getName(id);\n\n            log(\"Chunked upload request failed for \" + id + \", chunk \" + chunkIdx);\n\n            handler.clearCachedChunk(id, chunkIdx);\n\n            var responseToReport = upload.normalizeResponse(response, false),\n                inProgressIdx;\n\n            if (responseToReport.reset) {\n                chunked.reset(id);\n            }\n            else {\n                inProgressIdx = qq.indexOf(handler._getFileState(id).chunking.inProgress, chunkIdx);\n                if (inProgressIdx >= 0) {\n                    handler._getFileState(id).chunking.inProgress.splice(inProgressIdx, 1);\n                    handler._getFileState(id).chunking.remaining.unshift(chunkIdx);\n                }\n            }\n\n            // We may have aborted all other in-progress chunks for this file due to a failure.\n            // If so, ignore the failures associated with those aborts.\n            if (!handler._getFileState(id).temp.ignoreFailure) {\n                // If this chunk has failed, we want to ignore all other failures of currently in-progress\n                // chunks since they will be explicitly aborted\n                if (concurrentChunkingPossible) {\n                    handler._getFileState(id).temp.ignoreFailure = true;\n\n                    log(qq.format(\"Going to attempt to abort these chunks: {}. These are currently in-progress: {}.\", JSON.stringify(Object.keys(handler._getXhrs(id))), JSON.stringify(handler._getFileState(id).chunking.inProgress)));\n                    qq.each(handler._getXhrs(id), function(ckid, ckXhr) {\n                        log(qq.format(\"Attempting to abort file {}.{}. XHR readyState {}. \", id, ckid, ckXhr.readyState));\n                        ckXhr.abort();\n                        // Flag the transport, in case we are waiting for some other async operation\n                        // to complete before attempting to upload the chunk\n                        ckXhr._cancelled = true;\n                    });\n\n                    // We must indicate that all aborted chunks are no longer in progress\n                    handler.moveInProgressToRemaining(id);\n\n                    // Free up any connections used by these chunks, but don't allow any\n                    // other files to take up the connections (until we have exhausted all auto-retries)\n                    connectionManager.free(id, true);\n                }\n\n                if (!options.onAutoRetry(id, name, responseToReport, xhr)) {\n                    // If one chunk fails, abort all of the others to avoid odd race conditions that occur\n                    // if a chunk succeeds immediately after one fails before we have determined if the upload\n                    // is a failure or not.\n                    upload.cleanup(id, responseToReport, xhr);\n                }\n            }\n        },\n\n        hasMoreParts: function(id) {\n            return !!handler._getFileState(id).chunking.remaining.length;\n        },\n\n        nextPart: function(id) {\n            var nextIdx = handler._getFileState(id).chunking.remaining.shift();\n\n            if (nextIdx >= handler._getTotalChunks(id)) {\n                nextIdx = null;\n            }\n\n            return nextIdx;\n        },\n\n        reset: function(id) {\n            log(\"Server or callback has ordered chunking effort to be restarted on next attempt for item ID \" + id, \"error\");\n\n            handler._maybeDeletePersistedChunkData(id);\n            handler.reevaluateChunking(id);\n            handler._getFileState(id).loaded = 0;\n        },\n\n        sendNext: function(id) {\n            var size = options.getSize(id),\n                name = options.getName(id),\n                chunkIdx = chunked.nextPart(id),\n                chunkData = handler._getChunkData(id, chunkIdx),\n                resuming = handler._getFileState(id).attemptingResume,\n                inProgressChunks = handler._getFileState(id).chunking.inProgress || [];\n\n            if (handler._getFileState(id).loaded == null) {\n                handler._getFileState(id).loaded = 0;\n            }\n\n            // Don't follow-through with the resume attempt if the integrator returns false from onResume\n            if (resuming && options.onResume(id, name, chunkData) === false) {\n                chunked.reset(id);\n                chunkIdx = chunked.nextPart(id);\n                chunkData = handler._getChunkData(id, chunkIdx);\n                resuming = false;\n            }\n\n            // If all chunks have already uploaded successfully, we must be re-attempting the finalize step.\n            if (chunkIdx == null && inProgressChunks.length === 0) {\n                chunked.finalize(id);\n            }\n\n            // Send the next chunk\n            else {\n                log(qq.format(\"Sending chunked upload request for item {}.{}, bytes {}-{} of {}.\", id, chunkIdx, chunkData.start + 1, chunkData.end, size));\n                options.onUploadChunk(id, name, handler._getChunkDataForCallback(chunkData));\n                inProgressChunks.push(chunkIdx);\n                handler._getFileState(id).chunking.inProgress = inProgressChunks;\n\n                if (concurrentChunkingPossible) {\n                    connectionManager.open(id, chunkIdx);\n                }\n\n                if (concurrentChunkingPossible && connectionManager.available() && handler._getFileState(id).chunking.remaining.length) {\n                    chunked.sendNext(id);\n                }\n\n                if (chunkData.blob.size === 0) {\n                    log(qq.format(\"Chunk {} for file {} will not be uploaded, zero sized chunk.\", chunkIdx, id), \"error\");\n                    chunked.handleFailure(chunkIdx, id, \"File is no longer available\", null);\n                }\n                else {\n                    handler.uploadChunk(id, chunkIdx, resuming).then(\n                        // upload chunk success\n                        function success(response, xhr) {\n                            log(\"Chunked upload request succeeded for \" + id + \", chunk \" + chunkIdx);\n\n                            handler.clearCachedChunk(id, chunkIdx);\n\n                            var inProgressChunks = handler._getFileState(id).chunking.inProgress || [],\n                                responseToReport = upload.normalizeResponse(response, true),\n                                inProgressChunkIdx = qq.indexOf(inProgressChunks, chunkIdx);\n\n                            log(qq.format(\"Chunk {} for file {} uploaded successfully.\", chunkIdx, id));\n\n                            chunked.done(id, chunkIdx, responseToReport, xhr);\n\n                            if (inProgressChunkIdx >= 0) {\n                                inProgressChunks.splice(inProgressChunkIdx, 1);\n                            }\n\n                            handler._maybePersistChunkedState(id);\n\n                            if (!chunked.hasMoreParts(id) && inProgressChunks.length === 0) {\n                                chunked.finalize(id);\n                            }\n                            else if (chunked.hasMoreParts(id)) {\n                                chunked.sendNext(id);\n                            }\n                            else {\n                                log(qq.format(\"File ID {} has no more chunks to send and these chunk indexes are still marked as in-progress: {}\", id, JSON.stringify(inProgressChunks)));\n                            }\n                        },\n\n                        // upload chunk failure\n                        function failure(response, xhr) {\n                            chunked.handleFailure(chunkIdx, id, response, xhr);\n                        }\n                        )\n                        .done(function() {\n                            handler.clearXhr(id, chunkIdx);\n                        });\n                }\n            }\n        }\n    },\n\n    connectionManager = {\n        _open: [],\n        _openChunks: {},\n        _waiting: [],\n\n        available: function() {\n            var max = options.maxConnections,\n                openChunkEntriesCount = 0,\n                openChunksCount = 0;\n\n            qq.each(connectionManager._openChunks, function(fileId, openChunkIndexes) {\n                openChunkEntriesCount++;\n                openChunksCount += openChunkIndexes.length;\n            });\n\n            return max - (connectionManager._open.length - openChunkEntriesCount + openChunksCount);\n        },\n\n        /**\n         * Removes element from queue, starts upload of next\n         */\n        free: function(id, dontAllowNext) {\n            var allowNext = !dontAllowNext,\n                waitingIndex = qq.indexOf(connectionManager._waiting, id),\n                connectionsIndex = qq.indexOf(connectionManager._open, id),\n                nextId;\n\n            delete connectionManager._openChunks[id];\n\n            if (upload.getProxyOrBlob(id) instanceof qq.BlobProxy) {\n                log(\"Generated blob upload has ended for \" + id + \", disposing generated blob.\");\n                delete handler._getFileState(id).file;\n            }\n\n            // If this file was not consuming a connection, it was just waiting, so remove it from the waiting array\n            if (waitingIndex >= 0) {\n                connectionManager._waiting.splice(waitingIndex, 1);\n            }\n            // If this file was consuming a connection, allow the next file to be uploaded\n            else if (allowNext && connectionsIndex >= 0) {\n                connectionManager._open.splice(connectionsIndex, 1);\n\n                nextId = connectionManager._waiting.shift();\n                if (nextId >= 0) {\n                    connectionManager._open.push(nextId);\n                    upload.start(nextId);\n                }\n            }\n        },\n\n        getWaitingOrConnected: function() {\n            var waitingOrConnected = [];\n\n            // Chunked files may have multiple connections open per chunk (if concurrent chunking is enabled)\n            // We need to grab the file ID of any file that has at least one chunk consuming a connection.\n            qq.each(connectionManager._openChunks, function(fileId, chunks) {\n                if (chunks && chunks.length) {\n                    waitingOrConnected.push(parseInt(fileId));\n                }\n            });\n\n            // For non-chunked files, only one connection will be consumed per file.\n            // This is where we aggregate those file IDs.\n            qq.each(connectionManager._open, function(idx, fileId) {\n                if (!connectionManager._openChunks[fileId]) {\n                    waitingOrConnected.push(parseInt(fileId));\n                }\n            });\n\n            // There may be files waiting for a connection.\n            waitingOrConnected = waitingOrConnected.concat(connectionManager._waiting);\n\n            return waitingOrConnected;\n        },\n\n        isUsingConnection: function(id) {\n            return qq.indexOf(connectionManager._open, id) >= 0;\n        },\n\n        open: function(id, chunkIdx) {\n            if (chunkIdx == null) {\n                connectionManager._waiting.push(id);\n            }\n\n            if (connectionManager.available()) {\n                if (chunkIdx == null) {\n                    connectionManager._waiting.pop();\n                    connectionManager._open.push(id);\n                }\n                else {\n                    (function() {\n                        var openChunksEntry = connectionManager._openChunks[id] || [];\n                        openChunksEntry.push(chunkIdx);\n                        connectionManager._openChunks[id] = openChunksEntry;\n                    }());\n                }\n\n                return true;\n            }\n\n            return false;\n        },\n\n        reset: function() {\n            connectionManager._waiting = [];\n            connectionManager._open = [];\n        }\n    },\n\n    simple = {\n        send: function(id, name) {\n            handler._getFileState(id).loaded = 0;\n\n            log(\"Sending simple upload request for \" + id);\n            handler.uploadFile(id).then(\n                function(response, optXhr) {\n                    log(\"Simple upload request succeeded for \" + id);\n\n                    var responseToReport = upload.normalizeResponse(response, true),\n                        size = options.getSize(id);\n\n                    options.onProgress(id, name, size, size);\n                    upload.maybeNewUuid(id, responseToReport);\n                    upload.cleanup(id, responseToReport, optXhr);\n                },\n\n                function(response, optXhr) {\n                    log(\"Simple upload request failed for \" + id);\n\n                    var responseToReport = upload.normalizeResponse(response, false);\n\n                    if (!options.onAutoRetry(id, name, responseToReport, optXhr)) {\n                        upload.cleanup(id, responseToReport, optXhr);\n                    }\n                }\n            );\n        }\n    },\n\n    upload = {\n        cancel: function(id) {\n            log(\"Cancelling \" + id);\n            options.paramsStore.remove(id);\n            connectionManager.free(id);\n        },\n\n        cleanup: function(id, response, optXhr) {\n            var name = options.getName(id);\n\n            options.onComplete(id, name, response, optXhr);\n\n            if (handler._getFileState(id)) {\n                handler._clearXhrs && handler._clearXhrs(id);\n            }\n\n            connectionManager.free(id);\n        },\n\n        // Returns a qq.BlobProxy, or an actual File/Blob if no proxy is involved, or undefined\n        // if none of these are available for the ID\n        getProxyOrBlob: function(id) {\n            return (handler.getProxy && handler.getProxy(id)) ||\n                (handler.getFile && handler.getFile(id));\n        },\n\n        initHandler: function() {\n            var handlerType = namespace ? qq[namespace] : qq.traditional,\n                handlerModuleSubtype = qq.supportedFeatures.ajaxUploading ? \"Xhr\" : \"Form\";\n\n            handler = new handlerType[handlerModuleSubtype + \"UploadHandler\"](\n                options,\n                {\n                    getDataByUuid: options.getDataByUuid,\n                    getName: options.getName,\n                    getSize: options.getSize,\n                    getUuid: options.getUuid,\n                    log: log,\n                    onCancel: options.onCancel,\n                    onProgress: options.onProgress,\n                    onUuidChanged: options.onUuidChanged\n                }\n            );\n\n            if (handler._removeExpiredChunkingRecords) {\n                handler._removeExpiredChunkingRecords();\n            }\n        },\n\n        isDeferredEligibleForUpload: function(id) {\n            return options.isQueued(id);\n        },\n\n        // For Blobs that are part of a group of generated images, along with a reference image,\n        // this will ensure the blobs in the group are uploaded in the order they were triggered,\n        // even if some async processing must be completed on one or more Blobs first.\n        maybeDefer: function(id, blob) {\n            // If we don't have a file/blob yet & no file/blob exists for this item, request it,\n            // and then submit the upload to the specific handler once the blob is available.\n            // ASSUMPTION: This condition will only ever be true if XHR uploading is supported.\n            if (blob && !handler.getFile(id) && blob instanceof qq.BlobProxy) {\n\n                // Blob creation may take some time, so the caller may want to update the\n                // UI to indicate that an operation is in progress, even before the actual\n                // upload begins and an onUpload callback is invoked.\n                options.onUploadPrep(id);\n\n                log(\"Attempting to generate a blob on-demand for \" + id);\n                blob.create().then(function(generatedBlob) {\n                    log(\"Generated an on-demand blob for \" + id);\n\n                    // Update record associated with this file by providing the generated Blob\n                    handler.updateBlob(id, generatedBlob);\n\n                    // Propagate the size for this generated Blob\n                    options.setSize(id, generatedBlob.size);\n\n                    // Order handler to recalculate chunking possibility, if applicable\n                    handler.reevaluateChunking(id);\n\n                    upload.maybeSendDeferredFiles(id);\n                },\n\n                // Blob could not be generated.  Fail the upload & attempt to prevent retries.  Also bubble error message.\n                function(errorMessage) {\n                    var errorResponse = {};\n\n                    if (errorMessage) {\n                        errorResponse.error = errorMessage;\n                    }\n\n                    log(qq.format(\"Failed to generate blob for ID {}.  Error message: {}.\", id, errorMessage), \"error\");\n\n                    options.onComplete(id, options.getName(id), qq.extend(errorResponse, preventRetryResponse), null);\n                    upload.maybeSendDeferredFiles(id);\n                    connectionManager.free(id);\n                });\n            }\n            else {\n                return upload.maybeSendDeferredFiles(id);\n            }\n\n            return false;\n        },\n\n        // Upload any grouped blobs, in the proper order, that are ready to be uploaded\n        maybeSendDeferredFiles: function(id) {\n            var idsInGroup = options.getIdsInProxyGroup(id),\n                uploadedThisId = false;\n\n            if (idsInGroup && idsInGroup.length) {\n                log(\"Maybe ready to upload proxy group file \" + id);\n\n                qq.each(idsInGroup, function(idx, idInGroup) {\n                    if (upload.isDeferredEligibleForUpload(idInGroup) && !!handler.getFile(idInGroup)) {\n                        uploadedThisId = idInGroup === id;\n                        upload.now(idInGroup);\n                    }\n                    else if (upload.isDeferredEligibleForUpload(idInGroup)) {\n                        return false;\n                    }\n                });\n            }\n            else {\n                uploadedThisId = true;\n                upload.now(id);\n            }\n\n            return uploadedThisId;\n        },\n\n        maybeNewUuid: function(id, response) {\n            if (response.newUuid !== undefined) {\n                options.onUuidChanged(id, response.newUuid);\n            }\n        },\n\n        // The response coming from handler implementations may be in various formats.\n        // Instead of hoping a promise nested 5 levels deep will always return an object\n        // as its first param, let's just normalize the response here.\n        normalizeResponse: function(originalResponse, successful) {\n            var response = originalResponse;\n\n            // The passed \"response\" param may not be a response at all.\n            // It could be a string, detailing the error, for example.\n            if (!qq.isObject(originalResponse)) {\n                response = {};\n\n                if (qq.isString(originalResponse) && !successful) {\n                    response.error = originalResponse;\n                }\n            }\n\n            response.success = successful;\n\n            return response;\n        },\n\n        now: function(id) {\n            var name = options.getName(id);\n\n            if (!controller.isValid(id)) {\n                throw new qq.Error(id + \" is not a valid file ID to upload!\");\n            }\n\n            options.onUpload(id, name);\n\n            if (chunkingPossible && handler._shouldChunkThisFile(id)) {\n                chunked.sendNext(id);\n            }\n            else {\n                simple.send(id, name);\n            }\n        },\n\n        start: function(id) {\n            var blobToUpload = upload.getProxyOrBlob(id);\n\n            if (blobToUpload) {\n                return upload.maybeDefer(id, blobToUpload);\n            }\n            else {\n                upload.now(id);\n                return true;\n            }\n        }\n    };\n\n    qq.extend(this, {\n        /**\n         * Adds file or file input to the queue\n         **/\n        add: function(id, file) {\n            handler.add.apply(this, arguments);\n        },\n\n        /**\n         * Sends the file identified by id\n         */\n        upload: function(id) {\n            if (connectionManager.open(id)) {\n                return upload.start(id);\n            }\n            return false;\n        },\n\n        retry: function(id) {\n            // On retry, if concurrent chunking has been enabled, we may have aborted all other in-progress chunks\n            // for a file when encountering a failed chunk upload.  We then signaled the controller to ignore\n            // all failures associated with these aborts.  We are now retrying, so we don't want to ignore\n            // any more failures at this point.\n            if (concurrentChunkingPossible) {\n                handler._getFileState(id).temp.ignoreFailure = false;\n            }\n\n            // If we are attempting to retry a file that is already consuming a connection, this is likely an auto-retry.\n            // Just go ahead and ask the handler to upload again.\n            if (connectionManager.isUsingConnection(id)) {\n                return upload.start(id);\n            }\n\n            // If we are attempting to retry a file that is not currently consuming a connection,\n            // this is likely a manual retry attempt.  We will need to ensure a connection is available\n            // before the retry commences.\n            else {\n                return controller.upload(id);\n            }\n        },\n\n        /**\n         * Cancels file upload by id\n         */\n        cancel: function(id) {\n            var cancelRetVal = handler.cancel(id);\n\n            if (qq.isGenericPromise(cancelRetVal)) {\n                cancelRetVal.then(function() {\n                    upload.cancel(id);\n                });\n            }\n            else if (cancelRetVal !== false) {\n                upload.cancel(id);\n            }\n        },\n\n        /**\n         * Cancels all queued or in-progress uploads\n         */\n        cancelAll: function() {\n            var waitingOrConnected = connectionManager.getWaitingOrConnected(),\n                i;\n\n            // ensure files are cancelled in reverse order which they were added\n            // to avoid a flash of time where a queued file begins to upload before it is canceled\n            if (waitingOrConnected.length) {\n                for (i = waitingOrConnected.length - 1; i >= 0; i--) {\n                    controller.cancel(waitingOrConnected[i]);\n                }\n            }\n\n            connectionManager.reset();\n        },\n\n        // Returns a File, Blob, or the Blob/File for the reference/parent file if the targeted blob is a proxy.\n        // Undefined if no file record is available.\n        getFile: function(id) {\n            if (handler.getProxy && handler.getProxy(id)) {\n                return handler.getProxy(id).referenceBlob;\n            }\n\n            return handler.getFile && handler.getFile(id);\n        },\n\n        // Returns true if the Blob associated with the ID is related to a proxy s\n        isProxied: function(id) {\n            return !!(handler.getProxy && handler.getProxy(id));\n        },\n\n        getInput: function(id) {\n            if (handler.getInput) {\n                return handler.getInput(id);\n            }\n        },\n\n        reset: function() {\n            log(\"Resetting upload handler\");\n            controller.cancelAll();\n            connectionManager.reset();\n            handler.reset();\n        },\n\n        expunge: function(id) {\n            if (controller.isValid(id)) {\n                return handler.expunge(id);\n            }\n        },\n\n        /**\n         * Determine if the file exists.\n         */\n        isValid: function(id) {\n            return handler.isValid(id);\n        },\n\n        getResumableFilesData: function() {\n            if (handler.getResumableFilesData) {\n                return handler.getResumableFilesData();\n            }\n            return [];\n        },\n\n        /**\n         * This may or may not be implemented, depending on the handler.  For handlers where a third-party ID is\n         * available (such as the \"key\" for Amazon S3), this will return that value.  Otherwise, the return value\n         * will be undefined.\n         *\n         * @param id Internal file ID\n         * @returns {*} Some identifier used by a 3rd-party service involved in the upload process\n         */\n        getThirdPartyFileId: function(id) {\n            if (controller.isValid(id)) {\n                return handler.getThirdPartyFileId(id);\n            }\n        },\n\n        /**\n         * Attempts to pause the associated upload if the specific handler supports this and the file is \"valid\".\n         * @param id ID of the upload/file to pause\n         * @returns {boolean} true if the upload was paused\n         */\n        pause: function(id) {\n            if (controller.isResumable(id) && handler.pause && controller.isValid(id) && handler.pause(id)) {\n                connectionManager.free(id);\n                handler.moveInProgressToRemaining(id);\n                return true;\n            }\n            return false;\n        },\n\n        // True if the file is eligible for pause/resume.\n        isResumable: function(id) {\n            return !!handler.isResumable && handler.isResumable(id);\n        }\n    });\n\n    qq.extend(options, o);\n    log = options.log;\n    chunkingPossible = options.chunking.enabled && qq.supportedFeatures.chunking;\n    concurrentChunkingPossible = chunkingPossible && options.chunking.concurrent.enabled;\n\n    preventRetryResponse = (function() {\n        var response = {};\n\n        response[options.preventRetryParam] = true;\n\n        return response;\n    }());\n\n    upload.initHandler();\n};\n","/*globals qq */\n/*jshint -W117 */\nqq.WindowReceiveMessage = function(o) {\n    \"use strict\";\n\n    var options = {\n            log: function(message, level) {}\n        },\n        callbackWrapperDetachers = {};\n\n    qq.extend(options, o);\n\n    qq.extend(this, {\n        receiveMessage: function(id, callback) {\n            var onMessageCallbackWrapper = function(event) {\n                    callback(event.data);\n                };\n\n            if (window.postMessage) {\n                callbackWrapperDetachers[id] = qq(window).attach(\"message\", onMessageCallbackWrapper);\n            }\n            else {\n                log(\"iframe message passing not supported in this browser!\", \"error\");\n            }\n        },\n\n        stopReceivingMessages: function(id) {\n            if (window.postMessage) {\n                var detacher = callbackWrapperDetachers[id];\n                if (detacher) {\n                    detacher();\n                }\n            }\n        }\n    });\n};\n","/* globals qq */\n/**\n * Common APIs exposed to creators of upload via form/iframe handlers.  This is reused and possibly overridden\n * in some cases by specific form upload handlers.\n *\n * @constructor\n */\nqq.FormUploadHandler = function(spec) {\n    \"use strict\";\n\n    var options = spec.options,\n        handler = this,\n        proxy = spec.proxy,\n        formHandlerInstanceId = qq.getUniqueId(),\n        onloadCallbacks = {},\n        detachLoadEvents = {},\n        postMessageCallbackTimers = {},\n        isCors = options.isCors,\n        inputName = options.inputName,\n        getUuid = proxy.getUuid,\n        log = proxy.log,\n        corsMessageReceiver = new qq.WindowReceiveMessage({log: log});\n\n    /**\n     * Remove any trace of the file from the handler.\n     *\n     * @param id ID of the associated file\n     */\n    function expungeFile(id) {\n        delete detachLoadEvents[id];\n\n        // If we are dealing with CORS, we might still be waiting for a response from a loaded iframe.\n        // In that case, terminate the timer waiting for a message from the loaded iframe\n        // and stop listening for any more messages coming from this iframe.\n        if (isCors) {\n            clearTimeout(postMessageCallbackTimers[id]);\n            delete postMessageCallbackTimers[id];\n            corsMessageReceiver.stopReceivingMessages(id);\n        }\n\n        var iframe = document.getElementById(handler._getIframeName(id));\n        if (iframe) {\n            // To cancel request set src to something else.  We use src=\"javascript:false;\"\n            // because it doesn't trigger ie6 prompt on https\n            /* jshint scripturl:true */\n            iframe.setAttribute(\"src\", \"javascript:false;\");\n\n            qq(iframe).remove();\n        }\n    }\n\n    /**\n     * @param iframeName `document`-unique Name of the associated iframe\n     * @returns {*} ID of the associated file\n     */\n    function getFileIdForIframeName(iframeName) {\n        return iframeName.split(\"_\")[0];\n    }\n\n    /**\n     * Generates an iframe to be used as a target for upload-related form submits.  This also adds the iframe\n     * to the current `document`.  Note that the iframe is hidden from view.\n     *\n     * @param name Name of the iframe.\n     * @returns {HTMLIFrameElement} The created iframe\n     */\n    function initIframeForUpload(name) {\n        var iframe = qq.toElement(\"<iframe src='javascript:false;' name='\" + name + \"' />\");\n\n        iframe.setAttribute(\"id\", name);\n\n        iframe.style.display = \"none\";\n        document.body.appendChild(iframe);\n\n        return iframe;\n    }\n\n    /**\n     * If we are in CORS mode, we must listen for messages (containing the server response) from the associated\n     * iframe, since we cannot directly parse the content of the iframe due to cross-origin restrictions.\n     *\n     * @param iframe Listen for messages on this iframe.\n     * @param callback Invoke this callback with the message from the iframe.\n     */\n    function registerPostMessageCallback(iframe, callback) {\n        var iframeName = iframe.id,\n            fileId = getFileIdForIframeName(iframeName),\n            uuid = getUuid(fileId);\n\n        onloadCallbacks[uuid] = callback;\n\n        // When the iframe has loaded (after the server responds to an upload request)\n        // declare the attempt a failure if we don't receive a valid message shortly after the response comes in.\n        detachLoadEvents[fileId] = qq(iframe).attach(\"load\", function() {\n            if (handler.getInput(fileId)) {\n                log(\"Received iframe load event for CORS upload request (iframe name \" + iframeName + \")\");\n\n                postMessageCallbackTimers[iframeName] = setTimeout(function() {\n                    var errorMessage = \"No valid message received from loaded iframe for iframe name \" + iframeName;\n                    log(errorMessage, \"error\");\n                    callback({\n                        error: errorMessage\n                    });\n                }, 1000);\n            }\n        });\n\n        // Listen for messages coming from this iframe.  When a message has been received, cancel the timer\n        // that declares the upload a failure if a message is not received within a reasonable amount of time.\n        corsMessageReceiver.receiveMessage(iframeName, function(message) {\n            log(\"Received the following window message: '\" + message + \"'\");\n            var fileId = getFileIdForIframeName(iframeName),\n                response = handler._parseJsonResponse(message),\n                uuid = response.uuid,\n                onloadCallback;\n\n            if (uuid && onloadCallbacks[uuid]) {\n                log(\"Handling response for iframe name \" + iframeName);\n                clearTimeout(postMessageCallbackTimers[iframeName]);\n                delete postMessageCallbackTimers[iframeName];\n\n                handler._detachLoadEvent(iframeName);\n\n                onloadCallback = onloadCallbacks[uuid];\n\n                delete onloadCallbacks[uuid];\n                corsMessageReceiver.stopReceivingMessages(iframeName);\n                onloadCallback(response);\n            }\n            else if (!uuid) {\n                log(\"'\" + message + \"' does not contain a UUID - ignoring.\");\n            }\n        });\n    }\n\n    qq.extend(this, new qq.UploadHandler(spec));\n\n    qq.override(this, function(super_) {\n        return {\n            /**\n             * Adds File or Blob to the queue\n             **/\n            add: function(id, fileInput) {\n                super_.add(id, {input: fileInput});\n\n                fileInput.setAttribute(\"name\", inputName);\n\n                // remove file input from DOM\n                if (fileInput.parentNode) {\n                    qq(fileInput).remove();\n                }\n            },\n\n            expunge: function(id) {\n                expungeFile(id);\n                super_.expunge(id);\n            },\n\n            isValid: function(id) {\n                return super_.isValid(id) &&\n                    handler._getFileState(id).input !== undefined;\n            }\n        };\n    });\n\n    qq.extend(this, {\n        getInput: function(id) {\n            return handler._getFileState(id).input;\n        },\n\n        /**\n         * This function either delegates to a more specific message handler if CORS is involved,\n         * or simply registers a callback when the iframe has been loaded that invokes the passed callback\n         * after determining if the content of the iframe is accessible.\n         *\n         * @param iframe Associated iframe\n         * @param callback Callback to invoke after we have determined if the iframe content is accessible.\n         */\n        _attachLoadEvent: function(iframe, callback) {\n            /*jslint eqeq: true*/\n            var responseDescriptor;\n\n            if (isCors) {\n                registerPostMessageCallback(iframe, callback);\n            }\n            else {\n                detachLoadEvents[iframe.id] = qq(iframe).attach(\"load\", function() {\n                    log(\"Received response for \" + iframe.id);\n\n                    // when we remove iframe from dom\n                    // the request stops, but in IE load\n                    // event fires\n                    if (!iframe.parentNode) {\n                        return;\n                    }\n\n                    try {\n                        // fixing Opera 10.53\n                        if (iframe.contentDocument &&\n                            iframe.contentDocument.body &&\n                            iframe.contentDocument.body.innerHTML == \"false\") {\n                            // In Opera event is fired second time\n                            // when body.innerHTML changed from false\n                            // to server response approx. after 1 sec\n                            // when we upload file with iframe\n                            return;\n                        }\n                    }\n                    catch (error) {\n                        //IE may throw an \"access is denied\" error when attempting to access contentDocument on the iframe in some cases\n                        log(\"Error when attempting to access iframe during handling of upload response (\" + error.message + \")\", \"error\");\n                        responseDescriptor = {success: false};\n                    }\n\n                    callback(responseDescriptor);\n                });\n            }\n        },\n\n        /**\n         * Creates an iframe with a specific document-unique name.\n         *\n         * @param id ID of the associated file\n         * @returns {HTMLIFrameElement}\n         */\n        _createIframe: function(id) {\n            var iframeName = handler._getIframeName(id);\n\n            return initIframeForUpload(iframeName);\n        },\n\n        /**\n         * Called when we are no longer interested in being notified when an iframe has loaded.\n         *\n         * @param id Associated file ID\n         */\n        _detachLoadEvent: function(id) {\n            if (detachLoadEvents[id] !== undefined) {\n                detachLoadEvents[id]();\n                delete detachLoadEvents[id];\n            }\n        },\n\n        /**\n         * @param fileId ID of the associated file\n         * @returns {string} The `document`-unique name of the iframe\n         */\n        _getIframeName: function(fileId) {\n            return fileId + \"_\" + formHandlerInstanceId;\n        },\n\n        /**\n         * Generates a form element and appends it to the `document`.  When the form is submitted, a specific iframe is targeted.\n         * The name of the iframe is passed in as a property of the spec parameter, and must be unique in the `document`.  Note\n         * that the form is hidden from view.\n         *\n         * @param spec An object containing various properties to be used when constructing the form.  Required properties are\n         * currently: `method`, `endpoint`, `params`, `paramsInBody`, and `targetName`.\n         * @returns {HTMLFormElement} The created form\n         */\n        _initFormForUpload: function(spec) {\n            var method = spec.method,\n                endpoint = spec.endpoint,\n                params = spec.params,\n                paramsInBody = spec.paramsInBody,\n                targetName = spec.targetName,\n                form = qq.toElement(\"<form method='\" + method + \"' enctype='multipart/form-data'></form>\"),\n                url = endpoint;\n\n            if (paramsInBody) {\n                qq.obj2Inputs(params, form);\n            }\n            else {\n                url = qq.obj2url(params, endpoint);\n            }\n\n            form.setAttribute(\"action\", url);\n            form.setAttribute(\"target\", targetName);\n            form.style.display = \"none\";\n            document.body.appendChild(form);\n\n            return form;\n        },\n\n        /**\n         * @param innerHtmlOrMessage JSON message\n         * @returns {*} The parsed response, or an empty object if the response could not be parsed\n         */\n        _parseJsonResponse: function(innerHtmlOrMessage) {\n            var response = {};\n\n            try {\n                response = qq.parseJson(innerHtmlOrMessage);\n            }\n            catch (error) {\n                log(\"Error when attempting to parse iframe upload response (\" + error.message + \")\", \"error\");\n            }\n\n            return response;\n        }\n    });\n};\n","/* globals qq */\n/**\n * Common API exposed to creators of XHR handlers.  This is reused and possibly overriding in some cases by specific\n * XHR upload handlers.\n *\n * @constructor\n */\nqq.XhrUploadHandler = function(spec) {\n    \"use strict\";\n\n    var handler = this,\n        namespace = spec.options.namespace,\n        proxy = spec.proxy,\n        chunking = spec.options.chunking,\n        resume = spec.options.resume,\n        chunkFiles = chunking && spec.options.chunking.enabled && qq.supportedFeatures.chunking,\n        resumeEnabled = resume && spec.options.resume.enabled && chunkFiles && qq.supportedFeatures.resume,\n        getName = proxy.getName,\n        getSize = proxy.getSize,\n        getUuid = proxy.getUuid,\n        getEndpoint = proxy.getEndpoint,\n        getDataByUuid = proxy.getDataByUuid,\n        onUuidChanged = proxy.onUuidChanged,\n        onProgress = proxy.onProgress,\n        log = proxy.log;\n\n    function abort(id) {\n        qq.each(handler._getXhrs(id), function(xhrId, xhr) {\n            var ajaxRequester = handler._getAjaxRequester(id, xhrId);\n\n            xhr.onreadystatechange = null;\n            xhr.upload.onprogress = null;\n            xhr.abort();\n            ajaxRequester && ajaxRequester.canceled && ajaxRequester.canceled(id);\n        });\n    }\n\n    qq.extend(this, new qq.UploadHandler(spec));\n\n    qq.override(this, function(super_) {\n        return {\n            /**\n             * Adds File or Blob to the queue\n             **/\n            add: function(id, blobOrProxy) {\n                if (qq.isFile(blobOrProxy) || qq.isBlob(blobOrProxy)) {\n                    super_.add(id, {file: blobOrProxy});\n                }\n                else if (blobOrProxy instanceof qq.BlobProxy) {\n                    super_.add(id, {proxy: blobOrProxy});\n                }\n                else {\n                    throw new Error(\"Passed obj is not a File, Blob, or proxy\");\n                }\n\n                handler._initTempState(id);\n                resumeEnabled && handler._maybePrepareForResume(id);\n            },\n\n            expunge: function(id) {\n                abort(id);\n                handler._maybeDeletePersistedChunkData(id);\n                handler._clearXhrs(id);\n                super_.expunge(id);\n            }\n        };\n    });\n\n    qq.extend(this, {\n        // Clear the cached chunk `Blob` after we are done with it, just in case the `Blob` bytes are stored in memory.\n        clearCachedChunk: function(id, chunkIdx) {\n            delete handler._getFileState(id).temp.cachedChunks[chunkIdx];\n        },\n\n        clearXhr: function(id, chunkIdx) {\n            var tempState = handler._getFileState(id).temp;\n\n            if (tempState.xhrs) {\n                delete tempState.xhrs[chunkIdx];\n            }\n            if (tempState.ajaxRequesters) {\n                delete tempState.ajaxRequesters[chunkIdx];\n            }\n        },\n\n        // Called when all chunks have been successfully uploaded.  Expected promissory return type.\n        // This defines the default behavior if nothing further is required when all chunks have been uploaded.\n        finalizeChunks: function(id, responseParser) {\n            var lastChunkIdx = handler._getTotalChunks(id) - 1,\n                xhr = handler._getXhr(id, lastChunkIdx);\n\n            if (responseParser) {\n                return new qq.Promise().success(responseParser(xhr), xhr);\n            }\n\n            return new qq.Promise().success({}, xhr);\n        },\n\n        getFile: function(id) {\n            return handler.isValid(id) && handler._getFileState(id).file;\n        },\n\n        getProxy: function(id) {\n            return handler.isValid(id) && handler._getFileState(id).proxy;\n        },\n\n        /**\n         * @returns {Array} Array of objects containing properties useful to integrators\n         * when it is important to determine which files are potentially resumable.\n         */\n        getResumableFilesData: function() {\n            var resumableFilesData = [];\n\n            handler._iterateResumeRecords(function(key, uploadData) {\n                handler.moveInProgressToRemaining(null, uploadData.chunking.inProgress,  uploadData.chunking.remaining);\n\n                var data = {\n                    name: uploadData.name,\n                    remaining: uploadData.chunking.remaining,\n                    size: uploadData.size,\n                    uuid: uploadData.uuid\n                };\n\n                if (uploadData.key) {\n                    data.key = uploadData.key;\n                }\n\n                resumableFilesData.push(data);\n            });\n\n            return resumableFilesData;\n        },\n\n        isResumable: function(id) {\n            return !!chunking && handler.isValid(id) && !handler._getFileState(id).notResumable;\n        },\n\n        moveInProgressToRemaining: function(id, optInProgress, optRemaining) {\n            var inProgress = optInProgress || handler._getFileState(id).chunking.inProgress,\n                remaining = optRemaining || handler._getFileState(id).chunking.remaining;\n\n            if (inProgress) {\n                log(qq.format(\"Moving these chunks from in-progress {}, to remaining.\", JSON.stringify(inProgress)));\n                inProgress.reverse();\n                qq.each(inProgress, function(idx, chunkIdx) {\n                    remaining.unshift(chunkIdx);\n                });\n                inProgress.length = 0;\n            }\n        },\n\n        pause: function(id) {\n            if (handler.isValid(id)) {\n                log(qq.format(\"Aborting XHR upload for {} '{}' due to pause instruction.\", id, getName(id)));\n                handler._getFileState(id).paused = true;\n                abort(id);\n                return true;\n            }\n        },\n\n        reevaluateChunking: function(id) {\n            if (chunking && handler.isValid(id)) {\n                var state = handler._getFileState(id),\n                    totalChunks,\n                    i;\n\n                delete state.chunking;\n\n                state.chunking = {};\n                totalChunks = handler._getTotalChunks(id);\n                if (totalChunks > 1 || chunking.mandatory) {\n                    state.chunking.enabled = true;\n                    state.chunking.parts = totalChunks;\n                    state.chunking.remaining = [];\n\n                    for (i = 0; i < totalChunks; i++) {\n                        state.chunking.remaining.push(i);\n                    }\n\n                    handler._initTempState(id);\n                }\n                else {\n                    state.chunking.enabled = false;\n                }\n            }\n        },\n\n        updateBlob: function(id, newBlob) {\n            if (handler.isValid(id)) {\n                handler._getFileState(id).file = newBlob;\n            }\n        },\n\n        _clearXhrs: function(id) {\n            var tempState = handler._getFileState(id).temp;\n\n            qq.each(tempState.ajaxRequesters, function(chunkId) {\n                delete tempState.ajaxRequesters[chunkId];\n            });\n\n            qq.each(tempState.xhrs, function(chunkId) {\n                delete tempState.xhrs[chunkId];\n            });\n        },\n\n        /**\n         * Creates an XHR instance for this file and stores it in the fileState.\n         *\n         * @param id File ID\n         * @param optChunkIdx The chunk index associated with this XHR, if applicable\n         * @returns {XMLHttpRequest}\n         */\n        _createXhr: function(id, optChunkIdx) {\n            return handler._registerXhr(id, optChunkIdx, qq.createXhrInstance());\n        },\n\n        _getAjaxRequester: function(id, optChunkIdx) {\n            var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;\n            return handler._getFileState(id).temp.ajaxRequesters[chunkIdx];\n        },\n\n        _getChunkData: function(id, chunkIndex) {\n            var chunkSize = chunking.partSize,\n                fileSize = getSize(id),\n                fileOrBlob = handler.getFile(id),\n                startBytes = chunkSize * chunkIndex,\n                endBytes = startBytes + chunkSize >= fileSize ? fileSize : startBytes + chunkSize,\n                totalChunks = handler._getTotalChunks(id),\n                cachedChunks = this._getFileState(id).temp.cachedChunks,\n\n            // To work around a Webkit GC bug, we must keep each chunk `Blob` in scope until we are done with it.\n            // See https://github.com/Widen/fine-uploader/issues/937#issuecomment-41418760\n                blob = cachedChunks[chunkIndex] || qq.sliceBlob(fileOrBlob, startBytes, endBytes);\n\n            cachedChunks[chunkIndex] = blob;\n\n            return {\n                part: chunkIndex,\n                start: startBytes,\n                end: endBytes,\n                count: totalChunks,\n                blob: blob,\n                size: endBytes - startBytes\n            };\n        },\n\n        _getChunkDataForCallback: function(chunkData) {\n            return {\n                partIndex: chunkData.part,\n                startByte: chunkData.start + 1,\n                endByte: chunkData.end,\n                totalParts: chunkData.count\n            };\n        },\n\n        /**\n         * @param id File ID\n         * @returns {string} Identifier for this item that may appear in the browser's local storage\n         */\n        _getLocalStorageId: function(id) {\n            var formatVersion = \"5.0\",\n                name = getName(id),\n                size = getSize(id),\n                chunkSize = chunking.partSize,\n                endpoint = getEndpoint(id);\n\n            return qq.format(\"qq{}resume{}-{}-{}-{}-{}\", namespace, formatVersion, name, size, chunkSize, endpoint);\n        },\n\n        _getMimeType: function(id) {\n            return handler.getFile(id).type;\n        },\n\n        _getPersistableData: function(id) {\n            return handler._getFileState(id).chunking;\n        },\n\n        /**\n         * @param id ID of the associated file\n         * @returns {number} Number of parts this file can be divided into, or undefined if chunking is not supported in this UA\n         */\n        _getTotalChunks: function(id) {\n            if (chunking) {\n                var fileSize = getSize(id),\n                    chunkSize = chunking.partSize;\n\n                return Math.ceil(fileSize / chunkSize);\n            }\n        },\n\n        _getXhr: function(id, optChunkIdx) {\n            var chunkIdx = optChunkIdx == null ? -1 : optChunkIdx;\n            return handler._getFileState(id).temp.xhrs[chunkIdx];\n        },\n\n        _getXhrs: function(id) {\n            return handler._getFileState(id).temp.xhrs;\n        },\n\n        // Iterates through all XHR handler-created resume records (in local storage),\n        // invoking the passed callback and passing in the key and value of each local storage record.\n        _iterateResumeRecords: function(callback) {\n            if (resumeEnabled) {\n                qq.each(localStorage, function(key, item) {\n                    if (key.indexOf(qq.format(\"qq{}resume\", namespace)) === 0) {\n                        var uploadData = JSON.parse(item);\n                        callback(key, uploadData);\n                    }\n                });\n            }\n        },\n\n        _initTempState: function(id) {\n            handler._getFileState(id).temp = {\n                ajaxRequesters: {},\n                chunkProgress: {},\n                xhrs: {},\n                cachedChunks: {}\n            };\n        },\n\n        _markNotResumable: function(id) {\n            handler._getFileState(id).notResumable = true;\n        },\n\n        // Removes a chunked upload record from local storage, if possible.\n        // Returns true if the item was removed, false otherwise.\n        _maybeDeletePersistedChunkData: function(id) {\n            var localStorageId;\n\n            if (resumeEnabled && handler.isResumable(id)) {\n                localStorageId = handler._getLocalStorageId(id);\n\n                if (localStorageId && localStorage.getItem(localStorageId)) {\n                    localStorage.removeItem(localStorageId);\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        // If this is a resumable upload, grab the relevant data from storage and items in memory that track this upload\n        // so we can pick up from where we left off.\n        _maybePrepareForResume: function(id) {\n            var state = handler._getFileState(id),\n                localStorageId, persistedData;\n\n            // Resume is enabled and possible and this is the first time we've tried to upload this file in this session,\n            // so prepare for a resume attempt.\n            if (resumeEnabled && state.key === undefined) {\n                localStorageId = handler._getLocalStorageId(id);\n                persistedData = localStorage.getItem(localStorageId);\n\n                // If we found this item in local storage, maybe we should resume it.\n                if (persistedData) {\n                    persistedData = JSON.parse(persistedData);\n\n                    // If we found a resume record but we have already handled this file in this session,\n                    // don't try to resume it & ensure we don't persist future check data\n                    if (getDataByUuid(persistedData.uuid)) {\n                        handler._markNotResumable(id);\n                    }\n                    else {\n                        log(qq.format(\"Identified file with ID {} and name of {} as resumable.\", id, getName(id)));\n\n                        onUuidChanged(id, persistedData.uuid);\n\n                        state.key = persistedData.key;\n                        state.chunking = persistedData.chunking;\n                        state.loaded = persistedData.loaded;\n                        state.attemptingResume = true;\n\n                        handler.moveInProgressToRemaining(id);\n                    }\n                }\n            }\n        },\n\n        // Persist any data needed to resume this upload in a new session.\n        _maybePersistChunkedState: function(id) {\n            var state = handler._getFileState(id),\n                localStorageId, persistedData;\n\n            // If local storage isn't supported by the browser, or if resume isn't enabled or possible, give up\n            if (resumeEnabled && handler.isResumable(id)) {\n                localStorageId = handler._getLocalStorageId(id);\n\n                persistedData = {\n                    name: getName(id),\n                    size: getSize(id),\n                    uuid: getUuid(id),\n                    key: state.key,\n                    chunking: state.chunking,\n                    loaded: state.loaded,\n                    lastUpdated: Date.now()\n                };\n\n                try {\n                    localStorage.setItem(localStorageId, JSON.stringify(persistedData));\n                }\n                catch (error) {\n                    log(qq.format(\"Unable to save resume data for '{}' due to error: '{}'.\", id, error.toString()), \"warn\");\n                }\n            }\n        },\n\n        _registerProgressHandler: function(id, chunkIdx, chunkSize) {\n            var xhr = handler._getXhr(id, chunkIdx),\n                name = getName(id),\n                progressCalculator = {\n                    simple: function(loaded, total) {\n                        var fileSize = getSize(id);\n\n                        if (loaded === total) {\n                            onProgress(id, name, fileSize, fileSize);\n                        }\n                        else {\n                            onProgress(id, name, (loaded >= fileSize ? fileSize - 1 : loaded), fileSize);\n                        }\n                    },\n\n                    chunked: function(loaded, total) {\n                        var chunkProgress = handler._getFileState(id).temp.chunkProgress,\n                            totalSuccessfullyLoadedForFile = handler._getFileState(id).loaded,\n                            loadedForRequest = loaded,\n                            totalForRequest = total,\n                            totalFileSize = getSize(id),\n                            estActualChunkLoaded = loadedForRequest - (totalForRequest - chunkSize),\n                            totalLoadedForFile = totalSuccessfullyLoadedForFile;\n\n                        chunkProgress[chunkIdx] = estActualChunkLoaded;\n\n                        qq.each(chunkProgress, function(chunkIdx, chunkLoaded) {\n                            totalLoadedForFile += chunkLoaded;\n                        });\n\n                        onProgress(id, name, totalLoadedForFile, totalFileSize);\n                    }\n                };\n\n            xhr.upload.onprogress = function(e) {\n                if (e.lengthComputable) {\n                    /* jshint eqnull: true */\n                    var type = chunkSize == null ? \"simple\" : \"chunked\";\n                    progressCalculator[type](e.loaded, e.total);\n                }\n            };\n        },\n\n        /**\n         * Registers an XHR transport instance created elsewhere.\n         *\n         * @param id ID of the associated file\n         * @param optChunkIdx The chunk index associated with this XHR, if applicable\n         * @param xhr XMLHttpRequest object instance\n         * @param optAjaxRequester `qq.AjaxRequester` associated with this request, if applicable.\n         * @returns {XMLHttpRequest}\n         */\n        _registerXhr: function(id, optChunkIdx, xhr, optAjaxRequester) {\n            var xhrsId = optChunkIdx == null ? -1 : optChunkIdx,\n                tempState = handler._getFileState(id).temp;\n\n            tempState.xhrs = tempState.xhrs || {};\n            tempState.ajaxRequesters = tempState.ajaxRequesters || {};\n\n            tempState.xhrs[xhrsId] = xhr;\n\n            if (optAjaxRequester) {\n                tempState.ajaxRequesters[xhrsId] = optAjaxRequester;\n            }\n\n            return xhr;\n        },\n\n        // Deletes any local storage records that are \"expired\".\n        _removeExpiredChunkingRecords: function() {\n            var expirationDays = resume.recordsExpireIn;\n\n            handler._iterateResumeRecords(function(key, uploadData) {\n                var expirationDate = new Date(uploadData.lastUpdated);\n\n                // transform updated date into expiration date\n                expirationDate.setDate(expirationDate.getDate() + expirationDays);\n\n                if (expirationDate.getTime() <= Date.now()) {\n                    log(\"Removing expired resume record with key \" + key);\n                    localStorage.removeItem(key);\n                }\n            });\n        },\n\n        /**\n         * Determine if the associated file should be chunked.\n         *\n         * @param id ID of the associated file\n         * @returns {*} true if chunking is enabled, possible, and the file can be split into more than 1 part\n         */\n        _shouldChunkThisFile: function(id) {\n            var state = handler._getFileState(id);\n\n            if (!state.chunking) {\n                handler.reevaluateChunking(id);\n            }\n\n            return state.chunking.enabled;\n        }\n    });\n};\n","/*globals qq, XMLHttpRequest*/\nqq.DeleteFileAjaxRequester = function(o) {\n    \"use strict\";\n\n    var requester,\n        options = {\n            method: \"DELETE\",\n            uuidParamName: \"qquuid\",\n            endpointStore: {},\n            maxConnections: 3,\n            customHeaders: function(id) {return {};},\n            paramsStore: {},\n            cors: {\n                expected: false,\n                sendCredentials: false\n            },\n            log: function(str, level) {},\n            onDelete: function(id) {},\n            onDeleteComplete: function(id, xhrOrXdr, isError) {}\n        };\n\n    qq.extend(options, o);\n\n    function getMandatedParams() {\n        if (options.method.toUpperCase() === \"POST\") {\n            return {\n                _method: \"DELETE\"\n            };\n        }\n\n        return {};\n    }\n\n    requester = qq.extend(this, new qq.AjaxRequester({\n        acceptHeader: \"application/json\",\n        validMethods: [\"POST\", \"DELETE\"],\n        method: options.method,\n        endpointStore: options.endpointStore,\n        paramsStore: options.paramsStore,\n        mandatedParams: getMandatedParams(),\n        maxConnections: options.maxConnections,\n        customHeaders: function(id) {\n            return options.customHeaders.get(id);\n        },\n        log: options.log,\n        onSend: options.onDelete,\n        onComplete: options.onDeleteComplete,\n        cors: options.cors\n    }));\n\n    qq.extend(this, {\n        sendDelete: function(id, uuid, additionalMandatedParams) {\n            var additionalOptions = additionalMandatedParams || {};\n\n            options.log(\"Submitting delete file request for \" + id);\n\n            if (options.method === \"DELETE\") {\n                requester.initTransport(id)\n                    .withPath(uuid)\n                    .withParams(additionalOptions)\n                    .send();\n            }\n            else {\n                additionalOptions[options.uuidParamName] = uuid;\n                requester.initTransport(id)\n                    .withParams(additionalOptions)\n                    .send();\n            }\n        }\n    });\n};\n","/*global qq, define */\n/*jshint strict:false,bitwise:false,nonew:false,asi:true,-W064,-W116,-W089 */\n/**\n * Mega pixel image rendering library for iOS6+\n *\n * Fixes iOS6+'s image file rendering issue for large size image (over mega-pixel),\n * which causes unexpected subsampling when drawing it in canvas.\n * By using this library, you can safely render the image with proper stretching.\n *\n * Copyright (c) 2012 Shinichi Tomita <shinichi.tomita@gmail.com>\n * Released under the MIT license\n *\n * Heavily modified by Widen for Fine Uploader\n */\n(function() {\n\n    /**\n     * Detect subsampling in loaded image.\n     * In iOS, larger images than 2M pixels may be subsampled in rendering.\n     */\n    function detectSubsampling(img) {\n        var iw = img.naturalWidth,\n            ih = img.naturalHeight,\n            canvas = document.createElement(\"canvas\"),\n            ctx;\n\n        if (iw * ih > 1024 * 1024) { // subsampling may happen over megapixel image\n            canvas.width = canvas.height = 1;\n            ctx = canvas.getContext(\"2d\");\n            ctx.drawImage(img, -iw + 1, 0);\n            // subsampled image becomes half smaller in rendering size.\n            // check alpha channel value to confirm image is covering edge pixel or not.\n            // if alpha value is 0 image is not covering, hence subsampled.\n            return ctx.getImageData(0, 0, 1, 1).data[3] === 0;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * Detecting vertical squash in loaded image.\n     * Fixes a bug which squash image vertically while drawing into canvas for some images.\n     */\n    function detectVerticalSquash(img, iw, ih) {\n        var canvas = document.createElement(\"canvas\"),\n            sy = 0,\n            ey = ih,\n            py = ih,\n            ctx, data, alpha, ratio;\n\n        canvas.width = 1;\n        canvas.height = ih;\n        ctx = canvas.getContext(\"2d\");\n        ctx.drawImage(img, 0, 0);\n        data = ctx.getImageData(0, 0, 1, ih).data;\n\n        // search image edge pixel position in case it is squashed vertically.\n        while (py > sy) {\n            alpha = data[(py - 1) * 4 + 3];\n            if (alpha === 0) {\n                ey = py;\n            } else {\n                sy = py;\n            }\n            py = (ey + sy) >> 1;\n        }\n\n        ratio = (py / ih);\n        return (ratio === 0) ? 1 : ratio;\n    }\n\n    /**\n     * Rendering image element (with resizing) and get its data URL\n     */\n    function renderImageToDataURL(img, blob, options, doSquash) {\n        var canvas = document.createElement(\"canvas\"),\n            mime = options.mime || \"image/jpeg\",\n            promise = new qq.Promise();\n\n        renderImageToCanvas(img, blob, canvas, options, doSquash)\n            .then(function() {\n                promise.success(\n                    canvas.toDataURL(mime, options.quality || 0.8)\n                );\n            });\n\n        return promise;\n    }\n\n    function maybeCalculateDownsampledDimensions(spec) {\n        var maxPixels = 5241000; //iOS specific value\n\n        if (!qq.ios()) {\n            throw new qq.Error(\"Downsampled dimensions can only be reliably calculated for iOS!\");\n        }\n\n        if (spec.origHeight * spec.origWidth > maxPixels) {\n            return {\n                newHeight: Math.round(Math.sqrt(maxPixels * (spec.origHeight / spec.origWidth))),\n                newWidth: Math.round(Math.sqrt(maxPixels * (spec.origWidth / spec.origHeight)))\n            };\n        }\n    }\n\n    /**\n     * Rendering image element (with resizing) into the canvas element\n     */\n    function renderImageToCanvas(img, blob, canvas, options, doSquash) {\n        var iw = img.naturalWidth,\n            ih = img.naturalHeight,\n            width = options.width,\n            height = options.height,\n            ctx = canvas.getContext(\"2d\"),\n            promise = new qq.Promise(),\n            modifiedDimensions;\n\n        ctx.save();\n\n        if (options.resize) {\n            return renderImageToCanvasWithCustomResizer({\n                blob: blob,\n                canvas: canvas,\n                image: img,\n                imageHeight: ih,\n                imageWidth: iw,\n                orientation: options.orientation,\n                resize: options.resize,\n                targetHeight: height,\n                targetWidth: width\n            });\n        }\n\n        if (!qq.supportedFeatures.unlimitedScaledImageSize) {\n            modifiedDimensions = maybeCalculateDownsampledDimensions({\n                origWidth: width,\n                origHeight: height\n            });\n\n            if (modifiedDimensions) {\n                qq.log(qq.format(\"Had to reduce dimensions due to device limitations from {}w / {}h to {}w / {}h\",\n                    width, height, modifiedDimensions.newWidth, modifiedDimensions.newHeight),\n                    \"warn\");\n\n                width = modifiedDimensions.newWidth;\n                height = modifiedDimensions.newHeight;\n            }\n        }\n\n        transformCoordinate(canvas, width, height, options.orientation);\n\n        // Fine Uploader specific: Save some CPU cycles if not using iOS\n        // Assumption: This logic is only needed to overcome iOS image sampling issues\n        if (qq.ios()) {\n            (function() {\n                if (detectSubsampling(img)) {\n                    iw /= 2;\n                    ih /= 2;\n                }\n\n                var d = 1024, // size of tiling canvas\n                    tmpCanvas = document.createElement(\"canvas\"),\n                    vertSquashRatio = doSquash ? detectVerticalSquash(img, iw, ih) : 1,\n                    dw = Math.ceil(d * width / iw),\n                    dh = Math.ceil(d * height / ih / vertSquashRatio),\n                    sy = 0,\n                    dy = 0,\n                    tmpCtx, sx, dx;\n\n                tmpCanvas.width = tmpCanvas.height = d;\n                tmpCtx = tmpCanvas.getContext(\"2d\");\n\n                while (sy < ih) {\n                    sx = 0;\n                    dx = 0;\n                    while (sx < iw) {\n                        tmpCtx.clearRect(0, 0, d, d);\n                        tmpCtx.drawImage(img, -sx, -sy);\n                        ctx.drawImage(tmpCanvas, 0, 0, d, d, dx, dy, dw, dh);\n                        sx += d;\n                        dx += dw;\n                    }\n                    sy += d;\n                    dy += dh;\n                }\n                ctx.restore();\n                tmpCanvas = tmpCtx = null;\n            }());\n        }\n        else {\n            ctx.drawImage(img, 0, 0, width, height);\n        }\n\n        canvas.qqImageRendered && canvas.qqImageRendered();\n        promise.success();\n\n        return promise;\n    }\n\n    function renderImageToCanvasWithCustomResizer(resizeInfo) {\n        var blob = resizeInfo.blob,\n            image = resizeInfo.image,\n            imageHeight = resizeInfo.imageHeight,\n            imageWidth = resizeInfo.imageWidth,\n            orientation = resizeInfo.orientation,\n            promise = new qq.Promise(),\n            resize = resizeInfo.resize,\n            sourceCanvas = document.createElement(\"canvas\"),\n            sourceCanvasContext = sourceCanvas.getContext(\"2d\"),\n            targetCanvas = resizeInfo.canvas,\n            targetHeight = resizeInfo.targetHeight,\n            targetWidth = resizeInfo.targetWidth;\n\n        transformCoordinate(sourceCanvas, imageWidth, imageHeight, orientation);\n\n        targetCanvas.height = targetHeight;\n        targetCanvas.width = targetWidth;\n\n        sourceCanvasContext.drawImage(image, 0, 0);\n\n        resize({\n            blob: blob,\n            height: targetHeight,\n            image: image,\n            sourceCanvas: sourceCanvas,\n            targetCanvas: targetCanvas,\n            width: targetWidth\n        })\n            .then(\n                function success() {\n                    targetCanvas.qqImageRendered && targetCanvas.qqImageRendered();\n                    promise.success();\n                },\n                promise.failure\n            );\n\n        return promise;\n    }\n\n    /**\n     * Transform canvas coordination according to specified frame size and orientation\n     * Orientation value is from EXIF tag\n     */\n    function transformCoordinate(canvas, width, height, orientation) {\n        switch (orientation) {\n            case 5:\n            case 6:\n            case 7:\n            case 8:\n                canvas.width = height;\n                canvas.height = width;\n                break;\n            default:\n                canvas.width = width;\n                canvas.height = height;\n        }\n        var ctx = canvas.getContext(\"2d\");\n        switch (orientation) {\n            case 2:\n                // horizontal flip\n                ctx.translate(width, 0);\n                ctx.scale(-1, 1);\n                break;\n            case 3:\n                // 180 rotate left\n                ctx.translate(width, height);\n                ctx.rotate(Math.PI);\n                break;\n            case 4:\n                // vertical flip\n                ctx.translate(0, height);\n                ctx.scale(1, -1);\n                break;\n            case 5:\n                // vertical flip + 90 rotate right\n                ctx.rotate(0.5 * Math.PI);\n                ctx.scale(1, -1);\n                break;\n            case 6:\n                // 90 rotate right\n                ctx.rotate(0.5 * Math.PI);\n                ctx.translate(0, -height);\n                break;\n            case 7:\n                // horizontal flip + 90 rotate right\n                ctx.rotate(0.5 * Math.PI);\n                ctx.translate(width, -height);\n                ctx.scale(-1, 1);\n                break;\n            case 8:\n                // 90 rotate left\n                ctx.rotate(-0.5 * Math.PI);\n                ctx.translate(-width, 0);\n                break;\n            default:\n                break;\n        }\n    }\n\n    /**\n     * MegaPixImage class\n     */\n    function MegaPixImage(srcImage, errorCallback) {\n        var self = this;\n\n        if (window.Blob && srcImage instanceof Blob) {\n            (function() {\n                var img = new Image(),\n                    URL = window.URL && window.URL.createObjectURL ? window.URL :\n                        window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL : null;\n                if (!URL) { throw Error(\"No createObjectURL function found to create blob url\"); }\n                img.src = URL.createObjectURL(srcImage);\n                self.blob = srcImage;\n                srcImage = img;\n            }());\n        }\n        if (!srcImage.naturalWidth && !srcImage.naturalHeight) {\n            srcImage.onload = function() {\n                var listeners = self.imageLoadListeners;\n                if (listeners) {\n                    self.imageLoadListeners = null;\n                    // IE11 doesn't reliably report actual image dimensions immediately after onload for small files,\n                    // so let's push this to the end of the UI thread queue.\n                    setTimeout(function() {\n                        for (var i = 0, len = listeners.length; i < len; i++) {\n                            listeners[i]();\n                        }\n                    }, 0);\n                }\n            };\n            srcImage.onerror = errorCallback;\n            this.imageLoadListeners = [];\n        }\n        this.srcImage = srcImage;\n    }\n\n    /**\n     * Rendering megapix image into specified target element\n     */\n    MegaPixImage.prototype.render = function(target, options) {\n        options = options || {};\n\n        var self = this,\n            imgWidth = this.srcImage.naturalWidth,\n            imgHeight = this.srcImage.naturalHeight,\n            width = options.width,\n            height = options.height,\n            maxWidth = options.maxWidth,\n            maxHeight = options.maxHeight,\n            doSquash = !this.blob || this.blob.type === \"image/jpeg\",\n            tagName = target.tagName.toLowerCase(),\n            opt;\n\n        if (this.imageLoadListeners) {\n            this.imageLoadListeners.push(function() { self.render(target, options); });\n            return;\n        }\n\n        if (width && !height) {\n            height = (imgHeight * width / imgWidth) << 0;\n        } else if (height && !width) {\n            width = (imgWidth * height / imgHeight) << 0;\n        } else {\n            width = imgWidth;\n            height = imgHeight;\n        }\n        if (maxWidth && width > maxWidth) {\n            width = maxWidth;\n            height = (imgHeight * width / imgWidth) << 0;\n        }\n        if (maxHeight && height > maxHeight) {\n            height = maxHeight;\n            width = (imgWidth * height / imgHeight) << 0;\n        }\n\n        opt = { width: width, height: height },\n        qq.each(options, function(optionsKey, optionsValue) {\n            opt[optionsKey] = optionsValue;\n        });\n\n        if (tagName === \"img\") {\n            (function() {\n                var oldTargetSrc = target.src;\n                renderImageToDataURL(self.srcImage, self.blob, opt, doSquash)\n                    .then(function(dataUri) {\n                        target.src = dataUri;\n                        oldTargetSrc === target.src && target.onload();\n                    });\n            }());\n        } else if (tagName === \"canvas\") {\n            renderImageToCanvas(this.srcImage, this.blob, target, opt, doSquash);\n        }\n        if (typeof this.onrender === \"function\") {\n            this.onrender(target);\n        }\n    };\n\n    qq.MegaPixImage = MegaPixImage;\n})();\n","/*globals qq */\n/**\n * Draws a thumbnail of a Blob/File/URL onto an <img> or <canvas>.\n *\n * @constructor\n */\nqq.ImageGenerator = function(log) {\n    \"use strict\";\n\n    function isImg(el) {\n        return el.tagName.toLowerCase() === \"img\";\n    }\n\n    function isCanvas(el) {\n        return el.tagName.toLowerCase() === \"canvas\";\n    }\n\n    function isImgCorsSupported() {\n        return new Image().crossOrigin !== undefined;\n    }\n\n    function isCanvasSupported() {\n        var canvas = document.createElement(\"canvas\");\n\n        return canvas.getContext && canvas.getContext(\"2d\");\n    }\n\n    // This is only meant to determine the MIME type of a renderable image file.\n    // It is used to ensure images drawn from a URL that have transparent backgrounds\n    // are rendered correctly, among other things.\n    function determineMimeOfFileName(nameWithPath) {\n        /*jshint -W015 */\n        var pathSegments = nameWithPath.split(\"/\"),\n            name = pathSegments[pathSegments.length - 1].split(\"?\")[0],\n            extension = qq.getExtension(name);\n\n        extension = extension && extension.toLowerCase();\n\n        switch (extension) {\n            case \"jpeg\":\n            case \"jpg\":\n                return \"image/jpeg\";\n            case \"png\":\n                return \"image/png\";\n            case \"bmp\":\n                return \"image/bmp\";\n            case \"gif\":\n                return \"image/gif\";\n            case \"tiff\":\n            case \"tif\":\n                return \"image/tiff\";\n        }\n    }\n\n    // This will likely not work correctly in IE8 and older.\n    // It's only used as part of a formula to determine\n    // if a canvas can be used to scale a server-hosted thumbnail.\n    // If canvas isn't supported by the UA (IE8 and older)\n    // this method should not even be called.\n    function isCrossOrigin(url) {\n        var targetAnchor = document.createElement(\"a\"),\n            targetProtocol, targetHostname, targetPort;\n\n        targetAnchor.href = url;\n\n        targetProtocol = targetAnchor.protocol;\n        targetPort = targetAnchor.port;\n        targetHostname = targetAnchor.hostname;\n\n        if (targetProtocol.toLowerCase() !== window.location.protocol.toLowerCase()) {\n            return true;\n        }\n\n        if (targetHostname.toLowerCase() !== window.location.hostname.toLowerCase()) {\n            return true;\n        }\n\n        // IE doesn't take ports into consideration when determining if two endpoints are same origin.\n        if (targetPort !== window.location.port && !qq.ie()) {\n            return true;\n        }\n\n        return false;\n    }\n\n    function registerImgLoadListeners(img, promise) {\n        img.onload = function() {\n            img.onload = null;\n            img.onerror = null;\n            promise.success(img);\n        };\n\n        img.onerror = function() {\n            img.onload = null;\n            img.onerror = null;\n            log(\"Problem drawing thumbnail!\", \"error\");\n            promise.failure(img, \"Problem drawing thumbnail!\");\n        };\n    }\n\n    function registerCanvasDrawImageListener(canvas, promise) {\n        // The image is drawn on the canvas by a third-party library,\n        // and we want to know when this is completed.  Since the library\n        // may invoke drawImage many times in a loop, we need to be called\n        // back when the image is fully rendered.  So, we are expecting the\n        // code that draws this image to follow a convention that involves a\n        // function attached to the canvas instance be invoked when it is done.\n        canvas.qqImageRendered = function() {\n            promise.success(canvas);\n        };\n    }\n\n    // Fulfills a `qq.Promise` when an image has been drawn onto the target,\n    // whether that is a <canvas> or an <img>.  The attempt is considered a\n    // failure if the target is not an <img> or a <canvas>, or if the drawing\n    // attempt was not successful.\n    function registerThumbnailRenderedListener(imgOrCanvas, promise) {\n        var registered = isImg(imgOrCanvas) || isCanvas(imgOrCanvas);\n\n        if (isImg(imgOrCanvas)) {\n            registerImgLoadListeners(imgOrCanvas, promise);\n        }\n        else if (isCanvas(imgOrCanvas)) {\n            registerCanvasDrawImageListener(imgOrCanvas, promise);\n        }\n        else {\n            promise.failure(imgOrCanvas);\n            log(qq.format(\"Element container of type {} is not supported!\", imgOrCanvas.tagName), \"error\");\n        }\n\n        return registered;\n    }\n\n    // Draw a preview iff the current UA can natively display it.\n    // Also rotate the image if necessary.\n    function draw(fileOrBlob, container, options) {\n        var drawPreview = new qq.Promise(),\n            identifier = new qq.Identify(fileOrBlob, log),\n            maxSize = options.maxSize,\n            // jshint eqnull:true\n            orient = options.orient == null ? true : options.orient,\n            megapixErrorHandler = function() {\n                container.onerror = null;\n                container.onload = null;\n                log(\"Could not render preview, file may be too large!\", \"error\");\n                drawPreview.failure(container, \"Browser cannot render image!\");\n            };\n\n        identifier.isPreviewable().then(\n            function(mime) {\n                // If options explicitly specify that Orientation is not desired,\n                // replace the orient task with a dummy promise that \"succeeds\" immediately.\n                var dummyExif = {\n                        parse: function() {\n                            return new qq.Promise().success();\n                        }\n                    },\n                    exif = orient ? new qq.Exif(fileOrBlob, log) : dummyExif,\n                    mpImg = new qq.MegaPixImage(fileOrBlob, megapixErrorHandler);\n\n                if (registerThumbnailRenderedListener(container, drawPreview)) {\n                    exif.parse().then(\n                        function(exif) {\n                            var orientation = exif && exif.Orientation;\n\n                            mpImg.render(container, {\n                                maxWidth: maxSize,\n                                maxHeight: maxSize,\n                                orientation: orientation,\n                                mime: mime,\n                                resize: options.customResizeFunction\n                            });\n                        },\n\n                        function(failureMsg) {\n                            log(qq.format(\"EXIF data could not be parsed ({}).  Assuming orientation = 1.\", failureMsg));\n\n                            mpImg.render(container, {\n                                maxWidth: maxSize,\n                                maxHeight: maxSize,\n                                mime: mime,\n                                resize: options.customResizeFunction\n                            });\n                        }\n                    );\n                }\n            },\n\n            function() {\n                log(\"Not previewable\");\n                drawPreview.failure(container, \"Not previewable\");\n            }\n        );\n\n        return drawPreview;\n    }\n\n    function drawOnCanvasOrImgFromUrl(url, canvasOrImg, draw, maxSize, customResizeFunction) {\n        var tempImg = new Image(),\n            tempImgRender = new qq.Promise();\n\n        registerThumbnailRenderedListener(tempImg, tempImgRender);\n\n        if (isCrossOrigin(url)) {\n            tempImg.crossOrigin = \"anonymous\";\n        }\n\n        tempImg.src = url;\n\n        tempImgRender.then(\n            function rendered() {\n                registerThumbnailRenderedListener(canvasOrImg, draw);\n\n                var mpImg = new qq.MegaPixImage(tempImg);\n                mpImg.render(canvasOrImg, {\n                    maxWidth: maxSize,\n                    maxHeight: maxSize,\n                    mime: determineMimeOfFileName(url),\n                    resize: customResizeFunction\n                });\n            },\n\n            draw.failure\n        );\n    }\n\n    function drawOnImgFromUrlWithCssScaling(url, img, draw, maxSize) {\n        registerThumbnailRenderedListener(img, draw);\n        // NOTE: The fact that maxWidth/height is set on the thumbnail for scaled images\n        // that must drop back to CSS is known and exploited by the templating module.\n        // In this module, we pre-render \"waiting\" thumbs for all files immediately after they\n        // are submitted, and we must be sure to pass any style associated with the \"waiting\" preview.\n        qq(img).css({\n            maxWidth: maxSize + \"px\",\n            maxHeight: maxSize + \"px\"\n        });\n\n        img.src = url;\n    }\n\n    // Draw a (server-hosted) thumbnail given a URL.\n    // This will optionally scale the thumbnail as well.\n    // It attempts to use <canvas> to scale, but will fall back\n    // to max-width and max-height style properties if the UA\n    // doesn't support canvas or if the images is cross-domain and\n    // the UA doesn't support the crossorigin attribute on img tags,\n    // which is required to scale a cross-origin image using <canvas> &\n    // then export it back to an <img>.\n    function drawFromUrl(url, container, options) {\n        var draw = new qq.Promise(),\n            scale = options.scale,\n            maxSize = scale ? options.maxSize : null;\n\n        // container is an img, scaling needed\n        if (scale && isImg(container)) {\n            // Iff canvas is available in this UA, try to use it for scaling.\n            // Otherwise, fall back to CSS scaling\n            if (isCanvasSupported()) {\n                // Attempt to use <canvas> for image scaling,\n                // but we must fall back to scaling via CSS/styles\n                // if this is a cross-origin image and the UA doesn't support <img> CORS.\n                if (isCrossOrigin(url) && !isImgCorsSupported()) {\n                    drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);\n                }\n                else {\n                    drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);\n                }\n            }\n            else {\n                drawOnImgFromUrlWithCssScaling(url, container, draw, maxSize);\n            }\n        }\n        // container is a canvas, scaling optional\n        else if (isCanvas(container)) {\n            drawOnCanvasOrImgFromUrl(url, container, draw, maxSize);\n        }\n        // container is an img & no scaling: just set the src attr to the passed url\n        else if (registerThumbnailRenderedListener(container, draw)) {\n            container.src = url;\n        }\n\n        return draw;\n    }\n\n    qq.extend(this, {\n        /**\n         * Generate a thumbnail.  Depending on the arguments, this may either result in\n         * a client-side rendering of an image (if a `Blob` is supplied) or a server-generated\n         * image that may optionally be scaled client-side using <canvas> or CSS/styles (as a fallback).\n         *\n         * @param fileBlobOrUrl a `File`, `Blob`, or a URL pointing to the image\n         * @param container <img> or <canvas> to contain the preview\n         * @param options possible properties include `maxSize` (int), `orient` (bool - default true), resize` (bool - default true), and `customResizeFunction`.\n         * @returns qq.Promise fulfilled when the preview has been drawn, or the attempt has failed\n         */\n        generate: function(fileBlobOrUrl, container, options) {\n            if (qq.isString(fileBlobOrUrl)) {\n                log(\"Attempting to update thumbnail based on server response.\");\n                return drawFromUrl(fileBlobOrUrl, container, options || {});\n            }\n            else {\n                log(\"Attempting to draw client-side image preview.\");\n                return draw(fileBlobOrUrl, container, options || {});\n            }\n        }\n    });\n\n    /*<testing>*/\n    this._testing = {};\n    this._testing.isImg = isImg;\n    this._testing.isCanvas = isCanvas;\n    this._testing.isCrossOrigin = isCrossOrigin;\n    this._testing.determineMimeOfFileName = determineMimeOfFileName;\n    /*</testing>*/\n};\n","/*globals qq */\n/**\n * EXIF image data parser.  Currently only parses the Orientation tag value,\n * but this may be expanded to other tags in the future.\n *\n * @param fileOrBlob Attempt to parse EXIF data in this `Blob`\n * @constructor\n */\nqq.Exif = function(fileOrBlob, log) {\n    \"use strict\";\n\n    // Orientation is the only tag parsed here at this time.\n    var TAG_IDS = [274],\n        TAG_INFO = {\n            274: {\n                name: \"Orientation\",\n                bytes: 2\n            }\n        };\n\n    // Convert a little endian (hex string) to big endian (decimal).\n    function parseLittleEndian(hex) {\n        var result = 0,\n            pow = 0;\n\n        while (hex.length > 0) {\n            result += parseInt(hex.substring(0, 2), 16) * Math.pow(2, pow);\n            hex = hex.substring(2, hex.length);\n            pow += 8;\n        }\n\n        return result;\n    }\n\n    // Find the byte offset, of Application Segment 1 (EXIF).\n    // External callers need not supply any arguments.\n    function seekToApp1(offset, promise) {\n        var theOffset = offset,\n            thePromise = promise;\n        if (theOffset === undefined) {\n            theOffset = 2;\n            thePromise = new qq.Promise();\n        }\n\n        qq.readBlobToHex(fileOrBlob, theOffset, 4).then(function(hex) {\n            var match = /^ffe([0-9])/.exec(hex),\n                segmentLength;\n\n            if (match) {\n                if (match[1] !== \"1\") {\n                    segmentLength = parseInt(hex.slice(4, 8), 16);\n                    seekToApp1(theOffset + segmentLength + 2, thePromise);\n                }\n                else {\n                    thePromise.success(theOffset);\n                }\n            }\n            else {\n                thePromise.failure(\"No EXIF header to be found!\");\n            }\n        });\n\n        return thePromise;\n    }\n\n    // Find the byte offset of Application Segment 1 (EXIF) for valid JPEGs only.\n    function getApp1Offset() {\n        var promise = new qq.Promise();\n\n        qq.readBlobToHex(fileOrBlob, 0, 6).then(function(hex) {\n            if (hex.indexOf(\"ffd8\") !== 0) {\n                promise.failure(\"Not a valid JPEG!\");\n            }\n            else {\n                seekToApp1().then(function(offset) {\n                    promise.success(offset);\n                },\n                function(error) {\n                    promise.failure(error);\n                });\n            }\n        });\n\n        return promise;\n    }\n\n    // Determine the byte ordering of the EXIF header.\n    function isLittleEndian(app1Start) {\n        var promise = new qq.Promise();\n\n        qq.readBlobToHex(fileOrBlob, app1Start + 10, 2).then(function(hex) {\n            promise.success(hex === \"4949\");\n        });\n\n        return promise;\n    }\n\n    // Determine the number of directory entries in the EXIF header.\n    function getDirEntryCount(app1Start, littleEndian) {\n        var promise = new qq.Promise();\n\n        qq.readBlobToHex(fileOrBlob, app1Start + 18, 2).then(function(hex) {\n            if (littleEndian) {\n                return promise.success(parseLittleEndian(hex));\n            }\n            else {\n                promise.success(parseInt(hex, 16));\n            }\n        });\n\n        return promise;\n    }\n\n    // Get the IFD portion of the EXIF header as a hex string.\n    function getIfd(app1Start, dirEntries) {\n        var offset = app1Start + 20,\n            bytes = dirEntries * 12;\n\n        return qq.readBlobToHex(fileOrBlob, offset, bytes);\n    }\n\n    // Obtain an array of all directory entries (as hex strings) in the EXIF header.\n    function getDirEntries(ifdHex) {\n        var entries = [],\n            offset = 0;\n\n        while (offset + 24 <= ifdHex.length) {\n            entries.push(ifdHex.slice(offset, offset + 24));\n            offset += 24;\n        }\n\n        return entries;\n    }\n\n    // Obtain values for all relevant tags and return them.\n    function getTagValues(littleEndian, dirEntries) {\n        var TAG_VAL_OFFSET = 16,\n            tagsToFind = qq.extend([], TAG_IDS),\n            vals = {};\n\n        qq.each(dirEntries, function(idx, entry) {\n            var idHex = entry.slice(0, 4),\n                id = littleEndian ? parseLittleEndian(idHex) : parseInt(idHex, 16),\n                tagsToFindIdx = tagsToFind.indexOf(id),\n                tagValHex, tagName, tagValLength;\n\n            if (tagsToFindIdx >= 0) {\n                tagName = TAG_INFO[id].name;\n                tagValLength = TAG_INFO[id].bytes;\n                tagValHex = entry.slice(TAG_VAL_OFFSET, TAG_VAL_OFFSET + (tagValLength * 2));\n                vals[tagName] = littleEndian ? parseLittleEndian(tagValHex) : parseInt(tagValHex, 16);\n\n                tagsToFind.splice(tagsToFindIdx, 1);\n            }\n\n            if (tagsToFind.length === 0) {\n                return false;\n            }\n        });\n\n        return vals;\n    }\n\n    qq.extend(this, {\n        /**\n         * Attempt to parse the EXIF header for the `Blob` associated with this instance.\n         *\n         * @returns {qq.Promise} To be fulfilled when the parsing is complete.\n         * If successful, the parsed EXIF header as an object will be included.\n         */\n        parse: function() {\n            var parser = new qq.Promise(),\n                onParseFailure = function(message) {\n                    log(qq.format(\"EXIF header parse failed: '{}' \", message));\n                    parser.failure(message);\n                };\n\n            getApp1Offset().then(function(app1Offset) {\n                log(qq.format(\"Moving forward with EXIF header parsing for '{}'\", fileOrBlob.name === undefined ? \"blob\" : fileOrBlob.name));\n\n                isLittleEndian(app1Offset).then(function(littleEndian) {\n\n                    log(qq.format(\"EXIF Byte order is {} endian\", littleEndian ? \"little\" : \"big\"));\n\n                    getDirEntryCount(app1Offset, littleEndian).then(function(dirEntryCount) {\n\n                        log(qq.format(\"Found {} APP1 directory entries\", dirEntryCount));\n\n                        getIfd(app1Offset, dirEntryCount).then(function(ifdHex) {\n                            var dirEntries = getDirEntries(ifdHex),\n                                tagValues = getTagValues(littleEndian, dirEntries);\n\n                            log(\"Successfully parsed some EXIF tags\");\n\n                            parser.success(tagValues);\n                        }, onParseFailure);\n                    }, onParseFailure);\n                }, onParseFailure);\n            }, onParseFailure);\n\n            return parser;\n        }\n    });\n\n    /*<testing>*/\n    this._testing = {};\n    this._testing.parseLittleEndian = parseLittleEndian;\n    /*</testing>*/\n};\n","/*globals qq */\nqq.Identify = function(fileOrBlob, log) {\n    \"use strict\";\n\n    function isIdentifiable(magicBytes, questionableBytes) {\n        var identifiable = false,\n            magicBytesEntries = [].concat(magicBytes);\n\n        qq.each(magicBytesEntries, function(idx, magicBytesArrayEntry) {\n            if (questionableBytes.indexOf(magicBytesArrayEntry) === 0) {\n                identifiable = true;\n                return false;\n            }\n        });\n\n        return identifiable;\n    }\n\n    qq.extend(this, {\n        /**\n         * Determines if a Blob can be displayed natively in the current browser.  This is done by reading magic\n         * bytes in the beginning of the file, so this is an asynchronous operation.  Before we attempt to read the\n         * file, we will examine the blob's type attribute to save CPU cycles.\n         *\n         * @returns {qq.Promise} Promise that is fulfilled when identification is complete.\n         * If successful, the MIME string is passed to the success handler.\n         */\n        isPreviewable: function() {\n            var self = this,\n                identifier = new qq.Promise(),\n                previewable = false,\n                name = fileOrBlob.name === undefined ? \"blob\" : fileOrBlob.name;\n\n            log(qq.format(\"Attempting to determine if {} can be rendered in this browser\", name));\n\n            log(\"First pass: check type attribute of blob object.\");\n\n            if (this.isPreviewableSync()) {\n                log(\"Second pass: check for magic bytes in file header.\");\n\n                qq.readBlobToHex(fileOrBlob, 0, 4).then(function(hex) {\n                    qq.each(self.PREVIEWABLE_MIME_TYPES, function(mime, bytes) {\n                        if (isIdentifiable(bytes, hex)) {\n                            // Safari is the only supported browser that can deal with TIFFs natively,\n                            // so, if this is a TIFF and the UA isn't Safari, declare this file \"non-previewable\".\n                            if (mime !== \"image/tiff\" || qq.supportedFeatures.tiffPreviews) {\n                                previewable = true;\n                                identifier.success(mime);\n                            }\n\n                            return false;\n                        }\n                    });\n\n                    log(qq.format(\"'{}' is {} able to be rendered in this browser\", name, previewable ? \"\" : \"NOT\"));\n\n                    if (!previewable) {\n                        identifier.failure();\n                    }\n                },\n                function() {\n                    log(\"Error reading file w/ name '\" + name + \"'.  Not able to be rendered in this browser.\");\n                    identifier.failure();\n                });\n            }\n            else {\n                identifier.failure();\n            }\n\n            return identifier;\n        },\n\n        /**\n         * Determines if a Blob can be displayed natively in the current browser.  This is done by checking the\n         * blob's type attribute.  This is a synchronous operation, useful for situations where an asynchronous operation\n         * would be challenging to support.  Note that the blob's type property is not as accurate as reading the\n         * file's magic bytes.\n         *\n         * @returns {Boolean} true if the blob can be rendered in the current browser\n         */\n        isPreviewableSync: function() {\n            var fileMime = fileOrBlob.type,\n                // Assumption: This will only ever be executed in browsers that support `Object.keys`.\n                isRecognizedImage = qq.indexOf(Object.keys(this.PREVIEWABLE_MIME_TYPES), fileMime) >= 0,\n                previewable = false,\n                name = fileOrBlob.name === undefined ? \"blob\" : fileOrBlob.name;\n\n            if (isRecognizedImage) {\n                if (fileMime === \"image/tiff\") {\n                    previewable = qq.supportedFeatures.tiffPreviews;\n                }\n                else {\n                    previewable = true;\n                }\n            }\n\n            !previewable && log(name + \" is not previewable in this browser per the blob's type attr\");\n\n            return previewable;\n        }\n    });\n};\n\nqq.Identify.prototype.PREVIEWABLE_MIME_TYPES = {\n    \"image/jpeg\": \"ffd8ff\",\n    \"image/gif\": \"474946\",\n    \"image/png\": \"89504e\",\n    \"image/bmp\": \"424d\",\n    \"image/tiff\": [\"49492a00\", \"4d4d002a\"]\n};\n","/*globals qq*/\n/**\n * Attempts to validate an image, wherever possible.\n *\n * @param blob File or Blob representing a user-selecting image.\n * @param log Uses this to post log messages to the console.\n * @constructor\n */\nqq.ImageValidation = function(blob, log) {\n    \"use strict\";\n\n    /**\n     * @param limits Object with possible image-related limits to enforce.\n     * @returns {boolean} true if at least one of the limits has a non-zero value\n     */\n    function hasNonZeroLimits(limits) {\n        var atLeastOne = false;\n\n        qq.each(limits, function(limit, value) {\n            if (value > 0) {\n                atLeastOne = true;\n                return false;\n            }\n        });\n\n        return atLeastOne;\n    }\n\n    /**\n     * @returns {qq.Promise} The promise is a failure if we can't obtain the width & height.\n     * Otherwise, `success` is called on the returned promise with an object containing\n     * `width` and `height` properties.\n     */\n    function getWidthHeight() {\n        var sizeDetermination = new qq.Promise();\n\n        new qq.Identify(blob, log).isPreviewable().then(function() {\n            var image = new Image(),\n                url = window.URL && window.URL.createObjectURL ? window.URL :\n                      window.webkitURL && window.webkitURL.createObjectURL ? window.webkitURL :\n                      null;\n\n            if (url) {\n                image.onerror = function() {\n                    log(\"Cannot determine dimensions for image.  May be too large.\", \"error\");\n                    sizeDetermination.failure();\n                };\n\n                image.onload = function() {\n                    sizeDetermination.success({\n                        width: this.width,\n                        height: this.height\n                    });\n                };\n\n                image.src = url.createObjectURL(blob);\n            }\n            else {\n                log(\"No createObjectURL function available to generate image URL!\", \"error\");\n                sizeDetermination.failure();\n            }\n        }, sizeDetermination.failure);\n\n        return sizeDetermination;\n    }\n\n    /**\n     *\n     * @param limits Object with possible image-related limits to enforce.\n     * @param dimensions Object containing `width` & `height` properties for the image to test.\n     * @returns {String || undefined} The name of the failing limit.  Undefined if no failing limits.\n     */\n    function getFailingLimit(limits, dimensions) {\n        var failingLimit;\n\n        qq.each(limits, function(limitName, limitValue) {\n            if (limitValue > 0) {\n                var limitMatcher = /(max|min)(Width|Height)/.exec(limitName),\n                    dimensionPropName = limitMatcher[2].charAt(0).toLowerCase() + limitMatcher[2].slice(1),\n                    actualValue = dimensions[dimensionPropName];\n\n                /*jshint -W015*/\n                switch (limitMatcher[1]) {\n                    case \"min\":\n                        if (actualValue < limitValue) {\n                            failingLimit = limitName;\n                            return false;\n                        }\n                        break;\n                    case \"max\":\n                        if (actualValue > limitValue) {\n                            failingLimit = limitName;\n                            return false;\n                        }\n                        break;\n                }\n            }\n        });\n\n        return failingLimit;\n    }\n\n    /**\n     * Validate the associated blob.\n     *\n     * @param limits\n     * @returns {qq.Promise} `success` is called on the promise is the image is valid or\n     * if the blob is not an image, or if the image is not verifiable.\n     * Otherwise, `failure` with the name of the failing limit.\n     */\n    this.validate = function(limits) {\n        var validationEffort = new qq.Promise();\n\n        log(\"Attempting to validate image.\");\n\n        if (hasNonZeroLimits(limits)) {\n            getWidthHeight().then(function(dimensions) {\n                var failingLimit = getFailingLimit(limits, dimensions);\n\n                if (failingLimit) {\n                    validationEffort.failure(failingLimit);\n                }\n                else {\n                    validationEffort.success();\n                }\n            }, validationEffort.success);\n        }\n        else {\n            validationEffort.success();\n        }\n\n        return validationEffort;\n    };\n};\n","/* globals qq */\n/**\n * Module used to control populating the initial list of files.\n *\n * @constructor\n */\nqq.Session = function(spec) {\n    \"use strict\";\n\n    var options = {\n        endpoint: null,\n        params: {},\n        customHeaders: {},\n        cors: {},\n        addFileRecord: function(sessionData) {},\n        log: function(message, level) {}\n    };\n\n    qq.extend(options, spec, true);\n\n    function isJsonResponseValid(response) {\n        if (qq.isArray(response)) {\n            return true;\n        }\n\n        options.log(\"Session response is not an array.\", \"error\");\n    }\n\n    function handleFileItems(fileItems, success, xhrOrXdr, promise) {\n        var someItemsIgnored = false;\n\n        success = success && isJsonResponseValid(fileItems);\n\n        if (success) {\n            qq.each(fileItems, function(idx, fileItem) {\n                /* jshint eqnull:true */\n                if (fileItem.uuid == null) {\n                    someItemsIgnored = true;\n                    options.log(qq.format(\"Session response item {} did not include a valid UUID - ignoring.\", idx), \"error\");\n                }\n                else if (fileItem.name == null) {\n                    someItemsIgnored = true;\n                    options.log(qq.format(\"Session response item {} did not include a valid name - ignoring.\", idx), \"error\");\n                }\n                else {\n                    try {\n                        options.addFileRecord(fileItem);\n                        return true;\n                    }\n                    catch (err) {\n                        someItemsIgnored = true;\n                        options.log(err.message, \"error\");\n                    }\n                }\n\n                return false;\n            });\n        }\n\n        promise[success && !someItemsIgnored ? \"success\" : \"failure\"](fileItems, xhrOrXdr);\n    }\n\n    // Initiate a call to the server that will be used to populate the initial file list.\n    // Returns a `qq.Promise`.\n    this.refresh = function() {\n        /*jshint indent:false */\n        var refreshEffort = new qq.Promise(),\n            refreshCompleteCallback = function(response, success, xhrOrXdr) {\n                handleFileItems(response, success, xhrOrXdr, refreshEffort);\n            },\n            requesterOptions = qq.extend({}, options),\n            requester = new qq.SessionAjaxRequester(\n                qq.extend(requesterOptions, {onComplete: refreshCompleteCallback})\n            );\n\n        requester.queryServer();\n\n        return refreshEffort;\n    };\n};\n","/*globals qq, XMLHttpRequest*/\n/**\n * Thin module used to send GET requests to the server, expecting information about session\n * data used to initialize an uploader instance.\n *\n * @param spec Various options used to influence the associated request.\n * @constructor\n */\nqq.SessionAjaxRequester = function(spec) {\n    \"use strict\";\n\n    var requester,\n        options = {\n            endpoint: null,\n            customHeaders: {},\n            params: {},\n            cors: {\n                expected: false,\n                sendCredentials: false\n            },\n            onComplete: function(response, success, xhrOrXdr) {},\n            log: function(str, level) {}\n        };\n\n    qq.extend(options, spec);\n\n    function onComplete(id, xhrOrXdr, isError) {\n        var response = null;\n\n        /* jshint eqnull:true */\n        if (xhrOrXdr.responseText != null) {\n            try {\n                response = qq.parseJson(xhrOrXdr.responseText);\n            }\n            catch (err) {\n                options.log(\"Problem parsing session response: \" + err.message, \"error\");\n                isError = true;\n            }\n        }\n\n        options.onComplete(response, !isError, xhrOrXdr);\n    }\n\n    requester = qq.extend(this, new qq.AjaxRequester({\n        acceptHeader: \"application/json\",\n        validMethods: [\"GET\"],\n        method: \"GET\",\n        endpointStore: {\n            get: function() {\n                return options.endpoint;\n            }\n        },\n        customHeaders: options.customHeaders,\n        log: options.log,\n        onComplete: onComplete,\n        cors: options.cors\n    }));\n\n    qq.extend(this, {\n        queryServer: function() {\n            var params = qq.extend({}, options.params);\n\n            options.log(\"Session query request.\");\n\n            requester.initTransport(\"sessionRefresh\")\n                .withParams(params)\n                .withCacheBuster()\n                .send();\n        }\n    });\n};\n","/* globals qq, ExifRestorer */\n/**\n * Controls generation of scaled images based on a reference image encapsulated in a `File` or `Blob`.\n * Scaled images are generated and converted to blobs on-demand.\n * Multiple scaled images per reference image with varying sizes and other properties are supported.\n *\n * @param spec Information about the scaled images to generate.\n * @param log Logger instance\n * @constructor\n */\nqq.Scaler = function(spec, log) {\n    \"use strict\";\n\n    var self = this,\n        customResizeFunction = spec.customResizer,\n        includeOriginal = spec.sendOriginal,\n        orient = spec.orient,\n        defaultType = spec.defaultType,\n        defaultQuality = spec.defaultQuality / 100,\n        failedToScaleText = spec.failureText,\n        includeExif = spec.includeExif,\n        sizes = this._getSortedSizes(spec.sizes);\n\n    // Revealed API for instances of this module\n    qq.extend(this, {\n        // If no targeted sizes have been declared or if this browser doesn't support\n        // client-side image preview generation, there is no scaling to do.\n        enabled: qq.supportedFeatures.scaling && sizes.length > 0,\n\n        getFileRecords: function(originalFileUuid, originalFileName, originalBlobOrBlobData) {\n            var self = this,\n                records = [],\n                originalBlob = originalBlobOrBlobData.blob ? originalBlobOrBlobData.blob : originalBlobOrBlobData,\n                identifier = new qq.Identify(originalBlob, log);\n\n            // If the reference file cannot be rendered natively, we can't create scaled versions.\n            if (identifier.isPreviewableSync()) {\n                // Create records for each scaled version & add them to the records array, smallest first.\n                qq.each(sizes, function(idx, sizeRecord) {\n                    var outputType = self._determineOutputType({\n                        defaultType: defaultType,\n                        requestedType: sizeRecord.type,\n                        refType: originalBlob.type\n                    });\n\n                    records.push({\n                        uuid: qq.getUniqueId(),\n                        name: self._getName(originalFileName, {\n                            name: sizeRecord.name,\n                            type: outputType,\n                            refType: originalBlob.type\n                        }),\n                        blob: new qq.BlobProxy(originalBlob,\n                        qq.bind(self._generateScaledImage, self, {\n                            customResizeFunction: customResizeFunction,\n                            maxSize: sizeRecord.maxSize,\n                            orient: orient,\n                            type: outputType,\n                            quality: defaultQuality,\n                            failedText: failedToScaleText,\n                            includeExif: includeExif,\n                            log: log\n                        }))\n                    });\n                });\n\n                records.push({\n                    uuid: originalFileUuid,\n                    name: originalFileName,\n                    size: originalBlob.size,\n                    blob: includeOriginal ? originalBlob : null\n                });\n            }\n            else {\n                records.push({\n                    uuid: originalFileUuid,\n                    name: originalFileName,\n                    size: originalBlob.size,\n                    blob: originalBlob\n                });\n            }\n\n            return records;\n        },\n\n        handleNewFile: function(file, name, uuid, size, fileList, batchId, uuidParamName, api) {\n            var self = this,\n                buttonId = file.qqButtonId || (file.blob && file.blob.qqButtonId),\n                scaledIds = [],\n                originalId = null,\n                addFileToHandler = api.addFileToHandler,\n                uploadData = api.uploadData,\n                paramsStore = api.paramsStore,\n                proxyGroupId = qq.getUniqueId();\n\n            qq.each(self.getFileRecords(uuid, name, file), function(idx, record) {\n                var blobSize = record.size,\n                    id;\n\n                if (record.blob instanceof qq.BlobProxy) {\n                    blobSize = -1;\n                }\n\n                id = uploadData.addFile({\n                    uuid: record.uuid,\n                    name: record.name,\n                    size: blobSize,\n                    batchId: batchId,\n                    proxyGroupId: proxyGroupId\n                });\n\n                if (record.blob instanceof qq.BlobProxy) {\n                    scaledIds.push(id);\n                }\n                else {\n                    originalId = id;\n                }\n\n                if (record.blob) {\n                    addFileToHandler(id, record.blob);\n                    fileList.push({id: id, file: record.blob});\n                }\n                else {\n                    uploadData.setStatus(id, qq.status.REJECTED);\n                }\n            });\n\n            // If we are potentially uploading an original file and some scaled versions,\n            // ensure the scaled versions include reference's to the parent's UUID and size\n            // in their associated upload requests.\n            if (originalId !== null) {\n                qq.each(scaledIds, function(idx, scaledId) {\n                    var params = {\n                        qqparentuuid: uploadData.retrieve({id: originalId}).uuid,\n                        qqparentsize: uploadData.retrieve({id: originalId}).size\n                    };\n\n                    // Make sure the UUID for each scaled image is sent with the upload request,\n                    // to be consistent (since we may need to ensure it is sent for the original file as well).\n                    params[uuidParamName] = uploadData.retrieve({id: scaledId}).uuid;\n\n                    uploadData.setParentId(scaledId, originalId);\n                    paramsStore.addReadOnly(scaledId, params);\n                });\n\n                // If any scaled images are tied to this parent image, be SURE we send its UUID as an upload request\n                // parameter as well.\n                if (scaledIds.length) {\n                    (function() {\n                        var param = {};\n                        param[uuidParamName] = uploadData.retrieve({id: originalId}).uuid;\n                        paramsStore.addReadOnly(originalId, param);\n                    }());\n                }\n            }\n        }\n    });\n};\n\nqq.extend(qq.Scaler.prototype, {\n    scaleImage: function(id, specs, api) {\n        \"use strict\";\n\n        if (!qq.supportedFeatures.scaling) {\n            throw new qq.Error(\"Scaling is not supported in this browser!\");\n        }\n\n        var scalingEffort = new qq.Promise(),\n            log = api.log,\n            file = api.getFile(id),\n            uploadData = api.uploadData.retrieve({id: id}),\n            name = uploadData && uploadData.name,\n            uuid = uploadData && uploadData.uuid,\n            scalingOptions = {\n                customResizer: specs.customResizer,\n                sendOriginal: false,\n                orient: specs.orient,\n                defaultType: specs.type || null,\n                defaultQuality: specs.quality,\n                failedToScaleText: \"Unable to scale\",\n                sizes: [{name: \"\", maxSize: specs.maxSize}]\n            },\n            scaler = new qq.Scaler(scalingOptions, log);\n\n        if (!qq.Scaler || !qq.supportedFeatures.imagePreviews || !file) {\n            scalingEffort.failure();\n\n            log(\"Could not generate requested scaled image for \" + id + \".  \" +\n                \"Scaling is either not possible in this browser, or the file could not be located.\", \"error\");\n        }\n        else {\n            (qq.bind(function() {\n                // Assumption: There will never be more than one record\n                var record = scaler.getFileRecords(uuid, name, file)[0];\n\n                if (record && record.blob instanceof qq.BlobProxy) {\n                    record.blob.create().then(scalingEffort.success, scalingEffort.failure);\n                }\n                else {\n                    log(id + \" is not a scalable image!\", \"error\");\n                    scalingEffort.failure();\n                }\n            }, this)());\n        }\n\n        return scalingEffort;\n    },\n\n    // NOTE: We cannot reliably determine at this time if the UA supports a specific MIME type for the target format.\n    // image/jpeg and image/png are the only safe choices at this time.\n    _determineOutputType: function(spec) {\n        \"use strict\";\n\n        var requestedType = spec.requestedType,\n            defaultType = spec.defaultType,\n            referenceType = spec.refType;\n\n        // If a default type and requested type have not been specified, this should be a\n        // JPEG if the original type is a JPEG, otherwise, a PNG.\n        if (!defaultType && !requestedType) {\n            if (referenceType !== \"image/jpeg\") {\n                return \"image/png\";\n            }\n            return referenceType;\n        }\n\n        // A specified default type is used when a requested type is not specified.\n        if (!requestedType) {\n            return defaultType;\n        }\n\n        // If requested type is specified, use it, as long as this recognized type is supported by the current UA\n        if (qq.indexOf(Object.keys(qq.Identify.prototype.PREVIEWABLE_MIME_TYPES), requestedType) >= 0) {\n            if (requestedType === \"image/tiff\") {\n                return qq.supportedFeatures.tiffPreviews ? requestedType : defaultType;\n            }\n\n            return requestedType;\n        }\n\n        return defaultType;\n    },\n\n    // Get a file name for a generated scaled file record, based on the provided scaled image description\n    _getName: function(originalName, scaledVersionProperties) {\n        \"use strict\";\n\n        var startOfExt = originalName.lastIndexOf(\".\"),\n            versionType = scaledVersionProperties.type || \"image/png\",\n            referenceType = scaledVersionProperties.refType,\n            scaledName = \"\",\n            scaledExt = qq.getExtension(originalName),\n            nameAppendage = \"\";\n\n        if (scaledVersionProperties.name && scaledVersionProperties.name.trim().length) {\n            nameAppendage = \" (\" + scaledVersionProperties.name + \")\";\n        }\n\n        if (startOfExt >= 0) {\n            scaledName = originalName.substr(0, startOfExt);\n\n            if (referenceType !== versionType) {\n                scaledExt = versionType.split(\"/\")[1];\n            }\n\n            scaledName += nameAppendage + \".\" + scaledExt;\n        }\n        else {\n            scaledName = originalName + nameAppendage;\n        }\n\n        return scaledName;\n    },\n\n    // We want the smallest scaled file to be uploaded first\n    _getSortedSizes: function(sizes) {\n        \"use strict\";\n\n        sizes = qq.extend([], sizes);\n\n        return sizes.sort(function(a, b) {\n            if (a.maxSize > b.maxSize) {\n                return 1;\n            }\n            if (a.maxSize < b.maxSize) {\n                return -1;\n            }\n            return 0;\n        });\n    },\n\n    _generateScaledImage: function(spec, sourceFile) {\n        \"use strict\";\n\n        var self = this,\n            customResizeFunction = spec.customResizeFunction,\n            log = spec.log,\n            maxSize = spec.maxSize,\n            orient = spec.orient,\n            type = spec.type,\n            quality = spec.quality,\n            failedText = spec.failedText,\n            includeExif = spec.includeExif && sourceFile.type === \"image/jpeg\" && type === \"image/jpeg\",\n            scalingEffort = new qq.Promise(),\n            imageGenerator = new qq.ImageGenerator(log),\n            canvas = document.createElement(\"canvas\");\n\n        log(\"Attempting to generate scaled version for \" + sourceFile.name);\n\n        imageGenerator.generate(sourceFile, canvas, {maxSize: maxSize, orient: orient, customResizeFunction: customResizeFunction}).then(function() {\n            var scaledImageDataUri = canvas.toDataURL(type, quality),\n                signalSuccess = function() {\n                    log(\"Success generating scaled version for \" + sourceFile.name);\n                    var blob = qq.dataUriToBlob(scaledImageDataUri);\n                    scalingEffort.success(blob);\n                };\n\n            if (includeExif) {\n                self._insertExifHeader(sourceFile, scaledImageDataUri, log).then(function(scaledImageDataUriWithExif) {\n                    scaledImageDataUri = scaledImageDataUriWithExif;\n                    signalSuccess();\n                },\n                function() {\n                    log(\"Problem inserting EXIF header into scaled image.  Using scaled image w/out EXIF data.\", \"error\");\n                    signalSuccess();\n                });\n            }\n            else {\n                signalSuccess();\n            }\n        }, function() {\n            log(\"Failed attempt to generate scaled version for \" + sourceFile.name, \"error\");\n            scalingEffort.failure(failedText);\n        });\n\n        return scalingEffort;\n    },\n\n    // Attempt to insert the original image's EXIF header into a scaled version.\n    _insertExifHeader: function(originalImage, scaledImageDataUri, log) {\n        \"use strict\";\n\n        var reader = new FileReader(),\n            insertionEffort = new qq.Promise(),\n            originalImageDataUri = \"\";\n\n        reader.onload = function() {\n            originalImageDataUri = reader.result;\n            insertionEffort.success(qq.ExifRestorer.restore(originalImageDataUri, scaledImageDataUri));\n        };\n\n        reader.onerror = function() {\n            log(\"Problem reading \" + originalImage.name + \" during attempt to transfer EXIF data to scaled version.\", \"error\");\n            insertionEffort.failure();\n        };\n\n        reader.readAsDataURL(originalImage);\n\n        return insertionEffort;\n    },\n\n    _dataUriToBlob: function(dataUri) {\n        \"use strict\";\n\n        var byteString, mimeString, arrayBuffer, intArray;\n\n        // convert base64 to raw binary data held in a string\n        if (dataUri.split(\",\")[0].indexOf(\"base64\") >= 0) {\n            byteString = atob(dataUri.split(\",\")[1]);\n        }\n        else {\n            byteString = decodeURI(dataUri.split(\",\")[1]);\n        }\n\n        // extract the MIME\n        mimeString = dataUri.split(\",\")[0]\n            .split(\":\")[1]\n            .split(\";\")[0];\n\n        // write the bytes of the binary string to an ArrayBuffer\n        arrayBuffer = new ArrayBuffer(byteString.length);\n        intArray = new Uint8Array(arrayBuffer);\n        qq.each(byteString, function(idx, character) {\n            intArray[idx] = character.charCodeAt(0);\n        });\n\n        return this._createBlob(arrayBuffer, mimeString);\n    },\n\n    _createBlob: function(data, mime) {\n        \"use strict\";\n\n        var BlobBuilder = window.BlobBuilder ||\n                window.WebKitBlobBuilder ||\n                window.MozBlobBuilder ||\n                window.MSBlobBuilder,\n            blobBuilder = BlobBuilder && new BlobBuilder();\n\n        if (blobBuilder) {\n            blobBuilder.append(data);\n            return blobBuilder.getBlob(mime);\n        }\n        else {\n            return new Blob([data], {type: mime});\n        }\n    }\n});\n","//Based on MinifyJpeg\n//http://elicon.blog57.fc2.com/blog-entry-206.html\n\nqq.ExifRestorer = (function()\n{\n   \n\tvar ExifRestorer = {};\n\t \n    ExifRestorer.KEY_STR = \"ABCDEFGHIJKLMNOP\" +\n                         \"QRSTUVWXYZabcdef\" +\n                         \"ghijklmnopqrstuv\" +\n                         \"wxyz0123456789+/\" +\n                         \"=\";\n\n    ExifRestorer.encode64 = function(input)\n    {\n        var output = \"\",\n            chr1, chr2, chr3 = \"\",\n            enc1, enc2, enc3, enc4 = \"\",\n            i = 0;\n\n        do {\n            chr1 = input[i++];\n            chr2 = input[i++];\n            chr3 = input[i++];\n\n            enc1 = chr1 >> 2;\n            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);\n            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);\n            enc4 = chr3 & 63;\n\n            if (isNaN(chr2)) {\n               enc3 = enc4 = 64;\n            } else if (isNaN(chr3)) {\n               enc4 = 64;\n            }\n\n            output = output +\n               this.KEY_STR.charAt(enc1) +\n               this.KEY_STR.charAt(enc2) +\n               this.KEY_STR.charAt(enc3) +\n               this.KEY_STR.charAt(enc4);\n            chr1 = chr2 = chr3 = \"\";\n            enc1 = enc2 = enc3 = enc4 = \"\";\n        } while (i < input.length);\n\n        return output;\n    };\n    \n    ExifRestorer.restore = function(origFileBase64, resizedFileBase64)\n    {\n        var expectedBase64Header = \"data:image/jpeg;base64,\";\n\n        if (!origFileBase64.match(expectedBase64Header))\n        {\n        \treturn resizedFileBase64;\n        }       \n        \n        var rawImage = this.decode64(origFileBase64.replace(expectedBase64Header, \"\"));\n        var segments = this.slice2Segments(rawImage);\n                \n        var image = this.exifManipulation(resizedFileBase64, segments);\n        \n        return expectedBase64Header + this.encode64(image);\n        \n    };\n\n\n    ExifRestorer.exifManipulation = function(resizedFileBase64, segments)\n    {\n            var exifArray = this.getExifArray(segments),\n                newImageArray = this.insertExif(resizedFileBase64, exifArray),\n                aBuffer = new Uint8Array(newImageArray);\n\n            return aBuffer;\n    };\n\n\n    ExifRestorer.getExifArray = function(segments)\n    {\n            var seg;\n            for (var x = 0; x < segments.length; x++)\n            {\n                seg = segments[x];\n                if (seg[0] == 255 & seg[1] == 225) //(ff e1)\n                {\n                    return seg;\n                }\n            }\n            return [];\n    };\n\n\n    ExifRestorer.insertExif = function(resizedFileBase64, exifArray)\n    {\n            var imageData = resizedFileBase64.replace(\"data:image/jpeg;base64,\", \"\"),\n                buf = this.decode64(imageData),\n                separatePoint = buf.indexOf(255,3),\n                mae = buf.slice(0, separatePoint),\n                ato = buf.slice(separatePoint),\n                array = mae;\n\n            array = array.concat(exifArray);\n            array = array.concat(ato);\n           return array;\n    };\n\n\n    \n    ExifRestorer.slice2Segments = function(rawImageArray)\n    {\n        var head = 0,\n            segments = [];\n\n        while (1)\n        {\n            if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 218){break;}\n            if (rawImageArray[head] == 255 & rawImageArray[head + 1] == 216)\n            {\n                head += 2;\n            }\n            else\n            {\n                var length = rawImageArray[head + 2] * 256 + rawImageArray[head + 3],\n                    endPoint = head + length + 2,\n                    seg = rawImageArray.slice(head, endPoint);\n                segments.push(seg);\n                head = endPoint;\n            }\n            if (head > rawImageArray.length){break;}\n        }\n\n        return segments;\n    };\n\n\n    \n    ExifRestorer.decode64 = function(input) \n    {\n        var output = \"\",\n            chr1, chr2, chr3 = \"\",\n            enc1, enc2, enc3, enc4 = \"\",\n            i = 0,\n            buf = [];\n\n        // remove all characters that are not A-Z, a-z, 0-9, +, /, or =\n        var base64test = /[^A-Za-z0-9\\+\\/\\=]/g;\n        if (base64test.exec(input)) {\n            throw new Error(\"There were invalid base64 characters in the input text.  \" +\n                \"Valid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='\");\n        }\n        input = input.replace(/[^A-Za-z0-9\\+\\/\\=]/g, \"\");\n\n        do {\n            enc1 = this.KEY_STR.indexOf(input.charAt(i++));\n            enc2 = this.KEY_STR.indexOf(input.charAt(i++));\n            enc3 = this.KEY_STR.indexOf(input.charAt(i++));\n            enc4 = this.KEY_STR.indexOf(input.charAt(i++));\n\n            chr1 = (enc1 << 2) | (enc2 >> 4);\n            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);\n            chr3 = ((enc3 & 3) << 6) | enc4;\n\n            buf.push(chr1);\n\n            if (enc3 != 64) {\n               buf.push(chr2);\n            }\n            if (enc4 != 64) {\n               buf.push(chr3);\n            }\n\n            chr1 = chr2 = chr3 = \"\";\n            enc1 = enc2 = enc3 = enc4 = \"\";\n\n        } while (i < input.length);\n\n        return buf;\n    };\n\n    \n    return ExifRestorer;\n})();\n","/* globals qq */\n/**\n * Keeps a running tally of total upload progress for a batch of files.\n *\n * @param callback Invoked when total progress changes, passing calculated total loaded & total size values.\n * @param getSize Function that returns the size of a file given its ID\n * @constructor\n */\nqq.TotalProgress = function(callback, getSize) {\n    \"use strict\";\n\n    var perFileProgress = {},\n        totalLoaded = 0,\n        totalSize = 0,\n\n        lastLoadedSent = -1,\n        lastTotalSent = -1,\n        callbackProxy = function(loaded, total) {\n            if (loaded !== lastLoadedSent || total !== lastTotalSent) {\n                callback(loaded, total);\n            }\n\n            lastLoadedSent = loaded;\n            lastTotalSent = total;\n        },\n\n        /**\n         * @param failed Array of file IDs that have failed\n         * @param retryable Array of file IDs that are retryable\n         * @returns true if none of the failed files are eligible for retry\n         */\n        noRetryableFiles = function(failed, retryable) {\n            var none = true;\n\n            qq.each(failed, function(idx, failedId) {\n                if (qq.indexOf(retryable, failedId) >= 0) {\n                    none = false;\n                    return false;\n                }\n            });\n\n            return none;\n        },\n\n        onCancel = function(id) {\n            updateTotalProgress(id, -1, -1);\n            delete perFileProgress[id];\n        },\n\n        onAllComplete = function(successful, failed, retryable) {\n            if (failed.length === 0 || noRetryableFiles(failed, retryable)) {\n                callbackProxy(totalSize, totalSize);\n                this.reset();\n            }\n        },\n\n        onNew = function(id) {\n            var size = getSize(id);\n\n            // We might not know the size yet, such as for blob proxies\n            if (size > 0) {\n                updateTotalProgress(id, 0, size);\n                perFileProgress[id] = {loaded: 0, total: size};\n            }\n        },\n\n        /**\n         * Invokes the callback with the current total progress of all files in the batch.  Called whenever it may\n         * be appropriate to re-calculate and disseminate this data.\n         *\n         * @param id ID of a file that has changed in some important way\n         * @param newLoaded New loaded value for this file.  -1 if this value should no longer be part of calculations\n         * @param newTotal New total size of the file.  -1 if this value should no longer be part of calculations\n         */\n        updateTotalProgress = function(id, newLoaded, newTotal) {\n            var oldLoaded = perFileProgress[id] ? perFileProgress[id].loaded : 0,\n                oldTotal = perFileProgress[id] ? perFileProgress[id].total : 0;\n\n            if (newLoaded === -1 && newTotal === -1) {\n                totalLoaded -= oldLoaded;\n                totalSize -= oldTotal;\n            }\n            else {\n                if (newLoaded) {\n                    totalLoaded += newLoaded - oldLoaded;\n                }\n                if (newTotal) {\n                    totalSize += newTotal - oldTotal;\n                }\n            }\n\n            callbackProxy(totalLoaded, totalSize);\n        };\n\n    qq.extend(this, {\n        // Called when a batch of files has completed uploading.\n        onAllComplete: onAllComplete,\n\n        // Called when the status of a file has changed.\n        onStatusChange: function(id, oldStatus, newStatus) {\n            if (newStatus === qq.status.CANCELED || newStatus === qq.status.REJECTED) {\n                onCancel(id);\n            }\n            else if (newStatus === qq.status.SUBMITTING) {\n                onNew(id);\n            }\n        },\n\n        // Called whenever the upload progress of an individual file has changed.\n        onIndividualProgress: function(id, loaded, total) {\n            updateTotalProgress(id, loaded, total);\n            perFileProgress[id] = {loaded: loaded, total: total};\n        },\n\n        // Called whenever the total size of a file has changed, such as when the size of a generated blob is known.\n        onNewSize: function(id) {\n            onNew(id);\n        },\n\n        reset: function() {\n            perFileProgress = {};\n            totalLoaded = 0;\n            totalSize = 0;\n        }\n    });\n};\n","/*globals qq*/\nqq.PasteSupport = function(o) {\n    \"use strict\";\n\n    var options, detachPasteHandler;\n\n    options = {\n        targetElement: null,\n        callbacks: {\n            log: function(message, level) {},\n            pasteReceived: function(blob) {}\n        }\n    };\n\n    function isImage(item) {\n        return item.type &&\n            item.type.indexOf(\"image/\") === 0;\n    }\n\n    function registerPasteHandler() {\n        detachPasteHandler = qq(options.targetElement).attach(\"paste\", function(event) {\n            var clipboardData = event.clipboardData;\n\n            if (clipboardData) {\n                qq.each(clipboardData.items, function(idx, item) {\n                    if (isImage(item)) {\n                        var blob = item.getAsFile();\n                        options.callbacks.pasteReceived(blob);\n                    }\n                });\n            }\n        });\n    }\n\n    function unregisterPasteHandler() {\n        if (detachPasteHandler) {\n            detachPasteHandler();\n        }\n    }\n\n    qq.extend(options, o);\n    registerPasteHandler();\n\n    qq.extend(this, {\n        reset: function() {\n            unregisterPasteHandler();\n        }\n    });\n};\n","/* globals qq */\n/**\n * Module that handles support for existing forms.\n *\n * @param options Options passed from the integrator-supplied options related to form support.\n * @param startUpload Callback to invoke when files \"stored\" should be uploaded.\n * @param log Proxy for the logger\n * @constructor\n */\nqq.FormSupport = function(options, startUpload, log) {\n    \"use strict\";\n    var self  = this,\n        interceptSubmit = options.interceptSubmit,\n        formEl = options.element,\n        autoUpload = options.autoUpload;\n\n    // Available on the public API associated with this module.\n    qq.extend(this, {\n        // To be used by the caller to determine if the endpoint will be determined by some processing\n        // that occurs in this module, such as if the form has an action attribute.\n        // Ignore if `attachToForm === false`.\n        newEndpoint: null,\n\n        // To be used by the caller to determine if auto uploading should be allowed.\n        // Ignore if `attachToForm === false`.\n        newAutoUpload: autoUpload,\n\n        // true if a form was detected and is being tracked by this module\n        attachedToForm: false,\n\n        // Returns an object with names and values for all valid form elements associated with the attached form.\n        getFormInputsAsObject: function() {\n            /* jshint eqnull:true */\n            if (formEl == null) {\n                return null;\n            }\n\n            return self._form2Obj(formEl);\n        }\n    });\n\n    // If the form contains an action attribute, this should be the new upload endpoint.\n    function determineNewEndpoint(formEl) {\n        if (formEl.getAttribute(\"action\")) {\n            self.newEndpoint = formEl.getAttribute(\"action\");\n        }\n    }\n\n    // Return true only if the form is valid, or if we cannot make this determination.\n    // If the form is invalid, ensure invalid field(s) are highlighted in the UI.\n    function validateForm(formEl, nativeSubmit) {\n        if (formEl.checkValidity && !formEl.checkValidity()) {\n            log(\"Form did not pass validation checks - will not upload.\", \"error\");\n            nativeSubmit();\n        }\n        else {\n            return true;\n        }\n    }\n\n    // Intercept form submit attempts, unless the integrator has told us not to do this.\n    function maybeUploadOnSubmit(formEl) {\n        var nativeSubmit = formEl.submit;\n\n        // Intercept and squelch submit events.\n        qq(formEl).attach(\"submit\", function(event) {\n            event = event || window.event;\n\n            if (event.preventDefault) {\n                event.preventDefault();\n            }\n            else {\n                event.returnValue = false;\n            }\n\n            validateForm(formEl, nativeSubmit) && startUpload();\n        });\n\n        // The form's `submit()` function may be called instead (i.e. via jQuery.submit()).\n        // Intercept that too.\n        formEl.submit = function() {\n            validateForm(formEl, nativeSubmit) && startUpload();\n        };\n    }\n\n    // If the element value passed from the uploader is a string, assume it is an element ID - select it.\n    // The rest of the code in this module depends on this being an HTMLElement.\n    function determineFormEl(formEl) {\n        if (formEl) {\n            if (qq.isString(formEl)) {\n                formEl = document.getElementById(formEl);\n            }\n\n            if (formEl) {\n                log(\"Attaching to form element.\");\n                determineNewEndpoint(formEl);\n                interceptSubmit && maybeUploadOnSubmit(formEl);\n            }\n        }\n\n        return formEl;\n    }\n\n    formEl = determineFormEl(formEl);\n    this.attachedToForm = !!formEl;\n};\n\nqq.extend(qq.FormSupport.prototype, {\n    // Converts all relevant form fields to key/value pairs.  This is meant to mimic the data a browser will\n    // construct from a given form when the form is submitted.\n    _form2Obj: function(form) {\n        \"use strict\";\n        var obj = {},\n            notIrrelevantType = function(type) {\n                var irrelevantTypes = [\n                    \"button\",\n                    \"image\",\n                    \"reset\",\n                    \"submit\"\n                ];\n\n                return qq.indexOf(irrelevantTypes, type.toLowerCase()) < 0;\n            },\n            radioOrCheckbox = function(type) {\n                return qq.indexOf([\"checkbox\", \"radio\"], type.toLowerCase()) >= 0;\n            },\n            ignoreValue = function(el) {\n                if (radioOrCheckbox(el.type) && !el.checked) {\n                    return true;\n                }\n\n                return el.disabled && el.type.toLowerCase() !== \"hidden\";\n            },\n            selectValue = function(select) {\n                var value = null;\n\n                qq.each(qq(select).children(), function(idx, child) {\n                    if (child.tagName.toLowerCase() === \"option\" && child.selected) {\n                        value = child.value;\n                        return false;\n                    }\n                });\n\n                return value;\n            };\n\n        qq.each(form.elements, function(idx, el) {\n            if ((qq.isInput(el, true) || el.tagName.toLowerCase() === \"textarea\") &&\n                notIrrelevantType(el.type) &&\n                !ignoreValue(el)) {\n\n                obj[el.name] = el.value;\n            }\n            else if (el.tagName.toLowerCase() === \"select\" && !ignoreValue(el)) {\n                var value = selectValue(el);\n\n                if (value !== null) {\n                    obj[el.name] = value;\n                }\n            }\n        });\n\n        return obj;\n    }\n});\n","/*globals qq*/\n/**\n * Upload handler used that assumes the current user agent does not have any support for the\n * File API, and, therefore, makes use of iframes and forms to submit the files directly to\n * a generic server.\n *\n * @param options Options passed from the base handler\n * @param proxy Callbacks & methods used to query for or push out data/changes\n */\nqq.traditional = qq.traditional || {};\nqq.traditional.FormUploadHandler = function(options, proxy) {\n    \"use strict\";\n\n    var handler = this,\n        getName = proxy.getName,\n        getUuid = proxy.getUuid,\n        log = proxy.log;\n\n    /**\n     * Returns json object received by iframe from server.\n     */\n    function getIframeContentJson(id, iframe) {\n        /*jshint evil: true*/\n\n        var response, doc, innerHtml;\n\n        //IE may throw an \"access is denied\" error when attempting to access contentDocument on the iframe in some cases\n        try {\n            // iframe.contentWindow.document - for IE<7\n            doc = iframe.contentDocument || iframe.contentWindow.document;\n            innerHtml = doc.body.innerHTML;\n\n            log(\"converting iframe's innerHTML to JSON\");\n            log(\"innerHTML = \" + innerHtml);\n            //plain text response may be wrapped in <pre> tag\n            if (innerHtml && innerHtml.match(/^<pre/i)) {\n                innerHtml = doc.body.firstChild.firstChild.nodeValue;\n            }\n\n            response = handler._parseJsonResponse(innerHtml);\n        }\n        catch (error) {\n            log(\"Error when attempting to parse form upload response (\" + error.message + \")\", \"error\");\n            response = {success: false};\n        }\n\n        return response;\n    }\n\n    /**\n     * Creates form, that will be submitted to iframe\n     */\n    function createForm(id, iframe) {\n        var params = options.paramsStore.get(id),\n            method = options.method.toLowerCase() === \"get\" ? \"GET\" : \"POST\",\n            endpoint = options.endpointStore.get(id),\n            name = getName(id);\n\n        params[options.uuidName] = getUuid(id);\n        params[options.filenameParam] = name;\n\n        return handler._initFormForUpload({\n            method: method,\n            endpoint: endpoint,\n            params: params,\n            paramsInBody: options.paramsInBody,\n            targetName: iframe.name\n        });\n    }\n\n    this.uploadFile = function(id) {\n        var input = handler.getInput(id),\n            iframe = handler._createIframe(id),\n            promise = new qq.Promise(),\n            form;\n\n        form = createForm(id, iframe);\n        form.appendChild(input);\n\n        handler._attachLoadEvent(iframe, function(responseFromMessage) {\n            log(\"iframe loaded\");\n\n            var response = responseFromMessage ? responseFromMessage : getIframeContentJson(id, iframe);\n\n            handler._detachLoadEvent(id);\n\n            //we can't remove an iframe if the iframe doesn't belong to the same domain\n            if (!options.cors.expected) {\n                qq(iframe).remove();\n            }\n\n            if (response.success) {\n                promise.success(response);\n            }\n            else {\n                promise.failure(response);\n            }\n        });\n\n        log(\"Sending upload request for \" + id);\n        form.submit();\n        qq(form).remove();\n\n        return promise;\n    };\n\n    qq.extend(this, new qq.FormUploadHandler({\n        options: {\n            isCors: options.cors.expected,\n            inputName: options.inputName\n        },\n\n        proxy: {\n            onCancel: options.onCancel,\n            getName: getName,\n            getUuid: getUuid,\n            log: log\n        }\n    }));\n};\n","/*globals qq*/\n/**\n * Upload handler used to upload to traditional endpoints.  It depends on File API support, and, therefore,\n * makes use of `XMLHttpRequest` level 2 to upload `File`s and `Blob`s to a generic server.\n *\n * @param spec Options passed from the base handler\n * @param proxy Callbacks & methods used to query for or push out data/changes\n */\nqq.traditional = qq.traditional || {};\nqq.traditional.XhrUploadHandler = function(spec, proxy) {\n    \"use strict\";\n\n    var handler = this,\n        getName = proxy.getName,\n        getSize = proxy.getSize,\n        getUuid = proxy.getUuid,\n        log = proxy.log,\n        multipart = spec.forceMultipart || spec.paramsInBody,\n\n        addChunkingSpecificParams = function(id, params, chunkData) {\n            var size = getSize(id),\n                name = getName(id);\n\n            params[spec.chunking.paramNames.partIndex] = chunkData.part;\n            params[spec.chunking.paramNames.partByteOffset] = chunkData.start;\n            params[spec.chunking.paramNames.chunkSize] = chunkData.size;\n            params[spec.chunking.paramNames.totalParts] = chunkData.count;\n            params[spec.totalFileSizeName] = size;\n\n            /**\n             * When a Blob is sent in a multipart request, the filename value in the content-disposition header is either \"blob\"\n             * or an empty string.  So, we will need to include the actual file name as a param in this case.\n             */\n            if (multipart) {\n                params[spec.filenameParam] = name;\n            }\n        },\n\n        allChunksDoneRequester = new qq.traditional.AllChunksDoneAjaxRequester({\n            cors: spec.cors,\n            endpoint: spec.chunking.success.endpoint,\n            log: log\n        }),\n\n        createReadyStateChangedHandler = function(id, xhr) {\n            var promise = new qq.Promise();\n\n            xhr.onreadystatechange = function() {\n                if (xhr.readyState === 4) {\n                    var result = onUploadOrChunkComplete(id, xhr);\n\n                    if (result.success) {\n                        promise.success(result.response, xhr);\n                    }\n                    else {\n                        promise.failure(result.response, xhr);\n                    }\n                }\n            };\n\n            return promise;\n        },\n\n        getChunksCompleteParams = function(id) {\n            var params = spec.paramsStore.get(id),\n                name = getName(id),\n                size = getSize(id);\n\n            params[spec.uuidName] = getUuid(id);\n            params[spec.filenameParam] = name;\n            params[spec.totalFileSizeName] = size;\n            params[spec.chunking.paramNames.totalParts] = handler._getTotalChunks(id);\n\n            return params;\n        },\n\n        isErrorUploadResponse = function(xhr, response) {\n            return qq.indexOf([200, 201, 202, 203, 204], xhr.status) < 0 ||\n                !response.success ||\n                response.reset;\n        },\n\n        onUploadOrChunkComplete = function(id, xhr) {\n            var response;\n\n            log(\"xhr - server response received for \" + id);\n            log(\"responseText = \" + xhr.responseText);\n\n            response = parseResponse(true, xhr);\n\n            return {\n                success: !isErrorUploadResponse(xhr, response),\n                response: response\n            };\n        },\n\n        // If this is an upload response, we require a JSON payload, otherwise, it is optional.\n        parseResponse = function(upload, xhr) {\n            var response = {};\n\n            try {\n                log(qq.format(\"Received response status {} with body: {}\", xhr.status, xhr.responseText));\n                response = qq.parseJson(xhr.responseText);\n            }\n            catch (error) {\n                upload && log(\"Error when attempting to parse xhr response text (\" + error.message + \")\", \"error\");\n            }\n\n            return response;\n        },\n\n        sendChunksCompleteRequest = function(id) {\n            var promise = new qq.Promise();\n\n            allChunksDoneRequester.complete(\n                    id,\n                    handler._createXhr(id),\n                    getChunksCompleteParams(id),\n                    spec.customHeaders.get(id)\n                )\n                .then(function(xhr) {\n                    promise.success(parseResponse(false, xhr), xhr);\n                }, function(xhr) {\n                    promise.failure(parseResponse(false, xhr), xhr);\n                });\n\n            return promise;\n        },\n\n        setParamsAndGetEntityToSend = function(params, xhr, fileOrBlob, id) {\n            var formData = new FormData(),\n                method = spec.method,\n                endpoint = spec.endpointStore.get(id),\n                name = getName(id),\n                size = getSize(id);\n\n            params[spec.uuidName] = getUuid(id);\n            params[spec.filenameParam] = name;\n\n            if (multipart) {\n                params[spec.totalFileSizeName] = size;\n            }\n\n            //build query string\n            if (!spec.paramsInBody) {\n                if (!multipart) {\n                    params[spec.inputName] = name;\n                }\n                endpoint = qq.obj2url(params, endpoint);\n            }\n\n            xhr.open(method, endpoint, true);\n\n            if (spec.cors.expected && spec.cors.sendCredentials) {\n                xhr.withCredentials = true;\n            }\n\n            if (multipart) {\n                if (spec.paramsInBody) {\n                    qq.obj2FormData(params, formData);\n                }\n\n                formData.append(spec.inputName, fileOrBlob);\n                return formData;\n            }\n\n            return fileOrBlob;\n        },\n\n        setUploadHeaders = function(id, xhr) {\n            var extraHeaders = spec.customHeaders.get(id),\n                fileOrBlob = handler.getFile(id);\n\n            xhr.setRequestHeader(\"Accept\", \"application/json\");\n            xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n            xhr.setRequestHeader(\"Cache-Control\", \"no-cache\");\n\n            if (!multipart) {\n                xhr.setRequestHeader(\"Content-Type\", \"application/octet-stream\");\n                //NOTE: return mime type in xhr works on chrome 16.0.9 firefox 11.0a2\n                xhr.setRequestHeader(\"X-Mime-Type\", fileOrBlob.type);\n            }\n\n            qq.each(extraHeaders, function(name, val) {\n                xhr.setRequestHeader(name, val);\n            });\n        };\n\n    qq.extend(this, {\n        uploadChunk: function(id, chunkIdx, resuming) {\n            var chunkData = handler._getChunkData(id, chunkIdx),\n                xhr = handler._createXhr(id, chunkIdx),\n                size = getSize(id),\n                promise, toSend, params;\n\n            promise = createReadyStateChangedHandler(id, xhr);\n            handler._registerProgressHandler(id, chunkIdx, chunkData.size);\n            params = spec.paramsStore.get(id);\n            addChunkingSpecificParams(id, params, chunkData);\n\n            if (resuming) {\n                params[spec.resume.paramNames.resuming] = true;\n            }\n\n            toSend = setParamsAndGetEntityToSend(params, xhr, chunkData.blob, id);\n            setUploadHeaders(id, xhr);\n            xhr.send(toSend);\n\n            return promise;\n        },\n\n        uploadFile: function(id) {\n            var fileOrBlob = handler.getFile(id),\n                promise, xhr, params, toSend;\n\n            xhr = handler._createXhr(id);\n            handler._registerProgressHandler(id);\n            promise = createReadyStateChangedHandler(id, xhr);\n            params = spec.paramsStore.get(id);\n            toSend = setParamsAndGetEntityToSend(params, xhr, fileOrBlob, id);\n            setUploadHeaders(id, xhr);\n            xhr.send(toSend);\n\n            return promise;\n        }\n    });\n\n    qq.extend(this, new qq.XhrUploadHandler({\n        options: qq.extend({namespace: \"traditional\"}, spec),\n        proxy: qq.extend({getEndpoint: spec.endpointStore.get}, proxy)\n    }));\n\n    qq.override(this, function(super_) {\n        return {\n            finalizeChunks: function(id) {\n                if (spec.chunking.success.endpoint) {\n                    return sendChunksCompleteRequest(id);\n                }\n                else {\n                    return super_.finalizeChunks(id, qq.bind(parseResponse, this, true));\n                }\n            }\n        };\n    });\n};\n","/*globals qq*/\n/**\n * Ajax requester used to send a POST to a traditional endpoint once all chunks for a specific file have uploaded\n * successfully.\n *\n * @param o Options from the caller - will override the defaults.\n * @constructor\n */\nqq.traditional.AllChunksDoneAjaxRequester = function(o) {\n    \"use strict\";\n\n    var requester,\n        method = \"POST\",\n        options = {\n            cors: {\n                allowXdr: false,\n                expected: false,\n                sendCredentials: false\n            },\n            endpoint: null,\n            log: function(str, level) {}\n        },\n        promises = {},\n        endpointHandler = {\n            get: function(id) {\n                return options.endpoint;\n            }\n        };\n\n    qq.extend(options, o);\n\n    requester = qq.extend(this, new qq.AjaxRequester({\n        acceptHeader: \"application/json\",\n        validMethods: [method],\n        method: method,\n        endpointStore: endpointHandler,\n        allowXRequestedWithAndCacheControl: false,\n        cors: options.cors,\n        log: options.log,\n        onComplete: function(id, xhr, isError) {\n            var promise = promises[id];\n\n            delete promises[id];\n\n            if (isError) {\n                promise.failure(xhr);\n            }\n            else {\n                promise.success(xhr);\n            }\n        }\n    }));\n\n    qq.extend(this, {\n        complete: function(id, xhr, params, headers) {\n            var promise = new qq.Promise();\n\n            options.log(\"Submitting All Chunks Done request for \" + id);\n\n            promises[id] = promise;\n\n            requester.initTransport(id)\n                .withParams(params)\n                .withHeaders(headers)\n                .send(xhr);\n\n            return promise;\n        }\n    });\n};\n"]}