{"version":3,"sources":["webpack/universalModuleDefinition","webpack/bootstrap","util/buffer.ts","util/compat.ts","io/interfaces.ts","io/adapters.ts","flatbuffers/js/flatbuffers.mjs","util/utf8.ts","text-encoding-utf-8/lib/encoding.lib.mjs","buffer/index.js","(webpack)/buildin/global.js","base64-js/index.js","ieee754/index.js","isarray/index.js","fb/Schema.ts","fb/Message.ts","vector.ts","enum.ts","util/bit.ts","visitor.ts","visitor/typecomparator.ts","type.ts","data.ts","util/pretty.ts","builder/valid.ts","builder/buffer.ts","builder.ts","builder/bool.ts","builder/null.ts","builder/date.ts","builder/decimal.ts","builder/dictionary.ts","builder/fixedsizebinary.ts","util/math.ts","builder/float.ts","util/bn.ts","builder/int.ts","builder/time.ts","builder/timestamp.ts","builder/interval.ts","builder/binary.ts","builder/utf8.ts","builder/run.ts","vector/row.ts","util/vector.ts","vector/chunked.ts","column.ts","util/args.ts","schema.ts","builder/list.ts","builder/fixedsizelist.ts","builder/map.ts","builder/struct.ts","builder/union.ts","visitor/set.ts","visitor/builderctor.ts","fb/File.ts","builder/index.ts","ipc/metadata/file.ts","io/stream.ts","io/file.ts","util/int.ts","visitor/vectorloader.ts","visitor/typeassembler.ts","ipc/metadata/json.ts","ipc/metadata/message.ts","ipc/message.ts","visitor/vectorassembler.ts","visitor/jsontypeassembler.ts","visitor/jsonvectorassembler.ts","ipc/writer.ts","util/recordbatch.ts","vector/base.ts","vector/binary.ts","vector/bool.ts","vector/date.ts","vector/decimal.ts","vector/dictionary.ts","vector/fixedsizebinary.ts","vector/fixedsizelist.ts","vector/float.ts","vector/interval.ts","vector/int.ts","vector/list.ts","vector/map.ts","vector/null.ts","vector/struct.ts","vector/timestamp.ts","vector/time.ts","vector/union.ts","vector/utf8.ts","util/fn.ts","visitor/get.ts","visitor/indexof.ts","visitor/iterator.ts","visitor/toarray.ts","visitor/bytewidth.ts","visitor/vectorctor.ts","vector/index.ts","table.ts","recordbatch.ts","ipc/reader.ts","io/whatwg/builder.ts","compute/predicate.ts","compute/dataframe.ts","Arrow.ts","Arrow.dom.ts","io/whatwg/iterable.ts","io/whatwg/reader.ts","io/whatwg/writer.ts"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","__webpack_exports__","memcpy","joinUint8Arrays","toArrayBufferView","toInt8Array","toInt16Array","toInt32Array","toBigInt64Array","toUint8Array","toUint16Array","toUint32Array","toBigUint64Array","toFloat32Array","toFloat64Array","toUint8ClampedArray","toArrayBufferViewIterator","toInt8ArrayIterator","toInt16ArrayIterator","toInt32ArrayIterator","toUint8ArrayIterator","toUint16ArrayIterator","toUint32ArrayIterator","toFloat32ArrayIterator","toFloat64ArrayIterator","toUint8ClampedArrayIterator","toArrayBufferViewAsyncIterator","toInt8ArrayAsyncIterator","toInt16ArrayAsyncIterator","toInt32ArrayAsyncIterator","toUint8ArrayAsyncIterator","toUint16ArrayAsyncIterator","toUint32ArrayAsyncIterator","toFloat32ArrayAsyncIterator","toFloat64ArrayAsyncIterator","toUint8ClampedArrayAsyncIterator","rebaseValueOffsets","compareArrayLike","flatbuffers__WEBPACK_IMPORTED_MODULE_0__","_util_utf8__WEBPACK_IMPORTED_MODULE_1__","_compat__WEBPACK_IMPORTED_MODULE_2__","ByteBuffer","SharedArrayBuf","SharedArrayBuffer","ArrayBuffer","target","source","targetByteOffset","sourceByteLength","byteLength","targetByteLength","dst","Uint8Array","buffer","byteOffset","src","Math","min","set","chunks","size","sliced","result","xOffset","yOffset","xLen","yLen","x","y","j","length","collapseContiguousByteRanges","reduce","b","offset","index","Infinity","subarray","slice","ArrayBufferViewCtor","input","bytes","isView","BYTES_PER_ELEMENT","from","Int8Array","Int16Array","Int32Array","Uint16Array","Uint32Array","Float32Array","Float64Array","Uint8ClampedArray","pump","iterator","next","ArrayCtor","wrap","buffers","it","done","async","emit","asyncIterator","valueOffsets","a","BigIntCtor","BigIntAvailable","BigInt64ArrayCtor","BigUint64ArrayCtor","isObject","isPromise","isIterable","isAsyncIterable","isArrowJSON","isIteratorResult","isFileHandle","isFetchResponse","isWritableDOMStream","isReadableDOMStream","isWritableNodeStream","isReadableNodeStream","_io_interfaces__WEBPACK_IMPORTED_MODULE_0__","BigIntUnavailableError","Error","BigIntUnavailable","asIntN","asUintN","BigInt","BigInt64ArrayAvailable","BigInt64ArrayUnavailableError","BigInt64Array","[object Object]","BigUint64ArrayAvailable","BigUint64ArrayUnavailableError","BigUint64Array","isNumber","isBoolean","isFunction","then","ITERATOR_DONE","ArrowJSON","ReadableInterop","AsyncQueue","_adapters__WEBPACK_IMPORTED_MODULE_0__","freeze","_json","this","schema","batches","dictionaries","_getDOMStream","tee","writable","options","_getNodeStream","pipe","pipeTo","duplex","pipeThrough","_DOMStream","toDOMStream","_nodeStream","toNodeStream","super","_values","resolvers","_closedPromise","Promise","_closedPromiseResolve","closed","reason","return","_ensureOpen","push","shift","resolve","_error","error","reject","undefined","_","abort","close","_args","_util_buffer__WEBPACK_IMPORTED_MODULE_0__","fromIterable","cmd","threw","bufferLength","byteRange","isNaN","e","throw","fromAsyncIterable","fromDOMStream","AdaptiveByteReader","releaseLock","fromNodeStream","stream","events","event","err","onEvent","race","map","isFinite","evt","fn","destroy","cleanup","byobReader","defaultReader","supportsBYOB","reader","getBYOBReader","getDefaultReader","catch","readFromBYOBReader","read","readInto","handler","flatbuffers","Offset","Table","SIZEOF_SHORT","SIZEOF_INT","FILE_IDENTIFIER_LENGTH","Encoding","UTF8_BYTES","UTF16_STRING","int32","float32","float64","isLittleEndian","Long","low","high","ZERO","toFloat64","equals","other","Builder","opt_initial_size","initial_size","bb","allocate","space","minalign","vtable","vtable_in_use","isNested","object_start","vtables","vector_num_elems","force_defaults","clear","capacity","forceDefaults","dataBuffer","asUint8Array","position","prep","additional_bytes","align_size","old_buf_size","growByteBuffer","pad","byte_size","writeInt8","writeInt16","writeInt32","writeInt64","writeFloat32","writeFloat64","addInt8","addInt16","addInt32","addInt64","addFloat32","addFloat64","addFieldInt8","voffset","defaultValue","slot","addFieldInt16","addFieldInt32","addFieldInt64","addFieldFloat32","addFieldFloat64","addFieldOffset","addOffset","addFieldStruct","nested","obj","notNested","new_buf_size","nbb","setPosition","startObject","numfields","endObject","vtableloc","trimmed_size","len","existing_vtable","vt1","outer_loop","vt2","readInt16","finish","root_table","opt_file_identifier","file_identifier","charCodeAt","requiredField","table","field","table_start","vtable_start","readInt32","startVector","elem_size","num_elems","alignment","endVector","createString","utf8","codePoint","createLong","bytes_","position_","readInt8","readUint8","readUint16","readUint32","readInt64","readUint64","readFloat32","readFloat64","writeUint8","writeUint16","writeUint32","writeUint64","getBufferIdentifier","String","fromCharCode","__offset","bb_pos","vtable_offset","__union","__string","opt_encoding","__indirect","__vector","__vector_len","__has_identifier","ident","Buffer","decodeUtf8","encodeUtf8","_buffer__WEBPACK_IMPORTED_MODULE_0__","text_encoding_utf_8__WEBPACK_IMPORTED_MODULE_1__","_Buffer","useNativeEncoders","TextDecoder","TextEncoder","decoder","decode","toString","encoder","encode","inRange","max","ToDictionary","TypeError","end_of_stream","Stream","tokens","endOfStream","prepend","token","Array","isArray","unshift","pop","finished","decoderError","fatal","opt_code_point","DEFAULT_ENCODING","encoding","toLowerCase","_streaming","_BOMseen","_decoder","_fatal","_ignoreBOM","_encoder","_options","UTF8Decoder","utf8_code_point","utf8_bytes_seen","utf8_bytes_needed","utf8_lower_boundary","utf8_upper_boundary","bite","code_point","UTF8Encoder","count","temp","input_stream","code_points","apply","indexOf","cp","codePointsToString","opt_string","string","u","stringToCodePoints","global","base64","ieee754","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","__proto__","arg","encodingOrOffset","allocUnsafe","array","fromArrayLike","fromArrayBuffer","isEncoding","actual","write","fromString","isBuffer","checked","copy","val","type","data","fromObject","assertSize","loweredCase","utf8ToBytes","base64ToBytes","swap","bidirectionalIndexOf","dir","arrayIndexOf","lastIndexOf","arr","indexSize","arrLength","valLength","buf","readUInt16BE","foundIndex","found","hexWrite","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","base64Slice","start","end","fromByteArray","utf8Slice","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","foo","typedArraySupport","poolSize","_augment","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","concat","list","pos","swap16","swap32","swap64","arguments","hexSlice","asciiSlice","latin1Slice","utf16leSlice","inspect","match","join","thisStart","thisEnd","thisCopy","targetCopy","includes","toJSON","_arr","ret","out","toHex","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","code","INVALID_BASE64_RE","leadSurrogate","toByteArray","trim","replace","stringtrim","base64clean","g","Function","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","len2","encodeChunk","lookup","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","log","LN2","Schema_org","arrow","apache","org","Message_org","AbstractVector","flatbuf","MetadataVersion","UnionMode","Precision","DateUnit","TimeUnit","IntervalUnit","Type","Endianness","Null","__init","builder","startNull","endNull","Struct_","startStruct_","endStruct_","List","startList","endList","LargeList","startLargeList","endLargeList","FixedSizeList","listSize","startFixedSizeList","addListSize","endFixedSizeList","Map","keysSorted","startMap","addKeysSorted","endMap","Union","Sparse","typeIdsOffset","numElems","startUnion","addMode","addTypeIds","endUnion","Int","bitWidth","isSigned","startInt","addBitWidth","addIsSigned","endInt","FloatingPoint","HALF","precision","startFloatingPoint","addPrecision","endFloatingPoint","Utf8","startUtf8","endUtf8","Binary","startBinary","endBinary","LargeUtf8","startLargeUtf8","endLargeUtf8","LargeBinary","startLargeBinary","endLargeBinary","FixedSizeBinary","byteWidth","startFixedSizeBinary","addByteWidth","endFixedSizeBinary","Bool","startBool","endBool","Decimal","scale","startDecimal","addScale","endDecimal","Date","MILLISECOND","unit","startDate","addUnit","endDate","Time","startTime","endTime","Timestamp","SECOND","optionalEncoding","timezoneOffset","startTimestamp","addTimezone","endTimestamp","Interval","YEAR_MONTH","startInterval","endInterval","Duration","startDuration","endDuration","KeyValue","keyOffset","valueOffset","startKeyValue","addKey","addValue","endKeyValue","DictionaryEncoding","id","indexTypeOffset","isOrdered","startDictionaryEncoding","addId","addIndexType","addIsOrdered","endDictionaryEncoding","Field","NONE","nameOffset","nullable","typeType","typeOffset","dictionaryOffset","childrenOffset","customMetadataOffset","startField","addName","addNullable","addTypeType","addType","addDictionary","addChildren","addCustomMetadata","endField","Schema","Little","endianness","fieldsOffset","startSchema","addEndianness","addFields","endSchema","MessageHeader","FieldNode","null_count","RecordBatch","nodesOffset","buffersOffset","startRecordBatch","addLength","addNodes","addBuffers","endRecordBatch","DictionaryBatch","dataOffset","isDelta","startDictionaryBatch","addData","addIsDelta","endDictionaryBatch","Message","V1","version","headerType","headerOffset","bodyLength","startMessage","addVersion","addHeaderType","addHeader","addBodyLength","endMessage","BufferType","enum_ArrowType","getBool","_data","_index","byte","bit","getBit","setBool","truncateBitmap","bitmap","alignedSize","packBools","iterateBits","values","xs","begin","context","byteIndex","popcnt_bit_range","lhs","rhs","sum","rhsInside","lhsInside","popcnt_array","cnt","view","DataView","popcnt_uint32","getUint32","getUint16","getUint8","uint32","Visitor","nodes","args","node","visit","getVisitFn","throwIfNotFound","visitor","dtype","data_Data","inferDType","type_DataType","visitNull","visitBool","visitInt","Int8","visitInt8","Int16","visitInt16","Int32","visitInt32","Int64","visitInt64","Uint8","visitUint8","Uint16","visitUint16","Uint32","visitUint32","Uint64","visitUint64","Float","visitFloat","Float16","visitFloat16","Float32","visitFloat32","Float64","visitFloat64","visitUtf8","visitBinary","visitFixedSizeBinary","visitDate","DateDay","visitDateDay","DateMillisecond","visitDateMillisecond","visitTimestamp","TimestampSecond","visitTimestampSecond","TimestampMillisecond","visitTimestampMillisecond","TimestampMicrosecond","visitTimestampMicrosecond","TimestampNanosecond","visitTimestampNanosecond","visitTime","TimeSecond","visitTimeSecond","TimeMillisecond","visitTimeMillisecond","TimeMicrosecond","visitTimeMicrosecond","TimeNanosecond","visitTimeNanosecond","visitDecimal","visitList","Struct","visitStruct","visitUnion","DenseUnion","visitDenseUnion","SparseUnion","visitSparseUnion","Dictionary","visitDictionary","visitInterval","IntervalDayTime","visitIntervalDayTime","IntervalYearMonth","visitIntervalYearMonth","visitFixedSizeList","visitMap","_node","typeId","SINGLE","DOUBLE","MICROSECOND","NANOSECOND","DAY","DAY_TIME","Dense","typecomparator_TypeComparator","constructor","instance","compareFields","fields","others","every","f","compareField","compareConstructor","compareAny","compareInt","compareFloat","compareDate","compareTimestamp","timezone","compareTime","compareUnion","typeIds","children","compareInterval","indices","dictionary","proto","ArrayType","type_Null","type_Int_","type_Float","type_Float16","type_Float32","type_Float64","type_Binary","type_Utf8","type_Bool","type_Decimal","type_Date_","type_DateDay","type_DateMillisecond","type_Time_","type_TimeSecond","type_TimeMillisecond","type_TimeMicrosecond","type_TimeNanosecond","type_Timestamp_","type_TimestampSecond","type_TimestampMillisecond","type_TimestampMicrosecond","type_TimestampNanosecond","type_Interval_","type_IntervalDayTime","type_IntervalYearMonth","type_List","child","valueType","valueField","type_Struct","type_Union_","typeIdToChildIndex","idx","type_DenseUnion","type_SparseUnion","type_FixedSizeBinary","type_FixedSizeList","type_Map_","keyType","getId","atomicDictionaryId","type_Dictionary","strideForType","kUnknownNullCount","nullCount","childData","_nullCount","stride","nullBitmap","childStride","_sliceBuffers","clone","_sliceChildren","newLength","VALIDITY","TYPE","OFFSET","DATA","util_buffer","valueOffsetsOrChildren","undf","valueToString","toPrimitive","JSON","stringify","createIsValidFunction","nullValues","fnBody","noNaNs","filter","compat","valueToCase","roundLengthUpToNearest64Bytes","BPE","sliceOrExtendArray","buffer_BufferBuilder","_resize","reservedLength","reservedByteLength","extra","reserved","DataBufferBuilder","reserve","BitmapBufferBuilder","numValid","numInvalid","cur","OffsetsBufferBuilder","flush","buffer_WideBufferBuilder","ArrayType64","_ArrayType64","buffer64","builder_Builder","nulls","_nulls","_isValid","queueingStrategy","highWaterMark","sizeProperty","numChunks","new","append","toVector","throughIterable","throughAsyncIterable","numChildren","_offsets","_typeIds","setValid","isValid","setValue","_setValue","valid","offsets","last","forEach","builder_FixedWidthBuilder","opts","builder_VariableWidthBuilder","_pendingLength","pending","_pending","current","_flush","pendingLength","_flushPending","bool_BoolBuilder","null_NullBuilder","date_DateBuilder","DateDayBuilder","DateMillisecondBuilder","decimal_DecimalBuilder","dictionary_DictionaryBuilder","dictionaryHashFunction","hashFn","_dictionaryOffset","_keysToIndices","valueToKey","keysToIndices","prev","_dictionary","curr","fixedsizebinary_FixedSizeBinaryBuilder","f64","u32","uint16ToFloat64","h","expo","sigf","sign","float64ToUint16","float_FloatBuilder","float_Float16Builder","Float32Builder","Float64Builder","isArrowBigNumSymbol","for","BigNum","setPrototypeOf","SignedBigNum","UnsignedBigNum","DecimalBigNum","bignumToNumber","bn","signed","words","number","bignumToString","bignumToBigInt","decimalToString","digits","base32","checks","reverse","valueOf","hint","assign","TypedArray","BigIntArray","bn_BN","int_IntBuilder","Int8Builder","Int16Builder","Int32Builder","int_Int64Builder","toBigInt","values64","Uint8Builder","Uint16Builder","Uint32Builder","int_Uint64Builder","memo","time_TimeBuilder","TimeSecondBuilder","TimeMillisecondBuilder","TimeMicrosecondBuilder","TimeNanosecondBuilder","timestamp_TimestampBuilder","TimestampSecondBuilder","TimestampMillisecondBuilder","TimestampMicrosecondBuilder","TimestampNanosecondBuilder","interval_IntervalBuilder","IntervalDayTimeBuilder","IntervalYearMonthBuilder","binary_BinaryBuilder","utf8_Utf8Builder","run_Run","kParent","kRowIndex","kKeyToIdx","kIdxToVal","kCustomInspect","row_Row","parent","numKeys","ktoi","itov","getValue","getIndex","ki","keys","vi","k","v","kr","vr","has","callbackfn","thisArg","callback","defineProperties","MapRow","createRowProxy","getChildAt","StructRow","defineRowProxyProperties","findIndex","desc","row","setter","Proxy","getKey","RowProxyHandler","isExtensible","deleteProperty","preventExtensions","ownKeys","receiver","Reflect","clampIndex","adjust","clampRange","big0","isNaNFast","createElementComparator","search","typeofSearch","valueOfSearch","comparators","createSubElementsComparator","creatMapComparator","createArrayLikeComparator","createVectorComparator","createObjectComparator","compareArray","compareObject","vec","compareVector","lKeyItr","rKeyItr","rValItr","rVal","lKey","rKey","chunked_Chunked","vectors","calculateOffsets","_type","_chunks","_chunkOffsets","_length","_numChildren","selectChunkArgs","flatten","VectorName","chunk","isDictionary","_indices","_sliceInternal","columns","_children","vector","mid","isValidInternal","getInternal","element","self","indexOfInternal","toArray","arraySet","typedSet","chunkIndex","fromIndex","slices","chunkOffsets","chunkLength","chunkOffset","to","column_Column","_field","SingleChunkColumn","rest","schema_Field","some","metadata","column","_chunk","selectArgs","Ctor","vals","_selectArgs","selectColumnArgs","_selectFieldArgs","selectFieldArgs","_selectChunkArgs","selectVectorChildrenArgs","_selectVectorChildrenArgs","selectColumnChildrenArgs","_selectColumnChildrenArgs","toKeysAndValues","entries","fieldIndex","valueIndex","schema_Schema","generateDictionaryMap","compareSchemas","columnNames","names","columnIndices","Boolean","curFields","mergeMaps","newFields","f2","newDictionaries","m1","m2","list_ListBuilder","_run","run","fixedsizelist_FixedSizeListBuilder","childIndex","map_MapBuilder","struct_StructBuilder","union_UnionBuilder","_valueToChildTypeId","childTypeId","SparseUnionBuilder","union_DenseUnionBuilder","set_SetVisitor","setEpochMsToMillisecondsLong","epochMs","setVariableWidthBytes","setDateDay","setEpochMsToDays","setDateMillisecond","setNumeric","setFloat16","setNumericX2","long","setTimestampSecond","setTimestampMillisecond","setTimestampMicrosecond","setEpochMsToMicrosecondsLong","setTimestampNanosecond","setEpochMsToNanosecondsLong","setTimeSecond","setTimeMillisecond","setTimeMicrosecond","setTimeNanosecond","setDenseUnion","setSparseUnion","setIntervalDayTime","setIntervalYearMonth","itr","_setStructMapValue","_setStructVectorValue","_setStructArrayValue","_setStructObjectValue","set_instance","builderctor_instance","File_org","newBuilder","defaultOptions","getChildOptions","T","Footer","Block","schemaOffset","dictionariesOffset","recordBatchesOffset","startFooter","addSchema","addDictionaries","addRecordBatches","endFooter","metaDataLength","file_Builder","_Block","_Footer","file_Footer_","V4","recordBatches","dictionaryBatches","_recordBatches","_dictionaryBatches","footer","getRootAsFooter","OffHeapFooter","startRecordBatchesVector","numRecordBatches","rb","FileBlock","startDictionariesVector","numDictionaries","db","dictionaryBatchesOffset","finishFooterBuffer","block","getRecordBatch","getDictionaryBatch","_footer","recordBatchesLength","dictionariesLength","fileBlock","createBlock","stream_AsyncByteQueue","interfaces","sync","stream_ByteStream","stream_ByteStreamSource","adapters","peek","stream_AsyncByteStream","stream_AsyncByteStreamSource","body","cancel","file_RandomAccessFile","readAt","getInt32","file_AsyncRandomAccessFile","file","_handle","stat","bytesRead","carryBit16","intAsHex","kInt32DecimalDigits","kPowersOfTen","BaseInt64","L","R","product","lessThan","int_Uint64","_times","_plus","out_buffer","posn","group","multiple","times","plus","left","right","int_Int64","this_high","other_high","negate","startsWith","Int128","L0","L1","L2","L3","R0","R1","R2","R3","multiply","sums","vectorloader_VectorLoader","nodesIndex","buffersIndex","nextFieldNode","readNullBitmap","readData","readOffsets","visitMany","readTypeIds","readDictionary","nextBufferRange","vectorloader_JSONVectorLoader","sources","isTimestamp","convertArray","isInt","isTime","isDate","isDecimal","isBinary","isFixedSizeBinary","joined","binaryDataFromJSON","isBool","isUtf8","typeassembler_Long","typeassembler_Null","typeassembler_Binary","typeassembler_Bool","typeassembler_Utf8","typeassembler_Decimal","typeassembler_Date","typeassembler_List","typeassembler_Struct","typeassembler_FixedSizeBinary","typeassembler_FixedSizeList","typeassembler_Map_","typeassembler_instance","startTypeIdsVector","createTypeIdsVector","indexType","recordBatchFromJSON","message_RecordBatch","fieldNodesFromJSON","fieldNodes","nullCountFromJSON","buffersFromJSON","BufferRegion","fieldChildrenFromJSON","fromJSON","validity","customMetadataFromJSON","_metadata","indexTypeFromJSON","typeFromJSON","message_Long","message_Builder","message_ByteBuffer","message_Type","_Field","_Schema","_Message","_KeyValue","_FieldNode","_Endianness","_RecordBatch","_DictionaryBatch","message_Message","header","_version","_headerType","_createHeader","_bodyLength","msg","message","messageHeaderFromJSON","_message","getRootAsMessage","decodeMessageHeader","isSchema","isRecordBatch","isDictionaryBatch","finishMessageBuffer","_nodes","_buffers","_id","_isDelta","decodeFieldChildren","childrenLength","decodeCustomMetadata","entry","customMetadataLength","customMetadata","decodeIndexType","decodeFieldType","typeIdsArray","childOffsets","childrenVectorOffset","createChildrenVector","metadataOffset","createCustomMetadataVector","dictType","dictMeta","fieldOffsets","startFieldsVector","fieldsVectorOffset","createFieldsVector","platformIsLittleEndian","Big","_schema","fieldsLength","decodeSchemaFields","schemaFieldsFromJSON","recordBatch","startNodesVector","nodesVectorOffset","startBuffersVector","b_","buffersVectorOffset","batch","nodesLength","decodeFieldNodes","bufferRegions","buffersLength","decodeBuffers","dictionaryBatch","createFieldNode","setInt16","ipc_message_ByteBuffer","invalidMessageType","nullMessage","invalidMessageMetadata","expected","invalidMessageBodyLength","message_MessageReader","readMetadataLength","readMetadata","throwIfNull","readMessage","PADDING","metadataLength","message_AsyncMessageReader","message_JSONMessageReader","_body","_batchIndex","_dictionaryIndex","flattenDataSources","MAGIC","MAGIC_STR","checkForMagicArrowString","magicLength","magicAndPadding","magicX2AndPadding","vectorassembler_VectorAssembler","_bufferRegions","assembler","vectorChildren","recordbatch_RecordBatch","assembleResult","isNull","addBuffer","_nullV","assembleFlatVector","assembleFlatListVector","firstOffset","lastOffset","assembleListVector","assembleNestedVector","maxChildTypeId","childLengths","shiftedOffsets","unshiftedOffsets","childLength","jsontypeassembler_JSONTypeAssembler","jsonvectorassembler_JSONVectorAssembler","bigNumsToStrings","binaryToString","octets","toUpperCase","writer_RecordBatchWriter","_position","_started","_sink","_dictionaryBlocks","_recordBatchBlocks","_dictionaryDeltaOffsets","autoDestroy","writeLegacyIpcFormat","_autoDestroy","_writeLegacyIpcFormat","writableStrategy","readableStrategy","writeAll","writeAllAsync","reset","sink","objectMode","_writeFooter","compareTo","_writeSchema","payload","table_Table","recordbatch_InternalEmptyPlaceholderRecordBatch","_writeRecordBatch","flatbufferSize","prefixSize","nPaddingBytes","_write","of","_writePadding","_writeMessage","assemble","_writeDictionaries","_writeBodyBuffers","padding","_writeDictionaryBatch","writer_RecordBatchStreamWriter","writer","writer_RecordBatchFileWriter","_writeMagic","writer_RecordBatchJSONWriter","_dictionaries","fieldToJSON","dictionaryBatchToJSON","records","noopBuf","nullBufs","bitmapLength","distributeVectorsIntoRecordBatches","vecs","batchArgs","numBatches","batchLength","numColumns","Number","distributeChildData","uniformlyDistributeChunksAcrossRecordBatches","_changeLengthAndBackfillNullBitmap","base_BaseVector","_bindDataAccessors","isConcatSpreadable","binary_BinaryVector","bool_BoolVector","vectorFromValuesWithType","date_DateVector","DateDayVector","DateMillisecondVector","decimal_DecimalVector","dictionary_DictionaryVector","fixedsizebinary_FixedSizeBinaryVector","fixedsizelist_FixedSizeListVector","float_FloatVector","ArrowType","vectorTypeToDataType","InputType","arrayTypeToDataType","convertTo16Bit","Float16Vector","Float32Vector","Float64Vector","typeCtor","dataCtor","ctor","interval_IntervalVector","IntervalDayTimeVector","IntervalYearMonthVector","int_IntVector","is64bit","int_vectorTypeToDataType","int_arrayTypeToDataType","convert32To64Bit","Int8Vector","Int16Vector","Int32Vector","int_Int64Vector","_values64","Uint8Vector","Uint16Vector","Uint32Vector","int_Uint64Vector","list_ListVector","map_MapVector","null_NullVector","struct_kRowIndex","struct_StructVector","_row","bound","timestamp_TimestampVector","TimestampSecondVector","TimestampMillisecondVector","TimestampMicrosecondVector","TimestampNanosecondVector","time_TimeVector","TimeSecondVector","TimeMillisecondVector","TimeMicrosecondVector","TimeNanosecondVector","union_UnionVector","DenseUnionVector","SparseUnionVector","utf8_Utf8Vector","partial0","partial2","get_GetVisitor","epochMillisecondsLongToMs","epochMillisecondsToDate","getVariableWidthBytes","getDateDay","epochDaysToMs","epochDaysToDate","getDateMillisecond","epochMillisecondsLongToDate","getNumeric","getFloat16","getBigInts","getTimestampSecond","getTimestampMillisecond","getTimestampMicrosecond","epochMicrosecondsLongToMs","getTimestampNanosecond","epochNanosecondsLongToMs","getTimeSecond","getTimeMillisecond","getTimeMicrosecond","getTimeNanosecond","getDenseUnion","getSparseUnion","getIntervalDayTime","getIntervalYearMonth","interval","int32s","_vector","decimal","get_instance","indexof_IndexOfVisitor","indexOfValue","searchElement","indexOfNull","indexOfUnion","indexof_instance","iterator_IteratorVisitor","vectorIterator","getFn","nullByte","nullBit","nullableIterator","iterator_instance","toarray_ToArrayVisitor","arrayOfVector","toarray_instance","variableWidthColumnErrorMessage","bytewidth_instance","____","visitFields","vectorctor_instance","newDataType","transform","getByteWidth","wrapNullableSet","VectorCtor","partial1","partialType0","empty","fromStruct","tableFromIterable","tableFromAsyncIterable","reader_RecordBatchReader","isSync","open","opening","cols","numCols","getColumnAt","getColumnIndex","nameToIndex","selectAt","columnName","oldToNew","newIdx","_f","_fs","fs","vs","batchData","ensureSameLengthData","recordbatch_DictionaryCollector","collect","impl","_impl","isFile","isAsync","isStream","readRecordBatch","RecordBatchStreamReader","reader_RecordBatchJSONReaderImpl","fromArrowJSON","AsyncRecordBatchFileReader","reader_AsyncRecordBatchFileReaderImpl","AsyncRecordBatchStreamReader","reader_AsyncRecordBatchStreamReaderImpl","fromFileHandle","RecordBatchFileReader","reader_RecordBatchFileReaderImpl","fromAsyncByteStream","reader_RecordBatchStreamReaderImpl","fromByteStream","readAllSync","readAllAsync","reader_RecordBatchReaderImpl","_recordBatchIndex","_loadVectors","types","_reader","shouldAutoDestroy","readSchema","_readNextMessageAndValidate","readMessageBody","_loadRecordBatch","_loadDictionaryBatch","_readFooter","_readDictionaryBatch","seek","builder_BuilderTransform","_numChunks","_finished","_bufferedSize","builderOptions","_controller","_builder","_getSize","chunkByteLength","readableHighWaterMark","writableHighWaterMark","ReadableStream","pull","_maybeFlush","WritableStream","_writeValueAndReturnChunkSize","bufferedSize","controller","desiredSize","_enqueue","enqueue","Value","Literal","predicate_Equals","LTeq","GTeq","Not","ge","le","eq","Col","colidx","Predicate","expr","And","Or","ComparisonPredicate","_bindLitLit","_bindLitCol","_bindColLit","_bindColCol","CombinationPredicate","accum","_batch","rtrn","left_func","right_func","col","lit","col_func","lastDictionary","reverseLookup","lastKey","func","CustomPredicate","bind_","predicate_lit","predicate_col","and","or","custom","countBy","dataframe_DataFrame","scan","scanReverse","predicate","dataframe_FilteredDataFrame","batchIndex","numRows","count_by","countByteLength","ceil","counts","dataframe_CountByResult","_predicate","isBound","util","bn_namespaceObject","util_int_namespaceObject","bit_namespaceObject","math_namespaceObject","util_vector_namespaceObject","predicate_namespaceObject","bm","hwm","asyncIterableAsReadableDOMStream","iterableAsReadableDOMStream","queue","readable"],"mappings":"CAAA,SAAAA,EAAAC,GACA,iBAAAC,SAAA,iBAAAC,OACAA,OAAAD,QAAAD,IACA,mBAAAG,eAAAC,IACAD,OAAA,WAAAH,GACA,iBAAAC,QACAA,QAAA,MAAAD,IAEAD,EAAA,MAAAC,IARA,CASCK,OAAA,WACD,mBCTA,IAAAC,EAAA,GAGA,SAAAC,EAAAC,GAGA,GAAAF,EAAAE,GACA,OAAAF,EAAAE,GAAAP,QAGA,IAAAC,EAAAI,EAAAE,GAAA,CACAC,EAAAD,EACAE,GAAA,EACAT,QAAA,IAUA,OANAU,EAAAH,GAAAI,KAAAV,EAAAD,QAAAC,IAAAD,QAAAM,GAGAL,EAAAQ,GAAA,EAGAR,EAAAD,QA0DA,OArDAM,EAAAM,EAAAF,EAGAJ,EAAAO,EAAAR,EAGAC,EAAAQ,EAAA,SAAAd,EAAAe,EAAAC,GACAV,EAAAW,EAAAjB,EAAAe,IACAG,OAAAC,eAAAnB,EAAAe,EAAA,CAA0CK,YAAA,EAAAC,IAAAL,KAK1CV,EAAAgB,EAAA,SAAAtB,GACA,oBAAAuB,eAAAC,aACAN,OAAAC,eAAAnB,EAAAuB,OAAAC,YAAA,CAAwDC,MAAA,WAExDP,OAAAC,eAAAnB,EAAA,cAAiDyB,OAAA,KAQjDnB,EAAAoB,EAAA,SAAAD,EAAAE,GAEA,GADA,EAAAA,IAAAF,EAAAnB,EAAAmB,IACA,EAAAE,EAAA,OAAAF,EACA,KAAAE,GAAA,iBAAAF,QAAAG,WAAA,OAAAH,EACA,IAAAI,EAAAX,OAAAY,OAAA,MAGA,GAFAxB,EAAAgB,EAAAO,GACAX,OAAAC,eAAAU,EAAA,WAAyCT,YAAA,EAAAK,UACzC,EAAAE,GAAA,iBAAAF,EAAA,QAAAM,KAAAN,EAAAnB,EAAAQ,EAAAe,EAAAE,EAAA,SAAAA,GAAgH,OAAAN,EAAAM,IAAqBC,KAAA,KAAAD,IACrI,OAAAF,GAIAvB,EAAA2B,EAAA,SAAAhC,GACA,IAAAe,EAAAf,KAAA2B,WACA,WAA2B,OAAA3B,EAAA,SAC3B,WAAiC,OAAAA,GAEjC,OADAK,EAAAQ,EAAAE,EAAA,IAAAA,GACAA,GAIAV,EAAAW,EAAA,SAAAiB,EAAAC,GAAsD,OAAAjB,OAAAkB,UAAAC,eAAA1B,KAAAuB,EAAAC,IAGtD7B,EAAAgC,EAAA,GAIAhC,IAAAiC,EAAA,mCClFAjC,EAAAgB,EAAAkB,GAAAlC,EAAAQ,EAAA0B,EAAA,2BAAAC,IAAAnC,EAAAQ,EAAA0B,EAAA,oCAAAE,IAAApC,EAAAQ,EAAA0B,EAAA,sCAAAG,IAAArC,EAAAQ,EAAA0B,EAAA,gCAAAI,IAAAtC,EAAAQ,EAAA0B,EAAA,iCAAAK,IAAAvC,EAAAQ,EAAA0B,EAAA,iCAAAM,IAAAxC,EAAAQ,EAAA0B,EAAA,oCAAAO,IAAAzC,EAAAQ,EAAA0B,EAAA,iCAAAQ,IAAA1C,EAAAQ,EAAA0B,EAAA,kCAAAS,IAAA3C,EAAAQ,EAAA0B,EAAA,kCAAAU,IAAA5C,EAAAQ,EAAA0B,EAAA,qCAAAW,IAAA7C,EAAAQ,EAAA0B,EAAA,mCAAAY,IAAA9C,EAAAQ,EAAA0B,EAAA,mCAAAa,IAAA/C,EAAAQ,EAAA0B,EAAA,wCAAAc,IAAAhD,EAAAQ,EAAA0B,EAAA,8CAAAe,IAAAjD,EAAAQ,EAAA0B,EAAA,wCAAAgB,IAAAlD,EAAAQ,EAAA0B,EAAA,yCAAAiB,IAAAnD,EAAAQ,EAAA0B,EAAA,yCAAAkB,IAAApD,EAAAQ,EAAA0B,EAAA,yCAAAmB,IAAArD,EAAAQ,EAAA0B,EAAA,0CAAAoB,IAAAtD,EAAAQ,EAAA0B,EAAA,0CAAAqB,IAAAvD,EAAAQ,EAAA0B,EAAA,2CAAAsB,IAAAxD,EAAAQ,EAAA0B,EAAA,2CAAAuB,IAAAzD,EAAAQ,EAAA0B,EAAA,gDAAAwB,IAAA1D,EAAAQ,EAAA0B,EAAA,mDAAAyB,IAAA3D,EAAAQ,EAAA0B,EAAA,6CAAA0B,IAAA5D,EAAAQ,EAAA0B,EAAA,8CAAA2B,IAAA7D,EAAAQ,EAAA0B,EAAA,8CAAA4B,IAAA9D,EAAAQ,EAAA0B,EAAA,8CAAA6B,IAAA/D,EAAAQ,EAAA0B,EAAA,+CAAA8B,IAAAhE,EAAAQ,EAAA0B,EAAA,+CAAA+B,IAAAjE,EAAAQ,EAAA0B,EAAA,gDAAAgC,IAAAlE,EAAAQ,EAAA0B,EAAA,gDAAAiC,IAAAnE,EAAAQ,EAAA0B,EAAA,qDAAAkC,IAAApE,EAAAQ,EAAA0B,EAAA,uCAAAmC,IAAArE,EAAAQ,EAAA0B,EAAA,qCAAAoC,IAAA,IAAAC,EAAAvE,EAAA,GAAAwE,EAAAxE,EAAA,GAAAyE,EAAAzE,EAAA,GAmBO0E,EAAaH,EAAA,EAAYG,WAMhC,MAAMC,EAA+C,oBAAtBC,kBAAoCA,kBAAoBC,YA2BhF,SAAS1C,EAAyE2C,EAAiBC,EAAiBC,EAAmB,EAAGC,EAAmBF,EAAOG,YACvK,MAAMC,EAAmBL,EAAOI,WAC1BE,EAAM,IAAIC,WAAWP,EAAOQ,OAAQR,EAAOS,WAAYJ,GACvDK,EAAM,IAAIH,WAAWN,EAAOO,OAAQP,EAAOQ,WAAYE,KAAKC,IAAIT,EAAkBE,IAExF,OADAC,EAAIO,IAAIH,EAAKR,GACNF,EAIJ,SAAS1C,EAAgBwD,EAAsBC,GAIlD,IAEId,EAAoBe,EAAoBR,EAFxCS,EArCR,SAAsCH,GAClC,IACII,EAAiBC,EAAiBC,EAAcC,EADhDJ,EAASH,EAAO,GAAK,CAACA,EAAO,IAAM,GAEvC,IAAK,IAAIQ,EAAGC,EAAGnG,EAAI,EAAGoG,EAAI,EAAG3E,EAAIiE,EAAOW,SAAUrG,EAAIyB,GAClDyE,EAAIL,EAAOO,GACXD,EAAIT,EAAO1F,IAENkG,IAAMC,GAAKD,EAAEd,SAAWe,EAAEf,QAAUe,EAAEd,WAAaa,EAAEb,WACtDc,IAAMN,IAASO,GAAKD,MAGrBd,WAAYS,EAASd,WAAYgB,GAASE,KAC1Cb,WAAYU,EAASf,WAAYiB,GAASE,GAExCL,EAAUE,EAAQD,GAAYA,EAAUE,EAAQH,EACjDK,IAAMN,IAASO,GAAKD,GAGxBN,EAAOO,GAAK,IAAIjB,WAAWe,EAAEd,OAAQU,EAASC,EAAUD,EAAUG,IAEtE,OAAOJ,EAiBMS,CAA6BZ,GACtCV,EAAaa,EAAOU,OAAO,CAACL,EAAGM,IAAMN,EAAIM,EAAExB,WAAY,GAEvDyB,EAAS,EAAGC,GAAS,EAAGL,EAASd,KAAKC,IAAIG,GAAQgB,IAAU3B,GAChE,IAAK,IAAIvD,EAAIoE,EAAOQ,SAAUK,EAAQjF,GAAI,CAGtC,GAAI4E,GAAWI,GADfb,GADAf,EAASgB,EAAOa,IACAE,SAAS,EAAGrB,KAAKC,IAAIX,EAAOwB,OAAQA,EAASI,KAC9BJ,OAAS,CAChCT,EAAOS,OAASxB,EAAOwB,OACvBR,EAAOa,GAAS7B,EAAO+B,SAAShB,EAAOS,QAChCT,EAAOS,SAAWxB,EAAOwB,QAAUK,IAC9CtB,EAASnD,EAAOmD,EAAQQ,EAAQa,GAAWrB,EAASQ,EACpD,MAEJ3D,EAAOmD,IAAWA,EAAS,IAAID,WAAWkB,IAAUT,EAAQa,GAC5DA,GAAUb,EAAOS,OAErB,MAAO,CAACjB,GAAU,IAAID,WAAW,GAAIU,EAAOgB,MAAMH,GAAQ1B,GAAcI,EAASA,EAAOJ,WAAa,IAWlG,SAAS7C,EAAkB2E,EAA0BC,GAExD,IAAI9F,EAAaP,OAAA6D,EAAA,EAAA7D,CAAiBqG,GAASA,EAAM9F,MAAQ8F,EAEzD,OAAI9F,aAAiB6F,EACbA,IAAwB3B,WAGjB,IAAI2B,EAAoB7F,EAAMmE,OAAQnE,EAAMoE,WAAYpE,EAAM+D,YAElE/D,EAENA,GACgB,iBAAVA,IAAsBA,EAAQP,OAAA4D,EAAA,EAAA5D,CAAWO,IAChDA,aAAiB0D,YAAsB,IAAImC,EAAoB7F,GAC/DA,aAAiBwD,EAAyB,IAAIqC,EAAoB7F,GAClEA,aAAiBuD,EAAqBrC,EAAkB2E,EAAqB7F,EAAM+F,SAC/ErC,YAAYsC,OAAOhG,GAA2CA,EAAM+D,YAAc,EAAI,IAAI8B,EAAoB,GAChH,IAAIA,EAAoB7F,EAAMmE,OAAQnE,EAAMoE,WAAYpE,EAAM+D,WAAa8B,EAAoBI,mBADjEJ,EAAoBK,KAAKlG,IALxC,IAAI6F,EAAoB,GAS3B,MAAM1E,EAAe2E,GAAgC5E,EAAkBiF,UAAWL,GAC5E1E,EAAgB0E,GAAgC5E,EAAkBkF,WAAYN,GAC9EzE,EAAgByE,GAAgC5E,EAAkBmF,WAAYP,GAC9ExE,EAAmBwE,GAAgC5E,EAAkBoC,EAAA,EAAewC,GACpFvE,EAAgBuE,GAAgC5E,EAAkBgD,WAAY4B,GAC9EtE,EAAiBsE,GAAgC5E,EAAkBoF,YAAaR,GAChFrE,EAAiBqE,GAAgC5E,EAAkBqF,YAAaT,GAChFpE,EAAoBoE,GAAgC5E,EAAkBoC,EAAA,EAAgBwC,GACtFnE,EAAkBmE,GAAgC5E,EAAkBsF,aAAcV,GAClFlE,EAAkBkE,GAAgC5E,EAAkBuF,aAAcX,GAClFjE,EAAuBiE,GAAgC5E,EAAkBwF,kBAAmBZ,GAMlHa,EAAsDC,IAAkBA,EAASC,OAAeD,GAG/F,SAAU9E,EAAgDgF,EAAqClD,GAElG,MAAMmD,EAAO,UAAa9B,SAAcA,GAClC+B,EAC4B,iBAAXpD,EAAuBmD,EAAKnD,GACnCF,YAAYsC,OAAOpC,GAAWmD,EAAKnD,GACtCA,aAAkBF,YAAeqD,EAAKnD,GACzCA,aAAkBJ,EAAkBuD,EAAKnD,GAChDnE,OAAA6D,EAAA,EAAA7D,CAAiCmE,GAAyBA,EAAfmD,EAAKnD,SAE5C+C,EAAK,UAAYM,GACpB,IAAIpH,EAA+B,KACnC,GACIA,EAAIoH,EAAGJ,WAAW3F,EAAkB4F,EAAWjH,WACzCA,EAAEqH,MAJJ,CAKTF,EAAQlH,OAAO8G,cAGA,MAAM7E,EAAuB+D,GAAwChE,EAA0BqE,UAAWL,GACpG9D,EAAwB8D,GAAwChE,EAA0BsE,WAAYN,GACtG7D,EAAwB6D,GAAwChE,EAA0BuE,WAAYP,GACtG5D,EAAwB4D,GAAwChE,EAA0BoC,WAAY4B,GACtG3D,EAAyB2D,GAAwChE,EAA0BwE,YAAaR,GACxG1D,EAAyB0D,GAAwChE,EAA0ByE,YAAaT,GACxGzD,EAA0ByD,GAAwChE,EAA0B0E,aAAcV,GAC1GxD,EAA0BwD,GAAwChE,EAA0B2E,aAAcX,GAC1GvD,EAA+BuD,GAAwChE,EAA0B4E,kBAAmBZ,GAMzIqB,eAAgB3E,EAAqDsE,EAAqClD,GAG7G,GAAInE,OAAA6D,EAAA,EAAA7D,CAAgCmE,GAChC,aAAcpB,EAA+BsE,QAAiBlD,GAGlE,MAAMmD,EAAOI,gBAAmBlC,eAAoBA,GAU9C+B,EACiC,iBAAXpD,EAAuBmD,EAAKnD,GACnCF,YAAYsC,OAAOpC,GAAWmD,EAAKnD,GACtCA,aAAkBF,YAAeqD,EAAKnD,GACzCA,aAAkBJ,EAAkBuD,EAAKnD,GAChDnE,OAAA6D,EAAA,EAAA7D,CAAiCmE,GAd5BuD,gBAA0CvD,SAC5C+C,EAAK,UAAWM,GACnB,IAAIpH,EAA+B,KACnC,GACIA,EAAIoH,EAAGJ,WAAWhH,GAAKA,EAAEG,cACnBH,EAAEqH,MAJJ,CAKTtD,EAAO9D,OAAO8G,cAQ8BQ,CAAKxD,GACrDnE,OAAA6D,EAAA,EAAA7D,CAAsCmE,GACUA,EADAmD,EAAKnD,SAGjD+C,EAAK,gBAAkBM,GAC1B,IAAIpH,EAA+B,KACnC,GACIA,QAAUoH,EAAGJ,WAAW3F,EAAkB4F,EAAWjH,WAC/CA,EAAEqH,MAJJ,CAKTF,EAAQlH,OAAOuH,mBAGA,MAAM5E,EAA4BqD,GAA6CtD,EAA+B2D,UAAWL,GACnHpD,EAA6BoD,GAA6CtD,EAA+B4D,WAAYN,GACrHnD,EAA6BmD,GAA6CtD,EAA+B6D,WAAYP,GACrHlD,EAA6BkD,GAA6CtD,EAA+B0B,WAAY4B,GACrHjD,EAA8BiD,GAA6CtD,EAA+B8D,YAAaR,GACvHhD,EAA8BgD,GAA6CtD,EAA+B+D,YAAaT,GACvH/C,EAA+B+C,GAA6CtD,EAA+BgE,aAAcV,GACzH9C,EAA+B8C,GAA6CtD,EAA+BiE,aAAcX,GACzH7C,EAAoC6C,GAA6CtD,EAA+BkE,kBAAmBZ,GAGxJ,SAAS5C,EAAmBsC,EAAgBJ,EAAgBkC,GAG/D,GAAe,IAAX9B,EAAc,CACd8B,EAAeA,EAAa1B,MAAM,EAAGR,EAAS,GAC9C,IAAK,IAAIrG,GAAK,IAAKA,GAAKqG,GACpBkC,EAAavI,IAAMyG,EAG3B,OAAO8B,EAIJ,SAASnE,EAA2CoE,EAAMhC,GAC7D,IAAIxG,EAAI,EAAGyB,EAAI+G,EAAEnC,OACjB,GAAI5E,IAAM+E,EAAEH,OAAU,OAAO,EAC7B,GAAI5E,EAAI,EACJ,GAAK,GAAI+G,EAAExI,KAAOwG,EAAExG,GAAM,OAAO,UAAoBA,EAAIyB,GAE7D,OAAO,iCCrOX3B,EAAAQ,EAAA0B,EAAA,sBAAAyG,IAAA3I,EAAAQ,EAAA0B,EAAA,sBAAA0G,IAAA5I,EAAAQ,EAAA0B,EAAA,sBAAA2G,IAAA7I,EAAAQ,EAAA0B,EAAA,sBAAA4G,IAAA9I,EAAAQ,EAAA0B,EAAA,sBAAA6G,IAAA/I,EAAAQ,EAAA0B,EAAA,sBAAA8G,IAAAhJ,EAAAQ,EAAA0B,EAAA,sBAAA+G,IAAAjJ,EAAAQ,EAAA0B,EAAA,sBAAAgH,IAAAlJ,EAAAQ,EAAA0B,EAAA,sBAAAiH,IAAAnJ,EAAAQ,EAAA0B,EAAA,sBAAAkH,IAAApJ,EAAAQ,EAAA0B,EAAA,sBAAAmH,IAAArJ,EAAAQ,EAAA0B,EAAA,sBAAAoH,IAAAtJ,EAAAQ,EAAA0B,EAAA,sBAAAqH,IAAAvJ,EAAAQ,EAAA0B,EAAA,sBAAAsH,IAAAxJ,EAAAQ,EAAA0B,EAAA,sBAAAuH,IAAAzJ,EAAAQ,EAAA0B,EAAA,sBAAAwH,IAAA,IAAAC,EAAA3J,EAAA,GA2CA,MAAO2I,EAAYC,GAAmB,MAClC,MAAMgB,EAAyB,KAAQ,MAAUC,MAAM,gDACvD,SAASC,IAAsB,MAAMF,IAGrC,OAFAE,EAAkBC,OAAS,MAAQ,MAAMH,MACzCE,EAAkBE,QAAU,MAAQ,MAAMJ,MACjB,oBAAXK,OAAyB,CAACA,QAAQ,GAAQ,CAAOH,GAAmB,IALhD,IAS/BjB,EAAmBqB,GAA0B,MAChD,MAAMC,EAAgC,KAAQ,MAAUN,MAAM,uDAO9D,MAAgC,oBAAlBO,cAAgC,CAACA,eAAe,GAAQ,CANtE,MACIhD,+BAAiC,OAAO,EACxCiD,YAAc,MAAMF,IACpBE,cAAgB,MAAMF,IACtBE,cAAgB,MAAMF,OAE6E,IARvD,IAY7CrB,EAAoBwB,GAA2B,MAClD,MAAMC,EAAiC,KAAQ,MAAUV,MAAM,wDAO/D,MAAiC,oBAAnBW,eAAiC,CAACA,gBAAgB,GAAQ,CANxE,MACIpD,+BAAiC,OAAO,EACxCiD,YAAc,MAAME,IACpBF,cAAgB,MAAME,IACtBF,cAAgB,MAAME,OAEgF,IARxD,GAejCE,EAAYrE,GAAwB,iBAANA,EAC9BsE,EAAatE,GAAwB,kBAANA,EAC/BuE,EAAcvE,GAAwB,mBAANA,EAExC2C,EAAY3C,GAA6B,MAALA,GAAaxF,OAAOwF,KAAOA,EAG/D4C,EAAsB5C,GACxB2C,EAAS3C,IAAMuE,EAAWvE,EAAEwE,MAS1B3B,EAAuB7C,GACzB2C,EAAS3C,IAAMuE,EAAWvE,EAAEnF,OAAO8G,WAIjCmB,EAA4B9C,GAC9B2C,EAAS3C,IAAMuE,EAAWvE,EAAEnF,OAAOuH,gBAIjCW,EAAe/C,GACjB2C,EAAS3C,IAAM2C,EAAS3C,EAAU,QAShCgD,EAA6BhD,GAC/B2C,EAAS3C,IAAO,SAAUA,GAAO,UAAWA,EAa1CiD,EAAgBjD,GAClB2C,EAAS3C,IAAMuE,EAAWvE,EAAQ,OAAMqE,EAASrE,EAAM,IASrDkD,EAAmBlD,GACrB2C,EAAS3C,IAAMoD,EAAoBpD,EAAQ,MAIzCmD,EAAgCnD,GAClC2C,EAAS3C,IACZuE,EAAWvE,EAAS,QACpBuE,EAAWvE,EAAa,cACtBA,aAAauD,EAAA,GAIVH,EAAgCpD,GAClC2C,EAAS3C,IACZuE,EAAWvE,EAAU,SACrBuE,EAAWvE,EAAa,cACtBA,aAAauD,EAAA,GAIVF,EAAwBrD,GAC1B2C,EAAS3C,IACZuE,EAAWvE,EAAO,MAClBuE,EAAWvE,EAAS,QACpBsE,EAAUtE,EAAY,aACpBA,aAAauD,EAAA,GAIVD,EAAwBtD,GAC1B2C,EAAS3C,IACZuE,EAAWvE,EAAQ,OACnBuE,EAAWvE,EAAQ,OACnBsE,EAAUtE,EAAY,aACpBA,aAAauD,EAAA,iCC/KvB3J,EAAAQ,EAAA0B,EAAA,sBAAA2I,IAAA7K,EAAAQ,EAAA0B,EAAA,sBAAA4I,IAAA9K,EAAAQ,EAAA0B,EAAA,sBAAA6I,IAAA/K,EAAAQ,EAAA0B,EAAA,sBAAA8I,IAAA,IAAAC,EAAAjL,EAAA,GAoBO,MAAM6K,EAAqBjK,OAAOsK,OAAO,CAAE7C,MAAM,EAAMlH,WAAO,IAU9D,MAAM2J,EAETT,YAAoBc,GAAAC,KAAAD,QACpBE,aAA2B,OAAOD,KAAKD,MAAc,OACrDG,cAA8B,OAAQF,KAAKD,MAAe,SAAK,GAC/DI,mBAAmC,OAAQH,KAAKD,MAAoB,cAAK,IAgCtE,MAAeJ,EAKXV,MACH,OAAOe,KAAKI,gBAAgBC,MAEzBpB,KAAsCqB,EAAaC,GACtD,OAAOP,KAAKQ,iBAAiBC,KAAKH,EAAUC,GAEzCtB,OAAOqB,EAA6BC,GAAyB,OAAOP,KAAKI,gBAAgBM,OAAOJ,EAAUC,GAC1GtB,YAA2C0B,EAAsDJ,GACpG,OAAOP,KAAKI,gBAAgBQ,YAAYD,EAAQJ,GAI5CtB,gBACJ,OAAOe,KAAKa,aAAeb,KAAKa,WAAab,KAAKc,eAI9C7B,iBACJ,OAAOe,KAAKe,cAAgBf,KAAKe,YAAcf,KAAKgB,iBAQrD,MAAMpB,UAAkED,EAS3EV,cACIgC,QAPMjB,KAAAkB,QAAuB,GAIvBlB,KAAAmB,UAAqD,GAI3DnB,KAAKoB,eAAiB,IAAIC,QAASzL,GAAMoK,KAAKsB,sBAAwB1L,GAG1E2L,aAAqC,OAAOvB,KAAKoB,eAC1CnC,aAAauC,SAAsBxB,KAAKyB,OAAOD,GAC/CvC,MAAMlJ,GACLiK,KAAK0B,gBACL1B,KAAKmB,UAAUhG,QAAU,EAClB6E,KAAKkB,QAAQS,KAAK5L,GAClBiK,KAAKmB,UAAUS,QAASC,QAAQ,CAAE5E,MAAM,EAAOlH,WAGvDkJ,MAAMlJ,GACLiK,KAAKsB,wBACLtB,KAAKmB,UAAUhG,QAAU,EAClB6E,KAAK8B,OAAS,CAAEC,MAAOhM,GACvBiK,KAAKmB,UAAUS,QAASI,OAAO,CAAE/E,MAAM,EAAMlH,WAGrDkJ,QACH,GAAIe,KAAKsB,sBAAuB,CAC5B,MAAMH,UAAEA,GAAcnB,KACtB,KAAOmB,EAAUhG,OAAS,GACtBgG,EAAUS,QAASC,QAAQpC,GAE/BO,KAAKsB,wBACLtB,KAAKsB,2BAAwBW,GAI9BhD,CAACpJ,OAAOuH,iBAAmB,OAAO4C,KAClCf,YAAYsB,GACf,OAAOV,EAAA,EAAeiB,YACjBd,KAAKsB,uBAAyBtB,KAAK8B,OAC7B9B,KACAA,KAAKkB,QACZX,GAEDtB,aAAasB,GAChB,OAAOV,EAAA,EAAemB,aACjBhB,KAAKsB,uBAAyBtB,KAAK8B,OAC7B9B,KACAA,KAAKkB,QACZX,GAEDtB,YAAYiD,GAAgC,aAAflC,KAAKmC,MAAMD,GAAWzC,EACnDR,aAAaiD,GAA+B,aAAdlC,KAAKoC,QAAgB3C,EAEnDR,WAAWxE,GAAmD,aAAcuF,KAAKpD,KAAKnC,EAAM,SAAS1E,MACrGkJ,WAAWxE,GAAmD,aAAcuF,KAAKpD,KAAKnC,EAAM,SAAS1E,MACrGkJ,QAAQoD,GACX,OAAIrC,KAAKkB,QAAQ/F,OAAS,EACfkG,QAAQQ,QAAQ,CAAE5E,MAAM,EAAOlH,MAAOiK,KAAKkB,QAAQU,UACnD5B,KAAK8B,OACLT,QAAQW,OAAO,CAAE/E,MAAM,EAAMlH,MAAOiK,KAAK8B,OAAOC,QAC/C/B,KAAKsB,sBAGN,IAAID,QAAmC,CAACQ,EAASG,KACpDhC,KAAKmB,UAAUQ,KAAK,CAAEE,UAASG,aAH5BX,QAAQQ,QAAQpC,GAQrBR,cACN,GAAIe,KAAKsB,sBACL,OAAO,EAEX,MAAU7C,SAASuB,kDCjL3B,IAAAsC,EAAA1N,EAAA,GA4BekC,EAAA,GACXyL,aAA6C5I,GAClC+C,EAyBf,UAAuD/C,GAEnD,IAAIsD,EAC4B/C,EAC5BsI,EAAsB/H,EAFPgI,GAAQ,EACvB1F,EAAwB,GACY2F,EAAe,EAEvD,SAASC,IACL,MAAY,SAARH,EACOhN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GAAM,KAEzCP,EAAQ6C,EAAS2F,GAAgBlN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GACpDP,KAIRsI,MAAK/H,cAAqB,MAG7B,IAAIuC,EAAKxH,OAAA8M,EAAA,qBAAA9M,CAAqBmE,GAAQ9D,OAAO8G,YAE7C,IACI,GAUI,KARGM,OAAMlH,MAAOmE,GAAW0I,MAAMnI,EAAOiI,GACpC1F,EAAGJ,UAAKqF,GAAajF,EAAGJ,KAAKnC,EAAOiI,KAEnCzF,GAAQ/C,EAAOJ,WAAa,IAC7BiD,EAAQ4E,KAAKzH,GACbwI,GAAgBxI,EAAOJ,YAGvBmD,GAAQxC,GAAQiI,EAChB,KACOF,MAAK/H,cAAekI,WAClBlI,EAAOiI,UAEdzF,GACZ,MAAO4F,IACJJ,GAAQ,IAA8B,mBAAbzF,EAAG8F,OAA0B9F,EAAG8F,MAAMD,YAErD,IAAVJ,GAA0C,mBAAdzF,EAAGyE,QAA2BzE,EAAGyE,UAjElDc,CAAgB5I,IAEhCoJ,kBAAkDpJ,GACvC+C,EAmEfQ,gBAAkEvD,GAE9D,IAAIsD,EAC4B/C,EAC5BsI,EAAsB/H,EAFPgI,GAAQ,EACvB1F,EAAwB,GACY2F,EAAe,EAEvD,SAASC,IACL,MAAY,SAARH,EACOhN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GAAM,KAEzCP,EAAQ6C,EAAS2F,GAAgBlN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GACpDP,KAIRsI,MAAK/H,cAAqB,MAG7B,IAAIuC,EAAKxH,OAAA8M,EAAA,0BAAA9M,CAA0BmE,GAAQ9D,OAAOuH,iBAElD,IACI,GAWI,KATGH,OAAMlH,MAAOmE,GAAW0I,MAAMnI,EAAOiI,SAC5B1F,EAAGJ,UAAKqF,SACRjF,EAAGJ,KAAKnC,EAAOiI,KAEtBzF,GAAQ/C,EAAOJ,WAAa,IAC7BiD,EAAQ4E,KAAKzH,GACbwI,GAAgBxI,EAAOJ,YAGvBmD,GAAQxC,GAAQiI,EAChB,KACOF,MAAK/H,cAAekI,WAClBlI,EAAOiI,UAEdzF,GACZ,MAAO4F,IACJJ,GAAQ,IAA8B,mBAAbzF,EAAG8F,aAAgC9F,EAAG8F,MAAMD,YAE3D,IAAVJ,GAA0C,mBAAdzF,EAAGyE,cAAiCzE,EAAGyE,UA5GxDsB,CAAqBpJ,IAErCqJ,cAA8CrJ,GACnC+C,EAiHfQ,gBAA8DvD,GAE1D,IACgCO,EAC5BsI,EAAsB/H,EAFtBwC,GAAO,EAAOwF,GAAQ,EACtB1F,EAAwB,GACY2F,EAAe,EAEvD,SAASC,IACL,MAAY,SAARH,EACOhN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GAAM,KAEzCP,EAAQ6C,EAAS2F,GAAgBlN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GACpDP,KAIRsI,MAAK/H,cAAqB,MAG7B,IAAIuC,EAAK,IAAIiG,EAAmBtJ,GAEhC,IACI,GAWI,KATGsD,OAAMlH,MAAOmE,GAAW0I,MAAMnI,EAAOiI,SAC5B1F,EAAS,UAAEiF,SACXjF,EAAS,KAAEvC,EAAOiI,KAEzBzF,GAAQ/C,EAAOJ,WAAa,IAC7BiD,EAAQ4E,KAAKnM,OAAA8M,EAAA,aAAA9M,CAAa0E,IAC1BwI,GAAgBxI,EAAOJ,YAGvBmD,GAAQxC,GAAQiI,EAChB,KACOF,MAAK/H,cAAekI,WAClBlI,EAAOiI,UAEdzF,GACZ,MAAO4F,IACJJ,GAAQ,UAAgBzF,EAAW,OAAE6F,YAE3B,IAAVJ,QAA0BzF,EAAW,SAChCrD,EAAe,QAAKqD,EAAGkG,eA3JjBF,CAAiBrJ,IAEjCwJ,eAAeC,GACJ1G,EAqQfQ,gBAA+BkG,GAE3B,IAGIZ,EAAsB/H,EACMP,EAJ5BmJ,EAAkB,GAClBC,EAAmB,QACnBrG,GAAO,EAAOsG,EAAoB,KACEb,EAAe,EACnD3F,EAAwB,GAE5B,SAAS4F,IACL,MAAY,SAARH,EACOhN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GAAM,KAEzCP,EAAQ6C,EAAS2F,GAAgBlN,OAAA8M,EAAA,gBAAA9M,CAAgBuH,EAAStC,GACpDP,GAQX,KAHGsI,MAAK/H,cAAqB,MAGxB2I,EAAsB,MAAK,aAAa,IAAInJ,WAAW,GAE5D,IAEIoJ,EAAO,GAAKG,EAAQJ,EAAQ,OAC5BC,EAAO,GAAKG,EAAQJ,EAAQ,SAE5B,EAAG,CAOC,GANAC,EAAO,GAAKG,EAAQJ,EAAQ,aAG3BE,EAAOC,SAAalC,QAAQoC,KAAKJ,EAAOK,IAAK1I,GAAMA,EAAE,KAGxC,UAAVsI,EAAqB,MAsBzB,IArBMrG,EAAiB,QAAVqG,KAEJK,SAASlJ,EAAOiI,IAGjBxI,EAAS1E,OAAA8M,EAAA,aAAA9M,CAAa4N,EAAa,KAAE3I,EAAOiI,KAKjC5I,WAAcW,EAAOiI,IAC5BxI,EAAS1E,OAAA8M,EAAA,aAAA9M,CAAa4N,EAAa,UAAEnB,KARzC/H,EAAS1E,OAAA8M,EAAA,aAAA9M,CAAa4N,EAAa,UAAEnB,IAYrC/H,EAAOJ,WAAa,IACpBiD,EAAQ4E,KAAKzH,GACbwI,GAAgBxI,EAAOJ,aAI3BmD,GAAQxC,GAAQiI,EAChB,KACOF,MAAK/H,cAAekI,WAClBlI,EAAOiI,UAEdzF,iBAKd,SAAgDoG,EAAiBE,GAE7D,OADArJ,EAAS6C,EAAgB,KAClB,IAAIsE,QAAWnE,MAAO2E,EAASG,KAClC,IAAK,MAAO4B,EAAKC,KAAOR,EACpBD,EAAY,IAAEQ,EAAKC,GAEvB,IAII,MAAMC,EAAWV,EAAwB,QACzCU,GAAWA,EAAQ7O,KAAKmO,EAAQG,GAChCA,OAAMtB,EACR,MAAOY,GAAKU,EAAMV,GAAKU,UACd,MAAPA,EAAcvB,EAAOuB,GAAO1B,OAjB9BkC,CAAQV,EAAkB,UAAVC,EAAoBC,EAAM,OArUpCJ,CAAeC,IAG/BnE,YAAetF,EAAwC4G,GACnD,MAAU9B,MAAM,oDAGpBQ,aAAgBtF,EAAwC4G,GACpD,MAAU9B,MAAM,sDAKxB,MAAM/B,EAAsDC,IAAkBA,EAASC,OAAeD,GAgJtG,MAAMsG,EAOFhE,YAAoBtF,GAAAqG,KAAArG,SAJZqG,KAAAgE,WAA8C,KAC9ChE,KAAAiE,cAAuD,KAI3D,IACIjE,KAAKkE,gBAAkBlE,KAAKmE,OAASnE,KAAKoE,iBAC5C,MAAOvB,GACL7C,KAAKkE,eAAmBlE,KAAKmE,OAASnE,KAAKqE,qBAInD9C,aACI,OAAOvB,KAAKmE,OAASnE,KAAKmE,OAAe,OAAEG,MAAM,QAAYjD,QAAQQ,UAGzE5C,cACQe,KAAKmE,QACLnE,KAAKmE,OAAOjB,cAEhBlD,KAAKmE,OAASnE,KAAKgE,WAAahE,KAAKiE,cAAgB,KAGzDhF,aAAauC,GACT,MAAM2C,OAAEA,EAAMxK,OAAEA,GAAWqG,KAC3BmE,SAAiBA,EAAe,OAAE3C,GAAQ8C,MAAM,QAChD3K,GAAWA,EAAe,QAAKqG,KAAKkD,cAGxCjE,WAAWxE,GACP,GAAa,IAATA,EACA,MAAO,CAAEwC,KAAqB,MAAf+C,KAAKmE,OAAgBpO,MAAO,IAAIkE,WAAW,IAE9D,MAAMU,EAAUqF,KAAKkE,cAAgC,iBAATzJ,QAEhCuF,KAAKuE,mBAAmB9J,SADxBuF,KAAKqE,mBAAmBG,OAGpC,OADC7J,EAAOsC,OAAStC,EAAO5E,MAAQP,OAAA8M,EAAA,aAAA9M,CAAamF,IACtCA,EAGHsE,mBAWJ,OAVIe,KAAKgE,YAAchE,KAAKkD,cACvBlD,KAAKiE,gBACNjE,KAAKiE,cAAgBjE,KAAKrG,OAAkB,YAM5CqG,KAAKiE,cAAsB,OAAEK,MAAM,SAE/BtE,KAAKmE,OAASnE,KAAKiE,cAGvBhF,gBAWJ,OAVIe,KAAKiE,eAAiBjE,KAAKkD,cAC1BlD,KAAKgE,aACNhE,KAAKgE,WAAahE,KAAKrG,OAAkB,UAAE,CAAE1D,KAAM,SAMnD+J,KAAKgE,WAAmB,OAAEM,MAAM,SAE5BtE,KAAKmE,OAASnE,KAAKgE,WAKvB/E,yBAAyBxE,GAC7B,aAKRyC,eAAeuH,EAASN,EAAkCjK,EAAyBqB,EAAgBd,GAC/F,GAAIc,GAAUd,EACV,MAAO,CAAEwC,MAAM,EAAOlH,MAAO,IAAIkE,WAAWC,EAAQ,EAAGO,IAE3D,MAAMwC,KAAEA,EAAIlH,MAAEA,SAAgBoO,EAAOK,KAAK,IAAIvK,WAAWC,EAAQqB,EAAQd,EAAOc,IAChF,IAAMA,GAAUxF,EAAM+D,YAAcW,IAAUwC,EAC1C,aAAawH,EAASN,EAAQpO,EAAMmE,OAAQqB,EAAQd,GAExD,MAAO,CAAEwC,OAAMlH,MAAO,IAAIkE,WAAWlE,EAAMmE,OAAQ,EAAGqB,IAbrCkJ,CAASzE,KAAKoE,gBAAiB,IAAI3K,YAAYgB,GAAO,EAAGA,IAqB9E,MAAM+I,EAAU,CAAmBJ,EAA+BE,KAC9D,IACIzB,EADA6C,EAAWxC,GAAWL,EAAQ,CAACyB,EAAOpB,IAE1C,MAAO,CAACoB,EAAOoB,EAAS,IAAIrD,QACvBzL,IAAOiM,EAAUjM,IAAMwN,EAAa,KAAEE,EAAOoB,oCCvStD9P,EAAAQ,EAAA0B,EAAA,sBAAA6N,IAiBA,IAAAA,EAAA,GAKAA,EAAAC,OAQAD,EAAAE,MAMAF,EAAAG,aAAA,EAMAH,EAAAI,WAAA,EAMAJ,EAAAK,uBAAA,EAKAL,EAAAM,SAAA,CACAC,WAAA,EACAC,aAAA,GAOAR,EAAAS,MAAA,IAAAhJ,WAAA,GAMAuI,EAAAU,QAAA,IAAA9I,aAAAoI,EAAAS,MAAAlL,QAMAyK,EAAAW,QAAA,IAAA9I,aAAAmI,EAAAS,MAAAlL,QAMAyK,EAAAY,eAAA,QAAAlJ,YAAA,IAAApC,WAAA,OAAAC,QAAA,GASAyK,EAAAa,KAAA,SAAAC,EAAAC,GAKA1F,KAAAyF,IAAA,EAAAA,EAMAzF,KAAA0F,KAAA,EAAAA,GAQAf,EAAAa,KAAApP,OAAA,SAAAqP,EAAAC,GAEA,UAAAD,GAAA,GAAAC,EAAAf,EAAAa,KAAAG,KAAA,IAAAhB,EAAAa,KAAAC,EAAAC,IAMAf,EAAAa,KAAA9O,UAAAkP,UAAA,WACA,OAAA5F,KAAAyF,MAAA,cAAAzF,KAAA0F,MAOAf,EAAAa,KAAA9O,UAAAmP,OAAA,SAAAC,GACA,OAAA9F,KAAAyF,KAAAK,EAAAL,KAAAzF,KAAA0F,MAAAI,EAAAJ,MAOAf,EAAAa,KAAAG,KAAA,IAAAhB,EAAAa,KAAA,KAUAb,EAAAoB,QAAA,SAAAC,GACA,GAAAA,EAGAC,EAAAD,OAFA,IAAAC,EAAA,KASAjG,KAAAkG,GAAAvB,EAAArL,WAAA6M,SAAAF,GAQAjG,KAAAoG,MAAAH,EAQAjG,KAAAqG,SAAA,EAQArG,KAAAsG,OAAA,KAQAtG,KAAAuG,cAAA,EAQAvG,KAAAwG,UAAA,EAQAxG,KAAAyG,aAAA,EAQAzG,KAAA0G,QAAA,GAQA1G,KAAA2G,iBAAA,EAQA3G,KAAA4G,gBAAA,GAGAjC,EAAAoB,QAAArP,UAAAmQ,MAAA,WACA7G,KAAAkG,GAAAW,QACA7G,KAAAoG,MAAApG,KAAAkG,GAAAY,WACA9G,KAAAqG,SAAA,EACArG,KAAAsG,OAAA,KACAtG,KAAAuG,cAAA,EACAvG,KAAAwG,UAAA,EACAxG,KAAAyG,aAAA,EACAzG,KAAA0G,QAAA,GACA1G,KAAA2G,iBAAA,EACA3G,KAAA4G,gBAAA,GAUAjC,EAAAoB,QAAArP,UAAAqQ,cAAA,SAAAA,GACA/G,KAAA4G,eAAAG,GAUApC,EAAAoB,QAAArP,UAAAsQ,WAAA,WACA,OAAAhH,KAAAkG,IASAvB,EAAAoB,QAAArP,UAAAuQ,aAAA,WACA,OAAAjH,KAAAkG,GAAApK,QAAAJ,SAAAsE,KAAAkG,GAAAgB,WAAAlH,KAAAkG,GAAAgB,WAAAlH,KAAAzE,WAaAoJ,EAAAoB,QAAArP,UAAAyQ,KAAA,SAAA1M,EAAA2M,GAEA3M,EAAAuF,KAAAqG,WACArG,KAAAqG,SAAA5L,GAQA,IAHA,IAAA4M,EAAA,IAAArH,KAAAkG,GAAAY,WAAA9G,KAAAoG,MAAAgB,GAAA3M,EAAA,EAGAuF,KAAAoG,MAAAiB,EAAA5M,EAAA2M,GAAA,CACA,IAAAE,EAAAtH,KAAAkG,GAAAY,WACA9G,KAAAkG,GAAAvB,EAAAoB,QAAAwB,eAAAvH,KAAAkG,IACAlG,KAAAoG,OAAApG,KAAAkG,GAAAY,WAAAQ,EAGAtH,KAAAwH,IAAAH,IAMA1C,EAAAoB,QAAArP,UAAA8Q,IAAA,SAAAC,GACA,QAAA3S,EAAA,EAAiBA,EAAA2S,EAAe3S,IAChCkL,KAAAkG,GAAAwB,YAAA1H,KAAAoG,MAAA,IAOAzB,EAAAoB,QAAArP,UAAAgR,UAAA,SAAA3R,GACAiK,KAAAkG,GAAAwB,UAAA1H,KAAAoG,OAAA,EAAArQ,IAMA4O,EAAAoB,QAAArP,UAAAiR,WAAA,SAAA5R,GACAiK,KAAAkG,GAAAyB,WAAA3H,KAAAoG,OAAA,EAAArQ,IAMA4O,EAAAoB,QAAArP,UAAAkR,WAAA,SAAA7R,GACAiK,KAAAkG,GAAA0B,WAAA5H,KAAAoG,OAAA,EAAArQ,IAMA4O,EAAAoB,QAAArP,UAAAmR,WAAA,SAAA9R,GACAiK,KAAAkG,GAAA2B,WAAA7H,KAAAoG,OAAA,EAAArQ,IAMA4O,EAAAoB,QAAArP,UAAAoR,aAAA,SAAA/R,GACAiK,KAAAkG,GAAA4B,aAAA9H,KAAAoG,OAAA,EAAArQ,IAMA4O,EAAAoB,QAAArP,UAAAqR,aAAA,SAAAhS,GACAiK,KAAAkG,GAAA6B,aAAA/H,KAAAoG,OAAA,EAAArQ,IAQA4O,EAAAoB,QAAArP,UAAAsR,QAAA,SAAAjS,GACAiK,KAAAmH,KAAA,KACAnH,KAAA0H,UAAA3R,IAOA4O,EAAAoB,QAAArP,UAAAuR,SAAA,SAAAlS,GACAiK,KAAAmH,KAAA,KACAnH,KAAA2H,WAAA5R,IAOA4O,EAAAoB,QAAArP,UAAAwR,SAAA,SAAAnS,GACAiK,KAAAmH,KAAA,KACAnH,KAAA4H,WAAA7R,IAOA4O,EAAAoB,QAAArP,UAAAyR,SAAA,SAAApS,GACAiK,KAAAmH,KAAA,KACAnH,KAAA6H,WAAA9R,IAOA4O,EAAAoB,QAAArP,UAAA0R,WAAA,SAAArS,GACAiK,KAAAmH,KAAA,KACAnH,KAAA8H,aAAA/R,IAOA4O,EAAAoB,QAAArP,UAAA2R,WAAA,SAAAtS,GACAiK,KAAAmH,KAAA,KACAnH,KAAA+H,aAAAhS,IASA4O,EAAAoB,QAAArP,UAAA4R,aAAA,SAAAC,EAAAxS,EAAAyS,IACAxI,KAAA4G,gBAAA7Q,GAAAyS,KACAxI,KAAAgI,QAAAjS,GACAiK,KAAAyI,KAAAF,KASA5D,EAAAoB,QAAArP,UAAAgS,cAAA,SAAAH,EAAAxS,EAAAyS,IACAxI,KAAA4G,gBAAA7Q,GAAAyS,KACAxI,KAAAiI,SAAAlS,GACAiK,KAAAyI,KAAAF,KASA5D,EAAAoB,QAAArP,UAAAiS,cAAA,SAAAJ,EAAAxS,EAAAyS,IACAxI,KAAA4G,gBAAA7Q,GAAAyS,KACAxI,KAAAkI,SAAAnS,GACAiK,KAAAyI,KAAAF,KASA5D,EAAAoB,QAAArP,UAAAkS,cAAA,SAAAL,EAAAxS,EAAAyS,IACAxI,KAAA4G,gBAAA7Q,EAAA8P,OAAA2C,KACAxI,KAAAmI,SAAApS,GACAiK,KAAAyI,KAAAF,KASA5D,EAAAoB,QAAArP,UAAAmS,gBAAA,SAAAN,EAAAxS,EAAAyS,IACAxI,KAAA4G,gBAAA7Q,GAAAyS,KACAxI,KAAAoI,WAAArS,GACAiK,KAAAyI,KAAAF,KASA5D,EAAAoB,QAAArP,UAAAoS,gBAAA,SAAAP,EAAAxS,EAAAyS,IACAxI,KAAA4G,gBAAA7Q,GAAAyS,KACAxI,KAAAqI,WAAAtS,GACAiK,KAAAyI,KAAAF,KASA5D,EAAAoB,QAAArP,UAAAqS,eAAA,SAAAR,EAAAxS,EAAAyS,IACAxI,KAAA4G,gBAAA7Q,GAAAyS,KACAxI,KAAAgJ,UAAAjT,GACAiK,KAAAyI,KAAAF,KAWA5D,EAAAoB,QAAArP,UAAAuS,eAAA,SAAAV,EAAAxS,EAAAyS,GACAzS,GAAAyS,IACAxI,KAAAkJ,OAAAnT,GACAiK,KAAAyI,KAAAF,KAWA5D,EAAAoB,QAAArP,UAAAwS,OAAA,SAAAC,GACA,GAAAA,GAAAnJ,KAAAzE,SACA,MAAAkD,MAAA,mDAQAkG,EAAAoB,QAAArP,UAAA0S,UAAA,WACA,GAAApJ,KAAAwG,SACA,MAAA/H,MAAA,0DASAkG,EAAAoB,QAAArP,UAAA+R,KAAA,SAAAF,GACAvI,KAAAsG,OAAAiC,GAAAvI,KAAAzE,UAMAoJ,EAAAoB,QAAArP,UAAA6E,OAAA,WACA,OAAAyE,KAAAkG,GAAAY,WAAA9G,KAAAoG,OAeAzB,EAAAoB,QAAAwB,eAAA,SAAArB,GACA,IAAAoB,EAAApB,EAAAY,WAGA,cAAAQ,EACA,MAAA7I,MAAA,uDAGA,IAAA4K,EAAA/B,GAAA,EACAgC,EAAA3E,EAAArL,WAAA6M,SAAAkD,GAGA,OAFAC,EAAAC,YAAAF,EAAA/B,GACAgC,EAAAxN,QAAAvB,IAAA2L,EAAApK,QAAAuN,EAAA/B,GACAgC,GASA3E,EAAAoB,QAAArP,UAAAsS,UAAA,SAAAzN,GACAyE,KAAAmH,KAAAxC,EAAAI,WAAA,GACA/E,KAAA4H,WAAA5H,KAAAzE,WAAAoJ,EAAAI,aAWAJ,EAAAoB,QAAArP,UAAA8S,YAAA,SAAAC,GACAzJ,KAAAoJ,YACA,MAAApJ,KAAAsG,SACAtG,KAAAsG,OAAA,IAEAtG,KAAAuG,cAAAkD,EACA,QAAA3U,EAAA,EAAiBA,EAAA2U,EAAe3U,IAChCkL,KAAAsG,OAAAxR,GAAA,EAEAkL,KAAAwG,UAAA,EACAxG,KAAAyG,aAAAzG,KAAAzE,UAQAoJ,EAAAoB,QAAArP,UAAAgT,UAAA,WACA,SAAA1J,KAAAsG,SAAAtG,KAAAwG,SACA,MAAA/H,MAAA,qDAGAuB,KAAAkI,SAAA,GAKA,IAJA,IAAAyB,EAAA3J,KAAAzE,SAGAzG,EAAAkL,KAAAuG,cAAA,EACQzR,GAAA,MAAAkL,KAAAsG,OAAAxR,GAA+BA,KAIvC,IAHA,IAAA8U,EAAA9U,EAAA,EAGQA,GAAA,EAAQA,IAEhBkL,KAAAiI,SAAA,GAAAjI,KAAAsG,OAAAxR,GAAA6U,EAAA3J,KAAAsG,OAAAxR,GAAA,GAIAkL,KAAAiI,SAAA0B,EAAA3J,KAAAyG,cACA,IAAAoD,GAAAD,EAFA,GAEAjF,EAAAG,aACA9E,KAAAiI,SAAA4B,GAGA,IAAAC,EAAA,EACAC,EAAA/J,KAAAoG,MACA4D,EACA,IAAAlV,EAAA,EAAaA,EAAAkL,KAAA0G,QAAAvL,OAAyBrG,IAAA,CACtC,IAAAmV,EAAAjK,KAAAkG,GAAAY,WAAA9G,KAAA0G,QAAA5R,GACA,GAAA+U,GAAA7J,KAAAkG,GAAAgE,UAAAD,GAAA,CACA,QAAA/O,EAAAyJ,EAAAG,aAA4C5J,EAAA2O,EAAS3O,GAAAyJ,EAAAG,aACrD,GAAA9E,KAAAkG,GAAAgE,UAAAH,EAAA7O,IAAA8E,KAAAkG,GAAAgE,UAAAD,EAAA/O,GACA,SAAA8O,EAGAF,EAAA9J,KAAA0G,QAAA5R,GACA,OAqBA,OAjBAgV,GAGA9J,KAAAoG,MAAApG,KAAAkG,GAAAY,WAAA6C,EAGA3J,KAAAkG,GAAA0B,WAAA5H,KAAAoG,MAAA0D,EAAAH,KAIA3J,KAAA0G,QAAA/E,KAAA3B,KAAAzE,UAGAyE,KAAAkG,GAAA0B,WAAA5H,KAAAkG,GAAAY,WAAA6C,EAAA3J,KAAAzE,SAAAoO,IAGA3J,KAAAwG,UAAA,EACAmD,GAUAhF,EAAAoB,QAAArP,UAAAyT,OAAA,SAAAC,EAAAC,GACA,GAAAA,EAAA,CACA,IAAAC,EAAAD,EAGA,GAFArK,KAAAmH,KAAAnH,KAAAqG,SAAA1B,EAAAI,WACAJ,EAAAK,wBACAsF,EAAAnP,QAAAwJ,EAAAK,uBACA,MAAAvG,MAAA,+CACAkG,EAAAK,wBAEA,QAAAlQ,EAAA6P,EAAAK,uBAAA,EAAwDlQ,GAAA,EAAQA,IAChEkL,KAAA0H,UAAA4C,EAAAC,WAAAzV,IAGAkL,KAAAmH,KAAAnH,KAAAqG,SAAA1B,EAAAI,YACA/E,KAAAgJ,UAAAoB,GACApK,KAAAkG,GAAAqD,YAAAvJ,KAAAoG,QAWAzB,EAAAoB,QAAArP,UAAA8T,cAAA,SAAAC,EAAAC,GACA,IAAAC,EAAA3K,KAAAkG,GAAAY,WAAA2D,EACAG,EAAAD,EAAA3K,KAAAkG,GAAA2E,UAAAF,GAIA,KAHA,GAAA3K,KAAAkG,GAAAgE,UAAAU,EAAAF,IAIA,MAAAjM,MAAA,sBAAAiM,EAAA,iBAaA/F,EAAAoB,QAAArP,UAAAoU,YAAA,SAAAC,EAAAC,EAAAC,GACAjL,KAAAoJ,YACApJ,KAAA2G,iBAAAqE,EACAhL,KAAAmH,KAAAxC,EAAAI,WAAAgG,EAAAC,GACAhL,KAAAmH,KAAA8D,EAAAF,EAAAC,IAUArG,EAAAoB,QAAArP,UAAAwU,UAAA,WAEA,OADAlL,KAAA4H,WAAA5H,KAAA2G,kBACA3G,KAAAzE,UAWAoJ,EAAAoB,QAAArP,UAAAyU,aAAA,SAAAtU,GACA,GAAAA,aAAAoD,WACA,IAAAmR,EAAAvU,MAEA,CAAAuU,EAAA,GAGA,IAHA,IACAtW,EAAA,EAEAA,EAAA+B,EAAAsE,QAAA,CACA,IAAAkQ,EAGA/N,EAAAzG,EAAA0T,WAAAzV,KACA,GAAAwI,EAAA,OAAAA,GAAA,MACA+N,EAAA/N,OAGA+N,GAAA/N,GAAA,IADAzG,EAAA0T,WAAAzV,MACA,SAIAuW,EAAA,IACAD,EAAAzJ,KAAA0J,IAEAA,EAAA,KACAD,EAAAzJ,KAAA0J,GAAA,WAEAA,EAAA,MACAD,EAAAzJ,KAAA0J,GAAA,WAEAD,EAAAzJ,KACA0J,GAAA,SACAA,GAAA,WAEAD,EAAAzJ,KAAA0J,GAAA,WAEAD,EAAAzJ,KAAA,GAAA0J,EAAA,OAKArL,KAAAgI,QAAA,GACAhI,KAAA8K,YAAA,EAAAM,EAAAjQ,OAAA,GACA6E,KAAAkG,GAAAqD,YAAAvJ,KAAAoG,OAAAgF,EAAAjQ,QACArG,EAAA,UAAAyG,EAAAyE,KAAAoG,MAAAtK,EAAAkE,KAAAkG,GAAApK,QAA+DhH,EAAAsW,EAAAjQ,OAAiBrG,IAChFgH,EAAAP,KAAA6P,EAAAtW,GAEA,OAAAkL,KAAAkL,aAUAvG,EAAAoB,QAAArP,UAAA4U,WAAA,SAAA7F,EAAAC,GACA,OAAAf,EAAAa,KAAApP,OAAAqP,EAAAC,IAUAf,EAAArL,WAAA,SAAAwC,GAKAkE,KAAAuL,OAAAzP,EAMAkE,KAAAwL,UAAA,GASA7G,EAAArL,WAAA6M,SAAA,SAAAsB,GACA,WAAA9C,EAAArL,WAAA,IAAAW,WAAAwN,KAGA9C,EAAArL,WAAA5C,UAAAmQ,MAAA,WACA7G,KAAAwL,UAAA,GAQA7G,EAAArL,WAAA5C,UAAAoF,MAAA,WACA,OAAAkE,KAAAuL,QAQA5G,EAAArL,WAAA5C,UAAAwQ,SAAA,WACA,OAAAlH,KAAAwL,WAQA7G,EAAArL,WAAA5C,UAAA6S,YAAA,SAAArC,GACAlH,KAAAwL,UAAAtE,GAQAvC,EAAArL,WAAA5C,UAAAoQ,SAAA,WACA,OAAA9G,KAAAuL,OAAApQ,QAOAwJ,EAAArL,WAAA5C,UAAA+U,SAAA,SAAAlQ,GACA,OAAAyE,KAAA0L,UAAAnQ,IAAA,QAOAoJ,EAAArL,WAAA5C,UAAAgV,UAAA,SAAAnQ,GACA,OAAAyE,KAAAuL,OAAAhQ,IAOAoJ,EAAArL,WAAA5C,UAAAwT,UAAA,SAAA3O,GACA,OAAAyE,KAAA2L,WAAApQ,IAAA,QAOAoJ,EAAArL,WAAA5C,UAAAiV,WAAA,SAAApQ,GACA,OAAAyE,KAAAuL,OAAAhQ,GAAAyE,KAAAuL,OAAAhQ,EAAA,OAOAoJ,EAAArL,WAAA5C,UAAAmU,UAAA,SAAAtP,GACA,OAAAyE,KAAAuL,OAAAhQ,GAAAyE,KAAAuL,OAAAhQ,EAAA,MAAAyE,KAAAuL,OAAAhQ,EAAA,OAAAyE,KAAAuL,OAAAhQ,EAAA,QAOAoJ,EAAArL,WAAA5C,UAAAkV,WAAA,SAAArQ,GACA,OAAAyE,KAAA6K,UAAAtP,KAAA,GAOAoJ,EAAArL,WAAA5C,UAAAmV,UAAA,SAAAtQ,GACA,WAAAoJ,EAAAa,KAAAxF,KAAA6K,UAAAtP,GAAAyE,KAAA6K,UAAAtP,EAAA,KAOAoJ,EAAArL,WAAA5C,UAAAoV,WAAA,SAAAvQ,GACA,WAAAoJ,EAAAa,KAAAxF,KAAA4L,WAAArQ,GAAAyE,KAAA4L,WAAArQ,EAAA,KAOAoJ,EAAArL,WAAA5C,UAAAqV,YAAA,SAAAxQ,GAEA,OADAoJ,EAAAS,MAAA,GAAApF,KAAA6K,UAAAtP,GACAoJ,EAAAU,QAAA,IAOAV,EAAArL,WAAA5C,UAAAsV,YAAA,SAAAzQ,GAGA,OAFAoJ,EAAAS,MAAAT,EAAAY,eAAA,KAAAvF,KAAA6K,UAAAtP,GACAoJ,EAAAS,MAAAT,EAAAY,eAAA,KAAAvF,KAAA6K,UAAAtP,EAAA,GACAoJ,EAAAW,QAAA,IAOAX,EAAArL,WAAA5C,UAAAgR,UAAA,SAAAnM,EAAAxF,GACAiK,KAAAuL,OAAAhQ,GAA0C,GAO1CoJ,EAAArL,WAAA5C,UAAAuV,WAAA,SAAA1Q,EAAAxF,GACAiK,KAAAuL,OAAAhQ,GAAAxF,GAOA4O,EAAArL,WAAA5C,UAAAiR,WAAA,SAAApM,EAAAxF,GACAiK,KAAAuL,OAAAhQ,GAAAxF,EACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,GAOA4O,EAAArL,WAAA5C,UAAAwV,YAAA,SAAA3Q,EAAAxF,GACAiK,KAAAuL,OAAAhQ,GAAAxF,EACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,GAOA4O,EAAArL,WAAA5C,UAAAkR,WAAA,SAAArM,EAAAxF,GACAiK,KAAAuL,OAAAhQ,GAAAxF,EACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,EACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,GACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,IAOA4O,EAAArL,WAAA5C,UAAAyV,YAAA,SAAA5Q,EAAAxF,GACAiK,KAAAuL,OAAAhQ,GAAAxF,EACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,EACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,GACAiK,KAAAuL,OAAAhQ,EAAA,GAAAxF,GAAA,IAOA4O,EAAArL,WAAA5C,UAAAmR,WAAA,SAAAtM,EAAAxF,GACAiK,KAAA4H,WAAArM,EAAAxF,EAAA0P,KACAzF,KAAA4H,WAAArM,EAAA,EAAAxF,EAAA2P,OAOAf,EAAArL,WAAA5C,UAAA0V,YAAA,SAAA7Q,EAAAxF,GACAiK,KAAAmM,YAAA5Q,EAAAxF,EAAA0P,KACAzF,KAAAmM,YAAA5Q,EAAA,EAAAxF,EAAA2P,OAOAf,EAAArL,WAAA5C,UAAAoR,aAAA,SAAAvM,EAAAxF,GACA4O,EAAAU,QAAA,GAAAtP,EACAiK,KAAA4H,WAAArM,EAAAoJ,EAAAS,MAAA,KAOAT,EAAArL,WAAA5C,UAAAqR,aAAA,SAAAxM,EAAAxF,GACA4O,EAAAW,QAAA,GAAAvP,EACAiK,KAAA4H,WAAArM,EAAAoJ,EAAAS,MAAAT,EAAAY,eAAA,MACAvF,KAAA4H,WAAArM,EAAA,EAAAoJ,EAAAS,MAAAT,EAAAY,eAAA,OASAZ,EAAArL,WAAA5C,UAAA2V,oBAAA,WACA,GAAArM,KAAAuL,OAAApQ,OAAA6E,KAAAwL,UAAA7G,EAAAI,WACAJ,EAAAK,uBACA,MAAAvG,MACA,kEAGA,IADA,IAAA9D,EAAA,GACA7F,EAAA,EAAiBA,EAAA6P,EAAAK,uBAAwClQ,IACzD6F,GAAA2R,OAAAC,aACAvM,KAAAyL,SAAAzL,KAAAwL,UAAA7G,EAAAI,WAAAjQ,IAEA,OAAA6F,GAWAgK,EAAArL,WAAA5C,UAAA8V,SAAA,SAAAC,EAAAC,GACA,IAAApG,EAAAmG,EAAAzM,KAAA6K,UAAA4B,GACA,OAAAC,EAAA1M,KAAAkK,UAAA5D,GAAAtG,KAAAkK,UAAA5D,EAAAoG,GAAA,GAUA/H,EAAArL,WAAA5C,UAAAiW,QAAA,SAAA3W,EAAAuF,GAGA,OAFAvF,EAAAyW,OAAAlR,EAAAyE,KAAA6K,UAAAtP,GACAvF,EAAAkQ,GAAAlG,KACAhK,GAgBA2O,EAAArL,WAAA5C,UAAAkW,SAAA,SAAArR,EAAAsR,GACAtR,GAAAyE,KAAA6K,UAAAtP,GAEA,IAAAJ,EAAA6E,KAAA6K,UAAAtP,GACAZ,EAAA,GACA7F,EAAA,EAIA,GAFAyG,GAAAoJ,EAAAI,WAEA8H,IAAAlI,EAAAM,SAAAC,WACA,OAAAlF,KAAAuL,OAAA7P,SAAAH,IAAAJ,GAGA,KAAArG,EAAAqG,GAAA,CACA,IAAAkQ,EAGA/N,EAAA0C,KAAA0L,UAAAnQ,EAAAzG,KACA,GAAAwI,EAAA,IACA+N,EAAA/N,MACK,CACL,IAAAhC,EAAA0E,KAAA0L,UAAAnQ,EAAAzG,KACA,GAAAwI,EAAA,IACA+N,GACA,GAAA/N,IAAA,EACA,GAAAhC,MACO,CACP,IAAAnG,EAAA6K,KAAA0L,UAAAnQ,EAAAzG,KACA,GAAAwI,EAAA,IACA+N,GACA,GAAA/N,IAAA,IACA,GAAAhC,IAAA,EACA,GAAAnG,OAGAkW,GACA,EAAA/N,IAAA,IACA,GAAAhC,IAAA,IACA,GAAAnG,IAAA,EACA,GALA6K,KAAA0L,UAAAnQ,EAAAzG,MAYA6F,GADA0Q,EAAA,MACAiB,OAAAC,aAAAlB,GAGAiB,OAAAC,aACA,QAFAlB,GAAA,QAEA,IACA,YAAAA,IAIA,OAAA1Q,GAQAgK,EAAArL,WAAA5C,UAAAoW,WAAA,SAAAvR,GACA,OAAAA,EAAAyE,KAAA6K,UAAAtP,IASAoJ,EAAArL,WAAA5C,UAAAqW,SAAA,SAAAxR,GACA,OAAAA,EAAAyE,KAAA6K,UAAAtP,GAAAoJ,EAAAI,YASAJ,EAAArL,WAAA5C,UAAAsW,aAAA,SAAAzR,GACA,OAAAyE,KAAA6K,UAAAtP,EAAAyE,KAAA6K,UAAAtP,KAOAoJ,EAAArL,WAAA5C,UAAAuW,iBAAA,SAAAC,GACA,GAAAA,EAAA/R,QAAAwJ,EAAAK,uBACA,MAAAvG,MAAA,+CACAkG,EAAAK,wBAEA,QAAAlQ,EAAA,EAAiBA,EAAA6P,EAAAK,uBAAwClQ,IACzD,GAAAoY,EAAA3C,WAAAzV,IAAAkL,KAAAyL,SAAAzL,KAAAwL,UAAA7G,EAAAI,WAAAjQ,GACA,SAGA,UAUA6P,EAAArL,WAAA5C,UAAA4U,WAAA,SAAA7F,EAAAC,GACA,OAAAf,EAAAa,KAAApP,OAAAqP,EAAAC,mCC9sCA,SAAAyH,GAAAvY,EAAAQ,EAAA0B,EAAA,sBAAAsW,IAAAxY,EAAAQ,EAAA0B,EAAA,sBAAAuW,IAAA,IAAAC,EAAA1Y,EAAA,GAAA2Y,EAAA3Y,EAAA,GAwBA,MAAM4Y,EAA4B,mBAAXL,EAAwBA,EAAS,KAElDM,EAA2C,mBAAhBC,aAAqD,mBAAhBC,YAGzDP,EAAa,CAAEM,IACxB,GAAID,IAAsBD,EAAS,CAC/B,MAAMI,EAAU,IAAIF,EAAY,SAChC,OAAQxT,GAA2C0T,EAAQC,OAAO3T,GAEtE,OAAQ2B,IACJ,MAAM3B,OAAEA,EAAMC,WAAEA,EAAUgB,OAAEA,GAAW3F,OAAA8X,EAAA,aAAA9X,CAAaqG,GACpD,OAAO2R,EAAQvR,KAAK/B,EAAQC,EAAYgB,GAAQ2S,aAP9B,CASA,oBAAhBJ,YAA8BA,YAAcH,EAAA,GAGzCF,EAAa,CAAEM,IACxB,GAAIF,IAAsBD,EAAS,CAC/B,MAAMO,EAAU,IAAIJ,EACpB,OAAQ5X,GAAmBgY,EAAQC,OAAOjY,GAE9C,MAAO,CAAC8F,EAAQ,KAAOrG,OAAA8X,EAAA,aAAA9X,CAAagY,EAAQvR,KAAKJ,EAAO,UALlC,CAMA,oBAAhB8R,YAA8BA,YAAcJ,EAAA,GA/CtD,4CCeA,SAAAU,EAAA3Q,EAAAhD,EAAA4T,GACA,OAAA5T,GAAAgD,MAAA4Q,EAOA,SAAAC,EAAA5Y,GACA,QAAA0M,IAAA1M,EAAA,SACA,GAAAA,IAAAC,OAAAD,GAAA,OAAAA,EACA,MAAA6Y,UAAA,4CA1BAxZ,EAAAQ,EAAA0B,EAAA,sBAAA6W,IAAA/Y,EAAAQ,EAAA0B,EAAA,sBAAA4W,IAiJA,IAAAW,GAAA,EASA,SAAAC,EAAAC,GAEAvO,KAAAuO,OAAA,GAAA5S,MAAA1G,KAAAsZ,GAGAD,EAAA5X,UAAA,CAIA8X,YAAA,WACA,OAAAxO,KAAAuO,OAAApT,QAWAqJ,KAAA,WACA,OAAAxE,KAAAuO,OAAApT,OAEA6E,KAAAuO,OAAA3M,QADAyM,GAWAI,QAAA,SAAAC,GACA,GAAAC,MAAAC,QAAAF,GAEA,IADA,IAAAH,EAA6C,EAC7CA,EAAApT,QACA6E,KAAAuO,OAAAM,QAAAN,EAAAO,YAEA9O,KAAAuO,OAAAM,QAAAH,IAWA/M,KAAA,SAAA+M,GACA,GAAAC,MAAAC,QAAAF,GAEA,IADA,IAAAH,EAA6C,EAC7CA,EAAApT,QACA6E,KAAAuO,OAAA5M,KAAA4M,EAAA3M,cAEA5B,KAAAuO,OAAA5M,KAAA+M,KAYA,IAAAK,GAAA,EAOA,SAAAC,EAAAC,EAAAC,GACA,GAAAD,EACA,MAAAb,UAAA,iBACA,OAAAc,GAAA,MA+BA,IAAAC,EAAA,QAUA,SAAAzB,EAAA0B,EAAA7O,GACA,KAAAP,gBAAA0N,GACA,WAAAA,EAAA0B,EAAA7O,GAGA,IADA6O,OAAAnN,IAAAmN,KAAA9C,IAAA+C,cAAAF,KACAA,EACA,MAAA1Q,MAAA,mDAEA8B,EAAA4N,EAAA5N,GAGAP,KAAAsP,YAAA,EAEAtP,KAAAuP,UAAA,EAEAvP,KAAAwP,SAAA,KAEAxP,KAAAyP,SAAAlP,EAAA,MAEAP,KAAA0P,aAAAnP,EAAA,UAEA/K,OAAAC,eAAAuK,KAAA,YAA2CjK,MAAA,UAC3CP,OAAAC,eAAAuK,KAAA,SAAwCjK,MAAAiK,KAAAyP,SACxCja,OAAAC,eAAAuK,KAAA,aAA4CjK,MAAAiK,KAAA0P,aA6F5C,SAAA/B,EAAAyB,EAAA7O,GACA,KAAAP,gBAAA2N,GACA,WAAAA,EAAAyB,EAAA7O,GAEA,IADA6O,OAAAnN,IAAAmN,KAAA9C,IAAA+C,cAAAF,KACAA,EACA,MAAA1Q,MAAA,mDAEA8B,EAAA4N,EAAA5N,GAGAP,KAAAsP,YAAA,EAEAtP,KAAA2P,SAAA,KAEA3P,KAAA4P,SAAA,CAAmBX,QAAA1O,EAAA,OAEnB/K,OAAAC,eAAAuK,KAAA,YAA2CjK,MAAA,UA4D3C,SAAA8Z,EAAAtP,GACA,IAAA0O,EAAA1O,EAAA0O,MAMwBa,EAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,IACAC,EAAA,IASxBlQ,KAAA0E,QAAA,SAAAtB,EAAA+M,GAGA,GAAAA,IAAA9B,GAAA,IAAA2B,EAEA,OADAA,EAAA,EACAhB,EAAAC,GAIA,GAAAkB,IAAA9B,EACA,OAAAU,EAGA,OAAAiB,EAAA,CAGA,GAAA/B,EAAAkC,EAAA,OAEA,OAAAA,EAIA,GAAAlC,EAAAkC,EAAA,SAGAH,EAAA,EACAF,EAAAK,EAAA,SAIA,GAAAlC,EAAAkC,EAAA,SAEA,MAAAA,IACAF,EAAA,KAEA,MAAAE,IACAD,EAAA,KAGAF,EAAA,EACAF,EAAAK,EAAA,QAIA,KAAAlC,EAAAkC,EAAA,SAgBA,OAAAnB,EAAAC,GAdA,MAAAkB,IACAF,EAAA,KAEA,MAAAE,IACAD,EAAA,KAGAF,EAAA,EACAF,EAAAK,EAAA,IAaA,OADAL,IAAA,EAAAE,EACA,KAKA,IAAA/B,EAAAkC,EAAAF,EAAAC,GAaA,OARAJ,EAAAE,EAAAD,EAAA,EACAE,EAAA,IACAC,EAAA,IAGA9M,EAAAqL,QAAA0B,GAGAnB,EAAAC,GAgBA,GAXAgB,EAAA,IACAC,EAAA,IAMAJ,GAAAK,EAAA,QAAAH,GADAD,GAAA,IAKAA,IAAAC,EACA,YAGA,IAAAI,EAAAN,EAOA,OAHAA,EAAAE,EAAAD,EAAA,EAGAK,GASA,SAAAC,EAAA9P,GACAA,EAAA0O,MAMAjP,KAAA0E,QAAA,SAAAtB,EAAAgN,GAEA,GAAAA,IAAA/B,EACA,OAAAU,EAIA,GAAAd,EAAAmC,EAAA,OACA,OAAAA,EAGA,IAAAE,EAAA/U,EAEA0S,EAAAmC,EAAA,WACAE,EAAA,EACA/U,EAAA,KAGA0S,EAAAmC,EAAA,aACAE,EAAA,EACA/U,EAAA,KAGA0S,EAAAmC,EAAA,iBACAE,EAAA,EACA/U,EAAA,KAQA,IAHA,IAAAO,EAAA,EAAAsU,GAAA,EAAAE,GAAA/U,GAGA+U,EAAA,IAGA,IAAAC,EAAAH,GAAA,GAAAE,EAAA,GAGAxU,EAAA6F,KAAA,OAAA4O,GAGAD,GAAA,EAIA,OAAAxU,GAxWA4R,EAAAhX,UAAA,CAMAmX,OAAA,SAAAhS,EAAA0E,GACA,IAAAzE,EAEAA,EADA,iBAAAD,gBAAApC,YACA,IAAAQ,WAAA4B,GACK,iBAAAA,GAAA,WAAAA,GACLA,EAAA3B,kBAAAT,YACA,IAAAQ,WAAA4B,EAAA3B,OACA2B,EAAA1B,WACA0B,EAAA/B,YAEA,IAAAG,WAAA,GAGAsG,EAAA4N,EAAA5N,GAEAP,KAAAsP,aACAtP,KAAAwP,SAAA,IAAAK,EAAA,CAAuCZ,MAAAjP,KAAAyP,SACvCzP,KAAAuP,UAAA,GAEAvP,KAAAsP,aAAA/O,EAAA,OASA,IAPA,IAKA5F,EALA6V,EAAA,IAAAlC,EAAAxS,GAEA2U,EAAA,IAKAD,EAAAhC,gBACA7T,EAAAqF,KAAAwP,SAAA9K,QAAA8L,IAAAhM,WACAuK,GAEA,OAAApU,IAEAgU,MAAAC,QAAAjU,GACA8V,EAAA9O,KAAA+O,MAAAD,EAAsE,GAEtEA,EAAA9O,KAAAhH,IAEA,IAAAqF,KAAAsP,WAAA,CACA,GAEA,IADA3U,EAAAqF,KAAAwP,SAAA9K,QAAA8L,IAAAhM,WACAuK,EACA,MACA,OAAApU,IAEAgU,MAAAC,QAAAjU,GACA8V,EAAA9O,KAAA+O,MAAAD,EAAwE,GAExEA,EAAA9O,KAAAhH,WACO6V,EAAAhC,eACPxO,KAAAwP,SAAA,KAqBA,OAlBAiB,EAAAtV,UAIA,cAAAwV,QAAA3Q,KAAAoP,WACApP,KAAA0P,YAAA1P,KAAAuP,WAEA,QAAAkB,EAAA,IACAzQ,KAAAuP,UAAA,EACAkB,EAAA7O,SAIA5B,KAAAuP,UAAA,IAjQA,SAAAkB,GAEA,IADA,IAAA5Z,EAAA,GACA/B,EAAA,EAAiBA,EAAA2b,EAAAtV,SAAwBrG,EAAA,CACzC,IAAA8b,EAAAH,EAAA3b,GAEA+B,GADA+Z,GAAA,MACAtE,OAAAC,aAAAqE,GAGAtE,OAAAC,aAAA,QADAqE,GAAA,QACA,IACA,YAAAA,IAGA,OAAA/Z,EA0PAga,CAAAJ,KA+BA9C,EAAAjX,UAAA,CAMAsX,OAAA,SAAA8C,EAAAvQ,GACAuQ,MAAAxE,GAAA,GACA/L,EAAA4N,EAAA5N,GAKAP,KAAAsP,aACAtP,KAAA2P,SAAA,IAAAU,EAAArQ,KAAA4P,WACA5P,KAAAsP,aAAA/O,EAAA,OAMA,IAJA,IAGA5F,EAHAmB,EAAA,GACA0U,EAAA,IAAAlC,EA1YA,SAAAyC,GAgBA,IAZA,IAAAla,EAAAka,EAAAzE,GAGA/V,EAAAM,EAAAsE,OAGArG,EAAA,EAGAkc,EAAA,GAGAlc,EAAAyB,GAAA,CAGA,IAAApB,EAAA0B,EAAA0T,WAAAzV,GAKA,GAAAK,EAAA,OAAAA,EAAA,MAEA6b,EAAArP,KAAAxM,QAIA,UAAAA,MAAA,MAEA6b,EAAArP,KAAA,YAIA,UAAAxM,MAAA,MAGA,GAAAL,IAAAyB,EAAA,EACAya,EAAArP,KAAA,WAGA,CAEA,IAAAvM,EAAA2b,EAAAxG,WAAAzV,EAAA,GAGA,UAAAM,MAAA,OAEA,IAAAkI,EAAA,KAAAnI,EAGAmG,EAAA,KAAAlG,EAIA4b,EAAArP,KAAA,OAAArE,GAAA,IAAAhC,GAGAxG,GAAA,OAMAkc,EAAArP,KAAA,OAMA7M,GAAA,EAIA,OAAAkc,EA8TAC,CAAAH,KAGAN,EAAAhC,gBACA7T,EAAAqF,KAAA2P,SAAAjL,QAAA8L,IAAAhM,WACAuK,GAEAJ,MAAAC,QAAAjU,GACAmB,EAAA6F,KAAA+O,MAAA5U,EAA0D,GAE1DA,EAAA6F,KAAAhH,GAEA,IAAAqF,KAAAsP,WAAA,CACA,MACA3U,EAAAqF,KAAA2P,SAAAjL,QAAA8L,IAAAhM,WACAuK,GAEAJ,MAAAC,QAAAjU,GACAmB,EAAA6F,KAAA+O,MAAA5U,EAA4D,GAE5DA,EAAA6F,KAAAhH,GAEAqF,KAAA2P,SAAA,KAEA,WAAA1V,WAAA6B,oCCncA,SAAAoV,GAUA,IAAAC,EAAavc,EAAQ,GACrBwc,EAAcxc,EAAQ,IACtBga,EAAcha,EAAQ,IAmDtB,SAAAyc,IACA,OAAAlE,EAAAmE,oBACA,WACA,WAGA,SAAAC,EAAAC,EAAArW,GACA,GAAAkW,IAAAlW,EACA,UAAAsW,WAAA,8BAcA,OAZAtE,EAAAmE,qBAEAE,EAAA,IAAAvX,WAAAkB,IACAuW,UAAAvE,EAAAzW,WAGA,OAAA8a,IACAA,EAAA,IAAArE,EAAAhS,IAEAqW,EAAArW,UAGAqW,EAaA,SAAArE,EAAAwE,EAAAC,EAAAzW,GACA,KAAAgS,EAAAmE,qBAAAtR,gBAAAmN,GACA,WAAAA,EAAAwE,EAAAC,EAAAzW,GAIA,oBAAAwW,EAAA,CACA,oBAAAC,EACA,MAAAnT,MACA,qEAGA,OAAAoT,EAAA7R,KAAA2R,GAEA,OAAA1V,EAAA+D,KAAA2R,EAAAC,EAAAzW,GAWA,SAAAc,EAAAuV,EAAAzb,EAAA6b,EAAAzW,GACA,oBAAApF,EACA,UAAAqY,UAAA,yCAGA,0BAAA3U,aAAA1D,aAAA0D,YA6HA,SAAA+X,EAAAM,EAAA3X,EAAAgB,GAGA,GAFA2W,EAAAhY,WAEAK,EAAA,GAAA2X,EAAAhY,WAAAK,EACA,UAAAsX,WAAA,6BAGA,GAAAK,EAAAhY,WAAAK,GAAAgB,GAAA,GACA,UAAAsW,WAAA,6BAIAK,OADA7P,IAAA9H,QAAA8H,IAAA9G,EACA,IAAAlB,WAAA6X,QACG7P,IAAA9G,EACH,IAAAlB,WAAA6X,EAAA3X,GAEA,IAAAF,WAAA6X,EAAA3X,EAAAgB,GAGAgS,EAAAmE,qBAEAE,EAAAM,GACAJ,UAAAvE,EAAAzW,UAGA8a,EAAAO,EAAAP,EAAAM,GAEA,OAAAN,EAvJAQ,CAAAR,EAAAzb,EAAA6b,EAAAzW,GAGA,iBAAApF,EAwFA,SAAAyb,EAAAT,EAAA3B,GACA,iBAAAA,GAAA,KAAAA,IACAA,EAAA,QAGA,IAAAjC,EAAA8E,WAAA7C,GACA,UAAAhB,UAAA,8CAGA,IAAAjT,EAAA,EAAArB,EAAAiX,EAAA3B,GAGA8C,GAFAV,EAAAD,EAAAC,EAAArW,IAEAgX,MAAApB,EAAA3B,GAEA8C,IAAA/W,IAIAqW,IAAA7V,MAAA,EAAAuW,IAGA,OAAAV,EA5GAY,CAAAZ,EAAAzb,EAAA6b,GAsJA,SAAAJ,EAAArI,GACA,GAAAgE,EAAAkF,SAAAlJ,GAAA,CACA,IAAAU,EAAA,EAAAyI,EAAAnJ,EAAAhO,QAGA,YAFAqW,EAAAD,EAAAC,EAAA3H,IAEA1O,OACAqW,GAGArI,EAAAoJ,KAAAf,EAAA,IAAA3H,GACA2H,GAGA,GAAArI,EAAA,CACA,uBAAA1P,aACA0P,EAAAjP,kBAAAT,aAAA,WAAA0P,EACA,uBAAAA,EAAAhO,SA+8CAqX,EA/8CArJ,EAAAhO,SAg9CAqX,EA/8CAjB,EAAAC,EAAA,GAEAO,EAAAP,EAAArI,GAGA,cAAAA,EAAAsJ,MAAA7D,EAAAzF,EAAAuJ,MACA,OAAAX,EAAAP,EAAArI,EAAAuJ,MAw8CA,IAAAF,EAp8CA,UAAApE,UAAA,sFA9KAuE,CAAAnB,EAAAzb,GA4BA,SAAA6c,EAAAnY,GACA,oBAAAA,EACA,UAAA2T,UAAA,oCACG,GAAA3T,EAAA,EACH,UAAAgX,WAAA,wCA4BA,SAAAI,EAAAL,EAAA/W,GAGA,GAFAmY,EAAAnY,GACA+W,EAAAD,EAAAC,EAAA/W,EAAA,MAAA6X,EAAA7X,KACA0S,EAAAmE,oBACA,QAAAxc,EAAA,EAAmBA,EAAA2F,IAAU3F,EAC7B0c,EAAA1c,GAAA,EAGA,OAAA0c,EAwCA,SAAAO,EAAAP,EAAAM,GACA,IAAA3W,EAAA2W,EAAA3W,OAAA,MAAAmX,EAAAR,EAAA3W,QACAqW,EAAAD,EAAAC,EAAArW,GACA,QAAArG,EAAA,EAAiBA,EAAAqG,EAAYrG,GAAA,EAC7B0c,EAAA1c,GAAA,IAAAgd,EAAAhd,GAEA,OAAA0c,EA+DA,SAAAc,EAAAnX,GAGA,GAAAA,GAAAkW,IACA,UAAAI,WAAA,0DACAJ,IAAAvD,SAAA,cAEA,SAAA3S,EAsFA,SAAArB,EAAAiX,EAAA3B,GACA,GAAAjC,EAAAkF,SAAAtB,GACA,OAAAA,EAAA5V,OAEA,uBAAA1B,aAAA,mBAAAA,YAAAsC,SACAtC,YAAAsC,OAAAgV,iBAAAtX,aACA,OAAAsX,EAAAjX,WAEA,iBAAAiX,IACAA,EAAA,GAAAA,GAGA,IAAAlH,EAAAkH,EAAA5V,OACA,OAAA0O,EAAA,SAIA,IADA,IAAAgJ,GAAA,IAEA,OAAAzD,GACA,YACA,aACA,aACA,OAAAvF,EACA,WACA,YACA,UAAA5H,EACA,OAAA6Q,EAAA/B,GAAA5V,OACA,WACA,YACA,cACA,eACA,SAAA0O,EACA,UACA,OAAAA,IAAA,EACA,aACA,OAAAkJ,EAAAhC,GAAA5V,OACA,QACA,GAAA0X,EAAA,OAAAC,EAAA/B,GAAA5V,OACAiU,GAAA,GAAAA,GAAAC,cACAwD,GAAA,GAgFA,SAAAG,EAAA1X,EAAA/E,EAAArB,GACA,IAAAJ,EAAAwG,EAAA/E,GACA+E,EAAA/E,GAAA+E,EAAApG,GACAoG,EAAApG,GAAAJ,EAmIA,SAAAme,EAAA/Y,EAAAsY,EAAArY,EAAAiV,EAAA8D,GAEA,OAAAhZ,EAAAiB,OAAA,SAmBA,GAhBA,iBAAAhB,GACAiV,EAAAjV,EACAA,EAAA,GACGA,EAAA,WACHA,EAAA,WACGA,GAAA,aACHA,GAAA,YAGAyI,MADAzI,QAGAA,EAAA+Y,EAAA,EAAAhZ,EAAAiB,OAAA,GAIAhB,EAAA,IAAAA,EAAAD,EAAAiB,OAAAhB,GACAA,GAAAD,EAAAiB,OAAA,CACA,GAAA+X,EAAA,SACA/Y,EAAAD,EAAAiB,OAAA,OACG,GAAAhB,EAAA,GACH,IAAA+Y,EACA,SADA/Y,EAAA,EAUA,GALA,iBAAAqY,IACAA,EAAArF,EAAAlR,KAAAuW,EAAApD,IAIAjC,EAAAkF,SAAAG,GAEA,WAAAA,EAAArX,QACA,EAEAgY,EAAAjZ,EAAAsY,EAAArY,EAAAiV,EAAA8D,GACG,oBAAAV,EAEH,OADAA,GAAA,IACArF,EAAAmE,qBACA,mBAAArX,WAAAvD,UAAAia,QACAuC,EACAjZ,WAAAvD,UAAAia,QAAA1b,KAAAiF,EAAAsY,EAAArY,GAEAF,WAAAvD,UAAA0c,YAAAne,KAAAiF,EAAAsY,EAAArY,GAGAgZ,EAAAjZ,EAAA,CAAAsY,GAAArY,EAAAiV,EAAA8D,GAGA,UAAA9E,UAAA,wCAGA,SAAA+E,EAAAE,EAAAb,EAAArY,EAAAiV,EAAA8D,GACA,IA0BApe,EA1BAwe,EAAA,EACAC,EAAAF,EAAAlY,OACAqY,EAAAhB,EAAArX,OAEA,QAAA8G,IAAAmN,IAEA,UADAA,KAAA9C,IAAA+C,gBACA,UAAAD,GACA,YAAAA,GAAA,aAAAA,GAAA,CACA,GAAAiE,EAAAlY,OAAA,GAAAqX,EAAArX,OAAA,EACA,SAEAmY,EAAA,EACAC,GAAA,EACAC,GAAA,EACArZ,GAAA,EAIA,SAAAqK,EAAAiP,EAAA3e,GACA,WAAAwe,EACAG,EAAA3e,GAEA2e,EAAAC,aAAA5e,EAAAwe,GAKA,GAAAJ,EAAA,CACA,IAAAS,GAAA,EACA,IAAA7e,EAAAqF,EAAwBrF,EAAAye,EAAeze,IACvC,GAAA0P,EAAA6O,EAAAve,KAAA0P,EAAAgO,GAAA,IAAAmB,EAAA,EAAA7e,EAAA6e,IAEA,IADA,IAAAA,MAAA7e,GACAA,EAAA6e,EAAA,IAAAH,EAAA,OAAAG,EAAAL,OAEA,IAAAK,IAAA7e,KAAA6e,GACAA,GAAA,OAKA,IADAxZ,EAAAqZ,EAAAD,IAAApZ,EAAAoZ,EAAAC,GACA1e,EAAAqF,EAAwBrF,GAAA,EAAQA,IAAA,CAEhC,IADA,IAAA8e,GAAA,EACA1Y,EAAA,EAAqBA,EAAAsY,EAAetY,IACpC,GAAAsJ,EAAA6O,EAAAve,EAAAoG,KAAAsJ,EAAAgO,EAAAtX,GAAA,CACA0Y,GAAA,EACA,MAGA,GAAAA,EAAA,OAAA9e,EAIA,SAeA,SAAA+e,EAAAJ,EAAA1C,EAAAxV,EAAAJ,GACAI,MAAA,EACA,IAAAuY,EAAAL,EAAAtY,OAAAI,EACAJ,GAGAA,MACA2Y,IACA3Y,EAAA2Y,GAJA3Y,EAAA2Y,EASA,IAAAC,EAAAhD,EAAA5V,OACA,GAAA4Y,EAAA,eAAA3F,UAAA,sBAEAjT,EAAA4Y,EAAA,IACA5Y,EAAA4Y,EAAA,GAEA,QAAAjf,EAAA,EAAiBA,EAAAqG,IAAYrG,EAAA,CAC7B,IAAAkf,EAAAC,SAAAlD,EAAAmD,OAAA,EAAApf,EAAA,OACA,GAAA8N,MAAAoR,GAAA,OAAAlf,EACA2e,EAAAlY,EAAAzG,GAAAkf,EAEA,OAAAlf,EAGA,SAAAqf,EAAAV,EAAA1C,EAAAxV,EAAAJ,GACA,OAAAiZ,EAAAtB,EAAA/B,EAAA0C,EAAAtY,OAAAI,GAAAkY,EAAAlY,EAAAJ,GAGA,SAAAkZ,EAAAZ,EAAA1C,EAAAxV,EAAAJ,GACA,OAAAiZ,EAq6BA,SAAAE,GAEA,IADA,IAAAC,EAAA,GACAzf,EAAA,EAAiBA,EAAAwf,EAAAnZ,SAAgBrG,EAEjCyf,EAAA5S,KAAA,IAAA2S,EAAA/J,WAAAzV,IAEA,OAAAyf,EA36BAC,CAAAzD,GAAA0C,EAAAlY,EAAAJ,GAGA,SAAAsZ,EAAAhB,EAAA1C,EAAAxV,EAAAJ,GACA,OAAAkZ,EAAAZ,EAAA1C,EAAAxV,EAAAJ,GAGA,SAAAuZ,EAAAjB,EAAA1C,EAAAxV,EAAAJ,GACA,OAAAiZ,EAAArB,EAAAhC,GAAA0C,EAAAlY,EAAAJ,GAGA,SAAAwZ,EAAAlB,EAAA1C,EAAAxV,EAAAJ,GACA,OAAAiZ,EAk6BA,SAAAE,EAAAM,GAGA,IAFA,IAAAzf,EAAA0f,EAAAC,EACAP,EAAA,GACAzf,EAAA,EAAiBA,EAAAwf,EAAAnZ,WACjByZ,GAAA,QADiC9f,EAGjCK,EAAAmf,EAAA/J,WAAAzV,GACA+f,EAAA1f,GAAA,EACA2f,EAAA3f,EAAA,IACAof,EAAA5S,KAAAmT,GACAP,EAAA5S,KAAAkT,GAGA,OAAAN,EA/6BAQ,CAAAhE,EAAA0C,EAAAtY,OAAAI,GAAAkY,EAAAlY,EAAAJ,GAkFA,SAAA6Z,EAAAvB,EAAAwB,EAAAC,GACA,WAAAD,GAAAC,IAAAzB,EAAAtY,OACAgW,EAAAgE,cAAA1B,GAEAtC,EAAAgE,cAAA1B,EAAA9X,MAAAsZ,EAAAC,IAIA,SAAAE,EAAA3B,EAAAwB,EAAAC,GACAA,EAAA7a,KAAAC,IAAAmZ,EAAAtY,OAAA+Z,GAIA,IAHA,IAAAG,EAAA,GAEAvgB,EAAAmgB,EACAngB,EAAAogB,GAAA,CACA,IAQAI,EAAAC,EAAAC,EAAAC,EARAC,EAAAjC,EAAA3e,GACAuW,EAAA,KACAsK,EAAAD,EAAA,MACAA,EAAA,MACAA,EAAA,MACA,EAEA,GAAA5gB,EAAA6gB,GAAAT,EAGA,OAAAS,GACA,OACAD,EAAA,MACArK,EAAAqK,GAEA,MACA,OAEA,WADAJ,EAAA7B,EAAA3e,EAAA,OAEA2gB,GAAA,GAAAC,IAAA,KAAAJ,GACA,MACAjK,EAAAoK,GAGA,MACA,OACAH,EAAA7B,EAAA3e,EAAA,GACAygB,EAAA9B,EAAA3e,EAAA,GACA,UAAAwgB,IAAA,UAAAC,KACAE,GAAA,GAAAC,IAAA,OAAAJ,IAAA,KAAAC,GACA,OAAAE,EAAA,OAAAA,EAAA,SACApK,EAAAoK,GAGA,MACA,OACAH,EAAA7B,EAAA3e,EAAA,GACAygB,EAAA9B,EAAA3e,EAAA,GACA0gB,EAAA/B,EAAA3e,EAAA,GACA,UAAAwgB,IAAA,UAAAC,IAAA,UAAAC,KACAC,GAAA,GAAAC,IAAA,OAAAJ,IAAA,OAAAC,IAAA,KAAAC,GACA,OAAAC,EAAA,UACApK,EAAAoK,GAMA,OAAApK,GAGAA,EAAA,MACAsK,EAAA,GACKtK,EAAA,QAELA,GAAA,MACAgK,EAAA1T,KAAA0J,IAAA,eACAA,EAAA,WAAAA,GAGAgK,EAAA1T,KAAA0J,GACAvW,GAAA6gB,EAGA,OAQA,SAAAC,GACA,IAAA/L,EAAA+L,EAAAza,OACA,GAAA0O,GAAAgM,EACA,OAAAvJ,OAAAC,aAAAmE,MAAApE,OAAAsJ,GAIA,IAAAP,EAAA,GACAvgB,EAAA,EACA,KAAAA,EAAA+U,GACAwL,GAAA/I,OAAAC,aAAAmE,MACApE,OACAsJ,EAAAja,MAAA7G,KAAA+gB,IAGA,OAAAR,EAvBAS,CAAAT,GA98BA/gB,EAAA6Y,SACA7Y,EAAAyhB,WAoTA,SAAA5a,IACAA,OACAA,EAAA,GAEA,OAAAgS,EAAA6I,OAAA7a,IAvTA7G,EAAA2hB,kBAAA,GA0BA9I,EAAAmE,yBAAArP,IAAAiP,EAAAI,oBACAJ,EAAAI,oBAQA,WACA,IACA,IAAA+B,EAAA,IAAApZ,WAAA,GAEA,OADAoZ,EAAA3B,UAAA,CAAqBA,UAAAzX,WAAAvD,UAAAwf,IAAA,WAAmD,YACxE,KAAA7C,EAAA6C,OACA,mBAAA7C,EAAA3X,UACA,IAAA2X,EAAA3X,SAAA,KAAA5B,WACG,MAAA+I,GACH,UAfAsT,GAKA7hB,EAAA+c,eAkEAlE,EAAAiJ,SAAA,KAGAjJ,EAAAkJ,SAAA,SAAAhD,GAEA,OADAA,EAAA3B,UAAAvE,EAAAzW,UACA2c,GA2BAlG,EAAAlR,KAAA,SAAAlG,EAAA6b,EAAAzW,GACA,OAAAc,EAAA,KAAAlG,EAAA6b,EAAAzW,IAGAgS,EAAAmE,sBACAnE,EAAAzW,UAAAgb,UAAAzX,WAAAvD,UACAyW,EAAAuE,UAAAzX,WACA,oBAAApE,eAAAygB,SACAnJ,EAAAtX,OAAAygB,WAAAnJ,GAEA3X,OAAAC,eAAA0X,EAAAtX,OAAAygB,QAAA,CACAvgB,MAAA,KACAwgB,cAAA,KAiCApJ,EAAA6I,MAAA,SAAAvb,EAAA+b,EAAApH,GACA,OArBA,SAAAoC,EAAA/W,EAAA+b,EAAApH,GAEA,OADAwD,EAAAnY,GACAA,GAAA,EACA8W,EAAAC,EAAA/W,QAEAwH,IAAAuU,EAIA,iBAAApH,EACAmC,EAAAC,EAAA/W,GAAA+b,OAAApH,GACAmC,EAAAC,EAAA/W,GAAA+b,QAEAjF,EAAAC,EAAA/W,GAQAub,CAAA,KAAAvb,EAAA+b,EAAApH,IAiBAjC,EAAA0E,YAAA,SAAApX,GACA,OAAAoX,EAAA,KAAApX,IAKA0S,EAAAsJ,gBAAA,SAAAhc,GACA,OAAAoX,EAAA,KAAApX,IAiHA0S,EAAAkF,SAAA,SAAA/W,GACA,cAAAA,MAAAob,YAGAvJ,EAAAwJ,QAAA,SAAArZ,EAAAhC,GACA,IAAA6R,EAAAkF,SAAA/U,KAAA6P,EAAAkF,SAAA/W,GACA,UAAA8S,UAAA,6BAGA,GAAA9Q,IAAAhC,EAAA,SAKA,IAHA,IAAAN,EAAAsC,EAAAnC,OACAF,EAAAK,EAAAH,OAEArG,EAAA,EAAA+U,EAAAxP,KAAAC,IAAAU,EAAAC,GAAuCnG,EAAA+U,IAAS/U,EAChD,GAAAwI,EAAAxI,KAAAwG,EAAAxG,GAAA,CACAkG,EAAAsC,EAAAxI,GACAmG,EAAAK,EAAAxG,GACA,MAIA,OAAAkG,EAAAC,GAAA,EACAA,EAAAD,EAAA,EACA,GAGAmS,EAAA8E,WAAA,SAAA7C,GACA,QAAAA,EAAA9C,IAAA+C,eACA,UACA,WACA,YACA,YACA,aACA,aACA,aACA,WACA,YACA,cACA,eACA,SACA,QACA,WAIAlC,EAAAyJ,OAAA,SAAAC,EAAA1b,GACA,IAAAyT,EAAAiI,GACA,UAAAzI,UAAA,+CAGA,OAAAyI,EAAA1b,OACA,OAAAgS,EAAA6I,MAAA,GAGA,IAAAlhB,EACA,QAAAmN,IAAA9G,EAEA,IADAA,EAAA,EACArG,EAAA,EAAeA,EAAA+hB,EAAA1b,SAAiBrG,EAChCqG,GAAA0b,EAAA/hB,GAAAqG,OAIA,IAAAjB,EAAAiT,EAAA0E,YAAA1W,GACA2b,EAAA,EACA,IAAAhiB,EAAA,EAAaA,EAAA+hB,EAAA1b,SAAiBrG,EAAA,CAC9B,IAAA2e,EAAAoD,EAAA/hB,GACA,IAAAqY,EAAAkF,SAAAoB,GACA,UAAArF,UAAA,+CAEAqF,EAAAlB,KAAArY,EAAA4c,GACAA,GAAArD,EAAAtY,OAEA,OAAAjB,GA8CAiT,EAAArT,aA0EAqT,EAAAzW,UAAAggB,WAAA,EAQAvJ,EAAAzW,UAAAqgB,OAAA,WACA,IAAAlN,EAAA7J,KAAA7E,OACA,GAAA0O,EAAA,KACA,UAAA4H,WAAA,6CAEA,QAAA3c,EAAA,EAAiBA,EAAA+U,EAAS/U,GAAA,EAC1Bke,EAAAhT,KAAAlL,IAAA,GAEA,OAAAkL,MAGAmN,EAAAzW,UAAAsgB,OAAA,WACA,IAAAnN,EAAA7J,KAAA7E,OACA,GAAA0O,EAAA,KACA,UAAA4H,WAAA,6CAEA,QAAA3c,EAAA,EAAiBA,EAAA+U,EAAS/U,GAAA,EAC1Bke,EAAAhT,KAAAlL,IAAA,GACAke,EAAAhT,KAAAlL,EAAA,EAAAA,EAAA,GAEA,OAAAkL,MAGAmN,EAAAzW,UAAAugB,OAAA,WACA,IAAApN,EAAA7J,KAAA7E,OACA,GAAA0O,EAAA,KACA,UAAA4H,WAAA,6CAEA,QAAA3c,EAAA,EAAiBA,EAAA+U,EAAS/U,GAAA,EAC1Bke,EAAAhT,KAAAlL,IAAA,GACAke,EAAAhT,KAAAlL,EAAA,EAAAA,EAAA,GACAke,EAAAhT,KAAAlL,EAAA,EAAAA,EAAA,GACAke,EAAAhT,KAAAlL,EAAA,EAAAA,EAAA,GAEA,OAAAkL,MAGAmN,EAAAzW,UAAAoX,SAAA,WACA,IAAA3S,EAAA,EAAA6E,KAAA7E,OACA,WAAAA,EAAA,GACA,IAAA+b,UAAA/b,OAAAia,EAAApV,KAAA,EAAA7E,GAxHA,SAAAiU,EAAA6F,EAAAC,GACA,IAAArC,GAAA,EAcA,SALA5Q,IAAAgT,KAAA,KACAA,EAAA,GAIAA,EAAAjV,KAAA7E,OACA,SAOA,SAJA8G,IAAAiT,KAAAlV,KAAA7E,UACA+Z,EAAAlV,KAAA7E,QAGA+Z,GAAA,EACA,SAOA,IAHAA,KAAA,KACAD,KAAA,GAGA,SAKA,IAFA7F,MAAA,UAGA,OAAAA,GACA,UACA,OAAA+H,EAAAnX,KAAAiV,EAAAC,GAEA,WACA,YACA,OAAAE,EAAApV,KAAAiV,EAAAC,GAEA,YACA,OAAAkC,EAAApX,KAAAiV,EAAAC,GAEA,aACA,aACA,OAAAmC,EAAArX,KAAAiV,EAAAC,GAEA,aACA,OAAAF,EAAAhV,KAAAiV,EAAAC,GAEA,WACA,YACA,cACA,eACA,OAAAoC,EAAAtX,KAAAiV,EAAAC,GAEA,QACA,GAAArC,EAAA,UAAAzE,UAAA,qBAAAgB,GACAA,KAAA,IAAAC,cACAwD,GAAA,IAwDAnC,MAAA1Q,KAAAkX,YAGA/J,EAAAzW,UAAAmP,OAAA,SAAAvK,GACA,IAAA6R,EAAAkF,SAAA/W,GAAA,UAAA8S,UAAA,6BACA,OAAApO,OAAA1E,GACA,IAAA6R,EAAAwJ,QAAA3W,KAAA1E,IAGA6R,EAAAzW,UAAA6gB,QAAA,WACA,IAAAjD,EAAA,GACApG,EAAA5Z,EAAA2hB,kBAKA,OAJAjW,KAAA7E,OAAA,IACAmZ,EAAAtU,KAAA8N,SAAA,QAAAI,GAAAsJ,MAAA,SAAkDC,KAAA,KAClDzX,KAAA7E,OAAA+S,IAAAoG,GAAA,UAEA,WAAAA,EAAA,KAGAnH,EAAAzW,UAAAigB,QAAA,SAAAjd,EAAAub,EAAAC,EAAAwC,EAAAC,GACA,IAAAxK,EAAAkF,SAAA3Y,GACA,UAAA0U,UAAA,6BAgBA,QAbAnM,IAAAgT,IACAA,EAAA,QAEAhT,IAAAiT,IACAA,EAAAxb,IAAAyB,OAAA,QAEA8G,IAAAyV,IACAA,EAAA,QAEAzV,IAAA0V,IACAA,EAAA3X,KAAA7E,QAGA8Z,EAAA,GAAAC,EAAAxb,EAAAyB,QAAAuc,EAAA,GAAAC,EAAA3X,KAAA7E,OACA,UAAAsW,WAAA,sBAGA,GAAAiG,GAAAC,GAAA1C,GAAAC,EACA,SAEA,GAAAwC,GAAAC,EACA,SAEA,GAAA1C,GAAAC,EACA,SAQA,GAAAlV,OAAAtG,EAAA,SASA,IAPA,IAAAsB,GAJA2c,KAAA,IADAD,KAAA,GAMAzc,GAPAia,KAAA,IADAD,KAAA,GASApL,EAAAxP,KAAAC,IAAAU,EAAAC,GAEA2c,EAAA5X,KAAArE,MAAA+b,EAAAC,GACAE,EAAAne,EAAAiC,MAAAsZ,EAAAC,GAEApgB,EAAA,EAAiBA,EAAA+U,IAAS/U,EAC1B,GAAA8iB,EAAA9iB,KAAA+iB,EAAA/iB,GAAA,CACAkG,EAAA4c,EAAA9iB,GACAmG,EAAA4c,EAAA/iB,GACA,MAIA,OAAAkG,EAAAC,GAAA,EACAA,EAAAD,EAAA,EACA,GA6HAmS,EAAAzW,UAAAohB,SAAA,SAAAtF,EAAArY,EAAAiV,GACA,WAAApP,KAAA2Q,QAAA6B,EAAArY,EAAAiV,IAGAjC,EAAAzW,UAAAia,QAAA,SAAA6B,EAAArY,EAAAiV,GACA,OAAA6D,EAAAjT,KAAAwS,EAAArY,EAAAiV,GAAA,IAGAjC,EAAAzW,UAAA0c,YAAA,SAAAZ,EAAArY,EAAAiV,GACA,OAAA6D,EAAAjT,KAAAwS,EAAArY,EAAAiV,GAAA,IAkDAjC,EAAAzW,UAAAyb,MAAA,SAAApB,EAAAxV,EAAAJ,EAAAiU,GAEA,QAAAnN,IAAA1G,EACA6T,EAAA,OACAjU,EAAA6E,KAAA7E,OACAI,EAAA,OAEG,QAAA0G,IAAA9G,GAAA,iBAAAI,EACH6T,EAAA7T,EACAJ,EAAA6E,KAAA7E,OACAI,EAAA,MAEG,KAAAoI,SAAApI,GAWH,MAAAkD,MACA,2EAXAlD,GAAA,EACAoI,SAAAxI,IACAA,GAAA,OACA8G,IAAAmN,MAAA,UAEAA,EAAAjU,EACAA,OAAA8G,GASA,IAAA6R,EAAA9T,KAAA7E,OAAAI,EAGA,SAFA0G,IAAA9G,KAAA2Y,KAAA3Y,EAAA2Y,GAEA/C,EAAA5V,OAAA,IAAAA,EAAA,GAAAI,EAAA,IAAAA,EAAAyE,KAAA7E,OACA,UAAAsW,WAAA,0CAGArC,MAAA,QAGA,IADA,IAAAyD,GAAA,IAEA,OAAAzD,GACA,UACA,OAAAyE,EAAA7T,KAAA+Q,EAAAxV,EAAAJ,GAEA,WACA,YACA,OAAAgZ,EAAAnU,KAAA+Q,EAAAxV,EAAAJ,GAEA,YACA,OAAAkZ,EAAArU,KAAA+Q,EAAAxV,EAAAJ,GAEA,aACA,aACA,OAAAsZ,EAAAzU,KAAA+Q,EAAAxV,EAAAJ,GAEA,aAEA,OAAAuZ,EAAA1U,KAAA+Q,EAAAxV,EAAAJ,GAEA,WACA,YACA,cACA,eACA,OAAAwZ,EAAA3U,KAAA+Q,EAAAxV,EAAAJ,GAEA,QACA,GAAA0X,EAAA,UAAAzE,UAAA,qBAAAgB,GACAA,GAAA,GAAAA,GAAAC,cACAwD,GAAA,IAKA1F,EAAAzW,UAAAqhB,OAAA,WACA,OACAtF,KAAA,SACAC,KAAA/D,MAAAjY,UAAAiF,MAAA1G,KAAA+K,KAAAgY,MAAAhY,KAAA,KAwFA,IAAA6V,EAAA,KAoBA,SAAAuB,EAAA3D,EAAAwB,EAAAC,GACA,IAAA+C,EAAA,GACA/C,EAAA7a,KAAAC,IAAAmZ,EAAAtY,OAAA+Z,GAEA,QAAApgB,EAAAmgB,EAAqBngB,EAAAogB,IAASpgB,EAC9BmjB,GAAA3L,OAAAC,aAAA,IAAAkH,EAAA3e,IAEA,OAAAmjB,EAGA,SAAAZ,EAAA5D,EAAAwB,EAAAC,GACA,IAAA+C,EAAA,GACA/C,EAAA7a,KAAAC,IAAAmZ,EAAAtY,OAAA+Z,GAEA,QAAApgB,EAAAmgB,EAAqBngB,EAAAogB,IAASpgB,EAC9BmjB,GAAA3L,OAAAC,aAAAkH,EAAA3e,IAEA,OAAAmjB,EAGA,SAAAd,EAAA1D,EAAAwB,EAAAC,GACA,IAAArL,EAAA4J,EAAAtY,SAEA8Z,KAAA,KAAAA,EAAA,KACAC,KAAA,GAAAA,EAAArL,KAAAqL,EAAArL,GAGA,IADA,IAAAqO,EAAA,GACApjB,EAAAmgB,EAAqBngB,EAAAogB,IAASpgB,EAC9BojB,GAAAC,EAAA1E,EAAA3e,IAEA,OAAAojB,EAGA,SAAAZ,EAAA7D,EAAAwB,EAAAC,GAGA,IAFA,IAAApZ,EAAA2X,EAAA9X,MAAAsZ,EAAAC,GACAG,EAAA,GACAvgB,EAAA,EAAiBA,EAAAgH,EAAAX,OAAkBrG,GAAA,EACnCugB,GAAA/I,OAAAC,aAAAzQ,EAAAhH,GAAA,IAAAgH,EAAAhH,EAAA,IAEA,OAAAugB,EA0CA,SAAA+C,EAAA7c,EAAA8c,EAAAld,GACA,GAAAI,EAAA,MAAAA,EAAA,YAAAkW,WAAA,sBACA,GAAAlW,EAAA8c,EAAAld,EAAA,UAAAsW,WAAA,yCA+JA,SAAA6G,EAAA7E,EAAA1d,EAAAwF,EAAA8c,EAAAnK,EAAA5T,GACA,IAAA6S,EAAAkF,SAAAoB,GAAA,UAAArF,UAAA,+CACA,GAAArY,EAAAmY,GAAAnY,EAAAuE,EAAA,UAAAmX,WAAA,qCACA,GAAAlW,EAAA8c,EAAA5E,EAAAtY,OAAA,UAAAsW,WAAA,sBAkDA,SAAA8G,EAAA9E,EAAA1d,EAAAwF,EAAAid,GACAziB,EAAA,IAAAA,EAAA,MAAAA,EAAA,GACA,QAAAjB,EAAA,EAAAoG,EAAAb,KAAAC,IAAAmZ,EAAAtY,OAAAI,EAAA,GAAuDzG,EAAAoG,IAAOpG,EAC9D2e,EAAAlY,EAAAzG,IAAAiB,EAAA,QAAAyiB,EAAA1jB,EAAA,EAAAA,MACA,GAAA0jB,EAAA1jB,EAAA,EAAAA,GA8BA,SAAA2jB,EAAAhF,EAAA1d,EAAAwF,EAAAid,GACAziB,EAAA,IAAAA,EAAA,WAAAA,EAAA,GACA,QAAAjB,EAAA,EAAAoG,EAAAb,KAAAC,IAAAmZ,EAAAtY,OAAAI,EAAA,GAAuDzG,EAAAoG,IAAOpG,EAC9D2e,EAAAlY,EAAAzG,GAAAiB,IAAA,GAAAyiB,EAAA1jB,EAAA,EAAAA,GAAA,IAmJA,SAAA4jB,EAAAjF,EAAA1d,EAAAwF,EAAA8c,EAAAnK,EAAA5T,GACA,GAAAiB,EAAA8c,EAAA5E,EAAAtY,OAAA,UAAAsW,WAAA,sBACA,GAAAlW,EAAA,YAAAkW,WAAA,sBAGA,SAAAkH,EAAAlF,EAAA1d,EAAAwF,EAAAid,EAAAI,GAKA,OAJAA,GACAF,EAAAjF,EAAA1d,EAAAwF,EAAA,GAEA6V,EAAAe,MAAAsB,EAAA1d,EAAAwF,EAAAid,EAAA,MACAjd,EAAA,EAWA,SAAAsd,EAAApF,EAAA1d,EAAAwF,EAAAid,EAAAI,GAKA,OAJAA,GACAF,EAAAjF,EAAA1d,EAAAwF,EAAA,GAEA6V,EAAAe,MAAAsB,EAAA1d,EAAAwF,EAAAid,EAAA,MACAjd,EAAA,EA/cA4R,EAAAzW,UAAAiF,MAAA,SAAAsZ,EAAAC,GACA,IAoBA4D,EApBAjP,EAAA7J,KAAA7E,OAqBA,IApBA8Z,OAGA,GACAA,GAAApL,GACA,IAAAoL,EAAA,GACGA,EAAApL,IACHoL,EAAApL,IANAqL,OAAAjT,IAAAiT,EAAArL,IAAAqL,GASA,GACAA,GAAArL,GACA,IAAAqL,EAAA,GACGA,EAAArL,IACHqL,EAAArL,GAGAqL,EAAAD,IAAAC,EAAAD,GAGA9H,EAAAmE,qBACAwH,EAAA9Y,KAAAtE,SAAAuZ,EAAAC,IACAxD,UAAAvE,EAAAzW,cACG,CACH,IAAAqiB,EAAA7D,EAAAD,EACA6D,EAAA,IAAA3L,EAAA4L,OAAA9W,GACA,QAAAnN,EAAA,EAAmBA,EAAAikB,IAAcjkB,EACjCgkB,EAAAhkB,GAAAkL,KAAAlL,EAAAmgB,GAIA,OAAA6D,GAWA3L,EAAAzW,UAAAsiB,WAAA,SAAAzd,EAAAzB,EAAA8e,GACArd,GAAA,EACAzB,GAAA,EACA8e,GAAAR,EAAA7c,EAAAzB,EAAAkG,KAAA7E,QAKA,IAHA,IAAAqX,EAAAxS,KAAAzE,GACA0d,EAAA,EACAnkB,EAAA,IACAA,EAAAgF,IAAAmf,GAAA,MACAzG,GAAAxS,KAAAzE,EAAAzG,GAAAmkB,EAGA,OAAAzG,GAGArF,EAAAzW,UAAAwiB,WAAA,SAAA3d,EAAAzB,EAAA8e,GACArd,GAAA,EACAzB,GAAA,EACA8e,GACAR,EAAA7c,EAAAzB,EAAAkG,KAAA7E,QAKA,IAFA,IAAAqX,EAAAxS,KAAAzE,IAAAzB,GACAmf,EAAA,EACAnf,EAAA,IAAAmf,GAAA,MACAzG,GAAAxS,KAAAzE,IAAAzB,GAAAmf,EAGA,OAAAzG,GAGArF,EAAAzW,UAAAyiB,UAAA,SAAA5d,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACA6E,KAAAzE,IAGA4R,EAAAzW,UAAA0iB,aAAA,SAAA7d,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACA6E,KAAAzE,GAAAyE,KAAAzE,EAAA,OAGA4R,EAAAzW,UAAAgd,aAAA,SAAAnY,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACA6E,KAAAzE,IAAA,EAAAyE,KAAAzE,EAAA,IAGA4R,EAAAzW,UAAA2iB,aAAA,SAAA9d,EAAAqd,GAGA,OAFAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,SAEA6E,KAAAzE,GACAyE,KAAAzE,EAAA,MACAyE,KAAAzE,EAAA,QACA,SAAAyE,KAAAzE,EAAA,IAGA4R,EAAAzW,UAAA4iB,aAAA,SAAA/d,EAAAqd,GAGA,OAFAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QAEA,SAAA6E,KAAAzE,IACAyE,KAAAzE,EAAA,OACAyE,KAAAzE,EAAA,MACAyE,KAAAzE,EAAA,KAGA4R,EAAAzW,UAAA6iB,UAAA,SAAAhe,EAAAzB,EAAA8e,GACArd,GAAA,EACAzB,GAAA,EACA8e,GAAAR,EAAA7c,EAAAzB,EAAAkG,KAAA7E,QAKA,IAHA,IAAAqX,EAAAxS,KAAAzE,GACA0d,EAAA,EACAnkB,EAAA,IACAA,EAAAgF,IAAAmf,GAAA,MACAzG,GAAAxS,KAAAzE,EAAAzG,GAAAmkB,EAMA,OAFAzG,IAFAyG,GAAA,OAEAzG,GAAAnY,KAAAmf,IAAA,IAAA1f,IAEA0Y,GAGArF,EAAAzW,UAAA+iB,UAAA,SAAAle,EAAAzB,EAAA8e,GACArd,GAAA,EACAzB,GAAA,EACA8e,GAAAR,EAAA7c,EAAAzB,EAAAkG,KAAA7E,QAKA,IAHA,IAAArG,EAAAgF,EACAmf,EAAA,EACAzG,EAAAxS,KAAAzE,IAAAzG,GACAA,EAAA,IAAAmkB,GAAA,MACAzG,GAAAxS,KAAAzE,IAAAzG,GAAAmkB,EAMA,OAFAzG,IAFAyG,GAAA,OAEAzG,GAAAnY,KAAAmf,IAAA,IAAA1f,IAEA0Y,GAGArF,EAAAzW,UAAA+U,SAAA,SAAAlQ,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACA,IAAA6E,KAAAzE,IACA,OAAAyE,KAAAzE,GAAA,GADAyE,KAAAzE,IAIA4R,EAAAzW,UAAAgjB,YAAA,SAAAne,EAAAqd,GACAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACA,IAAAqX,EAAAxS,KAAAzE,GAAAyE,KAAAzE,EAAA,MACA,aAAAiX,EAAA,WAAAA,KAGArF,EAAAzW,UAAAijB,YAAA,SAAApe,EAAAqd,GACAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACA,IAAAqX,EAAAxS,KAAAzE,EAAA,GAAAyE,KAAAzE,IAAA,EACA,aAAAiX,EAAA,WAAAA,KAGArF,EAAAzW,UAAAkjB,YAAA,SAAAre,EAAAqd,GAGA,OAFAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QAEA6E,KAAAzE,GACAyE,KAAAzE,EAAA,MACAyE,KAAAzE,EAAA,OACAyE,KAAAzE,EAAA,QAGA4R,EAAAzW,UAAAmjB,YAAA,SAAAte,EAAAqd,GAGA,OAFAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QAEA6E,KAAAzE,IAAA,GACAyE,KAAAzE,EAAA,OACAyE,KAAAzE,EAAA,MACAyE,KAAAzE,EAAA,IAGA4R,EAAAzW,UAAAojB,YAAA,SAAAve,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACAiW,EAAA5M,KAAAxE,KAAAzE,GAAA,SAGA4R,EAAAzW,UAAAqjB,YAAA,SAAAxe,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACAiW,EAAA5M,KAAAxE,KAAAzE,GAAA,SAGA4R,EAAAzW,UAAAsjB,aAAA,SAAAze,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACAiW,EAAA5M,KAAAxE,KAAAzE,GAAA,SAGA4R,EAAAzW,UAAAujB,aAAA,SAAA1e,EAAAqd,GAEA,OADAA,GAAAR,EAAA7c,EAAA,EAAAyE,KAAA7E,QACAiW,EAAA5M,KAAAxE,KAAAzE,GAAA,SASA4R,EAAAzW,UAAAwjB,YAAA,SAAAnkB,EAAAwF,EAAAzB,EAAA8e,IACA7iB,KACAwF,GAAA,EACAzB,GAAA,EACA8e,IAEAN,EAAAtY,KAAAjK,EAAAwF,EAAAzB,EADAO,KAAAmf,IAAA,IAAA1f,GAAA,EACA,GAGA,IAAAmf,EAAA,EACAnkB,EAAA,EAEA,IADAkL,KAAAzE,GAAA,IAAAxF,IACAjB,EAAAgF,IAAAmf,GAAA,MACAjZ,KAAAzE,EAAAzG,GAAAiB,EAAAkjB,EAAA,IAGA,OAAA1d,EAAAzB,GAGAqT,EAAAzW,UAAAyjB,YAAA,SAAApkB,EAAAwF,EAAAzB,EAAA8e,IACA7iB,KACAwF,GAAA,EACAzB,GAAA,EACA8e,IAEAN,EAAAtY,KAAAjK,EAAAwF,EAAAzB,EADAO,KAAAmf,IAAA,IAAA1f,GAAA,EACA,GAGA,IAAAhF,EAAAgF,EAAA,EACAmf,EAAA,EAEA,IADAjZ,KAAAzE,EAAAzG,GAAA,IAAAiB,IACAjB,GAAA,IAAAmkB,GAAA,MACAjZ,KAAAzE,EAAAzG,GAAAiB,EAAAkjB,EAAA,IAGA,OAAA1d,EAAAzB,GAGAqT,EAAAzW,UAAA0jB,WAAA,SAAArkB,EAAAwF,EAAAqd,GAMA,OALA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,SACA4R,EAAAmE,sBAAAvb,EAAAsE,KAAAggB,MAAAtkB,IACAiK,KAAAzE,GAAA,IAAAxF,EACAwF,EAAA,GAWA4R,EAAAzW,UAAA4jB,cAAA,SAAAvkB,EAAAwF,EAAAqd,GAUA,OATA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,WACA4R,EAAAmE,qBACAtR,KAAAzE,GAAA,IAAAxF,EACAiK,KAAAzE,EAAA,GAAAxF,IAAA,GAEAwiB,EAAAvY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAGA4R,EAAAzW,UAAA6jB,cAAA,SAAAxkB,EAAAwF,EAAAqd,GAUA,OATA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,WACA4R,EAAAmE,qBACAtR,KAAAzE,GAAAxF,IAAA,EACAiK,KAAAzE,EAAA,OAAAxF,GAEAwiB,EAAAvY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAUA4R,EAAAzW,UAAA8jB,cAAA,SAAAzkB,EAAAwF,EAAAqd,GAYA,OAXA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,gBACA4R,EAAAmE,qBACAtR,KAAAzE,EAAA,GAAAxF,IAAA,GACAiK,KAAAzE,EAAA,GAAAxF,IAAA,GACAiK,KAAAzE,EAAA,GAAAxF,IAAA,EACAiK,KAAAzE,GAAA,IAAAxF,GAEA0iB,EAAAzY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAGA4R,EAAAzW,UAAA+jB,cAAA,SAAA1kB,EAAAwF,EAAAqd,GAYA,OAXA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,gBACA4R,EAAAmE,qBACAtR,KAAAzE,GAAAxF,IAAA,GACAiK,KAAAzE,EAAA,GAAAxF,IAAA,GACAiK,KAAAzE,EAAA,GAAAxF,IAAA,EACAiK,KAAAzE,EAAA,OAAAxF,GAEA0iB,EAAAzY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAGA4R,EAAAzW,UAAAgkB,WAAA,SAAA3kB,EAAAwF,EAAAzB,EAAA8e,GAGA,GAFA7iB,KACAwF,GAAA,GACAqd,EAAA,CACA,IAAA+B,EAAAtgB,KAAAmf,IAAA,IAAA1f,EAAA,GAEAwe,EAAAtY,KAAAjK,EAAAwF,EAAAzB,EAAA6gB,EAAA,GAAAA,GAGA,IAAA7lB,EAAA,EACAmkB,EAAA,EACA2B,EAAA,EAEA,IADA5a,KAAAzE,GAAA,IAAAxF,IACAjB,EAAAgF,IAAAmf,GAAA,MACAljB,EAAA,OAAA6kB,GAAA,IAAA5a,KAAAzE,EAAAzG,EAAA,KACA8lB,EAAA,GAEA5a,KAAAzE,EAAAzG,IAAAiB,EAAAkjB,GAAA,GAAA2B,EAAA,IAGA,OAAArf,EAAAzB,GAGAqT,EAAAzW,UAAAmkB,WAAA,SAAA9kB,EAAAwF,EAAAzB,EAAA8e,GAGA,GAFA7iB,KACAwF,GAAA,GACAqd,EAAA,CACA,IAAA+B,EAAAtgB,KAAAmf,IAAA,IAAA1f,EAAA,GAEAwe,EAAAtY,KAAAjK,EAAAwF,EAAAzB,EAAA6gB,EAAA,GAAAA,GAGA,IAAA7lB,EAAAgF,EAAA,EACAmf,EAAA,EACA2B,EAAA,EAEA,IADA5a,KAAAzE,EAAAzG,GAAA,IAAAiB,IACAjB,GAAA,IAAAmkB,GAAA,MACAljB,EAAA,OAAA6kB,GAAA,IAAA5a,KAAAzE,EAAAzG,EAAA,KACA8lB,EAAA,GAEA5a,KAAAzE,EAAAzG,IAAAiB,EAAAkjB,GAAA,GAAA2B,EAAA,IAGA,OAAArf,EAAAzB,GAGAqT,EAAAzW,UAAAgR,UAAA,SAAA3R,EAAAwF,EAAAqd,GAOA,OANA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,YACA4R,EAAAmE,sBAAAvb,EAAAsE,KAAAggB,MAAAtkB,IACAA,EAAA,IAAAA,EAAA,IAAAA,EAAA,GACAiK,KAAAzE,GAAA,IAAAxF,EACAwF,EAAA,GAGA4R,EAAAzW,UAAAokB,aAAA,SAAA/kB,EAAAwF,EAAAqd,GAUA,OATA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,gBACA4R,EAAAmE,qBACAtR,KAAAzE,GAAA,IAAAxF,EACAiK,KAAAzE,EAAA,GAAAxF,IAAA,GAEAwiB,EAAAvY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAGA4R,EAAAzW,UAAAqkB,aAAA,SAAAhlB,EAAAwF,EAAAqd,GAUA,OATA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,gBACA4R,EAAAmE,qBACAtR,KAAAzE,GAAAxF,IAAA,EACAiK,KAAAzE,EAAA,OAAAxF,GAEAwiB,EAAAvY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAGA4R,EAAAzW,UAAAskB,aAAA,SAAAjlB,EAAAwF,EAAAqd,GAYA,OAXA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,0BACA4R,EAAAmE,qBACAtR,KAAAzE,GAAA,IAAAxF,EACAiK,KAAAzE,EAAA,GAAAxF,IAAA,EACAiK,KAAAzE,EAAA,GAAAxF,IAAA,GACAiK,KAAAzE,EAAA,GAAAxF,IAAA,IAEA0iB,EAAAzY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAGA4R,EAAAzW,UAAAukB,aAAA,SAAAllB,EAAAwF,EAAAqd,GAaA,OAZA7iB,KACAwF,GAAA,EACAqd,GAAAN,EAAAtY,KAAAjK,EAAAwF,EAAA,0BACAxF,EAAA,IAAAA,EAAA,WAAAA,EAAA,GACAoX,EAAAmE,qBACAtR,KAAAzE,GAAAxF,IAAA,GACAiK,KAAAzE,EAAA,GAAAxF,IAAA,GACAiK,KAAAzE,EAAA,GAAAxF,IAAA,EACAiK,KAAAzE,EAAA,OAAAxF,GAEA0iB,EAAAzY,KAAAjK,EAAAwF,GAAA,GAEAA,EAAA,GAgBA4R,EAAAzW,UAAAwkB,aAAA,SAAAnlB,EAAAwF,EAAAqd,GACA,OAAAD,EAAA3Y,KAAAjK,EAAAwF,GAAA,EAAAqd,IAGAzL,EAAAzW,UAAAykB,aAAA,SAAAplB,EAAAwF,EAAAqd,GACA,OAAAD,EAAA3Y,KAAAjK,EAAAwF,GAAA,EAAAqd,IAWAzL,EAAAzW,UAAA0kB,cAAA,SAAArlB,EAAAwF,EAAAqd,GACA,OAAAC,EAAA7Y,KAAAjK,EAAAwF,GAAA,EAAAqd,IAGAzL,EAAAzW,UAAA2kB,cAAA,SAAAtlB,EAAAwF,EAAAqd,GACA,OAAAC,EAAA7Y,KAAAjK,EAAAwF,GAAA,EAAAqd,IAIAzL,EAAAzW,UAAA6b,KAAA,SAAA7Y,EAAA4hB,EAAArG,EAAAC,GAQA,GAPAD,MAAA,GACAC,GAAA,IAAAA,MAAAlV,KAAA7E,QACAmgB,GAAA5hB,EAAAyB,SAAAmgB,EAAA5hB,EAAAyB,QACAmgB,MAAA,GACApG,EAAA,GAAAA,EAAAD,IAAAC,EAAAD,GAGAC,IAAAD,EAAA,SACA,OAAAvb,EAAAyB,QAAA,IAAA6E,KAAA7E,OAAA,SAGA,GAAAmgB,EAAA,EACA,UAAA7J,WAAA,6BAEA,GAAAwD,EAAA,GAAAA,GAAAjV,KAAA7E,OAAA,UAAAsW,WAAA,6BACA,GAAAyD,EAAA,YAAAzD,WAAA,2BAGAyD,EAAAlV,KAAA7E,SAAA+Z,EAAAlV,KAAA7E,QACAzB,EAAAyB,OAAAmgB,EAAApG,EAAAD,IACAC,EAAAxb,EAAAyB,OAAAmgB,EAAArG,GAGA,IACAngB,EADA+U,EAAAqL,EAAAD,EAGA,GAAAjV,OAAAtG,GAAAub,EAAAqG,KAAApG,EAEA,IAAApgB,EAAA+U,EAAA,EAAqB/U,GAAA,IAAQA,EAC7B4E,EAAA5E,EAAAwmB,GAAAtb,KAAAlL,EAAAmgB,QAEG,GAAApL,EAAA,MAAAsD,EAAAmE,oBAEH,IAAAxc,EAAA,EAAeA,EAAA+U,IAAS/U,EACxB4E,EAAA5E,EAAAwmB,GAAAtb,KAAAlL,EAAAmgB,QAGAhb,WAAAvD,UAAA6D,IAAAtF,KACAyE,EACAsG,KAAAtE,SAAAuZ,IAAApL,GACAyR,GAIA,OAAAzR,GAOAsD,EAAAzW,UAAA8f,KAAA,SAAAhE,EAAAyC,EAAAC,EAAA9F,GAEA,oBAAAoD,EAAA,CASA,GARA,iBAAAyC,GACA7F,EAAA6F,EACAA,EAAA,EACAC,EAAAlV,KAAA7E,QACK,iBAAA+Z,IACL9F,EAAA8F,EACAA,EAAAlV,KAAA7E,QAEA,IAAAqX,EAAArX,OAAA,CACA,IAAAogB,EAAA/I,EAAAjI,WAAA,GACAgR,EAAA,MACA/I,EAAA+I,GAGA,QAAAtZ,IAAAmN,GAAA,iBAAAA,EACA,UAAAhB,UAAA,6BAEA,oBAAAgB,IAAAjC,EAAA8E,WAAA7C,GACA,UAAAhB,UAAA,qBAAAgB,OAEG,iBAAAoD,IACHA,GAAA,KAIA,GAAAyC,EAAA,GAAAjV,KAAA7E,OAAA8Z,GAAAjV,KAAA7E,OAAA+Z,EACA,UAAAzD,WAAA,sBAGA,GAAAyD,GAAAD,EACA,OAAAjV,KAQA,IAAAlL,EACA,GANAmgB,KAAA,EACAC,OAAAjT,IAAAiT,EAAAlV,KAAA7E,OAAA+Z,IAAA,EAEA1C,MAAA,GAGA,iBAAAA,EACA,IAAA1d,EAAAmgB,EAAmBngB,EAAAogB,IAASpgB,EAC5BkL,KAAAlL,GAAA0d,MAEG,CACH,IAAA1W,EAAAqR,EAAAkF,SAAAG,GACAA,EACAM,EAAA,IAAA3F,EAAAqF,EAAApD,GAAAtB,YACAjE,EAAA/N,EAAAX,OACA,IAAArG,EAAA,EAAeA,EAAAogB,EAAAD,IAAiBngB,EAChCkL,KAAAlL,EAAAmgB,GAAAnZ,EAAAhH,EAAA+U,GAIA,OAAA7J,MAMA,IAAAwb,EAAA,qBAmBA,SAAArD,EAAA5hB,GACA,OAAAA,EAAA,OAAAA,EAAAuX,SAAA,IACAvX,EAAAuX,SAAA,IAGA,SAAAgF,EAAA/B,EAAA6D,GAEA,IAAAvJ,EADAuJ,KAAAnZ,IAMA,IAJA,IAAAN,EAAA4V,EAAA5V,OACAsgB,EAAA,KACA3f,EAAA,GAEAhH,EAAA,EAAiBA,EAAAqG,IAAYrG,EAAA,CAI7B,IAHAuW,EAAA0F,EAAAxG,WAAAzV,IAGA,OAAAuW,EAAA,OAEA,IAAAoQ,EAAA,CAEA,GAAApQ,EAAA,QAEAuJ,GAAA,OAAA9Y,EAAA6F,KAAA,aACA,SACS,GAAA7M,EAAA,IAAAqG,EAAA,EAETyZ,GAAA,OAAA9Y,EAAA6F,KAAA,aACA,SAIA8Z,EAAApQ,EAEA,SAIA,GAAAA,EAAA,QACAuJ,GAAA,OAAA9Y,EAAA6F,KAAA,aACA8Z,EAAApQ,EACA,SAIAA,EAAA,OAAAoQ,EAAA,UAAApQ,EAAA,YACKoQ,IAEL7G,GAAA,OAAA9Y,EAAA6F,KAAA,aAMA,GAHA8Z,EAAA,KAGApQ,EAAA,KACA,IAAAuJ,GAAA,WACA9Y,EAAA6F,KAAA0J,QACK,GAAAA,EAAA,MACL,IAAAuJ,GAAA,WACA9Y,EAAA6F,KACA0J,GAAA,MACA,GAAAA,EAAA,UAEK,GAAAA,EAAA,OACL,IAAAuJ,GAAA,WACA9Y,EAAA6F,KACA0J,GAAA,OACAA,GAAA,SACA,GAAAA,EAAA,SAEK,MAAAA,EAAA,SASL,MAAA5M,MAAA,sBARA,IAAAmW,GAAA,WACA9Y,EAAA6F,KACA0J,GAAA,OACAA,GAAA,UACAA,GAAA,SACA,GAAAA,EAAA,MAOA,OAAAvP,EA4BA,SAAAiX,EAAAuB,GACA,OAAAnD,EAAAuK,YAhIA,SAAApH,GAIA,IAFAA,EAUA,SAAAA,GACA,OAAAA,EAAAqH,KAAArH,EAAAqH,OACArH,EAAAsH,QAAA,iBAZAC,CAAAvH,GAAAsH,QAAAJ,EAAA,KAEArgB,OAAA,WAEA,KAAAmZ,EAAAnZ,OAAA,MACAmZ,GAAA,IAEA,OAAAA,EAuHAwH,CAAAxH,IAGA,SAAAF,EAAAha,EAAAJ,EAAAuB,EAAAJ,GACA,QAAArG,EAAA,EAAiBA,EAAAqG,KACjBrG,EAAAyG,GAAAvB,EAAAmB,QAAArG,GAAAsF,EAAAe,UAD6BrG,EAE7BkF,EAAAlF,EAAAyG,GAAAnB,EAAAtF,GAEA,OAAAA,GAvvDA,sBCAA,IAAAinB,EAGAA,EAAA,WACA,OAAA/b,KADA,GAIA,IAEA+b,KAAAC,SAAA,iBACC,MAAAnZ,GAED,iBAAAnO,SAAAqnB,EAAArnB,QAOAH,EAAAD,QAAAynB,gCCjBAznB,EAAAwF,WAuCA,SAAAmiB,GACA,IAAAC,EAAAC,EAAAF,GACAG,EAAAF,EAAA,GACAG,EAAAH,EAAA,GACA,UAAAE,EAAAC,GAAA,EAAAA,GA1CA/nB,EAAAonB,YAiDA,SAAAO,GAeA,IAdA,IAAAK,EACAJ,EAAAC,EAAAF,GACAG,EAAAF,EAAA,GACAG,EAAAH,EAAA,GAEA7I,EAAA,IAAAkJ,EAVA,SAAAN,EAAAG,EAAAC,GACA,UAAAD,EAAAC,GAAA,EAAAA,EASAG,CAAAP,EAAAG,EAAAC,IAEAI,EAAA,EAGA5S,EAAAwS,EAAA,EACAD,EAAA,EACAA,EAEAtnB,EAAA,EAAiBA,EAAA+U,EAAS/U,GAAA,EAC1BwnB,EACAI,EAAAT,EAAA1R,WAAAzV,KAAA,GACA4nB,EAAAT,EAAA1R,WAAAzV,EAAA,QACA4nB,EAAAT,EAAA1R,WAAAzV,EAAA,OACA4nB,EAAAT,EAAA1R,WAAAzV,EAAA,IACAue,EAAAoJ,KAAAH,GAAA,OACAjJ,EAAAoJ,KAAAH,GAAA,MACAjJ,EAAAoJ,KAAA,IAAAH,EAGA,IAAAD,IACAC,EACAI,EAAAT,EAAA1R,WAAAzV,KAAA,EACA4nB,EAAAT,EAAA1R,WAAAzV,EAAA,OACAue,EAAAoJ,KAAA,IAAAH,GAGA,IAAAD,IACAC,EACAI,EAAAT,EAAA1R,WAAAzV,KAAA,GACA4nB,EAAAT,EAAA1R,WAAAzV,EAAA,OACA4nB,EAAAT,EAAA1R,WAAAzV,EAAA,OACAue,EAAAoJ,KAAAH,GAAA,MACAjJ,EAAAoJ,KAAA,IAAAH,GAGA,OAAAjJ,GA1FA/e,EAAA6gB,cAiHA,SAAAwH,GAQA,IAPA,IAAAL,EACAzS,EAAA8S,EAAAxhB,OACAyhB,EAAA/S,EAAA,EACAgT,EAAA,GAIA/nB,EAAA,EAAAgoB,EAAAjT,EAAA+S,EAA0C9nB,EAAAgoB,EAAUhoB,GAHpD,MAIA+nB,EAAAlb,KAAAob,EACAJ,EAAA7nB,IALA,MAKAgoB,IAAAhoB,EALA,QAUA,IAAA8nB,GACAN,EAAAK,EAAA9S,EAAA,GACAgT,EAAAlb,KACAqb,EAAAV,GAAA,GACAU,EAAAV,GAAA,MACA,OAEG,IAAAM,IACHN,GAAAK,EAAA9S,EAAA,OAAA8S,EAAA9S,EAAA,GACAgT,EAAAlb,KACAqb,EAAAV,GAAA,IACAU,EAAAV,GAAA,MACAU,EAAAV,GAAA,MACA,MAIA,OAAAO,EAAApF,KAAA,KA1IA,IALA,IAAAuF,EAAA,GACAN,EAAA,GACAH,EAAA,oBAAAtiB,sBAAA0U,MAEA4M,EAAA,mEACAzmB,EAAA,EAAkCA,EAAlCymB,KAA2CzmB,EAC3CkoB,EAAAloB,GAAAymB,EAAAzmB,GACA4nB,EAAAnB,EAAAhR,WAAAzV,MAQA,SAAAqnB,EAAAF,GACA,IAAApS,EAAAoS,EAAA9gB,OAEA,GAAA0O,EAAA,IACA,MAAApL,MAAA,kDAKA,IAAA2d,EAAAH,EAAAtL,QAAA,KAOA,OANA,IAAAyL,MAAAvS,GAMA,CAAAuS,EAJAA,IAAAvS,EACA,EACA,EAAAuS,EAAA,GAqEA,SAAAW,EAAAJ,EAAA1H,EAAAC,GAGA,IAFA,IAAAoH,EARAW,EASAC,EAAA,GACApoB,EAAAmgB,EAAqBngB,EAAAogB,EAASpgB,GAAA,EAC9BwnB,GACAK,EAAA7nB,IAAA,cACA6nB,EAAA7nB,EAAA,cACA,IAAA6nB,EAAA7nB,EAAA,IACAooB,EAAAvb,KAdAqb,GADAC,EAeAX,IAdA,OACAU,EAAAC,GAAA,OACAD,EAAAC,GAAA,MACAD,EAAA,GAAAC,IAaA,OAAAC,EAAAzF,KAAA,IAhGAiF,EAAA,OACAA,EAAA,sBCnBApoB,EAAAkQ,KAAA,SAAAtK,EAAAqB,EAAA4hB,EAAAC,EAAAC,GACA,IAAAxa,EAAA3N,EACAooB,EAAA,EAAAD,EAAAD,EAAA,EACAG,GAAA,GAAAD,GAAA,EACAE,EAAAD,GAAA,EACAE,GAAA,EACA3oB,EAAAqoB,EAAAE,EAAA,IACAjoB,EAAA+nB,GAAA,IACAtmB,EAAAqD,EAAAqB,EAAAzG,GAOA,IALAA,GAAAM,EAEAyN,EAAAhM,GAAA,IAAA4mB,GAAA,EACA5mB,KAAA4mB,EACAA,GAAAH,EACQG,EAAA,EAAW5a,EAAA,IAAAA,EAAA3I,EAAAqB,EAAAzG,MAAAM,EAAAqoB,GAAA,GAKnB,IAHAvoB,EAAA2N,GAAA,IAAA4a,GAAA,EACA5a,KAAA4a,EACAA,GAAAL,EACQK,EAAA,EAAWvoB,EAAA,IAAAA,EAAAgF,EAAAqB,EAAAzG,MAAAM,EAAAqoB,GAAA,GAEnB,OAAA5a,EACAA,EAAA,EAAA2a,MACG,IAAA3a,IAAA0a,EACH,OAAAroB,EAAAwoB,IAAAjiB,KAAA5E,GAAA,KAEA3B,GAAAmF,KAAAmf,IAAA,EAAA4D,GACAva,GAAA2a,EAEA,OAAA3mB,GAAA,KAAA3B,EAAAmF,KAAAmf,IAAA,EAAA3W,EAAAua,IAGA9oB,EAAA6d,MAAA,SAAAjY,EAAAnE,EAAAwF,EAAA4hB,EAAAC,EAAAC,GACA,IAAAxa,EAAA3N,EAAAC,EACAmoB,EAAA,EAAAD,EAAAD,EAAA,EACAG,GAAA,GAAAD,GAAA,EACAE,EAAAD,GAAA,EACAI,EAAA,KAAAP,EAAA/iB,qBAAA,EACAvF,EAAAqoB,EAAA,EAAAE,EAAA,EACAjoB,EAAA+nB,EAAA,KACAtmB,EAAAd,EAAA,OAAAA,GAAA,EAAAA,EAAA,MAmCA,IA/BA6M,MAFA7M,EAAAsE,KAAAujB,IAAA7nB,KAEAA,IAAA0F,KACAvG,EAAA0N,MAAA7M,GAAA,IACA8M,EAAA0a,IAGAxnB,GAAAZ,EAAAkF,KAAAmf,IAAA,IADA3W,EAAAxI,KAAAggB,MAAAhgB,KAAAwjB,IAAA9nB,GAAAsE,KAAAyjB,QACA,IACAjb,IACA1N,GAAA,IAGAY,GADA8M,EAAA2a,GAAA,EACAG,EAAAxoB,EAEAwoB,EAAAtjB,KAAAmf,IAAA,IAAAgE,IAEAroB,GAAA,IACA0N,IACA1N,GAAA,GAGA0N,EAAA2a,GAAAD,GACAroB,EAAA,EACA2N,EAAA0a,GACK1a,EAAA2a,GAAA,GACLtoB,GAAAa,EAAAZ,EAAA,GAAAkF,KAAAmf,IAAA,EAAA4D,GACAva,GAAA2a,IAEAtoB,EAAAa,EAAAsE,KAAAmf,IAAA,EAAAgE,EAAA,GAAAnjB,KAAAmf,IAAA,EAAA4D,GACAva,EAAA,IAIQua,GAAA,EAAWljB,EAAAqB,EAAAzG,GAAA,IAAAI,EAAAJ,GAAAM,EAAAF,GAAA,IAAAkoB,GAAA,GAInB,IAFAva,KAAAua,EAAAloB,EACAooB,GAAAF,EACQE,EAAA,EAAUpjB,EAAAqB,EAAAzG,GAAA,IAAA+N,EAAA/N,GAAAM,EAAAyN,GAAA,IAAAya,GAAA,GAElBpjB,EAAAqB,EAAAzG,EAAAM,IAAA,IAAAyB,kBClFA,IAAAiX,EAAA,GAAiBA,SAEjBvZ,EAAAD,QAAAqa,MAAAC,SAAA,SAAAyE,GACA,wBAAAvF,EAAA7Y,KAAAoe,4uDCKiB0K,EAAWC,EAAPC,EAAJC,ECJAC,SC2CV,MAAeC,GFvCLF,EAAAH,MAAG,IAACE,EAAAC,EAAAD,SAAAC,EAAAD,OAAM,IAAO,SAAAI,GAC9B,IAAYC,GAAZ,SAAYA,GAIRA,IAAA,WAKAA,IAAA,WAKAA,IAAA,WAKAA,IAAA,WAnBJ,CAAYA,EAAAD,EAAAC,kBAAAD,EAAAC,gBAAe,KADG,EAANN,EAAAC,EAAAD,QAAAC,EAAAD,MAAK,KAACK,UAAAL,EAAAK,QAAO,KA2BzC,SAAiBH,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYE,GAAZ,SAAYA,GACRA,IAAA,mBACAA,IAAA,iBAFJ,CAAYA,EAAAF,EAAAE,YAAAF,EAAAE,UAAS,KADS,CAAAP,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAUpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYG,GAAZ,SAAYA,GACRA,IAAA,eACAA,IAAA,mBACAA,IAAA,mBAHJ,CAAYA,EAAAH,EAAAG,YAAAH,EAAAG,UAAS,KADS,CAAAR,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAWpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYI,GAAZ,SAAYA,GACRA,IAAA,aACAA,IAAA,6BAFJ,CAAYA,EAAAJ,EAAAI,WAAAJ,EAAAI,SAAQ,KADU,CAAAT,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAUpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYK,GAAZ,SAAYA,GACRA,IAAA,mBACAA,IAAA,6BACAA,IAAA,6BACAA,IAAA,2BAJJ,CAAYA,EAAAL,EAAAK,WAAAL,EAAAK,SAAQ,KADU,CAAAV,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAYpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYM,GAAZ,SAAYA,GACRA,IAAA,2BACAA,IAAA,uBAFJ,CAAYA,EAAAN,EAAAM,eAAAN,EAAAM,aAAY,KADM,CAAAX,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAcpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYO,GAAZ,SAAYA,GACRA,IAAA,eACAA,IAAA,eACAA,IAAA,aACAA,IAAA,iCACAA,IAAA,mBACAA,IAAA,eACAA,IAAA,eACAA,IAAA,qBACAA,IAAA,eACAA,IAAA,eACAA,IAAA,0BACAA,IAAA,wBACAA,IAAA,gBACAA,IAAA,sBACAA,IAAA,kBACAA,IAAA,sCACAA,IAAA,kCACAA,IAAA,cACAA,IAAA,wBACAA,IAAA,8BACAA,IAAA,0BACAA,IAAA,0BAtBJ,CAAYA,EAAAP,EAAAO,OAAAP,EAAAO,KAAI,KADc,CAAAZ,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAiCpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYQ,GAAZ,SAAYA,GACRA,IAAA,mBACAA,IAAA,aAFJ,CAAYA,EAAAR,EAAAQ,aAAAR,EAAAQ,WAAU,KADQ,CAAAb,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAYpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAaS,EAAb7f,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,qBAAqBiH,EAA4BiD,GAC7C,OAAQA,GAAO,IAAI2V,GAAMC,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMjFjH,iBAAiB+f,GACbA,EAAQxV,YAAY,GAOxBvK,eAAe+f,GAEX,OADaA,EAAQtV,YAIzBzK,kBAAkB+f,GAEd,OADAF,EAAKG,UAAUD,GACRF,EAAKI,QAAQF,IA1CfX,EAAAS,KAAIA,EADa,CAAAd,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAsDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAac,EAAblgB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,wBAAwBiH,EAA4BiD,GAChD,OAAQA,GAAO,IAAIgW,GAASJ,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMpFjH,oBAAoB+f,GAChBA,EAAQxV,YAAY,GAOxBvK,kBAAkB+f,GAEd,OADaA,EAAQtV,YAIzBzK,qBAAqB+f,GAEjB,OADAG,EAAQC,aAAaJ,GACdG,EAAQE,WAAWL,IA1CrBX,EAAAc,QAAOA,EADU,CAAAnB,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAkDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAaiB,EAAbrgB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,qBAAqBiH,EAA4BiD,GAC7C,OAAQA,GAAO,IAAImW,GAAMP,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMjFjH,iBAAiB+f,GACbA,EAAQxV,YAAY,GAOxBvK,eAAe+f,GAEX,OADaA,EAAQtV,YAIzBzK,kBAAkB+f,GAEd,OADAM,EAAKC,UAAUP,GACRM,EAAKE,QAAQR,IA1CfX,EAAAiB,KAAIA,EADa,CAAAtB,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAqDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAaoB,EAAbxgB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,0BAA0BiH,EAA4BiD,GAClD,OAAQA,GAAO,IAAIsW,GAAWV,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMtFjH,sBAAsB+f,GAClBA,EAAQxV,YAAY,GAOxBvK,oBAAoB+f,GAEhB,OADaA,EAAQtV,YAIzBzK,uBAAuB+f,GAEnB,OADAS,EAAUC,eAAeV,GAClBS,EAAUE,aAAaX,IA1CzBX,EAAAoB,UAASA,EADQ,CAAAzB,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAkDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAauB,EAAb3gB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,8BAA8BiH,EAA4BiD,GACtD,OAAQA,GAAO,IAAIyW,GAAeb,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAQ1FjH,WACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2E,UAAU7K,KAAKyM,OAASlR,GAAU,EAM/D0D,0BAA0B+f,GACtBA,EAAQxV,YAAY,GAOxBvK,mBAAmB+f,EAA8Ba,GAC7Cb,EAAQrW,cAAc,EAAGkX,EAAU,GAOvC5gB,wBAAwB+f,GAEpB,OADaA,EAAQtV,YAIzBzK,2BAA2B+f,EAA8Ba,GAGrD,OAFAD,EAAcE,mBAAmBd,GACjCY,EAAcG,YAAYf,EAASa,GAC5BD,EAAcI,iBAAiBhB,IA7DjCX,EAAAuB,cAAaA,EADI,CAAA5B,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA8FpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa4B,EAAbhhB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,oBAAoBiH,EAA4BiD,GAC5C,OAAQA,GAAO,IAAI8W,GAAKlB,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAQhFjH,aACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,QAAOlR,KAAWyE,KAAKkG,GAAIuF,SAASzL,KAAKyM,OAASlR,GAMtD0D,gBAAgB+f,GACZA,EAAQxV,YAAY,GAOxBvK,qBAAqB+f,EAA8BkB,GAC/ClB,EAAQ1W,aAAa,GAAI4X,EAAY,GAOzCjhB,cAAc+f,GAEV,OADaA,EAAQtV,YAIzBzK,iBAAiB+f,EAA8BkB,GAG3C,OAFAD,EAAIE,SAASnB,GACbiB,EAAIG,cAAcpB,EAASkB,GACpBD,EAAII,OAAOrB,IA7DbX,EAAA4B,IAAGA,EADc,CAAAjC,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA0EpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAaiC,EAAbrhB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,sBAAsBiH,EAA4BiD,GAC9C,OAAQA,GAAO,IAAImX,GAAOvB,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMlFjH,OACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQE,UAAUgC,OAO5GthB,QAAQzD,GACJ,IAAID,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2E,UAAU7K,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,EAARC,GAAa,EAM9FyD,gBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAMlE0D,eACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAS,IAAIa,WAAW4D,KAAKkG,GAAIpK,QAAQ5B,OAAQ8F,KAAKkG,GAAIpK,QAAQ3B,WAAa6F,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,IAAW,KAMlL0D,kBAAkB+f,GACdA,EAAQxV,YAAY,GAOxBvK,eAAe+f,EAA8B/oB,GACzC+oB,EAAQtW,cAAc,EAAGzS,EAAMioB,EAAID,OAAOD,MAAMK,QAAQE,UAAUgC,QAOtEthB,kBAAkB+f,EAA8BwB,GAC5CxB,EAAQjW,eAAe,EAAGyX,EAAe,GAQ7CvhB,2BAA2B+f,EAA8BtM,GACrDsM,EAAQlU,YAAY,EAAG4H,EAAKvX,OAAQ,GACpC,IAAK,IAAIrG,EAAI4d,EAAKvX,OAAS,EAAGrG,GAAK,EAAGA,IAClCkqB,EAAQ9W,SAASwK,EAAK5d,IAE1B,OAAOkqB,EAAQ9T,YAOnBjM,0BAA0B+f,EAA8ByB,GACpDzB,EAAQlU,YAAY,EAAG2V,EAAU,GAOrCxhB,gBAAgB+f,GAEZ,OADaA,EAAQtV,YAIzBzK,mBAAmB+f,EAA8B/oB,EAA0CuqB,GAIvF,OAHAF,EAAMI,WAAW1B,GACjBsB,EAAMK,QAAQ3B,EAAS/oB,GACvBqqB,EAAMM,WAAW5B,EAASwB,GACnBF,EAAMO,SAAS7B,IAlHjBX,EAAAiC,MAAKA,EADY,CAAAtC,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA0HpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAayC,EAAb7hB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,oBAAoBiH,EAA4BiD,GAC5C,OAAQA,GAAO,IAAI2X,GAAK/B,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMhFjH,WACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2E,UAAU7K,KAAKyM,OAASlR,GAAU,EAM/D0D,WACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,QAAOlR,KAAWyE,KAAKkG,GAAIuF,SAASzL,KAAKyM,OAASlR,GAMtD0D,gBAAgB+f,GACZA,EAAQxV,YAAY,GAOxBvK,mBAAmB+f,EAA8B+B,GAC7C/B,EAAQrW,cAAc,EAAGoY,EAAU,GAOvC9hB,mBAAmB+f,EAA8BgC,GAC7ChC,EAAQ1W,aAAa,GAAI0Y,EAAU,GAOvC/hB,cAAc+f,GAEV,OADaA,EAAQtV,YAIzBzK,iBAAiB+f,EAA8B+B,EAAkBC,GAI7D,OAHAF,EAAIG,SAASjC,GACb8B,EAAII,YAAYlC,EAAS+B,GACzBD,EAAIK,YAAYnC,EAASgC,GAClBF,EAAIM,OAAOpC,IA5EbX,EAAAyC,IAAGA,EADc,CAAA9C,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAoFpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAagD,EAAbpiB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,8BAA8BiH,EAA4BiD,GACtD,OAAQA,GAAO,IAAIkY,GAAetC,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAM1FjH,YACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQG,UAAU8C,KAM5GriB,0BAA0B+f,GACtBA,EAAQxV,YAAY,GAOxBvK,oBAAoB+f,EAA8BuC,GAC9CvC,EAAQtW,cAAc,EAAG6Y,EAAWrD,EAAID,OAAOD,MAAMK,QAAQG,UAAU8C,MAO3EriB,wBAAwB+f,GAEpB,OADaA,EAAQtV,YAIzBzK,2BAA2B+f,EAA8BuC,GAGrD,OAFAF,EAAcG,mBAAmBxC,GACjCqC,EAAcI,aAAazC,EAASuC,GAC7BF,EAAcK,iBAAiB1C,IA3DjCX,EAAAgD,cAAaA,EADI,CAAArD,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAqEpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAasD,EAAb1iB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,qBAAqBiH,EAA4BiD,GAC7C,OAAQA,GAAO,IAAIwY,GAAM5C,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMjFjH,iBAAiB+f,GACbA,EAAQxV,YAAY,GAOxBvK,eAAe+f,GAEX,OADaA,EAAQtV,YAIzBzK,kBAAkB+f,GAEd,OADA2C,EAAKC,UAAU5C,GACR2C,EAAKE,QAAQ7C,IA1CfX,EAAAsD,KAAIA,EADa,CAAA3D,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAoDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAayD,EAAb7iB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,uBAAuBiH,EAA4BiD,GAC/C,OAAQA,GAAO,IAAI2Y,GAAQ/C,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMnFjH,mBAAmB+f,GACfA,EAAQxV,YAAY,GAOxBvK,iBAAiB+f,GAEb,OADaA,EAAQtV,YAIzBzK,oBAAoB+f,GAEhB,OADA8C,EAAOC,YAAY/C,GACZ8C,EAAOE,UAAUhD,IA1CnBX,EAAAyD,OAAMA,EADW,CAAA9D,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAqDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa4D,EAAbhjB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,0BAA0BiH,EAA4BiD,GAClD,OAAQA,GAAO,IAAI8Y,GAAWlD,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMtFjH,sBAAsB+f,GAClBA,EAAQxV,YAAY,GAOxBvK,oBAAoB+f,GAEhB,OADaA,EAAQtV,YAIzBzK,uBAAuB+f,GAEnB,OADAiD,EAAUC,eAAelD,GAClBiD,EAAUE,aAAanD,IA1CzBX,EAAA4D,UAASA,EADQ,CAAAjE,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAqDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa+D,EAAbnjB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,4BAA4BiH,EAA4BiD,GACpD,OAAQA,GAAO,IAAIiZ,GAAarD,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMxFjH,wBAAwB+f,GACpBA,EAAQxV,YAAY,GAOxBvK,sBAAsB+f,GAElB,OADaA,EAAQtV,YAIzBzK,yBAAyB+f,GAErB,OADAoD,EAAYC,iBAAiBrD,GACtBoD,EAAYE,eAAetD,IA1C7BX,EAAA+D,YAAWA,EADM,CAAApE,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAkDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAakE,EAAbtjB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,gCAAgCiH,EAA4BiD,GACxD,OAAQA,GAAO,IAAIoZ,GAAiBxD,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAQ5FjH,YACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2E,UAAU7K,KAAKyM,OAASlR,GAAU,EAM/D0D,4BAA4B+f,GACxBA,EAAQxV,YAAY,GAOxBvK,oBAAoB+f,EAA8BwD,GAC9CxD,EAAQrW,cAAc,EAAG6Z,EAAW,GAOxCvjB,0BAA0B+f,GAEtB,OADaA,EAAQtV,YAIzBzK,6BAA6B+f,EAA8BwD,GAGvD,OAFAD,EAAgBE,qBAAqBzD,GACrCuD,EAAgBG,aAAa1D,EAASwD,GAC/BD,EAAgBI,mBAAmB3D,IA7DrCX,EAAAkE,gBAAeA,EADE,CAAAvE,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAqEpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAauE,EAAb3jB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,qBAAqBiH,EAA4BiD,GAC7C,OAAQA,GAAO,IAAIyZ,GAAM7D,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMjFjH,iBAAiB+f,GACbA,EAAQxV,YAAY,GAOxBvK,eAAe+f,GAEX,OADaA,EAAQtV,YAIzBzK,kBAAkB+f,GAEd,OADA4D,EAAKC,UAAU7D,GACR4D,EAAKE,QAAQ9D,IA1CfX,EAAAuE,KAAIA,EADa,CAAA5E,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAkDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa0E,EAAb9jB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,wBAAwBiH,EAA4BiD,GAChD,OAAQA,GAAO,IAAI4Z,GAAShE,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAQpFjH,YACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2E,UAAU7K,KAAKyM,OAASlR,GAAU,EAQ/D0D,QACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2E,UAAU7K,KAAKyM,OAASlR,GAAU,EAM/D0D,oBAAoB+f,GAChBA,EAAQxV,YAAY,GAOxBvK,oBAAoB+f,EAA8BuC,GAC9CvC,EAAQrW,cAAc,EAAG4Y,EAAW,GAOxCtiB,gBAAgB+f,EAA8BgE,GAC1ChE,EAAQrW,cAAc,EAAGqa,EAAO,GAOpC/jB,kBAAkB+f,GAEd,OADaA,EAAQtV,YAIzBzK,qBAAqB+f,EAA8BuC,EAAmByB,GAIlE,OAHAD,EAAQE,aAAajE,GACrB+D,EAAQtB,aAAazC,EAASuC,GAC9BwB,EAAQG,SAASlE,EAASgE,GACnBD,EAAQI,WAAWnE,IAhFrBX,EAAA0E,QAAOA,EADU,CAAA/E,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA+FpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa+E,EAAbnkB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,qBAAqBiH,EAA4BiD,GAC7C,OAAQA,GAAO,IAAIia,GAAMrE,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMjFjH,OACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQI,SAAS4E,YAM3GpkB,iBAAiB+f,GACbA,EAAQxV,YAAY,GAOxBvK,eAAe+f,EAA8BsE,GACzCtE,EAAQtW,cAAc,EAAG4a,EAAMpF,EAAID,OAAOD,MAAMK,QAAQI,SAAS4E,aAOrEpkB,eAAe+f,GAEX,OADaA,EAAQtV,YAIzBzK,kBAAkB+f,EAA8BsE,GAG5C,OAFAF,EAAKG,UAAUvE,GACfoE,EAAKI,QAAQxE,EAASsE,GACfF,EAAKK,QAAQzE,IA3DfX,EAAA+E,KAAIA,EADa,CAAApF,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAuEpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAaqF,EAAbzkB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,qBAAqBiH,EAA4BiD,GAC7C,OAAQA,GAAO,IAAIua,GAAM3E,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMjFjH,OACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQK,SAAS2E,YAM3GpkB,WACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2E,UAAU7K,KAAKyM,OAASlR,GAAU,GAM/D0D,iBAAiB+f,GACbA,EAAQxV,YAAY,GAOxBvK,eAAe+f,EAA8BsE,GACzCtE,EAAQtW,cAAc,EAAG4a,EAAMpF,EAAID,OAAOD,MAAMK,QAAQK,SAAS2E,aAOrEpkB,mBAAmB+f,EAA8B+B,GAC7C/B,EAAQrW,cAAc,EAAGoY,EAAU,IAOvC9hB,eAAe+f,GAEX,OADaA,EAAQtV,YAIzBzK,kBAAkB+f,EAA8BsE,EAAyCvC,GAIrF,OAHA2C,EAAKC,UAAU3E,GACf0E,EAAKF,QAAQxE,EAASsE,GACtBI,EAAKxC,YAAYlC,EAAS+B,GACnB2C,EAAKE,QAAQ5E,IA5EfX,EAAAqF,KAAIA,EADa,CAAA1F,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA2FpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAawF,EAAb5kB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,0BAA0BiH,EAA4BiD,GAClD,OAAQA,GAAO,IAAI0a,GAAW9E,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMtFjH,OACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQK,SAASoF,OA8B3G7kB,SAAS8kB,GACL,IAAIxoB,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI0G,SAAS5M,KAAKyM,OAASlR,EAAQwoB,GAAoB,KAMhF9kB,sBAAsB+f,GAClBA,EAAQxV,YAAY,GAOxBvK,eAAe+f,EAA8BsE,GACzCtE,EAAQtW,cAAc,EAAG4a,EAAMpF,EAAID,OAAOD,MAAMK,QAAQK,SAASoF,QAOrE7kB,mBAAmB+f,EAA8BgF,GAC7ChF,EAAQjW,eAAe,EAAGib,EAAgB,GAO9C/kB,oBAAoB+f,GAEhB,OADaA,EAAQtV,YAIzBzK,uBAAuB+f,EAA8BsE,EAAyCU,GAI1F,OAHAH,EAAUI,eAAejF,GACzB6E,EAAUL,QAAQxE,EAASsE,GAC3BO,EAAUK,YAAYlF,EAASgF,GACxBH,EAAUM,aAAanF,IApGzBX,EAAAwF,UAASA,EADQ,CAAA7F,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA4GpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa+F,EAAbnlB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,yBAAyBiH,EAA4BiD,GACjD,OAAQA,GAAO,IAAIib,GAAUrF,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMrFjH,OACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQM,aAAa0F,WAM/GplB,qBAAqB+f,GACjBA,EAAQxV,YAAY,GAOxBvK,eAAe+f,EAA8BsE,GACzCtE,EAAQtW,cAAc,EAAG4a,EAAMpF,EAAID,OAAOD,MAAMK,QAAQM,aAAa0F,YAOzEplB,mBAAmB+f,GAEf,OADaA,EAAQtV,YAIzBzK,sBAAsB+f,EAA8BsE,GAGhD,OAFAc,EAASE,cAActF,GACvBoF,EAASZ,QAAQxE,EAASsE,GACnBc,EAASG,YAAYvF,IA3DvBX,EAAA+F,SAAQA,EADS,CAAApG,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAmEpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAamG,EAAbvlB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,yBAAyBiH,EAA4BiD,GACjD,OAAQA,GAAO,IAAIqb,GAAUzF,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMrFjH,OACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQK,SAAS2E,YAM3GpkB,qBAAqB+f,GACjBA,EAAQxV,YAAY,GAOxBvK,eAAe+f,EAA8BsE,GACzCtE,EAAQtW,cAAc,EAAG4a,EAAMpF,EAAID,OAAOD,MAAMK,QAAQK,SAAS2E,aAOrEpkB,mBAAmB+f,GAEf,OADaA,EAAQtV,YAIzBzK,sBAAsB+f,EAA8BsE,GAGhD,OAFAkB,EAASC,cAAczF,GACvBwF,EAAShB,QAAQxE,EAASsE,GACnBkB,EAASE,YAAY1F,IA3DvBX,EAAAmG,SAAQA,EADS,CAAAxG,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAuEpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAasG,EAAb1lB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,yBAAyBiH,EAA4BiD,GACjD,OAAQA,GAAO,IAAIwb,GAAU5F,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GASrFjH,IAAI8kB,GACA,IAAIxoB,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI0G,SAAS5M,KAAKyM,OAASlR,EAAQwoB,GAAoB,KAShF9kB,MAAM8kB,GACF,IAAIxoB,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI0G,SAAS5M,KAAKyM,OAASlR,EAAQwoB,GAAoB,KAMhF9kB,qBAAqB+f,GACjBA,EAAQxV,YAAY,GAOxBvK,cAAc+f,EAA8B4F,GACxC5F,EAAQjW,eAAe,EAAG6b,EAAW,GAOzC3lB,gBAAgB+f,EAA8B6F,GAC1C7F,EAAQjW,eAAe,EAAG8b,EAAa,GAO3C5lB,mBAAmB+f,GAEf,OADaA,EAAQtV,YAIzBzK,sBAAsB+f,EAA8B4F,EAA+BC,GAI/E,OAHAF,EAASG,cAAc9F,GACvB2F,EAASI,OAAO/F,EAAS4F,GACzBD,EAASK,SAAShG,EAAS6F,GACpBF,EAASM,YAAYjG,IAlFvBX,EAAAsG,SAAQA,EADS,CAAA3G,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA6FpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa6G,EAAbjmB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,mCAAmCiH,EAA4BiD,GAC3D,OAAQA,GAAO,IAAI+b,GAAoBnG,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAU/FjH,KACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2F,UAAU7L,KAAKyM,OAASlR,GAAUyE,KAAKkG,GAAIoF,WAAW,EAAG,GAUtFrM,UAAUkK,GACN,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQyC,KAAK/B,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKyM,OAASlR,GAASyE,KAAKkG,IAAO,KAW5HjH,YACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,QAAOlR,KAAWyE,KAAKkG,GAAIuF,SAASzL,KAAKyM,OAASlR,GAMtD0D,+BAA+B+f,GAC3BA,EAAQxV,YAAY,GAOxBvK,aAAa+f,EAA8BmG,GACvCnG,EAAQpW,cAAc,EAAGuc,EAAInG,EAAQ1T,WAAW,EAAG,IAOvDrM,oBAAoB+f,EAA8BoG,GAC9CpG,EAAQjW,eAAe,EAAGqc,EAAiB,GAO/CnmB,oBAAoB+f,EAA8BqG,GAC9CrG,EAAQ1W,aAAa,GAAI+c,EAAW,GAOxCpmB,6BAA6B+f,GAEzB,OADaA,EAAQtV,YAIzBzK,gCAAgC+f,EAA8BmG,EAAsBC,EAAqCC,GAKrH,OAJAH,EAAmBI,wBAAwBtG,GAC3CkG,EAAmBK,MAAMvG,EAASmG,GAClCD,EAAmBM,aAAaxG,EAASoG,GACzCF,EAAmBO,aAAazG,EAASqG,GAClCH,EAAmBQ,sBAAsB1G,IA1G3CX,EAAA6G,mBAAkBA,EADD,CAAAlH,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAsHpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAasH,EAAb1mB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,sBAAsBiH,EAA4BiD,GAC9C,OAAQA,GAAO,IAAIwc,GAAO5G,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAWlFjH,KAAK8kB,GACD,IAAIxoB,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI0G,SAAS5M,KAAKyM,OAASlR,EAAQwoB,GAAoB,KAQhF9kB,WACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,QAAOlR,KAAWyE,KAAKkG,GAAIuF,SAASzL,KAAKyM,OAASlR,GAMtD0D,WACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIwF,UAAU1L,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQO,KAAKgH,KASvG3mB,KAAkCkK,GAC9B,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,EAASyE,KAAKkG,GAAIyG,QAAQxD,EAAKnJ,KAAKyM,OAASlR,GAAU,KASlE0D,WAAWkK,GACP,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQ6G,oBAAoBnG,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKyM,OAASlR,GAASyE,KAAKkG,IAAO,KAW3IjH,SAASzD,EAAe2N,GACpB,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQsH,OAAO5G,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,EAARC,GAAYwE,KAAKkG,IAAO,KAM7JjH,iBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAUlE0D,eAAezD,EAAe2N,GAC1B,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQsG,UAAU5F,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,EAARC,GAAYwE,KAAKkG,IAAO,KAMhKjH,uBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAMlE0D,kBAAkB+f,GACdA,EAAQxV,YAAY,GAOxBvK,eAAe+f,EAA8B6G,GACzC7G,EAAQjW,eAAe,EAAG8c,EAAY,GAO1C5mB,mBAAmB+f,EAA8B8G,GAC7C9G,EAAQ1W,aAAa,GAAIwd,EAAU,GAOvC7mB,mBAAmB+f,EAA8B+G,GAC7C/G,EAAQ1W,aAAa,EAAGyd,EAAU7H,EAAID,OAAOD,MAAMK,QAAQO,KAAKgH,MAOpE3mB,eAAe+f,EAA8BgH,GACzChH,EAAQjW,eAAe,EAAGid,EAAY,GAO1C/mB,qBAAqB+f,EAA8BiH,GAC/CjH,EAAQjW,eAAe,EAAGkd,EAAkB,GAOhDhnB,mBAAmB+f,EAA8BkH,GAC7ClH,EAAQjW,eAAe,EAAGmd,EAAgB,GAQ9CjnB,4BAA4B+f,EAA8BtM,GACtDsM,EAAQlU,YAAY,EAAG4H,EAAKvX,OAAQ,GACpC,IAAK,IAAIrG,EAAI4d,EAAKvX,OAAS,EAAGrG,GAAK,EAAGA,IAClCkqB,EAAQhW,UAAU0J,EAAK5d,IAE3B,OAAOkqB,EAAQ9T,YAOnBjM,2BAA2B+f,EAA8ByB,GACrDzB,EAAQlU,YAAY,EAAG2V,EAAU,GAOrCxhB,yBAAyB+f,EAA8BmH,GACnDnH,EAAQjW,eAAe,EAAGod,EAAsB,GAQpDlnB,kCAAkC+f,EAA8BtM,GAC5DsM,EAAQlU,YAAY,EAAG4H,EAAKvX,OAAQ,GACpC,IAAK,IAAIrG,EAAI4d,EAAKvX,OAAS,EAAGrG,GAAK,EAAGA,IAClCkqB,EAAQhW,UAAU0J,EAAK5d,IAE3B,OAAOkqB,EAAQ9T,YAOnBjM,iCAAiC+f,EAA8ByB,GAC3DzB,EAAQlU,YAAY,EAAG2V,EAAU,GAOrCxhB,gBAAgB+f,GAEZ,OADaA,EAAQtV,YAIzBzK,mBAAmB+f,EAA8B6G,EAAgCC,EAAmBC,EAAyCC,EAAgCC,EAAsCC,EAAoCC,GASnP,OARAR,EAAMS,WAAWpH,GACjB2G,EAAMU,QAAQrH,EAAS6G,GACvBF,EAAMW,YAAYtH,EAAS8G,GAC3BH,EAAMY,YAAYvH,EAAS+G,GAC3BJ,EAAMa,QAAQxH,EAASgH,GACvBL,EAAMc,cAAczH,EAASiH,GAC7BN,EAAMe,YAAY1H,EAASkH,GAC3BP,EAAMgB,kBAAkB3H,EAASmH,GAC1BR,EAAMiB,SAAS5H,IAjPjBX,EAAAsH,MAAKA,EADY,CAAA3H,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KA4PpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GACjBA,EAAAlR,OAAb,MAAAlO,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KASXf,SACI,OAAOe,KAAKkG,GAAI2F,UAAU7L,KAAKyM,QASnCxN,SACI,OAAOe,KAAKkG,GAAI2F,UAAU7L,KAAKyM,OAAS,GAS5CxN,oBAAoB+f,EAA8BzjB,EAA0BJ,GAIxE,OAHA6jB,EAAQ7X,KAAK,EAAG,IAChB6X,EAAQnX,WAAW1M,GACnB6jB,EAAQnX,WAAWtM,GACZyjB,EAAQzjB,WA9CO,CAAAyiB,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KAyDpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAawI,EAAb5nB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,uBAAuBiH,EAA4BiD,GAC/C,OAAQA,GAAO,IAAI0d,GAAQ9H,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAUnFjH,aACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQQ,WAAWiI,OAQ7G7nB,OAAOzD,EAAe2N,GAClB,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQsH,OAAO5G,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,EAARC,GAAYwE,KAAKkG,IAAO,KAM7JjH,eACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAQlE0D,eAAezD,EAAe2N,GAC1B,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQsG,UAAU5F,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,EAARC,GAAYwE,KAAKkG,IAAO,KAMhKjH,uBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAMlE0D,mBAAmB+f,GACfA,EAAQxV,YAAY,GAOxBvK,qBAAqB+f,EAA8B+H,GAC/C/H,EAAQtW,cAAc,EAAGqe,EAAY7I,EAAID,OAAOD,MAAMK,QAAQQ,WAAWiI,QAO7E7nB,iBAAiB+f,EAA8BgI,GAC3ChI,EAAQjW,eAAe,EAAGie,EAAc,GAQ5C/nB,0BAA0B+f,EAA8BtM,GACpDsM,EAAQlU,YAAY,EAAG4H,EAAKvX,OAAQ,GACpC,IAAK,IAAIrG,EAAI4d,EAAKvX,OAAS,EAAGrG,GAAK,EAAGA,IAClCkqB,EAAQhW,UAAU0J,EAAK5d,IAE3B,OAAOkqB,EAAQ9T,YAOnBjM,yBAAyB+f,EAA8ByB,GACnDzB,EAAQlU,YAAY,EAAG2V,EAAU,GAOrCxhB,yBAAyB+f,EAA8BmH,GACnDnH,EAAQjW,eAAe,EAAGod,EAAsB,GAQpDlnB,kCAAkC+f,EAA8BtM,GAC5DsM,EAAQlU,YAAY,EAAG4H,EAAKvX,OAAQ,GACpC,IAAK,IAAIrG,EAAI4d,EAAKvX,OAAS,EAAGrG,GAAK,EAAGA,IAClCkqB,EAAQhW,UAAU0J,EAAK5d,IAE3B,OAAOkqB,EAAQ9T,YAOnBjM,iCAAiC+f,EAA8ByB,GAC3DzB,EAAQlU,YAAY,EAAG2V,EAAU,GAOrCxhB,iBAAiB+f,GAEb,OADaA,EAAQtV,YAQzBzK,0BAA0B+f,EAA8BzjB,GACpDyjB,EAAQ7U,OAAO5O,GAGnB0D,oBAAoB+f,EAA8B+H,EAAiDC,EAAkCb,GAKjI,OAJAU,EAAOI,YAAYjI,GACnB6H,EAAOK,cAAclI,EAAS+H,GAC9BF,EAAOM,UAAUnI,EAASgI,GAC1BH,EAAOF,kBAAkB3H,EAASmH,GAC3BU,EAAOO,UAAUpI,IAvKnBX,EAAAwI,OAAMA,EADW,CAAA7I,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBF,MAAG,KCrlEpB,SAAiBG,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAChBA,EAAAwI,OAAS9I,EAA0BE,OAAOD,MAAMK,QAAQwI,OADxC,CAAA7I,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBE,MAAG,KAepB,SAAiBD,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,IAAYgJ,GAAZ,SAAYA,GACRA,IAAA,eACAA,IAAA,mBACAA,IAAA,qCACAA,IAAA,6BACAA,IAAA,mBACAA,IAAA,+BANJ,CAAYA,EAAAhJ,EAAAgJ,gBAAAhJ,EAAAgJ,cAAa,KADK,CAAArJ,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBE,MAAG,KAwBpB,SAAiBD,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GACjBA,EAAAiJ,UAAb,MAAAroB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KASXf,SACI,OAAOe,KAAKkG,GAAI2F,UAAU7L,KAAKyM,QAUnCxN,YACI,OAAOe,KAAKkG,GAAI2F,UAAU7L,KAAKyM,OAAS,GAS5CxN,uBAAuB+f,EAA8B7jB,EAA0BosB,GAI3E,OAHAvI,EAAQ7X,KAAK,EAAG,IAChB6X,EAAQnX,WAAW0f,GACnBvI,EAAQnX,WAAW1M,GACZ6jB,EAAQzjB,WA/CO,CAAAyiB,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBE,MAAG,KA2DpB,SAAiBD,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAamJ,EAAbvoB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,4BAA4BiH,EAA4BiD,GACpD,OAAQA,GAAO,IAAIqe,GAAazI,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GASxFjH,SACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2F,UAAU7L,KAAKyM,OAASlR,GAAUyE,KAAKkG,GAAIoF,WAAW,EAAG,GAUtFrM,MAAMzD,EAAe2N,GACjB,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQiJ,WAAWvI,OAAO/e,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,GAARC,EAAYwE,KAAKkG,IAAO,KAM7IjH,cACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAelE0D,QAAQzD,EAAe2N,GACnB,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI4U,EAA0BE,OAAOD,MAAMK,QAAQlR,QAAQ4R,OAAO/e,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,GAARC,EAAYwE,KAAKkG,IAAO,KAMhKjH,gBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAMlE0D,wBAAwB+f,GACpBA,EAAQxV,YAAY,GAOxBvK,iBAAiB+f,EAA8B7jB,GAC3C6jB,EAAQpW,cAAc,EAAGzN,EAAQ6jB,EAAQ1T,WAAW,EAAG,IAO3DrM,gBAAgB+f,EAA8ByI,GAC1CzI,EAAQjW,eAAe,EAAG0e,EAAa,GAO3CxoB,wBAAwB+f,EAA8ByB,GAClDzB,EAAQlU,YAAY,GAAI2V,EAAU,GAOtCxhB,kBAAkB+f,EAA8B0I,GAC5C1I,EAAQjW,eAAe,EAAG2e,EAAe,GAO7CzoB,0BAA0B+f,EAA8ByB,GACpDzB,EAAQlU,YAAY,GAAI2V,EAAU,GAOtCxhB,sBAAsB+f,GAElB,OADaA,EAAQtV,YAIzBzK,yBAAyB+f,EAA8B7jB,EAA0BssB,EAAiCC,GAK9G,OAJAF,EAAYG,iBAAiB3I,GAC7BwI,EAAYI,UAAU5I,EAAS7jB,GAC/BqsB,EAAYK,SAAS7I,EAASyI,GAC9BD,EAAYM,WAAW9I,EAAS0I,GACzBF,EAAYO,eAAe/I,IA7I7BX,EAAAmJ,YAAWA,EADM,CAAAxJ,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBE,MAAG,KA4JpB,SAAiBD,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAa2J,EAAb/oB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,gCAAgCiH,EAA4BiD,GACxD,OAAQA,GAAO,IAAI6e,GAAiBjJ,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAM5FjH,KACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2F,UAAU7L,KAAKyM,OAASlR,GAAUyE,KAAKkG,GAAIoF,WAAW,EAAG,GAOtFrM,KAAKkK,GACD,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQmJ,aAAazI,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKyM,OAASlR,GAASyE,KAAKkG,IAAO,KASpIjH,UACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,QAAOlR,KAAWyE,KAAKkG,GAAIuF,SAASzL,KAAKyM,OAASlR,GAMtD0D,4BAA4B+f,GACxBA,EAAQxV,YAAY,GAOxBvK,aAAa+f,EAA8BmG,GACvCnG,EAAQpW,cAAc,EAAGuc,EAAInG,EAAQ1T,WAAW,EAAG,IAOvDrM,eAAe+f,EAA8BiJ,GACzCjJ,EAAQjW,eAAe,EAAGkf,EAAY,GAO1ChpB,kBAAkB+f,EAA8BkJ,GAC5ClJ,EAAQ1W,aAAa,GAAI4f,EAAS,GAOtCjpB,0BAA0B+f,GAEtB,OADaA,EAAQtV,YAIzBzK,6BAA6B+f,EAA8BmG,EAAsB8C,EAAgCC,GAK7G,OAJAF,EAAgBG,qBAAqBnJ,GACrCgJ,EAAgBzC,MAAMvG,EAASmG,GAC/B6C,EAAgBI,QAAQpJ,EAASiJ,GACjCD,EAAgBK,WAAWrJ,EAASkJ,GAC7BF,EAAgBM,mBAAmBtJ,IAjGrCX,EAAA2J,gBAAeA,EADE,CAAAhK,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBE,MAAG,KAyGpB,SAAiBD,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAakK,EAAbtpB,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,wBAAwBiH,EAA4BiD,GAChD,OAAQA,GAAO,IAAIof,GAASxJ,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMpFjH,UACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAWwiB,EAA0BE,OAAOD,MAAMK,QAAQC,gBAAgBkK,GAMxIvpB,aACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIwF,UAAU1L,KAAKyM,OAASlR,GAAW2iB,EAAID,OAAOD,MAAMK,QAAQgJ,cAAczB,KAOhH3mB,OAAoCkK,GAChC,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAIyG,QAAQxD,EAAKnJ,KAAKyM,OAASlR,GAAU,KAMlE0D,aACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,EAASyE,KAAKkG,GAAI2F,UAAU7L,KAAKyM,OAASlR,GAAUyE,KAAKkG,GAAIoF,WAAW,EAAG,GAQtFrM,eAAezD,EAAe2N,GAC1B,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,GAAU4N,GAAO,IAAI4U,EAA0BE,OAAOD,MAAMK,QAAQsG,UAAU5F,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,EAARC,GAAYwE,KAAKkG,IAAO,KAMtLjH,uBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAMlE0D,oBAAoB+f,GAChBA,EAAQxV,YAAY,GAOxBvK,kBAAkB+f,EAA8ByJ,GAC5CzJ,EAAQtW,cAAc,EAAG+f,EAAS1K,EAA0BE,OAAOD,MAAMK,QAAQC,gBAAgBkK,IAOrGvpB,qBAAqB+f,EAA8B0J,GAC/C1J,EAAQ1W,aAAa,EAAGogB,EAAYxK,EAAID,OAAOD,MAAMK,QAAQgJ,cAAczB,MAO/E3mB,iBAAiB+f,EAA8B2J,GAC3C3J,EAAQjW,eAAe,EAAG4f,EAAc,GAO5C1pB,qBAAqB+f,EAA8B4J,GAC/C5J,EAAQpW,cAAc,EAAGggB,EAAY5J,EAAQ1T,WAAW,EAAG,IAO/DrM,yBAAyB+f,EAA8BmH,GACnDnH,EAAQjW,eAAe,EAAGod,EAAsB,GAQpDlnB,kCAAkC+f,EAA8BtM,GAC5DsM,EAAQlU,YAAY,EAAG4H,EAAKvX,OAAQ,GACpC,IAAK,IAAIrG,EAAI4d,EAAKvX,OAAS,EAAGrG,GAAK,EAAGA,IAClCkqB,EAAQhW,UAAU0J,EAAK5d,IAE3B,OAAOkqB,EAAQ9T,YAOnBjM,iCAAiC+f,EAA8ByB,GAC3DzB,EAAQlU,YAAY,EAAG2V,EAAU,GAOrCxhB,kBAAkB+f,GAEd,OADaA,EAAQtV,YAQzBzK,2BAA2B+f,EAA8BzjB,GACrDyjB,EAAQ7U,OAAO5O,GAGnB0D,qBAAqB+f,EAA8ByJ,EAAyEC,EAAoDC,EAAkCC,EAA8BzC,GAO5O,OANAoC,EAAQM,aAAa7J,GACrBuJ,EAAQO,WAAW9J,EAASyJ,GAC5BF,EAAQQ,cAAc/J,EAAS0J,GAC/BH,EAAQS,UAAUhK,EAAS2J,GAC3BJ,EAAQU,cAAcjK,EAAS4J,GAC/BL,EAAQ5B,kBAAkB3H,EAASmH,GAC5BoC,EAAQW,WAAWlK,IAvKrBX,EAAAkK,QAAOA,EADU,CAAAvK,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBE,MAAG,KEvVb,IAmCKS,EAmEAuK,EAtGEC,EAAYrL,EAAYE,OAAOD,MAAMK,QAAQO,KAC7CH,EAAWV,EAAYE,OAAOD,MAAMK,QAAQI,SAC5CC,EAAWX,EAAYE,OAAOD,MAAMK,QAAQK,SAC5CF,EAAYT,EAAYE,OAAOD,MAAMK,QAAQG,UAC7CD,EAAYR,EAAYE,OAAOD,MAAMK,QAAQE,UAC7CI,EAAeZ,EAAYE,OAAOD,MAAMK,QAAQM,aAChD0I,EAAgBlJ,EAAaF,OAAOD,MAAMK,QAAQgJ,cAClD/I,EAAkBP,EAAYE,OAAOD,MAAMK,QAAQC,gBCT1D,SAAS+K,EAAQC,EAAYC,EAAgBC,EAAcC,GAC9D,OAA6B,IAArBD,EAAO,GAAKC,GAIjB,SAASC,EAAOJ,EAAYC,EAAgBC,EAAcC,GAC7D,OAAQD,EAAO,GAAKC,IAAQA,EAIzB,SAASE,EAAQ7tB,EAAmBN,EAAezF,GACtD,OAAOA,KACA+F,EAAMN,GAAS,IAAQ,GAAMA,EAAQ,KAAQ,IAC9CM,EAAMN,GAAS,MAAQ,GAAMA,EAAQ,MAAQ,EAIhD,SAASouB,EAAeruB,EAAgBJ,EAAgB0uB,GAC3D,MAAMC,EAAeD,EAAO/vB,WAAa,GAAK,EAC9C,GAAIyB,EAAS,GAAKsuB,EAAO/vB,WAAagwB,EAAa,CAC/C,MAAMhuB,EAAQ,IAAI7B,WAAW6vB,GAK7B,OAHAhuB,EAAMvB,IAAIgB,EAAS,GAAM,EAAIsuB,EAAOnuB,SAASH,GAAU,GAEnDwuB,EAAUC,EAAYH,EAAQtuB,EAAQJ,EAAQ,KAAMkuB,IAAU3tB,SAAS,EAAGouB,IACvEhuB,EAEX,OAAO+tB,EAIJ,SAASE,EAAUE,GACtB,IAAIC,EAAe,GACfp1B,EAAI,EAAG20B,EAAM,EAAGD,EAAO,EAC3B,IAAK,MAAMzzB,KAASk0B,EAChBl0B,IAAUyzB,GAAQ,GAAKC,GACT,KAARA,IACFS,EAAGp1B,KAAO00B,EACVA,EAAOC,EAAM,IAGX,IAAN30B,GAAW20B,EAAM,KAAKS,EAAGp1B,KAAO00B,GACpC,IAAIluB,EAAI,IAAIrB,WAAYiwB,EAAG/uB,OAAS,GAAK,GAEzC,OADAG,EAAEf,IAAI2vB,GACC5uB,EAIJ,SAAU0uB,EAAeluB,EAAmBquB,EAAehvB,EAAgBivB,EAClDz0B,GAC5B,IAAI8zB,EAAMU,EAAQ,EACdE,EAAYF,GAAS,EACrB3uB,EAAQ,EAAGsY,EAAY3Y,EAC3B,KAAO2Y,EAAY,EAAG2V,EAAM,EAAG,CAC3B,IAAID,EAAO1tB,EAAMuuB,KACjB,SACU10B,EAAIy0B,EAAS5uB,IAASguB,EAAMC,WAC3B3V,EAAY,KAAO2V,EAAM,IAWrC,SAASa,EAAiB5X,EAAkB6X,EAAaC,GAC5D,GAAIA,EAAMD,GAAO,EAAK,OAAO,EAE7B,GAAIC,EAAMD,EAAM,EAAG,CACf,IAAIE,EAAM,EACV,IAAK,MAAMhB,KAAOO,EAAYtX,EAAM6X,EAAKC,EAAMD,EAAK7X,EAAMgX,GACtDe,GAAOhB,EAEX,OAAOgB,EAGX,MAAMC,EAAYF,GAAO,GAAK,EAExBG,EAAYJ,GAAOA,EAAM,GAAM,EAAI,EAAI,EAAIA,EAAM,GACvD,OAEID,EAAiB5X,EAAM6X,EAAKI,GAE5BL,EAAiB5X,EAAMgY,EAAWF,GAElCI,EAAalY,EAAMiY,GAAa,EAAID,EAAYC,GAAc,GAK/D,SAASC,EAAavX,EAAsBlZ,EAAqBL,GACpE,IAAI+wB,EAAM,EAAG/T,EAAoB,EAAd3c,EACnB,MAAM2wB,EAAO,IAAIC,SAAS1X,EAAInZ,OAAQmZ,EAAIlZ,WAAYkZ,EAAIvZ,YACpD+P,OAAsB,IAAf/P,EAAwBuZ,EAAIvZ,WAAagd,EAAMhd,EAC5D,KAAO+P,EAAMiN,GAAO,GAChB+T,GAAOG,EAAcF,EAAKG,UAAUnU,IACpCA,GAAO,EAEX,KAAOjN,EAAMiN,GAAO,GAChB+T,GAAOG,EAAcF,EAAKI,UAAUpU,IACpCA,GAAO,EAEX,KAAOjN,EAAMiN,GAAO,GAChB+T,GAAOG,EAAcF,EAAKK,SAASrU,IACnCA,GAAO,EAEX,OAAO+T,EAIJ,SAASG,EAAcI,GAC1B,IAAIt2B,EAAa,EAATs2B,EAGR,OAAyC,WADzCt2B,GAAS,WADTA,GAAUA,IAAM,EAAK,cACIA,IAAM,EAAK,aACrBA,IAAM,GAAM,aAA8B,IDhF7D,SAAY8pB,GAERA,IAAA,eAEAA,IAAA,eAEAA,IAAA,aAEAA,IAAA,iBAEAA,IAAA,mBAEAA,IAAA,eAEAA,IAAA,eAEAA,IAAA,qBAEAA,IAAA,eAEAA,IAAA,eAEAA,IAAA,0BAEAA,IAAA,wBAEAA,IAAA,gBAEAA,IAAA,oBAEAA,IAAA,kBAEAA,IAAA,sCAEAA,IAAA,kCAEAA,IAAA,cAGAA,IAAA,4BACAA,IAAA,gBACAA,IAAA,kBACAA,IAAA,kBACAA,IAAA,kBACAA,IAAA,kBACAA,IAAA,oBACAA,IAAA,oBACAA,IAAA,oBACAA,IAAA,uBACAA,IAAA,uBACAA,IAAA,uBACAA,IAAA,uBACAA,IAAA,uCACAA,IAAA,uCACAA,IAAA,iDACAA,IAAA,iDACAA,IAAA,+CACAA,IAAA,6BACAA,IAAA,uCACAA,IAAA,uCACAA,IAAA,qCACAA,IAAA,6BACAA,IAAA,+BACAA,IAAA,uCACAA,IAAA,2CAhEJ,CAAYA,MAAI,KAmEhB,SAAYuK,GAIRA,IAAA,mBAKAA,IAAA,eAKAA,IAAA,uBAKAA,IAAA,eAnBJ,CAAYA,MAAU,KEpGf,MAAekC,EACXpsB,UAAUqsB,KAAiBC,GAC9B,OAAOD,EAAM5nB,IAAI,CAAC8nB,EAAM12B,IAAMkL,KAAKyrB,MAAMD,KAASD,EAAK7nB,IAAK1I,GAAMA,EAAElG,MAEjEmK,SAASssB,GACZ,OAAOvrB,KAAK0rB,WAAWH,EAAK,IAAI,GAAO7a,MAAM1Q,KAAMurB,GAEhDtsB,WAAWusB,EAAWG,GAAkB,GAC3C,OAuBR,SAAwCC,EAAkBJ,EAAWG,GAAkB,GACnF,IAAI9nB,EAAU,KACVgoB,EAAoBjN,EAAKgH,KAEpB4F,aAAgBM,GAAYD,EAAQE,EAAWP,EAAK/Y,MACpD+Y,aAAgBpN,EAAYyN,EAAQE,EAAWP,EAAK/Y,MACpD+Y,aAAgBQ,EAAYH,EAAQE,EAAWP,GACrB,iBAAlBK,EAAQL,KAAsBK,EAAQjN,EAAK4M,IAE5D,OAAQK,GACJ,KAAKjN,EAAKE,KAAsBjb,EAAK+nB,EAAQK,UAAW,MACxD,KAAKrN,EAAKgE,KAAsB/e,EAAK+nB,EAAQM,UAAW,MACxD,KAAKtN,EAAKkC,IAAsBjd,EAAK+nB,EAAQO,SAAU,MACvD,KAAKvN,EAAKwN,KAAsBvoB,EAAK+nB,EAAQS,WAAaT,EAAQO,SAAU,MAC5E,KAAKvN,EAAK0N,MAAsBzoB,EAAK+nB,EAAQW,YAAcX,EAAQO,SAAU,MAC7E,KAAKvN,EAAK4N,MAAsB3oB,EAAK+nB,EAAQa,YAAcb,EAAQO,SAAU,MAC7E,KAAKvN,EAAK8N,MAAsB7oB,EAAK+nB,EAAQe,YAAcf,EAAQO,SAAU,MAC7E,KAAKvN,EAAKgO,MAAsB/oB,EAAK+nB,EAAQiB,YAAcjB,EAAQO,SAAU,MAC7E,KAAKvN,EAAKkO,OAAsBjpB,EAAK+nB,EAAQmB,aAAenB,EAAQO,SAAU,MAC9E,KAAKvN,EAAKoO,OAAsBnpB,EAAK+nB,EAAQqB,aAAerB,EAAQO,SAAU,MAC9E,KAAKvN,EAAKsO,OAAsBrpB,EAAK+nB,EAAQuB,aAAevB,EAAQO,SAAU,MAC9E,KAAKvN,EAAKwO,MAAsBvpB,EAAK+nB,EAAQyB,WAAY,MACzD,KAAKzO,EAAK0O,QAAsBzpB,EAAK+nB,EAAQ2B,cAAgB3B,EAAQyB,WAAY,MACjF,KAAKzO,EAAK4O,QAAsB3pB,EAAK+nB,EAAQ6B,cAAgB7B,EAAQyB,WAAY,MACjF,KAAKzO,EAAK8O,QAAsB7pB,EAAK+nB,EAAQ+B,cAAgB/B,EAAQyB,WAAY,MACjF,KAAKzO,EAAK+C,KAAsB9d,EAAK+nB,EAAQgC,UAAW,MACxD,KAAKhP,EAAKkD,OAAsBje,EAAK+nB,EAAQiC,YAAa,MAC1D,KAAKjP,EAAK2D,gBAAsB1e,EAAK+nB,EAAQkC,qBAAsB,MACnE,KAAKlP,EAAKwE,KAAsBvf,EAAK+nB,EAAQmC,UAAW,MACxD,KAAKnP,EAAKoP,QAAsBnqB,EAAK+nB,EAAQqC,cAAgBrC,EAAQmC,UAAW,MAChF,KAAKnP,EAAKsP,gBAAsBrqB,EAAK+nB,EAAQuC,sBAAwBvC,EAAQmC,UAAW,MACxF,KAAKnP,EAAKiF,UAAsBhgB,EAAK+nB,EAAQwC,eAAgB,MAC7D,KAAKxP,EAAKyP,gBAAsBxqB,EAAK+nB,EAAQ0C,sBAAwB1C,EAAQwC,eAAgB,MAC7F,KAAKxP,EAAK2P,qBAAsB1qB,EAAK+nB,EAAQ4C,2BAA6B5C,EAAQwC,eAAgB,MAClG,KAAKxP,EAAK6P,qBAAsB5qB,EAAK+nB,EAAQ8C,2BAA6B9C,EAAQwC,eAAgB,MAClG,KAAKxP,EAAK+P,oBAAsB9qB,EAAK+nB,EAAQgD,0BAA4BhD,EAAQwC,eAAgB,MACjG,KAAKxP,EAAK8E,KAAsB7f,EAAK+nB,EAAQiD,UAAW,MACxD,KAAKjQ,EAAKkQ,WAAsBjrB,EAAK+nB,EAAQmD,iBAAmBnD,EAAQiD,UAAW,MACnF,KAAKjQ,EAAKoQ,gBAAsBnrB,EAAK+nB,EAAQqD,sBAAwBrD,EAAQiD,UAAW,MACxF,KAAKjQ,EAAKsQ,gBAAsBrrB,EAAK+nB,EAAQuD,sBAAwBvD,EAAQiD,UAAW,MACxF,KAAKjQ,EAAKwQ,eAAsBvrB,EAAK+nB,EAAQyD,qBAAuBzD,EAAQiD,UAAW,MACvF,KAAKjQ,EAAKmE,QAAsBlf,EAAK+nB,EAAQ0D,aAAc,MAC3D,KAAK1Q,EAAKU,KAAsBzb,EAAK+nB,EAAQ2D,UAAW,MACxD,KAAK3Q,EAAK4Q,OAAsB3rB,EAAK+nB,EAAQ6D,YAAa,MAC1D,KAAK7Q,EAAK0B,MAAsBzc,EAAK+nB,EAAQ8D,WAAY,MACzD,KAAK9Q,EAAK+Q,WAAsB9rB,EAAK+nB,EAAQgE,iBAAmBhE,EAAQ8D,WAAY,MACpF,KAAK9Q,EAAKiR,YAAsBhsB,EAAK+nB,EAAQkE,kBAAoBlE,EAAQ8D,WAAY,MACrF,KAAK9Q,EAAKmR,WAAsBlsB,EAAK+nB,EAAQoE,gBAAiB,MAC9D,KAAKpR,EAAKwF,SAAsBvgB,EAAK+nB,EAAQqE,cAAe,MAC5D,KAAKrR,EAAKsR,gBAAsBrsB,EAAK+nB,EAAQuE,sBAAwBvE,EAAQqE,cAAe,MAC5F,KAAKrR,EAAKwR,kBAAsBvsB,EAAK+nB,EAAQyE,wBAA0BzE,EAAQqE,cAAe,MAC9F,KAAKrR,EAAKgB,cAAsB/b,EAAK+nB,EAAQ0E,mBAAoB,MACjE,KAAK1R,EAAKqB,IAAsBpc,EAAK+nB,EAAQ2E,SAEjD,GAAkB,mBAAP1sB,EAAmB,OAAOA,EACrC,IAAK8nB,EAAiB,MAAO,IAAM,KACnC,MAAUltB,4BAA4BmgB,EAAKiN,OA/EhCH,CAAW1rB,KAAMwrB,EAAMG,GAE3B1sB,UAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,UAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,SAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,WAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,UAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,YAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,qBAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,UAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,eAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,UAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,aAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,UAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,YAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,WAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,gBAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,cAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,mBAAsBuxB,KAAenuB,GAAqB,OAAO,KACjEpD,SAAsBuxB,KAAenuB,GAAqB,OAAO,MAgE5E,SAAS0pB,EAA+BtZ,GACpC,OAAQA,EAAKge,QACT,KAAK7R,EAAKE,KAAM,OAAOF,EAAKE,KAC5B,KAAKF,EAAKkC,IACN,MAAMC,SAAEA,EAAQC,SAAEA,GAAcvO,EAChC,OAAQsO,GACJ,KAAM,EAAG,OAAOC,EAAWpC,EAAKwN,KAAQxN,EAAKgO,MAC7C,KAAK,GAAI,OAAO5L,EAAWpC,EAAK0N,MAAQ1N,EAAKkO,OAC7C,KAAK,GAAI,OAAO9L,EAAWpC,EAAK4N,MAAQ5N,EAAKoO,OAC7C,KAAK,GAAI,OAAOhM,EAAWpC,EAAK8N,MAAQ9N,EAAKsO,OAEjD,OAAOtO,EAAKkC,IAChB,KAAKlC,EAAKwO,MACN,OAAQ3a,EAAsB8O,WAC1B,KAAK/C,EAAU8C,KAAM,OAAO1C,EAAK0O,QACjC,KAAK9O,EAAUkS,OAAQ,OAAO9R,EAAK4O,QACnC,KAAKhP,EAAUmS,OAAQ,OAAO/R,EAAK8O,QAEvC,OAAO9O,EAAKwO,MAChB,KAAKxO,EAAKkD,OAAQ,OAAOlD,EAAKkD,OAC9B,KAAKlD,EAAK+C,KAAM,OAAO/C,EAAK+C,KAC5B,KAAK/C,EAAKgE,KAAM,OAAOhE,EAAKgE,KAC5B,KAAKhE,EAAKmE,QAAS,OAAOnE,EAAKmE,QAC/B,KAAKnE,EAAK8E,KACN,OAASjR,EAAqB6Q,MAC1B,KAAK5E,EAASoF,OAAQ,OAAOlF,EAAKkQ,WAClC,KAAKpQ,EAAS2E,YAAa,OAAOzE,EAAKoQ,gBACvC,KAAKtQ,EAASkS,YAAa,OAAOhS,EAAKsQ,gBACvC,KAAKxQ,EAASmS,WAAY,OAAOjS,EAAKwQ,eAE1C,OAAOxQ,EAAK8E,KAChB,KAAK9E,EAAKiF,UACN,OAASpR,EAA0B6Q,MAC/B,KAAK5E,EAASoF,OAAQ,OAAOlF,EAAKyP,gBAClC,KAAK3P,EAAS2E,YAAa,OAAOzE,EAAK2P,qBACvC,KAAK7P,EAASkS,YAAa,OAAOhS,EAAK6P,qBACvC,KAAK/P,EAASmS,WAAY,OAAOjS,EAAK+P,oBAE1C,OAAO/P,EAAKiF,UAChB,KAAKjF,EAAKwE,KACN,OAAS3Q,EAAsB6Q,MAC3B,KAAK7E,EAASqS,IAAK,OAAOlS,EAAKoP,QAC/B,KAAKvP,EAAS4E,YAAa,OAAOzE,EAAKsP,gBAE3C,OAAOtP,EAAKwE,KAChB,KAAKxE,EAAKwF,SACN,OAAS3R,EAAyB6Q,MAC9B,KAAK3E,EAAaoS,SAAU,OAAOnS,EAAKsR,gBACxC,KAAKvR,EAAa0F,WAAY,OAAOzF,EAAKwR,kBAE9C,OAAOxR,EAAKwF,SAChB,KAAKxF,EAAKqB,IAAK,OAAOrB,EAAKqB,IAC3B,KAAKrB,EAAKU,KAAM,OAAOV,EAAKU,KAC5B,KAAKV,EAAK4Q,OAAQ,OAAO5Q,EAAK4Q,OAC9B,KAAK5Q,EAAK0B,MACN,OAAS7N,EAAsBxc,MAC3B,KAAKsoB,EAAUyS,MAAO,OAAOpS,EAAK+Q,WAClC,KAAKpR,EAAUgC,OAAQ,OAAO3B,EAAKiR,YAEvC,OAAOjR,EAAK0B,MAChB,KAAK1B,EAAK2D,gBAAiB,OAAO3D,EAAK2D,gBACvC,KAAK3D,EAAKgB,cAAe,OAAOhB,EAAKgB,cACrC,KAAKhB,EAAKmR,WAAY,OAAOnR,EAAKmR,WAEtC,MAAUtxB,4BAA4BmgB,EAAKnM,EAAKge,YAmDnDpF,EAAQ30B,UAAkB21B,UAAY,KACtChB,EAAQ30B,UAAkB61B,WAAa,KACvClB,EAAQ30B,UAAkB+1B,WAAa,KACvCpB,EAAQ30B,UAAkBi2B,WAAa,KACvCtB,EAAQ30B,UAAkBm2B,WAAa,KACvCxB,EAAQ30B,UAAkBq2B,YAAc,KACxC1B,EAAQ30B,UAAkBu2B,YAAc,KACxC5B,EAAQ30B,UAAkBy2B,YAAc,KACxC9B,EAAQ30B,UAAkB62B,aAAe,KACzClC,EAAQ30B,UAAkB+2B,aAAe,KACzCpC,EAAQ30B,UAAkBi3B,aAAe,KACzCtC,EAAQ30B,UAAkBu3B,aAAe,KACzC5C,EAAQ30B,UAAkBy3B,qBAAuB,KACjD9C,EAAQ30B,UAAkB43B,qBAAuB,KACjDjD,EAAQ30B,UAAkB83B,0BAA4B,KACtDnD,EAAQ30B,UAAkBg4B,0BAA4B,KACtDrD,EAAQ30B,UAAkBk4B,yBAA2B,KACrDvD,EAAQ30B,UAAkBq4B,gBAAkB,KAC5C1D,EAAQ30B,UAAkBu4B,qBAAuB,KACjD5D,EAAQ30B,UAAkBy4B,qBAAuB,KACjD9D,EAAQ30B,UAAkB24B,oBAAsB,KAChDhE,EAAQ30B,UAAkBk5B,gBAAkB,KAC5CvE,EAAQ30B,UAAkBo5B,iBAAmB,KAC7CzE,EAAQ30B,UAAkBy5B,qBAAuB,KACjD9E,EAAQ30B,UAAkB25B,uBAAyB,KCxK7C,MAAMY,UAAuB5F,EAChCpsB,eAAsDgB,EAAmB6F,GACrE,OAAQ7F,IAAW6F,GACfA,aAAiB7F,EAAOixB,aACxBC,EAASC,cAAcnxB,EAAOoxB,OAAQvrB,EAAMurB,QAGpDpyB,cAAqDoyB,EAA6BC,GAC9E,OAAQD,IAAWC,GACf3iB,MAAMC,QAAQyiB,IACd1iB,MAAMC,QAAQ0iB,IACdD,EAAOl2B,SAAWm2B,EAAOn2B,QACzBk2B,EAAOE,MAAM,CAACC,EAAG18B,IAAMq8B,EAASM,aAAaD,EAAGF,EAAOx8B,KAG/DmK,aAAuCyL,EAAiB5E,GACpD,OAAQ4E,IAAU5E,GACdA,aAAiB4E,EAAMwmB,aACvBxmB,EAAMrV,OAASyQ,EAAMzQ,MACrBqV,EAAMob,WAAahgB,EAAMggB,UACzBqL,EAAS1F,MAAM/gB,EAAM+H,KAAM3M,EAAM2M,OAK7C,SAASif,EAAuCjf,EAAS3M,GACrD,OAAOA,aAAiB2M,EAAKye,YAGjC,SAASS,EAA+Blf,EAAS3M,GAC7C,OAAQ2M,IAAS3M,GAAU4rB,EAAmBjf,EAAM3M,GAGxD,SAAS8rB,EAA0Bnf,EAAS3M,GACxC,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAKsO,WAAajb,EAAMib,UACxBtO,EAAKuO,WAAalb,EAAMkb,SAIhC,SAAS6Q,EAA8Bpf,EAAS3M,GAC5C,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK8O,YAAczb,EAAMyb,UAWjC,SAASuQ,EAA6Brf,EAAS3M,GAC3C,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK6Q,OAASxd,EAAMwd,KAI5B,SAASyO,EAAsCtf,EAAS3M,GACpD,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK6Q,OAASxd,EAAMwd,MACpB7Q,EAAKuf,WAAalsB,EAAMksB,SAIhC,SAASC,EAA4Bxf,EAAS3M,GAC1C,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK6Q,OAASxd,EAAMwd,MACpB7Q,EAAKsO,WAAajb,EAAMib,SAoBhC,SAASmR,EAA8Bzf,EAAS3M,GAC5C,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAKxc,OAAS6P,EAAM7P,MACpBwc,EAAK0f,QAAQZ,MAAM,CAACv2B,EAAGlG,IAAMkG,IAAM8K,EAAMqsB,QAAQr9B,KACjDq8B,EAASC,cAAc3e,EAAK2f,SAAUtsB,EAAMssB,UAcpD,SAASC,EAAoC5f,EAAS3M,GAClD,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK6Q,OAASxd,EAAMwd,KAsB5B2N,EAAev6B,UAAUu1B,UAAwC0F,EACjEV,EAAev6B,UAAUw1B,UAAwCyF,EACjEV,EAAev6B,UAAUy1B,SAAwCyF,EACjEX,EAAev6B,UAAU21B,UAAwCuF,EACjEX,EAAev6B,UAAU61B,WAAwCqF,EACjEX,EAAev6B,UAAU+1B,WAAwCmF,EACjEX,EAAev6B,UAAUi2B,WAAwCiF,EACjEX,EAAev6B,UAAUm2B,WAAwC+E,EACjEX,EAAev6B,UAAUq2B,YAAwC6E,EACjEX,EAAev6B,UAAUu2B,YAAwC2E,EACjEX,EAAev6B,UAAUy2B,YAAwCyE,EACjEX,EAAev6B,UAAU22B,WAAsCwE,EAC/DZ,EAAev6B,UAAU62B,aAAsCsE,EAC/DZ,EAAev6B,UAAU+2B,aAAsCoE,EAC/DZ,EAAev6B,UAAUi3B,aAAsCkE,EAC/DZ,EAAev6B,UAAUk3B,UAAwC+D,EACjEV,EAAev6B,UAAUm3B,YAAwC8D,EACjEV,EAAev6B,UAAUo3B,qBA3GzB,SAA2Drb,EAAS3M,GAChE,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK+P,YAAc1c,EAAM0c,WAyGjCyO,EAAev6B,UAAUq3B,UAAuC+D,EAChEb,EAAev6B,UAAUu3B,aAAuC6D,EAChEb,EAAev6B,UAAUy3B,qBAAuC2D,EAChEb,EAAev6B,UAAU03B,eAAkC2D,EAC3Dd,EAAev6B,UAAU43B,qBAAkCyD,EAC3Dd,EAAev6B,UAAU83B,0BAAkCuD,EAC3Dd,EAAev6B,UAAUg4B,0BAAkCqD,EAC3Dd,EAAev6B,UAAUk4B,yBAAkCmD,EAC3Dd,EAAev6B,UAAUm4B,UAAuCoD,EAChEhB,EAAev6B,UAAUq4B,gBAAuCkD,EAChEhB,EAAev6B,UAAUu4B,qBAAuCgD,EAChEhB,EAAev6B,UAAUy4B,qBAAuC8C,EAChEhB,EAAev6B,UAAU24B,oBAAuC4C,EAChEhB,EAAev6B,UAAU44B,aAAwCqC,EACjEV,EAAev6B,UAAU64B,UA5FzB,SAAqC9c,EAAS3M,GAC1C,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK2f,SAASj3B,SAAW2K,EAAMssB,SAASj3B,QACxCg2B,EAASC,cAAc3e,EAAK2f,SAAUtsB,EAAMssB,WAyFpDnB,EAAev6B,UAAU+4B,YArFzB,SAAyChd,EAAS3M,GAC9C,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK2f,SAASj3B,SAAW2K,EAAMssB,SAASj3B,QACxCg2B,EAASC,cAAc3e,EAAK2f,SAAUtsB,EAAMssB,WAkFpDnB,EAAev6B,UAAUg5B,WAAsCwC,EAC/DjB,EAAev6B,UAAUk5B,gBAAsCsC,EAC/DjB,EAAev6B,UAAUo5B,iBAAsCoC,EAC/DjB,EAAev6B,UAAUs5B,gBAxEzB,SAAiDvd,EAAS3M,GACtD,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAK0S,KAAOrf,EAAMqf,IAClB1S,EAAK4S,YAAcvf,EAAMuf,WACzB8L,EAAS1F,MAAYhZ,EAAK6f,QAASxsB,EAAMwsB,UACzCnB,EAAS1F,MAAMhZ,EAAK8f,WAAYzsB,EAAMysB,aAmE9CtB,EAAev6B,UAAUu5B,cAAmCoC,EAC5DpB,EAAev6B,UAAUy5B,qBAAmCkC,EAC5DpB,EAAev6B,UAAU25B,uBAAmCgC,EAC5DpB,EAAev6B,UAAU45B,mBA3DzB,SAAuD7d,EAAS3M,GAC5D,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAKoN,WAAa/Z,EAAM+Z,UACxBpN,EAAK2f,SAASj3B,SAAW2K,EAAMssB,SAASj3B,QACxCg2B,EAASC,cAAc3e,EAAK2f,SAAUtsB,EAAMssB,WAuDpDnB,EAAev6B,UAAU65B,SAnDzB,SAAoC9d,EAAS3M,GACzC,OAAQ2M,IAAS3M,GACb4rB,EAAmBjf,EAAM3M,IACzB2M,EAAKyN,aAAepa,EAAMoa,YAC1BzN,EAAK2f,SAASj3B,SAAW2K,EAAMssB,SAASj3B,QACxCg2B,EAASC,cAAc3e,EAAK2f,SAAUtsB,EAAMssB,WAiD7C,MAAMjB,EAAW,IAAIF,EC3MrB,MAAejF,EAKC/sB,cAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKE,KACxF7f,aAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKkC,IACxF7hB,eAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKwO,MACxFnuB,gBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKkD,OACxF7iB,cAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAK+C,KACxF1iB,cAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKgE,KACxF3jB,iBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKmE,QACxF9jB,cAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKwE,KACxFnkB,cAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAK8E,KACxFzkB,mBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKiF,UACxF5kB,kBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKwF,SACxFnlB,cAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKU,KACxFrgB,gBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAK4Q,OACxFvwB,eAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAK0B,MACxFrhB,yBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAK2D,gBACxFtjB,uBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKgB,cACxF3gB,aAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKqB,IACxFhhB,oBAA0BjE,GAAgC,OAAOA,GAAKA,EAAEy1B,SAAW7R,EAAKmR,WAE3GU,aAA6B,OAAa7R,EAAKgH,KACxC3mB,UAAU6G,GACb,OAAOqrB,EAAS1F,MAAMzrB,KAAM8F,IAGfkmB,EAACn2B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOJ,SAAW,KAClBI,EAAOC,UAAY9jB,MACnB6jB,EAAM38B,OAAOC,aAAe,YAHC,CAIrCk2B,EAASt1B,WAMT,MAAMg8B,UAAa1G,EACf/sB,WAAa,MAAO,OAC3BwxB,aAAsB,OAAO7R,EAAKE,MACjB4T,EAAC78B,OAAOC,aAAe,CAAE08B,GAEvCE,EAAKh8B,UADSb,OAAOC,aAAe,OADC,GAuB5C,MAAM68B,UAAoC3G,EACtC/sB,YAA4B+hB,EACAD,GACxB9f,QAFwBjB,KAAAghB,WACAhhB,KAAA+gB,WAG5B0P,aAAsB,OAAO7R,EAAKkC,IAClC2R,gBACI,OAAQzyB,KAAK+gB,UACT,KAAM,EAAG,OAAO/gB,KAAKghB,SAAY9kB,UAAajC,WAC9C,KAAK,GAAI,OAAO+F,KAAKghB,SAAW7kB,WAAaE,YAC7C,KAAK,GACL,KAAK,GAAI,OAAO2D,KAAKghB,SAAW5kB,WAAaE,YAEjD,MAAUmC,sBAAsBuB,KAAKnK,OAAOC,qBAEzCmJ,WAAa,SAAUe,KAAKghB,SAAW,IAAM,SAAShhB,KAAK+gB,YACjD4R,EAAC98B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOxR,SAAW,KAClBwR,EAAOzR,SAAW,KAClByR,EAAM38B,OAAOC,aAAe,OAHC,CAIrC68B,EAAKj8B,WAML,MAAM01B,UAAauG,EAAkB1zB,cAAgBgC,OAAM,EAAM,IAEjE,MAAMqrB,UAAcqG,EAAmB1zB,cAAgBgC,OAAM,EAAM,KAEnE,MAAMurB,UAAcmG,EAAmB1zB,cAAgBgC,OAAM,EAAM,KAEnE,MAAMyrB,WAAciG,EAAmB1zB,cAAgBgC,OAAM,EAAM,KAEnE,MAAM2rB,WAAc+F,EAAmB1zB,cAAgBgC,OAAM,EAAO,IAEpE,MAAM6rB,WAAe6F,EAAoB1zB,cAAgBgC,OAAM,EAAO,KAEtE,MAAM+rB,WAAe2F,EAAoB1zB,cAAgBgC,OAAM,EAAO,KAEtE,MAAMisB,WAAeyF,EAAoB1zB,cAAgBgC,OAAM,EAAO,KAE7EzL,OAAOC,eAAe22B,EAAK11B,UAAW,YAAa,CAAEX,MAAOmG,YAC5D1G,OAAOC,eAAe62B,EAAM51B,UAAW,YAAa,CAAEX,MAAOoG,aAC7D3G,OAAOC,eAAe+2B,EAAM91B,UAAW,YAAa,CAAEX,MAAOqG,aAC7D5G,OAAOC,eAAei3B,GAAMh2B,UAAW,YAAa,CAAEX,MAAOqG,aAC7D5G,OAAOC,eAAem3B,GAAMl2B,UAAW,YAAa,CAAEX,MAAOkE,aAC7DzE,OAAOC,eAAeq3B,GAAOp2B,UAAW,YAAa,CAAEX,MAAOsG,cAC9D7G,OAAOC,eAAeu3B,GAAOt2B,UAAW,YAAa,CAAEX,MAAOuG,cAC9D9G,OAAOC,eAAey3B,GAAOx2B,UAAW,YAAa,CAAEX,MAAOuG,cAevD,MAAMs2B,WAAyC5G,EAClD/sB,YAA4BsiB,GACxBtgB,QADwBjB,KAAAuhB,YAG5BkP,aAAsB,OAAO7R,EAAKwO,MAClCqF,gBACI,OAAQzyB,KAAKuhB,WACT,KAAK/C,EAAU8C,KAAM,OAAOjlB,YAC5B,KAAKmiB,EAAUkS,OAAQ,OAAOn0B,aAC9B,KAAKiiB,EAAUmS,OAAQ,OAAOn0B,aAElC,MAAUiC,sBAAsBuB,KAAKnK,OAAOC,qBAEzCmJ,WAAa,cAAgBe,KAAKuhB,WAAa,GAAM,MAC3CqR,GAAC/8B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOjR,UAAY,KACnBiR,EAAM38B,OAAOC,aAAe,SAFC,CAGrC88B,GAAMl8B,WAIN,MAAMm8B,WAAgBD,GAAsB3zB,cAAgBgC,MAAMud,EAAU8C,OAE5E,MAAMwR,WAAgBF,GAAsB3zB,cAAgBgC,MAAMud,EAAUkS,SAE5E,MAAMqC,WAAgBH,GAAsB3zB,cAAgBgC,MAAMud,EAAUmS,SAEnFn7B,OAAOC,eAAeo9B,GAAQn8B,UAAW,YAAa,CAAEX,MAAOsG,cAC/D7G,OAAOC,eAAeq9B,GAAQp8B,UAAW,YAAa,CAAEX,MAAOwG,eAC/D/G,OAAOC,eAAes9B,GAAQr8B,UAAW,YAAa,CAAEX,MAAOyG,eAKxD,MAAMw2B,WAAehH,EACxB/sB,cACIgC,QAEJwvB,aAAsB,OAAO7R,EAAKkD,OAC3B7iB,WAAa,MAAO,UACV+zB,GAACn9B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOC,UAAYx4B,WACnBu4B,EAAM38B,OAAOC,aAAe,UAFC,CAGrCk9B,GAAOt8B,WAMP,MAAMu8B,WAAajH,EACtB/sB,cACIgC,QAEJwvB,aAAsB,OAAO7R,EAAK+C,KAC3B1iB,WAAa,MAAO,QACVg0B,GAACp9B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOC,UAAYx4B,WACnBu4B,EAAM38B,OAAOC,aAAe,QAFC,CAGrCm9B,GAAKv8B,WAML,MAAMw8B,WAAalH,EACtB/sB,cACIgC,QAEJwvB,aAAsB,OAAO7R,EAAKgE,KAC3B3jB,WAAa,MAAO,QACVi0B,GAACr9B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOC,UAAYx4B,WACnBu4B,EAAM38B,OAAOC,aAAe,QAFC,CAGrCo9B,GAAKx8B,WAML,MAAMy8B,WAAgBnH,EACzB/sB,YAA4B+jB,EACAzB,GACxBtgB,QAFwBjB,KAAAgjB,QACAhjB,KAAAuhB,YAG5BkP,aAAsB,OAAO7R,EAAKmE,QAC3B9jB,WAAa,iBAAkBe,KAAKuhB,aAAavhB,KAAKgjB,MAAQ,EAAI,IAAM,KAAKhjB,KAAKgjB,UACxEmQ,GAACt9B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOxP,MAAQ,KACfwP,EAAOjR,UAAY,KACnBiR,EAAOC,UAAYn2B,YACnBk2B,EAAM38B,OAAOC,aAAe,WAJC,CAKrCq9B,GAAQz8B,WAQR,MAAM08B,WAAuCpH,EAChD/sB,YAA4BqkB,GACxBriB,QADwBjB,KAAAsjB,OAG5BmN,aAAsB,OAAO7R,EAAKwE,KAC3BnkB,WAAa,aAAgC,IAAjBe,KAAKsjB,KAAO,MAAW7E,EAASze,KAAKsjB,UACvD8P,GAACv9B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOlP,KAAO,KACdkP,EAAOC,UAAYr2B,WACnBo2B,EAAM38B,OAAOC,aAAe,QAHC,CAIrCs9B,GAAM18B,WAIN,MAAM28B,WAAgBD,GAAsBn0B,cAAgBgC,MAAMwd,EAASqS,MAE3E,MAAMwC,WAAwBF,GAA8Bn0B,cAAgBgC,MAAMwd,EAAS4E,cAgBlG,MAAMkQ,WAAuCvH,EACzC/sB,YAA4BqkB,EACAvC,GACxB9f,QAFwBjB,KAAAsjB,OACAtjB,KAAA+gB,WAG5B0P,aAAsB,OAAO7R,EAAK8E,KAC3BzkB,WAAa,aAAce,KAAK+gB,YAAYrC,EAAS1e,KAAKsjB,UAChDiQ,GAAC19B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOlP,KAAO,KACdkP,EAAOzR,SAAW,KAClByR,EAAOC,UAAYr2B,WACnBo2B,EAAM38B,OAAOC,aAAe,QAJC,CAKrCy9B,GAAM78B,WAMN,MAAM88B,WAAmBD,GAAyBt0B,cAAgBgC,MAAMyd,EAASoF,OAAQ,KAEzF,MAAM2P,WAAwBF,GAA8Bt0B,cAAgBgC,MAAMyd,EAAS2E,YAAa,KAExG,MAAMqQ,WAAwBH,GAA8Bt0B,cAAgBgC,MAAMyd,EAASkS,YAAa,KAExG,MAAM+C,WAAuBJ,GAA6Bt0B,cAAgBgC,MAAMyd,EAASmS,WAAY,KAO5G,MAAM+C,WAAsD5H,EACxD/sB,YAA4BqkB,EACA0O,GACxB/wB,QAFwBjB,KAAAsjB,OACAtjB,KAAAgyB,WAG5BvB,aAAsB,OAAO7R,EAAKiF,UAC3B5kB,WAAa,mBAAoByf,EAAS1e,KAAKsjB,QAAQtjB,KAAKgyB,cAAgBhyB,KAAKgyB,WAAa,OACpF4B,GAAC/9B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOlP,KAAO,KACdkP,EAAOR,SAAW,KAClBQ,EAAOC,UAAYr2B,WACnBo2B,EAAM38B,OAAOC,aAAe,aAJC,CAKrC89B,GAAWl9B,WAMX,MAAMm9B,WAAwBD,GAAmC30B,YAAY+yB,GAA4B/wB,MAAMyd,EAASoF,OAAQkO,IAEhI,MAAM8B,WAA6BF,GAAwC30B,YAAY+yB,GAA4B/wB,MAAMyd,EAAS2E,YAAa2O,IAE/I,MAAM+B,WAA6BH,GAAwC30B,YAAY+yB,GAA4B/wB,MAAMyd,EAASkS,YAAaoB,IAE/I,MAAMgC,WAA4BJ,GAAuC30B,YAAY+yB,GAA4B/wB,MAAMyd,EAASmS,WAAYmB,IAOnJ,MAAMiC,WAAmDjI,EACrD/sB,YAA4BqkB,GACxBriB,QADwBjB,KAAAsjB,OAG5BmN,aAAsB,OAAO7R,EAAKwF,SAC3BnlB,WAAa,kBAAmB0f,EAAa3e,KAAKsjB,UACxC2Q,GAACp+B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOlP,KAAO,KACdkP,EAAOC,UAAYr2B,WACnBo2B,EAAM38B,OAAOC,aAAe,YAHC,CAIrCm+B,GAAUv9B,WAMV,MAAMw9B,WAAwBD,GAAkCh1B,cAAgBgC,MAAM0d,EAAaoS,WAEnG,MAAMoD,WAA0BF,GAAoCh1B,cAAgBgC,MAAM0d,EAAa0F,aAKvG,MAAM+P,WAAuCpI,EAChD/sB,YAAYo1B,GACRpzB,QACAjB,KAAKoyB,SAAW,CAACiC,GAGrB5D,aAAsB,OAAO7R,EAAKU,KAC3BrgB,WAAa,cAAee,KAAKs0B,aACxCA,gBAA4B,OAAOt0B,KAAKoyB,SAAS,GAAG3f,KACpD8hB,iBAAoC,OAAOv0B,KAAKoyB,SAAS,GACzDK,gBAAyC,OAAOzyB,KAAKs0B,UAAU7B,WAC9C2B,GAACv+B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOJ,SAAW,KAClBI,EAAM38B,OAAOC,aAAe,QAFC,CAGrCs+B,GAAK19B,WAML,MAAM89B,WAA4DxI,EAErE/sB,YAAYmzB,GACRnxB,QACAjB,KAAKoyB,SAAWA,EAEpB3B,aAAsB,OAAO7R,EAAK4Q,OAC3BvwB,WAAa,iBAAkBe,KAAKoyB,SAAS1uB,IAAK8tB,MAASA,EAAEn8B,QAAQm8B,EAAE/e,QAAQgF,KAAK,WAC1E+c,GAAC3+B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOJ,SAAW,KAClBI,EAAM38B,OAAOC,aAAe,UAFC,CAGrC0+B,GAAO99B,WAQd,MAAM+9B,WAA0CzI,EAK5C/sB,YAAYhJ,EACAk8B,EACAC,GACRnxB,QACAjB,KAAK/J,KAAOA,EACZ+J,KAAKoyB,SAAWA,EAChBpyB,KAAKmyB,QAAUA,EAAU/1B,WAAWH,KAAKk2B,GACzCnyB,KAAK00B,mBAAqBvC,EAAQ92B,OAAO,CAACq5B,EAAoBjE,EAAQkE,KAC1DD,EAAmBjE,GAAUkE,IAAQD,GAAsBA,EACpEl/B,OAAOY,OAAO,OAErBq6B,aAAsB,OAAO7R,EAAK0B,MAC3BrhB,WAAa,SAAUe,KAAKnK,OAAOC,gBACtCkK,KAAKoyB,SAAS1uB,IAAK1I,MAASA,EAAEyX,QAAQgF,KAAK,WAE9Bgd,GAAC5+B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOv8B,KAAO,KACdu8B,EAAOL,QAAU,KACjBK,EAAOJ,SAAW,KAClBI,EAAOkC,mBAAqB,KAC5BlC,EAAOC,UAAYv2B,UACnBs2B,EAAM38B,OAAOC,aAAe,SANC,CAOrC2+B,GAAO/9B,WAMP,MAAMk+B,WAAmBH,GAC5Bx1B,YAAYkzB,EAAgCC,GACxCnxB,MAAMsd,EAAUyS,MAAOmB,EAASC,IAKjC,MAAMyC,WAAoBJ,GAC7Bx1B,YAAYkzB,EAAgCC,GACxCnxB,MAAMsd,EAAUgC,OAAQ4R,EAASC,IAOlC,MAAM0C,WAAwB9I,EACjC/sB,YAA4BujB,GACxBvhB,QADwBjB,KAAAwiB,YAG5BiO,aAAsB,OAAO7R,EAAK2D,gBAC3BtjB,WAAa,yBAA0Be,KAAKwiB,cAClCsS,GAACj/B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOhQ,UAAY,KACnBgQ,EAAOC,UAAYx4B,WACnBu4B,EAAM38B,OAAOC,aAAe,mBAHC,CAIrCg/B,GAAgBp+B,WAMhB,MAAMq+B,WAAgD/I,EAEzD/sB,YAA4B4gB,EAAkBwU,GAC1CpzB,QADwBjB,KAAA6f,WAExB7f,KAAKoyB,SAAW,CAACiC,GAErB5D,aAAsB,OAAO7R,EAAKgB,cAClC0U,gBAA4B,OAAOt0B,KAAKoyB,SAAS,GAAG3f,KACpD8hB,iBAAoC,OAAOv0B,KAAKoyB,SAAS,GACzDK,gBAAyC,OAAOzyB,KAAKs0B,UAAU7B,UACxDxzB,WAAa,uBAAwBe,KAAK6f,aAAa7f,KAAKs0B,cAClDS,GAACl/B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOJ,SAAW,KAClBI,EAAO3S,SAAW,KAClB2S,EAAM38B,OAAOC,aAAe,iBAHC,CAIrCi/B,GAAcr+B,WAWd,MAAMs+B,WAAyEhJ,EAClF/sB,YAAYo1B,EAAoDnU,GAAa,GACzEjf,QACAjB,KAAKoyB,SAAW,CAACiC,GACjBr0B,KAAKkgB,WAAaA,EAItBuQ,aAAsB,OAAO7R,EAAKqB,IAClCgV,cAA6B,OAAOj1B,KAAKoyB,SAAS,GAAG3f,KAAK2f,SAAS,GAAG3f,KACtE6hB,gBAAiC,OAAOt0B,KAAKoyB,SAAS,GAAG3f,KAAK2f,SAAS,GAAG3f,KACnExT,WAAa,cAAee,KAAKoyB,SAAS,GAAG3f,KAAK2f,SAAS1uB,IAAK8tB,MAASA,EAAEn8B,QAAQm8B,EAAE/e,QAAQgF,KAAK,WACxFud,GAACn/B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOJ,SAAW,KAClBI,EAAOtS,WAAa,KACpBsS,EAAM38B,OAAOC,aAAe,QAHC,CAIrCk/B,GAAKt+B,WAIZ,MAAMw+B,GAAQ,CAAEC,GAAuB,MAAQA,EAAjC,EAAsD,GAQ7D,MAAMC,WAAyEpJ,EAKlF/sB,YAAYszB,EAAeD,EAAenN,EAA2BE,GACjEpkB,QACAjB,KAAKsyB,QAAUA,EACftyB,KAAKuyB,WAAaA,EAClBvyB,KAAKqlB,UAAYA,IAAa,EAC9BrlB,KAAKmlB,GAAW,MAANA,EAAa+P,KAAwB,iBAAP/P,EAAkBA,EAAKA,EAAG1f,IAEtEgrB,aAAsB,OAAO7R,EAAKmR,WAClCqC,eAAwB,OAAOpyB,KAAKuyB,WAAWH,SAC/CkC,gBAA4B,OAAOt0B,KAAKuyB,WACxCE,gBAAyC,OAAOzyB,KAAKuyB,WAAWE,UACzDxzB,WAAa,oBAAqBe,KAAKsyB,YAAYtyB,KAAKuyB,eAkB5D,SAAS8C,GAAc5iB,GAC1B,IAAIzc,EAASyc,EACb,OAAQA,EAAKge,QACT,KAAK7R,EAAKmE,QAAS,OAAO,EAC1B,KAAKnE,EAAKiF,UAAW,OAAO,EAC5B,KAAKjF,EAAKwE,KACV,KAAKxE,EAAKwF,SAAU,OAAO,EAAKpuB,EAAgBstB,KAChD,KAAK1E,EAAKkC,IACV,KAAKlC,EAAK8E,KAAM,QAAc1tB,EAAY+qB,SAAW,IAA9B,EACvB,KAAKnC,EAAKgB,cAAe,OAAQ5pB,EAAoB6pB,SACrD,KAAKjB,EAAK2D,gBAAiB,OAAQvsB,EAAsBwsB,UACzD,QAAS,OAAO,GA5BH4S,GAACv/B,OAAOC,aAAe,CAAE08B,IAC/BA,EAAOrN,GAAK,KACZqN,EAAOF,QAAU,KACjBE,EAAOnN,UAAY,KACnBmN,EAAOD,WAAa,KACpBC,EAAM38B,OAAOC,aAAe,cALC,CAMrCs/B,GAAW1+B,uBC1iBI,MAAM4+B,IAAqB,EAuB1C,MAAMxJ,GA+CT7sB,YAAYwT,EAASlX,EAAgBJ,EAAgBo6B,EAAoBx4B,EAAyCy4B,EAA+BjD,GAO7I,IAAIr4B,EANJ8F,KAAKyS,KAAOA,EACZzS,KAAKuyB,WAAaA,EAClBvyB,KAAKzE,OAASlB,KAAKggB,MAAMhgB,KAAK6T,IAAI3S,GAAU,EAAG,IAC/CyE,KAAK7E,OAASd,KAAKggB,MAAMhgB,KAAK6T,IAAI/S,GAAU,EAAG,IAC/C6E,KAAKy1B,WAAap7B,KAAKggB,MAAMhgB,KAAK6T,IAAIqnB,GAAa,GAAI,IACvDv1B,KAAKw1B,WAAaA,GAAa,IAAI9xB,IAAK1I,GAAMA,aAAa8wB,GAAO9wB,EAAIA,EAAE0X,MAEpE3V,aAAmB+uB,IACnB9rB,KAAK01B,OAAS34B,EAAQ24B,OACtB11B,KAAKiqB,OAASltB,EAAQktB,OACtBjqB,KAAKmyB,QAAUp1B,EAAQo1B,QACvBnyB,KAAK21B,WAAa54B,EAAQ44B,WAC1B31B,KAAK3C,aAAeN,EAAQM,eAE5B2C,KAAK01B,OAASL,GAAc5iB,GACxB1V,KACC7C,EAAU6C,EAAuB,MAAQiD,KAAK3C,aAAenD,IAC7DA,EAAU6C,EAAuB,MAAQiD,KAAKiqB,OAAS/vB,IACvDA,EAAU6C,EAAuB,MAAQiD,KAAK21B,WAAaz7B,IAC3DA,EAAU6C,EAAuB,MAAQiD,KAAKmyB,QAAUj4B,KA9CrEu2B,aAAkC,OAAOzwB,KAAKyS,KAAKge,OACnDgC,gBAAyC,OAAOzyB,KAAKyS,KAAKggB,UAC1D11B,cACI,MAAO,CAACiD,KAAK3C,aAAc2C,KAAKiqB,OAAQjqB,KAAK21B,WAAY31B,KAAKmyB,SAElEr4B,iBACI,IAAIA,EAAa,GACbuD,aAAEA,EAAY4sB,OAAEA,EAAM0L,WAAEA,EAAUxD,QAAEA,GAAYnyB,KAKpD,OAJA3C,IAAiBvD,GAAcuD,EAAavD,YAC5CmwB,IAAiBnwB,GAAcmwB,EAAOnwB,YACtC67B,IAAiB77B,GAAc67B,EAAW77B,YAC1Cq4B,IAAiBr4B,GAAcq4B,EAAQr4B,YAChCkG,KAAKw1B,UAAUn6B,OAAO,CAACvB,EAAYu6B,IAAUv6B,EAAau6B,EAAMv6B,WAAYA,GAKvFy7B,gBACI,IACII,EADAJ,EAAYv1B,KAAKy1B,WAKrB,OAHIF,GAAaD,KAAsBK,EAAa31B,KAAK21B,cACrD31B,KAAKy1B,WAAaF,EAAYv1B,KAAK7E,OAASmvB,EAAiBqL,EAAY31B,KAAKzE,OAAQyE,KAAKzE,OAASyE,KAAK7E,SAEtGo6B,EA4BJt2B,MAA0BwT,EAASlX,EAASyE,KAAKzE,OAAQJ,EAAS6E,KAAK7E,OAAQo6B,EAAYv1B,KAAKy1B,WAAY14B,EAA4BiD,KAAMw1B,EAA+Bx1B,KAAKw1B,WACrL,OAAO,IAAI1J,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAWx4B,EAASy4B,EAAWx1B,KAAKuyB,YAGvEtzB,MAAM1D,EAAgBJ,GACzB,MAAMu6B,OAAEA,EAAMjF,OAAEA,EAAM+E,UAAEA,GAAcx1B,KAIhCu1B,IAAkC,IAApBv1B,KAAKy1B,YAAoB,EACvCG,EAAyB,KAAXnF,EAAoCiF,EAAS,EAC3D34B,EAAUiD,KAAK61B,cAAct6B,EAAQJ,EAAQu6B,EAAQjF,GAC3D,OAAOzwB,KAAK81B,MAAS91B,KAAKyS,KAAMzS,KAAKzE,OAASA,EAAQJ,EAAQo6B,EAAWx4B,GAEnEy4B,EAAUr6B,QAAU6E,KAAK3C,aAAgBm4B,EAAYx1B,KAAK+1B,eAAeP,EAAWI,EAAcr6B,EAAQq6B,EAAcz6B,IAG3H8D,mCAAmC+2B,GACtC,GAAIh2B,KAAKywB,SAAW7R,EAAKE,KACrB,OAAO9e,KAAK81B,MAAM91B,KAAKyS,KAAM,EAAGujB,EAAW,GAE/C,MAAM76B,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAExB6pB,EAAS,IAAI5vB,YAAa+7B,EAAY,IAAM,KAAQ,GAAGxf,KAAK,IAAK,EAAGrb,GAAU,GAEpF0uB,EAAO1uB,GAAU,IAAM,GAAMA,IAAmB,EAATA,IAAiB,EAEpDo6B,EAAY,GACZ1L,EAAOtvB,IAAIqvB,EAAe5pB,KAAKzE,OAAQJ,EAAQ6E,KAAK21B,YAAa,GAErE,MAAM54B,EAAUiD,KAAKjD,QAErB,OADAA,EAAQosB,EAAW8M,UAAYpM,EACxB7pB,KAAK81B,MAAM91B,KAAKyS,KAAM,EAAGujB,EAAWT,GAAaS,EAAY76B,GAAS4B,GAGvEkC,cAAc1D,EAAgBJ,EAAgBu6B,EAAgBjF,GACpE,IAAIpd,GAAUtW,QAAEA,GAAYiD,KAO5B,OALCqT,EAAMtW,EAAQosB,EAAW+M,SAAWn5B,EAAQosB,EAAW+M,MAAQ7iB,EAAI3X,SAASH,EAAQA,EAASJ,KAE7FkY,EAAMtW,EAAQosB,EAAWgN,WAAap5B,EAAQosB,EAAWgN,QAAU9iB,EAAI3X,SAASH,EAAQA,EAASJ,EAAS,MAE1GkY,EAAMtW,EAAQosB,EAAWiN,SAAWr5B,EAAQosB,EAAWiN,MAAmB,IAAX3F,EAAepd,EAAMA,EAAI3X,SAASg6B,EAASn6B,EAAQm6B,GAAUn6B,EAASJ,KAC/H4B,EAGDkC,eAAeu2B,EAAmBj6B,EAAgBJ,GACxD,OAAOq6B,EAAU9xB,IAAK2wB,GAAUA,EAAM14B,MAAMJ,EAAQJ,IAOjD8D,WAA+BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAoBx4B,EAAyCy4B,EAA+BjD,GAEvK,OADIx1B,aAAmB+uB,GAAQ/uB,EAAUA,EAAQA,QAAqBA,IAAWA,EAAU,IACnF0V,EAAKge,QACT,KAAK7R,EAAKE,KAAiB,OAAiBgN,GAAKhN,KAA2BrM,EAAyBlX,EAAQJ,GAC7G,KAAKyjB,EAAKkC,IAAiB,OAAiBgL,GAAKhL,IAA2BrO,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAKmR,WAAiB,OAAiBjE,GAAKiE,WAA2Btd,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,GAAI7D,GACnM,KAAK3T,EAAKwO,MAAiB,OAAiBtB,GAAKsB,MAA2B3a,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAKgE,KAAiB,OAAiBkJ,GAAKlJ,KAA2BnQ,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAKmE,QAAiB,OAAiB+I,GAAK/I,QAA2BtQ,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAKwE,KAAiB,OAAiB0I,GAAK1I,KAA2B3Q,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAK8E,KAAiB,OAAiBoI,GAAKpI,KAA2BjR,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAKiF,UAAiB,OAAiBiI,GAAKjI,UAA2BpR,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAKwF,SAAiB,OAAiB0H,GAAK1H,SAA2B3R,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAK2D,gBAAiB,OAAiBuJ,GAAKvJ,gBAA2B9P,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWiN,OAAS,IAC/L,KAAKxX,EAAKkD,OAAiB,OAAiBgK,GAAKhK,OAA2BrP,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWgN,SAAW,GAAIp5B,EAAQosB,EAAWiN,OAAS,IACjO,KAAKxX,EAAK+C,KAAiB,OAAiBmK,GAAKnK,KAA2BlP,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWgN,SAAW,GAAIp5B,EAAQosB,EAAWiN,OAAS,IACjO,KAAKxX,EAAKU,KAAiB,OAAiBwM,GAAKxM,KAA2B7M,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWgN,SAAW,IAAKX,GAAa,IAAI,IACvN,KAAK5W,EAAKgB,cAAiB,OAAiBkM,GAAKlM,cAA2BnN,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,WAAYT,GAAa,IAAI,IACrL,KAAK5W,EAAK4Q,OAAiB,OAAiB1D,GAAK0D,OAA2B/c,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWT,GAAa,IAChL,KAAK5W,EAAKqB,IAAiB,OAAiB6L,GAAK7L,IAA2BxN,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAWgN,SAAW,IAAKX,GAAa,IAAI,IACvN,KAAK5W,EAAK0B,MAAiB,OAAiBwL,GAAKxL,MAA2B7N,EAAyBlX,EAAQJ,EAAQo6B,GAAa,EAAGx4B,EAAQosB,EAAW8M,UAAWl5B,EAAQosB,EAAW+M,OAAS,GAAIn5B,EAAQosB,EAAWgN,SAAWX,EAAWA,GAEhP,MAAU/2B,6BAA6BgU,EAAKge,UAIzCxxB,YAA4BwT,EAASlX,EAAgBJ,GACxD,OAAO,IAAI2wB,GAAKrZ,EAAMlX,EAAQJ,EAAQ,GAGnC8D,WAA0BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GACjH,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,kBAAwCwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,EAAqB6f,GACpJ,OAAO,IAAIzG,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAA+Bid,EAAK6f,QAAQG,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,IAAc,GAAIpD,GAGvJtzB,aAA8BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GACrH,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,YAA4BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GACnH,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,eAAkCwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GACzH,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,YAA6BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GACpH,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,YAA4BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GACnH,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,iBAAsCwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GAC7H,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,gBAAoCwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GAC3H,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,uBAAkDwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBjjB,GACzI,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,EAAWzM,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW/f,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAGhH12B,cAAgCwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBt4B,EAAkCqV,GACzJ,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,CAAC//B,OAAA6gC,GAAA,aAAA7gC,CAAa6H,GAAe7H,OAAA6gC,GAAA,aAAA7gC,CAAakd,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAG5G12B,YAA4BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBt4B,EAAkCqV,GACrJ,OAAO,IAAIoZ,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,CAAC//B,OAAA6gC,GAAA,aAAA7gC,CAAa6H,GAAe7H,OAAA6gC,GAAA,aAAA7gC,CAAakd,GAAOld,OAAA6gC,GAAA,aAAA7gC,CAAamgC,KAG5G12B,YAA4BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBt4B,EAAkCg3B,GACrJ,OAAO,IAAIvI,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,CAAC//B,OAAA6gC,GAAA,aAAA7gC,CAAa6H,QAAe4E,EAAWzM,OAAA6gC,GAAA,aAAA7gC,CAAamgC,IAAc,CAACtB,IAGlHp1B,qBAA8CwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBtB,GACrI,OAAO,IAAIvI,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,OAAWA,EAAWzM,OAAA6gC,GAAA,aAAA7gC,CAAamgC,IAAc,CAACtB,IAGjGp1B,cAAgCwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBvD,GACvH,OAAO,IAAItG,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,MAACtzB,OAAWA,EAAWzM,OAAA6gC,GAAA,aAAA7gC,CAAamgC,IAAcvD,GAGhGnzB,WAA2BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBt4B,EAAkCg3B,GACpJ,OAAO,IAAIvI,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAW,CAAC//B,OAAA6gC,GAAA,aAAA7gC,CAAa6H,QAAe4E,EAAWzM,OAAA6gC,GAAA,aAAA7gC,CAAamgC,IAAc,CAACtB,IAMlHp1B,aAA8BwT,EAASlX,EAAgBJ,EAAgBo6B,EAAmBI,EAAwBxD,EAAwBmE,EAAgElE,GAC7M,MAAMr1B,EAAoB,MACtBkF,OAAWA,EACXzM,OAAA6gC,GAAA,aAAA7gC,CAAamgC,GACbngC,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAWN,IAEtC,OAAI1f,EAAKxc,OAASsoB,EAAUgC,OACjB,IAAIuL,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAWx4B,EAASu5B,IAE9Dv5B,EAAQosB,EAAWgN,QAAU3gC,OAAA6gC,GAAA,aAAA7gC,CAAkC8gC,GACxD,IAAIxK,GAAKrZ,EAAMlX,EAAQJ,EAAQo6B,EAAWx4B,EAASq1B,KAIjEtG,GAAKp1B,UAAkB8+B,UAAYhgC,OAAOsK,OAAO,ICvRnC,MAAMy2B,QAAO,EAGrB,SAASC,GAAcx7B,GAC1B,GAAU,OAANA,EAAc,MAAO,OACzB,GAAIA,IAAMu7B,GAAQ,MAAO,YACzB,cAAev7B,GACX,IAAK,SACL,IAAK,SAAU,SAAUA,IACzB,IAAK,SAAU,UAAWA,KAM9B,MAAqC,mBAA1BA,EAAEnF,OAAO4gC,aACTz7B,EAAEnF,OAAO4gC,aAAa,UAE1Bh9B,YAAYsC,OAAOf,OAASA,KAAO07B,KAAKC,UAAU37B,eCMtD,SAAS47B,GAA6DC,GAEzE,IAAKA,GAAcA,EAAW17B,QAAU,EAEpC,OAAO,SAAiBpF,GAAc,OAAO,GAGjD,IAAI+gC,EAAS,GACTC,EAASF,EAAWG,OAAQh8B,GAAMA,GAAMA,GAgB5C,OAdI+7B,EAAO57B,OAAS,IAChB27B,uBACUC,EAAOrzB,IAAK1I,qBAgB9B,SAAqBA,GACjB,GAAiB,iBAANA,EACP,OAAOw7B,GAAcx7B,GAClB,GAAIi8B,GAAA,EACP,SAAUT,GAAcx7B,MAE5B,UAAWw7B,GAAcx7B,MArBdk8B,CAAYl8B,OAAOyc,KAAK,yCAO/Bof,EAAW17B,SAAW47B,EAAO57B,SAC7B27B,iCAAwCA,KAGjC9a,SAAS,OAAQ8a,mBCjChC,MAAMK,GAAgC,CAACttB,EAAautB,KAAoBvtB,EAAMutB,EAAO,IAAM,IAAQ,IAAMA,EAEnGC,GAAqB,CAAqChkB,EAAQxJ,EAAM,IAC1EwJ,EAAIlY,QAAU0O,EAAMwJ,EAAI3X,SAAS,EAAGmO,GAAOrU,OAAA6gC,GAAA,OAAA7gC,CAAO,IAAK6d,EAAI6d,YAAoBrnB,GAAMwJ,EAAK,GASvF,MAAMikB,GAETr4B,YAAY/E,EAAWw7B,EAAS,GAC5B11B,KAAK9F,OAASA,EACd8F,KAAK01B,OAASA,EACd11B,KAAKhE,kBAAoB9B,EAAO8B,kBAChCgE,KAAKyyB,UAAYv4B,EAAOg3B,YACxBlxB,KAAKu3B,QAAQv3B,KAAK7E,OAASjB,EAAOiB,OAASu6B,EAAS,GASxD57B,iBAA0B,OAAOkG,KAAK7E,OAAS6E,KAAK01B,OAAS11B,KAAKhE,kBAAoB,EACtFw7B,qBAA8B,OAAOx3B,KAAK9F,OAAOiB,OAAS6E,KAAK01B,OAC/D+B,yBAAkC,OAAOz3B,KAAK9F,OAAOJ,WAG9CmF,IAAIzD,EAAezF,GAAiB,OAAOiK,KAC3Cf,OAAOlJ,GAAiB,OAAOiK,KAAKzF,IAAIyF,KAAK7E,OAAQpF,GACrDkJ,QAAQy4B,GACX,GAAIA,EAAQ,EAAG,CACX13B,KAAK7E,QAAUu8B,EACf,MAAMhC,EAAS11B,KAAK01B,OACdv6B,EAAS6E,KAAK7E,OAASu6B,EACvBiC,EAAW33B,KAAK9F,OAAOiB,OACzBA,GAAUw8B,GACV33B,KAAKu3B,QACCJ,GADoB,IAAbQ,EACgC,EAATx8B,EACS,EAATA,EADY6E,KAAKhE,oBAK7D,OAAOgE,KAEJf,MAAM9D,EAAS6E,KAAK7E,QACvBA,EAASg8B,GAA8Bh8B,EAAS6E,KAAK01B,OAAQ11B,KAAKhE,mBAClE,MAAM8V,EAAQulB,GAAsBr3B,KAAK9F,OAAQiB,GAEjD,OADA6E,KAAK6G,QACEiL,EAEJ7S,QAGH,OAFAe,KAAK7E,OAAS,EACd6E,KAAKu3B,QAAQ,GACNv3B,KAEDf,QAAQ+2B,GACd,OAAOh2B,KAAK9F,OAAa1E,OAAA6gC,GAAA,OAAA7gC,CAAO,IAAIwK,KAAKyyB,UAAUuD,GAAYh2B,KAAK9F,SAI3Eo9B,GAAc5gC,UAAkB6E,OAAS,EAGnC,MAAMq8B,WAAgDN,GAClDr4B,OAAS,OAAOe,KAAKrK,IAAIqK,KAAK7E,OAAS,GACvC8D,IAAIzD,GAAiB,OAAOwE,KAAK9F,OAAOsB,GACxCyD,IAAIzD,EAAezF,GAGtB,OAFAiK,KAAK63B,QAAQr8B,EAAQwE,KAAK7E,OAAS,GACnC6E,KAAK9F,OAAOsB,EAAQwE,KAAK01B,QAAU3/B,EAC5BiK,MAKR,MAAM83B,WAA4BF,GAErC34B,YAAYyT,EAAO,IAAIzY,WAAW,IAAMgH,MAAMyR,EAAM,EAAI,GAEjD1S,KAAA+3B,SAAW,EAClBC,iBAA0B,OAAOh4B,KAAK7E,OAAS6E,KAAK+3B,SAC7C94B,IAAI01B,GAAe,OAAO30B,KAAK9F,OAAOy6B,GAAO,IAAMA,EAAM,EAAI,EAC7D11B,IAAI01B,EAAaniB,GACpB,MAAMtY,OAAEA,GAAW8F,KAAK63B,QAAQlD,EAAM30B,KAAK7E,OAAS,GAC9CquB,EAAOmL,GAAO,EAAGlL,EAAMkL,EAAM,EAAGsD,EAAM/9B,EAAOsvB,IAASC,EAAM,EAKlE,OAFAjX,EAAc,IAARylB,IAAe/9B,EAAOsvB,IAAW,GAAKC,IAASzpB,KAAK+3B,UAC5C,IAARE,IAAe/9B,EAAOsvB,MAAW,GAAKC,KAASzpB,KAAK+3B,UACnD/3B,KAEJf,QAEH,OADAe,KAAK+3B,SAAW,EACT92B,MAAM4F,SAKd,MAAMqxB,WAA6BN,GACtC34B,YAAYyT,EAAO,IAAItW,WAAW,IAAM6E,MAAMyR,EAAM,GAC7CzT,OAAOlJ,GACV,OAAOiK,KAAKzF,IAAIyF,KAAK7E,OAAS,EAAGpF,GAE9BkJ,IAAIzD,EAAezF,GACtB,MAAMwF,EAASyE,KAAK7E,OAAS,EACvBjB,EAAS8F,KAAK63B,QAAQr8B,EAAQD,EAAS,GAAGrB,OAKhD,OAJIqB,EAASC,KACTtB,EAAOsc,KAAKtc,EAAOqB,GAASA,EAAQC,GAExCtB,EAAOsB,GAAStB,EAAOsB,EAAQ,GAAKzF,EAC7BiK,KAEJf,MAAM9D,EAAS6E,KAAK7E,OAAS,GAIhC,OAHIA,EAAS6E,KAAK7E,QACd6E,KAAKzF,IAAIY,EAAS,EAAG,GAElB8F,MAAMk3B,MAAMh9B,EAAS,IAK7B,MAAMi9B,WAAuEd,GAKhFe,kBACI,OAAOr4B,KAAKs4B,eAAiBt4B,KAAKs4B,aAA4Ct4B,KAAK9F,kBAAkBkC,WAAa66B,GAAA,EAAgBA,GAAA,GAE/Hh4B,IAAIzD,EAAezF,GAEtB,OADAiK,KAAK63B,QAAQr8B,EAAQwE,KAAK7E,OAAS,UACpBpF,GACX,IAAK,SAAUiK,KAAKu4B,SAAS/8B,GAASzF,EAAO,MAC7C,IAAK,SAAUiK,KAAK9F,OAAOsB,EAAQwE,KAAK01B,QAAU3/B,EAAO,MACzD,QAASiK,KAAK9F,OAAOK,IAAIxE,EAAqByF,EAAQwE,KAAK01B,QAE/D,OAAO11B,KAEDf,QAAQ+2B,GACd,MAAMtjB,EAAOzR,MAAMs2B,QAAQvB,GACrB76B,EAASuX,EAAK5Y,YAAckG,KAAKhE,kBAAoBgE,KAAK01B,QAIhE,OAHIuB,GAAA,IACAj3B,KAAKu4B,SAAW,IAAIv4B,KAAKq4B,YAAY3lB,EAAKxY,OAAQwY,EAAKvY,WAAYgB,IAEhEuX,GCxER,MAAe8lB,GAuFlBv5B,aAAcwT,KAAQA,EAAMokB,WAAc4B,IAoBnCz4B,KAAA7E,OAAS,EAKT6E,KAAA+O,UAAW,EAxBd/O,KAAKyS,KAAOA,EACZzS,KAAKoyB,SAAW,GAChBpyB,KAAK62B,WAAa4B,EAClBz4B,KAAK01B,OAASL,GAAc5iB,GAC5BzS,KAAK04B,OAAS,IAAIZ,GACdW,GAASA,EAAMt9B,OAAS,IACxB6E,KAAK24B,SAAW/B,GAAsB6B,IAlFvCx5B,WAAkDsB,IAIlDtB,mBAA0DsB,GAC7D,MAAU9B,MAAM,mDAIbQ,kBAAyDsB,GAC5D,MAAU9B,MAAM,kDA2BbQ,uBAA8DsB,GACjE,OAgVR,SAAgEA,GAC5D,MAAQq4B,iBAAsBA,EAAmB,SAAYr4B,GACrDs4B,cAAmBA,GAAqC,UAArBD,EAA+B,IAAO,QAAYr4B,EACvFu4B,EAA6D,UAArBF,EAA+B,SAAW,aACxF,OAAO,UAAUj/B,GACb,IAAIo/B,EAAY,EACZ/Z,EAAUwZ,GAAQQ,IAAIz4B,GAC1B,IAAK,MAAMxK,KAAS4D,EACZqlB,EAAQia,OAAOljC,GAAO+iC,IAAiBD,KACrCE,UAAoB/Z,EAAQka,aAGlCla,EAAQ7U,SAAShP,OAAS,GAAmB,IAAd49B,WACzB/Z,EAAQka,aA7VXC,CAAgB54B,GA4BpBtB,4BAAmEsB,GACtE,OAyUR,SAAqEA,GACjE,MAAQq4B,iBAAsBA,EAAmB,SAAYr4B,GACrDs4B,cAAmBA,GAAqC,UAArBD,EAA+B,IAAO,QAAYr4B,EACvFu4B,EAA6D,UAArBF,EAA+B,SAAW,aACxF,OAAO17B,gBAAiBvD,GACpB,IAAIo/B,EAAY,EACZ/Z,EAAUwZ,GAAQQ,IAAIz4B,GAC1B,UAAW,MAAMxK,KAAS4D,EAClBqlB,EAAQia,OAAOljC,GAAO+iC,IAAiBD,KACrCE,UAAoB/Z,EAAQka,aAGlCla,EAAQ7U,SAAShP,OAAS,GAAmB,IAAd49B,WACzB/Z,EAAQka,aAtVXE,CAAqB74B,GAwDzBtB,WAAa,OAAOmf,EAAO4a,IAAIh5B,KAAKm4B,SAE3C1F,gBAAyB,OAAOzyB,KAAKyS,KAAKggB,UAC1C8C,gBAAyB,OAAOv1B,KAAK04B,OAAOV,WAC5CqB,kBAA2B,OAAOr5B,KAAKoyB,SAASj3B,OAKhDrB,iBACI,IAAIW,EAAO,EAKX,OAJAuF,KAAKs5B,WAAa7+B,GAAQuF,KAAKs5B,SAASx/B,YACxCkG,KAAKkB,UAAYzG,GAAQuF,KAAKkB,QAAQpH,YACtCkG,KAAK04B,SAAWj+B,GAAQuF,KAAK04B,OAAO5+B,YACpCkG,KAAKu5B,WAAa9+B,GAAQuF,KAAKu5B,SAASz/B,YACjCkG,KAAKoyB,SAAS/2B,OAAO,CAACZ,EAAM45B,IAAU55B,EAAO45B,EAAMv6B,WAAYW,GAM1E+8B,qBACI,OAAOx3B,KAAK04B,OAAOlB,eAMvBC,yBACI,IAAIh9B,EAAO,EAKX,OAJAuF,KAAKs5B,WAAa7+B,GAAQuF,KAAKs5B,SAAS7B,oBACxCz3B,KAAKkB,UAAYzG,GAAQuF,KAAKkB,QAAQu2B,oBACtCz3B,KAAK04B,SAAWj+B,GAAQuF,KAAK04B,OAAOjB,oBACpCz3B,KAAKu5B,WAAa9+B,GAAQuF,KAAKu5B,SAAS9B,oBACjCz3B,KAAKoyB,SAAS/2B,OAAO,CAACZ,EAAM45B,IAAU55B,EAAO45B,EAAMoD,mBAAoBh9B,GAKlF4C,mBAA4B,OAAO2C,KAAKs5B,SAAWt5B,KAAKs5B,SAASp/B,OAAS,KAI1E+vB,aAAsB,OAAOjqB,KAAKkB,QAAUlB,KAAKkB,QAAQhH,OAAS,KAGlEy7B,iBAA0B,OAAO31B,KAAK04B,OAAS14B,KAAK04B,OAAOx+B,OAAS,KAIpEi4B,cAAuB,OAAOnyB,KAAKu5B,SAAWv5B,KAAKu5B,SAASr/B,OAAS,KAY9D+E,OAAOlJ,GAA8B,OAAOiK,KAAKzF,IAAIyF,KAAK7E,OAAQpF,GAOlEkJ,QAAQlJ,GAAuC,OAAOiK,KAAK24B,SAAS5iC,GAYpEkJ,IAAIzD,EAAezF,GAItB,OAHIiK,KAAKw5B,SAASh+B,EAAOwE,KAAKy5B,QAAQ1jC,KAClCiK,KAAK05B,SAASl+B,EAAOzF,GAElBiK,KAUJf,SAASzD,EAAezF,GAAsBiK,KAAK25B,UAAU35B,KAAMxE,EAAOzF,GAC1EkJ,SAASzD,EAAeo+B,GAE3B,OADA55B,KAAK7E,OAAS6E,KAAK04B,OAAOn+B,IAAIiB,GAAQo+B,GAAOz+B,OACtCy+B,EAIJ36B,SAASo1B,EAAgBh/B,KAAU2K,KAAKq5B,eAC3C,MAAU56B,oDAAoDuB,KAAKyS,SAShExT,WAAqCzD,GACxC,OAAOwE,KAAKoyB,SAAS52B,IAAU,KAS5ByD,QAEH,MAAMlC,EAAe,GACfktB,EAAUjqB,KAAKkB,QACf24B,EAAW75B,KAAKs5B,SAChBnH,EAAWnyB,KAAKu5B,UAChBp+B,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAE1BmyB,GACAp1B,EAAQosB,EAAW+M,MAAQ/D,EAAQgG,MAAMh9B,GAEzC0+B,IAAY98B,EAAQosB,EAAWgN,QAAU0D,EAAQ1B,MAAMh9B,KAChD0+B,GAEP5P,IAAWltB,EAAQosB,EAAWiN,MAAQnM,EAAOkO,MAAM0B,EAAQC,SAC3D/8B,EAAQosB,EAAWgN,QAAU0D,EAAQ1B,MAAMh9B,IACpC8uB,IACPltB,EAAQosB,EAAWiN,MAAQnM,EAAOkO,MAAMh9B,IAG5Co6B,EAAY,IAAMx4B,EAAQosB,EAAW8M,UAAYj2B,KAAK04B,OAAOP,MAAMh9B,IAEnE,MAAMuX,EAAOoZ,GAAKkN,IACdh5B,KAAKyS,KAAM,EAAGtX,EAAQo6B,EAAWx4B,EACjCiD,KAAKoyB,SAAS1uB,IAAK2wB,GAAUA,EAAM8D,UAIvC,OAFAn4B,KAAK6G,QAEE6L,EAOJzT,SAGH,OAFAe,KAAK+O,UAAW,EAChB/O,KAAKoyB,SAAS2H,QAAS1F,GAAUA,EAAMlqB,UAChCnK,KAOJf,QAOH,OANAe,KAAK7E,OAAS,EACd6E,KAAKs5B,UAAat5B,KAAKs5B,SAASzyB,QAChC7G,KAAKkB,SAAYlB,KAAKkB,QAAQ2F,QAC9B7G,KAAK04B,QAAW14B,KAAK04B,OAAO7xB,QAC5B7G,KAAKu5B,UAAav5B,KAAKu5B,SAAS1yB,QAChC7G,KAAKoyB,SAAS2H,QAAS1F,GAAUA,EAAMxtB,SAChC7G,MAIdw4B,GAAQ9hC,UAAkByE,OAAS,EACnCq9B,GAAQ9hC,UAAkBg/B,OAAS,EACnC8C,GAAQ9hC,UAAkB07B,SAAW,KACrCoG,GAAQ9hC,UAAkBqY,UAAW,EACrCypB,GAAQ9hC,UAAkBmgC,WAAa,KACvC2B,GAAQ9hC,UAAkBiiC,SAAW,MAAM,GAGrC,MAAeqB,WAAsIxB,GACxJv5B,YAAYg7B,GACRh5B,MAAMg5B,GACNj6B,KAAKkB,QAAU,IAAI02B,GAAkB,IAAI53B,KAAKyyB,UAAU,GAAIzyB,KAAK01B,QAE9Dz2B,SAASzD,EAAezF,GAC3B,MAAMk0B,EAASjqB,KAAKkB,QAEpB,OADA+oB,EAAO4N,QAAQr8B,EAAQyuB,EAAO9uB,OAAS,GAChC8F,MAAMy4B,SAASl+B,EAAOzF,IAK9B,MAAemkC,WAAiF1B,GAInGv5B,YAAYg7B,GACRh5B,MAAMg5B,GAJAj6B,KAAAm6B,eAAyB,EAK/Bn6B,KAAKs5B,SAAW,IAAIpB,GAEjBj5B,SAASzD,EAAezF,GAC3B,MAAMqkC,EAAUp6B,KAAKq6B,WAAar6B,KAAKq6B,SAAW,IAAIpa,KAChDqa,EAAUF,EAAQzkC,IAAI6F,GAC5B8+B,IAAYt6B,KAAKm6B,gBAAkBG,EAAQn/B,QAC3C6E,KAAKm6B,gBAAkBpkC,EAAMoF,OAC7Bi/B,EAAQ7/B,IAAIiB,EAAOzF,GAEhBkJ,SAASzD,EAAei+B,GAC3B,QAAKx4B,MAAMu4B,SAASh+B,EAAOi+B,MACtBz5B,KAAKq6B,WAAar6B,KAAKq6B,SAAW,IAAIpa,MAAQ1lB,IAAIiB,OAAOyG,IACnD,GAIRhD,QAGH,OAFAe,KAAKm6B,eAAiB,EACtBn6B,KAAKq6B,cAAWp4B,EACThB,MAAM4F,QAEV5H,QAEH,OADAe,KAAKu6B,SACEt5B,MAAMk3B,QAEVl5B,SAEH,OADAe,KAAKu6B,SACEt5B,MAAMkJ,SAEPlL,SACN,MAAMm7B,EAAUp6B,KAAKq6B,SACfG,EAAgBx6B,KAAKm6B,eAM3B,OALAn6B,KAAKm6B,eAAiB,EACtBn6B,KAAKq6B,cAAWp4B,EACZm4B,GAAWA,EAAQ3/B,KAAO,GAC1BuF,KAAKy6B,cAAcL,EAASI,GAEzBx6B,MChdR,MAAM06B,WAAiClC,GAC1Cv5B,YAAYsB,GACRU,MAAMV,GACNP,KAAKkB,QAAU,IAAI42B,GAEhB74B,SAASzD,EAAezF,GAC3BiK,KAAKkB,QAAQ3G,IAAIiB,GAAQzF,ICP1B,MAAM4kC,WAAiCnC,GAEnCv5B,SAASzD,EAAezF,IACxBkJ,SAASzD,EAAeo+B,GAE3B,OADA55B,KAAK7E,OAASd,KAAK6T,IAAI1S,EAAQ,EAAGwE,KAAK7E,QAChCy+B,GCLR,MAAMgB,WAA0DZ,IAEhE,MAAMa,WAAoCD,IAE1C,MAAME,WAA4CF,ICJlD,MAAMG,WAAoCf,ICQ1C,MAAMgB,WAA6DxC,GAQtEv5B,aAAcwT,KAAQA,EAAMokB,WAAc4B,EAAOwC,uBAA0BC,IACvEj6B,MAAM,CAAEwR,KAAM,IAAI2iB,GAAW3iB,EAAK8f,WAAY9f,EAAK6f,QAAS7f,EAAK0S,GAAI1S,EAAK4S,aAC1ErlB,KAAK04B,OAAe,KACpB14B,KAAKm7B,kBAAoB,EACzBn7B,KAAKo7B,eAAiB5lC,OAAOY,OAAO,MACpC4J,KAAKsyB,QAAUkG,GAAQQ,IAAI,CAAEvmB,KAAQzS,KAAKyS,KAAK6f,QAASuE,WAAc4B,IACtEz4B,KAAKuyB,WAAaiG,GAAQQ,IAAI,CAAEvmB,KAAQzS,KAAKyS,KAAK8f,WAAYsE,WAAc,OACtD,mBAAXqE,IACPl7B,KAAKq7B,WAAaH,GAI1BjR,aAAsB,OAAOjqB,KAAKsyB,QAAQrI,OAC1CsL,gBAAyB,OAAOv1B,KAAKsyB,QAAQiD,UAC7CI,iBAA0B,OAAO31B,KAAKsyB,QAAQqD,WAC9C77B,iBAA0B,OAAOkG,KAAKsyB,QAAQx4B,WAAakG,KAAKuyB,WAAWz4B,WAC3E09B,qBAA8B,OAAOx3B,KAAKsyB,QAAQkF,eAAiBx3B,KAAKuyB,WAAWiF,eACnFC,yBAAkC,OAAOz3B,KAAKsyB,QAAQmF,mBAAqBz3B,KAAKuyB,WAAWkF,mBACpFx4B,QAAQlJ,GAA8B,OAAOiK,KAAKsyB,QAAQmH,QAAQ1jC,GAClEkJ,SAASzD,EAAeo+B,GAC3B,MAAMtH,EAAUtyB,KAAKsyB,QAGrB,OAFAsH,EAAQtH,EAAQkH,SAASh+B,EAAOo+B,GAChC55B,KAAK7E,OAASm3B,EAAQn3B,OACfy+B,EAEJ36B,SAASzD,EAAezF,GAC3B,IAAIulC,EAAgBt7B,KAAKo7B,eACrB/kC,EAAM2J,KAAKq7B,WAAWtlC,GACtB4+B,EAAM2G,EAAcjlC,GAIxB,YAHY4L,IAAR0yB,IACA2G,EAAcjlC,GAAOs+B,EAAM30B,KAAKm7B,kBAAoBn7B,KAAKuyB,WAAW0G,OAAOljC,GAAOoF,OAAS,GAExF6E,KAAKsyB,QAAQoH,SAASl+B,EAAOm5B,GAEjC11B,QACH,MAAMwT,EAAOzS,KAAKyS,KACZ8oB,EAAOv7B,KAAKw7B,YACZC,EAAOz7B,KAAKuyB,WAAW2G,WACvBxmB,EAAO1S,KAAKsyB,QAAQ6F,QAAQrC,MAAMrjB,GAKxC,OAJAC,EAAK6f,WAAagJ,EAAOA,EAAK3kB,OAAO6kB,GAAQA,EAC7Cz7B,KAAK+O,WAAa/O,KAAKm7B,mBAAqBM,EAAKtgC,QACjD6E,KAAKw7B,YAAc9oB,EAAK6f,WACxBvyB,KAAK6G,QACE6L,EAEJzT,SAKH,OAJAe,KAAKsyB,QAAQnoB,SACbnK,KAAKuyB,WAAWpoB,SAChBnK,KAAKm7B,kBAAoB,EACzBn7B,KAAKo7B,eAAiB5lC,OAAOY,OAAO,MAC7B6K,MAAMkJ,SAEVlL,QAGH,OAFAe,KAAKsyB,QAAQzrB,QACb7G,KAAKuyB,WAAW1rB,QACT5F,MAAM4F,QAEV5H,WAAWuT,GACd,MAAsB,iBAARA,EAAmBA,KAASA,KC1E3C,MAAMkpB,WAA4C1B,ICJzD,MAAM2B,GAAM,IAAIn/B,aAAa,GACvBo/B,GAAM,IAAIt/B,YAAYq/B,GAAIzhC,QASzB,SAAS2hC,GAAgBC,GAC5B,IAAIC,GAAY,MAAJD,IAAe,GACvBE,GAAY,KAAJF,GAAc,KACtBG,IAAS,MAAY,MAAJH,IAAe,IACpC,OAAQC,GACJ,KAAK,GAAM,OAAOE,GAAQD,EAAOte,IAAM,KACvC,KAAK,EAAM,OAAOue,GAAQD,EAAO,eAAiBA,EAAO,GAE7D,OAAOC,EAAQ,IAAMF,EAAO,KAAQ,EAAIC,GAUrC,SAASE,GAAgB9mC,GAE5B,GAAIA,GAAMA,EAAK,OAAO,MAEtBumC,GAAI,GAAKvmC,EAOT,IAAI6mC,GAAiB,WAATL,GAAI,KAAoB,GAAK,MACrCG,EAAiB,WAATH,GAAI,GAAkBI,EAAO,EA8CzC,OA5CID,GAAQ,WAgBJH,GAAI,GAAK,EACTG,EAAO,OAEPA,GAAe,WAAPA,IAAsB,GAC9BC,GAAiB,QAATJ,GAAI,KAAoB,IAE7BG,GAAQ,YAQfC,EAAO,UADPA,EAAO,SAAqB,QAATJ,GAAI,OACMG,GAAQ,IAAM,MAAS,GACpDA,EAAO,IASPA,EAAQA,EAAO,YAAe,GAC9BC,EAAgC,KAAd,QAATJ,GAAI,KAA6B,IAGvCK,EAAOF,EAAc,MAAPC,ECjFlB,MAAMG,WAA2DnC,IAGjE,MAAMoC,WAAoCD,GACtCl9B,SAASzD,EAAezF,GAE3BiK,KAAKkB,QAAQ3G,IAAIiB,EAAO0gC,GAAgBnmC,KAKzC,MAAMsmC,WAAoCF,GACtCl9B,SAASzD,EAAezF,GAC3BiK,KAAKkB,QAAQ3G,IAAIiB,EAAOzF,IAKzB,MAAMumC,WAAoCH,GACtCl9B,SAASzD,EAAezF,GAC3BiK,KAAKkB,QAAQ3G,IAAIiB,EAAOzF,ICnBzB,MAAMwmC,GAAsB1mC,OAAO2mC,IAAI,iBAO9C,SAASC,GAAkBzhC,KAAWkvB,GAClC,OAAkB,IAAdA,EAAG/uB,OACI3F,OAAOknC,eAAelnC,OAAA6gC,GAAA,kBAAA7gC,CAAkBwK,KAAiB,WAAGhF,GAAIgF,KAAKkxB,YAAYx6B,WAErFlB,OAAOknC,eAAe,IAAI18B,KAAiB,WAAEhF,KAAMkvB,GAAKlqB,KAAKkxB,YAAYx6B,WAuBpF,SAASimC,MAA2BpR,GAAmC,OAAOkR,GAAO/rB,MAAM1Q,KAAMurB,GAEjG,SAASqR,MAA6BrR,GAAmC,OAAOkR,GAAO/rB,MAAM1Q,KAAMurB,GAEnG,SAASsR,MAA4BtR,GAAmC,OAAOkR,GAAO/rB,MAAM1Q,KAAMurB,GAUlG,SAASuR,GAA0CC,GAC/C,IAEyCloB,EAAIC,GAFzC5a,OAAEA,EAAMC,WAAEA,EAAUgB,OAAEA,EAAQ6hC,OAAUA,GAAWD,EACnDE,EAAQ,IAAI7gC,WAAWlC,EAAQC,EAAYgB,GAC3C+hC,EAAS,EAAGpoC,EAAI,EAAGyB,EAAI0mC,EAAM9hC,OACjC,KAAOrG,EAAIyB,GACPue,EAAKmoB,EAAMnoC,KACX+f,EAAKooB,EAAMnoC,KACXkoC,IAAWnoB,KAAY,GACvBqoB,IAAWpoB,IAAO,GAAMD,EAAM/f,GAAK,GAEvC,OAAOooC,EAIJ,IAAIC,GAEAC,GAWX,SAASC,GAA2C//B,GAChD,IAAIggC,EAAS,GACTnsB,EAAS,IAAI7U,YAAY,GACzBihC,EAAS,IAAIlhC,YAAYiB,EAAEpD,OAAQoD,EAAEnD,WAAYmD,EAAExD,WAAa,GAChE0jC,EAAS,IAAIlhC,aAAaihC,EAAS,IAAIlhC,YAAYkhC,GAAQE,WAAWvjC,QACtEpF,GAAK,EAAGyB,EAAIgnC,EAAOpiC,OAAS,EAChC,EAAG,CACC,IAAKgW,EAAO,GAAKosB,EAAOzoC,EAAI,GAAIA,EAAIyB,GAChCgnC,EAAOzoC,KAAOqc,EAAO,GAAKA,EAAO,GAAK,GACtCA,EAAO,IAAOA,EAAO,GAAiB,GAAZA,EAAO,IAAY,IAAMosB,EAAOzoC,GAE9DyoC,EAAOzoC,GAAKqc,EAAO,GAAKA,EAAO,GAAK,GACpCA,EAAO,GAAKA,EAAO,GAAiB,GAAZA,EAAO,GAC/BmsB,KAAYnsB,EAAO,KAAKmsB,UACnBE,EAAO,IAAMA,EAAO,IAAMA,EAAO,IAAMA,EAAO,IACvD,OAAOF,GAAkB,IA5E7Bb,GAAO/lC,UAAU6lC,KAAuB,EACxCE,GAAO/lC,UAAUqhB,OAAS,WAA+C,UAAWolB,GAAen9B,UACnGy8B,GAAO/lC,UAAUgnC,QAAU,WAA+C,OAAOZ,GAAe98B,OAChGy8B,GAAO/lC,UAAUoX,SAAW,WAA+C,OAAOqvB,GAAen9B,OACjGy8B,GAAO/lC,UAAUb,OAAO4gC,aAAe,SAA6CkH,EAAwC,WACxH,OAAQA,GACJ,IAAK,SAAU,OAAOb,GAAe98B,MACrC,IAAK,SAAU,OAAOm9B,GAAen9B,MACrC,IAAK,UAAW,OAAOo9B,GAAep9B,MAE1C,OAAOm9B,GAAen9B,OAgB1BxK,OAAOknC,eAAeC,GAAajmC,UAAalB,OAAOY,OAAOgG,WAAW1F,YACzElB,OAAOknC,eAAeE,GAAelmC,UAAWlB,OAAOY,OAAOkG,YAAY5F,YAC1ElB,OAAOknC,eAAeG,GAAcnmC,UAAYlB,OAAOY,OAAOkG,YAAY5F,YAC1ElB,OAAOooC,OAAOjB,GAAajmC,UAAa+lC,GAAO/lC,UAAW,CAAEw6B,YAAeyL,GAAgBK,QAAU,EAAOa,WAAczhC,WAAa0hC,YAAe7G,GAAA,IACtJzhC,OAAOooC,OAAOhB,GAAelmC,UAAW+lC,GAAO/lC,UAAW,CAAEw6B,YAAe0L,GAAgBI,QAAU,EAAOa,WAAcvhC,YAAawhC,YAAe7G,GAAA,IACtJzhC,OAAOooC,OAAOf,GAAcnmC,UAAY+lC,GAAO/lC,UAAW,CAAEw6B,YAAe2L,GAAgBG,QAAU,EAAOa,WAAcvhC,YAAawhC,YAAe7G,GAAA,IAqBjJA,GAAA,GAIDmG,GAAiB,CAA6B9/B,GAA0B,IAAjBA,EAAExD,WAAmB,IAAIwD,EAAe,YAAEA,EAAEpD,OAAQoD,EAAEnD,WAAY,GAAG,GAAUkjC,GAAgB//B,IACtJ6/B,GAAiB,CAA6B7/B,GAA0B,IAAjBA,EAAExD,cAAsB,IAAIwD,EAAe,YAAEA,EAAEpD,OAAQoD,EAAEnD,WAAY,GAAG,KAAOkjC,GAAgB//B,KAHtJ8/B,GADAD,GAAiBE,GA2Bd,MAAMU,GA+BT9+B,YAAYge,EAAQ+D,GAChB,OAAO+c,GAAG/E,IAAI/b,EAAK+D,GA9BhB/hB,WAAkCge,EAAQ+D,GAC7C,OAAQA,GACJ,KAAK,EAAM,OAAO,IAAW2b,GAAc1f,GAC3C,KAAK,EAAO,OAAO,IAAW2f,GAAgB3f,GAElD,OAAQA,EAAIiU,aACR,KAAKh1B,UACL,KAAKC,WACL,KAAKC,WACL,KAAK66B,GAAA,EACD,OAAO,IAAW0F,GAAc1f,GAExC,OAAuB,KAAnBA,EAAInjB,WACG,IAAW+iC,GAAe5f,GAE9B,IAAW2f,GAAgB3f,GAG/Bhe,cAAkCge,GACrC,OAAO,IAAW0f,GAAc1f,GAG7Bhe,gBAAqCge,GACxC,OAAO,IAAW2f,GAAgB3f,GAG/Bhe,eAAoCge,GACvC,OAAO,IAAW4f,GAAe5f,IC1HlC,MAAM+gB,WAAqDhE,GACvD/6B,SAASzD,EAAezF,GAC3BiK,KAAKkB,QAAQ3G,IAAIiB,EAAOzF,IAKzB,MAAMkoC,WAAiCD,IAEvC,MAAME,WAAkCF,IAExC,MAAMG,WAAkCH,IAExC,MAAMI,WAAkCJ,GAE3C/+B,YAAYsB,GACJA,EAAoB,aACpBA,EAAoB,WAAKA,EAAoB,WAAcmD,IAAI26B,KAEnEp9B,MAAMV,GACNP,KAAKkB,QAAU,IAAIk3B,GAAkB,IAAIh8B,WAAW,GAAI,GAE5DkiC,eAAwB,OAAOt+B,KAAKkB,QAAQq3B,SACrCt5B,QAAQlJ,GAAsC,OAAOkL,MAAMw4B,QAAQ4E,GAAStoC,KAIhF,MAAMwoC,WAAkCP,IAExC,MAAMQ,WAAmCR,IAEzC,MAAMS,WAAmCT,IAEzC,MAAMU,WAAmCV,GAE5C/+B,YAAYsB,GACJA,EAAoB,aACpBA,EAAoB,WAAKA,EAAoB,WAAcmD,IAAI26B,KAEnEp9B,MAAMV,GACNP,KAAKkB,QAAU,IAAIk3B,GAAkB,IAAI97B,YAAY,GAAI,GAE7DgiC,eAAwB,OAAOt+B,KAAKkB,QAAQq3B,SACrCt5B,QAAQlJ,GAAuC,OAAOkL,MAAMw4B,QAAQ4E,GAAStoC,KAGxF,MAAMsoC,GAAW,CAAEM,GAAe5oC,IAC1B0D,YAAYsC,OAAOhG,KACnB4oC,EAAKzkC,OAASnE,EAAMmE,OACpBykC,EAAKxkC,WAAapE,EAAMoE,WACxBwkC,EAAK7kC,WAAa/D,EAAM+D,WACxB/D,EAAQqnC,GAAeuB,GACvBA,EAAKzkC,OAAS,MAEXnE,GARM,CASd,CAAE+nC,YAAe7G,GAAA,IC1Db,MAAM2H,WAAwD5E,IAE9D,MAAM6E,WAAuCD,IAE7C,MAAME,WAA4CF,IAElD,MAAMG,WAA4CH,IAElD,MAAMI,WAA2CJ,ICRjD,MAAMK,WAAuEjF,IAE7E,MAAMkF,WAA4CD,IAElD,MAAME,WAAiDF,IAEvD,MAAMG,WAAiDH,IAEvD,MAAMI,WAAgDJ,ICRtD,MAAMK,WAAoEtF,IAE1E,MAAMuF,WAA4CD,IAElD,MAAME,WAA8CF,gBCFpD,MAAMG,WAAmCvF,GAC5Cj7B,YAAYg7B,GACRh5B,MAAMg5B,GACNj6B,KAAKkB,QAAU,IAAIo2B,GAAc,IAAIr9B,WAAW,IAEpDH,iBACI,IAAIW,EAAOuF,KAAKm6B,eAAgC,EAAdn6B,KAAK7E,OAIvC,OAHA6E,KAAKs5B,WAAa7+B,GAAQuF,KAAKs5B,SAASx/B,YACxCkG,KAAKkB,UAAYzG,GAAQuF,KAAKkB,QAAQpH,YACtCkG,KAAK04B,SAAWj+B,GAAQuF,KAAK04B,OAAO5+B,YAC7BW,EAEJwE,SAASzD,EAAezF,GAC3B,OAAOkL,MAAMy4B,SAASl+B,EAAOhG,OAAA6gC,GAAA,aAAA7gC,CAAaO,IAEpCkJ,cAAcm7B,EAA8CI,GAClE,MAAMX,EAAU75B,KAAKs5B,SACf5mB,EAAO1S,KAAKkB,QAAQ22B,QAAQ2C,GAAetgC,OACjD,IAAuCnE,EAAnCyF,EAAQ,EAAGL,EAAS,EAAGI,EAAS,EACpC,KAAMC,EAAOzF,KAAUqkC,OACLn4B,IAAVlM,EACA8jC,EAAQt/B,IAAIiB,EAAO,IAEnBL,EAASpF,EAAMoF,OACfuX,EAAKnY,IAAIxE,EAAOwF,GAChBs+B,EAAQt/B,IAAIiB,EAAOL,GACnBI,GAAUJ,ICzBnB,MAAMukC,WAAiCxF,GAC1Cj7B,YAAYg7B,GACRh5B,MAAMg5B,GACNj6B,KAAKkB,QAAU,IAAIo2B,GAAc,IAAIr9B,WAAW,IAEpDH,iBACI,IAAIW,EAAOuF,KAAKm6B,eAAgC,EAAdn6B,KAAK7E,OAIvC,OAHA6E,KAAKs5B,WAAa7+B,GAAQuF,KAAKs5B,SAASx/B,YACxCkG,KAAKkB,UAAYzG,GAAQuF,KAAKkB,QAAQpH,YACtCkG,KAAK04B,SAAWj+B,GAAQuF,KAAK04B,OAAO5+B,YAC7BW,EAEJwE,SAASzD,EAAezF,GAC3B,OAAOkL,MAAMy4B,SAASl+B,EAAOhG,OAAA4V,GAAA,EAAA5V,CAAWO,IAGlCkJ,cAAcm7B,EAA8CI,KAGzEkF,GAAYhpC,UAAkB+jC,cAAiBgF,GAAc/oC,UAAkB+jC,cCtBzE,MAAMkF,GAGTxkC,aAAsB,OAAO6E,KAAKkB,QAAQ/F,OACnC8D,IAAIzD,GAAiB,OAAOwE,KAAKkB,QAAQ1F,GACzCyD,QAAqC,OAA3Be,KAAKkB,QAAgB,KAAalB,KAC5Cf,KAAKgrB,GACR,OAAIA,aAAkB7L,EACX6L,GAEXjqB,KAAKkB,QAAU+oB,EACRjqB,OCVA,MAAM4/B,GAAU/pC,OAAO2mC,IAAI,UACrBqD,GAAYhqC,OAAO2mC,IAAI,YACvBsD,GAAYjqC,OAAO2mC,IAAI,YACvBuD,GAAYlqC,OAAO2mC,IAAI,YACvBwD,GAAiBnqC,OAAO2mC,IAAI,8BAEjD,MAAeyD,GAUXhhC,YAAYihC,EAAwBC,GAChCngC,KAAK4/B,IAAWM,EAChBlgC,KAAKvF,KAAO0lC,EAUTlhC,UAAY,OAAOe,KAAKnK,OAAO8G,YAE/BsC,IAAI5I,GAAU,YAAyB4L,IAAlBjC,KAAKrK,IAAIU,GAE9B4I,IAAI5I,GACP,IAAImc,OAAMvQ,EACV,GAAI5L,QAAmC,CACnC,MAAM+pC,EAAOpgC,KAAK8/B,MAAe9/B,KAAK8/B,IAAa,IAAI7f,KACvD,IAAI0U,EAAMyL,EAAKzqC,IAAIU,GACnB,QAAY4L,IAAR0yB,EAAmB,CACnB,MAAM0L,EAAOrgC,KAAK+/B,MAAe//B,KAAK+/B,IAAiBpxB,MAAM3O,KAAKvF,YAC3CwH,KAArBuQ,EAAM6tB,EAAK1L,MAAyB0L,EAAK1L,GAAOniB,EAAMxS,KAAKsgC,SAAS3L,SACnE,IAAKA,EAAM30B,KAAKugC,SAASlqC,KAAS,EAAG,CACxC+pC,EAAK7lC,IAAIlE,EAAKs+B,GACd,MAAM0L,EAAOrgC,KAAK+/B,MAAe//B,KAAK+/B,IAAiBpxB,MAAM3O,KAAKvF,YAC3CwH,KAArBuQ,EAAM6tB,EAAK1L,MAAyB0L,EAAK1L,GAAOniB,EAAMxS,KAAKsgC,SAAS3L,KAG9E,OAAOniB,EAGJvT,IAAI5I,EAAQmc,GACf,GAAInc,QAAmC,CACnC,MAAM+pC,EAAOpgC,KAAK8/B,MAAe9/B,KAAK8/B,IAAa,IAAI7f,KACvD,IAAI0U,EAAMyL,EAAKzqC,IAAIU,GAInB,QAHY4L,IAAR0yB,GACAyL,EAAK7lC,IAAIlE,EAAKs+B,EAAM30B,KAAKugC,SAASlqC,IAElCs+B,GAAO,EAAG,EACG30B,KAAK+/B,MAAe//B,KAAK+/B,IAAiBpxB,MAAM3O,KAAKvF,QAC7Dk6B,GAAa30B,KAAK05B,SAAS/E,EAAKniB,IAG7C,OAAOxS,KAGJf,QAAgB,MAAUR,kBAAkBuB,KAAKnK,OAAOC,+BAExDmJ,OAAOiD,GAAiB,MAAUzD,kBAAkBuB,KAAKnK,OAAOC,sCAEhEmJ,EAAEpJ,OAAO8G,YAEZ,MAAM6jC,EAAKxgC,KAAKygC,OACVC,EAAK1gC,KAAKiqB,SACVmW,EAAOpgC,KAAK8/B,MAAe9/B,KAAK8/B,IAAa,IAAI7f,KACjDogB,EAAOrgC,KAAK+/B,MAAe//B,KAAK+/B,IAAiBpxB,MAAM3O,KAAKvF,OAElE,IAAK,IAAIkmC,EAAMC,EAAaC,EAAuBC,EAA9BhsC,EAAI,IAClB+rC,EAAKL,EAAG5jC,QAAQK,QAAS6jC,EAAKJ,EAAG9jC,QAAQK,OAC1CnI,EAEF6rC,EAAIE,EAAG9qC,MACP6qC,EAAIE,EAAG/qC,MACPsqC,EAAKvrC,GAAK8rC,EACVR,EAAKW,IAAIJ,IAAMP,EAAK7lC,IAAIomC,EAAG7rC,QACrB,CAAC6rC,EAAGC,GAIX3hC,QAAQ+hC,EAAwDC,GAEnE,MAAMT,EAAKxgC,KAAKygC,OACVC,EAAK1gC,KAAKiqB,SACViX,OAAuBj/B,IAAZg/B,EAAwBD,EACrC,CAACJ,EAAMD,EAAMzrC,IAAiB8rC,EAAW/rC,KAAKgsC,EAASL,EAAGD,EAAGzrC,GAC3DkrC,EAAOpgC,KAAK8/B,MAAe9/B,KAAK8/B,IAAa,IAAI7f,KACjDogB,EAAOrgC,KAAK+/B,MAAe//B,KAAK+/B,IAAiBpxB,MAAM3O,KAAKvF,OAElE,IAAK,IAAIkmC,EAAMC,EAAaC,EAAuBC,EAA9BhsC,EAAI,IAClB+rC,EAAKL,EAAG5jC,QAAQK,QAAS6jC,EAAKJ,EAAG9jC,QAAQK,OAC1CnI,EAEF6rC,EAAIE,EAAG9qC,MACP6qC,EAAIE,EAAG/qC,MACPsqC,EAAKvrC,GAAK8rC,EACVR,EAAKW,IAAIJ,IAAMP,EAAK7lC,IAAIomC,EAAG7rC,GAC3BosC,EAASN,EAAGD,EAAG3gC,MAIhBf,UAAY,MAAO,IAAIe,KAAKiqB,UAC5BhrB,SACH,MAAMkK,EAAM,GAEZ,OADAnJ,KAAK+5B,QAAQ,CAACvnB,EAAKnc,IAAQ8S,EAAI9S,GAAOmc,GAC/BrJ,EAGJlK,UAAY,OAAOe,KAAK8N,WACxB7O,CAAC+gC,MAAoB,OAAOhgC,KAAK8N,WACjC7O,WACH,MAAMqV,EAAgB,GAMtB,OALAtU,KAAK+5B,QAAQ,CAACvnB,EAAKnc,KACfA,EAAMmgC,GAAcngC,GACpBmc,EAAMgkB,GAAchkB,GACpB8B,EAAI3S,QAAQtL,MAAQmc,YAEZ8B,EAAImD,KAAK,WAGRwoB,GAACpqC,OAAOC,aAAe,CAAE08B,IACtCh9B,OAAO2rC,iBAAiB3O,EAAO,CAC3B/3B,KAAQ,CAAE6F,UAAU,EAAM5K,YAAY,EAAO6gB,cAAc,EAAOxgB,MAAO,GACzEkJ,CAAC2gC,IAAU,CAAEt/B,UAAU,EAAM5K,YAAY,EAAO6gB,cAAc,EAAOxgB,MAAO,MAC5EkJ,CAAC4gC,IAAY,CAAEv/B,UAAU,EAAM5K,YAAY,EAAO6gB,cAAc,EAAOxgB,OAAQ,KAE3Ey8B,EAAc38B,OAAOC,aAAe,OANR,CAOrCmqC,GAAIvpC,WAGJ,MAAM0qC,WAAmEnB,GAC5EhhC,YAAYtD,GAER,OADAsF,MAAMtF,EAAOA,EAAMR,QACZkmC,GAAerhC,MAEnBf,OACH,OAAOe,KAAK4/B,IAAS0B,WAAW,GAAIzrC,OAAO8G,YAExCsC,SACH,OAAOe,KAAK4/B,IAAS0B,WAAW,GAAIzrC,OAAO8G,YAExCsC,OAAO01B,GACV,OAAO30B,KAAK4/B,IAAS0B,WAAW,GAAI3rC,IAAIg/B,GAErC11B,SAAS5I,GACZ,OAAO2J,KAAK4/B,IAAS0B,WAAW,GAAI3wB,QAAQta,GAEzC4I,SAASzD,GACZ,OAAOwE,KAAK4/B,IAAS0B,WAAW,GAAI3rC,IAAI6F,GAErCyD,SAASzD,EAAezF,GAC3BiK,KAAK4/B,IAAS0B,WAAW,GAAI/mC,IAAIiB,EAAOzF,IAIzC,MAAMwrC,WAA+DtB,GACxEhhC,YAAYihC,GAER,OADAj/B,MAAMi/B,EAAQA,EAAOztB,KAAK2f,SAASj3B,QAC5BqmC,GAAyBxhC,MAE7Bf,QACH,IAAK,MAAMyL,KAAS1K,KAAK4/B,IAASntB,KAAK2f,eAC7B1nB,EAAMrV,KAGb4J,UACH,IAAK,MAAMyL,KAAS1K,KAAK4/B,IAASntB,KAAK2f,eAC5BpyB,KAAoB0K,EAAMrV,MAGlC4J,OAAO01B,GACV,OAAO30B,KAAK4/B,IAASntB,KAAK2f,SAASuC,GAAKt/B,KAErC4J,SAAS5I,GACZ,OAAO2J,KAAK4/B,IAASntB,KAAK2f,SAASqP,UAAWjQ,GAAMA,EAAEn8B,OAASgB,GAE5D4I,SAASzD,GACZ,OAAOwE,KAAK4/B,IAAS0B,WAAW9lC,GAAQ7F,IAAIqK,KAAK6/B,KAE9C5gC,SAASzD,EAAezF,GAC3B,OAAOiK,KAAK4/B,IAAS0B,WAAW9lC,GAAQjB,IAAIyF,KAAK6/B,IAAY9pC,IAIrEP,OAAOknC,eAAeuD,GAAIvpC,UAAWupB,IAAIvpB,WAGzC,MAAM8qC,GAA2B,MAC7B,MAAME,EAAO,CAAEhsC,YAAY,EAAM6gB,cAAc,EAAO5gB,IAAK,KAAa4E,IAAK,MAC7E,OAAuBonC,IACnB,IAAIhN,GAAO,EAAGyL,EAAOuB,EAAI7B,MAAe6B,EAAI7B,IAAa,IAAI7f,KAC7D,MAAM3qB,EAAUe,IAAa,WAAoB,OAAO2J,KAAKrK,IAAIU,KAC3DurC,EAAUvrC,IAAa,SAAkBmc,GAAY,OAAOxS,KAAKzF,IAAIlE,EAAKmc,KAChF,IAAK,MAAMnc,KAAOsrC,EAAIlB,OAClBL,EAAK7lC,IAAIlE,IAAOs+B,GAChB+M,EAAK/rC,IAAML,EAAOe,GAClBqrC,EAAKnnC,IAAMqnC,EAAOvrC,GAClBsrC,EAAIhrC,eAAeN,KAASqrC,EAAKhsC,YAAa,EAAMF,OAAOC,eAAeksC,EAAKtrC,EAAKqrC,IACpFC,EAAIhrC,eAAeg+B,KAAS+M,EAAKhsC,YAAa,EAAOF,OAAOC,eAAeksC,EAAKhN,EAAK+M,IAGzF,OADAA,EAAK/rC,IAAM+rC,EAAKnnC,IAAM,KACfonC,IAdkB,GAmB3BN,GAAiB,MACnB,GAAqB,oBAAVQ,MACP,OAAOL,GAEX,MAAMT,EAAMd,GAAIvpC,UAAUqqC,IACpBprC,EAAMsqC,GAAIvpC,UAAUf,IACpB4E,EAAM0lC,GAAIvpC,UAAU6D,IACpBunC,EAAS7B,GAAIvpC,UAAUorC,OACvBC,EAAqC,CACvCC,aAAY,KAAY,EACxBC,eAAc,KAAY,EAC1BC,kBAAiB,KAAY,EAC7BC,QAAQR,GAAmB,IAAIA,EAAIlB,QAAQ/8B,IAAK1I,MAASA,KACzDiE,IAAI0iC,EAAUtrC,GACV,OAAQA,GACJ,IAAK,SAAU,IAAK,WAAY,IAAK,WAAY,IAAK,WAAY,IAAK,UAAW,IAAK,SAAU,IAAK,UACtG,IAAK,cAAe,IAAK,gBAAiB,IAAK,uBAAwB,IAAK,WAAY,IAAK,iBAAkB,IAAK,UACpH,IAAK,OAAQ,IAAK,MAAO,IAAK,MAAO,IAAK,MAAO,IAAK,QAAS,IAAK,SAAU,IAAK,OAAQ,IAAK,SAAU,IAAK,UAAW,IAAK,UAC/H,IAAK,YAAa,IAAK,mBAAoB,IAAK,mBAAoB,IAAK,iBAAkB,IAAK,mBAAoB,IAAK,mBACzH,KAAKR,OAAO8G,SAAU,KAAK9G,OAAOC,YAAa,KAAK8pC,GAAS,KAAKC,GAAW,KAAKE,GAAW,KAAKD,GAAW,KAAKE,GAC9G,OAAO,EAKf,MAHmB,iBAAR3pC,GAAqBsrC,EAAIZ,IAAI1qC,KACpCA,EAAMsrC,EAAIG,OAAOzrC,IAEdsrC,EAAIZ,IAAI1qC,IAEnB4I,IAAI0iC,EAAUtrC,EAAkB+rC,GAC5B,OAAQ/rC,GACJ,IAAK,SAAU,IAAK,WAAY,IAAK,WAAY,IAAK,WAAY,IAAK,UAAW,IAAK,SAAU,IAAK,UACtG,IAAK,cAAe,IAAK,gBAAiB,IAAK,uBAAwB,IAAK,WAAY,IAAK,iBAAkB,IAAK,UACpH,IAAK,OAAQ,IAAK,MAAO,IAAK,MAAO,IAAK,MAAO,IAAK,QAAS,IAAK,SAAU,IAAK,OAAQ,IAAK,SAAU,IAAK,UAAW,IAAK,UAC/H,IAAK,YAAa,IAAK,mBAAoB,IAAK,mBAAoB,IAAK,iBAAkB,IAAK,mBAAoB,IAAK,mBACzH,KAAKR,OAAO8G,SAAU,KAAK9G,OAAOC,YAAa,KAAK8pC,GAAS,KAAKC,GAAW,KAAKE,GAAW,KAAKD,GAAW,KAAKE,GAC9G,OAAOqC,QAAQ1sC,IAAIgsC,EAAKtrC,EAAK+rC,GAKrC,MAHmB,iBAAR/rC,GAAqB0qC,EAAI9rC,KAAKmtC,EAAU/rC,KAC/CA,EAAMyrC,EAAO7sC,KAAKmtC,EAAU/rC,IAEzBV,EAAIV,KAAKmtC,EAAU/rC,IAE9B4I,IAAI0iC,EAAUtrC,EAAkBmc,EAAU4vB,GACtC,OAAQ/rC,GACJ,KAAKupC,GAAS,KAAKC,GAAW,KAAKE,GAAW,KAAKD,GAC/C,OAAOuC,QAAQ9nC,IAAIonC,EAAKtrC,EAAKmc,EAAK4vB,GACtC,IAAK,SAAU,IAAK,WAAY,IAAK,WAAY,IAAK,WAAY,IAAK,UAAW,IAAK,SAAU,IAAK,UACtG,IAAK,cAAe,IAAK,gBAAiB,IAAK,uBAAwB,IAAK,WAAY,IAAK,iBAAkB,IAAK,UACpH,IAAK,OAAQ,IAAK,MAAO,IAAK,MAAO,IAAK,MAAO,IAAK,QAAS,IAAK,SAAU,IAAK,OAAQ,IAAK,SAAU,IAAK,UAAW,IAAK,UAC/H,IAAK,YAAa,IAAK,mBAAoB,IAAK,mBAAoB,IAAK,iBAAkB,IAAK,mBAAoB,IAAK,mBACzH,KAAKvsC,OAAO8G,SAAU,KAAK9G,OAAOC,YAC9B,OAAO,EAKf,MAHmB,iBAARO,GAAqB0qC,EAAI9rC,KAAKmtC,EAAU/rC,KAC/CA,EAAMyrC,EAAO7sC,KAAKmtC,EAAU/rC,MAEzB0qC,EAAI9rC,KAAKmtC,EAAU/rC,MAASkE,EAAItF,KAAKmtC,EAAU/rC,EAAKmc,KAGnE,OAAuBmvB,GAAW,IAAIE,MAAMF,EAAKI,IA1D9B,GC3MhB,SAASO,GAAuE3oC,EAAW6B,EAAegE,GAC7G,MAAMrE,EAASxB,EAAOwB,OAChBonC,EAAS/mC,GAAS,EAAIA,EAASL,EAAUK,EAAQL,EACvD,OAAOqE,EAAOA,EAAK7F,EAAQ4oC,GAAUA,EAIzC,IAAIjmB,GAIG,SAASkmB,GAAiF7oC,EAAWwwB,EAA2BjV,EAAyB1V,GAK5J,IAAMrE,OAAQ0O,EAAM,GAAMlQ,EACtB4wB,EAAuB,iBAAVJ,EAAqB,EAAIA,EACtCK,EAAqB,iBAARtV,EAAmBrL,EAAMqL,EAS1C,OAPCqV,EAAM,IAAOA,GAAQA,EAAM1gB,EAAOA,GAAOA,GACzC2gB,EAAM,IAAOA,GAAQA,EAAM3gB,EAAOA,GAAOA,GAEzC2gB,EAAMD,IAASjO,GAAMiO,EAAKA,EAAMC,EAAKA,EAAMlO,IAE3CkO,EAAM3gB,IAAS2gB,EAAM3gB,GAEfrK,EAAOA,EAAK7F,EAAQ4wB,EAAKC,GAAO,CAACD,EAAKC,GAGjD,MAAMiY,GAAOxL,GAAA,EAAkBzhC,OAAAyhC,GAAA,EAAAzhC,CAAO,GAAK,EACrCktC,GAAa3sC,GAAeA,GAAUA,EAGrC,SAAS4sC,GAAwBC,GACpC,IAAIC,SAAsBD,EAE1B,GAAqB,WAAjBC,GAAwC,OAAXD,EAE7B,OAAIF,GAAUE,GACHF,GAEa,WAAjBG,EACA9sC,GAAeA,IAAU6sC,EACzB7sC,GAAgB0sC,GAAO1sC,IAAW6sC,EAG7C,GAAIA,aAAkBxf,KAAM,CACxB,MAAM0f,EAAgBF,EAAOlF,UAC7B,OAAQ3nC,GAAeA,aAAiBqtB,MAAQrtB,EAAM2nC,YAAcoF,EAGxE,OAAIrpC,YAAYsC,OAAO6mC,GACX7sC,KAAeA,GAAQP,OAAA6gC,GAAA,iBAAA7gC,CAAiBotC,EAAQ7sC,GAGxD6sC,aAAkB3iB,IAmB1B,SAA4BsK,GACxB,IAAIz1B,GAAK,EACT,MAAMiuC,EAAc,GAEpB,OADAxY,EAAIwP,QAAS6G,GAAMmC,IAAcjuC,GAAK6tC,GAAwB/B,IACvDoC,GAA4BD,GAvBCE,CAAmBL,GAEnDj0B,MAAMC,QAAQg0B,GAQtB,SAAmCrY,GAC/B,MAAMwY,EAAc,GACpB,IAAK,IAAIjuC,GAAK,EAAGyB,EAAIg0B,EAAIpvB,SAAUrG,EAAIyB,GACnCwsC,EAAYjuC,GAAK6tC,GAAwBpY,EAAIz1B,IAEjD,OAAOkuC,GAA4BD,GAbCG,CAA0BN,GAE1DA,aAAkBxkB,EAuB1B,SAAgCmM,GAC5B,MAAMwY,EAAc,GACpB,IAAK,IAAIjuC,GAAK,EAAGyB,EAAIg0B,EAAIpvB,SAAUrG,EAAIyB,GACnCwsC,EAAYjuC,GAAK6tC,GAAwBpY,EAAI50B,IAAIb,IAErD,OAAOkuC,GAA4BD,GA5BII,CAAuBP,GAgClE,SAAgCrY,GAC5B,MAAMkW,EAAOjrC,OAAOirC,KAAKlW,GAEzB,GAAoB,IAAhBkW,EAAKtlC,OAAgB,MAAO,KAAM,EACtC,MAAM4nC,EAAc,GACpB,IAAK,IAAIjuC,GAAK,EAAGyB,EAAIkqC,EAAKtlC,SAAUrG,EAAIyB,GACpCwsC,EAAYjuC,GAAK6tC,GAAwBpY,EAAIkW,EAAK3rC,KAEtD,OAAOkuC,GAA4BD,EAAatC,GAtCzC2C,CAAuBR,GAyClC,SAASI,GAA4BD,EAAsCtC,GACvE,OAAQjW,IACJ,IAAKA,GAAsB,iBAARA,EACf,OAAO,EAEX,OAAQA,EAAI0G,aACR,KAAKviB,MAAO,OAaxB,SAAsBo0B,EAAsC1vB,GACxD,MAAM9c,EAAIwsC,EAAY5nC,OACtB,GAAIkY,EAAIlY,SAAW5E,EAAK,OAAO,EAC/B,IAAK,IAAIzB,GAAK,IAAKA,EAAIyB,GACnB,IAAMwsC,EAAYjuC,GAAGue,EAAIve,IAAQ,OAAO,EAE5C,OAAO,EAnBoBuuC,CAAaN,EAAavY,GAC7C,KAAKvK,IACL,KAAKmhB,GACL,KAAKG,GACD,OAAO+B,GAAcP,EAAavY,EAAKA,EAAIiW,QAC/C,KAAKjrC,OACL,UAAKyM,EACD,OAAOqhC,GAAcP,EAAavY,EAAKiW,GAAQjrC,OAAOirC,KAAKjW,IAEnE,OAAOA,aAAepM,GAa9B,SAAuB2kB,EAAsCQ,GACzD,MAAMhtC,EAAIwsC,EAAY5nC,OACtB,GAAIooC,EAAIpoC,SAAW5E,EAAK,OAAO,EAC/B,IAAK,IAAIzB,GAAK,IAAKA,EAAIyB,GACnB,IAAMwsC,EAAYjuC,GAAGyuC,EAAI5tC,IAAIb,IAAQ,OAAO,EAEhD,OAAO,EAnB4B0uC,CAAcT,EAAavY,IAsBlE,SAAS8Y,GAAcP,EAAsC55B,EAAoBs3B,GAE7E,MAAMgD,EAAUhD,EAAK5qC,OAAO8G,YACtB+mC,EAAUv6B,aAAe8W,IAAM9W,EAAIs3B,OAASjrC,OAAOirC,KAAKt3B,GAAKtT,OAAO8G,YACpEgnC,EAAUx6B,aAAe8W,IAAM9W,EAAI8gB,SAAWz0B,OAAOy0B,OAAO9gB,GAAKtT,OAAO8G,YAE9E,IAAI7H,EAAI,EACJyB,EAAIwsC,EAAY5nC,OAChByoC,EAAOD,EAAQ/mC,OACfinC,EAAOJ,EAAQ7mC,OACfknC,EAAOJ,EAAQ9mC,OAEnB,KAAO9H,EAAIyB,IAAMstC,EAAK5mC,OAAS6mC,EAAK7mC,OAAS2mC,EAAK3mC,OAE1C4mC,EAAK9tC,QAAU+tC,EAAK/tC,OAAUgtC,EAAYjuC,GAAG8uC,EAAK7tC,UADnDjB,EAAG+uC,EAAOJ,EAAQ7mC,OAAQknC,EAAOJ,EAAQ9mC,OAAQgnC,EAAOD,EAAQ/mC,QAKvE,SAAI9H,IAAMyB,GAAKstC,EAAK5mC,MAAQ6mC,EAAK7mC,MAAQ2mC,EAAK3mC,QAG9CwmC,EAAQhiC,QAAUgiC,EAAQhiC,SAC1BiiC,EAAQjiC,QAAUiiC,EAAQjiC,SAC1BkiC,EAAQliC,QAAUkiC,EAAQliC,UACnB,GCjKJ,MAAMsiC,WACD3lB,EAwBRnf,YAAYwT,EAASjY,EAAsB,GAAIq/B,EAgMnD,SAA8CmK,GAC1C,IAAInK,EAAU,IAAIv9B,aAAa0nC,GAAW,IAAI7oC,OAAS,GACnDI,EAASs+B,EAAQ,GAAK,EAAG1+B,EAAS0+B,EAAQ1+B,OAC9C,IAAK,IAAIK,EAAQ,IAAKA,EAAQL,GAC1B0+B,EAAQr+B,GAAUD,GAAUyoC,EAAQxoC,EAAQ,GAAGL,OAEnD,OAAO0+B,EAtMkDoK,CAAiBzpC,IACtEyG,QAJMjB,KAAAy1B,YAAsB,EAK5Bz1B,KAAKkkC,MAAQzxB,EACbzS,KAAKmkC,QAAU3pC,EACfwF,KAAKokC,cAAgBvK,EACrB75B,KAAKqkC,QAAUxK,EAAQA,EAAQ1+B,OAAS,GACxC6E,KAAKskC,cAAgBtkC,KAAKkkC,MAAM9R,UAAY,IAAIj3B,OAxB7C8D,kBAAsC+kC,GACzC,OAAOO,GAA2BnmB,EAAQ4lB,GAIvC/kC,iBAAqC+kC,GACxC,MAAMxpC,EAASupC,GAAQS,WAAcR,GACrC,OAAO,IAAID,GAAWvpC,EAAO,GAAGiY,KAAMjY,GAoB1CiY,WAAoB,OAAOzS,KAAKkkC,MAChC/oC,aAAsB,OAAO6E,KAAKqkC,QAClC7pC,aAAsB,OAAOwF,KAAKmkC,QAClC1T,aAAkC,OAAOzwB,KAAKkkC,MAAMzT,OACpDgU,iBAA0B,iBAAkBzkC,KAAKkkC,SACjDxxB,WACI,OAAO1S,KAAKmkC,QAAQ,GAAKnkC,KAAKmkC,QAAQ,GAAGzxB,KAAa,KAG1D+f,gBAAyB,OAAOzyB,KAAKkkC,MAAMzR,UAC3C4G,kBAA2B,OAAOr5B,KAAKskC,aACvC5O,aAAsB,OAAO11B,KAAKmkC,QAAQ,GAAKnkC,KAAKmkC,QAAQ,GAAGzO,OAAS,EACxE57B,iBACI,OAAOkG,KAAKmkC,QAAQ9oC,OAAO,CAACvB,EAAY4qC,IAAU5qC,EAAa4qC,EAAM5qC,WAAY,GAErFy7B,gBACI,IAAIA,EAAYv1B,KAAKy1B,WAIrB,OAHIF,EAAY,IACZv1B,KAAKy1B,WAAaF,EAAYv1B,KAAKmkC,QAAQ9oC,OAAO,CAACL,GAAKu6B,eAAgBv6B,EAAIu6B,EAAW,IAEpFA,EAIXjD,cACI,GAAItG,EAAS2Y,aAAa3kC,KAAKkkC,OAAQ,CACnC,IAAKlkC,KAAK4kC,SAAU,CAChB,MAAMpqC,EAAgBwF,KAAKmkC,QAC3BnkC,KAAK4kC,SAA8B,IAAlBpqC,EAAOW,OAClBX,EAAO,GAAG83B,QACVyR,GAAQntB,UAAUpc,EAAOkJ,IAAK1I,GAAMA,EAAEs3B,UAEhD,OAAOtyB,KAAK4kC,SAEhB,OAAO,KAEXrS,iBACI,OAAIvG,EAAS2Y,aAAa3kC,KAAKkkC,OACpBlkC,KAAKmkC,QAAQnkC,KAAKmkC,QAAQhpC,OAAS,GAAGuX,KAAK6f,WAE/C,KAGJtzB,EAAEpJ,OAAO8G,YACZ,IAAK,MAAM+nC,KAAS1kC,KAAKmkC,cACdO,EAIRzlC,MAAMzE,EAASwF,KAAKmkC,SACvB,OAAO,IAAIJ,GAAQ/jC,KAAKkkC,MAAO1pC,GAG5ByE,UAAUqyB,GACb,OAAOtxB,KAAK81B,MAAMiO,GAAQS,QAAQxkC,QAASsxB,IAGxCryB,MAAMkrB,EAAgBjV,GACzB,OAAOstB,GAAWxiC,KAAMmqB,EAAOjV,EAAKlV,KAAK6kC,gBAGtC5lC,WAAqCzD,GAExC,GAAIA,EAAQ,GAAKA,GAASwE,KAAKskC,aAAgB,OAAO,KAEtD,IACIjQ,EAAmB3pB,EAAiBlQ,EADpCsqC,EAAU9kC,KAAK+kC,YAAc/kC,KAAK+kC,UAAY,IAGlD,OAAI1Q,EAAQyQ,EAAQtpC,IAAiB64B,GACjC3pB,GAAU1K,KAAKkkC,MAAM9R,UAAY,IAAI52B,MACrChB,EAASwF,KAAKmkC,QACTzgC,IAAKshC,GAAWA,EAAO1D,WAAc9lC,IACrCw7B,OAAQuM,GAAiC,MAAPA,IAC5BpoC,OAAS,EACR2pC,EAAQtpC,GAAS,IAAIuoC,GAAWr5B,EAAM+H,KAAMjY,GAIrD,KAKJyE,OAAiDzD,EAAegE,GACnE,IAAIm1B,EAAMn5B,EAENq+B,EAAU75B,KAAKokC,cAAe5Z,EAAMqP,EAAQ1+B,OAAS,EAEzD,GAAIw5B,EAAM,EAAiB,OAAO,KAClC,GAAIA,GAAOkF,EAAQrP,GAAQ,OAAO,KAClC,GAAIA,GAAO,EAAgB,OAAOhrB,EAAOA,EAAKQ,KAAM,EAAG20B,GAAO,CAAC,EAAGA,GAClE,IAAIpK,EAAM,EAAGzT,EAAM,EAAGmuB,EAAM,EAC5B,EAAG,CACC,GAAI1a,EAAM,IAAMC,EACZ,OAAOhrB,EAAOA,EAAKQ,KAAMuqB,EAAKoK,EAAM7d,GAAO,CAACyT,EAAKoK,EAAM7d,GAG3D6d,GAAOkF,EADPoL,EAAM1a,GAAQC,EAAMD,GAAO,EAAK,GACTA,EAAM0a,EAAQza,EAAMya,QACtCtQ,EAAMkF,EAAQrP,IAAQmK,IAAQ7d,EAAM+iB,EAAQtP,KACrD,OAAO,KAGJtrB,QAAQzD,GACX,QAASwE,KAAK4iC,OAAOpnC,EAAOwE,KAAKklC,iBAG9BjmC,IAAIzD,GACP,OAAOwE,KAAK4iC,OAAOpnC,EAAOwE,KAAKmlC,aAG5BlmC,IAAIzD,EAAezF,GACtBiK,KAAK4iC,OAAOpnC,EAAO,EAAGhB,UAAU1F,EAAGoG,IAAMV,EAAO1F,GAAGyF,IAAIW,EAAGnF,IAGvDkJ,QAAQmmC,EAAsB7pC,GACjC,OAAIA,GAA4B,iBAAXA,EACVyE,KAAK4iC,OAAOrnC,EAAQ,CAAC8pC,EAAMvwC,EAAGoG,IAAM8E,KAAKslC,gBAAgBD,EAAMvwC,EAAGoG,EAAGkqC,IAEzEplC,KAAKslC,gBAAgBtlC,KAAM,EAAG3F,KAAK6T,IAAI,EAAG3S,GAAU,GAAI6pC,GAG5DnmC,UACH,MAAMzE,OAAEA,GAAWwF,KACbzJ,EAAIiE,EAAOW,OACjB,IAAIs3B,EAAiBzyB,KAAKkkC,MAAMzR,UAChC,GAAIl8B,GAAK,EAAK,OAAO,IAAIk8B,EAAU,GACnC,GAAIl8B,GAAK,EAAK,OAAOiE,EAAO,GAAG+qC,UAC/B,IAAI17B,EAAM,EAAGzP,EAAUuU,MAAMpY,GAC7B,IAAK,IAAIzB,GAAK,IAAKA,EAAIyB,GACnBsT,IAAQzP,EAAItF,GAAK0F,EAAO1F,GAAGywC,WAAWpqC,OAEtCs3B,IAAcr4B,EAAI,GAAG82B,cACrBuB,EAAYr4B,EAAI,GAAG82B,aAEvB,IAAIl3B,EAAM,IAAIy4B,EAAU5oB,GACpBtP,EAAWk4B,IAAc9jB,MAAQ62B,GAAWC,GAChD,IAAK,IAAI3wC,GAAK,EAAG6/B,EAAM,IAAK7/B,EAAIyB,GAC5Bo+B,EAAMp6B,EAAIH,EAAItF,GAAIkF,EAAK26B,GAE3B,OAAO36B,EAGDiF,aAAYklC,QAAEA,GAAuBrvC,EAAWoG,GAAa,OAAOipC,EAAQrvC,GAAGa,IAAIuF,GACnF+D,iBAAgBklC,QAAEA,GAAuBrvC,EAAWoG,GAAa,OAAOipC,EAAQrvC,GAAG2kC,QAAQv+B,GAC3F+D,iBAAgBklC,QAAEA,GAAuBuB,EAAoBC,EAAmBP,GACtF,IAAItwC,EAAI4wC,EAAa,EAAGnvC,EAAI4tC,EAAQhpC,OAChC8Z,EAAQ0wB,EAAWpqC,EAAS,EAAGqY,GAAS,EAC5C,OAAS9e,EAAIyB,GAAG,CACZ,KAAMqd,EAAQuwB,EAAQrvC,GAAG6b,QAAQy0B,EAASnwB,IACtC,OAAO1Z,EAASqY,EAEpBqB,EAAQ,EACR1Z,GAAU4oC,EAAQrvC,GAAGqG,OAEzB,OAAQ,EAGF8D,eAAeomC,EAAkBlb,EAAejV,GACtD,MAAM0wB,EAAsB,IACtBprC,OAAEA,EAAQ4pC,cAAeyB,GAAiBR,EAChD,IAAK,IAAIvwC,GAAK,EAAGyB,EAAIiE,EAAOW,SAAUrG,EAAIyB,GAAI,CAC1C,MAAMmuC,EAAQlqC,EAAO1F,GACfgxC,EAAcpB,EAAMvpC,OACpB4qC,EAAcF,EAAa/wC,GAEjC,GAAIixC,GAAe7wB,EAAO,MAE1B,GAAIiV,GAAS4b,EAAcD,EAAe,SAE1C,GAAIC,GAAe5b,GAAU4b,EAAcD,GAAgB5wB,EAAK,CAC5D0wB,EAAOjkC,KAAK+iC,GACZ,SAGJ,MAAMzoC,EAAO5B,KAAK6T,IAAI,EAAGic,EAAQ4b,GAC3BC,EAAK3rC,KAAKC,IAAI4a,EAAM6wB,EAAaD,GACvCF,EAAOjkC,KAAK+iC,EAAM/oC,MAAMM,EAAM+pC,IAElC,OAAOX,EAAKvP,MAAM8P,IAe1B,MAAMH,GAAW,CAACrrC,EAAiBJ,EAAiBuB,KAChDvB,EAAIO,IAAIH,EAAKmB,GACLA,EAASnB,EAAIe,QAInBqqC,GAAW,CAACprC,EAAYJ,EAAYuB,KACtC,IAAIo5B,EAAMp5B,EACV,IAAK,IAAIzG,GAAK,EAAGyB,EAAI6D,EAAIe,SAAUrG,EAAIyB,GACnCyD,EAAI26B,KAASv6B,EAAItF,GAErB,OAAO6/B,GCjPJ,MAAMsR,WACDlC,GAyBR9kC,YAAYyL,EAAiBs5B,EAAuB,GAAInK,GAIpD,GAHAmK,EAAUD,GAAQS,WAAcR,GAChC/iC,MAAMyJ,EAAM+H,KAAMuxB,EAASnK,GAC3B75B,KAAKkmC,OAASx7B,EACS,IAAnBs5B,EAAQ7oC,UAAkB6E,gBAAgBmmC,IAC1C,OAAO,IAAIA,GAAkBz7B,EAAOs5B,EAAQ,GAAIhkC,KAAKokC,eAtBtDnlC,WAAqCyL,EAA0BgI,KAAwD0zB,GAE1H,MAAM5rC,EAASupC,GAAQS,QACnB71B,MAAMC,QAAQ8D,GAAQ,IAAIA,KAAS0zB,GACnC1zB,aAAgB0L,EAAS,CAAC1L,KAAS0zB,GACnC,CAAChoB,EAAO4a,IAAItmB,KAAS0zB,KAGzB,GAAqB,iBAAV17B,EAAoB,CAC3B,MAAM+H,EAAOjY,EAAO,GAAGkY,KAAKD,KAC5B/H,EAAQ,IAAI27B,GAAM37B,EAAO+H,GAAM,QACvB/H,EAAMob,UAAYtrB,EAAO8rC,KAAK,EAAG/Q,eAAgBA,EAAY,KACrE7qB,EAAQA,EAAMorB,MAAM,CAAEhQ,UAAU,KAEpC,OAAO,IAAImgB,GAAOv7B,EAAOlQ,GAe7BkQ,YAAqB,OAAO1K,KAAKkmC,OACjC7wC,WAAoB,OAAO2K,KAAKkmC,OAAO7wC,KACvCywB,eAAwB,OAAO9lB,KAAKkmC,OAAOpgB,SAC3CygB,eAAwB,OAAOvmC,KAAKkmC,OAAOK,SAEpCtnC,MAAMzE,EAASwF,KAAKmkC,SACvB,OAAO,IAAI8B,GAAOjmC,KAAKkmC,OAAQ1rC,GAG5ByE,WAAqCzD,GAExC,GAAIA,EAAQ,GAAKA,GAASwE,KAAKq5B,YAAe,OAAO,KAErD,IACImN,EAAmB97B,EAAiBlQ,EADpCsqC,EAAU9kC,KAAK+kC,YAAc/kC,KAAK+kC,UAAY,IAGlD,OAAIyB,EAAS1B,EAAQtpC,IAAiBgrC,GAClC97B,GAAU1K,KAAKyS,KAAK2f,UAAY,IAAI52B,MACpChB,EAASwF,KAAKmkC,QACTzgC,IAAKshC,GAAWA,EAAO1D,WAAc9lC,IACrCw7B,OAAQuM,GAAiC,MAAPA,IAC5BpoC,OAAS,EACR2pC,EAAQtpC,GAAS,IAAIyqC,GAAUv7B,EAAOlQ,GAI/C,MAKf,MAAM2rC,WAAoDF,GAEtDhnC,YAAYyL,EAAiBs6B,EAAmBnL,GAC5C54B,MAAMyJ,EAAO,CAACs6B,GAASnL,GACvB75B,KAAKymC,OAASzB,EAIX/lC,OAAiDzD,EAAegE,GACnE,OAAOA,EAAOA,EAAKQ,KAAM,EAAGxE,GAAS,CAAC,EAAGA,GAEtCyD,QAAQzD,GACX,OAAOwE,KAAKymC,OAAOhN,QAAQj+B,GAExByD,IAAIzD,GACP,OAAOwE,KAAKymC,OAAO9wC,IAAI6F,GAEpByD,IAAIzD,EAAezF,GACtBiK,KAAKymC,OAAOlsC,IAAIiB,EAAOzF,GAEpBkJ,QAAQmmC,EAAsB7pC,GACjC,OAAOyE,KAAKymC,OAAO91B,QAAQy0B,EAAS7pC,IChG5C,MAAMqT,GAAUD,MAAMC,QAGT83B,GAAa,CAAIC,EAAWC,IAAgBC,GAAYF,EAAMC,EAAM,GAAI,GAExEE,GAA2Dvb,IACpE,MAAO8F,EAAQpH,GAAU8c,GAAoBxb,EAAM,CAAC,GAAI,KACxD,OAAOtB,EAAOvmB,IAAI,CAAC1I,EAAGlG,IAClBkG,aAAairC,GAASA,GAAOjN,IAAIh+B,EAAE0P,MAAMorB,MAAMzE,EAAOv8B,IAAKkG,GAC3DA,aAAaojB,EAAS6nB,GAAOjN,IAAI3H,EAAOv8B,GAAIkG,GACtBirC,GAAOjN,IAAI3H,EAAOv8B,GAAI,MAIvCkyC,GAA0Dzb,GAAgBwb,GAAoBxb,EAAM,CAAC,GAAI,KAEzGgZ,GAAkB,CAAIoC,EAAWC,KAmB9C,SAASK,EAAoBN,EAAWC,EAAavxB,EAAUsf,GAC3D,IAAI5+B,EAAYmF,EAAIy5B,EACpB,IAAI7/B,GAAK,EAAGyB,EAAIqwC,EAAKzrC,OACrB,OAASrG,EAAIyB,GACLqY,GAAQ7Y,EAAQ6wC,EAAK9xC,IACrBoG,EAAI+rC,EAAiBN,EAAM5wC,EAAOsf,EAAKna,GAAGC,OACnCpF,aAAiBguC,GACxB7oC,EAAI+rC,EAAiBN,EAAM5wC,EAAMyE,OAAQ6a,EAAKna,GAAGC,OAC1CpF,aAAiB4wC,IAAQtxB,EAAIna,KAAOnF,GAEnD,OAAOsf,GA7BmD4xB,CAAiBN,EAAMC,EAAM,GAAI,GAElFM,GAA2B,CAAmBP,EAAuBC,KA+BlF,SAASO,EAA4CR,EAAuBC,EAAavxB,EAAUsf,GAC/F,IAAI5+B,EAAYmF,EAAIy5B,EACpB,IAAI7/B,GAAK,EAAGyB,EAAIqwC,EAAKzrC,OACrB,OAASrG,EAAIyB,GACLqY,GAAQ7Y,EAAQ6wC,EAAK9xC,IACrBoG,EAAIisC,EAA0BR,EAAM5wC,EAAOsf,EAAKna,GAAGC,OAC5CpF,aAAiB4wC,EACxBzrC,EAAI2rC,GAAYzoB,EAAQroB,EAAMkK,OAAOoxB,OAAO3tB,IAAI,CAACxB,EAAGpN,IAAMiB,EAAMurC,WAAWxsC,IAAMugB,EAAKna,GAAGC,OAClFpF,aAAiBqoB,IAAU/I,EAAIna,KAAOnF,GAErD,OAAOsf,GAzCuF8xB,CAA0BR,EAAMC,EAAM,GAAI,GAE/HQ,GAA2B,CAAmBT,EAAuBC,KA2ClF,SAASS,EAA4CV,EAAuBC,EAAavxB,EAAUsf,GAC/F,IAAI5+B,EAAYmF,EAAIy5B,EACpB,IAAI7/B,GAAK,EAAGyB,EAAIqwC,EAAKzrC,OACrB,OAASrG,EAAIyB,GACLqY,GAAQ7Y,EAAQ6wC,EAAK9xC,IACrBoG,EAAImsC,EAA0BV,EAAM5wC,EAAOsf,EAAKna,GAAGC,OAC5CpF,aAAiB4wC,EACxBzrC,EAAI2rC,GAAYZ,GAAQlwC,EAAMkK,OAAOoxB,OAAO3tB,IAAI,CAAC8tB,EAAG18B,IAAMmxC,GAAOjN,IAAIxH,EAAGz7B,EAAMurC,WAAWxsC,KAAOugB,EAAKna,GAAGC,OACjGpF,aAAiBkwC,KAAU5wB,EAAIna,KAAOnF,GAErD,OAAOsf,GArDuFgyB,CAA0BV,EAAMC,EAAM,GAAI,GAG5I,SAASC,GAAeF,EAAWC,EAAavxB,EAAUsf,GACtD,IAAI5+B,EAAYmF,EAAIy5B,EAChB7/B,GAAK,EAAGyB,EAAIqwC,EAAKzrC,OACrB,OAASrG,EAAIyB,GACLqY,GAAQ7Y,EAAQ6wC,EAAK9xC,IACrBoG,EAAI2rC,GAAYF,EAAM5wC,EAAOsf,EAAKna,GAAGC,OAC9BpF,aAAiB4wC,IAAQtxB,EAAIna,KAAOnF,GAEnD,OAAOsf,EA8CX,MAAMiyB,GAAkB,CAACpd,GAAqByW,EAAGC,GAAgB9rC,KAAeo1B,EAAG,GAAGp1B,GAAK6rC,EAAGzW,EAAG,GAAGp1B,GAAK8rC,EAAG1W,GAG5G,SAAS6c,GAAwDH,EAAa3uB,GAC1E,IAAIwoB,EAAalqC,EACjB,OAAQA,EAAIqwC,EAAKzrC,QACb,KAAK,EAAG,OAAO8c,EACf,KAAK,EAED,GADAwoB,EAAOxoB,EAAI,IACL2uB,EAAK,GAAO,OAAO3uB,EACzB,GAAIrJ,GAAQg4B,EAAK,IAAO,OAAOG,GAAiBH,EAAK,GAAI3uB,GACnD2uB,EAAK,aAAc9a,IAAQ8a,EAAK,aAAcxoB,GAAUwoB,EAAK,aAAc5a,KAC5EyU,EAAMmG,GAAQpxC,OAAO+xC,QAAQX,EAAK,IAAIvrC,OAAOisC,GAAiBrvB,IAEnE,MACJ,QACKrJ,GAAQ6xB,EAAOmG,EAAKrwC,EAAI,IAElBqwC,EAAOh4B,GAAQg4B,EAAK,IAAMA,EAAK,GAAKA,EAAKjrC,MAAM,EAAGpF,EAAI,IADtDqwC,EAAOh4B,GAAQg4B,EAAK,IAAMA,EAAK,GAAKA,EAAMnG,EAAO,IAIhE,IAGI/1B,EACA8H,EAJAg1B,GAAc,EACdC,GAAc,EACd9S,GAAO,EAAG9qB,EAAM+8B,EAAKzrC,QAGpBk2B,EAAQpH,GAAUhS,EAEvB,OAAS0c,EAAM9qB,IACX2I,EAAMo0B,EAAKjS,cACQsR,KAAWhc,IAASwd,GAAcj1B,GACjD6e,IAASmW,GAAch1B,EAAI9H,MAAMorB,MAAM2K,EAAK9L,GAAMniB,EAAIC,MAAM,MAEzDxT,CAAC01B,GAAMjqB,EAAQiqB,GAAQ8L,GACtBjuB,aAAewZ,IAAa/B,IAASwd,GAAcj1B,GACnD6e,IAASmW,GAAcnB,GAAMrN,IAAItuB,EAAO8H,GAAiB,GAClDA,GAAOA,EAAIC,OAASwX,IAASwd,GAAcj1B,KAClDA,aAAesZ,KAAS7B,EAAOwd,GAAcj1B,EAAM4L,EAAO4a,IAAIxmB,IAC9D6e,IAASmW,GAAcnB,GAAMrN,IAAItuB,EAAO8H,EAAIC,MAAM,KAI9D,OAAOwF,ECrHJ,MAAMyvB,GAsBTzoC,YAAYoyB,EAAkB,GAClBkV,EACApmC,GACRH,KAAKqxB,OAAUA,GAAU,GACzBrxB,KAAKumC,SAAWA,GAAY,IAAItmB,IAC3B9f,IACDA,EAAewnC,GAAsBtW,IAEzCrxB,KAAKG,aAAeA,EAxBjBlB,eAAessB,GAClB,OAAOmc,GAAO1O,IAAIzN,EAAK,GAAIA,EAAK,IAO7BtsB,cAAcssB,GACjB,OAAO,IAAImc,GAAOV,GAAgBzb,GAAM,IAiB5C51B,IAAYE,OAAOC,eAAiB,MAAO,SACpCmJ,WACH,kBAAmBe,KAAKqxB,OAAO3tB,IAAI,CAAC8tB,EAAG18B,OAASA,MAAM08B,KAAK/Z,KAAK,WAG7DxY,UAAU6G,GACb,OAAOqrB,EAASyW,eAAe5nC,KAAM8F,GAGlC7G,UAAmC4oC,GACtC,MAAMC,EAAQD,EAAYxsC,OAAO,CAAC6uB,EAAIlvB,KAAOkvB,EAAGlvB,IAAK,IAASkvB,EAAI10B,OAAOY,OAAO,OAChF,OAAO,IAAIsxC,GAA2B1nC,KAAKqxB,OAAO2F,OAAQxF,GAAMsW,EAAMtW,EAAEn8B,OAAQ2K,KAAKumC,UAElFtnC,YAAwC8oC,GAC3C,OAAO,IAAIL,GAA6BK,EAAcrkC,IAAK5O,GAAMkL,KAAKqxB,OAAOv8B,IAAIkiC,OAAOgR,SAAUhoC,KAAKumC,UAKpGtnC,UAAuDssB,GAE1D,MAAMzlB,EAAQylB,EAAK,aAAcmc,GAASnc,EAAK,GACzC,IAAImc,GAAUhB,GAA8BL,GAAO9a,IAEnD0c,EAAY,IAAIjoC,KAAKqxB,QACrBkV,EAAW2B,GAAUA,GAAU,IAAIjoB,IAAOjgB,KAAKumC,UAAWzgC,EAAMygC,UAChE4B,EAAYriC,EAAMurB,OAAO2F,OAAQoR,IACnC,MAAMtzC,EAAImzC,EAAUxG,UAAWjQ,GAAMA,EAAEn8B,OAAS+yC,EAAG/yC,MACnD,QAAQP,IAAKmzC,EAAUnzC,GAAKszC,EAAGtS,MAAM,CACjCyQ,SAAU2B,GAAUA,GAAU,IAAIjoB,IAAOgoB,EAAUnzC,GAAGyxC,UAAW6B,EAAG7B,eACjE,IAGL8B,EAAkBV,GAAsBQ,EAAW,IAAIloB,KAE7D,OAAO,IAAIynB,GACP,IAAIO,KAAcE,GAAY5B,EAC9B,IAAItmB,IAAI,IAAIjgB,KAAKG,gBAAiBkoC,MAKvC,MAAMhC,GAqBTpnC,YAAY5J,EAAcod,EAASqT,GAAW,EAAOygB,GACjDvmC,KAAK3K,KAAOA,EACZ2K,KAAKyS,KAAOA,EACZzS,KAAK8lB,SAAWA,EAChB9lB,KAAKumC,SAAWA,GAAY,IAAItmB,IApB7BhhB,cAAwCssB,GAC3C,IAAKl2B,EAAMod,EAAMqT,EAAUygB,GAAYhb,EAOvC,OANIA,EAAK,IAAyB,iBAAZA,EAAK,OACpBl2B,QAASk2B,EAAK,SACPtpB,IAATwQ,IAAwBA,EAAO8Y,EAAK,GAAG9Y,WAC1BxQ,IAAb6jB,IAA4BA,EAAWyF,EAAK,GAAGzF,eAClC7jB,IAAbskC,IAA4BA,EAAWhb,EAAK,GAAGgb,WAE7C,IAAIF,MAAYhxC,IAAQod,EAAMqT,EAAUygB,GAenD9V,aAAsB,OAAOzwB,KAAKyS,KAAKge,OACvC96B,IAAYE,OAAOC,eAAiB,MAAO,QACpCmJ,WAAa,SAAUe,KAAK3K,SAAS2K,KAAKyS,OAC1CxT,UAAU6G,GACb,OAAOqrB,EAASM,aAAazxB,KAAM8F,GAIhC7G,SAAiCssB,GACpC,IAAKl2B,EAAMod,EAAMqT,EAAUygB,GAAYhb,EAIvC,OAHEA,EAAK,IAAyB,iBAAZA,EAAK,KAEjBl2B,OAAO2K,KAAK3K,KAAMod,OAAOzS,KAAKyS,KAAMqT,WAAW9lB,KAAK8lB,SAAUygB,WAAWvmC,KAAKumC,UAAYhb,EAAK,KAD/Fl2B,EAAO2K,KAAK3K,KAAMod,EAAOzS,KAAKyS,KAAMqT,EAAW9lB,KAAK8lB,SAAUygB,EAAWvmC,KAAKumC,UAAYhb,EAE3F8a,GAAMrN,IAAO3jC,EAAMod,EAAMqT,EAAUygB,IAKlD,SAAS2B,GAAsBI,EAA6BC,GACxD,OAAO,IAAItoB,IAAI,IAAKqoB,GAAM,IAAIroB,OAAYsoB,GAAM,IAAItoB,MAIxD,SAAS0nB,GAAsBtW,EAAiBlxB,EAAe,IAAI8f,KAE/D,IAAK,IAAInrB,GAAK,EAAGyB,EAAI86B,EAAOl2B,SAAUrG,EAAIyB,GAAI,CAC1C,MACMkc,EADQ4e,EAAOv8B,GACF2d,KACnB,GAAIuZ,EAAS2Y,aAAalyB,GACtB,GAAKtS,EAAa4gC,IAAItuB,EAAK0S,KAEpB,GAAIhlB,EAAaxK,IAAI8c,EAAK0S,MAAQ1S,EAAK8f,WAC1C,MAAU9zB,MAAM,oFAFhB0B,EAAa5F,IAAIkY,EAAK0S,GAAI1S,EAAK8f,YAKnC9f,EAAK2f,UAAY3f,EAAK2f,SAASj3B,OAAS,GACxCwsC,GAAsBl1B,EAAK2f,SAAUjyB,GAI7C,OAAOA,EAKVunC,GAAOhxC,UAAkB26B,OAAS,KAClCqW,GAAOhxC,UAAkB6vC,SAAW,KACpCmB,GAAOhxC,UAAkByJ,aAAe,KAExCkmC,GAAM3vC,UAAkB+b,KAAO,KAC/B4zB,GAAM3vC,UAAkBrB,KAAO,KAC/BgxC,GAAM3vC,UAAkBovB,SAAW,KACnCugB,GAAM3vC,UAAkB6vC,SAAW,KC9J7B,MAAMiC,WAA2DtO,GAGpEj7B,YAAYg7B,GACRh5B,MAAMg5B,GAHAj6B,KAAAyoC,KAAO,IAAI9I,GAIjB3/B,KAAKs5B,SAAW,IAAIpB,GAEjBj5B,SAASo1B,EAAmBh/B,EAAO,KACtC,GAAI2K,KAAKq5B,YAAc,EACnB,MAAU56B,MAAM,wCAIpB,OAFAuB,KAAKoyB,SAASpyB,KAAKq5B,aAAehF,EAClCr0B,KAAKyS,KAAO,IAAI2hB,GAAK,IAAIiS,GAAMhxC,EAAMg/B,EAAM5hB,MAAM,IAC1CzS,KAAKq5B,YAAc,EAEvBp6B,QAEH,OADAe,KAAKyoC,KAAK5hC,QACH5F,MAAM4F,QAEP5H,cAAcm7B,GACpB,MAAMsO,EAAM1oC,KAAKyoC,KACX5O,EAAU75B,KAAKs5B,SACfI,EAAW15B,KAAK25B,UACtB,IAAe5jC,EAAXyF,EAAQ,EACZ,KAAMA,EAAOzF,KAAUqkC,OACLn4B,IAAVlM,EACA8jC,EAAQt/B,IAAIiB,EAAO,IAEnBq+B,EAAQt/B,IAAIiB,EAAOzF,EAAMoF,QACzBu+B,EAAS15B,KAAMxE,EAAOktC,EAAIpyC,KAAKP,MC9BxC,MAAM4yC,WAAoEnQ,GAAjFv5B,kCACce,KAAAyoC,KAAO,IAAI9I,GACd1gC,SAASzD,EAAezF,GAC3BkL,MAAMy4B,SAASl+B,EAAOwE,KAAKyoC,KAAKnyC,KAAKP,IAElCkJ,SAASo1B,EAAmBh/B,EAAO,KACtC,GAAI2K,KAAKq5B,YAAc,EACnB,MAAU56B,MAAM,iDAEpB,MAAMmqC,EAAa5oC,KAAKoyB,SAASzwB,KAAK0yB,GAEtC,OADAr0B,KAAKyS,KAAO,IAAIsiB,GAAc/0B,KAAKyS,KAAKoN,SAAU,IAAIwmB,GAAMhxC,EAAMg/B,EAAM5hB,MAAM,IACvEm2B,EAEJ3pC,QAEH,OADAe,KAAKyoC,KAAK5hC,QACH5F,MAAM4F,SCZd,MAAMgiC,WAAoF3O,GAGtFj7B,IAAIzD,EAAezF,GACtB,OAAOkL,MAAM1G,IAAIiB,EAAOzF,GAGrBkJ,SAASzD,EAAezF,GAC3BA,EAAQA,aAAiBkqB,IAAMlqB,EAAQ,IAAIkqB,IAAIzqB,OAAO+xC,QAAQxxC,IAC9D,MAAMqkC,EAAUp6B,KAAKq6B,WAAar6B,KAAKq6B,SAAW,IAAIpa,KAChDqa,EAAUF,EAAQzkC,IAAI6F,GAC5B8+B,IAAYt6B,KAAKm6B,gBAAkBG,EAAQ7/B,MAC3CuF,KAAKm6B,gBAAkBpkC,EAAM0E,KAC7B2/B,EAAQ7/B,IAAIiB,EAAOzF,GAGhBkJ,SAASo1B,EAA8Ch/B,KAAU2K,KAAKq5B,eACzE,GAAIr5B,KAAKq5B,YAAc,EACnB,MAAU56B,MAAM,wCAIpB,OAFAuB,KAAKoyB,SAASpyB,KAAKq5B,aAAehF,EAClCr0B,KAAKyS,KAAO,IAAIuiB,GAAW,IAAIqR,GAAMhxC,EAAMg/B,EAAM5hB,MAAM,GAAOzS,KAAKyS,KAAKyN,YACjElgB,KAAKq5B,YAAc,EAGpBp6B,cAAcm7B,GACpB,MAAMP,EAAU75B,KAAKs5B,SACfI,EAAW15B,KAAK25B,UACtBS,EAAQL,QAAQ,CAAChkC,EAAOyF,UACNyG,IAAVlM,EACA8jC,EAAQt/B,IAAIiB,EAAO,IAEnBq+B,EAAQt/B,IAAIiB,EAAOzF,EAAM0E,MACzBi/B,EAAS15B,KAAMxE,EAAOzF,OCrC/B,MAAM+yC,WAAgFtQ,GAClFv5B,SAASo1B,EAAgBh/B,KAAU2K,KAAKq5B,eAC3C,MAAMuP,EAAa5oC,KAAKoyB,SAASzwB,KAAK0yB,GAEtC,OADAr0B,KAAKyS,KAAO,IAAI+hB,GAAO,IAAIx0B,KAAKyS,KAAK2f,SAAU,IAAIiU,GAAMhxC,EAAMg/B,EAAM5hB,MAAM,KACpEm2B,GCCR,MAAeG,WAAmDvQ,GAIrEv5B,YAAYsB,GACRU,MAAMV,GACNP,KAAKu5B,SAAW,IAAI3B,GAAkB,IAAI17B,UAAU,GAAI,GACX,mBAAlCqE,EAA4B,qBACnCP,KAAKgpC,oBAAsBzoC,EAA4B,oBAI/Dm0B,yBAAkC,OAAO10B,KAAKyS,KAAKiiB,mBAE5Cz1B,OAAOlJ,EAA4BkzC,GACtC,OAAOjpC,KAAKzF,IAAIyF,KAAK7E,OAAQpF,EAAOkzC,GAGjChqC,IAAIzD,EAAezF,EAA4BkzC,GAOlD,YANoBhnC,IAAhBgnC,IACAA,EAAcjpC,KAAKgpC,oBAAoBhpC,KAAMjK,EAAOyF,IAEpDwE,KAAKw5B,SAASh+B,EAAOwE,KAAKy5B,QAAQ1jC,KAClCiK,KAAK05B,SAASl+B,EAAOzF,EAAOkzC,GAEzBjpC,KAIJf,SAASzD,EAAezF,EAAoBkzC,GAC/CjpC,KAAKu5B,SAASh/B,IAAIiB,EAAOytC,GACzBhoC,MAAMy4B,SAASl+B,EAAOzF,GAInBkJ,SAASo1B,EAAgBh/B,KAAU2K,KAAKoyB,SAASj3B,UACpD,MAAM8tC,EAAcjpC,KAAKoyB,SAASzwB,KAAK0yB,IAC/B5hB,MAAM2f,SAAEA,EAAQn8B,KAAEA,EAAIk8B,QAAEA,IAAcnyB,KACxCqxB,EAAS,IAAIe,EAAU,IAAIiU,GAAMhxC,EAAMg/B,EAAM5hB,OAEnD,OADAzS,KAAKyS,KAAW,IAAIgiB,GAAMx+B,EAAM,IAAIk8B,EAAS8W,GAAc5X,GACpD4X,EAKDhqC,oBAAoB+f,EAAiCjpB,EAAYwF,GACvE,MAAUkD,MAAM,sNAOjB,MAAMyqC,WAA+DH,IAErE,MAAMI,WAA6DJ,GAItE9pC,YAAYsB,GACRU,MAAMV,GACNP,KAAKs5B,SAAW,IAAI1B,GAAkB,IAAIx7B,WAAW,IAIlD6C,SAASzD,EAAezF,EAAoBkzC,GAC/C,MAAML,EAAa5oC,KAAKyS,KAAKiiB,mBAAmBuU,GAEhD,OADAjpC,KAAKs5B,SAAS/+B,IAAIiB,EAAOwE,KAAKshC,WAAWsH,GAAaztC,QAC/C8F,MAAMy4B,SAASl+B,EAAOzF,EAAOkzC,ICLrC,MAAMG,WAAmB/d,GAGhC,MAEMge,GAA+B,CAAC32B,EAAkBlX,EAAe8tC,KACnE52B,EAAKlX,GAAU8tC,EAAU,WAAc,EACvC52B,EAAKlX,EAAQ,GAAM8tC,EAAU,WAAc,GAczCC,GAAwB,CAACtf,EAAoB5sB,EAA0B7B,EAAezF,KACxF,MAAQkJ,CAACzD,GAAQR,EAAGiE,CAACzD,EAAQ,GAAIP,GAAMoC,EAC9B,MAALrC,GAAkB,MAALC,GACbgvB,EAAO1vB,IAAIxE,EAAM2F,SAAS,EAAGT,EAAID,GAAIA,IAgBvCwuC,GAAqB,EAA8Bvf,UAAiCzuB,EAAezF,KArChF,EAAC2c,EAAkBlX,EAAe8tC,KAAsB52B,EAAKlX,GAAU8tC,EAAU,MAAY,GAqCkBG,CAAiBxf,EAAQzuB,EAAOzF,EAAM2nC,YAExKgM,GAAqB,EAA8Bzf,UAAiCzuB,EAAezF,KAA+BszC,GAA6Bpf,EAAgB,EAARzuB,EAAWzF,EAAM2nC,YAExLiM,GAAqB,EAA8BjU,SAAQzL,UAAyBzuB,EAAezF,KAA+Bk0B,EAAOyL,EAASl6B,GAASzF,GAE3J6zC,GAAqB,EAA8BlU,SAAQzL,UAAyBzuB,EAAezF,KAA+Bk0B,EAAOyL,EAASl6B,GAAS0gC,GAAgBnmC,IAE3K8zC,GAAqB,CAA4B7E,EAAuBxpC,EAAezF,KACzF,cAAeA,GACX,IAAK,SAAUivC,EAAO1G,SAAS9iC,GAASzF,EAAO,MAC/C,IAAK,SAAUivC,EAAO/a,OAAOzuB,EAAQwpC,EAAOtP,QAAU3/B,EAAO,MAC7D,QACI,MAAMyc,EAAMzc,GACN2/B,OAAEA,EAAMjD,UAAEA,GAAcuS,EACxB8E,EAAOt0C,OAAA6gC,GAAA,kBAAA7gC,CAA+Bi9B,EAAWjgB,GACvDwyB,EAAO/a,OAAO1vB,IAAIuvC,EAAKpuC,SAAS,EAAGg6B,GAASA,EAASl6B,KAqC3DuuC,GAA0B,EAAmC9f,UAAyBzuB,EAAezF,IAA6BszC,GAA6Bpf,EAAgB,EAARzuB,EAAWzF,EAAQ,KAE1Li0C,GAA0B,EAAmC/f,UAAyBzuB,EAAezF,IAA6BszC,GAA6Bpf,EAAgB,EAARzuB,EAAWzF,GAElLk0C,GAA0B,EAAmChgB,UAAyBzuB,EAAezF,IAvFtE,EAAC2c,EAAkBlX,EAAe8tC,KACnE52B,EAAKlX,GAAqB,IAAV8tC,EAAkB,WAAc,EAChD52B,EAAKlX,EAAQ,GAAiB,IAAV8tC,EAAkB,WAAc,GAqFgFY,CAA6BjgB,EAAgB,EAARzuB,EAAWzF,GAElLo0C,GAA0B,EAAmClgB,UAAyBzuB,EAAezF,IApFvE,EAAC2c,EAAkBlX,EAAe8tC,KAClE52B,EAAKlX,GAAqB,IAAV8tC,EAAqB,WAAc,EACnD52B,EAAKlX,EAAQ,GAAiB,IAAV8tC,EAAqB,WAAc,GAkF6Ec,CAA4BngB,EAAgB,EAARzuB,EAAWzF,GAajLs0C,GAAqB,EAA8BpgB,SAAQyL,UAAyBl6B,EAAezF,KAA+Bk0B,EAAOyL,EAASl6B,GAASzF,GAE3Ju0C,GAAqB,EAA8BrgB,SAAQyL,UAAyBl6B,EAAezF,KAA+Bk0B,EAAOyL,EAASl6B,GAASzF,GAE3Jw0C,GAAqB,EAA8BtgB,UAAiCzuB,EAAezF,KAA+Bk0B,EAAO1vB,IAAIxE,EAAM2F,SAAS,EAAG,GAAI,EAAIF,IAEvKgvC,GAAqB,EAA8BvgB,UAAiCzuB,EAAezF,KAA+Bk0B,EAAO1vB,IAAIxE,EAAM2F,SAAS,EAAG,GAAI,EAAIF,IA0DvKivC,GAAgB,CAAuBzF,EAAuBxpC,EAAezF,KAC/E,MAAM6yC,EAAa5D,EAAOtQ,mBAAmBsQ,EAAO7S,QAAQ32B,IACtD64B,EAAQ2Q,EAAO1D,WAAWsH,GAChCvU,GAASA,EAAM95B,IAAIyqC,EAAO3nC,aAAa7B,GAAQzF,IAI7C20C,GAAiB,CAAwB1F,EAAuBxpC,EAAezF,KACjF,MAAM6yC,EAAa5D,EAAOtQ,mBAAmBsQ,EAAO7S,QAAQ32B,IACtD64B,EAAQ2Q,EAAO1D,WAAWsH,GAChCvU,GAASA,EAAM95B,IAAIiB,EAAOzF,IAoBxB40C,GAAqB,EAA8B1gB,UAAyBzuB,EAAezF,KAA+Bk0B,EAAO1vB,IAAIxE,EAAM2F,SAAS,EAAG,GAAI,EAAIF,IAE/JovC,GAAuB,EAAgC3gB,UAAyBzuB,EAAezF,KAA+Bk0B,EAAOzuB,GAAqB,GAAXzF,EAAM,GAAYA,EAAM,GAAK,IAUlLqzC,GAAW1yC,UAAUw1B,UA7LL,GAAmB3wB,SAAQ0uB,UAAyBzuB,EAAegX,KAC/E,MAAMmiB,EAAMp5B,EAASC,EACrBgX,EAAOyX,EAAO0K,GAAO,IAAQ,GAAMA,EAAM,EAClC1K,EAAO0K,GAAO,MAAQ,GAAMA,EAAM,KA2L7CyU,GAAW1yC,UAAUy1B,SApJN,EAAgB6Y,EAAuBxpC,EAAezF,KACjEivC,EAAOvyB,KAAKsO,SAAW,GACjB4oB,GAAW3E,EAAiCxpC,EAAOzF,GACnD8zC,GAAa7E,EAAiCxpC,EAAOzF,KAkJ/DqzC,GAAW1yC,UAAU21B,UAAyCsd,GAC9DP,GAAW1yC,UAAU61B,WAAyCod,GAC9DP,GAAW1yC,UAAU+1B,WAAyCkd,GAC9DP,GAAW1yC,UAAUi2B,WAAuCkd,GAC5DT,GAAW1yC,UAAUm2B,WAAyC8c,GAC9DP,GAAW1yC,UAAUq2B,YAAyC4c,GAC9DP,GAAW1yC,UAAUu2B,YAAyC0c,GAC9DP,GAAW1yC,UAAUy2B,YAAuC0c,GAC5DT,GAAW1yC,UAAU22B,WArJJ,EAAkB2X,EAAuBxpC,EAAezF,KACrEivC,EAAOvyB,KAAK8O,YAAc/C,EAAU8C,KAC9BqoB,GAAW3E,EAAiCxpC,EAAOzF,GACnD6zC,GAAW5E,EAA+BxpC,EAAOzF,KAmJ3DqzC,GAAW1yC,UAAU62B,aAAyCqc,GAC9DR,GAAW1yC,UAAU+2B,aAAyCkc,GAC9DP,GAAW1yC,UAAUi3B,aAAyCgc,GAC9DP,GAAW1yC,UAAUk3B,UAvKL,GAAmB3D,SAAQ5sB,gBAA+B7B,EAAezF,KACrFwzC,GAAsBtf,EAAQ5sB,EAAc7B,EAAOhG,OAAA4V,GAAA,EAAA5V,CAAWO,MAuKlEqzC,GAAW1yC,UAAUm3B,YA1KH,GAAqB5D,SAAQ5sB,gBAA+B7B,EAAezF,IAAuBwzC,GAAsBtf,EAAQ5sB,EAAc7B,EAAOzF,IA2KvKqzC,GAAW1yC,UAAUo3B,qBA9KM,GAA8B4H,SAAQzL,UAAyBzuB,EAAezF,KAA+Bk0B,EAAO1vB,IAAIxE,EAAM2F,SAAS,EAAGg6B,GAASA,EAASl6B,KA+KvL4tC,GAAW1yC,UAAUq3B,UArJL,EAAmBiX,EAAuBxpC,EAAezF,KACrEivC,EAAOvyB,KAAK6Q,OAAS7E,EAASqS,IACxB0Y,GAAWxE,EAA+BxpC,EAAOzF,GACjD2zC,GAAmB1E,EAAuCxpC,EAAOzF,KAmJ3EqzC,GAAW1yC,UAAUu3B,aAAyCub,GAC9DJ,GAAW1yC,UAAUy3B,qBAAiCub,GACtDN,GAAW1yC,UAAU03B,eAxIW,EAAsB4W,EAAuBxpC,EAAezF,KACxF,OAAQivC,EAAOvyB,KAAK6Q,MAChB,KAAK5E,EAASoF,OAAa,OAAYimB,GAAmB/E,EAAuCxpC,EAAOzF,GACxG,KAAK2oB,EAAS2E,YAAa,OAAO2mB,GAAwBhF,EAA4CxpC,EAAOzF,GAC7G,KAAK2oB,EAASkS,YAAa,OAAOqZ,GAAwBjF,EAA4CxpC,EAAOzF,GAC7G,KAAK2oB,EAASmS,WAAa,OAAQsZ,GAAuBnF,EAA2CxpC,EAAOzF,MAoIpHqzC,GAAW1yC,UAAU43B,qBAAiCyb,GACtDX,GAAW1yC,UAAU83B,0BAA4Bwb,GACjDZ,GAAW1yC,UAAUg4B,0BAA4Bub,GACjDb,GAAW1yC,UAAUk4B,yBAA6Bub,GAClDf,GAAW1yC,UAAUm4B,UA1HM,EAAiBmW,EAAuBxpC,EAAezF,KAC9E,OAAQivC,EAAOvyB,KAAK6Q,MAChB,KAAK5E,EAASoF,OAAa,OAAYumB,GAAcrF,EAAkCxpC,EAAOzF,GAC9F,KAAK2oB,EAAS2E,YAAa,OAAOinB,GAAmBtF,EAAuCxpC,EAAOzF,GACnG,KAAK2oB,EAASkS,YAAa,OAAO2Z,GAAmBvF,EAAuCxpC,EAAOzF,GACnG,KAAK2oB,EAASmS,WAAa,OAAQ2Z,GAAkBxF,EAAsCxpC,EAAOzF,MAsH1GqzC,GAAW1yC,UAAUq4B,gBAAsCsb,GAC3DjB,GAAW1yC,UAAUu4B,qBAAiCqb,GACtDlB,GAAW1yC,UAAUy4B,qBAAiCob,GACtDnB,GAAW1yC,UAAU24B,oBAAkCmb,GACvDpB,GAAW1yC,UAAU44B,aArHF,GAAsBrF,UAAyBzuB,EAAezF,KAA+Bk0B,EAAO1vB,IAAIxE,EAAM2F,SAAS,EAAG,GAAI,EAAIF,KAsHrJ4tC,GAAW1yC,UAAU64B,UAnHL,EAAiByV,EAAuBxpC,EAAezF,KACnE,MAAMk0B,EAAS+a,EAAO1D,WAAW,GAAKjkC,EAAe2nC,EAAO3nC,aAC5D,IAAK,IAAIs3B,GAAO,EAAGkW,EAAMxtC,EAAa7B,GAAQ0Z,EAAM7X,EAAa7B,EAAQ,GAAIqvC,EAAM31B,GAC/E+U,EAAO1vB,IAAIswC,IAAO90C,EAAMJ,MAAMg/B,MAiHtCyU,GAAW1yC,UAAU+4B,YA/FH,EAAmBuV,EAAuBxpC,EAAezF,KAEvE,MAAM2jC,EAAW3jC,aAAiBkqB,IALI,EAAC1qB,EAAWqrC,IAAwB,CAACzrC,EAAkBq8B,EAAUtvB,IAAc/M,GAAKA,EAAEoF,IAAIhF,EAAGqrC,EAAEjrC,IAAI67B,EAAEn8B,OAKhGy1C,CAAmBtvC,EAAOzF,GACpDA,aAAiBqoB,EAPO,EAAC7oB,EAAWqrC,IAAc,CAACzrC,EAAkB+M,EAAUpN,IAAcK,GAAKA,EAAEoF,IAAIhF,EAAGqrC,EAAEjrC,IAAIb,IAOvFi2C,CAAsBvvC,EAAOzF,GACvD4Y,MAAMC,QAAQ7Y,GATS,EAACR,EAAWqrC,IAAa,CAACzrC,EAAkB+M,EAAUpN,IAAcK,GAAKA,EAAEoF,IAAIhF,EAAGqrC,EAAE9rC,IASjFk2C,CAAqBxvC,EAAOzF,GAN9B,EAACR,EAAWqrC,IAA8B,CAACzrC,EAAkBq8B,EAAUtvB,IAAc/M,GAAKA,EAAEoF,IAAIhF,EAAGqrC,EAAEpP,EAAEn8B,OAOrG41C,CAAsBzvC,EAAOzF,GAExEivC,EAAOvyB,KAAK2f,SAAS2H,QAAQ,CAACvI,EAAU18B,IAAc4kC,EAASsL,EAAO1D,WAAWxsC,GAAI08B,EAAG18B,MAyF5Fs0C,GAAW1yC,UAAUg5B,WApFJ,EAEfsV,EAAWxpC,EAAezF,KACxBivC,EAAOvyB,KAAKxc,OAASsoB,EAAUyS,MAC3ByZ,GAAczF,EAAkCxpC,EAAOzF,GACvD20C,GAAe1F,EAAmCxpC,EAAOzF,KAgFjEqzC,GAAW1yC,UAAUk5B,gBAAsC6a,GAC3DrB,GAAW1yC,UAAUo5B,iBAAqC4a,GAC1DtB,GAAW1yC,UAAUs5B,gBAhEC,EAAuBgV,EAAuBxpC,EAAezF,KAC/E,MAAMM,EAAM2uC,EAAOlD,OAAOtmC,GACd,OAARnF,GACA2uC,EAAOtL,SAASrjC,EAAKN,KA8D7BqzC,GAAW1yC,UAAUu5B,cAxDI,EAAqB+U,EAAuBxpC,EAAezF,KAC/EivC,EAAOvyB,KAAK6Q,OAAS3E,EAAaoS,SAC7B4Z,GAAmB3F,EAAuCxpC,EAAOzF,GACjE60C,GAAqB5F,EAAyCxpC,EAAOzF,KAsD/EqzC,GAAW1yC,UAAUy5B,qBAAiCwa,GACtDvB,GAAW1yC,UAAU25B,uBAA+Bua,GACpDxB,GAAW1yC,UAAU45B,mBA/CI,EAA0B0U,EAAuBxpC,EAAezF,KACrF,MAAMs+B,EAAQ2Q,EAAO1D,WAAW,IAAK5L,OAAEA,GAAWsP,EAClD,IAAK,IAAIrQ,GAAO,EAAGp5B,EAASC,EAAQk6B,IAAUf,EAAMe,GAChDrB,EAAM95B,IAAIgB,EAASo5B,EAAK5+B,EAAMJ,IAAIg/B,MA6C1CyU,GAAW1yC,UAAU65B,SArHN,EAAiByU,EAAuBxpC,EAAezF,KAClE,MAAMk0B,EAAS+a,EAAO1D,WAAW,GAAKjkC,EAAe2nC,EAAO3nC,aACtDkqC,EAAUxxC,aAAiBkqB,IAAM,IAAIlqB,GAASP,OAAO+xC,QAAQxxC,GACnE,IAAK,IAAI4+B,GAAO,EAAGkW,EAAMxtC,EAAa7B,GAAQ0Z,EAAM7X,EAAa7B,EAAQ,GAAIqvC,EAAM31B,GAC/E+U,EAAO1vB,IAAIswC,IAAOtD,IAAU5S,MAoH7B,MAAMuW,GAAW,IAAI9B,GC/PrB,MAAM+B,GAAW,IA/CjB,cAA6B9f,EACzBpsB,YAA+B,OAAO07B,GACtC17B,YAA+B,OAAOy7B,GACtCz7B,WAA+B,OAAO++B,GACtC/+B,YAA+B,OAAOg/B,GACtCh/B,aAA+B,OAAOi/B,GACtCj/B,aAA+B,OAAOk/B,GACtCl/B,aAA+B,OAAOm/B,GACtCn/B,aAA+B,OAAOs/B,GACtCt/B,cAA+B,OAAOu/B,GACtCv/B,cAA+B,OAAOw/B,GACtCx/B,cAA+B,OAAOy/B,GACtCz/B,aAA+B,OAAOk9B,GACtCl9B,eAA+B,OAAOm9B,GACtCn9B,eAA+B,OAAOo9B,GACtCp9B,eAA+B,OAAOq9B,GACtCr9B,YAA+B,OAAOygC,GACtCzgC,cAA+B,OAAOwgC,GACtCxgC,uBAA+B,OAAOy8B,GACtCz8B,YAA+B,OAAO27B,GACtC37B,eAA+B,OAAO47B,GACtC57B,uBAA+B,OAAO67B,GACtC77B,iBAA+B,OAAOggC,GACtChgC,uBAA+B,OAAOigC,GACtCjgC,4BAA+B,OAAOkgC,GACtClgC,4BAA+B,OAAOmgC,GACtCngC,2BAA+B,OAAOogC,GACtCpgC,YAA+B,OAAO2/B,GACtC3/B,kBAA+B,OAAO4/B,GACtC5/B,uBAA+B,OAAO6/B,GACtC7/B,uBAA+B,OAAO8/B,GACtC9/B,sBAA+B,OAAO+/B,GACtC//B,eAA+B,OAAO87B,GACtC97B,YAA+B,OAAOupC,GACtCvpC,cAA+B,OAAO6pC,GACtC7pC,aAA+B,OAAO8pC,GACtC9pC,kBAA+B,OAAOkqC,GACtClqC,mBAA+B,OAAOiqC,GACtCjqC,kBAA+B,OAAO+7B,GACtC/7B,gBAA+B,OAAOqgC,GACtCrgC,uBAA+B,OAAOsgC,GACtCtgC,yBAA+B,OAAOugC,GACtCvgC,qBAA+B,OAAO0pC,GACtC1pC,WAA+B,OAAO4pC,KClF1C,IAAUuC,GCqCjB5S,GAAQQ,IAER,SAASqS,EAAkD9qC,GAEvD,MAAMkS,EAAOlS,EAAQkS,KACrB,MAAMuM,EAAU,IAAKmsB,GAAsBzf,WAAcjZ,EAArC,GAAJ,CAAkDlS,GAElE,GAAIkS,EAAK2f,UAAY3f,EAAK2f,SAASj3B,OAAS,EAAG,CAE3C,MAAMi3B,EAAW7xB,EAAkB,UAAK,GAClC+qC,EAAiB,CAAEzU,WAAct2B,EAAoB,YACrDgrC,EAAkB58B,MAAMC,QAAQwjB,GAChC,CAAElwB,EAAUpN,IAAcs9B,EAASt9B,IAAMw2C,EACzC,EAAIj2C,UAAkB+8B,EAAS/8B,IAASi2C,EAE9C74B,EAAK2f,SAAS2H,QAAQ,CAACrvB,EAAOlP,KAC1B,MAAMiX,KAAEA,GAAS/H,EACXuvB,EAAOsR,EAAgB7gC,EAAOlP,GACpCwjB,EAAQoT,SAASzwB,KAAK0pC,EAAW,IAAKpR,EAAMxnB,YAIpD,OAAOuM,GAGVxpB,OAAOirC,KAAK7hB,GACRlb,IAAK8nC,GAAW5sB,EAAK4sB,IACrBxU,OAAQwU,GAAmC,iBAANA,GAAkBA,IAAM5sB,EAAKgH,MAClEmU,QAAStJ,IACc0a,GAAsB1f,MAAMgF,GACpC/5B,UAAUijC,UAAYuR,GAAWxf,WAAW+E,KAG/DiP,GAAYhpC,UAAkBijC,UAAYuR,GAAWrd,YDtEtD,SAAiB3P,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GAC9B,MAAaotB,EAAbxsC,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,uBAAuBiH,EAA4BiD,GAC/C,OAAQA,GAAO,IAAIsiC,GAAQ1sB,OAAO7Y,EAAG2E,UAAU3E,EAAGgB,YAAchB,EAAGgB,WAAYhB,GAMnFjH,UACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAAkByE,KAAKkG,GAAIgE,UAAUlK,KAAKyM,OAASlR,GAAWwiB,EAA0BE,OAAOD,MAAMK,QAAQC,gBAAgBkK,GAOxIvpB,OAAOkK,GACH,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI4U,EAA0BE,OAAOD,MAAMK,QAAQwI,QAAQ9H,OAAO/e,KAAKkG,GAAI4G,WAAW9M,KAAKyM,OAASlR,GAASyE,KAAKkG,IAAO,KAQrJjH,aAAazD,EAAe2N,GACxB,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQqtB,OAAO3sB,OAAO/e,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,GAARC,EAAYwE,KAAKkG,IAAO,KAMzIjH,qBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,GAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAQlE0D,cAAczD,EAAe2N,GACzB,IAAI5N,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,GAAU4N,GAAO,IAAI+U,EAAID,OAAOD,MAAMK,QAAQqtB,OAAO3sB,OAAO/e,KAAKkG,GAAI6G,SAAS/M,KAAKyM,OAASlR,GAAkB,GAARC,EAAYwE,KAAKkG,IAAO,KAMzIjH,sBACI,IAAI1D,EAASyE,KAAKkG,GAAIsG,SAASxM,KAAKyM,OAAQ,IAC5C,OAAOlR,EAASyE,KAAKkG,GAAI8G,aAAahN,KAAKyM,OAASlR,GAAU,EAMlE0D,mBAAmB+f,GACfA,EAAQxV,YAAY,GAOxBvK,kBAAkB+f,EAA8ByJ,GAC5CzJ,EAAQtW,cAAc,EAAG+f,EAAS1K,EAA0BE,OAAOD,MAAMK,QAAQC,gBAAgBkK,IAOrGvpB,iBAAiB+f,EAA8B2sB,GAC3C3sB,EAAQjW,eAAe,EAAG4iC,EAAc,GAO5C1sC,uBAAuB+f,EAA8B4sB,GACjD5sB,EAAQjW,eAAe,EAAG6iC,EAAoB,GAOlD3sC,+BAA+B+f,EAA8ByB,GACzDzB,EAAQlU,YAAY,GAAI2V,EAAU,GAOtCxhB,wBAAwB+f,EAA8B6sB,GAClD7sB,EAAQjW,eAAe,EAAG8iC,EAAqB,GAOnD5sC,gCAAgC+f,EAA8ByB,GAC1DzB,EAAQlU,YAAY,GAAI2V,EAAU,GAOtCxhB,iBAAiB+f,GAEb,OADaA,EAAQtV,YAQzBzK,0BAA0B+f,EAA8BzjB,GACpDyjB,EAAQ7U,OAAO5O,GAGnB0D,oBAAoB+f,EAA8ByJ,EAAyEkjB,EAAkCC,EAAwCC,GAMjM,OALAJ,EAAOK,YAAY9sB,GACnBysB,EAAO3iB,WAAW9J,EAASyJ,GAC3BgjB,EAAOM,UAAU/sB,EAAS2sB,GAC1BF,EAAOO,gBAAgBhtB,EAAS4sB,GAChCH,EAAOQ,iBAAiBjtB,EAAS6sB,GAC1BJ,EAAOS,UAAUltB,IA3JnBX,EAAAotB,OAAMA,EADW,CAAAztB,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBmtB,QAAG,KAmKpB,SAAiBltB,IAAI,SAAAD,IAAO,SAAAD,IAAM,SAAAK,GACjBA,EAAAqtB,MAAb,MAAAzsC,cACIe,KAAAkG,GAAoC,KAEpClG,KAAAyM,OAAiB,EAMjBxN,OAAOnK,EAAWoR,GAGd,OAFAlG,KAAKyM,OAAS3X,EACdkL,KAAKkG,GAAKA,EACHlG,KAQXf,SACI,OAAOe,KAAKkG,GAAI2F,UAAU7L,KAAKyM,QAQnCxN,iBACI,OAAOe,KAAKkG,GAAI2E,UAAU7K,KAAKyM,OAAS,GAS5CxN,aACI,OAAOe,KAAKkG,GAAI2F,UAAU7L,KAAKyM,OAAS,IAU5CxN,mBAAmB+f,EAA8BzjB,EAA0B4wC,EAAwBvjB,GAM/F,OALA5J,EAAQ7X,KAAK,EAAG,IAChB6X,EAAQnX,WAAW+gB,GACnB5J,EAAQxX,IAAI,GACZwX,EAAQpX,WAAWukC,GACnBntB,EAAQnX,WAAWtM,GACZyjB,EAAQzjB,WAzDO,CAAAyiB,EAAAK,UAAAL,EAAAK,QAAO,KAAb,CAAAJ,EAAAD,QAAAC,EAAAD,MAAK,KAAZ,CAAAE,EAAAD,SAAAC,EAAAD,OAAM,KAA3B,CAAiBmtB,QAAG,iBExJb5lC,GAAOb,GAAA,EAAYa,KACnB4mC,GAAUznC,GAAA,EAAYoB,QACtBzM,GAAaqL,GAAA,EAAYrL,WACzB+yC,GAASjB,GAAUntB,OAAOD,MAAMK,QAAQqtB,MACxCY,GAAUlB,GAAUntB,OAAOD,MAAMK,QAAQotB,OAQhD,MAAMc,GA0CFttC,YAAmBgB,EACAwoB,EAA2BnK,EAAgBkuB,GAClDC,EAA6BC,GAFtB1sC,KAAAC,SACAD,KAAAyoB,UAEfgkB,IAAkBzsC,KAAK2sC,eAAiBF,GACxCC,IAAsB1sC,KAAK4sC,mBAAqBF,GA3C7CztC,cAAcwU,GACjBA,EAAM,IAAIna,GAAW9D,OAAA6gC,GAAA,aAAA7gC,CAAaie,IAClC,MAAMo5B,EAASP,GAAQQ,gBAAgBr5B,GACjCxT,EAASynC,GAAO75B,OAAOg/B,EAAO5sC,UACpC,OAAO,IAAI8sC,GAAc9sC,EAAQ4sC,GAI9B5tC,cAAc4tC,GAEjB,MAAMvxC,EAAa,IAAI8wC,GACjBT,EAAejE,GAAO15B,OAAO1S,EAAGuxC,EAAO5sC,QAE7CqsC,GAAQU,yBAAyB1xC,EAAGuxC,EAAOI,kBAC3C,IAAIJ,EAAOJ,iBAAiB9wC,QAAQ8hC,UAAU1D,QAASmT,GAAOC,GAAUn/B,OAAO1S,EAAG4xC,IAClF,MAAMrB,EAAsBvwC,EAAE4P,YAE9BohC,GAAQc,wBAAwB9xC,EAAGuxC,EAAOQ,iBAC1C,IAAIR,EAAOH,qBAAqB/wC,QAAQ8hC,UAAU1D,QAASuT,GAAOH,GAAUn/B,OAAO1S,EAAGgyC,IAEtF,MAAMC,EAA0BjyC,EAAE4P,YASlC,OAPAohC,GAAQR,YAAYxwC,GACpBgxC,GAAQP,UAAUzwC,EAAGqwC,GACrBW,GAAQxjB,WAAWxtB,EAAGgjB,EAAgBkuB,IACtCF,GAAQL,iBAAiB3wC,EAAGuwC,GAC5BS,GAAQN,gBAAgB1wC,EAAGiyC,GAC3BjB,GAAQkB,mBAAmBlyC,EAAGgxC,GAAQJ,UAAU5wC,IAEzCA,EAAE2L,eAObgmC,uBAAgC,OAAOjtC,KAAK2sC,eAAexxC,OAC3DkyC,sBAA+B,OAAOrtC,KAAK4sC,mBAAmBzxC,OASvD8D,iBACH,IAAK,IAAIwuC,EAAO34C,GAAK,EAAGyB,EAAIyJ,KAAKitC,mBAAoBn4C,EAAIyB,IACjDk3C,EAAQztC,KAAK0tC,eAAe54C,YAAY24C,GAI7CxuC,qBACH,IAAK,IAAIwuC,EAAO34C,GAAK,EAAGyB,EAAIyJ,KAAKqtC,kBAAmBv4C,EAAIyB,IAChDk3C,EAAQztC,KAAK2tC,mBAAmB74C,YAAY24C,GAIjDxuC,eAAezD,GAClB,OAAOA,GAAS,GACTA,EAAQwE,KAAKitC,kBACbjtC,KAAK2sC,eAAenxC,IAAU,KAGlCyD,mBAAmBzD,GACtB,OAAOA,GAAS,GACTA,EAAQwE,KAAKqtC,iBACbrtC,KAAK4sC,mBAAmBpxC,IAAU,MAOjD,MAAMuxC,WAAsBR,GAKxBttC,YAAYgB,EAA0B2tC,GAClC3sC,MAAMhB,EAAQ2tC,EAAQnlB,WADYzoB,KAAA4tC,UAHtCX,uBAAgC,OAAOjtC,KAAK4tC,QAAQC,sBACpDR,sBAA+B,OAAOrtC,KAAK4tC,QAAQE,qBAM5C7uC,eAAezD,GAClB,GAAIA,GAAS,GAAKA,EAAQwE,KAAKitC,iBAAkB,CAC7C,MAAMc,EAAY/tC,KAAK4tC,QAAQnB,cAAcjxC,GAC7C,GAAIuyC,EAAa,OAAOZ,GAAUt/B,OAAOkgC,GAE7C,OAAO,KAGJ9uC,mBAAmBzD,GACtB,GAAIA,GAAS,GAAKA,EAAQwE,KAAKqtC,gBAAiB,CAC5C,MAAMU,EAAY/tC,KAAK4tC,QAAQztC,aAAa3E,GAC5C,GAAIuyC,EAAa,OAAOZ,GAAUt/B,OAAOkgC,GAE7C,OAAO,MAKR,MAAMZ,GAGFluC,cAAcwuC,GACjB,OAAO,IAAIN,GAAUM,EAAMtB,iBAAkBsB,EAAM7kB,aAAc6kB,EAAMlyC,UAIpE0D,cAAc3D,EAAYyyC,GAC7B,MAAM5B,eAAEA,GAAmB4B,EACrBxyC,EAAS,IAAIiK,GAAKuoC,EAAUxyC,OAAQ,GACpCqtB,EAAa,IAAIpjB,GAAKuoC,EAAUnlB,WAAY,GAClD,OAAOyjB,GAAO2B,YAAY1yC,EAAGC,EAAQ4wC,EAAgBvjB,GAOzD3pB,YAAYktC,EAAwBvjB,EAA2BrtB,GAC3DyE,KAAKmsC,eAAiBA,EACtBnsC,KAAKzE,OAA2B,iBAAXA,EAAsBA,EAASA,EAAOkK,IAC3DzF,KAAK4oB,WAAmC,iBAAfA,EAA0BA,EAAaA,EAAWnjB,iBC9H5E,MAAMwoC,WAAoEC,GAAA,EACtEjvC,MAAMlJ,GACT,IAAKA,EAAQP,OAAA6gC,GAAA,aAAA7gC,CAAaO,IAAQ+D,WAAa,EAC3C,OAAOmH,MAAMkR,MAAMpc,GAKpBkJ,SAASkvC,GAAO,GACnB,OAAOA,EACD34C,OAAA4V,GAAA,EAAA5V,CAAWwK,KAAK1I,cAAa,IAC7B0I,KAAK1I,cAAa,GAAOkI,KAAK4L,GAAA,GAIjCnM,aAAakvC,GAAO,GACvB,OAAOA,EAAO34C,OAAA6gC,GAAA,gBAAA7gC,CAAgBwK,KAAKkB,SAAkB,GAAK,WACtD,IAAInE,EAAU,GAAIjD,EAAa,EAC/B,UAAW,MAAM4qC,KAAS1kC,KACtBjD,EAAQ4E,KAAK+iC,GACb5qC,GAAc4qC,EAAM5qC,WAExB,OAAOtE,OAAA6gC,GAAA,gBAAA7gC,CAAgBuH,EAASjD,GAAY,IANU,IAY3D,MAAMs0C,GAGTnvC,YAAYtF,GACJA,IACAqG,KAAKrG,OAAS,IAAI00C,GAAiBC,EAAA,EAAe/rC,aAAa5I,KAGvEsF,CAACpJ,OAAO8G,YAAc,OAAOqD,KACtBf,KAAKlJ,GAAe,OAAOiK,KAAKrG,OAAOiD,KAAK7G,GAC5CkJ,MAAMlJ,GAAe,OAAOiK,KAAKrG,OAAOmJ,MAAM/M,GAC9CkJ,OAAOlJ,GAAe,OAAOiK,KAAKrG,OAAO8H,OAAO1L,GAChDkJ,KAAKxE,GAAwB,OAAOuF,KAAKrG,OAAO40C,KAAK9zC,GACrDwE,KAAKxE,GAAwB,OAAOuF,KAAKrG,OAAO6K,KAAK/J,IAIzD,MAAM+zC,GAGTvvC,YAAYtF,GACJA,aAAkB60C,GAClBxuC,KAAKrG,OAAUA,EAA2BA,OACnCA,aAAkBs0C,GACzBjuC,KAAKrG,OAAS,IAAI80C,GAAsBH,EAAA,EAAevrC,kBAAkBpJ,IAClEnE,OAAAyhC,GAAA,EAAAzhC,CAAqBmE,GAC5BqG,KAAKrG,OAAS,IAAI80C,GAAsBH,EAAA,EAAenrC,eAAexJ,IAC/DnE,OAAAyhC,GAAA,EAAAzhC,CAA0CmE,GACjDqG,KAAKrG,OAAS,IAAI80C,GAAsBH,EAAA,EAAetrC,cAAcrJ,IAC9DnE,OAAAyhC,GAAA,EAAAzhC,CAAgBmE,GACvBqG,KAAKrG,OAAS,IAAI80C,GAAsBH,EAAA,EAAetrC,cAAcrJ,EAAO+0C,OACrEl5C,OAAAyhC,GAAA,EAAAzhC,CAAiCmE,GACxCqG,KAAKrG,OAAS,IAAI80C,GAAsBH,EAAA,EAAe/rC,aAAa5I,IAC7DnE,OAAAyhC,GAAA,EAAAzhC,CAAgCmE,GACvCqG,KAAKrG,OAAS,IAAI80C,GAAsBH,EAAA,EAAevrC,kBAAkBpJ,IAClEnE,OAAAyhC,GAAA,EAAAzhC,CAAsCmE,KAC7CqG,KAAKrG,OAAS,IAAI80C,GAAsBH,EAAA,EAAevrC,kBAAkBpJ,KAGjFsF,CAACpJ,OAAOuH,iBAAmB,OAAO4C,KAC3Bf,KAAKlJ,GAAe,OAAOiK,KAAKrG,OAAOiD,KAAK7G,GAC5CkJ,MAAMlJ,GAAe,OAAOiK,KAAKrG,OAAOmJ,MAAM/M,GAC9CkJ,OAAOlJ,GAAe,OAAOiK,KAAKrG,OAAO8H,OAAO1L,GACvDwL,aAAqC,OAAOvB,KAAKrG,OAAO4H,OACjDtC,OAAOuC,GAAgB,OAAOxB,KAAKrG,OAAOg1C,OAAOntC,GACjDvC,KAAKxE,GAAwB,OAAOuF,KAAKrG,OAAO40C,KAAK9zC,GACrDwE,KAAKxE,GAAwB,OAAOuF,KAAKrG,OAAO6K,KAAK/J,IAchE,MAAM4zC,GACFpvC,YAAsBtF,GAAAqG,KAAArG,SACfsF,OAAOuC,GAAgBxB,KAAKyB,OAAOD,GACnCvC,KAAKxE,GAAkC,OAAOuF,KAAKpD,KAAKnC,EAAM,QAAQ1E,MACtEkJ,KAAKxE,GAAkC,OAAOuF,KAAKpD,KAAKnC,EAAM,QAAQ1E,MACtEkJ,KAAKxE,EAAsB+H,EAAuB,QAAU,OAAOxC,KAAKrG,OAAOiD,KAAK,CAAE4F,MAAK/H,SAC3FwE,MAAMlJ,GAAe,OAAOP,OAAOY,OAAQ4J,KAAKrG,OAAOmJ,OAAS9C,KAAKrG,OAAOmJ,MAAM/M,IAAWm4C,GAAA,GAC7FjvC,OAAOlJ,GAAe,OAAOP,OAAOY,OAAQ4J,KAAKrG,OAAO8H,QAAUzB,KAAKrG,OAAO8H,OAAO1L,IAAWm4C,GAAA,IAI3G,MAAMO,GAIFxvC,YAAuBtF,GAAAqG,KAAArG,SACnBqG,KAAKoB,eAAiB,IAAIC,QAASzL,GAAMoK,KAAKsB,sBAAwB1L,GAEnEqJ,aAAauC,SAAsBxB,KAAKyB,OAAOD,GACtDD,aAAqC,OAAOvB,KAAKoB,eAC1CnC,WAAWxE,GAA2C,aAAcuF,KAAKpD,KAAKnC,EAAM,SAAS1E,MAC7FkJ,WAAWxE,GAA2C,aAAcuF,KAAKpD,KAAKnC,EAAM,SAAS1E,MAC7FkJ,WAAWxE,EAAsB+H,EAAuB,QAAU,aAAcxC,KAAKrG,OAAOiD,KAAK,CAAE4F,MAAK/H,SACxGwE,YAAYlJ,GACf,MAAM4E,EAAUqF,KAAKrG,OAAOmJ,aAAe9C,KAAKrG,OAAOmJ,MAAM/M,IAAWm4C,GAAA,EAGxE,OAFAluC,KAAKsB,uBAAyBtB,KAAKsB,wBACnCtB,KAAKsB,2BAAwBW,EACtBzM,OAAOY,OAAOuE,GAElBsE,aAAalJ,GAChB,MAAM4E,EAAUqF,KAAKrG,OAAO8H,cAAgBzB,KAAKrG,OAAO8H,OAAO1L,IAAWm4C,GAAA,EAG1E,OAFAluC,KAAKsB,uBAAyBtB,KAAKsB,wBACnCtB,KAAKsB,2BAAwBW,EACtBzM,OAAOY,OAAOuE,ICrItB,MAAMi0C,WAAyBR,GAIlCnvC,YAAY/E,EAA8BJ,GACtCmH,QAHGjB,KAAAkH,SAAmB,EAItBlH,KAAK9F,OAAS1E,OAAA6gC,GAAA,aAAA7gC,CAAa0E,GAC3B8F,KAAKvF,UAA6B,IAAfX,EAA6BkG,KAAK9F,OAAOJ,WAAaA,EAEtEmF,UAAUiI,GACb,MAAMhN,OAAEA,EAAMC,WAAEA,GAAe6F,KAAK6uC,OAAO3nC,EAAU,GACrD,OAAO,IAAI6jB,SAAS7wB,EAAQC,GAAY20C,SAAS,GAAG,GAEjD7vC,KAAKiI,GAER,OADAlH,KAAKkH,SAAW7M,KAAKC,IAAI4M,EAAUlH,KAAKvF,MACjCyM,EAAWlH,KAAKvF,KAEpBwE,KAAKoe,GACR,MAAMnjB,OAAEA,EAAMO,KAAEA,EAAIyM,SAAEA,GAAalH,KACnC,OAAI9F,GAAUgN,EAAWzM,GACC,iBAAX4iB,IAAuBA,EAAS5hB,KAC3CuE,KAAKkH,SAAW7M,KAAKC,IAAIG,EACpByM,EAAW7M,KAAKC,IAAIG,EAAOyM,EAAUmW,IACnCnjB,EAAOwB,SAASwL,EAAUlH,KAAKkH,WAEnC,KAEJjI,OAAOiI,EAAkBmW,GAC5B,MAAM5J,EAAMzT,KAAK9F,OACXgb,EAAM7a,KAAKC,IAAI0F,KAAKvF,KAAMyM,EAAWmW,GAC3C,OAAO5J,EAAMA,EAAI/X,SAASwL,EAAUgO,GAAO,IAAIjb,WAAWojB,GAEvDpe,QAAUe,KAAK9F,SAAW8F,KAAK9F,OAAS,MACxC+E,MAAMlJ,GAA6B,OAAdiK,KAAKoC,QAAgB,CAAEnF,MAAM,EAAMlH,SACxDkJ,OAAOlJ,GAA6B,OAAdiK,KAAKoC,QAAgB,CAAEnF,MAAM,EAAMlH,UAI7D,MAAMg5C,WAA8BP,GAMvCvvC,YAAY+vC,EAAkBl1C,GAC1BmH,QAJGjB,KAAAkH,SAAmB,EAKtBlH,KAAKivC,QAAUD,EACW,iBAAfl1C,EACPkG,KAAKvF,KAAOX,EAEZkG,KAAKq6B,SAAW,WACZr6B,KAAKvF,YAAcu0C,EAAKE,QAAQz0C,YACzBuF,KAAKq6B,UAFA,GAMjBp7B,gBAAgBiI,GACnB,MAAMhN,OAAEA,EAAMC,WAAEA,SAAqB6F,KAAK6uC,OAAO3nC,EAAU,GAC3D,OAAO,IAAI6jB,SAAS7wB,EAAQC,GAAY20C,SAAS,GAAG,GAEjD7vC,WAAWiI,GAGd,OAFAlH,KAAKq6B,gBAAkBr6B,KAAKq6B,SAC5Br6B,KAAKkH,SAAW7M,KAAKC,IAAI4M,EAAUlH,KAAKvF,MACjCyM,EAAWlH,KAAKvF,KAEpBwE,WAAWoe,GACdrd,KAAKq6B,gBAAkBr6B,KAAKq6B,SAC5B,MAAQ4U,QAASD,EAAIv0C,KAAEA,EAAIyM,SAAEA,GAAalH,KAC1C,GAAIgvC,GAAQ9nC,EAAWzM,EAAM,CACH,iBAAX4iB,IAAuBA,EAAS5hB,KAC3C,IAAIqb,EAAM5P,EAAU3L,EAAS,EAAG4zC,EAAY,EACxCj6B,EAAM7a,KAAKC,IAAIG,EAAMqc,EAAMzc,KAAKC,IAAIG,EAAOqc,EAAKuG,IAChDnjB,EAAS,IAAID,WAAWI,KAAK6T,IAAI,GAAIlO,KAAKkH,SAAWgO,GAAO4B,IAChE,MAAQA,GAAOq4B,GAAaj6B,IAAQ3Z,GAAU4zC,GAAaj1C,EAAOJ,cAC3Dq1C,mBAAoBH,EAAKxqC,KAAKtK,EAAQqB,EAAQrB,EAAOJ,WAAayB,EAAQub,IAEjF,OAAO5c,EAEX,OAAO,KAEJ+E,aAAaiI,EAAkBmW,GAClCrd,KAAKq6B,gBAAkBr6B,KAAKq6B,SAC5B,MAAQ4U,QAASD,EAAIv0C,KAAEA,GAASuF,KAChC,GAAIgvC,GAAS9nC,EAAWmW,EAAU5iB,EAAM,CACpC,MACMP,EAAS,IAAID,WADPI,KAAKC,IAAIG,EAAMyM,EAAWmW,GACFnW,GACpC,aAAc8nC,EAAKxqC,KAAKtK,EAAQ,EAAGmjB,EAAQnW,IAAWhN,OAE1D,OAAO,IAAID,WAAWojB,GAEnBpe,cAAgB,MAAMuyB,EAAIxxB,KAAKivC,QAASjvC,KAAKivC,QAAU,KAAMzd,SAAWA,EAAEpvB,QAC1EnD,YAAYlJ,GAAmC,aAAdiK,KAAKoC,QAAgB,CAAEnF,MAAM,EAAMlH,SACpEkJ,aAAalJ,GAAmC,aAAdiK,KAAKoC,QAAgB,CAAEnF,MAAM,EAAMlH,UChGhF,MAAMq5C,GAAa,MAGnB,SAASC,GAASt5C,GAId,OAHIA,EAAQ,IACRA,EAAQ,WAAaA,EAAQ,QAErBA,EAAM+X,SAAS,MAI/B,MAAMwhC,GAAsB,EAEtBC,GAAe,CAAC,EACA,GACA,IACA,IACA,IACA,IACA,IACA,IACA,KAGf,MAAMC,GACTvwC,YAAuB/E,GAAA8F,KAAA9F,SAEhB+E,OAAiB,OAAOe,KAAK9F,OAAO,GACpC+E,MAAiB,OAAOe,KAAK9F,OAAO,GAEjC+E,OAAO6G,GAGb,MAAM2pC,EAAI,IAAInzC,YAAY,CACtB0D,KAAK9F,OAAO,KAAO,GACF,MAAjB8F,KAAK9F,OAAO,GACZ8F,KAAK9F,OAAO,KAAO,GACF,MAAjB8F,KAAK9F,OAAO,KAGVw1C,EAAI,IAAIpzC,YAAY,CACtBwJ,EAAM5L,OAAO,KAAO,GACF,MAAlB4L,EAAM5L,OAAO,GACb4L,EAAM5L,OAAO,KAAO,GACF,MAAlB4L,EAAM5L,OAAO,KAGjB,IAAIy1C,EAAUF,EAAE,GAAKC,EAAE,GACvB1vC,KAAK9F,OAAO,GAAe,MAAVy1C,EAEjB,IAAIllB,EAAMklB,IAAY,GAgBtB,OAbAllB,GADAklB,EAAUF,EAAE,GAAKC,EAAE,GAInBjlB,GADAklB,EAAWF,EAAE,GAAKC,EAAE,KAAQ,EAG5B1vC,KAAK9F,OAAO,IAAMuwB,GAAO,GAEzBzqB,KAAK9F,OAAO,GAAMuwB,IAAQ,EAAIklB,EAAUP,GAAa,EAErDpvC,KAAK9F,OAAO,IAAMuwB,IAAQ,GAC1BzqB,KAAK9F,OAAO,IAAMu1C,EAAE,GAAKC,EAAE,GAAKD,EAAE,GAAKC,EAAE,GAAKD,EAAE,GAAKC,EAAE,GACvD1vC,KAAK9F,OAAO,IAAOu1C,EAAE,GAAKC,EAAE,GAAKD,EAAE,GAAKC,EAAE,GAAKD,EAAE,GAAKC,EAAE,GAAKD,EAAE,GAAKC,EAAE,IAAO,GAEtE1vC,KAGDf,MAAM6G,GACZ,MAAM2kB,EAAOzqB,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,KAAQ,EACnD8F,KAAK9F,OAAO,IAAM4L,EAAM5L,OAAO,GAC3BuwB,EAAOzqB,KAAK9F,OAAO,KAAO,KAC1B8F,KAAK9F,OAAO,GAEhB8F,KAAK9F,OAAO,GAAKuwB,EAGdxrB,SAAS6G,GACZ,OAAO9F,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,IAChC8F,KAAK9F,OAAO,KAAO4L,EAAM5L,OAAO,IAAM8F,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,GAGtE+E,OAAO6G,GACV,OAAO9F,KAAK9F,OAAO,KAAO4L,EAAM5L,OAAO,IAAM8F,KAAK9F,OAAO,IAAM4L,EAAM5L,OAAO,GAGzE+E,YAAY6G,GACf,OAAOA,EAAM8pC,SAAS5vC,MAGnBf,MACH,SAAUowC,GAASrvC,KAAK9F,OAAO,OAAOm1C,GAASrvC,KAAK9F,OAAO,OAK5D,MAAM21C,WAAeL,GACjBvwC,MAAM6G,GAET,OADA9F,KAAK8vC,OAAOhqC,GACL9F,KAGJf,KAAK6G,GAER,OADA9F,KAAK+vC,MAAMjqC,GACJ9F,KAIJf,YAAYuT,EAAUw9B,EAAa,IAAI1zC,YAAY,IACtD,OAAOuzC,GAAOz9B,WACM,iBAAV,EAAqBI,EAAMA,EAAI1E,WACrCkiC,GAKD/wC,kBAAkBge,EAAa+yB,EAAa,IAAI1zC,YAAY,IAO/D,OAAOuzC,GAAOz9B,WAAW6K,EAAInP,WAAYkiC,GAItC/wC,kBAAkBqV,EAAa07B,EAAa,IAAI1zC,YAAY,IAC/D,MAAMnB,EAASmZ,EAAInZ,OAEnB,IAAI+c,EAAM,IAAI23B,GAAOG,GACrB,IAAK,IAAIC,EAAO,EAAGA,EAAO90C,GAAS,CAC/B,MAAM+0C,EAAQZ,GAAsBn0C,EAAS80C,EAC/BX,GAAsBn0C,EAAS80C,EACvCvL,EAAQ,IAAImL,GAAO,IAAIvzC,YAAY,CAAC2X,SAASK,EAAIJ,OAAO+7B,EAAMC,GAAQ,IAAK,KAC3EC,EAAW,IAAIN,GAAO,IAAIvzC,YAAY,CAACizC,GAAaW,GAAQ,KAElEh4B,EAAIk4B,MAAMD,GACVj4B,EAAIm4B,KAAK3L,GAETuL,GAAQC,EAGZ,OAAOh4B,EAIJjZ,oBAAoBgrB,GACvB,MAAMvX,EAAO,IAAIpW,YAA4B,EAAhB2tB,EAAO9uB,QACpC,IAAK,IAAIrG,GAAK,EAAGyB,EAAI0zB,EAAO9uB,SAAUrG,EAAIyB,GACtCs5C,GAAO5zC,KAAKguB,EAAOn1B,GAAI,IAAIwH,YAAYoW,EAAKxY,OAAQwY,EAAKvY,WAAa,EAAIrF,EAAI,EAAG,IAErF,OAAO4d,EAIJzT,gBAAgBqxC,EAAcC,GAEjC,OADW,IAAIV,GAAO,IAAIvzC,YAAYg0C,EAAKp2C,SAC/Bk2C,MAAMG,GAIftxC,WAAWqxC,EAAcC,GAE5B,OADW,IAAIV,GAAO,IAAIvzC,YAAYg0C,EAAKp2C,SAC/Bm2C,KAAKE,IAKlB,MAAMC,WAAchB,GAChBvwC,SAKH,OAJAe,KAAK9F,OAAO,GAAuB,GAAjB8F,KAAK9F,OAAO,GAC9B8F,KAAK9F,OAAO,IAAM8F,KAAK9F,OAAO,GAER,GAAlB8F,KAAK9F,OAAO,MAAa8F,KAAK9F,OAAO,GAClC8F,KAGJf,MAAM6G,GAET,OADA9F,KAAK8vC,OAAOhqC,GACL9F,KAGJf,KAAK6G,GAER,OADA9F,KAAK+vC,MAAMjqC,GACJ9F,KAGJf,SAAS6G,GAEZ,MAAM2qC,EAAYzwC,KAAK9F,OAAO,IAAM,EAC9Bw2C,EAAa5qC,EAAM5L,OAAO,IAAM,EACtC,OAAOu2C,EAAYC,GACdD,IAAcC,GAAc1wC,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,GAI5D+E,YAAYuT,EAAUw9B,EAAa,IAAI1zC,YAAY,IACtD,OAAOk0C,GAAMp+B,WACO,iBAAV,EAAqBI,EAAMA,EAAI1E,WACrCkiC,GAKD/wC,kBAAkBge,EAAa+yB,EAAa,IAAI1zC,YAAY,IAO/D,OAAOk0C,GAAMp+B,WAAW6K,EAAInP,WAAYkiC,GAIrC/wC,kBAAkBqV,EAAa07B,EAAa,IAAI1zC,YAAY,IAE/D,MAAMq0C,EAASr8B,EAAIs8B,WAAW,KACxBz1C,EAASmZ,EAAInZ,OAEnB,IAAI+c,EAAM,IAAIs4B,GAAMR,GACpB,IAAK,IAAIC,EAAOU,EAAS,EAAI,EAAGV,EAAO90C,GAAS,CAC5C,MAAM+0C,EAAQZ,GAAsBn0C,EAAS80C,EAC/BX,GAAsBn0C,EAAS80C,EACvCvL,EAAQ,IAAI8L,GAAM,IAAIl0C,YAAY,CAAC2X,SAASK,EAAIJ,OAAO+7B,EAAMC,GAAQ,IAAK,KAC1EC,EAAW,IAAIK,GAAM,IAAIl0C,YAAY,CAACizC,GAAaW,GAAQ,KAEjEh4B,EAAIk4B,MAAMD,GACVj4B,EAAIm4B,KAAK3L,GAETuL,GAAQC,EAEZ,OAAOS,EAASz4B,EAAIy4B,SAAWz4B,EAI5BjZ,oBAAoBgrB,GACvB,MAAMvX,EAAO,IAAIpW,YAA4B,EAAhB2tB,EAAO9uB,QACpC,IAAK,IAAIrG,GAAK,EAAGyB,EAAI0zB,EAAO9uB,SAAUrG,EAAIyB,GACtCi6C,GAAMv0C,KAAKguB,EAAOn1B,GAAI,IAAIwH,YAAYoW,EAAKxY,OAAQwY,EAAKvY,WAAa,EAAIrF,EAAI,EAAG,IAEpF,OAAO4d,EAIJzT,gBAAgBqxC,EAAaC,GAEhC,OADW,IAAIC,GAAM,IAAIl0C,YAAYg0C,EAAKp2C,SAC9Bk2C,MAAMG,GAIftxC,WAAWqxC,EAAaC,GAE3B,OADW,IAAIC,GAAM,IAAIl0C,YAAYg0C,EAAKp2C,SAC9Bm2C,KAAKE,IAKlB,MAAMM,GACT5xC,YAAqB/E,GAAA8F,KAAA9F,SAOd+E,OACH,OAAO,IAAIuxC,GAAM,IAAIl0C,YAAY0D,KAAK9F,OAAOA,OAAQ8F,KAAK9F,OAAOC,WAAa,EAAG,IAG9E8E,MACH,OAAO,IAAIuxC,GAAM,IAAIl0C,YAAY0D,KAAK9F,OAAOA,OAAQ8F,KAAK9F,OAAOC,WAAY,IAG1E8E,SASH,OARAe,KAAK9F,OAAO,GAAuB,GAAjB8F,KAAK9F,OAAO,GAC9B8F,KAAK9F,OAAO,IAAM8F,KAAK9F,OAAO,GAC9B8F,KAAK9F,OAAO,IAAM8F,KAAK9F,OAAO,GAC9B8F,KAAK9F,OAAO,IAAM8F,KAAK9F,OAAO,GAER,GAAlB8F,KAAK9F,OAAO,MAAa8F,KAAK9F,OAAO,GACnB,GAAlB8F,KAAK9F,OAAO,MAAa8F,KAAK9F,OAAO,GACnB,GAAlB8F,KAAK9F,OAAO,MAAa8F,KAAK9F,OAAO,GAClC8F,KAGJf,MAAM6G,GAGT,MAAMgrC,EAAK,IAAIjB,GAAO,IAAIvzC,YAAY,CAAC0D,KAAK9F,OAAO,GAAK,KAClD62C,EAAK,IAAIlB,GAAO,IAAIvzC,YAAY,CAAC0D,KAAK9F,OAAO,GAAK,KAClD82C,EAAK,IAAInB,GAAO,IAAIvzC,YAAY,CAAC0D,KAAK9F,OAAO,GAAK,KAClD+2C,EAAK,IAAIpB,GAAO,IAAIvzC,YAAY,CAAC0D,KAAK9F,OAAO,GAAK,KAElDg3C,EAAK,IAAIrB,GAAO,IAAIvzC,YAAY,CAACwJ,EAAM5L,OAAO,GAAI,KAClDi3C,EAAK,IAAItB,GAAO,IAAIvzC,YAAY,CAACwJ,EAAM5L,OAAO,GAAI,KAClDk3C,EAAK,IAAIvB,GAAO,IAAIvzC,YAAY,CAACwJ,EAAM5L,OAAO,GAAI,KAClDm3C,EAAK,IAAIxB,GAAO,IAAIvzC,YAAY,CAACwJ,EAAM5L,OAAO,GAAI,KAExD,IAAIy1C,EAAUE,GAAOyB,SAASL,EAAII,GAClCrxC,KAAK9F,OAAO,GAAKy1C,EAAQlqC,MAEzB,IAAIglB,EAAM,IAAIolB,GAAO,IAAIvzC,YAAY,CAACqzC,EAAQjqC,OAAQ,KAuBtD,OArBAiqC,EAAUE,GAAOyB,SAASN,EAAIK,GAC9B5mB,EAAI4lB,KAAKV,GAETA,EAAUE,GAAOyB,SAASL,EAAIG,GAC9B3mB,EAAI4lB,KAAKV,GAET3vC,KAAK9F,OAAO,GAAKuwB,EAAIhlB,MAErBzF,KAAK9F,OAAO,GAAMuwB,EAAImlB,SAASD,GAAW,EAAI,EAE9C3vC,KAAK9F,OAAO,GAAKuwB,EAAI/kB,OACV,IAAImqC,GAAO,IAAIvzC,YAAY0D,KAAK9F,OAAOA,OAAQ8F,KAAK9F,OAAOC,WAAa,EAAG,IAEjFk2C,KAAKR,GAAOyB,SAASP,EAAIM,IACzBhB,KAAKR,GAAOyB,SAASN,EAAII,IACzBf,KAAKR,GAAOyB,SAASL,EAAIE,IAC9BnxC,KAAK9F,OAAO,IAAM21C,GAAOyB,SAASR,EAAIO,GACrBhB,KAAKR,GAAOyB,SAASP,EAAIK,IACzBf,KAAKR,GAAOyB,SAASN,EAAIG,IACzBd,KAAKR,GAAOyB,SAASL,EAAIC,IAAKzrC,MAExCzF,KAGJf,KAAK6G,GACR,IAAIyrC,EAAO,IAAIj1C,YAAY,GAqB3B,OApBAi1C,EAAK,GAAMvxC,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,KAAQ,EACjDq3C,EAAK,GAAMvxC,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,KAAQ,EACjDq3C,EAAK,GAAMvxC,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,KAAQ,EACjDq3C,EAAK,GAAMvxC,KAAK9F,OAAO,GAAK4L,EAAM5L,OAAO,KAAQ,EAE7Cq3C,EAAK,GAAMvxC,KAAK9F,OAAO,KAAO,KAC5Bq3C,EAAK,GAEPA,EAAK,GAAMvxC,KAAK9F,OAAO,KAAO,KAC5Bq3C,EAAK,GAEPA,EAAK,GAAMvxC,KAAK9F,OAAO,KAAO,KAC5Bq3C,EAAK,GAGXvxC,KAAK9F,OAAO,GAAKq3C,EAAK,GACtBvxC,KAAK9F,OAAO,GAAKq3C,EAAK,GACtBvxC,KAAK9F,OAAO,GAAKq3C,EAAK,GACtBvxC,KAAK9F,OAAO,GAAKq3C,EAAK,GAEfvxC,KAGJf,MACH,SAAUowC,GAASrvC,KAAK9F,OAAO,OAAOm1C,GAASrvC,KAAK9F,OAAO,OAAOm1C,GAASrvC,KAAK9F,OAAO,OAAOm1C,GAASrvC,KAAK9F,OAAO,MAIhH+E,gBAAgBqxC,EAAcC,GAEjC,OADW,IAAIM,GAAO,IAAIv0C,YAAYg0C,EAAKp2C,SAC/Bk2C,MAAMG,GAIftxC,WAAWqxC,EAAcC,GAE5B,OADW,IAAIM,GAAO,IAAIv0C,YAAYg0C,EAAKp2C,SAC/Bm2C,KAAKE,GAIdtxC,YAAYuT,EAAUw9B,EAAa,IAAI1zC,YAAY,IACtD,OAAOu0C,GAAOz+B,WACM,iBAAV,EAAqBI,EAAMA,EAAI1E,WACrCkiC,GAKD/wC,kBAAkBge,EAAa+yB,EAAa,IAAI1zC,YAAY,IAO/D,OAAOu0C,GAAOz+B,WAAW6K,EAAInP,WAAYkiC,GAItC/wC,kBAAkBqV,EAAa07B,EAAa,IAAI1zC,YAAY,IAE/D,MAAMq0C,EAASr8B,EAAIs8B,WAAW,KACxBz1C,EAASmZ,EAAInZ,OAEnB,IAAI+c,EAAM,IAAI24B,GAAOb,GACrB,IAAK,IAAIC,EAAOU,EAAS,EAAI,EAAGV,EAAO90C,GAAS,CAC5C,MAAM+0C,EAAQZ,GAAsBn0C,EAAS80C,EAC/BX,GAAsBn0C,EAAS80C,EACvCvL,EAAQ,IAAImM,GAAO,IAAIv0C,YAAY,CAAC2X,SAASK,EAAIJ,OAAO+7B,EAAMC,GAAQ,IAAK,EAAG,EAAG,KACjFC,EAAW,IAAIU,GAAO,IAAIv0C,YAAY,CAACizC,GAAaW,GAAQ,EAAG,EAAG,KAExEh4B,EAAIk4B,MAAMD,GACVj4B,EAAIm4B,KAAK3L,GAETuL,GAAQC,EAGZ,OAAOS,EAASz4B,EAAIy4B,SAAWz4B,EAI5BjZ,oBAAoBgrB,GAEvB,MAAMvX,EAAO,IAAIpW,YAA4B,EAAhB2tB,EAAO9uB,QACpC,IAAK,IAAIrG,GAAK,EAAGyB,EAAI0zB,EAAO9uB,SAAUrG,EAAIyB,GACtCs6C,GAAO50C,KAAKguB,EAAOn1B,GAAI,IAAIwH,YAAYoW,EAAKxY,OAAQwY,EAAKvY,WAAa,GAAQrF,EAAG,IAErF,OAAO4d,GChZR,MAAM8+B,WAAqBnmB,EAO9BpsB,YAAYnD,EAAmBwvB,EAAoBvuB,EAAyBoD,GACxEc,QALIjB,KAAAyxC,YAAsB,EAEtBzxC,KAAA0xC,cAAwB,EAI5B1xC,KAAKlE,MAAQA,EACbkE,KAAKsrB,MAAQA,EACbtrB,KAAKjD,QAAUA,EACfiD,KAAKG,aAAeA,EAGjBlB,MAA0BusB,GAC7B,OAAOvqB,MAAMwqB,MAAMD,aAAgB6a,GAAQ7a,EAAK/Y,KAAO+Y,GAGpDvsB,UAAuDwT,GAAStX,OAAEA,GAAsB6E,KAAK2xC,iBAAmB,OAAkB7lB,GAAKhN,KAAKrM,EAAM,EAAGtX,GACrJ8D,UAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAkB7lB,GAAKlJ,KAAKnQ,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,SAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAmB7lB,GAAKhL,IAAIrO,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,WAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAiB7lB,GAAKsB,MAAM3a,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,UAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAkB7lB,GAAKnK,KAAKlP,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK8xC,YAAYr/B,GAAOzS,KAAK6xC,SAASp/B,IACpPxT,YAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAgB7lB,GAAKhK,OAAOrP,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK8xC,YAAYr/B,GAAOzS,KAAK6xC,SAASp/B,IACpPxT,qBAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAO7lB,GAAKvJ,gBAAgB9P,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,UAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAkB7lB,GAAK1I,KAAK3Q,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,eAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAa7lB,GAAKjI,UAAUpR,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,UAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAkB7lB,GAAKpI,KAAKjR,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,aAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAe7lB,GAAK/I,QAAQtQ,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,UAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAkB7lB,GAAKxM,KAAK7M,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK8xC,YAAYr/B,GAAOzS,KAAKyrB,MAAMhZ,EAAK2f,SAAS,KAC/PnzB,YAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAgB7lB,GAAK0D,OAAO/c,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK+xC,UAAUt/B,EAAK2f,WAClOnzB,WAAuDwT,GAAyD,OAAOA,EAAKxc,OAASsoB,EAAUgC,OAASvgB,KAAK8vB,iBAAiBrd,GAA4BzS,KAAK4vB,gBAAgBnd,GAC/NxT,gBAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAiB7lB,GAAKxL,MAAM7N,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAKgyC,YAAYv/B,GAAOzS,KAAK8xC,YAAYr/B,GAAOzS,KAAK+xC,UAAUt/B,EAAK2f,WAClRnzB,iBAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAiB7lB,GAAKxL,MAAM7N,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAKgyC,YAAYv/B,GAAOzS,KAAK+xC,UAAUt/B,EAAK2f,WAC1PnzB,gBAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAY7lB,GAAKiE,WAAWtd,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,EAAK6f,SAAUtyB,KAAKiyC,eAAex/B,IAC/PxT,cAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAc7lB,GAAK1H,SAAS3R,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK6xC,SAASp/B,IAC5NxT,mBAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAS7lB,GAAKlM,cAAcnN,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAKyrB,MAAMhZ,EAAK2f,SAAS,KACvOnzB,SAAuDwT,GAAStX,OAAEA,EAAMo6B,UAAEA,GAAcv1B,KAAK2xC,iBAAmB,OAAmB7lB,GAAK7L,IAAIxN,EAAM,EAAGtX,EAAQo6B,EAAWv1B,KAAK4xC,eAAen/B,EAAM8iB,GAAYv1B,KAAK8xC,YAAYr/B,GAAOzS,KAAKyrB,MAAMhZ,EAAK2f,SAAS,KAE5PnzB,gBAAkB,OAAOe,KAAKsrB,QAAQtrB,KAAKyxC,YAC3CxyC,kBAAoB,OAAOe,KAAKjD,UAAUiD,KAAK0xC,cAC/CzyC,eAAmCwT,EAAS8iB,EAAmBr7B,EAAS8F,KAAKkyC,mBACnF,OAAO3c,EAAY,GAAKv1B,KAAK6xC,SAASp/B,EAAMvY,IAAW,IAAID,WAAW,GAEhEgF,YAAgCwT,EAASvY,GAAyB,OAAO8F,KAAK6xC,SAASp/B,EAAMvY,GAC7F+E,YAAgCwT,EAASvY,GAAyB,OAAO8F,KAAK6xC,SAASp/B,EAAMvY,GAC7F+E,SAA6BilC,GAAU/oC,OAAEA,EAAMI,OAAEA,GAAWyE,KAAKkyC,mBACvE,OAAOlyC,KAAKlE,MAAMJ,SAASH,EAAQA,EAASJ,GAEtC8D,eAA0CwT,GAChD,OAAOzS,KAAKG,aAAaxK,IAAI8c,EAAK0S,KAKnC,MAAMgtB,WAAyBX,GAElCvyC,YAAYmzC,EAAkB9mB,EAAoBvuB,EAAyBoD,GACvEc,MAAM,IAAIhH,WAAW,GAAIqxB,EAAOvuB,EAASoD,GACzCH,KAAKoyC,QAAUA,EAETnzC,eAAmCilC,EAAU3O,GAAmBh6B,OAAEA,GAAWyE,KAAKkyC,mBACxF,OAAO3c,GAAa,EAAI,IAAIt7B,WAAW,GAAK8vB,EAAU/pB,KAAKoyC,QAAQ72C,IAE7D0D,YAAgCilC,GAAU3oC,OAAEA,GAAWyE,KAAKkyC,mBAClE,OAAO18C,OAAA6gC,GAAA,kBAAA7gC,CAAkByE,WAAYzE,OAAA6gC,GAAA,kBAAA7gC,CAAkB4G,WAAY4D,KAAKoyC,QAAQ72C,KAE1E0D,YAAgCwT,GAASlX,OAAEA,GAAWyE,KAAKkyC,mBACjE,OAAO18C,OAAA6gC,GAAA,kBAAA7gC,CAAkByE,WAAYzE,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAWzyB,KAAKoyC,QAAQ72C,KAE9E0D,SAA6BwT,GAASlX,OAAEA,GAAWyE,KAAKkyC,mBAC9D,MAAME,QAAEA,GAAYpyC,KACpB,OAAIgsB,EAASqmB,YAAY5/B,GACdjd,OAAA6gC,GAAA,kBAAA7gC,CAAkByE,WAAYu2C,GAAM8B,aAAaF,EAAQ72C,MACxDywB,EAASumB,MAAM9/B,IAASuZ,EAASwmB,OAAO//B,KAA4B,KAAlBA,EAAKsO,SACxDvrB,OAAA6gC,GAAA,kBAAA7gC,CAAkByE,WAAYu2C,GAAM8B,aAAaF,EAAQ72C,KACzDywB,EAASymB,OAAOhgC,IAASA,EAAK6Q,OAAS7E,EAAS4E,YAChD7tB,OAAA6gC,GAAA,kBAAA7gC,CAAkByE,WAAYu2C,GAAM8B,aAAaF,EAAQ72C,KACzDywB,EAAS0mB,UAAUjgC,GACnBjd,OAAA6gC,GAAA,kBAAA7gC,CAAkByE,WAAY42C,GAAOyB,aAAaF,EAAQ72C,KAC1DywB,EAAS2mB,SAASlgC,IAASuZ,EAAS4mB,kBAAkBngC,GAYzE,SAA4BwX,GAIxB,MAAM4oB,EAAS5oB,EAAOxS,KAAK,IACrB/E,EAAO,IAAIzY,WAAW44C,EAAO13C,OAAS,GAC5C,IAAK,IAAIrG,EAAI,EAAGA,EAAI+9C,EAAO13C,OAAQrG,GAAK,EACpC4d,EAAK5d,GAAK,GAAKmf,SAAS4+B,EAAO3+B,OAAOpf,EAAG,GAAI,IAEjD,OAAO4d,EApBQogC,CAAmBV,EAAQ72C,IAC3BywB,EAAS+mB,OAAOtgC,GAChBsX,EAAUqoB,EAAQ72C,IAClBywB,EAASgnB,OAAOvgC,GAChBjd,OAAA4V,GAAA,EAAA5V,CAAY48C,EAAQ72C,GAAqBkc,KAAK,KAElDjiB,OAAA6gC,GAAA,kBAAA7gC,CAAkByE,WAAYzE,OAAA6gC,GAAA,kBAAA7gC,CAAkBid,EAAKggB,UAAW2f,EAAQ72C,GAAQmI,IAAK1I,IAAOA,MC3G3G,IAAOi4C,GAAOtuC,GAAA,EAAYa,KAOnB0tC,GAAOn1B,EAAYE,OAAOD,MAAMK,QAAQS,KACxCgC,GAAM/C,EAAYE,OAAOD,MAAMK,QAAQyC,IACvCO,GAAgBtD,EAAYE,OAAOD,MAAMK,QAAQgD,cACjD8xB,GAASp1B,EAAYE,OAAOD,MAAMK,QAAQyD,OAC1CsxB,GAAOr1B,EAAYE,OAAOD,MAAMK,QAAQuE,KACxCywB,GAAOt1B,EAAYE,OAAOD,MAAMK,QAAQsD,KACxC2xB,GAAUv1B,EAAYE,OAAOD,MAAMK,QAAQ0E,QAC3CwwB,GAAOx1B,EAAYE,OAAOD,MAAMK,QAAQ+E,KACxCM,GAAO3F,EAAYE,OAAOD,MAAMK,QAAQqF,KACxCG,GAAY9F,EAAYE,OAAOD,MAAMK,QAAQwF,UAC7CO,GAAWrG,EAAYE,OAAOD,MAAMK,QAAQ+F,SAC5CovB,GAAOz1B,EAAYE,OAAOD,MAAMK,QAAQiB,KACxCm0B,GAAS11B,EAAYE,OAAOD,MAAMK,QAAQc,QAC1CmB,GAAQvC,EAAYE,OAAOD,MAAMK,QAAQiC,MACzC4E,GAAqBnH,EAAYE,OAAOD,MAAMK,QAAQ6G,mBACtDwuB,GAAkB31B,EAAYE,OAAOD,MAAMK,QAAQkE,gBACnDoxB,GAAgB51B,EAAYE,OAAOD,MAAMK,QAAQuB,cACjDg0B,GAAO71B,EAAYE,OAAOD,MAAMK,QAAQ4B,IAkHxC,MAAM4zB,GAAW,IA1GjB,cAA4BxoB,EACxBpsB,MAA+BusB,EAASxM,GAC3C,OAAgB,MAARwM,GAA2B,MAAXxM,OAAmB/c,EAAYhB,MAAMwqB,MAAMD,EAAMxM,GAEtE/f,UAA+BuxB,EAAUl1B,GAE5C,OADA43C,GAAKj0B,UAAU3jB,GACR43C,GAAKh0B,QAAQ5jB,GAEjB2D,SAA6BusB,EAASlwB,GAIzC,OAHAwlB,GAAIG,SAAS3lB,GACbwlB,GAAII,YAAY5lB,EAAGkwB,EAAKzK,UACxBD,GAAIK,YAAY7lB,EAAGkwB,EAAKxK,UACjBF,GAAIM,OAAO9lB,GAEf2D,WAAiCusB,EAASlwB,GAG7C,OAFA+lB,GAAcG,mBAAmBlmB,GACjC+lB,GAAcI,aAAanmB,EAAGkwB,EAAKjK,WAC5BF,GAAcK,iBAAiBpmB,GAEnC2D,YAAmCuxB,EAAUl1B,GAEhD,OADA63C,GAAOpxB,YAAYzmB,GACZ63C,GAAOnxB,UAAU1mB,GAErB2D,UAA+BuxB,EAAUl1B,GAE5C,OADA83C,GAAKvwB,UAAUvnB,GACR83C,GAAKtwB,QAAQxnB,GAEjB2D,UAA+BuxB,EAAUl1B,GAE5C,OADA+3C,GAAKzxB,UAAUtmB,GACR+3C,GAAKxxB,QAAQvmB,GAEjB2D,aAAqCusB,EAASlwB,GAIjD,OAHAg4C,GAAQrwB,aAAa3nB,GACrBg4C,GAAQpwB,SAAS5nB,EAAGkwB,EAAKxI,OACzBswB,GAAQ7xB,aAAanmB,EAAGkwB,EAAKjK,WACtB+xB,GAAQnwB,WAAW7nB,GAEvB2D,UAAgCusB,EAASlwB,GAG5C,OAFAi4C,GAAKhwB,UAAUjoB,GACfi4C,GAAK/vB,QAAQloB,EAAGkwB,EAAKlI,MACdiwB,GAAK9vB,QAAQnoB,GAEjB2D,UAA+BusB,EAASlwB,GAI3C,OAHAooB,GAAKC,UAAUroB,GACfooB,GAAKF,QAAQloB,EAAGkwB,EAAKlI,MACrBI,GAAKxC,YAAY5lB,EAAGkwB,EAAKzK,UAClB2C,GAAKE,QAAQtoB,GAEjB2D,eAAyCusB,EAASlwB,GACrD,MAAM02B,EAAYxG,EAAKwG,UAAY12B,EAAE6P,aAAaqgB,EAAKwG,gBAAc/vB,EAMrE,OALA4hB,GAAUI,eAAe3oB,GACzBuoB,GAAUL,QAAQloB,EAAGkwB,EAAKlI,WACTrhB,IAAb+vB,GACAnO,GAAUK,YAAY5oB,EAAG02B,GAEtBnO,GAAUM,aAAa7oB,GAE3B2D,cAAuCusB,EAASlwB,GAGnD,OAFA8oB,GAASE,cAAchpB,GACvB8oB,GAASZ,QAAQloB,EAAGkwB,EAAKlI,MAClBc,GAASG,YAAYjpB,GAEzB2D,UAA+BuxB,EAAUl1B,GAE5C,OADAk4C,GAAKj0B,UAAUjkB,GACRk4C,GAAKh0B,QAAQlkB,GAEjB2D,YAAmCuxB,EAAUl1B,GAEhD,OADAm4C,GAAOr0B,aAAa9jB,GACbm4C,GAAOp0B,WAAW/jB,GAEtB2D,WAAiCusB,EAASlwB,GAC7CglB,GAAMwzB,mBAAmBx4C,EAAGkwB,EAAK2G,QAAQh3B,QACzC,MAAMg3B,EAAU7R,GAAMyzB,oBAAoBz4C,EAAGkwB,EAAK2G,SAIlD,OAHA7R,GAAMI,WAAWplB,GACjBglB,GAAMK,QAAQrlB,EAAGkwB,EAAKv1B,MACtBqqB,GAAMM,WAAWtlB,EAAG62B,GACb7R,GAAMO,SAASvlB,GAEnB2D,gBAA2CusB,EAASlwB,GACvD,MAAM04C,EAAYh0C,KAAKyrB,MAAMD,EAAK8G,QAASh3B,GAO3C,OANA4pB,GAAmBI,wBAAwBhqB,GAC3C4pB,GAAmBK,MAAMjqB,EAAG,IAAI23C,GAAKznB,EAAKrG,GAAI,IAC9CD,GAAmBO,aAAanqB,EAAGkwB,EAAKnG,gBACtBpjB,IAAd+xC,GACA9uB,GAAmBM,aAAalqB,EAAG04C,GAEhC9uB,GAAmBQ,sBAAsBpqB,GAE7C2D,qBAAqDusB,EAASlwB,GAGjE,OAFAo4C,GAAgBjxB,qBAAqBnnB,GACrCo4C,GAAgBhxB,aAAapnB,EAAGkwB,EAAKhJ,WAC9BkxB,GAAgB/wB,mBAAmBrnB,GAEvC2D,mBAAiDusB,EAASlwB,GAG7D,OAFAq4C,GAAc7zB,mBAAmBxkB,GACjCq4C,GAAc5zB,YAAYzkB,EAAGkwB,EAAK3L,UAC3B8zB,GAAc3zB,iBAAiB1kB,GAEnC2D,SAA8BusB,EAASlwB,GAG1C,OAFAs4C,GAAKzzB,SAAS7kB,GACds4C,GAAKxzB,cAAc9kB,EAAGkwB,EAAKtL,YACpB0zB,GAAKvzB,OAAO/kB,KCjHpB,SAAS24C,GAAoB34C,GAChC,OAAO,IAAI44C,GACP54C,EAAS,MAyBjB,SAAS64C,EAAmBjqB,GACxB,OAAQA,GAAM,IAAI7uB,OAAoB,CAAC+4C,EAAY5N,IAAgB,IAC5D4N,EACH,IAAI9sB,GACAkf,EAAc,MACd6N,GAAkB7N,EAAiB,cAEpC2N,EAAmB3N,EAAiB,WACxC,IAhCC2N,CAAmB74C,EAAW,SAoCtC,SAASg5C,EAAgBpqB,EAAWntB,EAA0B,IAC1D,IAAK,IAAIjI,GAAK,EAAGyB,GAAK2zB,GAAM,IAAI/uB,SAAUrG,EAAIyB,GAAI,CAC9C,MAAMiwC,EAAStc,EAAGp1B,GAClB0xC,EAAiB,UAAKzpC,EAAQ4E,KAAK,IAAI4yC,GAAax3C,EAAQ5B,OAAQqrC,EAAiB,SAAErrC,SACvFqrC,EAAa,MAAKzpC,EAAQ4E,KAAK,IAAI4yC,GAAax3C,EAAQ5B,OAAQqrC,EAAa,KAAErrC,SAC/EqrC,EAAe,QAAKzpC,EAAQ4E,KAAK,IAAI4yC,GAAax3C,EAAQ5B,OAAQqrC,EAAe,OAAErrC,SACnFqrC,EAAa,MAAKzpC,EAAQ4E,KAAK,IAAI4yC,GAAax3C,EAAQ5B,OAAQqrC,EAAa,KAAErrC,SAC/E4B,EAAUu3C,EAAgB9N,EAAiB,SAAGzpC,GAElD,OAAOA,EA5CHu3C,CAAgBh5C,EAAW,UAkBnC,SAASk5C,GAAsBtO,EAAa/lC,GACxC,OAAQ+lC,EAAiB,UAAK,IAAIlP,OAAOgR,SAAStkC,IAAK8tB,GAAW6U,GAAMoO,SAASjjB,EAAGrxB,IA6BxF,SAASk0C,GAAkBK,GACvB,OAAQA,GAAY,IAAIr5C,OAAO,CAACovB,EAAKjY,IAAQiY,KAAgB,IAARjY,GAAY,GAyCrE,SAASmiC,GAAuBC,GAC5B,OAAO,IAAI30B,IAAoBzqB,OAAO+xC,QAAQqN,GAAa,KAI/D,SAASC,GAAkB3Q,GACvB,OAAO,IAAIvR,EAAIuR,EAAgB,SAAGA,EAAgB,UAItD,SAAS4Q,GAAatjB,EAAQY,GAE1B,MAAM3B,EAASe,EAAQ,KAAQ,KAE/B,OAAQf,GACJ,IAAK,OACL,IAAK,OAAU,OAAO,IAAIiC,EAC1B,IAAK,SAAU,OAAO,IAAIM,GAC1B,IAAK,OAAU,OAAO,IAAIC,GAC1B,IAAK,OAAU,OAAO,IAAIC,GAC1B,IAAK,OAAU,OAAO,IAAIkB,IAAMhC,GAAY,IAAI,IAChD,IAAK,SACL,IAAK,UAAW,OAAO,IAAIoC,GAAOpC,GAAY,IAGlD,OAAQ3B,GACJ,IAAK,MAAO,CACR,MAAMz6B,EAAIw7B,EAAQ,KAClB,OAAO,IAAImB,EAAI38B,EAAY,SAAGA,EAAY,UAE9C,IAAK,gBAAiB,CAClB,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAIoB,GAAMpU,EAAUxoB,EAAa,YAE5C,IAAK,UAAW,CACZ,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAI2B,GAAQn9B,EAAS,MAAGA,EAAa,WAEhD,IAAK,OAAQ,CACT,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAI4B,GAAM3U,EAASzoB,EAAQ,OAEtC,IAAK,OAAQ,CACT,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAI+B,GAAK7U,EAAS1oB,EAAQ,MAAWA,EAAY,UAE5D,IAAK,YAAa,CACd,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAIoC,GAAUlV,EAAS1oB,EAAQ,MAAWA,EAAY,UAEjE,IAAK,WAAY,CACb,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAIyC,GAAStV,EAAa3oB,EAAQ,OAE7C,IAAK,QAAS,CACV,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAIiD,GAAMlW,EAAUvoB,EAAQ,MAAYA,EAAW,SAAK,GAAKo8B,GAAY,IAEpF,IAAK,kBAAmB,CACpB,MAAMp8B,EAAIw7B,EAAQ,KAClB,OAAO,IAAIsD,GAAgB9+B,EAAa,WAE5C,IAAK,gBAAiB,CAClB,MAAMA,EAAIw7B,EAAQ,KAClB,OAAO,IAAIuD,GAAc/+B,EAAY,UAAIo8B,GAAY,IAAI,IAE7D,IAAK,MAAO,CACR,MAAMp8B,EAAIw7B,EAAQ,KAClB,OAAO,IAAIwD,IAAM5C,GAAY,IAAI,GAAIp8B,EAAc,aAG3D,MAAUyI,6BAA6BgyB,MC/K3C,IAAOskB,GAAOpwC,GAAA,EAAYa,KACnBwvC,GAAUrwC,GAAA,EAAYoB,QACtBkvC,GAAatwC,GAAA,EAAYrL,WAEzB47C,GAAOn3B,EAAYE,OAAOD,MAAMK,QAAQO,KACxCu2B,GAASp3B,EAAYE,OAAOD,MAAMK,QAAQsH,MAC1CyvB,GAAUr3B,EAAYE,OAAOD,MAAMK,QAAQwI,OAC3CrZ,GAAUuQ,EAAYE,OAAOD,MAAMK,QAAQlR,OAC3CkoC,GAAWl3B,EAAaF,OAAOD,MAAMK,QAAQkK,QAC7C+sB,GAAYv3B,EAAYE,OAAOD,MAAMK,QAAQsG,SAC7C4wB,GAAap3B,EAAaF,OAAOD,MAAMK,QAAQiJ,UAC/CkuB,GAAcz3B,EAAYE,OAAOD,MAAMK,QAAQQ,WAC/C42B,GAAet3B,EAAaF,OAAOD,MAAMK,QAAQmJ,YACjDkuB,GAAmBv3B,EAAaF,OAAOD,MAAMK,QAAQ2J,gBAcrD,MAAM2tB,GAsET12C,YAAY2pB,EAA2BH,EAA0BC,EAAektB,GAC5E51C,KAAK61C,SAAWptB,EAChBzoB,KAAK81C,YAAcptB,EACnB1oB,KAAK0uC,KAAO,IAAIz0C,WAAW,GAC3B27C,IAAW51C,KAAK+1C,cAAgB,KAAMH,IACtC51C,KAAKg2C,YAAoC,iBAAfptB,EAA0BA,EAAaA,EAAWnjB,IAxEzExG,gBAAyCg3C,EAAUvtB,GACtD,MAAMwtB,EAAU,IAAIP,GAAQ,EAAGr3B,EAAgBkuB,GAAI9jB,GAEnD,OADAwtB,EAAQH,cA8IhB,SAA+BG,EAAczjC,GACzC,MAAO,KACH,OAAQA,GACJ,KAAK4U,EAAcR,OAAQ,OAAO6gB,GAAO+M,SAASyB,GAClD,KAAK7uB,EAAcG,YAAa,OAAO0sB,GAAYO,SAASyB,GAC5D,KAAK7uB,EAAcW,gBAAiB,OAAOA,GAAgBysB,SAASyB,GAExE,MAAUz3C,4CAA4C4oB,EAAc5U,aAAgBA,QArJ5D0jC,CAAsBF,EAAKvtB,GAC5CwtB,EAIJj3C,cAAcwU,GACjBA,EAAM,IAAIwhC,GAAWz/C,OAAA6gC,GAAA,aAAA7gC,CAAaie,IAClC,MAAM2iC,EAAWf,GAASgB,iBAAiB5iC,GACrCmV,EAAmBwtB,EAASxtB,aAC5BH,EAA2B2tB,EAAS3tB,UACpCC,EAA4B0tB,EAAS1tB,aACrCwtB,EAAU,IAAIP,GAAQ/sB,EAAYH,EAASC,GAEjD,OADAwtB,EAAQH,cA8IhB,SAA6BG,EAAmBzjC,GAC5C,MAAO,KACH,OAAQA,GACJ,KAAK4U,EAAcR,OAAQ,OAAO6gB,GAAO75B,OAAOqoC,EAAQN,OAAO,IAAIR,KACnE,KAAK/tB,EAAcG,YAAa,OAAO0sB,GAAYrmC,OAAOqoC,EAAQN,OAAO,IAAIH,IAAkBS,EAAQztB,WACvG,KAAKpB,EAAcW,gBAAiB,OAAOA,GAAgBna,OAAOqoC,EAAQN,OAAO,IAAIF,IAAsBQ,EAAQztB,WAEvH,MAAUhqB,4CAA4C4oB,EAAc5U,aAAgBA,QArJ5D6jC,CAAoBF,EAAU1tB,GAC/CwtB,EAIJj3C,cAAuCi3C,GAC1C,IAAI56C,EAAI,IAAI05C,GAAWrsB,GAAgB,EAcvC,OAbIutB,EAAQK,WACR5tB,EAAe+e,GAAO15B,OAAO1S,EAAG46C,EAAQN,UACjCM,EAAQM,gBACf7tB,EAAeurB,GAAYlmC,OAAO1S,EAAG46C,EAAQN,UACtCM,EAAQO,sBACf9tB,EAAeX,GAAgBha,OAAO1S,EAAG46C,EAAQN,WAErDP,GAASxsB,aAAavtB,GACtB+5C,GAASvsB,WAAWxtB,EAAGgjB,EAAgBkuB,IACvC6I,GAASrsB,UAAU1tB,EAAGqtB,GACtB0sB,GAAStsB,cAAcztB,EAAG46C,EAAQxtB,YAClC2sB,GAASpsB,cAAc3tB,EAAG,IAAIy5C,GAAKmB,EAAQttB,WAAY,IACvDysB,GAASqB,oBAAoBp7C,EAAG+5C,GAASnsB,WAAW5tB,IAC7CA,EAAE2L,eAINhI,YAAY22C,EAAgDhtB,EAAa,GAC5E,GAAIgtB,aAAkBlO,GAClB,OAAO,IAAIiO,GAAQ,EAAGr3B,EAAgBkuB,GAAInlB,EAAcR,OAAQ+uB,GAEpE,GAAIA,aAAkB1B,GAClB,OAAO,IAAIyB,GAAQ/sB,EAAYtK,EAAgBkuB,GAAInlB,EAAcG,YAAaouB,GAElF,GAAIA,aAAkB5tB,GAClB,OAAO,IAAI2tB,GAAQ/sB,EAAYtK,EAAgBkuB,GAAInlB,EAAcW,gBAAiB4tB,GAEtF,MAAUn3C,sCAAsCm3C,KAQpDnjC,WAAoB,OAAOzS,KAAK0oB,WAChCD,cAAuB,OAAOzoB,KAAK61C,SACnCntB,iBAA0B,OAAO1oB,KAAK81C,YACtCltB,iBAA0B,OAAO5oB,KAAKg2C,YAG/B/2C,SAAW,OAAOe,KAAK+1C,gBACvB92C,WAAoD,OAAOe,KAAK0oB,aAAerB,EAAcR,OAC7F5nB,gBAA8D,OAAOe,KAAK0oB,aAAerB,EAAcG,YACvGvoB,oBAAsE,OAAOe,KAAK0oB,aAAerB,EAAcW,iBAenH,MAAMksB,GAIT5oB,YAAqB,OAAOtrB,KAAK22C,OACjCx7C,aAAsB,OAAO6E,KAAKqkC,QAClCtnC,cAAuB,OAAOiD,KAAK42C,SACnC33C,YAAY9D,EAAuBmwB,EAAoBvuB,GACnDiD,KAAK22C,OAASrrB,EACdtrB,KAAK42C,SAAW75C,EAChBiD,KAAKqkC,QAA4B,iBAAXlpC,EAAsBA,EAASA,EAAOsK,KAQ7D,MAAMuiB,GAKT7C,SAAkB,OAAOnlB,KAAK62C,IAC9BnkC,WAAoB,OAAO1S,KAAKspB,MAChCpB,cAAuB,OAAOloB,KAAK82C,SACnC37C,aAA8B,OAAO6E,KAAK0S,KAAKvX,OAC/CmwB,YAAkC,OAAOtrB,KAAK0S,KAAK4Y,MACnDvuB,cAAuC,OAAOiD,KAAK0S,KAAK3V,QAExDkC,YAAYyT,EAAmByS,EAAmB+C,GAAmB,GACjEloB,KAAKspB,MAAQ5W,EACb1S,KAAK82C,SAAW5uB,EAChBloB,KAAK62C,IAAoB,iBAAP1xB,EAAkBA,EAAKA,EAAG1f,KAQ7C,MAAM8uC,GAGTt1C,YAAY1D,EAAuBJ,GAC/B6E,KAAKzE,OAA2B,iBAAXA,EAAsBA,EAASA,EAAOkK,IAC3DzF,KAAK7E,OAA2B,iBAAXA,EAAsBA,EAASA,EAAOsK,KAQ5D,MAAM6hB,GAGTroB,YAAY9D,EAAuBo6B,GAC/Bv1B,KAAK7E,OAA2B,iBAAXA,EAAsBA,EAASA,EAAOsK,IAC3DzF,KAAKu1B,UAAiC,iBAAdA,EAAyBA,EAAYA,EAAU9vB,KAsJ/E,SAASsxC,GAAoBrsC,EAAevK,GACxC,MAAMiyB,EAAW,GACjB,IAAK,IAAIZ,EAAG18B,GAAK,EAAGoG,GAAK,EAAG3E,EAAImU,EAAMssC,mBAAoBliD,EAAIyB,IACtDi7B,EAAI9mB,EAAM0nB,SAASt9B,MACnBs9B,IAAWl3B,GAAKmrC,GAAMx4B,OAAO2jB,EAAGrxB,IAGxC,OAAOiyB,EAyCX,SAAS6kB,GAAqB/W,GAC1B,MAAMxtB,EAAO,IAAIuN,IACjB,GAAIigB,EACA,IAAK,IAAIgX,EAAO7gD,EAAKvB,GAAK,EAAGyB,EAAoC,EAAhC2pC,EAAOiX,yBAA8BriD,EAAIyB,IACjE2gD,EAAQhX,EAAOkX,eAAetiD,KAA8B,OAAtBuB,EAAM6gD,EAAM7gD,QACnDqc,EAAKnY,IAAIlE,EAAK6gD,EAAMnhD,SAIhC,OAAO2c,EAIX,SAAS2kC,GAAgBnT,GACrB,OAAO,IAAIvR,EAAIuR,EAAMljB,WAAYkjB,EAAMnjB,YAI3C,SAASu2B,GAAgB9lB,EAAWY,GAEhC,MAAM3B,EAASe,EAAEzL,WAEjB,OAAQ0K,GACJ,KAAKykB,GAAKtvB,KACV,KAAKsvB,GAAKp2B,KAAS,OAAO,IAAI4T,EAC9B,KAAKwiB,GAAKpzB,OAAS,OAAO,IAAIkR,GAC9B,KAAKkiB,GAAKvzB,KAAS,OAAO,IAAIsR,GAC9B,KAAKiiB,GAAKtyB,KAAS,OAAO,IAAIsQ,GAC9B,KAAKgiB,GAAK51B,KAAS,OAAO,IAAI8U,IAAMhC,GAAY,IAAI,IACpD,KAAK8iB,GAAK/1B,QAAS,OAAO,IAAIqV,GAAOpC,GAAY,IAGrD,OAAQ3B,GACJ,KAAKykB,GAAKp0B,IAAK,CACX,MAAM9qB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQyC,KACtD,OAAO,IAAI6R,EAAI38B,EAAEgrB,WAAYhrB,EAAE+qB,YAEnC,KAAKm0B,GAAK7zB,cAAe,CACrB,MAAMrrB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQgD,eACtD,OAAO,IAAIuR,GAAM58B,EAAEurB,aAEvB,KAAK2zB,GAAKnyB,QAAS,CACf,MAAM/sB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQ0E,SACtD,OAAO,IAAIoQ,GAAQn9B,EAAEgtB,QAAShtB,EAAEurB,aAEpC,KAAK2zB,GAAK9xB,KAAM,CACZ,MAAMptB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQ+E,MACtD,OAAO,IAAIgQ,GAAMp9B,EAAEstB,QAEvB,KAAK4xB,GAAKxxB,KAAM,CACZ,MAAM1tB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQqF,MACtD,OAAO,IAAI6P,GAAKv9B,EAAEstB,OAAQttB,EAAE+qB,YAEhC,KAAKm0B,GAAKrxB,UAAW,CACjB,MAAM7tB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQwF,WACtD,OAAO,IAAI+P,GAAU59B,EAAEstB,OAAQttB,EAAEg8B,YAErC,KAAKkjB,GAAK9wB,SAAU,CAChB,MAAMpuB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQ+F,UACtD,OAAO,IAAI6P,GAASj+B,EAAEstB,QAE1B,KAAK4xB,GAAK50B,MAAO,CACb,MAAMtqB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQiC,OACtD,OAAO,IAAImU,GAAMz+B,EAAEC,OAAQD,EAAEuhD,gBAAkB,GAAInlB,GAAY,IAEnE,KAAK8iB,GAAK3yB,gBAAiB,CACvB,MAAMvsB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQkE,iBACtD,OAAO,IAAIuS,GAAgB9+B,EAAEwsB,aAEjC,KAAK0yB,GAAKt1B,cAAe,CACrB,MAAM5pB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQuB,eACtD,OAAO,IAAImV,GAAc/+B,EAAE6pB,YAAauS,GAAY,IAAI,IAE5D,KAAK8iB,GAAKj1B,IAAK,CACX,MAAMjqB,EAAIw7B,EAAE/e,KAAK,IAAIsL,EAAYE,OAAOD,MAAMK,QAAQ4B,KACtD,OAAO,IAAI+U,IAAM5C,GAAY,IAAI,GAAIp8B,EAAEkqB,eAG/C,MAAUzhB,6BAA6By2C,GAAKzkB,QAAaA,MAxP7D4V,GAAc,OAwRd,SAAqB/qC,EAAYoP,GAE7B,IAAImb,GAAc,EACdG,GAAc,EACdC,GAAoB,EAEpBxT,EAAO/H,EAAM+H,KACbge,EAAqB/lB,EAAM+lB,OAE1BzE,EAAS2Y,aAAalyB,IAGvBge,EAAShe,EAAK8f,WAAW9B,OACzBxK,EAAmB4tB,GAAcpoB,MAAMhZ,EAAMnX,GAC7C0qB,EAAa6tB,GAAcpoB,MAAMhZ,EAAK8f,WAAYj3B,IAJlD0qB,EAAa6tB,GAAcpoB,MAAMhZ,EAAMnX,GAO3C,MAAMk8C,GAAgB/kC,EAAK2f,UAAY,IAAI1uB,IAAK8tB,GAAa6U,GAAMr4B,OAAO1S,EAAGk2B,IACvEimB,EAAuBtC,GAAOuC,qBAAqBp8C,EAAGk8C,GAEtDG,EAAmBjtC,EAAM67B,UAAY77B,EAAM67B,SAAS9rC,KAAO,EAC7D06C,GAAOyC,2BAA2Bt8C,EAAG,IAAIoP,EAAM67B,UAAU7iC,IAAI,EAAEi9B,EAAGC,MAC9D,MAAMvqC,EAAMiF,EAAE6P,gBAAgBw1B,KACxBnuB,EAAMlX,EAAE6P,gBAAgBy1B,KAI9B,OAHA0U,GAAUxwB,cAAcxpB,GACxBg6C,GAAUvwB,OAAOzpB,EAAGjF,GACpBi/C,GAAUtwB,SAAS1pB,EAAGkX,GACf8iC,GAAUrwB,YAAY3pB,OAPkC,EAUnEoP,EAAMrV,OACNwwB,EAAavqB,EAAE6P,aAAaT,EAAMrV,OAGtC8/C,GAAO/uB,WAAW9qB,GAClB65C,GAAO3uB,QAAQlrB,EAAG0qB,GAClBmvB,GAAO5uB,YAAYjrB,EAAGm1B,GACtB0kB,GAAOzuB,YAAYprB,EAAGm8C,GACtBtC,GAAO7uB,YAAYhrB,IAAKoP,EAAMob,WAEV,IAAhBD,GAAqBsvB,GAAO9uB,QAAQ/qB,EAAGuqB,IACjB,IAAtBI,GAA2BkvB,GAAO1uB,cAAcnrB,EAAG2qB,IAC/B,IAApB0xB,GAAyBxC,GAAOxuB,kBAAkBrrB,EAAGq8C,GAEzD,OAAOxC,GAAOvuB,SAAStrB,IAnU3B+qC,GAAc,OAoId,SAAqB7U,EAAWrxB,GAE5B,IAAIglB,EACAza,EACA+H,EACAguB,EACAoX,EACAC,EAGC33C,IAAkB23C,EAAWtmB,EAAEe,cAQ1BpyB,EAAa4gC,IAAI5b,EAAK2yB,EAAS3yB,KAAK1f,MAW1Cg7B,GAAQA,EAAOqX,EAAS9D,aAAeqD,GAAgB5W,GAAiB,IAAIjU,EAC5EqrB,EAAW,IAAIziB,GAAWj1B,EAAaxK,IAAIwvB,GAAMsb,EAAMtb,EAAI2yB,EAASzyB,aACpE3a,EAAQ,IAAI27B,GAAM7U,EAAEn8B,OAASwiD,EAAUrmB,EAAE1L,WAAYmxB,GAAqBzlB,MAX1EiP,GAAQA,EAAOqX,EAAS9D,aAAeqD,GAAgB5W,GAAiB,IAAIjU,EAC5ErsB,EAAa5F,IAAI4qB,EAAI1S,EAAO6kC,GAAgB9lB,EAAGulB,GAAoBvlB,EAAGrxB,KACtE03C,EAAW,IAAIziB,GAAW3iB,EAAMguB,EAAMtb,EAAI2yB,EAASzyB,aACnD3a,EAAQ,IAAI27B,GAAM7U,EAAEn8B,OAASwiD,EAAUrmB,EAAE1L,WAAYmxB,GAAqBzlB,MAZ1E/e,EAAO6kC,GAAgB9lB,EAAGulB,GAAoBvlB,EAAGrxB,IACjDuK,EAAQ,IAAI27B,GAAM7U,EAAEn8B,OAASod,EAAM+e,EAAE1L,WAAYmxB,GAAqBzlB,KAqB1E,OAAO9mB,GAAS,MApKpB27B,GAAgB,SDpIT,SAAuBH,EAAa/lC,GAEvC,IAAIglB,EACAsb,EACA/1B,EACAotC,EACArlC,EACAolC,EA0BJ,OAvBK13C,IAAkB23C,EAAW5R,EAAmB,YAQ3C/lC,EAAa4gC,IAAI5b,EAAK2yB,EAAa,KAWzCrX,GAAQA,EAAOqX,EAAoB,WAAKjD,GAAkBpU,GAAiB,IAAIjU,EAC/EqrB,EAAW,IAAIziB,GAAWj1B,EAAaxK,IAAIwvB,GAAMsb,EAAMtb,EAAI2yB,EAAoB,WAC/EptC,EAAQ,IAAI27B,GAAMH,EAAa,KAAG2R,EAAU3R,EAAiB,SAAGyO,GAAuBzO,EAAuB,mBAX9GzF,GAAQA,EAAOqX,EAAoB,WAAKjD,GAAkBpU,GAAiB,IAAIjU,EAC/ErsB,EAAa5F,IAAI4qB,EAAI1S,EAAOqiC,GAAa5O,EAAQsO,GAAsBtO,EAAQ/lC,KAC/E03C,EAAW,IAAIziB,GAAW3iB,EAAMguB,EAAMtb,EAAI2yB,EAAoB,WAC9DptC,EAAQ,IAAI27B,GAAMH,EAAa,KAAG2R,EAAU3R,EAAiB,SAAGyO,GAAuBzO,EAAuB,mBAZ9GzzB,EAAOqiC,GAAa5O,EAAQsO,GAAsBtO,EAAQ/lC,IAC1DuK,EAAQ,IAAI27B,GAAMH,EAAa,KAAGzzB,EAAMyzB,EAAiB,SAAGyO,GAAuBzO,EAAuB,kBAqBvGx7B,GAAS,MCqGpBg9B,GAAe,OAwPf,SAAsBpsC,EAAY2E,GAE9B,MAAM83C,EAAe93C,EAAOoxB,OAAO3tB,IAAK8tB,GAAM6U,GAAMr4B,OAAO1S,EAAGk2B,IAE9D4jB,GAAQ4C,kBAAkB18C,EAAGy8C,EAAa58C,QAE1C,MAAM88C,EAAqB7C,GAAQ8C,mBAAmB58C,EAAGy8C,GAEnDJ,EAAmB13C,EAAOsmC,UAAYtmC,EAAOsmC,SAAS9rC,KAAO,EAC/D26C,GAAQwC,2BAA2Bt8C,EAAG,IAAI2E,EAAOsmC,UAAU7iC,IAAI,EAAEi9B,EAAGC,MAChE,MAAMvqC,EAAMiF,EAAE6P,gBAAgBw1B,KACxBnuB,EAAMlX,EAAE6P,gBAAgBy1B,KAI9B,OAHA0U,GAAUxwB,cAAcxpB,GACxBg6C,GAAUvwB,OAAOzpB,EAAGjF,GACpBi/C,GAAUtwB,SAAS1pB,EAAGkX,GACf8iC,GAAUrwB,YAAY3pB,OAPoC,EAUzE85C,GAAQnuB,YAAY3rB,GACpB85C,GAAQjuB,UAAU7rB,EAAG28C,GACrB7C,GAAQluB,cAAc5rB,EAAG68C,GAAyB3C,GAAY1uB,OAAS0uB,GAAY4C,MAE3D,IAApBT,GAAyBvC,GAAQzuB,kBAAkBrrB,EAAGq8C,GAE1D,OAAOvC,GAAQhuB,UAAU9rB,IA/Q7BosC,GAAe,OAoDf,SAAsB2Q,EAAkBl4C,EAAsC,IAAI8f,KAC9E,MAAMoR,EAqDV,SAA4BpxB,EAAiBE,GACzC,MAAMkxB,EAAS,GACf,IAAK,IAAIG,EAAG18B,GAAK,EAAGoG,GAAK,EAAG3E,EAAI0J,EAAOq4C,iBAAkBxjD,EAAIyB,IACrDi7B,EAAIvxB,EAAOoxB,OAAOv8B,MAClBu8B,IAASn2B,GAAKmrC,GAAMx4B,OAAO2jB,EAAGrxB,IAGtC,OAAOkxB,EA5DQknB,CAAmBF,EAASl4C,GAC3C,OAAO,IAAIunC,GAAOrW,EAAQ4lB,GAAqBoB,GAAUl4C,IArD7DunC,GAAiB,SD1MV,SAAwB2Q,EAAcl4C,EAAsC,IAAI8f,KACnF,OAAO,IAAIynB,GAyBf,SAA8B2Q,EAAcl4C,GACxC,OAAQk4C,EAAgB,QAAK,IAAIrhB,OAAOgR,SAAStkC,IAAK8tB,GAAW6U,GAAMoO,SAASjjB,EAAGrxB,IAzB/Eq4C,CAAqBH,EAASl4C,GAC9Bw0C,GAAuB0D,EAAwB,gBAC/Cl4C,ICwMR+zC,GAAoB,OAgUpB,SAA2B54C,EAAYm9C,GAEnC,MAAMntB,EAAQmtB,EAAYntB,OAAS,GAC7BvuB,EAAU07C,EAAY17C,SAAW,GAEvC04C,GAAaiD,iBAAiBp9C,EAAGgwB,EAAMnwB,QACvCmwB,EAAM3vB,QAAQ8hC,UAAU1D,QAASxjC,GAAM+wB,GAAUtZ,OAAO1S,EAAG/E,IAE3D,MAAMoiD,EAAoBr9C,EAAE4P,YAE5BuqC,GAAamD,mBAAmBt9C,EAAGyB,EAAQ5B,QAC3C4B,EAAQpB,QAAQ8hC,UAAU1D,QAAS8e,GAAOtE,GAAavmC,OAAO1S,EAAGu9C,IAEjE,MAAMC,EAAsBx9C,EAAE4P,YAM9B,OAJAuqC,GAAa9tB,iBAAiBrsB,GAC9Bm6C,GAAa7tB,UAAUtsB,EAAG,IAAIy5C,GAAK0D,EAAYt9C,OAAQ,IACvDs6C,GAAa5tB,SAASvsB,EAAGq9C,GACzBlD,GAAa3tB,WAAWxsB,EAAGw9C,GACpBrD,GAAa1tB,eAAezsB,IAlVvC44C,GAAoB,OAsDpB,SAA2B6E,EAAqBtwB,EAAUnK,EAAgBkuB,IACtE,OAAO,IAAI0H,GAAY6E,EAAM59C,SAmBjC,SAA0B49C,GACtB,MAAMztB,EAAQ,GACd,IAAK,IAAIkG,EAAG18B,GAAK,EAAGoG,GAAK,EAAG3E,EAAIwiD,EAAMC,gBAAiBlkD,EAAIyB,IACnDi7B,EAAIunB,EAAMztB,MAAMx2B,MAChBw2B,IAAQpwB,GAAKosB,GAAUzZ,OAAO2jB,IAGtC,OAAOlG,EA1BgC2tB,CAAiBF,GA8B5D,SAAuBA,EAAqBtwB,GACxC,MAAMywB,EAAgB,GACtB,IAAK,IAAI59C,EAAGxG,GAAK,EAAGoG,GAAK,EAAG3E,EAAIwiD,EAAMI,kBAAmBrkD,EAAIyB,IACrD+E,EAAIy9C,EAAMh8C,QAAQjI,MAIlB2zB,EAAUnK,EAAgBkuB,KACtBlxC,EAAEmR,QAAW,GAAK3X,EAAI,IAE1BokD,IAAgBh+C,GAAKq5C,GAAa1mC,OAAOvS,IAGjD,OAAO49C,EA3CyDE,CAAcL,EAAOtwB,KAtDzFyrB,GAAsB,SAAID,GAE1BjsB,GAAwB,OAmVxB,SAA+B1sB,EAAY+9C,GACvC,MAAMpxB,EAAaisB,GAAYlmC,OAAO1S,EAAG+9C,EAAgB3mC,MAKzD,OAJAgjC,GAAiBvtB,qBAAqB7sB,GACtCo6C,GAAiBnwB,MAAMjqB,EAAG,IAAIy5C,GAAKsE,EAAgBl0B,GAAI,IACvDuwB,GAAiBrtB,WAAW/sB,EAAG+9C,EAAgBnxB,SAC/CwtB,GAAiBttB,QAAQ9sB,EAAG2sB,GACrBytB,GAAiBptB,mBAAmBhtB,IAxV/C0sB,GAAwB,OAuDxB,SAA+B+wB,EAAyBtwB,EAAUnK,EAAgBkuB,IAC9E,OAAO,IAAIxkB,GAAgBksB,GAAYrmC,OAAOkrC,EAAMrmC,OAAS+V,GAAUswB,EAAM5zB,KAAM4zB,EAAM7wB,YAvD7FF,GAA0B,SDhMnB,SAAiC1sB,GACpC,OAAO,IAAI0sB,GACPisB,GAAoB34C,EAAQ,MAC5BA,EAAM,GAAGA,EAAW,UC+L5BgsB,GAAkB,OAyVlB,SAAyBhsB,EAAYkwB,GACjC,OAAO+pB,GAAW+D,gBAAgBh+C,EAAG,IAAIy5C,GAAKvpB,EAAKrwB,OAAQ,GAAI,IAAI45C,GAAKvpB,EAAK+J,UAAW,KAzV5FjO,GAAkB,OA6DlB,SAAyBkK,GACrB,OAAO,IAAIlK,GAAUkK,EAAEr2B,SAAUq2B,EAAE+D,cA5DvCgf,GAAqB,OA2VrB,SAA4Bj5C,EAAYkwB,GACpC,OAAOhe,GAAQ+D,aAAajW,EAAG,IAAIy5C,GAAKvpB,EAAKjwB,OAAQ,GAAI,IAAIw5C,GAAKvpB,EAAKrwB,OAAQ,KA3VnFo5C,GAAqB,OAqDrB,SAA4Bj5C,GACxB,OAAO,IAAIi5C,GAAaj5C,EAAEC,SAAUD,EAAEH,WAyS1C,MAAMg9C,GAAyB,WAC3B,MAAMj+C,EAAS,IAAIT,YAAY,GAG/B,OAFA,IAAIsxB,SAAS7wB,GAAQq/C,SAAS,EAAG,KAAK,GAED,MAA9B,IAAIp9C,WAAWjC,GAAQ,GAJH,GCjkB/B,IAAOs/C,GAAa70C,GAAA,EAAYrL,WAQjB,MAAMmgD,GAA4BhnC,eAAoC4U,EAAc5U,kDAC9EinC,GAA4BjnC,2CAAgE4U,EAAc5U,kCAC1GknC,GAA2B,CAACC,EAAkB1nC,wBAAuC0nC,mCAA0C1nC,KAC/H2nC,GAA2B,CAACD,EAAkB1nC,wBAAuC0nC,2CAAkD1nC,KAGrJ,MAAM4nC,GAET76C,YAAYtF,GACRqG,KAAKrG,OAASA,aAAkBy0C,GAAaz0C,EAAS,IAAIy0C,GAAWz0C,GAElEsF,CAACpJ,OAAO8G,YAAyC,OAAOqD,KACxDf,OACH,IAAIrJ,EACJ,OAAKA,EAAIoK,KAAK+5C,sBAAsB98C,KAAeixC,GAAA,GAIjC,IAAbt4C,EAAEG,QACFH,EAAIoK,KAAK+5C,sBAAsB98C,KAAeixC,GAAA,GAC9Ct4C,EAAIoK,KAAKg6C,aAAapkD,EAAEG,QAAQkH,KAAeixC,GAAA,EACtCt4C,EAEXqJ,MAAMlJ,GAAe,OAAOiK,KAAKrG,OAAOmJ,MAAM/M,GAC9CkJ,OAAOlJ,GAAe,OAAOiK,KAAKrG,OAAO8H,OAAO1L,GAChDkJ,YAAqCwT,GACxC,IAAI7c,EACJ,IAAKA,EAAIoK,KAAKpD,QAAQK,KAAQ,OAAO,KACrC,GAAa,MAARwV,GAAiB7c,EAAEG,MAAM2yB,aAAejW,EACzC,MAAUhU,MAAMg7C,GAAmBhnC,IAEvC,OAAO7c,EAAEG,MAENkJ,gBAAgB2pB,GACnB,GAAIA,GAAc,EAAK,OAAO,IAAI3uB,WAAW,GAC7C,MAAMwZ,EAAMje,OAAA6gC,GAAA,aAAA7gC,CAAawK,KAAKrG,OAAO6K,KAAKokB,IAC1C,GAAInV,EAAI3Z,WAAa8uB,EACjB,MAAUnqB,MAAMo7C,GAAyBjxB,EAAYnV,EAAI3Z,aAI7D,OAAiB2Z,EAAItZ,WAAa,GAAM,GACvBsZ,EAAItZ,WAAasZ,EAAI3Z,YAAe2Z,EAAIvZ,OAAOJ,WAAa2Z,EAAMA,EAAI9X,QAEpFsD,WAAWg7C,GAAc,GAC5B,MAAMxnC,EAAO4U,EAAcR,OACrBqvB,EAAUl2C,KAAKk6C,YAAYznC,GAC3BxS,EAASi2C,GAAWA,EAAQN,SAClC,GAAIqE,IAAgBh6C,EAChB,MAAUxB,MAAMi7C,GAAYjnC,IAEhC,OAAOxS,EAEDhB,qBACN,MAAMwU,EAAMzT,KAAKrG,OAAO6K,KAAK21C,IACvBj0C,EAAKuN,GAAO,IAAI+lC,GAAW/lC,GAC3B5J,EAAM3D,GAAMA,EAAG2E,UAAU,IAAM,EACrC,MAAO,CAAE5N,KAAc,IAAR4M,EAAW9T,MAAO8T,GAE3B5K,aAAam7C,GACnB,MAAM3mC,EAAMzT,KAAKrG,OAAO6K,KAAK41C,GAC7B,IAAK3mC,EAAO,OAAOy6B,GAAA,EACnB,GAAIz6B,EAAI3Z,WAAasgD,EACjB,MAAU37C,MAAMk7C,GAAuBS,EAAgB3mC,EAAI3Z,aAE/D,MAAO,CAAEmD,MAAM,EAAOlH,MAAO4/C,GAAQ9nC,OAAO4F,KAK7C,MAAM4mC,GAITp7C,YAAYtF,EAAaG,GACrBkG,KAAKrG,OAASA,aAAkB60C,GAAkB70C,EAC5CnE,OAAAyhC,GAAA,EAAAzhC,CAAamE,GACb,IAAIo1C,GAAsBp1C,EAAQG,GAClC,IAAI00C,GAAgB70C,GAEvBsF,CAACpJ,OAAOuH,iBAAmD,OAAO4C,KAClEf,aACH,IAAIrJ,EACJ,OAAKA,QAAUoK,KAAK+5C,sBAAsB98C,KAAeixC,GAAA,GAIvC,IAAbt4C,EAAEG,QACFH,QAAUoK,KAAK+5C,sBAAsB98C,KAAeixC,GAAA,GACpDt4C,QAAUoK,KAAKg6C,aAAapkD,EAAEG,QAAQkH,KAAeixC,GAAA,EAC5Ct4C,EAEXqJ,YAAYlJ,GAAe,aAAaiK,KAAKrG,OAAOmJ,MAAM/M,GAC1DkJ,aAAalJ,GAAe,aAAaiK,KAAKrG,OAAO8H,OAAO1L,GAC5DkJ,kBAA2CwT,GAC9C,IAAI7c,EACJ,IAAKA,QAAUoK,KAAKpD,QAAQK,KAAQ,OAAO,KAC3C,GAAa,MAARwV,GAAiB7c,EAAEG,MAAM2yB,aAAejW,EACzC,MAAUhU,MAAMg7C,GAAmBhnC,IAEvC,OAAO7c,EAAEG,MAENkJ,sBAAsB2pB,GACzB,GAAIA,GAAc,EAAK,OAAO,IAAI3uB,WAAW,GAC7C,MAAMwZ,EAAMje,OAAA6gC,GAAA,aAAA7gC,OAAmBwK,KAAKrG,OAAO6K,KAAKokB,IAChD,GAAInV,EAAI3Z,WAAa8uB,EACjB,MAAUnqB,MAAMo7C,GAAyBjxB,EAAYnV,EAAI3Z,aAI7D,OAAiB2Z,EAAItZ,WAAa,GAAM,GACvBsZ,EAAItZ,WAAasZ,EAAI3Z,YAAe2Z,EAAIvZ,OAAOJ,WAAa2Z,EAAMA,EAAI9X,QAEpFsD,iBAAiBg7C,GAAc,GAClC,MAAMxnC,EAAO4U,EAAcR,OACrBqvB,QAAgBl2C,KAAKk6C,YAAYznC,GACjCxS,EAASi2C,GAAWA,EAAQN,SAClC,GAAIqE,IAAgBh6C,EAChB,MAAUxB,MAAMi7C,GAAYjnC,IAEhC,OAAOxS,EAEDhB,2BACN,MAAMwU,QAAYzT,KAAKrG,OAAO6K,KAAK21C,IAC7Bj0C,EAAKuN,GAAO,IAAI+lC,GAAW/lC,GAC3B5J,EAAM3D,GAAMA,EAAG2E,UAAU,IAAM,EACrC,MAAO,CAAE5N,KAAc,IAAR4M,EAAW9T,MAAO8T,GAE3B5K,mBAAmBm7C,GACzB,MAAM3mC,QAAYzT,KAAKrG,OAAO6K,KAAK41C,GACnC,IAAK3mC,EAAO,OAAOy6B,GAAA,EACnB,GAAIz6B,EAAI3Z,WAAasgD,EACjB,MAAU37C,MAAMk7C,GAAuBS,EAAgB3mC,EAAI3Z,aAE/D,MAAO,CAAEmD,MAAM,EAAOlH,MAAO4/C,GAAQ9nC,OAAO4F,KAK7C,MAAM6mC,WAA0BR,GAMnC76C,YAAYtF,GACRsH,MAAM,IAAIhH,WAAW,IANjB+F,KAAAq4C,SAAU,EAEVr4C,KAAAu6C,MAAe,GACfv6C,KAAAw6C,YAAc,EACdx6C,KAAAy6C,iBAAmB,EAGvBz6C,KAAKD,MAAQpG,aAAkBu0C,GAAA,EAAYv0C,EAAS,IAAIu0C,GAAA,EAAUv0C,GAE/DsF,OACH,MAAMc,MAAEA,GAAUC,KAClB,IAAKA,KAAKq4C,QAAS,CAGf,OAFAr4C,KAAKq4C,SAAU,EAER,CAAEp7C,MAAM,EAAOlH,MADN4/C,GAAQlB,SAAS10C,EAAME,OAAQonB,EAAcR,SAGjE,GAAI7mB,KAAKy6C,iBAAmB16C,EAAMI,aAAahF,OAAQ,CACnD,MAAM49C,EAAQh5C,EAAMI,aAAaH,KAAKy6C,oBAGtC,OAFAz6C,KAAKu6C,MAAQxB,EAAY,KAAW,QAE7B,CAAE97C,MAAM,EAAOlH,MADN4/C,GAAQlB,SAASsE,EAAO1xB,EAAcW,kBAG1D,GAAIhoB,KAAKw6C,YAAcz6C,EAAMG,QAAQ/E,OAAQ,CACzC,MAAM49C,EAAQh5C,EAAMG,QAAQF,KAAKw6C,eAGjC,OAFAx6C,KAAKu6C,MAAQxB,EAAe,QAErB,CAAE97C,MAAM,EAAOlH,MADN4/C,GAAQlB,SAASsE,EAAO1xB,EAAcG,cAI1D,OADAxnB,KAAKu6C,MAAQ,GACNrM,GAAA,EAEJjvC,gBAAgB+2C,GACnB,OACA,SAAS0E,EAAmBxwB,GACxB,OAAQA,GAAM,IAAI7uB,OAAgB,CAAC0B,EAASypC,IAAgB,IACrDzpC,KACCypC,EAAiB,UAAK,CAACA,EAAiB,WAAM,MAC9CA,EAAa,MAAK,CAACA,EAAa,OAAM,MACtCA,EAAe,QAAK,CAACA,EAAe,SAAM,MAC1CA,EAAa,MAAK,CAACA,EAAa,OAAM,MACvCkU,EAAmBlU,EAAiB,WACxC,IATAkU,CAAmB16C,KAAKu6C,OAY5Bt7C,YAAqCwT,GACxC,IAAI7c,EACJ,IAAKA,EAAIoK,KAAKpD,QAAQK,KAAQ,OAAO,KACrC,GAAa,MAARwV,GAAiB7c,EAAEG,MAAM2yB,aAAejW,EACzC,MAAUhU,MAAMg7C,GAAmBhnC,IAEvC,OAAO7c,EAAEG,MAENkJ,aACH,MAAMwT,EAAO4U,EAAcR,OACrBqvB,EAAUl2C,KAAKk6C,YAAYznC,GAC3BxS,EAASi2C,GAAWA,EAAQN,SAClC,IAAKM,IAAYj2C,EACb,MAAUxB,MAAMi7C,GAAYjnC,IAEhC,OAAOxS,GAKR,MAAMk6C,GAAU,EAIVQ,GAAQ,IAAI1gD,WAAW2gD,GAEpC,IAAK,IAAI9lD,GAAI,EAAGA,GAAI8lD,EAAkB9lD,IAAK,EACvC6lD,GAAM7lD,IALe,SAKAyV,WAAWzV,IAI7B,SAAS+lD,GAAyB3gD,EAAoBsB,EAAQ,GACjE,IAAK,IAAI1G,GAAK,EAAGyB,EAAIokD,GAAMx/C,SAAUrG,EAAIyB,GACrC,GAAIokD,GAAM7lD,KAAOoF,EAAOsB,EAAQ1G,GAC5B,OAAO,EAGf,OAAO,EAIJ,MAAMgmD,GAAcH,GAAMx/C,OAEpB4/C,GAAkBD,GAAcX,GAEhCa,GAAkC,EAAdF,GAAkBX,GCrM5C,MAAMc,WAAwB5vB,EAUjCpsB,cAAwBgC,QAiCdjB,KAAAwc,YAAc,EACdxc,KAAA22C,OAAsB,GACtB32C,KAAA42C,SAA8B,GAC9B52C,KAAAk7C,eAAiC,GA3CpCj8C,mBAAmDssB,GACtD,MAAM4vB,EAAY,IAAIF,GAChBG,EAAiBlU,GAAyBmU,GAAa9vB,IACtD+vB,EAAiBH,GAAaA,EAAUpJ,UAAUqJ,GACzD,OAAOE,EAKJr8C,MAAwB+lC,GAC3B,IAAKhZ,EAAS2Y,aAAaK,EAAOvyB,MAAO,CACrC,MAAMC,KAAEA,EAAIvX,OAAEA,EAAMo6B,UAAEA,GAAcyP,EACpC,GAAI7pC,EAAS,WAET,MAAM,IAAIsW,WAAW,sDAEpBua,EAASuvB,OAAOvW,EAAOvyB,OACxB+oC,GAAUvmD,KAAK+K,KAAMu1B,GAAa,EAC5B,IAAIt7B,WAAW,GACf2vB,EAAelX,EAAKnX,OAAQJ,EAAQuX,EAAKijB,aAGnD31B,KAAKsrB,MAAM3pB,KAAK,IAAI2lB,GAAUnsB,EAAQo6B,IAE1C,OAAOt0B,MAAMwqB,MAAMuZ,GAGhB/lC,UAA0Bw8C,GAC7B,OAAOz7C,KAEJf,gBAAsC+lC,GAEzC,OAAOhlC,KAAKyrB,MAAMuZ,EAAO1S,SAG7BhH,YAAqB,OAAOtrB,KAAK22C,OACjC55C,cAAuB,OAAOiD,KAAK42C,SACnC98C,iBAA0B,OAAOkG,KAAKwc,YACtC08B,oBAA6B,OAAOl5C,KAAKk7C,gBAS7C,SAASM,GAAiCvxB,GACtC,MAAMnwB,EAAcmwB,EAAOnwB,WAAa,GAAK,EAI7C,OAHAkG,KAAKjD,QAAQ4E,KAAKsoB,GAClBjqB,KAAKk5C,cAAcv3C,KAAK,IAAI4yC,GAAav0C,KAAKwc,YAAa1iB,IAC3DkG,KAAKwc,aAAe1iB,EACbkG,KAwEX,SAAS07C,GAAmI1W,GACxI,OAAOwW,GAAUvmD,KAAK+K,KAAMglC,EAAO/a,OAAOvuB,SAAS,EAAGspC,EAAO7pC,OAAS6pC,EAAOtP,SAIjF,SAASimB,GAAuE3W,GAC5E,MAAM7pC,OAAEA,EAAM8uB,OAAEA,EAAM5sB,aAAEA,GAAiB2nC,EACnC4W,EAAcv+C,EAAa,GAC3Bw+C,EAAax+C,EAAalC,GAC1BrB,EAAaO,KAAKC,IAAIuhD,EAAaD,EAAa3xB,EAAOnwB,WAAa8hD,GAI1E,OAFAJ,GAAUvmD,KAAK+K,KAAMxK,OAAA6gC,GAAA,mBAAA7gC,EAAoB6H,EAAa,GAAIlC,EAAQkC,IAClEm+C,GAAUvmD,KAAK+K,KAAMiqB,EAAOvuB,SAASkgD,EAAaA,EAAc9hD,IACzDkG,KAIX,SAAS87C,GAAiF9W,GACtF,MAAM7pC,OAAEA,EAAMkC,aAAEA,GAAiB2nC,EAMjC,OAJI3nC,GACAm+C,GAAUvmD,KAAK+K,KAAMxK,OAAA6gC,GAAA,mBAAA7gC,CAAmB6H,EAAa,GAAIlC,EAAQkC,IAG9D2C,KAAKyrB,MAAMuZ,EAAO1D,WAAW,IAIxC,SAASya,GAAsE/W,GAC3E,OAAOhlC,KAAK+xC,UAAU/M,EAAOvyB,KAAK2f,SAAS1uB,IAAI,CAACxB,EAAGpN,IAAMkwC,EAAO1D,WAAWxsC,IAAKkiC,OAAOgR,UAAU,GAGrGiT,GAAgBvkD,UAAUw1B,UAnD1B,SAAmE8Y,GAE/D,IAAI/a,EACJ,OAAI+a,EAAOzP,WAAayP,EAAO7pC,OAEpBqgD,GAAUvmD,KAAK+K,KAAM,IAAI/F,WAAW,KACnCgwB,EAAS+a,EAAO/a,kBAAmBhwB,WAEpCuhD,GAAUvmD,KAAK+K,KAAM4pB,EAAeob,EAAOzpC,OAAQypC,EAAO7pC,OAAQ8uB,IAOtEuxB,GAAUvmD,KAAK+K,KAAM+pB,EAAUib,KAqC1CiW,GAAgBvkD,UAAUy1B,SAA2BuvB,GACrDT,GAAgBvkD,UAAU22B,WAA2BquB,GACrDT,GAAgBvkD,UAAUk3B,UAAuB+tB,GACjDV,GAAgBvkD,UAAUm3B,YAAuB8tB,GACjDV,GAAgBvkD,UAAUo3B,qBAA2B4tB,GACrDT,GAAgBvkD,UAAUq3B,UAA2B2tB,GACrDT,GAAgBvkD,UAAU03B,eAA2BstB,GACrDT,GAAgBvkD,UAAUm4B,UAA2B6sB,GACrDT,GAAgBvkD,UAAU44B,aAA2BosB,GACrDT,GAAgBvkD,UAAU64B,UAA2BusB,GACrDb,GAAgBvkD,UAAU+4B,YAAyBssB,GACnDd,GAAgBvkD,UAAUg5B,WAhH1B,SAA+DsV,GAC3D,MAAMvyB,KAAEA,EAAItX,OAAEA,EAAMg3B,QAAEA,EAAO90B,aAAEA,GAAiB2nC,EAIhD,GAFAwW,GAAUvmD,KAAK+K,KAAMmyB,GAEjB1f,EAAKxc,OAASsoB,EAAUgC,OACxB,OAAOw7B,GAAqB9mD,KAAK+K,KAAMglC,GACpC,GAAIvyB,EAAKxc,OAASsoB,EAAUyS,MAAO,CAEtC,GAAIgU,EAAOzpC,QAAU,EAIjB,OAFAigD,GAAUvmD,KAAK+K,KAAM3C,GAEd0+C,GAAqB9mD,KAAK+K,KAAMglC,GACpC,CAIH,MAAMgX,EAAiB7pB,EAAQ92B,OAAO,CAACL,EAAGC,IAAMZ,KAAK6T,IAAIlT,EAAGC,GAAIk3B,EAAQ,IAClE8pB,EAAe,IAAI7/C,WAAW4/C,EAAiB,GAE/CxE,EAAe,IAAIp7C,WAAW4/C,EAAiB,GAAGxlC,MAAM,GACxD0lC,EAAiB,IAAI9/C,WAAWjB,GAIhCghD,EAAmB3mD,OAAA6gC,GAAA,mBAAA7gC,EAAoB6H,EAAa,GAAIlC,EAAQkC,GACtE,IAAK,IAAIozB,EAAQ7uB,EAAOpG,GAAS,IAAKA,EAAQL,IACe,KAApDyG,EAAQ41C,EAAa/mB,EAAS0B,EAAQ32B,OACvCoG,EAAQ41C,EAAa/mB,GAAU0rB,EAAiB1rB,IAEpDyrB,EAAe1gD,GAAS2gD,EAAiB3gD,GAASoG,IAChDq6C,EAAaxrB,GAEnB+qB,GAAUvmD,KAAK+K,KAAMk8C,GAErB,IAAK,IAAI7nB,EAAsBuU,GAAc,EAAGvP,EAAc5mB,EAAK2f,SAASj3B,SAAUytC,EAAavP,GAC/F,GAAIhF,EAAQ2Q,EAAO1D,WAAWsH,GAAa,CACvC,MAAMnY,EAAShe,EAAK0f,QAAQyW,GACtBwT,EAAc/hD,KAAKC,IAAIa,EAAQ8gD,EAAaxrB,IAClDzwB,KAAKyrB,MAAM4I,EAAM14B,MAAM67C,EAAa/mB,GAAS2rB,MAK7D,OAAOp8C,MAoEXi7C,GAAgBvkD,UAAUu5B,cAA2ByrB,GACrDT,GAAgBvkD,UAAU45B,mBAA2BwrB,GACrDb,GAAgBvkD,UAAU65B,SAA2BurB,GC9M9C,MAAMO,WAA0BhxB,EAC5BpsB,MAA+BusB,GAClC,OAAe,MAARA,OAAevpB,EAAYhB,MAAMwqB,MAAMD,GAE3CvsB,WAA+BwxB,OAAEA,IACpC,MAAO,CAAEp7B,KAAQ+zB,EAAUqH,GAAQphB,eAEhCpQ,UAA6BwxB,OAAEA,EAAM1P,SAAEA,EAAQC,SAAEA,IACpD,MAAO,CAAE3rB,KAAQ+zB,EAAUqH,GAAQphB,cAAe0R,SAAYA,EAAUC,SAAYA,GAEjF/hB,YAAiCwxB,OAAEA,EAAMlP,UAAEA,IAC9C,MAAO,CAAElsB,KAAQ+zB,EAAUqH,GAAQphB,cAAekS,UAAa/C,EAAU+C,IAEtEtiB,aAAmCwxB,OAAEA,IACxC,MAAO,CAAEp7B,KAAQ+zB,EAAUqH,GAAQphB,eAEhCpQ,WAA+BwxB,OAAEA,IACpC,MAAO,CAAEp7B,KAAQ+zB,EAAUqH,GAAQphB,eAEhCpQ,WAA+BwxB,OAAEA,IACpC,MAAO,CAAEp7B,KAAQ+zB,EAAUqH,GAAQphB,eAEhCpQ,cAAqCwxB,OAAEA,EAAMzN,MAAEA,EAAKzB,UAAEA,IACzD,MAAO,CAAElsB,KAAQ+zB,EAAUqH,GAAQphB,cAAe2T,MAASA,EAAOzB,UAAaA,GAE5EtiB,WAAgCwxB,OAAEA,EAAMnN,KAAEA,IAC7C,MAAO,CAAEjuB,KAAQ+zB,EAAUqH,GAAQphB,cAAeiU,KAAQ7E,EAAS6E,IAEhErkB,WAA+BwxB,OAAEA,EAAMnN,KAAEA,EAAIvC,SAAEA,IAClD,MAAO,CAAE1rB,KAAQ+zB,EAAUqH,GAAQphB,cAAeiU,KAAQ5E,EAAS4E,GAAOvC,YAEvE9hB,gBAAyCwxB,OAAEA,EAAMuB,SAAEA,EAAQ1O,KAAEA,IAChE,MAAO,CAAEjuB,KAAQ+zB,EAAUqH,GAAQphB,cAAeiU,KAAQ5E,EAAS4E,GAAO0O,YAEvE/yB,eAAuCwxB,OAAEA,EAAMnN,KAAEA,IACpD,MAAO,CAAEjuB,KAAQ+zB,EAAUqH,GAAQphB,cAAeiU,KAAQ3E,EAAa2E,IAEpErkB,WAA+BwxB,OAAEA,IACpC,MAAO,CAAEp7B,KAAQ+zB,EAAUqH,GAAQphB,eAEhCpQ,aAAmCwxB,OAAEA,IACxC,MAAO,CAAEp7B,KAAQ+zB,EAAUqH,GAAQphB,eAEhCpQ,YAAiCwxB,OAAEA,EAAMx6B,KAAEA,EAAIk8B,QAAEA,IACpD,MAAO,CACH98B,KAAQ+zB,EAAUqH,GAAQphB,cAC1BpZ,KAAQsoB,EAAUtoB,GAClBk8B,QAAW,IAAIA,IAGhBlzB,gBAA2CusB,GAC9C,OAAOxrB,KAAKyrB,MAAMD,EAAK+G,YAEpBtzB,sBAAqDwxB,OAAEA,EAAMjO,UAAEA,IAClE,MAAO,CAAEntB,KAAQ+zB,EAAUqH,GAAQphB,cAAemT,UAAaA,GAE5DvjB,oBAAiDwxB,OAAEA,EAAM5Q,SAAEA,IAC9D,MAAO,CAAExqB,KAAQ+zB,EAAUqH,GAAQphB,cAAewQ,SAAYA,GAE3D5gB,UAA8BwxB,OAAEA,EAAMvQ,WAAEA,IAC3C,MAAO,CAAE7qB,KAAQ+zB,EAAUqH,GAAQphB,cAAe6Q,WAAcA,IC3BjE,MAAMo8B,WAA4BjxB,EAG9BpsB,mBAAmDssB,GACtD,OAAO,IAAI+wB,IAAsBvK,UAAU3K,GAAyBiU,GAAa9vB,IAG9EtsB,MAAwBunC,GAC3B,MAAM9zB,KAAEA,EAAIrd,KAAEA,EAAI8F,OAAEA,GAAWqrC,GACzBjrC,OAAEA,EAAMg6B,UAAEA,EAASI,WAAEA,GAAejjB,EACpCD,EAAOuZ,EAAS2Y,aAAa6B,EAAO/zB,MAAQ+zB,EAAO/zB,KAAK6f,QAAUkU,EAAO/zB,KACzE1V,EAAUvH,OAAOooC,OAAO,GAAIlrB,EAAK3V,QAAS,CAAEkC,CAACkqB,EAAW8M,eAAWh0B,IACzE,MAAO,CACH5M,KAAQA,EACRib,MAASnV,EACT86B,SAAYjK,EAASuvB,OAAO9oC,QAAQxQ,EAC9BszB,GAAa,EAAI5mB,MAAM1S,KAAK,CAAEd,UAAU,IAAM,GAC9C,IAAI6uB,EAAY2L,EAAYp6B,EAAQJ,EAAQ,KAAMuuB,OACrDzoB,MAAMwqB,MAAMrN,EAAO4a,IAAItmB,EAAKojB,MAAMrjB,EAAMlX,EAAQJ,EAAQ,EAAG4B,MAG/DkC,YAAc,MAAO,GACrBA,WAA0BgrB,OAAEA,EAAM1uB,OAAEA,EAAMJ,OAAEA,IAC/C,MAAO,CAAEi7B,KAAQ,IAAIpM,EAAYC,EAAQ1uB,EAAQJ,EAAQ,KAAMkuB,KAE5DpqB,SAAwB+lC,GAC3B,MAAO,CACH5O,KAAQ4O,EAAOvyB,KAAKsO,SAAW,GACzB,IAAIikB,EAAO/a,QACX,IAAIsyB,GAAiBvX,EAAO/a,OAAsC,KAGzEhrB,WAA4B+lC,GAC/B,MAAO,CAAE5O,KAAQ,IAAI4O,EAAO/a,SAEzBhrB,UAA0B+lC,GAC7B,MAAO,CAAE5O,KAAQ,IAAI4O,GAAS7O,OAAU,IAAI6O,EAAO3nC,eAEhD4B,YAA8B+lC,GACjC,MAAO,CAAE5O,KAAQ,IAAIomB,GAAexX,IAAU7O,OAAQ,IAAI6O,EAAO3nC,eAE9D4B,qBAAgD+lC,GACnD,MAAO,CAAE5O,KAAQ,IAAIomB,GAAexX,KAEjC/lC,UAA2B+lC,GAC9B,MAAO,CACH5O,KAAQ4O,EAAOvyB,KAAK6Q,OAAS7E,EAASqS,IAChC,IAAIkU,EAAO/a,QACX,IAAIsyB,GAAiBvX,EAAO/a,OAAQ,KAG3ChrB,eAAoC+lC,GACvC,MAAO,CAAE5O,KAAQ,IAAImmB,GAAiBvX,EAAO/a,OAAQ,KAElDhrB,UAA0B+lC,GAC7B,MAAO,CACH5O,KAAQ4O,EAAOvyB,KAAK6Q,KAAO5E,EAASkS,YAC9B,IAAIoU,EAAO/a,QACX,IAAIsyB,GAAiBvX,EAAO/a,OAAQ,KAG3ChrB,aAAgC+lC,GACnC,MAAO,CAAE5O,KAAQ,IAAImmB,GAAiBvX,EAAO/a,OAAQ,KAElDhrB,UAA0B+lC,GAC7B,MAAO,CACH7O,OAAU,IAAI6O,EAAO3nC,cACrB+0B,SAAY4S,EAAOvyB,KAAK2f,SAAS1uB,IAAI,CAAC8tB,EAAG18B,IACrCkL,KAAKyrB,MAAM,IAAIwa,GAAOzU,EAAG,CAACwT,EAAO1D,WAAWxsC,QAGjDmK,YAA8B+lC,GACjC,MAAO,CACH5S,SAAY4S,EAAOvyB,KAAK2f,SAAS1uB,IAAI,CAAC8tB,EAAG18B,IACrCkL,KAAKyrB,MAAM,IAAIwa,GAAOzU,EAAG,CAACwT,EAAO1D,WAAWxsC,QAGjDmK,WAA4B+lC,GAC/B,MAAO,CACH9O,KAAQ,IAAI8O,EAAO7S,SACnBgE,OAAU6O,EAAOvyB,KAAKxc,OAASsoB,EAAUyS,MAAQ,IAAIgU,EAAO3nC,mBAAgB4E,EAC5EmwB,SAAY4S,EAAOvyB,KAAK2f,SAAS1uB,IAAI,CAAC8tB,EAAG18B,IAAMkL,KAAKyrB,MAAM,IAAIwa,GAAOzU,EAAG,CAACwT,EAAO1D,WAAWxsC,QAG5FmK,cAAkC+lC,GACrC,MAAO,CAAE5O,KAAQ,IAAI4O,EAAO/a,SAEzBhrB,mBAA4C+lC,GAC/C,MAAO,CACH5S,SAAY4S,EAAOvyB,KAAK2f,SAAS1uB,IAAI,CAAC8tB,EAAG18B,IACrCkL,KAAKyrB,MAAM,IAAIwa,GAAOzU,EAAG,CAACwT,EAAO1D,WAAWxsC,QAGjDmK,SAAyB+lC,GAC5B,MAAO,CACH7O,OAAU,IAAI6O,EAAO3nC,cACrB+0B,SAAY4S,EAAOvyB,KAAK2f,SAAS1uB,IAAI,CAAC8tB,EAAG18B,IACrCkL,KAAKyrB,MAAM,IAAIwa,GAAOzU,EAAG,CAACwT,EAAO1D,WAAWxsC,SAM5D,SAAU0nD,GAAexX,GACrB,IAAK,MAAMyX,KAAUzX,QACXyX,EAAOphD,OAAO,CAACiZ,EAAKkV,OACZlV,KAAO,KAAc,IAAPkV,GAAa1b,SAAS,KAAKnS,OAAO,KAC3D,IAAI+gD,cAKf,SAAUH,GAAiBtyB,EAAkCyL,GACzD,IAAK,IAAI5gC,GAAK,EAAGyB,EAAI0zB,EAAO9uB,OAASu6B,IAAU5gC,EAAIyB,WACtCwnC,GAAG/E,IAAI/O,EAAOvuB,UAAU5G,EAAI,GAAK4gC,GAAS5gC,EAAI,GAAK4gC,IAAS,KC5HtE,MAAMinB,WAAuEzO,GAAA,EAiBhFjvC,YAAYsB,GACRU,QAMMjB,KAAA48C,UAAY,EACZ58C,KAAA68C,UAAW,EAIX78C,KAAA88C,MAAQ,IAAI7O,GACZjuC,KAAAq4C,QAAyB,KACzBr4C,KAAA+8C,kBAAiC,GACjC/8C,KAAAg9C,mBAAkC,GAClCh9C,KAAAi9C,wBAA0B,IAAIh9B,IAdpCzqB,OAAAyhC,GAAA,EAAAzhC,CAAS+K,KAAaA,EAAU,CAAE28C,aAAa,EAAMC,sBAAsB,IAC3En9C,KAAKo9C,aAA+C,kBAAxB78C,EAAQ28C,aAA6B38C,EAAQ28C,YACzEl9C,KAAKq9C,sBAAiE,kBAAjC98C,EAAQ48C,sBAAsC58C,EAAQ48C,qBAjBxFl+C,mBAAmBsB,GACtB,MAAU9B,MAAM,mDAGbQ,kBAEHq+C,EAEAC,GAEA,MAAU9+C,MAAM,kDAuBbQ,SAASkvC,GAAY,GACxB,OAAOnuC,KAAK88C,MAAMhvC,SAASqgC,GAIxBlvC,aAAakvC,GAAY,GAC5B,OAAOnuC,KAAK88C,MAAMxlD,aAAa62C,GAO5BlvC,SAASpD,GACZ,OAAIrG,OAAAyhC,GAAA,EAAAzhC,CAAeqG,GACRA,EAAM2D,KAAMxE,GAAMgF,KAAKw9C,SAASxiD,IAChCxF,OAAAyhC,GAAA,EAAAzhC,CAAgCqG,GAChC4hD,GAAcz9C,KAAMnE,GAExB2hD,GAASx9C,KAAYnE,GAGhC0F,aAAsB,OAAOvB,KAAK88C,MAAMv7C,OACjCtC,CAACpJ,OAAOuH,iBAAmB,OAAO4C,KAAK88C,MAAMjnD,OAAOuH,iBACpD6B,YAAYsB,GAAsC,OAAOP,KAAK88C,MAAMh8C,YAAYP,GAChFtB,aAAasB,GAA8C,OAAOP,KAAK88C,MAAM97C,aAAaT,GAE1FtB,QACH,OAAOe,KAAK09C,QAAQZ,MAAM16C,QAEvBnD,MAAMuC,GACT,OAAOxB,KAAK09C,QAAQZ,MAAM36C,MAAMX,GAE7BvC,SAEH,OADAe,KAAKo9C,aAAep9C,KAAKoC,QAAUpC,KAAK09C,MAAM19C,KAAK88C,MAAO98C,KAAKq4C,SACxDr4C,KAEJf,MAAM0+C,EAA2C39C,KAAK88C,MAAO78C,EAA2B,MAiC3F,OA/BK09C,IAAS39C,KAAK88C,OAAWa,aAAgB1P,GAC1CjuC,KAAK88C,MAAQa,GAEb39C,KAAK88C,MAAQ,IAAI7O,GACb0P,GAAQnoD,OAAAyhC,GAAA,EAAAzhC,CAAoBmoD,GAC5B39C,KAAKc,YAAY,CAAE2R,KAAM,UAAW/R,OAAOi9C,GACpCA,GAAQnoD,OAAAyhC,GAAA,EAAAzhC,CAAqBmoD,IACpC39C,KAAKgB,aAAa,CAAE48C,YAAY,IAASn9C,KAAKk9C,IAIlD39C,KAAK68C,UAAY78C,KAAKq4C,SACtBr4C,KAAK69C,aAAa79C,KAAKq4C,SAG3Br4C,KAAK68C,UAAW,EAChB78C,KAAK+8C,kBAAoB,GACzB/8C,KAAKg9C,mBAAqB,GAC1Bh9C,KAAKi9C,wBAA0B,IAAIh9B,IAE9BhgB,GAAYA,EAAO69C,UAAU99C,KAAKq4C,WACpB,OAAXp4C,GACAD,KAAK48C,UAAY,EACjB58C,KAAKq4C,QAAU,OAEfr4C,KAAK68C,UAAW,EAChB78C,KAAKq4C,QAAUp4C,EACfD,KAAK+9C,aAAa99C,KAInBD,KAGJf,MAAM++C,GAET,IAAI/9C,EAA2B,KAE/B,IAAKD,KAAK88C,MACN,MAAUr+C,MAAM,+BACb,GAAIu/C,QACP,OAAOh+C,KAAKmK,eAAYlI,EACrB,GAAI+7C,aAAmBC,MAAWh+C,EAAS+9C,EAAQ/9C,QACtD,OAAOD,KAAKmK,eAAYlI,EACrB,GAAI+7C,aAAmB3C,MAAiBp7C,EAAS+9C,EAAQ/9C,QAC5D,OAAOD,KAAKmK,eAAYlI,EAG5B,GAAIhC,IAAWA,EAAO69C,UAAU99C,KAAKq4C,SAAU,CAC3C,GAAIr4C,KAAK68C,UAAY78C,KAAKo9C,aACtB,OAAOp9C,KAAKoC,QAEhBpC,KAAK09C,MAAM19C,KAAK88C,MAAO78C,GAGvB+9C,aAAmB3C,GACb2C,aAAmBE,IACrBl+C,KAAKm+C,kBAAkBH,GAEpBA,aAAmBC,GAC1Bj+C,KAAKw9C,SAASQ,EAAQxjD,QACfhF,OAAAyhC,GAAA,EAAAzhC,CAAWwoD,IAClBh+C,KAAKw9C,SAASQ,GAIZ/+C,cAAuCi3C,EAAqBjrC,EAAY,GAE9E,MAAM3N,EAAI2N,EAAY,EAChB/Q,EAASy7C,GAAQ3nC,OAAOkoC,GACxBkI,EAAiBlkD,EAAOJ,WACxBukD,EAAcr+C,KAAKq9C,sBAA4B,EAAJ,EAC3CvzB,EAAes0B,EAAiBC,EAAa/gD,GAAMA,EACnDghD,EAAgBx0B,EAAcs0B,EAAiBC,EAiBrD,OAfInI,EAAQxtB,aAAerB,EAAcG,YACrCxnB,KAAKg9C,mBAAmBr7C,KAAK,IAAIwrC,GAAUrjB,EAAaosB,EAAQttB,WAAY5oB,KAAK48C,YAC1E1G,EAAQxtB,aAAerB,EAAcW,iBAC5ChoB,KAAK+8C,kBAAkBp7C,KAAK,IAAIwrC,GAAUrjB,EAAaosB,EAAQttB,WAAY5oB,KAAK48C,YAI/E58C,KAAKq9C,uBACNr9C,KAAKu+C,OAAOniD,WAAWoiD,IAAI,IAG/Bx+C,KAAKu+C,OAAOniD,WAAWoiD,GAAG10B,EAAcu0B,IAEpCD,EAAiB,GAAKp+C,KAAKu+C,OAAOrkD,GAE/B8F,KAAKy+C,cAAcH,GAGpBr/C,OAAOylC,GACb,GAAI1kC,KAAK68C,SAAU,CACf,MAAM3iD,EAAS1E,OAAA6gC,GAAA,aAAA7gC,CAAakvC,GACxBxqC,GAAUA,EAAOJ,WAAa,IAC9BkG,KAAK88C,MAAM3qC,MAAMjY,GACjB8F,KAAK48C,WAAa1iD,EAAOJ,YAGjC,OAAOkG,KAGDf,aAAagB,GACnB,OAAOD,KAAK0+C,cAAc/I,GAAQ15C,KAAKgE,IAIjChB,aAAagB,GAEnB,OAAOD,KAAKq9C,sBACNr9C,KAAKu+C,OAAOniD,WAAWoiD,GAAG,IAC1Bx+C,KAAKu+C,OAAOniD,WAAWoiD,IAAI,EAAG,IAG9Bv/C,cACN,OAAOe,KAAKu+C,OAAO5D,IAGb17C,cAAcoe,GACpB,OAAOA,EAAS,EAAIrd,KAAKu+C,OAAO,IAAItkD,WAAWojB,IAAWrd,KAGpDf,kBAAkB85C,GACxB,MAAMj/C,WAAEA,EAAUwxB,MAAEA,EAAK4tB,cAAEA,EAAan8C,QAAEA,GAAYk+C,GAAgB0D,SAAS5F,GACzEN,EAAc,IAAIvE,GAAqB6E,EAAM59C,OAAQmwB,EAAO4tB,GAC5DhD,EAAUP,GAAQ15C,KAAKw8C,EAAa3+C,GAC1C,OAAOkG,KACF4+C,mBAAmB7F,GACnB2F,cAAcxI,GACd2I,kBAAkB9hD,GAGjBkC,sBAAsBszB,EAAoBpN,EAAY+C,GAAU,GACtEloB,KAAKi9C,wBAAwB1iD,IAAI4qB,EAAIoN,EAAWp3B,QAAU6E,KAAKi9C,wBAAwBtnD,IAAIwvB,IAAO,IAClG,MAAMrrB,WAAEA,EAAUwxB,MAAEA,EAAK4tB,cAAEA,EAAan8C,QAAEA,GAAYk+C,GAAgB0D,SAASpsB,GACzEkmB,EAAc,IAAIvE,GAAqB3hB,EAAWp3B,OAAQmwB,EAAO4tB,GACjEG,EAAkB,IAAIrxB,GAAyBywB,EAAatzB,EAAI+C,GAChEguB,EAAUP,GAAQ15C,KAAKo9C,EAAiBv/C,GAC9C,OAAOkG,KACF0+C,cAAcxI,GACd2I,kBAAkB9hD,GAGjBkC,kBAAkBlC,GACxB,IAAI7C,EACAO,EAAcqkD,EAClB,IAAK,IAAIhqD,GAAK,EAAGyB,EAAIwG,EAAQ5B,SAAUrG,EAAIyB,IAClC2D,EAAS6C,EAAQjI,MAAQ2F,EAAOP,EAAOJ,YAAc,IACtDkG,KAAKu+C,OAAOrkD,IACP4kD,GAAYrkD,EAAO,GAAK,GAAMA,GAAQ,GACvCuF,KAAKy+C,cAAcK,IAI/B,OAAO9+C,KAGDf,mBAAmB85C,GACzB,IAAK,IAAK5zB,EAAIoN,KAAewmB,EAAM54C,aAAc,CAC7C,IAAI5E,EAASyE,KAAKi9C,wBAAwBtnD,IAAIwvB,IAAO,EACrD,GAAe,IAAX5pB,IAAiBg3B,EAAaA,EAAW52B,MAAMJ,IAASJ,OAAS,EAAG,CACpE,MAAMX,EAAS,WAAY+3B,EAAcA,EAAmB/3B,OAAS,CAAC+3B,GACtE,IAAK,MAAMmS,KAASlqC,EAChBwF,KAAK++C,sBAAsBra,EAAOvf,EAAI5pB,EAAS,GAC/CA,GAAUmpC,EAAMvpC,QAI5B,OAAO6E,MAKR,MAAMg/C,WAA6ErC,GAM/E19C,gBAA6DpD,EAAY0E,GAC5E,MAAM0+C,EAAS,IAAID,GAA2Bz+C,GAC9C,OAAI/K,OAAAyhC,GAAA,EAAAzhC,CAAeqG,GACRA,EAAM2D,KAAMxE,GAAMikD,EAAOzB,SAASxiD,IAClCxF,OAAAyhC,GAAA,EAAAzhC,CAAgCqG,GAChC4hD,GAAcwB,EAAQpjD,GAE1B2hD,GAASyB,EAAQpjD,IAKzB,MAAMqjD,WAA2EvC,GAgBpF19C,cACIgC,QACAjB,KAAKo9C,cAAe,EAZjBn+C,gBAA6DpD,GAChE,MAAMojD,EAAS,IAAIC,GACnB,OAAI1pD,OAAAyhC,GAAA,EAAAzhC,CAAeqG,GACRA,EAAM2D,KAAMxE,GAAMikD,EAAOzB,SAASxiD,IAClCxF,OAAAyhC,GAAA,EAAAzhC,CAAgCqG,GAChC4hD,GAAcwB,EAAQpjD,GAE1B2hD,GAASyB,EAAQpjD,GASlBoD,aAAagB,GACnB,OAAOD,KAAKm/C,cAAcV,cAAc,GAGlCx/C,aAAagB,GACnB,MAAM/F,EAASqyC,GAAOv+B,OAAO,IAAIu+B,GAC7BtsC,EAAQqe,EAAgBkuB,GACxBxsC,KAAKg9C,mBAAoBh9C,KAAK+8C,oBAElC,OAAO97C,MACF48C,aAAa59C,GACbs+C,OAAOrkD,GACPqkD,OAAOniD,WAAWoiD,GAAGtkD,EAAOJ,aAC5BqlD,eAKN,MAAMC,WAA2EzC,GAepF19C,cACIgC,QACAjB,KAAKo9C,cAAe,EACpBp9C,KAAK2sC,eAAiB,GACtB3sC,KAAKq/C,cAAgB,GAXlBpgD,gBAA6FpD,GAChG,OAAO,IAAIujD,IAA2B5B,SAAS3hD,GAazCoD,gBAAkB,OAAOe,KAEzBf,aAAagB,GAAqB,OAAOD,KACzCf,aAAagB,GACnB,OAAOD,KAAKu+C,yBACR7nB,KAAKC,UAAU,CAAEtF,OAAQpxB,EAAOoxB,OAAO3tB,IAAI47C,KAAgB,KAAM,MAG/DrgD,mBAAmB85C,GAIzB,OAHIA,EAAM54C,aAAa1F,KAAO,GAC1BuF,KAAKq/C,cAAc19C,KAAKo3C,GAErB/4C,KAEDf,sBAAsBszB,EAAoBpN,EAAY+C,GAAU,GAKtE,OAJAloB,KAAKi9C,wBAAwB1iD,IAAI4qB,EAAIoN,EAAWp3B,QAAU6E,KAAKi9C,wBAAwBtnD,IAAIwvB,IAAO,IAClGnlB,KAAKu+C,OAAyC,IAAlCv+C,KAAK+8C,kBAAkB5hD,OAAe,OAAS,WAC3D6E,KAAKu+C,UA4Eb,SAA+BhsB,EAAoBpN,EAAY+C,GAAU,GACrE,MAAMxd,EAAQ,IAAI27B,MAASlhB,IAAMoN,EAAW9f,KAAM8f,EAAWgD,UAAY,GACnEuP,EAAUwX,GAAoBqC,SAAS,IAAI1Y,GAAOv7B,EAAO,CAAC6nB,KAChE,OAAOmE,KAAKC,UAAU,CAClBxR,GAAMA,EACN+C,QAAWA,EACXxV,KAAQ,CACJpC,MAASiiB,EAAWp3B,OACpB2pC,QAAWA,IAEhB,KAAM,GAtFUya,CAAsBhtB,EAAYpN,EAAI+C,MACrDloB,KAAK+8C,kBAAkBp7C,KAAK,IAAIwrC,GAAU,EAAG,EAAG,IACzCntC,KAEDf,kBAAkB85C,GAGxB,OAFA/4C,KAAK4+C,mBAAmB7F,GACxB/4C,KAAK2sC,eAAehrC,KAAKo3C,GAClB/4C,KAEJf,QAEH,GAAIe,KAAKq/C,cAAclkD,OAAS,EAAG,CAC/B6E,KAAKu+C,OAAO,4BACZ,IAAK,MAAMxF,KAAS/4C,KAAKq/C,cACrBp+C,MAAM29C,mBAAmB7F,GAE7B/4C,KAAKu+C,OAAO,SAGhB,GAAIv+C,KAAK2sC,eAAexxC,OAAS,EAAG,CAChC,IAAK,IAAIrG,GAAK,EAAGyB,EAAIyJ,KAAK2sC,eAAexxC,SAAUrG,EAAIyB,GACnDyJ,KAAKu+C,OAAa,IAANzpD,EAAU,0BAA4B,WAClDkL,KAAKu+C,UAoEMiB,EApEsBx/C,KAAK2sC,eAAe73C,GAqE1D4hC,KAAKC,UAAU,CAClBrmB,MAASkvC,EAAQrkD,OACjB2pC,QAAWwX,GAAoBqC,SAASa,IACzC,KAAM,MAvEGx/C,KAAKg9C,mBAAmBr7C,KAAK,IAAIwrC,GAAU,EAAG,EAAG,IAErDntC,KAAKu+C,OAAO,SAiExB,IAA2BiB,EAvDnB,OAPIx/C,KAAKq4C,SACLr4C,KAAKu+C,OAAO,OAGhBv+C,KAAKq/C,cAAgB,GACrBr/C,KAAK2sC,eAAiB,GAEf1rC,MAAMmB,SAKrB,SAASo7C,GAAsDyB,EAA8BpjD,GACzF,IAAIrB,EAASqB,EACTA,aAAiBoiD,KACjBzjD,EAASqB,EAAMrB,OACfykD,EAAOvB,WAAMz7C,EAAWpG,EAAMoE,SAElC,IAAK,MAAM84C,KAASv+C,EAChBykD,EAAO9sC,MAAM4mC,GAEjB,OAAOkG,EAAO90C,SAIlBjN,eAAeugD,GAA2DwB,EAA8B/+C,GACpG,UAAW,MAAM64C,KAAS74C,EACtB++C,EAAO9sC,MAAM4mC,GAEjB,OAAOkG,EAAO90C,SAIlB,SAASm1C,IAAYjqD,KAAEA,EAAIod,KAAEA,EAAIqT,SAAEA,IAC/B,MAAMq1B,EAAY,IAAIkB,GACtB,MAAO,CACHhnD,KAAQA,EAAMywB,SAAYA,EAC1BrT,KAAQ0oC,EAAU1vB,MAAMhZ,GACxB2f,UAAa3f,EAAK2f,UAAY,IAAI1uB,IAAI47C,IACtC/sB,WAAevG,EAAS2Y,aAAalyB,GAAoB,CACrD0S,GAAM1S,EAAK0S,GACXE,UAAa5S,EAAK4S,UAClB2uB,UAAamH,EAAU1vB,MAAMhZ,EAAK6f,eAHOrwB,GCxbrD,MAAMw9C,GAAU,IAAIxlD,WAAW,GACzBylD,GAAYC,GAAmC,CACjDF,GAASA,GAAS,IAAIxlD,WAAW0lD,GAAeF,IAiC7C,SAASG,GAAgF3/C,EAAmB4/C,GAC/G,OAIJ,SAAmG5/C,EAAmB6kC,GAElH,MAAMzT,EAAS,IAAIpxB,EAAOoxB,QACpByuB,EAAY,GACZnhB,EAAO,CAAEohB,WAAYjb,EAAQzpC,OAAO,CAAC9E,EAAGpB,IAAMkF,KAAK6T,IAAI3X,EAAGpB,EAAEgG,QAAS,IAE3E,IAEIk5B,EAFA0rB,EAAa,EAAGC,EAAc,EAC9BlrD,GAAa,EAAGmrD,EAAanb,EAAQ3pC,OACZq6B,EAAgC,GAE7D,KAAOmJ,EAAKohB,cAAe,GAAG,CAE1B,IAAKC,EAAcE,IAA0BprD,GAAK,IAAKA,EAAImrD,GACvDzqB,EAAU1gC,GAAKu/B,EAAQyQ,EAAQhwC,GAAG8M,QAClCo+C,EAAc3lD,KAAKC,IAAI0lD,EAAa3rB,EAAQA,EAAMl5B,OAAS6kD,GAG3Dr8C,SAASq8C,KACTxqB,EAAY2qB,GAAoB9uB,EAAQ2uB,EAAaxqB,EAAWsP,EAASnG,GACrEqhB,EAAc,IACdF,EAAUC,KAAgB,CAACC,EAAaxqB,EAAU75B,WAI9D,MAAO,CACHsE,EAAS,IAAIynC,GAAUrW,EAAQpxB,EAAOsmC,UACtCuZ,EAAUp8C,IAAKwmB,GAAO,IAAImxB,GAAYp7C,KAAWiqB,KA9B9Ck2B,CAAgDngD,EAAQ4/C,EAAKn8C,IAAKk9B,GAAMA,aAAamD,GAAUnD,EAAEpmC,OAAOkJ,IAAKvO,GAAMA,EAAEud,MAAQ,CAACkuB,EAAEluB,QAmC3I,SAASytC,GAAiE9uB,EAA6B2uB,EAAqBxqB,EAA+BsP,EAA+BnG,GACtL,IAAIjsB,EACAhI,EACAvP,EAAS,EAAGrG,GAAK,EAAGyB,EAAIuuC,EAAQ3pC,OACpC,MAAMwkD,GAAiBK,EAAc,IAAM,KAAQ,EACnD,OAASlrD,EAAIyB,IACJmc,EAAO8iB,EAAU1gC,MAASqG,EAASuX,EAAKvX,SAAW6kD,EAChD7kD,IAAW6kD,EACXxqB,EAAU1gC,GAAK4d,GAEf8iB,EAAU1gC,GAAK4d,EAAK/W,MAAM,EAAGqkD,GAC7BttC,EAAOA,EAAK/W,MAAMqkD,EAAa7kD,EAAS6kD,GACxCrhB,EAAKohB,WAAa1lD,KAAK6T,IAAIywB,EAAKohB,WAAYjb,EAAQhwC,GAAG+Z,QAAQ6D,OAGlEhI,EAAQ2mB,EAAOv8B,IAAIgxB,WAAauL,EAAOv8B,GAAK4V,EAAMorB,MAAM,CAAEhQ,UAAU,KACrE0P,EAAU1gC,GAAK4d,EAAOA,EAAK2tC,mCAAmCL,GACxDl0B,GAAKkN,IAAItuB,EAAM+H,KAAM,EAAGutC,EAAaA,EAAaN,GAASC,KAGzE,OAAOnqB,ECnFJ,MAAe8qB,WAA6CliC,EAK/Dnf,YAAYyT,EAAe0f,GACvBnxB,QACAjB,KAAK+kC,UAAY3S,EACjBpyB,KAAKq5B,YAAc3mB,EAAK8iB,UAAUr6B,OAClC6E,KAAKugD,mBAAmBvgD,KAAK0S,KAAOA,GAMxCD,WAAoB,OAAOzS,KAAK0S,KAAKD,KACrCge,aAAsB,OAAOzwB,KAAK0S,KAAK+d,OACvCt1B,aAAsB,OAAO6E,KAAK0S,KAAKvX,OACvCI,aAAsB,OAAOyE,KAAK0S,KAAKnX,OACvCm6B,aAAsB,OAAO11B,KAAK0S,KAAKgjB,OACvCH,gBAAyB,OAAOv1B,KAAK0S,KAAK6iB,UAC1Cz7B,iBAA0B,OAAOkG,KAAK0S,KAAK5Y,WAC3C2qC,iBAA0B,SAAU7lB,EAAK5e,KAAKywB,gBAE9CgC,gBAAyC,OAAOzyB,KAAKyS,KAAKggB,UAE1DxI,aAAsB,OAAOjqB,KAAK0S,KAAKuX,OACvCkI,cAAuB,OAAOnyB,KAAK0S,KAAKyf,QACxCwD,iBAA0B,OAAO31B,KAAK0S,KAAKijB,WAC3Ct4B,mBAA4B,OAAO2C,KAAK0S,KAAKrV,aAE7C1H,IAAYE,OAAOC,eAAiB,SAAUkK,KAAKykC,cAAczkC,KAAKyS,KAAK5c,OAAOC,gBAE3EmJ,MAA8ByT,EAAe0f,EAAWpyB,KAAK+kC,WAChE,OAAO3mB,EAAO4a,IAAOtmB,EAAM0f,GAGxBnzB,UAAUqyB,GACb,OAAOyS,GAAQntB,OAAU5W,QAASsxB,GAG/BryB,MAAMkrB,EAAgBjV,GAIzB,OAAOstB,GAAWxiC,KAAMmqB,EAAOjV,EAAKlV,KAAK6kC,gBAGtC5lC,QAAQzD,GACX,GAAIwE,KAAKu1B,UAAY,EAAG,CACpB,MAAMZ,EAAM30B,KAAKzE,OAASC,EAG1B,OAAgB,KAFJwE,KAAK21B,WAAWhB,GAAO,GACd,GAAMA,EAAM,GAGrC,OAAO,EAGJ11B,WAAqCzD,GACxC,OAAOA,EAAQ,GAAKA,GAASwE,KAAKq5B,YAAc,MAC3Cr5B,KAAK+kC,YAAc/kC,KAAK+kC,UAAY,KAAKvpC,KACzCwE,KAAK+kC,UAAUvpC,GAAS4iB,EAAO4a,IAAOh5B,KAAK0S,KAAK8iB,UAAUh6B,KAI5DyD,SAAgB,MAAO,IAAIe,MAExBf,eAAeomC,EAAYlb,EAAejV,GAChD,OAAOmwB,EAAKvP,MAAMuP,EAAK3yB,KAAK/W,MAAMwuB,EAAOjV,EAAMiV,GAAQ,MAIjDlrB,mBAAmByT,KAKhC4tC,GAAW5pD,UAAkBb,OAAO2qD,qBAAsB,ECxFpD,MAAMC,WAAqBH,GACvBrhD,SACH,OAAOmf,EAAO4a,IAAIh5B,KAAK0S,KAAKojB,MAAM,IAAI7C,MCCvC,MAAMytB,WAAmBJ,GAMrBrhD,YAAyBpD,GAC5B,OAAO8kD,GAAyB,IAAM,IAAIztB,GAAQr3B,ICFnD,MAAM+kD,WAA4CN,GAQ9CrhD,eAA6CssB,GAChD,OAAoB,IAAhBA,EAAKpwB,OACEwlD,GAAyB,IAAMp1B,EAAK,KAAO9M,EAASqS,IAAM,IAAIuC,GAAY,IAAIC,GAAwB/H,EAAK,IAE/Go1B,GAAyB,IAAM,IAAIrtB,GAAwB/H,EAAK,KAKxE,MAAMs1B,WAAsBD,IAG5B,MAAME,WAA8BF,IC7BpC,MAAMG,WAAsBT,ICS5B,MAAMU,WAA+EV,GAcxFrhD,YAAYyT,GACRzR,MAAMyR,GACN1S,KAAKsyB,QAAUlU,EAAO4a,IAAItmB,EAAKojB,MAAM91B,KAAKyS,KAAK6f,UAX5CrzB,eAAqEssB,GACxE,GAAoB,IAAhBA,EAAKpwB,OAAc,CACnB,MAAO8uB,EAAQqI,EAASmO,GAAQlV,EAC1B9Y,EAAO,IAAI2iB,GAAWnL,EAAOxX,KAAM6f,EAAS,KAAM,MACxD,OAAOlU,EAAO4a,IAAIlN,GAAKiE,WAAWtd,EAAM,EAAGguB,EAAKtlC,OAAQ,EAAG,KAAMslC,EAAMxW,IAE3E,OAAO02B,GAAyB,IAAMp1B,EAAK,GAAG9Y,KAAM8Y,EAAK,IAU7DgH,iBAA0B,OAAmBvyB,KAAK0S,KAAK6f,WAChDtzB,cAAclJ,GAAY,OAAOiK,KAAKuyB,WAAW5hB,QAAQ5a,GACzDkJ,OAAO01B,GAAsC,OAAO30B,KAAKsyB,QAAQ38B,IAAIg/B,GACrE11B,SAAS5I,GAAmC,OAAO2J,KAAKuyB,WAAW58B,IAAIU,GACvE4I,OAAO01B,EAAat+B,GAA8B,OAAO2J,KAAKsyB,QAAQ/3B,IAAIo6B,EAAKt+B,GAC/E4I,SAAS5I,EAAaN,GAA6B,OAAOiK,KAAKuyB,WAAWh4B,IAAIlE,EAAKN,IAG7FirD,GAAiBtqD,UAAkB47B,QAAU,KCtCvC,MAAM2uB,WAA8BX,ICApC,MAAMY,WAAsDZ,ICyB5D,MAAMa,WAA6Cb,GAmB/CrhD,YAAyEpD,GAE5E,IAAIulD,EAAYC,GAAqBrhD,MAErC,GAAKnE,aAAiBpC,aAAgBA,YAAYsC,OAAOF,GAAQ,CAC7D,IAAIylD,EAAYC,GAAoB1lD,EAAMq1B,cAAkCkwB,EAQ5E,GALkB,OAAdA,IACAA,EAAYE,GAIZF,GAAaA,IAAcE,EAAW,CACtC,IAAI7uC,EAAO,IAAI2uC,EACXjmD,EAASU,EAAM/B,WAAa2Y,EAAKggB,UAAUz2B,kBAG/C,IAAKwlD,GAAeJ,EAAWvlD,EAAMq1B,aACjC,OAAO9S,EAAO4a,IAAIlN,GAAKsB,MAAM3a,EAAM,EAAGtX,EAAQ,EAAG,KAAMU,KAKnE,GAAIulD,EAIA,OAAOT,GAAyB,IAAM,IAAIS,EAAmBvlD,GAGjE,GAAKA,aAAiBkvB,UAAclvB,aAAiBpC,YACjD,MAAM,IAAI2U,sDAAsDvS,EAAMq1B,YAAY77B,QAGtF,MAAM,IAAI+Y,UAAU,mCAKrB,MAAMqzC,WAAsBN,GAOxBliD,iBAAmB,OAAO,IAAI1C,aAAayD,MAC3Cf,iBAAmB,OAAO,IAAIzC,aAAawD,OAI/C,MAAM0hD,WAAsBP,IAE5B,MAAMQ,WAAsBR,IAEnC,MAAMK,GAAiB,CAACI,EAAeC,IAC3BD,IAAa/uB,IAAagvB,IAAaxlD,YAI7CklD,GAAuBO,IACzB,OAAQA,GACJ,KAAKzlD,YAAgB,OAAOw2B,GAC5B,KAAKt2B,aAAgB,OAAOu2B,GAC5B,KAAKt2B,aAAgB,OAAOu2B,GAC5B,QAAS,OAAO,OAKlBsuB,GAAwBS,IAC1B,OAAQA,GACJ,KAAKL,GAAe,OAAO5uB,GAC3B,KAAK6uB,GAAe,OAAO5uB,GAC3B,KAAK6uB,GAAe,OAAO5uB,GAC3B,QAAS,OAAO,OCxHjB,MAAMgvB,WAAsDzB,IAE5D,MAAM0B,WAA8BD,IAEpC,MAAME,WAAgCF,IC+BtC,MAAMG,WAAuC5B,GA+BzCrhD,eAAwEssB,GAE3E,IAAK1vB,EAAOsmD,GAAU,GAAS52B,EAC3B61B,EAAYgB,GAAqBpiD,KAAMmiD,GAE3C,GAAKtmD,aAAiBpC,aAAgBA,YAAYsC,OAAOF,GAAQ,CAC7D,IAAIylD,EAAYe,GAAoBxmD,EAAMq1B,YAA6BixB,IAAYf,EAQnF,GALkB,OAAdA,IACAA,EAAYE,GAIZF,GAAaA,IAAcE,EAAW,CACtC,IAAI7uC,EAAO,IAAI2uC,EACXjmD,EAASU,EAAM/B,WAAa2Y,EAAKggB,UAAUz2B,kBAK/C,OAHIsmD,GAAiBlB,EAAWvlD,EAAMq1B,eAClC/1B,GAAU,IAEPijB,EAAO4a,IAAIlN,GAAKhL,IAAIrO,EAAM,EAAGtX,EAAQ,EAAG,KAAMU,KAI7D,GAAIulD,EAIA,OAAOT,GAAyB,IAAM,IAAIS,EAAmBvlD,GAGjE,GAAKA,aAAiBkvB,UAAclvB,aAAiBpC,YACjD,MAAM,IAAI2U,wDAAwDvS,EAAMq1B,YAAY77B,QAGxF,MAAM,IAAI+Y,UAAU,iCAKrB,MAAMm0C,WAAmBL,IAEzB,MAAMM,WAAoBN,IAE1B,MAAMO,WAAoBP,IAE1B,MAAMQ,WAAoBR,GACtBjjD,kBACH,OAAOzJ,OAAA6gC,GAAA,gBAAA7gC,CAAgBwK,KAAKiqB,QAIhCqU,eACI,OAAOt+B,KAAK2iD,YAAc3iD,KAAK2iD,UAAY3iD,KAAK3I,oBAKjD,MAAMurD,WAAoBV,IAE1B,MAAMW,WAAqBX,IAE3B,MAAMY,WAAqBZ,IAE3B,MAAMa,WAAqBb,GACvBjjD,mBACH,OAAOzJ,OAAA6gC,GAAA,iBAAA7gC,CAAiBwK,KAAKiqB,QAIjCqU,eACI,OAAOt+B,KAAK2iD,YAAc3iD,KAAK2iD,UAAY3iD,KAAKvI,qBAIxD,MAAM6qD,GAAmB,CAACV,EAAeC,MAC7BD,IAAal1B,IAASk1B,IAAa10B,IACnC20B,IAAazlD,YAAcylD,IAAavlD,aAI9C+lD,GAAsB,CAACP,EAAoBK,KAC7C,OAAQL,GACJ,KAAK5lD,UAAgB,OAAOkwB,EAC5B,KAAKjwB,WAAgB,OAAOmwB,EAC5B,KAAKlwB,WAAgB,OAAO+lD,EAAUz1B,GAAQF,EAC9C,KAAKyK,GAAA,EAAgB,OAAOvK,GAC5B,KAAKzyB,WAAgB,OAAO2yB,GAC5B,KAAKvwB,YAAgB,OAAOywB,GAC5B,KAAKxwB,YAAgB,OAAO6lD,EAAUj1B,GAASF,GAC/C,KAAKiK,GAAA,EAAgB,OAAO/J,GAC5B,QAAS,OAAO,OAKlBk1B,GAAuB,CAACN,EAA6BK,KACvD,OAAQL,GACJ,KAAKS,GAAc,OAAOn2B,EAC1B,KAAKo2B,GAAc,OAAOl2B,EAC1B,KAAKm2B,GAAc,OAAON,EAAUz1B,GAAQF,EAC5C,KAAKk2B,GAAc,OAAOh2B,GAC1B,KAAKk2B,GAAc,OAAOh2B,GAC1B,KAAKi2B,GAAc,OAAO/1B,GAC1B,KAAKg2B,GAAc,OAAOX,EAAUj1B,GAASF,GAC7C,KAAK+1B,GAAc,OAAO71B,GAC1B,QAAS,OAAO,OC7KjB,MAAM81B,WAA6C1C,ICGnD,MAAM2C,WAAsE3C,GACxErhD,SACH,MAAMo1B,EAAQr0B,KAAKyS,KAAK2f,SAAS,GACjC,OAAOhU,EAAO4a,IAAIh5B,KAAK0S,KAAKojB,MAAM,IAAI1B,GAAmCC,KAEtEp1B,KAAKzD,GACR,MAAM64B,EAAQr0B,KAAKshC,WAAyC,IACpDriC,CAACzD,GAAQ2uB,EAAOlrB,CAACzD,EAAQ,GAAI0Z,GAAQlV,KAAK3C,aAClD,OAAO,IAAI+jC,GAAO/M,EAAO14B,MAAMwuB,EAAOjV,KCXvC,MAAMguC,WAAmB5C,ICAjB,MAAM6C,GAAYttD,OAAO2mC,IAAI,YAErC,MAAM4mB,WAAkE9C,GAGpErhD,KAAKzD,GACR,MAAMg3B,EAAQxyB,KAAKqjD,OAASrjD,KAAKqjD,KAAO,IAAI9hB,GAAavhC,OACnDsjD,EAAQ9tD,OAAOY,OAAOo8B,GAE5B,OADA8wB,EAAMH,IAAa3nD,EACZ8nD,GCTR,MAAMC,WAAyDjD,IAE/D,MAAMkD,WAA8BD,IAEpC,MAAME,WAAmCF,IAEzC,MAAMG,WAAmCH,IAEzC,MAAMI,WAAkCJ,ICRxC,MAAMK,WAA0CtD,IAEhD,MAAMuD,WAAyBD,IAE/B,MAAME,WAA8BF,IAEpC,MAAMG,WAA8BH,IAEpC,MAAMI,WAA6BJ,ICRnC,MAAMK,WAA6C3D,GACtD5rB,yBAAkC,OAAO10B,KAAK0S,KAAKD,KAAKiiB,oBAIrD,MAAMwvB,WAAyBD,GAClC5mD,mBAA4B,OAAO2C,KAAK0S,KAAKrV,cAI1C,MAAM8mD,WAA0BF,ICLhC,MAAMG,WAAmB9D,GAMrBrhD,YAAyBpD,GAC5B,OAAO8kD,GAAyB,IAAM,IAAI1tB,GAAQp3B,GAE/CoD,WACH,OAAOmf,EAAO4a,IAAIh5B,KAAK0S,KAAKojB,MAAM,IAAI9C,MClBvC,SAASqxB,GAAY54B,GACxB,OAAO,WAAoB,OAAOA,EAAMzrB,OASrC,SAASskD,GAAY74B,GACxB,OAAO,SAAkBnuB,EAAQhC,GAAU,OAAOmwB,EAAMzrB,KAAM1C,EAAGhC,IC2D9D,MAAMipD,WAAmBl5B,GAElB,MACMm5B,GAA4B,CAAC9xC,EAAkBlX,IAAkB,WAAckX,EAAKlX,EAAQ,IAAOkX,EAAKlX,KAAW,GAInHipD,GAA2Bnb,GAAoB,IAAIlmB,KAAKkmB,GAOtEob,GAAwB,CAACz6B,EAAoB5sB,EAA0B7B,KACzE,MAAQyD,CAACzD,GAAQR,EAAGiE,CAACzD,EAAQ,GAAIP,GAAMoC,EACvC,OAAY,MAALrC,GAAkB,MAALC,EAAYgvB,EAAOvuB,SAASV,EAAGC,GAAK,MAgBtD0pD,GAAqB,EAA8B16B,UAAiCzuB,IAxBpD,EAACkX,EAAkBlX,IAAkBipD,GANvC,EAAC/xC,EAAkBlX,IAAkB,MAAWkX,EAAKlX,GAMUopD,CAAclyC,EAAMlX,IAwBEqpD,CAAgB56B,EAAQzuB,GAE3IspD,GAAqB,EAA8B76B,UAAiCzuB,IAzBxC,EAACkX,EAAkBlX,IAAkBipD,GAAwBD,GAA0B9xC,EAAMlX,IAyBtBupD,CAA4B96B,EAAgB,EAARzuB,GAEvJwpD,GAAqB,EAA8BtvB,SAAQzL,UAAyBzuB,IAA+ByuB,EAAOyL,EAASl6B,GAEnIypD,GAAqB,EAA8BvvB,SAAQzL,UAAyBzuB,IAA+BqgC,GAAgB5R,EAAOyL,EAASl6B,IAEnJ0pD,GAAqB,EAAwBxvB,SAAQzL,SAAQxX,QAAuBjX,IAAqCuiC,GAAG/E,IAAI/O,EAAOvuB,SAASg6B,EAASl6B,EAAOk6B,GAAUl6B,EAAQ,IAAKiX,EAAKuO,UAqC5LmkC,GAA0B,EAAmCl7B,UAAyBzuB,IAA+B,IAAOgpD,GAA0Bv6B,EAAgB,EAARzuB,GAE9J4pD,GAA0B,EAAmCn7B,UAAyBzuB,IAA+BgpD,GAA0Bv6B,EAAgB,EAARzuB,GAEvJ6pD,GAA0B,EAAmCp7B,UAAyBzuB,IA7E5C,EAACkX,EAAkBlX,IAAgCkX,EAAKlX,EAAQ,GAAK,IAAhC,YAA0CkX,EAAKlX,KAAW,GAAK,IA6EzB8pD,CAA0Br7B,EAAgB,EAARzuB,GAEvJ+pD,GAA0B,EAAmCt7B,UAAyBzuB,IA9E7C,EAACkX,EAAkBlX,IAAgCkX,EAAKlX,EAAQ,GAAK,IAAhC,YAA6CkX,EAAKlX,KAAW,GAAK,IA8E3BgqD,CAAyBv7B,EAAgB,EAARzuB,GAatJiqD,GAAqB,EAA8Bx7B,SAAQyL,UAAyBl6B,IAA+ByuB,EAAOyL,EAASl6B,GAEnIkqD,GAAqB,EAA8Bz7B,SAAQyL,UAAyBl6B,IAA+ByuB,EAAOyL,EAASl6B,GAEnImqD,GAAqB,EAA8B17B,UAAiCzuB,IAA+BuiC,GAAGf,OAAO/S,EAAOvuB,SAAS,EAAIF,EAAO,GAAKA,EAAQ,KAErKoqD,GAAqB,EAA8B37B,UAAiCzuB,IAA+BuiC,GAAGf,OAAO/S,EAAOvuB,SAAS,EAAIF,EAAO,GAAKA,EAAQ,KA0CrKqqD,GAAgB,CAAuB7gB,EAAuBxpC,KAChE,MAAMotC,EAAa5D,EAAOtQ,mBAAmBsQ,EAAO7S,QAAQ32B,IACtD64B,EAAQ2Q,EAAO1D,WAAWsH,GAChC,OAAOvU,EAAQA,EAAM1+B,IAAIqvC,EAAO3nC,aAAa7B,IAAU,MAIrDsqD,GAAiB,CAAwB9gB,EAAuBxpC,KAClE,MAAMotC,EAAa5D,EAAOtQ,mBAAmBsQ,EAAO7S,QAAQ32B,IACtD64B,EAAQ2Q,EAAO1D,WAAWsH,GAChC,OAAOvU,EAAQA,EAAM1+B,IAAI6F,GAAS,MAgBhCuqD,GAAqB,EAA8B97B,UAAyBzuB,IAA+ByuB,EAAOvuB,SAAS,EAAIF,EAAO,GAAKA,EAAQ,IAGnJwqD,GAAuB,EAAgC/7B,UAAyBzuB,KAClF,MAAMyqD,EAAWh8B,EAAOzuB,GAClB0qD,EAAS,IAAI9pD,WAAW,GAG9B,OAFA8pD,EAAO,GAAKD,EAAW,GAAK,EAC5BC,EAAO,GAAKD,EAAW,GAAK,EACrBC,GASX3B,GAAW7tD,UAAUu1B,UA/KL,EAAiBk6B,EAAwB58B,IAAgC,MAgLzFg7B,GAAW7tD,UAAUw1B,UAxKL,GAAmB3wB,SAAQ0uB,UAAyBzuB,KAChE,MAAMm5B,EAAMp5B,EAASC,EAErB,OAAmC,IADtByuB,EAAO0K,GAAO,GACZ,GAAMA,EAAM,KAsK/B4vB,GAAW7tD,UAAUy1B,SAvIN,EAAgB6Y,EAAuBxpC,IAClDwpC,EAAOvyB,KAAKsO,SAAW,GACjBikC,GAAWhgB,EAAiCxpC,GAC5C0pD,GAAWlgB,EAAiCxpC,IAqItD+oD,GAAW7tD,UAAU21B,UAAyC24B,GAC9DT,GAAW7tD,UAAU61B,WAAyCy4B,GAC9DT,GAAW7tD,UAAU+1B,WAAyCu4B,GAC9DT,GAAW7tD,UAAUi2B,WAAyCu4B,GAC9DX,GAAW7tD,UAAUm2B,WAAyCm4B,GAC9DT,GAAW7tD,UAAUq2B,YAAyCi4B,GAC9DT,GAAW7tD,UAAUu2B,YAAyC+3B,GAC9DT,GAAW7tD,UAAUy2B,YAAyC+3B,GAC9DX,GAAW7tD,UAAU22B,WAxIJ,EAAmB2X,EAAuBxpC,IACvDwpC,EAAOvyB,KAAK8O,YAAc/C,EAAU8C,KAC9B0jC,GAAWhgB,EAAiCxpC,GAC5CypD,GAAWjgB,EAA+BxpC,IAsIpD+oD,GAAW7tD,UAAU62B,aAAyC03B,GAC9DV,GAAW7tD,UAAU+2B,aAAyCu3B,GAC9DT,GAAW7tD,UAAUi3B,aAAyCq3B,GAC9DT,GAAW7tD,UAAUk3B,UA3JL,GAAmB3D,SAAQ5sB,gBAA+B7B,KACtE,MAAMM,EAAQ4oD,GAAsBz6B,EAAQ5sB,EAAc7B,GAC1D,OAAiB,OAAVM,EAAiBtG,OAAA4V,GAAA,EAAA5V,CAAWsG,GAAS,OA0JhDyoD,GAAW7tD,UAAUm3B,YA9JH,GAAqB5D,SAAQ5sB,gBAA+B7B,IAA+BkpD,GAAsBz6B,EAAQ5sB,EAAc7B,IA+JzJ+oD,GAAW7tD,UAAUo3B,qBAlKM,GAA8B4H,SAAQzL,UAAyBzuB,IAA+ByuB,EAAOvuB,SAASg6B,EAASl6B,EAAOk6B,GAAUl6B,EAAQ,KAmK3K+oD,GAAW7tD,UAAUq3B,UAvIL,EAAmBiX,EAAuBxpC,IACtDwpC,EAAOvyB,KAAK6Q,OAAS7E,EAASqS,IACxB6zB,GAAW3f,EAA+BxpC,GAC1CspD,GAAmB9f,EAAuCxpC,IAqIpE+oD,GAAW7tD,UAAUu3B,aAAyC02B,GAC9DJ,GAAW7tD,UAAUy3B,qBAAiC22B,GACtDP,GAAW7tD,UAAU03B,eA1HW,EAAsB4W,EAAuBxpC,KACzE,OAAQwpC,EAAOvyB,KAAK6Q,MAChB,KAAK5E,EAASoF,OAAa,OAAYqhC,GAAmBngB,EAAuCxpC,GACjG,KAAKkjB,EAAS2E,YAAa,OAAO+hC,GAAwBpgB,EAA4CxpC,GACtG,KAAKkjB,EAASkS,YAAa,OAAOy0B,GAAwBrgB,EAA4CxpC,GACtG,KAAKkjB,EAASmS,WAAa,OAAQ00B,GAAuBvgB,EAA2CxpC,MAsH7G+oD,GAAW7tD,UAAU43B,qBAAiC62B,GACtDZ,GAAW7tD,UAAU83B,0BAA4B42B,GACjDb,GAAW7tD,UAAUg4B,0BAA4B22B,GACjDd,GAAW7tD,UAAUk4B,yBAA6B22B,GAClDhB,GAAW7tD,UAAUm4B,UA5GM,EAAiBmW,EAAuBxpC,KAC/D,OAAQwpC,EAAOvyB,KAAK6Q,MAChB,KAAK5E,EAASoF,OAAa,OAAY2hC,GAAczgB,EAAkCxpC,GACvF,KAAKkjB,EAAS2E,YAAa,OAAOqiC,GAAmB1gB,EAAuCxpC,GAC5F,KAAKkjB,EAASkS,YAAa,OAAO+0B,GAAmB3gB,EAAuCxpC,GAC5F,KAAKkjB,EAASmS,WAAa,OAAQ+0B,GAAkB5gB,EAAsCxpC,MAwGnG+oD,GAAW7tD,UAAUq4B,gBAAsC02B,GAC3DlB,GAAW7tD,UAAUu4B,qBAAiCy2B,GACtDnB,GAAW7tD,UAAUy4B,qBAAiCw2B,GACtDpB,GAAW7tD,UAAU24B,oBAAkCu2B,GACvDrB,GAAW7tD,UAAU44B,aAvGF,GAAsBrF,UAAyBzuB,IAA+BuiC,GAAGqoB,QAAQn8B,EAAOvuB,SAAS,EAAIF,EAAO,GAAKA,EAAQ,MAwGpJ+oD,GAAW7tD,UAAU64B,UArGL,EAAiByV,EAAuBxpC,KACpD,MAAM64B,EAAQ2Q,EAAO1D,WAAW,IAAKjkC,aAAEA,EAAYq4B,OAAEA,GAAWsP,EAChE,OAAO3Q,EAAM14B,MAAM0B,EAAa7B,EAAQk6B,GAASr4B,EAAc7B,EAAQk6B,EAAU,MAoGrF6uB,GAAW7tD,UAAU+4B,YA3FH,EAAmBuV,EAAuBxpC,IACjDwpC,EAAO1uC,KAAKkF,IA2FvB+oD,GAAW7tD,UAAUg5B,WAtFJ,EAEfsV,EAAWxpC,IACFwpC,EAAOvyB,KAAKxc,OAASsoB,EAAUyS,MAClC60B,GAAc7gB,EAAkCxpC,GAChDsqD,GAAe9gB,EAAmCxpC,IAkF1D+oD,GAAW7tD,UAAUk5B,gBAAsCi2B,GAC3DtB,GAAW7tD,UAAUo5B,iBAAqCg2B,GAC1DvB,GAAW7tD,UAAUs5B,gBAlEC,EAAuBgV,EAAuBxpC,IACzDwpC,EAAO1E,SAAS0E,EAAOlD,OAAOtmC,KAkEzC+oD,GAAW7tD,UAAUu5B,cA7DD,EAAqB+U,EAAuBxpC,IAC3DwpC,EAAOvyB,KAAK6Q,OAAS3E,EAAaoS,SAC7Bg1B,GAAmB/gB,EAAuCxpC,GAC1DwqD,GAAqBhhB,EAAyCxpC,IA2DxE+oD,GAAW7tD,UAAUy5B,qBAAiC41B,GACtDxB,GAAW7tD,UAAU25B,uBAA+B21B,GACpDzB,GAAW7tD,UAAU45B,mBA9CI,EAA0B0U,EAAuBxpC,KACtE,MAAM64B,EAAQ2Q,EAAO1D,WAAW,IAAK5L,OAAEA,GAAWsP,EAClD,OAAO3Q,EAAM14B,MAAMH,EAAQk6B,GAASl6B,EAAQ,GAAKk6B,KA6CrD6uB,GAAW7tD,UAAU65B,SAzGN,EAAiByU,EAAuBxpC,IAC5CwpC,EAAO1uC,KAAKkF,IA2GhB,MAAM6qD,GAAW,IAAI9B,GCzOrB,MAAM+B,WAAuBj7B,GAuBpC,SAASk7B,GAAiCvhB,EAAuBwhB,EAAoC7gB,GACjG,QAAsB1jC,IAAlBukD,EAA+B,OAAQ,EAC3C,GAAsB,OAAlBA,EAA0B,OAhBlC,SAAyCxhB,EAAuBW,GAC5D,MAAMhQ,WAAEA,GAAeqP,EACvB,IAAKrP,GAAcqP,EAAOzP,WAAa,EACnC,OAAQ,EAEZ,IAAIzgC,EAAI,EACR,IAAK,MAAM2kC,KAAWzP,EAAY2L,EAAYqP,EAAOtyB,KAAKnX,QAAUoqC,GAAa,GAAIX,EAAO7pC,OAAQw6B,EAAYtM,GAAU,CACtH,IAAKoQ,EAAW,OAAO3kC,IACrBA,EAEN,OAAQ,EAM6B2xD,CAAYzhB,EAAQW,GACzD,MAAMhvB,EAAUgsB,GAAwB6jB,GACxC,IAAK,IAAI1xD,GAAK6wC,GAAa,GAAK,EAAGpvC,EAAIyuC,EAAO7pC,SAAUrG,EAAIyB,GACxD,GAAIogB,EAAQquB,EAAOrvC,IAAIb,IACnB,OAAOA,EAGf,OAAQ,EAIZ,SAAS4xD,GAAiC1hB,EAAuBwhB,EAAoC7gB,GAKjG,MAAMhvB,EAAUgsB,GAAwB6jB,GACxC,IAAK,IAAI1xD,GAAK6wC,GAAa,GAAK,EAAGpvC,EAAIyuC,EAAO7pC,SAAUrG,EAAIyB,GACxD,GAAIogB,EAAQquB,EAAOrvC,IAAIb,IACnB,OAAOA,EAGf,OAAQ,EAGZwxD,GAAe5vD,UAAUu1B,UA/CzB,SAAqB+Y,EAA0BwhB,GAE3C,OAAyB,OAAlBA,GAA0BxhB,EAAO7pC,OAAS,EAAI,GAAK,GA8C9DmrD,GAAe5vD,UAAUw1B,UAA4Bq6B,GACrDD,GAAe5vD,UAAUy1B,SAA4Bo6B,GACrDD,GAAe5vD,UAAU21B,UAA4Bk6B,GACrDD,GAAe5vD,UAAU61B,WAA4Bg6B,GACrDD,GAAe5vD,UAAU+1B,WAA4B85B,GACrDD,GAAe5vD,UAAUi2B,WAA4B45B,GACrDD,GAAe5vD,UAAUm2B,WAA4B05B,GACrDD,GAAe5vD,UAAUq2B,YAA4Bw5B,GACrDD,GAAe5vD,UAAUu2B,YAA4Bs5B,GACrDD,GAAe5vD,UAAUy2B,YAA4Bo5B,GACrDD,GAAe5vD,UAAU22B,WAA4Bk5B,GACrDD,GAAe5vD,UAAU62B,aAA4Bg5B,GACrDD,GAAe5vD,UAAU+2B,aAA4B84B,GACrDD,GAAe5vD,UAAUi3B,aAA4B44B,GACrDD,GAAe5vD,UAAUk3B,UAA4B24B,GACrDD,GAAe5vD,UAAUm3B,YAA4B04B,GACrDD,GAAe5vD,UAAUo3B,qBAA4By4B,GACrDD,GAAe5vD,UAAUq3B,UAA4Bw4B,GACrDD,GAAe5vD,UAAUu3B,aAA4Bs4B,GACrDD,GAAe5vD,UAAUy3B,qBAA4Bo4B,GACrDD,GAAe5vD,UAAU03B,eAA4Bm4B,GACrDD,GAAe5vD,UAAU43B,qBAA4Bi4B,GACrDD,GAAe5vD,UAAU83B,0BAA4B+3B,GACrDD,GAAe5vD,UAAUg4B,0BAA4B63B,GACrDD,GAAe5vD,UAAUk4B,yBAA4B23B,GACrDD,GAAe5vD,UAAUm4B,UAA4B03B,GACrDD,GAAe5vD,UAAUq4B,gBAA4Bw3B,GACrDD,GAAe5vD,UAAUu4B,qBAA4Bs3B,GACrDD,GAAe5vD,UAAUy4B,qBAA4Bo3B,GACrDD,GAAe5vD,UAAU24B,oBAA4Bk3B,GACrDD,GAAe5vD,UAAU44B,aAA4Bi3B,GACrDD,GAAe5vD,UAAU64B,UAA4Bg3B,GACrDD,GAAe5vD,UAAU+4B,YAA4B82B,GACrDD,GAAe5vD,UAAUg5B,WAA4B62B,GACrDD,GAAe5vD,UAAUk5B,gBAA4B82B,GACrDJ,GAAe5vD,UAAUo5B,iBAA4B42B,GACrDJ,GAAe5vD,UAAUs5B,gBAA4Bu2B,GACrDD,GAAe5vD,UAAUu5B,cAA4Bs2B,GACrDD,GAAe5vD,UAAUy5B,qBAA4Bo2B,GACrDD,GAAe5vD,UAAU25B,uBAA4Bk2B,GACrDD,GAAe5vD,UAAU45B,mBAA4Bi2B,GACrDD,GAAe5vD,UAAU65B,SAA4Bg2B,GAG9C,MAAMI,GAAW,IAAIL,GC/FrB,MAAMM,WAAwBv7B,GAarC,SAASw7B,GAAmC7hB,GAGxC,GAAIA,EAAOzP,UAAY,EACnB,OAdR,SAA8CyP,GAC1C,MAAM8hB,EAAQT,GAAW36B,WAAWsZ,GACpC,OAAOhb,EACHgb,EAAOrP,WAAYqP,EAAOzpC,OAAQypC,EAAO7pC,OAAQ6pC,EACjD,CAACzB,EAAoB5O,EAAaoyB,EAAkBC,IACjB,IAA7BD,EAAW,GAAKC,GAAkBF,EAAMvjB,EAAK5O,GAAO,MASnDsyB,CAAoBjiB,GAG/B,MAAMvyB,KAAEA,EAAIge,OAAEA,EAAMt1B,OAAEA,GAAW6pC,EAGjC,OAAsB,IAAlBA,EAAOtP,SACNjF,IAAW7R,EAAKiF,WAChB4M,IAAW7R,EAAKkC,KAAkC,KAA1BrO,EAAasO,UACrC0P,IAAW7R,EAAK8E,MAAoC,KAA3BjR,EAAcsO,UACvC0P,IAAW7R,EAAKwO,OAAU3a,EAAe8O,UAAY,GAE/CyjB,EAAO/a,OAAOvuB,SAAS,EAAGP,GAAQtF,OAAO8G,YAI7C,UAAYmqD,GACf,IAAK,IAAItrD,GAAS,IAAKA,EAAQL,SACrB2rD,EAAM9hB,EAAQxpC,GAFrB,CAIJ6qD,GAAW36B,WAAWsZ,IAG7B4hB,GAAgBlwD,UAAUu1B,UAA4B46B,GACtDD,GAAgBlwD,UAAUw1B,UAA4B26B,GACtDD,GAAgBlwD,UAAUy1B,SAA4B06B,GACtDD,GAAgBlwD,UAAU21B,UAA4Bw6B,GACtDD,GAAgBlwD,UAAU61B,WAA4Bs6B,GACtDD,GAAgBlwD,UAAU+1B,WAA4Bo6B,GACtDD,GAAgBlwD,UAAUi2B,WAA4Bk6B,GACtDD,GAAgBlwD,UAAUm2B,WAA4Bg6B,GACtDD,GAAgBlwD,UAAUq2B,YAA4B85B,GACtDD,GAAgBlwD,UAAUu2B,YAA4B45B,GACtDD,GAAgBlwD,UAAUy2B,YAA4B05B,GACtDD,GAAgBlwD,UAAU22B,WAA4Bw5B,GACtDD,GAAgBlwD,UAAU62B,aAA4Bs5B,GACtDD,GAAgBlwD,UAAU+2B,aAA4Bo5B,GACtDD,GAAgBlwD,UAAUi3B,aAA4Bk5B,GACtDD,GAAgBlwD,UAAUk3B,UAA4Bi5B,GACtDD,GAAgBlwD,UAAUm3B,YAA4Bg5B,GACtDD,GAAgBlwD,UAAUo3B,qBAA4B+4B,GACtDD,GAAgBlwD,UAAUq3B,UAA4B84B,GACtDD,GAAgBlwD,UAAUu3B,aAA4B44B,GACtDD,GAAgBlwD,UAAUy3B,qBAA4B04B,GACtDD,GAAgBlwD,UAAU03B,eAA4By4B,GACtDD,GAAgBlwD,UAAU43B,qBAA4Bu4B,GACtDD,GAAgBlwD,UAAU83B,0BAA4Bq4B,GACtDD,GAAgBlwD,UAAUg4B,0BAA4Bm4B,GACtDD,GAAgBlwD,UAAUk4B,yBAA4Bi4B,GACtDD,GAAgBlwD,UAAUm4B,UAA4Bg4B,GACtDD,GAAgBlwD,UAAUq4B,gBAA4B83B,GACtDD,GAAgBlwD,UAAUu4B,qBAA4B43B,GACtDD,GAAgBlwD,UAAUy4B,qBAA4B03B,GACtDD,GAAgBlwD,UAAU24B,oBAA4Bw3B,GACtDD,GAAgBlwD,UAAU44B,aAA4Bu3B,GACtDD,GAAgBlwD,UAAU64B,UAA4Bs3B,GACtDD,GAAgBlwD,UAAU+4B,YAA4Bo3B,GACtDD,GAAgBlwD,UAAUg5B,WAA4Bm3B,GACtDD,GAAgBlwD,UAAUk5B,gBAA4Bi3B,GACtDD,GAAgBlwD,UAAUo5B,iBAA4B+2B,GACtDD,GAAgBlwD,UAAUs5B,gBAA4B62B,GACtDD,GAAgBlwD,UAAUu5B,cAA4B42B,GACtDD,GAAgBlwD,UAAUy5B,qBAA4B02B,GACtDD,GAAgBlwD,UAAU25B,uBAA4Bw2B,GACtDD,GAAgBlwD,UAAU45B,mBAA4Bu2B,GACtDD,GAAgBlwD,UAAU65B,SAA4Bs2B,GAG/C,MAAMK,GAAW,IAAIN,GCtFrB,MAAMO,WAAuB97B,GAGpC,SAAS+7B,GAAkCpiB,GAEvC,MAAMvyB,KAAEA,EAAItX,OAAEA,EAAMu6B,OAAEA,GAAWsP,EAGjC,OAAQvyB,EAAKge,QACT,KAAK7R,EAAKkC,IACV,KAAKlC,EAAKwO,MAAO,KAAKxO,EAAKmE,QAC3B,KAAKnE,EAAK8E,KAAM,KAAK9E,EAAKiF,UACtB,OAAOmhB,EAAO/a,OAAOvuB,SAAS,EAAGP,EAASu6B,GAIlD,MAAO,IAAIwxB,GAAgBz7B,MAAMuZ,IAGrCmiB,GAAezwD,UAAUu1B,UAA4Bm7B,GACrDD,GAAezwD,UAAUw1B,UAA4Bk7B,GACrDD,GAAezwD,UAAUy1B,SAA4Bi7B,GACrDD,GAAezwD,UAAU21B,UAA4B+6B,GACrDD,GAAezwD,UAAU61B,WAA4B66B,GACrDD,GAAezwD,UAAU+1B,WAA4B26B,GACrDD,GAAezwD,UAAUi2B,WAA4By6B,GACrDD,GAAezwD,UAAUm2B,WAA4Bu6B,GACrDD,GAAezwD,UAAUq2B,YAA4Bq6B,GACrDD,GAAezwD,UAAUu2B,YAA4Bm6B,GACrDD,GAAezwD,UAAUy2B,YAA4Bi6B,GACrDD,GAAezwD,UAAU22B,WAA4B+5B,GACrDD,GAAezwD,UAAU62B,aAA4B65B,GACrDD,GAAezwD,UAAU+2B,aAA4B25B,GACrDD,GAAezwD,UAAUi3B,aAA4By5B,GACrDD,GAAezwD,UAAUk3B,UAA4Bw5B,GACrDD,GAAezwD,UAAUm3B,YAA4Bu5B,GACrDD,GAAezwD,UAAUo3B,qBAA4Bs5B,GACrDD,GAAezwD,UAAUq3B,UAA4Bq5B,GACrDD,GAAezwD,UAAUu3B,aAA4Bm5B,GACrDD,GAAezwD,UAAUy3B,qBAA4Bi5B,GACrDD,GAAezwD,UAAU03B,eAA4Bg5B,GACrDD,GAAezwD,UAAU43B,qBAA4B84B,GACrDD,GAAezwD,UAAU83B,0BAA4B44B,GACrDD,GAAezwD,UAAUg4B,0BAA4B04B,GACrDD,GAAezwD,UAAUk4B,yBAA4Bw4B,GACrDD,GAAezwD,UAAUm4B,UAA4Bu4B,GACrDD,GAAezwD,UAAUq4B,gBAA4Bq4B,GACrDD,GAAezwD,UAAUu4B,qBAA4Bm4B,GACrDD,GAAezwD,UAAUy4B,qBAA4Bi4B,GACrDD,GAAezwD,UAAU24B,oBAA4B+3B,GACrDD,GAAezwD,UAAU44B,aAA4B83B,GACrDD,GAAezwD,UAAU64B,UAA4B63B,GACrDD,GAAezwD,UAAU+4B,YAA4B23B,GACrDD,GAAezwD,UAAUg5B,WAA4B03B,GACrDD,GAAezwD,UAAUk5B,gBAA4Bw3B,GACrDD,GAAezwD,UAAUo5B,iBAA4Bs3B,GACrDD,GAAezwD,UAAUs5B,gBAA4Bo3B,GACrDD,GAAezwD,UAAUu5B,cAA4Bm3B,GACrDD,GAAezwD,UAAUy5B,qBAA4Bi3B,GACrDD,GAAezwD,UAAU25B,uBAA4B+2B,GACrDD,GAAezwD,UAAU45B,mBAA4B82B,GACrDD,GAAezwD,UAAU65B,SAA4B62B,GAG9C,MAAMC,GAAW,IAAIF,GCvHP18B,GAAM,CAACzvB,EAAWC,IAAcD,EAAIC,EACpCqsD,GAAmC70C,6DAA6EA,IAmC9H,MAAM80C,GAAW,IAxBjB,cAA+Bl8B,EAC3BpsB,UAAsBuoD,GAA0B,OAAO,EACvDvoD,SAAsBwT,GAA0B,OAAOA,EAAKsO,SAAW,EACvE9hB,WAAsBwT,GAA0B,OAAOA,EAAKggB,UAAUz2B,kBACtEiD,YAAsBwT,GAA0B,MAAUhU,MAAM6oD,GAAgC70C,IAChGxT,UAAsBwT,GAA0B,MAAUhU,MAAM6oD,GAAgC70C,IAChGxT,UAAsBuoD,GAA0B,OAAO,EAAI,EAC3DvoD,aAAsBuoD,GAA0B,OAAO,GACvDvoD,UAAsBwT,GAA0B,OAAyB,GAAjBA,EAAK6Q,KAAO,GACpErkB,UAAsBwT,GAA0B,OAAOA,EAAKsO,SAAW,EACvE9hB,eAAsBwT,GAA0B,OAAOA,EAAK6Q,OAAS5E,EAASoF,OAAS,EAAI,EAC3F7kB,cAAsBwT,GAA0B,OAAyB,GAAjBA,EAAK6Q,KAAO,GACpErkB,UAAsBwT,GAA0B,MAAUhU,MAAM6oD,GAAgC70C,IAChGxT,YAAsBwT,GAA0B,OAAOzS,KAAKynD,YAAYh1C,EAAK2f,UAAU/2B,OAAOovB,GAAK,GACnGxrB,WAAsBwT,GAA0B,OAAOzS,KAAKynD,YAAYh1C,EAAK2f,UAAU/2B,OAAOovB,GAAK,GACnGxrB,qBAAsBwT,GAA0B,OAAOA,EAAK+P,UAC5DvjB,mBAAsBwT,GAA0B,OAAOA,EAAKoN,SAAW7f,KAAKynD,YAAYh1C,EAAK2f,UAAU/2B,OAAOovB,GAAK,GACnHxrB,SAAsBwT,GAA0B,OAAOzS,KAAKynD,YAAYh1C,EAAK2f,UAAU/2B,OAAOovB,GAAK,GACnGxrB,gBAAsBwT,GAA0B,OAAOzS,KAAKyrB,MAAMhZ,EAAK6f,SACvErzB,YAAsBoyB,GAA0B,OAAQA,GAAU,IAAI3tB,IAAKgH,GAAU1K,KAAKyrB,MAAM/gB,EAAM+H,OACtGxT,YAAsBgB,GAA0B,OAAOD,KAAKynD,YAAYxnD,EAAOoxB,QAAQh2B,OAAOovB,GAAK,KCmCvG,MAAMi9B,GAAW,IA/CjB,cAAmCr8B,EAC/BpsB,YAA+B,OAAOikD,GACtCjkD,YAA+B,OAAOyhD,GACtCzhD,WAA+B,OAAOijD,GACtCjjD,YAA+B,OAAOsjD,GACtCtjD,aAA+B,OAAOujD,GACtCvjD,aAA+B,OAAOwjD,GACtCxjD,aAA+B,OAAOyjD,GACtCzjD,aAA+B,OAAO2jD,GACtC3jD,cAA+B,OAAO4jD,GACtC5jD,cAA+B,OAAO6jD,GACtC7jD,cAA+B,OAAO8jD,GACtC9jD,aAA+B,OAAOkiD,GACtCliD,eAA+B,OAAOwiD,GACtCxiD,eAA+B,OAAOyiD,GACtCziD,eAA+B,OAAO0iD,GACtC1iD,YAA+B,OAAOmlD,GACtCnlD,cAA+B,OAAOwhD,GACtCxhD,uBAA+B,OAAOgiD,GACtChiD,YAA+B,OAAO2hD,GACtC3hD,eAA+B,OAAO4hD,GACtC5hD,uBAA+B,OAAO6hD,GACtC7hD,iBAA+B,OAAOskD,GACtCtkD,uBAA+B,OAAOukD,GACtCvkD,4BAA+B,OAAOwkD,GACtCxkD,4BAA+B,OAAOykD,GACtCzkD,2BAA+B,OAAO0kD,GACtC1kD,YAA+B,OAAO2kD,GACtC3kD,kBAA+B,OAAO4kD,GACtC5kD,uBAA+B,OAAO6kD,GACtC7kD,uBAA+B,OAAO8kD,GACtC9kD,sBAA+B,OAAO+kD,GACtC/kD,eAA+B,OAAO8hD,GACtC9hD,YAA+B,OAAO+jD,GACtC/jD,cAA+B,OAAOmkD,GACtCnkD,aAA+B,OAAOglD,GACtChlD,kBAA+B,OAAOilD,GACtCjlD,mBAA+B,OAAOklD,GACtCllD,kBAA+B,OAAO+hD,GACtC/hD,gBAA+B,OAAO8iD,GACtC9iD,uBAA+B,OAAO+iD,GACtC/iD,yBAA+B,OAAOgjD,GACtChjD,qBAA+B,OAAOiiD,GACtCjiD,WAA+B,OAAOgkD,KCG1C,SAAStC,GAA0DgH,EAAsB9rD,GAC5F,GAAIrG,OAAAyhC,GAAA,EAAAzhC,CAAWqG,GACX,OAAOuiB,EAAOniB,KAAK,CAAE46B,WAAc,CAAC,UAAM50B,GAAYwQ,KAAMk1C,IAAe19B,OAAUpuB,IAClF,GAAIrG,OAAAyhC,GAAA,EAAAzhC,CAAgBqG,GACvB,OAAOuiB,EAAOniB,KAAK,CAAE46B,WAAc,CAAC,UAAM50B,GAAYwQ,KAAMk1C,IAAe19B,OAAUpuB,IAEzF,MACIouB,OAAUA,EAAS,GACnBxX,KAAQA,EAAOk1C,IACf9wB,WAAcA,EAAa,CAAC,UAAM50B,IAClC,IAAKpG,GACT,OAAOrG,OAAAyhC,GAAA,EAAAzhC,CAAWy0B,GACZ7L,EAAOniB,KAAK,CAAE46B,gBAAeh7B,EAAO4W,SA5B9C2L,EAAO4a,IAMP,SAAuCtmB,KAAkB6Y,GACrD,OAAO,IAAKm8B,GAAqBh8B,WAAchZ,EAApC,GAAJ,CAAiDA,KAAS6Y,IAJrEnN,EAAOniB,KAgCP,SAA2DJ,GACvD,MAAQouB,OAAUA,EAAS,MAAO1pB,GAAY,CAAEs2B,WAAc,CAAC,UAAM50B,MAAepG,GACpF,GAAIrG,OAAAyhC,GAAA,EAAAzhC,CAAgCy0B,GAAS,CACzC,MAAMzvB,EAAS,IAAIg+B,GAAQW,gBAAgB54B,EAAxBi4B,CAAiCvO,IACpD,OAAyB,IAAlBzvB,EAAOW,OAAeX,EAAO,GAAKupC,GAAQntB,OAAUpc,GAE/D,MAAO,OAAQA,IACX,MAAMotD,EAAYpvB,GAAQY,qBAAqB74B,GAC/C,UAAW,MAAMmkC,KAASkjB,EAAU39B,GAChCzvB,EAAOmH,KAAK+iC,GAEhB,OAAyB,IAAlBlqC,EAAOW,OAAeX,EAAO,GAAKupC,GAAQntB,OAAUpc,IALxD,CAMJ,KAWP8lD,GAAW5pD,UAAUf,IAAM,SAAgE6F,GACvF,OAAO6qD,GAAW56B,MAAMzrB,KAAMxE,IAGlC8kD,GAAW5pD,UAAU6D,IAAM,SAAgEiB,EAAezF,GACtG,OAAOm1C,GAAWzf,MAAMzrB,KAAMxE,EAAOzF,IAGzCuqD,GAAW5pD,UAAUia,QAAU,SAAoE5a,EAA2B4vC,GAC1H,OAAOghB,GAAel7B,MAAMzrB,KAAMjK,EAAO4vC,IAG7C2a,GAAW5pD,UAAU6uC,QAAU,WAC3B,OAAO8hB,GAAe57B,MAAMzrB,OAGhCsgD,GAAW5pD,UAAUmxD,aAAe,WAChC,OAAON,GAAiB97B,MAAMzrB,KAAKyS,OAGvC6tC,GAAW5pD,UAAUb,OAAO8G,UAAY,WACpC,OAAOuqD,GAAgBz7B,MAAMzrB,OAGhCsgD,GAAW5pD,UAAkB6pD,mBAqC9B,WACI,MAAM5qB,EAAa31B,KAAK21B,WACpBA,GAAcA,EAAW77B,WAAa,IACtCkG,KAAKrK,KAjBmFkO,EAiB7D7D,KAAKrK,IAhB7B,SAAkBb,GAAa,OAAOkL,KAAKy5B,QAAQ3kC,GAAK+O,EAAG5O,KAAK+K,KAAMlL,GAAK,OAiB9EkL,KAAKzF,IAbb,SAA6GsJ,GACzG,OAAO,SAAkB/O,EAAWwI,GAC5BqsB,EAAQ3pB,KAAK21B,WAAY31B,KAAKzE,OAASzG,IAAI,MAACwI,KAC5CuG,EAAG5O,KAAK+K,KAAMlL,EAAGwI,IAUVwqD,CAAgB9nD,KAAKzF,MAlBxC,IAAgGsJ,GApB/FrO,OAAOirC,KAAK7hB,GACRlb,IAAK8nC,GAAW5sB,EAAK4sB,IACrBxU,OAAQwU,GAAmC,iBAANA,GACrCxU,OAAQvG,GAAWA,IAAW7R,EAAKgH,MACnCmU,QAAStJ,IACN,MAAMs3B,EAAaL,GAAqBj8B,MAAMgF,GAC9Cs3B,EAAWrxD,UAAe,IPrJ3B,SAAqB+0B,GACxB,OAAO,SAAkBnuB,GAAU,OAAOmuB,EAAMzrB,KAAM1C,IOoJpB0qD,CAAY3B,GAAW36B,WAAW+E,IAChEs3B,EAAWrxD,UAAe,IAAI4tD,GAAYpZ,GAAWxf,WAAW+E,IAChEs3B,EAAWrxD,UAAmB,QAAI4tD,GAAYqC,GAAej7B,WAAW+E,IACxEs3B,EAAWrxD,UAAmB,QAAI2tD,GAAYgD,GAAe37B,WAAW+E,IACxEs3B,EAAWrxD,UAAwB,aAK3C,SAAwC+0B,GACpC,OAAO,WAAoB,OAAOA,EAAMzrB,KAAKyS,OANFw1C,CAAaV,GAAiB77B,WAAW+E,IAChFs3B,EAAWrxD,UAAUb,OAAO8G,UAAY0nD,GAAY6C,GAAgBx7B,WAAW+E,MC9HhF,MAAMwtB,WACDla,GA8HR9kC,eAAessB,GAEX,IAAItrB,EAAoB,KAEpBsrB,EAAK,aAAcmc,KAAUznC,EAASsrB,EAAK3pB,SAE/C,IAAIpH,EAASksC,GAA2B2U,GAAa9vB,GAErD,IAAKtrB,KAAYA,EAASzF,EAAO,IAAMA,EAAO,GAAGyF,QAC7C,MAAM,IAAImO,UAAU,uEAGxB5T,EAAO,KAAOA,EAAO,GAAK,IAAI0jD,GAAqCj+C,IAEnEgB,MAAM,IAAIuzB,GAAOv0B,EAAOoxB,QAAS72B,GAEjCwF,KAAKq4C,QAAUp4C,EACfD,KAAKmkC,QAAU3pC,EAxIZyE,aAAyDgB,EAAS,IAAIynC,GAAU,KAAO,OAAO,IAAIuW,GAASh+C,EAAQ,IAcnHhB,YAAsEpD,GAEzE,IAAKA,EAAS,OAAOoiD,GAAMiK,QAE3B,GAAqB,iBAAVrsD,EAAoB,CAC3B,IAAI4O,EAAQjV,OAAAyhC,GAAA,EAAAzhC,CAAWqG,EAAc,QAyMjD,SAAqFA,GACjF,MAAM4W,KAAEA,GAAS5W,EACjB,GAAI4W,aAAgB+hB,GAChB,OAAOypB,GAAMkK,WAAW/E,GAAannD,KAAKJ,IAE9C,OAAO,KA9M2CusD,CAA4BvsD,GAC/DrG,OAAAyhC,GAAA,EAAAzhC,CAAgBqG,EAAc,QAgNjD,SAA0FA,GACtF,MAAM4W,KAAEA,GAAS5W,EACjB,GAAI4W,aAAgB+hB,GAChB,OAAO4uB,GAAannD,KAAKJ,GAAsD2D,KAAMwlC,GAAWiZ,GAAMkK,WAAWnjB,IAErH,OAAO,KArN2CqjB,CAAiCxsD,GACjC,KAC1C,GAAc,OAAV4O,EAAkB,OAAOA,EAGjC,IAAItG,EAASmkD,GAAkBrsD,KAAQJ,GAEvC,OAAIrG,OAAAyhC,GAAA,EAAAzhC,CAAgC2O,GACzB,gBAAmB85C,GAAMhiD,WAAWkI,GAApC,GAEPA,EAAOokD,WAAapkD,EAASA,EAAOqkD,QAC5BrkD,EAAOlE,OAAyB,IAAIg+C,GAAS95C,EAAOlE,OAAQ,IAAIkE,IAAhD85C,GAAMiK,QAE3B,OAAQO,IACX,MAAMtkD,QAAeskD,EACfxoD,EAASkE,EAAOlE,OAChBC,EAAyB,GAC/B,GAAID,EAAQ,CACR,UAAW,IAAI84C,KAAS50C,EACpBjE,EAAQyB,KAAKo3C,GAEjB,OAAO,IAAIkF,GAASh+C,EAAQC,GAEhC,OAAO+9C,GAAMiK,SAVV,CAWJ/jD,EAAOqkD,QAIPvpD,uBAAoEtF,GACvE,aAAaskD,GAAMhiD,KAAQtC,GAIxBsF,kBAA+D+lC,GAClE,OAAOiZ,GAAMjlB,IAAOgM,EAAOtyB,KAAK8iB,UAAiCwP,EAAOvyB,KAAK2f,UAyD1EnzB,cAAcypD,GACjB,OAAO,IAAIzK,O5BpH6EnZ,E4BoHjCgC,GAAiB4hB,G5BnHrE9I,GAAsC,IAAIlY,GAAU5C,EAAQphC,IAAI,EAAGgH,WAAYA,IAASo6B,KAD5F,IAAyFA,E4BoJ5F7kC,aAAsB,OAAOD,KAAKq4C,QAClCl9C,aAAsB,OAAO6E,KAAKqkC,QAClC7pC,aAAsB,OAAOwF,KAAKmkC,QAClCwkB,cAAuB,OAAO3oD,KAAKskC,aAE5BrlC,MAAMzE,EAASwF,KAAKmkC,SACvB,OAAO,IAAI8Z,GAASj+C,KAAKq4C,QAAS79C,GAG/ByE,UAA6B5J,GAChC,OAAO2K,KAAK4oD,YAAY5oD,KAAK6oD,eAAexzD,IAEzC4J,YAAsCzD,GACzC,OAAOwE,KAAKshC,WAAW9lC,GAEpByD,eAAkC5J,GACrC,OAAO2K,KAAKq4C,QAAQhnB,OAAOoQ,UAAWjQ,GAAMA,EAAEn8B,OAASA,GAEpD4J,WAAqCzD,GACxC,GAAIA,EAAQ,GAAKA,GAASwE,KAAKq5B,YAAe,OAAO,KACrD,IAAI3uB,EAAiB2pB,EACrB,MAAMhD,EAAUrxB,KAAKq4C,QAAwBhnB,OACvCyT,EAAU9kC,KAAK+kC,YAAc/kC,KAAK+kC,UAAY,IACpD,GAAI1Q,EAAQyQ,EAAQtpC,GAAU,OAAO64B,EACrC,GAAI3pB,EAAQ2mB,EAAO71B,GAAQ,CACvB,MAAMhB,EAASwF,KAAKmkC,QACfzgC,IAAKghC,GAAUA,EAAMpD,WAAc9lC,IACnCw7B,OAAQuM,GAAiC,MAAPA,GACvC,GAAI/oC,EAAOW,OAAS,EAChB,OAAQ2pC,EAAQtpC,GAAS,IAAIyqC,GAAUv7B,EAAOlQ,GAGtD,OAAO,KAIJyE,UAAUmQ,EAAW,SAAUhM,GAAS,GAI3C,OAHgBA,EAEV47C,GADAE,IAEQ1B,SAASx9C,MAAM1I,cAAa,GAEvC2H,QACH,OAAOe,KAAKqkC,QAETplC,UAAmC4oC,GACtC,MAAMihB,EAAc9oD,KAAKq4C,QAAQhnB,OAAOh2B,OAAO,CAACnG,EAAGs8B,EAAG18B,IAAMI,EAAEqF,IAAIi3B,EAAEn8B,KAAWP,GAAI,IAAImrB,KACvF,OAAOjgB,KAAK+oD,YAAYlhB,EAAYnkC,IAAKslD,GAAeF,EAAYnzD,IAAIqzD,IAAchyB,OAAQh8B,GAAMA,GAAK,IAEtGiE,YAAwC8oC,GAC3C,MAAM9nC,EAASD,KAAKq4C,QAAQ0Q,YAAehhB,GAC3C,OAAO,IAAIkW,GAAMh+C,EAAQD,KAAKmkC,QAAQzgC,IAAI,EAAGvI,SAAQuX,MAAQ8iB,gBAClD,IAAI6lB,GAAYp7C,EAAQ9E,EAAQ4sC,EAAcrkC,IAAK5O,GAAM0gC,EAAU1gC,IAAIkiC,OAAOgR,YAGtF/oC,OAAoD6G,GAEvD,MAAMurB,EAASrxB,KAAKq4C,QAAQhnB,QACrBiB,EAAS22B,GAAYnjD,EAAM7F,OAAOoxB,OAAOh2B,OAAO,CAACsjC,EAAMyJ,EAAI8gB,KAC9D,MAAO52B,EAAS22B,GAAYtqB,EACtB7pC,EAAIu8B,EAAOoQ,UAAWjQ,GAAMA,EAAEn8B,OAAS+yC,EAAG/yC,MAEhD,OADCP,EAAKm0D,EAASn0D,GAAKo0D,EAAU52B,EAAQ3wB,KAAKunD,GACpCvqB,GACR,CAAC,GAAI,KAEF1+B,EAASD,KAAKq4C,QAAQza,OAAO93B,EAAM7F,QACnC6kC,EAAU,IACTzT,EAAO3tB,IAAI,CAACylD,EAAIr0D,EAAGs0D,EAAKluD,EAAI+tD,EAASn0D,UAC7BmN,IAAN/G,EAAkB8E,KAAK4oD,YAAY9zD,GAAKgR,EAAM8iD,YAAY1tD,OAC5Do3B,EAAQ5uB,IAAK5O,GAAMgR,EAAM8iD,YAAY9zD,KAC1CkiC,OAAOgR,SAET,OAAO,IAAIiW,MAAgB2B,GAAwC3/C,EAAQ6kC,KC3O5E,MAAMuW,WACD+H,GA6BRnkD,eAAessB,GACX,IAAI7Y,EAEA0f,EADAnyB,EAASsrB,EAAK,GAElB,GAAIA,EAAK,aAAcO,IAClB,CAAEpZ,EAAM0f,GAAa7G,MACnB,CACH,MAAM8F,EAASpxB,EAAOoxB,QACf,CAAEl2B,EAAQq6B,GAAajK,EAC9B7Y,EAAOoZ,GAAK0D,OAAO,IAAIgF,GAAUnD,GAAS,EAAGl2B,EAAQ,EAAG,KAAMq6B,GAElEv0B,MAAMyR,EAAM0f,GACZpyB,KAAKq4C,QAAUp4C,EAjCZhB,YAAsEsB,GACzE,OAAI/K,OAAAyhC,GAAA,EAAAzhC,CAA0C+K,EAAgB,QACnD09C,GAAMhiD,KAAKsE,GAQnBtB,cAA2DssB,GAC9D,MAAO89B,EAAIn/B,GAAM8c,GAAmBzb,GAC9B+9B,EAAKp/B,EAAG8M,OAAQh8B,GAA+BA,aAAaojB,GAClE,OAAO,IAAIi9B,M7B/BZ,SACHp7C,EACAzF,EACAwlD,EAAcxlD,EAAOa,OAAO,CAACtG,EAAGI,IAAMkF,KAAK6T,IAAInZ,EAAGI,EAAEgG,QAAS,IAE7D,IAAIuX,EACAhI,EACA5V,GAAK,EAAGyB,EAAIiE,EAAOW,OACvB,MAAMk2B,EAAS,IAAIpxB,EAAOoxB,QACpBk4B,EAAY,GACZ5J,GAAiBK,EAAc,IAAM,KAAQ,EACnD,OAASlrD,EAAIyB,IACJmc,EAAOlY,EAAO1F,KAAO4d,EAAKvX,SAAW6kD,EACtCuJ,EAAUz0D,GAAK4d,IAEdhI,EAAQ2mB,EAAOv8B,IAAIgxB,WAAauL,EAAOv8B,GAAKu8B,EAAOv8B,GAAGghC,MAAM,CAAEhQ,UAAU,KACzEyjC,EAAUz0D,GAAK4d,EAAOA,EAAK2tC,mCAAmCL,GACxDl0B,GAAKkN,IAAItuB,EAAM+H,KAAM,EAAGutC,EAAaA,EAAaN,GAASC,KAGzE,MAAO,CAAC,IAAIjY,GAAUrW,GAAS2uB,EAAauJ,G6BWdC,CAAqB,IAAI9hB,GAAU2hB,GAAKC,EAAG5lD,IAAK1I,GAAMA,EAAE0X,QAuB/EzT,MAAMyT,EAAuB0f,EAAWpyB,KAAK+kC,WAChD,OAAO,IAAIsW,GAAer7C,KAAKq4C,QAAS3lC,EAAM0f,GAG3CnzB,UAAUqyB,GACb,MAAMrxB,EAASD,KAAKq4C,QAAS79C,EAASupC,GAAQS,QAAQxkC,QAASsxB,GAC/D,OAAO,IAAI2sB,GAAMh+C,EAAQzF,EAAOkJ,IAAI,EAAGgP,UAAW,IAAI2oC,GAAYp7C,EAAQyS,KAG9EzS,aAAsB,OAAOD,KAAKq4C,QAClCsQ,cAAuB,OAAO3oD,KAAKq4C,QAAQhnB,OAAOl2B,OAClDgF,mBACI,OAAOH,KAAKq/C,gBAAkBr/C,KAAKq/C,cAAgBoK,GAAoBC,QAAQ1pD,OAG5Ef,UAAmC4oC,GACtC,MAAMihB,EAAc9oD,KAAKq4C,QAAQhnB,OAAOh2B,OAAO,CAACnG,EAAGs8B,EAAG18B,IAAMI,EAAEqF,IAAIi3B,EAAEn8B,KAAWP,GAAI,IAAImrB,KACvF,OAAOjgB,KAAK+oD,YAAYlhB,EAAYnkC,IAAKslD,GAAeF,EAAYnzD,IAAIqzD,IAAchyB,OAAQh8B,GAAMA,GAAK,IAEtGiE,YAAwC8oC,GAC3C,MAAM9nC,EAASD,KAAKq4C,QAAQ0Q,YAAYhhB,GAClCvS,EAAYuS,EAAcrkC,IAAK5O,GAAMkL,KAAK0S,KAAK8iB,UAAU1gC,IAAIkiC,OAAOgR,SAC1E,OAAO,IAAIqT,GAAkCp7C,EAAQD,KAAK7E,OAAQq6B,IAanE,MAAM0oB,WAA0F7C,GACnGp8C,YAAYgB,GACRgB,MAAMhB,EAAQ,EAAGA,EAAOoxB,OAAO3tB,IAAK8tB,GAAM1F,GAAKkN,IAAIxH,EAAE/e,KAAM,EAAG,EAAG,MAKzE,MAAMg3C,WAA4Bp+B,EAAlCpsB,kCACWe,KAAAG,aAAe,IAAI8f,IACnBhhB,eAAsC85C,GACzC,OAAO,IAAI0Q,IAAsBh+B,MAC7BstB,EAAMrmC,KAAM,IAAI8hB,GAAOukB,EAAM94C,OAAOoxB,SACtClxB,aAEClB,MAAMyT,EAAYD,GACrB,OAAIuZ,EAAS2Y,aAAalyB,GACfzS,KAAKgwB,gBAAgBtd,EAAMD,IAElCC,EAAK8iB,UAAUuE,QAAQ,CAAC1F,EAAOv/B,IAC3BkL,KAAKyrB,MAAM4I,EAAO5hB,EAAK2f,SAASt9B,GAAG2d,OAEpCzS,MAEJf,gBAAgByT,EAAYD,GAC/B,MAAM8f,EAAa7f,EAAK6f,WAIxB,OAHIA,GAAcA,EAAWp3B,OAAS,GAClC6E,KAAKG,aAAa5F,IAAIkY,EAAK0S,GAAIoN,GAE5BvyB,MCtFR,MAAMsoD,WAAuEpa,GAAA,EAGhFjvC,YAAsB0qD,GAClB1oD,QACAjB,KAAK4pD,MAAQD,EAGjBpoD,aAAsB,OAAOvB,KAAK4pD,MAAMroD,OACxCtB,aAAsB,OAAOD,KAAK4pD,MAAM3pD,OACxCi9C,kBAA2B,OAAOl9C,KAAK4pD,MAAM1M,YAC7C/8C,mBAA4B,OAAOH,KAAK4pD,MAAMzpD,aAC9CktC,sBAA+B,OAAOrtC,KAAK4pD,MAAMvc,gBACjDJ,uBAAgC,OAAOjtC,KAAK4pD,MAAM3c,iBAClDJ,aAAsB,OAAO7sC,KAAK4pD,MAAMC,SAAW7pD,KAAK4pD,MAAM/c,OAAS,KAEhE5tC,SAA0C,OAAOe,KAAK4pD,MAAMrB,SAC5DtpD,UAAgD,OAAOe,KAAK4pD,MAAME,UAClE7qD,SAA8C,OAAOe,KAAK4pD,MAAMC,SAChE5qD,WAAkD,OAAOe,KAAK4pD,MAAMG,WAEpE9qD,OACH,OAAOe,KAAK4pD,MAAMhtD,OAEfqC,MAAMlJ,GACT,OAAOiK,KAAK4pD,MAAM9mD,MAAM/M,GAErBkJ,OAAOlJ,GACV,OAAOiK,KAAK4pD,MAAMnoD,OAAO1L,GAEtBkJ,SACH,OAAOe,KAAK4pD,MAAMjb,SAEf1vC,MAAMgB,GAIT,OAHAD,KAAK4pD,MAAMlM,MAAMz9C,GACjBD,KAAKa,gBAAaoB,EAClBjC,KAAKe,iBAAckB,EACZjC,KAEJf,KAAKsB,GACR,MAAMkoD,EAAUzoD,KAAK4pD,MAAMpB,KAAKjoD,GAChC,OAAO/K,OAAAyhC,GAAA,EAAAzhC,CAAUizD,GAAWA,EAAQjpD,KAAK,IAAMQ,MAAQA,KAEpDf,gBAAgBzD,GACnB,OAAOwE,KAAK4pD,MAAMC,SAAW7pD,KAAK4pD,MAAMI,gBAAgBxuD,GAAS,KAE9DyD,CAACpJ,OAAO8G,YACX,OAA2CqD,KAAK4pD,MAAO/zD,OAAO8G,YAE3DsC,CAACpJ,OAAOuH,iBACX,OAAgD4C,KAAK4pD,MAAO/zD,OAAOuH,iBAEhE6B,cACH,OAAOqvC,EAAA,EAAextC,YACjBd,KAAKuoD,SACA,CAAEtpD,CAACpJ,OAAO8G,UAAW,IAAMqD,MAC3B,CAAEf,CAACpJ,OAAOuH,eAAgB,IAAM4C,OAEvCf,eACH,OAAOqvC,EAAA,EAAettC,aACjBhB,KAAKuoD,SACA,CAAEtpD,CAACpJ,OAAO8G,UAAW,IAAMqD,MAC3B,CAAEf,CAACpJ,OAAOuH,eAAgB,IAAM4C,MACtC,CAAE49C,YAAY,IAKf3+C,mBAAmBsB,GACtB,MAAU9B,MAAM,mDAGbQ,kBAEHq+C,EAEAC,GAEA,MAAU9+C,MAAM,kDAWbQ,YAAyDtF,GAC5D,OAAIA,aAAkB2uD,GACX3uD,EACAnE,OAAAyhC,GAAA,EAAAzhC,CAAYmE,GA4iB/B,SAA8DA,GAC1D,OAAO,IAAIswD,GAAwB,IAAIC,GAA6BvwD,IA5iBrDwwD,CAAiBxwD,GACjBnE,OAAAyhC,GAAA,EAAAzhC,CAAamE,GAikBhCuD,eAAqEvD,GACjE,MAAMc,KAAEA,SAAed,EAAOu1C,OACxBF,EAAO,IAAID,GAAsBp1C,EAAQc,GAC/C,GAAIA,GAAQugD,IACJH,SAA+B7L,EAAKH,OAAO,EAAIiM,GAAc,GAAK,IAClE,OAAO,IAAIsP,GAA2B,IAAIC,GAAkCrb,IAGpF,OAAO,IAAIsb,GAA6B,IAAIC,GAAoCvb,IAxkBjEwb,CAAkB7wD,GAClBnE,OAAAyhC,GAAA,EAAAzhC,CAAemE,GACf,gBAAmB2uD,GAAkBrsD,WAAgBtC,GAArD,GACAnE,OAAAyhC,GAAA,EAAAzhC,CAAgBmE,IAAWnE,OAAAyhC,GAAA,EAAAzhC,CAAoBmE,IAAWnE,OAAAyhC,GAAA,EAAAzhC,CAAqBmE,IAAWnE,OAAAyhC,GAAA,EAAAzhC,CAAgBmE,GAojB7HuD,eAA0EvD,GACtE,MAAMmC,QAAcnC,EAAO40C,KAAMuM,GAAc,GAAK,GACpD,OAAOh/C,GAASA,EAAMhC,YAAc,EAAK+gD,GAAyB/+C,GAE5D,IAAI2uD,GAAsB,IAAIC,SAAmC/wD,EAAO6K,SADxE,IAAI8lD,GAA6B,IAAIC,GAAoC5wD,IAEzE,IAAI2wD,GAA6B,IAAIC,GAAoCrtD,wBAxjBhEytD,CAAuB,IAAInc,GAAgB70C,IA0iB9D,SAA+DA,GAC3D,MAAMmC,EAAQnC,EAAO40C,KAAMuM,GAAc,GAAK,GAC9C,OAAOh/C,GAASA,EAAMhC,YAAc,EAAK+gD,GAAyB/+C,GAE5D,IAAI2uD,GAAsB,IAAIC,GAA6B/wD,EAAO6K,SADlE,IAAIylD,GAAwB,IAAIW,GAA+BjxD,IAE/D,IAAIswD,GAAwB,IAAIW,GAA+B,kBA7iB1DC,CAAkB,IAAIzc,GAAWz0C,IAWrCsF,eAA4DtF,GAC/D,OAAIA,aAAkB2uD,GACX3uD,EAAO4uD,SAAWuC,GAAYnxD,GAAUoxD,GAAapxD,GACrDnE,OAAAyhC,GAAA,EAAAzhC,CAAYmE,IAAWF,YAAYsC,OAAOpC,IAAWnE,OAAAyhC,GAAA,EAAAzhC,CAAiCmE,IAAWnE,OAAAyhC,GAAA,EAAAzhC,CAAiBmE,GAClHmxD,GAAenxD,GAEnBoxD,GAAgBpxD,IAyBxB,MAAMswD,WAA6E3B,GACtFrpD,YAAsB2qD,GAAyC3oD,MAAO2oD,GAAhD5pD,KAAA4pD,QACf3qD,CAACpJ,OAAO8G,YAAc,OAAQqD,KAAK4pD,MAA2C/zD,OAAO8G,YACrFsC,OAAQpJ,OAAOuH,uBAAiE4C,KAAKnK,OAAO8G,aAGhG,MAAM2tD,WAAkFhC,GAC3FrpD,YAAsB2qD,GAA8C3oD,MAAO2oD,GAArD5pD,KAAA4pD,QACf3qD,CAACpJ,OAAO8G,YAAgD,MAAU8B,MAAM,gDACxEQ,CAACpJ,OAAOuH,iBAAmB,OAAQ4C,KAAK4pD,MAAgD/zD,OAAOuH,kBAGnG,MAAMqtD,WAA2ER,GACpFhrD,YAAsB2qD,GAAuC3oD,MAAO2oD,GAA9C5pD,KAAA4pD,SAGnB,MAAMQ,WAAgFE,GACzFrrD,YAAsB2qD,GAA4C3oD,MAAO2oD,GAAnD5pD,KAAA4pD,SAkG1B,MAAeoB,GAaX/rD,YAAYkB,EAAe,IAAI8f,KATxBjgB,KAAAuB,QAAS,EACTvB,KAAAk9C,aAAc,EAGXl9C,KAAAy6C,iBAAmB,EACnBz6C,KAAAirD,kBAAoB,EAK1BjrD,KAAKG,aAAeA,EAJxBktC,sBAA+B,OAAOrtC,KAAKy6C,iBAC3CxN,uBAAgC,OAAOjtC,KAAKirD,kBAMrChsD,SAA0C,OAAO,EACjDA,UAAgD,OAAO,EACvDA,SAA8C,OAAO,EACrDA,WAAkD,OAAO,EAEzDA,MAAMgB,GAKT,OAJAD,KAAKy6C,iBAAmB,EACxBz6C,KAAKirD,kBAAoB,EACzBjrD,KAAKC,OAAeA,EACpBD,KAAKG,aAAe,IAAI8f,IACjBjgB,KAGDf,iBAAiB22C,EAA8BlH,GACrD,OAAO,IAAI2M,GAAer7C,KAAKC,OAAQ21C,EAAOz6C,OAAQ6E,KAAKkrD,aAAatV,EAAQlH,EAAM1uC,KAAKC,OAAOoxB,SAE5FpyB,qBAAqB22C,EAAkClH,GAC7D,MAAMvpB,GAAEA,EAAE+C,QAAEA,EAAOxV,KAAEA,GAASkjC,GACxBz1C,aAAEA,EAAYF,OAAEA,GAAWD,KAC3BuyB,EAAapyB,EAAaxK,IAAIwvB,GACpC,GAAI+C,IAAYqK,EAAY,CACxB,MAAM9f,EAAOxS,EAAOE,aAAaxK,IAAIwvB,GACrC,OAAQoN,GAAcrK,EAAUqK,EAAW3b,OACvCwH,EAAO4a,IAAIh5B,KAAKkrD,aAAax4C,EAAMg8B,EAAM,CAACj8B,IAAO,KACjD2L,EAAO4a,IAAIh5B,KAAKkrD,aAAax4C,EAAMg8B,EAAM,CAACj8B,IAAO,IAEzD,OAAO8f,EAEDtzB,aAAa22C,EAA8BlH,EAAWyc,GAC5D,OAAO,IAAI3Z,GAAa9C,EAAMkH,EAAOtqB,MAAOsqB,EAAO74C,QAASiD,KAAKG,cAAc4xC,UAAUoZ,IAKjG,MAAMP,WAAiFI,GAKnF/rD,YAAYtF,EAAoCwG,GAC5Cc,MAAMd,GACNH,KAAKorD,QAAW51D,OAAAyhC,GAAA,EAAAzhC,CAAYmE,GAEtB,IAAI2gD,GAAkBt6C,KAAKivC,QAAUt1C,GADrC,IAAImgD,GAAc95C,KAAKivC,QAAUt1C,GAIpCsF,SAA0C,OAAO,EACjDA,WAAkD,OAAO,EACzDA,CAACpJ,OAAO8G,YACX,OAAOqD,KAEJf,UACEe,KAAKuB,SAAWvB,KAAKuB,QAAS,KAC/BvB,KAAK09C,QAAQ0N,QAAQ3pD,SACrBzB,KAAKorD,QAAgB,KACrBprD,KAAKG,aAAqB,MAG3BlB,KAAKsB,GAOR,OANKP,KAAKuB,SACNvB,KAAKk9C,YAAcmO,GAAkBrrD,KAAMO,GACrCP,KAAKC,SAAWD,KAAKC,OAASD,KAAKorD,QAAQE,eAC7CtrD,KAAK2uC,UAGN3uC,KAEJf,MAAMlJ,GACT,OAAKiK,KAAKuB,QAAUvB,KAAKk9C,cAAgBl9C,KAAKuB,QAAS,GAC5CvB,KAAK09C,QAAQ0N,QAAQtoD,MAAM/M,GAE/Bm4C,GAAA,EAEJjvC,OAAOlJ,GACV,OAAKiK,KAAKuB,QAAUvB,KAAKk9C,cAAgBl9C,KAAKuB,QAAS,GAC5CvB,KAAK09C,QAAQ0N,QAAQ3pD,OAAO1L,GAEhCm4C,GAAA,EAEJjvC,OACH,GAAIe,KAAKuB,OAAU,OAAO2sC,GAAA,EAC1B,IAAIgI,GAA2BkV,QAASjnD,GAAWnE,KACnD,KAAOk2C,EAAUl2C,KAAKurD,+BAClB,GAAIrV,EAAQK,WACRv2C,KAAK09C,MAAMxH,EAAQN,cAChB,IAAIM,EAAQM,gBAAiB,CAChCx2C,KAAKirD,oBACL,MAAMrV,EAASM,EAAQN,SACjB17C,EAASiK,EAAOqnD,gBAAgBtV,EAAQttB,YAE9C,MAAO,CAAE3rB,MAAM,EAAOlH,MADFiK,KAAKyrD,iBAAiB7V,EAAQ17C,IAE/C,GAAIg8C,EAAQO,oBAAqB,CACpCz2C,KAAKy6C,mBACL,MAAM7E,EAASM,EAAQN,SACjB17C,EAASiK,EAAOqnD,gBAAgBtV,EAAQttB,YACxCoc,EAAShlC,KAAK0rD,qBAAqB9V,EAAQ17C,GACjD8F,KAAKG,aAAa5F,IAAIq7C,EAAOzwB,GAAI6f,IAGzC,OAAIhlC,KAAKC,QAAqC,IAA3BD,KAAKirD,mBACpBjrD,KAAKirD,oBACE,CAAEhuD,MAAM,EAAOlH,MAAO,IAAImoD,GAAwCl+C,KAAKC,UAE3ED,KAAKyB,SAENxC,4BAAqDwT,GAC3D,OAAOzS,KAAKorD,QAAQlR,YAAeznC,IAK3C,MAAM83C,WAAsFS,GAKxF/rD,YAAYtF,EAAyBwG,GACjCc,MAAMd,GACNH,KAAKorD,QAAU,IAAI/Q,GAAmBr6C,KAAKivC,QAAUt1C,GAElDsF,UAAgD,OAAO,EACvDA,WAAkD,OAAO,EACzDA,CAACpJ,OAAOuH,iBACX,OAAO4C,KAEJf,gBACEe,KAAKuB,SAAWvB,KAAKuB,QAAS,WACzBvB,KAAK09C,QAAQ0N,QAAQ3pD,SAC3BzB,KAAKorD,QAAgB,KACrBprD,KAAKG,aAAqB,MAG3BlB,WAAWsB,GAOd,OANKP,KAAKuB,SACNvB,KAAKk9C,YAAcmO,GAAkBrrD,KAAMO,GACrCP,KAAKC,SAAWD,KAAKC,aAAgBD,KAAKorD,QAAQE,qBAC9CtrD,KAAK2uC,UAGZ3uC,KAEJf,YAAYlJ,GACf,OAAKiK,KAAKuB,QAAUvB,KAAKk9C,cAAgBl9C,KAAKuB,QAAS,SACtCvB,KAAK09C,QAAQ0N,QAAQtoD,MAAM/M,GAErCm4C,GAAA,EAEJjvC,aAAalJ,GAChB,OAAKiK,KAAKuB,QAAUvB,KAAKk9C,cAAgBl9C,KAAKuB,QAAS,SACtCvB,KAAK09C,QAAQ0N,QAAQ3pD,OAAO1L,GAEtCm4C,GAAA,EAEJjvC,aACH,GAAIe,KAAKuB,OAAU,OAAO2sC,GAAA,EAC1B,IAAIgI,GAA2BkV,QAASjnD,GAAWnE,KACnD,KAAOk2C,QAAgBl2C,KAAKurD,+BACxB,GAAIrV,EAAQK,iBACFv2C,KAAK09C,MAAMxH,EAAQN,cACtB,IAAIM,EAAQM,gBAAiB,CAChCx2C,KAAKirD,oBACL,MAAMrV,EAASM,EAAQN,SACjB17C,QAAeiK,EAAOqnD,gBAAgBtV,EAAQttB,YAEpD,MAAO,CAAE3rB,MAAM,EAAOlH,MADFiK,KAAKyrD,iBAAiB7V,EAAQ17C,IAE/C,GAAIg8C,EAAQO,oBAAqB,CACpCz2C,KAAKy6C,mBACL,MAAM7E,EAASM,EAAQN,SACjB17C,QAAeiK,EAAOqnD,gBAAgBtV,EAAQttB,YAC9Coc,EAAShlC,KAAK0rD,qBAAqB9V,EAAQ17C,GACjD8F,KAAKG,aAAa5F,IAAIq7C,EAAOzwB,GAAI6f,IAGzC,OAAIhlC,KAAKC,QAAqC,IAA3BD,KAAKirD,mBACpBjrD,KAAKirD,oBACE,CAAEhuD,MAAM,EAAOlH,MAAO,IAAImoD,GAAwCl+C,KAAKC,gBAErED,KAAKyB,SAEZxC,kCAA2DwT,GACjE,aAAazS,KAAKorD,QAAQlR,YAAeznC,IAKjD,MAAMi4C,WAA+EE,GAUjF3rD,YAAYtF,EAAiDwG,GACzDc,MAAMtH,aAAkBi1C,GAAmBj1C,EAAS,IAAIi1C,GAAiBj1C,GAASwG,GALtF0sC,aAAsB,OAAO7sC,KAAK4tC,QAClCP,sBAA+B,OAAOrtC,KAAK4tC,QAAU5tC,KAAK4tC,QAAQP,gBAAkB,EACpFJ,uBAAgC,OAAOjtC,KAAK4tC,QAAU5tC,KAAK4tC,QAAQX,iBAAmB,EAK/EhuC,SAA0C,OAAO,EACjDA,SAA8C,OAAO,EACrDA,KAAKsB,GACR,IAAKP,KAAKuB,SAAWvB,KAAK4tC,QAAS,CAC/B5tC,KAAKC,QAAUD,KAAK4tC,QAAU5tC,KAAK2rD,eAAe1rD,OAClD,IAAK,MAAMwtC,KAASztC,KAAK4tC,QAAQlB,oBAC7Be,GAASztC,KAAK4rD,qBAAqB5rD,KAAKy6C,oBAGhD,OAAOx5C,MAAMunD,KAAKjoD,GAEftB,gBAAgBzD,GACnB,GAAIwE,KAAKuB,OAAU,OAAO,KACrBvB,KAAK4tC,SAAW5tC,KAAKwoD,OAC1B,MAAM/a,EAAQztC,KAAK4tC,SAAW5tC,KAAK4tC,QAAQF,eAAelyC,GAC1D,GAAIiyC,GAASztC,KAAKivC,QAAQ4c,KAAKpe,EAAMlyC,QAAS,CAC1C,MAAM26C,EAAUl2C,KAAKorD,QAAQlR,YAAY7yB,EAAcG,aACvD,GAAI0uB,GAAWA,EAAQM,gBAAiB,CACpC,MAAMZ,EAASM,EAAQN,SACjB17C,EAAS8F,KAAKorD,QAAQI,gBAAgBtV,EAAQttB,YAEpD,OADoB5oB,KAAKyrD,iBAAiB7V,EAAQ17C,IAI1D,OAAO,KAED+E,qBAAqBzD,GAC3B,MAAMiyC,EAAQztC,KAAK4tC,SAAW5tC,KAAK4tC,QAAQD,mBAAmBnyC,GAC9D,GAAIiyC,GAASztC,KAAKivC,QAAQ4c,KAAKpe,EAAMlyC,QAAS,CAC1C,MAAM26C,EAAUl2C,KAAKorD,QAAQlR,YAAY7yB,EAAcW,iBACvD,GAAIkuB,GAAWA,EAAQO,oBAAqB,CACxC,MAAMb,EAASM,EAAQN,SACjB17C,EAAS8F,KAAKorD,QAAQI,gBAAgBtV,EAAQttB,YAC9Coc,EAAShlC,KAAK0rD,qBAAqB9V,EAAQ17C,GACjD8F,KAAKG,aAAa5F,IAAIq7C,EAAOzwB,GAAI6f,KAInC/lC,cACN,MAAMgwC,QAAEA,GAAYjvC,KACdzE,EAAS0zC,EAAQx0C,KAAOsgD,GACxB5/C,EAAS8zC,EAAQpkC,UAAUtP,GAC3BrB,EAAS+0C,EAAQJ,OAAOtzC,EAASJ,EAAQA,GAC/C,OAAOoxC,GAAO1+B,OAAO3T,GAEf+E,4BAAqDwT,GAE3D,GADKzS,KAAK4tC,SAAW5tC,KAAKwoD,OACtBxoD,KAAK4tC,SAAW5tC,KAAKirD,kBAAoBjrD,KAAKitC,iBAAkB,CAChE,MAAMQ,EAAQztC,KAAK4tC,SAAW5tC,KAAK4tC,QAAQF,eAAe1tC,KAAKirD,mBAC/D,GAAIxd,GAASztC,KAAKivC,QAAQ4c,KAAKpe,EAAMlyC,QACjC,OAAOyE,KAAKorD,QAAQlR,YAAYznC,GAGxC,OAAO,MAKf,MAAM43C,WAAoFE,GAYtFtrD,YAAYtF,KAA+CysC,GACvD,MAAMtsC,EAAgC,iBAAZssC,EAAK,GAA2BA,EAAKxkC,aAAUK,EACnE9B,EAAeimC,EAAK,aAAcnmB,IAA4BmmB,EAAKxkC,aAAUK,EACnFhB,MAAMtH,aAAkBo1C,GAAwBp1C,EAAS,IAAIo1C,GAAsBp1C,EAAQG,GAAaqG,GAT5G0sC,aAAsB,OAAO7sC,KAAK4tC,QAClCP,sBAA+B,OAAOrtC,KAAK4tC,QAAU5tC,KAAK4tC,QAAQP,gBAAkB,EACpFJ,uBAAgC,OAAOjtC,KAAK4tC,QAAU5tC,KAAK4tC,QAAQX,iBAAmB,EAS/EhuC,SAA8C,OAAO,EACrDA,UAAgD,OAAO,EACvDA,WAAWsB,GACd,IAAKP,KAAKuB,SAAWvB,KAAK4tC,QAAS,CAC/B5tC,KAAKC,QAAUD,KAAK4tC,cAAgB5tC,KAAK2rD,eAAe1rD,OACxD,IAAK,MAAMwtC,KAASztC,KAAK4tC,QAAQlB,oBAC7Be,SAAeztC,KAAK4rD,qBAAqB5rD,KAAKy6C,oBAGtD,aAAax5C,MAAMunD,KAAKjoD,GAErBtB,sBAAsBzD,GACzB,GAAIwE,KAAKuB,OAAU,OAAO,KACrBvB,KAAK4tC,eAAiB5tC,KAAKwoD,OAChC,MAAM/a,EAAQztC,KAAK4tC,SAAW5tC,KAAK4tC,QAAQF,eAAelyC,GAC1D,GAAIiyC,SAAgBztC,KAAKivC,QAAQ4c,KAAKpe,EAAMlyC,QAAU,CAClD,MAAM26C,QAAgBl2C,KAAKorD,QAAQlR,YAAY7yB,EAAcG,aAC7D,GAAI0uB,GAAWA,EAAQM,gBAAiB,CACpC,MAAMZ,EAASM,EAAQN,SACjB17C,QAAe8F,KAAKorD,QAAQI,gBAAgBtV,EAAQttB,YAE1D,OADoB5oB,KAAKyrD,iBAAiB7V,EAAQ17C,IAI1D,OAAO,KAED+E,2BAA2BzD,GACjC,MAAMiyC,EAAQztC,KAAK4tC,SAAW5tC,KAAK4tC,QAAQD,mBAAmBnyC,GAC9D,GAAIiyC,SAAgBztC,KAAKivC,QAAQ4c,KAAKpe,EAAMlyC,QAAU,CAClD,MAAM26C,QAAgBl2C,KAAKorD,QAAQlR,YAAY7yB,EAAcW,iBAC7D,GAAIkuB,GAAWA,EAAQO,oBAAqB,CACxC,MAAMb,EAASM,EAAQN,SACjB17C,QAAe8F,KAAKorD,QAAQI,gBAAgBtV,EAAQttB,YACpDoc,EAAShlC,KAAK0rD,qBAAqB9V,EAAQ17C,GACjD8F,KAAKG,aAAa5F,IAAIq7C,EAAOzwB,GAAI6f,KAInC/lC,oBACN,MAAMgwC,QAAEA,GAAYjvC,KACpBivC,EAAQ5U,gBAAkB4U,EAAQ5U,SAClC,MAAM9+B,EAAS0zC,EAAQx0C,KAAOsgD,GACxB5/C,QAAe8zC,EAAQpkC,UAAUtP,GACjCrB,QAAe+0C,EAAQJ,OAAOtzC,EAASJ,EAAQA,GACrD,OAAOoxC,GAAO1+B,OAAO3T,GAEf+E,kCAA2DwT,GAEjE,GADKzS,KAAK4tC,eAAiB5tC,KAAKwoD,OAC5BxoD,KAAK4tC,SAAW5tC,KAAKirD,kBAAoBjrD,KAAKitC,iBAAkB,CAChE,MAAMQ,EAAQztC,KAAK4tC,QAAQF,eAAe1tC,KAAKirD,mBAC/C,GAAIxd,SAAeztC,KAAKivC,QAAQ4c,KAAKpe,EAAMlyC,QACvC,aAAayE,KAAKorD,QAAQlR,YAAYznC,GAG9C,OAAO,MAKf,MAAMy3C,WAA+EU,GACjF3rD,YAAYtF,EAAuBwG,GAC/Bc,MAAMtH,EAAQwG,GAERlB,aAAa22C,EAA8BlH,EAAWyc,GAC5D,OAAO,IAAIhZ,GAAiBzD,EAAMkH,EAAOtqB,MAAOsqB,EAAO74C,QAASiD,KAAKG,cAAc4xC,UAAUoZ,IAWrG,SAASE,GAAkBhmB,EAAgC9kC,GACvD,OAAOA,GAA8C,kBAA3BA,EAAqB,YAAmBA,EAAqB,YAAI8kC,EAAkB,YAIjH,SAAUylB,GAAyDnxD,GAC/D,MAAMwK,EAASmkD,GAAkBrsD,KAActC,GAC/C,IACI,IAAKwK,EAAOqkD,KAAK,CAAEtL,aAAa,IAAS37C,OACrC,SAAW4C,SAAmBA,EAAOu5C,QAAQ8K,OAAQjnD,gBAEjD4C,EAAOwqC,UAIvBzxC,eAAgB6tD,GAA0DpxD,GACtE,MAAMwK,QAAemkD,GAAkBrsD,KAActC,GACrD,IACI,WAAYwK,EAAOqkD,KAAK,CAAEtL,aAAa,KAAU37C,OAC7C,SAAW4C,gBAAyBA,EAAOu5C,QAAQ8K,QAAQjnD,sBAEjD4C,EAAOwqC,UC7pBtB,MAAMmd,GAYT7sD,YAAYsB,GANJP,KAAA+rD,WAAa,EACb/rD,KAAAgsD,WAAY,EACZhsD,KAAAisD,cAAgB,EAQpB,MACI1O,iBAAsBA,EACtBD,iBAAsBA,EACtB1kB,iBAAsBA,EAAmB,WACtCszB,GACH3rD,EAEJP,KAAKmsD,YAAc,KACnBnsD,KAAKosD,SAAW5zB,GAAQQ,IAAckzB,GACtClsD,KAAKqsD,SAAgC,UAArBzzB,EAA+BkN,GAAcwmB,GAE7D,MAAQzzB,cAAmB0zB,GAA6C,UAArB3zB,EAA+B,MAAU,MAAS,IAAK2kB,IAClG1kB,cAAmB2zB,GAA6C,UAArB5zB,EAA+B,MAAU,MAAS,IAAK0kB,GAE1Gt9C,KAAe,SAAI,IAAIysD,eAAqB,CACxC9d,OAAY,KAAS3uC,KAAKosD,SAASvlD,SACnC6lD,KAAWv3D,IAAQ6K,KAAK2sD,YAAY3sD,KAAKosD,SAAUpsD,KAAKmsD,YAAch3D,IACtE8f,MAAY9f,IAAQ6K,KAAK2sD,YAAY3sD,KAAKosD,SAAUpsD,KAAKmsD,YAAch3D,KACxE,CACC0jC,cAAiB0zB,EACjB9xD,KAA6B,UAArBm+B,EAA+BkN,GAAcwmB,KAGzDtsD,KAAe,SAAI,IAAI4sD,eAAe,CAClCzqD,MAAW,KAAQnC,KAAKosD,SAASvlD,SACjCsL,MAAW,KAAQnS,KAAK2sD,YAAY3sD,KAAKosD,SAAUpsD,KAAKmsD,cACxD/pD,MAAW,KAAQpC,KAAK2sD,YAAY3sD,KAAKosD,SAASjiD,SAAUnK,KAAKmsD,eAClE,CACCtzB,cAAiB2zB,EACjB/xD,KAAS1E,GAA+BiK,KAAK6sD,8BAA8B92D,KAI3EkJ,8BAA8BlJ,GAClC,MAAM+2D,EAAe9sD,KAAKisD,cAE1B,OADAjsD,KAAKisD,cAAgBjsD,KAAKqsD,SAASrsD,KAAKosD,SAASnzB,OAAOljC,IACjDiK,KAAKisD,cAAgBa,EAGxB7tD,YAAY+f,EAA4B+tC,GACzB,OAAfA,IACA/sD,KAAKisD,eAAiBc,EAAWC,eAC/BhtD,KAAK+rD,YAAc/rD,KAAKitD,SAASF,EAAY/tC,EAAQka,YAEvDla,EAAQjQ,YACJiQ,EAAQ7jB,OAAS,GAAyB,IAApB6E,KAAK+rD,eACzB/rD,KAAK+rD,YAAc/rD,KAAKitD,SAASF,EAAY/tC,EAAQka,aAEtDl5B,KAAKgsD,YAAchsD,KAAKgsD,WAAY,IACrChsD,KAAKitD,SAASF,EAAY,QAK9B9tD,SAAS8tD,EAAmDroB,GAChE1kC,KAAKisD,cAAgB,EACrBjsD,KAAKmsD,YAAc,KACT,OAAVznB,EAAiBqoB,EAAW3qD,QAAU2qD,EAAWG,QAAQxoB,IAIlD,MAAMoB,GAAyCpB,GAAkCA,EAAMvpC,OACjFmxD,GAA6C5nB,GAAkCA,EAAM5qC,WCxFnG,MAAeqzD,GAClBluD,GAAG6G,GAEC,OADMA,aAAiBqnD,KAAUrnD,EAAQ,IAAIsnD,GAAQtnD,IAC9C,IAAIunD,GAAOrtD,KAAM8F,GAE5B7G,GAAG6G,GAEC,OADMA,aAAiBqnD,KAAUrnD,EAAQ,IAAIsnD,GAAQtnD,IAC9C,IAAIwnD,GAAKttD,KAAM8F,GAE1B7G,GAAG6G,GAEC,OADMA,aAAiBqnD,KAAUrnD,EAAQ,IAAIsnD,GAAQtnD,IAC9C,IAAIynD,GAAKvtD,KAAM8F,GAE1B7G,GAAG6G,GACC,OAAO,IAAI0nD,GAAIxtD,KAAKytD,GAAG3nD,IAE3B7G,GAAG6G,GACC,OAAO,IAAI0nD,GAAIxtD,KAAK0tD,GAAG5nD,IAE3B7G,GAAG6G,GACC,OAAO,IAAI0nD,GAAIxtD,KAAK2tD,GAAG7nD,KAKxB,MAAMsnD,WAAwBD,GACjCluD,YAAmB2hC,GAAQ3/B,QAARjB,KAAA4gC,KAIhB,MAAMgtB,WAAoBT,GAM7BluD,YAAmB5J,GAAgB4L,QAAhBjB,KAAA3K,OACnB4J,KAAK85C,GACD,IAAK/4C,KAAK6tD,OAAQ,CAGd7tD,KAAK6tD,QAAU,EACf,MAAMx8B,EAAS0nB,EAAM94C,OAAOoxB,OAC5B,IAAK,IAAIsD,GAAO,IAAKA,EAAMtD,EAAOl2B,QAC9B,GAAIk2B,EAAOsD,GAAKt/B,OAAS2K,KAAK3K,KAAM,CAChC2K,KAAK6tD,OAASl5B,EACd,MAGR,GAAI30B,KAAK6tD,OAAS,EAAK,MAAUpvD,6BAA6BuB,KAAK3K,SAGvE,MAAMkuC,EAAMvjC,KAAKglC,OAAS+T,EAAMzX,WAAWthC,KAAK6tD,QAChD,OAAQl5B,GAAgB4O,EAAI5tC,IAAIg/B,IAKjC,MAAem5B,GAElB7uD,OAAO8uD,GAA0B,OAAO,IAAIC,GAAIhuD,QAAS+tD,GACzD9uD,MAAM8uD,GAAyB,OAAO,IAAIE,GAAGjuD,QAAS+tD,GACtD9uD,MAAmB,OAAO,IAAIuuD,GAAIxtD,OAI/B,MAAekuD,WAAoCJ,GACtD7uD,YAA4BqxC,EAAgCC,GACxDtvC,QADwBjB,KAAAswC,OAAgCtwC,KAAAuwC,QAI5DtxC,KAAK85C,GACD,OAAI/4C,KAAKswC,gBAAgB8c,GACjBptD,KAAKuwC,iBAAiB6c,GACfptD,KAAKmuD,YAAYpV,EAAO/4C,KAAKswC,KAAMtwC,KAAKuwC,OAGxCvwC,KAAKouD,YAAYrV,EAAO/4C,KAAKswC,KAAMtwC,KAAKuwC,OAG/CvwC,KAAKuwC,iBAAiB6c,GACfptD,KAAKquD,YAAYtV,EAAO/4C,KAAKswC,KAAatwC,KAAKuwC,OAE/CvwC,KAAKsuD,YAAYvV,EAAO/4C,KAAKswC,KAAatwC,KAAKuwC,QAY/D,MAAege,WAA6BT,GAE/C7uD,eAAemzB,GACXnxB,QACAjB,KAAKoyB,SAAWA,GAIjBm8B,GAAqB73D,UAAW07B,SAAW58B,OAAOsK,OAAO,IAGzD,MAAMkuD,WAAYO,GACrBtvD,eAAemzB,GAEXA,EAAWA,EAAS/2B,OAAO,CAACmzD,EAAoB53D,IACrC43D,EAAM53C,OAAOhgB,aAAao3D,GAAMp3D,EAAEw7B,SAAWx7B,GACrD,IACHqK,SAASmxB,GAEbnzB,KAAK85C,GACD,MAAMuK,EAAQtjD,KAAKoyB,SAAS1uB,IAAK9M,GAAMA,EAAEN,KAAKyiD,IAC9C,MAAO,CAACpkB,EAAaokB,IAAuBuK,EAAM/xB,MAAO36B,GAAMA,EAAE+9B,EAAKokB,KAKvE,MAAMkV,WAAWM,GACpBtvD,eAAemzB,GAEXA,EAAWA,EAAS/2B,OAAO,CAACmzD,EAAoB53D,IACrC43D,EAAM53C,OAAOhgB,aAAaq3D,GAAKr3D,EAAEw7B,SAAWx7B,GACpD,IACHqK,SAASmxB,GAEbnzB,KAAK85C,GACD,MAAMuK,EAAQtjD,KAAKoyB,SAAS1uB,IAAK9M,GAAMA,EAAEN,KAAKyiD,IAC9C,MAAO,CAACpkB,EAAaokB,IAAuBuK,EAAMhd,KAAM1vC,GAAMA,EAAE+9B,EAAKokB,KAKtE,MAAMsU,WAAea,GAKdjvD,YAAYwvD,EAAqBne,EAAeC,GACtD,MAAMme,EAAgBpe,EAAK1P,GAAK2P,EAAM3P,EACtC,MAAO,IAAM8tB,EAGPzvD,YAAY85C,EAAoBzI,EAAWC,GACjD,MAAMoe,EAAYre,EAAKh6C,KAAKyiD,GACtB6V,EAAare,EAAMj6C,KAAKyiD,GAC9B,MAAO,CAACpkB,EAAaokB,IAAuB4V,EAAUh6B,EAAKokB,IAAU6V,EAAWj6B,EAAKokB,GAG/E95C,YAAY85C,EAAoB8V,EAAUC,GAChD,MAAMC,EAAWF,EAAIv4D,KAAKyiD,GAC1B,GAAI8V,EAAI7pB,kBAAkBgc,GAAkB,CACxC,IAAI3qD,EACJ,MAAM2uC,EAAS6pB,EAAI7pB,OASnB,OARIA,EAAOzS,aAAevyB,KAAKgvD,gBAC3B34D,EAAM2uC,EAAOiqB,cAAcH,EAAIluB,GAC/B5gC,KAAKgvD,eAAiBhqB,EAAOzS,WAC7BvyB,KAAKkvD,QAAU74D,GAEfA,EAAM2J,KAAKkvD,SAGF,IAAT74D,EAMO,KAAM,EAELs+B,GACGqQ,EAAOlD,OAAOnN,KAASt+B,EAItC,MAAO,CAACs+B,EAAa+zB,IAAsBqG,EAASp6B,EAAK+zB,IAASoG,EAAIluB,EAIpE3hC,YAAY85C,EAAoB+V,EAAcD,GAEpD,OAAO7uD,KAAKquD,YAAYtV,EAAO8V,EAAKC,IAKrC,MAAMxB,WAAaY,GACZjvD,YAAYwvD,EAAqBne,EAAeC,GACtD,MAAMme,EAAgBpe,EAAK1P,GAAK2P,EAAM3P,EACtC,MAAO,IAAM8tB,EAGPzvD,YAAY85C,EAAoBzI,EAAWC,GACjD,MAAMoe,EAAYre,EAAKh6C,KAAKyiD,GACtB6V,EAAare,EAAMj6C,KAAKyiD,GAC9B,MAAO,CAACpkB,EAAa+zB,IAAsBiG,EAAUh6B,EAAK+zB,IAASkG,EAAWj6B,EAAK+zB,GAG7EzpD,YAAY85C,EAAoB8V,EAAUC,GAChD,MAAMC,EAAWF,EAAIv4D,KAAKyiD,GAC1B,MAAO,CAACpkB,EAAa+zB,IAAsBqG,EAASp6B,EAAK+zB,IAASoG,EAAIluB,EAGhE3hC,YAAY85C,EAAoB+V,EAAcD,GACpD,MAAME,EAAWF,EAAIv4D,KAAKyiD,GAC1B,MAAO,CAACpkB,EAAa+zB,IAAsBoG,EAAIluB,GAAKmuB,EAASp6B,EAAK+zB,IAKnE,MAAM6E,WAAaW,GACZjvD,YAAYwvD,EAAqBne,EAAeC,GACtD,MAAMme,EAAgBpe,EAAK1P,GAAK2P,EAAM3P,EACtC,MAAO,IAAM8tB,EAGPzvD,YAAY85C,EAAoBzI,EAAWC,GACjD,MAAMoe,EAAYre,EAAKh6C,KAAKyiD,GACtB6V,EAAare,EAAMj6C,KAAKyiD,GAC9B,MAAO,CAACpkB,EAAa+zB,IAAsBiG,EAAUh6B,EAAK+zB,IAASkG,EAAWj6B,EAAK+zB,GAG7EzpD,YAAY85C,EAAoB8V,EAAUC,GAChD,MAAMC,EAAWF,EAAIv4D,KAAKyiD,GAC1B,MAAO,CAACpkB,EAAa+zB,IAAsBqG,EAASp6B,EAAK+zB,IAASoG,EAAIluB,EAGhE3hC,YAAY85C,EAAoB+V,EAAcD,GACpD,MAAME,EAAWF,EAAIv4D,KAAKyiD,GAC1B,MAAO,CAACpkB,EAAa+zB,IAAsBoG,EAAIluB,GAAKmuB,EAASp6B,EAAK+zB,IAKnE,MAAM8E,WAAYM,GACrB7uD,YAA4Bo1B,GACxBpzB,QADwBjB,KAAAq0B,QAI5Bp1B,KAAK85C,GACD,MAAMoW,EAAOnvD,KAAKq0B,MAAM/9B,KAAKyiD,GAC7B,MAAO,CAACpkB,EAAaokB,KAAwBoW,EAAKx6B,EAAKokB,IAKxD,MAAMqW,WAAwBtB,GACjC7uD,YAAoBrC,EAA6ByyD,GAC7CpuD,QADgBjB,KAAApD,OAA6BoD,KAAAqvD,QAIjDpwD,KAAK85C,GAED,OADA/4C,KAAKqvD,MAAMtW,GACJ/4C,KAAKpD,MAIb,SAAS0yD,GAAI1uB,GAAsB,OAAO,IAAIwsB,GAAQxsB,GACtD,SAAS2uB,GAAIh5D,GAAuB,OAAO,IAAIq3D,GAAIr3D,GACnD,SAASi5D,MAAO54D,GAAuB,OAAO,IAAIo3D,MAAOp3D,GACzD,SAAS64D,MAAM74D,GAAsB,OAAO,IAAIq3D,MAAMr3D,GACtD,SAAS84D,GAAO9yD,EAAqBtG,GACxC,OAAO,IAAI84D,GAAgBxyD,EAAMtG,GCrQrC2nD,GAAMvnD,UAAUi5D,QAAU,SAAsBt6D,GAAsB,OAAO,IAAIu6D,GAAU5vD,KAAKxF,QAAQm1D,QAAQt6D,IAChH4oD,GAAMvnD,UAAUm5D,KAAO,SAAsBjzD,EAAgBtG,GAAmB,OAAO,IAAIs5D,GAAU5vD,KAAKxF,QAAQq1D,KAAKjzD,EAAMtG,IAC7H2nD,GAAMvnD,UAAUo5D,YAAc,SAAsBlzD,EAAgBtG,GAAmB,OAAO,IAAIs5D,GAAU5vD,KAAKxF,QAAQs1D,YAAYlzD,EAAMtG,IAC3I2nD,GAAMvnD,UAAUsgC,OAAS,SAAsB+4B,GAA2C,OAAO,IAAIH,GAAU5vD,KAAKxF,QAAQw8B,OAAO+4B,IAE5H,MAAMH,WAA+D3R,GACjEh/C,OAAO8wD,GACV,OAAO,IAAIC,GAAqBhwD,KAAKxF,OAAQu1D,GAE1C9wD,KAAKrC,EAAgBtG,GACxB,MAAM4J,EAAUF,KAAKxF,OAAQulD,EAAa7/C,EAAQ/E,OAClD,IAAK,IAAI80D,GAAc,IAAKA,EAAalQ,GAAa,CAElD,MAAMhH,EAAQ74C,EAAQ+vD,GAClB35D,GAAQA,EAAKyiD,GAEjB,IAAK,IAAIv9C,GAAS,EAAG00D,EAAUnX,EAAM59C,SAAUK,EAAQ00D,GACnDtzD,EAAKpB,EAAOu9C,IAIjB95C,YAAYrC,EAAgBtG,GAC/B,MAAM4J,EAAUF,KAAKxF,OACrB,IAAK,IAAIy1D,EADiC/vD,EAAQ/E,SACd80D,GAAc,GAAI,CAElD,MAAMlX,EAAQ74C,EAAQ+vD,GAClB35D,GAAQA,EAAKyiD,GAEjB,IAAK,IAAIv9C,EAAQu9C,EAAM59C,SAAUK,GAAS,GACtCoB,EAAKpB,EAAOu9C,IAIjB95C,QAAQ5J,GACX,MAAM6K,EAAUF,KAAKxF,OAAQulD,EAAa7/C,EAAQ/E,OAC5Cg1D,EAA2B,iBAAT96D,EAAoB,IAAIu4D,GAAIv4D,GAAQA,EAG5D86D,EAAS75D,KAAK4J,EAAQ6/C,EAAa,IACnC,MAAM/a,EAASmrB,EAASnrB,OACxB,IAAKhZ,EAAS2Y,aAAaK,EAAOvyB,MAC9B,MAAUhU,MAAM,8DAGpB,MAAM2xD,EAAkB/1D,KAAKg2D,KAAKh2D,KAAKwjB,IAAImnB,EAAO7pC,QAAUd,KAAKwjB,IAAI,MAI/DyyC,EAAS,IAH4B,GAAnBF,EAAuB9zD,YACvB8zD,GAAmB,EAAI/zD,YAAcpC,YAE1B+qC,EAAOzS,WAAWp3B,QACrD,IAAK,IAAI80D,GAAc,IAAKA,EAAalQ,GAAa,CAElD,MAAMhH,EAAQ74C,EAAQ+vD,GAEtBE,EAAS75D,KAAKyiD,GACd,MAAMtY,EAAQ0vB,EAASnrB,OAAyB1S,QAEhD,IAAK,IAAI92B,GAAS,EAAG00D,EAAUnX,EAAM59C,SAAUK,EAAQ00D,GAAU,CAC7D,IAAI75D,EAAMoqC,EAAK9qC,IAAI6F,GACP,OAARnF,GAAgBi6D,EAAOj6D,MAGnC,OAAO,IAAIk6D,GAAcvrB,EAAOzS,WAAY2vB,GAAUjmD,KAAKq0D,KAK5D,MAAMC,WAA0EtS,GACnFh/C,YAAYgrB,EAAmBqmC,GAE3B,MAAMrwD,EAAS,IAAIynC,GAAU,CACzB,IAAIrB,GAAM,SAAUpc,EAAOxX,MAC3B,IAAI4zB,GAAM,SAAUiqB,EAAO79C,QAE/BxR,MAAM,IAAIo6C,GAAep7C,EAAQqwD,EAAOn1D,OAAQ,CAAC8uB,EAAQqmC,KAEtDrxD,SACH,MAAMgrB,EAASjqB,KAAK4oD,YAAY,GAC1B0H,EAAStwD,KAAK4oD,YAAY,GAC1BjuD,EAAS,GACf,IAAK,IAAI7F,GAAK,IAAKA,EAAIkL,KAAK7E,QACxBR,EAAOsvB,EAAOt0B,IAAIb,IAAMw7D,EAAO36D,IAAIb,GAEvC,OAAO6F,GAKR,MAAMq1D,WAAuEJ,GAEhF3wD,YAAaiB,EAA2B6vD,GACpC9uD,MAAMf,GACNF,KAAKwwD,WAAaT,EAEf9wD,KAAKrC,EAAgBtG,GAKxB,MAAM4J,EAAUF,KAAKmkC,QACf4b,EAAa7/C,EAAQ/E,OAC3B,IAAK,IAAI80D,GAAc,IAAKA,EAAalQ,GAAa,CAElD,MAAMhH,EAAQ74C,EAAQ+vD,GAChBF,EAAY/vD,KAAKwwD,WAAWl6D,KAAKyiD,GACvC,IAAI0X,GAAU,EAEd,IAAK,IAAIj1D,GAAS,EAAG00D,EAAUnX,EAAM59C,SAAUK,EAAQ00D,GAC/CH,EAAUv0D,EAAOu9C,KAGbziD,IAASm6D,IACTn6D,EAAKyiD,GACL0X,GAAU,GAEd7zD,EAAKpB,EAAOu9C,KAKrB95C,YAAYrC,EAAgBtG,GAC/B,MAAM4J,EAAUF,KAAKmkC,QAErB,IAAK,IAAI8rB,EADU/vD,EAAQ/E,SACS80D,GAAc,GAAI,CAElD,MAAMlX,EAAQ74C,EAAQ+vD,GAChBF,EAAY/vD,KAAKwwD,WAAWl6D,KAAKyiD,GACvC,IAAI0X,GAAU,EAEd,IAAK,IAAIj1D,EAAQu9C,EAAM59C,SAAUK,GAAS,GAClCu0D,EAAUv0D,EAAOu9C,KAGbziD,IAASm6D,IACTn6D,EAAKyiD,GACL0X,GAAU,GAEd7zD,EAAKpB,EAAOu9C,KAKrB95C,QAOH,IAAIwrB,EAAM,EACV,MAAMvqB,EAAUF,KAAKmkC,QACf4b,EAAa7/C,EAAQ/E,OAC3B,IAAK,IAAI80D,GAAc,IAAKA,EAAalQ,GAAa,CAElD,MAAMhH,EAAQ74C,EAAQ+vD,GAChBF,EAAY/vD,KAAKwwD,WAAWl6D,KAAKyiD,GAEvC,IAAK,IAAIv9C,GAAS,EAAG00D,EAAUnX,EAAM59C,SAAUK,EAAQ00D,GAC/CH,EAAUv0D,EAAOu9C,MAAYtuB,EAGzC,OAAOA,EAEJxrB,EAAEpJ,OAAO8G,YAKZ,MAAMuD,EAAUF,KAAKmkC,QACf4b,EAAa7/C,EAAQ/E,OAC3B,IAAK,IAAI80D,GAAc,IAAKA,EAAalQ,GAAa,CAElD,MAAMhH,EAAQ74C,EAAQ+vD,GAIhBF,EAAY/vD,KAAKwwD,WAAWl6D,KAAKyiD,GAEvC,IAAK,IAAIv9C,GAAS,EAAG00D,EAAUnX,EAAM59C,SAAUK,EAAQ00D,GAC/CH,EAAUv0D,EAAOu9C,WAAgBA,EAAMpjD,IAAI6F,KAIpDyD,OAAO8wD,GACV,OAAO,IAAIC,GACPhwD,KAAKmkC,QACLnkC,KAAKwwD,WAAWhB,IAAIO,IAGrB9wD,QAAQ5J,GACX,MAAM6K,EAAUF,KAAKmkC,QAAS4b,EAAa7/C,EAAQ/E,OAC7Cg1D,EAA2B,iBAAT96D,EAAoB,IAAIu4D,GAAIv4D,GAAQA,EAG5D86D,EAAS75D,KAAK4J,EAAQ6/C,EAAa,IACnC,MAAM/a,EAASmrB,EAASnrB,OACxB,IAAKhZ,EAAS2Y,aAAaK,EAAOvyB,MAC9B,MAAUhU,MAAM,8DAGpB,MAAM2xD,EAAkB/1D,KAAKg2D,KAAKh2D,KAAKwjB,IAAImnB,EAAO7pC,QAAUd,KAAKwjB,IAAI,MAI/DyyC,EAAS,IAH4B,GAAnBF,EAAuB9zD,YACvB8zD,GAAmB,EAAI/zD,YAAcpC,YAE1B+qC,EAAOzS,WAAWp3B,QAErD,IAAK,IAAI80D,GAAc,IAAKA,EAAalQ,GAAa,CAElD,MAAMhH,EAAQ74C,EAAQ+vD,GAChBF,EAAY/vD,KAAKwwD,WAAWl6D,KAAKyiD,GAEvCoX,EAAS75D,KAAKyiD,GACd,MAAMtY,EAAQ0vB,EAASnrB,OAAyB1S,QAEhD,IAAK,IAAI92B,GAAS,EAAG00D,EAAUnX,EAAM59C,SAAUK,EAAQ00D,GAAU,CAC7D,IAAI75D,EAAMoqC,EAAK9qC,IAAI6F,GACP,OAARnF,GAAgB05D,EAAUv0D,EAAOu9C,IAAUuX,EAAOj6D,MAG9D,OAAO,IAAIk6D,GAAcvrB,EAAOzS,WAAY2vB,GAAUjmD,KAAKq0D,KC3I5D,MAAMI,GAAO,IACbC,KACAC,KACAC,KACAC,KACAz6B,MACA06B,GCpHPn8D,EAAAQ,EAAA0B,EAAA,8BAAAsyB,IAAAx0B,EAAAQ,EAAA0B,EAAA,6BAAA2nB,IAAA7pB,EAAAQ,EAAA0B,EAAA,iCAAA6nB,IAAA/pB,EAAAQ,EAAA0B,EAAA,kCAAAuwB,IAAAzyB,EAAAQ,EAAA0B,EAAA,oCAAAwnB,IAAA1pB,EAAAQ,EAAA0B,EAAA,8BAAA0nB,IAAA5pB,EAAAQ,EAAA0B,EAAA,6BAAA4nB,IAAA9pB,EAAAQ,EAAA0B,EAAA,yBAAA8nB,IAAAhqB,EAAAQ,EAAA0B,EAAA,8BAAAynB,IAAA3pB,EAAAQ,EAAA0B,EAAA,+BAAAqyB,IAAAv0B,EAAAQ,EAAA0B,EAAA,yBAAAg1B,KAAAl3B,EAAAQ,EAAA0B,EAAA,6BAAAk1B,IAAAp3B,EAAAQ,EAAA0B,EAAA,yBAAA47B,IAAA99B,EAAAQ,EAAA0B,EAAA,yBAAAo8B,KAAAt+B,EAAAQ,EAAA0B,EAAA,wBAAA67B,IAAA/9B,EAAAQ,EAAA0B,EAAA,yBAAAs1B,IAAAx3B,EAAAQ,EAAA0B,EAAA,0BAAAw1B,IAAA13B,EAAAQ,EAAA0B,EAAA,0BAAA01B,IAAA53B,EAAAQ,EAAA0B,EAAA,0BAAA41B,KAAA93B,EAAAQ,EAAA0B,EAAA,0BAAA81B,KAAAh4B,EAAAQ,EAAA0B,EAAA,2BAAAg2B,KAAAl4B,EAAAQ,EAAA0B,EAAA,2BAAAk2B,KAAAp4B,EAAAQ,EAAA0B,EAAA,2BAAAo2B,KAAAt4B,EAAAQ,EAAA0B,EAAA,0BAAA87B,KAAAh+B,EAAAQ,EAAA0B,EAAA,4BAAA+7B,KAAAj+B,EAAAQ,EAAA0B,EAAA,4BAAAg8B,KAAAl+B,EAAAQ,EAAA0B,EAAA,4BAAAi8B,KAAAn+B,EAAAQ,EAAA0B,EAAA,yBAAAm8B,KAAAr+B,EAAAQ,EAAA0B,EAAA,2BAAAk8B,KAAAp+B,EAAAQ,EAAA0B,EAAA,oCAAAg+B,KAAAlgC,EAAAQ,EAAA0B,EAAA,0BAAAs8B,KAAAx+B,EAAAQ,EAAA0B,EAAA,4BAAAu8B,KAAAz+B,EAAAQ,EAAA0B,EAAA,oCAAAw8B,KAAA1+B,EAAAQ,EAAA0B,EAAA,8BAAA88B,KAAAh/B,EAAAQ,EAAA0B,EAAA,oCAAA+8B,KAAAj/B,EAAAQ,EAAA0B,EAAA,yCAAAg9B,KAAAl/B,EAAAQ,EAAA0B,EAAA,yCAAAi9B,KAAAn/B,EAAAQ,EAAA0B,EAAA,wCAAAk9B,KAAAp/B,EAAAQ,EAAA0B,EAAA,yBAAAy8B,KAAA3+B,EAAAQ,EAAA0B,EAAA,+BAAA08B,KAAA5+B,EAAAQ,EAAA0B,EAAA,oCAAA28B,KAAA7+B,EAAAQ,EAAA0B,EAAA,oCAAA48B,KAAA9+B,EAAAQ,EAAA0B,EAAA,mCAAA68B,KAAA/+B,EAAAQ,EAAA0B,EAAA,4BAAAq8B,KAAAv+B,EAAAQ,EAAA0B,EAAA,yBAAAs9B,KAAAx/B,EAAAQ,EAAA0B,EAAA,2BAAA09B,KAAA5/B,EAAAQ,EAAA0B,EAAA,0BAAA29B,KAAA7/B,EAAAQ,EAAA0B,EAAA,+BAAA89B,KAAAhgC,EAAAQ,EAAA0B,EAAA,gCAAA+9B,KAAAjgC,EAAAQ,EAAA0B,EAAA,+BAAAs+B,KAAAxgC,EAAAQ,EAAA0B,EAAA,6BAAAm9B,KAAAr/B,EAAAQ,EAAA0B,EAAA,oCAAAo9B,KAAAt/B,EAAAQ,EAAA0B,EAAA,sCAAAq9B,KAAAv/B,EAAAQ,EAAA0B,EAAA,kCAAAi+B,KAAAngC,EAAAQ,EAAA0B,EAAA,yBAAAk+B,KAAApgC,EAAAQ,EAAA0B,EAAA,0BAAAmnD,KAAArpD,EAAAQ,EAAA0B,EAAA,2BAAAmvC,KAAArxC,EAAAQ,EAAA0B,EAAA,2BAAA4wC,KAAA9yC,EAAAQ,EAAA0B,EAAA,0BAAAuvC,KAAAzxC,EAAAQ,EAAA0B,EAAA,4BAAAu0B,IAAAz2B,EAAAQ,EAAA0B,EAAA,2BAAAsnB,IAAAxpB,EAAAQ,EAAA0B,EAAA,+BAAAwpD,KAAA1rD,EAAAQ,EAAA0B,EAAA,iCAAA2pD,KAAA7rD,EAAAQ,EAAA0B,EAAA,+BAAA4pD,KAAA9rD,EAAAQ,EAAA0B,EAAA,4BAAAitC,KAAAnvC,EAAAQ,EAAA0B,EAAA,+BAAA8pD,KAAAhsD,EAAAQ,EAAA0B,EAAA,kCAAA+pD,KAAAjsD,EAAAQ,EAAA0B,EAAA,0CAAAgqD,KAAAlsD,EAAAQ,EAAA0B,EAAA,kCAAAiqD,KAAAnsD,EAAAQ,EAAA0B,EAAA,qCAAAkqD,KAAApsD,EAAAQ,EAAA0B,EAAA,0CAAAmqD,KAAArsD,EAAAQ,EAAA0B,EAAA,wCAAAoqD,KAAAtsD,EAAAQ,EAAA0B,EAAA,gCAAAqqD,KAAAvsD,EAAAQ,EAAA0B,EAAA,kCAAA2qD,KAAA7sD,EAAAQ,EAAA0B,EAAA,kCAAA4qD,KAAA9sD,EAAAQ,EAAA0B,EAAA,kCAAA6qD,KAAA/sD,EAAAQ,EAAA0B,EAAA,mCAAAirD,KAAAntD,EAAAQ,EAAA0B,EAAA,0CAAAkrD,KAAAptD,EAAAQ,EAAA0B,EAAA,4CAAAmrD,KAAArtD,EAAAQ,EAAA0B,EAAA,8BAAAorD,KAAAttD,EAAAQ,EAAA0B,EAAA,+BAAAyrD,KAAA3tD,EAAAQ,EAAA0B,EAAA,gCAAA0rD,KAAA5tD,EAAAQ,EAAA0B,EAAA,gCAAA2rD,KAAA7tD,EAAAQ,EAAA0B,EAAA,gCAAA4rD,KAAA9tD,EAAAQ,EAAA0B,EAAA,gCAAA8rD,KAAAhuD,EAAAQ,EAAA0B,EAAA,iCAAA+rD,KAAAjuD,EAAAQ,EAAA0B,EAAA,iCAAAgsD,KAAAluD,EAAAQ,EAAA0B,EAAA,iCAAAisD,KAAAnuD,EAAAQ,EAAA0B,EAAA,+BAAAksD,KAAApuD,EAAAQ,EAAA0B,EAAA,8BAAAmsD,KAAAruD,EAAAQ,EAAA0B,EAAA,+BAAAosD,KAAAtuD,EAAAQ,EAAA0B,EAAA,iCAAAssD,KAAAxuD,EAAAQ,EAAA0B,EAAA,oCAAAysD,KAAA3uD,EAAAQ,EAAA0B,EAAA,0CAAA0sD,KAAA5uD,EAAAQ,EAAA0B,EAAA,+CAAA2sD,KAAA7uD,EAAAQ,EAAA0B,EAAA,+CAAA4sD,KAAA9uD,EAAAQ,EAAA0B,EAAA,8CAAA6sD,KAAA/uD,EAAAQ,EAAA0B,EAAA,+BAAA8sD,KAAAhvD,EAAAQ,EAAA0B,EAAA,qCAAA+sD,KAAAjvD,EAAAQ,EAAA0B,EAAA,0CAAAgtD,KAAAlvD,EAAAQ,EAAA0B,EAAA,0CAAAitD,KAAAnvD,EAAAQ,EAAA0B,EAAA,yCAAAktD,KAAApvD,EAAAQ,EAAA0B,EAAA,gCAAAmtD,KAAArvD,EAAAQ,EAAA0B,EAAA,qCAAAotD,KAAAtvD,EAAAQ,EAAA0B,EAAA,sCAAAqtD,KAAAvvD,EAAAQ,EAAA0B,EAAA,+BAAAstD,KAAAxvD,EAAAQ,EAAA0B,EAAA,+BAAAs3C,KAAAx5C,EAAAQ,EAAA0B,EAAA,oCAAA03C,KAAA55C,EAAAQ,EAAA0B,EAAA,mCAAAm3C,KAAAr5C,EAAAQ,EAAA0B,EAAA,sCAAAwxD,KAAA1zD,EAAAQ,EAAA0B,EAAA,0CAAA2zD,KAAA71D,EAAAQ,EAAA0B,EAAA,4CAAAmzD,KAAAr1D,EAAAQ,EAAA0B,EAAA,+CAAAszD,KAAAx1D,EAAAQ,EAAA0B,EAAA,iDAAAwzD,KAAA11D,EAAAQ,EAAA0B,EAAA,sCAAA6lD,KAAA/nD,EAAAQ,EAAA0B,EAAA,0CAAAooD,KAAAtqD,EAAAQ,EAAA0B,EAAA,4CAAAkoD,KAAApqD,EAAAQ,EAAA0B,EAAA,0CAAAsoD,KAAAxqD,EAAAQ,EAAA0B,EAAA,kCAAAgjD,KAAAllD,EAAAQ,EAAA0B,EAAA,uCAAAujD,KAAAzlD,EAAAQ,EAAA0B,EAAA,sCAAAwjD,KAAA1lD,EAAAQ,EAAA0B,EAAA,4BAAA6+C,KAAA/gD,EAAAQ,EAAA0B,EAAA,gCAAAukD,KAAAzmD,EAAAQ,EAAA0B,EAAA,8BAAA84D,KAAAh7D,EAAAQ,EAAA0B,EAAA,sCAAAk5D,KAAAp7D,EAAAQ,EAAA0B,EAAA,kCAAAy5D,KAAA37D,EAAAQ,EAAA0B,EAAA,8BAAAk6D,IAAAp8D,EAAAQ,EAAA0B,EAAA,yBAAA45D,KAAA97D,EAAAQ,EAAA0B,EAAA,4BAAA0hC,KAAA5jC,EAAAQ,EAAA0B,EAAA,kCAAA2oC,KAAA7qC,EAAAQ,EAAA0B,EAAA,gCAAA4jC,KAAA9lC,EAAAQ,EAAA0B,EAAA,gCAAA8jC,KAAAhmC,EAAAQ,EAAA0B,EAAA,mCAAA+jC,KAAAjmC,EAAAQ,EAAA0B,EAAA,2CAAAgkC,KAAAlmC,EAAAQ,EAAA0B,EAAA,mCAAAikC,KAAAnmC,EAAAQ,EAAA0B,EAAA,sCAAAkkC,KAAApmC,EAAAQ,EAAA0B,EAAA,2CAAA4kC,KAAA9mC,EAAAQ,EAAA0B,EAAA,yCAAA6xC,KAAA/zC,EAAAQ,EAAA0B,EAAA,iCAAAqlC,KAAAvnC,EAAAQ,EAAA0B,EAAA,mCAAAslC,KAAAxnC,EAAAQ,EAAA0B,EAAA,mCAAAulC,KAAAznC,EAAAQ,EAAA0B,EAAA,mCAAAwlC,KAAA1nC,EAAAQ,EAAA0B,EAAA,oCAAAwoC,KAAA1qC,EAAAQ,EAAA0B,EAAA,2CAAAyoC,KAAA3qC,EAAAQ,EAAA0B,EAAA,6CAAA0oC,KAAA5qC,EAAAQ,EAAA0B,EAAA,+BAAAknC,KAAAppC,EAAAQ,EAAA0B,EAAA,gCAAAmnC,KAAArpC,EAAAQ,EAAA0B,EAAA,iCAAAonC,KAAAtpC,EAAAQ,EAAA0B,EAAA,iCAAAqnC,KAAAvpC,EAAAQ,EAAA0B,EAAA,iCAAAsnC,KAAAxpC,EAAAQ,EAAA0B,EAAA,iCAAAynC,KAAA3pC,EAAAQ,EAAA0B,EAAA,kCAAA0nC,KAAA5pC,EAAAQ,EAAA0B,EAAA,kCAAA2nC,KAAA7pC,EAAAQ,EAAA0B,EAAA,kCAAA4nC,KAAA9pC,EAAAQ,EAAA0B,EAAA,gCAAA0xC,KAAA5zC,EAAAQ,EAAA0B,EAAA,+BAAA+xC,KAAAj0C,EAAAQ,EAAA0B,EAAA,gCAAA6jC,KAAA/lC,EAAAQ,EAAA0B,EAAA,kCAAAgyC,KAAAl0C,EAAAQ,EAAA0B,EAAA,qCAAAmoC,KAAArqC,EAAAQ,EAAA0B,EAAA,2CAAAooC,KAAAtqC,EAAAQ,EAAA0B,EAAA,gDAAAqoC,KAAAvqC,EAAAQ,EAAA0B,EAAA,gDAAAsoC,KAAAxqC,EAAAQ,EAAA0B,EAAA,+CAAAuoC,KAAAzqC,EAAAQ,EAAA0B,EAAA,gCAAA8nC,KAAAhqC,EAAAQ,EAAA0B,EAAA,sCAAA+nC,KAAAjqC,EAAAQ,EAAA0B,EAAA,2CAAAgoC,KAAAlqC,EAAAQ,EAAA0B,EAAA,2CAAAioC,KAAAnqC,EAAAQ,EAAA0B,EAAA,0CAAAkoC,KAAApqC,EAAAQ,EAAA0B,EAAA,iCAAAiyC,KAAAn0C,EAAAQ,EAAA0B,EAAA,sCAAAqyC,KAAAv0C,EAAAQ,EAAA0B,EAAA,uCAAAoyC,KAAAt0C,EAAAQ,EAAA0B,EAAA,gCAAA4oC,KA0BA4O,EAAA,EAAextC,YCJR,SAAwBnH,EAAwC4G,GACnE,GAAI/K,OAAAyhC,GAAA,EAAAzhC,CAAmBmE,GAAW,OAqCtC,SAA6CA,EAA0B4G,GAEnE,IAAIvD,EAA8B,KAClC,MAAMi0D,EAAM1wD,GAA4B,UAAjBA,EAAQkS,OAAqB,EAC9Cy+C,EAAM3wD,GAAWA,EAAQs4B,eAAkB,GAAK,GAEtD,OAAO,IAAI4zB,eAAkB,IACtBlsD,EACHtB,YAAY8tD,SAAoBnwD,EAAKmwD,EAAY/vD,IAAOA,EAAKrD,EAAO9D,OAAOuH,oBAC3E6B,WAAW8tD,GAAc/vD,QAAYJ,EAAKmwD,EAAY/vD,GAAO+vD,EAAW3qD,SACxEnD,eAAkBjC,GAAOA,EAAGyE,cAAgBzE,EAAGyE,SAAuBzE,EAAK,OAC5E,CAAE67B,cAAeo4B,EAAKC,OAAMjvD,KAAc1B,IAE7CrD,eAAeN,EAAKmwD,EAAgD/vD,GAChE,IAAIyW,EACA7d,EAA8B,KAC9B6E,EAAOsyD,EAAWC,aAAe,KACrC,OAASp3D,QAAUoH,EAAGJ,KAAKq0D,EAAKx2D,EAAO,OAAOwC,MAM1C,GALIxD,YAAYsC,OAAOnG,EAAEG,SAAW0d,EAAMje,OAAA6gC,GAAA,aAAA7gC,CAAaI,EAAEG,UAC7C,MAAR0E,GAAgBw2D,IAAOx2D,EAAOA,EAAOgZ,EAAI3Z,WAAa,GACtDlE,EAAEG,MAAc0d,GAEpBs5C,EAAWG,QAAQt3D,EAAEG,OACT,MAAR0E,KAAkBA,GAAQ,EAAK,OAEvCsyD,EAAW3qD,SA9D0B+uD,CAAiCx3D,EAAQ4G,GAClF,GAAI/K,OAAAyhC,GAAA,EAAAzhC,CAAcmE,GAAW,OAMjC,SAAwCA,EAAqB4G,GAEzD,IAAIvD,EAAyB,KAC7B,MAAMi0D,EAAM1wD,GAA4B,UAAjBA,EAAQkS,OAAqB,EAC9Cy+C,EAAM3wD,GAAWA,EAAQs4B,eAAkB,GAAK,GAEtD,OAAO,IAAI4zB,eAAkB,IACtBlsD,EACHtB,MAAM8tD,GAAcnwD,EAAKmwD,EAAY/vD,IAAOA,EAAKrD,EAAO9D,OAAO8G,eAC/DsC,KAAK8tD,GAAc/vD,EAAMJ,EAAKmwD,EAAY/vD,GAAO+vD,EAAW3qD,SAC5DnD,SAAYjC,GAAOA,EAAGyE,QAAUzE,EAAGyE,SAAuBzE,EAAK,OAChE,CAAE67B,cAAeo4B,EAAKC,OAAMjvD,KAAc1B,IAE7C,SAAS3D,EAAKmwD,EAAgD/vD,GAC1D,IAAIyW,EACA7d,EAA8B,KAC9B6E,EAAOsyD,EAAWC,aAAe,KACrC,OAASp3D,EAAIoH,EAAGJ,KAAKq0D,EAAKx2D,EAAO,OAAOwC,MAMpC,GALIxD,YAAYsC,OAAOnG,EAAEG,SAAW0d,EAAMje,OAAA6gC,GAAA,aAAA7gC,CAAaI,EAAEG,UAC7C,MAAR0E,GAAgBw2D,IAAOx2D,EAAOA,EAAOgZ,EAAI3Z,WAAa,GACtDlE,EAAEG,MAAc0d,GAEpBs5C,EAAWG,QAAQt3D,EAAEG,OACT,MAAR0E,KAAkBA,GAAQ,EAAK,OAEvCsyD,EAAW3qD,SA/BqBgvD,CAA4Bz3D,EAAQ4G,GAExE,MAAU9B,MAAM,mEDCpB+5B,GAAoB,WJKb,SAAwEj4B,GAC3E,OAAO,IAAIurD,GAAiBvrD,IILhC+nD,GAA8B,WELvB,SAAwFhL,EAA8CC,GAEzI,MAAM8T,EAAQ,IAAIpjB,GAClB,IAAI9pC,EAAsC,KAE1C,MAAMmtD,EAAW,IAAI7E,eAA+B,CAChDxtD,qBAAuBoyD,EAAMjvD,SAC7BnD,YAAY8tD,SAAoBnwD,EAAKmwD,EAAY5oD,IAAWA,QAMhEjH,iBACI,mBAAoBorD,GAAkBrsD,KAAQo1D,IAAQ7I,KAAKjL,GAPgBiL,MAC3EvpD,WAAW8tD,GAAc5oD,QAAevH,EAAKmwD,EAAY5oD,GAAU4oD,EAAW3qD,WAGlF,MAAO,CAAE9B,SAAU,IAAIssD,eAAeyE,EAAO,CAAEx4B,cAAiB,SAAYykB,IAAqBgU,YAMjGp0D,eAAeN,EAAKmwD,EAA6D5oD,GAC7E,IAAI1J,EAAOsyD,EAAWC,YAClBp3D,EAA2C,KAC/C,OAASA,QAAUuO,EAAOvH,QAAQK,MAE9B,GADA8vD,EAAWG,QAAQt3D,EAAEG,OACT,MAAR0E,KAAkBA,GAAQ,EAC1B,OAGRsyD,EAAW3qD,UFpBnBu6C,GAA8B,WGNvB,SAEHW,EACAC,GAGA,MAAM0B,EAAS,IAAIj/C,KAAQs9C,GACrBn5C,EAAS,IAAIqqC,GAAgByQ,GAC7BqS,EAAW,IAAI7E,eAAe,CAChCh6C,KAAM,QACNxT,qBAAuBkF,EAAOwqC,UAC9B1vC,WAAW8tD,SAAoBnwD,EAAKmwD,IACpC9tD,YAAY8tD,SAAoBnwD,EAAKmwD,KACtC,CAAEl0B,cAAiB,SAAY0kB,IAElC,MAAO,CAAEj9C,SAAU,IAAIssD,eAAe3N,EAAQ3B,GAAmBgU,YAEjEp0D,eAAeN,EAAKmwD,GAChB,IAAIt5C,EAAyB,KACzBhZ,EAAOsyD,EAAWC,YACtB,KAAOv5C,QAAYtP,EAAOK,KAAK/J,GAAQ,OAEnC,GADAsyD,EAAWG,QAAQz5C,GACP,MAARhZ,IAAiBA,GAAQgZ,EAAI3Z,aAAe,EAAK,OAEzDizD,EAAW3qD","file":"Arrow.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"Arrow\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Arrow\"] = factory();\n\telse\n\t\troot[\"Arrow\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 12);\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { flatbuffers } from 'flatbuffers';\nimport { encodeUtf8 } from '../util/utf8';\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport { TypedArray, TypedArrayConstructor } from '../interfaces';\nimport { BigIntArray, BigIntArrayConstructor } from '../interfaces';\nimport { isPromise, isIterable, isAsyncIterable, isIteratorResult, BigInt64Array, BigUint64Array } from './compat';\n\n/** @ignore */\nconst SharedArrayBuf = (typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : ArrayBuffer);\n\n/** @ignore */\nfunction collapseContiguousByteRanges(chunks: Uint8Array[]) {\n    let result = chunks[0] ? [chunks[0]] : [];\n    let xOffset: number, yOffset: number, xLen: number, yLen: number;\n    for (let x, y, i = 0, j = 0, n = chunks.length; ++i < n;) {\n        x = result[j];\n        y = chunks[i];\n        // continue if x and y don't share the same underlying ArrayBuffer, or if x isn't before y\n        if (!x || !y || x.buffer !== y.buffer || y.byteOffset < x.byteOffset) {\n            y && (result[++j] = y);\n            continue;\n        }\n        ({ byteOffset: xOffset, byteLength: xLen } = x);\n        ({ byteOffset: yOffset, byteLength: yLen } = y);\n        // continue if the byte ranges of x and y aren't contiguous\n        if ((xOffset + xLen) < yOffset || (yOffset + yLen) < xOffset) {\n            y && (result[++j] = y);\n            continue;\n        }\n        result[j] = new Uint8Array(x.buffer, xOffset, yOffset - xOffset + yLen);\n    }\n    return result;\n}\n\n/** @ignore */\nexport function memcpy<TTarget extends ArrayBufferView, TSource extends ArrayBufferView>(target: TTarget, source: TSource, targetByteOffset = 0, sourceByteLength = source.byteLength) {\n    const targetByteLength = target.byteLength;\n    const dst = new Uint8Array(target.buffer, target.byteOffset, targetByteLength);\n    const src = new Uint8Array(source.buffer, source.byteOffset, Math.min(sourceByteLength, targetByteLength));\n    dst.set(src, targetByteOffset);\n    return target;\n}\n\n/** @ignore */\nexport function joinUint8Arrays(chunks: Uint8Array[], size?: number | null): [Uint8Array, Uint8Array[], number] {\n    // collapse chunks that share the same underlying ArrayBuffer and whose byte ranges overlap,\n    // to avoid unnecessarily copying the bytes to do this buffer join. This is a common case during\n    // streaming, where we may be reading partial byte ranges out of the same underlying ArrayBuffer\n    let result = collapseContiguousByteRanges(chunks);\n    let byteLength = result.reduce((x, b) => x + b.byteLength, 0);\n    let source: Uint8Array, sliced: Uint8Array, buffer: Uint8Array | void;\n    let offset = 0, index = -1, length = Math.min(size || Infinity, byteLength);\n    for (let n = result.length; ++index < n;) {\n        source = result[index];\n        sliced = source.subarray(0, Math.min(source.length, length - offset));\n        if (length <= (offset + sliced.length)) {\n            if (sliced.length < source.length) {\n                result[index] = source.subarray(sliced.length);\n            } else if (sliced.length === source.length) { index++; }\n            buffer ? memcpy(buffer, sliced, offset) : (buffer = sliced);\n            break;\n        }\n        memcpy(buffer || (buffer = new Uint8Array(length)), sliced, offset);\n        offset += sliced.length;\n    }\n    return [buffer || new Uint8Array(0), result.slice(index), byteLength - (buffer ? buffer.byteLength : 0)];\n}\n\n/** @ignore */\nexport type ArrayBufferViewInput = ArrayBufferView | ArrayBufferLike | ArrayBufferView | Iterable<number> | ArrayLike<number> | ByteBuffer | string | null | undefined  |\n                    IteratorResult<ArrayBufferView | ArrayBufferLike | ArrayBufferView | Iterable<number> | ArrayLike<number> | ByteBuffer | string | null | undefined> |\n          ReadableStreamReadResult<ArrayBufferView | ArrayBufferLike | ArrayBufferView | Iterable<number> | ArrayLike<number> | ByteBuffer | string | null | undefined> ;\n\n/** @ignore */\nexport function toArrayBufferView<T extends TypedArray>(ArrayBufferViewCtor: TypedArrayConstructor<T>, input: ArrayBufferViewInput): T;\nexport function toArrayBufferView<T extends BigIntArray>(ArrayBufferViewCtor: BigIntArrayConstructor<T>, input: ArrayBufferViewInput): T;\nexport function toArrayBufferView(ArrayBufferViewCtor: any, input: ArrayBufferViewInput) {\n\n    let value: any = isIteratorResult(input) ? input.value : input;\n\n    if (value instanceof ArrayBufferViewCtor) {\n        if (ArrayBufferViewCtor === Uint8Array) {\n            // Node's `Buffer` class passes the `instanceof Uint8Array` check, but we need\n            // a real Uint8Array, since Buffer#slice isn't the same as Uint8Array#slice :/\n            return new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength);\n        }\n        return value;\n    }\n    if (!value) { return new ArrayBufferViewCtor(0); }\n    if (typeof value === 'string') { value = encodeUtf8(value); }\n    if (value instanceof ArrayBuffer) { return new ArrayBufferViewCtor(value); }\n    if (value instanceof SharedArrayBuf) { return new ArrayBufferViewCtor(value); }\n    if (value instanceof ByteBuffer) { return toArrayBufferView(ArrayBufferViewCtor, value.bytes()); }\n    return !ArrayBuffer.isView(value) ? ArrayBufferViewCtor.from(value) : value.byteLength <= 0 ? new ArrayBufferViewCtor(0)\n        : new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength / ArrayBufferViewCtor.BYTES_PER_ELEMENT);\n}\n\n/** @ignore */ export const toInt8Array = (input: ArrayBufferViewInput) => toArrayBufferView(Int8Array, input);\n/** @ignore */ export const toInt16Array = (input: ArrayBufferViewInput) => toArrayBufferView(Int16Array, input);\n/** @ignore */ export const toInt32Array = (input: ArrayBufferViewInput) => toArrayBufferView(Int32Array, input);\n/** @ignore */ export const toBigInt64Array = (input: ArrayBufferViewInput) => toArrayBufferView(BigInt64Array, input);\n/** @ignore */ export const toUint8Array = (input: ArrayBufferViewInput) => toArrayBufferView(Uint8Array, input);\n/** @ignore */ export const toUint16Array = (input: ArrayBufferViewInput) => toArrayBufferView(Uint16Array, input);\n/** @ignore */ export const toUint32Array = (input: ArrayBufferViewInput) => toArrayBufferView(Uint32Array, input);\n/** @ignore */ export const toBigUint64Array = (input: ArrayBufferViewInput) => toArrayBufferView(BigUint64Array, input);\n/** @ignore */ export const toFloat32Array = (input: ArrayBufferViewInput) => toArrayBufferView(Float32Array, input);\n/** @ignore */ export const toFloat64Array = (input: ArrayBufferViewInput) => toArrayBufferView(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArray = (input: ArrayBufferViewInput) => toArrayBufferView(Uint8ClampedArray, input);\n\n/** @ignore */\ntype ArrayBufferViewIteratorInput = Iterable<ArrayBufferViewInput> | ArrayBufferViewInput;\n\n/** @ignore */\nconst pump = <T extends Iterator<any> | AsyncIterator<any>>(iterator: T) => { iterator.next(); return iterator; };\n\n/** @ignore */\nexport function* toArrayBufferViewIterator<T extends TypedArray>(ArrayCtor: TypedArrayConstructor<T>, source: ArrayBufferViewIteratorInput) {\n\n    const wrap = function*<T>(x: T) { yield x; };\n    const buffers: Iterable<ArrayBufferViewInput> =\n                   (typeof source === 'string') ? wrap(source)\n                 : (ArrayBuffer.isView(source)) ? wrap(source)\n              : (source instanceof ArrayBuffer) ? wrap(source)\n           : (source instanceof SharedArrayBuf) ? wrap(source)\n    : !isIterable<ArrayBufferViewInput>(source) ? wrap(source) : source;\n\n    yield* pump((function* (it) {\n        let r: IteratorResult<any> = <any> null;\n        do {\n            r = it.next(yield toArrayBufferView(ArrayCtor, r));\n        } while (!r.done);\n    })(buffers[Symbol.iterator]()));\n}\n\n/** @ignore */ export const toInt8ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Int8Array, input);\n/** @ignore */ export const toInt16ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Int16Array, input);\n/** @ignore */ export const toInt32ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Int32Array, input);\n/** @ignore */ export const toUint8ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint8Array, input);\n/** @ignore */ export const toUint16ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint16Array, input);\n/** @ignore */ export const toUint32ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint32Array, input);\n/** @ignore */ export const toFloat32ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Float32Array, input);\n/** @ignore */ export const toFloat64ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint8ClampedArray, input);\n\n/** @ignore */\ntype ArrayBufferViewAsyncIteratorInput = AsyncIterable<ArrayBufferViewInput> | Iterable<ArrayBufferViewInput> | PromiseLike<ArrayBufferViewInput> | ArrayBufferViewInput;\n\n/** @ignore */\nexport async function* toArrayBufferViewAsyncIterator<T extends TypedArray>(ArrayCtor: TypedArrayConstructor<T>, source: ArrayBufferViewAsyncIteratorInput): AsyncIterableIterator<T> {\n\n    // if a Promise, unwrap the Promise and iterate the resolved value\n    if (isPromise<ArrayBufferViewInput>(source)) {\n        return yield* toArrayBufferViewAsyncIterator(ArrayCtor, await source);\n    }\n\n    const wrap = async function*<T>(x: T) { yield await x; };\n    const emit = async function* <T extends Iterable<any>>(source: T) {\n        yield* pump((function*(it: Iterator<any>) {\n            let r: IteratorResult<any> = <any> null;\n            do {\n                r = it.next(yield r && r.value);\n            } while (!r.done);\n        })(source[Symbol.iterator]()));\n    };\n\n    const buffers: AsyncIterable<ArrayBufferViewInput> =\n                        (typeof source === 'string') ? wrap(source) // if string, wrap in an AsyncIterableIterator\n                      : (ArrayBuffer.isView(source)) ? wrap(source) // if TypedArray, wrap in an AsyncIterableIterator\n                   : (source instanceof ArrayBuffer) ? wrap(source) // if ArrayBuffer, wrap in an AsyncIterableIterator\n                : (source instanceof SharedArrayBuf) ? wrap(source) // if SharedArrayBuffer, wrap in an AsyncIterableIterator\n          : isIterable<ArrayBufferViewInput>(source) ? emit(source) // If Iterable, wrap in an AsyncIterableIterator and compose the `next` values\n    : !isAsyncIterable<ArrayBufferViewInput>(source) ? wrap(source) // If not an AsyncIterable, treat as a sentinel and wrap in an AsyncIterableIterator\n                                                     : source; // otherwise if AsyncIterable, use it\n\n    yield* pump((async function* (it) {\n        let r: IteratorResult<any> = <any> null;\n        do {\n            r = await it.next(yield toArrayBufferView(ArrayCtor, r));\n        } while (!r.done);\n    })(buffers[Symbol.asyncIterator]()));\n}\n\n/** @ignore */ export const toInt8ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Int8Array, input);\n/** @ignore */ export const toInt16ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Int16Array, input);\n/** @ignore */ export const toInt32ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Int32Array, input);\n/** @ignore */ export const toUint8ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint8Array, input);\n/** @ignore */ export const toUint16ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint16Array, input);\n/** @ignore */ export const toUint32ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint32Array, input);\n/** @ignore */ export const toFloat32ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Float32Array, input);\n/** @ignore */ export const toFloat64ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input);\n\n/** @ignore */\nexport function rebaseValueOffsets(offset: number, length: number, valueOffsets: Int32Array) {\n    // If we have a non-zero offset, create a new offsets array with the values\n    // shifted by the start offset, such that the new start offset is 0\n    if (offset !== 0) {\n        valueOffsets = valueOffsets.slice(0, length + 1);\n        for (let i = -1; ++i <= length;) {\n            valueOffsets[i] += offset;\n        }\n    }\n    return valueOffsets;\n}\n\n/** @ignore */\nexport function compareArrayLike<T extends ArrayLike<any>>(a: T, b: T) {\n    let i = 0, n = a.length;\n    if (n !== b.length) { return false; }\n    if (n > 0) {\n        do { if (a[i] !== b[i]) { return false; } } while (++i < n);\n    }\n    return true;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { ReadableInterop, ArrowJSONLike } from '../io/interfaces';\n\n/** @ignore */\ntype FSReadStream = import('fs').ReadStream;\n/** @ignore */\ntype FileHandle = import('fs').promises.FileHandle;\n\n/** @ignore */\nexport interface Subscription {\n    unsubscribe: () => void;\n}\n\n/** @ignore */\nexport interface Observer<T> {\n    closed?: boolean;\n    next: (value: T) => void;\n    error: (err: any) => void;\n    complete: () => void;\n}\n\n/** @ignore */\nexport interface Observable<T> {\n    subscribe: (observer: Observer<T>) => Subscription;\n}\n\n/** @ignore */\nconst [BigIntCtor, BigIntAvailable] = (() => {\n    const BigIntUnavailableError = () => { throw new Error('BigInt is not available in this environment'); };\n    function BigIntUnavailable() { throw BigIntUnavailableError(); }\n    BigIntUnavailable.asIntN = () => { throw BigIntUnavailableError(); };\n    BigIntUnavailable.asUintN = () => { throw BigIntUnavailableError(); };\n    return typeof BigInt !== 'undefined' ? [BigInt, true] : [<any> BigIntUnavailable, false];\n})() as [BigIntConstructor, boolean];\n\n/** @ignore */\nconst [BigInt64ArrayCtor, BigInt64ArrayAvailable] = (() => {\n    const BigInt64ArrayUnavailableError = () => { throw new Error('BigInt64Array is not available in this environment'); };\n    class BigInt64ArrayUnavailable {\n        static get BYTES_PER_ELEMENT() { return 8; }\n        static of() { throw BigInt64ArrayUnavailableError(); }\n        static from() { throw BigInt64ArrayUnavailableError(); }\n        constructor() { throw BigInt64ArrayUnavailableError(); }\n    }\n    return typeof BigInt64Array !== 'undefined' ? [BigInt64Array, true] : [<any> BigInt64ArrayUnavailable, false];\n})() as [BigInt64ArrayConstructor, boolean];\n\n/** @ignore */\nconst [BigUint64ArrayCtor, BigUint64ArrayAvailable] = (() => {\n    const BigUint64ArrayUnavailableError = () => { throw new Error('BigUint64Array is not available in this environment'); };\n    class BigUint64ArrayUnavailable {\n        static get BYTES_PER_ELEMENT() { return 8; }\n        static of() { throw BigUint64ArrayUnavailableError(); }\n        static from() { throw BigUint64ArrayUnavailableError(); }\n        constructor() { throw BigUint64ArrayUnavailableError(); }\n    }\n    return typeof BigUint64Array !== 'undefined' ? [BigUint64Array, true] : [<any> BigUint64ArrayUnavailable, false];\n})() as [BigUint64ArrayConstructor, boolean];\n\nexport { BigIntCtor as BigInt, BigIntAvailable };\nexport { BigInt64ArrayCtor as BigInt64Array, BigInt64ArrayAvailable };\nexport { BigUint64ArrayCtor as BigUint64Array, BigUint64ArrayAvailable };\n\n/** @ignore */ const isNumber = (x: any) => typeof x === 'number';\n/** @ignore */ const isBoolean = (x: any) => typeof x === 'boolean';\n/** @ignore */ const isFunction = (x: any) => typeof x === 'function';\n/** @ignore */\nexport const isObject = (x: any): x is Object => x != null && Object(x) === x;\n\n/** @ignore */\nexport const isPromise = <T = any>(x: any): x is PromiseLike<T> => {\n    return isObject(x) && isFunction(x.then);\n};\n\n/** @ignore */\nexport const isObservable = <T = any>(x: any): x is Observable<T> => {\n    return isObject(x) && isFunction(x.subscribe);\n};\n\n/** @ignore */\nexport const isIterable = <T = any>(x: any): x is Iterable<T> => {\n    return isObject(x) && isFunction(x[Symbol.iterator]);\n};\n\n/** @ignore */\nexport const isAsyncIterable = <T = any>(x: any): x is AsyncIterable<T> => {\n    return isObject(x) && isFunction(x[Symbol.asyncIterator]);\n};\n\n/** @ignore */\nexport const isArrowJSON = (x: any): x is ArrowJSONLike  => {\n    return isObject(x) && isObject(x['schema']);\n};\n\n/** @ignore */\nexport const isArrayLike = <T = any>(x: any): x is ArrayLike<T> => {\n    return isObject(x) && isNumber(x['length']);\n};\n\n/** @ignore */\nexport const isIteratorResult = <T = any>(x: any): x is IteratorResult<T> => {\n    return isObject(x) && ('done' in x) && ('value' in x);\n};\n\n/** @ignore */\nexport const isUnderlyingSink = <T = any>(x: any): x is UnderlyingSink<T> => {\n    return isObject(x) &&\n        isFunction(x['abort']) &&\n        isFunction(x['close']) &&\n        isFunction(x['start']) &&\n        isFunction(x['write']);\n};\n\n/** @ignore */\nexport const isFileHandle = (x: any): x is FileHandle => {\n    return isObject(x) && isFunction(x['stat']) && isNumber(x['fd']);\n};\n\n/** @ignore */\nexport const isFSReadStream = (x: any): x is FSReadStream => {\n    return isReadableNodeStream(x) && isNumber((<any> x)['bytesRead']);\n};\n\n/** @ignore */\nexport const isFetchResponse = (x: any): x is Response => {\n    return isObject(x) && isReadableDOMStream(x['body']);\n};\n\n/** @ignore */\nexport const isWritableDOMStream = <T = any>(x: any): x is WritableStream<T> => {\n    return isObject(x) &&\n        isFunction(x['abort']) &&\n        isFunction(x['getWriter']) &&\n        !(x instanceof ReadableInterop);\n};\n\n/** @ignore */\nexport const isReadableDOMStream = <T = any>(x: any): x is ReadableStream<T> => {\n    return isObject(x) &&\n        isFunction(x['cancel']) &&\n        isFunction(x['getReader']) &&\n        !(x instanceof ReadableInterop);\n};\n\n/** @ignore */\nexport const isWritableNodeStream = (x: any): x is NodeJS.WritableStream => {\n    return isObject(x) &&\n        isFunction(x['end']) &&\n        isFunction(x['write']) &&\n        isBoolean(x['writable']) &&\n        !(x instanceof ReadableInterop);\n};\n\n/** @ignore */\nexport const isReadableNodeStream = (x: any): x is NodeJS.ReadableStream => {\n    return isObject(x) &&\n        isFunction(x['read']) &&\n        isFunction(x['pipe']) &&\n        isBoolean(x['readable']) &&\n        !(x instanceof ReadableInterop);\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport streamAdapters from './adapters';\n\n/** @ignore */\nexport const ITERATOR_DONE: any = Object.freeze({ done: true, value: void (0) });\n\n/** @ignore */\nexport type FileHandle = import('fs').promises.FileHandle;\n/** @ignore */\nexport type ArrowJSONLike = { schema: any; batches?: any[]; dictionaries?: any[]; };\n/** @ignore */\nexport type ReadableDOMStreamOptions = { type: 'bytes' | undefined, autoAllocateChunkSize?: number, highWaterMark?: number };\n\n/** @ignore */\nexport class ArrowJSON {\n    // @ts-ignore\n    constructor(private _json: ArrowJSONLike) {}\n    public get schema(): any { return this._json['schema']; }\n    public get batches(): any[] { return (this._json['batches'] || []) as any[]; }\n    public get dictionaries(): any[] { return (this._json['dictionaries'] || []) as any[]; }\n}\n\n/** @ignore */\nexport interface Readable<T> {\n\n    readonly closed: Promise<void>;\n    cancel(reason?: any): Promise<void>;\n\n    read(size?: number | null): Promise<T | null>;\n    peek(size?: number | null): Promise<T | null>;\n    throw(value?: any): Promise<IteratorResult<any>>;\n    return(value?: any): Promise<IteratorResult<any>>;\n    next(size?: number | null): Promise<IteratorResult<T>>;\n}\n\n/** @ignore */\nexport interface Writable<T> {\n    readonly closed: Promise<void>;\n    close(): void;\n    write(chunk: T): void;\n    abort(reason?: any): void;\n}\n\n/** @ignore */\nexport interface ReadableWritable<TReadable, TWritable> extends Readable<TReadable>, Writable<TWritable> {\n    [Symbol.asyncIterator](): AsyncIterableIterator<TReadable>;\n    toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<TReadable>;\n    toNodeStream(options?: import('stream').ReadableOptions): import('stream').Readable;\n}\n\n/** @ignore */\nexport abstract class ReadableInterop<T> {\n\n    public abstract toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<T>;\n    public abstract toNodeStream(options?: import('stream').ReadableOptions): import('stream').Readable;\n\n    public tee(): [ReadableStream<T>, ReadableStream<T>] {\n        return this._getDOMStream().tee();\n    }\n    public pipe<R extends NodeJS.WritableStream>(writable: R, options?: { end?: boolean; }) {\n        return this._getNodeStream().pipe(writable, options);\n    }\n    public pipeTo(writable: WritableStream<T>, options?: PipeOptions) { return this._getDOMStream().pipeTo(writable, options); }\n    public pipeThrough<R extends ReadableStream<any>>(duplex: { writable: WritableStream<T>, readable: R }, options?: PipeOptions) {\n        return this._getDOMStream().pipeThrough(duplex, options);\n    }\n\n    protected _DOMStream?: ReadableStream<T>;\n    private _getDOMStream() {\n        return this._DOMStream || (this._DOMStream = this.toDOMStream());\n    }\n\n    protected _nodeStream?: import('stream').Readable;\n    private _getNodeStream() {\n        return this._nodeStream || (this._nodeStream = this.toNodeStream());\n    }\n}\n\n/** @ignore */\ntype Resolution<T> = { resolve: (value?: T | PromiseLike<T>) => void; reject: (reason?: any) => void; };\n\n/** @ignore */\nexport class AsyncQueue<TReadable = Uint8Array, TWritable = TReadable> extends ReadableInterop<TReadable>\n    implements AsyncIterableIterator<TReadable>, ReadableWritable<TReadable, TWritable> {\n\n    protected _values: TWritable[] = [];\n    protected _error?: { error: any; };\n    protected _closedPromise: Promise<void>;\n    protected _closedPromiseResolve?: (value?: any) => void;\n    protected resolvers: Resolution<IteratorResult<TReadable>>[] = [];\n\n    constructor() {\n        super();\n        this._closedPromise = new Promise((r) => this._closedPromiseResolve = r);\n    }\n\n    public get closed(): Promise<void> { return this._closedPromise; }\n    public async cancel(reason?: any) { await this.return(reason); }\n    public write(value: TWritable) {\n        if (this._ensureOpen()) {\n            this.resolvers.length <= 0\n                ? (this._values.push(value))\n                : (this.resolvers.shift()!.resolve({ done: false, value } as any));\n        }\n    }\n    public abort(value?: any) {\n        if (this._closedPromiseResolve) {\n            this.resolvers.length <= 0\n                ? (this._error = { error: value })\n                : (this.resolvers.shift()!.reject({ done: true, value }));\n        }\n    }\n    public close() {\n        if (this._closedPromiseResolve) {\n            const { resolvers } = this;\n            while (resolvers.length > 0) {\n                resolvers.shift()!.resolve(ITERATOR_DONE);\n            }\n            this._closedPromiseResolve();\n            this._closedPromiseResolve = undefined;\n        }\n    }\n\n    public [Symbol.asyncIterator]() { return this; }\n    public toDOMStream(options?: ReadableDOMStreamOptions) {\n        return streamAdapters.toDOMStream(\n            (this._closedPromiseResolve || this._error)\n                ? (this as AsyncIterable<TReadable>)\n                : (this._values as any) as Iterable<TReadable>,\n            options);\n    }\n    public toNodeStream(options?: import('stream').ReadableOptions) {\n        return streamAdapters.toNodeStream(\n            (this._closedPromiseResolve || this._error)\n                ? (this as AsyncIterable<TReadable>)\n                : (this._values as any) as Iterable<TReadable>,\n            options);\n    }\n    public async throw(_?: any) { await this.abort(_); return ITERATOR_DONE; }\n    public async return(_?: any) { await this.close(); return ITERATOR_DONE; }\n\n    public async read(size?: number | null): Promise<TReadable | null> { return (await this.next(size, 'read')).value; }\n    public async peek(size?: number | null): Promise<TReadable | null> { return (await this.next(size, 'peek')).value; }\n    public next(..._args: any[]): Promise<IteratorResult<TReadable>> {\n        if (this._values.length > 0) {\n            return Promise.resolve({ done: false, value: this._values.shift()! } as any);\n        } else if (this._error) {\n            return Promise.reject({ done: true, value: this._error.error });\n        } else if (!this._closedPromiseResolve) {\n            return Promise.resolve(ITERATOR_DONE);\n        } else {\n            return new Promise<IteratorResult<TReadable>>((resolve, reject) => {\n                this.resolvers.push({ resolve, reject });\n            });\n        }\n    }\n\n    protected _ensureOpen() {\n        if (this._closedPromiseResolve) {\n            return true;\n        }\n        throw new Error(`${this} is closed`);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport {\n    toUint8Array,\n    joinUint8Arrays,\n    ArrayBufferViewInput,\n    toUint8ArrayIterator,\n    toUint8ArrayAsyncIterator\n} from '../util/buffer';\n\nimport { ReadableDOMStreamOptions } from './interfaces';\n\n/** @ignore */\nexport default {\n    fromIterable<T extends ArrayBufferViewInput>(source: Iterable<T> | T): IterableIterator<Uint8Array> {\n        return pump(fromIterable<T>(source));\n    },\n    fromAsyncIterable<T extends ArrayBufferViewInput>(source: AsyncIterable<T> | PromiseLike<T>): AsyncIterableIterator<Uint8Array> {\n        return pump(fromAsyncIterable<T>(source));\n    },\n    fromDOMStream<T extends ArrayBufferViewInput>(source: ReadableStream<T>): AsyncIterableIterator<Uint8Array> {\n        return pump(fromDOMStream<T>(source));\n    },\n    fromNodeStream(stream: NodeJS.ReadableStream): AsyncIterableIterator<Uint8Array> {\n        return pump(fromNodeStream(stream));\n    },\n    // @ts-ignore\n    toDOMStream<T>(source: Iterable<T> | AsyncIterable<T>, options?: ReadableDOMStreamOptions): ReadableStream<T> {\n        throw new Error(`\"toDOMStream\" not available in this environment`);\n    },\n    // @ts-ignore\n    toNodeStream<T>(source: Iterable<T> | AsyncIterable<T>, options?: import('stream').ReadableOptions): import('stream').Readable {\n        throw new Error(`\"toNodeStream\" not available in this environment`);\n    },\n};\n\n/** @ignore */\nconst pump = <T extends Iterator<any> | AsyncIterator<any>>(iterator: T) => { iterator.next(); return iterator; };\n\n/** @ignore */\nfunction* fromIterable<T extends ArrayBufferViewInput>(source: Iterable<T> | T): IterableIterator<Uint8Array> {\n\n    let done: boolean, threw = false;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before creating the source Iterator\n    ({ cmd, size } = yield <any> null);\n\n    // initialize the iterator\n    let it = toUint8ArrayIterator(source)[Symbol.iterator]();\n\n    try {\n        do {\n            // read the next value\n            ({ done, value: buffer } = isNaN(size - bufferLength) ?\n                it.next(undefined) : it.next(size - bufferLength));\n            // if chunk is not null or empty, push it onto the queue\n            if (!done && buffer.byteLength > 0) {\n                buffers.push(buffer);\n                bufferLength += buffer.byteLength;\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } catch (e) {\n        (threw = true) && (typeof it.throw === 'function') && (it.throw(e));\n    } finally {\n        (threw === false) && (typeof it.return === 'function') && (it.return());\n    }\n}\n\n/** @ignore */\nasync function* fromAsyncIterable<T extends ArrayBufferViewInput>(source: AsyncIterable<T> | PromiseLike<T>): AsyncIterableIterator<Uint8Array> {\n\n    let done: boolean, threw = false;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before creating the source AsyncIterator\n    ({ cmd, size } = yield <any> null);\n\n    // initialize the iterator\n    let it = toUint8ArrayAsyncIterator(source)[Symbol.asyncIterator]();\n\n    try {\n        do {\n            // read the next value\n            ({ done, value: buffer } = isNaN(size - bufferLength)\n                ? await it.next(undefined)\n                : await it.next(size - bufferLength));\n            // if chunk is not null or empty, push it onto the queue\n            if (!done && buffer.byteLength > 0) {\n                buffers.push(buffer);\n                bufferLength += buffer.byteLength;\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } catch (e) {\n        (threw = true) && (typeof it.throw === 'function') && (await it.throw(e));\n    } finally {\n        (threw === false) && (typeof it.return === 'function') && (await it.return());\n    }\n}\n\n// All this manual Uint8Array chunk management can be avoided if/when engines\n// add support for ArrayBuffer.transfer() or ArrayBuffer.prototype.realloc():\n// https://github.com/domenic/proposal-arraybuffer-transfer\n/** @ignore */\nasync function* fromDOMStream<T extends ArrayBufferViewInput>(source: ReadableStream<T>): AsyncIterableIterator<Uint8Array> {\n\n    let done = false, threw = false;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before we establish the ReadableStream lock\n    ({ cmd, size } = yield <any> null);\n\n    // initialize the reader and lock the stream\n    let it = new AdaptiveByteReader(source);\n\n    try {\n        do {\n            // read the next value\n            ({ done, value: buffer } = isNaN(size - bufferLength)\n                ? await it['read'](undefined)\n                : await it['read'](size - bufferLength));\n            // if chunk is not null or empty, push it onto the queue\n            if (!done && buffer.byteLength > 0) {\n                buffers.push(toUint8Array(buffer));\n                bufferLength += buffer.byteLength;\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } catch (e) {\n        (threw = true) && (await it['cancel'](e));\n    } finally {\n        (threw === false) ? (await it['cancel']())\n            : source['locked'] && it.releaseLock();\n    }\n}\n\n/** @ignore */\nclass AdaptiveByteReader<T extends ArrayBufferViewInput> {\n\n    private supportsBYOB: boolean;\n    private byobReader: ReadableStreamBYOBReader | null = null;\n    private defaultReader: ReadableStreamDefaultReader<T> | null = null;\n    private reader: ReadableStreamBYOBReader | ReadableStreamDefaultReader<T> | null;\n\n    constructor(private source: ReadableStream<T>) {\n        try {\n            this.supportsBYOB = !!(this.reader = this.getBYOBReader());\n        } catch (e) {\n            this.supportsBYOB = !!!(this.reader = this.getDefaultReader());\n        }\n    }\n\n    get closed(): Promise<void> {\n        return this.reader ? this.reader['closed'].catch(() => {}) : Promise.resolve();\n    }\n\n    releaseLock(): void {\n        if (this.reader) {\n            this.reader.releaseLock();\n        }\n        this.reader = this.byobReader = this.defaultReader = null;\n    }\n\n    async cancel(reason?: any): Promise<void> {\n        const { reader, source } = this;\n        reader && (await reader['cancel'](reason).catch(() => {}));\n        source && (source['locked'] && this.releaseLock());\n    }\n\n    async read(size?: number): Promise<ReadableStreamReadResult<Uint8Array>> {\n        if (size === 0) {\n            return { done: this.reader == null, value: new Uint8Array(0) };\n        }\n        const result = !this.supportsBYOB || typeof size !== 'number'\n            ? await this.getDefaultReader().read()\n            : await this.readFromBYOBReader(size);\n        !result.done && (result.value = toUint8Array(result as ReadableStreamReadResult<Uint8Array>));\n        return result as ReadableStreamReadResult<Uint8Array>;\n    }\n\n    private getDefaultReader() {\n        if (this.byobReader) { this.releaseLock(); }\n        if (!this.defaultReader) {\n            this.defaultReader = this.source['getReader']();\n            // We have to catch and swallow errors here to avoid uncaught promise rejection exceptions\n            // that seem to be raised when we call `releaseLock()` on this reader. I'm still mystified\n            // about why these errors are raised, but I'm sure there's some important spec reason that\n            // I haven't considered. I hate to employ such an anti-pattern here, but it seems like the\n            // only solution in this case :/\n            this.defaultReader['closed'].catch(() => {});\n        }\n        return (this.reader = this.defaultReader);\n    }\n\n    private getBYOBReader() {\n        if (this.defaultReader) { this.releaseLock(); }\n        if (!this.byobReader) {\n            this.byobReader = this.source['getReader']({ mode: 'byob' });\n            // We have to catch and swallow errors here to avoid uncaught promise rejection exceptions\n            // that seem to be raised when we call `releaseLock()` on this reader. I'm still mystified\n            // about why these errors are raised, but I'm sure there's some important spec reason that\n            // I haven't considered. I hate to employ such an anti-pattern here, but it seems like the\n            // only solution in this case :/\n            this.byobReader['closed'].catch(() => {});\n        }\n        return (this.reader = this.byobReader);\n    }\n\n    // This strategy plucked from the example in the streams spec:\n    // https://streams.spec.whatwg.org/#example-manual-read-bytes\n    private async readFromBYOBReader(size: number) {\n        return await readInto(this.getBYOBReader(), new ArrayBuffer(size), 0, size);\n    }\n}\n\n/** @ignore */\nasync function readInto(reader: ReadableStreamBYOBReader, buffer: ArrayBufferLike, offset: number, size: number): Promise<ReadableStreamReadResult<Uint8Array>> {\n    if (offset >= size) {\n        return { done: false, value: new Uint8Array(buffer, 0, size) };\n    }\n    const { done, value } = await reader.read(new Uint8Array(buffer, offset, size - offset));\n    if (((offset += value.byteLength) < size) && !done) {\n        return await readInto(reader, value.buffer, offset, size);\n    }\n    return { done, value: new Uint8Array(value.buffer, 0, offset) };\n}\n\n/** @ignore */\ntype EventName = 'end' | 'error' | 'readable';\n/** @ignore */\ntype Event = [EventName, (_: any) => void, Promise<[EventName, Error | null]>];\n/** @ignore */\nconst onEvent = <T extends string>(stream: NodeJS.ReadableStream, event: T) => {\n    let handler = (_: any) => resolve([event, _]);\n    let resolve: (value?: [T, any] | PromiseLike<[T, any]>) => void;\n    return [event, handler, new Promise<[T, any]>(\n        (r) => (resolve = r) && stream['once'](event, handler)\n    )] as Event;\n};\n\n/** @ignore */\nasync function* fromNodeStream(stream: NodeJS.ReadableStream): AsyncIterableIterator<Uint8Array> {\n\n    let events: Event[] = [];\n    let event: EventName = 'error';\n    let done = false, err: Error | null = null;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array | Buffer | string;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before we\n    // add the listener for the source stream's 'readable' event.\n    ({ cmd, size } = yield <any> null);\n\n    // ignore stdin if it's a TTY\n    if ((stream as any)['isTTY']) { return yield new Uint8Array(0); }\n\n    try {\n        // initialize the stream event handlers\n        events[0] = onEvent(stream, 'end');\n        events[1] = onEvent(stream, 'error');\n\n        do {\n            events[2] = onEvent(stream, 'readable');\n\n            // wait on the first message event from the stream\n            [event, err] = await Promise.race(events.map((x) => x[2]));\n\n            // if the stream emitted an Error, rethrow it\n            if (event === 'error') { break; }\n            if (!(done = event === 'end')) {\n                // If the size is NaN, request to read everything in the stream's internal buffer\n                if (!isFinite(size - bufferLength)) {\n                    buffer = toUint8Array(stream['read'](undefined));\n                } else {\n                    buffer = toUint8Array(stream['read'](size - bufferLength));\n                    // If the byteLength is 0, then the requested amount is more than the stream has\n                    // in its internal buffer. In this case the stream needs a \"kick\" to tell it to\n                    // continue emitting readable events, so request to read everything the stream\n                    // has in its internal buffer right now.\n                    if (buffer.byteLength < (size - bufferLength)) {\n                        buffer = toUint8Array(stream['read'](undefined));\n                    }\n                }\n                // if chunk is not null or empty, push it onto the queue\n                if (buffer.byteLength > 0) {\n                    buffers.push(buffer);\n                    bufferLength += buffer.byteLength;\n                }\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } finally {\n        await cleanup(events, event === 'error' ? err : null);\n    }\n\n    function cleanup<T extends Error | null | void>(events: Event[], err?: T) {\n        buffer = buffers = <any> null;\n        return new Promise<T>(async (resolve, reject) => {\n            for (const [evt, fn] of events) {\n                stream['off'](evt, fn);\n            }\n            try {\n                // Some stream implementations don't call the destroy callback,\n                // because it's really a node-internal API. Just calling `destroy`\n                // here should be enough to conform to the ReadableStream contract\n                const destroy = (stream as any)['destroy'];\n                destroy && destroy.call(stream, err);\n                err = undefined;\n            } catch (e) { err = e || err; } finally {\n                err != null ? reject(err) : resolve();\n            }\n        });\n    }\n}\n","/// @file\n/// @addtogroup flatbuffers_javascript_api\n/// @{\n/// @cond FLATBUFFERS_INTERNAL\n\n/**\n * @fileoverview\n *\n * Need to suppress 'global this' error so the Node.js export line doesn't cause\n * closure compile to error out.\n * @suppress {globalThis}\n */\n\n/**\n * @const\n * @namespace\n */\nvar flatbuffers = {};\n\n/**\n * @typedef {number}\n */\nflatbuffers.Offset;\n\n/**\n * @typedef {{\n *   bb: flatbuffers.ByteBuffer,\n *   bb_pos: number\n * }}\n */\nflatbuffers.Table;\n\n/**\n * @type {number}\n * @const\n */\nflatbuffers.SIZEOF_SHORT = 2;\n\n/**\n * @type {number}\n * @const\n */\nflatbuffers.SIZEOF_INT = 4;\n\n/**\n * @type {number}\n * @const\n */\nflatbuffers.FILE_IDENTIFIER_LENGTH = 4;\n\n/**\n * @enum {number}\n */\nflatbuffers.Encoding = {\n  UTF8_BYTES: 1,\n  UTF16_STRING: 2\n};\n\n/**\n * @type {Int32Array}\n * @const\n */\nflatbuffers.int32 = new Int32Array(2);\n\n/**\n * @type {Float32Array}\n * @const\n */\nflatbuffers.float32 = new Float32Array(flatbuffers.int32.buffer);\n\n/**\n * @type {Float64Array}\n * @const\n */\nflatbuffers.float64 = new Float64Array(flatbuffers.int32.buffer);\n\n/**\n * @type {boolean}\n * @const\n */\nflatbuffers.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;\n\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @constructor\n * @param {number} low\n * @param {number} high\n */\nflatbuffers.Long = function(low, high) {\n  /**\n   * @type {number}\n   * @const\n   */\n  this.low = low | 0;\n\n  /**\n   * @type {number}\n   * @const\n   */\n  this.high = high | 0;\n};\n\n/**\n * @param {number} low\n * @param {number} high\n * @returns {flatbuffers.Long}\n */\nflatbuffers.Long.create = function(low, high) {\n  // Special-case zero to avoid GC overhead for default values\n  return low == 0 && high == 0 ? flatbuffers.Long.ZERO : new flatbuffers.Long(low, high);\n};\n\n/**\n * @returns {number}\n */\nflatbuffers.Long.prototype.toFloat64 = function() {\n  return (this.low >>> 0) + this.high * 0x100000000;\n};\n\n/**\n * @param {flatbuffers.Long} other\n * @returns {boolean}\n */\nflatbuffers.Long.prototype.equals = function(other) {\n  return this.low == other.low && this.high == other.high;\n};\n\n/**\n * @type {flatbuffers.Long}\n * @const\n */\nflatbuffers.Long.ZERO = new flatbuffers.Long(0, 0);\n\n/// @endcond\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a FlatBufferBuilder.\n *\n * @constructor\n * @param {number=} opt_initial_size\n */\nflatbuffers.Builder = function(opt_initial_size) {\n  if (!opt_initial_size) {\n    var initial_size = 1024;\n  } else {\n    var initial_size = opt_initial_size;\n  }\n\n  /**\n   * @type {flatbuffers.ByteBuffer}\n   * @private\n   */\n  this.bb = flatbuffers.ByteBuffer.allocate(initial_size);\n\n  /**\n   * Remaining space in the ByteBuffer.\n   *\n   * @type {number}\n   * @private\n   */\n  this.space = initial_size;\n\n  /**\n   * Minimum alignment encountered so far.\n   *\n   * @type {number}\n   * @private\n   */\n  this.minalign = 1;\n\n  /**\n   * The vtable for the current table.\n   *\n   * @type {Array.<number>}\n   * @private\n   */\n  this.vtable = null;\n\n  /**\n   * The amount of fields we're actually using.\n   *\n   * @type {number}\n   * @private\n   */\n  this.vtable_in_use = 0;\n\n  /**\n   * Whether we are currently serializing a table.\n   *\n   * @type {boolean}\n   * @private\n   */\n  this.isNested = false;\n\n  /**\n   * Starting offset of the current struct/table.\n   *\n   * @type {number}\n   * @private\n   */\n  this.object_start = 0;\n\n  /**\n   * List of offsets of all vtables.\n   *\n   * @type {Array.<number>}\n   * @private\n   */\n  this.vtables = [];\n\n  /**\n   * For the current vector being built.\n   *\n   * @type {number}\n   * @private\n   */\n  this.vector_num_elems = 0;\n\n  /**\n   * False omits default values from the serialized data\n   *\n   * @type {boolean}\n   * @private\n   */\n  this.force_defaults = false;\n};\n\nflatbuffers.Builder.prototype.clear = function() {\n  this.bb.clear();\n  this.space = this.bb.capacity();\n  this.minalign = 1;\n  this.vtable = null;\n  this.vtable_in_use = 0;\n  this.isNested = false;\n  this.object_start = 0;\n  this.vtables = [];\n  this.vector_num_elems = 0;\n  this.force_defaults = false;\n};\n\n/**\n * In order to save space, fields that are set to their default value\n * don't get serialized into the buffer. Forcing defaults provides a\n * way to manually disable this optimization.\n *\n * @param {boolean} forceDefaults true always serializes default values\n */\nflatbuffers.Builder.prototype.forceDefaults = function(forceDefaults) {\n  this.force_defaults = forceDefaults;\n};\n\n/**\n * Get the ByteBuffer representing the FlatBuffer. Only call this after you've\n * called finish(). The actual data starts at the ByteBuffer's current position,\n * not necessarily at 0.\n *\n * @returns {flatbuffers.ByteBuffer}\n */\nflatbuffers.Builder.prototype.dataBuffer = function() {\n  return this.bb;\n};\n\n/**\n * Get the bytes representing the FlatBuffer. Only call this after you've\n * called finish().\n *\n * @returns {Uint8Array}\n */\nflatbuffers.Builder.prototype.asUint8Array = function() {\n  return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * Prepare to write an element of `size` after `additional_bytes` have been\n * written, e.g. if you write a string, you need to align such the int length\n * field is aligned to 4 bytes, and the string data follows it directly. If all\n * you need to do is alignment, `additional_bytes` will be 0.\n *\n * @param {number} size This is the of the new element to write\n * @param {number} additional_bytes The padding size\n */\nflatbuffers.Builder.prototype.prep = function(size, additional_bytes) {\n  // Track the biggest thing we've ever aligned to.\n  if (size > this.minalign) {\n    this.minalign = size;\n  }\n\n  // Find the amount of alignment needed such that `size` is properly\n  // aligned after `additional_bytes`\n  var align_size = ((~(this.bb.capacity() - this.space + additional_bytes)) + 1) & (size - 1);\n\n  // Reallocate the buffer if needed.\n  while (this.space < align_size + size + additional_bytes) {\n    var old_buf_size = this.bb.capacity();\n    this.bb = flatbuffers.Builder.growByteBuffer(this.bb);\n    this.space += this.bb.capacity() - old_buf_size;\n  }\n\n  this.pad(align_size);\n};\n\n/**\n * @param {number} byte_size\n */\nflatbuffers.Builder.prototype.pad = function(byte_size) {\n  for (var i = 0; i < byte_size; i++) {\n    this.bb.writeInt8(--this.space, 0);\n  }\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeInt8 = function(value) {\n  this.bb.writeInt8(this.space -= 1, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeInt16 = function(value) {\n  this.bb.writeInt16(this.space -= 2, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeInt32 = function(value) {\n  this.bb.writeInt32(this.space -= 4, value);\n};\n\n/**\n * @param {flatbuffers.Long} value\n */\nflatbuffers.Builder.prototype.writeInt64 = function(value) {\n  this.bb.writeInt64(this.space -= 8, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeFloat32 = function(value) {\n  this.bb.writeFloat32(this.space -= 4, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeFloat64 = function(value) {\n  this.bb.writeFloat64(this.space -= 8, value);\n};\n/// @endcond\n\n/**\n * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `int8` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt8 = function(value) {\n  this.prep(1, 0);\n  this.writeInt8(value);\n};\n\n/**\n * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `int16` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt16 = function(value) {\n  this.prep(2, 0);\n  this.writeInt16(value);\n};\n\n/**\n * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `int32` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt32 = function(value) {\n  this.prep(4, 0);\n  this.writeInt32(value);\n};\n\n/**\n * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {flatbuffers.Long} value The `int64` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt64 = function(value) {\n  this.prep(8, 0);\n  this.writeInt64(value);\n};\n\n/**\n * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `float32` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addFloat32 = function(value) {\n  this.prep(4, 0);\n  this.writeFloat32(value);\n};\n\n/**\n * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `float64` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addFloat64 = function(value) {\n  this.prep(8, 0);\n  this.writeFloat64(value);\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt8 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addInt8(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt16 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addInt16(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt32 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addInt32(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {flatbuffers.Long} value\n * @param {flatbuffers.Long} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt64 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || !value.equals(defaultValue)) {\n    this.addInt64(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldFloat32 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addFloat32(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldFloat64 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addFloat64(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {flatbuffers.Offset} value\n * @param {flatbuffers.Offset} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldOffset = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addOffset(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * Structs are stored inline, so nothing additional is being added. `d` is always 0.\n *\n * @param {number} voffset\n * @param {flatbuffers.Offset} value\n * @param {flatbuffers.Offset} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldStruct = function(voffset, value, defaultValue) {\n  if (value != defaultValue) {\n    this.nested(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * Structures are always stored inline, they need to be created right\n * where they're used.  You'll get this assertion failure if you\n * created it elsewhere.\n *\n * @param {flatbuffers.Offset} obj The offset of the created object\n */\nflatbuffers.Builder.prototype.nested = function(obj) {\n  if (obj != this.offset()) {\n    throw new Error('FlatBuffers: struct must be serialized inline.');\n  }\n};\n\n/**\n * Should not be creating any other object, string or vector\n * while an object is being constructed\n */\nflatbuffers.Builder.prototype.notNested = function() {\n  if (this.isNested) {\n    throw new Error('FlatBuffers: object serialization must not be nested.');\n  }\n};\n\n/**\n * Set the current vtable at `voffset` to the current location in the buffer.\n *\n * @param {number} voffset\n */\nflatbuffers.Builder.prototype.slot = function(voffset) {\n  this.vtable[voffset] = this.offset();\n};\n\n/**\n * @returns {flatbuffers.Offset} Offset relative to the end of the buffer.\n */\nflatbuffers.Builder.prototype.offset = function() {\n  return this.bb.capacity() - this.space;\n};\n\n/**\n * Doubles the size of the backing ByteBuffer and copies the old data towards\n * the end of the new buffer (since we build the buffer backwards).\n *\n * @param {flatbuffers.ByteBuffer} bb The current buffer with the existing data\n * @returns {flatbuffers.ByteBuffer} A new byte buffer with the old data copied\n * to it. The data is located at the end of the buffer.\n *\n * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass\n * it a uint8Array we need to suppress the type check:\n * @suppress {checkTypes}\n */\nflatbuffers.Builder.growByteBuffer = function(bb) {\n  var old_buf_size = bb.capacity();\n\n  // Ensure we don't grow beyond what fits in an int.\n  if (old_buf_size & 0xC0000000) {\n    throw new Error('FlatBuffers: cannot grow buffer beyond 2 gigabytes.');\n  }\n\n  var new_buf_size = old_buf_size << 1;\n  var nbb = flatbuffers.ByteBuffer.allocate(new_buf_size);\n  nbb.setPosition(new_buf_size - old_buf_size);\n  nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);\n  return nbb;\n};\n/// @endcond\n\n/**\n * Adds on offset, relative to where it will be written.\n *\n * @param {flatbuffers.Offset} offset The offset to add.\n */\nflatbuffers.Builder.prototype.addOffset = function(offset) {\n  this.prep(flatbuffers.SIZEOF_INT, 0); // Ensure alignment is already done.\n  this.writeInt32(this.offset() - offset + flatbuffers.SIZEOF_INT);\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * Start encoding a new object in the buffer.  Users will not usually need to\n * call this directly. The FlatBuffers compiler will generate helper methods\n * that call this method internally.\n *\n * @param {number} numfields\n */\nflatbuffers.Builder.prototype.startObject = function(numfields) {\n  this.notNested();\n  if (this.vtable == null) {\n    this.vtable = [];\n  }\n  this.vtable_in_use = numfields;\n  for (var i = 0; i < numfields; i++) {\n    this.vtable[i] = 0; // This will push additional elements as needed\n  }\n  this.isNested = true;\n  this.object_start = this.offset();\n};\n\n/**\n * Finish off writing the object that is under construction.\n *\n * @returns {flatbuffers.Offset} The offset to the object inside `dataBuffer`\n */\nflatbuffers.Builder.prototype.endObject = function() {\n  if (this.vtable == null || !this.isNested) {\n    throw new Error('FlatBuffers: endObject called without startObject');\n  }\n\n  this.addInt32(0);\n  var vtableloc = this.offset();\n\n  // Trim trailing zeroes.\n  var i = this.vtable_in_use - 1;\n  for (; i >= 0 && this.vtable[i] == 0; i--) {}\n  var trimmed_size = i + 1;\n\n  // Write out the current vtable.\n  for (; i >= 0; i--) {\n    // Offset relative to the start of the table.\n    this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);\n  }\n\n  var standard_fields = 2; // The fields below:\n  this.addInt16(vtableloc - this.object_start);\n  var len = (trimmed_size + standard_fields) * flatbuffers.SIZEOF_SHORT;\n  this.addInt16(len);\n\n  // Search for an existing vtable that matches the current one.\n  var existing_vtable = 0;\n  var vt1 = this.space;\nouter_loop:\n  for (i = 0; i < this.vtables.length; i++) {\n    var vt2 = this.bb.capacity() - this.vtables[i];\n    if (len == this.bb.readInt16(vt2)) {\n      for (var j = flatbuffers.SIZEOF_SHORT; j < len; j += flatbuffers.SIZEOF_SHORT) {\n        if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {\n          continue outer_loop;\n        }\n      }\n      existing_vtable = this.vtables[i];\n      break;\n    }\n  }\n\n  if (existing_vtable) {\n    // Found a match:\n    // Remove the current vtable.\n    this.space = this.bb.capacity() - vtableloc;\n\n    // Point table to existing vtable.\n    this.bb.writeInt32(this.space, existing_vtable - vtableloc);\n  } else {\n    // No match:\n    // Add the location of the current vtable to the list of vtables.\n    this.vtables.push(this.offset());\n\n    // Point table to current vtable.\n    this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);\n  }\n\n  this.isNested = false;\n  return vtableloc;\n};\n/// @endcond\n\n/**\n * Finalize a buffer, poiting to the given `root_table`.\n *\n * @param {flatbuffers.Offset} root_table\n * @param {string=} opt_file_identifier\n */\nflatbuffers.Builder.prototype.finish = function(root_table, opt_file_identifier) {\n  if (opt_file_identifier) {\n    var file_identifier = opt_file_identifier;\n    this.prep(this.minalign, flatbuffers.SIZEOF_INT +\n      flatbuffers.FILE_IDENTIFIER_LENGTH);\n    if (file_identifier.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {\n      throw new Error('FlatBuffers: file identifier must be length ' +\n        flatbuffers.FILE_IDENTIFIER_LENGTH);\n    }\n    for (var i = flatbuffers.FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {\n      this.writeInt8(file_identifier.charCodeAt(i));\n    }\n  }\n  this.prep(this.minalign, flatbuffers.SIZEOF_INT);\n  this.addOffset(root_table);\n  this.bb.setPosition(this.space);\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * This checks a required field has been set in a given table that has\n * just been constructed.\n *\n * @param {flatbuffers.Offset} table\n * @param {number} field\n */\nflatbuffers.Builder.prototype.requiredField = function(table, field) {\n  var table_start = this.bb.capacity() - table;\n  var vtable_start = table_start - this.bb.readInt32(table_start);\n  var ok = this.bb.readInt16(vtable_start + field) != 0;\n\n  // If this fails, the caller will show what field needs to be set.\n  if (!ok) {\n    throw new Error('FlatBuffers: field ' + field + ' must be set');\n  }\n};\n\n/**\n * Start a new array/vector of objects.  Users usually will not call\n * this directly. The FlatBuffers compiler will create a start/end\n * method for vector types in generated code.\n *\n * @param {number} elem_size The size of each element in the array\n * @param {number} num_elems The number of elements in the array\n * @param {number} alignment The alignment of the array\n */\nflatbuffers.Builder.prototype.startVector = function(elem_size, num_elems, alignment) {\n  this.notNested();\n  this.vector_num_elems = num_elems;\n  this.prep(flatbuffers.SIZEOF_INT, elem_size * num_elems);\n  this.prep(alignment, elem_size * num_elems); // Just in case alignment > int.\n};\n\n/**\n * Finish off the creation of an array and all its elements. The array must be\n * created with `startVector`.\n *\n * @returns {flatbuffers.Offset} The offset at which the newly created array\n * starts.\n */\nflatbuffers.Builder.prototype.endVector = function() {\n  this.writeInt32(this.vector_num_elems);\n  return this.offset();\n};\n/// @endcond\n\n/**\n * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed\n * instead of a string, it is assumed to contain valid UTF-8 encoded data.\n *\n * @param {string|Uint8Array} s The string to encode\n * @return {flatbuffers.Offset} The offset in the buffer where the encoded string starts\n */\nflatbuffers.Builder.prototype.createString = function(s) {\n  if (s instanceof Uint8Array) {\n    var utf8 = s;\n  } else {\n    var utf8 = [];\n    var i = 0;\n\n    while (i < s.length) {\n      var codePoint;\n\n      // Decode UTF-16\n      var a = s.charCodeAt(i++);\n      if (a < 0xD800 || a >= 0xDC00) {\n        codePoint = a;\n      } else {\n        var b = s.charCodeAt(i++);\n        codePoint = (a << 10) + b + (0x10000 - (0xD800 << 10) - 0xDC00);\n      }\n\n      // Encode UTF-8\n      if (codePoint < 0x80) {\n        utf8.push(codePoint);\n      } else {\n        if (codePoint < 0x800) {\n          utf8.push(((codePoint >> 6) & 0x1F) | 0xC0);\n        } else {\n          if (codePoint < 0x10000) {\n            utf8.push(((codePoint >> 12) & 0x0F) | 0xE0);\n          } else {\n            utf8.push(\n              ((codePoint >> 18) & 0x07) | 0xF0,\n              ((codePoint >> 12) & 0x3F) | 0x80);\n          }\n          utf8.push(((codePoint >> 6) & 0x3F) | 0x80);\n        }\n        utf8.push((codePoint & 0x3F) | 0x80);\n      }\n    }\n  }\n\n  this.addInt8(0);\n  this.startVector(1, utf8.length, 1);\n  this.bb.setPosition(this.space -= utf8.length);\n  for (var i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {\n    bytes[offset++] = utf8[i];\n  }\n  return this.endVector();\n};\n\n/**\n * A helper function to avoid generated code depending on this file directly.\n *\n * @param {number} low\n * @param {number} high\n * @returns {flatbuffers.Long}\n */\nflatbuffers.Builder.prototype.createLong = function(low, high) {\n  return flatbuffers.Long.create(low, high);\n};\n////////////////////////////////////////////////////////////////////////////////\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * Create a new ByteBuffer with a given array of bytes (`Uint8Array`).\n *\n * @constructor\n * @param {Uint8Array} bytes\n */\nflatbuffers.ByteBuffer = function(bytes) {\n  /**\n   * @type {Uint8Array}\n   * @private\n   */\n  this.bytes_ = bytes;\n\n  /**\n   * @type {number}\n   * @private\n   */\n  this.position_ = 0;\n};\n\n/**\n * Create and allocate a new ByteBuffer with a given size.\n *\n * @param {number} byte_size\n * @returns {flatbuffers.ByteBuffer}\n */\nflatbuffers.ByteBuffer.allocate = function(byte_size) {\n  return new flatbuffers.ByteBuffer(new Uint8Array(byte_size));\n};\n\nflatbuffers.ByteBuffer.prototype.clear = function() {\n  this.position_ = 0;\n};\n\n/**\n * Get the underlying `Uint8Array`.\n *\n * @returns {Uint8Array}\n */\nflatbuffers.ByteBuffer.prototype.bytes = function() {\n  return this.bytes_;\n};\n\n/**\n * Get the buffer's position.\n *\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.position = function() {\n  return this.position_;\n};\n\n/**\n * Set the buffer's position.\n *\n * @param {number} position\n */\nflatbuffers.ByteBuffer.prototype.setPosition = function(position) {\n  this.position_ = position;\n};\n\n/**\n * Get the buffer's capacity.\n *\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.capacity = function() {\n  return this.bytes_.length;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readInt8 = function(offset) {\n  return this.readUint8(offset) << 24 >> 24;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readUint8 = function(offset) {\n  return this.bytes_[offset];\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readInt16 = function(offset) {\n  return this.readUint16(offset) << 16 >> 16;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readUint16 = function(offset) {\n  return this.bytes_[offset] | this.bytes_[offset + 1] << 8;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readInt32 = function(offset) {\n  return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readUint32 = function(offset) {\n  return this.readInt32(offset) >>> 0;\n};\n\n/**\n * @param {number} offset\n * @returns {flatbuffers.Long}\n */\nflatbuffers.ByteBuffer.prototype.readInt64 = function(offset) {\n  return new flatbuffers.Long(this.readInt32(offset), this.readInt32(offset + 4));\n};\n\n/**\n * @param {number} offset\n * @returns {flatbuffers.Long}\n */\nflatbuffers.ByteBuffer.prototype.readUint64 = function(offset) {\n  return new flatbuffers.Long(this.readUint32(offset), this.readUint32(offset + 4));\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readFloat32 = function(offset) {\n  flatbuffers.int32[0] = this.readInt32(offset);\n  return flatbuffers.float32[0];\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readFloat64 = function(offset) {\n  flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1] = this.readInt32(offset);\n  flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);\n  return flatbuffers.float64[0];\n};\n\n/**\n * @param {number} offset\n * @param {number|boolean} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt8 = function(offset, value) {\n  this.bytes_[offset] = /** @type {number} */(value);\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint8 = function(offset, value) {\n  this.bytes_[offset] = value;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt16 = function(offset, value) {\n  this.bytes_[offset] = value;\n  this.bytes_[offset + 1] = value >> 8;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint16 = function(offset, value) {\n    this.bytes_[offset] = value;\n    this.bytes_[offset + 1] = value >> 8;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt32 = function(offset, value) {\n  this.bytes_[offset] = value;\n  this.bytes_[offset + 1] = value >> 8;\n  this.bytes_[offset + 2] = value >> 16;\n  this.bytes_[offset + 3] = value >> 24;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint32 = function(offset, value) {\n    this.bytes_[offset] = value;\n    this.bytes_[offset + 1] = value >> 8;\n    this.bytes_[offset + 2] = value >> 16;\n    this.bytes_[offset + 3] = value >> 24;\n};\n\n/**\n * @param {number} offset\n * @param {flatbuffers.Long} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt64 = function(offset, value) {\n  this.writeInt32(offset, value.low);\n  this.writeInt32(offset + 4, value.high);\n};\n\n/**\n * @param {number} offset\n * @param {flatbuffers.Long} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint64 = function(offset, value) {\n    this.writeUint32(offset, value.low);\n    this.writeUint32(offset + 4, value.high);\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeFloat32 = function(offset, value) {\n  flatbuffers.float32[0] = value;\n  this.writeInt32(offset, flatbuffers.int32[0]);\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeFloat64 = function(offset, value) {\n  flatbuffers.float64[0] = value;\n  this.writeInt32(offset, flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1]);\n  this.writeInt32(offset + 4, flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0]);\n};\n\n/**\n * Return the file identifier.   Behavior is undefined for FlatBuffers whose\n * schema does not include a file_identifier (likely points at padding or the\n * start of a the root vtable).\n * @returns {string}\n */\nflatbuffers.ByteBuffer.prototype.getBufferIdentifier = function() {\n  if (this.bytes_.length < this.position_ + flatbuffers.SIZEOF_INT +\n      flatbuffers.FILE_IDENTIFIER_LENGTH) {\n    throw new Error(\n        'FlatBuffers: ByteBuffer is too short to contain an identifier.');\n  }\n  var result = \"\";\n  for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {\n    result += String.fromCharCode(\n        this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i));\n  }\n  return result;\n};\n\n/**\n * Look up a field in the vtable, return an offset into the object, or 0 if the\n * field is not present.\n *\n * @param {number} bb_pos\n * @param {number} vtable_offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__offset = function(bb_pos, vtable_offset) {\n  var vtable = bb_pos - this.readInt32(bb_pos);\n  return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;\n};\n\n/**\n * Initialize any Table-derived type to point to the union at the given offset.\n *\n * @param {flatbuffers.Table} t\n * @param {number} offset\n * @returns {flatbuffers.Table}\n */\nflatbuffers.ByteBuffer.prototype.__union = function(t, offset) {\n  t.bb_pos = offset + this.readInt32(offset);\n  t.bb = this;\n  return t;\n};\n\n/**\n * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.\n * This allocates a new string and converts to wide chars upon each access.\n *\n * To avoid the conversion to UTF-16, pass flatbuffers.Encoding.UTF8_BYTES as\n * the \"optionalEncoding\" argument. This is useful for avoiding conversion to\n * and from UTF-16 when the data will just be packaged back up in another\n * FlatBuffer later on.\n *\n * @param {number} offset\n * @param {flatbuffers.Encoding=} opt_encoding Defaults to UTF16_STRING\n * @returns {string|Uint8Array}\n */\nflatbuffers.ByteBuffer.prototype.__string = function(offset, opt_encoding) {\n  offset += this.readInt32(offset);\n\n  var length = this.readInt32(offset);\n  var result = '';\n  var i = 0;\n\n  offset += flatbuffers.SIZEOF_INT;\n\n  if (opt_encoding === flatbuffers.Encoding.UTF8_BYTES) {\n    return this.bytes_.subarray(offset, offset + length);\n  }\n\n  while (i < length) {\n    var codePoint;\n\n    // Decode UTF-8\n    var a = this.readUint8(offset + i++);\n    if (a < 0xC0) {\n      codePoint = a;\n    } else {\n      var b = this.readUint8(offset + i++);\n      if (a < 0xE0) {\n        codePoint =\n          ((a & 0x1F) << 6) |\n          (b & 0x3F);\n      } else {\n        var c = this.readUint8(offset + i++);\n        if (a < 0xF0) {\n          codePoint =\n            ((a & 0x0F) << 12) |\n            ((b & 0x3F) << 6) |\n            (c & 0x3F);\n        } else {\n          var d = this.readUint8(offset + i++);\n          codePoint =\n            ((a & 0x07) << 18) |\n            ((b & 0x3F) << 12) |\n            ((c & 0x3F) << 6) |\n            (d & 0x3F);\n        }\n      }\n    }\n\n    // Encode UTF-16\n    if (codePoint < 0x10000) {\n      result += String.fromCharCode(codePoint);\n    } else {\n      codePoint -= 0x10000;\n      result += String.fromCharCode(\n        (codePoint >> 10) + 0xD800,\n        (codePoint & ((1 << 10) - 1)) + 0xDC00);\n    }\n  }\n\n  return result;\n};\n\n/**\n * Retrieve the relative offset stored at \"offset\"\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__indirect = function(offset) {\n  return offset + this.readInt32(offset);\n};\n\n/**\n * Get the start of data of a vector whose offset is stored at \"offset\" in this object.\n *\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__vector = function(offset) {\n  return offset + this.readInt32(offset) + flatbuffers.SIZEOF_INT; // data starts after the length\n};\n\n/**\n * Get the length of a vector whose offset is stored at \"offset\" in this object.\n *\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__vector_len = function(offset) {\n  return this.readInt32(offset + this.readInt32(offset));\n};\n\n/**\n * @param {string} ident\n * @returns {boolean}\n */\nflatbuffers.ByteBuffer.prototype.__has_identifier = function(ident) {\n  if (ident.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {\n    throw new Error('FlatBuffers: file identifier must be length ' +\n                    flatbuffers.FILE_IDENTIFIER_LENGTH);\n  }\n  for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {\n    if (ident.charCodeAt(i) != this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * A helper function to avoid generated code depending on this file directly.\n *\n * @param {number} low\n * @param {number} high\n * @returns {flatbuffers.Long}\n */\nflatbuffers.ByteBuffer.prototype.createLong = function(low, high) {\n  return flatbuffers.Long.create(low, high);\n};\n\n// Exports for Node.js and RequireJS\nexport { flatbuffers };\n\n/// @endcond\n/// @}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { toUint8Array } from './buffer';\nimport {\n    TextDecoder as TextDecoderPolyfill,\n    TextEncoder as TextEncoderPolyfill,\n} from 'text-encoding-utf-8';\n\n/** @ignore @suppress {missingRequire} */\nconst _Buffer = typeof Buffer === 'function' ? Buffer : null;\n/** @ignore */\nconst useNativeEncoders = typeof TextDecoder === 'function' && typeof TextEncoder === 'function';\n\n/** @ignore */\nexport const decodeUtf8 = ((TextDecoder) => {\n    if (useNativeEncoders || !_Buffer) {\n        const decoder = new TextDecoder('utf-8');\n        return (buffer?: ArrayBuffer | ArrayBufferView) => decoder.decode(buffer);\n    }\n    return (input: ArrayBufferLike | ArrayBufferView) => {\n        const { buffer, byteOffset, length } = toUint8Array(input);\n        return _Buffer.from(buffer, byteOffset, length).toString();\n    };\n})(typeof TextDecoder !== 'undefined' ? TextDecoder : TextDecoderPolyfill);\n\n/** @ignore */\nexport const encodeUtf8 = ((TextEncoder) => {\n    if (useNativeEncoders || !_Buffer) {\n        const encoder = new TextEncoder();\n        return (value?: string) => encoder.encode(value);\n    }\n    return (input = '') => toUint8Array(_Buffer.from(input, 'utf8'));\n})(typeof TextEncoder !== 'undefined' ? TextEncoder : TextEncoderPolyfill);\n","'use strict';\n\n// This is free and unencumbered software released into the public domain.\n// See LICENSE.md for more information.\n\n//\n// Utilities\n//\n\n/**\n * @param {number} a The number to test.\n * @param {number} min The minimum value in the range, inclusive.\n * @param {number} max The maximum value in the range, inclusive.\n * @return {boolean} True if a >= min and a <= max.\n */\nfunction inRange(a, min, max) {\n  return min <= a && a <= max;\n}\n\n/**\n * @param {*} o\n * @return {Object}\n */\nfunction ToDictionary(o) {\n  if (o === undefined) return {};\n  if (o === Object(o)) return o;\n  throw TypeError('Could not convert argument to dictionary');\n}\n\n/**\n * @param {string} string Input string of UTF-16 code units.\n * @return {!Array.<number>} Code points.\n */\nfunction stringToCodePoints(string) {\n  // https://heycam.github.io/webidl/#dfn-obtain-unicode\n\n  // 1. Let S be the DOMString value.\n  var s = String(string);\n\n  // 2. Let n be the length of S.\n  var n = s.length;\n\n  // 3. Initialize i to 0.\n  var i = 0;\n\n  // 4. Initialize U to be an empty sequence of Unicode characters.\n  var u = [];\n\n  // 5. While i < n:\n  while (i < n) {\n\n    // 1. Let c be the code unit in S at index i.\n    var c = s.charCodeAt(i);\n\n    // 2. Depending on the value of c:\n\n    // c < 0xD800 or c > 0xDFFF\n    if (c < 0xD800 || c > 0xDFFF) {\n      // Append to U the Unicode character with code point c.\n      u.push(c);\n    }\n\n    // 0xDC00 ≤ c ≤ 0xDFFF\n    else if (0xDC00 <= c && c <= 0xDFFF) {\n      // Append to U a U+FFFD REPLACEMENT CHARACTER.\n      u.push(0xFFFD);\n    }\n\n    // 0xD800 ≤ c ≤ 0xDBFF\n    else if (0xD800 <= c && c <= 0xDBFF) {\n      // 1. If i = n−1, then append to U a U+FFFD REPLACEMENT\n      // CHARACTER.\n      if (i === n - 1) {\n        u.push(0xFFFD);\n      }\n      // 2. Otherwise, i < n−1:\n      else {\n        // 1. Let d be the code unit in S at index i+1.\n        var d = string.charCodeAt(i + 1);\n\n        // 2. If 0xDC00 ≤ d ≤ 0xDFFF, then:\n        if (0xDC00 <= d && d <= 0xDFFF) {\n          // 1. Let a be c & 0x3FF.\n          var a = c & 0x3FF;\n\n          // 2. Let b be d & 0x3FF.\n          var b = d & 0x3FF;\n\n          // 3. Append to U the Unicode character with code point\n          // 2^16+2^10*a+b.\n          u.push(0x10000 + (a << 10) + b);\n\n          // 4. Set i to i+1.\n          i += 1;\n        }\n\n        // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a\n        // U+FFFD REPLACEMENT CHARACTER.\n        else  {\n          u.push(0xFFFD);\n        }\n      }\n    }\n\n    // 3. Set i to i+1.\n    i += 1;\n  }\n\n  // 6. Return U.\n  return u;\n}\n\n/**\n * @param {!Array.<number>} code_points Array of code points.\n * @return {string} string String of UTF-16 code units.\n */\nfunction codePointsToString(code_points) {\n  var s = '';\n  for (var i = 0; i < code_points.length; ++i) {\n    var cp = code_points[i];\n    if (cp <= 0xFFFF) {\n      s += String.fromCharCode(cp);\n    } else {\n      cp -= 0x10000;\n      s += String.fromCharCode((cp >> 10) + 0xD800,\n                               (cp & 0x3FF) + 0xDC00);\n    }\n  }\n  return s;\n}\n\n\n//\n// Implementation of Encoding specification\n// https://encoding.spec.whatwg.org/\n//\n\n//\n// 3. Terminology\n//\n\n/**\n * End-of-stream is a special token that signifies no more tokens\n * are in the stream.\n * @const\n */ var end_of_stream = -1;\n\n/**\n * A stream represents an ordered sequence of tokens.\n *\n * @constructor\n * @param {!(Array.<number>|Uint8Array)} tokens Array of tokens that provide the\n * stream.\n */\nfunction Stream(tokens) {\n  /** @type {!Array.<number>} */\n  this.tokens = [].slice.call(tokens);\n}\n\nStream.prototype = {\n  /**\n   * @return {boolean} True if end-of-stream has been hit.\n   */\n  endOfStream: function() {\n    return !this.tokens.length;\n  },\n\n  /**\n   * When a token is read from a stream, the first token in the\n   * stream must be returned and subsequently removed, and\n   * end-of-stream must be returned otherwise.\n   *\n   * @return {number} Get the next token from the stream, or\n   * end_of_stream.\n   */\n   read: function() {\n    if (!this.tokens.length)\n      return end_of_stream;\n     return this.tokens.shift();\n   },\n\n  /**\n   * When one or more tokens are prepended to a stream, those tokens\n   * must be inserted, in given order, before the first token in the\n   * stream.\n   *\n   * @param {(number|!Array.<number>)} token The token(s) to prepend to the stream.\n   */\n  prepend: function(token) {\n    if (Array.isArray(token)) {\n      var tokens = /**@type {!Array.<number>}*/(token);\n      while (tokens.length)\n        this.tokens.unshift(tokens.pop());\n    } else {\n      this.tokens.unshift(token);\n    }\n  },\n\n  /**\n   * When one or more tokens are pushed to a stream, those tokens\n   * must be inserted, in given order, after the last token in the\n   * stream.\n   *\n   * @param {(number|!Array.<number>)} token The tokens(s) to prepend to the stream.\n   */\n  push: function(token) {\n    if (Array.isArray(token)) {\n      var tokens = /**@type {!Array.<number>}*/(token);\n      while (tokens.length)\n        this.tokens.push(tokens.shift());\n    } else {\n      this.tokens.push(token);\n    }\n  }\n};\n\n//\n// 4. Encodings\n//\n\n// 4.1 Encoders and decoders\n\n/** @const */\nvar finished = -1;\n\n/**\n * @param {boolean} fatal If true, decoding errors raise an exception.\n * @param {number=} opt_code_point Override the standard fallback code point.\n * @return {number} The code point to insert on a decoding error.\n */\nfunction decoderError(fatal, opt_code_point) {\n  if (fatal)\n    throw TypeError('Decoder error');\n  return opt_code_point || 0xFFFD;\n}\n\n/** @interface */\nfunction Decoder() {}\nDecoder.prototype = {\n  /**\n   * @param {Stream} stream The stream of bytes being decoded.\n   * @param {number} bite The next byte read from the stream.\n   * @return {?(number|!Array.<number>)} The next code point(s)\n   *     decoded, or null if not enough data exists in the input\n   *     stream to decode a complete code point, or |finished|.\n   */\n  handler: function(stream, bite) {}\n};\n\n/** @interface */\nfunction Encoder() {}\nEncoder.prototype = {\n  /**\n   * @param {Stream} stream The stream of code points being encoded.\n   * @param {number} code_point Next code point read from the stream.\n   * @return {(number|!Array.<number>)} Byte(s) to emit, or |finished|.\n   */\n  handler: function(stream, code_point) {}\n};\n\n//\n// 7. API\n//\n\n/** @const */ var DEFAULT_ENCODING = 'utf-8';\n\n// 7.1 Interface TextDecoder\n\n/**\n * @constructor\n * @param {string=} encoding The label of the encoding;\n *     defaults to 'utf-8'.\n * @param {Object=} options\n */\nfunction TextDecoder(encoding, options) {\n  if (!(this instanceof TextDecoder)) {\n    return new TextDecoder(encoding, options);\n  }\n  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;\n  if (encoding !== DEFAULT_ENCODING) {\n    throw new Error('Encoding not supported. Only utf-8 is supported');\n  }\n  options = ToDictionary(options);\n\n  /** @private @type {boolean} */\n  this._streaming = false;\n  /** @private @type {boolean} */\n  this._BOMseen = false;\n  /** @private @type {?Decoder} */\n  this._decoder = null;\n  /** @private @type {boolean} */\n  this._fatal = Boolean(options['fatal']);\n  /** @private @type {boolean} */\n  this._ignoreBOM = Boolean(options['ignoreBOM']);\n\n  Object.defineProperty(this, 'encoding', {value: 'utf-8'});\n  Object.defineProperty(this, 'fatal', {value: this._fatal});\n  Object.defineProperty(this, 'ignoreBOM', {value: this._ignoreBOM});\n}\n\nTextDecoder.prototype = {\n  /**\n   * @param {ArrayBufferView=} input The buffer of bytes to decode.\n   * @param {Object=} options\n   * @return {string} The decoded string.\n   */\n  decode: function decode(input, options) {\n    var bytes;\n    if (typeof input === 'object' && input instanceof ArrayBuffer) {\n      bytes = new Uint8Array(input);\n    } else if (typeof input === 'object' && 'buffer' in input &&\n               input.buffer instanceof ArrayBuffer) {\n      bytes = new Uint8Array(input.buffer,\n                             input.byteOffset,\n                             input.byteLength);\n    } else {\n      bytes = new Uint8Array(0);\n    }\n\n    options = ToDictionary(options);\n\n    if (!this._streaming) {\n      this._decoder = new UTF8Decoder({fatal: this._fatal});\n      this._BOMseen = false;\n    }\n    this._streaming = Boolean(options['stream']);\n\n    var input_stream = new Stream(bytes);\n\n    var code_points = [];\n\n    /** @type {?(number|!Array.<number>)} */\n    var result;\n\n    while (!input_stream.endOfStream()) {\n      result = this._decoder.handler(input_stream, input_stream.read());\n      if (result === finished)\n        break;\n      if (result === null)\n        continue;\n      if (Array.isArray(result))\n        code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));\n      else\n        code_points.push(result);\n    }\n    if (!this._streaming) {\n      do {\n        result = this._decoder.handler(input_stream, input_stream.read());\n        if (result === finished)\n          break;\n        if (result === null)\n          continue;\n        if (Array.isArray(result))\n          code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));\n        else\n          code_points.push(result);\n      } while (!input_stream.endOfStream());\n      this._decoder = null;\n    }\n\n    if (code_points.length) {\n      // If encoding is one of utf-8, utf-16be, and utf-16le, and\n      // ignore BOM flag and BOM seen flag are unset, run these\n      // subsubsteps:\n      if (['utf-8'].indexOf(this.encoding) !== -1 &&\n          !this._ignoreBOM && !this._BOMseen) {\n        // If token is U+FEFF, set BOM seen flag.\n        if (code_points[0] === 0xFEFF) {\n          this._BOMseen = true;\n          code_points.shift();\n        } else {\n          // Otherwise, if token is not end-of-stream, set BOM seen\n          // flag and append token to output.\n          this._BOMseen = true;\n        }\n      }\n    }\n\n    return codePointsToString(code_points);\n  }\n};\n\n// 7.2 Interface TextEncoder\n\n/**\n * @constructor\n * @param {string=} encoding The label of the encoding;\n *     defaults to 'utf-8'.\n * @param {Object=} options\n */\nfunction TextEncoder(encoding, options) {\n  if (!(this instanceof TextEncoder))\n    return new TextEncoder(encoding, options);\n  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;\n  if (encoding !== DEFAULT_ENCODING) {\n    throw new Error('Encoding not supported. Only utf-8 is supported');\n  }\n  options = ToDictionary(options);\n\n  /** @private @type {boolean} */\n  this._streaming = false;\n  /** @private @type {?Encoder} */\n  this._encoder = null;\n  /** @private @type {{fatal: boolean}} */\n  this._options = {fatal: Boolean(options['fatal'])};\n\n  Object.defineProperty(this, 'encoding', {value: 'utf-8'});\n}\n\nTextEncoder.prototype = {\n  /**\n   * @param {string=} opt_string The string to encode.\n   * @param {Object=} options\n   * @return {Uint8Array} Encoded bytes, as a Uint8Array.\n   */\n  encode: function encode(opt_string, options) {\n    opt_string = opt_string ? String(opt_string) : '';\n    options = ToDictionary(options);\n\n    // NOTE: This option is nonstandard. None of the encodings\n    // permitted for encoding (i.e. UTF-8, UTF-16) are stateful,\n    // so streaming is not necessary.\n    if (!this._streaming)\n      this._encoder = new UTF8Encoder(this._options);\n    this._streaming = Boolean(options['stream']);\n\n    var bytes = [];\n    var input_stream = new Stream(stringToCodePoints(opt_string));\n    /** @type {?(number|!Array.<number>)} */\n    var result;\n    while (!input_stream.endOfStream()) {\n      result = this._encoder.handler(input_stream, input_stream.read());\n      if (result === finished)\n        break;\n      if (Array.isArray(result))\n        bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));\n      else\n        bytes.push(result);\n    }\n    if (!this._streaming) {\n      while (true) {\n        result = this._encoder.handler(input_stream, input_stream.read());\n        if (result === finished)\n          break;\n        if (Array.isArray(result))\n          bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));\n        else\n          bytes.push(result);\n      }\n      this._encoder = null;\n    }\n    return new Uint8Array(bytes);\n  }\n};\n\n//\n// 8. The encoding\n//\n\n// 8.1 utf-8\n\n/**\n * @constructor\n * @implements {Decoder}\n * @param {{fatal: boolean}} options\n */\nfunction UTF8Decoder(options) {\n  var fatal = options.fatal;\n\n  // utf-8's decoder's has an associated utf-8 code point, utf-8\n  // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8\n  // lower boundary (initially 0x80), and a utf-8 upper boundary\n  // (initially 0xBF).\n  var /** @type {number} */ utf8_code_point = 0,\n      /** @type {number} */ utf8_bytes_seen = 0,\n      /** @type {number} */ utf8_bytes_needed = 0,\n      /** @type {number} */ utf8_lower_boundary = 0x80,\n      /** @type {number} */ utf8_upper_boundary = 0xBF;\n\n  /**\n   * @param {Stream} stream The stream of bytes being decoded.\n   * @param {number} bite The next byte read from the stream.\n   * @return {?(number|!Array.<number>)} The next code point(s)\n   *     decoded, or null if not enough data exists in the input\n   *     stream to decode a complete code point.\n   */\n  this.handler = function(stream, bite) {\n    // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,\n    // set utf-8 bytes needed to 0 and return error.\n    if (bite === end_of_stream && utf8_bytes_needed !== 0) {\n      utf8_bytes_needed = 0;\n      return decoderError(fatal);\n    }\n\n    // 2. If byte is end-of-stream, return finished.\n    if (bite === end_of_stream)\n      return finished;\n\n    // 3. If utf-8 bytes needed is 0, based on byte:\n    if (utf8_bytes_needed === 0) {\n\n      // 0x00 to 0x7F\n      if (inRange(bite, 0x00, 0x7F)) {\n        // Return a code point whose value is byte.\n        return bite;\n      }\n\n      // 0xC2 to 0xDF\n      if (inRange(bite, 0xC2, 0xDF)) {\n        // Set utf-8 bytes needed to 1 and utf-8 code point to byte\n        // − 0xC0.\n        utf8_bytes_needed = 1;\n        utf8_code_point = bite - 0xC0;\n      }\n\n      // 0xE0 to 0xEF\n      else if (inRange(bite, 0xE0, 0xEF)) {\n        // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.\n        if (bite === 0xE0)\n          utf8_lower_boundary = 0xA0;\n        // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.\n        if (bite === 0xED)\n          utf8_upper_boundary = 0x9F;\n        // 3. Set utf-8 bytes needed to 2 and utf-8 code point to\n        // byte − 0xE0.\n        utf8_bytes_needed = 2;\n        utf8_code_point = bite - 0xE0;\n      }\n\n      // 0xF0 to 0xF4\n      else if (inRange(bite, 0xF0, 0xF4)) {\n        // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.\n        if (bite === 0xF0)\n          utf8_lower_boundary = 0x90;\n        // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.\n        if (bite === 0xF4)\n          utf8_upper_boundary = 0x8F;\n        // 3. Set utf-8 bytes needed to 3 and utf-8 code point to\n        // byte − 0xF0.\n        utf8_bytes_needed = 3;\n        utf8_code_point = bite - 0xF0;\n      }\n\n      // Otherwise\n      else {\n        // Return error.\n        return decoderError(fatal);\n      }\n\n      // Then (byte is in the range 0xC2 to 0xF4) set utf-8 code\n      // point to utf-8 code point << (6 × utf-8 bytes needed) and\n      // return continue.\n      utf8_code_point = utf8_code_point << (6 * utf8_bytes_needed);\n      return null;\n    }\n\n    // 4. If byte is not in the range utf-8 lower boundary to utf-8\n    // upper boundary, run these substeps:\n    if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {\n\n      // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8\n      // bytes seen to 0, set utf-8 lower boundary to 0x80, and set\n      // utf-8 upper boundary to 0xBF.\n      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;\n      utf8_lower_boundary = 0x80;\n      utf8_upper_boundary = 0xBF;\n\n      // 2. Prepend byte to stream.\n      stream.prepend(bite);\n\n      // 3. Return error.\n      return decoderError(fatal);\n    }\n\n    // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary\n    // to 0xBF.\n    utf8_lower_boundary = 0x80;\n    utf8_upper_boundary = 0xBF;\n\n    // 6. Increase utf-8 bytes seen by one and set utf-8 code point\n    // to utf-8 code point + (byte − 0x80) << (6 × (utf-8 bytes\n    // needed − utf-8 bytes seen)).\n    utf8_bytes_seen += 1;\n    utf8_code_point += (bite - 0x80) << (6 * (utf8_bytes_needed - utf8_bytes_seen));\n\n    // 7. If utf-8 bytes seen is not equal to utf-8 bytes needed,\n    // continue.\n    if (utf8_bytes_seen !== utf8_bytes_needed)\n      return null;\n\n    // 8. Let code point be utf-8 code point.\n    var code_point = utf8_code_point;\n\n    // 9. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes\n    // seen to 0.\n    utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;\n\n    // 10. Return a code point whose value is code point.\n    return code_point;\n  };\n}\n\n/**\n * @constructor\n * @implements {Encoder}\n * @param {{fatal: boolean}} options\n */\nfunction UTF8Encoder(options) {\n  var fatal = options.fatal;\n  /**\n   * @param {Stream} stream Input stream.\n   * @param {number} code_point Next code point read from the stream.\n   * @return {(number|!Array.<number>)} Byte(s) to emit.\n   */\n  this.handler = function(stream, code_point) {\n    // 1. If code point is end-of-stream, return finished.\n    if (code_point === end_of_stream)\n      return finished;\n\n    // 2. If code point is in the range U+0000 to U+007F, return a\n    // byte whose value is code point.\n    if (inRange(code_point, 0x0000, 0x007f))\n      return code_point;\n\n    // 3. Set count and offset based on the range code point is in:\n    var count, offset;\n    // U+0080 to U+07FF:    1 and 0xC0\n    if (inRange(code_point, 0x0080, 0x07FF)) {\n      count = 1;\n      offset = 0xC0;\n    }\n    // U+0800 to U+FFFF:    2 and 0xE0\n    else if (inRange(code_point, 0x0800, 0xFFFF)) {\n      count = 2;\n      offset = 0xE0;\n    }\n    // U+10000 to U+10FFFF: 3 and 0xF0\n    else if (inRange(code_point, 0x10000, 0x10FFFF)) {\n      count = 3;\n      offset = 0xF0;\n    }\n\n    // 4.Let bytes be a byte sequence whose first byte is (code\n    // point >> (6 × count)) + offset.\n    var bytes = [(code_point >> (6 * count)) + offset];\n\n    // 5. Run these substeps while count is greater than 0:\n    while (count > 0) {\n\n      // 1. Set temp to code point >> (6 × (count − 1)).\n      var temp = code_point >> (6 * (count - 1));\n\n      // 2. Append to bytes 0x80 | (temp & 0x3F).\n      bytes.push(0x80 | (temp & 0x3F));\n\n      // 3. Decrease count by one.\n      count -= 1;\n    }\n\n    // 6. Return bytes bytes, in order.\n    return bytes;\n  };\n}\n\nexport {TextEncoder, TextDecoder};\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/* tslint:disable:class-name */\n\n// automatically generated by the FlatBuffers compiler, do not modify\n\nimport { flatbuffers } from 'flatbuffers';\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum MetadataVersion {\n        /**\n         * 0.1.0\n         */\n        V1 = 0,\n\n        /**\n         * 0.2.0\n         */\n        V2 = 1,\n\n        /**\n         * 0.3.0 -> 0.7.1\n         */\n        V3 = 2,\n\n        /**\n         * >= 0.8.0\n         */\n        V4 = 3\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum UnionMode {\n        Sparse = 0,\n        Dense = 1\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum Precision {\n        HALF = 0,\n        SINGLE = 1,\n        DOUBLE = 2\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum DateUnit {\n        DAY = 0,\n        MILLISECOND = 1\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum TimeUnit {\n        SECOND = 0,\n        MILLISECOND = 1,\n        MICROSECOND = 2,\n        NANOSECOND = 3\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum IntervalUnit {\n        YEAR_MONTH = 0,\n        DAY_TIME = 1\n    }\n}\n\n/**\n * ----------------------------------------------------------------------\n * Top-level Type value, enabling extensible type-specific metadata. We can\n * add new logical types to Type without breaking backwards compatibility\n *\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum Type {\n        NONE = 0,\n        Null = 1,\n        Int = 2,\n        FloatingPoint = 3,\n        Binary = 4,\n        Utf8 = 5,\n        Bool = 6,\n        Decimal = 7,\n        Date = 8,\n        Time = 9,\n        Timestamp = 10,\n        Interval = 11,\n        List = 12,\n        Struct_ = 13,\n        Union = 14,\n        FixedSizeBinary = 15,\n        FixedSizeList = 16,\n        Map = 17,\n        Duration = 18,\n        LargeBinary = 19,\n        LargeUtf8 = 20,\n        LargeList = 21\n    }\n}\n\n/**\n * ----------------------------------------------------------------------\n * Endianness of the platform producing the data\n *\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum Endianness {\n        Little = 0,\n        Big = 1\n    }\n}\n\n/**\n * These are stored in the flatbuffer in the Type union below\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Null {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Null\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Null {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Null= obj\n         * @returns Null\n         */\n        static getRootAsNull(bb: flatbuffers.ByteBuffer, obj?: Null): Null {\n            return (obj || new Null).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startNull(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endNull(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createNull(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Null.startNull(builder);\n            return Null.endNull(builder);\n        }\n    }\n}\n/**\n * A Struct_ in the flatbuffer metadata is the same as an Arrow Struct\n * (according to the physical memory layout). We used Struct_ here as\n * Struct is a reserved word in Flatbuffers\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Struct_ {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Struct_\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Struct_ {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Struct_= obj\n         * @returns Struct_\n         */\n        static getRootAsStruct_(bb: flatbuffers.ByteBuffer, obj?: Struct_): Struct_ {\n            return (obj || new Struct_).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startStruct_(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endStruct_(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createStruct_(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Struct_.startStruct_(builder);\n            return Struct_.endStruct_(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class List {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns List\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): List {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param List= obj\n         * @returns List\n         */\n        static getRootAsList(bb: flatbuffers.ByteBuffer, obj?: List): List {\n            return (obj || new List).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startList(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            List.startList(builder);\n            return List.endList(builder);\n        }\n    }\n}\n/**\n * Same as List, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class LargeList {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns LargeList\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): LargeList {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param LargeList= obj\n         * @returns LargeList\n         */\n        static getRootAsLargeList(bb: flatbuffers.ByteBuffer, obj?: LargeList): LargeList {\n            return (obj || new LargeList).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startLargeList(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endLargeList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createLargeList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            LargeList.startLargeList(builder);\n            return LargeList.endLargeList(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FixedSizeList {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FixedSizeList\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FixedSizeList {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param FixedSizeList= obj\n         * @returns FixedSizeList\n         */\n        static getRootAsFixedSizeList(bb: flatbuffers.ByteBuffer, obj?: FixedSizeList): FixedSizeList {\n            return (obj || new FixedSizeList).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Number of list items per value\n         *\n         * @returns number\n         */\n        listSize(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFixedSizeList(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number listSize\n         */\n        static addListSize(builder: flatbuffers.Builder, listSize: number) {\n            builder.addFieldInt32(0, listSize, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFixedSizeList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createFixedSizeList(builder: flatbuffers.Builder, listSize: number): flatbuffers.Offset {\n            FixedSizeList.startFixedSizeList(builder);\n            FixedSizeList.addListSize(builder, listSize);\n            return FixedSizeList.endFixedSizeList(builder);\n        }\n    }\n}\n/**\n * A Map is a logical nested type that is represented as\n *\n * List<entry: Struct<key: K, value: V>>\n *\n * In this layout, the keys and values are each respectively contiguous. We do\n * not constrain the key and value types, so the application is responsible\n * for ensuring that the keys are hashable and unique. Whether the keys are sorted\n * may be set in the metadata for this field\n *\n * In a Field with Map type, the Field has a child Struct field, which then\n * has two children: key type and the second the value type. The names of the\n * child fields may be respectively \"entry\", \"key\", and \"value\", but this is\n * not enforced\n *\n * Map\n *   - child[0] entry: Struct\n *     - child[0] key: K\n *     - child[1] value: V\n *\n * Neither the \"entry\" field nor the \"key\" field may be nullable.\n *\n * The metadata is structured so that Arrow systems without special handling\n * for Map can make Map an alias for List. The \"layout\" attribute for the Map\n * field must have the same contents as a List.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Map {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Map\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Map {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Map= obj\n         * @returns Map\n         */\n        static getRootAsMap(bb: flatbuffers.ByteBuffer, obj?: Map): Map {\n            return (obj || new Map).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Set to true if the keys within each value are sorted\n         *\n         * @returns boolean\n         */\n        keysSorted(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startMap(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean keysSorted\n         */\n        static addKeysSorted(builder: flatbuffers.Builder, keysSorted: boolean) {\n            builder.addFieldInt8(0, +keysSorted, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endMap(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createMap(builder: flatbuffers.Builder, keysSorted: boolean): flatbuffers.Offset {\n            Map.startMap(builder);\n            Map.addKeysSorted(builder, keysSorted);\n            return Map.endMap(builder);\n        }\n    }\n}\n/**\n * A union is a complex type with children in Field\n * By default ids in the type vector refer to the offsets in the children\n * optionally typeIds provides an indirection between the child offset and the type id\n * for each child typeIds[offset] is the id used in the type vector\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Union {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Union\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Union {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Union= obj\n         * @returns Union\n         */\n        static getRootAsUnion(bb: flatbuffers.ByteBuffer, obj?: Union): Union {\n            return (obj || new Union).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.UnionMode\n         */\n        mode(): org.apache.arrow.flatbuf.UnionMode {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.UnionMode.Sparse;\n        }\n\n        /**\n         * @param number index\n         * @returns number\n         */\n        typeIds(index: number): number | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.readInt32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;\n        }\n\n        /**\n         * @returns number\n         */\n        typeIdsLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @returns Int32Array\n         */\n        typeIdsArray(): Int32Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? new Int32Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startUnion(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.UnionMode mode\n         */\n        static addMode(builder: flatbuffers.Builder, mode: org.apache.arrow.flatbuf.UnionMode) {\n            builder.addFieldInt16(0, mode, org.apache.arrow.flatbuf.UnionMode.Sparse);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset typeIdsOffset\n         */\n        static addTypeIds(builder: flatbuffers.Builder, typeIdsOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, typeIdsOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<number> data\n         * @returns flatbuffers.Offset\n         */\n        static createTypeIdsVector(builder: flatbuffers.Builder, data: number[] | Int32Array): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addInt32(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startTypeIdsVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endUnion(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createUnion(builder: flatbuffers.Builder, mode: org.apache.arrow.flatbuf.UnionMode, typeIdsOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Union.startUnion(builder);\n            Union.addMode(builder, mode);\n            Union.addTypeIds(builder, typeIdsOffset);\n            return Union.endUnion(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Int {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Int\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Int {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Int= obj\n         * @returns Int\n         */\n        static getRootAsInt(bb: flatbuffers.ByteBuffer, obj?: Int): Int {\n            return (obj || new Int).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns number\n         */\n        bitWidth(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @returns boolean\n         */\n        isSigned(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startInt(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number bitWidth\n         */\n        static addBitWidth(builder: flatbuffers.Builder, bitWidth: number) {\n            builder.addFieldInt32(0, bitWidth, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean isSigned\n         */\n        static addIsSigned(builder: flatbuffers.Builder, isSigned: boolean) {\n            builder.addFieldInt8(1, +isSigned, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endInt(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createInt(builder: flatbuffers.Builder, bitWidth: number, isSigned: boolean): flatbuffers.Offset {\n            Int.startInt(builder);\n            Int.addBitWidth(builder, bitWidth);\n            Int.addIsSigned(builder, isSigned);\n            return Int.endInt(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FloatingPoint {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FloatingPoint\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FloatingPoint {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param FloatingPoint= obj\n         * @returns FloatingPoint\n         */\n        static getRootAsFloatingPoint(bb: flatbuffers.ByteBuffer, obj?: FloatingPoint): FloatingPoint {\n            return (obj || new FloatingPoint).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.Precision\n         */\n        precision(): org.apache.arrow.flatbuf.Precision {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.Precision.HALF;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFloatingPoint(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.Precision precision\n         */\n        static addPrecision(builder: flatbuffers.Builder, precision: org.apache.arrow.flatbuf.Precision) {\n            builder.addFieldInt16(0, precision, org.apache.arrow.flatbuf.Precision.HALF);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFloatingPoint(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createFloatingPoint(builder: flatbuffers.Builder, precision: org.apache.arrow.flatbuf.Precision): flatbuffers.Offset {\n            FloatingPoint.startFloatingPoint(builder);\n            FloatingPoint.addPrecision(builder, precision);\n            return FloatingPoint.endFloatingPoint(builder);\n        }\n    }\n}\n/**\n * Unicode with UTF-8 encoding\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Utf8 {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Utf8\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Utf8 {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Utf8= obj\n         * @returns Utf8\n         */\n        static getRootAsUtf8(bb: flatbuffers.ByteBuffer, obj?: Utf8): Utf8 {\n            return (obj || new Utf8).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startUtf8(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Utf8.startUtf8(builder);\n            return Utf8.endUtf8(builder);\n        }\n    }\n}\n/**\n * Opaque binary data\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Binary {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Binary\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Binary {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Binary= obj\n         * @returns Binary\n         */\n        static getRootAsBinary(bb: flatbuffers.ByteBuffer, obj?: Binary): Binary {\n            return (obj || new Binary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startBinary(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Binary.startBinary(builder);\n            return Binary.endBinary(builder);\n        }\n    }\n}\n/**\n * Same as Utf8, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class LargeUtf8 {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns LargeUtf8\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): LargeUtf8 {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param LargeUtf8= obj\n         * @returns LargeUtf8\n         */\n        static getRootAsLargeUtf8(bb: flatbuffers.ByteBuffer, obj?: LargeUtf8): LargeUtf8 {\n            return (obj || new LargeUtf8).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startLargeUtf8(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endLargeUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createLargeUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            LargeUtf8.startLargeUtf8(builder);\n            return LargeUtf8.endLargeUtf8(builder);\n        }\n    }\n}\n/**\n * Same as Binary, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class LargeBinary {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns LargeBinary\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): LargeBinary {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param LargeBinary= obj\n         * @returns LargeBinary\n         */\n        static getRootAsLargeBinary(bb: flatbuffers.ByteBuffer, obj?: LargeBinary): LargeBinary {\n            return (obj || new LargeBinary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startLargeBinary(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endLargeBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createLargeBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            LargeBinary.startLargeBinary(builder);\n            return LargeBinary.endLargeBinary(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FixedSizeBinary {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FixedSizeBinary\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FixedSizeBinary {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param FixedSizeBinary= obj\n         * @returns FixedSizeBinary\n         */\n        static getRootAsFixedSizeBinary(bb: flatbuffers.ByteBuffer, obj?: FixedSizeBinary): FixedSizeBinary {\n            return (obj || new FixedSizeBinary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Number of bytes per value\n         *\n         * @returns number\n         */\n        byteWidth(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFixedSizeBinary(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number byteWidth\n         */\n        static addByteWidth(builder: flatbuffers.Builder, byteWidth: number) {\n            builder.addFieldInt32(0, byteWidth, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFixedSizeBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createFixedSizeBinary(builder: flatbuffers.Builder, byteWidth: number): flatbuffers.Offset {\n            FixedSizeBinary.startFixedSizeBinary(builder);\n            FixedSizeBinary.addByteWidth(builder, byteWidth);\n            return FixedSizeBinary.endFixedSizeBinary(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Bool {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Bool\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Bool {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Bool= obj\n         * @returns Bool\n         */\n        static getRootAsBool(bb: flatbuffers.ByteBuffer, obj?: Bool): Bool {\n            return (obj || new Bool).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startBool(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endBool(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createBool(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Bool.startBool(builder);\n            return Bool.endBool(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Decimal {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Decimal\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Decimal {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Decimal= obj\n         * @returns Decimal\n         */\n        static getRootAsDecimal(bb: flatbuffers.ByteBuffer, obj?: Decimal): Decimal {\n            return (obj || new Decimal).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Total number of decimal digits\n         *\n         * @returns number\n         */\n        precision(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * Number of digits after the decimal point \".\"\n         *\n         * @returns number\n         */\n        scale(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDecimal(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number precision\n         */\n        static addPrecision(builder: flatbuffers.Builder, precision: number) {\n            builder.addFieldInt32(0, precision, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number scale\n         */\n        static addScale(builder: flatbuffers.Builder, scale: number) {\n            builder.addFieldInt32(1, scale, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDecimal(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDecimal(builder: flatbuffers.Builder, precision: number, scale: number): flatbuffers.Offset {\n            Decimal.startDecimal(builder);\n            Decimal.addPrecision(builder, precision);\n            Decimal.addScale(builder, scale);\n            return Decimal.endDecimal(builder);\n        }\n    }\n}\n/**\n * Date is either a 32-bit or 64-bit type representing elapsed time since UNIX\n * epoch (1970-01-01), stored in either of two units:\n *\n * * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no\n *   leap seconds), where the values are evenly divisible by 86400000\n * * Days (32 bits) since the UNIX epoch\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Date {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Date\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Date {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Date= obj\n         * @returns Date\n         */\n        static getRootAsDate(bb: flatbuffers.ByteBuffer, obj?: Date): Date {\n            return (obj || new Date).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.DateUnit\n         */\n        unit(): org.apache.arrow.flatbuf.DateUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.DateUnit.MILLISECOND;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDate(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.DateUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.DateUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.DateUnit.MILLISECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDate(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDate(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.DateUnit): flatbuffers.Offset {\n            Date.startDate(builder);\n            Date.addUnit(builder, unit);\n            return Date.endDate(builder);\n        }\n    }\n}\n/**\n * Time type. The physical storage type depends on the unit\n * - SECOND and MILLISECOND: 32 bits\n * - MICROSECOND and NANOSECOND: 64 bits\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Time {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Time\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Time {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Time= obj\n         * @returns Time\n         */\n        static getRootAsTime(bb: flatbuffers.ByteBuffer, obj?: Time): Time {\n            return (obj || new Time).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.TimeUnit\n         */\n        unit(): org.apache.arrow.flatbuf.TimeUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.TimeUnit.MILLISECOND;\n        }\n\n        /**\n         * @returns number\n         */\n        bitWidth(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 32;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startTime(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.TimeUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.MILLISECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number bitWidth\n         */\n        static addBitWidth(builder: flatbuffers.Builder, bitWidth: number) {\n            builder.addFieldInt32(1, bitWidth, 32);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endTime(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createTime(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit, bitWidth: number): flatbuffers.Offset {\n            Time.startTime(builder);\n            Time.addUnit(builder, unit);\n            Time.addBitWidth(builder, bitWidth);\n            return Time.endTime(builder);\n        }\n    }\n}\n/**\n * Time elapsed from the Unix epoch, 00:00:00.000 on 1 January 1970, excluding\n * leap seconds, as a 64-bit integer. Note that UNIX time does not include\n * leap seconds.\n *\n * The Timestamp metadata supports both \"time zone naive\" and \"time zone\n * aware\" timestamps. Read about the timezone attribute for more detail\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Timestamp {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Timestamp\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Timestamp {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Timestamp= obj\n         * @returns Timestamp\n         */\n        static getRootAsTimestamp(bb: flatbuffers.ByteBuffer, obj?: Timestamp): Timestamp {\n            return (obj || new Timestamp).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.TimeUnit\n         */\n        unit(): org.apache.arrow.flatbuf.TimeUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.TimeUnit.SECOND;\n        }\n\n        /**\n         * The time zone is a string indicating the name of a time zone, one of:\n         *\n         * * As used in the Olson time zone database (the \"tz database\" or\n         *   \"tzdata\"), such as \"America/New_York\"\n         * * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30\n         *\n         * Whether a timezone string is present indicates different semantics about\n         * the data:\n         *\n         * * If the time zone is null or equal to an empty string, the data is \"time\n         *   zone naive\" and shall be displayed *as is* to the user, not localized\n         *   to the locale of the user. This data can be though of as UTC but\n         *   without having \"UTC\" as the time zone, it is not considered to be\n         *   localized to any time zone\n         *\n         * * If the time zone is set to a valid value, values can be displayed as\n         *   \"localized\" to that time zone, even though the underlying 64-bit\n         *   integers are identical to the same data stored in UTC. Converting\n         *   between time zones is a metadata-only operation and does not change the\n         *   underlying values\n         *\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        timezone(): string | null;\n        timezone(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        timezone(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startTimestamp(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.TimeUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.SECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset timezoneOffset\n         */\n        static addTimezone(builder: flatbuffers.Builder, timezoneOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, timezoneOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endTimestamp(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createTimestamp(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit, timezoneOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Timestamp.startTimestamp(builder);\n            Timestamp.addUnit(builder, unit);\n            Timestamp.addTimezone(builder, timezoneOffset);\n            return Timestamp.endTimestamp(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Interval {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Interval\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Interval {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Interval= obj\n         * @returns Interval\n         */\n        static getRootAsInterval(bb: flatbuffers.ByteBuffer, obj?: Interval): Interval {\n            return (obj || new Interval).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.IntervalUnit\n         */\n        unit(): org.apache.arrow.flatbuf.IntervalUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.IntervalUnit.YEAR_MONTH;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startInterval(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.IntervalUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.IntervalUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.IntervalUnit.YEAR_MONTH);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endInterval(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createInterval(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.IntervalUnit): flatbuffers.Offset {\n            Interval.startInterval(builder);\n            Interval.addUnit(builder, unit);\n            return Interval.endInterval(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Duration {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Duration\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Duration {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Duration= obj\n         * @returns Duration\n         */\n        static getRootAsDuration(bb: flatbuffers.ByteBuffer, obj?: Duration): Duration {\n            return (obj || new Duration).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.TimeUnit\n         */\n        unit(): org.apache.arrow.flatbuf.TimeUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.TimeUnit.MILLISECOND;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDuration(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.TimeUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.MILLISECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDuration(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDuration(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit): flatbuffers.Offset {\n            Duration.startDuration(builder);\n            Duration.addUnit(builder, unit);\n            return Duration.endDuration(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * user defined key value pairs to add custom metadata to arrow\n * key namespacing is the responsibility of the user\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class KeyValue {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns KeyValue\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): KeyValue {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param KeyValue= obj\n         * @returns KeyValue\n         */\n        static getRootAsKeyValue(bb: flatbuffers.ByteBuffer, obj?: KeyValue): KeyValue {\n            return (obj || new KeyValue).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        key(): string | null;\n        key(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        key(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        value(): string | null;\n        value(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        value(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startKeyValue(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset keyOffset\n         */\n        static addKey(builder: flatbuffers.Builder, keyOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(0, keyOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset valueOffset\n         */\n        static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, valueOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endKeyValue(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createKeyValue(builder: flatbuffers.Builder, keyOffset: flatbuffers.Offset, valueOffset: flatbuffers.Offset): flatbuffers.Offset {\n            KeyValue.startKeyValue(builder);\n            KeyValue.addKey(builder, keyOffset);\n            KeyValue.addValue(builder, valueOffset);\n            return KeyValue.endKeyValue(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * Dictionary encoding metadata\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class DictionaryEncoding {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns DictionaryEncoding\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): DictionaryEncoding {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param DictionaryEncoding= obj\n         * @returns DictionaryEncoding\n         */\n        static getRootAsDictionaryEncoding(bb: flatbuffers.ByteBuffer, obj?: DictionaryEncoding): DictionaryEncoding {\n            return (obj || new DictionaryEncoding).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * The known dictionary id in the application where this data is used. In\n         * the file or streaming formats, the dictionary ids are found in the\n         * DictionaryBatch messages\n         *\n         * @returns flatbuffers.Long\n         */\n        id(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * The dictionary indices are constrained to be positive integers. If this\n         * field is null, the indices must be signed int32\n         *\n         * @param org.apache.arrow.flatbuf.Int= obj\n         * @returns org.apache.arrow.flatbuf.Int|null\n         */\n        indexType(obj?: org.apache.arrow.flatbuf.Int): org.apache.arrow.flatbuf.Int | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Int).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * By default, dictionaries are not ordered, or the order does not have\n         * semantic meaning. In some statistical, applications, dictionary-encoding\n         * is used to represent ordered categorical data, and we provide a way to\n         * preserve that metadata here\n         *\n         * @returns boolean\n         */\n        isOrdered(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDictionaryEncoding(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long id\n         */\n        static addId(builder: flatbuffers.Builder, id: flatbuffers.Long) {\n            builder.addFieldInt64(0, id, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset indexTypeOffset\n         */\n        static addIndexType(builder: flatbuffers.Builder, indexTypeOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, indexTypeOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean isOrdered\n         */\n        static addIsOrdered(builder: flatbuffers.Builder, isOrdered: boolean) {\n            builder.addFieldInt8(2, +isOrdered, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDictionaryEncoding(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDictionaryEncoding(builder: flatbuffers.Builder, id: flatbuffers.Long, indexTypeOffset: flatbuffers.Offset, isOrdered: boolean): flatbuffers.Offset {\n            DictionaryEncoding.startDictionaryEncoding(builder);\n            DictionaryEncoding.addId(builder, id);\n            DictionaryEncoding.addIndexType(builder, indexTypeOffset);\n            DictionaryEncoding.addIsOrdered(builder, isOrdered);\n            return DictionaryEncoding.endDictionaryEncoding(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * A field represents a named column in a record / row batch or child of a\n * nested type.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Field {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Field\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Field {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Field= obj\n         * @returns Field\n         */\n        static getRootAsField(bb: flatbuffers.ByteBuffer, obj?: Field): Field {\n            return (obj || new Field).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Name is not required, in i.e. a List\n         *\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        name(): string | null;\n        name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        name(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * Whether or not this field can contain nulls. Should be true in general.\n         *\n         * @returns boolean\n         */\n        nullable(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.Type\n         */\n        typeType(): org.apache.arrow.flatbuf.Type {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? /**  */ (this.bb!.readUint8(this.bb_pos + offset)) : org.apache.arrow.flatbuf.Type.NONE;\n        }\n\n        /**\n         * This is the type of the decoded value if the field is dictionary encoded.\n         *\n         * @param flatbuffers.Table obj\n         * @returns ?flatbuffers.Table\n         */\n        type<T extends flatbuffers.Table>(obj: T): T | null {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;\n        }\n\n        /**\n         * Present only if the field is dictionary encoded.\n         *\n         * @param org.apache.arrow.flatbuf.DictionaryEncoding= obj\n         * @returns org.apache.arrow.flatbuf.DictionaryEncoding|null\n         */\n        dictionary(obj?: org.apache.arrow.flatbuf.DictionaryEncoding): org.apache.arrow.flatbuf.DictionaryEncoding | null {\n            let offset = this.bb!.__offset(this.bb_pos, 12);\n            return offset ? (obj || new org.apache.arrow.flatbuf.DictionaryEncoding).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * children apply only to nested data types like Struct, List and Union. For\n         * primitive types children will have length 0.\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Field= obj\n         * @returns org.apache.arrow.flatbuf.Field\n         */\n        children(index: number, obj?: org.apache.arrow.flatbuf.Field): org.apache.arrow.flatbuf.Field | null {\n            let offset = this.bb!.__offset(this.bb_pos, 14);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Field).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        childrenLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 14);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * User-defined metadata\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.KeyValue= obj\n         * @returns org.apache.arrow.flatbuf.KeyValue\n         */\n        customMetadata(index: number, obj?: org.apache.arrow.flatbuf.KeyValue): org.apache.arrow.flatbuf.KeyValue | null {\n            let offset = this.bb!.__offset(this.bb_pos, 16);\n            return offset ? (obj || new org.apache.arrow.flatbuf.KeyValue).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        customMetadataLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 16);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startField(builder: flatbuffers.Builder) {\n            builder.startObject(7);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset nameOffset\n         */\n        static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(0, nameOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean nullable\n         */\n        static addNullable(builder: flatbuffers.Builder, nullable: boolean) {\n            builder.addFieldInt8(1, +nullable, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.Type typeType\n         */\n        static addTypeType(builder: flatbuffers.Builder, typeType: org.apache.arrow.flatbuf.Type) {\n            builder.addFieldInt8(2, typeType, org.apache.arrow.flatbuf.Type.NONE);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset typeOffset\n         */\n        static addType(builder: flatbuffers.Builder, typeOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(3, typeOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset dictionaryOffset\n         */\n        static addDictionary(builder: flatbuffers.Builder, dictionaryOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(4, dictionaryOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset childrenOffset\n         */\n        static addChildren(builder: flatbuffers.Builder, childrenOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(5, childrenOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createChildrenVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startChildrenVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset customMetadataOffset\n         */\n        static addCustomMetadata(builder: flatbuffers.Builder, customMetadataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(6, customMetadataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createCustomMetadataVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startCustomMetadataVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endField(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createField(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset, nullable: boolean, typeType: org.apache.arrow.flatbuf.Type, typeOffset: flatbuffers.Offset, dictionaryOffset: flatbuffers.Offset, childrenOffset: flatbuffers.Offset, customMetadataOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Field.startField(builder);\n            Field.addName(builder, nameOffset);\n            Field.addNullable(builder, nullable);\n            Field.addTypeType(builder, typeType);\n            Field.addType(builder, typeOffset);\n            Field.addDictionary(builder, dictionaryOffset);\n            Field.addChildren(builder, childrenOffset);\n            Field.addCustomMetadata(builder, customMetadataOffset);\n            return Field.endField(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * A Buffer represents a single contiguous memory segment\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Buffer {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Buffer\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Buffer {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * The relative offset into the shared memory page where the bytes for this\n         * buffer starts\n         *\n         * @returns flatbuffers.Long\n         */\n        offset(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos);\n        }\n\n        /**\n         * The absolute length (in bytes) of the memory buffer. The memory is found\n         * from offset (inclusive) to offset + length (non-inclusive).\n         *\n         * @returns flatbuffers.Long\n         */\n        length(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos + 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long offset\n         * @param flatbuffers.Long length\n         * @returns flatbuffers.Offset\n         */\n        static createBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Long, length: flatbuffers.Long): flatbuffers.Offset {\n            builder.prep(8, 16);\n            builder.writeInt64(length);\n            builder.writeInt64(offset);\n            return builder.offset();\n        }\n\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * A Schema describes the columns in a row batch\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Schema {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Schema\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Schema {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Schema= obj\n         * @returns Schema\n         */\n        static getRootAsSchema(bb: flatbuffers.ByteBuffer, obj?: Schema): Schema {\n            return (obj || new Schema).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * endianness of the buffer\n         * it is Little Endian by default\n         * if endianness doesn't match the underlying system then the vectors need to be converted\n         *\n         * @returns org.apache.arrow.flatbuf.Endianness\n         */\n        endianness(): org.apache.arrow.flatbuf.Endianness {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.Endianness.Little;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Field= obj\n         * @returns org.apache.arrow.flatbuf.Field\n         */\n        fields(index: number, obj?: org.apache.arrow.flatbuf.Field): org.apache.arrow.flatbuf.Field | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Field).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        fieldsLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.KeyValue= obj\n         * @returns org.apache.arrow.flatbuf.KeyValue\n         */\n        customMetadata(index: number, obj?: org.apache.arrow.flatbuf.KeyValue): org.apache.arrow.flatbuf.KeyValue | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? (obj || new org.apache.arrow.flatbuf.KeyValue).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        customMetadataLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startSchema(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.Endianness endianness\n         */\n        static addEndianness(builder: flatbuffers.Builder, endianness: org.apache.arrow.flatbuf.Endianness) {\n            builder.addFieldInt16(0, endianness, org.apache.arrow.flatbuf.Endianness.Little);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset fieldsOffset\n         */\n        static addFields(builder: flatbuffers.Builder, fieldsOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, fieldsOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createFieldsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startFieldsVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset customMetadataOffset\n         */\n        static addCustomMetadata(builder: flatbuffers.Builder, customMetadataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, customMetadataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createCustomMetadataVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startCustomMetadataVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endSchema(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset offset\n         */\n        static finishSchemaBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n            builder.finish(offset);\n        }\n\n        static createSchema(builder: flatbuffers.Builder, endianness: org.apache.arrow.flatbuf.Endianness, fieldsOffset: flatbuffers.Offset, customMetadataOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Schema.startSchema(builder);\n            Schema.addEndianness(builder, endianness);\n            Schema.addFields(builder, fieldsOffset);\n            Schema.addCustomMetadata(builder, customMetadataOffset);\n            return Schema.endSchema(builder);\n        }\n    }\n}\n","// automatically generated by the FlatBuffers compiler, do not modify\n\nimport { flatbuffers } from 'flatbuffers';\nimport * as NS7624605610262437867 from './Schema';\nexport namespace org.apache.arrow.flatbuf {\n    export import Schema = NS7624605610262437867.org.apache.arrow.flatbuf.Schema;\n}\n/**\n * ----------------------------------------------------------------------\n * The root Message type\n * This union enables us to easily send different message types without\n * redundant storage, and in the future we can easily add new message types.\n *\n * Arrow implementations do not need to implement all of the message types,\n * which may include experimental metadata types. For maximum compatibility,\n * it is best to send data using RecordBatch\n *\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum MessageHeader {\n        NONE = 0,\n        Schema = 1,\n        DictionaryBatch = 2,\n        RecordBatch = 3,\n        Tensor = 4,\n        SparseTensor = 5\n    }\n}\n\n/**\n * ----------------------------------------------------------------------\n * Data structures for describing a table row batch (a collection of\n * equal-length Arrow arrays)\n * Metadata about a field at some level of a nested type tree (but not\n * its children).\n *\n * For example, a List<Int16> with values [[1, 2, 3], null, [4], [5, 6], null]\n * would have {length: 5, null_count: 2} for its List node, and {length: 6,\n * null_count: 0} for its Int16 node, as separate FieldNode structs\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FieldNode {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FieldNode\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FieldNode {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * The number of value slots in the Arrow array at this level of a nested\n         * tree\n         *\n         * @returns flatbuffers.Long\n         */\n        length(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos);\n        }\n\n        /**\n         * The number of observed nulls. Fields with null_count == 0 may choose not\n         * to write their physical validity bitmap out as a materialized buffer,\n         * instead setting the length of the bitmap buffer to 0.\n         *\n         * @returns flatbuffers.Long\n         */\n        nullCount(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos + 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long length\n         * @param flatbuffers.Long null_count\n         * @returns flatbuffers.Offset\n         */\n        static createFieldNode(builder: flatbuffers.Builder, length: flatbuffers.Long, null_count: flatbuffers.Long): flatbuffers.Offset {\n            builder.prep(8, 16);\n            builder.writeInt64(null_count);\n            builder.writeInt64(length);\n            return builder.offset();\n        }\n\n    }\n}\n/**\n * A data header describing the shared memory layout of a \"record\" or \"row\"\n * batch. Some systems call this a \"row batch\" internally and others a \"record\n * batch\".\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class RecordBatch {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns RecordBatch\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): RecordBatch {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param RecordBatch= obj\n         * @returns RecordBatch\n         */\n        static getRootAsRecordBatch(bb: flatbuffers.ByteBuffer, obj?: RecordBatch): RecordBatch {\n            return (obj || new RecordBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * number of records / rows. The arrays in the batch should all have this\n         * length\n         *\n         * @returns flatbuffers.Long\n         */\n        length(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * Nodes correspond to the pre-ordered flattened logical schema\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.FieldNode= obj\n         * @returns org.apache.arrow.flatbuf.FieldNode\n         */\n        nodes(index: number, obj?: org.apache.arrow.flatbuf.FieldNode): org.apache.arrow.flatbuf.FieldNode | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.FieldNode).__init(this.bb!.__vector(this.bb_pos + offset) + index * 16, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        nodesLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * Buffers correspond to the pre-ordered flattened buffer tree\n         *\n         * The number of buffers appended to this list depends on the schema. For\n         * example, most primitive arrays will have 2 buffers, 1 for the validity\n         * bitmap and 1 for the values. For struct arrays, there will only be a\n         * single buffer for the validity (nulls) bitmap\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Buffer= obj\n         * @returns org.apache.arrow.flatbuf.Buffer\n         */\n        buffers(index: number, obj?: NS7624605610262437867.org.apache.arrow.flatbuf.Buffer): NS7624605610262437867.org.apache.arrow.flatbuf.Buffer | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? (obj || new NS7624605610262437867.org.apache.arrow.flatbuf.Buffer).__init(this.bb!.__vector(this.bb_pos + offset) + index * 16, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        buffersLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startRecordBatch(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long length\n         */\n        static addLength(builder: flatbuffers.Builder, length: flatbuffers.Long) {\n            builder.addFieldInt64(0, length, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset nodesOffset\n         */\n        static addNodes(builder: flatbuffers.Builder, nodesOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, nodesOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startNodesVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(16, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset buffersOffset\n         */\n        static addBuffers(builder: flatbuffers.Builder, buffersOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, buffersOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startBuffersVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(16, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endRecordBatch(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createRecordBatch(builder: flatbuffers.Builder, length: flatbuffers.Long, nodesOffset: flatbuffers.Offset, buffersOffset: flatbuffers.Offset): flatbuffers.Offset {\n            RecordBatch.startRecordBatch(builder);\n            RecordBatch.addLength(builder, length);\n            RecordBatch.addNodes(builder, nodesOffset);\n            RecordBatch.addBuffers(builder, buffersOffset);\n            return RecordBatch.endRecordBatch(builder);\n        }\n    }\n}\n/**\n * For sending dictionary encoding information. Any Field can be\n * dictionary-encoded, but in this case none of its children may be\n * dictionary-encoded.\n * There is one vector / column per dictionary, but that vector / column\n * may be spread across multiple dictionary batches by using the isDelta\n * flag\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class DictionaryBatch {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns DictionaryBatch\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): DictionaryBatch {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param DictionaryBatch= obj\n         * @returns DictionaryBatch\n         */\n        static getRootAsDictionaryBatch(bb: flatbuffers.ByteBuffer, obj?: DictionaryBatch): DictionaryBatch {\n            return (obj || new DictionaryBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns flatbuffers.Long\n         */\n        id(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * @param org.apache.arrow.flatbuf.RecordBatch= obj\n         * @returns org.apache.arrow.flatbuf.RecordBatch|null\n         */\n        data(obj?: org.apache.arrow.flatbuf.RecordBatch): org.apache.arrow.flatbuf.RecordBatch | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.RecordBatch).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * If isDelta is true the values in the dictionary are to be appended to a\n         * dictionary with the indicated id\n         *\n         * @returns boolean\n         */\n        isDelta(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDictionaryBatch(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long id\n         */\n        static addId(builder: flatbuffers.Builder, id: flatbuffers.Long) {\n            builder.addFieldInt64(0, id, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset dataOffset\n         */\n        static addData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, dataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean isDelta\n         */\n        static addIsDelta(builder: flatbuffers.Builder, isDelta: boolean) {\n            builder.addFieldInt8(2, +isDelta, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDictionaryBatch(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDictionaryBatch(builder: flatbuffers.Builder, id: flatbuffers.Long, dataOffset: flatbuffers.Offset, isDelta: boolean): flatbuffers.Offset {\n            DictionaryBatch.startDictionaryBatch(builder);\n            DictionaryBatch.addId(builder, id);\n            DictionaryBatch.addData(builder, dataOffset);\n            DictionaryBatch.addIsDelta(builder, isDelta);\n            return DictionaryBatch.endDictionaryBatch(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Message {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Message\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Message {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Message= obj\n         * @returns Message\n         */\n        static getRootAsMessage(bb: flatbuffers.ByteBuffer, obj?: Message): Message {\n            return (obj || new Message).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.MetadataVersion\n         */\n        version(): NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1;\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.MessageHeader\n         */\n        headerType(): org.apache.arrow.flatbuf.MessageHeader {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? /**  */ (this.bb!.readUint8(this.bb_pos + offset)) : org.apache.arrow.flatbuf.MessageHeader.NONE;\n        }\n\n        /**\n         * @param flatbuffers.Table obj\n         * @returns ?flatbuffers.Table\n         */\n        header<T extends flatbuffers.Table>(obj: T): T | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;\n        }\n\n        /**\n         * @returns flatbuffers.Long\n         */\n        bodyLength(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.KeyValue= obj\n         * @returns org.apache.arrow.flatbuf.KeyValue\n         */\n        customMetadata(index: number, obj?: NS7624605610262437867.org.apache.arrow.flatbuf.KeyValue): NS7624605610262437867.org.apache.arrow.flatbuf.KeyValue | null {\n            let offset = this.bb!.__offset(this.bb_pos, 12);\n            return offset ? (obj || new NS7624605610262437867.org.apache.arrow.flatbuf.KeyValue).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        customMetadataLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 12);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startMessage(builder: flatbuffers.Builder) {\n            builder.startObject(5);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.MetadataVersion version\n         */\n        static addVersion(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion) {\n            builder.addFieldInt16(0, version, NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.MessageHeader headerType\n         */\n        static addHeaderType(builder: flatbuffers.Builder, headerType: org.apache.arrow.flatbuf.MessageHeader) {\n            builder.addFieldInt8(1, headerType, org.apache.arrow.flatbuf.MessageHeader.NONE);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset headerOffset\n         */\n        static addHeader(builder: flatbuffers.Builder, headerOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, headerOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long bodyLength\n         */\n        static addBodyLength(builder: flatbuffers.Builder, bodyLength: flatbuffers.Long) {\n            builder.addFieldInt64(3, bodyLength, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset customMetadataOffset\n         */\n        static addCustomMetadata(builder: flatbuffers.Builder, customMetadataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(4, customMetadataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createCustomMetadataVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startCustomMetadataVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endMessage(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset offset\n         */\n        static finishMessageBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n            builder.finish(offset);\n        }\n\n        static createMessage(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion, headerType: org.apache.arrow.flatbuf.MessageHeader, headerOffset: flatbuffers.Offset, bodyLength: flatbuffers.Long, customMetadataOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Message.startMessage(builder);\n            Message.addVersion(builder, version);\n            Message.addHeaderType(builder, headerType);\n            Message.addHeader(builder, headerOffset);\n            Message.addBodyLength(builder, bodyLength);\n            Message.addCustomMetadata(builder, customMetadataOffset);\n            return Message.endMessage(builder);\n        }\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { DataType } from './type';\nimport { Chunked } from './vector/chunked';\n\n/** @ignore */\nexport interface Clonable<R extends AbstractVector> {\n    clone(...args: any[]): R;\n}\n\n/** @ignore */\nexport interface Sliceable<R extends AbstractVector> {\n    slice(begin?: number, end?: number): R;\n}\n\n/** @ignore */\nexport interface Applicative<T extends DataType, R extends Chunked> {\n    concat(...others: Vector<T>[]): R;\n    readonly [Symbol.isConcatSpreadable]: boolean;\n}\n\nexport interface AbstractVector<T extends DataType = any>\n    extends Clonable<Vector<T>>,\n            Sliceable<Vector<T>>,\n            Applicative<T, Chunked<T>> {\n\n    readonly TType: T['TType'];\n    readonly TArray: T['TArray'];\n    readonly TValue: T['TValue'];\n}\n\nexport abstract class AbstractVector<T extends DataType = any> implements Iterable<T['TValue'] | null> {\n\n    public abstract readonly data: Data<T>;\n    public abstract readonly type: T;\n    public abstract readonly typeId: T['TType'];\n    public abstract readonly length: number;\n    public abstract readonly stride: number;\n    public abstract readonly nullCount: number;\n    public abstract readonly byteLength: number;\n    public abstract readonly numChildren: number;\n\n    public abstract readonly ArrayType: T['ArrayType'];\n\n    public abstract isValid(index: number): boolean;\n    public abstract get(index: number): T['TValue'] | null;\n    public abstract set(index: number, value: T['TValue'] | null): void;\n    public abstract indexOf(value: T['TValue'] | null, fromIndex?: number): number;\n    public abstract [Symbol.iterator](): IterableIterator<T['TValue'] | null>;\n\n    public abstract toArray(): T['TArray'];\n    public abstract getChildAt<R extends DataType = any>(index: number): Vector<R> | null;\n}\n\nexport { AbstractVector as Vector };\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport * as Schema_ from './fb/Schema';\nimport * as Message_ from './fb/Message';\n\nexport import ArrowType = Schema_.org.apache.arrow.flatbuf.Type;\nexport import DateUnit = Schema_.org.apache.arrow.flatbuf.DateUnit;\nexport import TimeUnit = Schema_.org.apache.arrow.flatbuf.TimeUnit;\nexport import Precision = Schema_.org.apache.arrow.flatbuf.Precision;\nexport import UnionMode = Schema_.org.apache.arrow.flatbuf.UnionMode;\nexport import IntervalUnit = Schema_.org.apache.arrow.flatbuf.IntervalUnit;\nexport import MessageHeader = Message_.org.apache.arrow.flatbuf.MessageHeader;\nexport import MetadataVersion = Schema_.org.apache.arrow.flatbuf.MetadataVersion;\n\n/**\n * Main data type enumeration.\n *\n * Data types in this library are all *logical*. They can be expressed as\n * either a primitive physical type (bytes or bits of some fixed size), a\n * nested type consisting of other data types, or another data type (e.g. a\n * timestamp encoded as an int64).\n *\n * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow\n * IPC payload.\n *\n * The rest of the values are specified here so TypeScript can narrow the type\n * signatures further beyond the base Arrow Types. The Arrow DataTypes include\n * metadata like `bitWidth` that impact the type signatures of the values we\n * accept and return.\n *\n * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an\n * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`\n * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the\n * underlying `Int32Array`.\n *\n * Library consumers benefit by knowing the narrowest type, since we can ensure\n * the types across all public methods are propagated, and never bail to `any`.\n * These values are _never_ used at runtime, and they will _never_ be written\n * to the flatbuffers metadata of serialized Arrow IPC payloads.\n */\nexport enum Type {\n    /** The default placeholder type */\n    NONE            =  0,\n    /** A NULL type having no physical storage */\n    Null            =  1,\n    /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */\n    Int             =  2,\n    /** 2, 4, or 8-byte floating point value */\n    Float           =  3,\n    /** Variable-length bytes (no guarantee of UTF8-ness) */\n    Binary          =  4,\n    /** UTF8 variable-length string as List<Char> */\n    Utf8            =  5,\n    /** Boolean as 1 bit, LSB bit-packed ordering */\n    Bool            =  6,\n    /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */\n    Decimal         =  7,\n    /** int32_t days or int64_t milliseconds since the UNIX epoch */\n    Date            =  8,\n    /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */\n    Time            =  9,\n    /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */\n    Timestamp       = 10,\n    /** YEAR_MONTH or DAY_TIME interval in SQL style */\n    Interval        = 11,\n    /** A list of some logical data type */\n    List            = 12,\n    /** Struct of logical types */\n    Struct          = 13,\n    /** Union of logical types */\n    Union           = 14,\n    /** Fixed-size binary. Each value occupies the same number of bytes */\n    FixedSizeBinary = 15,\n    /** Fixed-size list. Each value occupies the same number of bytes */\n    FixedSizeList   = 16,\n    /** Map of named logical types */\n    Map             = 17,\n\n    /** Dictionary aka Category type */\n    Dictionary            = -1,\n    Int8                  = -2,\n    Int16                 = -3,\n    Int32                 = -4,\n    Int64                 = -5,\n    Uint8                 = -6,\n    Uint16                = -7,\n    Uint32                = -8,\n    Uint64                = -9,\n    Float16               = -10,\n    Float32               = -11,\n    Float64               = -12,\n    DateDay               = -13,\n    DateMillisecond       = -14,\n    TimestampSecond       = -15,\n    TimestampMillisecond  = -16,\n    TimestampMicrosecond  = -17,\n    TimestampNanosecond   = -18,\n    TimeSecond            = -19,\n    TimeMillisecond       = -20,\n    TimeMicrosecond       = -21,\n    TimeNanosecond        = -22,\n    DenseUnion            = -23,\n    SparseUnion           = -24,\n    IntervalDayTime       = -25,\n    IntervalYearMonth     = -26,\n}\n\nexport enum BufferType {\n    /**\n     * used in List type, Dense Union and variable length primitive types (String, Binary)\n     */\n    OFFSET = 0,\n\n    /**\n     * actual data, either wixed width primitive types in slots or variable width delimited by an OFFSET vector\n     */\n    DATA = 1,\n\n    /**\n     * Bit vector indicating if each value is null\n     */\n    VALIDITY = 2,\n\n    /**\n     * Type vector used in Union type\n     */\n    TYPE = 3\n  }\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nexport function getBool(_data: any, _index: number, byte: number, bit: number) {\n    return (byte & 1 << bit) !== 0;\n}\n\n/** @ignore */\nexport function getBit(_data: any, _index: number, byte: number, bit: number): 0 | 1 {\n    return (byte & 1 << bit) >> bit as (0 | 1);\n}\n\n/** @ignore */\nexport function setBool(bytes: Uint8Array, index: number, value: any) {\n    return value ?\n        !!(bytes[index >> 3] |=  (1 << (index % 8))) || true :\n        !(bytes[index >> 3] &= ~(1 << (index % 8))) && false ;\n}\n\n/** @ignore */\nexport function truncateBitmap(offset: number, length: number, bitmap: Uint8Array) {\n    const alignedSize = (bitmap.byteLength + 7) & ~7;\n    if (offset > 0 || bitmap.byteLength < alignedSize) {\n        const bytes = new Uint8Array(alignedSize);\n        // If the offset is a multiple of 8 bits, it's safe to slice the bitmap\n        bytes.set(offset % 8 === 0 ? bitmap.subarray(offset >> 3) :\n            // Otherwise iterate each bit from the offset and return a new one\n            packBools(iterateBits(bitmap, offset, length, null, getBool)).subarray(0, alignedSize));\n        return bytes;\n    }\n    return bitmap;\n}\n\n/** @ignore */\nexport function packBools(values: Iterable<any>) {\n    let xs: number[] = [];\n    let i = 0, bit = 0, byte = 0;\n    for (const value of values) {\n        value && (byte |= 1 << bit);\n        if (++bit === 8) {\n            xs[i++] = byte;\n            byte = bit = 0;\n        }\n    }\n    if (i === 0 || bit > 0) { xs[i++] = byte; }\n    let b = new Uint8Array((xs.length + 7) & ~7);\n    b.set(xs);\n    return b;\n}\n\n/** @ignore */\nexport function* iterateBits<T>(bytes: Uint8Array, begin: number, length: number, context: any,\n                                get: (context: any, index: number, byte: number, bit: number) => T) {\n    let bit = begin % 8;\n    let byteIndex = begin >> 3;\n    let index = 0, remaining = length;\n    for (; remaining > 0; bit = 0) {\n        let byte = bytes[byteIndex++];\n        do {\n            yield get(context, index++, byte, bit);\n        } while (--remaining > 0 && ++bit < 8);\n    }\n}\n\n/**\n * Compute the population count (the number of bits set to 1) for a range of bits in a Uint8Array.\n * @param vector The Uint8Array of bits for which to compute the population count.\n * @param lhs The range's left-hand side (or start) bit\n * @param rhs The range's right-hand side (or end) bit\n */\n/** @ignore */\nexport function popcnt_bit_range(data: Uint8Array, lhs: number, rhs: number): number {\n    if (rhs - lhs <= 0) { return 0; }\n    // If the bit range is less than one byte, sum the 1 bits in the bit range\n    if (rhs - lhs < 8) {\n        let sum = 0;\n        for (const bit of iterateBits(data, lhs, rhs - lhs, data, getBit)) {\n            sum += bit;\n        }\n        return sum;\n    }\n    // Get the next lowest multiple of 8 from the right hand side\n    const rhsInside = rhs >> 3 << 3;\n    // Get the next highest multiple of 8 from the left hand side\n    const lhsInside = lhs + (lhs % 8 === 0 ? 0 : 8 - lhs % 8);\n    return (\n        // Get the popcnt of bits between the left hand side, and the next highest multiple of 8\n        popcnt_bit_range(data, lhs, lhsInside) +\n        // Get the popcnt of bits between the right hand side, and the next lowest multiple of 8\n        popcnt_bit_range(data, rhsInside, rhs) +\n        // Get the popcnt of all bits between the left and right hand sides' multiples of 8\n        popcnt_array(data, lhsInside >> 3, (rhsInside - lhsInside) >> 3)\n    );\n}\n\n/** @ignore */\nexport function popcnt_array(arr: ArrayBufferView, byteOffset?: number, byteLength?: number) {\n    let cnt = 0, pos = byteOffset! | 0;\n    const view = new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n    const len =  byteLength === void 0 ? arr.byteLength : pos + byteLength;\n    while (len - pos >= 4) {\n        cnt += popcnt_uint32(view.getUint32(pos));\n        pos += 4;\n    }\n    while (len - pos >= 2) {\n        cnt += popcnt_uint32(view.getUint16(pos));\n        pos += 2;\n    }\n    while (len - pos >= 1) {\n        cnt += popcnt_uint32(view.getUint8(pos));\n        pos += 1;\n    }\n    return cnt;\n}\n\n/** @ignore */\nexport function popcnt_uint32(uint32: number): number {\n    let i = uint32 | 0;\n    i = i - ((i >>> 1) & 0x55555555);\n    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);\n    return (((i + (i >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Vector } from './vector';\nimport { Type, Precision, DateUnit, TimeUnit, IntervalUnit, UnionMode } from './enum';\nimport { DataType, Float, Int, Date_, Interval, Time, Timestamp, Union, } from './type';\n\nexport abstract class Visitor {\n    public visitMany(nodes: any[], ...args: any[][]) {\n        return nodes.map((node, i) => this.visit(node, ...args.map((x) => x[i])));\n    }\n    public visit(...args: any[]) {\n        return this.getVisitFn(args[0], false).apply(this, args);\n    }\n    public getVisitFn(node: any, throwIfNotFound = true) {\n        return getVisitFn(this, node, throwIfNotFound);\n    }\n    public visitNull            (_node: any, ..._args: any[]): any { return null; }\n    public visitBool            (_node: any, ..._args: any[]): any { return null; }\n    public visitInt             (_node: any, ..._args: any[]): any { return null; }\n    public visitFloat           (_node: any, ..._args: any[]): any { return null; }\n    public visitUtf8            (_node: any, ..._args: any[]): any { return null; }\n    public visitBinary          (_node: any, ..._args: any[]): any { return null; }\n    public visitFixedSizeBinary (_node: any, ..._args: any[]): any { return null; }\n    public visitDate            (_node: any, ..._args: any[]): any { return null; }\n    public visitTimestamp       (_node: any, ..._args: any[]): any { return null; }\n    public visitTime            (_node: any, ..._args: any[]): any { return null; }\n    public visitDecimal         (_node: any, ..._args: any[]): any { return null; }\n    public visitList            (_node: any, ..._args: any[]): any { return null; }\n    public visitStruct          (_node: any, ..._args: any[]): any { return null; }\n    public visitUnion           (_node: any, ..._args: any[]): any { return null; }\n    public visitDictionary      (_node: any, ..._args: any[]): any { return null; }\n    public visitInterval        (_node: any, ..._args: any[]): any { return null; }\n    public visitFixedSizeList   (_node: any, ..._args: any[]): any { return null; }\n    public visitMap             (_node: any, ..._args: any[]): any { return null; }\n}\n\n/** @ignore */\nfunction getVisitFn<T extends DataType>(visitor: Visitor, node: any, throwIfNotFound = true) {\n    let fn: any = null;\n    let dtype: T['TType'] = Type.NONE;\n    // tslint:disable\n    if      (node instanceof Data    ) { dtype = inferDType(node.type as T); }\n    else if (node instanceof Vector  ) { dtype = inferDType(node.type as T); }\n    else if (node instanceof DataType) { dtype = inferDType(node      as T); }\n    else if (typeof (dtype = node) !== 'number') { dtype = Type[node] as any as T['TType']; }\n\n    switch (dtype) {\n        case Type.Null:                 fn = visitor.visitNull; break;\n        case Type.Bool:                 fn = visitor.visitBool; break;\n        case Type.Int:                  fn = visitor.visitInt; break;\n        case Type.Int8:                 fn = visitor.visitInt8 || visitor.visitInt; break;\n        case Type.Int16:                fn = visitor.visitInt16 || visitor.visitInt; break;\n        case Type.Int32:                fn = visitor.visitInt32 || visitor.visitInt; break;\n        case Type.Int64:                fn = visitor.visitInt64 || visitor.visitInt; break;\n        case Type.Uint8:                fn = visitor.visitUint8 || visitor.visitInt; break;\n        case Type.Uint16:               fn = visitor.visitUint16 || visitor.visitInt; break;\n        case Type.Uint32:               fn = visitor.visitUint32 || visitor.visitInt; break;\n        case Type.Uint64:               fn = visitor.visitUint64 || visitor.visitInt; break;\n        case Type.Float:                fn = visitor.visitFloat; break;\n        case Type.Float16:              fn = visitor.visitFloat16 || visitor.visitFloat; break;\n        case Type.Float32:              fn = visitor.visitFloat32 || visitor.visitFloat; break;\n        case Type.Float64:              fn = visitor.visitFloat64 || visitor.visitFloat; break;\n        case Type.Utf8:                 fn = visitor.visitUtf8; break;\n        case Type.Binary:               fn = visitor.visitBinary; break;\n        case Type.FixedSizeBinary:      fn = visitor.visitFixedSizeBinary; break;\n        case Type.Date:                 fn = visitor.visitDate; break;\n        case Type.DateDay:              fn = visitor.visitDateDay || visitor.visitDate; break;\n        case Type.DateMillisecond:      fn = visitor.visitDateMillisecond || visitor.visitDate; break;\n        case Type.Timestamp:            fn = visitor.visitTimestamp; break;\n        case Type.TimestampSecond:      fn = visitor.visitTimestampSecond || visitor.visitTimestamp; break;\n        case Type.TimestampMillisecond: fn = visitor.visitTimestampMillisecond || visitor.visitTimestamp; break;\n        case Type.TimestampMicrosecond: fn = visitor.visitTimestampMicrosecond || visitor.visitTimestamp; break;\n        case Type.TimestampNanosecond:  fn = visitor.visitTimestampNanosecond || visitor.visitTimestamp; break;\n        case Type.Time:                 fn = visitor.visitTime; break;\n        case Type.TimeSecond:           fn = visitor.visitTimeSecond || visitor.visitTime; break;\n        case Type.TimeMillisecond:      fn = visitor.visitTimeMillisecond || visitor.visitTime; break;\n        case Type.TimeMicrosecond:      fn = visitor.visitTimeMicrosecond || visitor.visitTime; break;\n        case Type.TimeNanosecond:       fn = visitor.visitTimeNanosecond || visitor.visitTime; break;\n        case Type.Decimal:              fn = visitor.visitDecimal; break;\n        case Type.List:                 fn = visitor.visitList; break;\n        case Type.Struct:               fn = visitor.visitStruct; break;\n        case Type.Union:                fn = visitor.visitUnion; break;\n        case Type.DenseUnion:           fn = visitor.visitDenseUnion || visitor.visitUnion; break;\n        case Type.SparseUnion:          fn = visitor.visitSparseUnion || visitor.visitUnion; break;\n        case Type.Dictionary:           fn = visitor.visitDictionary; break;\n        case Type.Interval:             fn = visitor.visitInterval; break;\n        case Type.IntervalDayTime:      fn = visitor.visitIntervalDayTime || visitor.visitInterval; break;\n        case Type.IntervalYearMonth:    fn = visitor.visitIntervalYearMonth || visitor.visitInterval; break;\n        case Type.FixedSizeList:        fn = visitor.visitFixedSizeList; break;\n        case Type.Map:                  fn = visitor.visitMap; break;\n    }\n    if (typeof fn === 'function') return fn;\n    if (!throwIfNotFound) return () => null;\n    throw new Error(`Unrecognized type '${Type[dtype]}'`);\n}\n\n/** @ignore */\nfunction inferDType<T extends DataType>(type: T): Type {\n    switch (type.typeId) {\n        case Type.Null: return Type.Null;\n        case Type.Int:\n            const { bitWidth, isSigned } = (type as any as Int);\n            switch (bitWidth) {\n                case  8: return isSigned ? Type.Int8  : Type.Uint8 ;\n                case 16: return isSigned ? Type.Int16 : Type.Uint16;\n                case 32: return isSigned ? Type.Int32 : Type.Uint32;\n                case 64: return isSigned ? Type.Int64 : Type.Uint64;\n            }\n            return Type.Int;\n        case Type.Float:\n            switch((type as any as Float).precision) {\n                case Precision.HALF: return Type.Float16;\n                case Precision.SINGLE: return Type.Float32;\n                case Precision.DOUBLE: return Type.Float64;\n            }\n            return Type.Float;\n        case Type.Binary: return Type.Binary;\n        case Type.Utf8: return Type.Utf8;\n        case Type.Bool: return Type.Bool;\n        case Type.Decimal: return Type.Decimal;\n        case Type.Time:\n            switch ((type as any as Time).unit) {\n                case TimeUnit.SECOND: return Type.TimeSecond;\n                case TimeUnit.MILLISECOND: return Type.TimeMillisecond;\n                case TimeUnit.MICROSECOND: return Type.TimeMicrosecond;\n                case TimeUnit.NANOSECOND: return Type.TimeNanosecond;\n            }\n            return Type.Time;\n        case Type.Timestamp:\n            switch ((type as any as Timestamp).unit) {\n                case TimeUnit.SECOND: return Type.TimestampSecond;\n                case TimeUnit.MILLISECOND: return Type.TimestampMillisecond;\n                case TimeUnit.MICROSECOND: return Type.TimestampMicrosecond;\n                case TimeUnit.NANOSECOND: return Type.TimestampNanosecond;\n            }\n            return Type.Timestamp;\n        case Type.Date:\n            switch ((type as any as Date_).unit) {\n                case DateUnit.DAY: return Type.DateDay;\n                case DateUnit.MILLISECOND: return Type.DateMillisecond;\n            }\n            return Type.Date;\n        case Type.Interval:\n            switch ((type as any as Interval).unit) {\n                case IntervalUnit.DAY_TIME: return Type.IntervalDayTime;\n                case IntervalUnit.YEAR_MONTH: return Type.IntervalYearMonth;\n            }\n            return Type.Interval;\n        case Type.Map: return Type.Map;\n        case Type.List: return Type.List;\n        case Type.Struct: return Type.Struct;\n        case Type.Union:\n            switch ((type as any as Union).mode) {\n                case UnionMode.Dense: return Type.DenseUnion;\n                case UnionMode.Sparse: return Type.SparseUnion;\n            }\n            return Type.Union;\n        case Type.FixedSizeBinary: return Type.FixedSizeBinary;\n        case Type.FixedSizeList: return Type.FixedSizeList;\n        case Type.Dictionary: return Type.Dictionary;\n    }\n    throw new Error(`Unrecognized type '${Type[type.typeId]}'`);\n}\n\nexport interface Visitor {\n    visitNull                  (node: any, ...args: any[]): any;\n    visitBool                  (node: any, ...args: any[]): any;\n    visitInt                   (node: any, ...args: any[]): any;\n    visitInt8?                 (node: any, ...args: any[]): any;\n    visitInt16?                (node: any, ...args: any[]): any;\n    visitInt32?                (node: any, ...args: any[]): any;\n    visitInt64?                (node: any, ...args: any[]): any;\n    visitUint8?                (node: any, ...args: any[]): any;\n    visitUint16?               (node: any, ...args: any[]): any;\n    visitUint32?               (node: any, ...args: any[]): any;\n    visitUint64?               (node: any, ...args: any[]): any;\n    visitFloat                 (node: any, ...args: any[]): any;\n    visitFloat16?              (node: any, ...args: any[]): any;\n    visitFloat32?              (node: any, ...args: any[]): any;\n    visitFloat64?              (node: any, ...args: any[]): any;\n    visitUtf8                  (node: any, ...args: any[]): any;\n    visitBinary                (node: any, ...args: any[]): any;\n    visitFixedSizeBinary       (node: any, ...args: any[]): any;\n    visitDate                  (node: any, ...args: any[]): any;\n    visitDateDay?              (node: any, ...args: any[]): any;\n    visitDateMillisecond?      (node: any, ...args: any[]): any;\n    visitTimestamp             (node: any, ...args: any[]): any;\n    visitTimestampSecond?      (node: any, ...args: any[]): any;\n    visitTimestampMillisecond? (node: any, ...args: any[]): any;\n    visitTimestampMicrosecond? (node: any, ...args: any[]): any;\n    visitTimestampNanosecond?  (node: any, ...args: any[]): any;\n    visitTime                  (node: any, ...args: any[]): any;\n    visitTimeSecond?           (node: any, ...args: any[]): any;\n    visitTimeMillisecond?      (node: any, ...args: any[]): any;\n    visitTimeMicrosecond?      (node: any, ...args: any[]): any;\n    visitTimeNanosecond?       (node: any, ...args: any[]): any;\n    visitDecimal               (node: any, ...args: any[]): any;\n    visitList                  (node: any, ...args: any[]): any;\n    visitStruct                (node: any, ...args: any[]): any;\n    visitUnion                 (node: any, ...args: any[]): any;\n    visitDenseUnion?           (node: any, ...args: any[]): any;\n    visitSparseUnion?          (node: any, ...args: any[]): any;\n    visitDictionary            (node: any, ...args: any[]): any;\n    visitInterval              (node: any, ...args: any[]): any;\n    visitIntervalDayTime?      (node: any, ...args: any[]): any;\n    visitIntervalYearMonth?    (node: any, ...args: any[]): any;\n    visitFixedSizeList         (node: any, ...args: any[]): any;\n    visitMap                   (node: any, ...args: any[]): any;\n}\n\n// Add these here so they're picked up by the externs creator\n// in the build, and closure-compiler doesn't minify them away\n(Visitor.prototype as any).visitInt8 = null;\n(Visitor.prototype as any).visitInt16 = null;\n(Visitor.prototype as any).visitInt32 = null;\n(Visitor.prototype as any).visitInt64 = null;\n(Visitor.prototype as any).visitUint8 = null;\n(Visitor.prototype as any).visitUint16 = null;\n(Visitor.prototype as any).visitUint32 = null;\n(Visitor.prototype as any).visitUint64 = null;\n(Visitor.prototype as any).visitFloat16 = null;\n(Visitor.prototype as any).visitFloat32 = null;\n(Visitor.prototype as any).visitFloat64 = null;\n(Visitor.prototype as any).visitDateDay = null;\n(Visitor.prototype as any).visitDateMillisecond = null;\n(Visitor.prototype as any).visitTimestampSecond = null;\n(Visitor.prototype as any).visitTimestampMillisecond = null;\n(Visitor.prototype as any).visitTimestampMicrosecond = null;\n(Visitor.prototype as any).visitTimestampNanosecond = null;\n(Visitor.prototype as any).visitTimeSecond = null;\n(Visitor.prototype as any).visitTimeMillisecond = null;\n(Visitor.prototype as any).visitTimeMicrosecond = null;\n(Visitor.prototype as any).visitTimeNanosecond = null;\n(Visitor.prototype as any).visitDenseUnion = null;\n(Visitor.prototype as any).visitSparseUnion = null;\n(Visitor.prototype as any).visitIntervalDayTime = null;\n(Visitor.prototype as any).visitIntervalYearMonth = null;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { Schema, Field } from '../schema';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface TypeComparator extends Visitor {\n    visit<T extends DataType>(type: T, other?: DataType | null): other is T;\n    visitMany<T extends DataType>(nodes: T[], others?: DataType[] | null): boolean[];\n    getVisitFn<T extends DataType>(node: VectorType<T> |  Data<T> | T): (other?: DataType | null) => other is T;\n    visitNull                 <T extends Null>                 (type: T, other?: DataType | null): other is T;\n    visitBool                 <T extends Bool>                 (type: T, other?: DataType | null): other is T;\n    visitInt                  <T extends Int>                  (type: T, other?: DataType | null): other is T;\n    visitInt8                 <T extends Int8>                 (type: T, other?: DataType | null): other is T;\n    visitInt16                <T extends Int16>                (type: T, other?: DataType | null): other is T;\n    visitInt32                <T extends Int32>                (type: T, other?: DataType | null): other is T;\n    visitInt64                <T extends Int64>                (type: T, other?: DataType | null): other is T;\n    visitUint8                <T extends Uint8>                (type: T, other?: DataType | null): other is T;\n    visitUint16               <T extends Uint16>               (type: T, other?: DataType | null): other is T;\n    visitUint32               <T extends Uint32>               (type: T, other?: DataType | null): other is T;\n    visitUint64               <T extends Uint64>               (type: T, other?: DataType | null): other is T;\n    visitFloat                <T extends Float>                (type: T, other?: DataType | null): other is T;\n    visitFloat16              <T extends Float16>              (type: T, other?: DataType | null): other is T;\n    visitFloat32              <T extends Float32>              (type: T, other?: DataType | null): other is T;\n    visitFloat64              <T extends Float64>              (type: T, other?: DataType | null): other is T;\n    visitUtf8                 <T extends Utf8>                 (type: T, other?: DataType | null): other is T;\n    visitBinary               <T extends Binary>               (type: T, other?: DataType | null): other is T;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>      (type: T, other?: DataType | null): other is T;\n    visitDate                 <T extends Date_>                (type: T, other?: DataType | null): other is T;\n    visitDateDay              <T extends DateDay>              (type: T, other?: DataType | null): other is T;\n    visitDateMillisecond      <T extends DateMillisecond>      (type: T, other?: DataType | null): other is T;\n    visitTimestamp            <T extends Timestamp>            (type: T, other?: DataType | null): other is T;\n    visitTimestampSecond      <T extends TimestampSecond>      (type: T, other?: DataType | null): other is T;\n    visitTimestampMillisecond <T extends TimestampMillisecond> (type: T, other?: DataType | null): other is T;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond> (type: T, other?: DataType | null): other is T;\n    visitTimestampNanosecond  <T extends TimestampNanosecond>  (type: T, other?: DataType | null): other is T;\n    visitTime                 <T extends Time>                 (type: T, other?: DataType | null): other is T;\n    visitTimeSecond           <T extends TimeSecond>           (type: T, other?: DataType | null): other is T;\n    visitTimeMillisecond      <T extends TimeMillisecond>      (type: T, other?: DataType | null): other is T;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>      (type: T, other?: DataType | null): other is T;\n    visitTimeNanosecond       <T extends TimeNanosecond>       (type: T, other?: DataType | null): other is T;\n    visitDecimal              <T extends Decimal>              (type: T, other?: DataType | null): other is T;\n    visitList                 <T extends List>                 (type: T, other?: DataType | null): other is T;\n    visitStruct               <T extends Struct>               (type: T, other?: DataType | null): other is T;\n    visitUnion                <T extends Union>                (type: T, other?: DataType | null): other is T;\n    visitDenseUnion           <T extends DenseUnion>           (type: T, other?: DataType | null): other is T;\n    visitSparseUnion          <T extends SparseUnion>          (type: T, other?: DataType | null): other is T;\n    visitDictionary           <T extends Dictionary>           (type: T, other?: DataType | null): other is T;\n    visitInterval             <T extends Interval>             (type: T, other?: DataType | null): other is T;\n    visitIntervalDayTime      <T extends IntervalDayTime>      (type: T, other?: DataType | null): other is T;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>    (type: T, other?: DataType | null): other is T;\n    visitFixedSizeList        <T extends FixedSizeList>        (type: T, other?: DataType | null): other is T;\n    visitMap                  <T extends Map_>                 (type: T, other?: DataType | null): other is T;\n}\n\n/** @ignore */\nexport class TypeComparator extends Visitor {\n    compareSchemas<T extends { [key: string]: DataType }>(schema: Schema<T>, other?: Schema | null): other is Schema<T> {\n        return (schema === other) || (\n            other instanceof schema.constructor &&\n            instance.compareFields(schema.fields, other.fields)\n        );\n    }\n    compareFields<T extends { [key: string]: DataType }>(fields: Field<T[keyof T]>[], others?: Field[] | null): others is Field<T[keyof T]>[] {\n        return (fields === others) || (\n            Array.isArray(fields) &&\n            Array.isArray(others) &&\n            fields.length === others.length &&\n            fields.every((f, i) => instance.compareField(f, others[i]))\n        );\n    }\n    compareField<T extends DataType = any>(field: Field<T>, other?: Field | null): other is Field<T> {\n        return (field === other) || (\n            other instanceof field.constructor &&\n            field.name === other.name &&\n            field.nullable === other.nullable &&\n            instance.visit(field.type, other.type)\n        );\n    }\n}\n\nfunction compareConstructor<T extends DataType>(type: T, other?: DataType | null): other is T {\n    return other instanceof type.constructor;\n}\n\nfunction compareAny<T extends DataType>(type: T, other?: DataType | null): other is T {\n    return (type === other) || compareConstructor(type, other);\n}\n\nfunction compareInt<T extends Int>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.bitWidth === other.bitWidth &&\n        type.isSigned === other.isSigned\n    );\n}\n\nfunction compareFloat<T extends Float>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.precision === other.precision\n    );\n}\n\nfunction compareFixedSizeBinary<T extends FixedSizeBinary>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.byteWidth === other.byteWidth\n    );\n}\n\nfunction compareDate<T extends Date_>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit\n    );\n}\n\nfunction compareTimestamp<T extends Timestamp>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit &&\n        type.timezone === other.timezone\n    );\n}\n\nfunction compareTime<T extends Time>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit &&\n        type.bitWidth === other.bitWidth\n    );\n}\n\nfunction compareList<T extends List>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareStruct<T extends Struct>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareUnion<T extends Union>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.mode === other.mode &&\n        type.typeIds.every((x, i) => x === other.typeIds[i]) &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareDictionary<T extends Dictionary>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.id === other.id &&\n        type.isOrdered === other.isOrdered &&\n        instance.visit(<any> type.indices, other.indices) &&\n        instance.visit(type.dictionary, other.dictionary)\n    );\n}\n\nfunction compareInterval<T extends Interval>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit\n    );\n}\n\nfunction compareFixedSizeList<T extends FixedSizeList>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.listSize === other.listSize &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareMap<T extends Map_>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.keysSorted === other.keysSorted &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nTypeComparator.prototype.visitNull                 =             compareAny;\nTypeComparator.prototype.visitBool                 =             compareAny;\nTypeComparator.prototype.visitInt                  =             compareInt;\nTypeComparator.prototype.visitInt8                 =             compareInt;\nTypeComparator.prototype.visitInt16                =             compareInt;\nTypeComparator.prototype.visitInt32                =             compareInt;\nTypeComparator.prototype.visitInt64                =             compareInt;\nTypeComparator.prototype.visitUint8                =             compareInt;\nTypeComparator.prototype.visitUint16               =             compareInt;\nTypeComparator.prototype.visitUint32               =             compareInt;\nTypeComparator.prototype.visitUint64               =             compareInt;\nTypeComparator.prototype.visitFloat                =           compareFloat;\nTypeComparator.prototype.visitFloat16              =           compareFloat;\nTypeComparator.prototype.visitFloat32              =           compareFloat;\nTypeComparator.prototype.visitFloat64              =           compareFloat;\nTypeComparator.prototype.visitUtf8                 =             compareAny;\nTypeComparator.prototype.visitBinary               =             compareAny;\nTypeComparator.prototype.visitFixedSizeBinary      = compareFixedSizeBinary;\nTypeComparator.prototype.visitDate                 =            compareDate;\nTypeComparator.prototype.visitDateDay              =            compareDate;\nTypeComparator.prototype.visitDateMillisecond      =            compareDate;\nTypeComparator.prototype.visitTimestamp            =       compareTimestamp;\nTypeComparator.prototype.visitTimestampSecond      =       compareTimestamp;\nTypeComparator.prototype.visitTimestampMillisecond =       compareTimestamp;\nTypeComparator.prototype.visitTimestampMicrosecond =       compareTimestamp;\nTypeComparator.prototype.visitTimestampNanosecond  =       compareTimestamp;\nTypeComparator.prototype.visitTime                 =            compareTime;\nTypeComparator.prototype.visitTimeSecond           =            compareTime;\nTypeComparator.prototype.visitTimeMillisecond      =            compareTime;\nTypeComparator.prototype.visitTimeMicrosecond      =            compareTime;\nTypeComparator.prototype.visitTimeNanosecond       =            compareTime;\nTypeComparator.prototype.visitDecimal              =             compareAny;\nTypeComparator.prototype.visitList                 =            compareList;\nTypeComparator.prototype.visitStruct               =          compareStruct;\nTypeComparator.prototype.visitUnion                =           compareUnion;\nTypeComparator.prototype.visitDenseUnion           =           compareUnion;\nTypeComparator.prototype.visitSparseUnion          =           compareUnion;\nTypeComparator.prototype.visitDictionary           =      compareDictionary;\nTypeComparator.prototype.visitInterval             =        compareInterval;\nTypeComparator.prototype.visitIntervalDayTime      =        compareInterval;\nTypeComparator.prototype.visitIntervalYearMonth    =        compareInterval;\nTypeComparator.prototype.visitFixedSizeList        =   compareFixedSizeList;\nTypeComparator.prototype.visitMap                  =             compareMap;\n\n/** @ignore */\nexport const instance = new TypeComparator();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/* tslint:disable:class-name */\n\nimport { Field } from './schema';\nimport { flatbuffers } from 'flatbuffers';\nimport { TypedArrayConstructor } from './interfaces';\nimport { VectorType as V, TypeToDataType } from './interfaces';\nimport { instance as comparer } from './visitor/typecomparator';\n\nimport Long = flatbuffers.Long;\nimport {\n    Type,\n    Precision, UnionMode,\n    DateUnit, TimeUnit, IntervalUnit\n} from './enum';\n\n/** @ignore */\nexport type TimeBitWidth = 32 | 64;\n/** @ignore */\nexport type IntBitWidth = 8 | 16 | 32 | 64;\n/** @ignore */\nexport type IsSigned = { 'true': true; 'false': false };\n/** @ignore */\nexport type RowLike<T extends { [key: string]: DataType }> =\n      ( Iterable<[string, T[keyof T]['TValue'] | null]> )\n    & { [P in keyof T]: T[P]['TValue'] | null }\n    & { get<K extends keyof T>(key: K): T[K]['TValue'] | null; }\n    & { set<K extends keyof T>(key: K, val: T[K]['TValue'] | null): void; }\n    ;\n\n/** @ignore */\nexport type MapLike<K extends DataType = any, V extends DataType = any> =\n      { [P in K['TValue']]: V['TValue'] | null }\n    & ( Map<K['TValue'], V['TValue'] | null> )\n    ;\n\nexport interface DataType<TType extends Type = Type, TChildren extends { [key: string]: DataType } = any> {\n    readonly TType: TType;\n    readonly TArray: any;\n    readonly TValue: any;\n    readonly ArrayType: any;\n    readonly children: Field<TChildren[keyof TChildren]>[];\n}\n\n/**\n * An abstract base class for classes that encapsulate metadata about each of\n * the logical types that Arrow can represent.\n */\nexport abstract class DataType<TType extends Type = Type, TChildren extends { [key: string]: DataType } = any> {\n\n    // @ts-ignore\n    public [Symbol.toStringTag]: string;\n\n    /** @nocollapse */ static            isNull (x: any): x is Null            { return x && x.typeId === Type.Null;            }\n    /** @nocollapse */ static             isInt (x: any): x is Int_            { return x && x.typeId === Type.Int;             }\n    /** @nocollapse */ static           isFloat (x: any): x is Float           { return x && x.typeId === Type.Float;           }\n    /** @nocollapse */ static          isBinary (x: any): x is Binary          { return x && x.typeId === Type.Binary;          }\n    /** @nocollapse */ static            isUtf8 (x: any): x is Utf8            { return x && x.typeId === Type.Utf8;            }\n    /** @nocollapse */ static            isBool (x: any): x is Bool            { return x && x.typeId === Type.Bool;            }\n    /** @nocollapse */ static         isDecimal (x: any): x is Decimal         { return x && x.typeId === Type.Decimal;         }\n    /** @nocollapse */ static            isDate (x: any): x is Date_           { return x && x.typeId === Type.Date;            }\n    /** @nocollapse */ static            isTime (x: any): x is Time_           { return x && x.typeId === Type.Time;            }\n    /** @nocollapse */ static       isTimestamp (x: any): x is Timestamp_      { return x && x.typeId === Type.Timestamp;       }\n    /** @nocollapse */ static        isInterval (x: any): x is Interval_       { return x && x.typeId === Type.Interval;        }\n    /** @nocollapse */ static            isList (x: any): x is List            { return x && x.typeId === Type.List;            }\n    /** @nocollapse */ static          isStruct (x: any): x is Struct          { return x && x.typeId === Type.Struct;          }\n    /** @nocollapse */ static           isUnion (x: any): x is Union_          { return x && x.typeId === Type.Union;           }\n    /** @nocollapse */ static isFixedSizeBinary (x: any): x is FixedSizeBinary { return x && x.typeId === Type.FixedSizeBinary; }\n    /** @nocollapse */ static   isFixedSizeList (x: any): x is FixedSizeList   { return x && x.typeId === Type.FixedSizeList;   }\n    /** @nocollapse */ static             isMap (x: any): x is Map_            { return x && x.typeId === Type.Map;             }\n    /** @nocollapse */ static      isDictionary (x: any): x is Dictionary      { return x && x.typeId === Type.Dictionary;      }\n\n    public get typeId(): TType { return <any> Type.NONE; }\n    public compareTo(other: DataType): other is TypeToDataType<TType> {\n        return comparer.visit(this, other);\n    }\n\n    protected static [Symbol.toStringTag] = ((proto: DataType) => {\n        (<any> proto).children = null;\n        (<any> proto).ArrayType = Array;\n        return proto[Symbol.toStringTag] = 'DataType';\n    })(DataType.prototype);\n}\n\n/** @ignore */\nexport interface Null extends DataType<Type.Null> { TArray: void; TValue: null; }\n/** @ignore */\nexport class Null extends DataType<Type.Null> {\n    public toString() { return `Null`; }\n    public get typeId() { return Type.Null as Type.Null; }\n    protected static [Symbol.toStringTag] = ((proto: Null) => {\n        return proto[Symbol.toStringTag] = 'Null';\n    })(Null.prototype);\n}\n\n/** @ignore */\ntype Ints = Type.Int | Type.Int8 | Type.Int16 | Type.Int32 | Type.Int64 | Type.Uint8 | Type.Uint16 | Type.Uint32 | Type.Uint64;\n/** @ignore */\ntype IType = {\n    [Type.Int   ]: { bitWidth: IntBitWidth; isSigned: true | false; TArray: IntArray;    TValue: number | bigint | Int32Array | Uint32Array; };\n    [Type.Int8  ]: { bitWidth:           8; isSigned: true;         TArray: Int8Array;   TValue: number; };\n    [Type.Int16 ]: { bitWidth:          16; isSigned: true;         TArray: Int16Array;  TValue: number; };\n    [Type.Int32 ]: { bitWidth:          32; isSigned: true;         TArray: Int32Array;  TValue: number; };\n    [Type.Int64 ]: { bitWidth:          64; isSigned: true;         TArray: Int32Array;  TValue: bigint | Int32Array | Uint32Array; };\n    [Type.Uint8 ]: { bitWidth:           8; isSigned: false;        TArray: Uint8Array;  TValue: number; };\n    [Type.Uint16]: { bitWidth:          16; isSigned: false;        TArray: Uint16Array; TValue: number; };\n    [Type.Uint32]: { bitWidth:          32; isSigned: false;        TArray: Uint32Array; TValue: number; };\n    [Type.Uint64]: { bitWidth:          64; isSigned: false;        TArray: Uint32Array; TValue: bigint | Int32Array | Uint32Array; };\n};\n\n/** @ignore */\ninterface Int_<T extends Ints = Ints> extends DataType<T> { TArray: IType[T]['TArray']; TValue: IType[T]['TValue']; }\n/** @ignore */\nclass Int_<T extends Ints = Ints> extends DataType<T> {\n    constructor(public readonly isSigned: IType[T]['isSigned'],\n                public readonly bitWidth: IType[T]['bitWidth']) {\n        super();\n    }\n    public get typeId() { return Type.Int as T; }\n    public get ArrayType(): TypedArrayConstructor<IType[T]['TArray']> {\n        switch (this.bitWidth) {\n            case  8: return this.isSigned ?  Int8Array :  Uint8Array;\n            case 16: return this.isSigned ? Int16Array : Uint16Array;\n            case 32: return this.isSigned ? Int32Array : Uint32Array;\n            case 64: return this.isSigned ? Int32Array : Uint32Array;\n        }\n        throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n    }\n    public toString() { return `${this.isSigned ? `I` : `Ui`}nt${this.bitWidth}`; }\n    protected static [Symbol.toStringTag] = ((proto: Int_) => {\n        (<any> proto).isSigned = null;\n        (<any> proto).bitWidth = null;\n        return proto[Symbol.toStringTag] = 'Int';\n    })(Int_.prototype);\n}\n\nexport { Int_ as Int };\n\n/** @ignore */\nexport class Int8 extends Int_<Type.Int8> { constructor() { super(true, 8); } }\n/** @ignore */\nexport class Int16 extends Int_<Type.Int16> { constructor() { super(true, 16); } }\n/** @ignore */\nexport class Int32 extends Int_<Type.Int32> { constructor() { super(true, 32); } }\n/** @ignore */\nexport class Int64 extends Int_<Type.Int64> { constructor() { super(true, 64); } }\n/** @ignore */\nexport class Uint8 extends Int_<Type.Uint8> { constructor() { super(false, 8); } }\n/** @ignore */\nexport class Uint16 extends Int_<Type.Uint16> { constructor() { super(false, 16); } }\n/** @ignore */\nexport class Uint32 extends Int_<Type.Uint32> { constructor() { super(false, 32); } }\n/** @ignore */\nexport class Uint64 extends Int_<Type.Uint64> { constructor() { super(false, 64); } }\n\nObject.defineProperty(Int8.prototype, 'ArrayType', { value: Int8Array });\nObject.defineProperty(Int16.prototype, 'ArrayType', { value: Int16Array });\nObject.defineProperty(Int32.prototype, 'ArrayType', { value: Int32Array });\nObject.defineProperty(Int64.prototype, 'ArrayType', { value: Int32Array });\nObject.defineProperty(Uint8.prototype, 'ArrayType', { value: Uint8Array });\nObject.defineProperty(Uint16.prototype, 'ArrayType', { value: Uint16Array });\nObject.defineProperty(Uint32.prototype, 'ArrayType', { value: Uint32Array });\nObject.defineProperty(Uint64.prototype, 'ArrayType', { value: Uint32Array });\n\n/** @ignore */\ntype Floats = Type.Float | Type.Float16 | Type.Float32 | Type.Float64;\n/** @ignore */\ntype FType = {\n    [Type.Float  ]: { precision: Precision;        TArray: FloatArray;    TValue: number; };\n    [Type.Float16]: { precision: Precision.HALF;   TArray: Uint16Array;   TValue: number; };\n    [Type.Float32]: { precision: Precision.SINGLE; TArray: Float32Array;  TValue: number; };\n    [Type.Float64]: { precision: Precision.DOUBLE; TArray: Float64Array;  TValue: number; };\n};\n\n/** @ignore */\nexport interface Float<T extends Floats = Floats> extends DataType<T> { TArray: FType[T]['TArray']; TValue: number; }\n/** @ignore */\nexport class Float<T extends Floats = Floats> extends DataType<T> {\n    constructor(public readonly precision: Precision) {\n        super();\n    }\n    public get typeId() { return Type.Float as T; }\n    public get ArrayType(): TypedArrayConstructor<FType[T]['TArray']> {\n        switch (this.precision) {\n            case Precision.HALF: return Uint16Array;\n            case Precision.SINGLE: return Float32Array;\n            case Precision.DOUBLE: return Float64Array;\n        }\n        throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n    }\n    public toString() { return `Float${(this.precision << 5) || 16}`; }\n    protected static [Symbol.toStringTag] = ((proto: Float) => {\n        (<any> proto).precision = null;\n        return proto[Symbol.toStringTag] = 'Float';\n    })(Float.prototype);\n}\n\n/** @ignore */\nexport class Float16 extends Float<Type.Float16> { constructor() { super(Precision.HALF); } }\n/** @ignore */\nexport class Float32 extends Float<Type.Float32> { constructor() { super(Precision.SINGLE); } }\n/** @ignore */\nexport class Float64 extends Float<Type.Float64> { constructor() { super(Precision.DOUBLE); } }\n\nObject.defineProperty(Float16.prototype, 'ArrayType', { value: Uint16Array });\nObject.defineProperty(Float32.prototype, 'ArrayType', { value: Float32Array });\nObject.defineProperty(Float64.prototype, 'ArrayType', { value: Float64Array });\n\n/** @ignore */\nexport interface Binary extends DataType<Type.Binary> { TArray: Uint8Array; TValue: Uint8Array; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class Binary extends DataType<Type.Binary> {\n    constructor() {\n        super();\n    }\n    public get typeId() { return Type.Binary as Type.Binary; }\n    public toString() { return `Binary`; }\n    protected static [Symbol.toStringTag] = ((proto: Binary) => {\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'Binary';\n    })(Binary.prototype);\n}\n\n/** @ignore */\nexport interface Utf8 extends DataType<Type.Utf8> { TArray: Uint8Array; TValue: string; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class Utf8 extends DataType<Type.Utf8> {\n    constructor() {\n        super();\n    }\n    public get typeId() { return Type.Utf8 as Type.Utf8; }\n    public toString() { return `Utf8`; }\n    protected static [Symbol.toStringTag] = ((proto: Utf8) => {\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'Utf8';\n    })(Utf8.prototype);\n}\n\n/** @ignore */\nexport interface Bool extends DataType<Type.Bool> { TArray: Uint8Array; TValue: boolean; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class Bool extends DataType<Type.Bool> {\n    constructor() {\n        super();\n    }\n    public get typeId() { return Type.Bool as Type.Bool; }\n    public toString() { return `Bool`; }\n    protected static [Symbol.toStringTag] = ((proto: Bool) => {\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'Bool';\n    })(Bool.prototype);\n}\n\n/** @ignore */\nexport interface Decimal extends DataType<Type.Decimal> { TArray: Uint32Array; TValue: Uint32Array; ArrayType: TypedArrayConstructor<Uint32Array>; }\n/** @ignore */\nexport class Decimal extends DataType<Type.Decimal> {\n    constructor(public readonly scale: number,\n                public readonly precision: number) {\n        super();\n    }\n    public get typeId() { return Type.Decimal as Type.Decimal; }\n    public toString() { return `Decimal[${this.precision}e${this.scale > 0 ? `+` : ``}${this.scale}]`; }\n    protected static [Symbol.toStringTag] = ((proto: Decimal) => {\n        (<any> proto).scale = null;\n        (<any> proto).precision = null;\n        (<any> proto).ArrayType = Uint32Array;\n        return proto[Symbol.toStringTag] = 'Decimal';\n    })(Decimal.prototype);\n}\n\n/** @ignore */\nexport type Dates = Type.Date | Type.DateDay | Type.DateMillisecond;\n/** @ignore */\nexport interface Date_<T extends Dates = Dates> extends DataType<T> { TArray: Int32Array; TValue: Date; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nexport class Date_<T extends Dates = Dates> extends DataType<T> {\n    constructor(public readonly unit: DateUnit) {\n        super();\n    }\n    public get typeId() { return Type.Date as T; }\n    public toString() { return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Date_) => {\n        (<any> proto).unit = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Date';\n    })(Date_.prototype);\n}\n\n/** @ignore */\nexport class DateDay extends Date_<Type.DateDay> { constructor() { super(DateUnit.DAY); } }\n/** @ignore */\nexport class DateMillisecond extends Date_<Type.DateMillisecond> { constructor() { super(DateUnit.MILLISECOND); } }\n\n/** @ignore */\ntype Times = Type.Time | Type.TimeSecond | Type.TimeMillisecond | Type.TimeMicrosecond | Type.TimeNanosecond;\n/** @ignore */\ntype TimesType = {\n    [Type.Time           ]: { unit: TimeUnit;             TValue: number | Int32Array };\n    [Type.TimeSecond     ]: { unit: TimeUnit.SECOND;      TValue: number;             };\n    [Type.TimeMillisecond]: { unit: TimeUnit.MILLISECOND; TValue: number;             };\n    [Type.TimeMicrosecond]: { unit: TimeUnit.MICROSECOND; TValue: Int32Array;         };\n    [Type.TimeNanosecond ]: { unit: TimeUnit.NANOSECOND;  TValue: Int32Array;         };\n};\n\n/** @ignore */\ninterface Time_<T extends Times = Times> extends DataType<T> { TArray: Int32Array; TValue: TimesType[T]['TValue']; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nclass Time_<T extends Times = Times> extends DataType<T> {\n    constructor(public readonly unit: TimesType[T]['unit'],\n                public readonly bitWidth: TimeBitWidth) {\n        super();\n    }\n    public get typeId() { return Type.Time as T; }\n    public toString() { return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Time_) => {\n        (<any> proto).unit = null;\n        (<any> proto).bitWidth = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Time';\n    })(Time_.prototype);\n}\n\nexport { Time_ as Time };\n\n/** @ignore */\nexport class TimeSecond extends Time_<Type.TimeSecond> { constructor() { super(TimeUnit.SECOND, 32); } }\n/** @ignore */\nexport class TimeMillisecond extends Time_<Type.TimeMillisecond> { constructor() { super(TimeUnit.MILLISECOND, 32); } }\n/** @ignore */\nexport class TimeMicrosecond extends Time_<Type.TimeMicrosecond> { constructor() { super(TimeUnit.MICROSECOND, 64); } }\n/** @ignore */\nexport class TimeNanosecond extends Time_<Type.TimeNanosecond> { constructor() { super(TimeUnit.NANOSECOND, 64); } }\n\n/** @ignore */\ntype Timestamps = Type.Timestamp | Type.TimestampSecond | Type.TimestampMillisecond | Type.TimestampMicrosecond | Type.TimestampNanosecond;\n/** @ignore */\ninterface Timestamp_<T extends Timestamps = Timestamps> extends DataType<T> { TArray: Int32Array; TValue: number; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nclass Timestamp_<T extends Timestamps = Timestamps> extends DataType<T> {\n    constructor(public readonly unit: TimeUnit,\n                public readonly timezone?: string | null) {\n        super();\n    }\n    public get typeId() { return Type.Timestamp as T; }\n    public toString() { return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ``}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Timestamp_) => {\n        (<any> proto).unit = null;\n        (<any> proto).timezone = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Timestamp';\n    })(Timestamp_.prototype);\n}\n\nexport { Timestamp_ as Timestamp };\n\n/** @ignore */\nexport class TimestampSecond extends Timestamp_<Type.TimestampSecond> { constructor(timezone?: string | null) { super(TimeUnit.SECOND, timezone); } }\n/** @ignore */\nexport class TimestampMillisecond extends Timestamp_<Type.TimestampMillisecond> { constructor(timezone?: string | null) { super(TimeUnit.MILLISECOND, timezone); } }\n/** @ignore */\nexport class TimestampMicrosecond extends Timestamp_<Type.TimestampMicrosecond> { constructor(timezone?: string | null) { super(TimeUnit.MICROSECOND, timezone); } }\n/** @ignore */\nexport class TimestampNanosecond extends Timestamp_<Type.TimestampNanosecond> { constructor(timezone?: string | null) { super(TimeUnit.NANOSECOND, timezone); } }\n\n/** @ignore */\ntype Intervals = Type.Interval | Type.IntervalDayTime | Type.IntervalYearMonth;\n/** @ignore */\ninterface Interval_<T extends Intervals = Intervals> extends DataType<T> { TArray: Int32Array; TValue: Int32Array; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nclass Interval_<T extends Intervals = Intervals> extends DataType<T> {\n    constructor(public readonly unit: IntervalUnit) {\n        super();\n    }\n    public get typeId() { return Type.Interval as T; }\n    public toString() { return `Interval<${IntervalUnit[this.unit]}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Interval_) => {\n        (<any> proto).unit = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Interval';\n    })(Interval_.prototype);\n}\n\nexport { Interval_ as Interval };\n\n/** @ignore */\nexport class IntervalDayTime extends Interval_<Type.IntervalDayTime> { constructor() { super(IntervalUnit.DAY_TIME); } }\n/** @ignore */\nexport class IntervalYearMonth extends Interval_<Type.IntervalYearMonth> { constructor() { super(IntervalUnit.YEAR_MONTH); } }\n\n/** @ignore */\nexport interface List<T extends DataType = any> extends DataType<Type.List, { [0]: T }>  { TArray: IterableArrayLike<T>; TValue: V<T>; }\n/** @ignore */\nexport class List<T extends DataType = any> extends DataType<Type.List, { [0]: T }> {\n    constructor(child: Field<T>) {\n        super();\n        this.children = [child];\n    }\n    public readonly children: Field<T>[];\n    public get typeId() { return Type.List as Type.List; }\n    public toString() { return `List<${this.valueType}>`; }\n    public get valueType(): T { return this.children[0].type as T; }\n    public get valueField(): Field<T> { return this.children[0] as Field<T>; }\n    public get ArrayType(): T['ArrayType'] { return this.valueType.ArrayType; }\n    protected static [Symbol.toStringTag] = ((proto: List) => {\n        (<any> proto).children = null;\n        return proto[Symbol.toStringTag] = 'List';\n    })(List.prototype);\n}\n\n/** @ignore */\nexport interface Struct<T extends { [key: string]: DataType } = any> extends DataType<Type.Struct> { TArray: IterableArrayLike<RowLike<T>>; TValue: RowLike<T>; dataTypes: T; }\n/** @ignore */\nexport class Struct<T extends { [key: string]: DataType } = any> extends DataType<Type.Struct, T> {\n    public readonly children: Field<T[keyof T]>[];\n    constructor(children: Field<T[keyof T]>[]) {\n        super();\n        this.children = children;\n    }\n    public get typeId() { return Type.Struct as Type.Struct; }\n    public toString() { return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Struct) => {\n        (<any> proto).children = null;\n        return proto[Symbol.toStringTag] = 'Struct';\n    })(Struct.prototype);\n}\n\n/** @ignore */\ntype Unions = Type.Union | Type.DenseUnion | Type.SparseUnion;\n/** @ignore */\ninterface Union_<T extends Unions = Unions> extends DataType<T> { TArray: Int8Array; TValue: any; ArrayType: TypedArrayConstructor<Int8Array>; }\n/** @ignore */\nclass Union_<T extends Unions = Unions> extends DataType<T> {\n    public readonly mode: UnionMode;\n    public readonly typeIds: Int32Array;\n    public readonly children: Field<any>[];\n    public readonly typeIdToChildIndex: { [key: number]: number };\n    constructor(mode: UnionMode,\n                typeIds: number[] | Int32Array,\n                children: Field<any>[]) {\n        super();\n        this.mode = mode;\n        this.children = children;\n        this.typeIds = typeIds = Int32Array.from(typeIds);\n        this.typeIdToChildIndex = typeIds.reduce((typeIdToChildIndex, typeId, idx) => {\n            return (typeIdToChildIndex[typeId] = idx) && typeIdToChildIndex || typeIdToChildIndex;\n        }, Object.create(null) as { [key: number]: number });\n    }\n    public get typeId() { return Type.Union as T; }\n    public toString() { return `${this[Symbol.toStringTag]}<${\n        this.children.map((x) => `${x.type}`).join(` | `)\n    }>`; }\n    protected static [Symbol.toStringTag] = ((proto: Union_) => {\n        (<any> proto).mode = null;\n        (<any> proto).typeIds = null;\n        (<any> proto).children = null;\n        (<any> proto).typeIdToChildIndex = null;\n        (<any> proto).ArrayType = Int8Array;\n        return proto[Symbol.toStringTag] = 'Union';\n    })(Union_.prototype);\n}\n\nexport { Union_ as Union };\n\n/** @ignore */\nexport class DenseUnion extends Union_<Type.DenseUnion> {\n    constructor(typeIds: number[] | Int32Array, children: Field[]) {\n        super(UnionMode.Dense, typeIds, children);\n    }\n}\n\n/** @ignore */\nexport class SparseUnion extends Union_<Type.SparseUnion> {\n    constructor(typeIds: number[] | Int32Array, children: Field[]) {\n        super(UnionMode.Sparse, typeIds, children);\n    }\n}\n\n/** @ignore */\nexport interface FixedSizeBinary extends DataType<Type.FixedSizeBinary> { TArray: Uint8Array; TValue: Uint8Array; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class FixedSizeBinary extends DataType<Type.FixedSizeBinary> {\n    constructor(public readonly byteWidth: number) {\n        super();\n    }\n    public get typeId() { return Type.FixedSizeBinary as Type.FixedSizeBinary; }\n    public toString() { return `FixedSizeBinary[${this.byteWidth}]`; }\n    protected static [Symbol.toStringTag] = ((proto: FixedSizeBinary) => {\n        (<any> proto).byteWidth = null;\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'FixedSizeBinary';\n    })(FixedSizeBinary.prototype);\n}\n\n/** @ignore */\nexport interface FixedSizeList<T extends DataType = any> extends DataType<Type.FixedSizeList> { TArray: IterableArrayLike<T['TArray']>; TValue: V<T>; }\n/** @ignore */\nexport class FixedSizeList<T extends DataType = any> extends DataType<Type.FixedSizeList, { [0]: T }> {\n    public readonly children: Field<T>[];\n    constructor(public readonly listSize: number, child: Field<T>) {\n        super();\n        this.children = [child];\n    }\n    public get typeId() { return Type.FixedSizeList as Type.FixedSizeList; }\n    public get valueType(): T { return this.children[0].type as T; }\n    public get valueField(): Field<T> { return this.children[0] as Field<T>; }\n    public get ArrayType(): T['ArrayType'] { return this.valueType.ArrayType; }\n    public toString() { return `FixedSizeList[${this.listSize}]<${this.valueType}>`; }\n    protected static [Symbol.toStringTag] = ((proto: FixedSizeList) => {\n        (<any> proto).children = null;\n        (<any> proto).listSize = null;\n        return proto[Symbol.toStringTag] = 'FixedSizeList';\n    })(FixedSizeList.prototype);\n}\n\n/** @ignore */\nexport interface Map_<TKey extends DataType = any, TValue extends DataType = any> extends DataType<Type.Map> {\n    TArray: IterableArrayLike<Map<TKey['TValue'], TValue['TValue'] | null>>;\n    TChild: Struct<{ key: TKey, value: TValue }>;\n    TValue: MapLike<TKey, TValue>;\n}\n\n/** @ignore */\nexport class Map_<TKey extends DataType = any, TValue extends DataType = any> extends DataType<Type.Map> {\n    constructor(child: Field<Struct<{ key: TKey, value: TValue }>>, keysSorted = false) {\n        super();\n        this.children = [child];\n        this.keysSorted = keysSorted;\n    }\n    public readonly keysSorted: boolean;\n    public readonly children: Field<Struct<{ key: TKey, value: TValue }>>[];\n    public get typeId() { return Type.Map as Type.Map; }\n    public get keyType(): TKey { return this.children[0].type.children[0].type as TKey; }\n    public get valueType(): TValue { return this.children[0].type.children[1].type as TValue; }\n    public toString() { return `Map<{${this.children[0].type.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Map_) => {\n        (<any> proto).children = null;\n        (<any> proto).keysSorted = null;\n        return proto[Symbol.toStringTag] = 'Map_';\n    })(Map_.prototype);\n}\n\n/** @ignore */\nconst getId = ((atomicDictionaryId) => () => ++atomicDictionaryId)(-1);\n\n/** @ignore */\nexport type TKeys = Int8 | Int16 | Int32 | Uint8 | Uint16 | Uint32;\n\n/** @ignore */\nexport interface Dictionary<T extends DataType = any, TKey extends TKeys = TKeys> extends DataType<Type.Dictionary> { TArray: TKey['TArray']; TValue: T['TValue']; }\n/** @ignore */\nexport class Dictionary<T extends DataType = any, TKey extends TKeys = TKeys> extends DataType<Type.Dictionary> {\n    public readonly id: number;\n    public readonly indices: TKey;\n    public readonly dictionary: T;\n    public readonly isOrdered: boolean;\n    constructor(dictionary: T, indices: TKey, id?: Long | number | null, isOrdered?: boolean | null) {\n        super();\n        this.indices = indices;\n        this.dictionary = dictionary;\n        this.isOrdered = isOrdered || false;\n        this.id = id == null ? getId() : typeof id === 'number' ? id : id.low;\n    }\n    public get typeId() { return Type.Dictionary as Type.Dictionary; }\n    public get children() { return this.dictionary.children; }\n    public get valueType(): T { return this.dictionary as T; }\n    public get ArrayType(): T['ArrayType'] { return this.dictionary.ArrayType; }\n    public toString() { return `Dictionary<${this.indices}, ${this.dictionary}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Dictionary) => {\n        (<any> proto).id = null;\n        (<any> proto).indices = null;\n        (<any> proto).isOrdered = null;\n        (<any> proto).dictionary = null;\n        return proto[Symbol.toStringTag] = 'Dictionary';\n    })(Dictionary.prototype);\n}\n\n/** @ignore */\nexport interface IterableArrayLike<T = any> extends ArrayLike<T>, Iterable<T> {}\n/** @ignore */\nexport type FloatArray = Uint16Array | Float32Array | Float64Array;\n/** @ignore */\nexport type IntArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;\n\n/** @ignore */\nexport function strideForType(type: DataType) {\n    let t: any = type;\n    switch (type.typeId) {\n        case Type.Decimal: return 4;\n        case Type.Timestamp: return 2;\n        case Type.Date: return 1 + (t as Date_).unit;\n        case Type.Interval: return 1 + (t as Interval_).unit;\n        case Type.Int: return 1 + +((t as Int_).bitWidth > 32);\n        case Type.Time: return 1 + +((t as Time_).bitWidth > 32);\n        case Type.FixedSizeList: return (t as FixedSizeList).listSize;\n        case Type.FixedSizeBinary: return (t as FixedSizeBinary).byteWidth;\n        default: return 1;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from './vector';\nimport { truncateBitmap } from './util/bit';\nimport { popcnt_bit_range } from './util/bit';\nimport { BufferType, UnionMode, Type } from './enum';\nimport { DataType, SparseUnion, DenseUnion, strideForType } from './type';\nimport { toArrayBufferView, toUint8Array, toInt32Array } from './util/buffer';\nimport {\n    Dictionary,\n    Null, Int, Float,\n    Binary, Bool, Utf8, Decimal,\n    Date_, Time, Timestamp, Interval,\n    List, Struct, Union, FixedSizeBinary, FixedSizeList, Map_,\n} from './type';\n\n// When slicing, we do not know the null count of the sliced range without\n// doing some computation. To avoid doing this eagerly, we set the null count\n// to -1 (any negative number will do). When Vector.nullCount is called the\n// first time, the null count will be computed. See ARROW-33\n/** @ignore */ export type kUnknownNullCount = -1;\n/** @ignore */ export const kUnknownNullCount = -1;\n\n/** @ignore */ export type NullBuffer = Uint8Array | null | undefined;\n/** @ignore */ export type TypeIdsBuffer = Int8Array  | ArrayLike<number> | Iterable<number> | undefined;\n/** @ignore */ export type ValueOffsetsBuffer = Int32Array  | ArrayLike<number> | Iterable<number> | undefined;\n/** @ignore */ export type DataBuffer<T extends DataType> = T['TArray'] | ArrayLike<number> | Iterable<number> | undefined;\n\n/** @ignore */\nexport interface Buffers<T extends DataType> {\n      [BufferType.OFFSET]: Int32Array;\n        [BufferType.DATA]: T['TArray'];\n    [BufferType.VALIDITY]: Uint8Array;\n        [BufferType.TYPE]: T['TArray'];\n}\n\n/** @ignore */\nexport interface Data<T extends DataType = DataType> {\n    readonly TType: T['TType'];\n    readonly TArray: T['TArray'];\n    readonly TValue: T['TValue'];\n}\n\n/** @ignore */\nexport class Data<T extends DataType = DataType> {\n\n    public readonly type: T;\n    public readonly length: number;\n    public readonly offset: number;\n    public readonly stride: number;\n    public readonly childData: Data[];\n\n    /**\n     * The dictionary for this Vector, if any. Only used for Dictionary type.\n     */\n    public dictionary?: Vector;\n\n    public readonly values: Buffers<T>[BufferType.DATA];\n    // @ts-ignore\n    public readonly typeIds: Buffers<T>[BufferType.TYPE];\n    // @ts-ignore\n    public readonly nullBitmap: Buffers<T>[BufferType.VALIDITY];\n    // @ts-ignore\n    public readonly valueOffsets: Buffers<T>[BufferType.OFFSET];\n\n    public get typeId(): T['TType'] { return this.type.typeId; }\n    public get ArrayType(): T['ArrayType'] { return this.type.ArrayType; }\n    public get buffers() {\n        return [this.valueOffsets, this.values, this.nullBitmap, this.typeIds] as Buffers<T>;\n    }\n    public get byteLength(): number {\n        let byteLength = 0;\n        let { valueOffsets, values, nullBitmap, typeIds } = this;\n        valueOffsets && (byteLength += valueOffsets.byteLength);\n        values       && (byteLength += values.byteLength);\n        nullBitmap   && (byteLength += nullBitmap.byteLength);\n        typeIds      && (byteLength += typeIds.byteLength);\n        return this.childData.reduce((byteLength, child) => byteLength + child.byteLength, byteLength);\n    }\n\n    protected _nullCount: number | kUnknownNullCount;\n\n    public get nullCount() {\n        let nullCount = this._nullCount;\n        let nullBitmap: Uint8Array | undefined;\n        if (nullCount <= kUnknownNullCount && (nullBitmap = this.nullBitmap)) {\n            this._nullCount = nullCount = this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);\n        }\n        return nullCount;\n    }\n\n    constructor(type: T, offset: number, length: number, nullCount?: number, buffers?: Partial<Buffers<T>> | Data<T>, childData?: (Data | Vector)[], dictionary?: Vector) {\n        this.type = type;\n        this.dictionary = dictionary;\n        this.offset = Math.floor(Math.max(offset || 0, 0));\n        this.length = Math.floor(Math.max(length || 0, 0));\n        this._nullCount = Math.floor(Math.max(nullCount || 0, -1));\n        this.childData = (childData || []).map((x) => x instanceof Data ? x : x.data) as Data[];\n        let buffer: Buffers<T>[keyof Buffers<T>];\n        if (buffers instanceof Data) {\n            this.stride = buffers.stride;\n            this.values = buffers.values;\n            this.typeIds = buffers.typeIds;\n            this.nullBitmap = buffers.nullBitmap;\n            this.valueOffsets = buffers.valueOffsets;\n        } else {\n            this.stride = strideForType(type);\n            if (buffers) {\n                (buffer = (buffers as Buffers<T>)[0]) && (this.valueOffsets = buffer);\n                (buffer = (buffers as Buffers<T>)[1]) && (this.values = buffer);\n                (buffer = (buffers as Buffers<T>)[2]) && (this.nullBitmap = buffer);\n                (buffer = (buffers as Buffers<T>)[3]) && (this.typeIds = buffer);\n            }\n        }\n    }\n\n    public clone<R extends DataType>(type: R, offset = this.offset, length = this.length, nullCount = this._nullCount, buffers: Buffers<R> = <any> this, childData: (Data | Vector)[] = this.childData) {\n        return new Data(type, offset, length, nullCount, buffers, childData, this.dictionary);\n    }\n\n    public slice(offset: number, length: number): Data<T> {\n        const { stride, typeId, childData } = this;\n        // +true === 1, +false === 0, so this means\n        // we keep nullCount at 0 if it's already 0,\n        // otherwise set to the invalidated flag -1\n        const nullCount = +(this._nullCount === 0) - 1;\n        const childStride = typeId === 16 /* FixedSizeList */ ? stride : 1;\n        const buffers = this._sliceBuffers(offset, length, stride, typeId);\n        return this.clone<T>(this.type, this.offset + offset, length, nullCount, buffers,\n            // Don't slice children if we have value offsets (the variable-width types)\n            (!childData.length || this.valueOffsets) ? childData : this._sliceChildren(childData, childStride * offset, childStride * length));\n    }\n\n    public _changeLengthAndBackfillNullBitmap(newLength: number): Data<T> {\n        if (this.typeId === Type.Null) {\n            return this.clone(this.type, 0, newLength, 0);\n        }\n        const { length, nullCount } = this;\n        // start initialized with 0s (nulls), then fill from 0 to length with 1s (not null)\n        const bitmap = new Uint8Array(((newLength + 63) & ~63) >> 3).fill(255, 0, length >> 3);\n        // set all the bits in the last byte (up to bit `length - length % 8`) to 1 (not null)\n        bitmap[length >> 3] = (1 << (length - (length & ~7))) - 1;\n        // if we have a nullBitmap, truncate + slice and set it over the pre-filled 1s\n        if (nullCount > 0) {\n            bitmap.set(truncateBitmap(this.offset, length, this.nullBitmap), 0);\n        }\n        const buffers = this.buffers;\n        buffers[BufferType.VALIDITY] = bitmap;\n        return this.clone(this.type, 0, newLength, nullCount + (newLength - length), buffers);\n    }\n\n    protected _sliceBuffers(offset: number, length: number, stride: number, typeId: T['TType']): Buffers<T> {\n        let arr: any, { buffers } = this;\n        // If typeIds exist, slice the typeIds buffer\n        (arr = buffers[BufferType.TYPE]) && (buffers[BufferType.TYPE] = arr.subarray(offset, offset + length));\n        // If offsets exist, only slice the offsets buffer\n        (arr = buffers[BufferType.OFFSET]) && (buffers[BufferType.OFFSET] = arr.subarray(offset, offset + length + 1)) ||\n        // Otherwise if no offsets, slice the data buffer. Don't slice the data vector for Booleans, since the offset goes by bits not bytes\n        (arr = buffers[BufferType.DATA]) && (buffers[BufferType.DATA] = typeId === 6 ? arr : arr.subarray(stride * offset, stride * (offset + length)));\n        return buffers;\n    }\n\n    protected _sliceChildren(childData: Data[], offset: number, length: number): Data[] {\n        return childData.map((child) => child.slice(offset, length));\n    }\n\n    //\n    // Convenience methods for creating Data instances for each of the Arrow Vector types\n    //\n    /** @nocollapse */\n    public static new<T extends DataType>(type: T, offset: number, length: number, nullCount?: number, buffers?: Partial<Buffers<T>> | Data<T>, childData?: (Data | Vector)[], dictionary?: Vector): Data<T> {\n        if (buffers instanceof Data) { buffers = buffers.buffers; } else if (!buffers) { buffers = [] as Partial<Buffers<T>>; }\n        switch (type.typeId) {\n            case Type.Null:            return <unknown> Data.Null(            <unknown> type as Null,            offset, length) as Data<T>;\n            case Type.Int:             return <unknown> Data.Int(             <unknown> type as Int,             offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Dictionary:      return <unknown> Data.Dictionary(      <unknown> type as Dictionary,      offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || [], dictionary!) as Data<T>;\n            case Type.Float:           return <unknown> Data.Float(           <unknown> type as Float,           offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Bool:            return <unknown> Data.Bool(            <unknown> type as Bool,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Decimal:         return <unknown> Data.Decimal(         <unknown> type as Decimal,         offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Date:            return <unknown> Data.Date(            <unknown> type as Date_,           offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Time:            return <unknown> Data.Time(            <unknown> type as Time,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Timestamp:       return <unknown> Data.Timestamp(       <unknown> type as Timestamp,       offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Interval:        return <unknown> Data.Interval(        <unknown> type as Interval,        offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.FixedSizeBinary: return <unknown> Data.FixedSizeBinary( <unknown> type as FixedSizeBinary, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Binary:          return <unknown> Data.Binary(          <unknown> type as Binary,          offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Utf8:            return <unknown> Data.Utf8(            <unknown> type as Utf8,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.List:            return <unknown> Data.List(            <unknown> type as List,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], (childData || [])[0]) as Data<T>;\n            case Type.FixedSizeList:   return <unknown> Data.FixedSizeList(   <unknown> type as FixedSizeList,   offset, length, nullCount || 0, buffers[BufferType.VALIDITY], (childData || [])[0]) as Data<T>;\n            case Type.Struct:          return <unknown> Data.Struct(          <unknown> type as Struct,          offset, length, nullCount || 0, buffers[BufferType.VALIDITY], childData || []) as Data<T>;\n            case Type.Map:             return <unknown> Data.Map(             <unknown> type as Map_,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], (childData || [])[0]) as Data<T>;\n            case Type.Union:           return <unknown> Data.Union(           <unknown> type as Union,           offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.TYPE] || [], buffers[BufferType.OFFSET] || childData, childData) as Data<T>;\n        }\n        throw new Error(`Unrecognized typeId ${type.typeId}`);\n    }\n\n    /** @nocollapse */\n    public static Null<T extends Null>(type: T, offset: number, length: number) {\n        return new Data(type, offset, length, 0);\n    }\n    /** @nocollapse */\n    public static Int<T extends Int>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Dictionary<T extends Dictionary>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>, dictionary: Vector<T['dictionary']>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView<T['TArray']>(type.indices.ArrayType, data), toUint8Array(nullBitmap)], [], dictionary);\n    }\n    /** @nocollapse */\n    public static Float<T extends Float>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Bool<T extends Bool>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Decimal<T extends Decimal>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Date<T extends Date_>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Time<T extends Time>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Timestamp<T extends Timestamp>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Interval<T extends Interval>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static FixedSizeBinary<T extends FixedSizeBinary>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Binary<T extends Binary>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, data: Uint8Array) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), toUint8Array(data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Utf8<T extends Utf8>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, data: Uint8Array) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), toUint8Array(data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static List<T extends List>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, child: Data<T['valueType']> | Vector<T['valueType']>) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    /** @nocollapse */\n    public static FixedSizeList<T extends FixedSizeList>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, child: Data<T['valueType']> | Vector<T['valueType']>) {\n        return new Data(type, offset, length, nullCount, [undefined, undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    /** @nocollapse */\n    public static Struct<T extends Struct>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, children: (Data | Vector)[]) {\n        return new Data(type, offset, length, nullCount, [undefined, undefined, toUint8Array(nullBitmap)], children);\n    }\n    /** @nocollapse */\n    public static Map<T extends Map_>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, child: (Data | Vector)) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    public static Union<T extends SparseUnion>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, children: (Data | Vector)[], _?: any): Data<T>;\n    public static Union<T extends DenseUnion>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, valueOffsets: ValueOffsetsBuffer, children: (Data | Vector)[]): Data<T>;\n    public static Union<T extends Union>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, valueOffsetsOrChildren: ValueOffsetsBuffer | (Data | Vector)[], children?: (Data | Vector)[]): Data<T>;\n    /** @nocollapse */\n    public static Union<T extends Union>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, valueOffsetsOrChildren: ValueOffsetsBuffer | (Data | Vector)[], children?: (Data | Vector)[]) {\n        const buffers = <unknown> [\n            undefined, undefined,\n            toUint8Array(nullBitmap),\n            toArrayBufferView(type.ArrayType, typeIds)\n        ] as Partial<Buffers<T>>;\n        if (type.mode === UnionMode.Sparse) {\n            return new Data(type, offset, length, nullCount, buffers, valueOffsetsOrChildren as (Data | Vector)[]);\n        }\n        buffers[BufferType.OFFSET] = toInt32Array(<ValueOffsetsBuffer> valueOffsetsOrChildren);\n        return new Data(type, offset, length, nullCount, buffers, children);\n    }\n}\n\n(Data.prototype as any).childData = Object.freeze([]);\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */ const undf = void (0);\n\n/** @ignore */\nexport function valueToString(x: any) {\n    if (x === null) { return 'null'; }\n    if (x === undf) { return 'undefined'; }\n    switch (typeof x) {\n        case 'number': return `${x}`;\n        case 'bigint': return `${x}`;\n        case 'string': return `\"${x}\"`;\n    }\n    // If [Symbol.toPrimitive] is implemented (like in BN)\n    // use it instead of JSON.stringify(). This ensures we\n    // print BigInts, Decimals, and Binary in their native\n    // representation\n    if (typeof x[Symbol.toPrimitive] === 'function') {\n        return x[Symbol.toPrimitive]('string');\n    }\n    return ArrayBuffer.isView(x) ? `[${x}]` : JSON.stringify(x);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../type';\nimport { valueToString } from '../util/pretty';\nimport { BigIntAvailable } from '../util/compat';\n\n/**\n * Dynamically compile the null values into an `isValid()` function whose\n * implementation is a switch statement. Microbenchmarks in v8 indicate\n * this approach is 25% faster than using an ES6 Map.\n *\n * @example\n * console.log(createIsValidFunction([null, 'N/A', NaN]));\n * `function (x) {\n *     if (x !== x) return false;\n *     switch (x) {\n *         case null:\n *         case \"N/A\":\n *             return false;\n *     }\n *     return true;\n * }`\n *\n * @ignore\n * @param nullValues\n */\nexport function createIsValidFunction<T extends DataType = any, TNull = any>(nullValues?: ReadonlyArray<TNull>) {\n\n    if (!nullValues || nullValues.length <= 0) {\n        // @ts-ignore\n        return function isValid(value: any) { return true; };\n    }\n\n    let fnBody = '';\n    let noNaNs = nullValues.filter((x) => x === x);\n\n    if (noNaNs.length > 0) {\n        fnBody = `\n    switch (x) {${noNaNs.map((x) => `\n        case ${valueToCase(x)}:`).join('')}\n            return false;\n    }`;\n    }\n\n    // NaN doesn't equal anything including itself, so it doesn't work as a\n    // switch case. Instead we must explicitly check for NaN before the switch.\n    if (nullValues.length !== noNaNs.length) {\n        fnBody = `if (x !== x) return false;\\n${fnBody}`;\n    }\n\n    return new Function(`x`, `${fnBody}\\nreturn true;`) as (value: T['TValue'] | TNull) => boolean;\n}\n\n/** @ignore */\nfunction valueToCase(x: any) {\n    if (typeof x !== 'bigint') {\n        return valueToString(x);\n    } else if (BigIntAvailable) {\n        return `${valueToString(x)}n`;\n    }\n    return `\"${valueToString(x)}\"`;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { memcpy } from '../util/buffer';\nimport { BigIntAvailable, BigInt64Array, BigUint64Array } from '../util/compat';\nimport {\n    TypedArray, TypedArrayConstructor,\n    BigIntArray, BigIntArrayConstructor\n} from '../interfaces';\n\n/** @ignore */ type DataValue<T> = T extends TypedArray ? number : T extends BigIntArray ? WideValue<T> : T;\n/** @ignore */ type WideValue<T extends BigIntArray> = T extends BigIntArray ? bigint | Int32Array | Uint32Array : never;\n/** @ignore */ type ArrayCtor<T extends TypedArray | BigIntArray> =\n    T extends TypedArray  ? TypedArrayConstructor<T>  :\n    T extends BigIntArray ? BigIntArrayConstructor<T> :\n    any;\n\n/** @ignore */\nconst roundLengthUpToNearest64Bytes = (len: number, BPE: number) => ((((len * BPE) + 63) & ~63) || 64) / BPE;\n/** @ignore */\nconst sliceOrExtendArray = <T extends TypedArray | BigIntArray>(arr: T, len = 0) => (\n    arr.length >= len ? arr.subarray(0, len) : memcpy(new (arr.constructor as any)(len), arr, 0)\n) as T;\n\n/** @ignore */\nexport interface BufferBuilder<T extends TypedArray | BigIntArray = any, TValue = DataValue<T>> {\n    readonly offset: number;\n}\n\n/** @ignore */\nexport class BufferBuilder<T extends TypedArray | BigIntArray = any, TValue = DataValue<T>> {\n\n    constructor(buffer: T, stride = 1) {\n        this.buffer = buffer;\n        this.stride = stride;\n        this.BYTES_PER_ELEMENT = buffer.BYTES_PER_ELEMENT;\n        this.ArrayType = buffer.constructor as ArrayCtor<T>;\n        this._resize(this.length = buffer.length / stride | 0);\n    }\n\n    public buffer: T;\n    public length: number;\n    public readonly stride: number;\n    public readonly ArrayType: ArrayCtor<T>;\n    public readonly BYTES_PER_ELEMENT: number;\n\n    public get byteLength() { return this.length * this.stride * this.BYTES_PER_ELEMENT | 0; }\n    public get reservedLength() { return this.buffer.length / this.stride; }\n    public get reservedByteLength() { return this.buffer.byteLength; }\n\n    // @ts-ignore\n    public set(index: number, value: TValue) { return this; }\n    public append(value: TValue) { return this.set(this.length, value); }\n    public reserve(extra: number) {\n        if (extra > 0) {\n            this.length += extra;\n            const stride = this.stride;\n            const length = this.length * stride;\n            const reserved = this.buffer.length;\n            if (length >= reserved) {\n                this._resize(reserved === 0\n                    ? roundLengthUpToNearest64Bytes(length * 1, this.BYTES_PER_ELEMENT)\n                    : roundLengthUpToNearest64Bytes(length * 2, this.BYTES_PER_ELEMENT)\n                );\n            }\n        }\n        return this;\n    }\n    public flush(length = this.length) {\n        length = roundLengthUpToNearest64Bytes(length * this.stride, this.BYTES_PER_ELEMENT);\n        const array = sliceOrExtendArray<T>(this.buffer, length);\n        this.clear();\n        return array;\n    }\n    public clear() {\n        this.length = 0;\n        this._resize(0);\n        return this;\n    }\n    protected _resize(newLength: number) {\n        return this.buffer = <T> memcpy(new this.ArrayType(newLength), this.buffer);\n    }\n}\n\n(BufferBuilder.prototype as any).offset = 0;\n\n/** @ignore */\nexport class DataBufferBuilder<T extends TypedArray> extends BufferBuilder<T, number> {\n    public last() { return this.get(this.length - 1); }\n    public get(index: number) { return this.buffer[index]; }\n    public set(index: number, value: number) {\n        this.reserve(index - this.length + 1);\n        this.buffer[index * this.stride] = value;\n        return this;\n    }\n}\n\n/** @ignore */\nexport class BitmapBufferBuilder extends DataBufferBuilder<Uint8Array> {\n\n    constructor(data = new Uint8Array(0)) { super(data, 1 / 8); }\n\n    public numValid = 0;\n    public get numInvalid() { return this.length - this.numValid; }\n    public get(idx: number) { return this.buffer[idx >> 3] >> idx % 8 & 1; }\n    public set(idx: number, val: number) {\n        const { buffer } = this.reserve(idx - this.length + 1);\n        const byte = idx >> 3, bit = idx % 8, cur = buffer[byte] >> bit & 1;\n        // If `val` is truthy and the current bit is 0, flip it to 1 and increment `numValid`.\n        // If `val` is falsey and the current bit is 1, flip it to 0 and decrement `numValid`.\n        val ? cur === 0 && ((buffer[byte] |=  (1 << bit)), ++this.numValid)\n            : cur === 1 && ((buffer[byte] &= ~(1 << bit)), --this.numValid);\n        return this;\n    }\n    public clear() {\n        this.numValid = 0;\n        return super.clear();\n    }\n}\n\n/** @ignore */\nexport class OffsetsBufferBuilder extends DataBufferBuilder<Int32Array> {\n    constructor(data = new Int32Array(1)) { super(data, 1); }\n    public append(value: number) {\n        return this.set(this.length - 1, value);\n    }\n    public set(index: number, value: number) {\n        const offset = this.length - 1;\n        const buffer = this.reserve(index - offset + 1).buffer;\n        if (offset < index++) {\n            buffer.fill(buffer[offset], offset, index);\n        }\n        buffer[index] = buffer[index - 1] + value;\n        return this;\n    }\n    public flush(length = this.length - 1) {\n        if (length > this.length) {\n            this.set(length - 1, 0);\n        }\n        return super.flush(length + 1);\n    }\n}\n\n/** @ignore */\nexport class WideBufferBuilder<T extends TypedArray, R extends BigIntArray> extends BufferBuilder<T, DataValue<T>> {\n    // @ts-ignore\n    public buffer64: R;\n    // @ts-ignore\n    protected _ArrayType64: BigIntArrayConstructor<R>;\n    public get ArrayType64() {\n        return this._ArrayType64 || (this._ArrayType64 = <BigIntArrayConstructor<R>> (this.buffer instanceof Int32Array ? BigInt64Array : BigUint64Array));\n    }\n    public set(index: number, value: DataValue<T>) {\n        this.reserve(index - this.length + 1);\n        switch (typeof value) {\n            case 'bigint': this.buffer64[index] = value; break;\n            case 'number': this.buffer[index * this.stride] = value; break;\n            default: this.buffer.set(value as TypedArray, index * this.stride);\n        }\n        return this;\n    }\n    protected _resize(newLength: number) {\n        const data = super._resize(newLength);\n        const length = data.byteLength / (this.BYTES_PER_ELEMENT * this.stride);\n        if (BigIntAvailable) {\n            this.buffer64 = new this.ArrayType64(data.buffer, data.byteOffset, length);\n        }\n        return data;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from './vector';\nimport { BufferType } from './enum';\nimport { Data, Buffers } from './data';\nimport { createIsValidFunction } from './builder/valid';\nimport { BuilderType as B, VectorType as V} from './interfaces';\nimport { BufferBuilder, BitmapBufferBuilder, DataBufferBuilder, OffsetsBufferBuilder } from './builder/buffer';\nimport {\n    DataType, strideForType,\n    Float, Int, Decimal, FixedSizeBinary,\n    Date_, Time, Timestamp, Interval,\n    Utf8, Binary, List, Map_\n} from './type';\n\n/**\n * A set of options required to create a `Builder` instance for a given `DataType`.\n * @see {@link Builder}\n */\nexport interface BuilderOptions<T extends DataType = any, TNull = any> {\n    type: T;\n    nullValues?: TNull[] | ReadonlyArray<TNull> | null;\n    children?: { [key: string]: BuilderOptions; } | BuilderOptions[];\n}\n\n/**\n * A set of options to create an Iterable or AsyncIterable `Builder` transform function.\n * @see {@link Builder.throughIterable}\n * @see {@link Builder.throughAsyncIterable}\n */\n\nexport interface IterableBuilderOptions<T extends DataType = any, TNull = any> extends BuilderOptions<T, TNull> {\n    highWaterMark?: number;\n    queueingStrategy?: 'bytes' | 'count';\n    dictionaryHashFunction?: (value: any) => string | number;\n    valueToChildTypeId?: (builder: Builder<T, TNull>, value: any, offset: number) => number;\n}\n\n/**\n * An abstract base class for types that construct Arrow Vectors from arbitrary JavaScript values.\n *\n * A `Builder` is responsible for writing arbitrary JavaScript values\n * to ArrayBuffers and/or child Builders according to the Arrow specification\n * for each DataType, creating or resizing the underlying ArrayBuffers as necessary.\n *\n * The `Builder` for each Arrow `DataType` handles converting and appending\n * values for a given `DataType`. The high-level {@link Builder.new `Builder.new()`} convenience\n * method creates the specific `Builder` subclass for the supplied `DataType`.\n *\n * Once created, `Builder` instances support both appending values to the end\n * of the `Builder`, and random-access writes to specific indices\n * (`Builder.prototype.append(value)` is a convenience method for\n * `builder.set(builder.length, value)`). Appending or setting values beyond the\n * Builder's current length may cause the builder to grow its underlying buffers\n * or child Builders (if applicable) to accommodate the new values.\n *\n * After enough values have been written to a `Builder`, `Builder.prototype.flush()`\n * will commit the values to the underlying ArrayBuffers (or child Builders). The\n * internal Builder state will be reset, and an instance of `Data<T>` is returned.\n * Alternatively, `Builder.prototype.toVector()` will flush the `Builder` and return\n * an instance of `Vector<T>` instead.\n *\n * When there are no more values to write, use `Builder.prototype.finish()` to\n * finalize the `Builder`. This does not reset the internal state, so it is\n * necessary to call `Builder.prototype.flush()` or `toVector()` one last time\n * if there are still values queued to be flushed.\n *\n * Note: calling `Builder.prototype.finish()` is required when using a `DictionaryBuilder`,\n * because this is when it flushes the values that have been enqueued in its internal\n * dictionary's `Builder`, and creates the `dictionaryVector` for the `Dictionary` `DataType`.\n *\n * ```ts\n * import { Builder, Utf8 } from 'apache-arrow';\n *\n * const utf8Builder = Builder.new({\n *     type: new Utf8(),\n *     nullValues: [null, 'n/a']\n * });\n *\n * utf8Builder\n *     .append('hello')\n *     .append('n/a')\n *     .append('world')\n *     .append(null);\n *\n * const utf8Vector = utf8Builder.finish().toVector();\n *\n * console.log(utf8Vector.toJSON());\n * // > [\"hello\", null, \"world\", null]\n * ```\n *\n * @typeparam T The `DataType` of this `Builder`.\n * @typeparam TNull The type(s) of values which will be considered null-value sentinels.\n */\nexport abstract class Builder<T extends DataType = any, TNull = any> {\n\n    /**\n     * Create a `Builder` instance based on the `type` property of the supplied `options` object.\n     * @param {BuilderOptions<T, TNull>} options An object with a required `DataType` instance\n     * and other optional parameters to be passed to the `Builder` subclass for the given `type`.\n     *\n     * @typeparam T The `DataType` of the `Builder` to create.\n     * @typeparam TNull The type(s) of values which will be considered null-value sentinels.\n     * @nocollapse\n     */\n    // @ts-ignore\n    public static new<T extends DataType = any, TNull = any>(options: BuilderOptions<T, TNull>): B<T, TNull> {}\n\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughNode<T extends DataType = any, TNull = any>(options: import('./io/node/builder').BuilderDuplexOptions<T, TNull>): import('stream').Duplex {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughDOM<T extends DataType = any, TNull = any>(options: import('./io/whatwg/builder').BuilderTransformOptions<T, TNull>): import('./io/whatwg/builder').BuilderTransform<T, TNull> {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n\n    /**\n     * Transform a synchronous `Iterable` of arbitrary JavaScript values into a\n     * sequence of Arrow Vector<T> following the chunking semantics defined in\n     * the supplied `options` argument.\n     *\n     * This function returns a function that accepts an `Iterable` of values to\n     * transform. When called, this function returns an Iterator of `Vector<T>`.\n     *\n     * The resulting `Iterator<Vector<T>>` yields Vectors based on the\n     * `queueingStrategy` and `highWaterMark` specified in the `options` argument.\n     *\n     * * If `queueingStrategy` is `\"count\"` (or omitted), The `Iterator<Vector<T>>`\n     *   will flush the underlying `Builder` (and yield a new `Vector<T>`) once the\n     *   Builder's `length` reaches or exceeds the supplied `highWaterMark`.\n     * * If `queueingStrategy` is `\"bytes\"`, the `Iterator<Vector<T>>` will flush\n     *   the underlying `Builder` (and yield a new `Vector<T>`) once its `byteLength`\n     *   reaches or exceeds the supplied `highWaterMark`.\n     *\n     * @param {IterableBuilderOptions<T, TNull>} options An object of properties which determine the `Builder` to create and the chunking semantics to use.\n     * @returns A function which accepts a JavaScript `Iterable` of values to\n     *          write, and returns an `Iterator` that yields Vectors according\n     *          to the chunking semantics defined in the `options` argument.\n     * @nocollapse\n     */\n    public static throughIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>) {\n        return throughIterable(options);\n    }\n\n    /**\n     * Transform an `AsyncIterable` of arbitrary JavaScript values into a\n     * sequence of Arrow Vector<T> following the chunking semantics defined in\n     * the supplied `options` argument.\n     *\n     * This function returns a function that accepts an `AsyncIterable` of values to\n     * transform. When called, this function returns an AsyncIterator of `Vector<T>`.\n     *\n     * The resulting `AsyncIterator<Vector<T>>` yields Vectors based on the\n     * `queueingStrategy` and `highWaterMark` specified in the `options` argument.\n     *\n     * * If `queueingStrategy` is `\"count\"` (or omitted), The `AsyncIterator<Vector<T>>`\n     *   will flush the underlying `Builder` (and yield a new `Vector<T>`) once the\n     *   Builder's `length` reaches or exceeds the supplied `highWaterMark`.\n     * * If `queueingStrategy` is `\"bytes\"`, the `AsyncIterator<Vector<T>>` will flush\n     *   the underlying `Builder` (and yield a new `Vector<T>`) once its `byteLength`\n     *   reaches or exceeds the supplied `highWaterMark`.\n     *\n     * @param {IterableBuilderOptions<T, TNull>} options An object of properties which determine the `Builder` to create and the chunking semantics to use.\n     * @returns A function which accepts a JavaScript `AsyncIterable` of values\n     *          to write, and returns an `AsyncIterator` that yields Vectors\n     *          according to the chunking semantics defined in the `options`\n     *          argument.\n     * @nocollapse\n     */\n    public static throughAsyncIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>) {\n        return throughAsyncIterable(options);\n    }\n\n    /**\n     * Construct a builder with the given Arrow DataType with optional null values,\n     * which will be interpreted as \"null\" when set or appended to the `Builder`.\n     * @param {{ type: T, nullValues?: any[] }} options A `BuilderOptions` object used to create this `Builder`.\n     */\n    constructor({ 'type': type, 'nullValues': nulls }: BuilderOptions<T, TNull>) {\n        this.type = type;\n        this.children = [];\n        this.nullValues = nulls;\n        this.stride = strideForType(type);\n        this._nulls = new BitmapBufferBuilder();\n        if (nulls && nulls.length > 0) {\n            this._isValid = createIsValidFunction(nulls);\n        }\n    }\n\n    /**\n     * The Builder's `DataType` instance.\n     * @readonly\n     */\n    public type: T;\n    /**\n     * The number of values written to the `Builder` that haven't been flushed yet.\n     * @readonly\n     */\n    public length = 0;\n    /**\n     * A boolean indicating whether `Builder.prototype.finish()` has been called on this `Builder`.\n     * @readonly\n     */\n    public finished = false;\n    /**\n     * The number of elements in the underlying values TypedArray that\n     * represent a single logical element, determined by this Builder's\n     * `DataType`. This is 1 for most types, but is larger when the `DataType`\n     * is `Int64`, `Uint64`, `Decimal`, `DateMillisecond`, certain variants of\n     * `Interval`, `Time`, or `Timestamp`, `FixedSizeBinary`, and `FixedSizeList`.\n     * @readonly\n     */\n    public readonly stride: number;\n    public readonly children: Builder[];\n    /**\n     * The list of null-value sentinels for this `Builder`. When one of these values\n     * is written to the `Builder` (either via `Builder.prototype.set()` or `Builder.prototype.append()`),\n     * a 1-bit is written to this Builder's underlying null BitmapBufferBuilder.\n     * @readonly\n     */\n    public readonly nullValues?: TNull[] | ReadonlyArray<TNull> | null;\n\n    /**\n     * Flush the `Builder` and return a `Vector<T>`.\n     * @returns {Vector<T>} A `Vector<T>` of the flushed values.\n     */\n    public toVector() { return Vector.new(this.flush()); }\n\n    public get ArrayType() { return this.type.ArrayType; }\n    public get nullCount() { return this._nulls.numInvalid; }\n    public get numChildren() { return this.children.length; }\n\n    /**\n     * @returns The aggregate length (in bytes) of the values that have been written.\n     */\n    public get byteLength(): number {\n        let size = 0;\n        this._offsets && (size += this._offsets.byteLength);\n        this._values && (size += this._values.byteLength);\n        this._nulls && (size += this._nulls.byteLength);\n        this._typeIds && (size += this._typeIds.byteLength);\n        return this.children.reduce((size, child) => size + child.byteLength, size);\n    }\n\n    /**\n     * @returns The aggregate number of rows that have been reserved to write new values.\n     */\n    public get reservedLength(): number {\n        return this._nulls.reservedLength;\n    }\n\n    /**\n     * @returns The aggregate length (in bytes) that has been reserved to write new values.\n     */\n    public get reservedByteLength(): number {\n        let size = 0;\n        this._offsets && (size += this._offsets.reservedByteLength);\n        this._values && (size += this._values.reservedByteLength);\n        this._nulls && (size += this._nulls.reservedByteLength);\n        this._typeIds && (size += this._typeIds.reservedByteLength);\n        return this.children.reduce((size, child) => size + child.reservedByteLength, size);\n    }\n\n    // @ts-ignore\n    protected _offsets: DataBufferBuilder<Int32Array>;\n    public get valueOffsets() { return this._offsets ? this._offsets.buffer : null; }\n\n    // @ts-ignore\n    protected _values: BufferBuilder<T['TArray'], any>;\n    public get values() { return this._values ? this._values.buffer : null; }\n\n    protected _nulls: BitmapBufferBuilder;\n    public get nullBitmap() { return this._nulls ? this._nulls.buffer : null; }\n\n    // @ts-ignore\n    protected _typeIds: DataBufferBuilder<Int8Array>;\n    public get typeIds() { return this._typeIds ? this._typeIds.buffer : null; }\n\n    // @ts-ignore\n    protected _isValid: (value: T['TValue'] | TNull) => boolean;\n    // @ts-ignore\n    protected _setValue: (inst: Builder<T>, index: number, value: T['TValue']) => void;\n\n    /**\n     * Appends a value (or null) to this `Builder`.\n     * This is equivalent to `builder.set(builder.length, value)`.\n     * @param {T['TValue'] | TNull } value The value to append.\n     */\n    public append(value: T['TValue'] | TNull) { return this.set(this.length, value); }\n\n    /**\n     * Validates whether a value is valid (true), or null (false)\n     * @param {T['TValue'] | TNull } value The value to compare against null the value representations\n     */\n    // @ts-ignore\n    public isValid(value: T['TValue'] | TNull): boolean { return this._isValid(value); }\n\n    /**\n     * Write a value (or null-value sentinel) at the supplied index.\n     * If the value matches one of the null-value representations, a 1-bit is\n     * written to the null `BitmapBufferBuilder`. Otherwise, a 0 is written to\n     * the null `BitmapBufferBuilder`, and the value is passed to\n     * `Builder.prototype.setValue()`.\n     * @param {number} index The index of the value to write.\n     * @param {T['TValue'] | TNull } value The value to write at the supplied index.\n     * @returns {this} The updated `Builder` instance.\n     */\n    public set(index: number, value: T['TValue'] | TNull) {\n        if (this.setValid(index, this.isValid(value))) {\n            this.setValue(index, value);\n        }\n        return this;\n    }\n\n    /**\n     * Write a value to the underlying buffers at the supplied index, bypassing\n     * the null-value check. This is a low-level method that\n     * @param {number} index\n     * @param {T['TValue'] | TNull } value\n     */\n    // @ts-ignore\n    public setValue(index: number, value: T['TValue']) { this._setValue(this, index, value); }\n    public setValid(index: number, valid: boolean) {\n        this.length = this._nulls.set(index, +valid).length;\n        return valid;\n    }\n\n    // @ts-ignore\n    public addChild(child: Builder, name = `${this.numChildren}`) {\n        throw new Error(`Cannot append children to non-nested type \"${this.type}\"`);\n    }\n\n    /**\n     * Retrieve the child `Builder` at the supplied `index`, or null if no child\n     * exists at that index.\n     * @param {number} index The index of the child `Builder` to retrieve.\n     * @returns {Builder | null} The child Builder at the supplied index or null.\n     */\n    public getChildAt<R extends DataType = any>(index: number): Builder<R> | null {\n        return this.children[index] || null;\n    }\n\n    /**\n     * Commit all the values that have been written to their underlying\n     * ArrayBuffers, including any child Builders if applicable, and reset\n     * the internal `Builder` state.\n     * @returns A `Data<T>` of the buffers and childData representing the values written.\n     */\n    public flush() {\n\n        const buffers: any = [];\n        const values =  this._values;\n        const offsets =  this._offsets;\n        const typeIds =  this._typeIds;\n        const { length, nullCount } = this;\n\n        if (typeIds) { /* Unions */\n            buffers[BufferType.TYPE] = typeIds.flush(length);\n            // DenseUnions\n            offsets && (buffers[BufferType.OFFSET] = offsets.flush(length));\n        } else if (offsets) { /* Variable-width primitives (Binary, Utf8) and Lists */\n            // Binary, Utf8\n            values && (buffers[BufferType.DATA] = values.flush(offsets.last()));\n            buffers[BufferType.OFFSET] = offsets.flush(length);\n        } else if (values) { /* Fixed-width primitives (Int, Float, Decimal, Time, Timestamp, and Interval) */\n            buffers[BufferType.DATA] = values.flush(length);\n        }\n\n        nullCount > 0 && (buffers[BufferType.VALIDITY] = this._nulls.flush(length));\n\n        const data = Data.new<T>(\n            this.type, 0, length, nullCount, buffers as Buffers<T>,\n            this.children.map((child) => child.flush())) as Data<T>;\n\n        this.clear();\n\n        return data;\n    }\n\n    /**\n     * Finalize this `Builder`, and child builders if applicable.\n     * @returns {this} The finalized `Builder` instance.\n     */\n    public finish() {\n        this.finished = true;\n        this.children.forEach((child) => child.finish());\n        return this;\n    }\n\n    /**\n     * Clear this Builder's internal state, including child Builders if applicable, and reset the length to 0.\n     * @returns {this} The cleared `Builder` instance.\n     */\n    public clear() {\n        this.length = 0;\n        this._offsets && (this._offsets.clear());\n        this._values && (this._values.clear());\n        this._nulls && (this._nulls.clear());\n        this._typeIds && (this._typeIds.clear());\n        this.children.forEach((child) => child.clear());\n        return this;\n    }\n}\n\n(Builder.prototype as any).length = 1;\n(Builder.prototype as any).stride = 1;\n(Builder.prototype as any).children = null;\n(Builder.prototype as any).finished = false;\n(Builder.prototype as any).nullValues = null;\n(Builder.prototype as any)._isValid = () => true;\n\n/** @ignore */\nexport abstract class FixedWidthBuilder<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval = any, TNull = any> extends Builder<T, TNull> {\n    constructor(opts: BuilderOptions<T, TNull>) {\n        super(opts);\n        this._values = new DataBufferBuilder(new this.ArrayType(0), this.stride);\n    }\n    public setValue(index: number, value: T['TValue']) {\n        const values = this._values;\n        values.reserve(index - values.length + 1);\n        return super.setValue(index, value);\n    }\n}\n\n/** @ignore */\nexport abstract class VariableWidthBuilder<T extends Binary | Utf8 | List | Map_, TNull = any> extends Builder<T, TNull> {\n    protected _pendingLength: number = 0;\n    protected _offsets: OffsetsBufferBuilder;\n    protected _pending: Map<number, any> | undefined;\n    constructor(opts: BuilderOptions<T, TNull>) {\n        super(opts);\n        this._offsets = new OffsetsBufferBuilder();\n    }\n    public setValue(index: number, value: T['TValue']) {\n        const pending = this._pending || (this._pending = new Map());\n        const current = pending.get(index);\n        current && (this._pendingLength -= current.length);\n        this._pendingLength += value.length;\n        pending.set(index, value);\n    }\n    public setValid(index: number, isValid: boolean) {\n        if (!super.setValid(index, isValid)) {\n            (this._pending || (this._pending = new Map())).set(index, undefined);\n            return false;\n        }\n        return true;\n    }\n    public clear() {\n        this._pendingLength = 0;\n        this._pending = undefined;\n        return super.clear();\n    }\n    public flush() {\n        this._flush();\n        return super.flush();\n    }\n    public finish() {\n        this._flush();\n        return super.finish();\n    }\n    protected _flush() {\n        const pending = this._pending;\n        const pendingLength = this._pendingLength;\n        this._pendingLength = 0;\n        this._pending = undefined;\n        if (pending && pending.size > 0) {\n            this._flushPending(pending, pendingLength);\n        }\n        return this;\n    }\n    protected abstract _flushPending(pending: Map<number, any>, pendingLength: number): void;\n}\n\n/** @ignore */\ntype ThroughIterable<T extends DataType = any, TNull = any> = (source: Iterable<T['TValue'] | TNull>) => IterableIterator<V<T>>;\n\n/** @ignore */\nfunction throughIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>): ThroughIterable<T, TNull> {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty: 'length' | 'byteLength' = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return function*(source: Iterable<T['TValue'] | TNull>) {\n        let numChunks = 0;\n        let builder = Builder.new(options);\n        for (const value of source) {\n            if (builder.append(value)[sizeProperty] >= highWaterMark) {\n                ++numChunks && (yield builder.toVector());\n            }\n        }\n        if (builder.finish().length > 0 || numChunks === 0) {\n            yield builder.toVector();\n        }\n    };\n}\n\n/** @ignore */\ntype ThroughAsyncIterable<T extends DataType = any, TNull = any> = (source: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull>) => AsyncIterableIterator<V<T>>;\n\n/** @ignore */\nfunction throughAsyncIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>): ThroughAsyncIterable<T, TNull> {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty: 'length' | 'byteLength' = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return async function* (source: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull>) {\n        let numChunks = 0;\n        let builder = Builder.new(options);\n        for await (const value of source) {\n            if (builder.append(value)[sizeProperty] >= highWaterMark) {\n                ++numChunks && (yield builder.toVector());\n            }\n        }\n        if (builder.finish().length > 0 || numChunks === 0) {\n            yield builder.toVector();\n        }\n    };\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Bool } from '../type';\nimport { BitmapBufferBuilder } from './buffer';\nimport { Builder, BuilderOptions } from '../builder';\n\n/** @ignore */\nexport class BoolBuilder<TNull = any> extends Builder<Bool, TNull> {\n    constructor(options: BuilderOptions<Bool, TNull>) {\n        super(options);\n        this._values = new BitmapBufferBuilder();\n    }\n    public setValue(index: number, value: boolean) {\n        this._values.set(index, +value);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Null } from '../type';\nimport { Builder } from '../builder';\n\n/** @ignore */\nexport class NullBuilder<TNull = any> extends Builder<Null, TNull> {\n    // @ts-ignore\n    public setValue(index: number, value: null) {}\n    public setValid(index: number, valid: boolean) {\n        this.length = Math.max(index + 1, this.length);\n        return valid;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Date_, DateDay, DateMillisecond } from '../type';\n\n/** @ignore */\nexport class DateBuilder<T extends Date_ = Date_, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class DateDayBuilder<TNull = any> extends DateBuilder<DateDay, TNull> {}\n/** @ignore */\nexport class DateMillisecondBuilder<TNull = any> extends DateBuilder<DateMillisecond, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Decimal } from '../type';\nimport { FixedWidthBuilder } from '../builder';\n\n/** @ignore */\nexport class DecimalBuilder<TNull = any> extends FixedWidthBuilder<Decimal, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { IntBuilder } from './int';\nimport { Dictionary, DataType } from '../type';\nimport { Builder, BuilderOptions } from '../builder';\n\ntype DictionaryHashFunction = (x: any) => string | number;\n\nexport interface DictionaryBuilderOptions<T extends DataType = any, TNull = any> extends BuilderOptions<T, TNull> {\n    dictionaryHashFunction?: DictionaryHashFunction;\n}\n\n/** @ignore */\nexport class DictionaryBuilder<T extends Dictionary, TNull = any> extends Builder<T, TNull> {\n\n    protected _dictionaryOffset: number;\n    protected _dictionary?: Vector<T['dictionary']>;\n    protected _keysToIndices: { [key: string]: number };\n    public readonly indices: IntBuilder<T['indices']>;\n    public readonly dictionary: Builder<T['dictionary']>;\n\n    constructor({ 'type': type, 'nullValues': nulls, 'dictionaryHashFunction': hashFn }: DictionaryBuilderOptions<T, TNull>) {\n        super({ type: new Dictionary(type.dictionary, type.indices, type.id, type.isOrdered) as T });\n        this._nulls = <any> null;\n        this._dictionaryOffset = 0;\n        this._keysToIndices = Object.create(null);\n        this.indices = Builder.new({ 'type': this.type.indices, 'nullValues': nulls }) as IntBuilder<T['indices']>;\n        this.dictionary = Builder.new({ 'type': this.type.dictionary, 'nullValues': null }) as Builder<T['dictionary']>;\n        if (typeof hashFn === 'function') {\n            this.valueToKey = hashFn;\n        }\n    }\n\n    public get values() { return this.indices.values; }\n    public get nullCount() { return this.indices.nullCount; }\n    public get nullBitmap() { return this.indices.nullBitmap; }\n    public get byteLength() { return this.indices.byteLength + this.dictionary.byteLength; }\n    public get reservedLength() { return this.indices.reservedLength + this.dictionary.reservedLength; }\n    public get reservedByteLength() { return this.indices.reservedByteLength + this.dictionary.reservedByteLength; }\n    public isValid(value: T['TValue'] | TNull) { return this.indices.isValid(value); }\n    public setValid(index: number, valid: boolean) {\n        const indices = this.indices;\n        valid = indices.setValid(index, valid);\n        this.length = indices.length;\n        return valid;\n    }\n    public setValue(index: number, value: T['TValue']) {\n        let keysToIndices = this._keysToIndices;\n        let key = this.valueToKey(value);\n        let idx = keysToIndices[key];\n        if (idx === undefined) {\n            keysToIndices[key] = idx = this._dictionaryOffset + this.dictionary.append(value).length - 1;\n        }\n        return this.indices.setValue(index, idx);\n    }\n    public flush() {\n        const type = this.type;\n        const prev = this._dictionary;\n        const curr = this.dictionary.toVector();\n        const data = this.indices.flush().clone(type);\n        data.dictionary = prev ? prev.concat(curr) : curr;\n        this.finished || (this._dictionaryOffset += curr.length);\n        this._dictionary = data.dictionary as Vector<T['dictionary']>;\n        this.clear();\n        return data;\n    }\n    public finish() {\n        this.indices.finish();\n        this.dictionary.finish();\n        this._dictionaryOffset = 0;\n        this._keysToIndices = Object.create(null);\n        return super.finish();\n    }\n    public clear() {\n        this.indices.clear();\n        this.dictionary.clear();\n        return super.clear();\n    }\n    public valueToKey(val: any): string | number {\n        return typeof val === 'string' ? val : `${val}`;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedSizeBinary } from '../type';\nimport { FixedWidthBuilder } from '../builder';\n\n/** @ignore */\nexport class FixedSizeBinaryBuilder<TNull = any> extends FixedWidthBuilder<FixedSizeBinary, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nconst f64 = new Float64Array(1);\nconst u32 = new Uint32Array(f64.buffer);\n\n/**\n * Convert uint16 (logically a float16) to a JS float64. Inspired by numpy's `npy_half_to_double`:\n * https://github.com/numpy/numpy/blob/5a5987291dc95376bb098be8d8e5391e89e77a2c/numpy/core/src/npymath/halffloat.c#L29\n * @param h {number} the uint16 to convert\n * @private\n * @ignore\n */\nexport function uint16ToFloat64(h: number) {\n    let expo = (h & 0x7C00) >> 10;\n    let sigf = (h & 0x03FF) / 1024;\n    let sign = (-1) ** ((h & 0x8000) >> 15);\n    switch (expo) {\n        case 0x1F: return sign * (sigf ? NaN : 1 / 0);\n        case 0x00: return sign * (sigf ? 6.103515625e-5 * sigf : 0);\n    }\n    return sign * (2 ** (expo - 15)) * (1 + sigf);\n}\n\n/**\n * Convert a float64 to uint16 (assuming the float64 is logically a float16). Inspired by numpy's `npy_double_to_half`:\n * https://github.com/numpy/numpy/blob/5a5987291dc95376bb098be8d8e5391e89e77a2c/numpy/core/src/npymath/halffloat.c#L43\n * @param d {number} The float64 to convert\n * @private\n * @ignore\n */\nexport function float64ToUint16(d: number) {\n\n    if (d !== d) { return 0x7E00; } // NaN\n\n    f64[0] = d;\n\n    // Magic numbers:\n    // 0x80000000 = 10000000 00000000 00000000 00000000 -- masks the 32nd bit\n    // 0x7ff00000 = 01111111 11110000 00000000 00000000 -- masks the 21st-31st bits\n    // 0x000fffff = 00000000 00001111 11111111 11111111 -- masks the 1st-20th bit\n\n    let sign = (u32[1] & 0x80000000) >> 16 & 0xFFFF;\n    let expo = (u32[1] & 0x7ff00000), sigf = 0x0000;\n\n    if (expo >= 0x40f00000) {\n        //\n        // If exponent overflowed, the float16 is either NaN or Infinity.\n        // Rules to propagate the sign bit: mantissa > 0 ? NaN : +/-Infinity\n        //\n        // Magic numbers:\n        // 0x40F00000 = 01000000 11110000 00000000 00000000 -- 6-bit exponent overflow\n        // 0x7C000000 = 01111100 00000000 00000000 00000000 -- masks the 27th-31st bits\n        //\n        // returns:\n        // qNaN, aka 32256 decimal, 0x7E00 hex, or 01111110 00000000 binary\n        // sNaN, aka 32000 decimal, 0x7D00 hex, or 01111101 00000000 binary\n        // +inf, aka 31744 decimal, 0x7C00 hex, or 01111100 00000000 binary\n        // -inf, aka 64512 decimal, 0xFC00 hex, or 11111100 00000000 binary\n        //\n        // If mantissa is greater than 23 bits, set to +Infinity like numpy\n        if (u32[0] > 0) {\n            expo = 0x7C00;\n        } else {\n            expo = (expo & 0x7C000000) >> 16;\n            sigf = (u32[1] & 0x000fffff) >> 10;\n        }\n    } else if (expo <= 0x3f000000) {\n        //\n        // If exponent underflowed, the float is either signed zero or subnormal.\n        //\n        // Magic numbers:\n        // 0x3F000000 = 00111111 00000000 00000000 00000000 -- 6-bit exponent underflow\n        //\n        sigf = 0x100000 + (u32[1] & 0x000fffff);\n        sigf = 0x100000 + (sigf << ((expo >> 20) - 998)) >> 21;\n        expo = 0;\n    } else {\n        //\n        // No overflow or underflow, rebase the exponent and round the mantissa\n        // Magic numbers:\n        // 0x200 = 00000010 00000000 -- masks off the 10th bit\n        //\n\n        // Ensure the first mantissa bit (the 10th one) is 1 and round\n        expo = (expo - 0x3f000000) >> 10;\n        sigf = ((u32[1] & 0x000fffff) + 0x200) >> 10;\n    }\n\n    return sign | expo | sigf & 0xFFFF;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { float64ToUint16 } from '../util/math';\nimport { FixedWidthBuilder } from '../builder';\nimport { Float, Float16, Float32, Float64 } from '../type';\n\n/** @ignore */\nexport class FloatBuilder<T extends Float = Float, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n\n/** @ignore */\nexport class Float16Builder<TNull = any> extends FloatBuilder<Float16, TNull> {\n    public setValue(index: number, value: number) {\n        // convert JS float64 to a uint16\n        this._values.set(index, float64ToUint16(value));\n    }\n}\n\n/** @ignore */\nexport class Float32Builder<TNull = any> extends FloatBuilder<Float32, TNull> {\n    public setValue(index: number, value: number) {\n        this._values.set(index, value);\n    }\n}\n\n/** @ignore */\nexport class Float64Builder<TNull = any> extends FloatBuilder<Float64, TNull> {\n    public setValue(index: number, value: number) {\n        this._values.set(index, value);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { ArrayBufferViewInput, toArrayBufferView } from './buffer';\nimport { TypedArray, TypedArrayConstructor } from '../interfaces';\nimport { BigIntArray, BigIntArrayConstructor } from '../interfaces';\nimport { BigIntAvailable, BigInt64Array, BigUint64Array } from './compat';\n\n/** @ignore */\nexport const isArrowBigNumSymbol = Symbol.for('isArrowBigNum');\n\n/** @ignore */ type BigNumArray = IntArray | UintArray;\n/** @ignore */ type IntArray = Int8Array | Int16Array | Int32Array;\n/** @ignore */ type UintArray = Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray;\n\n/** @ignore */\nfunction BigNum(this: any, x: any, ...xs: any) {\n    if (xs.length === 0) {\n        return Object.setPrototypeOf(toArrayBufferView(this['TypedArray'], x), this.constructor.prototype);\n    }\n    return Object.setPrototypeOf(new this['TypedArray'](x, ...xs), this.constructor.prototype);\n}\n\nBigNum.prototype[isArrowBigNumSymbol] = true;\nBigNum.prototype.toJSON = function<T extends BN<BigNumArray>>(this: T) { return `\"${bignumToString(this)}\"`; };\nBigNum.prototype.valueOf = function<T extends BN<BigNumArray>>(this: T) { return bignumToNumber(this); };\nBigNum.prototype.toString = function<T extends BN<BigNumArray>>(this: T) { return bignumToString(this); };\nBigNum.prototype[Symbol.toPrimitive] = function<T extends BN<BigNumArray>>(this: T, hint: 'string' | 'number' | 'default' = 'default') {\n    switch (hint) {\n        case 'number': return bignumToNumber(this);\n        case 'string': return bignumToString(this);\n        case 'default': return bignumToBigInt(this);\n    }\n    return bignumToString(this);\n};\n\n/** @ignore */\ntype TypedArrayConstructorArgs =\n    [number | void] |\n    [Iterable<number> | Iterable<bigint>] |\n    [ArrayBufferLike, number | void, number | void] ;\n\n/** @ignore */\nfunction SignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }\n/** @ignore */\nfunction UnsignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }\n/** @ignore */\nfunction DecimalBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }\n\nObject.setPrototypeOf(SignedBigNum.prototype,   Object.create(Int32Array.prototype));\nObject.setPrototypeOf(UnsignedBigNum.prototype, Object.create(Uint32Array.prototype));\nObject.setPrototypeOf(DecimalBigNum.prototype,  Object.create(Uint32Array.prototype));\nObject.assign(SignedBigNum.prototype,   BigNum.prototype, { 'constructor': SignedBigNum,   'signed': true,  'TypedArray': Int32Array,  'BigIntArray': BigInt64Array  });\nObject.assign(UnsignedBigNum.prototype, BigNum.prototype, { 'constructor': UnsignedBigNum, 'signed': false, 'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });\nObject.assign(DecimalBigNum.prototype,  BigNum.prototype, { 'constructor': DecimalBigNum,  'signed': true,  'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });\n\n/** @ignore */\nfunction bignumToNumber<T extends BN<BigNumArray>>(bn: T) {\n    let { buffer, byteOffset, length, 'signed': signed } = bn;\n    let words = new Int32Array(buffer, byteOffset, length);\n    let number = 0, i = 0, n = words.length, hi, lo;\n    while (i < n) {\n        lo = words[i++];\n        hi = words[i++];\n        signed || (hi = hi >>> 0);\n        number += (lo >>> 0) + (hi * (i ** 32));\n    }\n    return number;\n}\n\n/** @ignore */\nexport let bignumToString: { <T extends BN<BigNumArray>>(a: T): string; };\n/** @ignore */\nexport let bignumToBigInt: { <T extends BN<BigNumArray>>(a: T): bigint; };\n\nif (!BigIntAvailable) {\n    bignumToString = decimalToString;\n    bignumToBigInt = <any> bignumToString;\n} else {\n    bignumToBigInt = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0] : <any>decimalToString(a));\n    bignumToString = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? `${new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0]}` : decimalToString(a));\n}\n\n/** @ignore */\nfunction decimalToString<T extends BN<BigNumArray>>(a: T) {\n    let digits = '';\n    let base64 = new Uint32Array(2);\n    let base32 = new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2);\n    let checks = new Uint32Array((base32 = new Uint16Array(base32).reverse()).buffer);\n    let i = -1, n = base32.length - 1;\n    do {\n        for (base64[0] = base32[i = 0]; i < n;) {\n            base32[i++] = base64[1] = base64[0] / 10;\n            base64[0] = ((base64[0] - base64[1] * 10) << 16) + base32[i];\n        }\n        base32[i] = base64[1] = base64[0] / 10;\n        base64[0] = base64[0] - base64[1] * 10;\n        digits = `${base64[0]}${digits}`;\n    } while (checks[0] || checks[1] || checks[2] || checks[3]);\n    return digits ? digits : `0`;\n}\n\n/** @ignore */\nexport class BN<T extends BigNumArray> {\n    /** @nocollapse */\n    public static new<T extends BigNumArray>(num: T, isSigned?: boolean): (T & BN<T>) {\n        switch (isSigned) {\n            case true: return new (<any> SignedBigNum)(num) as (T & BN<T>);\n            case false: return new (<any> UnsignedBigNum)(num) as (T & BN<T>);\n        }\n        switch (num.constructor) {\n            case Int8Array:\n            case Int16Array:\n            case Int32Array:\n            case BigInt64Array:\n                return new (<any> SignedBigNum)(num) as (T & BN<T>);\n        }\n        if (num.byteLength === 16) {\n            return new (<any> DecimalBigNum)(num) as (T & BN<T>);\n        }\n        return new (<any> UnsignedBigNum)(num) as (T & BN<T>);\n    }\n    /** @nocollapse */\n    public static signed<T extends IntArray>(num: T): (T & BN<T>) {\n        return new (<any> SignedBigNum)(num) as (T & BN<T>);\n    }\n    /** @nocollapse */\n    public static unsigned<T extends UintArray>(num: T): (T & BN<T>) {\n        return new (<any> UnsignedBigNum)(num) as (T & BN<T>);\n    }\n    /** @nocollapse */\n    public static decimal<T extends UintArray>(num: T): (T & BN<T>) {\n        return new (<any> DecimalBigNum)(num) as (T & BN<T>);\n    }\n    constructor(num: T, isSigned?: boolean) {\n        return BN.new(num, isSigned) as any;\n    }\n}\n\n/** @ignore */\nexport interface BN<T extends BigNumArray> extends TypedArrayLike<T> {\n\n    new<T extends ArrayBufferViewInput>(buffer: T, signed?: boolean): T;\n\n    readonly signed: boolean;\n    readonly TypedArray: TypedArrayConstructor<TypedArray>;\n    readonly BigIntArray: BigIntArrayConstructor<BigIntArray>;\n\n    [Symbol.toStringTag]:\n        'Int8Array'         |\n        'Int16Array'        |\n        'Int32Array'        |\n        'Uint8Array'        |\n        'Uint16Array'       |\n        'Uint32Array'       |\n        'Uint8ClampedArray';\n\n    /**\n     * Convert the bytes to their (positive) decimal representation for printing\n     */\n    toString(): string;\n    /**\n     * Down-convert the bytes to a 53-bit precision integer. Invoked by JS for\n     * arithmetic operators, like `+`. Easy (and unsafe) way to convert BN to\n     * number via `+bn_inst`\n     */\n    valueOf(): number;\n    /**\n     * Return the JSON representation of the bytes. Must be wrapped in double-quotes,\n     * so it's compatible with JSON.stringify().\n     */\n    toJSON(): string;\n    [Symbol.toPrimitive](hint?: any): number | string | bigint;\n}\n\n/** @ignore */\ninterface TypedArrayLike<T extends BigNumArray> {\n\n    readonly length: number;\n    readonly buffer: ArrayBuffer;\n    readonly byteLength: number;\n    readonly byteOffset: number;\n    readonly BYTES_PER_ELEMENT: number;\n\n    includes(searchElement: number, fromIndex?: number | undefined): boolean;\n    copyWithin(target: number, start: number, end?: number | undefined): this;\n    every(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): boolean;\n    fill(value: number, start?: number | undefined, end?: number | undefined): this;\n    filter(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): T;\n    find(predicate: (value: number, index: number, obj: T) => boolean, thisArg?: any): number | undefined;\n    findIndex(predicate: (value: number, index: number, obj: T) => boolean, thisArg?: any): number;\n    forEach(callbackfn: (value: number, index: number, array: T) => void, thisArg?: any): void;\n    indexOf(searchElement: number, fromIndex?: number | undefined): number;\n    join(separator?: string | undefined): string;\n    lastIndexOf(searchElement: number, fromIndex?: number | undefined): number;\n    map(callbackfn: (value: number, index: number, array: T) => number, thisArg?: any): T;\n    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number): number;\n    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number, initialValue: number): number;\n    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: T) => U, initialValue: U): U;\n    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number): number;\n    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number, initialValue: number): number;\n    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: T) => U, initialValue: U): U;\n    reverse(): T;\n    set(array: ArrayLike<number>, offset?: number | undefined): void;\n    slice(start?: number | undefined, end?: number | undefined): T;\n    some(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): boolean;\n    sort(compareFn?: ((a: number, b: number) => number) | undefined): this;\n    subarray(begin: number, end?: number | undefined): T;\n    toLocaleString(): string;\n    entries(): IterableIterator<[number, number]>;\n    keys(): IterableIterator<number>;\n    values(): IterableIterator<number>;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { bignumToBigInt } from '../util/bn';\nimport { WideBufferBuilder } from './buffer';\nimport { BigInt64Array } from '../util/compat';\nimport { FixedWidthBuilder, BuilderOptions } from '../builder';\nimport { Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64 } from '../type';\n\n/** @ignore */\nexport class IntBuilder<T extends Int = Int, TNull = any> extends FixedWidthBuilder<T, TNull> {\n    public setValue(index: number, value: T['TValue']) {\n        this._values.set(index, value);\n    }\n}\n\n/** @ignore */\nexport class Int8Builder<TNull = any> extends IntBuilder<Int8, TNull> {}\n/** @ignore */\nexport class Int16Builder<TNull = any> extends IntBuilder<Int16, TNull> {}\n/** @ignore */\nexport class Int32Builder<TNull = any> extends IntBuilder<Int32, TNull> {}\n/** @ignore */\nexport class Int64Builder<TNull = any> extends IntBuilder<Int64, TNull> {\n    protected _values: WideBufferBuilder<Int32Array, BigInt64Array>;\n    constructor(options: BuilderOptions<Int64, TNull>) {\n        if (options['nullValues']) {\n            options['nullValues'] = (options['nullValues'] as TNull[]).map(toBigInt);\n        }\n        super(options);\n        this._values = new WideBufferBuilder(new Int32Array(0), 2);\n    }\n    public get values64() { return this._values.buffer64; }\n    public isValid(value: Int32Array | bigint | TNull) { return super.isValid(toBigInt(value)); }\n}\n\n/** @ignore */\nexport class Uint8Builder<TNull = any> extends IntBuilder<Uint8, TNull> {}\n/** @ignore */\nexport class Uint16Builder<TNull = any> extends IntBuilder<Uint16, TNull> {}\n/** @ignore */\nexport class Uint32Builder<TNull = any> extends IntBuilder<Uint32, TNull> {}\n/** @ignore */\nexport class Uint64Builder<TNull = any> extends IntBuilder<Uint64, TNull> {\n    protected _values: WideBufferBuilder<Uint32Array, BigUint64Array>;\n    constructor(options: BuilderOptions<Uint64, TNull>) {\n        if (options['nullValues']) {\n            options['nullValues'] = (options['nullValues'] as TNull[]).map(toBigInt);\n        }\n        super(options);\n        this._values = new WideBufferBuilder(new Uint32Array(0), 2);\n    }\n    public get values64() { return this._values.buffer64; }\n    public isValid(value: Uint32Array | bigint | TNull) { return super.isValid(toBigInt(value)); }\n}\n\nconst toBigInt = ((memo: any) => (value: any) => {\n    if (ArrayBuffer.isView(value)) {\n        memo.buffer = value.buffer;\n        memo.byteOffset = value.byteOffset;\n        memo.byteLength = value.byteLength;\n        value = bignumToBigInt(memo);\n        memo.buffer = null;\n    }\n    return value;\n})({ 'BigIntArray': BigInt64Array });\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond } from '../type';\n\n/** @ignore */\nexport class TimeBuilder<T extends Time = Time, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class TimeSecondBuilder<TNull = any> extends TimeBuilder<TimeSecond, TNull> {}\n/** @ignore */\nexport class TimeMillisecondBuilder<TNull = any> extends TimeBuilder<TimeMillisecond, TNull> {}\n/** @ignore */\nexport class TimeMicrosecondBuilder<TNull = any> extends TimeBuilder<TimeMicrosecond, TNull> {}\n/** @ignore */\nexport class TimeNanosecondBuilder<TNull = any> extends TimeBuilder<TimeNanosecond, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond } from '../type';\n\n/** @ignore */\nexport class TimestampBuilder<T extends Timestamp = Timestamp, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class TimestampSecondBuilder<TNull = any> extends TimestampBuilder<TimestampSecond, TNull> {}\n/** @ignore */\nexport class TimestampMillisecondBuilder<TNull = any> extends TimestampBuilder<TimestampMillisecond, TNull> {}\n/** @ignore */\nexport class TimestampMicrosecondBuilder<TNull = any> extends TimestampBuilder<TimestampMicrosecond, TNull> {}\n/** @ignore */\nexport class TimestampNanosecondBuilder<TNull = any> extends TimestampBuilder<TimestampNanosecond, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Interval, IntervalDayTime, IntervalYearMonth } from '../type';\n\n/** @ignore */\nexport class IntervalBuilder<T extends Interval = Interval, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class IntervalDayTimeBuilder<TNull = any> extends IntervalBuilder<IntervalDayTime, TNull> {}\n/** @ignore */\nexport class IntervalYearMonthBuilder<TNull = any> extends IntervalBuilder<IntervalYearMonth, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Binary } from '../type';\nimport { toUint8Array } from '../util/buffer';\nimport { BufferBuilder } from './buffer';\nimport { VariableWidthBuilder, BuilderOptions } from '../builder';\n\n/** @ignore */\nexport class BinaryBuilder<TNull = any> extends VariableWidthBuilder<Binary, TNull> {\n    constructor(opts: BuilderOptions<Binary, TNull>) {\n        super(opts);\n        this._values = new BufferBuilder(new Uint8Array(0));\n    }\n    public get byteLength(): number {\n        let size = this._pendingLength + (this.length * 4);\n        this._offsets && (size += this._offsets.byteLength);\n        this._values && (size += this._values.byteLength);\n        this._nulls && (size += this._nulls.byteLength);\n        return size;\n    }\n    public setValue(index: number, value: Uint8Array) {\n        return super.setValue(index, toUint8Array(value));\n    }\n    protected _flushPending(pending: Map<number, Uint8Array | undefined>, pendingLength: number) {\n        const offsets = this._offsets;\n        const data = this._values.reserve(pendingLength).buffer;\n        let index = 0, length = 0, offset = 0, value: Uint8Array | undefined;\n        for ([index, value] of pending) {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            } else {\n                length = value.length;\n                data.set(value, offset);\n                offsets.set(index, length);\n                offset += length;\n            }\n        }\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Utf8 } from '../type';\nimport { encodeUtf8 } from '../util/utf8';\nimport { BinaryBuilder } from './binary';\nimport { BufferBuilder } from './buffer';\nimport { VariableWidthBuilder, BuilderOptions } from '../builder';\n\n/** @ignore */\nexport class Utf8Builder<TNull = any> extends VariableWidthBuilder<Utf8, TNull> {\n    constructor(opts: BuilderOptions<Utf8, TNull>) {\n        super(opts);\n        this._values = new BufferBuilder(new Uint8Array(0));\n    }\n    public get byteLength(): number {\n        let size = this._pendingLength + (this.length * 4);\n        this._offsets && (size += this._offsets.byteLength);\n        this._values && (size += this._values.byteLength);\n        this._nulls && (size += this._nulls.byteLength);\n        return size;\n    }\n    public setValue(index: number, value: string) {\n        return super.setValue(index, encodeUtf8(value) as any);\n    }\n    // @ts-ignore\n    protected _flushPending(pending: Map<number, Uint8Array | undefined>, pendingLength: number): void {}\n}\n\n(Utf8Builder.prototype as any)._flushPending = (BinaryBuilder.prototype as any)._flushPending;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\n\n/** @ignore */\nexport class Run<T extends DataType = any, TNull = any> {\n    // @ts-ignore\n    protected _values: ArrayLike<T['TValue'] | TNull>;\n    public get length() { return this._values.length; }\n    public get(index: number) { return this._values[index]; }\n    public clear() { this._values = <any> null; return this; }\n    public bind(values: Vector<T> | ArrayLike<T['TValue'] | TNull>) {\n        if (values instanceof Vector) {\n            return values;\n        }\n        this._values = values;\n        return this as any;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { StructVector } from './struct';\nimport { valueToString } from '../util/pretty';\nimport { DataType, Struct, RowLike } from '../type';\n\n/** @ignore */ const kParent = Symbol.for('parent');\n/** @ignore */ const kRowIndex = Symbol.for('rowIndex');\n/** @ignore */ const kKeyToIdx = Symbol.for('keyToIdx');\n/** @ignore */ const kIdxToVal = Symbol.for('idxToVal');\n/** @ignore */ const kCustomInspect = Symbol.for('nodejs.util.inspect.custom');\n\nabstract class Row<K extends PropertyKey = any, V = any> implements Map<K, V> {\n\n    public readonly size: number;\n    public readonly [Symbol.toStringTag]: string;\n\n    protected [kRowIndex]: number;\n    protected [kParent]: Vector<Struct>;\n    protected [kKeyToIdx]: Map<K, number>;\n    protected [kIdxToVal]: V[];\n\n    constructor(parent: Vector<Struct>, numKeys: number) {\n        this[kParent] = parent;\n        this.size = numKeys;\n    }\n\n    public abstract keys(): IterableIterator<K>;\n    public abstract values(): IterableIterator<V>;\n    public abstract getKey(idx: number): K;\n    public abstract getIndex(key: K): number;\n    public abstract getValue(idx: number): V;\n    public abstract setValue(idx: number, val: V): void;\n\n    public entries() { return this[Symbol.iterator](); }\n\n    public has(key: K) { return this.get(key) !== undefined; }\n\n    public get(key: K) {\n        let val = undefined;\n        if (key !== null && key !== undefined) {\n            const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n            let idx = ktoi.get(key);\n            if (idx !== undefined) {\n                const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n                ((val = itov[idx]) !== undefined) || (itov[idx] = val = this.getValue(idx));\n            } else if ((idx = this.getIndex(key)) > -1) {\n                ktoi.set(key, idx);\n                const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n                ((val = itov[idx]) !== undefined) || (itov[idx] = val = this.getValue(idx));\n            }\n        }\n        return val;\n    }\n\n    public set(key: K, val: V) {\n        if (key !== null && key !== undefined) {\n            const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n            let idx = ktoi.get(key);\n            if (idx === undefined) {\n                ktoi.set(key, idx = this.getIndex(key));\n            }\n            if (idx > -1) {\n                const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n                itov[idx] = <any> this.setValue(idx, val);\n            }\n        }\n        return this;\n    }\n\n    public clear(): void { throw new Error(`Clearing ${this[Symbol.toStringTag]} not supported.`); }\n\n    public delete(_: K): boolean { throw new Error(`Deleting ${this[Symbol.toStringTag]} values not supported.`); }\n\n    public *[Symbol.iterator](): IterableIterator<[K, V]> {\n\n        const ki = this.keys();\n        const vi = this.values();\n        const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n        const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n\n        for (let k: K, v: V, i = 0, kr: IteratorResult<K>, vr: IteratorResult<V>;\n            !((kr = ki.next()).done || (vr = vi.next()).done);\n            ++i\n        ) {\n            k = kr.value;\n            v = vr.value;\n            itov[i] = v;\n            ktoi.has(k) || ktoi.set(k, i);\n            yield [k, v];\n        }\n    }\n\n    public forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {\n\n        const ki = this.keys();\n        const vi = this.values();\n        const callback = thisArg === undefined ? callbackfn :\n            (v: V, k: K, m: Map<K, V>) => callbackfn.call(thisArg, v, k, m);\n        const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n        const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n\n        for (let k: K, v: V, i = 0, kr: IteratorResult<K>, vr: IteratorResult<V>;\n            !((kr = ki.next()).done || (vr = vi.next()).done);\n            ++i\n        ) {\n            k = kr.value;\n            v = vr.value;\n            itov[i] = v;\n            ktoi.has(k) || ktoi.set(k, i);\n            callback(v, k, this);\n        }\n    }\n\n    public toArray() { return [...this.values()]; }\n    public toJSON() {\n        const obj = {} as any;\n        this.forEach((val, key) => obj[key] = val);\n        return obj;\n    }\n\n    public inspect() { return this.toString(); }\n    public [kCustomInspect]() { return this.toString(); }\n    public toString() {\n        const str: string[] = [];\n        this.forEach((val, key) => {\n            key = valueToString(key);\n            val = valueToString(val);\n            str.push(`${key}: ${val}`);\n        });\n        return `{ ${str.join(', ')} }`;\n    }\n\n    protected static [Symbol.toStringTag] = ((proto: Row) => {\n        Object.defineProperties(proto, {\n            'size': { writable: true, enumerable: false, configurable: false, value: 0 },\n            [kParent]: { writable: true, enumerable: false, configurable: false, value: null },\n            [kRowIndex]: { writable: true, enumerable: false, configurable: false, value: -1 },\n        });\n        return (proto as any)[Symbol.toStringTag] = 'Row';\n    })(Row.prototype);\n}\n\nexport class MapRow<K extends DataType = any, V extends DataType = any> extends Row<K['TValue'], V['TValue'] | null> {\n    constructor(slice: Vector<Struct<{ key: K, value: V }>>) {\n        super(slice, slice.length);\n        return createRowProxy(this);\n    }\n    public keys() {\n        return this[kParent].getChildAt(0)![Symbol.iterator]();\n    }\n    public values() {\n        return this[kParent].getChildAt(1)![Symbol.iterator]();\n    }\n    public getKey(idx: number): K['TValue'] {\n        return this[kParent].getChildAt(0)!.get(idx);\n    }\n    public getIndex(key: K['TValue']): number {\n        return this[kParent].getChildAt(0)!.indexOf(key);\n    }\n    public getValue(index: number): V['TValue'] | null {\n        return this[kParent].getChildAt(1)!.get(index);\n    }\n    public setValue(index: number, value: V['TValue'] | null): void {\n        this[kParent].getChildAt(1)!.set(index, value);\n    }\n}\n\nexport class StructRow<T extends { [key: string]: DataType } = any> extends Row<keyof T, T[keyof T]['TValue'] | null> {\n    constructor(parent: StructVector<T>) {\n        super(parent, parent.type.children.length);\n        return defineRowProxyProperties(this);\n    }\n    public *keys() {\n        for (const field of this[kParent].type.children) {\n            yield field.name as keyof T;\n        }\n    }\n    public *values() {\n        for (const field of this[kParent].type.children) {\n            yield (this as RowLike<T>)[field.name];\n        }\n    }\n    public getKey(idx: number): keyof T {\n        return this[kParent].type.children[idx].name as keyof T;\n    }\n    public getIndex(key: keyof T): number {\n        return this[kParent].type.children.findIndex((f) => f.name === key);\n    }\n    public getValue(index: number): T[keyof T]['TValue'] | null {\n        return this[kParent].getChildAt(index)!.get(this[kRowIndex]);\n    }\n    public setValue(index: number, value: T[keyof T]['TValue'] | null): void {\n        return this[kParent].getChildAt(index)!.set(this[kRowIndex], value);\n    }\n}\n\nObject.setPrototypeOf(Row.prototype, Map.prototype);\n\n/** @ignore */\nconst defineRowProxyProperties = (() => {\n    const desc = { enumerable: true, configurable: false, get: null as any, set: null as any };\n    return <T extends Row>(row: T) => {\n        let idx = -1, ktoi = row[kKeyToIdx] || (row[kKeyToIdx] = new Map());\n        const getter = (key: any) => function(this: T) { return this.get(key); };\n        const setter = (key: any) => function(this: T, val: any) { return this.set(key, val); };\n        for (const key of row.keys()) {\n            ktoi.set(key, ++idx);\n            desc.get = getter(key);\n            desc.set = setter(key);\n            row.hasOwnProperty(key) || (desc.enumerable = true, Object.defineProperty(row, key, desc));\n            row.hasOwnProperty(idx) || (desc.enumerable = false, Object.defineProperty(row, idx, desc));\n        }\n        desc.get = desc.set = null;\n        return row;\n    };\n})();\n\n/** @ignore */\nconst createRowProxy = (() => {\n    if (typeof Proxy === 'undefined') {\n        return defineRowProxyProperties;\n    }\n    const has = Row.prototype.has;\n    const get = Row.prototype.get;\n    const set = Row.prototype.set;\n    const getKey = Row.prototype.getKey;\n    const RowProxyHandler: ProxyHandler<Row> = {\n        isExtensible() { return false; },\n        deleteProperty() { return false; },\n        preventExtensions() { return true; },\n        ownKeys(row: Row) { return [...row.keys()].map((x) => `${x}`); },\n        has(row: Row, key: PropertyKey) {\n            switch (key) {\n                case 'getKey': case 'getIndex': case 'getValue': case 'setValue': case 'toArray': case 'toJSON': case 'inspect':\n                case 'constructor': case 'isPrototypeOf': case 'propertyIsEnumerable': case 'toString': case 'toLocaleString': case 'valueOf':\n                case 'size': case 'has': case 'get': case 'set': case 'clear': case 'delete': case 'keys': case 'values': case 'entries': case 'forEach':\n                case '__proto__': case '__defineGetter__': case '__defineSetter__': case 'hasOwnProperty': case '__lookupGetter__': case '__lookupSetter__':\n                case Symbol.iterator: case Symbol.toStringTag: case kParent: case kRowIndex: case kIdxToVal: case kKeyToIdx: case kCustomInspect:\n                    return true;\n            }\n            if (typeof key === 'number' && !row.has(key)) {\n                key = row.getKey(key);\n            }\n            return row.has(key);\n        },\n        get(row: Row, key: PropertyKey, receiver: any) {\n            switch (key) {\n                case 'getKey': case 'getIndex': case 'getValue': case 'setValue': case 'toArray': case 'toJSON': case 'inspect':\n                case 'constructor': case 'isPrototypeOf': case 'propertyIsEnumerable': case 'toString': case 'toLocaleString': case 'valueOf':\n                case 'size': case 'has': case 'get': case 'set': case 'clear': case 'delete': case 'keys': case 'values': case 'entries': case 'forEach':\n                case '__proto__': case '__defineGetter__': case '__defineSetter__': case 'hasOwnProperty': case '__lookupGetter__': case '__lookupSetter__':\n                case Symbol.iterator: case Symbol.toStringTag: case kParent: case kRowIndex: case kIdxToVal: case kKeyToIdx: case kCustomInspect:\n                    return Reflect.get(row, key, receiver);\n            }\n            if (typeof key === 'number' && !has.call(receiver, key)) {\n                key = getKey.call(receiver, key);\n            }\n            return get.call(receiver, key);\n        },\n        set(row: Row, key: PropertyKey, val: any, receiver: any) {\n            switch (key) {\n                case kParent: case kRowIndex: case kIdxToVal: case kKeyToIdx:\n                    return Reflect.set(row, key, val, receiver);\n                case 'getKey': case 'getIndex': case 'getValue': case 'setValue': case 'toArray': case 'toJSON': case 'inspect':\n                case 'constructor': case 'isPrototypeOf': case 'propertyIsEnumerable': case 'toString': case 'toLocaleString': case 'valueOf':\n                case 'size': case 'has': case 'get': case 'set': case 'clear': case 'delete': case 'keys': case 'values': case 'entries': case 'forEach':\n                case '__proto__': case '__defineGetter__': case '__defineSetter__': case 'hasOwnProperty': case '__lookupGetter__': case '__lookupSetter__':\n                case Symbol.iterator: case Symbol.toStringTag:\n                    return false;\n            }\n            if (typeof key === 'number' && !has.call(receiver, key)) {\n                key = getKey.call(receiver, key);\n            }\n            return has.call(receiver, key) ? !!set.call(receiver, key, val) : false;\n        },\n    };\n    return <T extends Row>(row: T) => new Proxy(row, RowProxyHandler) as T;\n})();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { MapRow, StructRow } from '../vector/row';\nimport { compareArrayLike } from '../util/buffer';\nimport { BigInt, BigIntAvailable } from './compat';\n\n/** @ignore */\ntype RangeLike = { length: number; stride?: number };\n/** @ignore */\ntype ClampThen<T extends RangeLike> = (source: T, index: number) => any;\n/** @ignore */\ntype ClampRangeThen<T extends RangeLike> = (source: T, offset: number, length: number) => any;\n\nexport function clampIndex<T extends RangeLike>(source: T, index: number): number;\nexport function clampIndex<T extends RangeLike, N extends ClampThen<T> = ClampThen<T>>(source: T, index: number, then: N): ReturnType<N>;\n/** @ignore */\nexport function clampIndex<T extends RangeLike, N extends ClampThen<T> = ClampThen<T>>(source: T, index: number, then?: N) {\n    const length = source.length;\n    const adjust = index > -1 ? index : (length + (index % length));\n    return then ? then(source, adjust) : adjust;\n}\n\n/** @ignore */\nlet tmp: number;\nexport function clampRange<T extends RangeLike>(source: T, begin: number | undefined, end: number | undefined): [number, number];\nexport function clampRange<T extends RangeLike, N extends ClampRangeThen<T> = ClampRangeThen<T>>(source: T, begin: number | undefined, end: number | undefined, then: N): ReturnType<N>;\n/** @ignore */\nexport function clampRange<T extends RangeLike, N extends ClampRangeThen<T> = ClampRangeThen<T>>(source: T, begin: number | undefined, end: number | undefined, then?: N) {\n\n    // Adjust args similar to Array.prototype.slice. Normalize begin/end to\n    // clamp between 0 and length, and wrap around on negative indices, e.g.\n    // slice(-1, 5) or slice(5, -1)\n    let { length: len = 0 } = source;\n    let lhs = typeof begin !== 'number' ? 0 : begin;\n    let rhs = typeof end !== 'number' ? len : end;\n    // wrap around on negative start/end positions\n    (lhs < 0) && (lhs = ((lhs % len) + len) % len);\n    (rhs < 0) && (rhs = ((rhs % len) + len) % len);\n    // ensure lhs <= rhs\n    (rhs < lhs) && (tmp = lhs, lhs = rhs, rhs = tmp);\n     // ensure rhs <= length\n    (rhs > len) && (rhs = len);\n\n    return then ? then(source, lhs, rhs) : [lhs, rhs];\n}\n\nconst big0 = BigIntAvailable ? BigInt(0) : 0;\nconst isNaNFast = (value: any) => value !== value;\n\n/** @ignore */\nexport function createElementComparator(search: any) {\n    let typeofSearch = typeof search;\n    // Compare primitives\n    if (typeofSearch !== 'object' || search === null) {\n        // Compare NaN\n        if (isNaNFast(search)) {\n            return isNaNFast;\n        }\n        return typeofSearch !== 'bigint'\n            ? (value: any) => value === search\n            : (value: any) => (big0 + value) === search;\n    }\n    // Compare Dates\n    if (search instanceof Date) {\n        const valueOfSearch = search.valueOf();\n        return (value: any) => value instanceof Date ? (value.valueOf() === valueOfSearch) : false;\n    }\n    // Compare TypedArrays\n    if (ArrayBuffer.isView(search)) {\n        return (value: any) => value ? compareArrayLike(search, value) : false;\n    }\n    // Compare Maps and Rows\n    if (search instanceof Map) { return creatMapComparator(search); }\n    // Compare Array-likes\n    if (Array.isArray(search)) { return createArrayLikeComparator(search); }\n    // Compare Vectors\n    if (search instanceof Vector) { return createVectorComparator(search); }\n    // Compare non-empty Objects\n    return createObjectComparator(search);\n}\n\n/** @ignore */\nfunction createArrayLikeComparator(lhs: ArrayLike<any>) {\n    const comparators = [] as ((x: any) => boolean)[];\n    for (let i = -1, n = lhs.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs[i]);\n    }\n    return createSubElementsComparator(comparators);\n}\n\n/** @ignore */\nfunction creatMapComparator(lhs: Map<any, any>) {\n    let i = -1;\n    const comparators = [] as ((x: any) => boolean)[];\n    lhs.forEach((v) => comparators[++i] = createElementComparator(v));\n    return createSubElementsComparator(comparators);\n}\n\n/** @ignore */\nfunction createVectorComparator(lhs: Vector<any>) {\n    const comparators = [] as ((x: any) => boolean)[];\n    for (let i = -1, n = lhs.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs.get(i));\n    }\n    return createSubElementsComparator(comparators);\n}\n\n/** @ignore */\nfunction createObjectComparator(lhs: any) {\n    const keys = Object.keys(lhs);\n    // Only compare non-empty Objects\n    if (keys.length === 0) { return () => false; }\n    const comparators = [] as ((x: any) => boolean)[];\n    for (let i = -1, n = keys.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs[keys[i]]);\n    }\n    return createSubElementsComparator(comparators, keys);\n}\n\nfunction createSubElementsComparator(comparators: ((x: any) => boolean)[], keys?: Iterable<string>) {\n    return (rhs: any) => {\n        if (!rhs || typeof rhs !== 'object') {\n            return false;\n        }\n        switch (rhs.constructor) {\n            case Array: return compareArray(comparators, rhs);\n            case Map:\n            case MapRow:\n            case StructRow:\n                return compareObject(comparators, rhs, rhs.keys());\n            case Object:\n            case undefined: // support `Object.create(null)` objects\n                return compareObject(comparators, rhs, keys || Object.keys(rhs));\n        }\n        return rhs instanceof Vector ? compareVector(comparators, rhs) : false;\n    };\n}\n\nfunction compareArray(comparators: ((x: any) => boolean)[], arr: any[]) {\n    const n = comparators.length;\n    if (arr.length !== n) { return false; }\n    for (let i = -1; ++i < n;) {\n        if (!(comparators[i](arr[i]))) { return false; }\n    }\n    return true;\n}\n\nfunction compareVector(comparators: ((x: any) => boolean)[], vec: Vector) {\n    const n = comparators.length;\n    if (vec.length !== n) { return false; }\n    for (let i = -1; ++i < n;) {\n        if (!(comparators[i](vec.get(i)))) { return false; }\n    }\n    return true;\n}\n\nfunction compareObject(comparators: ((x: any) => boolean)[], obj: Map<any, any>, keys: Iterable<string>) {\n\n    const lKeyItr = keys[Symbol.iterator]();\n    const rKeyItr = obj instanceof Map ? obj.keys() : Object.keys(obj)[Symbol.iterator]();\n    const rValItr = obj instanceof Map ? obj.values() : Object.values(obj)[Symbol.iterator]();\n\n    let i = 0;\n    let n = comparators.length;\n    let rVal = rValItr.next();\n    let lKey = lKeyItr.next();\n    let rKey = rKeyItr.next();\n\n    for (; i < n && !lKey.done && !rKey.done && !rVal.done;\n         ++i, lKey = lKeyItr.next(), rKey = rKeyItr.next(), rVal = rValItr.next()) {\n        if (lKey.value !== rKey.value || !comparators[i](rVal.value)) {\n            break;\n        }\n    }\n    if (i === n && lKey.done && rKey.done && rVal.done) {\n        return true;\n    }\n    lKeyItr.return && lKeyItr.return();\n    rKeyItr.return && rKeyItr.return();\n    rValItr.return && rValItr.return();\n    return false;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Field } from '../schema';\nimport { clampRange } from '../util/vector';\nimport { DataType, Dictionary } from '../type';\nimport { selectChunkArgs } from '../util/args';\nimport { DictionaryVector } from './dictionary';\nimport { AbstractVector, Vector } from '../vector';\nimport { Clonable, Sliceable, Applicative } from '../vector';\n\n/** @ignore */\ntype ChunkedDict<T extends DataType> = T extends Dictionary ? Vector<T['dictionary']> : null | never;\n/** @ignore */\ntype ChunkedKeys<T extends DataType> = T extends Dictionary ? Vector<T['indices']> | Chunked<T['indices']> : null | never;\n\n/** @ignore */\nexport type SearchContinuation<T extends Chunked> = (column: T, chunkIndex: number, valueIndex: number) => any;\n\n/** @ignore */\nexport class Chunked<T extends DataType = any>\n    extends AbstractVector<T>\n    implements Clonable<Chunked<T>>,\n               Sliceable<Chunked<T>>,\n               Applicative<T, Chunked<T>> {\n\n    /** @nocollapse */\n    public static flatten<T extends DataType>(...vectors: (Vector<T> | Vector<T>[])[]) {\n        return selectChunkArgs<Vector<T>>(Vector, vectors);\n    }\n\n    /** @nocollapse */\n    public static concat<T extends DataType>(...vectors: (Vector<T> | Vector<T>[])[]) {\n        const chunks = Chunked.flatten<T>(...vectors);\n        return new Chunked<T>(chunks[0].type, chunks);\n    }\n\n    protected _type: T;\n    protected _length: number;\n    protected _chunks: Vector<T>[];\n    protected _numChildren: number;\n    protected _children?: Chunked[];\n    protected _nullCount: number = -1;\n    protected _chunkOffsets: Uint32Array;\n\n    constructor(type: T, chunks: Vector<T>[] = [], offsets = calculateOffsets(chunks)) {\n        super();\n        this._type = type;\n        this._chunks = chunks;\n        this._chunkOffsets = offsets;\n        this._length = offsets[offsets.length - 1];\n        this._numChildren = (this._type.children || []).length;\n    }\n\n    public get type() { return this._type; }\n    public get length() { return this._length; }\n    public get chunks() { return this._chunks; }\n    public get typeId(): T['TType'] { return this._type.typeId; }\n    public get VectorName() { return `Chunked<${this._type}>`; }\n    public get data(): Data<T> {\n        return this._chunks[0] ? this._chunks[0].data : <any> null;\n    }\n\n    public get ArrayType() { return this._type.ArrayType; }\n    public get numChildren() { return this._numChildren; }\n    public get stride() { return this._chunks[0] ? this._chunks[0].stride : 1; }\n    public get byteLength(): number {\n        return this._chunks.reduce((byteLength, chunk) => byteLength + chunk.byteLength, 0);\n    }\n    public get nullCount() {\n        let nullCount = this._nullCount;\n        if (nullCount < 0) {\n            this._nullCount = nullCount = this._chunks.reduce((x, { nullCount }) => x + nullCount, 0);\n        }\n        return nullCount;\n    }\n\n    protected _indices?: ChunkedKeys<T>;\n    public get indices(): ChunkedKeys<T> | null {\n        if (DataType.isDictionary(this._type)) {\n            if (!this._indices) {\n                const chunks = (<any> this._chunks) as DictionaryVector<T, any>[];\n                this._indices = (chunks.length === 1\n                    ? chunks[0].indices\n                    : Chunked.concat(...chunks.map((x) => x.indices))) as ChunkedKeys<T>;\n            }\n            return this._indices;\n        }\n        return null;\n    }\n    public get dictionary(): ChunkedDict<T> | null {\n        if (DataType.isDictionary(this._type)) {\n            return this._chunks[this._chunks.length - 1].data.dictionary as ChunkedDict<T>;\n        }\n        return null;\n    }\n\n    public *[Symbol.iterator](): IterableIterator<T['TValue'] | null> {\n        for (const chunk of this._chunks) {\n            yield* chunk;\n        }\n    }\n\n    public clone(chunks = this._chunks): Chunked<T> {\n        return new Chunked(this._type, chunks);\n    }\n\n    public concat(...others: Vector<T>[]): Chunked<T> {\n        return this.clone(Chunked.flatten(this, ...others));\n    }\n\n    public slice(begin?: number, end?: number): Chunked<T> {\n        return clampRange(this, begin, end, this._sliceInternal);\n    }\n\n    public getChildAt<R extends DataType = any>(index: number): Chunked<R> | null {\n\n        if (index < 0 || index >= this._numChildren) { return null; }\n\n        let columns = this._children || (this._children = []);\n        let child: Chunked<R>, field: Field<R>, chunks: Vector<R>[];\n\n        if (child = columns[index]) { return child; }\n        if (field = ((this._type.children || [])[index] as Field<R>)) {\n            chunks = this._chunks\n                .map((vector) => vector.getChildAt<R>(index))\n                .filter((vec): vec is Vector<R> => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Chunked<R>(field.type, chunks));\n            }\n        }\n\n        return null;\n    }\n\n    public search(index: number): [number, number] | null;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N): ReturnType<N>;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N) {\n        let idx = index;\n        // binary search to find the child vector and value indices\n        let offsets = this._chunkOffsets, rhs = offsets.length - 1;\n        // return early if out of bounds, or if there's just one child\n        if (idx < 0            ) { return null; }\n        if (idx >= offsets[rhs]) { return null; }\n        if (rhs <= 1           ) { return then ? then(this, 0, idx) : [0, idx]; }\n        let lhs = 0, pos = 0, mid = 0;\n        do {\n            if (lhs + 1 === rhs) {\n                return then ? then(this, lhs, idx - pos) : [lhs, idx - pos];\n            }\n            mid = lhs + ((rhs - lhs) / 2) | 0;\n            idx >= offsets[mid] ? (lhs = mid) : (rhs = mid);\n        } while (idx < offsets[rhs] && idx >= (pos = offsets[lhs]));\n        return null;\n    }\n\n    public isValid(index: number): boolean {\n        return !!this.search(index, this.isValidInternal);\n    }\n\n    public get(index: number): T['TValue'] | null {\n        return this.search(index, this.getInternal);\n    }\n\n    public set(index: number, value: T['TValue'] | null): void {\n        this.search(index, ({ chunks }, i, j) => chunks[i].set(j, value));\n    }\n\n    public indexOf(element: T['TValue'], offset?: number): number {\n        if (offset && typeof offset === 'number') {\n            return this.search(offset, (self, i, j) => this.indexOfInternal(self, i, j, element))!;\n        }\n        return this.indexOfInternal(this, 0, Math.max(0, offset || 0), element);\n    }\n\n    public toArray(): T['TArray'] {\n        const { chunks } = this;\n        const n = chunks.length;\n        let ArrayType: any = this._type.ArrayType;\n        if (n <= 0) { return new ArrayType(0); }\n        if (n <= 1) { return chunks[0].toArray(); }\n        let len = 0, src = new Array(n);\n        for (let i = -1; ++i < n;) {\n            len += (src[i] = chunks[i].toArray()).length;\n        }\n        if (ArrayType !== src[0].constructor) {\n            ArrayType = src[0].constructor;\n        }\n        let dst = new ArrayType(len);\n        let set: any = ArrayType === Array ? arraySet : typedSet;\n        for (let i = -1, idx = 0; ++i < n;) {\n            idx = set(src[i], dst, idx);\n        }\n        return dst;\n    }\n\n    protected getInternal({ _chunks }: Chunked<T>, i: number, j: number) { return _chunks[i].get(j); }\n    protected isValidInternal({ _chunks }: Chunked<T>, i: number, j: number) { return _chunks[i].isValid(j); }\n    protected indexOfInternal({ _chunks }: Chunked<T>, chunkIndex: number, fromIndex: number, element: T['TValue']) {\n        let i = chunkIndex - 1, n = _chunks.length;\n        let start = fromIndex, offset = 0, found = -1;\n        while (++i < n) {\n            if (~(found = _chunks[i].indexOf(element, start))) {\n                return offset + found;\n            }\n            start = 0;\n            offset += _chunks[i].length;\n        }\n        return -1;\n    }\n\n    protected _sliceInternal(self: Chunked<T>, begin: number, end: number) {\n        const slices: Vector<T>[] = [];\n        const { chunks, _chunkOffsets: chunkOffsets } = self;\n        for (let i = -1, n = chunks.length; ++i < n;) {\n            const chunk = chunks[i];\n            const chunkLength = chunk.length;\n            const chunkOffset = chunkOffsets[i];\n            // If the child is to the right of the slice boundary, we can stop\n            if (chunkOffset >= end) { break; }\n            // If the child is to the left of of the slice boundary, exclude\n            if (begin >= chunkOffset + chunkLength) { continue; }\n            // If the child is between both left and right boundaries, include w/o slicing\n            if (chunkOffset >= begin && (chunkOffset + chunkLength) <= end) {\n                slices.push(chunk);\n                continue;\n            }\n            // If the child overlaps one of the slice boundaries, include that slice\n            const from = Math.max(0, begin - chunkOffset);\n            const to = Math.min(end - chunkOffset, chunkLength);\n            slices.push(chunk.slice(from, to) as Vector<T>);\n        }\n        return self.clone(slices);\n    }\n}\n\n/** @ignore */\nfunction calculateOffsets<T extends DataType>(vectors: Vector<T>[]) {\n    let offsets = new Uint32Array((vectors || []).length + 1);\n    let offset = offsets[0] = 0, length = offsets.length;\n    for (let index = 0; ++index < length;) {\n        offsets[index] = (offset += vectors[index - 1].length);\n    }\n    return offsets;\n}\n\n/** @ignore */\nconst typedSet = (src: TypedArray, dst: TypedArray, offset: number) => {\n    dst.set(src, offset);\n    return (offset + src.length);\n};\n\n/** @ignore */\nconst arraySet = (src: any[], dst: any[], offset: number) => {\n    let idx = offset;\n    for (let i = -1, n = src.length; ++i < n;) {\n        dst[idx++] = src[i];\n    }\n    return idx;\n};\n\n/** @ignore */\ninterface TypedArray extends ArrayBufferView {\n    readonly length: number;\n    readonly [n: number]: number;\n    set(array: ArrayLike<number>, offset?: number): void;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Field } from './schema';\nimport { DataType } from './type';\nimport { Vector } from './vector';\nimport { Clonable, Sliceable, Applicative } from './vector';\nimport { VectorCtorArgs, VectorType as V } from './interfaces';\nimport { Chunked, SearchContinuation } from './vector/chunked';\n\nexport interface Column<T extends DataType = any> {\n    typeId: T['TType'];\n    concat(...others: Vector<T>[]): Column<T>;\n    slice(begin?: number, end?: number): Column<T>;\n    clone(chunks?: Vector<T>[], offsets?: Uint32Array): Column<T>;\n}\n\nexport class Column<T extends DataType = any>\n    extends Chunked<T>\n    implements Clonable<Column<T>>,\n               Sliceable<Column<T>>,\n               Applicative<T, Column<T>> {\n\n    public static new<T extends DataType>(field: string | Field<T>, ...chunks: (Vector<T> | Vector<T>[])[]): Column<T>;\n    public static new<T extends DataType>(field: string | Field<T>, data: Data<T>, ...args: VectorCtorArgs<V<T>>): Column<T>;\n    /** @nocollapse */\n    public static new<T extends DataType = any>(field: string | Field<T>, data: Data<T> | Vector<T> | (Data<T> | Vector<T>)[], ...rest: any[]) {\n\n        const chunks = Chunked.flatten<T>(\n            Array.isArray(data) ? [...data, ...rest] :\n            data instanceof Vector ? [data, ...rest] :\n            [Vector.new(data, ...rest)]\n        );\n\n        if (typeof field === 'string') {\n            const type = chunks[0].data.type;\n            field = new Field(field, type, true);\n        } else if (!field.nullable && chunks.some(({ nullCount }) => nullCount > 0)) {\n            field = field.clone({ nullable: true });\n        }\n        return new Column(field, chunks);\n    }\n\n    constructor(field: Field<T>, vectors: Vector<T>[] = [], offsets?: Uint32Array) {\n        vectors = Chunked.flatten<T>(...vectors);\n        super(field.type, vectors, offsets);\n        this._field = field;\n        if (vectors.length === 1 && !(this instanceof SingleChunkColumn)) {\n            return new SingleChunkColumn(field, vectors[0], this._chunkOffsets);\n        }\n    }\n\n    protected _field: Field<T>;\n    protected _children?: Column[];\n\n    public get field() { return this._field; }\n    public get name() { return this._field.name; }\n    public get nullable() { return this._field.nullable; }\n    public get metadata() { return this._field.metadata; }\n\n    public clone(chunks = this._chunks) {\n        return new Column(this._field, chunks);\n    }\n\n    public getChildAt<R extends DataType = any>(index: number): Column<R> | null {\n\n        if (index < 0 || index >= this.numChildren) { return null; }\n\n        let columns = this._children || (this._children = []);\n        let column: Column<R>, field: Field<R>, chunks: Vector<R>[];\n\n        if (column = columns[index]) { return column; }\n        if (field = ((this.type.children || [])[index] as Field<R>)) {\n            chunks = this._chunks\n                .map((vector) => vector.getChildAt<R>(index))\n                .filter((vec): vec is Vector<R> => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Column<R>(field, chunks));\n            }\n        }\n\n        return null;\n    }\n}\n\n/** @ignore */\nclass SingleChunkColumn<T extends DataType = any> extends Column<T> {\n    protected _chunk: Vector<T>;\n    constructor(field: Field<T>, vector: Vector<T>, offsets?: Uint32Array) {\n        super(field, [vector], offsets);\n        this._chunk = vector;\n    }\n    public search(index: number): [number, number] | null;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N): ReturnType<N>;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N) {\n        return then ? then(this, 0, index) : [0, index];\n    }\n    public isValid(index: number): boolean {\n        return this._chunk.isValid(index);\n    }\n    public get(index: number): T['TValue'] | null {\n        return this._chunk.get(index);\n    }\n    public set(index: number, value: T['TValue'] | null): void {\n        this._chunk.set(index, value);\n    }\n    public indexOf(element: T['TValue'], offset?: number): number {\n        return this._chunk.indexOf(element, offset);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Field } from '../schema';\nimport { Column } from '../column';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Chunked } from '../vector/chunked';\n\ntype RecordBatchCtor = typeof import('../recordbatch').RecordBatch;\n\nconst isArray = Array.isArray;\n\n/** @ignore */\nexport const selectArgs = <T>(Ctor: any, vals: any[]) => _selectArgs(Ctor, vals, [], 0) as T[];\n/** @ignore */\nexport const selectColumnArgs = <T extends { [key: string]: DataType }>(args: any[]) => {\n    const [fields, values] = _selectFieldArgs<T>(args, [[], []]);\n    return values.map((x, i) =>\n        x instanceof Column ? Column.new(x.field.clone(fields[i]), x) :\n        x instanceof Vector ? Column.new(fields[i], x) as Column<T[keyof T]> :\n                              Column.new(fields[i], [] as Vector<T[keyof T]>[]));\n};\n\n/** @ignore */\nexport const selectFieldArgs = <T extends { [key: string]: DataType }>(args: any[]) => _selectFieldArgs<T>(args, [[], []]);\n/** @ignore */\nexport const selectChunkArgs = <T>(Ctor: any, vals: any[]) => _selectChunkArgs(Ctor, vals, [], 0) as T[];\n/** @ignore */\nexport const selectVectorChildrenArgs = <T extends Vector>(Ctor: RecordBatchCtor, vals: any[]) => _selectVectorChildrenArgs(Ctor, vals, [], 0) as T[];\n/** @ignore */\nexport const selectColumnChildrenArgs = <T extends Column>(Ctor: RecordBatchCtor, vals: any[]) => _selectColumnChildrenArgs(Ctor, vals, [], 0) as T[];\n\n/** @ignore */\nfunction _selectArgs<T>(Ctor: any, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Ctor) { res[j++] = value; }\n    }\n    return res;\n}\n\n/** @ignore */\nfunction _selectChunkArgs<T>(Ctor: any, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectChunkArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Chunked) {\n            j = _selectChunkArgs(Ctor, value.chunks, res, j).length;\n        } else if (value instanceof Ctor) { res[j++] = value; }\n    }\n    return res;\n}\n\n/** @ignore */\nfunction _selectVectorChildrenArgs<T extends Vector>(Ctor: RecordBatchCtor, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectVectorChildrenArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Ctor) {\n            j = _selectArgs(Vector, value.schema.fields.map((_, i) => value.getChildAt(i)!), res, j).length;\n        } else if (value instanceof Vector) { res[j++] = value as T; }\n    }\n    return res;\n}\n\n/** @ignore */\nfunction _selectColumnChildrenArgs<T extends Column>(Ctor: RecordBatchCtor, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectColumnChildrenArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Ctor) {\n            j = _selectArgs(Column, value.schema.fields.map((f, i) => Column.new(f, value.getChildAt(i)!)), res, j).length;\n        } else if (value instanceof Column) { res[j++] = value as T; }\n    }\n    return res;\n}\n\n/** @ignore */\nconst toKeysAndValues = (xs: [any[], any[]], [k, v]: [any, any], i: number) => (xs[0][i] = k, xs[1][i] = v, xs);\n\n/** @ignore */\nfunction _selectFieldArgs<T extends { [key: string]: DataType }>(vals: any[], ret: [Field<T[keyof T]>[], Vector<T[keyof T]>[]]): [Field<T[keyof T]>[], (T[keyof T] | Vector<T[keyof T]>)[]] {\n    let keys: any[], n: number;\n    switch (n = vals.length) {\n        case 0: return ret;\n        case 1:\n            keys = ret[0];\n            if (!(vals[0])) { return ret; }\n            if (isArray(vals[0])) { return _selectFieldArgs(vals[0], ret); }\n            if (!(vals[0] instanceof Data || vals[0] instanceof Vector || vals[0] instanceof DataType)) {\n                [keys, vals] = Object.entries(vals[0]).reduce(toKeysAndValues, ret);\n            }\n            break;\n        default:\n            !isArray(keys = vals[n - 1])\n                ? (vals = isArray(vals[0]) ? vals[0] : vals, keys = [])\n                : (vals = isArray(vals[0]) ? vals[0] : vals.slice(0, n - 1));\n    }\n\n    let fieldIndex = -1;\n    let valueIndex = -1;\n    let idx = -1, len = vals.length;\n    let field: number | string | Field<T[keyof T]>;\n    let val: Vector<T[keyof T]> | Data<T[keyof T]>;\n    let [fields, values] = ret as [Field<T[keyof T]>[], any[]];\n\n    while (++idx < len) {\n        val = vals[idx];\n        if (val instanceof Column && (values[++valueIndex] = val)) {\n            fields[++fieldIndex] = val.field.clone(keys[idx], val.type, true);\n        } else {\n            ({ [idx]: field = idx } = keys);\n            if (val instanceof DataType && (values[++valueIndex] = val)) {\n                fields[++fieldIndex] = Field.new(field, val as DataType, true) as Field<T[keyof T]>;\n            } else if (val && val.type && (values[++valueIndex] = val)) {\n                val instanceof Data && (values[valueIndex] = val = Vector.new(val) as Vector);\n                fields[++fieldIndex] = Field.new(field, val.type, true) as Field<T[keyof T]>;\n            }\n        }\n    }\n    return ret;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Vector } from './vector';\nimport { DataType } from './type';\nimport { selectArgs } from './util/args';\nimport { selectFieldArgs } from './util/args';\nimport { instance as comparer } from './visitor/typecomparator';\n\ntype VectorMap = { [key: string]: Vector };\ntype Fields<T extends { [key: string]: DataType }> = (keyof T)[] | Field<T[keyof T]>[];\ntype ChildData<T extends { [key: string]: DataType }> = T[keyof T][] | Data<T[keyof T]>[] | Vector<T[keyof T]>[];\n\nexport class Schema<T extends { [key: string]: DataType } = any> {\n\n    public static from<T extends { [key: string]: DataType } = any>(children: T): Schema<T>;\n    public static from<T extends VectorMap = any>(children: T): Schema<{ [P in keyof T]: T[P]['type'] }>;\n    public static from<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): Schema<T>;\n    /** @nocollapse */\n    public static from(...args: any[]) {\n        return Schema.new(args[0], args[1]);\n    }\n\n    public static new<T extends { [key: string]: DataType } = any>(children: T): Schema<T>;\n    public static new<T extends VectorMap = any>(children: T): Schema<{ [P in keyof T]: T[P]['type'] }>;\n    public static new<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): Schema<T>;\n    /** @nocollapse */\n    public static new(...args: any[]) {\n        return new Schema(selectFieldArgs(args)[0]);\n    }\n\n    public readonly fields: Field<T[keyof T]>[];\n    public readonly metadata: Map<string, string>;\n    public readonly dictionaries: Map<number, DataType>;\n\n    constructor(fields: Field[] = [],\n                metadata?: Map<string, string> | null,\n                dictionaries?: Map<number, DataType> | null) {\n        this.fields = (fields || []) as Field<T[keyof T]>[];\n        this.metadata = metadata || new Map();\n        if (!dictionaries) {\n            dictionaries = generateDictionaryMap(fields);\n        }\n        this.dictionaries = dictionaries;\n    }\n    public get [Symbol.toStringTag]() { return 'Schema'; }\n    public toString() {\n        return `Schema<{ ${this.fields.map((f, i) => `${i}: ${f}`).join(', ')} }>`;\n    }\n\n    public compareTo(other?: Schema | null): other is Schema<T> {\n        return comparer.compareSchemas(this, other);\n    }\n\n    public select<K extends keyof T = any>(...columnNames: K[]) {\n        const names = columnNames.reduce((xs, x) => (xs[x] = true) && xs, Object.create(null));\n        return new Schema<{ [P in K]: T[P] }>(this.fields.filter((f) => names[f.name]), this.metadata);\n    }\n    public selectAt<K extends T[keyof T] = any>(...columnIndices: number[]) {\n        return new Schema<{ [key: string]: K }>(columnIndices.map((i) => this.fields[i]).filter(Boolean), this.metadata);\n    }\n\n    public assign<R extends { [key: string]: DataType } = any>(schema: Schema<R>): Schema<T & R>;\n    public assign<R extends { [key: string]: DataType } = any>(...fields: (Field<R[keyof R]> | Field<R[keyof R]>[])[]): Schema<T & R>;\n    public assign<R extends { [key: string]: DataType } = any>(...args: (Schema<R> | Field<R[keyof R]> | Field<R[keyof R]>[])[]) {\n\n        const other = args[0] instanceof Schema ? args[0] as Schema<R>\n            : new Schema<R>(selectArgs<Field<R[keyof R]>>(Field, args));\n\n        const curFields = [...this.fields] as Field[];\n        const metadata = mergeMaps(mergeMaps(new Map(), this.metadata), other.metadata);\n        const newFields = other.fields.filter((f2) => {\n            const i = curFields.findIndex((f) => f.name === f2.name);\n            return ~i ? (curFields[i] = f2.clone({\n                metadata: mergeMaps(mergeMaps(new Map(), curFields[i].metadata), f2.metadata)\n            })) && false : true;\n        }) as Field[];\n\n        const newDictionaries = generateDictionaryMap(newFields, new Map());\n\n        return new Schema<T & R>(\n            [...curFields, ...newFields], metadata,\n            new Map([...this.dictionaries, ...newDictionaries])\n        );\n    }\n}\n\nexport class Field<T extends DataType = any> {\n\n    public static new<T extends DataType = any>(props: { name: string | number, type: T, nullable?: boolean, metadata?: Map<string, string> | null }): Field<T>;\n    public static new<T extends DataType = any>(name: string | number | Field<T>, type: T, nullable?: boolean, metadata?: Map<string, string> | null): Field<T>;\n    /** @nocollapse */\n    public static new<T extends DataType = any>(...args: any[]) {\n        let [name, type, nullable, metadata] = args;\n        if (args[0] && typeof args[0] === 'object') {\n            ({ name } = args[0]);\n            (type === undefined) && (type = args[0].type);\n            (nullable === undefined) && (nullable = args[0].nullable);\n            (metadata === undefined) && (metadata = args[0].metadata);\n        }\n        return new Field<T>(`${name}`, type, nullable, metadata);\n    }\n\n    public readonly type: T;\n    public readonly name: string;\n    public readonly nullable: boolean;\n    public readonly metadata: Map<string, string>;\n\n    constructor(name: string, type: T, nullable = false, metadata?: Map<string, string> | null) {\n        this.name = name;\n        this.type = type;\n        this.nullable = nullable;\n        this.metadata = metadata || new Map();\n    }\n\n    public get typeId() { return this.type.typeId; }\n    public get [Symbol.toStringTag]() { return 'Field'; }\n    public toString() { return `${this.name}: ${this.type}`; }\n    public compareTo(other?: Field | null): other is Field<T> {\n        return comparer.compareField(this, other);\n    }\n    public clone<R extends DataType = T>(props: { name?: string | number, type?: R, nullable?: boolean, metadata?: Map<string, string> | null }): Field<R>;\n    public clone<R extends DataType = T>(name?: string | number | Field<T>, type?: R, nullable?: boolean, metadata?: Map<string, string> | null): Field<R>;\n    public clone<R extends DataType = T>(...args: any[]) {\n        let [name, type, nullable, metadata] = args;\n        (!args[0] || typeof args[0] !== 'object')\n            ? ([name = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata] = args)\n            : ({name = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata} = args[0]);\n        return Field.new<R>(name, type, nullable, metadata);\n    }\n}\n\n/** @ignore */\nfunction mergeMaps<TKey, TVal>(m1?: Map<TKey, TVal> | null, m2?: Map<TKey, TVal> | null): Map<TKey, TVal> {\n    return new Map([...(m1 || new Map()), ...(m2 || new Map())]);\n}\n\n/** @ignore */\nfunction generateDictionaryMap(fields: Field[], dictionaries = new Map<number, DataType>()): Map<number, DataType> {\n\n    for (let i = -1, n = fields.length; ++i < n;) {\n        const field = fields[i];\n        const type = field.type;\n        if (DataType.isDictionary(type)) {\n            if (!dictionaries.has(type.id)) {\n                dictionaries.set(type.id, type.dictionary);\n            } else if (dictionaries.get(type.id) !== type.dictionary) {\n                throw new Error(`Cannot create Schema containing two different dictionaries with the same Id`);\n            }\n        }\n        if (type.children && type.children.length > 0) {\n            generateDictionaryMap(type.children, dictionaries);\n        }\n    }\n\n    return dictionaries;\n}\n\n// Add these here so they're picked up by the externs creator\n// in the build, and closure-compiler doesn't minify them away\n(Schema.prototype as any).fields = null;\n(Schema.prototype as any).metadata = null;\n(Schema.prototype as any).dictionaries = null;\n\n(Field.prototype as any).type = null;\n(Field.prototype as any).name = null;\n(Field.prototype as any).nullable = null;\n(Field.prototype as any).metadata = null;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Run } from './run';\nimport { Field } from '../schema';\nimport { DataType, List } from '../type';\nimport { OffsetsBufferBuilder } from './buffer';\nimport { Builder, BuilderOptions, VariableWidthBuilder } from '../builder';\n\n/** @ignore */\nexport class ListBuilder<T extends DataType = any, TNull = any> extends VariableWidthBuilder<List<T>, TNull> {\n    protected _run = new Run<T, TNull>();\n    protected _offsets: OffsetsBufferBuilder;\n    constructor(opts: BuilderOptions<List<T>, TNull>) {\n        super(opts);\n        this._offsets = new OffsetsBufferBuilder();\n    }\n    public addChild(child: Builder<T>, name = '0') {\n        if (this.numChildren > 0) {\n            throw new Error('ListBuilder can only have one child.');\n        }\n        this.children[this.numChildren] = child;\n        this.type = new List(new Field(name, child.type, true));\n        return this.numChildren - 1;\n    }\n    public clear() {\n        this._run.clear();\n        return super.clear();\n    }\n    protected _flushPending(pending: Map<number, T['TValue'] | undefined>) {\n        const run = this._run;\n        const offsets = this._offsets;\n        const setValue = this._setValue;\n        let index = 0, value: Uint8Array | undefined;\n        for ([index, value] of pending) {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            } else {\n                offsets.set(index, value.length);\n                setValue(this, index, run.bind(value));\n            }\n        }\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Run } from './run';\nimport { Field } from '../schema';\nimport { Builder } from '../builder';\nimport { DataType, FixedSizeList } from '../type';\n\n/** @ignore */\nexport class FixedSizeListBuilder<T extends DataType = any, TNull = any> extends Builder<FixedSizeList<T>, TNull> {\n    protected _run = new Run<T, TNull>();\n    public setValue(index: number, value: T['TValue']) {\n        super.setValue(index, this._run.bind(value));\n    }\n    public addChild(child: Builder<T>, name = '0') {\n        if (this.numChildren > 0) {\n            throw new Error('FixedSizeListBuilder can only have one child.');\n        }\n        const childIndex = this.children.push(child);\n        this.type = new FixedSizeList(this.type.listSize, new Field(name, child.type, true));\n        return childIndex;\n    }\n    public clear() {\n        this._run.clear();\n        return super.clear();\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Field } from '../schema';\nimport { DataType, Map_, Struct } from '../type';\nimport { Builder, VariableWidthBuilder } from '../builder';\n\n/** @ignore */ type MapValue<K extends DataType = any, V extends DataType = any> = Map_<K, V>['TValue'];\n/** @ignore */ type MapValues<K extends DataType = any, V extends DataType = any> = Map<number, MapValue<K, V> | undefined>;\n/** @ignore */ type MapValueExt<K extends DataType = any, V extends DataType = any> = MapValue<K, V> | { [key: string]: V } | { [key: number]: V } ;\n\n/** @ignore */\nexport class MapBuilder<K extends DataType = any, V extends DataType = any, TNull = any> extends VariableWidthBuilder<Map_<K, V>, TNull> {\n\n    protected _pending: MapValues<K, V> | undefined;\n    public set(index: number, value: MapValueExt<K, V> | TNull) {\n        return super.set(index, value as MapValue<K, V> | TNull);\n    }\n\n    public setValue(index: number, value: MapValueExt<K, V>) {\n        value = value instanceof Map ? value : new Map(Object.entries(value));\n        const pending = this._pending || (this._pending = new Map() as MapValues<K, V>);\n        const current = pending.get(index);\n        current && (this._pendingLength -= current.size);\n        this._pendingLength += value.size;\n        pending.set(index, value);\n    }\n\n    public addChild(child: Builder<Struct<{ key: K, value: V }>>, name = `${this.numChildren}`) {\n        if (this.numChildren > 0) {\n            throw new Error('ListBuilder can only have one child.');\n        }\n        this.children[this.numChildren] = child;\n        this.type = new Map_<K, V>(new Field(name, child.type, true), this.type.keysSorted);\n        return this.numChildren - 1;\n    }\n\n    protected _flushPending(pending: MapValues<K, V>) {\n        const offsets = this._offsets;\n        const setValue = this._setValue;\n        pending.forEach((value, index) => {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            } else {\n                offsets.set(index, value.size);\n                setValue(this, index, value);\n            }\n        });\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Field } from '../schema';\nimport { Builder } from '../builder';\nimport { DataType, Struct } from '../type';\n\n/** @ignore */\nexport class StructBuilder<T extends { [key: string]: DataType } = any, TNull = any> extends Builder<Struct<T>, TNull> {\n    public addChild(child: Builder, name = `${this.numChildren}`) {\n        const childIndex = this.children.push(child);\n        this.type = new Struct([...this.type.children, new Field(name, child.type, true)]);\n        return childIndex;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Field } from '../schema';\nimport { DataBufferBuilder } from './buffer';\nimport { Builder, BuilderOptions } from '../builder';\nimport { Union, SparseUnion, DenseUnion } from '../type';\n\nexport interface UnionBuilderOptions<T extends Union = any, TNull = any> extends BuilderOptions<T, TNull> {\n    valueToChildTypeId?: (builder: UnionBuilder<T, TNull>, value: any, offset: number) => number;\n}\n\n/** @ignore */\nexport abstract class UnionBuilder<T extends Union, TNull = any> extends Builder<T, TNull> {\n\n    protected _typeIds: DataBufferBuilder<Int8Array>;\n\n    constructor(options: UnionBuilderOptions<T, TNull>) {\n        super(options);\n        this._typeIds = new DataBufferBuilder(new Int8Array(0), 1);\n        if (typeof options['valueToChildTypeId'] === 'function') {\n            this._valueToChildTypeId = options['valueToChildTypeId'];\n        }\n    }\n\n    public get typeIdToChildIndex() { return this.type.typeIdToChildIndex; }\n\n    public append(value: T['TValue'] | TNull, childTypeId?: number) {\n        return this.set(this.length, value, childTypeId);\n    }\n\n    public set(index: number, value: T['TValue'] | TNull, childTypeId?: number) {\n        if (childTypeId === undefined) {\n            childTypeId = this._valueToChildTypeId(this, value, index);\n        }\n        if (this.setValid(index, this.isValid(value))) {\n            this.setValue(index, value, childTypeId);\n        }\n        return this;\n    }\n\n    // @ts-ignore\n    public setValue(index: number, value: T['TValue'], childTypeId?: number) {\n        this._typeIds.set(index, childTypeId!);\n        super.setValue(index, value);\n    }\n\n    // @ts-ignore\n    public addChild(child: Builder, name = `${this.children.length}`) {\n        const childTypeId = this.children.push(child);\n        const { type: { children, mode, typeIds } } = this;\n        const fields = [...children, new Field(name, child.type)];\n        this.type = <T> new Union(mode, [...typeIds, childTypeId], fields);\n        return childTypeId;\n    }\n\n    /** @ignore */\n    // @ts-ignore\n    protected _valueToChildTypeId(builder: UnionBuilder<T, TNull>, value: any, offset: number): number {\n        throw new Error(`Cannot map UnionBuilder value to child typeId. \\\nPass the \\`childTypeId\\` as the second argument to unionBuilder.append(), \\\nor supply a \\`valueToChildTypeId\\` function as part of the UnionBuilder constructor options.`);\n    }\n}\n\n/** @ignore */\nexport class SparseUnionBuilder<T extends SparseUnion, TNull = any> extends UnionBuilder<T, TNull> {}\n/** @ignore */\nexport class DenseUnionBuilder<T extends DenseUnion, TNull = any> extends UnionBuilder<T, TNull> {\n\n    protected _offsets: DataBufferBuilder<Int32Array>;\n\n    constructor(options: UnionBuilderOptions<T, TNull>) {\n        super(options);\n        this._offsets = new DataBufferBuilder(new Int32Array(0));\n    }\n\n    /** @ignore */\n    public setValue(index: number, value: T['TValue'], childTypeId?: number) {\n        const childIndex = this.type.typeIdToChildIndex[childTypeId!];\n        this._offsets.set(index, this.getChildAt(childIndex)!.length);\n        return super.setValue(index, value, childTypeId);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Field } from '../schema';\nimport { Vector } from '../vector';\nimport { Visitor } from '../visitor';\nimport { encodeUtf8 } from '../util/utf8';\nimport { VectorType } from '../interfaces';\nimport { float64ToUint16 } from '../util/math';\nimport { toArrayBufferView } from '../util/buffer';\nimport { Type, UnionMode, Precision, DateUnit, TimeUnit, IntervalUnit } from '../enum';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface SetVisitor extends Visitor {\n    visit<T extends VectorType>(node: T, index: number, value: T['TValue']): void;\n    visitMany<T extends VectorType>(nodes: T[], indices: number[], values: T['TValue'][]): void[];\n    getVisitFn<T extends Type>(node: T): (vector: VectorType<T>, index: number, value: VectorType<T>['TValue']) => void;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>, index: number, value: VectorType<T>['TValue']) => void;\n    visitNull                 <T extends Null>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitBool                 <T extends Bool>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt                  <T extends Int>                 (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt8                 <T extends Int8>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt16                <T extends Int16>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt32                <T extends Int32>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt64                <T extends Int64>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint8                <T extends Uint8>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint16               <T extends Uint16>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint32               <T extends Uint32>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint64               <T extends Uint64>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat                <T extends Float>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat16              <T extends Float16>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat32              <T extends Float32>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat64              <T extends Float64>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUtf8                 <T extends Utf8>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitBinary               <T extends Binary>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDate                 <T extends Date_>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDateDay              <T extends DateDay>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDateMillisecond      <T extends DateMillisecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestamp            <T extends Timestamp>           (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampSecond      <T extends TimestampSecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampMillisecond <T extends TimestampMillisecond>(vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond>(vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampNanosecond  <T extends TimestampNanosecond> (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTime                 <T extends Time>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeSecond           <T extends TimeSecond>          (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeMillisecond      <T extends TimeMillisecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeNanosecond       <T extends TimeNanosecond>      (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDecimal              <T extends Decimal>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitList                 <T extends List>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitStruct               <T extends Struct>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUnion                <T extends Union>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDenseUnion           <T extends DenseUnion>          (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitSparseUnion          <T extends SparseUnion>         (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDictionary           <T extends Dictionary>          (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInterval             <T extends Interval>            (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitIntervalDayTime      <T extends IntervalDayTime>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>   (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFixedSizeList        <T extends FixedSizeList>       (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitMap                  <T extends Map_>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n}\n\n/** @ignore */\nexport class SetVisitor extends Visitor {}\n\n/** @ignore */\nconst setEpochMsToDays = (data: Int32Array, index: number, epochMs: number) => { data[index] = (epochMs / 86400000) | 0; };\n/** @ignore */\nconst setEpochMsToMillisecondsLong = (data: Int32Array, index: number, epochMs: number) => {\n    data[index] = (epochMs % 4294967296) | 0;\n    data[index + 1] = (epochMs / 4294967296) | 0;\n};\n/** @ignore */\nconst setEpochMsToMicrosecondsLong = (data: Int32Array, index: number, epochMs: number) => {\n    data[index] = ((epochMs * 1000) % 4294967296) | 0;\n    data[index + 1] = ((epochMs * 1000) / 4294967296) | 0;\n};\n/** @ignore */\nconst setEpochMsToNanosecondsLong = (data: Int32Array, index: number, epochMs: number) => {\n    data[index] = ((epochMs * 1000000) % 4294967296) | 0;\n    data[index + 1] = ((epochMs * 1000000) / 4294967296) | 0;\n};\n\n/** @ignore */\nconst setVariableWidthBytes = (values: Uint8Array, valueOffsets: Int32Array, index: number, value: Uint8Array) => {\n    const { [index]: x, [index + 1]: y } = valueOffsets;\n    if (x != null && y != null) {\n        values.set(value.subarray(0, y - x), x);\n    }\n};\n\n/** @ignore */\nconst setBool = <T extends Bool>({ offset, values }: VectorType<T>, index: number, val: boolean) => {\n    const idx = offset + index;\n    val ? (values[idx >> 3] |=  (1 << (idx % 8)))  // true\n        : (values[idx >> 3] &= ~(1 << (idx % 8))); // false\n\n};\n\n/** @ignore */ type Numeric1X = Int8 | Int16 | Int32 | Uint8 | Uint16 | Uint32 | Float32 | Float64;\n/** @ignore */ type Numeric2X = Int64 | Uint64;\n\n/** @ignore */\nconst setDateDay         = <T extends DateDay>        ({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { setEpochMsToDays(values, index, value.valueOf()); };\n/** @ignore */\nconst setDateMillisecond = <T extends DateMillisecond>({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { setEpochMsToMillisecondsLong(values, index * 2, value.valueOf()); };\n/** @ignore */\nconst setNumeric         = <T extends Numeric1X>      ({ stride, values }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = value; };\n/** @ignore */\nconst setFloat16         = <T extends Float16>        ({ stride, values }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = float64ToUint16(value); };\n/** @ignore */\nconst setNumericX2       = <T extends Numeric2X>      (vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    switch (typeof value) {\n        case 'bigint': vector.values64[index] = value; break;\n        case 'number': vector.values[index * vector.stride] = value; break;\n        default:\n            const val = value as T['TArray'];\n            const { stride, ArrayType } = vector;\n            const long = toArrayBufferView<T['TArray']>(ArrayType, val);\n            vector.values.set(long.subarray(0, stride), stride * index);\n    }\n};\n/** @ignore */\nconst setFixedSizeBinary = <T extends FixedSizeBinary>({ stride, values }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, stride), stride * index); };\n\n/** @ignore */\nconst setBinary = <T extends Binary>({ values, valueOffsets }: VectorType<T>, index: number, value: T['TValue']) => setVariableWidthBytes(values, valueOffsets, index, value);\n/** @ignore */\nconst setUtf8 = <T extends Utf8>({ values, valueOffsets }: VectorType<T>, index: number, value: T['TValue']) => {\n    setVariableWidthBytes(values, valueOffsets, index, encodeUtf8(value));\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setInt = <T extends Int>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    vector.type.bitWidth < 64\n        ? setNumeric(vector as VectorType<Numeric1X>, index, value as Numeric1X['TValue'])\n        : setNumericX2(vector as VectorType<Numeric2X>, index, value as Numeric2X['TValue']);\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setFloat = <T extends Float>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    vector.type.precision !== Precision.HALF\n        ? setNumeric(vector as VectorType<Numeric1X>, index, value)\n        : setFloat16(vector as VectorType<Float16>, index, value);\n};\n\n/* istanbul ignore next */\nconst setDate = <T extends Date_> (vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    vector.type.unit === DateUnit.DAY\n        ? setDateDay(vector as VectorType<DateDay>, index, value)\n        : setDateMillisecond(vector as VectorType<DateMillisecond>, index, value);\n};\n\n/** @ignore */\nconst setTimestampSecond      = <T extends TimestampSecond>     ({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToMillisecondsLong(values, index * 2, value / 1000);\n/** @ignore */\nconst setTimestampMillisecond = <T extends TimestampMillisecond>({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToMillisecondsLong(values, index * 2, value);\n/** @ignore */\nconst setTimestampMicrosecond = <T extends TimestampMicrosecond>({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToMicrosecondsLong(values, index * 2, value);\n/** @ignore */\nconst setTimestampNanosecond  = <T extends TimestampNanosecond> ({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToNanosecondsLong(values, index * 2, value);\n/* istanbul ignore next */\n/** @ignore */\nconst setTimestamp            = <T extends Timestamp>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      setTimestampSecond(vector as VectorType<TimestampSecond>, index, value);\n        case TimeUnit.MILLISECOND: return setTimestampMillisecond(vector as VectorType<TimestampMillisecond>, index, value);\n        case TimeUnit.MICROSECOND: return setTimestampMicrosecond(vector as VectorType<TimestampMicrosecond>, index, value);\n        case TimeUnit.NANOSECOND:  return  setTimestampNanosecond(vector as VectorType<TimestampNanosecond>, index, value);\n    }\n};\n\n/** @ignore */\nconst setTimeSecond      = <T extends TimeSecond>     ({ values, stride }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = value; };\n/** @ignore */\nconst setTimeMillisecond = <T extends TimeMillisecond>({ values, stride }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = value; };\n/** @ignore */\nconst setTimeMicrosecond = <T extends TimeMicrosecond>({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 2), 2 * index); };\n/** @ignore */\nconst setTimeNanosecond  = <T extends TimeNanosecond> ({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 2), 2 * index); };\n/* istanbul ignore next */\n/** @ignore */\nconst setTime            = <T extends Time>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      setTimeSecond(vector as VectorType<TimeSecond>, index, value as TimeSecond['TValue']);\n        case TimeUnit.MILLISECOND: return setTimeMillisecond(vector as VectorType<TimeMillisecond>, index, value as TimeMillisecond['TValue']);\n        case TimeUnit.MICROSECOND: return setTimeMicrosecond(vector as VectorType<TimeMicrosecond>, index, value as TimeMicrosecond['TValue']);\n        case TimeUnit.NANOSECOND:  return  setTimeNanosecond(vector as VectorType<TimeNanosecond>, index, value as TimeNanosecond['TValue']);\n    }\n};\n\n/** @ignore */\nconst setDecimal = <T extends Decimal>({ values }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 4), 4 * index); };\n\n/** @ignore */\nconst setList = <T extends List>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const values = vector.getChildAt(0)!, valueOffsets = vector.valueOffsets;\n    for (let idx = -1, itr = valueOffsets[index], end = valueOffsets[index + 1]; itr < end;) {\n        values.set(itr++, value.get(++idx));\n    }\n};\n\n/** @ignore */\nconst setMap = <T extends Map_>(vector: VectorType<T>, index: number, value: T['TValue']) => {\n    const values = vector.getChildAt(0)!, valueOffsets = vector.valueOffsets;\n    const entries = value instanceof Map ? [...value] : Object.entries(value);\n    for (let idx = -1, itr = valueOffsets[index], end = valueOffsets[index + 1]; itr < end;) {\n        values.set(itr++, entries[++idx]);\n    }\n};\n\n/** @ignore */ const _setStructArrayValue = (o: number, v: any[]) => (c: Vector | null, _: Field, i: number) => c && c.set(o, v[i]);\n/** @ignore */ const _setStructVectorValue = (o: number, v: Vector) => (c: Vector | null, _: Field, i: number) => c && c.set(o, v.get(i));\n/** @ignore */ const _setStructMapValue = (o: number, v: Map<string, any>) => (c: Vector | null, f: Field, _: number) => c && c.set(o, v.get(f.name));\n/** @ignore */ const _setStructObjectValue = (o: number, v: { [key: string]: any }) => (c: Vector | null, f: Field, _: number) => c && c.set(o, v[f.name]);\n/** @ignore */\nconst setStruct = <T extends Struct>(vector: VectorType<T>, index: number, value: T['TValue']) => {\n\n    const setValue = value instanceof Map    ? _setStructMapValue(index, value)    :\n                     value instanceof Vector ? _setStructVectorValue(index, value) :\n                     Array.isArray(value)    ? _setStructArrayValue(index, value)  :\n                                               _setStructObjectValue(index, value) ;\n\n    vector.type.children.forEach((f: Field, i: number) => setValue(vector.getChildAt(i), f, i));\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setUnion = <\n    V extends VectorType<Union> | VectorType<DenseUnion> | VectorType<SparseUnion>\n>(vector: V, index: number, value: V['TValue']) => {\n    vector.type.mode === UnionMode.Dense ?\n        setDenseUnion(vector as VectorType<DenseUnion>, index, value) :\n        setSparseUnion(vector as VectorType<SparseUnion>, index, value);\n};\n\n/** @ignore */\nconst setDenseUnion = <T extends DenseUnion>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    child && child.set(vector.valueOffsets[index], value);\n};\n\n/** @ignore */\nconst setSparseUnion = <T extends SparseUnion>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    child && child.set(index, value);\n};\n\n/** @ignore */\nconst setDictionary = <T extends Dictionary>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const key = vector.getKey(index);\n    if (key !== null) {\n        vector.setValue(key, value);\n    }\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setIntervalValue = <T extends Interval>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    (vector.type.unit === IntervalUnit.DAY_TIME)\n        ? setIntervalDayTime(vector as VectorType<IntervalDayTime>, index, value)\n        : setIntervalYearMonth(vector as VectorType<IntervalYearMonth>, index, value);\n};\n\n/** @ignore */\nconst setIntervalDayTime = <T extends IntervalDayTime>({ values }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 2), 2 * index); };\n/** @ignore */\nconst setIntervalYearMonth = <T extends IntervalYearMonth>({ values }: VectorType<T>, index: number, value: T['TValue']): void => { values[index] = (value[0] * 12) + (value[1] % 12); };\n\n/** @ignore */\nconst setFixedSizeList = <T extends FixedSizeList>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const child = vector.getChildAt(0)!, { stride } = vector;\n    for (let idx = -1, offset = index * stride; ++idx < stride;) {\n        child.set(offset + idx, value.get(idx));\n    }\n};\n\nSetVisitor.prototype.visitBool                 =                 setBool;\nSetVisitor.prototype.visitInt                  =                  setInt;\nSetVisitor.prototype.visitInt8                 =              setNumeric;\nSetVisitor.prototype.visitInt16                =              setNumeric;\nSetVisitor.prototype.visitInt32                =              setNumeric;\nSetVisitor.prototype.visitInt64                =            setNumericX2;\nSetVisitor.prototype.visitUint8                =              setNumeric;\nSetVisitor.prototype.visitUint16               =              setNumeric;\nSetVisitor.prototype.visitUint32               =              setNumeric;\nSetVisitor.prototype.visitUint64               =            setNumericX2;\nSetVisitor.prototype.visitFloat                =                setFloat;\nSetVisitor.prototype.visitFloat16              =              setFloat16;\nSetVisitor.prototype.visitFloat32              =              setNumeric;\nSetVisitor.prototype.visitFloat64              =              setNumeric;\nSetVisitor.prototype.visitUtf8                 =                 setUtf8;\nSetVisitor.prototype.visitBinary               =               setBinary;\nSetVisitor.prototype.visitFixedSizeBinary      =      setFixedSizeBinary;\nSetVisitor.prototype.visitDate                 =                 setDate;\nSetVisitor.prototype.visitDateDay              =              setDateDay;\nSetVisitor.prototype.visitDateMillisecond      =      setDateMillisecond;\nSetVisitor.prototype.visitTimestamp            =            setTimestamp;\nSetVisitor.prototype.visitTimestampSecond      =      setTimestampSecond;\nSetVisitor.prototype.visitTimestampMillisecond = setTimestampMillisecond;\nSetVisitor.prototype.visitTimestampMicrosecond = setTimestampMicrosecond;\nSetVisitor.prototype.visitTimestampNanosecond  =  setTimestampNanosecond;\nSetVisitor.prototype.visitTime                 =                 setTime;\nSetVisitor.prototype.visitTimeSecond           =           setTimeSecond;\nSetVisitor.prototype.visitTimeMillisecond      =      setTimeMillisecond;\nSetVisitor.prototype.visitTimeMicrosecond      =      setTimeMicrosecond;\nSetVisitor.prototype.visitTimeNanosecond       =       setTimeNanosecond;\nSetVisitor.prototype.visitDecimal              =              setDecimal;\nSetVisitor.prototype.visitList                 =                 setList;\nSetVisitor.prototype.visitStruct               =               setStruct;\nSetVisitor.prototype.visitUnion                =                setUnion;\nSetVisitor.prototype.visitDenseUnion           =           setDenseUnion;\nSetVisitor.prototype.visitSparseUnion          =          setSparseUnion;\nSetVisitor.prototype.visitDictionary           =           setDictionary;\nSetVisitor.prototype.visitInterval             =        setIntervalValue;\nSetVisitor.prototype.visitIntervalDayTime      =      setIntervalDayTime;\nSetVisitor.prototype.visitIntervalYearMonth    =    setIntervalYearMonth;\nSetVisitor.prototype.visitFixedSizeList        =        setFixedSizeList;\nSetVisitor.prototype.visitMap                  =                  setMap;\n\n/** @ignore */\nexport const instance = new SetVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { DataType } from '../type';\nimport { Visitor } from '../visitor';\nimport { VectorType, BuilderCtor } from '../interfaces';\nimport { BinaryBuilder } from '../builder/binary';\nimport { BoolBuilder } from '../builder/bool';\nimport { DateBuilder, DateDayBuilder, DateMillisecondBuilder } from '../builder/date';\nimport { DecimalBuilder } from '../builder/decimal';\nimport { DictionaryBuilder } from '../builder/dictionary';\nimport { FixedSizeBinaryBuilder } from '../builder/fixedsizebinary';\nimport { FixedSizeListBuilder } from '../builder/fixedsizelist';\nimport { FloatBuilder, Float16Builder, Float32Builder, Float64Builder } from '../builder/float';\nimport { IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder } from '../builder/interval';\nimport { IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder } from '../builder/int';\nimport { ListBuilder } from '../builder/list';\nimport { MapBuilder } from '../builder/map';\nimport { NullBuilder } from '../builder/null';\nimport { StructBuilder } from '../builder/struct';\nimport { TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder } from '../builder/timestamp';\nimport { TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder } from '../builder/time';\nimport { UnionBuilder, DenseUnionBuilder, SparseUnionBuilder } from '../builder/union';\nimport { Utf8Builder } from '../builder/utf8';\n\n/** @ignore */\nexport interface GetBuilderCtor extends Visitor {\n    visit<T extends Type>(type: T): BuilderCtor<T>;\n    visitMany<T extends Type>(types: T[]): BuilderCtor<T>[];\n    getVisitFn<T extends Type>(type: T): () => BuilderCtor<T>;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): () => BuilderCtor<T>;\n}\n\n/** @ignore */\nexport class GetBuilderCtor extends Visitor {\n    public visitNull                 () { return NullBuilder;                 }\n    public visitBool                 () { return BoolBuilder;                 }\n    public visitInt                  () { return IntBuilder;                  }\n    public visitInt8                 () { return Int8Builder;                 }\n    public visitInt16                () { return Int16Builder;                }\n    public visitInt32                () { return Int32Builder;                }\n    public visitInt64                () { return Int64Builder;                }\n    public visitUint8                () { return Uint8Builder;                }\n    public visitUint16               () { return Uint16Builder;               }\n    public visitUint32               () { return Uint32Builder;               }\n    public visitUint64               () { return Uint64Builder;               }\n    public visitFloat                () { return FloatBuilder;                }\n    public visitFloat16              () { return Float16Builder;              }\n    public visitFloat32              () { return Float32Builder;              }\n    public visitFloat64              () { return Float64Builder;              }\n    public visitUtf8                 () { return Utf8Builder;                 }\n    public visitBinary               () { return BinaryBuilder;               }\n    public visitFixedSizeBinary      () { return FixedSizeBinaryBuilder;      }\n    public visitDate                 () { return DateBuilder;                 }\n    public visitDateDay              () { return DateDayBuilder;              }\n    public visitDateMillisecond      () { return DateMillisecondBuilder;      }\n    public visitTimestamp            () { return TimestampBuilder;            }\n    public visitTimestampSecond      () { return TimestampSecondBuilder;      }\n    public visitTimestampMillisecond () { return TimestampMillisecondBuilder; }\n    public visitTimestampMicrosecond () { return TimestampMicrosecondBuilder; }\n    public visitTimestampNanosecond  () { return TimestampNanosecondBuilder;  }\n    public visitTime                 () { return TimeBuilder;                 }\n    public visitTimeSecond           () { return TimeSecondBuilder;           }\n    public visitTimeMillisecond      () { return TimeMillisecondBuilder;      }\n    public visitTimeMicrosecond      () { return TimeMicrosecondBuilder;      }\n    public visitTimeNanosecond       () { return TimeNanosecondBuilder;       }\n    public visitDecimal              () { return DecimalBuilder;              }\n    public visitList                 () { return ListBuilder;                 }\n    public visitStruct               () { return StructBuilder;               }\n    public visitUnion                () { return UnionBuilder;                }\n    public visitDenseUnion           () { return DenseUnionBuilder;           }\n    public visitSparseUnion          () { return SparseUnionBuilder;          }\n    public visitDictionary           () { return DictionaryBuilder;           }\n    public visitInterval             () { return IntervalBuilder;             }\n    public visitIntervalDayTime      () { return IntervalDayTimeBuilder;      }\n    public visitIntervalYearMonth    () { return IntervalYearMonthBuilder;    }\n    public visitFixedSizeList        () { return FixedSizeListBuilder;        }\n    public visitMap                  () { return MapBuilder;                  }\n}\n\n/** @ignore */\nexport const instance = new GetBuilderCtor();\n","// automatically generated by the FlatBuffers compiler, do not modify\n\nimport { flatbuffers } from 'flatbuffers';\nimport * as NS7624605610262437867 from './Schema';\n/**\n * ----------------------------------------------------------------------\n * Arrow File metadata\n *\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Footer {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Footer\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Footer {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Footer= obj\n         * @returns Footer\n         */\n        static getRootAsFooter(bb: flatbuffers.ByteBuffer, obj?: Footer): Footer {\n            return (obj || new Footer).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.MetadataVersion\n         */\n        version(): NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1;\n        }\n\n        /**\n         * @param org.apache.arrow.flatbuf.Schema= obj\n         * @returns org.apache.arrow.flatbuf.Schema|null\n         */\n        schema(obj?: NS7624605610262437867.org.apache.arrow.flatbuf.Schema): NS7624605610262437867.org.apache.arrow.flatbuf.Schema | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new NS7624605610262437867.org.apache.arrow.flatbuf.Schema).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Block= obj\n         * @returns org.apache.arrow.flatbuf.Block\n         */\n        dictionaries(index: number, obj?: org.apache.arrow.flatbuf.Block): org.apache.arrow.flatbuf.Block | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Block).__init(this.bb!.__vector(this.bb_pos + offset) + index * 24, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        dictionariesLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Block= obj\n         * @returns org.apache.arrow.flatbuf.Block\n         */\n        recordBatches(index: number, obj?: org.apache.arrow.flatbuf.Block): org.apache.arrow.flatbuf.Block | null {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Block).__init(this.bb!.__vector(this.bb_pos + offset) + index * 24, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        recordBatchesLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFooter(builder: flatbuffers.Builder) {\n            builder.startObject(4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.MetadataVersion version\n         */\n        static addVersion(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion) {\n            builder.addFieldInt16(0, version, NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset schemaOffset\n         */\n        static addSchema(builder: flatbuffers.Builder, schemaOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, schemaOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset dictionariesOffset\n         */\n        static addDictionaries(builder: flatbuffers.Builder, dictionariesOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, dictionariesOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startDictionariesVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(24, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset recordBatchesOffset\n         */\n        static addRecordBatches(builder: flatbuffers.Builder, recordBatchesOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(3, recordBatchesOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startRecordBatchesVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(24, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFooter(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset offset\n         */\n        static finishFooterBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n            builder.finish(offset);\n        }\n\n        static createFooter(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion, schemaOffset: flatbuffers.Offset, dictionariesOffset: flatbuffers.Offset, recordBatchesOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Footer.startFooter(builder);\n            Footer.addVersion(builder, version);\n            Footer.addSchema(builder, schemaOffset);\n            Footer.addDictionaries(builder, dictionariesOffset);\n            Footer.addRecordBatches(builder, recordBatchesOffset);\n            return Footer.endFooter(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Block {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Block\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Block {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * Index to the start of the RecordBlock (note this is past the Message header)\n         *\n         * @returns flatbuffers.Long\n         */\n        offset(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos);\n        }\n\n        /**\n         * Length of the metadata\n         *\n         * @returns number\n         */\n        metaDataLength(): number {\n            return this.bb!.readInt32(this.bb_pos + 8);\n        }\n\n        /**\n         * Length of the data (this is aligned so there can be a gap between this and\n         * the metatdata).\n         *\n         * @returns flatbuffers.Long\n         */\n        bodyLength(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos + 16);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long offset\n         * @param number metaDataLength\n         * @param flatbuffers.Long bodyLength\n         * @returns flatbuffers.Offset\n         */\n        static createBlock(builder: flatbuffers.Builder, offset: flatbuffers.Long, metaDataLength: number, bodyLength: flatbuffers.Long): flatbuffers.Offset {\n            builder.prep(8, 24);\n            builder.writeInt64(bodyLength);\n            builder.pad(4);\n            builder.writeInt32(metaDataLength);\n            builder.writeInt64(offset);\n            return builder.offset();\n        }\n\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nexport { Builder, BuilderOptions } from '../builder';\nexport { BoolBuilder } from './bool';\nexport { NullBuilder } from './null';\nexport { DateBuilder, DateDayBuilder, DateMillisecondBuilder } from './date';\nexport { DecimalBuilder } from './decimal';\nexport { DictionaryBuilder } from './dictionary';\nexport { FixedSizeBinaryBuilder } from './fixedsizebinary';\nexport { FloatBuilder, Float16Builder, Float32Builder, Float64Builder } from './float';\nexport { IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder } from './int';\nexport { TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder } from './time';\nexport { TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder } from './timestamp';\nexport { IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder } from './interval';\nexport { Utf8Builder } from './utf8';\nexport { BinaryBuilder } from './binary';\nexport { ListBuilder } from './list';\nexport { FixedSizeListBuilder } from './fixedsizelist';\nexport { MapBuilder } from './map';\nexport { StructBuilder } from './struct';\nexport { UnionBuilder, SparseUnionBuilder, DenseUnionBuilder } from './union';\n\nimport { Type } from '../enum';\nimport { Field } from '../schema';\nimport { DataType } from '../type';\nimport { Utf8Builder } from './utf8';\nimport { BuilderType as B } from '../interfaces';\nimport { Builder, BuilderOptions } from '../builder';\nimport { instance as setVisitor } from '../visitor/set';\nimport { instance as getBuilderConstructor } from '../visitor/builderctor';\n\n/** @nocollapse */\nBuilder.new = newBuilder;\n\nfunction newBuilder<T extends DataType = any, TNull = any>(options: BuilderOptions<T, TNull>): B<T, TNull> {\n\n    const type = options.type;\n    const builder = new (getBuilderConstructor.getVisitFn<T>(type)())(options) as Builder<T, TNull>;\n\n    if (type.children && type.children.length > 0) {\n\n        const children = options['children'] || [] as BuilderOptions[];\n        const defaultOptions = { 'nullValues': options['nullValues'] };\n        const getChildOptions = Array.isArray(children)\n            ? ((_: Field, i: number) => children[i] || defaultOptions)\n            : (({ name }: Field) => children[name] || defaultOptions);\n\n        type.children.forEach((field, index) => {\n            const { type } = field;\n            const opts = getChildOptions(field, index);\n            builder.children.push(newBuilder({ ...opts, type }));\n        });\n    }\n\n    return builder as B<T, TNull>;\n}\n\n(Object.keys(Type) as any[])\n    .map((T: any) => Type[T] as any)\n    .filter((T: any): T is Type => typeof T === 'number' && T !== Type.NONE)\n    .forEach((typeId) => {\n        const BuilderCtor = getBuilderConstructor.visit(typeId);\n        BuilderCtor.prototype._setValue = setVisitor.getVisitFn(typeId);\n    });\n\n(Utf8Builder.prototype as any)._setValue = setVisitor.visitBinary;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/* tslint:disable:class-name */\n\nimport * as File_ from '../../fb/File';\nimport { flatbuffers } from 'flatbuffers';\n\nimport Long = flatbuffers.Long;\nimport Builder = flatbuffers.Builder;\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport _Block = File_.org.apache.arrow.flatbuf.Block;\nimport _Footer = File_.org.apache.arrow.flatbuf.Footer;\n\nimport { Schema } from '../../schema';\nimport { MetadataVersion } from '../../enum';\nimport { toUint8Array } from '../../util/buffer';\nimport { ArrayBufferViewInput } from '../../util/buffer';\n\n/** @ignore */\nclass Footer_ {\n\n    /** @nocollapse */\n    public static decode(buf: ArrayBufferViewInput) {\n        buf = new ByteBuffer(toUint8Array(buf));\n        const footer = _Footer.getRootAsFooter(buf);\n        const schema = Schema.decode(footer.schema()!);\n        return new OffHeapFooter(schema, footer) as Footer_;\n    }\n\n    /** @nocollapse */\n    public static encode(footer: Footer_) {\n\n        const b: Builder = new Builder();\n        const schemaOffset = Schema.encode(b, footer.schema);\n\n        _Footer.startRecordBatchesVector(b, footer.numRecordBatches);\n        [...footer.recordBatches()].slice().reverse().forEach((rb) => FileBlock.encode(b, rb));\n        const recordBatchesOffset = b.endVector();\n\n        _Footer.startDictionariesVector(b, footer.numDictionaries);\n        [...footer.dictionaryBatches()].slice().reverse().forEach((db) => FileBlock.encode(b, db));\n\n        const dictionaryBatchesOffset = b.endVector();\n\n        _Footer.startFooter(b);\n        _Footer.addSchema(b, schemaOffset);\n        _Footer.addVersion(b, MetadataVersion.V4);\n        _Footer.addRecordBatches(b, recordBatchesOffset);\n        _Footer.addDictionaries(b, dictionaryBatchesOffset);\n        _Footer.finishFooterBuffer(b, _Footer.endFooter(b));\n\n        return b.asUint8Array();\n    }\n\n    // @ts-ignore\n    protected _recordBatches: FileBlock[];\n    // @ts-ignore\n    protected _dictionaryBatches: FileBlock[];\n    public get numRecordBatches() { return this._recordBatches.length; }\n    public get numDictionaries() { return this._dictionaryBatches.length; }\n\n    constructor(public schema: Schema,\n                public version: MetadataVersion = MetadataVersion.V4,\n                recordBatches?: FileBlock[], dictionaryBatches?: FileBlock[]) {\n        recordBatches && (this._recordBatches = recordBatches);\n        dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);\n    }\n\n    public *recordBatches(): Iterable<FileBlock> {\n        for (let block, i = -1, n = this.numRecordBatches; ++i < n;) {\n            if (block = this.getRecordBatch(i)) { yield block; }\n        }\n    }\n\n    public *dictionaryBatches(): Iterable<FileBlock> {\n        for (let block, i = -1, n = this.numDictionaries; ++i < n;) {\n            if (block = this.getDictionaryBatch(i)) { yield block; }\n        }\n    }\n\n    public getRecordBatch(index: number) {\n        return index >= 0\n            && index < this.numRecordBatches\n            && this._recordBatches[index] || null;\n    }\n\n    public getDictionaryBatch(index: number) {\n        return index >= 0\n            && index < this.numDictionaries\n            && this._dictionaryBatches[index] || null;\n    }\n}\n\nexport { Footer_ as Footer };\n\n/** @ignore */\nclass OffHeapFooter extends Footer_ {\n\n    public get numRecordBatches() { return this._footer.recordBatchesLength(); }\n    public get numDictionaries() { return this._footer.dictionariesLength(); }\n\n    constructor(schema: Schema, protected _footer: _Footer) {\n        super(schema, _footer.version());\n    }\n\n    public getRecordBatch(index: number) {\n        if (index >= 0 && index < this.numRecordBatches) {\n            const fileBlock = this._footer.recordBatches(index);\n            if (fileBlock) { return FileBlock.decode(fileBlock); }\n        }\n        return null;\n    }\n\n    public getDictionaryBatch(index: number) {\n        if (index >= 0 && index < this.numDictionaries) {\n            const fileBlock = this._footer.dictionaries(index);\n            if (fileBlock) { return FileBlock.decode(fileBlock); }\n        }\n        return null;\n    }\n}\n\n/** @ignore */\nexport class FileBlock {\n\n    /** @nocollapse */\n    public static decode(block: _Block) {\n        return new FileBlock(block.metaDataLength(), block.bodyLength(), block.offset());\n    }\n\n    /** @nocollapse */\n    public static encode(b: Builder, fileBlock: FileBlock) {\n        const { metaDataLength } = fileBlock;\n        const offset = new Long(fileBlock.offset, 0);\n        const bodyLength = new Long(fileBlock.bodyLength, 0);\n        return _Block.createBlock(b, offset, metaDataLength, bodyLength);\n    }\n\n    public offset: number;\n    public bodyLength: number;\n    public metaDataLength: number;\n\n    constructor(metaDataLength: number, bodyLength: Long | number, offset: Long | number) {\n        this.metaDataLength = metaDataLength;\n        this.offset = typeof offset === 'number' ? offset : offset.low;\n        this.bodyLength = typeof bodyLength === 'number' ? bodyLength : bodyLength.low;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport streamAdapters from './adapters';\nimport { decodeUtf8 } from '../util/utf8';\nimport { ITERATOR_DONE, Readable, Writable, AsyncQueue } from './interfaces';\nimport { toUint8Array, joinUint8Arrays, ArrayBufferViewInput } from '../util/buffer';\n\nimport {\n    isPromise, isFetchResponse,\n    isIterable, isAsyncIterable,\n    isReadableDOMStream, isReadableNodeStream\n} from '../util/compat';\n\n/** @ignore */\nexport type WritableSink<T> = Writable<T> | WritableStream<T> | NodeJS.WritableStream | null;\n/** @ignore */\nexport type ReadableSource<T> = Readable<T> | PromiseLike<T> | AsyncIterable<T> | ReadableStream<T> | NodeJS.ReadableStream | null;\n\n/** @ignore */\nexport class AsyncByteQueue<T extends ArrayBufferViewInput = Uint8Array> extends AsyncQueue<Uint8Array, T> {\n    public write(value: ArrayBufferViewInput | Uint8Array) {\n        if ((value = toUint8Array(value)).byteLength > 0) {\n            return super.write(value as T);\n        }\n    }\n    public toString(sync: true): string;\n    public toString(sync?: false): Promise<string>;\n    public toString(sync = false) {\n        return sync\n            ? decodeUtf8(this.toUint8Array(true))\n            : this.toUint8Array(false).then(decodeUtf8);\n    }\n    public toUint8Array(sync: true): Uint8Array;\n    public toUint8Array(sync?: false): Promise<Uint8Array>;\n    public toUint8Array(sync = false) {\n        return sync ? joinUint8Arrays(this._values as any[])[0] : (async () => {\n            let buffers = [], byteLength = 0;\n            for await (const chunk of this) {\n                buffers.push(chunk);\n                byteLength += chunk.byteLength;\n            }\n            return joinUint8Arrays(buffers, byteLength)[0];\n        })();\n    }\n}\n\n/** @ignore */\nexport class ByteStream implements IterableIterator<Uint8Array> {\n    // @ts-ignore\n    private source: ByteStreamSource<Uint8Array>;\n    constructor(source?: Iterable<ArrayBufferViewInput> | ArrayBufferViewInput) {\n        if (source) {\n            this.source = new ByteStreamSource(streamAdapters.fromIterable(source));\n        }\n    }\n    [Symbol.iterator]() { return this; }\n    public next(value?: any) { return this.source.next(value); }\n    public throw(value?: any) { return this.source.throw(value); }\n    public return(value?: any) { return this.source.return(value); }\n    public peek(size?: number | null) { return this.source.peek(size); }\n    public read(size?: number | null) { return this.source.read(size); }\n}\n\n/** @ignore */\nexport class AsyncByteStream implements Readable<Uint8Array>, AsyncIterableIterator<Uint8Array> {\n    // @ts-ignore\n    private source: AsyncByteStreamSource<Uint8Array>;\n    constructor(source?: PromiseLike<ArrayBufferViewInput> | Response | ReadableStream<ArrayBufferViewInput> | NodeJS.ReadableStream | AsyncIterable<ArrayBufferViewInput> | Iterable<ArrayBufferViewInput>) {\n        if (source instanceof AsyncByteStream) {\n            this.source = (source as AsyncByteStream).source;\n        } else if (source instanceof AsyncByteQueue) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        } else if (isReadableNodeStream(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromNodeStream(source));\n        } else if (isReadableDOMStream<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source));\n        } else if (isFetchResponse(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source.body!));\n        } else if (isIterable<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromIterable(source));\n        } else if (isPromise<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        } else if (isAsyncIterable<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        }\n    }\n    [Symbol.asyncIterator]() { return this; }\n    public next(value?: any) { return this.source.next(value); }\n    public throw(value?: any) { return this.source.throw(value); }\n    public return(value?: any) { return this.source.return(value); }\n    public get closed(): Promise<void> { return this.source.closed; }\n    public cancel(reason?: any) { return this.source.cancel(reason); }\n    public peek(size?: number | null) { return this.source.peek(size); }\n    public read(size?: number | null) { return this.source.read(size); }\n}\n\n/** @ignore */\ninterface ByteStreamSourceIterator<T> extends IterableIterator<T> {\n    next(value?: { cmd: 'peek' | 'read', size?: number | null }): IteratorResult<T>;\n}\n\n/** @ignore */\ninterface AsyncByteStreamSourceIterator<T> extends AsyncIterableIterator<T> {\n    next(value?: { cmd: 'peek' | 'read', size?: number | null }): Promise<IteratorResult<T>>;\n}\n\n/** @ignore */\nclass ByteStreamSource<T> {\n    constructor(protected source: ByteStreamSourceIterator<T>) {}\n    public cancel(reason?: any) { this.return(reason); }\n    public peek(size?: number | null): T | null { return this.next(size, 'peek').value; }\n    public read(size?: number | null): T | null { return this.next(size, 'read').value; }\n    public next(size?: number | null, cmd: 'peek' | 'read' = 'read') { return this.source.next({ cmd, size }); }\n    public throw(value?: any) { return Object.create((this.source.throw && this.source.throw(value)) || ITERATOR_DONE); }\n    public return(value?: any) { return Object.create((this.source.return && this.source.return(value)) || ITERATOR_DONE); }\n}\n\n/** @ignore */\nclass AsyncByteStreamSource<T> implements Readable<T> {\n\n    private _closedPromise: Promise<void>;\n    private _closedPromiseResolve?: (value?: any) => void;\n    constructor (protected source: ByteStreamSourceIterator<T> | AsyncByteStreamSourceIterator<T>) {\n        this._closedPromise = new Promise((r) => this._closedPromiseResolve = r);\n    }\n    public async cancel(reason?: any) { await this.return(reason); }\n    public get closed(): Promise<void> { return this._closedPromise; }\n    public async read(size?: number | null): Promise<T | null> { return (await this.next(size, 'read')).value; }\n    public async peek(size?: number | null): Promise<T | null> { return (await this.next(size, 'peek')).value; }\n    public async next(size?: number | null, cmd: 'peek' | 'read' = 'read') { return (await this.source.next({ cmd, size })); }\n    public async throw(value?: any) {\n        const result = (this.source.throw && await this.source.throw(value)) || ITERATOR_DONE;\n        this._closedPromiseResolve && this._closedPromiseResolve();\n        this._closedPromiseResolve = undefined;\n        return Object.create(result);\n    }\n    public async return(value?: any) {\n        const result = (this.source.return && await this.source.return(value)) || ITERATOR_DONE;\n        this._closedPromiseResolve && this._closedPromiseResolve();\n        this._closedPromiseResolve = undefined;\n        return Object.create(result);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FileHandle } from './interfaces';\nimport { ByteStream, AsyncByteStream } from './stream';\nimport { ArrayBufferViewInput, toUint8Array } from '../util/buffer';\n\n/** @ignore */\nexport class RandomAccessFile extends ByteStream {\n    public size: number;\n    public position: number = 0;\n    protected buffer: Uint8Array | null;\n    constructor(buffer: ArrayBufferViewInput, byteLength?: number) {\n        super();\n        this.buffer = toUint8Array(buffer);\n        this.size = typeof byteLength === 'undefined' ? this.buffer.byteLength : byteLength;\n    }\n    public readInt32(position: number) {\n        const { buffer, byteOffset } = this.readAt(position, 4);\n        return new DataView(buffer, byteOffset).getInt32(0, true);\n    }\n    public seek(position: number) {\n        this.position = Math.min(position, this.size);\n        return position < this.size;\n    }\n    public read(nBytes?: number | null) {\n        const { buffer, size, position } = this;\n        if (buffer && position < size) {\n            if (typeof nBytes !== 'number') { nBytes = Infinity; }\n            this.position = Math.min(size,\n                 position + Math.min(size - position, nBytes));\n            return buffer.subarray(position, this.position);\n        }\n        return null;\n    }\n    public readAt(position: number, nBytes: number) {\n        const buf = this.buffer;\n        const end = Math.min(this.size, position + nBytes);\n        return buf ? buf.subarray(position, end) : new Uint8Array(nBytes);\n    }\n    public close() { this.buffer && (this.buffer = null); }\n    public throw(value?: any) { this.close(); return { done: true, value }; }\n    public return(value?: any) { this.close(); return { done: true, value }; }\n}\n\n/** @ignore */\nexport class AsyncRandomAccessFile extends AsyncByteStream {\n    // @ts-ignore\n    public size: number;\n    public position: number = 0;\n    public _pending?: Promise<void>;\n    protected _handle: FileHandle | null;\n    constructor(file: FileHandle, byteLength?: number) {\n        super();\n        this._handle = file;\n        if (typeof byteLength === 'number') {\n            this.size = byteLength;\n        } else {\n            this._pending = (async () => {\n                this.size = (await file.stat()).size;\n                delete this._pending;\n            })();\n        }\n    }\n    public async readInt32(position: number) {\n        const { buffer, byteOffset } = await this.readAt(position, 4);\n        return new DataView(buffer, byteOffset).getInt32(0, true);\n    }\n    public async seek(position: number) {\n        this._pending && await this._pending;\n        this.position = Math.min(position, this.size);\n        return position < this.size;\n    }\n    public async read(nBytes?: number | null) {\n        this._pending && await this._pending;\n        const { _handle: file, size, position } = this;\n        if (file && position < size) {\n            if (typeof nBytes !== 'number') { nBytes = Infinity; }\n            let pos = position, offset = 0, bytesRead = 0;\n            let end = Math.min(size, pos + Math.min(size - pos, nBytes));\n            let buffer = new Uint8Array(Math.max(0, (this.position = end) - pos));\n            while ((pos += bytesRead) < end && (offset += bytesRead) < buffer.byteLength) {\n                ({ bytesRead } = await file.read(buffer, offset, buffer.byteLength - offset, pos));\n            }\n            return buffer;\n        }\n        return null;\n    }\n    public async readAt(position: number, nBytes: number) {\n        this._pending && await this._pending;\n        const { _handle: file, size } = this;\n        if (file && (position + nBytes) < size) {\n            const end = Math.min(size, position + nBytes);\n            const buffer = new Uint8Array(end - position);\n            return (await file.read(buffer, 0, nBytes, position)).buffer;\n        }\n        return new Uint8Array(nBytes);\n    }\n    public async close() { const f = this._handle; this._handle = null; f && await f.close(); }\n    public async throw(value?: any) { await this.close(); return { done: true, value }; }\n    public async return(value?: any) { await this.close(); return { done: true, value }; }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nconst carryBit16 = 1 << 16;\n\n/** @ignore */\nfunction intAsHex(value: number): string {\n    if (value < 0) {\n        value = 0xFFFFFFFF + value + 1;\n    }\n    return `0x${value.toString(16)}`;\n}\n\n/** @ignore */\nconst kInt32DecimalDigits = 8;\n/** @ignore */\nconst kPowersOfTen = [1,\n                      10,\n                      100,\n                      1000,\n                      10000,\n                      100000,\n                      1000000,\n                      10000000,\n                      100000000];\n\n/** @ignore */\nexport class BaseInt64 {\n    constructor (protected buffer: Uint32Array) {}\n\n    public high(): number { return this.buffer[1]; }\n    public low (): number { return this.buffer[0]; }\n\n    protected _times(other: BaseInt64) {\n        // Break the left and right numbers into 16 bit chunks\n        // so that we can multiply them without overflow.\n        const L = new Uint32Array([\n            this.buffer[1] >>> 16,\n            this.buffer[1] & 0xFFFF,\n            this.buffer[0] >>> 16,\n            this.buffer[0] & 0xFFFF\n        ]);\n\n        const R = new Uint32Array([\n            other.buffer[1] >>> 16,\n            other.buffer[1] & 0xFFFF,\n            other.buffer[0] >>> 16,\n            other.buffer[0] & 0xFFFF\n        ]);\n\n        let product = L[3] * R[3];\n        this.buffer[0] = product & 0xFFFF;\n\n        let sum = product >>> 16;\n\n        product = L[2] * R[3];\n        sum += product;\n\n        product = (L[3] * R[2]) >>> 0;\n        sum += product;\n\n        this.buffer[0] += sum << 16;\n\n        this.buffer[1] = (sum >>> 0 < product ? carryBit16 : 0);\n\n        this.buffer[1] += sum >>> 16;\n        this.buffer[1] += L[1] * R[3] + L[2] * R[2] + L[3] * R[1];\n        this.buffer[1] += (L[0] * R[3] + L[1] * R[2] + L[2] * R[1] + L[3] * R[0]) << 16;\n\n        return this;\n      }\n\n    protected _plus(other: BaseInt64) {\n        const sum = (this.buffer[0] + other.buffer[0]) >>> 0;\n        this.buffer[1] += other.buffer[1];\n        if (sum < (this.buffer[0] >>> 0)) {\n          ++this.buffer[1];\n        }\n        this.buffer[0] = sum;\n    }\n\n    public lessThan(other: BaseInt64): boolean {\n        return this.buffer[1] < other.buffer[1] ||\n            (this.buffer[1] === other.buffer[1] && this.buffer[0] < other.buffer[0]);\n    }\n\n    public equals(other: BaseInt64): boolean {\n        return this.buffer[1] === other.buffer[1] && this.buffer[0] == other.buffer[0];\n    }\n\n    public greaterThan(other: BaseInt64): boolean {\n        return other.lessThan(this);\n    }\n\n    public hex(): string {\n        return `${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;\n    }\n}\n\n/** @ignore */\nexport class Uint64 extends BaseInt64 {\n    public times(other: Uint64): Uint64 {\n        this._times(other);\n        return this;\n    }\n\n    public plus(other: Uint64): Uint64 {\n        this._plus(other);\n        return this;\n    }\n\n    /** @nocollapse */\n    public static from(val: any, out_buffer = new Uint32Array(2)): Uint64 {\n        return Uint64.fromString(\n            typeof(val) === 'string' ? val : val.toString(),\n            out_buffer\n        );\n    }\n\n    /** @nocollapse */\n    public static fromNumber(num: number, out_buffer = new Uint32Array(2)): Uint64 {\n        // Always parse numbers as strings - pulling out high and low bits\n        // directly seems to lose precision sometimes\n        // For example:\n        //     > -4613034156400212000 >>> 0\n        //     721782784\n        // The correct lower 32-bits are 721782752\n        return Uint64.fromString(num.toString(), out_buffer);\n    }\n\n    /** @nocollapse */\n    public static fromString(str: string, out_buffer = new Uint32Array(2)): Uint64 {\n        const length = str.length;\n\n        let out = new Uint64(out_buffer);\n        for (let posn = 0; posn < length;) {\n            const group = kInt32DecimalDigits < length - posn ?\n                          kInt32DecimalDigits : length - posn;\n            const chunk = new Uint64(new Uint32Array([parseInt(str.substr(posn, group), 10), 0]));\n            const multiple = new Uint64(new Uint32Array([kPowersOfTen[group], 0]));\n\n            out.times(multiple);\n            out.plus(chunk);\n\n            posn += group;\n        }\n\n        return out;\n    }\n\n    /** @nocollapse */\n    public static convertArray(values: (string|number)[]): Uint32Array {\n        const data = new Uint32Array(values.length * 2);\n        for (let i = -1, n = values.length; ++i < n;) {\n            Uint64.from(values[i], new Uint32Array(data.buffer, data.byteOffset + 2 * i * 4, 2));\n        }\n        return data;\n    }\n\n    /** @nocollapse */\n    public static multiply(left: Uint64, right: Uint64): Uint64 {\n        let rtrn = new Uint64(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n\n    /** @nocollapse */\n    public static add(left: Uint64, right: Uint64): Uint64 {\n        let rtrn = new Uint64(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n}\n\n/** @ignore */\nexport class Int64 extends BaseInt64 {\n    public negate(): Int64 {\n        this.buffer[0] = ~this.buffer[0] + 1;\n        this.buffer[1] = ~this.buffer[1];\n\n        if (this.buffer[0] == 0) { ++this.buffer[1]; }\n        return this;\n    }\n\n    public times(other: Int64): Int64 {\n        this._times(other);\n        return this;\n    }\n\n    public plus(other: Int64): Int64 {\n        this._plus(other);\n        return this;\n    }\n\n    public lessThan(other: Int64): boolean {\n        // force high bytes to be signed\n        const this_high = this.buffer[1] << 0;\n        const other_high = other.buffer[1] << 0;\n        return this_high < other_high ||\n            (this_high === other_high && this.buffer[0] < other.buffer[0]);\n    }\n\n    /** @nocollapse */\n    public static from(val: any, out_buffer = new Uint32Array(2)): Int64 {\n        return Int64.fromString(\n            typeof(val) === 'string' ? val : val.toString(),\n            out_buffer\n        );\n    }\n\n    /** @nocollapse */\n    public static fromNumber(num: number, out_buffer = new Uint32Array(2)): Int64 {\n        // Always parse numbers as strings - pulling out high and low bits\n        // directly seems to lose precision sometimes\n        // For example:\n        //     > -4613034156400212000 >>> 0\n        //     721782784\n        // The correct lower 32-bits are 721782752\n        return Int64.fromString(num.toString(), out_buffer);\n    }\n\n    /** @nocollapse */\n    public static fromString(str: string, out_buffer = new Uint32Array(2)): Int64 {\n        // TODO: Assert that out_buffer is 0 and length = 2\n        const negate = str.startsWith('-');\n        const length = str.length;\n\n        let out = new Int64(out_buffer);\n        for (let posn = negate ? 1 : 0; posn < length;) {\n            const group = kInt32DecimalDigits < length - posn ?\n                          kInt32DecimalDigits : length - posn;\n            const chunk = new Int64(new Uint32Array([parseInt(str.substr(posn, group), 10), 0]));\n            const multiple = new Int64(new Uint32Array([kPowersOfTen[group], 0]));\n\n            out.times(multiple);\n            out.plus(chunk);\n\n            posn += group;\n        }\n        return negate ? out.negate() : out;\n    }\n\n    /** @nocollapse */\n    public static convertArray(values: (string|number)[]): Uint32Array {\n        const data = new Uint32Array(values.length * 2);\n        for (let i = -1, n = values.length; ++i < n;) {\n            Int64.from(values[i], new Uint32Array(data.buffer, data.byteOffset + 2 * i * 4, 2));\n        }\n        return data;\n    }\n\n    /** @nocollapse */\n    public static multiply(left: Int64, right: Int64): Int64 {\n        let rtrn = new Int64(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n\n    /** @nocollapse */\n    public static add(left: Int64, right: Int64): Int64 {\n        let rtrn = new Int64(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n}\n\n/** @ignore */\nexport class Int128 {\n    constructor (private buffer: Uint32Array) {\n        // buffer[3] MSB (high)\n        // buffer[2]\n        // buffer[1]\n        // buffer[0] LSB (low)\n    }\n\n    public high(): Int64 {\n        return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));\n    }\n\n    public low(): Int64 {\n        return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset, 2));\n    }\n\n    public negate(): Int128 {\n        this.buffer[0] = ~this.buffer[0] + 1;\n        this.buffer[1] = ~this.buffer[1];\n        this.buffer[2] = ~this.buffer[2];\n        this.buffer[3] = ~this.buffer[3];\n\n        if (this.buffer[0] == 0) { ++this.buffer[1]; }\n        if (this.buffer[1] == 0) { ++this.buffer[2]; }\n        if (this.buffer[2] == 0) { ++this.buffer[3]; }\n        return this;\n    }\n\n    public times(other: Int128): Int128 {\n        // Break the left and right numbers into 32 bit chunks\n        // so that we can multiply them without overflow.\n        const L0 = new Uint64(new Uint32Array([this.buffer[3],  0]));\n        const L1 = new Uint64(new Uint32Array([this.buffer[2],  0]));\n        const L2 = new Uint64(new Uint32Array([this.buffer[1],  0]));\n        const L3 = new Uint64(new Uint32Array([this.buffer[0],  0]));\n\n        const R0 = new Uint64(new Uint32Array([other.buffer[3], 0]));\n        const R1 = new Uint64(new Uint32Array([other.buffer[2], 0]));\n        const R2 = new Uint64(new Uint32Array([other.buffer[1], 0]));\n        const R3 = new Uint64(new Uint32Array([other.buffer[0], 0]));\n\n        let product = Uint64.multiply(L3, R3);\n        this.buffer[0] = product.low();\n\n        let sum = new Uint64(new Uint32Array([product.high(), 0]));\n\n        product = Uint64.multiply(L2, R3);\n        sum.plus(product);\n\n        product = Uint64.multiply(L3, R2);\n        sum.plus(product);\n\n        this.buffer[1] = sum.low();\n\n        this.buffer[3] = (sum.lessThan(product) ? 1 : 0);\n\n        this.buffer[2] = sum.high();\n        let high = new Uint64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));\n\n        high.plus(Uint64.multiply(L1, R3))\n            .plus(Uint64.multiply(L2, R2))\n            .plus(Uint64.multiply(L3, R1));\n        this.buffer[3] += Uint64.multiply(L0, R3)\n                        .plus(Uint64.multiply(L1, R2))\n                        .plus(Uint64.multiply(L2, R1))\n                        .plus(Uint64.multiply(L3, R0)).low();\n\n        return this;\n    }\n\n    public plus(other: Int128): Int128 {\n        let sums = new Uint32Array(4);\n        sums[3] = (this.buffer[3] + other.buffer[3]) >>> 0;\n        sums[2] = (this.buffer[2] + other.buffer[2]) >>> 0;\n        sums[1] = (this.buffer[1] + other.buffer[1]) >>> 0;\n        sums[0] = (this.buffer[0] + other.buffer[0]) >>> 0;\n\n        if (sums[0] < (this.buffer[0] >>> 0)) {\n            ++sums[1];\n        }\n        if (sums[1] < (this.buffer[1] >>> 0)) {\n            ++sums[2];\n        }\n        if (sums[2] < (this.buffer[2] >>> 0)) {\n            ++sums[3];\n        }\n\n        this.buffer[3] = sums[3];\n        this.buffer[2] = sums[2];\n        this.buffer[1] = sums[1];\n        this.buffer[0] = sums[0];\n\n        return this;\n    }\n\n    public hex(): string {\n        return `${intAsHex(this.buffer[3])} ${intAsHex(this.buffer[2])} ${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;\n    }\n\n    /** @nocollapse */\n    public static multiply(left: Int128, right: Int128): Int128 {\n        let rtrn = new Int128(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n\n    /** @nocollapse */\n    public static add(left: Int128, right: Int128): Int128 {\n        let rtrn = new Int128(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n\n    /** @nocollapse */\n    public static from(val: any, out_buffer = new Uint32Array(4)): Int128 {\n        return Int128.fromString(\n            typeof(val) === 'string' ? val : val.toString(),\n            out_buffer\n        );\n    }\n\n    /** @nocollapse */\n    public static fromNumber(num: number, out_buffer = new Uint32Array(4)): Int128 {\n        // Always parse numbers as strings - pulling out high and low bits\n        // directly seems to lose precision sometimes\n        // For example:\n        //     > -4613034156400212000 >>> 0\n        //     721782784\n        // The correct lower 32-bits are 721782752\n        return Int128.fromString(num.toString(), out_buffer);\n    }\n\n    /** @nocollapse */\n    public static fromString(str: string, out_buffer = new Uint32Array(4)): Int128 {\n        // TODO: Assert that out_buffer is 0 and length = 4\n        const negate = str.startsWith('-');\n        const length = str.length;\n\n        let out = new Int128(out_buffer);\n        for (let posn = negate ? 1 : 0; posn < length;) {\n            const group = kInt32DecimalDigits < length - posn ?\n                          kInt32DecimalDigits : length - posn;\n            const chunk = new Int128(new Uint32Array([parseInt(str.substr(posn, group), 10), 0, 0, 0]));\n            const multiple = new Int128(new Uint32Array([kPowersOfTen[group], 0, 0, 0]));\n\n            out.times(multiple);\n            out.plus(chunk);\n\n            posn += group;\n        }\n\n        return negate ? out.negate() : out;\n    }\n\n    /** @nocollapse */\n    public static convertArray(values: (string|number)[]): Uint32Array {\n        // TODO: Distinguish between string and number at compile-time\n        const data = new Uint32Array(values.length * 4);\n        for (let i = -1, n = values.length; ++i < n;) {\n            Int128.from(values[i], new Uint32Array(data.buffer, data.byteOffset + 4 * 4 * i, 4));\n        }\n        return data;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport * as type from '../type';\nimport { Field } from '../schema';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Visitor } from '../visitor';\nimport { packBools } from '../util/bit';\nimport { encodeUtf8 } from '../util/utf8';\nimport { Int64, Int128 } from '../util/int';\nimport { UnionMode, DateUnit } from '../enum';\nimport { toArrayBufferView } from '../util/buffer';\nimport { BufferRegion, FieldNode } from '../ipc/metadata/message';\n\n/** @ignore */\nexport interface VectorLoader extends Visitor {\n    visit<T extends DataType>(node: Field<T> | T): Data<T>;\n    visitMany<T extends DataType>(nodes: (Field<T> | T)[]): Data<T>[];\n}\n\n/** @ignore */\nexport class VectorLoader extends Visitor {\n    private bytes: Uint8Array;\n    private nodes: FieldNode[];\n    private nodesIndex: number = -1;\n    private buffers: BufferRegion[];\n    private buffersIndex: number = -1;\n    private dictionaries: Map<number, Vector<any>>;\n    constructor(bytes: Uint8Array, nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>) {\n        super();\n        this.bytes = bytes;\n        this.nodes = nodes;\n        this.buffers = buffers;\n        this.dictionaries = dictionaries;\n    }\n\n    public visit<T extends DataType>(node: Field<T> | T): Data<T> {\n        return super.visit(node instanceof Field ? node.type : node);\n    }\n\n    public visitNull            <T extends type.Null>            (type: T, { length,           } = this.nextFieldNode()) { return            Data.Null(type, 0, length);                                                                                                                                 }\n    public visitBool            <T extends type.Bool>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Bool(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitInt             <T extends type.Int>             (type: T, { length, nullCount } = this.nextFieldNode()) { return             Data.Int(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitFloat           <T extends type.Float>           (type: T, { length, nullCount } = this.nextFieldNode()) { return           Data.Float(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitUtf8            <T extends type.Utf8>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Utf8(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.readData(type));                                   }\n    public visitBinary          <T extends type.Binary>          (type: T, { length, nullCount } = this.nextFieldNode()) { return          Data.Binary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.readData(type));                                   }\n    public visitFixedSizeBinary <T extends type.FixedSizeBinary> (type: T, { length, nullCount } = this.nextFieldNode()) { return Data.FixedSizeBinary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitDate            <T extends type.Date_>           (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Date(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitTimestamp       <T extends type.Timestamp>       (type: T, { length, nullCount } = this.nextFieldNode()) { return       Data.Timestamp(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitTime            <T extends type.Time>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Time(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitDecimal         <T extends type.Decimal>         (type: T, { length, nullCount } = this.nextFieldNode()) { return         Data.Decimal(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitList            <T extends type.List>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.List(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.visit(type.children[0]));                          }\n    public visitStruct          <T extends type.Struct>          (type: T, { length, nullCount } = this.nextFieldNode()) { return          Data.Struct(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.visitMany(type.children));                                                 }\n    public visitUnion           <T extends type.Union>           (type: T                                              ) { return type.mode === UnionMode.Sparse ? this.visitSparseUnion(type as type.SparseUnion) : this.visitDenseUnion(type as type.DenseUnion);                                      }\n    public visitDenseUnion      <T extends type.DenseUnion>      (type: T, { length, nullCount } = this.nextFieldNode()) { return           Data.Union(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readTypeIds(type), this.readOffsets(type), this.visitMany(type.children)); }\n    public visitSparseUnion     <T extends type.SparseUnion>     (type: T, { length, nullCount } = this.nextFieldNode()) { return           Data.Union(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readTypeIds(type), this.visitMany(type.children));                         }\n    public visitDictionary      <T extends type.Dictionary>      (type: T, { length, nullCount } = this.nextFieldNode()) { return      Data.Dictionary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type.indices), this.readDictionary(type));                        }\n    public visitInterval        <T extends type.Interval>        (type: T, { length, nullCount } = this.nextFieldNode()) { return        Data.Interval(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitFixedSizeList   <T extends type.FixedSizeList>   (type: T, { length, nullCount } = this.nextFieldNode()) { return   Data.FixedSizeList(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.visit(type.children[0]));                                                  }\n    public visitMap             <T extends type.Map_>            (type: T, { length, nullCount } = this.nextFieldNode()) { return             Data.Map(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.visit(type.children[0]));                          }\n\n    protected nextFieldNode() { return this.nodes[++this.nodesIndex]; }\n    protected nextBufferRange() { return this.buffers[++this.buffersIndex]; }\n    protected readNullBitmap<T extends DataType>(type: T, nullCount: number, buffer = this.nextBufferRange()) {\n        return nullCount > 0 && this.readData(type, buffer) || new Uint8Array(0);\n    }\n    protected readOffsets<T extends DataType>(type: T, buffer?: BufferRegion) { return this.readData(type, buffer); }\n    protected readTypeIds<T extends DataType>(type: T, buffer?: BufferRegion) { return this.readData(type, buffer); }\n    protected readData<T extends DataType>(_type: T, { length, offset } = this.nextBufferRange()) {\n        return this.bytes.subarray(offset, offset + length);\n    }\n    protected readDictionary<T extends type.Dictionary>(type: T): Vector<T['dictionary']> {\n        return this.dictionaries.get(type.id)!;\n    }\n}\n\n/** @ignore */\nexport class JSONVectorLoader extends VectorLoader {\n    private sources: any[][];\n    constructor(sources: any[][], nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>) {\n        super(new Uint8Array(0), nodes, buffers, dictionaries);\n        this.sources = sources;\n    }\n    protected readNullBitmap<T extends DataType>(_type: T, nullCount: number, { offset } = this.nextBufferRange()) {\n        return nullCount <= 0 ? new Uint8Array(0) : packBools(this.sources[offset]);\n    }\n    protected readOffsets<T extends DataType>(_type: T, { offset } = this.nextBufferRange()) {\n        return toArrayBufferView(Uint8Array, toArrayBufferView(Int32Array, this.sources[offset]));\n    }\n    protected readTypeIds<T extends DataType>(type: T, { offset } = this.nextBufferRange()) {\n        return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, this.sources[offset]));\n    }\n    protected readData<T extends DataType>(type: T, { offset } = this.nextBufferRange()) {\n        const { sources } = this;\n        if (DataType.isTimestamp(type)) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));\n        } else if ((DataType.isInt(type) || DataType.isTime(type)) && type.bitWidth === 64) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));\n        } else if (DataType.isDate(type) && type.unit === DateUnit.MILLISECOND) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));\n        } else if (DataType.isDecimal(type)) {\n            return toArrayBufferView(Uint8Array, Int128.convertArray(sources[offset] as string[]));\n        } else if (DataType.isBinary(type) || DataType.isFixedSizeBinary(type)) {\n            return binaryDataFromJSON(sources[offset] as string[]);\n        } else if (DataType.isBool(type)) {\n            return packBools(sources[offset] as number[]);\n        } else if (DataType.isUtf8(type)) {\n            return encodeUtf8((sources[offset] as string[]).join(''));\n        }\n        return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, sources[offset].map((x) => +x)));\n    }\n}\n\n/** @ignore */\nfunction binaryDataFromJSON(values: string[]) {\n    // \"DATA\": [\"49BC7D5B6C47D2\",\"3F5FB6D9322026\"]\n    // There are definitely more efficient ways to do this... but it gets the\n    // job done.\n    const joined = values.join('');\n    const data = new Uint8Array(joined.length / 2);\n    for (let i = 0; i < joined.length; i += 2) {\n        data[i >> 1] = parseInt(joined.substr(i, 2), 16);\n    }\n    return data;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { flatbuffers } from 'flatbuffers';\nimport Long = flatbuffers.Long;\nimport Builder = flatbuffers.Builder;\nimport * as Schema_ from '../fb/Schema';\n\nimport * as type from '../type';\nimport { Visitor } from '../visitor';\n\nimport Null = Schema_.org.apache.arrow.flatbuf.Null;\nimport Int = Schema_.org.apache.arrow.flatbuf.Int;\nimport FloatingPoint = Schema_.org.apache.arrow.flatbuf.FloatingPoint;\nimport Binary = Schema_.org.apache.arrow.flatbuf.Binary;\nimport Bool = Schema_.org.apache.arrow.flatbuf.Bool;\nimport Utf8 = Schema_.org.apache.arrow.flatbuf.Utf8;\nimport Decimal = Schema_.org.apache.arrow.flatbuf.Decimal;\nimport Date = Schema_.org.apache.arrow.flatbuf.Date;\nimport Time = Schema_.org.apache.arrow.flatbuf.Time;\nimport Timestamp = Schema_.org.apache.arrow.flatbuf.Timestamp;\nimport Interval = Schema_.org.apache.arrow.flatbuf.Interval;\nimport List = Schema_.org.apache.arrow.flatbuf.List;\nimport Struct = Schema_.org.apache.arrow.flatbuf.Struct_;\nimport Union = Schema_.org.apache.arrow.flatbuf.Union;\nimport DictionaryEncoding = Schema_.org.apache.arrow.flatbuf.DictionaryEncoding;\nimport FixedSizeBinary = Schema_.org.apache.arrow.flatbuf.FixedSizeBinary;\nimport FixedSizeList = Schema_.org.apache.arrow.flatbuf.FixedSizeList;\nimport Map_ = Schema_.org.apache.arrow.flatbuf.Map;\n\n/** @ignore */\nexport interface TypeAssembler extends Visitor {\n    visit<T extends type.DataType>(node: T, builder: Builder): number | undefined;\n}\n\n/** @ignore */\nexport class TypeAssembler extends Visitor {\n    public visit<T extends type.DataType>(node: T, builder: Builder): number | undefined {\n        return (node == null || builder == null) ? undefined : super.visit(node, builder);\n    }\n    public visitNull<T extends type.Null>(_node: T, b: Builder) {\n        Null.startNull(b);\n        return Null.endNull(b);\n    }\n    public visitInt<T extends type.Int>(node: T, b: Builder) {\n        Int.startInt(b);\n        Int.addBitWidth(b, node.bitWidth);\n        Int.addIsSigned(b, node.isSigned);\n        return Int.endInt(b);\n    }\n    public visitFloat<T extends type.Float>(node: T, b: Builder) {\n        FloatingPoint.startFloatingPoint(b);\n        FloatingPoint.addPrecision(b, node.precision);\n        return FloatingPoint.endFloatingPoint(b);\n    }\n    public visitBinary<T extends type.Binary>(_node: T, b: Builder) {\n        Binary.startBinary(b);\n        return Binary.endBinary(b);\n    }\n    public visitBool<T extends type.Bool>(_node: T, b: Builder) {\n        Bool.startBool(b);\n        return Bool.endBool(b);\n    }\n    public visitUtf8<T extends type.Utf8>(_node: T, b: Builder) {\n        Utf8.startUtf8(b);\n        return Utf8.endUtf8(b);\n    }\n    public visitDecimal<T extends type.Decimal>(node: T, b: Builder) {\n        Decimal.startDecimal(b);\n        Decimal.addScale(b, node.scale);\n        Decimal.addPrecision(b, node.precision);\n        return Decimal.endDecimal(b);\n    }\n    public visitDate<T extends type.Date_>(node: T, b: Builder) {\n        Date.startDate(b);\n        Date.addUnit(b, node.unit);\n        return Date.endDate(b);\n    }\n    public visitTime<T extends type.Time>(node: T, b: Builder) {\n        Time.startTime(b);\n        Time.addUnit(b, node.unit);\n        Time.addBitWidth(b, node.bitWidth);\n        return Time.endTime(b);\n    }\n    public visitTimestamp<T extends type.Timestamp>(node: T, b: Builder) {\n        const timezone = (node.timezone && b.createString(node.timezone)) || undefined;\n        Timestamp.startTimestamp(b);\n        Timestamp.addUnit(b, node.unit);\n        if (timezone !== undefined) {\n            Timestamp.addTimezone(b, timezone);\n        }\n        return Timestamp.endTimestamp(b);\n    }\n    public visitInterval<T extends type.Interval>(node: T, b: Builder) {\n        Interval.startInterval(b);\n        Interval.addUnit(b, node.unit);\n        return Interval.endInterval(b);\n    }\n    public visitList<T extends type.List>(_node: T, b: Builder) {\n        List.startList(b);\n        return List.endList(b);\n    }\n    public visitStruct<T extends type.Struct>(_node: T, b: Builder) {\n        Struct.startStruct_(b);\n        return Struct.endStruct_(b);\n    }\n    public visitUnion<T extends type.Union>(node: T, b: Builder) {\n        Union.startTypeIdsVector(b, node.typeIds.length);\n        const typeIds = Union.createTypeIdsVector(b, node.typeIds);\n        Union.startUnion(b);\n        Union.addMode(b, node.mode);\n        Union.addTypeIds(b, typeIds);\n        return Union.endUnion(b);\n    }\n    public visitDictionary<T extends type.Dictionary>(node: T, b: Builder) {\n        const indexType = this.visit(node.indices, b);\n        DictionaryEncoding.startDictionaryEncoding(b);\n        DictionaryEncoding.addId(b, new Long(node.id, 0));\n        DictionaryEncoding.addIsOrdered(b, node.isOrdered);\n        if (indexType !== undefined) {\n            DictionaryEncoding.addIndexType(b, indexType);\n        }\n        return DictionaryEncoding.endDictionaryEncoding(b);\n    }\n    public visitFixedSizeBinary<T extends type.FixedSizeBinary>(node: T, b: Builder) {\n        FixedSizeBinary.startFixedSizeBinary(b);\n        FixedSizeBinary.addByteWidth(b, node.byteWidth);\n        return FixedSizeBinary.endFixedSizeBinary(b);\n    }\n    public visitFixedSizeList<T extends type.FixedSizeList>(node: T, b: Builder) {\n        FixedSizeList.startFixedSizeList(b);\n        FixedSizeList.addListSize(b, node.listSize);\n        return FixedSizeList.endFixedSizeList(b);\n    }\n    public visitMap<T extends type.Map_>(node: T, b: Builder) {\n        Map_.startMap(b);\n        Map_.addKeysSorted(b, node.keysSorted);\n        return Map_.endMap(b);\n    }\n}\n\n/** @ignore */\nexport const instance = new TypeAssembler();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Schema, Field } from '../../schema';\nimport {\n    DataType, Dictionary, TimeBitWidth,\n    Utf8, Binary, Decimal, FixedSizeBinary,\n    List, FixedSizeList, Map_, Struct, Union,\n    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys,\n} from '../../type';\n\nimport { DictionaryBatch, RecordBatch, FieldNode, BufferRegion } from './message';\nimport { TimeUnit, Precision, IntervalUnit, UnionMode, DateUnit } from '../../enum';\n\n/** @ignore */\nexport function schemaFromJSON(_schema: any, dictionaries: Map<number, DataType> = new Map()) {\n    return new Schema(\n        schemaFieldsFromJSON(_schema, dictionaries),\n        customMetadataFromJSON(_schema['customMetadata']),\n        dictionaries\n    );\n}\n\n/** @ignore */\nexport function recordBatchFromJSON(b: any) {\n    return new RecordBatch(\n        b['count'],\n        fieldNodesFromJSON(b['columns']),\n        buffersFromJSON(b['columns'])\n    );\n}\n\n/** @ignore */\nexport function dictionaryBatchFromJSON(b: any) {\n    return new DictionaryBatch(\n        recordBatchFromJSON(b['data']),\n        b['id'], b['isDelta']\n    );\n}\n\n/** @ignore */\nfunction schemaFieldsFromJSON(_schema: any, dictionaries?: Map<number, DataType>) {\n    return (_schema['fields'] || []).filter(Boolean).map((f: any) => Field.fromJSON(f, dictionaries));\n}\n\n/** @ignore */\nfunction fieldChildrenFromJSON(_field: any, dictionaries?: Map<number, DataType>): Field[] {\n    return (_field['children'] || []).filter(Boolean).map((f: any) => Field.fromJSON(f, dictionaries));\n}\n\n/** @ignore */\nfunction fieldNodesFromJSON(xs: any[]): FieldNode[] {\n    return (xs || []).reduce<FieldNode[]>((fieldNodes, column: any) => [\n        ...fieldNodes,\n        new FieldNode(\n            column['count'],\n            nullCountFromJSON(column['VALIDITY'])\n        ),\n        ...fieldNodesFromJSON(column['children'])\n    ], [] as FieldNode[]);\n}\n\n/** @ignore */\nfunction buffersFromJSON(xs: any[], buffers: BufferRegion[] = []): BufferRegion[] {\n    for (let i = -1, n = (xs || []).length; ++i < n;) {\n        const column = xs[i];\n        column['VALIDITY'] && buffers.push(new BufferRegion(buffers.length, column['VALIDITY'].length));\n        column['TYPE'] && buffers.push(new BufferRegion(buffers.length, column['TYPE'].length));\n        column['OFFSET'] && buffers.push(new BufferRegion(buffers.length, column['OFFSET'].length));\n        column['DATA'] && buffers.push(new BufferRegion(buffers.length, column['DATA'].length));\n        buffers = buffersFromJSON(column['children'], buffers);\n    }\n    return buffers;\n}\n\n/** @ignore */\nfunction nullCountFromJSON(validity: number[]) {\n    return (validity || []).reduce((sum, val) => sum + +(val === 0), 0);\n}\n\n/** @ignore */\nexport function fieldFromJSON(_field: any, dictionaries?: Map<number, DataType>) {\n\n    let id: number;\n    let keys: TKeys | null;\n    let field: Field | void;\n    let dictMeta: any;\n    let type: DataType<any>;\n    let dictType: Dictionary;\n\n    // If no dictionary encoding\n    if (!dictionaries || !(dictMeta = _field['dictionary'])) {\n        type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries));\n        field = new Field(_field['name'], type, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));\n    }\n    // tslint:disable\n    // If dictionary encoded and the first time we've seen this dictionary id, decode\n    // the data type and child fields, then wrap in a Dictionary type and insert the\n    // data type into the dictionary types map.\n    else if (!dictionaries.has(id = dictMeta['id'])) {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta['indexType']) ? indexTypeFromJSON(keys) as TKeys : new Int32();\n        dictionaries.set(id, type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries)));\n        dictType = new Dictionary(type, keys, id, dictMeta['isOrdered']);\n        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));\n    }\n    // If dictionary encoded, and have already seen this dictionary Id in the schema, then reuse the\n    // data type and wrap in a new Dictionary type and field.\n    else {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta['indexType']) ? indexTypeFromJSON(keys) as TKeys : new Int32();\n        dictType = new Dictionary(dictionaries.get(id)!, keys, id, dictMeta['isOrdered']);\n        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));\n    }\n    return field || null;\n}\n\n/** @ignore */\nfunction customMetadataFromJSON(_metadata?: object) {\n    return new Map<string, string>(Object.entries(_metadata || {}));\n}\n\n/** @ignore */\nfunction indexTypeFromJSON(_type: any) {\n    return new Int(_type['isSigned'], _type['bitWidth']);\n}\n\n/** @ignore */\nfunction typeFromJSON(f: any, children?: Field[]): DataType<any> {\n\n    const typeId = f['type']['name'];\n\n    switch (typeId) {\n        case 'NONE':   return new Null();\n        case 'null':   return new Null();\n        case 'binary': return new Binary();\n        case 'utf8':   return new Utf8();\n        case 'bool':   return new Bool();\n        case 'list':   return new List((children || [])[0]);\n        case 'struct': return new Struct(children || []);\n        case 'struct_': return new Struct(children || []);\n    }\n\n    switch (typeId) {\n        case 'int': {\n            const t = f['type'];\n            return new Int(t['isSigned'], t['bitWidth'] as IntBitWidth);\n        }\n        case 'floatingpoint': {\n            const t = f['type'];\n            return new Float(Precision[t['precision']] as any);\n        }\n        case 'decimal': {\n            const t = f['type'];\n            return new Decimal(t['scale'], t['precision']);\n        }\n        case 'date': {\n            const t = f['type'];\n            return new Date_(DateUnit[t['unit']] as any);\n        }\n        case 'time': {\n            const t = f['type'];\n            return new Time(TimeUnit[t['unit']] as any, t['bitWidth'] as TimeBitWidth);\n        }\n        case 'timestamp': {\n            const t = f['type'];\n            return new Timestamp(TimeUnit[t['unit']] as any, t['timezone']);\n        }\n        case 'interval': {\n            const t = f['type'];\n            return new Interval(IntervalUnit[t['unit']] as any);\n        }\n        case 'union': {\n            const t = f['type'];\n            return new Union(UnionMode[t['mode']] as any, (t['typeIds'] || []), children || []);\n        }\n        case 'fixedsizebinary': {\n            const t = f['type'];\n            return new FixedSizeBinary(t['byteWidth']);\n        }\n        case 'fixedsizelist': {\n            const t = f['type'];\n            return new FixedSizeList(t['listSize'], (children || [])[0]);\n        }\n        case 'map': {\n            const t = f['type'];\n            return new Map_((children || [])[0], t['keysSorted']);\n        }\n    }\n    throw new Error(`Unrecognized type: \"${typeId}\"`);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { flatbuffers } from 'flatbuffers';\nimport * as Schema_ from '../../fb/Schema';\nimport * as Message_ from '../../fb/Message';\n\nimport { Schema, Field } from '../../schema';\nimport { toUint8Array } from '../../util/buffer';\nimport { ArrayBufferViewInput } from '../../util/buffer';\nimport { MessageHeader, MetadataVersion } from '../../enum';\nimport { instance as typeAssembler } from '../../visitor/typeassembler';\nimport { fieldFromJSON, schemaFromJSON, recordBatchFromJSON, dictionaryBatchFromJSON } from './json';\n\nimport Long = flatbuffers.Long;\nimport Builder = flatbuffers.Builder;\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport _Int = Schema_.org.apache.arrow.flatbuf.Int;\nimport Type = Schema_.org.apache.arrow.flatbuf.Type;\nimport _Field = Schema_.org.apache.arrow.flatbuf.Field;\nimport _Schema = Schema_.org.apache.arrow.flatbuf.Schema;\nimport _Buffer = Schema_.org.apache.arrow.flatbuf.Buffer;\nimport _Message = Message_.org.apache.arrow.flatbuf.Message;\nimport _KeyValue = Schema_.org.apache.arrow.flatbuf.KeyValue;\nimport _FieldNode = Message_.org.apache.arrow.flatbuf.FieldNode;\nimport _Endianness = Schema_.org.apache.arrow.flatbuf.Endianness;\nimport _RecordBatch = Message_.org.apache.arrow.flatbuf.RecordBatch;\nimport _DictionaryBatch = Message_.org.apache.arrow.flatbuf.DictionaryBatch;\nimport _DictionaryEncoding = Schema_.org.apache.arrow.flatbuf.DictionaryEncoding;\n\nimport {\n    DataType, Dictionary, TimeBitWidth,\n    Utf8, Binary, Decimal, FixedSizeBinary,\n    List, FixedSizeList, Map_, Struct, Union,\n    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys,\n} from '../../type';\n\n/**\n * @ignore\n * @private\n **/\nexport class Message<T extends MessageHeader = any> {\n\n    /** @nocollapse */\n    public static fromJSON<T extends MessageHeader>(msg: any, headerType: T): Message<T> {\n        const message = new Message(0, MetadataVersion.V4, headerType);\n        message._createHeader = messageHeaderFromJSON(msg, headerType);\n        return message;\n    }\n\n    /** @nocollapse */\n    public static decode(buf: ArrayBufferViewInput) {\n        buf = new ByteBuffer(toUint8Array(buf));\n        const _message = _Message.getRootAsMessage(buf);\n        const bodyLength: Long = _message.bodyLength()!;\n        const version: MetadataVersion = _message.version();\n        const headerType: MessageHeader = _message.headerType();\n        const message = new Message(bodyLength, version, headerType);\n        message._createHeader = decodeMessageHeader(_message, headerType);\n        return message;\n    }\n\n    /** @nocollapse */\n    public static encode<T extends MessageHeader>(message: Message<T>) {\n        let b = new Builder(), headerOffset = -1;\n        if (message.isSchema()) {\n            headerOffset = Schema.encode(b, message.header() as Schema);\n        } else if (message.isRecordBatch()) {\n            headerOffset = RecordBatch.encode(b, message.header() as RecordBatch);\n        } else if (message.isDictionaryBatch()) {\n            headerOffset = DictionaryBatch.encode(b, message.header() as DictionaryBatch);\n        }\n        _Message.startMessage(b);\n        _Message.addVersion(b, MetadataVersion.V4);\n        _Message.addHeader(b, headerOffset);\n        _Message.addHeaderType(b, message.headerType);\n        _Message.addBodyLength(b, new Long(message.bodyLength, 0));\n        _Message.finishMessageBuffer(b, _Message.endMessage(b));\n        return b.asUint8Array();\n    }\n\n    /** @nocollapse */\n    public static from(header: Schema | RecordBatch | DictionaryBatch, bodyLength = 0) {\n        if (header instanceof Schema) {\n            return new Message(0, MetadataVersion.V4, MessageHeader.Schema, header);\n        }\n        if (header instanceof RecordBatch) {\n            return new Message(bodyLength, MetadataVersion.V4, MessageHeader.RecordBatch, header);\n        }\n        if (header instanceof DictionaryBatch) {\n            return new Message(bodyLength, MetadataVersion.V4, MessageHeader.DictionaryBatch, header);\n        }\n        throw new Error(`Unrecognized Message header: ${header}`);\n    }\n\n    // @ts-ignore\n    public body: Uint8Array;\n    protected _headerType: T;\n    protected _bodyLength: number;\n    protected _version: MetadataVersion;\n    public get type() { return this.headerType; }\n    public get version() { return this._version; }\n    public get headerType() { return this._headerType; }\n    public get bodyLength() { return this._bodyLength; }\n    // @ts-ignore\n    protected _createHeader: MessageHeaderDecoder;\n    public header() { return this._createHeader<T>(); }\n    public isSchema(): this is Message<MessageHeader.Schema> { return this.headerType === MessageHeader.Schema; }\n    public isRecordBatch(): this is Message<MessageHeader.RecordBatch> { return this.headerType === MessageHeader.RecordBatch; }\n    public isDictionaryBatch(): this is Message<MessageHeader.DictionaryBatch> { return this.headerType === MessageHeader.DictionaryBatch; }\n\n    constructor(bodyLength: Long | number, version: MetadataVersion, headerType: T, header?: any) {\n        this._version = version;\n        this._headerType = headerType;\n        this.body = new Uint8Array(0);\n        header && (this._createHeader = () => header);\n        this._bodyLength = typeof bodyLength === 'number' ? bodyLength : bodyLength.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class RecordBatch {\n    protected _length: number;\n    protected _nodes: FieldNode[];\n    protected _buffers: BufferRegion[];\n    public get nodes() { return this._nodes; }\n    public get length() { return this._length; }\n    public get buffers() { return this._buffers; }\n    constructor(length: Long | number, nodes: FieldNode[], buffers: BufferRegion[]) {\n        this._nodes = nodes;\n        this._buffers = buffers;\n        this._length = typeof length === 'number' ? length : length.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class DictionaryBatch {\n\n    protected _id: number;\n    protected _isDelta: boolean;\n    protected _data: RecordBatch;\n    public get id() { return this._id; }\n    public get data() { return this._data; }\n    public get isDelta() { return this._isDelta; }\n    public get length(): number { return this.data.length; }\n    public get nodes(): FieldNode[] { return this.data.nodes; }\n    public get buffers(): BufferRegion[] { return this.data.buffers; }\n\n    constructor(data: RecordBatch, id: Long | number, isDelta: boolean = false) {\n        this._data = data;\n        this._isDelta = isDelta;\n        this._id = typeof id === 'number' ? id : id.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class BufferRegion {\n    public offset: number;\n    public length: number;\n    constructor(offset: Long | number, length: Long | number) {\n        this.offset = typeof offset === 'number' ? offset : offset.low;\n        this.length = typeof length === 'number' ? length : length.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class FieldNode {\n    public length: number;\n    public nullCount: number;\n    constructor(length: Long | number, nullCount: Long | number) {\n        this.length = typeof length === 'number' ? length : length.low;\n        this.nullCount = typeof nullCount === 'number' ? nullCount : nullCount.low;\n    }\n}\n\n/** @ignore */\nfunction messageHeaderFromJSON(message: any, type: MessageHeader) {\n    return (() => {\n        switch (type) {\n            case MessageHeader.Schema: return Schema.fromJSON(message);\n            case MessageHeader.RecordBatch: return RecordBatch.fromJSON(message);\n            case MessageHeader.DictionaryBatch: return DictionaryBatch.fromJSON(message);\n        }\n        throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);\n    }) as MessageHeaderDecoder;\n}\n\n/** @ignore */\nfunction decodeMessageHeader(message: _Message, type: MessageHeader) {\n    return (() => {\n        switch (type) {\n            case MessageHeader.Schema: return Schema.decode(message.header(new _Schema())!);\n            case MessageHeader.RecordBatch: return RecordBatch.decode(message.header(new _RecordBatch())!, message.version());\n            case MessageHeader.DictionaryBatch: return DictionaryBatch.decode(message.header(new _DictionaryBatch())!, message.version());\n        }\n        throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);\n    }) as MessageHeaderDecoder;\n}\n\nField['encode'] = encodeField;\nField['decode'] = decodeField;\nField['fromJSON'] = fieldFromJSON;\n\nSchema['encode'] = encodeSchema;\nSchema['decode'] = decodeSchema;\nSchema['fromJSON'] = schemaFromJSON;\n\nRecordBatch['encode'] = encodeRecordBatch;\nRecordBatch['decode'] = decodeRecordBatch;\nRecordBatch['fromJSON'] = recordBatchFromJSON;\n\nDictionaryBatch['encode'] = encodeDictionaryBatch;\nDictionaryBatch['decode'] = decodeDictionaryBatch;\nDictionaryBatch['fromJSON'] = dictionaryBatchFromJSON;\n\nFieldNode['encode'] = encodeFieldNode;\nFieldNode['decode'] = decodeFieldNode;\n\nBufferRegion['encode'] = encodeBufferRegion;\nBufferRegion['decode'] = decodeBufferRegion;\n\ndeclare module '../../schema' {\n    namespace Field {\n        export { encodeField as encode };\n        export { decodeField as decode };\n        export { fieldFromJSON as fromJSON };\n    }\n    namespace Schema {\n        export { encodeSchema as encode };\n        export { decodeSchema as decode };\n        export { schemaFromJSON as fromJSON };\n    }\n}\n\ndeclare module './message' {\n    namespace RecordBatch {\n        export { encodeRecordBatch as encode };\n        export { decodeRecordBatch as decode };\n        export { recordBatchFromJSON as fromJSON };\n    }\n    namespace DictionaryBatch {\n        export { encodeDictionaryBatch as encode };\n        export { decodeDictionaryBatch as decode };\n        export { dictionaryBatchFromJSON as fromJSON };\n    }\n    namespace FieldNode {\n        export { encodeFieldNode as encode };\n        export { decodeFieldNode as decode };\n    }\n    namespace BufferRegion {\n        export { encodeBufferRegion as encode };\n        export { decodeBufferRegion as decode };\n    }\n}\n\n/** @ignore */\nfunction decodeSchema(_schema: _Schema, dictionaries: Map<number, DataType> = new Map()) {\n    const fields = decodeSchemaFields(_schema, dictionaries);\n    return new Schema(fields, decodeCustomMetadata(_schema), dictionaries);\n}\n\n/** @ignore */\nfunction decodeRecordBatch(batch: _RecordBatch, version = MetadataVersion.V4) {\n    return new RecordBatch(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version));\n}\n\n/** @ignore */\nfunction decodeDictionaryBatch(batch: _DictionaryBatch, version = MetadataVersion.V4) {\n    return new DictionaryBatch(RecordBatch.decode(batch.data()!, version), batch.id(), batch.isDelta());\n}\n\n/** @ignore */\nfunction decodeBufferRegion(b: _Buffer) {\n    return new BufferRegion(b.offset(), b.length());\n}\n\n/** @ignore */\nfunction decodeFieldNode(f: _FieldNode) {\n    return new FieldNode(f.length(), f.nullCount());\n}\n\n/** @ignore */\nfunction decodeFieldNodes(batch: _RecordBatch) {\n    const nodes = [] as FieldNode[];\n    for (let f, i = -1, j = -1, n = batch.nodesLength(); ++i < n;) {\n        if (f = batch.nodes(i)) {\n            nodes[++j] = FieldNode.decode(f);\n        }\n    }\n    return nodes;\n}\n\n/** @ignore */\nfunction decodeBuffers(batch: _RecordBatch, version: MetadataVersion) {\n    const bufferRegions = [] as BufferRegion[];\n    for (let b, i = -1, j = -1, n = batch.buffersLength(); ++i < n;) {\n        if (b = batch.buffers(i)) {\n        // If this Arrow buffer was written before version 4,\n        // advance the buffer's bb_pos 8 bytes to skip past\n        // the now-removed page_id field\n        if (version < MetadataVersion.V4) {\n                b.bb_pos += (8 * (i + 1));\n            }\n            bufferRegions[++j] = BufferRegion.decode(b);\n        }\n    }\n    return bufferRegions;\n}\n\n/** @ignore */\nfunction decodeSchemaFields(schema: _Schema, dictionaries?: Map<number, DataType>) {\n    const fields = [] as Field[];\n    for (let f, i = -1, j = -1, n = schema.fieldsLength(); ++i < n;) {\n        if (f = schema.fields(i)) {\n            fields[++j] = Field.decode(f, dictionaries);\n        }\n    }\n    return fields;\n}\n\n/** @ignore */\nfunction decodeFieldChildren(field: _Field, dictionaries?: Map<number, DataType>): Field[] {\n    const children = [] as Field[];\n    for (let f, i = -1, j = -1, n = field.childrenLength(); ++i < n;) {\n        if (f = field.children(i)) {\n            children[++j] = Field.decode(f, dictionaries);\n        }\n    }\n    return children;\n}\n\n/** @ignore */\nfunction decodeField(f: _Field, dictionaries?: Map<number, DataType>) {\n\n    let id: number;\n    let field: Field | void;\n    let type: DataType<any>;\n    let keys: _Int | TKeys | null;\n    let dictType: Dictionary;\n    let dictMeta: _DictionaryEncoding | null;\n\n    // If no dictionary encoding\n    if (!dictionaries || !(dictMeta = f.dictionary())) {\n        type = decodeFieldType(f, decodeFieldChildren(f, dictionaries));\n        field = new Field(f.name()!, type, f.nullable(), decodeCustomMetadata(f));\n    }\n    // tslint:disable\n    // If dictionary encoded and the first time we've seen this dictionary id, decode\n    // the data type and child fields, then wrap in a Dictionary type and insert the\n    // data type into the dictionary types map.\n    else if (!dictionaries.has(id = dictMeta.id().low)) {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta.indexType()) ? decodeIndexType(keys) as TKeys : new Int32();\n        dictionaries.set(id, type = decodeFieldType(f, decodeFieldChildren(f, dictionaries)));\n        dictType = new Dictionary(type, keys, id, dictMeta.isOrdered());\n        field = new Field(f.name()!, dictType, f.nullable(), decodeCustomMetadata(f));\n    }\n    // If dictionary encoded, and have already seen this dictionary Id in the schema, then reuse the\n    // data type and wrap in a new Dictionary type and field.\n    else {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta.indexType()) ? decodeIndexType(keys) as TKeys : new Int32();\n        dictType = new Dictionary(dictionaries.get(id)!, keys, id, dictMeta.isOrdered());\n        field = new Field(f.name()!, dictType, f.nullable(), decodeCustomMetadata(f));\n    }\n    return field || null;\n}\n\n/** @ignore */\nfunction decodeCustomMetadata(parent?: _Schema | _Field | null) {\n    const data = new Map<string, string>();\n    if (parent) {\n        for (let entry, key, i = -1, n = parent.customMetadataLength() | 0; ++i < n;) {\n            if ((entry = parent.customMetadata(i)) && (key = entry.key()) != null) {\n                data.set(key, entry.value()!);\n            }\n        }\n    }\n    return data;\n}\n\n/** @ignore */\nfunction decodeIndexType(_type: _Int) {\n    return new Int(_type.isSigned(), _type.bitWidth() as IntBitWidth);\n}\n\n/** @ignore */\nfunction decodeFieldType(f: _Field, children?: Field[]): DataType<any> {\n\n    const typeId = f.typeType();\n\n    switch (typeId) {\n        case Type.NONE:    return new Null();\n        case Type.Null:    return new Null();\n        case Type.Binary:  return new Binary();\n        case Type.Utf8:    return new Utf8();\n        case Type.Bool:    return new Bool();\n        case Type.List:    return new List((children || [])[0]);\n        case Type.Struct_: return new Struct(children || []);\n    }\n\n    switch (typeId) {\n        case Type.Int: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Int())!;\n            return new Int(t.isSigned(), t.bitWidth());\n        }\n        case Type.FloatingPoint: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.FloatingPoint())!;\n            return new Float(t.precision());\n        }\n        case Type.Decimal: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Decimal())!;\n            return new Decimal(t.scale(), t.precision());\n        }\n        case Type.Date: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Date())!;\n            return new Date_(t.unit());\n        }\n        case Type.Time: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Time())!;\n            return new Time(t.unit(), t.bitWidth() as TimeBitWidth);\n        }\n        case Type.Timestamp: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Timestamp())!;\n            return new Timestamp(t.unit(), t.timezone());\n        }\n        case Type.Interval: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Interval())!;\n            return new Interval(t.unit());\n        }\n        case Type.Union: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Union())!;\n            return new Union(t.mode(), t.typeIdsArray() || [], children || []);\n        }\n        case Type.FixedSizeBinary: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.FixedSizeBinary())!;\n            return new FixedSizeBinary(t.byteWidth());\n        }\n        case Type.FixedSizeList: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.FixedSizeList())!;\n            return new FixedSizeList(t.listSize(), (children || [])[0]);\n        }\n        case Type.Map: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Map())!;\n            return new Map_((children || [])[0], t.keysSorted());\n        }\n    }\n    throw new Error(`Unrecognized type: \"${Type[typeId]}\" (${typeId})`);\n}\n\n/** @ignore */\nfunction encodeSchema(b: Builder, schema: Schema) {\n\n    const fieldOffsets = schema.fields.map((f) => Field.encode(b, f));\n\n    _Schema.startFieldsVector(b, fieldOffsets.length);\n\n    const fieldsVectorOffset = _Schema.createFieldsVector(b, fieldOffsets);\n\n    const metadataOffset = !(schema.metadata && schema.metadata.size > 0) ? -1 :\n        _Schema.createCustomMetadataVector(b, [...schema.metadata].map(([k, v]) => {\n            const key = b.createString(`${k}`);\n            const val = b.createString(`${v}`);\n            _KeyValue.startKeyValue(b);\n            _KeyValue.addKey(b, key);\n            _KeyValue.addValue(b, val);\n            return _KeyValue.endKeyValue(b);\n        }));\n\n    _Schema.startSchema(b);\n    _Schema.addFields(b, fieldsVectorOffset);\n    _Schema.addEndianness(b, platformIsLittleEndian ? _Endianness.Little : _Endianness.Big);\n\n    if (metadataOffset !== -1) { _Schema.addCustomMetadata(b, metadataOffset); }\n\n    return _Schema.endSchema(b);\n}\n\n/** @ignore */\nfunction encodeField(b: Builder, field: Field) {\n\n    let nameOffset = -1;\n    let typeOffset = -1;\n    let dictionaryOffset = -1;\n\n    let type = field.type;\n    let typeId: Type = <any> field.typeId;\n\n    if (!DataType.isDictionary(type)) {\n        typeOffset = typeAssembler.visit(type, b)!;\n    } else {\n        typeId = type.dictionary.typeId;\n        dictionaryOffset = typeAssembler.visit(type, b)!;\n        typeOffset = typeAssembler.visit(type.dictionary, b)!;\n    }\n\n    const childOffsets = (type.children || []).map((f: Field) => Field.encode(b, f));\n    const childrenVectorOffset = _Field.createChildrenVector(b, childOffsets);\n\n    const metadataOffset = !(field.metadata && field.metadata.size > 0) ? -1 :\n        _Field.createCustomMetadataVector(b, [...field.metadata].map(([k, v]) => {\n            const key = b.createString(`${k}`);\n            const val = b.createString(`${v}`);\n            _KeyValue.startKeyValue(b);\n            _KeyValue.addKey(b, key);\n            _KeyValue.addValue(b, val);\n            return _KeyValue.endKeyValue(b);\n        }));\n\n    if (field.name) {\n        nameOffset = b.createString(field.name);\n    }\n\n    _Field.startField(b);\n    _Field.addType(b, typeOffset);\n    _Field.addTypeType(b, typeId);\n    _Field.addChildren(b, childrenVectorOffset);\n    _Field.addNullable(b, !!field.nullable);\n\n    if (nameOffset !== -1) { _Field.addName(b, nameOffset); }\n    if (dictionaryOffset !== -1) { _Field.addDictionary(b, dictionaryOffset); }\n    if (metadataOffset !== -1) { _Field.addCustomMetadata(b, metadataOffset); }\n\n    return _Field.endField(b);\n}\n\n/** @ignore */\nfunction encodeRecordBatch(b: Builder, recordBatch: RecordBatch) {\n\n    const nodes = recordBatch.nodes || [];\n    const buffers = recordBatch.buffers || [];\n\n    _RecordBatch.startNodesVector(b, nodes.length);\n    nodes.slice().reverse().forEach((n) => FieldNode.encode(b, n));\n\n    const nodesVectorOffset = b.endVector();\n\n    _RecordBatch.startBuffersVector(b, buffers.length);\n    buffers.slice().reverse().forEach((b_) => BufferRegion.encode(b, b_));\n\n    const buffersVectorOffset = b.endVector();\n\n    _RecordBatch.startRecordBatch(b);\n    _RecordBatch.addLength(b, new Long(recordBatch.length, 0));\n    _RecordBatch.addNodes(b, nodesVectorOffset);\n    _RecordBatch.addBuffers(b, buffersVectorOffset);\n    return _RecordBatch.endRecordBatch(b);\n}\n\n/** @ignore */\nfunction encodeDictionaryBatch(b: Builder, dictionaryBatch: DictionaryBatch) {\n    const dataOffset = RecordBatch.encode(b, dictionaryBatch.data);\n    _DictionaryBatch.startDictionaryBatch(b);\n    _DictionaryBatch.addId(b, new Long(dictionaryBatch.id, 0));\n    _DictionaryBatch.addIsDelta(b, dictionaryBatch.isDelta);\n    _DictionaryBatch.addData(b, dataOffset);\n    return _DictionaryBatch.endDictionaryBatch(b);\n}\n\n/** @ignore */\nfunction encodeFieldNode(b: Builder, node: FieldNode) {\n    return _FieldNode.createFieldNode(b, new Long(node.length, 0), new Long(node.nullCount, 0));\n}\n\n/** @ignore */\nfunction encodeBufferRegion(b: Builder, node: BufferRegion) {\n    return _Buffer.createBuffer(b, new Long(node.offset, 0), new Long(node.length, 0));\n}\n\n/** @ignore */\nconst platformIsLittleEndian = (function() {\n    const buffer = new ArrayBuffer(2);\n    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);\n    // Int16Array uses the platform's endianness.\n    return new Int16Array(buffer)[0] === 256;\n})();\n\n/** @ignore */\ntype MessageHeaderDecoder = <T extends MessageHeader>() => T extends MessageHeader.Schema ? Schema\n                                                         : T extends MessageHeader.RecordBatch ? RecordBatch\n                                                         : T extends MessageHeader.DictionaryBatch ? DictionaryBatch : never;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { MessageHeader } from '../enum';\nimport { flatbuffers } from 'flatbuffers';\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport { Message } from './metadata/message';\nimport { isFileHandle } from '../util/compat';\nimport { AsyncRandomAccessFile } from '../io/file';\nimport { toUint8Array, ArrayBufferViewInput } from '../util/buffer';\nimport { ByteStream, ReadableSource, AsyncByteStream } from '../io/stream';\nimport { ArrowJSON, ArrowJSONLike, ITERATOR_DONE, FileHandle } from '../io/interfaces';\n\n/** @ignore */ const invalidMessageType       = (type: MessageHeader) => `Expected ${MessageHeader[type]} Message in stream, but was null or length 0.`;\n/** @ignore */ const nullMessage              = (type: MessageHeader) => `Header pointer of flatbuffer-encoded ${MessageHeader[type]} Message is null or length 0.`;\n/** @ignore */ const invalidMessageMetadata   = (expected: number, actual: number) => `Expected to read ${expected} metadata bytes, but only read ${actual}.`;\n/** @ignore */ const invalidMessageBodyLength = (expected: number, actual: number) => `Expected to read ${expected} bytes for message body, but only read ${actual}.`;\n\n/** @ignore */\nexport class MessageReader implements IterableIterator<Message> {\n    protected source: ByteStream;\n    constructor(source: ByteStream | ArrayBufferViewInput | Iterable<ArrayBufferViewInput>) {\n        this.source = source instanceof ByteStream ? source : new ByteStream(source);\n    }\n    public [Symbol.iterator](): IterableIterator<Message> { return this as IterableIterator<Message>; }\n    public next(): IteratorResult<Message> {\n        let r;\n        if ((r = this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        // ARROW-6313: If the first 4 bytes are continuation indicator (-1), read\n        // the next 4 for the 32-bit metadata length. Otherwise, assume this is a\n        // pre-v0.15 message, where the first 4 bytes are the metadata length.\n        if ((r.value === -1) &&\n            (r = this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        if ((r = this.readMetadata(r.value)).done) { return ITERATOR_DONE; }\n        return (<any> r) as IteratorResult<Message>;\n    }\n    public throw(value?: any) { return this.source.throw(value); }\n    public return(value?: any) { return this.source.return(value); }\n    public readMessage<T extends MessageHeader>(type?: T | null) {\n        let r: IteratorResult<Message<T>>;\n        if ((r = this.next()).done) { return null; }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    public readMessageBody(bodyLength: number): Uint8Array {\n        if (bodyLength <= 0) { return new Uint8Array(0); }\n        const buf = toUint8Array(this.source.read(bodyLength));\n        if (buf.byteLength < bodyLength) {\n            throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));\n        }\n        // 1. Work around bugs in fs.ReadStream's internal Buffer pooling, see: https://github.com/nodejs/node/issues/24817\n        // 2. Work around https://github.com/whatwg/streams/blob/0ebe4b042e467d9876d80ae045de3843092ad797/reference-implementation/lib/helpers.js#L126\n        return /* 1. */ (buf.byteOffset % 8 === 0) &&\n               /* 2. */ (buf.byteOffset + buf.byteLength) <= buf.buffer.byteLength ? buf : buf.slice();\n    }\n    public readSchema(throwIfNull = false) {\n        const type = MessageHeader.Schema;\n        const message = this.readMessage(type);\n        const schema = message && message.header();\n        if (throwIfNull && !schema) {\n            throw new Error(nullMessage(type));\n        }\n        return schema;\n    }\n    protected readMetadataLength(): IteratorResult<number> {\n        const buf = this.source.read(PADDING);\n        const bb = buf && new ByteBuffer(buf);\n        const len = bb && bb.readInt32(0) || 0;\n        return { done: len === 0, value: len };\n    }\n    protected readMetadata(metadataLength: number): IteratorResult<Message> {\n        const buf = this.source.read(metadataLength);\n        if (!buf) { return ITERATOR_DONE; }\n        if (buf.byteLength < metadataLength) {\n            throw new Error(invalidMessageMetadata(metadataLength, buf.byteLength));\n        }\n        return { done: false, value: Message.decode(buf) };\n    }\n}\n\n/** @ignore */\nexport class AsyncMessageReader implements AsyncIterableIterator<Message> {\n    protected source: AsyncByteStream;\n    constructor(source: ReadableSource<Uint8Array>);\n    constructor(source: FileHandle, byteLength?: number);\n    constructor(source: any, byteLength?: number) {\n        this.source = source instanceof AsyncByteStream ? source\n            : isFileHandle(source)\n            ? new AsyncRandomAccessFile(source, byteLength!)\n            : new AsyncByteStream(source);\n    }\n    public [Symbol.asyncIterator](): AsyncIterableIterator<Message> { return this as AsyncIterableIterator<Message>; }\n    public async next(): Promise<IteratorResult<Message>> {\n        let r;\n        if ((r = await this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        // ARROW-6313: If the first 4 bytes are continuation indicator (-1), read\n        // the next 4 for the 32-bit metadata length. Otherwise, assume this is a\n        // pre-v0.15 message, where the first 4 bytes are the metadata length.\n        if ((r.value === -1) &&\n            (r = await this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        if ((r = await this.readMetadata(r.value)).done) { return ITERATOR_DONE; }\n        return (<any> r) as IteratorResult<Message>;\n    }\n    public async throw(value?: any) { return await this.source.throw(value); }\n    public async return(value?: any) { return await this.source.return(value); }\n    public async readMessage<T extends MessageHeader>(type?: T | null) {\n        let r: IteratorResult<Message<T>>;\n        if ((r = await this.next()).done) { return null; }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    public async readMessageBody(bodyLength: number): Promise<Uint8Array> {\n        if (bodyLength <= 0) { return new Uint8Array(0); }\n        const buf = toUint8Array(await this.source.read(bodyLength));\n        if (buf.byteLength < bodyLength) {\n            throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));\n        }\n        // 1. Work around bugs in fs.ReadStream's internal Buffer pooling, see: https://github.com/nodejs/node/issues/24817\n        // 2. Work around https://github.com/whatwg/streams/blob/0ebe4b042e467d9876d80ae045de3843092ad797/reference-implementation/lib/helpers.js#L126\n        return /* 1. */ (buf.byteOffset % 8 === 0) &&\n               /* 2. */ (buf.byteOffset + buf.byteLength) <= buf.buffer.byteLength ? buf : buf.slice();\n    }\n    public async readSchema(throwIfNull = false) {\n        const type = MessageHeader.Schema;\n        const message = await this.readMessage(type);\n        const schema = message && message.header();\n        if (throwIfNull && !schema) {\n            throw new Error(nullMessage(type));\n        }\n        return schema;\n    }\n    protected async readMetadataLength(): Promise<IteratorResult<number>> {\n        const buf = await this.source.read(PADDING);\n        const bb = buf && new ByteBuffer(buf);\n        const len = bb && bb.readInt32(0) || 0;\n        return { done: len === 0, value: len };\n    }\n    protected async readMetadata(metadataLength: number): Promise<IteratorResult<Message>> {\n        const buf = await this.source.read(metadataLength);\n        if (!buf) { return ITERATOR_DONE; }\n        if (buf.byteLength < metadataLength) {\n            throw new Error(invalidMessageMetadata(metadataLength, buf.byteLength));\n        }\n        return { done: false, value: Message.decode(buf) };\n    }\n}\n\n/** @ignore */\nexport class JSONMessageReader extends MessageReader {\n    private _schema = false;\n    private _json: ArrowJSON;\n    private _body: any[] = [];\n    private _batchIndex = 0;\n    private _dictionaryIndex = 0;\n    constructor(source: ArrowJSON | ArrowJSONLike) {\n        super(new Uint8Array(0));\n        this._json = source instanceof ArrowJSON ? source : new ArrowJSON(source);\n    }\n    public next() {\n        const { _json } = this;\n        if (!this._schema) {\n            this._schema = true;\n            const message = Message.fromJSON(_json.schema, MessageHeader.Schema);\n            return { done: false, value: message };\n        }\n        if (this._dictionaryIndex < _json.dictionaries.length) {\n            const batch = _json.dictionaries[this._dictionaryIndex++];\n            this._body = batch['data']['columns'];\n            const message = Message.fromJSON(batch, MessageHeader.DictionaryBatch);\n            return { done: false, value: message };\n        }\n        if (this._batchIndex < _json.batches.length) {\n            const batch = _json.batches[this._batchIndex++];\n            this._body = batch['columns'];\n            const message = Message.fromJSON(batch, MessageHeader.RecordBatch);\n            return { done: false, value: message };\n        }\n        this._body = [];\n        return ITERATOR_DONE;\n    }\n    public readMessageBody(_bodyLength?: number) {\n        return flattenDataSources(this._body) as any;\n        function flattenDataSources(xs: any[]): any[][] {\n            return (xs || []).reduce<any[][]>((buffers, column: any) => [\n                ...buffers,\n                ...(column['VALIDITY'] && [column['VALIDITY']] || []),\n                ...(column['TYPE'] && [column['TYPE']] || []),\n                ...(column['OFFSET'] && [column['OFFSET']] || []),\n                ...(column['DATA'] && [column['DATA']] || []),\n                ...flattenDataSources(column['children'])\n            ], [] as any[][]);\n        }\n    }\n    public readMessage<T extends MessageHeader>(type?: T | null) {\n        let r: IteratorResult<Message<T>>;\n        if ((r = this.next()).done) { return null; }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    public readSchema() {\n        const type = MessageHeader.Schema;\n        const message = this.readMessage(type);\n        const schema = message && message.header();\n        if (!message || !schema) {\n            throw new Error(nullMessage(type));\n        }\n        return schema;\n    }\n}\n\n/** @ignore */\nexport const PADDING = 4;\n/** @ignore */\nexport const MAGIC_STR = 'ARROW1';\n/** @ignore */\nexport const MAGIC = new Uint8Array(MAGIC_STR.length);\n\nfor (let i = 0; i < MAGIC_STR.length; i += 1 | 0) {\n    MAGIC[i] = MAGIC_STR.charCodeAt(i);\n}\n\n/** @ignore */\nexport function checkForMagicArrowString(buffer: Uint8Array, index = 0) {\n    for (let i = -1, n = MAGIC.length; ++i < n;) {\n        if (MAGIC[i] !== buffer[index + i]) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/** @ignore */\nexport const magicLength = MAGIC.length;\n/** @ignore */\nexport const magicAndPadding = magicLength + PADDING;\n/** @ignore */\nexport const magicX2AndPadding = magicLength * 2 + PADDING;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { Visitor } from '../visitor';\nimport { Type, UnionMode } from '../enum';\nimport { RecordBatch } from '../recordbatch';\nimport { VectorType as V } from '../interfaces';\nimport { rebaseValueOffsets } from '../util/buffer';\nimport { packBools, truncateBitmap } from '../util/bit';\nimport { selectVectorChildrenArgs } from '../util/args';\nimport { BufferRegion, FieldNode } from '../ipc/metadata/message';\nimport {\n    DataType, Dictionary,\n    Float, Int, Date_, Interval, Time, Timestamp, Union,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n} from '../type';\n\n/** @ignore */\nexport interface VectorAssembler extends Visitor {\n    visit<T extends Vector>(node: T): this;\n    visitMany<T extends Vector>(nodes: T[]): this[];\n    getVisitFn<T extends Type>(node: T): (vector: V<T>) => this;\n    getVisitFn<T extends DataType>(node: V<T> | Data<T> | T): (vector: V<T>) => this;\n\n    visitBool                 <T extends Bool>            (vector: V<T>): this;\n    visitInt                  <T extends Int>             (vector: V<T>): this;\n    visitFloat                <T extends Float>           (vector: V<T>): this;\n    visitUtf8                 <T extends Utf8>            (vector: V<T>): this;\n    visitBinary               <T extends Binary>          (vector: V<T>): this;\n    visitFixedSizeBinary      <T extends FixedSizeBinary> (vector: V<T>): this;\n    visitDate                 <T extends Date_>           (vector: V<T>): this;\n    visitTimestamp            <T extends Timestamp>       (vector: V<T>): this;\n    visitTime                 <T extends Time>            (vector: V<T>): this;\n    visitDecimal              <T extends Decimal>         (vector: V<T>): this;\n    visitList                 <T extends List>            (vector: V<T>): this;\n    visitStruct               <T extends Struct>          (vector: V<T>): this;\n    visitUnion                <T extends Union>           (vector: V<T>): this;\n    visitInterval             <T extends Interval>        (vector: V<T>): this;\n    visitFixedSizeList        <T extends FixedSizeList>   (vector: V<T>): this;\n    visitMap                  <T extends Map_>            (vector: V<T>): this;\n}\n\n/** @ignore */\nexport class VectorAssembler extends Visitor {\n\n    /** @nocollapse */\n    public static assemble<T extends Vector | RecordBatch>(...args: (T | T[])[]) {\n        const assembler = new VectorAssembler();\n        const vectorChildren = selectVectorChildrenArgs(RecordBatch, args);\n        const [assembleResult = assembler] = assembler.visitMany(vectorChildren);\n        return assembleResult;\n    }\n\n    private constructor() { super(); }\n\n    public visit<T extends Vector>(vector: T): this {\n        if (!DataType.isDictionary(vector.type)) {\n            const { data, length, nullCount } = vector;\n            if (length > 2147483647) {\n                /* istanbul ignore next */\n                throw new RangeError('Cannot write arrays larger than 2^31 - 1 in length');\n            }\n            if (!DataType.isNull(vector.type)) {\n                addBuffer.call(this, nullCount <= 0\n                    ? new Uint8Array(0) // placeholder validity buffer\n                    : truncateBitmap(data.offset, length, data.nullBitmap)\n                );\n            }\n            this.nodes.push(new FieldNode(length, nullCount));\n        }\n        return super.visit(vector);\n    }\n\n    public visitNull<T extends Null>(_nullV: V<T>) {\n        return this;\n    }\n    public visitDictionary<T extends Dictionary>(vector: V<T>) {\n        // Assemble the indices here, Dictionary assembled separately.\n        return this.visit(vector.indices);\n    }\n\n    public get nodes() { return this._nodes; }\n    public get buffers() { return this._buffers; }\n    public get byteLength() { return this._byteLength; }\n    public get bufferRegions() { return this._bufferRegions; }\n\n    protected _byteLength = 0;\n    protected _nodes: FieldNode[] = [];\n    protected _buffers: ArrayBufferView[] = [];\n    protected _bufferRegions: BufferRegion[] = [];\n}\n\n/** @ignore */\nfunction addBuffer(this: VectorAssembler, values: ArrayBufferView) {\n    const byteLength = (values.byteLength + 7) & ~7; // Round up to a multiple of 8\n    this.buffers.push(values);\n    this.bufferRegions.push(new BufferRegion(this._byteLength, byteLength));\n    this._byteLength += byteLength;\n    return this;\n}\n\n/** @ignore */\nfunction assembleUnion<T extends Union>(this: VectorAssembler, vector: V<T>) {\n    const { type, length, typeIds, valueOffsets } = vector;\n    // All Union Vectors have a typeIds buffer\n    addBuffer.call(this, typeIds);\n    // If this is a Sparse Union, treat it like all other Nested types\n    if (type.mode === UnionMode.Sparse) {\n        return assembleNestedVector.call(this, vector);\n    } else if (type.mode === UnionMode.Dense) {\n        // If this is a Dense Union, add the valueOffsets buffer and potentially slice the children\n        if (vector.offset <= 0) {\n            // If the Vector hasn't been sliced, write the existing valueOffsets\n            addBuffer.call(this, valueOffsets);\n            // We can treat this like all other Nested types\n            return assembleNestedVector.call(this, vector);\n        } else {\n            // A sliced Dense Union is an unpleasant case. Because the offsets are different for\n            // each child vector, we need to \"rebase\" the valueOffsets for each child\n            // Union typeIds are not necessary 0-indexed\n            const maxChildTypeId = typeIds.reduce((x, y) => Math.max(x, y), typeIds[0]);\n            const childLengths = new Int32Array(maxChildTypeId + 1);\n            // Set all to -1 to indicate that we haven't observed a first occurrence of a particular child yet\n            const childOffsets = new Int32Array(maxChildTypeId + 1).fill(-1);\n            const shiftedOffsets = new Int32Array(length);\n            // If we have a non-zero offset, then the value offsets do not start at\n            // zero. We must a) create a new offsets array with shifted offsets and\n            // b) slice the values array accordingly\n            const unshiftedOffsets = rebaseValueOffsets(-valueOffsets[0], length, valueOffsets);\n            for (let typeId, shift, index = -1; ++index < length;) {\n                if ((shift = childOffsets[typeId = typeIds[index]]) === -1) {\n                    shift = childOffsets[typeId] = unshiftedOffsets[typeId];\n                }\n                shiftedOffsets[index] = unshiftedOffsets[index] - shift;\n                ++childLengths[typeId];\n            }\n            addBuffer.call(this, shiftedOffsets);\n            // Slice and visit children accordingly\n            for (let child: Vector | null, childIndex = -1, numChildren = type.children.length; ++childIndex < numChildren;) {\n                if (child = vector.getChildAt(childIndex)) {\n                    const typeId = type.typeIds[childIndex];\n                    const childLength = Math.min(length, childLengths[typeId]);\n                    this.visit(child.slice(childOffsets[typeId], childLength));\n                }\n            }\n        }\n    }\n    return this;\n}\n\n/** @ignore */\nfunction assembleBoolVector<T extends Bool>(this: VectorAssembler, vector: V<T>) {\n    // Bool vector is a special case of FlatVector, as its data buffer needs to stay packed\n    let values: Uint8Array;\n    if (vector.nullCount >= vector.length) {\n        // If all values are null, just insert a placeholder empty data buffer (fastest path)\n        return addBuffer.call(this, new Uint8Array(0));\n    } else if ((values = vector.values) instanceof Uint8Array) {\n        // If values is already a Uint8Array, slice the bitmap (fast path)\n        return addBuffer.call(this, truncateBitmap(vector.offset, vector.length, values));\n    }\n    // Otherwise if the underlying data *isn't* a Uint8Array, enumerate the\n    // values as bools and re-pack them into a Uint8Array. This code isn't\n    // reachable unless you're trying to manipulate the Data internals,\n    // we we're only doing this for safety.\n    /* istanbul ignore next */\n    return addBuffer.call(this, packBools(vector));\n}\n\n/** @ignore */\nfunction assembleFlatVector<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval>(this: VectorAssembler, vector: V<T>) {\n    return addBuffer.call(this, vector.values.subarray(0, vector.length * vector.stride));\n}\n\n/** @ignore */\nfunction assembleFlatListVector<T extends Utf8 | Binary>(this: VectorAssembler, vector: V<T>) {\n    const { length, values, valueOffsets } = vector;\n    const firstOffset = valueOffsets[0];\n    const lastOffset = valueOffsets[length];\n    const byteLength = Math.min(lastOffset - firstOffset, values.byteLength - firstOffset);\n    // Push in the order FlatList types read their buffers\n    addBuffer.call(this, rebaseValueOffsets(-valueOffsets[0], length, valueOffsets)); // valueOffsets buffer first\n    addBuffer.call(this, values.subarray(firstOffset, firstOffset + byteLength)); // sliced values buffer second\n    return this;\n}\n\n/** @ignore */\nfunction assembleListVector<T extends Map_ | List | FixedSizeList>(this: VectorAssembler, vector: V<T>) {\n    const { length, valueOffsets } = vector;\n    // If we have valueOffsets (MapVector, ListVector), push that buffer first\n    if (valueOffsets) {\n        addBuffer.call(this, rebaseValueOffsets(valueOffsets[0], length, valueOffsets));\n    }\n    // Then insert the List's values child\n    return this.visit(vector.getChildAt(0)!);\n}\n\n/** @ignore */\nfunction assembleNestedVector<T extends Struct | Union>(this: VectorAssembler, vector: V<T>) {\n    return this.visitMany(vector.type.children.map((_, i) => vector.getChildAt(i)!).filter(Boolean))[0];\n}\n\nVectorAssembler.prototype.visitBool            =     assembleBoolVector;\nVectorAssembler.prototype.visitInt             =     assembleFlatVector;\nVectorAssembler.prototype.visitFloat           =     assembleFlatVector;\nVectorAssembler.prototype.visitUtf8            = assembleFlatListVector;\nVectorAssembler.prototype.visitBinary          = assembleFlatListVector;\nVectorAssembler.prototype.visitFixedSizeBinary =     assembleFlatVector;\nVectorAssembler.prototype.visitDate            =     assembleFlatVector;\nVectorAssembler.prototype.visitTimestamp       =     assembleFlatVector;\nVectorAssembler.prototype.visitTime            =     assembleFlatVector;\nVectorAssembler.prototype.visitDecimal         =     assembleFlatVector;\nVectorAssembler.prototype.visitList            =     assembleListVector;\nVectorAssembler.prototype.visitStruct          =   assembleNestedVector;\nVectorAssembler.prototype.visitUnion           =          assembleUnion;\nVectorAssembler.prototype.visitInterval        =     assembleFlatVector;\nVectorAssembler.prototype.visitFixedSizeList   =     assembleListVector;\nVectorAssembler.prototype.visitMap             =     assembleListVector;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport * as type from '../type';\nimport { Visitor } from '../visitor';\nimport { ArrowType, Precision, DateUnit, TimeUnit, IntervalUnit, UnionMode } from '../enum';\n\n/** @ignore */\nexport interface JSONTypeAssembler extends Visitor {\n    visit<T extends type.DataType>(node: T): object | undefined;\n}\n\n/** @ignore */\nexport class JSONTypeAssembler extends Visitor {\n    public visit<T extends type.DataType>(node: T): object | undefined {\n        return node == null ? undefined : super.visit(node);\n    }\n    public visitNull<T extends type.Null>({ typeId }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase() };\n    }\n    public visitInt<T extends type.Int>({ typeId, bitWidth, isSigned }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'bitWidth': bitWidth, 'isSigned': isSigned };\n    }\n    public visitFloat<T extends type.Float>({ typeId, precision }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'precision': Precision[precision] };\n    }\n    public visitBinary<T extends type.Binary>({ typeId }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase() };\n    }\n    public visitBool<T extends type.Bool>({ typeId }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase() };\n    }\n    public visitUtf8<T extends type.Utf8>({ typeId }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase() };\n    }\n    public visitDecimal<T extends type.Decimal>({ typeId, scale, precision }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'scale': scale, 'precision': precision };\n    }\n    public visitDate<T extends type.Date_>({ typeId, unit }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'unit': DateUnit[unit] };\n    }\n    public visitTime<T extends type.Time>({ typeId, unit, bitWidth }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'unit': TimeUnit[unit], bitWidth };\n    }\n    public visitTimestamp<T extends type.Timestamp>({ typeId, timezone, unit }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'unit': TimeUnit[unit], timezone };\n    }\n    public visitInterval<T extends type.Interval>({ typeId, unit }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'unit': IntervalUnit[unit] };\n    }\n    public visitList<T extends type.List>({ typeId }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase() };\n    }\n    public visitStruct<T extends type.Struct>({ typeId }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase() };\n    }\n    public visitUnion<T extends type.Union>({ typeId, mode, typeIds }: T) {\n        return {\n            'name': ArrowType[typeId].toLowerCase(),\n            'mode': UnionMode[mode],\n            'typeIds': [...typeIds]\n        };\n    }\n    public visitDictionary<T extends type.Dictionary>(node: T) {\n        return this.visit(node.dictionary);\n    }\n    public visitFixedSizeBinary<T extends type.FixedSizeBinary>({ typeId, byteWidth }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'byteWidth': byteWidth };\n    }\n    public visitFixedSizeList<T extends type.FixedSizeList>({ typeId, listSize }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'listSize': listSize };\n    }\n    public visitMap<T extends type.Map_>({ typeId, keysSorted }: T) {\n        return { 'name': ArrowType[typeId].toLowerCase(), 'keysSorted': keysSorted };\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BN } from '../util/bn';\nimport { Column } from '../column';\nimport { Vector } from '../vector';\nimport { Visitor } from '../visitor';\nimport { BufferType } from '../enum';\nimport { RecordBatch } from '../recordbatch';\nimport { VectorType as V } from '../interfaces';\nimport { UnionMode, DateUnit, TimeUnit } from '../enum';\nimport { iterateBits, getBit, getBool } from '../util/bit';\nimport { selectColumnChildrenArgs } from '../util/args';\nimport {\n    DataType,\n    Float, Int, Date_, Interval, Time, Timestamp, Union,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n} from '../type';\n\n/** @ignore */\nexport interface JSONVectorAssembler extends Visitor {\n\n    visit     <T extends Column>  (node: T  ): object;\n    visitMany <T extends Column>  (cols: T[]): object[];\n    getVisitFn<T extends DataType>(node: Column<T>): (column: Column<T>) => { name: string, count: number, VALIDITY: (0 | 1)[], DATA?: any[], OFFSET?: number[], TYPE?: number[], children?: any[] };\n\n    visitNull                 <T extends Null>            (vector: V<T>): { };\n    visitBool                 <T extends Bool>            (vector: V<T>): { DATA: boolean[] };\n    visitInt                  <T extends Int>             (vector: V<T>): { DATA: (number | string)[]  };\n    visitFloat                <T extends Float>           (vector: V<T>): { DATA: number[]  };\n    visitUtf8                 <T extends Utf8>            (vector: V<T>): { DATA: string[], OFFSET: number[] };\n    visitBinary               <T extends Binary>          (vector: V<T>): { DATA: string[], OFFSET: number[] };\n    visitFixedSizeBinary      <T extends FixedSizeBinary> (vector: V<T>): { DATA: string[]  };\n    visitDate                 <T extends Date_>           (vector: V<T>): { DATA: number[]  };\n    visitTimestamp            <T extends Timestamp>       (vector: V<T>): { DATA: string[]  };\n    visitTime                 <T extends Time>            (vector: V<T>): { DATA: number[]  };\n    visitDecimal              <T extends Decimal>         (vector: V<T>): { DATA: string[]  };\n    visitList                 <T extends List>            (vector: V<T>): { children: any[], OFFSET: number[] };\n    visitStruct               <T extends Struct>          (vector: V<T>): { children: any[] };\n    visitUnion                <T extends Union>           (vector: V<T>): { children: any[], TYPE: number[],  };\n    visitInterval             <T extends Interval>        (vector: V<T>): { DATA: number[]  };\n    visitFixedSizeList        <T extends FixedSizeList>   (vector: V<T>): { children: any[] };\n    visitMap                  <T extends Map_>            (vector: V<T>): { children: any[] };\n}\n\n/** @ignore */\nexport class JSONVectorAssembler extends Visitor {\n\n    /** @nocollapse */\n    public static assemble<T extends Column | RecordBatch>(...args: (T | T[])[]) {\n        return new JSONVectorAssembler().visitMany(selectColumnChildrenArgs(RecordBatch, args));\n    }\n\n    public visit<T extends Column>(column: T) {\n        const { data, name, length } = column;\n        const { offset, nullCount, nullBitmap } = data;\n        const type = DataType.isDictionary(column.type) ? column.type.indices : column.type;\n        const buffers = Object.assign([], data.buffers, { [BufferType.VALIDITY]: undefined });\n        return {\n            'name': name,\n            'count': length,\n            'VALIDITY': DataType.isNull(type) ? undefined\n                : nullCount <= 0 ? Array.from({ length }, () => 1)\n                : [...iterateBits(nullBitmap, offset, length, null, getBit)],\n            ...super.visit(Vector.new(data.clone(type, offset, length, 0, buffers)))\n        };\n    }\n    public visitNull() { return {}; }\n    public visitBool<T extends Bool>({ values, offset, length }: V<T>) {\n        return { 'DATA': [...iterateBits(values, offset, length, null, getBool)] };\n    }\n    public visitInt<T extends Int>(vector: V<T>) {\n        return {\n            'DATA': vector.type.bitWidth < 64\n                ? [...vector.values]\n                : [...bigNumsToStrings(vector.values as (Int32Array | Uint32Array), 2)]\n        };\n    }\n    public visitFloat<T extends Float>(vector: V<T>) {\n        return { 'DATA': [...vector.values] };\n    }\n    public visitUtf8<T extends Utf8>(vector: V<T>) {\n        return { 'DATA': [...vector], 'OFFSET': [...vector.valueOffsets] };\n    }\n    public visitBinary<T extends Binary>(vector: V<T>) {\n        return { 'DATA': [...binaryToString(vector)], OFFSET: [...vector.valueOffsets] };\n    }\n    public visitFixedSizeBinary<T extends FixedSizeBinary>(vector: V<T>) {\n        return { 'DATA': [...binaryToString(vector)] };\n    }\n    public visitDate<T extends Date_>(vector: V<T>) {\n        return {\n            'DATA': vector.type.unit === DateUnit.DAY\n                ? [...vector.values]\n                : [...bigNumsToStrings(vector.values, 2)]\n        };\n    }\n    public visitTimestamp<T extends Timestamp>(vector: V<T>) {\n        return { 'DATA': [...bigNumsToStrings(vector.values, 2)] };\n    }\n    public visitTime<T extends Time>(vector: V<T>) {\n        return {\n            'DATA': vector.type.unit < TimeUnit.MICROSECOND\n                ? [...vector.values]\n                : [...bigNumsToStrings(vector.values, 2)]\n        };\n    }\n    public visitDecimal<T extends Decimal>(vector: V<T>) {\n        return { 'DATA': [...bigNumsToStrings(vector.values, 4)] };\n    }\n    public visitList<T extends List>(vector: V<T>) {\n        return {\n            'OFFSET': [...vector.valueOffsets],\n            'children': vector.type.children.map((f, i) =>\n                this.visit(new Column(f, [vector.getChildAt(i)!])))\n        };\n    }\n    public visitStruct<T extends Struct>(vector: V<T>) {\n        return {\n            'children': vector.type.children.map((f, i) =>\n                this.visit(new Column(f, [vector.getChildAt(i)!])))\n        };\n    }\n    public visitUnion<T extends Union>(vector: V<T>) {\n        return {\n            'TYPE': [...vector.typeIds],\n            'OFFSET': vector.type.mode === UnionMode.Dense ? [...vector.valueOffsets] : undefined,\n            'children': vector.type.children.map((f, i) => this.visit(new Column(f, [vector.getChildAt(i)!])))\n        };\n    }\n    public visitInterval<T extends Interval>(vector: V<T>) {\n        return { 'DATA': [...vector.values] };\n    }\n    public visitFixedSizeList<T extends FixedSizeList>(vector: V<T>) {\n        return {\n            'children': vector.type.children.map((f, i) =>\n                this.visit(new Column(f, [vector.getChildAt(i)!])))\n        };\n    }\n    public visitMap<T extends Map_>(vector: V<T>) {\n        return {\n            'OFFSET': [...vector.valueOffsets],\n            'children': vector.type.children.map((f, i) =>\n                this.visit(new Column(f, [vector.getChildAt(i)!])))\n        };\n    }\n}\n\n/** @ignore */\nfunction* binaryToString(vector: Vector<Binary> | Vector<FixedSizeBinary>) {\n    for (const octets of vector as Iterable<Uint8Array>) {\n        yield octets.reduce((str, byte) => {\n            return `${str}${('0' + (byte & 0xFF).toString(16)).slice(-2)}`;\n        }, '').toUpperCase();\n    }\n}\n\n/** @ignore */\nfunction* bigNumsToStrings(values: Uint32Array | Int32Array, stride: number) {\n    for (let i = -1, n = values.length / stride; ++i < n;) {\n        yield `${BN.new(values.subarray((i + 0) * stride, (i + 1) * stride), false)}`;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Table } from '../table';\nimport { MAGIC } from './message';\nimport { Vector } from '../vector';\nimport { Column } from '../column';\nimport { DataType } from '../type';\nimport { Schema, Field } from '../schema';\nimport { Message } from './metadata/message';\nimport * as metadata from './metadata/message';\nimport { FileBlock, Footer } from './metadata/file';\nimport { MessageHeader, MetadataVersion } from '../enum';\nimport { WritableSink, AsyncByteQueue } from '../io/stream';\nimport { VectorAssembler } from '../visitor/vectorassembler';\nimport { JSONTypeAssembler } from '../visitor/jsontypeassembler';\nimport { JSONVectorAssembler } from '../visitor/jsonvectorassembler';\nimport { ArrayBufferViewInput, toUint8Array } from '../util/buffer';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from '../recordbatch';\nimport { Writable, ReadableInterop, ReadableDOMStreamOptions } from '../io/interfaces';\nimport { isPromise, isAsyncIterable, isWritableDOMStream, isWritableNodeStream, isIterable, isObject } from '../util/compat';\n\nexport interface RecordBatchStreamWriterOptions {\n    /**\n     *\n     */\n    autoDestroy?: boolean;\n    /**\n     * A flag indicating whether the RecordBatchWriter should construct pre-0.15.0\n     * encapsulated IPC Messages, which reserves  4 bytes for the Message metadata\n     * length instead of 8.\n     * @see https://issues.apache.org/jira/browse/ARROW-6313\n     */\n    writeLegacyIpcFormat?: boolean;\n}\n\nexport class RecordBatchWriter<T extends { [key: string]: DataType } = any> extends ReadableInterop<Uint8Array> implements Writable<RecordBatch<T>> {\n\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughNode(options?: import('stream').DuplexOptions & { autoDestroy: boolean }): import('stream').Duplex {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    public static throughDOM<T extends { [key: string]: DataType }>(\n        // @ts-ignore\n        writableStrategy?: QueuingStrategy<RecordBatch<T>> & { autoDestroy: boolean },\n        // @ts-ignore\n        readableStrategy?: { highWaterMark?: number, size?: any }\n    ): { writable: WritableStream<Table<T> | RecordBatch<T>>, readable: ReadableStream<Uint8Array> } {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n\n    constructor(options?: RecordBatchStreamWriterOptions) {\n        super();\n        isObject(options) || (options = { autoDestroy: true, writeLegacyIpcFormat: false });\n        this._autoDestroy = (typeof options.autoDestroy === 'boolean') ? options.autoDestroy : true;\n        this._writeLegacyIpcFormat = (typeof options.writeLegacyIpcFormat === 'boolean') ? options.writeLegacyIpcFormat : false;\n    }\n\n    protected _position = 0;\n    protected _started = false;\n    protected _autoDestroy: boolean;\n    protected _writeLegacyIpcFormat: boolean;\n    // @ts-ignore\n    protected _sink = new AsyncByteQueue();\n    protected _schema: Schema | null = null;\n    protected _dictionaryBlocks: FileBlock[] = [];\n    protected _recordBatchBlocks: FileBlock[] = [];\n    protected _dictionaryDeltaOffsets = new Map<number, number>();\n\n    public toString(sync: true): string;\n    public toString(sync?: false): Promise<string>;\n    public toString(sync: any = false) {\n        return this._sink.toString(sync) as Promise<string> | string;\n    }\n    public toUint8Array(sync: true): Uint8Array;\n    public toUint8Array(sync?: false): Promise<Uint8Array>;\n    public toUint8Array(sync: any = false) {\n        return this._sink.toUint8Array(sync) as Promise<Uint8Array> | Uint8Array;\n    }\n\n    public writeAll(input: Table<T> | Iterable<RecordBatch<T>>): this;\n    public writeAll(input: AsyncIterable<RecordBatch<T>>): Promise<this>;\n    public writeAll(input: PromiseLike<AsyncIterable<RecordBatch<T>>>): Promise<this>;\n    public writeAll(input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>): Promise<this>;\n    public writeAll(input: PromiseLike<any> | Table<T> | Iterable<RecordBatch<T>> | AsyncIterable<RecordBatch<T>>) {\n        if (isPromise<any>(input)) {\n            return input.then((x) => this.writeAll(x));\n        } else if (isAsyncIterable<RecordBatch<T>>(input)) {\n            return writeAllAsync(this, input);\n        }\n        return writeAll(this, <any> input);\n    }\n\n    public get closed() { return this._sink.closed; }\n    public [Symbol.asyncIterator]() { return this._sink[Symbol.asyncIterator](); }\n    public toDOMStream(options?: ReadableDOMStreamOptions) { return this._sink.toDOMStream(options); }\n    public toNodeStream(options?: import('stream').ReadableOptions) { return this._sink.toNodeStream(options); }\n\n    public close() {\n        return this.reset()._sink.close();\n    }\n    public abort(reason?: any) {\n        return this.reset()._sink.abort(reason);\n    }\n    public finish() {\n        this._autoDestroy ? this.close() : this.reset(this._sink, this._schema);\n        return this;\n    }\n    public reset(sink: WritableSink<ArrayBufferViewInput> = this._sink, schema: Schema<T> | null = null) {\n\n        if ((sink === this._sink) || (sink instanceof AsyncByteQueue)) {\n            this._sink = sink as AsyncByteQueue;\n        } else {\n            this._sink = new AsyncByteQueue();\n            if (sink && isWritableDOMStream(sink)) {\n                this.toDOMStream({ type: 'bytes' }).pipeTo(sink);\n            } else if (sink && isWritableNodeStream(sink)) {\n                this.toNodeStream({ objectMode: false }).pipe(sink);\n            }\n        }\n\n        if (this._started && this._schema) {\n            this._writeFooter(this._schema);\n        }\n\n        this._started = false;\n        this._dictionaryBlocks = [];\n        this._recordBatchBlocks = [];\n        this._dictionaryDeltaOffsets = new Map();\n\n        if (!schema || !(schema.compareTo(this._schema))) {\n            if (schema === null) {\n                this._position = 0;\n                this._schema = null;\n            } else {\n                this._started = true;\n                this._schema = schema;\n                this._writeSchema(schema);\n            }\n        }\n\n        return this;\n    }\n\n    public write(payload?: Table<T> | RecordBatch<T> | Iterable<RecordBatch<T>> | null) {\n\n        let schema: Schema<T> | null = null;\n\n        if (!this._sink) {\n            throw new Error(`RecordBatchWriter is closed`);\n        } else if (payload === null || payload === undefined) {\n            return this.finish() && undefined;\n        } else if (payload instanceof Table && !(schema = payload.schema)) {\n            return this.finish() && undefined;\n        } else if (payload instanceof RecordBatch && !(schema = payload.schema)) {\n            return this.finish() && undefined;\n        }\n\n        if (schema && !schema.compareTo(this._schema)) {\n            if (this._started && this._autoDestroy) {\n                return this.close();\n            }\n            this.reset(this._sink, schema);\n        }\n\n        if (payload instanceof RecordBatch) {\n            if (!(payload instanceof _InternalEmptyPlaceholderRecordBatch)) {\n                this._writeRecordBatch(payload);\n            }\n        } else if (payload instanceof Table) {\n            this.writeAll(payload.chunks);\n        } else if (isIterable(payload)) {\n            this.writeAll(payload);\n        }\n    }\n\n    protected _writeMessage<T extends MessageHeader>(message: Message<T>, alignment = 8) {\n\n        const a = alignment - 1;\n        const buffer = Message.encode(message);\n        const flatbufferSize = buffer.byteLength;\n        const prefixSize = !this._writeLegacyIpcFormat ? 8 : 4;\n        const alignedSize = (flatbufferSize + prefixSize + a) & ~a;\n        const nPaddingBytes = alignedSize - flatbufferSize - prefixSize;\n\n        if (message.headerType === MessageHeader.RecordBatch) {\n            this._recordBatchBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));\n        } else if (message.headerType === MessageHeader.DictionaryBatch) {\n            this._dictionaryBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));\n        }\n\n        // If not in legacy pre-0.15.0 mode, write the stream continuation indicator\n        if (!this._writeLegacyIpcFormat) {\n            this._write(Int32Array.of(-1));\n        }\n        // Write the flatbuffer size prefix including padding\n        this._write(Int32Array.of(alignedSize - prefixSize));\n        // Write the flatbuffer\n        if (flatbufferSize > 0) { this._write(buffer); }\n        // Write any padding\n        return this._writePadding(nPaddingBytes);\n    }\n\n    protected _write(chunk: ArrayBufferViewInput) {\n        if (this._started) {\n            const buffer = toUint8Array(chunk);\n            if (buffer && buffer.byteLength > 0) {\n                this._sink.write(buffer);\n                this._position += buffer.byteLength;\n            }\n        }\n        return this;\n    }\n\n    protected _writeSchema(schema: Schema<T>) {\n        return this._writeMessage(Message.from(schema));\n    }\n\n    // @ts-ignore\n    protected _writeFooter(schema: Schema<T>) {\n        // eos bytes\n        return this._writeLegacyIpcFormat\n            ? this._write(Int32Array.of(0))\n            : this._write(Int32Array.of(-1, 0));\n    }\n\n    protected _writeMagic() {\n        return this._write(MAGIC);\n    }\n\n    protected _writePadding(nBytes: number) {\n        return nBytes > 0 ? this._write(new Uint8Array(nBytes)) : this;\n    }\n\n    protected _writeRecordBatch(batch: RecordBatch<T>) {\n        const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(batch);\n        const recordBatch = new metadata.RecordBatch(batch.length, nodes, bufferRegions);\n        const message = Message.from(recordBatch, byteLength);\n        return this\n            ._writeDictionaries(batch)\n            ._writeMessage(message)\n            ._writeBodyBuffers(buffers);\n    }\n\n    protected _writeDictionaryBatch(dictionary: Vector, id: number, isDelta = false) {\n        this._dictionaryDeltaOffsets.set(id, dictionary.length + (this._dictionaryDeltaOffsets.get(id) || 0));\n        const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(dictionary);\n        const recordBatch = new metadata.RecordBatch(dictionary.length, nodes, bufferRegions);\n        const dictionaryBatch = new metadata.DictionaryBatch(recordBatch, id, isDelta);\n        const message = Message.from(dictionaryBatch, byteLength);\n        return this\n            ._writeMessage(message)\n            ._writeBodyBuffers(buffers);\n    }\n\n    protected _writeBodyBuffers(buffers: ArrayBufferView[]) {\n        let buffer: ArrayBufferView;\n        let size: number, padding: number;\n        for (let i = -1, n = buffers.length; ++i < n;) {\n            if ((buffer = buffers[i]) && (size = buffer.byteLength) > 0) {\n                this._write(buffer);\n                if ((padding = ((size + 7) & ~7) - size) > 0) {\n                    this._writePadding(padding);\n                }\n            }\n        }\n        return this;\n    }\n\n    protected _writeDictionaries(batch: RecordBatch<T>) {\n        for (let [id, dictionary] of batch.dictionaries) {\n            let offset = this._dictionaryDeltaOffsets.get(id) || 0;\n            if (offset === 0 || (dictionary = dictionary.slice(offset)).length > 0) {\n                const chunks = 'chunks' in dictionary ? (dictionary as any).chunks : [dictionary];\n                for (const chunk of chunks) {\n                    this._writeDictionaryBatch(chunk, id, offset > 0);\n                    offset += chunk.length;\n                }\n            }\n        }\n        return this;\n    }\n}\n\n/** @ignore */\nexport class RecordBatchStreamWriter<T extends { [key: string]: DataType } = any> extends RecordBatchWriter<T> {\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: Table<T> | Iterable<RecordBatch<T>>, options?: RecordBatchStreamWriterOptions): RecordBatchStreamWriter<T>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: AsyncIterable<RecordBatch<T>>, options?: RecordBatchStreamWriterOptions): Promise<RecordBatchStreamWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<AsyncIterable<RecordBatch<T>>>, options?: RecordBatchStreamWriterOptions): Promise<RecordBatchStreamWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>, options?: RecordBatchStreamWriterOptions): Promise<RecordBatchStreamWriter<T>>;\n    /** @nocollapse */\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: any, options?: RecordBatchStreamWriterOptions) {\n        const writer = new RecordBatchStreamWriter<T>(options);\n        if (isPromise<any>(input)) {\n            return input.then((x) => writer.writeAll(x));\n        } else if (isAsyncIterable<RecordBatch<T>>(input)) {\n            return writeAllAsync(writer, input);\n        }\n        return writeAll(writer, input);\n    }\n}\n\n/** @ignore */\nexport class RecordBatchFileWriter<T extends { [key: string]: DataType } = any> extends RecordBatchWriter<T> {\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: Table<T> | Iterable<RecordBatch<T>>): RecordBatchFileWriter<T>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: AsyncIterable<RecordBatch<T>>): Promise<RecordBatchFileWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<AsyncIterable<RecordBatch<T>>>): Promise<RecordBatchFileWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>): Promise<RecordBatchFileWriter<T>>;\n    /** @nocollapse */\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: any) {\n        const writer = new RecordBatchFileWriter<T>();\n        if (isPromise<any>(input)) {\n            return input.then((x) => writer.writeAll(x));\n        } else if (isAsyncIterable<RecordBatch<T>>(input)) {\n            return writeAllAsync(writer, input);\n        }\n        return writeAll(writer, input);\n    }\n\n    constructor() {\n        super();\n        this._autoDestroy = true;\n    }\n\n    // @ts-ignore\n    protected _writeSchema(schema: Schema<T>) {\n        return this._writeMagic()._writePadding(2);\n    }\n\n    protected _writeFooter(schema: Schema<T>) {\n        const buffer = Footer.encode(new Footer(\n            schema, MetadataVersion.V4,\n            this._recordBatchBlocks, this._dictionaryBlocks\n        ));\n        return super\n            ._writeFooter(schema) // EOS bytes for sequential readers\n            ._write(buffer) // Write the flatbuffer\n            ._write(Int32Array.of(buffer.byteLength)) // then the footer size suffix\n            ._writeMagic(); // then the magic suffix\n    }\n}\n\n/** @ignore */\nexport class RecordBatchJSONWriter<T extends { [key: string]: DataType } = any> extends RecordBatchWriter<T> {\n\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: Table<T> | Iterable<RecordBatch<T>>): RecordBatchJSONWriter<T>;\n    // @ts-ignore\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: AsyncIterable<RecordBatch<T>>): Promise<RecordBatchJSONWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: PromiseLike<AsyncIterable<RecordBatch<T>>>): Promise<RecordBatchJSONWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>): Promise<RecordBatchJSONWriter<T>>;\n    /** @nocollapse */\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: any) {\n        return new RecordBatchJSONWriter<T>().writeAll(input as any);\n    }\n\n    private _recordBatches: RecordBatch[];\n    private _dictionaries: RecordBatch[];\n\n    constructor() {\n        super();\n        this._autoDestroy = true;\n        this._recordBatches = [];\n        this._dictionaries = [];\n    }\n\n    protected _writeMessage() { return this; }\n    // @ts-ignore\n    protected _writeFooter(schema: Schema<T>) { return this; }\n    protected _writeSchema(schema: Schema<T>) {\n        return this._write(`{\\n  \"schema\": ${\n            JSON.stringify({ fields: schema.fields.map(fieldToJSON) }, null, 2)\n        }`);\n    }\n    protected _writeDictionaries(batch: RecordBatch<T>) {\n        if (batch.dictionaries.size > 0) {\n            this._dictionaries.push(batch);\n        }\n        return this;\n    }\n    protected _writeDictionaryBatch(dictionary: Vector, id: number, isDelta = false) {\n        this._dictionaryDeltaOffsets.set(id, dictionary.length + (this._dictionaryDeltaOffsets.get(id) || 0));\n        this._write(this._dictionaryBlocks.length === 0 ? `    ` : `,\\n    `);\n        this._write(`${dictionaryBatchToJSON(dictionary, id, isDelta)}`);\n        this._dictionaryBlocks.push(new FileBlock(0, 0, 0));\n        return this;\n    }\n    protected _writeRecordBatch(batch: RecordBatch<T>) {\n        this._writeDictionaries(batch);\n        this._recordBatches.push(batch);\n        return this;\n    }\n    public close() {\n\n        if (this._dictionaries.length > 0) {\n            this._write(`,\\n  \"dictionaries\": [\\n`);\n            for (const batch of this._dictionaries) {\n                super._writeDictionaries(batch);\n            }\n            this._write(`\\n  ]`);\n        }\n\n        if (this._recordBatches.length > 0) {\n            for (let i = -1, n = this._recordBatches.length; ++i < n;) {\n                this._write(i === 0 ? `,\\n  \"batches\": [\\n    ` : `,\\n    `);\n                this._write(`${recordBatchToJSON(this._recordBatches[i])}`);\n                this._recordBatchBlocks.push(new FileBlock(0, 0, 0));\n            }\n            this._write(`\\n  ]`);\n        }\n\n        if (this._schema) {\n            this._write(`\\n}`);\n        }\n\n        this._dictionaries = [];\n        this._recordBatches = [];\n\n        return super.close();\n    }\n}\n\n/** @ignore */\nfunction writeAll<T extends { [key: string]: DataType } = any>(writer: RecordBatchWriter<T>, input: Table<T> | Iterable<RecordBatch<T>>) {\n    let chunks = input as Iterable<RecordBatch<T>>;\n    if (input instanceof Table) {\n        chunks = input.chunks;\n        writer.reset(undefined, input.schema);\n    }\n    for (const batch of chunks) {\n        writer.write(batch);\n    }\n    return writer.finish();\n}\n\n/** @ignore */\nasync function writeAllAsync<T extends { [key: string]: DataType } = any>(writer: RecordBatchWriter<T>, batches: AsyncIterable<RecordBatch<T>>) {\n    for await (const batch of batches) {\n        writer.write(batch);\n    }\n    return writer.finish();\n}\n\n/** @ignore */\nfunction fieldToJSON({ name, type, nullable }: Field): object {\n    const assembler = new JSONTypeAssembler();\n    return {\n        'name': name, 'nullable': nullable,\n        'type': assembler.visit(type),\n        'children': (type.children || []).map(fieldToJSON),\n        'dictionary': !DataType.isDictionary(type) ? undefined : {\n            'id': type.id,\n            'isOrdered': type.isOrdered,\n            'indexType': assembler.visit(type.indices)\n        }\n    };\n}\n\n/** @ignore */\nfunction dictionaryBatchToJSON(dictionary: Vector, id: number, isDelta = false) {\n    const field = new Field(`${id}`, dictionary.type, dictionary.nullCount > 0);\n    const columns = JSONVectorAssembler.assemble(new Column(field, [dictionary]));\n    return JSON.stringify({\n        'id': id,\n        'isDelta': isDelta,\n        'data': {\n            'count': dictionary.length,\n            'columns': columns\n        }\n    }, null, 2);\n}\n\n/** @ignore */\nfunction recordBatchToJSON(records: RecordBatch) {\n    return JSON.stringify({\n        'count': records.length,\n        'columns': JSONVectorAssembler.assemble(records)\n    }, null, 2);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Column } from '../column';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Data, Buffers } from '../data';\nimport { Schema, Field } from '../schema';\nimport { Chunked } from '../vector/chunked';\nimport { RecordBatch } from '../recordbatch';\n\nconst noopBuf = new Uint8Array(0);\nconst nullBufs = (bitmapLength: number) => <unknown> [\n    noopBuf, noopBuf, new Uint8Array(bitmapLength), noopBuf\n] as Buffers<any>;\n\n/** @ignore */\nexport function ensureSameLengthData<T extends { [key: string]: DataType } = any>(\n    schema: Schema<T>,\n    chunks: Data<T[keyof T]>[],\n    batchLength = chunks.reduce((l, c) => Math.max(l, c.length), 0)\n) {\n    let data: Data<T[keyof T]>;\n    let field: Field<T[keyof T]>;\n    let i = -1, n = chunks.length;\n    const fields = [...schema.fields];\n    const batchData = [] as Data<T[keyof T]>[];\n    const bitmapLength = ((batchLength + 63) & ~63) >> 3;\n    while (++i < n) {\n        if ((data = chunks[i]) && data.length === batchLength) {\n            batchData[i] = data;\n        } else {\n            (field = fields[i]).nullable || (fields[i] = fields[i].clone({ nullable: true }) as Field<T[keyof T]>);\n            batchData[i] = data ? data._changeLengthAndBackfillNullBitmap(batchLength)\n                : Data.new(field.type, 0, batchLength, batchLength, nullBufs(bitmapLength)) as Data<T[keyof T]>;\n        }\n    }\n    return [new Schema<T>(fields), batchLength, batchData] as [Schema<T>, number, Data<T[keyof T]>[]];\n}\n\n/** @ignore */\nexport function distributeColumnsIntoRecordBatches<T extends { [key: string]: DataType } = any>(columns: Column<T[keyof T]>[]): [Schema<T>, RecordBatch<T>[]] {\n    return distributeVectorsIntoRecordBatches<T>(new Schema<T>(columns.map(({ field }) => field)), columns);\n}\n\n/** @ignore */\nexport function distributeVectorsIntoRecordBatches<T extends { [key: string]: DataType } = any>(schema: Schema<T>, vecs: (Vector<T[keyof T]> | Chunked<T[keyof T]>)[]): [Schema<T>, RecordBatch<T>[]] {\n    return uniformlyDistributeChunksAcrossRecordBatches<T>(schema, vecs.map((v) => v instanceof Chunked ? v.chunks.map((c) => c.data) : [v.data]));\n}\n\n/** @ignore */\nfunction uniformlyDistributeChunksAcrossRecordBatches<T extends { [key: string]: DataType } = any>(schema: Schema<T>, columns: Data<T[keyof T]>[][]): [Schema<T>, RecordBatch<T>[]] {\n\n    const fields = [...schema.fields];\n    const batchArgs = [] as [number, Data<T[keyof T]>[]][];\n    const memo = { numBatches: columns.reduce((n, c) => Math.max(n, c.length), 0) };\n\n    let numBatches = 0, batchLength = 0;\n    let i: number = -1, numColumns = columns.length;\n    let child: Data<T[keyof T]>, childData: Data<T[keyof T]>[] = [];\n\n    while (memo.numBatches-- > 0) {\n\n        for (batchLength = Number.POSITIVE_INFINITY, i = -1; ++i < numColumns;) {\n            childData[i] = child = columns[i].shift()!;\n            batchLength = Math.min(batchLength, child ? child.length : batchLength);\n        }\n\n        if (isFinite(batchLength)) {\n            childData = distributeChildData(fields, batchLength, childData, columns, memo);\n            if (batchLength > 0) {\n                batchArgs[numBatches++] = [batchLength, childData.slice()];\n            }\n        }\n    }\n    return [\n        schema = new Schema<T>(fields, schema.metadata),\n        batchArgs.map((xs) => new RecordBatch(schema, ...xs))\n    ];\n}\n\n/** @ignore */\nfunction distributeChildData<T extends { [key: string]: DataType } = any>(fields: Field<T[keyof T]>[], batchLength: number, childData: Data<T[keyof T]>[], columns: Data<T[keyof T]>[][], memo: { numBatches: number }) {\n    let data: Data<T[keyof T]>;\n    let field: Field<T[keyof T]>;\n    let length = 0, i = -1, n = columns.length;\n    const bitmapLength = ((batchLength + 63) & ~63) >> 3;\n    while (++i < n) {\n        if ((data = childData[i]) && ((length = data.length) >= batchLength)) {\n            if (length === batchLength) {\n                childData[i] = data;\n            } else {\n                childData[i] = data.slice(0, batchLength);\n                data = data.slice(batchLength, length - batchLength);\n                memo.numBatches = Math.max(memo.numBatches, columns[i].unshift(data));\n            }\n        } else {\n            (field = fields[i]).nullable || (fields[i] = field.clone({ nullable: true }) as Field<T[keyof T]>);\n            childData[i] = data ? data._changeLengthAndBackfillNullBitmap(batchLength)\n                : Data.new(field.type, 0, batchLength, batchLength, nullBufs(bitmapLength)) as Data<T[keyof T]>;\n        }\n    }\n    return childData;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { DataType } from '../type';\nimport { Chunked } from './chunked';\nimport { clampRange } from '../util/vector';\nimport { VectorType as V } from '../interfaces';\nimport { AbstractVector, Vector, Clonable, Sliceable, Applicative } from '../vector';\n\n/** @ignore */\nexport interface BaseVector<T extends DataType = any> extends Clonable<V<T>>, Sliceable<V<T>>, Applicative<T, Chunked<T>> {\n    slice(begin?: number, end?: number): V<T>;\n    concat(...others: Vector<T>[]): Chunked<T>;\n    clone<R extends DataType = T>(data: Data<R>, children?: Vector<R>[]): V<R>;\n}\n\n/** @ignore */\nexport abstract class BaseVector<T extends DataType = any> extends AbstractVector<T>\n    implements Clonable<V<T>>, Sliceable<V<T>>, Applicative<T, Chunked<T>> {\n\n    protected _children?: Vector[];\n\n    constructor(data: Data<T>, children?: Vector[]) {\n        super();\n        this._children = children;\n        this.numChildren = data.childData.length;\n        this._bindDataAccessors(this.data = data);\n    }\n\n    public readonly data: Data<T>;\n    public readonly numChildren: number;\n\n    public get type() { return this.data.type; }\n    public get typeId() { return this.data.typeId; }\n    public get length() { return this.data.length; }\n    public get offset() { return this.data.offset; }\n    public get stride() { return this.data.stride; }\n    public get nullCount() { return this.data.nullCount; }\n    public get byteLength() { return this.data.byteLength; }\n    public get VectorName() { return `${Type[this.typeId]}Vector`; }\n\n    public get ArrayType(): T['ArrayType'] { return this.type.ArrayType; }\n\n    public get values() { return this.data.values; }\n    public get typeIds() { return this.data.typeIds; }\n    public get nullBitmap() { return this.data.nullBitmap; }\n    public get valueOffsets() { return this.data.valueOffsets; }\n\n    public get [Symbol.toStringTag]() { return `${this.VectorName}<${this.type[Symbol.toStringTag]}>`; }\n\n    public clone<R extends DataType = T>(data: Data<R>, children = this._children) {\n        return Vector.new<R>(data, children) as any;\n    }\n\n    public concat(...others: Vector<T>[]) {\n        return Chunked.concat<T>(this, ...others);\n    }\n\n    public slice(begin?: number, end?: number) {\n        // Adjust args similar to Array.prototype.slice. Normalize begin/end to\n        // clamp between 0 and length, and wrap around on negative indices, e.g.\n        // slice(-1, 5) or slice(5, -1)\n        return clampRange(this, begin, end, this._sliceInternal);\n    }\n\n    public isValid(index: number): boolean {\n        if (this.nullCount > 0) {\n            const idx = this.offset + index;\n            const val = this.nullBitmap[idx >> 3];\n            const mask = (val & (1 << (idx % 8)));\n            return mask !== 0;\n        }\n        return true;\n    }\n\n    public getChildAt<R extends DataType = any>(index: number): Vector<R> | null {\n        return index < 0 || index >= this.numChildren ? null : (\n            (this._children || (this._children = []))[index] ||\n            (this._children[index] = Vector.new<R>(this.data.childData[index] as Data<R>))\n        ) as Vector<R>;\n    }\n\n    public toJSON(): any { return [...this]; }\n\n    protected _sliceInternal(self: this, begin: number, end: number) {\n        return self.clone(self.data.slice(begin, end - begin), null!);\n    }\n\n    // @ts-ignore\n    protected _bindDataAccessors(data: Data<T>) {\n        // Implementation in src/vectors/index.ts due to circular dependency/packaging shenanigans\n    }\n}\n\n(BaseVector.prototype as any)[Symbol.isConcatSpreadable] = true;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { Binary, Utf8 } from '../type';\n\n/** @ignore */\nexport class BinaryVector extends BaseVector<Binary> {\n    public asUtf8() {\n        return Vector.new(this.data.clone(new Utf8()));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Bool } from '../type';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\n\n/** @ignore */\nexport class BoolVector extends BaseVector<Bool> {\n    public static from<TNull = any>(input: Iterable<boolean | TNull>): BoolVector;\n    public static from<TNull = any>(input: AsyncIterable<boolean | TNull>): Promise<BoolVector>;\n    public static from<TNull = any>(input: VectorBuilderOptions<Bool, TNull>): Chunked<Bool>;\n    public static from<TNull = any>(input: VectorBuilderOptionsAsync<Bool, TNull>): Promise<Chunked<Bool>>;\n    /** @nocollapse */\n    public static from<TNull = any>(input: Iterable<boolean | TNull> | AsyncIterable<boolean | TNull> | VectorBuilderOptions<Bool, TNull> | VectorBuilderOptionsAsync<Bool, TNull>) {\n        return vectorFromValuesWithType(() => new Bool(), input);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DateUnit } from '../enum';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorType as V } from '../interfaces';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { Date_, DateDay, DateMillisecond  } from '../type';\n\n/** @ignore */\ntype FromArgs<T extends Date_> = [Iterable<Date>, T['unit']];\n\n/** @ignore */\nexport class DateVector<T extends Date_ = Date_> extends BaseVector<T> {\n    public static from<T extends DateUnit.DAY>(...args: FromArgs<DateDay>): V<DateDay>;\n    public static from<T extends DateUnit.MILLISECOND>(...args: FromArgs<DateMillisecond>): V<DateMillisecond>;\n    public static from<T extends Date_, TNull = any>(input: Iterable<Date | TNull>): V<T>;\n    public static from<T extends Date_, TNull = any>(input: AsyncIterable<Date | TNull>): Promise<V<T>>;\n    public static from<T extends Date_, TNull = any>(input: VectorBuilderOptions<T, TNull>): Chunked<T>;\n    public static from<T extends Date_, TNull = any>(input: VectorBuilderOptionsAsync<T, TNull>): Promise<Chunked<T>>;\n    /** @nocollapse */\n    public static from<T extends Date_, TNull = any>(...args: FromArgs<T> | [Iterable<Date | TNull> | AsyncIterable<Date | TNull> | VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>]) {\n        if (args.length === 2) {\n            return vectorFromValuesWithType(() => args[1] === DateUnit.DAY ? new DateDay() : new DateMillisecond() as T, args[0]);\n        }\n        return vectorFromValuesWithType(() => new DateMillisecond() as T, args[0]);\n    }\n}\n\n/** @ignore */\nexport class DateDayVector extends DateVector<DateDay> {}\n\n/** @ignore */\nexport class DateMillisecondVector extends DateVector<DateMillisecond> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Decimal } from '../type';\nimport { BaseVector } from './base';\n\n/** @ignore */\nexport class DecimalVector extends BaseVector<Decimal> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { VectorType as V } from '../interfaces';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { DataType, Dictionary, TKeys } from '../type';\n\n/** @ignore */\ntype FromArgs<T extends DataType = any, TKey extends TKeys = TKeys> = [Vector<T>, TKey, ArrayLike<number> | TKey['TArray']];\n\n/** @ignore */\nexport class DictionaryVector<T extends DataType = any, TKey extends TKeys = TKeys> extends BaseVector<Dictionary<T, TKey>> {\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(...args: FromArgs<T, TKey>): V<Dictionary<T, TKey>>;\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(input: VectorBuilderOptions<Dictionary<T, TKey>>): Vector<Dictionary<T, TKey>>;\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(input: VectorBuilderOptionsAsync<Dictionary<T, TKey>>): Promise<Vector<Dictionary<T, TKey>>>;\n    /** @nocollapse */\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(...args: any[]) {\n        if (args.length === 3) {\n            const [values, indices, keys] = args as FromArgs<T, TKey>;\n            const type = new Dictionary(values.type, indices, null, null);\n            return Vector.new(Data.Dictionary(type, 0, keys.length, 0, null, keys, values));\n        }\n        return vectorFromValuesWithType(() => args[0].type, args[0]);\n    }\n\n    constructor(data: Data<Dictionary<T, TKey>>) {\n        super(data);\n        this.indices = Vector.new(data.clone(this.type.indices));\n    }\n\n    public readonly indices: V<TKey>;\n\n    public get dictionary() { return <Vector<T>> this.data.dictionary; }\n    public reverseLookup(value: T) { return this.dictionary.indexOf(value); }\n    public getKey(idx: number): TKey['TValue'] | null { return this.indices.get(idx); }\n    public getValue(key: number): T['TValue'] | null { return this.dictionary.get(key); }\n    public setKey(idx: number, key: TKey['TValue'] | null) { return this.indices.set(idx, key); }\n    public setValue(key: number, value: T['TValue'] | null) { return this.dictionary.set(key, value); }\n}\n\n(DictionaryVector.prototype as any).indices = null;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { FixedSizeBinary } from '../type';\n\n/** @ignore */\nexport class FixedSizeBinaryVector extends BaseVector<FixedSizeBinary> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { DataType, FixedSizeList } from '../type';\n\n/** @ignore */\nexport class FixedSizeListVector<T extends DataType = any> extends BaseVector<FixedSizeList<T>> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { Float, Float16, Float32, Float64, FloatArray } from '../type';\nimport { VectorType as V, TypedArrayConstructor } from '../interfaces';\n\n/** @ignore */\ntype FloatVectorConstructors =\n    typeof FloatVector   |\n    typeof Float16Vector |\n    typeof Float32Vector |\n    typeof Float64Vector ;\n\n/** @ignore */\ntype FromInput<T extends Float, TNull = any> =\n    FloatArray                          |\n    Iterable<T['TValue'] | TNull>       |\n    AsyncIterable<T['TValue'] | TNull>  |\n    VectorBuilderOptions<T, TNull>      |\n    VectorBuilderOptionsAsync<T, TNull> ;\n\n/** @ignore */\ntype FloatArrayCtor = TypedArrayConstructor<FloatArray>;\n\n/** @ignore */\nexport class FloatVector<T extends Float = Float> extends BaseVector<T> {\n\n    // Guaranteed zero-copy variants\n    public static from(this: typeof FloatVector, input: Uint16Array): Float16Vector;\n    public static from(this: typeof FloatVector, input: Float32Array): Float32Vector;\n    public static from(this: typeof FloatVector, input: Float64Array): Float64Vector;\n\n    // Zero-copy if input is a TypedArray of the same type as the\n    // Vector that from is called on, otherwise uses the Builders\n    public static from<TNull = any>(this: typeof Float16Vector,  input: FromInput<Float16, TNull>): Float16Vector;\n    public static from<TNull = any>(this: typeof Float32Vector,  input: FromInput<Float32, TNull>): Float32Vector;\n    public static from<TNull = any>(this: typeof Float64Vector,  input: FromInput<Float64, TNull>): Float64Vector;\n\n    // Not zero-copy\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: Iterable<T['TValue'] | TNull>): V<T>;\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: AsyncIterable<T['TValue'] | TNull>): Promise<V<T>>;\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: VectorBuilderOptions<T, TNull>): Chunked<T>;\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: VectorBuilderOptionsAsync<T, TNull>): Promise<Chunked<T>>;\n    /** @nocollapse */\n    public static from<T extends Float, TNull = any>(this: FloatVectorConstructors, input: FromInput<T, TNull>) {\n\n        let ArrowType = vectorTypeToDataType(this);\n\n        if ((input instanceof ArrayBuffer) || ArrayBuffer.isView(input)) {\n            let InputType = arrayTypeToDataType(input.constructor as FloatArrayCtor) || ArrowType;\n            // Special case, infer the Arrow DataType from the input if calling the base\n            // FloatVector.from with a TypedArray, e.g. `FloatVector.from(new Float32Array())`\n            if (ArrowType === null) {\n                ArrowType = InputType;\n            }\n            // If the DataType inferred from the Vector constructor matches the\n            // DataType inferred from the input arguments, return zero-copy view\n            if (ArrowType && ArrowType === InputType) {\n                let type = new ArrowType();\n                let length = input.byteLength / type.ArrayType.BYTES_PER_ELEMENT;\n                // If the ArrowType is Float16 but the input type isn't a Uint16Array,\n                // let the Float16Builder handle casting the input values to Uint16s.\n                if (!convertTo16Bit(ArrowType, input.constructor)) {\n                    return Vector.new(Data.Float(type, 0, length, 0, null, input as FloatArray));\n                }\n            }\n        }\n\n        if (ArrowType) {\n            // If the DataType inferred from the Vector constructor is different than\n            // the DataType inferred from the input TypedArray, or if input isn't a\n            // TypedArray, use the Builders to construct the result Vector\n            return vectorFromValuesWithType(() => new ArrowType!() as T, input);\n        }\n\n        if ((input instanceof DataView) || (input instanceof ArrayBuffer)) {\n            throw new TypeError(`Cannot infer float type from instance of ${input.constructor.name}`);\n        }\n\n        throw new TypeError('Unrecognized FloatVector input');\n    }\n}\n\n/** @ignore */\nexport class Float16Vector extends FloatVector<Float16> {\n    // Since JS doesn't have half floats, `toArray()` returns a zero-copy slice\n    // of the underlying Uint16Array data. This behavior ensures we don't incur\n    // extra compute or copies if you're calling `toArray()` in order to create\n    // a buffer for something like WebGL. Buf if you're using JS and want typed\n    // arrays of 4-to-8-byte precision, these methods will enumerate the values\n    // and clamp to the desired byte lengths.\n    public toFloat32Array() { return new Float32Array(this as Iterable<number>); }\n    public toFloat64Array() { return new Float64Array(this as Iterable<number>); }\n}\n\n/** @ignore */\nexport class Float32Vector extends FloatVector<Float32> {}\n/** @ignore */\nexport class Float64Vector extends FloatVector<Float64> {}\n\nconst convertTo16Bit = (typeCtor: any, dataCtor: any) => {\n    return (typeCtor === Float16) && (dataCtor !== Uint16Array);\n};\n\n/** @ignore */\nconst arrayTypeToDataType = (ctor: FloatArrayCtor) => {\n    switch (ctor) {\n        case Uint16Array:    return Float16;\n        case Float32Array:   return Float32;\n        case Float64Array:   return Float64;\n        default: return null;\n    }\n};\n\n/** @ignore */\nconst vectorTypeToDataType = (ctor: FloatVectorConstructors) => {\n    switch (ctor) {\n        case Float16Vector: return Float16;\n        case Float32Vector: return Float32;\n        case Float64Vector: return Float64;\n        default: return null;\n    }\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Interval, IntervalDayTime, IntervalYearMonth } from '../type';\n\n/** @ignore */\nexport class IntervalVector<T extends Interval = Interval> extends BaseVector<T> {}\n/** @ignore */\nexport class IntervalDayTimeVector extends IntervalVector<IntervalDayTime> {}\n/** @ignore */\nexport class IntervalYearMonthVector extends IntervalVector<IntervalYearMonth> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { BigInt64Array, BigUint64Array } from '../util/compat';\nimport { toBigInt64Array, toBigUint64Array } from '../util/buffer';\nimport { Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64, IntArray } from '../type';\nimport { VectorType as V, TypedArrayConstructor, BigIntArrayConstructor, BigIntArray } from '../interfaces';\n\n/** @ignore */\ntype IntVectorConstructors =\n    typeof IntVector    |\n    typeof Int8Vector   |\n    typeof Int16Vector  |\n    typeof Int32Vector  |\n    typeof Uint8Vector  |\n    typeof Uint16Vector |\n    typeof Uint32Vector |\n    typeof Int64Vector  |\n    typeof Uint64Vector ;\n\n/** @ignore */\ntype FromInput<T extends Int, TNull = any> =\n    IntArray | BigIntArray              |\n    Iterable<T['TValue'] | TNull>       |\n    AsyncIterable<T['TValue'] | TNull>  |\n    VectorBuilderOptions<T, TNull>      |\n    VectorBuilderOptionsAsync<T, TNull> ;\n\n/** @ignore */\ntype FromArgs<T extends Int, TNull = any> = [FromInput<T, TNull>, boolean?];\n\n/** @ignore */\ntype IntArrayCtor = TypedArrayConstructor<IntArray> | BigIntArrayConstructor<BigIntArray>;\n\n/** @ignore */\nexport class IntVector<T extends Int = Int> extends BaseVector<T> {\n\n    // Guaranteed zero-copy variants\n    public static from(this: typeof IntVector, input: Int8Array): Int8Vector;\n    public static from(this: typeof IntVector, input: Int16Array): Int16Vector;\n    public static from(this: typeof IntVector, input: Int32Array): Int32Vector;\n    public static from(this: typeof IntVector, input: BigInt64Array): Int64Vector;\n    public static from(this: typeof IntVector, input: Int32Array, is64bit: true): Int64Vector;\n    public static from(this: typeof IntVector, input: Uint8Array): Uint8Vector;\n    public static from(this: typeof IntVector, input: Uint16Array): Uint16Vector;\n    public static from(this: typeof IntVector, input: Uint32Array): Uint32Vector;\n    public static from(this: typeof IntVector, input: BigUint64Array): Uint64Vector;\n    public static from(this: typeof IntVector, input: Uint32Array, is64bit: true): Uint64Vector;\n\n    // Zero-copy if input is a TypedArray of the same type as the\n    // Vector that from is called on, otherwise uses the Builders\n    public static from<TNull = any>(this: typeof Int8Vector,   input: FromInput<Int8, TNull>): Int8Vector;\n    public static from<TNull = any>(this: typeof Int16Vector,  input: FromInput<Int16, TNull>): Int16Vector;\n    public static from<TNull = any>(this: typeof Int32Vector,  input: FromInput<Int32, TNull>): Int32Vector;\n    public static from<TNull = any>(this: typeof Int64Vector,  input: FromInput<Int64, TNull>): Int64Vector;\n    public static from<TNull = any>(this: typeof Uint8Vector,  input: FromInput<Uint8, TNull>): Uint8Vector;\n    public static from<TNull = any>(this: typeof Uint16Vector, input: FromInput<Uint16, TNull>): Uint16Vector;\n    public static from<TNull = any>(this: typeof Uint32Vector, input: FromInput<Uint32, TNull>): Uint32Vector;\n    public static from<TNull = any>(this: typeof Uint64Vector, input: FromInput<Uint64, TNull>): Uint64Vector;\n\n    // Not zero-copy\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: Iterable<T['TValue'] | TNull>): V<T>;\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: AsyncIterable<T['TValue'] | TNull>): Promise<V<T>>;\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: VectorBuilderOptions<T, TNull>): Chunked<T>;\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: VectorBuilderOptionsAsync<T, TNull>): Promise<Chunked<T>>;\n    /** @nocollapse */\n    public static from<T extends Int, TNull = any>(this: IntVectorConstructors, ...args: FromArgs<T, TNull>) {\n\n        let [input, is64bit = false] = args;\n        let ArrowType = vectorTypeToDataType(this, is64bit);\n\n        if ((input instanceof ArrayBuffer) || ArrayBuffer.isView(input)) {\n            let InputType = arrayTypeToDataType(input.constructor as IntArrayCtor, is64bit) || ArrowType;\n            // Special case, infer the Arrow DataType from the input if calling the base\n            // IntVector.from with a TypedArray, e.g. `IntVector.from(new Int32Array())`\n            if (ArrowType === null) {\n                ArrowType = InputType;\n            }\n            // If the DataType inferred from the Vector constructor matches the\n            // DataType inferred from the input arguments, return zero-copy view\n            if (ArrowType && ArrowType === InputType) {\n                let type = new ArrowType();\n                let length = input.byteLength / type.ArrayType.BYTES_PER_ELEMENT;\n                // If the ArrowType is 64bit but the input type is 32bit pairs, update the logical length\n                if (convert32To64Bit(ArrowType, input.constructor)) {\n                    length *= 0.5;\n                }\n                return Vector.new(Data.Int(type, 0, length, 0, null, input as IntArray));\n            }\n        }\n\n        if (ArrowType) {\n            // If the DataType inferred from the Vector constructor is different than\n            // the DataType inferred from the input TypedArray, or if input isn't a\n            // TypedArray, use the Builders to construct the result Vector\n            return vectorFromValuesWithType(() => new ArrowType!() as T, input);\n        }\n\n        if ((input instanceof DataView) || (input instanceof ArrayBuffer)) {\n            throw new TypeError(`Cannot infer integer type from instance of ${input.constructor.name}`);\n        }\n\n        throw new TypeError('Unrecognized IntVector input');\n    }\n}\n\n/** @ignore */\nexport class Int8Vector extends IntVector<Int8> {}\n/** @ignore */\nexport class Int16Vector extends IntVector<Int16> {}\n/** @ignore */\nexport class Int32Vector extends IntVector<Int32> {}\n/** @ignore */\nexport class Int64Vector extends IntVector<Int64> {\n    public toBigInt64Array() {\n        return toBigInt64Array(this.values);\n    }\n    // @ts-ignore\n    private _values64: BigInt64Array;\n    public get values64(): BigInt64Array {\n        return this._values64 || (this._values64 = this.toBigInt64Array());\n    }\n}\n\n/** @ignore */\nexport class Uint8Vector extends IntVector<Uint8> {}\n/** @ignore */\nexport class Uint16Vector extends IntVector<Uint16> {}\n/** @ignore */\nexport class Uint32Vector extends IntVector<Uint32> {}\n/** @ignore */\nexport class Uint64Vector extends IntVector<Uint64> {\n    public toBigUint64Array() {\n        return toBigUint64Array(this.values);\n    }\n    // @ts-ignore\n    private _values64: BigUint64Array;\n    public get values64(): BigUint64Array {\n        return this._values64 || (this._values64 = this.toBigUint64Array());\n    }\n}\n\nconst convert32To64Bit = (typeCtor: any, dataCtor: any) => {\n    return (typeCtor === Int64 || typeCtor === Uint64) &&\n           (dataCtor === Int32Array || dataCtor === Uint32Array);\n};\n\n/** @ignore */\nconst arrayTypeToDataType = (ctor: IntArrayCtor, is64bit: boolean) => {\n    switch (ctor) {\n        case Int8Array:      return Int8;\n        case Int16Array:     return Int16;\n        case Int32Array:     return is64bit ? Int64 : Int32;\n        case BigInt64Array:  return Int64;\n        case Uint8Array:     return Uint8;\n        case Uint16Array:    return Uint16;\n        case Uint32Array:    return is64bit ? Uint64 : Uint32;\n        case BigUint64Array: return Uint64;\n        default: return null;\n    }\n};\n\n/** @ignore */\nconst vectorTypeToDataType = (ctor: IntVectorConstructors, is64bit: boolean) => {\n    switch (ctor) {\n        case Int8Vector:   return Int8;\n        case Int16Vector:  return Int16;\n        case Int32Vector:  return is64bit ? Int64 : Int32;\n        case Int64Vector:  return Int64;\n        case Uint8Vector:  return Uint8;\n        case Uint16Vector: return Uint16;\n        case Uint32Vector: return is64bit ? Uint64 : Uint32;\n        case Uint64Vector: return Uint64;\n        default: return null;\n    }\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { DataType, List } from '../type';\n\n/** @ignore */\nexport class ListVector<T extends DataType = any> extends BaseVector<List<T>> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { MapRow } from './row';\nimport { Field } from '../schema';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { DataType, Map_, Struct, List } from '../type';\n\n/** @ignore */\nexport class MapVector<K extends DataType = any, V extends DataType = any> extends BaseVector<Map_<K, V>> {\n    public asList() {\n        const child = this.type.children[0] as Field<Struct<{ key: K, value: V }>>;\n        return Vector.new(this.data.clone(new List<Struct<{ key: K, value: V }>>(child)));\n    }\n    public bind(index: number): Map_<K, V>['TValue'] {\n        const child = this.getChildAt<Struct<{ key: K, value: V }>>(0);\n        const { [index]: begin, [index + 1]: end } = this.valueOffsets;\n        return new MapRow(child!.slice(begin, end));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Null } from '../type';\nimport { BaseVector } from './base';\n\n/** @ignore */\nexport class NullVector extends BaseVector<Null> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { StructRow } from './row';\nimport { BaseVector } from './base';\nimport { DataType, Struct } from '../type';\n\n/** @ignore */ const kRowIndex = Symbol.for('rowIndex');\n/** @ignore */\nexport class StructVector<T extends { [key: string]: DataType } = any> extends BaseVector<Struct<T>> {\n    // @ts-ignore\n    private _row: StructRow<T>;\n    public bind(index: number): Struct<T>['TValue'] {\n        const proto = this._row || (this._row = new StructRow<T>(this));\n        const bound = Object.create(proto);\n        bound[kRowIndex] = index;\n        return bound;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond } from '../type';\n\n/** @ignore */\nexport class TimestampVector<T extends Timestamp = Timestamp> extends BaseVector<T> {}\n/** @ignore */\nexport class TimestampSecondVector extends TimestampVector<TimestampSecond> {}\n/** @ignore */\nexport class TimestampMillisecondVector extends TimestampVector<TimestampMillisecond> {}\n/** @ignore */\nexport class TimestampMicrosecondVector extends TimestampVector<TimestampMicrosecond> {}\n/** @ignore */\nexport class TimestampNanosecondVector extends TimestampVector<TimestampNanosecond> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond } from '../type';\n\n/** @ignore */\nexport class TimeVector<T extends Time = Time> extends BaseVector<T> {}\n/** @ignore */\nexport class TimeSecondVector extends TimeVector<TimeSecond> {}\n/** @ignore */\nexport class TimeMillisecondVector extends TimeVector<TimeMillisecond> {}\n/** @ignore */\nexport class TimeMicrosecondVector extends TimeVector<TimeMicrosecond> {}\n/** @ignore */\nexport class TimeNanosecondVector extends TimeVector<TimeNanosecond> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Union, DenseUnion, SparseUnion} from '../type';\n\n/** @ignore */\nexport class UnionVector<T extends Union = Union> extends BaseVector<T> {\n    public get typeIdToChildIndex() { return this.data.type.typeIdToChildIndex; }\n}\n\n/** @ignore */\nexport class DenseUnionVector extends UnionVector<DenseUnion> {\n    public get valueOffsets() { return this.data.valueOffsets!; }\n}\n\n/** @ignore */\nexport class SparseUnionVector extends UnionVector<SparseUnion> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { Binary, Utf8 } from '../type';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\n\n/** @ignore */\nexport class Utf8Vector extends BaseVector<Utf8> {\n    public static from<TNull = any>(input: Iterable<string | TNull>): Utf8Vector;\n    public static from<TNull = any>(input: AsyncIterable<string | TNull>): Promise<Utf8Vector>;\n    public static from<TNull = any>(input: VectorBuilderOptions<Utf8, TNull>): Chunked<Utf8>;\n    public static from<TNull = any>(input: VectorBuilderOptionsAsync<Utf8, TNull>): Promise<Chunked<Utf8>>;\n    /** @nocollapse */\n    public static from<TNull = any>(input: Iterable<string | TNull> | AsyncIterable<string | TNull> | VectorBuilderOptions<Utf8, TNull> | VectorBuilderOptionsAsync<Utf8, TNull>) {\n        return vectorFromValuesWithType(() => new Utf8(), input);\n    }\n    public asBinary() {\n        return Vector.new(this.data.clone(new Binary()));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nexport function partial0<T>(visit: (node: T) => any) {\n    return function(this: T) { return visit(this); };\n}\n\n/** @ignore */\nexport function partial1<T>(visit: (node: T, a: any) => any) {\n    return function(this: T, a: any) { return visit(this, a); };\n}\n\n/** @ignore */\nexport function partial2<T>(visit: (node: T, a: any, b: any) => any) {\n    return function(this: T, a: any, b: any) { return visit(this, a, b); };\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { BN } from '../util/bn';\nimport { Visitor } from '../visitor';\nimport { decodeUtf8 } from '../util/utf8';\nimport { VectorType } from '../interfaces';\nimport { uint16ToFloat64 } from '../util/math';\nimport { Type, UnionMode, Precision, DateUnit, TimeUnit, IntervalUnit } from '../enum';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface GetVisitor extends Visitor {\n    visit<T extends VectorType>  (node: T, index: number): T['TValue'];\n    visitMany<T extends VectorType>  (nodes: T[], indices: number[]): T['TValue'][];\n    getVisitFn<T extends Type>    (node: T): (vector: VectorType<T>, index: number) => VectorType<T>['TValue'];\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>, index: number) => VectorType<T>['TValue'];\n    visitNull                 <T extends Null>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitBool                 <T extends Bool>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt                  <T extends Int>                  (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt8                 <T extends Int8>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt16                <T extends Int16>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt32                <T extends Int32>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt64                <T extends Int64>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint8                <T extends Uint8>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint16               <T extends Uint16>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint32               <T extends Uint32>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint64               <T extends Uint64>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat                <T extends Float>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat16              <T extends Float16>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat32              <T extends Float32>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat64              <T extends Float64>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitUtf8                 <T extends Utf8>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitBinary               <T extends Binary>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitFixedSizeBinary      <T extends FixedSizeBinary>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitDate                 <T extends Date_>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitDateDay              <T extends DateDay>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitDateMillisecond      <T extends DateMillisecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestamp            <T extends Timestamp>            (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampSecond      <T extends TimestampSecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampMillisecond <T extends TimestampMillisecond> (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampMicrosecond <T extends TimestampMicrosecond> (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampNanosecond  <T extends TimestampNanosecond>  (vector: VectorType<T>, index: number): T['TValue'];\n    visitTime                 <T extends Time>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeSecond           <T extends TimeSecond>           (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeMillisecond      <T extends TimeMillisecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeMicrosecond      <T extends TimeMicrosecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeNanosecond       <T extends TimeNanosecond>       (vector: VectorType<T>, index: number): T['TValue'];\n    visitDecimal              <T extends Decimal>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitList                 <T extends List>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitStruct               <T extends Struct>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitUnion                <T extends Union>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitDenseUnion           <T extends DenseUnion>           (vector: VectorType<T>, index: number): T['TValue'];\n    visitSparseUnion          <T extends SparseUnion>          (vector: VectorType<T>, index: number): T['TValue'];\n    visitDictionary           <T extends Dictionary>           (vector: VectorType<T>, index: number): T['TValue'];\n    visitInterval             <T extends Interval>             (vector: VectorType<T>, index: number): T['TValue'];\n    visitIntervalDayTime      <T extends IntervalDayTime>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitIntervalYearMonth    <T extends IntervalYearMonth>    (vector: VectorType<T>, index: number): T['TValue'];\n    visitFixedSizeList        <T extends FixedSizeList>        (vector: VectorType<T>, index: number): T['TValue'];\n    visitMap                  <T extends Map_>                 (vector: VectorType<T>, index: number): T['TValue'];\n}\n\n/** @ignore */\nexport class GetVisitor extends Visitor {}\n\n/** @ignore */const epochDaysToMs = (data: Int32Array, index: number) => 86400000 * data[index];\n/** @ignore */const epochMillisecondsLongToMs = (data: Int32Array, index: number) => 4294967296 * (data[index + 1]) + (data[index] >>> 0);\n/** @ignore */const epochMicrosecondsLongToMs = (data: Int32Array, index: number) => 4294967296 * (data[index + 1] / 1000) + ((data[index] >>> 0) / 1000);\n/** @ignore */const epochNanosecondsLongToMs = (data: Int32Array, index: number) => 4294967296 * (data[index + 1] / 1000000) + ((data[index] >>> 0) / 1000000);\n\n/** @ignore */const epochMillisecondsToDate = (epochMs: number) => new Date(epochMs);\n/** @ignore */const epochDaysToDate = (data: Int32Array, index: number) => epochMillisecondsToDate(epochDaysToMs(data, index));\n/** @ignore */const epochMillisecondsLongToDate = (data: Int32Array, index: number) => epochMillisecondsToDate(epochMillisecondsLongToMs(data, index));\n\n/** @ignore */\nconst getNull = <T extends Null>(_vector: VectorType<T>, _index: number): T['TValue'] => null;\n/** @ignore */\nconst getVariableWidthBytes = (values: Uint8Array, valueOffsets: Int32Array, index: number) => {\n    const { [index]: x, [index + 1]: y } = valueOffsets;\n    return x != null && y != null ? values.subarray(x, y) : null as any;\n};\n\n/** @ignore */\nconst getBool = <T extends Bool>({ offset, values }: VectorType<T>, index: number): T['TValue'] => {\n    const idx = offset + index;\n    const byte = values[idx >> 3];\n    return (byte & 1 << (idx % 8)) !== 0;\n};\n\n/** @ignore */\ntype Numeric1X = Int8 | Int16 | Int32 | Uint8 | Uint16 | Uint32 | Float32 | Float64;\n/** @ignore */\ntype Numeric2X = Int64 | Uint64;\n\n/** @ignore */\nconst getDateDay         = <T extends DateDay>        ({ values         }: VectorType<T>, index: number): T['TValue'] => epochDaysToDate(values, index);\n/** @ignore */\nconst getDateMillisecond = <T extends DateMillisecond>({ values         }: VectorType<T>, index: number): T['TValue'] => epochMillisecondsLongToDate(values, index * 2);\n/** @ignore */\nconst getNumeric         = <T extends Numeric1X>      ({ stride, values }: VectorType<T>, index: number): T['TValue'] => values[stride * index];\n/** @ignore */\nconst getFloat16         = <T extends Float16>        ({ stride, values }: VectorType<T>, index: number): T['TValue'] => uint16ToFloat64(values[stride * index]);\n/** @ignore */\nconst getBigInts         = <T extends Numeric2X>({ stride, values, type }: VectorType<T>, index: number): T['TValue'] => <any> BN.new(values.subarray(stride * index, stride * (index + 1)), type.isSigned);\n/** @ignore */\nconst getFixedSizeBinary = <T extends FixedSizeBinary>({ stride, values }: VectorType<T>, index: number): T['TValue'] => values.subarray(stride * index, stride * (index + 1));\n\n/** @ignore */\nconst getBinary = <T extends Binary>({ values, valueOffsets }: VectorType<T>, index: number): T['TValue'] => getVariableWidthBytes(values, valueOffsets, index);\n/** @ignore */\nconst getUtf8 = <T extends Utf8>({ values, valueOffsets }: VectorType<T>, index: number): T['TValue'] => {\n    const bytes = getVariableWidthBytes(values, valueOffsets, index);\n    return bytes !== null ? decodeUtf8(bytes) : null as any;\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst getInt = <T extends Int>(vector: VectorType<T>, index: number): T['TValue'] => (\n    vector.type.bitWidth < 64\n        ? getNumeric(vector as VectorType<Numeric1X>, index)\n        : getBigInts(vector as VectorType<Numeric2X>, index)\n);\n\n/* istanbul ignore next */\n/** @ignore */\nconst getFloat = <T extends Float> (vector: VectorType<T>, index: number): T['TValue'] => (\n    vector.type.precision !== Precision.HALF\n        ? getNumeric(vector as VectorType<Numeric1X>, index)\n        : getFloat16(vector as VectorType<Float16>, index)\n);\n\n/* istanbul ignore next */\n/** @ignore */\nconst getDate = <T extends Date_> (vector: VectorType<T>, index: number): T['TValue'] => (\n    vector.type.unit === DateUnit.DAY\n        ? getDateDay(vector as VectorType<DateDay>, index)\n        : getDateMillisecond(vector as VectorType<DateMillisecond>, index)\n);\n\n/** @ignore */\nconst getTimestampSecond      = <T extends TimestampSecond>     ({ values }: VectorType<T>, index: number): T['TValue'] => 1000 * epochMillisecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampMillisecond = <T extends TimestampMillisecond>({ values }: VectorType<T>, index: number): T['TValue'] => epochMillisecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampMicrosecond = <T extends TimestampMicrosecond>({ values }: VectorType<T>, index: number): T['TValue'] => epochMicrosecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampNanosecond  = <T extends TimestampNanosecond> ({ values }: VectorType<T>, index: number): T['TValue'] => epochNanosecondsLongToMs(values, index * 2);\n/* istanbul ignore next */\n/** @ignore */\nconst getTimestamp            = <T extends Timestamp>(vector: VectorType<T>, index: number): T['TValue'] => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      getTimestampSecond(vector as VectorType<TimestampSecond>, index);\n        case TimeUnit.MILLISECOND: return getTimestampMillisecond(vector as VectorType<TimestampMillisecond>, index);\n        case TimeUnit.MICROSECOND: return getTimestampMicrosecond(vector as VectorType<TimestampMicrosecond>, index);\n        case TimeUnit.NANOSECOND:  return  getTimestampNanosecond(vector as VectorType<TimestampNanosecond>, index);\n    }\n};\n\n/** @ignore */\nconst getTimeSecond      = <T extends TimeSecond>     ({ values, stride }: VectorType<T>, index: number): T['TValue'] => values[stride * index];\n/** @ignore */\nconst getTimeMillisecond = <T extends TimeMillisecond>({ values, stride }: VectorType<T>, index: number): T['TValue'] => values[stride * index];\n/** @ignore */\nconst getTimeMicrosecond = <T extends TimeMicrosecond>({ values         }: VectorType<T>, index: number): T['TValue'] => BN.signed(values.subarray(2 * index, 2 * (index + 1)));\n/** @ignore */\nconst getTimeNanosecond  = <T extends TimeNanosecond> ({ values         }: VectorType<T>, index: number): T['TValue'] => BN.signed(values.subarray(2 * index, 2 * (index + 1)));\n/* istanbul ignore next */\n/** @ignore */\nconst getTime            = <T extends Time>(vector: VectorType<T>, index: number): T['TValue'] => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      getTimeSecond(vector as VectorType<TimeSecond>, index);\n        case TimeUnit.MILLISECOND: return getTimeMillisecond(vector as VectorType<TimeMillisecond>, index);\n        case TimeUnit.MICROSECOND: return getTimeMicrosecond(vector as VectorType<TimeMicrosecond>, index);\n        case TimeUnit.NANOSECOND:  return  getTimeNanosecond(vector as VectorType<TimeNanosecond>, index);\n    }\n};\n\n/** @ignore */\nconst getDecimal = <T extends Decimal>({ values }: VectorType<T>, index: number): T['TValue'] => BN.decimal(values.subarray(4 * index, 4 * (index + 1)));\n\n/** @ignore */\nconst getList = <T extends List>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const child = vector.getChildAt(0)!, { valueOffsets, stride } = vector;\n    return child.slice(valueOffsets[index * stride], valueOffsets[(index * stride) + 1]) as T['TValue'];\n};\n\n/** @ignore */\nconst getMap = <T extends Map_>(vector: VectorType<T>, index: number): T['TValue'] => {\n    return vector.bind(index) as T['TValue'];\n};\n\n/** @ignore */\nconst getStruct = <T extends Struct>(vector: VectorType<T>, index: number): T['TValue'] => {\n    return vector.bind(index) as T['TValue'];\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst getUnion = <\n    V extends VectorType<Union> | VectorType<DenseUnion> | VectorType<SparseUnion>\n>(vector: V, index: number): V['TValue'] => {\n    return vector.type.mode === UnionMode.Dense ?\n        getDenseUnion(vector as VectorType<DenseUnion>, index) :\n        getSparseUnion(vector as VectorType<SparseUnion>, index);\n};\n\n/** @ignore */\nconst getDenseUnion = <T extends DenseUnion>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    return child ? child.get(vector.valueOffsets[index]) : null;\n};\n\n/** @ignore */\nconst getSparseUnion = <T extends SparseUnion>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    return child ? child.get(index) : null;\n};\n\n/** @ignore */\nconst getDictionary = <T extends Dictionary>(vector: VectorType<T>, index: number): T['TValue'] => {\n    return vector.getValue(vector.getKey(index)!);\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst getInterval = <T extends Interval>(vector: VectorType<T>, index: number): T['TValue'] =>\n    (vector.type.unit === IntervalUnit.DAY_TIME)\n        ? getIntervalDayTime(vector as VectorType<IntervalDayTime>, index)\n        : getIntervalYearMonth(vector as VectorType<IntervalYearMonth>, index);\n\n/** @ignore */\nconst getIntervalDayTime = <T extends IntervalDayTime>({ values }: VectorType<T>, index: number): T['TValue'] => values.subarray(2 * index, 2 * (index + 1));\n\n/** @ignore */\nconst getIntervalYearMonth = <T extends IntervalYearMonth>({ values }: VectorType<T>, index: number): T['TValue'] => {\n    const interval = values[index];\n    const int32s = new Int32Array(2);\n    int32s[0] = interval / 12 | 0; /* years */\n    int32s[1] = interval % 12 | 0; /* months */\n    return int32s;\n};\n\n/** @ignore */\nconst getFixedSizeList = <T extends FixedSizeList>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const child = vector.getChildAt(0)!, { stride } = vector;\n    return child.slice(index * stride, (index + 1) * stride) as T['TValue'];\n};\n\nGetVisitor.prototype.visitNull                 =                 getNull;\nGetVisitor.prototype.visitBool                 =                 getBool;\nGetVisitor.prototype.visitInt                  =                  getInt;\nGetVisitor.prototype.visitInt8                 =              getNumeric;\nGetVisitor.prototype.visitInt16                =              getNumeric;\nGetVisitor.prototype.visitInt32                =              getNumeric;\nGetVisitor.prototype.visitInt64                =              getBigInts;\nGetVisitor.prototype.visitUint8                =              getNumeric;\nGetVisitor.prototype.visitUint16               =              getNumeric;\nGetVisitor.prototype.visitUint32               =              getNumeric;\nGetVisitor.prototype.visitUint64               =              getBigInts;\nGetVisitor.prototype.visitFloat                =                getFloat;\nGetVisitor.prototype.visitFloat16              =              getFloat16;\nGetVisitor.prototype.visitFloat32              =              getNumeric;\nGetVisitor.prototype.visitFloat64              =              getNumeric;\nGetVisitor.prototype.visitUtf8                 =                 getUtf8;\nGetVisitor.prototype.visitBinary               =               getBinary;\nGetVisitor.prototype.visitFixedSizeBinary      =      getFixedSizeBinary;\nGetVisitor.prototype.visitDate                 =                 getDate;\nGetVisitor.prototype.visitDateDay              =              getDateDay;\nGetVisitor.prototype.visitDateMillisecond      =      getDateMillisecond;\nGetVisitor.prototype.visitTimestamp            =            getTimestamp;\nGetVisitor.prototype.visitTimestampSecond      =      getTimestampSecond;\nGetVisitor.prototype.visitTimestampMillisecond = getTimestampMillisecond;\nGetVisitor.prototype.visitTimestampMicrosecond = getTimestampMicrosecond;\nGetVisitor.prototype.visitTimestampNanosecond  =  getTimestampNanosecond;\nGetVisitor.prototype.visitTime                 =                 getTime;\nGetVisitor.prototype.visitTimeSecond           =           getTimeSecond;\nGetVisitor.prototype.visitTimeMillisecond      =      getTimeMillisecond;\nGetVisitor.prototype.visitTimeMicrosecond      =      getTimeMicrosecond;\nGetVisitor.prototype.visitTimeNanosecond       =       getTimeNanosecond;\nGetVisitor.prototype.visitDecimal              =              getDecimal;\nGetVisitor.prototype.visitList                 =                 getList;\nGetVisitor.prototype.visitStruct               =               getStruct;\nGetVisitor.prototype.visitUnion                =                getUnion;\nGetVisitor.prototype.visitDenseUnion           =           getDenseUnion;\nGetVisitor.prototype.visitSparseUnion          =          getSparseUnion;\nGetVisitor.prototype.visitDictionary           =           getDictionary;\nGetVisitor.prototype.visitInterval             =             getInterval;\nGetVisitor.prototype.visitIntervalDayTime      =      getIntervalDayTime;\nGetVisitor.prototype.visitIntervalYearMonth    =    getIntervalYearMonth;\nGetVisitor.prototype.visitFixedSizeList        =        getFixedSizeList;\nGetVisitor.prototype.visitMap                  =                  getMap;\n\n/** @ignore */\nexport const instance = new GetVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { getBool, iterateBits } from '../util/bit';\nimport { createElementComparator } from '../util/vector';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface IndexOfVisitor extends Visitor {\n    visit<T extends VectorType>  (node: T, value: T['TValue'] | null, index?: number): number;\n    visitMany <T extends VectorType>  (nodes: T[], values: (T['TValue'] | null)[], indices: (number | undefined)[]): number[];\n    getVisitFn<T extends Type>    (node: T): (vector: VectorType<T>, value: VectorType<T>['TValue'] | null, index?: number) => number;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>, value:         T['TValue'] | null, index?: number) => number;\n    visitNull                 <T extends Null>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitBool                 <T extends Bool>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt                  <T extends Int>                 (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt8                 <T extends Int8>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt16                <T extends Int16>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt32                <T extends Int32>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt64                <T extends Int64>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint8                <T extends Uint8>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint16               <T extends Uint16>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint32               <T extends Uint32>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint64               <T extends Uint64>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat                <T extends Float>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat16              <T extends Float16>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat32              <T extends Float32>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat64              <T extends Float64>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUtf8                 <T extends Utf8>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitBinary               <T extends Binary>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDate                 <T extends Date_>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDateDay              <T extends DateDay>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDateMillisecond      <T extends DateMillisecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestamp            <T extends Timestamp>           (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampSecond      <T extends TimestampSecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampMillisecond <T extends TimestampMillisecond>(vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond>(vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampNanosecond  <T extends TimestampNanosecond> (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTime                 <T extends Time>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeSecond           <T extends TimeSecond>          (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeMillisecond      <T extends TimeMillisecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeNanosecond       <T extends TimeNanosecond>      (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDecimal              <T extends Decimal>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitList                 <T extends List>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitStruct               <T extends Struct>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUnion                <T extends Union>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDenseUnion           <T extends DenseUnion>          (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitSparseUnion          <T extends SparseUnion>         (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDictionary           <T extends Dictionary>          (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInterval             <T extends Interval>            (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitIntervalDayTime      <T extends IntervalDayTime>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>   (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFixedSizeList        <T extends FixedSizeList>       (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitMap                  <T extends Map_>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n}\n\n/** @ignore */\nexport class IndexOfVisitor extends Visitor {}\n\n/** @ignore */\nfunction nullIndexOf(vector: VectorType<Null>, searchElement?: null) {\n    // if you're looking for nulls and the vector isn't empty, we've got 'em!\n    return searchElement === null && vector.length > 0 ? 0 : -1;\n}\n\n/** @ignore */\nfunction indexOfNull<T extends DataType>(vector: VectorType<T>, fromIndex?: number): number {\n    const { nullBitmap } = vector;\n    if (!nullBitmap || vector.nullCount <= 0) {\n        return -1;\n    }\n    let i = 0;\n    for (const isValid of iterateBits(nullBitmap, vector.data.offset + (fromIndex || 0), vector.length, nullBitmap, getBool)) {\n        if (!isValid) { return i; }\n        ++i;\n    }\n    return -1;\n}\n\n/** @ignore */\nfunction indexOfValue<T extends DataType>(vector: VectorType<T>, searchElement?: T['TValue'] | null, fromIndex?: number): number {\n    if (searchElement === undefined) { return -1; }\n    if (searchElement === null) { return indexOfNull(vector, fromIndex); }\n    const compare = createElementComparator(searchElement);\n    for (let i = (fromIndex || 0) - 1, n = vector.length; ++i < n;) {\n        if (compare(vector.get(i))) {\n            return i;\n        }\n    }\n    return -1;\n}\n\n/** @ignore */\nfunction indexOfUnion<T extends DataType>(vector: VectorType<T>, searchElement?: T['TValue'] | null, fromIndex?: number): number {\n    // Unions are special -- they do have a nullBitmap, but so can their children.\n    // If the searchElement is null, we don't know whether it came from the Union's\n    // bitmap or one of its childrens'. So we don't interrogate the Union's bitmap,\n    // since that will report the wrong index if a child has a null before the Union.\n    const compare = createElementComparator(searchElement);\n    for (let i = (fromIndex || 0) - 1, n = vector.length; ++i < n;) {\n        if (compare(vector.get(i))) {\n            return i;\n        }\n    }\n    return -1;\n}\n\nIndexOfVisitor.prototype.visitNull                 =  nullIndexOf;\nIndexOfVisitor.prototype.visitBool                 = indexOfValue;\nIndexOfVisitor.prototype.visitInt                  = indexOfValue;\nIndexOfVisitor.prototype.visitInt8                 = indexOfValue;\nIndexOfVisitor.prototype.visitInt16                = indexOfValue;\nIndexOfVisitor.prototype.visitInt32                = indexOfValue;\nIndexOfVisitor.prototype.visitInt64                = indexOfValue;\nIndexOfVisitor.prototype.visitUint8                = indexOfValue;\nIndexOfVisitor.prototype.visitUint16               = indexOfValue;\nIndexOfVisitor.prototype.visitUint32               = indexOfValue;\nIndexOfVisitor.prototype.visitUint64               = indexOfValue;\nIndexOfVisitor.prototype.visitFloat                = indexOfValue;\nIndexOfVisitor.prototype.visitFloat16              = indexOfValue;\nIndexOfVisitor.prototype.visitFloat32              = indexOfValue;\nIndexOfVisitor.prototype.visitFloat64              = indexOfValue;\nIndexOfVisitor.prototype.visitUtf8                 = indexOfValue;\nIndexOfVisitor.prototype.visitBinary               = indexOfValue;\nIndexOfVisitor.prototype.visitFixedSizeBinary      = indexOfValue;\nIndexOfVisitor.prototype.visitDate                 = indexOfValue;\nIndexOfVisitor.prototype.visitDateDay              = indexOfValue;\nIndexOfVisitor.prototype.visitDateMillisecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimestamp            = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampSecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampMillisecond = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampMicrosecond = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampNanosecond  = indexOfValue;\nIndexOfVisitor.prototype.visitTime                 = indexOfValue;\nIndexOfVisitor.prototype.visitTimeSecond           = indexOfValue;\nIndexOfVisitor.prototype.visitTimeMillisecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimeMicrosecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimeNanosecond       = indexOfValue;\nIndexOfVisitor.prototype.visitDecimal              = indexOfValue;\nIndexOfVisitor.prototype.visitList                 = indexOfValue;\nIndexOfVisitor.prototype.visitStruct               = indexOfValue;\nIndexOfVisitor.prototype.visitUnion                = indexOfValue;\nIndexOfVisitor.prototype.visitDenseUnion           = indexOfUnion;\nIndexOfVisitor.prototype.visitSparseUnion          = indexOfUnion;\nIndexOfVisitor.prototype.visitDictionary           = indexOfValue;\nIndexOfVisitor.prototype.visitInterval             = indexOfValue;\nIndexOfVisitor.prototype.visitIntervalDayTime      = indexOfValue;\nIndexOfVisitor.prototype.visitIntervalYearMonth    = indexOfValue;\nIndexOfVisitor.prototype.visitFixedSizeList        = indexOfValue;\nIndexOfVisitor.prototype.visitMap                  = indexOfValue;\n\n/** @ignore */\nexport const instance = new IndexOfVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { iterateBits } from '../util/bit';\nimport { instance as getVisitor } from './get';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface IteratorVisitor extends Visitor {\n    visit<T extends VectorType>(node: T): IterableIterator<T['TValue'] | null>;\n    visitMany <T extends VectorType>(nodes: T[]): IterableIterator<T['TValue'] | null>[];\n    getVisitFn<T extends Type>(node: T): (vector: VectorType<T>) => IterableIterator<VectorType<T>['TValue'] | null>;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>) => IterableIterator<VectorType<T>['TValue'] | null>;\n    visitNull                 <T extends Null>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitBool                 <T extends Bool>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt                  <T extends Int>                  (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt8                 <T extends Int8>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt16                <T extends Int16>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt32                <T extends Int32>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt64                <T extends Int64>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint8                <T extends Uint8>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint16               <T extends Uint16>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint32               <T extends Uint32>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint64               <T extends Uint64>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat                <T extends Float>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat16              <T extends Float16>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat32              <T extends Float32>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat64              <T extends Float64>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUtf8                 <T extends Utf8>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitBinary               <T extends Binary>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDate                 <T extends Date_>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDateDay              <T extends DateDay>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDateMillisecond      <T extends DateMillisecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestamp            <T extends Timestamp>            (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampSecond      <T extends TimestampSecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampMillisecond <T extends TimestampMillisecond> (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond> (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampNanosecond  <T extends TimestampNanosecond>  (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTime                 <T extends Time>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeSecond           <T extends TimeSecond>           (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeMillisecond      <T extends TimeMillisecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeNanosecond       <T extends TimeNanosecond>       (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDecimal              <T extends Decimal>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitList                 <T extends List>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitStruct               <T extends Struct>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUnion                <T extends Union>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDenseUnion           <T extends DenseUnion>           (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitSparseUnion          <T extends SparseUnion>          (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDictionary           <T extends Dictionary>           (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInterval             <T extends Interval>             (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitIntervalDayTime      <T extends IntervalDayTime>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>    (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFixedSizeList        <T extends FixedSizeList>        (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitMap                  <T extends Map_>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n}\n\n/** @ignore */\nexport class IteratorVisitor extends Visitor {}\n\n/** @ignore */\nfunction nullableIterator<T extends DataType>(vector: VectorType<T>): IterableIterator<T['TValue'] | null> {\n    const getFn = getVisitor.getVisitFn(vector);\n    return iterateBits<T['TValue'] | null>(\n        vector.nullBitmap, vector.offset, vector.length, vector,\n        (vec: VectorType<T>, idx: number, nullByte: number, nullBit: number) =>\n            ((nullByte & 1 << nullBit) !== 0) ? getFn(vec, idx) : null\n    );\n}\n\n/** @ignore */\nfunction vectorIterator<T extends DataType>(vector: VectorType<T>): IterableIterator<T['TValue'] | null> {\n\n    // If nullable, iterate manually\n    if (vector.nullCount > 0) {\n        return nullableIterator<T>(vector);\n    }\n\n    const { type, typeId, length } = vector;\n\n    // Fast case, defer to native iterators if possible\n    if (vector.stride === 1 && (\n        (typeId === Type.Timestamp) ||\n        (typeId === Type.Int && (type as Int).bitWidth !== 64) ||\n        (typeId === Type.Time && (type as Time).bitWidth !== 64) ||\n        (typeId === Type.Float && (type as Float).precision > 0 /* Precision.HALF */)\n    )) {\n        return vector.values.subarray(0, length)[Symbol.iterator]();\n    }\n\n    // Otherwise, iterate manually\n    return (function* (getFn) {\n        for (let index = -1; ++index < length;) {\n            yield getFn(vector, index);\n        }\n    })(getVisitor.getVisitFn(vector));\n}\n\nIteratorVisitor.prototype.visitNull                 = vectorIterator;\nIteratorVisitor.prototype.visitBool                 = vectorIterator;\nIteratorVisitor.prototype.visitInt                  = vectorIterator;\nIteratorVisitor.prototype.visitInt8                 = vectorIterator;\nIteratorVisitor.prototype.visitInt16                = vectorIterator;\nIteratorVisitor.prototype.visitInt32                = vectorIterator;\nIteratorVisitor.prototype.visitInt64                = vectorIterator;\nIteratorVisitor.prototype.visitUint8                = vectorIterator;\nIteratorVisitor.prototype.visitUint16               = vectorIterator;\nIteratorVisitor.prototype.visitUint32               = vectorIterator;\nIteratorVisitor.prototype.visitUint64               = vectorIterator;\nIteratorVisitor.prototype.visitFloat                = vectorIterator;\nIteratorVisitor.prototype.visitFloat16              = vectorIterator;\nIteratorVisitor.prototype.visitFloat32              = vectorIterator;\nIteratorVisitor.prototype.visitFloat64              = vectorIterator;\nIteratorVisitor.prototype.visitUtf8                 = vectorIterator;\nIteratorVisitor.prototype.visitBinary               = vectorIterator;\nIteratorVisitor.prototype.visitFixedSizeBinary      = vectorIterator;\nIteratorVisitor.prototype.visitDate                 = vectorIterator;\nIteratorVisitor.prototype.visitDateDay              = vectorIterator;\nIteratorVisitor.prototype.visitDateMillisecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimestamp            = vectorIterator;\nIteratorVisitor.prototype.visitTimestampSecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimestampMillisecond = vectorIterator;\nIteratorVisitor.prototype.visitTimestampMicrosecond = vectorIterator;\nIteratorVisitor.prototype.visitTimestampNanosecond  = vectorIterator;\nIteratorVisitor.prototype.visitTime                 = vectorIterator;\nIteratorVisitor.prototype.visitTimeSecond           = vectorIterator;\nIteratorVisitor.prototype.visitTimeMillisecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimeMicrosecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimeNanosecond       = vectorIterator;\nIteratorVisitor.prototype.visitDecimal              = vectorIterator;\nIteratorVisitor.prototype.visitList                 = vectorIterator;\nIteratorVisitor.prototype.visitStruct               = vectorIterator;\nIteratorVisitor.prototype.visitUnion                = vectorIterator;\nIteratorVisitor.prototype.visitDenseUnion           = vectorIterator;\nIteratorVisitor.prototype.visitSparseUnion          = vectorIterator;\nIteratorVisitor.prototype.visitDictionary           = vectorIterator;\nIteratorVisitor.prototype.visitInterval             = vectorIterator;\nIteratorVisitor.prototype.visitIntervalDayTime      = vectorIterator;\nIteratorVisitor.prototype.visitIntervalYearMonth    = vectorIterator;\nIteratorVisitor.prototype.visitFixedSizeList        = vectorIterator;\nIteratorVisitor.prototype.visitMap                  = vectorIterator;\n\n/** @ignore */\nexport const instance = new IteratorVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { instance as iteratorVisitor } from './iterator';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface ToArrayVisitor extends Visitor {\n    visit<T extends VectorType>(node: T): T['TArray'];\n    visitMany<T extends VectorType>(nodes: T[]): T['TArray'][];\n    getVisitFn<T extends Type>(node: T): (vector: VectorType<T>) => VectorType<T>['TArray'];\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>) => VectorType<T>['TArray'];\n    visitNull                                    <T extends Null>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitBool                                    <T extends Bool>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt                                     <T extends Int>                 (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt8                                    <T extends Int8>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt16                                   <T extends Int16>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt32                                   <T extends Int32>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt64                                   <T extends Int64>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint8                                   <T extends Uint8>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint16                                  <T extends Uint16>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint32                                  <T extends Uint32>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint64                                  <T extends Uint64>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat                                   <T extends Float>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat16                                 <T extends Float16>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat32                                 <T extends Float32>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat64                                 <T extends Float64>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUtf8                                    <T extends Utf8>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitBinary                                  <T extends Binary>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFixedSizeBinary                         <T extends FixedSizeBinary>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDate                                    <T extends Date_>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDateDay                                 <T extends DateDay>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDateMillisecond                         <T extends DateMillisecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestamp                               <T extends Timestamp>           (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampSecond                         <T extends TimestampSecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampMillisecond                    <T extends TimestampMillisecond>(vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampMicrosecond                    <T extends TimestampMicrosecond>(vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampNanosecond                     <T extends TimestampNanosecond> (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTime                                    <T extends Time>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeSecond                              <T extends TimeSecond>          (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeMillisecond                         <T extends TimeMillisecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeMicrosecond                         <T extends TimeMicrosecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeNanosecond                          <T extends TimeNanosecond>      (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDecimal                                 <T extends Decimal>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitList                <R extends DataType, T extends List<R>>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitStruct                                  <T extends Struct>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUnion                                   <T extends Union>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDenseUnion                              <T extends DenseUnion>          (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitSparseUnion                             <T extends SparseUnion>         (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDictionary          <R extends DataType, T extends Dictionary<R>>       (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInterval                                <T extends Interval>            (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitIntervalDayTime                         <T extends IntervalDayTime>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitIntervalYearMonth                       <T extends IntervalYearMonth>   (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFixedSizeList       <R extends DataType, T extends FixedSizeList<R>>    (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitMap                                     <T extends Map_>                (vector: VectorType<T>): VectorType<T>['TArray'];\n}\n\n/** @ignore */\nexport class ToArrayVisitor extends Visitor {}\n\n/** @ignore */\nfunction arrayOfVector<T extends DataType>(vector: VectorType<T>): T['TArray'] {\n\n    const { type, length, stride } = vector;\n\n    // Fast case, return subarray if possible\n    switch (type.typeId) {\n        case Type.Int:\n        case Type.Float: case Type.Decimal:\n        case Type.Time: case Type.Timestamp:\n            return vector.values.subarray(0, length * stride);\n    }\n\n    // Otherwise if not primitive, slow copy\n    return [...iteratorVisitor.visit(vector)] as T['TArray'];\n}\n\nToArrayVisitor.prototype.visitNull                 = arrayOfVector;\nToArrayVisitor.prototype.visitBool                 = arrayOfVector;\nToArrayVisitor.prototype.visitInt                  = arrayOfVector;\nToArrayVisitor.prototype.visitInt8                 = arrayOfVector;\nToArrayVisitor.prototype.visitInt16                = arrayOfVector;\nToArrayVisitor.prototype.visitInt32                = arrayOfVector;\nToArrayVisitor.prototype.visitInt64                = arrayOfVector;\nToArrayVisitor.prototype.visitUint8                = arrayOfVector;\nToArrayVisitor.prototype.visitUint16               = arrayOfVector;\nToArrayVisitor.prototype.visitUint32               = arrayOfVector;\nToArrayVisitor.prototype.visitUint64               = arrayOfVector;\nToArrayVisitor.prototype.visitFloat                = arrayOfVector;\nToArrayVisitor.prototype.visitFloat16              = arrayOfVector;\nToArrayVisitor.prototype.visitFloat32              = arrayOfVector;\nToArrayVisitor.prototype.visitFloat64              = arrayOfVector;\nToArrayVisitor.prototype.visitUtf8                 = arrayOfVector;\nToArrayVisitor.prototype.visitBinary               = arrayOfVector;\nToArrayVisitor.prototype.visitFixedSizeBinary      = arrayOfVector;\nToArrayVisitor.prototype.visitDate                 = arrayOfVector;\nToArrayVisitor.prototype.visitDateDay              = arrayOfVector;\nToArrayVisitor.prototype.visitDateMillisecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimestamp            = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampSecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampMillisecond = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampMicrosecond = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampNanosecond  = arrayOfVector;\nToArrayVisitor.prototype.visitTime                 = arrayOfVector;\nToArrayVisitor.prototype.visitTimeSecond           = arrayOfVector;\nToArrayVisitor.prototype.visitTimeMillisecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimeMicrosecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimeNanosecond       = arrayOfVector;\nToArrayVisitor.prototype.visitDecimal              = arrayOfVector;\nToArrayVisitor.prototype.visitList                 = arrayOfVector;\nToArrayVisitor.prototype.visitStruct               = arrayOfVector;\nToArrayVisitor.prototype.visitUnion                = arrayOfVector;\nToArrayVisitor.prototype.visitDenseUnion           = arrayOfVector;\nToArrayVisitor.prototype.visitSparseUnion          = arrayOfVector;\nToArrayVisitor.prototype.visitDictionary           = arrayOfVector;\nToArrayVisitor.prototype.visitInterval             = arrayOfVector;\nToArrayVisitor.prototype.visitIntervalDayTime      = arrayOfVector;\nToArrayVisitor.prototype.visitIntervalYearMonth    = arrayOfVector;\nToArrayVisitor.prototype.visitFixedSizeList        = arrayOfVector;\nToArrayVisitor.prototype.visitMap                  = arrayOfVector;\n\n/** @ignore */\nexport const instance = new ToArrayVisitor();\n","/* istanbul ignore file */\n\n// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { Type, TimeUnit } from '../enum';\nimport { Schema, Field } from '../schema';\nimport {\n    DataType, Dictionary,\n    Float, Int, Date_, Interval, Time, Timestamp,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary,\n    List, FixedSizeList, Map_, Struct, Union,\n} from '../type';\n\n/** @ignore */ const sum = (x: number, y: number) => x + y;\n/** @ignore */ const variableWidthColumnErrorMessage = (type: DataType) => `Cannot compute the byte width of variable-width column ${type}`;\n\n/** @ignore */\nexport interface ByteWidthVisitor extends Visitor {\n    visit<T extends DataType>(node: T): number;\n    visitMany<T extends DataType>(nodes: T[]): number[];\n    getVisitFn<T extends Type>    (node: T): (type: DataType<T>) => number;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (type: T) => number;\n}\n\n/** @ignore */\nexport class ByteWidthVisitor extends Visitor {\n    public visitNull            (____: Null            ) { return 0; }\n    public visitInt             (type: Int             ) { return type.bitWidth / 8; }\n    public visitFloat           (type: Float           ) { return type.ArrayType.BYTES_PER_ELEMENT; }\n    public visitBinary          (type: Binary          ) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    public visitUtf8            (type: Utf8            ) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    public visitBool            (____: Bool            ) { return 1 / 8; }\n    public visitDecimal         (____: Decimal         ) { return 16; }\n    public visitDate            (type: Date_           ) { return (type.unit + 1) * 4; }\n    public visitTime            (type: Time            ) { return type.bitWidth / 8; }\n    public visitTimestamp       (type: Timestamp       ) { return type.unit === TimeUnit.SECOND ? 4 : 8; }\n    public visitInterval        (type: Interval        ) { return (type.unit + 1) * 4; }\n    public visitList            (type: List            ) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    public visitStruct          (type: Struct          ) { return this.visitFields(type.children).reduce(sum, 0); }\n    public visitUnion           (type: Union           ) { return this.visitFields(type.children).reduce(sum, 0); }\n    public visitFixedSizeBinary (type: FixedSizeBinary ) { return type.byteWidth; }\n    public visitFixedSizeList   (type: FixedSizeList   ) { return type.listSize * this.visitFields(type.children).reduce(sum, 0); }\n    public visitMap             (type: Map_            ) { return this.visitFields(type.children).reduce(sum, 0); }\n    public visitDictionary      (type: Dictionary      ) { return this.visit(type.indices); }\n    public visitFields          (fields: Field[]       ) { return (fields || []).map((field) => this.visit(field.type)); }\n    public visitSchema          (schema: Schema        ) { return this.visitFields(schema.fields).reduce(sum, 0); }\n}\n\n/** @ignore */\nexport const instance = new ByteWidthVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { DataType } from '../type';\nimport { Visitor } from '../visitor';\nimport { VectorType, VectorCtor } from '../interfaces';\n\nimport { BinaryVector } from '../vector/binary';\nimport { BoolVector } from '../vector/bool';\nimport { DateVector, DateDayVector, DateMillisecondVector } from '../vector/date';\nimport { DecimalVector } from '../vector/decimal';\nimport { DictionaryVector } from '../vector/dictionary';\nimport { FixedSizeBinaryVector } from '../vector/fixedsizebinary';\nimport { FixedSizeListVector } from '../vector/fixedsizelist';\nimport { FloatVector, Float16Vector, Float32Vector, Float64Vector } from '../vector/float';\nimport { IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector } from '../vector/interval';\nimport { IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector } from '../vector/int';\nimport { ListVector } from '../vector/list';\nimport { MapVector } from '../vector/map';\nimport { NullVector } from '../vector/null';\nimport { StructVector } from '../vector/struct';\nimport { TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector } from '../vector/timestamp';\nimport { TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector } from '../vector/time';\nimport { UnionVector, DenseUnionVector, SparseUnionVector } from '../vector/union';\nimport { Utf8Vector } from '../vector/utf8';\n\n/** @ignore */\nexport interface GetVectorConstructor extends Visitor {\n    visit<T extends Type>(node: T): VectorCtor<T>;\n    visitMany <T extends Type>(nodes: T[]): VectorCtor<T>[];\n    getVisitFn<T extends Type>(node: T): () => VectorCtor<T>;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): () => VectorCtor<T>;\n}\n\n/** @ignore */\nexport class GetVectorConstructor extends Visitor {\n    public visitNull                 () { return NullVector; }\n    public visitBool                 () { return BoolVector; }\n    public visitInt                  () { return IntVector; }\n    public visitInt8                 () { return Int8Vector; }\n    public visitInt16                () { return Int16Vector; }\n    public visitInt32                () { return Int32Vector; }\n    public visitInt64                () { return Int64Vector; }\n    public visitUint8                () { return Uint8Vector; }\n    public visitUint16               () { return Uint16Vector; }\n    public visitUint32               () { return Uint32Vector; }\n    public visitUint64               () { return Uint64Vector; }\n    public visitFloat                () { return FloatVector; }\n    public visitFloat16              () { return Float16Vector; }\n    public visitFloat32              () { return Float32Vector; }\n    public visitFloat64              () { return Float64Vector; }\n    public visitUtf8                 () { return Utf8Vector; }\n    public visitBinary               () { return BinaryVector; }\n    public visitFixedSizeBinary      () { return FixedSizeBinaryVector; }\n    public visitDate                 () { return DateVector; }\n    public visitDateDay              () { return DateDayVector; }\n    public visitDateMillisecond      () { return DateMillisecondVector; }\n    public visitTimestamp            () { return TimestampVector; }\n    public visitTimestampSecond      () { return TimestampSecondVector; }\n    public visitTimestampMillisecond () { return TimestampMillisecondVector; }\n    public visitTimestampMicrosecond () { return TimestampMicrosecondVector; }\n    public visitTimestampNanosecond  () { return TimestampNanosecondVector; }\n    public visitTime                 () { return TimeVector; }\n    public visitTimeSecond           () { return TimeSecondVector; }\n    public visitTimeMillisecond      () { return TimeMillisecondVector; }\n    public visitTimeMicrosecond      () { return TimeMicrosecondVector; }\n    public visitTimeNanosecond       () { return TimeNanosecondVector; }\n    public visitDecimal              () { return DecimalVector; }\n    public visitList                 () { return ListVector; }\n    public visitStruct               () { return StructVector; }\n    public visitUnion                () { return UnionVector; }\n    public visitDenseUnion           () { return DenseUnionVector; }\n    public visitSparseUnion          () { return SparseUnionVector; }\n    public visitDictionary           () { return DictionaryVector; }\n    public visitInterval             () { return IntervalVector; }\n    public visitIntervalDayTime      () { return IntervalDayTimeVector; }\n    public visitIntervalYearMonth    () { return IntervalYearMonthVector; }\n    public visitFixedSizeList        () { return FixedSizeListVector; }\n    public visitMap                  () { return MapVector; }\n}\n\n/** @ignore */\nexport const instance = new GetVectorConstructor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nexport { Vector } from '../vector';\nexport { BaseVector } from './base';\nexport { BinaryVector } from './binary';\nexport { BoolVector } from './bool';\nexport { Chunked } from './chunked';\nexport { DateVector, DateDayVector, DateMillisecondVector } from './date';\nexport { DecimalVector } from './decimal';\nexport { DictionaryVector } from './dictionary';\nexport { FixedSizeBinaryVector } from './fixedsizebinary';\nexport { FixedSizeListVector } from './fixedsizelist';\nexport { FloatVector, Float16Vector, Float32Vector, Float64Vector } from './float';\nexport { IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector } from './interval';\nexport { IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector } from './int';\nexport { ListVector } from './list';\nexport { MapVector } from './map';\nexport { NullVector } from './null';\nexport { StructVector } from './struct';\nexport { TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector } from './timestamp';\nexport { TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector } from './time';\nexport { UnionVector, DenseUnionVector, SparseUnionVector } from './union';\nexport { Utf8Vector } from './utf8';\nexport { MapRow, StructRow } from './row';\n\nimport * as fn from '../util/fn';\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { setBool } from '../util/bit';\nimport { isIterable, isAsyncIterable } from '../util/compat';\nimport { Builder, IterableBuilderOptions } from '../builder';\nimport { VectorType as V, VectorCtorArgs } from '../interfaces';\nimport { instance as getVisitor } from '../visitor/get';\nimport { instance as setVisitor } from '../visitor/set';\nimport { instance as indexOfVisitor } from '../visitor/indexof';\nimport { instance as toArrayVisitor } from '../visitor/toarray';\nimport { instance as iteratorVisitor } from '../visitor/iterator';\nimport { instance as byteWidthVisitor } from '../visitor/bytewidth';\nimport { instance as getVectorConstructor } from '../visitor/vectorctor';\n\ndeclare module '../vector' {\n    namespace Vector {\n        export { newVector as new };\n        export { vectorFrom as from };\n    }\n}\n\ndeclare module './base' {\n    namespace BaseVector {\n        export { vectorFrom as from };\n    }\n    interface BaseVector<T extends DataType> {\n        get(index: number): T['TValue'] | null;\n        set(index: number, value: T['TValue'] | null): void;\n        indexOf(value: T['TValue'] | null, fromIndex?: number): number;\n        toArray(): T['TArray'];\n        getByteWidth(): number;\n        [Symbol.iterator](): IterableIterator<T['TValue'] | null>;\n    }\n}\n\n/** @nocollapse */\nVector.new = newVector;\n\n/** @nocollapse */\nVector.from = vectorFrom;\n\n/** @ignore */\nfunction newVector<T extends DataType>(data: Data<T>, ...args: VectorCtorArgs<V<T>>): V<T> {\n    return new (getVectorConstructor.getVisitFn<T>(data)())(data, ...args) as V<T>;\n}\n\n/** @ignore */\nexport interface VectorBuilderOptions<T extends DataType, TNull = any> extends IterableBuilderOptions<T, TNull> { values: Iterable<T['TValue'] | TNull>; }\n/** @ignore */\nexport interface VectorBuilderOptionsAsync<T extends DataType, TNull = any> extends IterableBuilderOptions<T, TNull> { values: AsyncIterable<T['TValue'] | TNull>; }\n\n/** @ignore */\nexport function vectorFromValuesWithType<T extends DataType, TNull = any>(newDataType: () => T, input: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull> | VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>) {\n    if (isIterable(input)) {\n        return Vector.from({ 'nullValues': [null, undefined], type: newDataType(), 'values': input }) as V<T>;\n    } else if (isAsyncIterable(input)) {\n        return Vector.from({ 'nullValues': [null, undefined], type: newDataType(), 'values': input }) as Promise<V<T>>;\n    }\n    const {\n        'values': values = [],\n        'type': type = newDataType(),\n        'nullValues': nullValues = [null, undefined],\n    } = { ...input };\n    return isIterable(values)\n        ? Vector.from({ nullValues, ...input, type } as VectorBuilderOptions<T, TNull>)\n        : Vector.from({ nullValues, ...input, type } as VectorBuilderOptionsAsync<T, TNull>);\n}\n\n/** @ignore */\nfunction vectorFrom<T extends DataType = any, TNull = any>(input: VectorBuilderOptions<T, TNull>): Vector<T>;\nfunction vectorFrom<T extends DataType = any, TNull = any>(input: VectorBuilderOptionsAsync<T, TNull>): Promise<Vector<T>>;\nfunction vectorFrom<T extends DataType = any, TNull = any>(input: VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>) {\n    const { 'values': values = [], ...options } = { 'nullValues': [null, undefined], ...input } as VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>;\n    if (isIterable<T['TValue'] | TNull>(values)) {\n        const chunks = [...Builder.throughIterable(options)(values)];\n        return chunks.length === 1 ? chunks[0] : Chunked.concat<T>(chunks);\n    }\n    return (async (chunks: V<T>[]) => {\n        const transform = Builder.throughAsyncIterable(options);\n        for await (const chunk of transform(values)) {\n            chunks.push(chunk);\n        }\n        return chunks.length === 1 ? chunks[0] : Chunked.concat<T>(chunks);\n    })([]);\n}\n\n//\n// We provide the following method implementations for code navigability purposes only.\n// They're overridden at runtime below with the specific Visitor implementation for each type,\n// short-circuiting the usual Visitor traversal and reducing intermediate lookups and calls.\n// This comment is here to remind you to not set breakpoints in these function bodies, or to inform\n// you why the breakpoints you have already set are not being triggered. Have a great day!\n//\n\nBaseVector.prototype.get = function baseVectorGet<T extends DataType>(this: BaseVector<T>, index: number): T['TValue'] | null {\n    return getVisitor.visit(this, index);\n};\n\nBaseVector.prototype.set = function baseVectorSet<T extends DataType>(this: BaseVector<T>, index: number, value: T['TValue'] | null): void {\n    return setVisitor.visit(this, index, value);\n};\n\nBaseVector.prototype.indexOf = function baseVectorIndexOf<T extends DataType>(this: BaseVector<T>, value: T['TValue'] | null, fromIndex?: number): number {\n    return indexOfVisitor.visit(this, value, fromIndex);\n};\n\nBaseVector.prototype.toArray = function baseVectorToArray<T extends DataType>(this: BaseVector<T>): T['TArray'] {\n    return toArrayVisitor.visit(this);\n};\n\nBaseVector.prototype.getByteWidth = function baseVectorGetByteWidth<T extends DataType>(this: BaseVector<T>): number {\n    return byteWidthVisitor.visit(this.type);\n};\n\nBaseVector.prototype[Symbol.iterator] = function baseVectorSymbolIterator<T extends DataType>(this: BaseVector<T>): IterableIterator<T['TValue'] | null> {\n    return iteratorVisitor.visit(this);\n};\n\n(BaseVector.prototype as any)._bindDataAccessors = bindBaseVectorDataAccessors;\n\n// Perf: bind and assign the operator Visitor methods to each of the Vector subclasses for each Type\n(Object.keys(Type) as any[])\n    .map((T: any) => Type[T] as any)\n    .filter((T: any): T is Type => typeof T === 'number')\n    .filter((typeId) => typeId !== Type.NONE)\n    .forEach((typeId) => {\n        const VectorCtor = getVectorConstructor.visit(typeId);\n        VectorCtor.prototype['get'] = fn.partial1(getVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['set'] = fn.partial2(setVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['indexOf'] = fn.partial2(indexOfVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['toArray'] = fn.partial0(toArrayVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['getByteWidth'] = partialType0(byteWidthVisitor.getVisitFn(typeId));\n        VectorCtor.prototype[Symbol.iterator] = fn.partial0(iteratorVisitor.getVisitFn(typeId));\n    });\n\n/** @ignore */\nfunction partialType0<T extends Vector>(visit: (node: T['type']) => any) {\n    return function(this: T) { return visit(this.type); };\n}\n\n/** @ignore */\nfunction wrapNullableGet<T extends DataType, V extends Vector<T>, F extends (i: number) => any>(fn: F): (...args: Parameters<F>) => ReturnType<F> {\n    return function(this: V, i: number) { return this.isValid(i) ? fn.call(this, i) : null; };\n}\n\n/** @ignore */\nfunction wrapNullableSet<T extends DataType, V extends BaseVector<T>, F extends (i: number, a: any) => void>(fn: F): (...args: Parameters<F>) => void {\n    return function(this: V, i: number, a: any) {\n        if (setBool(this.nullBitmap, this.offset + i, !(a === null || a === undefined))) {\n            fn.call(this, i, a);\n        }\n    };\n}\n\n/** @ignore */\nfunction bindBaseVectorDataAccessors<T extends DataType>(this: BaseVector<T>) {\n    const nullBitmap = this.nullBitmap;\n    if (nullBitmap && nullBitmap.byteLength > 0) {\n        this.get = wrapNullableGet(this.get);\n        this.set = wrapNullableSet(this.set);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Column } from './column';\nimport { Schema, Field } from './schema';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from './recordbatch';\nimport { DataFrame } from './compute/dataframe';\nimport { RecordBatchReader } from './ipc/reader';\nimport { DataType, RowLike, Struct } from './type';\nimport { selectColumnArgs, selectArgs } from './util/args';\nimport { Clonable, Sliceable, Applicative } from './vector';\nimport { isPromise, isIterable, isAsyncIterable } from './util/compat';\nimport { RecordBatchFileWriter, RecordBatchStreamWriter } from './ipc/writer';\nimport { distributeColumnsIntoRecordBatches, distributeVectorsIntoRecordBatches } from './util/recordbatch';\nimport { Vector, Chunked, StructVector, VectorBuilderOptions, VectorBuilderOptionsAsync } from './vector/index';\n\ntype VectorMap = { [key: string]: Vector };\ntype Fields<T extends { [key: string]: DataType }> = (keyof T)[] | Field<T[keyof T]>[];\ntype ChildData<T extends { [key: string]: DataType }> = Data<T[keyof T]>[] | Vector<T[keyof T]>[];\ntype Columns<T extends { [key: string]: DataType }> = Column<T[keyof T]>[] | Column<T[keyof T]>[][];\n\nexport interface Table<T extends { [key: string]: DataType } = any> {\n\n    get(index: number): Struct<T>['TValue'];\n    [Symbol.iterator](): IterableIterator<RowLike<T>>;\n\n    slice(begin?: number, end?: number): Table<T>;\n    concat(...others: Vector<Struct<T>>[]): Table<T>;\n    clone(chunks?: RecordBatch<T>[], offsets?: Uint32Array): Table<T>;\n\n    scan(next: import('./compute/dataframe').NextFunc, bind?: import('./compute/dataframe').BindFunc): void;\n    scanReverse(next: import('./compute/dataframe').NextFunc, bind?: import('./compute/dataframe').BindFunc): void;\n    countBy(name: import('./compute/predicate').Col | string): import('./compute/dataframe').CountByResult;\n    filter(predicate: import('./compute/predicate').Predicate): import('./compute/dataframe').FilteredDataFrame<T>;\n}\n\nexport class Table<T extends { [key: string]: DataType } = any>\n    extends Chunked<Struct<T>>\n    implements DataFrame<T>,\n               Clonable<Table<T>>,\n               Sliceable<Table<T>>,\n               Applicative<Struct<T>, Table<T>> {\n\n    /** @nocollapse */\n    public static empty<T extends { [key: string]: DataType } = {}>(schema = new Schema<T>([])) { return new Table<T>(schema, []); }\n\n    public static from(): Table<{}>;\n    public static from<T extends { [key: string]: DataType } = any>(source: RecordBatchReader<T>): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg0): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg2): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg1): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg3): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg4): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg5): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: PromiseLike<RecordBatchReader<T>>): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptions<Struct<T>, TNull>): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptionsAsync<Struct<T>, TNull>): Promise<Table<T>>;\n    /** @nocollapse */\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(input?: any) {\n\n        if (!input) { return Table.empty(); }\n\n        if (typeof input === 'object') {\n            let table = isIterable(input['values']) ? tableFromIterable<T, TNull>(input)\n                 : isAsyncIterable(input['values']) ? tableFromAsyncIterable<T, TNull>(input)\n                                                    : null;\n            if (table !== null) { return table; }\n        }\n\n        let reader = RecordBatchReader.from<T>(input) as RecordBatchReader<T> | Promise<RecordBatchReader<T>>;\n\n        if (isPromise<RecordBatchReader<T>>(reader)) {\n            return (async () => await Table.from(await reader))();\n        }\n        if (reader.isSync() && (reader = reader.open())) {\n            return !reader.schema ? Table.empty() : new Table<T>(reader.schema, [...reader]);\n        }\n        return (async (opening) => {\n            const reader = await opening;\n            const schema = reader.schema;\n            const batches: RecordBatch[] = [];\n            if (schema) {\n                for await (let batch of reader) {\n                    batches.push(batch);\n                }\n                return new Table<T>(schema, batches);\n            }\n            return Table.empty();\n        })(reader.open());\n    }\n\n    /** @nocollapse */\n    public static async fromAsync<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArgs): Promise<Table<T>> {\n        return await Table.from<T>(source as any);\n    }\n\n    /** @nocollapse */\n    public static fromStruct<T extends { [key: string]: DataType } = any>(vector: Vector<Struct<T>>) {\n        return Table.new<T>(vector.data.childData as Data<T[keyof T]>[], vector.type.children);\n    }\n\n    /**\n     * @summary Create a new Table from a collection of Columns or Vectors,\n     * with an optional list of names or Fields.\n     *\n     *\n     * `Table.new` accepts an Object of\n     * Columns or Vectors, where the keys will be used as the field names\n     * for the Schema:\n     * ```ts\n     * const i32s = Int32Vector.from([1, 2, 3]);\n     * const f32s = Float32Vector.from([.1, .2, .3]);\n     * const table = Table.new({ i32: i32s, f32: f32s });\n     * assert(table.schema.fields[0].name === 'i32');\n     * ```\n     *\n     * It also accepts a a list of Vectors with an optional list of names or\n     * Fields for the resulting Schema. If the list is omitted or a name is\n     * missing, the numeric index of each Vector will be used as the name:\n     * ```ts\n     * const i32s = Int32Vector.from([1, 2, 3]);\n     * const f32s = Float32Vector.from([.1, .2, .3]);\n     * const table = Table.new([i32s, f32s], ['i32']);\n     * assert(table.schema.fields[0].name === 'i32');\n     * assert(table.schema.fields[1].name === '1');\n     * ```\n     *\n     * If the supplied arguments are Columns, `Table.new` will infer the Schema\n     * from the Columns:\n     * ```ts\n     * const i32s = Column.new('i32', Int32Vector.from([1, 2, 3]));\n     * const f32s = Column.new('f32', Float32Vector.from([.1, .2, .3]));\n     * const table = Table.new(i32s, f32s);\n     * assert(table.schema.fields[0].name === 'i32');\n     * assert(table.schema.fields[1].name === 'f32');\n     * ```\n     *\n     * If the supplied Vector or Column lengths are unequal, `Table.new` will\n     * extend the lengths of the shorter Columns, allocating additional bytes\n     * to represent the additional null slots. The memory required to allocate\n     * these additional bitmaps can be computed as:\n     * ```ts\n     * let additionalBytes = 0;\n     * for (let vec in shorter_vectors) {\n     *     additionalBytes += (((longestLength - vec.length) + 63) & ~63) >> 3;\n     * }\n     * ```\n     *\n     * For example, an additional null bitmap for one million null values would require\n     * 125,000 bytes (`((1e6 + 63) & ~63) >> 3`), or approx. `0.11MiB`\n     */\n    public static new<T extends { [key: string]: DataType } = any>(...columns: Columns<T>): Table<T>;\n    public static new<T extends VectorMap = any>(children: T): Table<{ [P in keyof T]: T[P]['type'] }>;\n    public static new<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): Table<T>;\n    /** @nocollapse */\n    public static new(...cols: any[]) {\n        return new Table(...distributeColumnsIntoRecordBatches(selectColumnArgs(cols)));\n    }\n\n    constructor(batches: RecordBatch<T>[]);\n    constructor(...batches: RecordBatch<T>[]);\n    constructor(schema: Schema<T>, batches: RecordBatch<T>[]);\n    constructor(schema: Schema<T>, ...batches: RecordBatch<T>[]);\n    constructor(...args: any[]) {\n\n        let schema: Schema<T> = null!;\n\n        if (args[0] instanceof Schema) { schema = args.shift(); }\n\n        let chunks = selectArgs<RecordBatch<T>>(RecordBatch, args);\n\n        if (!schema && !(schema = chunks[0] && chunks[0].schema)) {\n            throw new TypeError('Table must be initialized with a Schema or at least one RecordBatch');\n        }\n\n        chunks[0] || (chunks[0] = new _InternalEmptyPlaceholderRecordBatch(schema));\n\n        super(new Struct(schema.fields), chunks);\n\n        this._schema = schema;\n        this._chunks = chunks;\n    }\n\n    protected _schema: Schema<T>;\n    // List of inner RecordBatches\n    protected _chunks: RecordBatch<T>[];\n    protected _children?: Column<T[keyof T]>[];\n\n    public get schema() { return this._schema; }\n    public get length() { return this._length; }\n    public get chunks() { return this._chunks; }\n    public get numCols() { return this._numChildren; }\n\n    public clone(chunks = this._chunks) {\n        return new Table<T>(this._schema, chunks);\n    }\n\n    public getColumn<R extends keyof T>(name: R): Column<T[R]> {\n        return this.getColumnAt(this.getColumnIndex(name)) as Column<T[R]>;\n    }\n    public getColumnAt<R extends DataType = any>(index: number): Column<R> | null {\n        return this.getChildAt(index);\n    }\n    public getColumnIndex<R extends keyof T>(name: R) {\n        return this._schema.fields.findIndex((f) => f.name === name);\n    }\n    public getChildAt<R extends DataType = any>(index: number): Column<R> | null {\n        if (index < 0 || index >= this.numChildren) { return null; }\n        let field: Field<R>, child: Column<R>;\n        const fields = (this._schema as Schema<any>).fields;\n        const columns = this._children || (this._children = []) as Column[];\n        if (child = columns[index]) { return child as Column<R>; }\n        if (field = fields[index]) {\n            const chunks = this._chunks\n                .map((chunk) => chunk.getChildAt<R>(index))\n                .filter((vec): vec is Vector<R> => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Column<R>(field, chunks));\n            }\n        }\n        return null;\n    }\n\n    // @ts-ignore\n    public serialize(encoding = 'binary', stream = true) {\n        const Writer = !stream\n            ? RecordBatchFileWriter\n            : RecordBatchStreamWriter;\n        return Writer.writeAll(this).toUint8Array(true);\n    }\n    public count(): number {\n        return this._length;\n    }\n    public select<K extends keyof T = any>(...columnNames: K[]) {\n        const nameToIndex = this._schema.fields.reduce((m, f, i) => m.set(f.name as K, i), new Map<K, number>());\n        return this.selectAt(...columnNames.map((columnName) => nameToIndex.get(columnName)!).filter((x) => x > -1));\n    }\n    public selectAt<K extends T[keyof T] = any>(...columnIndices: number[]) {\n        const schema = this._schema.selectAt<K>(...columnIndices);\n        return new Table(schema, this._chunks.map(({ length, data: { childData } }) => {\n            return new RecordBatch(schema, length, columnIndices.map((i) => childData[i]).filter(Boolean));\n        }));\n    }\n    public assign<R extends { [key: string]: DataType } = any>(other: Table<R>) {\n\n        const fields = this._schema.fields;\n        const [indices, oldToNew] = other.schema.fields.reduce((memo, f2, newIdx) => {\n            const [indices, oldToNew] = memo;\n            const i = fields.findIndex((f) => f.name === f2.name);\n            ~i ? (oldToNew[i] = newIdx) : indices.push(newIdx);\n            return memo;\n        }, [[], []] as number[][]);\n\n        const schema = this._schema.assign(other.schema);\n        const columns = [\n            ...fields.map((_f, i, _fs, j = oldToNew[i]) =>\n                (j === undefined ? this.getColumnAt(i) : other.getColumnAt(j))!),\n            ...indices.map((i) => other.getColumnAt(i)!)\n        ].filter(Boolean) as Column<(T & R)[keyof T | keyof R]>[];\n\n        return new Table<T & R>(...distributeVectorsIntoRecordBatches<any>(schema, columns));\n    }\n}\n\nfunction tableFromIterable<T extends { [key: string]: DataType } = any, TNull = any>(input: VectorBuilderOptions<Struct<T>, TNull>) {\n    const { type } = input;\n    if (type instanceof Struct) {\n        return Table.fromStruct(StructVector.from(input as VectorBuilderOptions<Struct<T>, TNull>));\n    }\n    return null;\n}\n\nfunction tableFromAsyncIterable<T extends { [key: string]: DataType } = any, TNull = any>(input: VectorBuilderOptionsAsync<Struct<T>, TNull>) {\n    const { type } = input;\n    if (type instanceof Struct) {\n        return StructVector.from(input as VectorBuilderOptionsAsync<Struct<T>, TNull>).then((vector) => Table.fromStruct(vector));\n    }\n    return null;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Table } from './table';\nimport { Vector } from './vector';\nimport { Visitor } from './visitor';\nimport { Schema, Field } from './schema';\nimport { isIterable } from './util/compat';\nimport { Chunked } from './vector/chunked';\nimport { selectFieldArgs } from './util/args';\nimport { DataType, Struct, Dictionary } from './type';\nimport { ensureSameLengthData } from './util/recordbatch';\nimport { Clonable, Sliceable, Applicative } from './vector';\nimport { StructVector, VectorBuilderOptions, VectorBuilderOptionsAsync } from './vector/index';\n\ntype VectorMap = { [key: string]: Vector };\ntype Fields<T extends { [key: string]: DataType }> = (keyof T)[] | Field<T[keyof T]>[];\ntype ChildData<T extends { [key: string]: DataType }> = (Data<T[keyof T]> | Vector<T[keyof T]>)[];\n\nexport interface RecordBatch<T extends { [key: string]: DataType } = any> {\n    concat(...others: Vector<Struct<T>>[]): Table<T>;\n    slice(begin?: number, end?: number): RecordBatch<T>;\n    clone(data: Data<Struct<T>>, children?: Vector[]): RecordBatch<T>;\n}\n\nexport class RecordBatch<T extends { [key: string]: DataType } = any>\n    extends StructVector<T>\n    implements Clonable<RecordBatch<T>>,\n               Sliceable<RecordBatch<T>>,\n               Applicative<Struct<T>, Table<T>> {\n\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptions<Struct<T>, TNull>): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptionsAsync<Struct<T>, TNull>): Promise<Table<T>>;\n    /** @nocollapse */\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptions<Struct<T>, TNull> | VectorBuilderOptionsAsync<Struct<T>, TNull>) {\n        if (isIterable<(Struct<T>)['TValue'] | TNull>(options['values'])) {\n            return Table.from(options as VectorBuilderOptions<Struct<T>, TNull>);\n        }\n        return Table.from(options as VectorBuilderOptionsAsync<Struct<T>, TNull>);\n    }\n\n    public static new<T extends VectorMap = any>(children: T): RecordBatch<{ [P in keyof T]: T[P]['type'] }>;\n    public static new<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): RecordBatch<T>;\n    /** @nocollapse */\n    public static new<T extends { [key: string]: DataType } = any>(...args: any[]) {\n        const [fs, xs] = selectFieldArgs<T>(args);\n        const vs = xs.filter((x): x is Vector<T[keyof T]> => x instanceof Vector);\n        return new RecordBatch(...ensureSameLengthData(new Schema<T>(fs), vs.map((x) => x.data)));\n    }\n\n    protected _schema: Schema;\n    protected _dictionaries?: Map<number, Vector>;\n\n    constructor(schema: Schema<T>, length: number, children: (Data | Vector)[]);\n    constructor(schema: Schema<T>, data: Data<Struct<T>>, children?: Vector[]);\n    constructor(...args: any[]) {\n        let data: Data<Struct<T>>;\n        let schema = args[0] as Schema<T>;\n        let children: Vector[] | undefined;\n        if (args[1] instanceof Data) {\n            [, data, children] = (args as [any, Data<Struct<T>>, Vector<T[keyof T]>[]?]);\n        } else {\n            const fields = schema.fields as Field<T[keyof T]>[];\n            const [, length, childData] = args as [any, number, Data<T[keyof T]>[]];\n            data = Data.Struct(new Struct<T>(fields), 0, length, 0, null, childData);\n        }\n        super(data, children);\n        this._schema = schema;\n    }\n\n    public clone(data: Data<Struct<T>>, children = this._children) {\n        return new RecordBatch<T>(this._schema, data, children);\n    }\n\n    public concat(...others: Vector<Struct<T>>[]): Table<T> {\n        const schema = this._schema, chunks = Chunked.flatten(this, ...others);\n        return new Table(schema, chunks.map(({ data }) => new RecordBatch(schema, data)));\n    }\n\n    public get schema() { return this._schema; }\n    public get numCols() { return this._schema.fields.length; }\n    public get dictionaries() {\n        return this._dictionaries || (this._dictionaries = DictionaryCollector.collect(this));\n    }\n\n    public select<K extends keyof T = any>(...columnNames: K[]) {\n        const nameToIndex = this._schema.fields.reduce((m, f, i) => m.set(f.name as K, i), new Map<K, number>());\n        return this.selectAt(...columnNames.map((columnName) => nameToIndex.get(columnName)!).filter((x) => x > -1));\n    }\n    public selectAt<K extends T[keyof T] = any>(...columnIndices: number[]) {\n        const schema = this._schema.selectAt(...columnIndices);\n        const childData = columnIndices.map((i) => this.data.childData[i]).filter(Boolean);\n        return new RecordBatch<{ [key: string]: K }>(schema, this.length, childData);\n    }\n}\n\n/**\n * An internal class used by the `RecordBatchReader` and `RecordBatchWriter`\n * implementations to differentiate between a stream with valid zero-length\n * RecordBatches, and a stream with a Schema message, but no RecordBatches.\n * @see https://github.com/apache/arrow/pull/4373\n * @ignore\n * @private\n */\n/* tslint:disable:class-name */\nexport class _InternalEmptyPlaceholderRecordBatch<T extends { [key: string]: DataType } = any> extends RecordBatch<T> {\n    constructor(schema: Schema<T>) {\n        super(schema, 0, schema.fields.map((f) => Data.new(f.type, 0, 0, 0)));\n    }\n}\n\n/** @ignore */\nclass DictionaryCollector extends Visitor {\n    public dictionaries = new Map<number, Vector>();\n    public static collect<T extends RecordBatch>(batch: T) {\n        return new DictionaryCollector().visit(\n            batch.data, new Struct(batch.schema.fields)\n        ).dictionaries;\n    }\n    public visit(data: Data, type: DataType) {\n        if (DataType.isDictionary(type)) {\n            return this.visitDictionary(data, type);\n        } else {\n            data.childData.forEach((child, i) =>\n                this.visit(child, type.children[i].type));\n        }\n        return this;\n    }\n    public visitDictionary(data: Data, type: Dictionary) {\n        const dictionary = data.dictionary;\n        if (dictionary && dictionary.length > 0) {\n            this.dictionaries.set(type.id, dictionary);\n        }\n        return this;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { MessageHeader } from '../enum';\nimport { Footer } from './metadata/file';\nimport { Schema, Field } from '../schema';\nimport streamAdapters from '../io/adapters';\nimport { Message } from './metadata/message';\nimport * as metadata from './metadata/message';\nimport { ArrayBufferViewInput } from '../util/buffer';\nimport { ByteStream, AsyncByteStream } from '../io/stream';\nimport { RandomAccessFile, AsyncRandomAccessFile } from '../io/file';\nimport { VectorLoader, JSONVectorLoader } from '../visitor/vectorloader';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from '../recordbatch';\nimport {\n    FileHandle,\n    ArrowJSONLike,\n    ITERATOR_DONE,\n    ReadableInterop,\n} from '../io/interfaces';\nimport {\n    MessageReader, AsyncMessageReader, JSONMessageReader,\n    checkForMagicArrowString, magicLength, magicAndPadding, magicX2AndPadding\n} from './message';\nimport {\n    isPromise,\n    isIterable, isAsyncIterable,\n    isIteratorResult, isArrowJSON,\n    isFileHandle, isFetchResponse,\n    isReadableDOMStream, isReadableNodeStream\n} from '../util/compat';\n\n/** @ignore */ export type FromArg0 = ArrowJSONLike;\n/** @ignore */ export type FromArg1 = PromiseLike<ArrowJSONLike>;\n/** @ignore */ export type FromArg2 = Iterable<ArrayBufferViewInput> | ArrayBufferViewInput;\n/** @ignore */ export type FromArg3 = PromiseLike<Iterable<ArrayBufferViewInput> | ArrayBufferViewInput>;\n/** @ignore */ export type FromArg4 = Response | NodeJS.ReadableStream | ReadableStream<ArrayBufferViewInput> | AsyncIterable<ArrayBufferViewInput>;\n/** @ignore */ export type FromArg5 = FileHandle | PromiseLike<FileHandle> | PromiseLike<FromArg4>;\n/** @ignore */ export type FromArgs = FromArg0 | FromArg1 | FromArg2 | FromArg3 | FromArg4 | FromArg5;\n\n/** @ignore */ type OpenOptions = { autoDestroy?: boolean; };\n/** @ignore */ type RecordBatchReaders<T extends { [key: string]: DataType } = any> = RecordBatchFileReader<T> | RecordBatchStreamReader<T>;\n/** @ignore */ type AsyncRecordBatchReaders<T extends { [key: string]: DataType } = any> = AsyncRecordBatchFileReader<T> | AsyncRecordBatchStreamReader<T>;\n/** @ignore */ type RecordBatchFileReaders<T extends { [key: string]: DataType } = any> = RecordBatchFileReader<T> | AsyncRecordBatchFileReader<T>;\n/** @ignore */ type RecordBatchStreamReaders<T extends { [key: string]: DataType } = any> = RecordBatchStreamReader<T> | AsyncRecordBatchStreamReader<T>;\n\nexport class RecordBatchReader<T extends { [key: string]: DataType } = any> extends ReadableInterop<RecordBatch<T>> {\n\n    protected _impl: RecordBatchReaderImpls<T>;\n    protected constructor(impl: RecordBatchReaderImpls<T>) {\n        super();\n        this._impl = impl;\n    }\n\n    public get closed() { return this._impl.closed; }\n    public get schema() { return this._impl.schema; }\n    public get autoDestroy() { return this._impl.autoDestroy; }\n    public get dictionaries() { return this._impl.dictionaries; }\n    public get numDictionaries() { return this._impl.numDictionaries; }\n    public get numRecordBatches() { return this._impl.numRecordBatches; }\n    public get footer() { return this._impl.isFile() ? this._impl.footer : null; }\n\n    public isSync(): this is RecordBatchReaders<T> { return this._impl.isSync(); }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return this._impl.isAsync(); }\n    public isFile(): this is RecordBatchFileReaders<T> { return this._impl.isFile(); }\n    public isStream(): this is RecordBatchStreamReaders<T> { return this._impl.isStream(); }\n\n    public next() {\n        return this._impl.next();\n    }\n    public throw(value?: any) {\n        return this._impl.throw(value);\n    }\n    public return(value?: any) {\n        return this._impl.return(value);\n    }\n    public cancel() {\n        return this._impl.cancel();\n    }\n    public reset(schema?: Schema<T> | null): this {\n        this._impl.reset(schema);\n        this._DOMStream = undefined;\n        this._nodeStream = undefined;\n        return this;\n    }\n    public open(options?: OpenOptions) {\n        const opening = this._impl.open(options);\n        return isPromise(opening) ? opening.then(() => this) : this;\n    }\n    public readRecordBatch(index: number): RecordBatch<T> | null | Promise<RecordBatch<T> | null> {\n        return this._impl.isFile() ? this._impl.readRecordBatch(index) : null;\n    }\n    public [Symbol.iterator](): IterableIterator<RecordBatch<T>> {\n        return (<IterableIterator<RecordBatch<T>>> this._impl)[Symbol.iterator]();\n    }\n    public [Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>> {\n        return (<AsyncIterableIterator<RecordBatch<T>>> this._impl)[Symbol.asyncIterator]();\n    }\n    public toDOMStream() {\n        return streamAdapters.toDOMStream<RecordBatch<T>>(\n            (this.isSync()\n                ? { [Symbol.iterator]: () => this } as Iterable<RecordBatch<T>>\n                : { [Symbol.asyncIterator]: () => this } as AsyncIterable<RecordBatch<T>>));\n    }\n    public toNodeStream() {\n        return streamAdapters.toNodeStream<RecordBatch<T>>(\n            (this.isSync()\n                ? { [Symbol.iterator]: () => this } as Iterable<RecordBatch<T>>\n                : { [Symbol.asyncIterator]: () => this } as AsyncIterable<RecordBatch<T>>),\n            { objectMode: true });\n    }\n\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughNode(options?: import('stream').DuplexOptions & { autoDestroy: boolean }): import('stream').Duplex {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    public static throughDOM<T extends { [key: string]: DataType }>(\n        // @ts-ignore\n        writableStrategy?: ByteLengthQueuingStrategy,\n        // @ts-ignore\n        readableStrategy?: { autoDestroy: boolean }\n    ): { writable: WritableStream<Uint8Array>, readable: ReadableStream<RecordBatch<T>> } {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n\n    public static from<T extends RecordBatchReader>(source: T): T;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg0): RecordBatchStreamReader<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg1): Promise<RecordBatchStreamReader<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg2): RecordBatchFileReader<T> | RecordBatchStreamReader<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg3): Promise<RecordBatchFileReader<T> | RecordBatchStreamReader<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg4): Promise<RecordBatchFileReader<T> | AsyncRecordBatchReaders<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg5): Promise<AsyncRecordBatchFileReader<T> | AsyncRecordBatchStreamReader<T>>;\n    /** @nocollapse */\n    public static from<T extends { [key: string]: DataType } = any>(source: any) {\n        if (source instanceof RecordBatchReader) {\n            return source;\n        } else if (isArrowJSON(source)) {\n            return fromArrowJSON<T>(source);\n        } else if (isFileHandle(source)) {\n            return fromFileHandle<T>(source);\n        } else if (isPromise<any>(source)) {\n            return (async () => await RecordBatchReader.from<any>(await source))();\n        } else if (isFetchResponse(source) || isReadableDOMStream(source) || isReadableNodeStream(source) || isAsyncIterable(source)) {\n            return fromAsyncByteStream<T>(new AsyncByteStream(source));\n        }\n        return fromByteStream<T>(new ByteStream(source));\n    }\n\n    public static readAll<T extends RecordBatchReader>(source: T): T extends RecordBatchReaders ? IterableIterator<T> : AsyncIterableIterator<T>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg0): IterableIterator<RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg1): AsyncIterableIterator<RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg2): IterableIterator<RecordBatchFileReader<T> | RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg3): AsyncIterableIterator<RecordBatchFileReader<T> | RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg4): AsyncIterableIterator<RecordBatchFileReader<T> | AsyncRecordBatchReaders<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg5): AsyncIterableIterator<AsyncRecordBatchFileReader<T> | AsyncRecordBatchStreamReader<T>>;\n    /** @nocollapse */\n    public static readAll<T extends { [key: string]: DataType } = any>(source: any) {\n        if (source instanceof RecordBatchReader) {\n            return source.isSync() ? readAllSync(source) : readAllAsync(source as AsyncRecordBatchReaders<T>);\n        } else if (isArrowJSON(source) || ArrayBuffer.isView(source) || isIterable<ArrayBufferViewInput>(source) || isIteratorResult(source)) {\n            return readAllSync<T>(source) as IterableIterator<RecordBatchReaders<T>>;\n        }\n        return readAllAsync<T>(source) as AsyncIterableIterator<RecordBatchReaders<T> | AsyncRecordBatchReaders<T>>;\n    }\n}\n\n//\n// Since TS is a structural type system, we define the following subclass stubs\n// so that concrete types exist to associate with with the interfaces below.\n//\n// The implementation for each RecordBatchReader is hidden away in the set of\n// `RecordBatchReaderImpl` classes in the second half of this file. This allows\n// us to export a single RecordBatchReader class, and swap out the impl based\n// on the io primitives or underlying arrow (JSON, file, or stream) at runtime.\n//\n// Async/await makes our job a bit harder, since it forces everything to be\n// either fully sync or fully async. This is why the logic for the reader impls\n// has been duplicated into both sync and async variants. Since the RBR\n// delegates to its impl, an RBR with an AsyncRecordBatchFileReaderImpl for\n// example will return async/await-friendly Promises, but one with a (sync)\n// RecordBatchStreamReaderImpl will always return values. Nothing should be\n// different about their logic, aside from the async handling. This is also why\n// this code looks highly structured, as it should be nearly identical and easy\n// to follow.\n//\n\n/** @ignore */\nexport class RecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    constructor(protected _impl: RecordBatchStreamReaderImpl<T>) { super (_impl); }\n    public [Symbol.iterator]() { return (this._impl as IterableIterator<RecordBatch<T>>)[Symbol.iterator](); }\n    public async *[Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>> { yield* this[Symbol.iterator](); }\n}\n/** @ignore */\nexport class AsyncRecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    constructor(protected _impl: AsyncRecordBatchStreamReaderImpl<T>) { super (_impl); }\n    public [Symbol.iterator](): IterableIterator<RecordBatch<T>> { throw new Error(`AsyncRecordBatchStreamReader is not Iterable`); }\n    public [Symbol.asyncIterator]() { return (this._impl as AsyncIterableIterator<RecordBatch<T>>)[Symbol.asyncIterator](); }\n}\n/** @ignore */\nexport class RecordBatchFileReader<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReader<T> {\n    constructor(protected _impl: RecordBatchFileReaderImpl<T>) { super (_impl); }\n}\n/** @ignore */\nexport class AsyncRecordBatchFileReader<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReader<T> {\n    constructor(protected _impl: AsyncRecordBatchFileReaderImpl<T>) { super (_impl); }\n}\n\n//\n// Now override the return types for each sync/async RecordBatchReader variant\n//\n\n/** @ignore */\nexport interface RecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    open(options?: OpenOptions | undefined): this;\n    cancel(): void;\n    throw(value?: any): IteratorResult<any>;\n    return(value?: any): IteratorResult<any>;\n    next(value?: any): IteratorResult<RecordBatch<T>>;\n}\n\n/** @ignore */\nexport interface AsyncRecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    open(options?: OpenOptions | undefined): Promise<this>;\n    cancel(): Promise<void>;\n    throw(value?: any): Promise<IteratorResult<any>>;\n    return(value?: any): Promise<IteratorResult<any>>;\n    next(value?: any): Promise<IteratorResult<RecordBatch<T>>>;\n}\n\n/** @ignore */\nexport interface RecordBatchFileReader<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReader<T> {\n    footer: Footer;\n    readRecordBatch(index: number): RecordBatch<T> | null;\n}\n\n/** @ignore */\nexport interface AsyncRecordBatchFileReader<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReader<T> {\n    footer: Footer;\n    readRecordBatch(index: number): Promise<RecordBatch<T> | null>;\n}\n\n/** @ignore */\ntype RecordBatchReaderImpls<T extends { [key: string]: DataType } = any> =\n     RecordBatchJSONReaderImpl<T> |\n     RecordBatchFileReaderImpl<T> |\n     RecordBatchStreamReaderImpl<T> |\n     AsyncRecordBatchFileReaderImpl<T> |\n     AsyncRecordBatchStreamReaderImpl<T>;\n\n/** @ignore */\ninterface RecordBatchReaderImpl<T extends { [key: string]: DataType } = any> {\n\n    closed: boolean;\n    schema: Schema<T>;\n    autoDestroy: boolean;\n    dictionaries: Map<number, Vector>;\n\n    isFile(): this is RecordBatchFileReaders<T>;\n    isStream(): this is RecordBatchStreamReaders<T>;\n    isSync(): this is RecordBatchReaders<T>;\n    isAsync(): this is AsyncRecordBatchReaders<T>;\n\n    reset(schema?: Schema<T> | null): this;\n}\n\n/** @ignore */\ninterface RecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> {\n\n    open(options?: OpenOptions): this;\n    cancel(): void;\n\n    throw(value?: any): IteratorResult<any>;\n    return(value?: any): IteratorResult<any>;\n    next(value?: any): IteratorResult<RecordBatch<T>>;\n\n    [Symbol.iterator](): IterableIterator<RecordBatch<T>>;\n}\n\n/** @ignore */\ninterface AsyncRecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> {\n\n    open(options?: OpenOptions): Promise<this>;\n    cancel(): Promise<void>;\n\n    throw(value?: any): Promise<IteratorResult<any>>;\n    return(value?: any): Promise<IteratorResult<any>>;\n    next(value?: any): Promise<IteratorResult<RecordBatch<T>>>;\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>>;\n}\n\n/** @ignore */\ninterface RecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReaderImpl<T> {\n    readRecordBatch(index: number): RecordBatch<T> | null;\n}\n\n/** @ignore */\ninterface AsyncRecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReaderImpl<T> {\n    readRecordBatch(index: number): Promise<RecordBatch<T> | null>;\n}\n\n/** @ignore */\nabstract class RecordBatchReaderImpl<T extends { [key: string]: DataType } = any> implements RecordBatchReaderImpl<T> {\n\n    // @ts-ignore\n    public schema: Schema;\n    public closed = false;\n    public autoDestroy = true;\n    public dictionaries: Map<number, Vector>;\n\n    protected _dictionaryIndex = 0;\n    protected _recordBatchIndex = 0;\n    public get numDictionaries() { return this._dictionaryIndex; }\n    public get numRecordBatches() { return this._recordBatchIndex; }\n\n    constructor(dictionaries = new Map<number, Vector>()) {\n        this.dictionaries = dictionaries;\n    }\n\n    public isSync(): this is RecordBatchReaders<T> { return false; }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return false; }\n    public isFile(): this is RecordBatchFileReaders<T> { return false; }\n    public isStream(): this is RecordBatchStreamReaders<T> { return false; }\n\n    public reset(schema?: Schema<T> | null) {\n        this._dictionaryIndex = 0;\n        this._recordBatchIndex = 0;\n        this.schema = <any> schema;\n        this.dictionaries = new Map();\n        return this;\n    }\n\n    protected _loadRecordBatch(header: metadata.RecordBatch, body: any) {\n        return new RecordBatch<T>(this.schema, header.length, this._loadVectors(header, body, this.schema.fields));\n    }\n    protected _loadDictionaryBatch(header: metadata.DictionaryBatch, body: any) {\n        const { id, isDelta, data } = header;\n        const { dictionaries, schema } = this;\n        const dictionary = dictionaries.get(id);\n        if (isDelta || !dictionary) {\n            const type = schema.dictionaries.get(id)!;\n            return (dictionary && isDelta ? dictionary.concat(\n                Vector.new(this._loadVectors(data, body, [type])[0])) :\n                Vector.new(this._loadVectors(data, body, [type])[0])) as Vector;\n        }\n        return dictionary;\n    }\n    protected _loadVectors(header: metadata.RecordBatch, body: any, types: (Field | DataType)[]) {\n        return new VectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);\n    }\n}\n\n/** @ignore */\nclass RecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> implements IterableIterator<RecordBatch<T>> {\n\n    protected _reader: MessageReader;\n    protected _handle: ByteStream | ArrowJSONLike;\n\n    constructor(source: ByteStream | ArrowJSONLike, dictionaries?: Map<number, Vector>) {\n        super(dictionaries);\n        this._reader = !isArrowJSON(source)\n            ? new MessageReader(this._handle = source)\n            : new JSONMessageReader(this._handle = source);\n    }\n\n    public isSync(): this is RecordBatchReaders<T> { return true; }\n    public isStream(): this is RecordBatchStreamReaders<T> { return true; }\n    public [Symbol.iterator](): IterableIterator<RecordBatch<T>> {\n        return this as IterableIterator<RecordBatch<T>>;\n    }\n    public cancel() {\n        if (!this.closed && (this.closed = true)) {\n            this.reset()._reader.return();\n            this._reader = <any> null;\n            this.dictionaries = <any> null;\n        }\n    }\n    public open(options?: OpenOptions) {\n        if (!this.closed) {\n            this.autoDestroy = shouldAutoDestroy(this, options);\n            if (!(this.schema || (this.schema = this._reader.readSchema()!))) {\n                this.cancel();\n            }\n        }\n        return this;\n    }\n    public throw(value?: any): IteratorResult<any> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return this.reset()._reader.throw(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public return(value?: any): IteratorResult<any> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return this.reset()._reader.return(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public next(): IteratorResult<RecordBatch<T>> {\n        if (this.closed) { return ITERATOR_DONE; }\n        let message: Message | null, { _reader: reader } = this;\n        while (message = this._readNextMessageAndValidate()) {\n            if (message.isSchema()) {\n                this.reset(message.header());\n            } else if (message.isRecordBatch()) {\n                this._recordBatchIndex++;\n                const header = message.header();\n                const buffer = reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return { done: false, value: recordBatch };\n            } else if (message.isDictionaryBatch()) {\n                this._dictionaryIndex++;\n                const header = message.header();\n                const buffer = reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n        if (this.schema && this._recordBatchIndex === 0) {\n            this._recordBatchIndex++;\n            return { done: false, value: new _InternalEmptyPlaceholderRecordBatch<T>(this.schema) };\n        }\n        return this.return();\n    }\n    protected _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null) {\n        return this._reader.readMessage<T>(type);\n    }\n}\n\n/** @ignore */\nclass AsyncRecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> implements AsyncIterableIterator<RecordBatch<T>> {\n\n    protected _handle: AsyncByteStream;\n    protected _reader: AsyncMessageReader;\n\n    constructor(source: AsyncByteStream, dictionaries?: Map<number, Vector>) {\n        super(dictionaries);\n        this._reader = new AsyncMessageReader(this._handle = source);\n    }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return true; }\n    public isStream(): this is RecordBatchStreamReaders<T> { return true; }\n    public [Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>> {\n        return this as AsyncIterableIterator<RecordBatch<T>>;\n    }\n    public async cancel() {\n        if (!this.closed && (this.closed = true)) {\n            await this.reset()._reader.return();\n            this._reader = <any> null;\n            this.dictionaries = <any> null;\n        }\n    }\n    public async open(options?: OpenOptions) {\n        if (!this.closed) {\n            this.autoDestroy = shouldAutoDestroy(this, options);\n            if (!(this.schema || (this.schema = (await this._reader.readSchema())!))) {\n                await this.cancel();\n            }\n        }\n        return this;\n    }\n    public async throw(value?: any): Promise<IteratorResult<any>> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return await this.reset()._reader.throw(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public async return(value?: any): Promise<IteratorResult<any>> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return await this.reset()._reader.return(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public async next() {\n        if (this.closed) { return ITERATOR_DONE; }\n        let message: Message | null, { _reader: reader } = this;\n        while (message = await this._readNextMessageAndValidate()) {\n            if (message.isSchema()) {\n                await this.reset(message.header());\n            } else if (message.isRecordBatch()) {\n                this._recordBatchIndex++;\n                const header = message.header();\n                const buffer = await reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return { done: false, value: recordBatch };\n            } else if (message.isDictionaryBatch()) {\n                this._dictionaryIndex++;\n                const header = message.header();\n                const buffer = await reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n        if (this.schema && this._recordBatchIndex === 0) {\n            this._recordBatchIndex++;\n            return { done: false, value: new _InternalEmptyPlaceholderRecordBatch<T>(this.schema) };\n        }\n        return await this.return();\n    }\n    protected async _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null) {\n        return await this._reader.readMessage<T>(type);\n    }\n}\n\n/** @ignore */\nclass RecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReaderImpl<T> {\n\n    // @ts-ignore\n    protected _footer?: Footer;\n    // @ts-ignore\n    protected _handle: RandomAccessFile;\n    public get footer() { return this._footer!; }\n    public get numDictionaries() { return this._footer ? this._footer.numDictionaries : 0; }\n    public get numRecordBatches() { return this._footer ? this._footer.numRecordBatches : 0; }\n\n    constructor(source: RandomAccessFile | ArrayBufferViewInput, dictionaries?: Map<number, Vector>) {\n        super(source instanceof RandomAccessFile ? source : new RandomAccessFile(source), dictionaries);\n    }\n    public isSync(): this is RecordBatchReaders<T> { return true; }\n    public isFile(): this is RecordBatchFileReaders<T> { return true; }\n    public open(options?: OpenOptions) {\n        if (!this.closed && !this._footer) {\n            this.schema = (this._footer = this._readFooter()).schema;\n            for (const block of this._footer.dictionaryBatches()) {\n                block && this._readDictionaryBatch(this._dictionaryIndex++);\n            }\n        }\n        return super.open(options);\n    }\n    public readRecordBatch(index: number) {\n        if (this.closed) { return null; }\n        if (!this._footer) { this.open(); }\n        const block = this._footer && this._footer.getRecordBatch(index);\n        if (block && this._handle.seek(block.offset)) {\n            const message = this._reader.readMessage(MessageHeader.RecordBatch);\n            if (message && message.isRecordBatch()) {\n                const header = message.header();\n                const buffer = this._reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return recordBatch;\n            }\n        }\n        return null;\n    }\n    protected _readDictionaryBatch(index: number) {\n        const block = this._footer && this._footer.getDictionaryBatch(index);\n        if (block && this._handle.seek(block.offset)) {\n            const message = this._reader.readMessage(MessageHeader.DictionaryBatch);\n            if (message && message.isDictionaryBatch()) {\n                const header = message.header();\n                const buffer = this._reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n    }\n    protected _readFooter() {\n        const { _handle } = this;\n        const offset = _handle.size - magicAndPadding;\n        const length = _handle.readInt32(offset);\n        const buffer = _handle.readAt(offset - length, length);\n        return Footer.decode(buffer);\n    }\n    protected _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null): Message<T> | null {\n        if (!this._footer) { this.open(); }\n        if (this._footer && this._recordBatchIndex < this.numRecordBatches) {\n            const block = this._footer && this._footer.getRecordBatch(this._recordBatchIndex);\n            if (block && this._handle.seek(block.offset)) {\n                return this._reader.readMessage(type);\n            }\n        }\n        return null;\n    }\n}\n\n/** @ignore */\nclass AsyncRecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReaderImpl<T>\n    implements AsyncRecordBatchFileReaderImpl<T> {\n\n    protected _footer?: Footer;\n    // @ts-ignore\n    protected _handle: AsyncRandomAccessFile;\n    public get footer() { return this._footer!; }\n    public get numDictionaries() { return this._footer ? this._footer.numDictionaries : 0; }\n    public get numRecordBatches() { return this._footer ? this._footer.numRecordBatches : 0; }\n\n    constructor(source: FileHandle, byteLength?: number, dictionaries?: Map<number, Vector>);\n    constructor(source: FileHandle | AsyncRandomAccessFile, dictionaries?: Map<number, Vector>);\n    constructor(source: FileHandle | AsyncRandomAccessFile, ...rest: any[]) {\n        const byteLength = typeof rest[0] !== 'number' ? <number> rest.shift() : undefined;\n        const dictionaries = rest[0] instanceof Map ? <Map<number, Vector>> rest.shift() : undefined;\n        super(source instanceof AsyncRandomAccessFile ? source : new AsyncRandomAccessFile(source, byteLength), dictionaries);\n    }\n    public isFile(): this is RecordBatchFileReaders<T> { return true; }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return true; }\n    public async open(options?: OpenOptions) {\n        if (!this.closed && !this._footer) {\n            this.schema = (this._footer = await this._readFooter()).schema;\n            for (const block of this._footer.dictionaryBatches()) {\n                block && await this._readDictionaryBatch(this._dictionaryIndex++);\n            }\n        }\n        return await super.open(options);\n    }\n    public async readRecordBatch(index: number) {\n        if (this.closed) { return null; }\n        if (!this._footer) { await this.open(); }\n        const block = this._footer && this._footer.getRecordBatch(index);\n        if (block && (await this._handle.seek(block.offset))) {\n            const message = await this._reader.readMessage(MessageHeader.RecordBatch);\n            if (message && message.isRecordBatch()) {\n                const header = message.header();\n                const buffer = await this._reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return recordBatch;\n            }\n        }\n        return null;\n    }\n    protected async _readDictionaryBatch(index: number) {\n        const block = this._footer && this._footer.getDictionaryBatch(index);\n        if (block && (await this._handle.seek(block.offset))) {\n            const message = await this._reader.readMessage(MessageHeader.DictionaryBatch);\n            if (message && message.isDictionaryBatch()) {\n                const header = message.header();\n                const buffer = await this._reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n    }\n    protected async _readFooter() {\n        const { _handle } = this;\n        _handle._pending && await _handle._pending;\n        const offset = _handle.size - magicAndPadding;\n        const length = await _handle.readInt32(offset);\n        const buffer = await _handle.readAt(offset - length, length);\n        return Footer.decode(buffer);\n    }\n    protected async _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null): Promise<Message<T> | null> {\n        if (!this._footer) { await this.open(); }\n        if (this._footer && this._recordBatchIndex < this.numRecordBatches) {\n            const block = this._footer.getRecordBatch(this._recordBatchIndex);\n            if (block && await this._handle.seek(block.offset)) {\n                return await this._reader.readMessage(type);\n            }\n        }\n        return null;\n    }\n}\n\n/** @ignore */\nclass RecordBatchJSONReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReaderImpl<T> {\n    constructor(source: ArrowJSONLike, dictionaries?: Map<number, Vector>) {\n        super(source, dictionaries);\n    }\n    protected _loadVectors(header: metadata.RecordBatch, body: any, types: (Field | DataType)[]) {\n        return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);\n    }\n}\n\n//\n// Define some helper functions and static implementations down here. There's\n// a bit of branching in the static methods that can lead to the same routines\n// being executed, so we've broken those out here for readability.\n//\n\n/** @ignore */\nfunction shouldAutoDestroy(self: { autoDestroy: boolean }, options?: OpenOptions) {\n    return options && (typeof options['autoDestroy'] === 'boolean') ? options['autoDestroy'] : self['autoDestroy'];\n}\n\n/** @ignore */\nfunction* readAllSync<T extends { [key: string]: DataType } = any>(source: RecordBatchReaders<T> | FromArg0 | FromArg2) {\n    const reader = RecordBatchReader.from<T>(<any> source) as RecordBatchReaders<T>;\n    try {\n        if (!reader.open({ autoDestroy: false }).closed) {\n            do { yield reader; } while (!(reader.reset().open()).closed);\n        }\n    } finally { reader.cancel(); }\n}\n\n/** @ignore */\nasync function* readAllAsync<T extends { [key: string]: DataType } = any>(source: AsyncRecordBatchReaders<T> | FromArg1 | FromArg3 | FromArg4 | FromArg5) {\n    const reader = await RecordBatchReader.from<T>(<any> source) as RecordBatchReader<T>;\n    try {\n        if (!(await reader.open({ autoDestroy: false })).closed) {\n            do { yield reader; } while (!(await reader.reset().open()).closed);\n        }\n    } finally { await reader.cancel(); }\n}\n\n/** @ignore */\nfunction fromArrowJSON<T extends { [key: string]: DataType }>(source: ArrowJSONLike) {\n    return new RecordBatchStreamReader(new RecordBatchJSONReaderImpl<T>(source));\n}\n\n/** @ignore */\nfunction fromByteStream<T extends { [key: string]: DataType }>(source: ByteStream) {\n    const bytes = source.peek((magicLength + 7) & ~7);\n    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes)\n        ? new RecordBatchStreamReader(new RecordBatchStreamReaderImpl<T>(source))\n        : new RecordBatchFileReader(new RecordBatchFileReaderImpl<T>(source.read()))\n        : new RecordBatchStreamReader(new RecordBatchStreamReaderImpl<T>(function*(): any {}()));\n}\n\n/** @ignore */\nasync function fromAsyncByteStream<T extends { [key: string]: DataType }>(source: AsyncByteStream) {\n    const bytes = await source.peek((magicLength + 7) & ~7);\n    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes)\n        ? new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl<T>(source))\n        : new RecordBatchFileReader(new RecordBatchFileReaderImpl<T>(await source.read()))\n        : new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl<T>(async function*(): any {}()));\n}\n\n/** @ignore */\nasync function fromFileHandle<T extends { [key: string]: DataType }>(source: FileHandle) {\n    const { size } = await source.stat();\n    const file = new AsyncRandomAccessFile(source, size);\n    if (size >= magicX2AndPadding) {\n        if (checkForMagicArrowString(await file.readAt(0, (magicLength + 7) & ~7))) {\n            return new AsyncRecordBatchFileReader(new AsyncRecordBatchFileReaderImpl<T>(file));\n        }\n    }\n    return new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl<T>(file));\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../../type';\nimport { Vector } from '../../vector';\nimport { VectorType as V } from '../../interfaces';\nimport { Builder, BuilderOptions } from '../../builder/index';\n\n/** @ignore */\nexport interface BuilderTransformOptions<T extends DataType = any, TNull = any> extends BuilderOptions<T, TNull> {\n    queueingStrategy?: 'bytes' | 'count';\n    dictionaryHashFunction?: (value: any) => string | number;\n    readableStrategy?: { highWaterMark?: number, size?: any, type?: 'bytes'; };\n    writableStrategy?: { highWaterMark?: number, size?: any, type?: 'bytes'; };\n    valueToChildTypeId?: (builder: Builder<T, TNull>, value: any, offset: number) => number;\n}\n\n/** @ignore */\nexport function builderThroughDOMStream<T extends DataType = any, TNull = any>(options: BuilderTransformOptions<T, TNull>) {\n    return new BuilderTransform(options);\n}\n\n/** @ignore */\nexport class BuilderTransform<T extends DataType = any, TNull = any> {\n\n    public readable: ReadableStream<V<T>>;\n    public writable: WritableStream<T['TValue'] | TNull>;\n    public _controller: ReadableStreamDefaultController<V<T>> | null;\n\n    private _numChunks = 0;\n    private _finished = false;\n    private _bufferedSize = 0;\n    private _builder: Builder<T, TNull>;\n    private _getSize: (builder: Builder<T, TNull>) => number;\n\n    constructor(options: BuilderTransformOptions<T, TNull>) {\n\n        // Access properties by string indexers to defeat closure compiler\n\n        const {\n            ['readableStrategy']: readableStrategy,\n            ['writableStrategy']: writableStrategy,\n            ['queueingStrategy']: queueingStrategy = 'count',\n            ...builderOptions\n        } = options;\n\n        this._controller = null;\n        this._builder = Builder.new<T, TNull>(builderOptions);\n        this._getSize = queueingStrategy !== 'bytes' ? chunkLength : chunkByteLength;\n\n        const { ['highWaterMark']: readableHighWaterMark = queueingStrategy === 'bytes' ? 2 ** 14 : 1000 } = { ...readableStrategy };\n        const { ['highWaterMark']: writableHighWaterMark = queueingStrategy === 'bytes' ? 2 ** 14 : 1000 } = { ...writableStrategy };\n\n        this['readable'] = new ReadableStream<V<T>>({\n            ['cancel']: ()  => { this._builder.clear(); },\n            ['pull']: (c) => { this._maybeFlush(this._builder, this._controller = c); },\n            ['start']: (c) => { this._maybeFlush(this._builder, this._controller = c); },\n        }, {\n            'highWaterMark': readableHighWaterMark,\n            'size': queueingStrategy !== 'bytes' ? chunkLength : chunkByteLength,\n        });\n\n        this['writable'] = new WritableStream({\n            ['abort']: () => { this._builder.clear(); },\n            ['write']: () => { this._maybeFlush(this._builder, this._controller); },\n            ['close']: () => { this._maybeFlush(this._builder.finish(), this._controller); },\n        }, {\n            'highWaterMark': writableHighWaterMark,\n            'size': (value: T['TValue'] | TNull) => this._writeValueAndReturnChunkSize(value),\n        });\n    }\n\n    private _writeValueAndReturnChunkSize(value: T['TValue'] | TNull) {\n        const bufferedSize = this._bufferedSize;\n        this._bufferedSize = this._getSize(this._builder.append(value));\n        return this._bufferedSize - bufferedSize;\n    }\n\n    private _maybeFlush(builder: Builder<T, TNull>, controller: ReadableStreamDefaultController<V<T>> | null) {\n        if (controller === null) { return; }\n        if (this._bufferedSize >= controller.desiredSize!) {\n            ++this._numChunks && this._enqueue(controller, builder.toVector());\n        }\n        if (builder.finished) {\n            if (builder.length > 0 || this._numChunks === 0) {\n                ++this._numChunks && this._enqueue(controller, builder.toVector());\n            }\n            if (!this._finished && (this._finished = true)) {\n                this._enqueue(controller, null);\n            }\n        }\n    }\n\n    private _enqueue(controller: ReadableStreamDefaultController<V<T>>, chunk: V<T> | null) {\n        this._bufferedSize = 0;\n        this._controller = null;\n        chunk === null ? controller.close() : controller.enqueue(chunk);\n    }\n}\n\n/** @ignore */ const chunkLength = <T extends DataType = any>(chunk: Vector<T> | Builder<T>) => chunk.length;\n/** @ignore */ const chunkByteLength = <T extends DataType = any>(chunk: Vector<T> | Builder<T>) => chunk.byteLength;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { RecordBatch } from '../recordbatch';\nimport { DictionaryVector } from '../vector/dictionary';\n\n/** @ignore */\nexport type ValueFunc<T> = (idx: number, cols: RecordBatch) => T | null;\n/** @ignore */\nexport type PredicateFunc = (idx: number, cols: RecordBatch) => boolean;\n\n/** @ignore */\nexport abstract class Value<T> {\n    eq(other: Value<T> | T): Predicate {\n        if (!(other instanceof Value)) { other = new Literal(other); }\n        return new Equals(this, other);\n    }\n    le(other: Value<T> | T): Predicate {\n        if (!(other instanceof Value)) { other = new Literal(other); }\n        return new LTeq(this, other);\n    }\n    ge(other: Value<T> | T): Predicate {\n        if (!(other instanceof Value)) { other = new Literal(other); }\n        return new GTeq(this, other);\n    }\n    lt(other: Value<T> | T): Predicate {\n        return new Not(this.ge(other));\n    }\n    gt(other: Value<T> | T): Predicate {\n        return new Not(this.le(other));\n    }\n    ne(other: Value<T> | T): Predicate {\n        return new Not(this.eq(other));\n    }\n}\n\n/** @ignore */\nexport class Literal<T= any> extends Value<T> {\n    constructor(public v: T) { super(); }\n}\n\n/** @ignore */\nexport class Col<T= any> extends Value<T> {\n    // @ts-ignore\n    public vector: Vector;\n    // @ts-ignore\n    public colidx: number;\n\n    constructor(public name: string) { super(); }\n    bind(batch: RecordBatch): (idx: number, batch?: RecordBatch) => any {\n        if (!this.colidx) {\n            // Assume column index doesn't change between calls to bind\n            //this.colidx = cols.findIndex(v => v.name.indexOf(this.name) != -1);\n            this.colidx = -1;\n            const fields = batch.schema.fields;\n            for (let idx = -1; ++idx < fields.length;) {\n                if (fields[idx].name === this.name) {\n                    this.colidx = idx;\n                    break;\n                }\n            }\n            if (this.colidx < 0) { throw new Error(`Failed to bind Col \"${this.name}\"`); }\n        }\n\n        const vec = this.vector = batch.getChildAt(this.colidx)!;\n        return (idx: number) => vec.get(idx);\n    }\n}\n\n/** @ignore */\nexport abstract class Predicate {\n    abstract bind(batch: RecordBatch): PredicateFunc;\n    and(...expr: Predicate[]): And { return new And(this, ...expr); }\n    or(...expr: Predicate[]): Or { return new Or(this, ...expr); }\n    not(): Predicate { return new Not(this); }\n}\n\n/** @ignore */\nexport abstract class ComparisonPredicate<T= any> extends Predicate {\n    constructor(public readonly left: Value<T>, public readonly right: Value<T>) {\n        super();\n    }\n\n    bind(batch: RecordBatch) {\n        if (this.left instanceof Literal) {\n            if (this.right instanceof Literal) {\n                return this._bindLitLit(batch, this.left, this.right);\n            } else { // right is a Col\n\n                return this._bindLitCol(batch, this.left, this.right as Col);\n            }\n        } else { // left is a Col\n            if (this.right instanceof Literal) {\n                return this._bindColLit(batch, this.left as Col, this.right);\n            } else { // right is a Col\n                return this._bindColCol(batch, this.left as Col, this.right as Col);\n            }\n        }\n    }\n\n    protected abstract _bindLitLit(batch: RecordBatch, left: Literal, right: Literal): PredicateFunc;\n    protected abstract _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc;\n    protected abstract _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc;\n    protected abstract _bindLitCol(batch: RecordBatch, lit: Literal, col: Col): PredicateFunc;\n}\n\n/** @ignore */\nexport abstract class CombinationPredicate extends Predicate {\n    readonly children: Predicate[];\n    constructor(...children: Predicate[]) {\n        super();\n        this.children = children;\n    }\n}\n// add children to prototype so it doesn't get mangled in es2015/umd\n(<any> CombinationPredicate.prototype).children = Object.freeze([]); // freeze for safety\n\n/** @ignore */\nexport class And extends CombinationPredicate {\n    constructor(...children: Predicate[]) {\n        // Flatten any Ands\n        children = children.reduce((accum: Predicate[], p: Predicate): Predicate[] => {\n            return accum.concat(p instanceof And ? p.children : p);\n        }, []);\n        super(...children);\n    }\n    bind(batch: RecordBatch) {\n        const bound = this.children.map((p) => p.bind(batch));\n        return (idx: number, batch: RecordBatch) => bound.every((p) => p(idx, batch));\n    }\n}\n\n/** @ignore */\nexport class Or extends CombinationPredicate {\n    constructor(...children: Predicate[]) {\n        // Flatten any Ors\n        children = children.reduce((accum: Predicate[], p: Predicate): Predicate[] => {\n            return accum.concat(p instanceof Or ? p.children : p);\n        }, []);\n        super(...children);\n    }\n    bind(batch: RecordBatch) {\n        const bound = this.children.map((p) => p.bind(batch));\n        return (idx: number, batch: RecordBatch) => bound.some((p) => p(idx, batch));\n    }\n}\n\n/** @ignore */\nexport class Equals extends ComparisonPredicate {\n    // Helpers used to cache dictionary reverse lookups between calls to bind\n    private lastDictionary: Vector|undefined;\n    private lastKey: number|undefined;\n\n    protected _bindLitLit(_batch: RecordBatch, left: Literal, right: Literal): PredicateFunc {\n        const rtrn: boolean = left.v == right.v;\n        return () => rtrn;\n    }\n\n    protected _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx: number, batch: RecordBatch) => left_func(idx, batch) == right_func(idx, batch);\n    }\n\n    protected _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc {\n        const col_func = col.bind(batch);\n        if (col.vector instanceof DictionaryVector) {\n            let key: any;\n            const vector = col.vector as DictionaryVector;\n            if (vector.dictionary !== this.lastDictionary) {\n                key = vector.reverseLookup(lit.v);\n                this.lastDictionary = vector.dictionary;\n                this.lastKey = key;\n            } else {\n                key = this.lastKey;\n            }\n\n            if (key === -1) {\n                // the value doesn't exist in the dictionary - always return\n                // false\n                // TODO: special-case of PredicateFunc that encapsulates this\n                // \"always false\" behavior. That way filtering operations don't\n                // have to bother checking\n                return () => false;\n            } else {\n                return (idx: number) => {\n                    return vector.getKey(idx) === key;\n                };\n            }\n        } else {\n            return (idx: number, cols: RecordBatch) => col_func(idx, cols) == lit.v;\n        }\n    }\n\n    protected _bindLitCol(batch: RecordBatch, lit: Literal, col: Col) {\n        // Equals is commutative\n        return this._bindColLit(batch, col, lit);\n    }\n}\n\n/** @ignore */\nexport class LTeq extends ComparisonPredicate {\n    protected _bindLitLit(_batch: RecordBatch, left: Literal, right: Literal): PredicateFunc {\n        const rtrn: boolean = left.v <= right.v;\n        return () => rtrn;\n    }\n\n    protected _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx: number, cols: RecordBatch) => left_func(idx, cols) <= right_func(idx, cols);\n    }\n\n    protected _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => col_func(idx, cols) <= lit.v;\n    }\n\n    protected _bindLitCol(batch: RecordBatch, lit: Literal, col: Col) {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => lit.v <= col_func(idx, cols);\n    }\n}\n\n/** @ignore */\nexport class GTeq extends ComparisonPredicate {\n    protected _bindLitLit(_batch: RecordBatch, left: Literal, right: Literal): PredicateFunc {\n        const rtrn: boolean = left.v >= right.v;\n        return () => rtrn;\n    }\n\n    protected _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx: number, cols: RecordBatch) => left_func(idx, cols) >= right_func(idx, cols);\n    }\n\n    protected _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => col_func(idx, cols) >= lit.v;\n    }\n\n    protected _bindLitCol(batch: RecordBatch, lit: Literal, col: Col) {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => lit.v >= col_func(idx, cols);\n    }\n}\n\n/** @ignore */\nexport class Not extends Predicate {\n    constructor(public readonly child: Predicate) {\n        super();\n    }\n\n    bind(batch: RecordBatch) {\n        const func = this.child.bind(batch);\n        return (idx: number, batch: RecordBatch) => !func(idx, batch);\n    }\n}\n\n/** @ignore */\nexport class CustomPredicate extends Predicate {\n    constructor(private next: PredicateFunc, private bind_: (batch: RecordBatch) => void) {\n        super();\n    }\n\n    bind(batch: RecordBatch) {\n        this.bind_(batch);\n        return this.next;\n    }\n}\n\nexport function lit(v: any): Value<any> { return new Literal(v); }\nexport function col(n: string): Col<any> { return new Col(n); }\nexport function and(...p: Predicate[]): And { return new And(...p); }\nexport function or(...p: Predicate[]): Or { return new Or(...p); }\nexport function custom(next: PredicateFunc, bind: (batch: RecordBatch) => void) {\n    return new CustomPredicate(next, bind);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Table } from '../table';\nimport { Vector } from '../vector';\nimport { IntVector } from '../vector/int';\nimport { Field, Schema } from '../schema';\nimport { Predicate, Col } from './predicate';\nimport { RecordBatch } from '../recordbatch';\nimport { VectorType as V } from '../interfaces';\nimport { DataType, Int, Struct, Dictionary } from '../type';\n\n/** @ignore */\nexport type BindFunc = (batch: RecordBatch) => void;\n/** @ignore */\nexport type NextFunc = (idx: number, batch: RecordBatch) => void;\n\nTable.prototype.countBy = function(this: Table, name: Col | string) { return new DataFrame(this.chunks).countBy(name); };\nTable.prototype.scan = function(this: Table, next: NextFunc, bind?: BindFunc) { return new DataFrame(this.chunks).scan(next, bind); };\nTable.prototype.scanReverse = function(this: Table, next: NextFunc, bind?: BindFunc) { return new DataFrame(this.chunks).scanReverse(next, bind); };\nTable.prototype.filter = function(this: Table, predicate: Predicate): FilteredDataFrame { return new DataFrame(this.chunks).filter(predicate); };\n\nexport class DataFrame<T extends { [key: string]: DataType } = any> extends Table<T> {\n    public filter(predicate: Predicate): FilteredDataFrame<T> {\n        return new FilteredDataFrame<T>(this.chunks, predicate);\n    }\n    public scan(next: NextFunc, bind?: BindFunc) {\n        const batches = this.chunks, numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            if (bind) { bind(batch); }\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                next(index, batch);\n            }\n        }\n    }\n    public scanReverse(next: NextFunc, bind?: BindFunc) {\n        const batches = this.chunks, numBatches = batches.length;\n        for (let batchIndex = numBatches; --batchIndex >= 0;) {\n            // load batches\n            const batch = batches[batchIndex];\n            if (bind) { bind(batch); }\n            // yield all indices\n            for (let index = batch.length; --index >= 0;) {\n                next(index, batch);\n            }\n        }\n    }\n    public countBy(name: Col | string) {\n        const batches = this.chunks, numBatches = batches.length;\n        const count_by = typeof name === 'string' ? new Col(name) : name as Col;\n        // Assume that all dictionary batches are deltas, which means that the\n        // last record batch has the most complete dictionary\n        count_by.bind(batches[numBatches - 1]);\n        const vector = count_by.vector as V<Dictionary>;\n        if (!DataType.isDictionary(vector.type)) {\n            throw new Error('countBy currently only supports dictionary-encoded columns');\n        }\n\n        const countByteLength = Math.ceil(Math.log(vector.length) / Math.log(256));\n        const CountsArrayType = countByteLength == 4 ? Uint32Array :\n                                countByteLength >= 2 ? Uint16Array : Uint8Array;\n\n        const counts = new CountsArrayType(vector.dictionary.length);\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            // rebind the countBy Col\n            count_by.bind(batch);\n            const keys = (count_by.vector as V<Dictionary>).indices;\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                let key = keys.get(index);\n                if (key !== null) { counts[key]++; }\n            }\n        }\n        return new CountByResult(vector.dictionary, IntVector.from(counts));\n    }\n}\n\n/** @ignore */\nexport class CountByResult<T extends DataType = any, TCount extends Int = Int> extends Table<{ values: T,  counts: TCount }> {\n    constructor(values: Vector<T>, counts: V<TCount>) {\n        type R = { values: T, counts: TCount };\n        const schema = new Schema<R>([\n            new Field('values', values.type),\n            new Field('counts', counts.type)\n        ]);\n        super(new RecordBatch<R>(schema, counts.length, [values, counts]));\n    }\n    public toJSON(): Object {\n        const values = this.getColumnAt(0)!;\n        const counts = this.getColumnAt(1)!;\n        const result = {} as { [k: string]: number | null };\n        for (let i = -1; ++i < this.length;) {\n            result[values.get(i)] = counts.get(i);\n        }\n        return result;\n    }\n}\n\n/** @ignore */\nexport class FilteredDataFrame<T extends { [key: string]: DataType } = any> extends DataFrame<T> {\n    private _predicate: Predicate;\n    constructor (batches: RecordBatch<T>[], predicate: Predicate) {\n        super(batches);\n        this._predicate = predicate;\n    }\n    public scan(next: NextFunc, bind?: BindFunc) {\n        // inlined version of this:\n        // this.parent.scan((idx, columns) => {\n        //     if (this.predicate(idx, columns)) next(idx, columns);\n        // });\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            let isBound = false;\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                if (predicate(index, batch)) {\n                    // bind batches lazily - if predicate doesn't match anything\n                    // in the batch we don't need to call bind on the batch\n                    if (bind && !isBound) {\n                        bind(batch);\n                        isBound = true;\n                    }\n                    next(index, batch);\n                }\n            }\n        }\n    }\n    public scanReverse(next: NextFunc, bind?: BindFunc) {\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = numBatches; --batchIndex >= 0;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            let isBound = false;\n            // yield all indices\n            for (let index = batch.length; --index >= 0;) {\n                if (predicate(index, batch)) {\n                    // bind batches lazily - if predicate doesn't match anything\n                    // in the batch we don't need to call bind on the batch\n                    if (bind && !isBound) {\n                        bind(batch);\n                        isBound = true;\n                    }\n                    next(index, batch);\n                }\n            }\n        }\n    }\n    public count(): number {\n        // inlined version of this:\n        // let sum = 0;\n        // this.parent.scan((idx, columns) => {\n        //     if (this.predicate(idx, columns)) ++sum;\n        // });\n        // return sum;\n        let sum = 0;\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                if (predicate(index, batch)) { ++sum; }\n            }\n        }\n        return sum;\n    }\n    public *[Symbol.iterator](): IterableIterator<Struct<T>['TValue']> {\n        // inlined version of this:\n        // this.parent.scan((idx, columns) => {\n        //     if (this.predicate(idx, columns)) next(idx, columns);\n        // });\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            // TODO: bind batches lazily\n            // If predicate doesn't match anything in the batch we don't need\n            // to bind the callback\n            const predicate = this._predicate.bind(batch);\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                if (predicate(index, batch)) { yield batch.get(index) as any; }\n            }\n        }\n    }\n    public filter(predicate: Predicate): FilteredDataFrame<T> {\n        return new FilteredDataFrame<T>(\n            this._chunks,\n            this._predicate.and(predicate)\n        );\n    }\n    public countBy(name: Col | string) {\n        const batches = this._chunks, numBatches = batches.length;\n        const count_by = typeof name === 'string' ? new Col(name) : name as Col;\n        // Assume that all dictionary batches are deltas, which means that the\n        // last record batch has the most complete dictionary\n        count_by.bind(batches[numBatches - 1]);\n        const vector = count_by.vector as V<Dictionary>;\n        if (!DataType.isDictionary(vector.type)) {\n            throw new Error('countBy currently only supports dictionary-encoded columns');\n        }\n\n        const countByteLength = Math.ceil(Math.log(vector.length) / Math.log(256));\n        const CountsArrayType = countByteLength == 4 ? Uint32Array :\n                                countByteLength >= 2 ? Uint16Array : Uint8Array;\n\n        const counts = new CountsArrayType(vector.dictionary.length);\n\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            // rebind the countBy Col\n            count_by.bind(batch);\n            const keys = (count_by.vector as V<Dictionary>).indices;\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                let key = keys.get(index);\n                if (key !== null && predicate(index, batch)) { counts[key]++; }\n            }\n        }\n        return new CountByResult(vector.dictionary, IntVector.from(counts));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nexport { ArrowType, DateUnit, IntervalUnit, MessageHeader, MetadataVersion, Precision, TimeUnit, Type, UnionMode, BufferType } from './enum';\nexport { Data } from './data';\nexport {\n    DataType,\n    Null,\n    Bool,\n    Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64,\n    Float, Float16, Float32, Float64,\n    Utf8,\n    Binary,\n    FixedSizeBinary,\n    Date_, DateDay, DateMillisecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Decimal,\n    List,\n    Struct,\n    Union, DenseUnion, SparseUnion,\n    Dictionary,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    FixedSizeList,\n    Map_,\n} from './type';\n\nexport { Table } from './table';\nexport { Column } from './column';\nexport { Visitor } from './visitor';\nexport { Schema, Field } from './schema';\nexport {\n    Vector,\n    BaseVector,\n    BinaryVector,\n    BoolVector,\n    Chunked,\n    DateVector, DateDayVector, DateMillisecondVector,\n    DecimalVector,\n    DictionaryVector,\n    FixedSizeBinaryVector,\n    FixedSizeListVector,\n    FloatVector, Float16Vector, Float32Vector, Float64Vector,\n    IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector,\n    IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector,\n    ListVector,\n    MapVector,\n    NullVector,\n    StructVector,\n    TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector,\n    TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector,\n    UnionVector, DenseUnionVector, SparseUnionVector,\n    Utf8Vector,\n} from './vector/index';\n\nexport {\n    Builder,\n    BinaryBuilder,\n    BoolBuilder,\n    DateBuilder, DateDayBuilder, DateMillisecondBuilder,\n    DecimalBuilder,\n    DictionaryBuilder,\n    FixedSizeBinaryBuilder,\n    FixedSizeListBuilder,\n    FloatBuilder, Float16Builder, Float32Builder, Float64Builder,\n    IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder,\n    IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder,\n    ListBuilder,\n    MapBuilder,\n    NullBuilder,\n    StructBuilder,\n    TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder,\n    TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder,\n    UnionBuilder, DenseUnionBuilder, SparseUnionBuilder,\n    Utf8Builder,\n} from './builder/index';\n\nexport { ByteStream, AsyncByteStream, AsyncByteQueue, ReadableSource, WritableSink } from './io/stream';\nexport { RecordBatchReader, RecordBatchFileReader, RecordBatchStreamReader, AsyncRecordBatchFileReader, AsyncRecordBatchStreamReader } from './ipc/reader';\nexport { RecordBatchWriter, RecordBatchFileWriter, RecordBatchStreamWriter, RecordBatchJSONWriter } from './ipc/writer';\nexport { MessageReader, AsyncMessageReader, JSONMessageReader } from './ipc/message';\nexport { Message } from './ipc/metadata/message';\nexport { RecordBatch } from './recordbatch';\nexport { ArrowJSONLike, FileHandle, Readable, Writable, ReadableWritable, ReadableDOMStreamOptions } from './io/interfaces';\nexport { DataFrame, FilteredDataFrame, CountByResult, BindFunc, NextFunc } from './compute/dataframe';\n\nimport * as util_bn_ from './util/bn';\nimport * as util_int_ from './util/int';\nimport * as util_bit_ from './util/bit';\nimport * as util_math_ from './util/math';\nimport * as util_buffer_ from './util/buffer';\nimport * as util_vector_ from './util/vector';\nimport * as predicate from './compute/predicate';\n\nexport { predicate };\n/** @ignore */\nexport const util = {\n    ...util_bn_,\n    ...util_int_,\n    ...util_bit_,\n    ...util_math_,\n    ...util_buffer_,\n    ...util_vector_\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport streamAdapters from './io/adapters';\nimport { Builder } from './builder/index';\nimport { RecordBatchReader } from './ipc/reader';\nimport { RecordBatchWriter } from './ipc/writer';\nimport { toDOMStream } from './io/whatwg/iterable';\nimport { builderThroughDOMStream } from './io/whatwg/builder';\nimport { recordBatchReaderThroughDOMStream } from './io/whatwg/reader';\nimport { recordBatchWriterThroughDOMStream } from './io/whatwg/writer';\n\nstreamAdapters.toDOMStream = toDOMStream;\nBuilder['throughDOM'] = builderThroughDOMStream;\nRecordBatchReader['throughDOM'] = recordBatchReaderThroughDOMStream;\nRecordBatchWriter['throughDOM'] = recordBatchWriterThroughDOMStream;\n\nexport {\n    ArrowType, DateUnit, IntervalUnit, MessageHeader, MetadataVersion, Precision, TimeUnit, Type, UnionMode, BufferType,\n    Data,\n    DataType,\n    Null,\n    Bool,\n    Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64,\n    Float, Float16, Float32, Float64,\n    Utf8,\n    Binary,\n    FixedSizeBinary,\n    Date_, DateDay, DateMillisecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Decimal,\n    List,\n    Struct,\n    Union, DenseUnion, SparseUnion,\n    Dictionary,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    FixedSizeList,\n    Map_,\n    Table,\n    Column,\n    Schema, Field,\n    Visitor,\n    Vector,\n    BaseVector,\n    BinaryVector,\n    BoolVector,\n    Chunked,\n    DateVector, DateDayVector, DateMillisecondVector,\n    DecimalVector,\n    DictionaryVector,\n    FixedSizeBinaryVector,\n    FixedSizeListVector,\n    FloatVector, Float16Vector, Float32Vector, Float64Vector,\n    IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector,\n    IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector,\n    ListVector,\n    MapVector,\n    NullVector,\n    StructVector,\n    TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector,\n    TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector,\n    UnionVector, DenseUnionVector, SparseUnionVector,\n    Utf8Vector,\n    ByteStream, AsyncByteStream, AsyncByteQueue, ReadableSource, WritableSink,\n    RecordBatchReader, RecordBatchFileReader, RecordBatchStreamReader, AsyncRecordBatchFileReader, AsyncRecordBatchStreamReader,\n    RecordBatchWriter, RecordBatchFileWriter, RecordBatchStreamWriter, RecordBatchJSONWriter,\n    MessageReader, AsyncMessageReader, JSONMessageReader,\n    Message,\n    RecordBatch,\n    ArrowJSONLike, FileHandle, Readable, Writable, ReadableWritable, ReadableDOMStreamOptions,\n    DataFrame, FilteredDataFrame, CountByResult, BindFunc, NextFunc,\n    predicate,\n    util,\n    Builder,\n    BinaryBuilder,\n    BoolBuilder,\n    DateBuilder, DateDayBuilder, DateMillisecondBuilder,\n    DecimalBuilder,\n    DictionaryBuilder,\n    FixedSizeBinaryBuilder,\n    FixedSizeListBuilder,\n    FloatBuilder, Float16Builder, Float32Builder, Float64Builder,\n    IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder,\n    IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder,\n    ListBuilder,\n    MapBuilder,\n    NullBuilder,\n    StructBuilder,\n    TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder,\n    TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder,\n    UnionBuilder, DenseUnionBuilder, SparseUnionBuilder,\n    Utf8Builder,\n} from './Arrow';\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { toUint8Array } from '../../util/buffer';\nimport { ReadableDOMStreamOptions } from '../../io/interfaces';\nimport { isIterable, isAsyncIterable } from '../../util/compat';\n\n/** @ignore */\nexport function toDOMStream<T>(source: Iterable<T> | AsyncIterable<T>, options?: ReadableDOMStreamOptions): ReadableStream<T> {\n    if (isAsyncIterable<T>(source)) { return asyncIterableAsReadableDOMStream(source, options); }\n    if (isIterable<T>(source)) { return iterableAsReadableDOMStream(source, options); }\n    /* istanbul ignore next */\n    throw new Error(`toDOMStream() must be called with an Iterable or AsyncIterable`);\n}\n\n/** @ignore */\nfunction iterableAsReadableDOMStream<T>(source: Iterable<T>, options?: ReadableDOMStreamOptions) {\n\n    let it: Iterator<T> | null = null;\n    const bm = (options && options.type === 'bytes') || false;\n    const hwm = options && options.highWaterMark || (2 ** 24);\n\n    return new ReadableStream<T>({\n        ...options as any,\n        start(controller) { next(controller, it || (it = source[Symbol.iterator]())); },\n        pull(controller) { it ? (next(controller, it)) : controller.close(); },\n        cancel() { (it && (it.return && it.return()) || true) && (it = null); }\n    }, { highWaterMark: bm ? hwm : undefined, ...options });\n\n    function next(controller: ReadableStreamDefaultController<T>, it: Iterator<T>) {\n        let buf: Uint8Array;\n        let r: IteratorResult<T> | null = null;\n        let size = controller.desiredSize || null;\n        while (!(r = it.next(bm ? size : null)).done) {\n            if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {\n                size != null && bm && (size = size - buf.byteLength + 1);\n                r.value = <any> buf;\n            }\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) { return; }\n        }\n        controller.close();\n    }\n}\n\n/** @ignore */\nfunction asyncIterableAsReadableDOMStream<T>(source: AsyncIterable<T>, options?: ReadableDOMStreamOptions) {\n\n    let it: AsyncIterator<T> | null = null;\n    const bm = (options && options.type === 'bytes') || false;\n    const hwm = options && options.highWaterMark || (2 ** 24);\n\n    return new ReadableStream<T>({\n        ...options as any,\n        async start(controller) { await next(controller, it || (it = source[Symbol.asyncIterator]())); },\n        async pull(controller) { it ? (await next(controller, it)) : controller.close(); },\n        async cancel() { (it && (it.return && await it.return()) || true) && (it = null); },\n    }, { highWaterMark: bm ? hwm : undefined, ...options });\n\n    async function next(controller: ReadableStreamDefaultController<T>, it: AsyncIterator<T>) {\n        let buf: Uint8Array;\n        let r: IteratorResult<T> | null = null;\n        let size = controller.desiredSize || null;\n        while (!(r = await it.next(bm ? size : null)).done) {\n            if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {\n                size != null && bm && (size = size - buf.byteLength + 1);\n                r.value = <any> buf;\n            }\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) { return; }\n        }\n        controller.close();\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../../type';\nimport { RecordBatch } from '../../recordbatch';\nimport { AsyncByteQueue } from '../../io/stream';\nimport { RecordBatchReader } from '../../ipc/reader';\n\n/** @ignore */\nexport function recordBatchReaderThroughDOMStream<T extends { [key: string]: DataType } = any>(writableStrategy?: ByteLengthQueuingStrategy, readableStrategy?: { autoDestroy: boolean }) {\n\n    const queue = new AsyncByteQueue();\n    let reader: RecordBatchReader<T> | null = null;\n\n    const readable = new ReadableStream<RecordBatch<T>>({\n        async cancel() { await queue.close(); },\n        async start(controller) { await next(controller, reader || (reader = await open())); },\n        async pull(controller) { reader ? await next(controller, reader) : controller.close(); }\n    });\n\n    return { writable: new WritableStream(queue, { 'highWaterMark': 2 ** 14, ...writableStrategy }), readable };\n\n    async function open() {\n        return await (await RecordBatchReader.from<T>(queue)).open(readableStrategy);\n    }\n\n    async function next(controller: ReadableStreamDefaultController<RecordBatch<T>>, reader: RecordBatchReader<T>) {\n        let size = controller.desiredSize;\n        let r: IteratorResult<RecordBatch<T>> | null = null;\n        while (!(r = await reader.next()).done) {\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) {\n                return;\n            }\n        }\n        controller.close();\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../../type';\nimport { RecordBatch } from '../../recordbatch';\nimport { AsyncByteStream } from '../../io/stream';\nimport { RecordBatchWriter } from '../../ipc/writer';\n\n/** @ignore */\nexport function recordBatchWriterThroughDOMStream<T extends { [key: string]: DataType } = any>(\n    this: typeof RecordBatchWriter,\n    writableStrategy?: QueuingStrategy<RecordBatch<T>> & { autoDestroy: boolean },\n    readableStrategy?: { highWaterMark?: number, size?: any }\n) {\n\n    const writer = new this<T>(writableStrategy);\n    const reader = new AsyncByteStream(writer);\n    const readable = new ReadableStream({\n        type: 'bytes',\n        async cancel() { await reader.cancel(); },\n        async pull(controller) { await next(controller); },\n        async start(controller) { await next(controller); },\n    }, { 'highWaterMark': 2 ** 14, ...readableStrategy });\n\n    return { writable: new WritableStream(writer, writableStrategy), readable };\n\n    async function next(controller: ReadableStreamDefaultController<Uint8Array>) {\n        let buf: Uint8Array | null = null;\n        let size = controller.desiredSize;\n        while (buf = await reader.read(size || null)) {\n            controller.enqueue(buf);\n            if (size != null && (size -= buf.byteLength) <= 0) { return; }\n        }\n        controller.close();\n    }\n}\n"],"sourceRoot":""}